int tri_tri_intersect_with_isectline(float V0[3], float V1[3], float V2[3],
                                     float U0[3], float U1[3], float U2[3],
                                     int *coplanar, float isectpt1[3],
                                     float isectpt2[3]) {
  float E1[3], E2[3];
  float N1[3], N2[3], d1, d2;
  float du0, du1, du2, dv0, dv1, dv2;
  float D[3];
  float isect1[2] = {0.0f, 0.0f}, isect2[2] = {0.0f, 0.0f};
  float isectpointA1[3] = {0.0f, 0.0f, 0.0f},
        isectpointA2[3] = {0.0f, 0.0f, 0.0f};
  float isectpointB1[3] = {0.0f, 0.0f, 0.0f},
        isectpointB2[3] = {0.0f, 0.0f, 0.0f};
  float du0du1, du0du2, dv0dv1, dv0dv2;
  short index;
  float vp0, vp1, vp2;
  float up0, up1, up2;
  float b, c, max;
  int smallest1, smallest2;
  E1[0] = V1[0] - V0[0];
  E1[1] = V1[1] - V0[1];
  E1[2] = V1[2] - V0[2];
  ;
  E2[0] = V2[0] - V0[0];
  E2[1] = V2[1] - V0[1];
  E2[2] = V2[2] - V0[2];
  ;
  N1[0] = E1[1] * E2[2] - E1[2] * E2[1];
  N1[1] = E1[2] * E2[0] - E1[0] * E2[2];
  N1[2] = E1[0] * E2[1] - E1[1] * E2[0];
  ;
  d1 = -(N1[0] * V0[0] + N1[1] * V0[1] + N1[2] * V0[2]);
  du0 = (N1[0] * U0[0] + N1[1] * U0[1] + N1[2] * U0[2]) + d1;
  du1 = (N1[0] * U1[0] + N1[1] * U1[1] + N1[2] * U1[2]) + d1;
  du2 = (N1[0] * U2[0] + N1[1] * U2[1] + N1[2] * U2[2]) + d1;
  if (fabs(du0) < 0.000001)
    du0 = 0.0;
  if (fabs(du1) < 0.000001)
    du1 = 0.0;
  if (fabs(du2) < 0.000001)
    du2 = 0.0;
  du0du1 = du0 * du1;
  du0du2 = du0 * du2;
  if (du0du1 > 0.0f && du0du2 > 0.0f)
    return 0;
  E1[0] = U1[0] - U0[0];
  E1[1] = U1[1] - U0[1];
  E1[2] = U1[2] - U0[2];
  ;
  E2[0] = U2[0] - U0[0];
  E2[1] = U2[1] - U0[1];
  E2[2] = U2[2] - U0[2];
  ;
  N2[0] = E1[1] * E2[2] - E1[2] * E2[1];
  N2[1] = E1[2] * E2[0] - E1[0] * E2[2];
  N2[2] = E1[0] * E2[1] - E1[1] * E2[0];
  ;
  d2 = -(N2[0] * U0[0] + N2[1] * U0[1] + N2[2] * U0[2]);
  dv0 = (N2[0] * V0[0] + N2[1] * V0[1] + N2[2] * V0[2]) + d2;
  dv1 = (N2[0] * V1[0] + N2[1] * V1[1] + N2[2] * V1[2]) + d2;
  dv2 = (N2[0] * V2[0] + N2[1] * V2[1] + N2[2] * V2[2]) + d2;
  if (fabs(dv0) < 0.000001)
    dv0 = 0.0;
  if (fabs(dv1) < 0.000001)
    dv1 = 0.0;
  if (fabs(dv2) < 0.000001)
    dv2 = 0.0;
  dv0dv1 = dv0 * dv1;
  dv0dv2 = dv0 * dv2;
  if (dv0dv1 > 0.0f && dv0dv2 > 0.0f)
    return 0;
  D[0] = N1[1] * N2[2] - N1[2] * N2[1];
  D[1] = N1[2] * N2[0] - N1[0] * N2[2];
  D[2] = N1[0] * N2[1] - N1[1] * N2[0];
  ;
  max = fabs(D[0]);
  index = 0;
  b = fabs(D[1]);
  c = fabs(D[2]);
  if (b > max)
    max = b, index = 1;
  if (c > max)
    max = c, index = 2;
  vp0 = V0[index];
  vp1 = V1[index];
  vp2 = V2[index];
  up0 = U0[index];
  up1 = U1[index];
  up2 = U2[index];
  *coplanar = compute_intervals_isectline(
      V0, V1, V2, vp0, vp1, vp2, dv0, dv1, dv2, dv0dv1, dv0dv2, &isect1[0],
      &isect1[1], isectpointA1, isectpointA2);
  if (*coplanar)
    return coplanar_tri_tri(N1, V0, V1, V2, U0, U1, U2);
  compute_intervals_isectline(U0, U1, U2, up0, up1, up2, du0, du1, du2, du0du1,
                              du0du2, &isect2[0], &isect2[1], isectpointB1,
                              isectpointB2);
  if (isect1[0] > isect1[1]) {
    float c;
    c = isect1[0];
    isect1[0] = isect1[1];
    isect1[1] = c;
    smallest1 = 1;
  } else
    smallest1 = 0;
  ;
  if (isect2[0] > isect2[1]) {
    float c;
    c = isect2[0];
    isect2[0] = isect2[1];
    isect2[1] = c;
    smallest2 = 1;
  } else
    smallest2 = 0;
  ;
  if (isect1[1] < isect2[0] || isect2[1] < isect1[0])
    return 0;
  if (isect2[0] < isect1[0]) {
    if (smallest1 == 0) {
      isectpt1[0] = isectpointA1[0];
      isectpt1[1] = isectpointA1[1];
      isectpt1[2] = isectpointA1[2];
      ;
    } else {
      isectpt1[0] = isectpointA2[0];
      isectpt1[1] = isectpointA2[1];
      isectpt1[2] = isectpointA2[2];
      ;
    }
    if (isect2[1] < isect1[1]) {
      if (smallest2 == 0) {
        isectpt2[0] = isectpointB2[0];
        isectpt2[1] = isectpointB2[1];
        isectpt2[2] = isectpointB2[2];
        ;
      } else {
        isectpt2[0] = isectpointB1[0];
        isectpt2[1] = isectpointB1[1];
        isectpt2[2] = isectpointB1[2];
        ;
      }
    } else {
      if (smallest1 == 0) {
        isectpt2[0] = isectpointA2[0];
        isectpt2[1] = isectpointA2[1];
        isectpt2[2] = isectpointA2[2];
        ;
      } else {
        isectpt2[0] = isectpointA1[0];
        isectpt2[1] = isectpointA1[1];
        isectpt2[2] = isectpointA1[2];
        ;
      }
    }
  } else {
    if (smallest2 == 0) {
      isectpt1[0] = isectpointB1[0];
      isectpt1[1] = isectpointB1[1];
      isectpt1[2] = isectpointB1[2];
      ;
    } else {
      isectpt1[0] = isectpointB2[0];
      isectpt1[1] = isectpointB2[1];
      isectpt1[2] = isectpointB2[2];
      ;
    }
    if (isect2[1] > isect1[1]) {
      if (smallest1 == 0) {
        isectpt2[0] = isectpointA2[0];
        isectpt2[1] = isectpointA2[1];
        isectpt2[2] = isectpointA2[2];
        ;
      } else {
        isectpt2[0] = isectpointA1[0];
        isectpt2[1] = isectpointA1[1];
        isectpt2[2] = isectpointA1[2];
        ;
      }
    } else {
      if (smallest2 == 0) {
        isectpt2[0] = isectpointB2[0];
        isectpt2[1] = isectpointB2[1];
        isectpt2[2] = isectpointB2[2];
        ;
      } else {
        isectpt2[0] = isectpointB1[0];
        isectpt2[1] = isectpointB1[1];
        isectpt2[2] = isectpointB1[2];
        ;
      }
    }
  }
  return 1;
}


x86 assembly (clang, -O0):
<tri_tri_intersect_with_isectline>:
push   %rbp
mov    %rsp,%rbp
sub    $0x130,%rsp
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
mov    %r9,-0x38(%rbp)
lea    -0x9c(%rbp),%rdi
xor    %esi,%esi
mov    $0x8,%edx
call   1040 <memset@plt>
lea    -0xa4(%rbp),%rdi
xor    %esi,%esi
mov    $0x8,%edx
call   1040 <memset@plt>
lea    -0xb0(%rbp),%rdi
xor    %esi,%esi
mov    $0xc,%edx
call   1040 <memset@plt>
lea    -0xbc(%rbp),%rdi
xor    %esi,%esi
mov    $0xc,%edx
call   1040 <memset@plt>
lea    -0xc8(%rbp),%rdi
xor    %esi,%esi
mov    $0xc,%edx
call   1040 <memset@plt>
lea    -0xd4(%rbp),%rdi
xor    %esi,%esi
mov    $0xc,%edx
call   1040 <memset@plt>
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
subss  (%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x10(%rbp),%rax
subss  0x4(%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
subss  0x8(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
subss  (%rax),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x10(%rbp),%rax
subss  0x4(%rax),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
subss  0x8(%rax),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x40(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x3c(%rbp),%xmm1
mulss  -0x4c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  -0x48(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x44(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  -0x50(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x5c(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x58(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x4(%rax),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x54(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x5c(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x58(%rbp),%xmm0
mov    -0x28(%rbp),%rax
mulss  0x4(%rax),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x54(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
addss  -0x6c(%rbp),%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x5c(%rbp),%xmm1
mov    -0x30(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x58(%rbp),%xmm0
mov    -0x30(%rbp),%rax
mulss  0x4(%rax),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x54(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
addss  -0x6c(%rbp),%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x5c(%rbp),%xmm1
mov    -0x38(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x58(%rbp),%xmm0
mov    -0x38(%rbp),%rax
mulss  0x4(%rax),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x54(%rbp),%xmm0
mov    -0x38(%rbp),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
addss  -0x6c(%rbp),%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x74(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movaps 0xc0b(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0xbef(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1423 <tri_tri_intersect_with_isectline+0x2f3>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x78(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movaps 0xbdd(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0xbc1(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1451 <tri_tri_intersect_with_isectline+0x321>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x7c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movaps 0xbaf(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0xb93(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    147f <tri_tri_intersect_with_isectline+0x34f>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x74(%rbp),%xmm0
mulss  -0x78(%rbp),%xmm0
movss  %xmm0,-0xd8(%rbp)
ff
movss  -0x74(%rbp),%xmm0
mulss  -0x7c(%rbp),%xmm0
movss  %xmm0,-0xdc(%rbp)
ff
movss  -0xd8(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    14d7 <tri_tri_intersect_with_isectline+0x3a7>
movss  -0xdc(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    14d7 <tri_tri_intersect_with_isectline+0x3a7>
movl   $0x0,-0x4(%rbp)
jmp    1f7c <tri_tri_intersect_with_isectline+0xe4c>
mov    -0x30(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x28(%rbp),%rax
subss  (%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x30(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x28(%rbp),%rax
subss  0x4(%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x30(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x28(%rbp),%rax
subss  0x8(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x38(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x28(%rbp),%rax
subss  (%rax),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x38(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x28(%rbp),%rax
subss  0x4(%rax),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x38(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x28(%rbp),%rax
subss  0x8(%rax),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x40(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x3c(%rbp),%xmm1
mulss  -0x4c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  -0x48(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x44(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  -0x50(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x68(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x64(%rbp),%xmm0
mov    -0x28(%rbp),%rax
mulss  0x4(%rax),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x60(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x68(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x64(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x4(%rax),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x60(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
addss  -0x70(%rbp),%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x68(%rbp),%xmm1
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x64(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mulss  0x4(%rax),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x60(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
addss  -0x70(%rbp),%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x68(%rbp),%xmm1
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x64(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mulss  0x4(%rax),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x60(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
addss  -0x70(%rbp),%xmm0
movss  %xmm0,-0x88(%rbp)
movss  -0x80(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movaps 0x8ff(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0x8e3(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    172f <tri_tri_intersect_with_isectline+0x5ff>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x84(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
movaps 0x8ce(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0x8b2(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1763 <tri_tri_intersect_with_isectline+0x633>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x88(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
movaps 0x89a(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0x87e(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1797 <tri_tri_intersect_with_isectline+0x667>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x80(%rbp),%xmm0
mulss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0xe0(%rbp)
ff
movss  -0x80(%rbp),%xmm0
mulss  -0x88(%rbp),%xmm0
ff
movss  %xmm0,-0xe4(%rbp)
ff
movss  -0xe0(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    17f5 <tri_tri_intersect_with_isectline+0x6c5>
movss  -0xe4(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    17f5 <tri_tri_intersect_with_isectline+0x6c5>
movl   $0x0,-0x4(%rbp)
jmp    1f7c <tri_tri_intersect_with_isectline+0xe4c>
movss  -0x58(%rbp),%xmm0
movss  -0x60(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  -0x64(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x94(%rbp)
ff
movss  -0x54(%rbp),%xmm0
movss  -0x68(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  -0x60(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x90(%rbp)
ff
movss  -0x5c(%rbp),%xmm0
movss  -0x64(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  -0x68(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
movss  -0x94(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movaps 0x775(%rip),%xmm1
pand   %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x10c(%rbp)
ff
movw   $0x0,-0xe6(%rbp)
movss  -0x90(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movaps 0x749(%rip),%xmm1
pand   %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x104(%rbp)
ff
movss  -0x8c(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movaps 0x726(%rip),%xmm1
pand   %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x108(%rbp)
ff
movss  -0x104(%rbp),%xmm0
ff
ucomiss -0x10c(%rbp),%xmm0
jbe    1928 <tri_tri_intersect_with_isectline+0x7f8>
movss  -0x104(%rbp),%xmm0
ff
movss  %xmm0,-0x10c(%rbp)
ff
movw   $0x1,-0xe6(%rbp)
movss  -0x108(%rbp),%xmm0
ff
ucomiss -0x10c(%rbp),%xmm0
jbe    1956 <tri_tri_intersect_with_isectline+0x826>
movss  -0x108(%rbp),%xmm0
ff
movss  %xmm0,-0x10c(%rbp)
ff
movw   $0x2,-0xe6(%rbp)
mov    -0x10(%rbp),%rax
movswq -0xe6(%rbp),%rcx
ff
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xec(%rbp)
ff
mov    -0x18(%rbp),%rax
movswq -0xe6(%rbp),%rcx
ff
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xf0(%rbp)
ff
mov    -0x20(%rbp),%rax
movswq -0xe6(%rbp),%rcx
ff
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xf4(%rbp)
ff
mov    -0x28(%rbp),%rax
movswq -0xe6(%rbp),%rcx
ff
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xf8(%rbp)
ff
mov    -0x30(%rbp),%rax
movswq -0xe6(%rbp),%rcx
ff
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xfc(%rbp)
ff
mov    -0x38(%rbp),%rax
movswq -0xe6(%rbp),%rcx
ff
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x100(%rbp)
ff
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdx
movss  -0xec(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movss  -0xf0(%rbp),%xmm1
ff
cvtss2sd %xmm1,%xmm1
movss  -0xf4(%rbp),%xmm2
ff
cvtss2sd %xmm2,%xmm2
movss  -0x80(%rbp),%xmm3
cvtss2sd %xmm3,%xmm3
movss  -0x84(%rbp),%xmm4
ff
cvtss2sd %xmm4,%xmm4
movss  -0x88(%rbp),%xmm5
ff
cvtss2sd %xmm5,%xmm5
movss  -0xe0(%rbp),%xmm6
ff
cvtss2sd %xmm6,%xmm6
movss  -0xe4(%rbp),%xmm7
ff
cvtss2sd %xmm7,%xmm7
lea    -0x9c(%rbp),%rcx
lea    -0x9c(%rbp),%r8
add    $0x4,%r8
lea    -0xb0(%rbp),%r9
lea    -0xbc(%rbp),%rax
mov    %rax,(%rsp)
mov    $0x8,%al
call   1050 <compute_intervals_isectline@plt>
mov    %eax,%ecx
mov    0x10(%rbp),%rax
mov    %ecx,(%rax)
mov    0x10(%rbp),%rax
cmpl   $0x0,(%rax)
je     1ac4 <tri_tri_intersect_with_isectline+0x994>
lea    -0x5c(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0x20(%rbp),%rcx
mov    -0x28(%rbp),%r8
mov    -0x30(%rbp),%r9
mov    -0x38(%rbp),%rax
mov    %rax,(%rsp)
mov    $0x0,%al
call   1030 <coplanar_tri_tri@plt>
mov    %eax,-0x4(%rbp)
jmp    1f7c <tri_tri_intersect_with_isectline+0xe4c>
mov    -0x28(%rbp),%rdi
mov    -0x30(%rbp),%rsi
mov    -0x38(%rbp),%rdx
movss  -0xf8(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movss  -0xfc(%rbp),%xmm1
ff
cvtss2sd %xmm1,%xmm1
movss  -0x100(%rbp),%xmm2
ff
cvtss2sd %xmm2,%xmm2
movss  -0x74(%rbp),%xmm3
cvtss2sd %xmm3,%xmm3
movss  -0x78(%rbp),%xmm4
cvtss2sd %xmm4,%xmm4
movss  -0x7c(%rbp),%xmm5
cvtss2sd %xmm5,%xmm5
movss  -0xd8(%rbp),%xmm6
ff
cvtss2sd %xmm6,%xmm6
movss  -0xdc(%rbp),%xmm7
ff
cvtss2sd %xmm7,%xmm7
lea    -0xa4(%rbp),%rcx
lea    -0xa4(%rbp),%r8
add    $0x4,%r8
lea    -0xc8(%rbp),%r9
lea    -0xd4(%rbp),%rax
mov    %rax,(%rsp)
mov    $0x8,%al
call   1050 <compute_intervals_isectline@plt>
movss  -0x9c(%rbp),%xmm0
ff
ucomiss -0x98(%rbp),%xmm0
jbe    1ba6 <tri_tri_intersect_with_isectline+0xa76>
movss  -0x9c(%rbp),%xmm0
ff
movss  %xmm0,-0x118(%rbp)
ff
movss  -0x98(%rbp),%xmm0
ff
movss  %xmm0,-0x9c(%rbp)
ff
movss  -0x118(%rbp),%xmm0
ff
movss  %xmm0,-0x98(%rbp)
ff
movl   $0x1,-0x110(%rbp)
jmp    1bb0 <tri_tri_intersect_with_isectline+0xa80>
movl   $0x0,-0x110(%rbp)
movss  -0xa4(%rbp),%xmm0
ff
ucomiss -0xa0(%rbp),%xmm0
jbe    1c04 <tri_tri_intersect_with_isectline+0xad4>
movss  -0xa4(%rbp),%xmm0
ff
movss  %xmm0,-0x11c(%rbp)
ff
movss  -0xa0(%rbp),%xmm0
ff
movss  %xmm0,-0xa4(%rbp)
ff
movss  -0x11c(%rbp),%xmm0
ff
movss  %xmm0,-0xa0(%rbp)
ff
movl   $0x1,-0x114(%rbp)
jmp    1c0e <tri_tri_intersect_with_isectline+0xade>
movl   $0x0,-0x114(%rbp)
movss  -0x98(%rbp),%xmm1
ff
movss  -0xa4(%rbp),%xmm0
ff
ucomiss %xmm1,%xmm0
ja     1c40 <tri_tri_intersect_with_isectline+0xb10>
movss  -0xa0(%rbp),%xmm1
ff
movss  -0x9c(%rbp),%xmm0
ff
ucomiss %xmm1,%xmm0
jbe    1c4c <tri_tri_intersect_with_isectline+0xb1c>
movl   $0x0,-0x4(%rbp)
jmp    1f7c <tri_tri_intersect_with_isectline+0xe4c>
movss  -0xa4(%rbp),%xmm1
ff
movss  -0x9c(%rbp),%xmm0
ff
ucomiss %xmm1,%xmm0
jbe    1def <tri_tri_intersect_with_isectline+0xcbf>
cmpl   $0x0,-0x110(%rbp)
jne    1ca9 <tri_tri_intersect_with_isectline+0xb79>
movss  -0xb0(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0xac(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0xa8(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movss  %xmm0,0x8(%rax)
jmp    1cdb <tri_tri_intersect_with_isectline+0xbab>
movss  -0xbc(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0xb8(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0xb4(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0xa0(%rbp),%xmm1
ff
movss  -0x98(%rbp),%xmm0
ff
ucomiss %xmm1,%xmm0
jbe    1d6f <tri_tri_intersect_with_isectline+0xc3f>
cmpl   $0x0,-0x114(%rbp)
jne    1d38 <tri_tri_intersect_with_isectline+0xc08>
movss  -0xd4(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0xd0(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0xcc(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
movss  %xmm0,0x8(%rax)
jmp    1d6a <tri_tri_intersect_with_isectline+0xc3a>
movss  -0xc8(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0xc4(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0xc0(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
movss  %xmm0,0x8(%rax)
jmp    1dea <tri_tri_intersect_with_isectline+0xcba>
cmpl   $0x0,-0x110(%rbp)
jne    1db3 <tri_tri_intersect_with_isectline+0xc83>
movss  -0xbc(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0xb8(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0xb4(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
movss  %xmm0,0x8(%rax)
jmp    1de5 <tri_tri_intersect_with_isectline+0xcb5>
movss  -0xb0(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0xac(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0xa8(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
movss  %xmm0,0x8(%rax)
jmp    1dea <tri_tri_intersect_with_isectline+0xcba>
jmp    1f75 <tri_tri_intersect_with_isectline+0xe45>
cmpl   $0x0,-0x114(%rbp)
jne    1e33 <tri_tri_intersect_with_isectline+0xd03>
movss  -0xc8(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0xc4(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0xc0(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movss  %xmm0,0x8(%rax)
jmp    1e65 <tri_tri_intersect_with_isectline+0xd35>
movss  -0xd4(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0xd0(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0xcc(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0xa0(%rbp),%xmm0
ff
ucomiss -0x98(%rbp),%xmm0
jbe    1ef5 <tri_tri_intersect_with_isectline+0xdc5>
cmpl   $0x0,-0x110(%rbp)
jne    1ebe <tri_tri_intersect_with_isectline+0xd8e>
movss  -0xbc(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0xb8(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0xb4(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
movss  %xmm0,0x8(%rax)
jmp    1ef0 <tri_tri_intersect_with_isectline+0xdc0>
movss  -0xb0(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0xac(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0xa8(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
movss  %xmm0,0x8(%rax)
jmp    1f70 <tri_tri_intersect_with_isectline+0xe40>
cmpl   $0x0,-0x114(%rbp)
jne    1f39 <tri_tri_intersect_with_isectline+0xe09>
movss  -0xd4(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0xd0(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0xcc(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
movss  %xmm0,0x8(%rax)
jmp    1f6b <tri_tri_intersect_with_isectline+0xe3b>
movss  -0xc8(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0xc4(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0xc0(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
movss  %xmm0,0x8(%rax)
jmp    1f70 <tri_tri_intersect_with_isectline+0xe40>
jmp    1f75 <tri_tri_intersect_with_isectline+0xe45>
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x130,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<tri_tri_intersect_with_isectline>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x118,%rsp
mov    %r9,%r12
mov    %r8,%r14
mov    %rcx,%r15
mov    %rdx,%r13
mov    %rsi,%rbx
mov    %rdi,%rbp
movq   $0x0,0x58(%rsp)
movq   $0x0,0x50(%rsp)
movl   $0x0,0x48(%rsp)
movq   $0x0,0x40(%rsp)
movl   $0x0,0x38(%rsp)
movq   $0x0,0x30(%rsp)
movl   $0x0,0x28(%rsp)
movq   $0x0,0x20(%rsp)
movl   $0x0,0x18(%rsp)
movq   $0x0,0x10(%rsp)
movss  0x4(%rsi),%xmm3
movsd  (%rdi),%xmm10
movaps %xmm10,%xmm0
shufps $0x55,%xmm10,%xmm0
movaps %xmm3,0x90(%rsp)
subss  %xmm0,%xmm3
movss  0x8(%rsi),%xmm2
movss  0x8(%rdi),%xmm1
movss  (%rsi),%xmm0
movaps %xmm0,0x70(%rsp)
movaps %xmm2,0xa0(%rsp)
unpcklps %xmm2,%xmm0
movaps %xmm1,%xmm2
movlhps %xmm10,%xmm2
shufps $0xe2,%xmm10,%xmm2
subps  %xmm2,%xmm0
movaps %xmm0,%xmm5
movaps %xmm3,%xmm15
movlhps %xmm0,%xmm3
shufps $0xe2,%xmm0,%xmm3
shufps $0xe1,%xmm0,%xmm0
movsd  (%rdx),%xmm11
movaps %xmm11,0x100(%rsp)
subps  %xmm10,%xmm11
movss  0x8(%rdx),%xmm6
movaps %xmm6,0x80(%rsp)
subss  %xmm1,%xmm6
shufps $0x55,%xmm5,%xmm5
movaps %xmm11,%xmm7
shufps $0x55,%xmm11,%xmm7
mulss  %xmm5,%xmm7
mulss  %xmm6,%xmm15
subss  %xmm7,%xmm15
movss  %xmm15,0x64(%rsp)
unpcklps %xmm11,%xmm6
mulps  %xmm3,%xmm6
mulps  %xmm0,%xmm11
subps  %xmm6,%xmm11
movaps %xmm11,%xmm13
shufps $0x55,%xmm11,%xmm13
movss  %xmm11,0x68(%rsp)
movss  %xmm13,0x6c(%rsp)
movsd  (%rcx),%xmm12
movsd  (%r8),%xmm5
movaps %xmm10,%xmm0
shufps $0x1,%xmm11,%xmm0
shufps $0xe2,%xmm11,%xmm0
movaps %xmm11,%xmm3
shufps $0x10,%xmm5,%xmm3
shufps $0xe2,%xmm5,%xmm3
mulps  %xmm0,%xmm3
movaps %xmm15,%xmm0
shufps $0x0,%xmm15,%xmm0
movaps %xmm5,%xmm6
unpcklps %xmm10,%xmm6
mulps  %xmm0,%xmm6
addps  %xmm3,%xmm6
movss  0x8(%r8),%xmm14
movaps %xmm14,%xmm3
unpcklps %xmm1,%xmm3
mulps  %xmm13,%xmm3
addps  %xmm6,%xmm3
movaps %xmm11,%xmm2
shufps $0x0,%xmm11,%xmm2
movaps %xmm12,%xmm9
shufps $0x55,%xmm12,%xmm9
movsd  0x4(%r9),%xmm7
movaps %xmm9,%xmm6
unpcklps %xmm7,%xmm6
mulps  %xmm2,%xmm6
movss  (%r9),%xmm8
movaps %xmm8,%xmm2
movlhps %xmm12,%xmm2
shufps $0xe2,%xmm12,%xmm2
mulps  %xmm0,%xmm2
addps  %xmm6,%xmm2
movss  0x8(%rcx),%xmm4
movaps %xmm7,%xmm0
movaps %xmm4,0xf0(%rsp)
movss  %xmm4,%xmm0
movaps %xmm13,0xe0(%rsp)
mulps  %xmm13,%xmm0
addps  %xmm2,%xmm0
movaps %xmm3,%xmm2
shufps $0x55,%xmm3,%xmm2
subss  %xmm2,%xmm3
subps  %xmm2,%xmm0
movaps 0xcda(%rip),%xmm4
movaps %xmm3,%xmm2
andps  %xmm4,%xmm2
cvtss2sd %xmm2,%xmm2
movsd  0xce8(%rip),%xmm6
ucomisd %xmm2,%xmm6
xorpd  %xmm6,%xmm6
ja     1345 <tri_tri_intersect_with_isectline+0x225>
movaps %xmm3,%xmm6
movaps %xmm0,%xmm2
andps  %xmm4,%xmm2
cvtps2pd %xmm2,%xmm2
cmpltpd 0xcb9(%rip),%xmm2
shufps $0xe8,%xmm2,%xmm2
andnps %xmm0,%xmm2
movaps %xmm2,%xmm3
mulss  %xmm6,%xmm3
pshufd $0x55,%xmm2,%xmm0
movaps %xmm2,%xmm13
movdqa %xmm0,0xd0(%rsp)
mulss  %xmm0,%xmm13
xor    %eax,%eax
ucomiss 0xca3(%rip),%xmm3
jbe    1394 <tri_tri_intersect_with_isectline+0x274>
xorps  %xmm0,%xmm0
ucomiss %xmm0,%xmm13
ja     1857 <tri_tri_intersect_with_isectline+0x737>
movaps %xmm3,0xb0(%rsp)
movaps %xmm2,0xc0(%rsp)
movss  %xmm6,0x60(%rsp)
subps  %xmm12,%xmm5
movaps 0xf0(%rsp),%xmm3
subss  %xmm3,%xmm14
subss  %xmm12,%xmm8
movaps %xmm3,%xmm0
movlhps %xmm9,%xmm0
shufps $0xe2,%xmm9,%xmm0
subps  %xmm0,%xmm7
movaps %xmm7,%xmm2
shufps $0x55,%xmm7,%xmm2
mulss  %xmm5,%xmm2
movaps %xmm14,%xmm9
mulss  %xmm8,%xmm9
subss  %xmm2,%xmm9
shufps $0xd4,%xmm5,%xmm14
shufps $0x52,%xmm5,%xmm14
unpcklps %xmm7,%xmm8
mulps  %xmm14,%xmm8
mulps  %xmm5,%xmm7
subps  %xmm8,%xmm7
movaps 0x70(%rsp),%xmm6
unpcklps %xmm12,%xmm6
movaps 0x90(%rsp),%xmm2
movss  %xmm2,%xmm12
movaps %xmm9,%xmm2
shufps $0x0,%xmm9,%xmm2
mulps  %xmm2,%xmm12
movaps %xmm7,%xmm5
shufps $0x55,%xmm7,%xmm5
mulps  %xmm5,%xmm6
addps  %xmm12,%xmm6
movaps 0xa0(%rsp),%xmm4
unpcklps %xmm3,%xmm4
movaps %xmm7,%xmm3
shufps $0x0,%xmm7,%xmm3
mulps  %xmm3,%xmm4
addps  %xmm6,%xmm4
movaps 0x100(%rsp),%xmm0
movaps %xmm0,%xmm6
shufps $0x11,%xmm10,%xmm6
shufps $0xe2,%xmm10,%xmm6
mulps  %xmm2,%xmm6
unpcklps %xmm0,%xmm10
mulps  %xmm5,%xmm10
addps  %xmm6,%xmm10
unpcklps 0x80(%rsp),%xmm1
mulps  %xmm3,%xmm1
addps  %xmm10,%xmm1
movaps %xmm4,%xmm2
shufps $0x55,%xmm4,%xmm2
subss  %xmm2,%xmm4
subps  %xmm2,%xmm1
movaps %xmm4,%xmm2
andps  0xb6b(%rip),%xmm2
cvtss2sd %xmm2,%xmm2
movsd  0xb7f(%rip),%xmm0
ucomisd %xmm2,%xmm0
xorps  %xmm10,%xmm10
xorps  %xmm12,%xmm12
ja     14b3 <tri_tri_intersect_with_isectline+0x393>
movaps %xmm4,%xmm12
movaps %xmm1,%xmm2
andps  0xb43(%rip),%xmm2
cvtps2pd %xmm2,%xmm3
cmpltpd 0xb47(%rip),%xmm3
shufps $0xe8,%xmm3,%xmm3
andnps %xmm1,%xmm3
movaps %xmm3,%xmm6
mulss  %xmm12,%xmm6
pshufd $0x55,%xmm3,%xmm14
movaps %xmm3,%xmm8
mulss  %xmm14,%xmm8
ucomiss %xmm10,%xmm6
jbe    14fa <tri_tri_intersect_with_isectline+0x3da>
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm8
ja     1857 <tri_tri_intersect_with_isectline+0x737>
movaps %xmm13,0xa0(%rsp)
movaps %xmm15,%xmm1
movaps 0xe0(%rsp),%xmm2
movlhps %xmm2,%xmm1
shufps $0xe2,%xmm2,%xmm1
movaps %xmm9,%xmm2
unpcklps %xmm7,%xmm2
mulps  %xmm1,%xmm2
movaps %xmm11,%xmm1
mulps  %xmm7,%xmm1
subps  %xmm2,%xmm1
mulss  %xmm11,%xmm5
mulss  %xmm9,%xmm15
subss  %xmm5,%xmm15
movaps 0xac0(%rip),%xmm2
andps  %xmm2,%xmm1
pshufd $0x55,%xmm1,%xmm0
xor    %eax,%eax
ucomiss %xmm1,%xmm0
seta   %al
andps  %xmm2,%xmm15
maxss  %xmm1,%xmm0
ucomiss %xmm0,%xmm15
mov    $0x2,%ecx
cmovbe %rax,%rcx
movss  0x0(%rbp,%rcx,4),%xmm0
movss  (%rbx,%rcx,4),%xmm1
movss  0x0(%r13,%rcx,4),%xmm2
movss  (%r15,%rcx,4),%xmm4
movss  %xmm4,0x90(%rsp)
movss  (%r14,%rcx,4),%xmm4
movss  %xmm4,0x80(%rsp)
movss  (%r12,%rcx,4),%xmm4
movss  %xmm4,0x70(%rsp)
cvtss2sd %xmm0,%xmm0
cvtss2sd %xmm1,%xmm1
cvtss2sd %xmm2,%xmm2
cvtss2sd %xmm3,%xmm3
xorps  %xmm4,%xmm4
cvtss2sd %xmm12,%xmm4
xorps  %xmm5,%xmm5
cvtss2sd %xmm14,%xmm5
cvtss2sd %xmm6,%xmm6
cvtss2sd %xmm8,%xmm7
lea    0x5c(%rsp),%r8
lea    0x30(%rsp),%rax
mov    %rax,(%rsp)
lea    0x58(%rsp),%rcx
lea    0x40(%rsp),%r9
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    %r13,%rdx
mov    $0x8,%al
call   1040 <compute_intervals_isectline@plt>
mov    0x150(%rsp),%rcx
mov    %eax,(%rcx)
test   %eax,%eax
je     1624 <tri_tri_intersect_with_isectline+0x504>
mov    %r12,(%rsp)
lea    0x64(%rsp),%rdi
mov    %rbp,%rsi
mov    %rbx,%rdx
mov    %r13,%rcx
mov    %r15,%r8
mov    %r14,%r9
xor    %eax,%eax
call   1030 <coplanar_tri_tri@plt>
jmp    1857 <tri_tri_intersect_with_isectline+0x737>
movss  0x90(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  0x80(%rsp),%xmm1
cvtss2sd %xmm1,%xmm1
movss  0x70(%rsp),%xmm2
cvtss2sd %xmm2,%xmm2
movaps 0xc0(%rsp),%xmm3
cvtss2sd %xmm3,%xmm3
movss  0x60(%rsp),%xmm4
cvtss2sd %xmm4,%xmm4
movaps 0xd0(%rsp),%xmm5
cvtss2sd %xmm5,%xmm5
movaps 0xb0(%rsp),%xmm6
cvtss2sd %xmm6,%xmm6
movaps 0xa0(%rsp),%xmm7
cvtss2sd %xmm7,%xmm7
lea    0x54(%rsp),%r8
lea    0x10(%rsp),%rax
mov    %rax,(%rsp)
lea    0x50(%rsp),%rcx
lea    0x20(%rsp),%r9
mov    %r15,%rdi
mov    %r14,%rsi
mov    %r12,%rdx
mov    $0x8,%al
call   1040 <compute_intervals_isectline@plt>
movss  0x58(%rsp),%xmm1
movss  0x5c(%rsp),%xmm2
ucomiss %xmm2,%xmm1
movaps %xmm1,%xmm6
movaps %xmm2,%xmm0
jbe    16d3 <tri_tri_intersect_with_isectline+0x5b3>
movss  %xmm2,0x58(%rsp)
movss  %xmm1,0x5c(%rsp)
movaps %xmm2,%xmm6
movaps %xmm1,%xmm0
movss  0x50(%rsp),%xmm4
movss  0x54(%rsp),%xmm5
ucomiss %xmm5,%xmm4
movaps %xmm5,%xmm3
movaps %xmm4,%xmm7
mov    $0x0,%eax
jbe    1701 <tri_tri_intersect_with_isectline+0x5e1>
movss  %xmm5,0x50(%rsp)
movss  %xmm4,0x54(%rsp)
movaps %xmm4,%xmm3
movaps %xmm5,%xmm7
ucomiss %xmm0,%xmm7
ja     1857 <tri_tri_intersect_with_isectline+0x737>
ucomiss %xmm3,%xmm6
ja     1857 <tri_tri_intersect_with_isectline+0x737>
mov    0x160(%rsp),%rax
mov    0x158(%rsp),%rcx
ucomiss %xmm7,%xmm6
jbe    1757 <tri_tri_intersect_with_isectline+0x637>
ucomiss %xmm2,%xmm1
jbe    1783 <tri_tri_intersect_with_isectline+0x663>
movss  0x30(%rsp),%xmm1
movss  %xmm1,(%rcx)
movss  0x34(%rsp),%xmm1
movss  %xmm1,0x4(%rcx)
movss  0x38(%rsp),%xmm1
movss  %xmm1,0x8(%rcx)
ucomiss %xmm3,%xmm0
ja     17ac <tri_tri_intersect_with_isectline+0x68c>
jmp    17f8 <tri_tri_intersect_with_isectline+0x6d8>
ucomiss %xmm5,%xmm4
jbe    17ce <tri_tri_intersect_with_isectline+0x6ae>
movss  0x10(%rsp),%xmm4
movss  %xmm4,(%rcx)
movss  0x14(%rsp),%xmm4
movss  %xmm4,0x4(%rcx)
movss  0x18(%rsp),%xmm4
movss  %xmm4,0x8(%rcx)
ucomiss %xmm0,%xmm3
jbe    17b1 <tri_tri_intersect_with_isectline+0x691>
jmp    17f3 <tri_tri_intersect_with_isectline+0x6d3>
movss  0x40(%rsp),%xmm1
movss  %xmm1,(%rcx)
movss  0x44(%rsp),%xmm1
movss  %xmm1,0x4(%rcx)
movss  0x48(%rsp),%xmm1
movss  %xmm1,0x8(%rcx)
ucomiss %xmm3,%xmm0
jbe    1832 <tri_tri_intersect_with_isectline+0x712>
ucomiss %xmm5,%xmm4
jbe    1815 <tri_tri_intersect_with_isectline+0x6f5>
movss  0x20(%rsp),%xmm0
movss  %xmm0,(%rax)
movss  0x24(%rsp),%xmm0
movss  %xmm0,0x4(%rax)
movss  0x28(%rsp),%xmm0
jmp    184d <tri_tri_intersect_with_isectline+0x72d>
movss  0x20(%rsp),%xmm4
movss  %xmm4,(%rcx)
movss  0x24(%rsp),%xmm4
movss  %xmm4,0x4(%rcx)
movss  0x28(%rsp),%xmm4
movss  %xmm4,0x8(%rcx)
ucomiss %xmm0,%xmm3
jbe    1815 <tri_tri_intersect_with_isectline+0x6f5>
ucomiss %xmm2,%xmm1
jbe    1832 <tri_tri_intersect_with_isectline+0x712>
movss  0x40(%rsp),%xmm0
movss  %xmm0,(%rax)
movss  0x44(%rsp),%xmm0
movss  %xmm0,0x4(%rax)
movss  0x48(%rsp),%xmm0
jmp    184d <tri_tri_intersect_with_isectline+0x72d>
movss  0x10(%rsp),%xmm0
movss  %xmm0,(%rax)
movss  0x14(%rsp),%xmm0
movss  %xmm0,0x4(%rax)
movss  0x18(%rsp),%xmm0
jmp    184d <tri_tri_intersect_with_isectline+0x72d>
movss  0x30(%rsp),%xmm0
movss  %xmm0,(%rax)
movss  0x34(%rsp),%xmm0
movss  %xmm0,0x4(%rax)
movss  0x38(%rsp),%xmm0
movss  %xmm0,0x8(%rax)
mov    $0x1,%eax
add    $0x118,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @tri_tri_intersect_with_isectline(float* %0, float* %1, float* %2, float* %3, float* %4, float* %5, i32* %6, float* %7, float* %8) {
%10 = alloca i32
%11 = alloca float*
%12 = alloca float*
%13 = alloca float*
%14 = alloca float*
%15 = alloca float*
%16 = alloca float*
%17 = alloca i32*
%18 = alloca float*
%19 = alloca float*
%20 = alloca [3 x float]
%21 = alloca [3 x float]
%22 = alloca [3 x float]
%23 = alloca [3 x float]
%24 = alloca float
%25 = alloca float
%26 = alloca float
%27 = alloca float
%28 = alloca float
%29 = alloca float
%30 = alloca float
%31 = alloca float
%32 = alloca [3 x float]
%33 = alloca [2 x float]
%34 = alloca [2 x float]
%35 = alloca [3 x float]
%36 = alloca [3 x float]
%37 = alloca [3 x float]
%38 = alloca [3 x float]
%39 = alloca float
%40 = alloca float
%41 = alloca float
%42 = alloca float
%43 = alloca i16
%44 = alloca float
%45 = alloca float
%46 = alloca float
%47 = alloca float
%48 = alloca float
%49 = alloca float
%50 = alloca float
%51 = alloca float
%52 = alloca float
%53 = alloca i32
%54 = alloca i32
%55 = alloca float
%56 = alloca float
store float* %0, float** %11
store float* %1, float** %12
store float* %2, float** %13
store float* %3, float** %14
store float* %4, float** %15
store float* %5, float** %16
store i32* %6, i32** %17
store float* %7, float** %18
store float* %8, float** %19
%57 = bitcast [2 x float]* %33 to i8*
%58 = bitcast [2 x float]* %34 to i8*
%59 = bitcast [3 x float]* %35 to i8*
%60 = bitcast [3 x float]* %36 to i8*
%61 = bitcast [3 x float]* %37 to i8*
%62 = bitcast [3 x float]* %38 to i8*
%63 = load float*, float** %12
%64 = getelementptr inbounds float, float* %63, i64 0
%65 = load float, float* %64
%66 = load float*, float** %11
%67 = getelementptr inbounds float, float* %66, i64 0
%68 = load float, float* %67
%69 = fsub float %65, %68
%70 = getelementptr inbounds [3 x float], [3 x float]* %20, i64 0, i64 0
store float %69, float* %70
%71 = load float*, float** %12
%72 = getelementptr inbounds float, float* %71, i64 1
%73 = load float, float* %72
%74 = load float*, float** %11
%75 = getelementptr inbounds float, float* %74, i64 1
%76 = load float, float* %75
%77 = fsub float %73, %76
%78 = getelementptr inbounds [3 x float], [3 x float]* %20, i64 0, i64 1
store float %77, float* %78
%79 = load float*, float** %12
%80 = getelementptr inbounds float, float* %79, i64 2
%81 = load float, float* %80
%82 = load float*, float** %11
%83 = getelementptr inbounds float, float* %82, i64 2
%84 = load float, float* %83
%85 = fsub float %81, %84
%86 = getelementptr inbounds [3 x float], [3 x float]* %20, i64 0, i64 2
store float %85, float* %86
%87 = load float*, float** %13
%88 = getelementptr inbounds float, float* %87, i64 0
%89 = load float, float* %88
%90 = load float*, float** %11
%91 = getelementptr inbounds float, float* %90, i64 0
%92 = load float, float* %91
%93 = fsub float %89, %92
%94 = getelementptr inbounds [3 x float], [3 x float]* %21, i64 0, i64 0
store float %93, float* %94
%95 = load float*, float** %13
%96 = getelementptr inbounds float, float* %95, i64 1
%97 = load float, float* %96
%98 = load float*, float** %11
%99 = getelementptr inbounds float, float* %98, i64 1
%100 = load float, float* %99
%101 = fsub float %97, %100
%102 = getelementptr inbounds [3 x float], [3 x float]* %21, i64 0, i64 1
store float %101, float* %102
%103 = load float*, float** %13
%104 = getelementptr inbounds float, float* %103, i64 2
%105 = load float, float* %104
%106 = load float*, float** %11
%107 = getelementptr inbounds float, float* %106, i64 2
%108 = load float, float* %107
%109 = fsub float %105, %108
%110 = getelementptr inbounds [3 x float], [3 x float]* %21, i64 0, i64 2
store float %109, float* %110
%111 = getelementptr inbounds [3 x float], [3 x float]* %20, i64 0, i64 1
%112 = load float, float* %111
%113 = getelementptr inbounds [3 x float], [3 x float]* %21, i64 0, i64 2
%114 = load float, float* %113
%115 = getelementptr inbounds [3 x float], [3 x float]* %20, i64 0, i64 2
%116 = load float, float* %115
%117 = getelementptr inbounds [3 x float], [3 x float]* %21, i64 0, i64 1
%118 = load float, float* %117
%119 = fmul float %116, %118
%120 = fneg float %119
%121 = call float @llvm.fmuladd.f32(float %112, float %114, float %120)
%122 = getelementptr inbounds [3 x float], [3 x float]* %22, i64 0, i64 0
store float %121, float* %122
%123 = getelementptr inbounds [3 x float], [3 x float]* %20, i64 0, i64 2
%124 = load float, float* %123
%125 = getelementptr inbounds [3 x float], [3 x float]* %21, i64 0, i64 0
%126 = load float, float* %125
%127 = getelementptr inbounds [3 x float], [3 x float]* %20, i64 0, i64 0
%128 = load float, float* %127
%129 = getelementptr inbounds [3 x float], [3 x float]* %21, i64 0, i64 2
%130 = load float, float* %129
%131 = fmul float %128, %130
%132 = fneg float %131
%133 = call float @llvm.fmuladd.f32(float %124, float %126, float %132)
%134 = getelementptr inbounds [3 x float], [3 x float]* %22, i64 0, i64 1
store float %133, float* %134
%135 = getelementptr inbounds [3 x float], [3 x float]* %20, i64 0, i64 0
%136 = load float, float* %135
%137 = getelementptr inbounds [3 x float], [3 x float]* %21, i64 0, i64 1
%138 = load float, float* %137
%139 = getelementptr inbounds [3 x float], [3 x float]* %20, i64 0, i64 1
%140 = load float, float* %139
%141 = getelementptr inbounds [3 x float], [3 x float]* %21, i64 0, i64 0
%142 = load float, float* %141
%143 = fmul float %140, %142
%144 = fneg float %143
%145 = call float @llvm.fmuladd.f32(float %136, float %138, float %144)
%146 = getelementptr inbounds [3 x float], [3 x float]* %22, i64 0, i64 2
store float %145, float* %146
%147 = getelementptr inbounds [3 x float], [3 x float]* %22, i64 0, i64 0
%148 = load float, float* %147
%149 = load float*, float** %11
%150 = getelementptr inbounds float, float* %149, i64 0
%151 = load float, float* %150
%152 = getelementptr inbounds [3 x float], [3 x float]* %22, i64 0, i64 1
%153 = load float, float* %152
%154 = load float*, float** %11
%155 = getelementptr inbounds float, float* %154, i64 1
%156 = load float, float* %155
%157 = fmul float %153, %156
%158 = call float @llvm.fmuladd.f32(float %148, float %151, float %157)
%159 = getelementptr inbounds [3 x float], [3 x float]* %22, i64 0, i64 2
%160 = load float, float* %159
%161 = load float*, float** %11
%162 = getelementptr inbounds float, float* %161, i64 2
%163 = load float, float* %162
%164 = call float @llvm.fmuladd.f32(float %160, float %163, float %158)
%165 = fneg float %164
store float %165, float* %24
%166 = getelementptr inbounds [3 x float], [3 x float]* %22, i64 0, i64 0
%167 = load float, float* %166
%168 = load float*, float** %14
%169 = getelementptr inbounds float, float* %168, i64 0
%170 = load float, float* %169
%171 = getelementptr inbounds [3 x float], [3 x float]* %22, i64 0, i64 1
%172 = load float, float* %171
%173 = load float*, float** %14
%174 = getelementptr inbounds float, float* %173, i64 1
%175 = load float, float* %174
%176 = fmul float %172, %175
%177 = call float @llvm.fmuladd.f32(float %167, float %170, float %176)
%178 = getelementptr inbounds [3 x float], [3 x float]* %22, i64 0, i64 2
%179 = load float, float* %178
%180 = load float*, float** %14
%181 = getelementptr inbounds float, float* %180, i64 2
%182 = load float, float* %181
%183 = call float @llvm.fmuladd.f32(float %179, float %182, float %177)
%184 = load float, float* %24
%185 = fadd float %183, %184
store float %185, float* %26
%186 = getelementptr inbounds [3 x float], [3 x float]* %22, i64 0, i64 0
%187 = load float, float* %186
%188 = load float*, float** %15
%189 = getelementptr inbounds float, float* %188, i64 0
%190 = load float, float* %189
%191 = getelementptr inbounds [3 x float], [3 x float]* %22, i64 0, i64 1
%192 = load float, float* %191
%193 = load float*, float** %15
%194 = getelementptr inbounds float, float* %193, i64 1
%195 = load float, float* %194
%196 = fmul float %192, %195
%197 = call float @llvm.fmuladd.f32(float %187, float %190, float %196)
%198 = getelementptr inbounds [3 x float], [3 x float]* %22, i64 0, i64 2
%199 = load float, float* %198
%200 = load float*, float** %15
%201 = getelementptr inbounds float, float* %200, i64 2
%202 = load float, float* %201
%203 = call float @llvm.fmuladd.f32(float %199, float %202, float %197)
%204 = load float, float* %24
%205 = fadd float %203, %204
store float %205, float* %27
%206 = getelementptr inbounds [3 x float], [3 x float]* %22, i64 0, i64 0
%207 = load float, float* %206
%208 = load float*, float** %16
%209 = getelementptr inbounds float, float* %208, i64 0
%210 = load float, float* %209
%211 = getelementptr inbounds [3 x float], [3 x float]* %22, i64 0, i64 1
%212 = load float, float* %211
%213 = load float*, float** %16
%214 = getelementptr inbounds float, float* %213, i64 1
%215 = load float, float* %214
%216 = fmul float %212, %215
%217 = call float @llvm.fmuladd.f32(float %207, float %210, float %216)
%218 = getelementptr inbounds [3 x float], [3 x float]* %22, i64 0, i64 2
%219 = load float, float* %218
%220 = load float*, float** %16
%221 = getelementptr inbounds float, float* %220, i64 2
%222 = load float, float* %221
%223 = call float @llvm.fmuladd.f32(float %219, float %222, float %217)
%224 = load float, float* %24
%225 = fadd float %223, %224
store float %225, float* %28
%226 = load float, float* %26
%227 = fpext float %226 to double
%228 = call double @llvm.fabs.f64(double %227)
%229 = fcmp olt double %228, 0x3EB0C6F7A0B5ED8D
br i1 %229, label %230, label %231
230: ; preds = %9
store float 0.000000e+00, float* %26
br label %231
231: ; preds = %230, %9
%232 = load float, float* %27
%233 = fpext float %232 to double
%234 = call double @llvm.fabs.f64(double %233)
%235 = fcmp olt double %234, 0x3EB0C6F7A0B5ED8D
br i1 %235, label %236, label %237
236: ; preds = %231
store float 0.000000e+00, float* %27
br label %237
237: ; preds = %236, %231
%238 = load float, float* %28
%239 = fpext float %238 to double
%240 = call double @llvm.fabs.f64(double %239)
%241 = fcmp olt double %240, 0x3EB0C6F7A0B5ED8D
br i1 %241, label %242, label %243
242: ; preds = %237
store float 0.000000e+00, float* %28
br label %243
243: ; preds = %242, %237
%244 = load float, float* %26
%245 = load float, float* %27
%246 = fmul float %244, %245
store float %246, float* %39
%247 = load float, float* %26
%248 = load float, float* %28
%249 = fmul float %247, %248
store float %249, float* %40
%250 = load float, float* %39
%251 = fcmp ogt float %250, 0.000000e+00
br i1 %251, label %252, label %256
252: ; preds = %243
%253 = load float, float* %40
%254 = fcmp ogt float %253, 0.000000e+00
br i1 %254, label %255, label %256
255: ; preds = %252
store i32 0, i32* %10
br label %847
256: ; preds = %252, %243
%257 = load float*, float** %15
%258 = getelementptr inbounds float, float* %257, i64 0
%259 = load float, float* %258
%260 = load float*, float** %14
%261 = getelementptr inbounds float, float* %260, i64 0
%262 = load float, float* %261
%263 = fsub float %259, %262
%264 = getelementptr inbounds [3 x float], [3 x float]* %20, i64 0, i64 0
store float %263, float* %264
%265 = load float*, float** %15
%266 = getelementptr inbounds float, float* %265, i64 1
%267 = load float, float* %266
%268 = load float*, float** %14
%269 = getelementptr inbounds float, float* %268, i64 1
%270 = load float, float* %269
%271 = fsub float %267, %270
%272 = getelementptr inbounds [3 x float], [3 x float]* %20, i64 0, i64 1
store float %271, float* %272
%273 = load float*, float** %15
%274 = getelementptr inbounds float, float* %273, i64 2
%275 = load float, float* %274
%276 = load float*, float** %14
%277 = getelementptr inbounds float, float* %276, i64 2
%278 = load float, float* %277
%279 = fsub float %275, %278
%280 = getelementptr inbounds [3 x float], [3 x float]* %20, i64 0, i64 2
store float %279, float* %280
%281 = load float*, float** %16
%282 = getelementptr inbounds float, float* %281, i64 0
%283 = load float, float* %282
%284 = load float*, float** %14
%285 = getelementptr inbounds float, float* %284, i64 0
%286 = load float, float* %285
%287 = fsub float %283, %286
%288 = getelementptr inbounds [3 x float], [3 x float]* %21, i64 0, i64 0
store float %287, float* %288
%289 = load float*, float** %16
%290 = getelementptr inbounds float, float* %289, i64 1
%291 = load float, float* %290
%292 = load float*, float** %14
%293 = getelementptr inbounds float, float* %292, i64 1
%294 = load float, float* %293
%295 = fsub float %291, %294
%296 = getelementptr inbounds [3 x float], [3 x float]* %21, i64 0, i64 1
store float %295, float* %296
%297 = load float*, float** %16
%298 = getelementptr inbounds float, float* %297, i64 2
%299 = load float, float* %298
%300 = load float*, float** %14
%301 = getelementptr inbounds float, float* %300, i64 2
%302 = load float, float* %301
%303 = fsub float %299, %302
%304 = getelementptr inbounds [3 x float], [3 x float]* %21, i64 0, i64 2
store float %303, float* %304
%305 = getelementptr inbounds [3 x float], [3 x float]* %20, i64 0, i64 1
%306 = load float, float* %305
%307 = getelementptr inbounds [3 x float], [3 x float]* %21, i64 0, i64 2
%308 = load float, float* %307
%309 = getelementptr inbounds [3 x float], [3 x float]* %20, i64 0, i64 2
%310 = load float, float* %309
%311 = getelementptr inbounds [3 x float], [3 x float]* %21, i64 0, i64 1
%312 = load float, float* %311
%313 = fmul float %310, %312
%314 = fneg float %313
%315 = call float @llvm.fmuladd.f32(float %306, float %308, float %314)
%316 = getelementptr inbounds [3 x float], [3 x float]* %23, i64 0, i64 0
store float %315, float* %316
%317 = getelementptr inbounds [3 x float], [3 x float]* %20, i64 0, i64 2
%318 = load float, float* %317
%319 = getelementptr inbounds [3 x float], [3 x float]* %21, i64 0, i64 0
%320 = load float, float* %319
%321 = getelementptr inbounds [3 x float], [3 x float]* %20, i64 0, i64 0
%322 = load float, float* %321
%323 = getelementptr inbounds [3 x float], [3 x float]* %21, i64 0, i64 2
%324 = load float, float* %323
%325 = fmul float %322, %324
%326 = fneg float %325
%327 = call float @llvm.fmuladd.f32(float %318, float %320, float %326)
%328 = getelementptr inbounds [3 x float], [3 x float]* %23, i64 0, i64 1
store float %327, float* %328
%329 = getelementptr inbounds [3 x float], [3 x float]* %20, i64 0, i64 0
%330 = load float, float* %329
%331 = getelementptr inbounds [3 x float], [3 x float]* %21, i64 0, i64 1
%332 = load float, float* %331
%333 = getelementptr inbounds [3 x float], [3 x float]* %20, i64 0, i64 1
%334 = load float, float* %333
%335 = getelementptr inbounds [3 x float], [3 x float]* %21, i64 0, i64 0
%336 = load float, float* %335
%337 = fmul float %334, %336
%338 = fneg float %337
%339 = call float @llvm.fmuladd.f32(float %330, float %332, float %338)
%340 = getelementptr inbounds [3 x float], [3 x float]* %23, i64 0, i64 2
store float %339, float* %340
%341 = getelementptr inbounds [3 x float], [3 x float]* %23, i64 0, i64 0
%342 = load float, float* %341
%343 = load float*, float** %14
%344 = getelementptr inbounds float, float* %343, i64 0
%345 = load float, float* %344
%346 = getelementptr inbounds [3 x float], [3 x float]* %23, i64 0, i64 1
%347 = load float, float* %346
%348 = load float*, float** %14
%349 = getelementptr inbounds float, float* %348, i64 1
%350 = load float, float* %349
%351 = fmul float %347, %350
%352 = call float @llvm.fmuladd.f32(float %342, float %345, float %351)
%353 = getelementptr inbounds [3 x float], [3 x float]* %23, i64 0, i64 2
%354 = load float, float* %353
%355 = load float*, float** %14
%356 = getelementptr inbounds float, float* %355, i64 2
%357 = load float, float* %356
%358 = call float @llvm.fmuladd.f32(float %354, float %357, float %352)
%359 = fneg float %358
store float %359, float* %25
%360 = getelementptr inbounds [3 x float], [3 x float]* %23, i64 0, i64 0
%361 = load float, float* %360
%362 = load float*, float** %11
%363 = getelementptr inbounds float, float* %362, i64 0
%364 = load float, float* %363
%365 = getelementptr inbounds [3 x float], [3 x float]* %23, i64 0, i64 1
%366 = load float, float* %365
%367 = load float*, float** %11
%368 = getelementptr inbounds float, float* %367, i64 1
%369 = load float, float* %368
%370 = fmul float %366, %369
%371 = call float @llvm.fmuladd.f32(float %361, float %364, float %370)
%372 = getelementptr inbounds [3 x float], [3 x float]* %23, i64 0, i64 2
%373 = load float, float* %372
%374 = load float*, float** %11
%375 = getelementptr inbounds float, float* %374, i64 2
%376 = load float, float* %375
%377 = call float @llvm.fmuladd.f32(float %373, float %376, float %371)
%378 = load float, float* %25
%379 = fadd float %377, %378
store float %379, float* %29
%380 = getelementptr inbounds [3 x float], [3 x float]* %23, i64 0, i64 0
%381 = load float, float* %380
%382 = load float*, float** %12
%383 = getelementptr inbounds float, float* %382, i64 0
%384 = load float, float* %383
%385 = getelementptr inbounds [3 x float], [3 x float]* %23, i64 0, i64 1
%386 = load float, float* %385
%387 = load float*, float** %12
%388 = getelementptr inbounds float, float* %387, i64 1
%389 = load float, float* %388
%390 = fmul float %386, %389
%391 = call float @llvm.fmuladd.f32(float %381, float %384, float %390)
%392 = getelementptr inbounds [3 x float], [3 x float]* %23, i64 0, i64 2
%393 = load float, float* %392
%394 = load float*, float** %12
%395 = getelementptr inbounds float, float* %394, i64 2
%396 = load float, float* %395
%397 = call float @llvm.fmuladd.f32(float %393, float %396, float %391)
%398 = load float, float* %25
%399 = fadd float %397, %398
store float %399, float* %30
%400 = getelementptr inbounds [3 x float], [3 x float]* %23, i64 0, i64 0
%401 = load float, float* %400
%402 = load float*, float** %13
%403 = getelementptr inbounds float, float* %402, i64 0
%404 = load float, float* %403
%405 = getelementptr inbounds [3 x float], [3 x float]* %23, i64 0, i64 1
%406 = load float, float* %405
%407 = load float*, float** %13
%408 = getelementptr inbounds float, float* %407, i64 1
%409 = load float, float* %408
%410 = fmul float %406, %409
%411 = call float @llvm.fmuladd.f32(float %401, float %404, float %410)
%412 = getelementptr inbounds [3 x float], [3 x float]* %23, i64 0, i64 2
%413 = load float, float* %412
%414 = load float*, float** %13
%415 = getelementptr inbounds float, float* %414, i64 2
%416 = load float, float* %415
%417 = call float @llvm.fmuladd.f32(float %413, float %416, float %411)
%418 = load float, float* %25
%419 = fadd float %417, %418
store float %419, float* %31
%420 = load float, float* %29
%421 = fpext float %420 to double
%422 = call double @llvm.fabs.f64(double %421)
%423 = fcmp olt double %422, 0x3EB0C6F7A0B5ED8D
br i1 %423, label %424, label %425
424: ; preds = %256
store float 0.000000e+00, float* %29
br label %425
425: ; preds = %424, %256
%426 = load float, float* %30
%427 = fpext float %426 to double
%428 = call double @llvm.fabs.f64(double %427)
%429 = fcmp olt double %428, 0x3EB0C6F7A0B5ED8D
br i1 %429, label %430, label %431
430: ; preds = %425
store float 0.000000e+00, float* %30
br label %431
431: ; preds = %430, %425
%432 = load float, float* %31
%433 = fpext float %432 to double
%434 = call double @llvm.fabs.f64(double %433)
%435 = fcmp olt double %434, 0x3EB0C6F7A0B5ED8D
br i1 %435, label %436, label %437
436: ; preds = %431
store float 0.000000e+00, float* %31
br label %437
437: ; preds = %436, %431
%438 = load float, float* %29
%439 = load float, float* %30
%440 = fmul float %438, %439
store float %440, float* %41
%441 = load float, float* %29
%442 = load float, float* %31
%443 = fmul float %441, %442
store float %443, float* %42
%444 = load float, float* %41
%445 = fcmp ogt float %444, 0.000000e+00
br i1 %445, label %446, label %450
446: ; preds = %437
%447 = load float, float* %42
%448 = fcmp ogt float %447, 0.000000e+00
br i1 %448, label %449, label %450
449: ; preds = %446
store i32 0, i32* %10
br label %847
450: ; preds = %446, %437
%451 = getelementptr inbounds [3 x float], [3 x float]* %22, i64 0, i64 1
%452 = load float, float* %451
%453 = getelementptr inbounds [3 x float], [3 x float]* %23, i64 0, i64 2
%454 = load float, float* %453
%455 = getelementptr inbounds [3 x float], [3 x float]* %22, i64 0, i64 2
%456 = load float, float* %455
%457 = getelementptr inbounds [3 x float], [3 x float]* %23, i64 0, i64 1
%458 = load float, float* %457
%459 = fmul float %456, %458
%460 = fneg float %459
%461 = call float @llvm.fmuladd.f32(float %452, float %454, float %460)
%462 = getelementptr inbounds [3 x float], [3 x float]* %32, i64 0, i64 0
store float %461, float* %462
%463 = getelementptr inbounds [3 x float], [3 x float]* %22, i64 0, i64 2
%464 = load float, float* %463
%465 = getelementptr inbounds [3 x float], [3 x float]* %23, i64 0, i64 0
%466 = load float, float* %465
%467 = getelementptr inbounds [3 x float], [3 x float]* %22, i64 0, i64 0
%468 = load float, float* %467
%469 = getelementptr inbounds [3 x float], [3 x float]* %23, i64 0, i64 2
%470 = load float, float* %469
%471 = fmul float %468, %470
%472 = fneg float %471
%473 = call float @llvm.fmuladd.f32(float %464, float %466, float %472)
%474 = getelementptr inbounds [3 x float], [3 x float]* %32, i64 0, i64 1
store float %473, float* %474
%475 = getelementptr inbounds [3 x float], [3 x float]* %22, i64 0, i64 0
%476 = load float, float* %475
%477 = getelementptr inbounds [3 x float], [3 x float]* %23, i64 0, i64 1
%478 = load float, float* %477
%479 = getelementptr inbounds [3 x float], [3 x float]* %22, i64 0, i64 1
%480 = load float, float* %479
%481 = getelementptr inbounds [3 x float], [3 x float]* %23, i64 0, i64 0
%482 = load float, float* %481
%483 = fmul float %480, %482
%484 = fneg float %483
%485 = call float @llvm.fmuladd.f32(float %476, float %478, float %484)
%486 = getelementptr inbounds [3 x float], [3 x float]* %32, i64 0, i64 2
store float %485, float* %486
%487 = getelementptr inbounds [3 x float], [3 x float]* %32, i64 0, i64 0
%488 = load float, float* %487
%489 = fpext float %488 to double
%490 = call double @llvm.fabs.f64(double %489)
%491 = fptrunc double %490 to float
store float %491, float* %52
store i16 0, i16* %43
%492 = getelementptr inbounds [3 x float], [3 x float]* %32, i64 0, i64 1
%493 = load float, float* %492
%494 = fpext float %493 to double
%495 = call double @llvm.fabs.f64(double %494)
%496 = fptrunc double %495 to float
store float %496, float* %50
%497 = getelementptr inbounds [3 x float], [3 x float]* %32, i64 0, i64 2
%498 = load float, float* %497
%499 = fpext float %498 to double
%500 = call double @llvm.fabs.f64(double %499)
%501 = fptrunc double %500 to float
store float %501, float* %51
%502 = load float, float* %50
%503 = load float, float* %52
%504 = fcmp ogt float %502, %503
br i1 %504, label %505, label %507
505: ; preds = %450
%506 = load float, float* %50
store float %506, float* %52
store i16 1, i16* %43
br label %507
507: ; preds = %505, %450
%508 = load float, float* %51
%509 = load float, float* %52
%510 = fcmp ogt float %508, %509
br i1 %510, label %511, label %513
511: ; preds = %507
%512 = load float, float* %51
store float %512, float* %52
store i16 2, i16* %43
br label %513
513: ; preds = %511, %507
%514 = load float*, float** %11
%515 = load i16, i16* %43
%516 = sext i16 %515 to i64
%517 = getelementptr inbounds float, float* %514, i64 %516
%518 = load float, float* %517
store float %518, float* %44
%519 = load float*, float** %12
%520 = load i16, i16* %43
%521 = sext i16 %520 to i64
%522 = getelementptr inbounds float, float* %519, i64 %521
%523 = load float, float* %522
store float %523, float* %45
%524 = load float*, float** %13
%525 = load i16, i16* %43
%526 = sext i16 %525 to i64
%527 = getelementptr inbounds float, float* %524, i64 %526
%528 = load float, float* %527
store float %528, float* %46
%529 = load float*, float** %14
%530 = load i16, i16* %43
%531 = sext i16 %530 to i64
%532 = getelementptr inbounds float, float* %529, i64 %531
%533 = load float, float* %532
store float %533, float* %47
%534 = load float*, float** %15
%535 = load i16, i16* %43
%536 = sext i16 %535 to i64
%537 = getelementptr inbounds float, float* %534, i64 %536
%538 = load float, float* %537
store float %538, float* %48
%539 = load float*, float** %16
%540 = load i16, i16* %43
%541 = sext i16 %540 to i64
%542 = getelementptr inbounds float, float* %539, i64 %541
%543 = load float, float* %542
store float %543, float* %49
%544 = load float*, float** %11
%545 = load float*, float** %12
%546 = load float*, float** %13
%547 = load float, float* %44
%548 = fpext float %547 to double
%549 = load float, float* %45
%550 = fpext float %549 to double
%551 = load float, float* %46
%552 = fpext float %551 to double
%553 = load float, float* %29
%554 = fpext float %553 to double
%555 = load float, float* %30
%556 = fpext float %555 to double
%557 = load float, float* %31
%558 = fpext float %557 to double
%559 = load float, float* %41
%560 = fpext float %559 to double
%561 = load float, float* %42
%562 = fpext float %561 to double
%563 = getelementptr inbounds [2 x float], [2 x float]* %33, i64 0, i64 0
%564 = getelementptr inbounds [2 x float], [2 x float]* %33, i64 0, i64 1
%565 = getelementptr inbounds [3 x float], [3 x float]* %35, i64 0, i64 0
%566 = getelementptr inbounds [3 x float], [3 x float]* %36, i64 0, i64 0
%567 = call i32 (float*, float*, float*, double, double, double, double, double, double, double, double, float*, float*, float*, float*, ...) bitcast (i32 (...)* @compute_intervals_isectline to i32 (float*, float*, float*, double, double, double, double, double, double, double, double, float*, float*, float*, float*, ...)*)(float* %544, float* %545, float* %546, double %548, double %550, double %552, double %554, double %556, double %558, double %560, double %562, float* %563, float* %564, float* %565, float* %566)
%568 = load i32*, i32** %17
store i32 %567, i32* %568
%569 = load i32*, i32** %17
%570 = load i32, i32* %569
%571 = icmp ne i32 %570, 0
br i1 %571, label %572, label %581
572: ; preds = %513
%573 = getelementptr inbounds [3 x float], [3 x float]* %22, i64 0, i64 0
%574 = load float*, float** %11
%575 = load float*, float** %12
%576 = load float*, float** %13
%577 = load float*, float** %14
%578 = load float*, float** %15
%579 = load float*, float** %16
%580 = call i32 (float*, float*, float*, float*, float*, float*, float*, ...) bitcast (i32 (...)* @coplanar_tri_tri to i32 (float*, float*, float*, float*, float*, float*, float*, ...)*)(float* %573, float* %574, float* %575, float* %576, float* %577, float* %578, float* %579)
store i32 %580, i32* %10
br label %847
581: ; preds = %513
%582 = load float*, float** %14
%583 = load float*, float** %15
%584 = load float*, float** %16
%585 = load float, float* %47
%586 = fpext float %585 to double
%587 = load float, float* %48
%588 = fpext float %587 to double
%589 = load float, float* %49
%590 = fpext float %589 to double
%591 = load float, float* %26
%592 = fpext float %591 to double
%593 = load float, float* %27
%594 = fpext float %593 to double
%595 = load float, float* %28
%596 = fpext float %595 to double
%597 = load float, float* %39
%598 = fpext float %597 to double
%599 = load float, float* %40
%600 = fpext float %599 to double
%601 = getelementptr inbounds [2 x float], [2 x float]* %34, i64 0, i64 0
%602 = getelementptr inbounds [2 x float], [2 x float]* %34, i64 0, i64 1
%603 = getelementptr inbounds [3 x float], [3 x float]* %37, i64 0, i64 0
%604 = getelementptr inbounds [3 x float], [3 x float]* %38, i64 0, i64 0
%605 = call i32 (float*, float*, float*, double, double, double, double, double, double, double, double, float*, float*, float*, float*, ...) bitcast (i32 (...)* @compute_intervals_isectline to i32 (float*, float*, float*, double, double, double, double, double, double, double, double, float*, float*, float*, float*, ...)*)(float* %582, float* %583, float* %584, double %586, double %588, double %590, double %592, double %594, double %596, double %598, double %600, float* %601, float* %602, float* %603, float* %604)
%606 = getelementptr inbounds [2 x float], [2 x float]* %33, i64 0, i64 0
%607 = load float, float* %606
%608 = getelementptr inbounds [2 x float], [2 x float]* %33, i64 0, i64 1
%609 = load float, float* %608
%610 = fcmp ogt float %607, %609
br i1 %610, label %611, label %619
611: ; preds = %581
%612 = getelementptr inbounds [2 x float], [2 x float]* %33, i64 0, i64 0
%613 = load float, float* %612
store float %613, float* %55
%614 = getelementptr inbounds [2 x float], [2 x float]* %33, i64 0, i64 1
%615 = load float, float* %614
%616 = getelementptr inbounds [2 x float], [2 x float]* %33, i64 0, i64 0
store float %615, float* %616
%617 = load float, float* %55
%618 = getelementptr inbounds [2 x float], [2 x float]* %33, i64 0, i64 1
store float %617, float* %618
store i32 1, i32* %53
br label %620
619: ; preds = %581
store i32 0, i32* %53
br label %620
620: ; preds = %619, %611
%621 = getelementptr inbounds [2 x float], [2 x float]* %34, i64 0, i64 0
%622 = load float, float* %621
%623 = getelementptr inbounds [2 x float], [2 x float]* %34, i64 0, i64 1
%624 = load float, float* %623
%625 = fcmp ogt float %622, %624
br i1 %625, label %626, label %634
626: ; preds = %620
%627 = getelementptr inbounds [2 x float], [2 x float]* %34, i64 0, i64 0
%628 = load float, float* %627
store float %628, float* %56
%629 = getelementptr inbounds [2 x float], [2 x float]* %34, i64 0, i64 1
%630 = load float, float* %629
%631 = getelementptr inbounds [2 x float], [2 x float]* %34, i64 0, i64 0
store float %630, float* %631
%632 = load float, float* %56
%633 = getelementptr inbounds [2 x float], [2 x float]* %34, i64 0, i64 1
store float %632, float* %633
store i32 1, i32* %54
br label %635
634: ; preds = %620
store i32 0, i32* %54
br label %635
635: ; preds = %634, %626
%636 = getelementptr inbounds [2 x float], [2 x float]* %33, i64 0, i64 1
%637 = load float, float* %636
%638 = getelementptr inbounds [2 x float], [2 x float]* %34, i64 0, i64 0
%639 = load float, float* %638
%640 = fcmp olt float %637, %639
br i1 %640, label %647, label %641
641: ; preds = %635
%642 = getelementptr inbounds [2 x float], [2 x float]* %34, i64 0, i64 1
%643 = load float, float* %642
%644 = getelementptr inbounds [2 x float], [2 x float]* %33, i64 0, i64 0
%645 = load float, float* %644
%646 = fcmp olt float %643, %645
br i1 %646, label %647, label %648
647: ; preds = %641, %635
store i32 0, i32* %10
br label %847
648: ; preds = %641
%649 = getelementptr inbounds [2 x float], [2 x float]* %34, i64 0, i64 0
%650 = load float, float* %649
%651 = getelementptr inbounds [2 x float], [2 x float]* %33, i64 0, i64 0
%652 = load float, float* %651
%653 = fcmp olt float %650, %652
br i1 %653, label %654, label %750
654: ; preds = %648
%655 = load i32, i32* %53
%656 = icmp eq i32 %655, 0
br i1 %656, label %657, label %670
657: ; preds = %654
%658 = getelementptr inbounds [3 x float], [3 x float]* %35, i64 0, i64 0
%659 = load float, float* %658
%660 = load float*, float** %18
%661 = getelementptr inbounds float, float* %660, i64 0
store float %659, float* %661
%662 = getelementptr inbounds [3 x float], [3 x float]* %35, i64 0, i64 1
%663 = load float, float* %662
%664 = load float*, float** %18
%665 = getelementptr inbounds float, float* %664, i64 1
store float %663, float* %665
%666 = getelementptr inbounds [3 x float], [3 x float]* %35, i64 0, i64 2
%667 = load float, float* %666
%668 = load float*, float** %18
%669 = getelementptr inbounds float, float* %668, i64 2
store float %667, float* %669
br label %683
670: ; preds = %654
%671 = getelementptr inbounds [3 x float], [3 x float]* %36, i64 0, i64 0
%672 = load float, float* %671
%673 = load float*, float** %18
%674 = getelementptr inbounds float, float* %673, i64 0
store float %672, float* %674
%675 = getelementptr inbounds [3 x float], [3 x float]* %36, i64 0, i64 1
%676 = load float, float* %675
%677 = load float*, float** %18
%678 = getelementptr inbounds float, float* %677, i64 1
store float %676, float* %678
%679 = getelementptr inbounds [3 x float], [3 x float]* %36, i64 0, i64 2
%680 = load float, float* %679
%681 = load float*, float** %18
%682 = getelementptr inbounds float, float* %681, i64 2
store float %680, float* %682
br label %683
683: ; preds = %670, %657
%684 = getelementptr inbounds [2 x float], [2 x float]* %34, i64 0, i64 1
%685 = load float, float* %684
%686 = getelementptr inbounds [2 x float], [2 x float]* %33, i64 0, i64 1
%687 = load float, float* %686
%688 = fcmp olt float %685, %687
br i1 %688, label %689, label %719
689: ; preds = %683
%690 = load i32, i32* %54
%691 = icmp eq i32 %690, 0
br i1 %691, label %692, label %705
692: ; preds = %689
%693 = getelementptr inbounds [3 x float], [3 x float]* %38, i64 0, i64 0
%694 = load float, float* %693
%695 = load float*, float** %19
%696 = getelementptr inbounds float, float* %695, i64 0
store float %694, float* %696
%697 = getelementptr inbounds [3 x float], [3 x float]* %38, i64 0, i64 1
%698 = load float, float* %697
%699 = load float*, float** %19
%700 = getelementptr inbounds float, float* %699, i64 1
store float %698, float* %700
%701 = getelementptr inbounds [3 x float], [3 x float]* %38, i64 0, i64 2
%702 = load float, float* %701
%703 = load float*, float** %19
%704 = getelementptr inbounds float, float* %703, i64 2
store float %702, float* %704
br label %718
705: ; preds = %689
%706 = getelementptr inbounds [3 x float], [3 x float]* %37, i64 0, i64 0
%707 = load float, float* %706
%708 = load float*, float** %19
%709 = getelementptr inbounds float, float* %708, i64 0
store float %707, float* %709
%710 = getelementptr inbounds [3 x float], [3 x float]* %37, i64 0, i64 1
%711 = load float, float* %710
%712 = load float*, float** %19
%713 = getelementptr inbounds float, float* %712, i64 1
store float %711, float* %713
%714 = getelementptr inbounds [3 x float], [3 x float]* %37, i64 0, i64 2
%715 = load float, float* %714
%716 = load float*, float** %19
%717 = getelementptr inbounds float, float* %716, i64 2
store float %715, float* %717
br label %718
718: ; preds = %705, %692
br label %749
719: ; preds = %683
%720 = load i32, i32* %53
%721 = icmp eq i32 %720, 0
br i1 %721, label %722, label %735
722: ; preds = %719
%723 = getelementptr inbounds [3 x float], [3 x float]* %36, i64 0, i64 0
%724 = load float, float* %723
%725 = load float*, float** %19
%726 = getelementptr inbounds float, float* %725, i64 0
store float %724, float* %726
%727 = getelementptr inbounds [3 x float], [3 x float]* %36, i64 0, i64 1
%728 = load float, float* %727
%729 = load float*, float** %19
%730 = getelementptr inbounds float, float* %729, i64 1
store float %728, float* %730
%731 = getelementptr inbounds [3 x float], [3 x float]* %36, i64 0, i64 2
%732 = load float, float* %731
%733 = load float*, float** %19
%734 = getelementptr inbounds float, float* %733, i64 2
store float %732, float* %734
br label %748
735: ; preds = %719
%736 = getelementptr inbounds [3 x float], [3 x float]* %35, i64 0, i64 0
%737 = load float, float* %736
%738 = load float*, float** %19
%739 = getelementptr inbounds float, float* %738, i64 0
store float %737, float* %739
%740 = getelementptr inbounds [3 x float], [3 x float]* %35, i64 0, i64 1
%741 = load float, float* %740
%742 = load float*, float** %19
%743 = getelementptr inbounds float, float* %742, i64 1
store float %741, float* %743
%744 = getelementptr inbounds [3 x float], [3 x float]* %35, i64 0, i64 2
%745 = load float, float* %744
%746 = load float*, float** %19
%747 = getelementptr inbounds float, float* %746, i64 2
store float %745, float* %747
br label %748
748: ; preds = %735, %722
br label %749
749: ; preds = %748, %718
br label %846
750: ; preds = %648
%751 = load i32, i32* %54
%752 = icmp eq i32 %751, 0
br i1 %752, label %753, label %766
753: ; preds = %750
%754 = getelementptr inbounds [3 x float], [3 x float]* %37, i64 0, i64 0
%755 = load float, float* %754
%756 = load float*, float** %18
%757 = getelementptr inbounds float, float* %756, i64 0
store float %755, float* %757
%758 = getelementptr inbounds [3 x float], [3 x float]* %37, i64 0, i64 1
%759 = load float, float* %758
%760 = load float*, float** %18
%761 = getelementptr inbounds float, float* %760, i64 1
store float %759, float* %761
%762 = getelementptr inbounds [3 x float], [3 x float]* %37, i64 0, i64 2
%763 = load float, float* %762
%764 = load float*, float** %18
%765 = getelementptr inbounds float, float* %764, i64 2
store float %763, float* %765
br label %779
766: ; preds = %750
%767 = getelementptr inbounds [3 x float], [3 x float]* %38, i64 0, i64 0
%768 = load float, float* %767
%769 = load float*, float** %18
%770 = getelementptr inbounds float, float* %769, i64 0
store float %768, float* %770
%771 = getelementptr inbounds [3 x float], [3 x float]* %38, i64 0, i64 1
%772 = load float, float* %771
%773 = load float*, float** %18
%774 = getelementptr inbounds float, float* %773, i64 1
store float %772, float* %774
%775 = getelementptr inbounds [3 x float], [3 x float]* %38, i64 0, i64 2
%776 = load float, float* %775
%777 = load float*, float** %18
%778 = getelementptr inbounds float, float* %777, i64 2
store float %776, float* %778
br label %779
779: ; preds = %766, %753
%780 = getelementptr inbounds [2 x float], [2 x float]* %34, i64 0, i64 1
%781 = load float, float* %780
%782 = getelementptr inbounds [2 x float], [2 x float]* %33, i64 0, i64 1
%783 = load float, float* %782
%784 = fcmp ogt float %781, %783
br i1 %784, label %785, label %815
785: ; preds = %779
%786 = load i32, i32* %53
%787 = icmp eq i32 %786, 0
br i1 %787, label %788, label %801
788: ; preds = %785
%789 = getelementptr inbounds [3 x float], [3 x float]* %36, i64 0, i64 0
%790 = load float, float* %789
%791 = load float*, float** %19
%792 = getelementptr inbounds float, float* %791, i64 0
store float %790, float* %792
%793 = getelementptr inbounds [3 x float], [3 x float]* %36, i64 0, i64 1
%794 = load float, float* %793
%795 = load float*, float** %19
%796 = getelementptr inbounds float, float* %795, i64 1
store float %794, float* %796
%797 = getelementptr inbounds [3 x float], [3 x float]* %36, i64 0, i64 2
%798 = load float, float* %797
%799 = load float*, float** %19
%800 = getelementptr inbounds float, float* %799, i64 2
store float %798, float* %800
br label %814
801: ; preds = %785
%802 = getelementptr inbounds [3 x float], [3 x float]* %35, i64 0, i64 0
%803 = load float, float* %802
%804 = load float*, float** %19
%805 = getelementptr inbounds float, float* %804, i64 0
store float %803, float* %805
%806 = getelementptr inbounds [3 x float], [3 x float]* %35, i64 0, i64 1
%807 = load float, float* %806
%808 = load float*, float** %19
%809 = getelementptr inbounds float, float* %808, i64 1
store float %807, float* %809
%810 = getelementptr inbounds [3 x float], [3 x float]* %35, i64 0, i64 2
%811 = load float, float* %810
%812 = load float*, float** %19
%813 = getelementptr inbounds float, float* %812, i64 2
store float %811, float* %813
br label %814
814: ; preds = %801, %788
br label %845
815: ; preds = %779
%816 = load i32, i32* %54
%817 = icmp eq i32 %816, 0
br i1 %817, label %818, label %831
818: ; preds = %815
%819 = getelementptr inbounds [3 x float], [3 x float]* %38, i64 0, i64 0
%820 = load float, float* %819
%821 = load float*, float** %19
%822 = getelementptr inbounds float, float* %821, i64 0
store float %820, float* %822
%823 = getelementptr inbounds [3 x float], [3 x float]* %38, i64 0, i64 1
%824 = load float, float* %823
%825 = load float*, float** %19
%826 = getelementptr inbounds float, float* %825, i64 1
store float %824, float* %826
%827 = getelementptr inbounds [3 x float], [3 x float]* %38, i64 0, i64 2
%828 = load float, float* %827
%829 = load float*, float** %19
%830 = getelementptr inbounds float, float* %829, i64 2
store float %828, float* %830
br label %844
831: ; preds = %815
%832 = getelementptr inbounds [3 x float], [3 x float]* %37, i64 0, i64 0
%833 = load float, float* %832
%834 = load float*, float** %19
%835 = getelementptr inbounds float, float* %834, i64 0
store float %833, float* %835
%836 = getelementptr inbounds [3 x float], [3 x float]* %37, i64 0, i64 1
%837 = load float, float* %836
%838 = load float*, float** %19
%839 = getelementptr inbounds float, float* %838, i64 1
store float %837, float* %839
%840 = getelementptr inbounds [3 x float], [3 x float]* %37, i64 0, i64 2
%841 = load float, float* %840
%842 = load float*, float** %19
%843 = getelementptr inbounds float, float* %842, i64 2
store float %841, float* %843
br label %844
844: ; preds = %831, %818
br label %845
845: ; preds = %844, %814
br label %846
846: ; preds = %845, %749
store i32 1, i32* %10
br label %847
847: ; preds = %846, %647, %572, %449, %255
%848 = load i32, i32* %10
ret i32 %848
}

LLVM IR (-O2):
define i32 @tri_tri_intersect_with_isectline(float* %0, float* %1, float* %2, float* %3, float* %4, float* %5, i32* nocapture writeonly %6, float* nocapture writeonly %7, float* writeonly %8) {
%10 = alloca [3 x float]
%11 = alloca i64
%12 = bitcast i64* %11 to [2 x float]*
%13 = alloca i64
%14 = bitcast i64* %13 to [2 x float]*
%15 = alloca [3 x float]
%16 = alloca [3 x float]
%17 = alloca [3 x float]
%18 = alloca [3 x float]
%19 = bitcast [3 x float]* %10 to i8*
%20 = bitcast i64* %11 to i8*
store i64 0, i64* %11
%21 = bitcast i64* %13 to i8*
store i64 0, i64* %13
%22 = bitcast [3 x float]* %15 to i8*
%23 = bitcast [3 x float]* %16 to i8*
%24 = bitcast [3 x float]* %17 to i8*
%25 = bitcast [3 x float]* %18 to i8*
%26 = load float, float* %1
%27 = getelementptr inbounds float, float* %1, i64 1
%28 = load float, float* %27
%29 = bitcast float* %0 to <2 x float>*
%30 = load <2 x float>, <2 x float>* %29
%31 = extractelement <2 x float> %30, i64 1
%32 = fsub float %28, %31
%33 = getelementptr inbounds float, float* %1, i64 2
%34 = load float, float* %33
%35 = getelementptr inbounds float, float* %0, i64 2
%36 = load float, float* %35
%37 = insertelement <2 x float> poison, float %26, i64 0
%38 = insertelement <2 x float> %37, float %34, i64 1
%39 = insertelement <2 x float> %30, float %36, i64 1
%40 = fsub <2 x float> %38, %39
%41 = shufflevector <2 x float> %40, <2 x float> poison, <2 x i32> <i32 1, i32 0>
%42 = bitcast float* %2 to <2 x float>*
%43 = load <2 x float>, <2 x float>* %42
%44 = fsub <2 x float> %43, %30
%45 = getelementptr inbounds float, float* %2, i64 2
%46 = load float, float* %45
%47 = fsub float %46, %36
%48 = extractelement <2 x float> %40, i64 1
%49 = fneg float %48
%50 = extractelement <2 x float> %44, i64 1
%51 = fmul float %50, %49
%52 = tail call float @llvm.fmuladd.f32(float %32, float %47, float %51)
%53 = getelementptr inbounds [3 x float], [3 x float]* %10, i64 0, i64 0
store float %52, float* %53
%54 = getelementptr inbounds [3 x float], [3 x float]* %10, i64 0, i64 1
%55 = insertelement <2 x float> %40, float %32, i64 1
%56 = fneg <2 x float> %55
%57 = insertelement <2 x float> poison, float %47, i64 0
%58 = shufflevector <2 x float> %57, <2 x float> %44, <2 x i32> <i32 0, i32 2>
%59 = fmul <2 x float> %58, %56
%60 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %41, <2 x float> %44, <2 x float> %59)
%61 = extractelement <2 x float> %60, i64 0
store float %61, float* %54
%62 = getelementptr inbounds [3 x float], [3 x float]* %10, i64 0, i64 2
%63 = extractelement <2 x float> %60, i64 1
store float %63, float* %62
%64 = bitcast float* %3 to <2 x float>*
%65 = load <2 x float>, <2 x float>* %64
%66 = getelementptr inbounds float, float* %3, i64 2
%67 = load float, float* %66
%68 = bitcast float* %4 to <2 x float>*
%69 = load <2 x float>, <2 x float>* %68
%70 = shufflevector <2 x float> %60, <2 x float> %30, <2 x i32> <i32 0, i32 3>
%71 = shufflevector <2 x float> %69, <2 x float> %60, <2 x i32> <i32 1, i32 2>
%72 = fmul <2 x float> %70, %71
%73 = insertelement <2 x float> poison, float %52, i64 0
%74 = shufflevector <2 x float> %73, <2 x float> poison, <2 x i32> zeroinitializer
%75 = shufflevector <2 x float> %69, <2 x float> %30, <2 x i32> <i32 0, i32 2>
%76 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %74, <2 x float> %75, <2 x float> %72)
%77 = getelementptr inbounds float, float* %4, i64 2
%78 = load float, float* %77
%79 = shufflevector <2 x float> %60, <2 x float> undef, <2 x i32> <i32 1, i32 undef>
%80 = shufflevector <2 x float> %60, <2 x float> poison, <2 x i32> <i32 1, i32 1>
%81 = insertelement <2 x float> poison, float %78, i64 0
%82 = insertelement <2 x float> %81, float %36, i64 1
%83 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %80, <2 x float> %82, <2 x float> %76)
%84 = extractelement <2 x float> %83, i64 0
%85 = extractelement <2 x float> %83, i64 1
%86 = fsub float %84, %85
%87 = load float, float* %5
%88 = getelementptr inbounds float, float* %5, i64 1
%89 = bitcast float* %88 to <2 x float>*
%90 = load <2 x float>, <2 x float>* %89
%91 = shufflevector <2 x float> %60, <2 x float> poison, <2 x i32> zeroinitializer
%92 = shufflevector <2 x float> %65, <2 x float> undef, <2 x i32> <i32 1, i32 undef>
%93 = shufflevector <2 x float> %92, <2 x float> %90, <2 x i32> <i32 0, i32 2>
%94 = fmul <2 x float> %91, %93
%95 = insertelement <2 x float> %65, float %87, i64 1
%96 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %74, <2 x float> %95, <2 x float> %94)
%97 = insertelement <2 x float> %90, float %67, i64 0
%98 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %80, <2 x float> %97, <2 x float> %96)
%99 = shufflevector <2 x float> %83, <2 x float> undef, <2 x i32> <i32 1, i32 1>
%100 = fsub <2 x float> %98, %99
%101 = tail call float @llvm.fabs.f32(float %86)
%102 = fpext float %101 to double
%103 = fcmp olt double %102, 0x3EB0C6F7A0B5ED8D
%104 = select i1 %103, float 0.000000e+00, float %86
%105 = call <2 x float> @llvm.fabs.v2f32(<2 x float> %100)
%106 = fpext <2 x float> %105 to <2 x double>
%107 = fcmp olt <2 x double> %106, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
%108 = select <2 x i1> %107, <2 x float> zeroinitializer, <2 x float> %100
%109 = extractelement <2 x float> %108, i64 0
%110 = fmul float %109, %104
%111 = extractelement <2 x float> %108, i64 1
%112 = fmul float %109, %111
%113 = fcmp ogt float %110, 0.000000e+00
%114 = fcmp ogt float %112, 0.000000e+00
%115 = select i1 %113, i1 %114, i1 false
br i1 %115, label %358, label %116
116: ; preds = %9
%117 = extractelement <2 x float> %65, i64 0
%118 = fsub <2 x float> %69, %65
%119 = fsub float %78, %67
%120 = fsub float %87, %117
%121 = insertelement <2 x float> %92, float %67, i64 1
%122 = fsub <2 x float> %90, %121
%123 = extractelement <2 x float> %118, i64 0
%124 = fneg float %123
%125 = extractelement <2 x float> %122, i64 1
%126 = fmul float %125, %124
%127 = tail call float @llvm.fmuladd.f32(float %119, float %120, float %126)
%128 = extractelement <2 x float> %118, i64 1
%129 = insertelement <2 x float> poison, float %128, i64 0
%130 = insertelement <2 x float> %129, float %119, i64 1
%131 = fneg <2 x float> %130
%132 = insertelement <2 x float> poison, float %120, i64 0
%133 = shufflevector <2 x float> %132, <2 x float> %122, <2 x i32> <i32 0, i32 2>
%134 = fmul <2 x float> %133, %131
%135 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %118, <2 x float> %122, <2 x float> %134)
%136 = insertelement <2 x float> %65, float %28, i64 0
%137 = insertelement <2 x float> poison, float %127, i64 0
%138 = shufflevector <2 x float> %137, <2 x float> poison, <2 x i32> zeroinitializer
%139 = fmul <2 x float> %136, %138
%140 = shufflevector <2 x float> %135, <2 x float> undef, <2 x i32> <i32 1, i32 1>
%141 = shufflevector <2 x float> %37, <2 x float> %65, <2 x i32> <i32 0, i32 2>
%142 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %140, <2 x float> %141, <2 x float> %139)
%143 = shufflevector <2 x float> %135, <2 x float> undef, <2 x i32> zeroinitializer
%144 = insertelement <2 x float> poison, float %34, i64 0
%145 = insertelement <2 x float> %144, float %67, i64 1
%146 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %143, <2 x float> %145, <2 x float> %142)
%147 = extractelement <2 x float> %146, i64 0
%148 = extractelement <2 x float> %146, i64 1
%149 = fsub float %147, %148
%150 = shufflevector <2 x float> %30, <2 x float> %43, <2 x i32> <i32 1, i32 3>
%151 = fmul <2 x float> %150, %138
%152 = shufflevector <2 x float> %30, <2 x float> %43, <2 x i32> <i32 0, i32 2>
%153 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %140, <2 x float> %152, <2 x float> %151)
%154 = insertelement <2 x float> poison, float %36, i64 0
%155 = insertelement <2 x float> %154, float %46, i64 1
%156 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %143, <2 x float> %155, <2 x float> %153)
%157 = shufflevector <2 x float> %146, <2 x float> undef, <2 x i32> <i32 1, i32 1>
%158 = fsub <2 x float> %156, %157
%159 = tail call float @llvm.fabs.f32(float %149)
%160 = fpext float %159 to double
%161 = fcmp olt double %160, 0x3EB0C6F7A0B5ED8D
%162 = select i1 %161, float 0.000000e+00, float %149
%163 = call <2 x float> @llvm.fabs.v2f32(<2 x float> %158)
%164 = fpext <2 x float> %163 to <2 x double>
%165 = fcmp olt <2 x double> %164, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
%166 = select <2 x i1> %165, <2 x float> zeroinitializer, <2 x float> %158
%167 = extractelement <2 x float> %166, i64 0
%168 = fmul float %167, %162
%169 = extractelement <2 x float> %166, i64 1
%170 = fmul float %167, %169
%171 = fcmp ogt float %168, 0.000000e+00
%172 = fcmp ogt float %170, 0.000000e+00
%173 = select i1 %171, i1 %172, i1 false
br i1 %173, label %358, label %174
174: ; preds = %116
%175 = extractelement <2 x float> %135, i64 1
%176 = insertelement <2 x float> %79, float %52, i64 1
%177 = fneg <2 x float> %176
%178 = shufflevector <2 x float> %137, <2 x float> %135, <2 x i32> <i32 0, i32 2>
%179 = fmul <2 x float> %178, %177
%180 = call <2 x float> @llvm.fmuladd.v2f32(<2 x float> %60, <2 x float> %135, <2 x float> %179)
%181 = fneg float %61
%182 = fmul float %175, %181
%183 = tail call float @llvm.fmuladd.f32(float %52, float %127, float %182)
%184 = call <2 x float> @llvm.fabs.v2f32(<2 x float> %180)
%185 = tail call float @llvm.fabs.f32(float %183)
%186 = extractelement <2 x float> %184, i64 0
%187 = extractelement <2 x float> %184, i64 1
%188 = fcmp ogt float %187, %186
%189 = zext i1 %188 to i64
%190 = select i1 %188, float %187, float %186
%191 = fcmp ogt float %185, %190
%192 = select i1 %191, i64 2, i64 %189
%193 = getelementptr inbounds float, float* %0, i64 %192
%194 = load float, float* %193
%195 = getelementptr inbounds float, float* %1, i64 %192
%196 = load float, float* %195
%197 = getelementptr inbounds float, float* %2, i64 %192
%198 = load float, float* %197
%199 = getelementptr inbounds float, float* %3, i64 %192
%200 = load float, float* %199
%201 = getelementptr inbounds float, float* %4, i64 %192
%202 = load float, float* %201
%203 = getelementptr inbounds float, float* %5, i64 %192
%204 = load float, float* %203
%205 = fpext float %194 to double
%206 = fpext float %196 to double
%207 = fpext float %198 to double
%208 = fpext float %167 to double
%209 = fpext float %162 to double
%210 = fpext float %169 to double
%211 = fpext float %168 to double
%212 = fpext float %170 to double
%213 = bitcast i64* %11 to float*
%214 = getelementptr inbounds [2 x float], [2 x float]* %12, i64 0, i64 1
%215 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 0
%216 = getelementptr inbounds [3 x float], [3 x float]* %16, i64 0, i64 0
%217 = call i32 (float*, float*, float*, double, double, double, double, double, double, double, double, float*, float*, float*, float*, ...) bitcast (i32 (...)* @compute_intervals_isectline to i32 (float*, float*, float*, double, double, double, double, double, double, double, double, float*, float*, float*, float*, ...)*)(float* %0, float* %1, float* %2, double %205, double %206, double %207, double %208, double %209, double %210, double %211, double %212, float* %213, float* %214, float* %215, float* %216)
store i32 %217, i32* %6
%218 = icmp eq i32 %217, 0
br i1 %218, label %221, label %219
219: ; preds = %174
%220 = call i32 (float*, float*, float*, float*, float*, float*, float*, ...) bitcast (i32 (...)* @coplanar_tri_tri to i32 (float*, float*, float*, float*, float*, float*, float*, ...)*)(float* %53, float* %0, float* %1, float* %2, float* %3, float* %4, float* %5)
br label %358
221: ; preds = %174
%222 = fpext float %200 to double
%223 = fpext float %202 to double
%224 = fpext float %204 to double
%225 = fpext float %109 to double
%226 = fpext float %104 to double
%227 = fpext float %111 to double
%228 = fpext float %110 to double
%229 = fpext float %112 to double
%230 = bitcast i64* %13 to float*
%231 = getelementptr inbounds [2 x float], [2 x float]* %14, i64 0, i64 1
%232 = getelementptr inbounds [3 x float], [3 x float]* %17, i64 0, i64 0
%233 = getelementptr inbounds [3 x float], [3 x float]* %18, i64 0, i64 0
%234 = call i32 (float*, float*, float*, double, double, double, double, double, double, double, double, float*, float*, float*, float*, ...) bitcast (i32 (...)* @compute_intervals_isectline to i32 (float*, float*, float*, double, double, double, double, double, double, double, double, float*, float*, float*, float*, ...)*)(float* %3, float* %4, float* %5, double %222, double %223, double %224, double %225, double %226, double %227, double %228, double %229, float* %230, float* %231, float* %232, float* %233)
%235 = load float, float* %213
%236 = load float, float* %214
%237 = fcmp ogt float %235, %236
br i1 %237, label %238, label %239
238: ; preds = %221
store float %236, float* %213
store float %235, float* %214
br label %239
239: ; preds = %221, %238
%240 = phi float [ %235, %221 ], [ %236, %238 ]
%241 = phi float [ %236, %221 ], [ %235, %238 ]
%242 = load float, float* %230
%243 = load float, float* %231
%244 = fcmp ogt float %242, %243
br i1 %244, label %245, label %246
245: ; preds = %239
store float %243, float* %230
store float %242, float* %231
br label %246
246: ; preds = %239, %245
%247 = phi float [ %243, %239 ], [ %242, %245 ]
%248 = phi float [ %242, %239 ], [ %243, %245 ]
%249 = fcmp olt float %241, %248
%250 = fcmp olt float %247, %240
%251 = select i1 %249, i1 true, i1 %250
br i1 %251, label %358, label %252
252: ; preds = %246
%253 = fcmp olt float %248, %240
br i1 %253, label %254, label %306
254: ; preds = %252
br i1 %237, label %255, label %264
255: ; preds = %254
%256 = load float, float* %216
store float %256, float* %7
%257 = getelementptr inbounds [3 x float], [3 x float]* %16, i64 0, i64 1
%258 = load float, float* %257
%259 = getelementptr inbounds float, float* %7, i64 1
store float %258, float* %259
%260 = getelementptr inbounds [3 x float], [3 x float]* %16, i64 0, i64 2
%261 = load float, float* %260
%262 = getelementptr inbounds float, float* %7, i64 2
store float %261, float* %262
%263 = fcmp olt float %247, %241
br i1 %263, label %273, label %298
264: ; preds = %254
%265 = load float, float* %215
store float %265, float* %7
%266 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 1
%267 = load float, float* %266
%268 = getelementptr inbounds float, float* %7, i64 1
store float %267, float* %268
%269 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 2
%270 = load float, float* %269
%271 = getelementptr inbounds float, float* %7, i64 2
store float %270, float* %271
%272 = fcmp olt float %247, %241
br i1 %272, label %273, label %290
273: ; preds = %264, %255
br i1 %244, label %282, label %274
274: ; preds = %273
%275 = load float, float* %233
store float %275, float* %8
%276 = getelementptr inbounds [3 x float], [3 x float]* %18, i64 0, i64 1
%277 = load float, float* %276
%278 = getelementptr inbounds float, float* %8, i64 1
store float %277, float* %278
%279 = getelementptr inbounds [3 x float], [3 x float]* %18, i64 0, i64 2
%280 = load float, float* %279
%281 = getelementptr inbounds float, float* %8, i64 2
store float %280, float* %281
br label %358
282: ; preds = %273
%283 = load float, float* %232
store float %283, float* %8
%284 = getelementptr inbounds [3 x float], [3 x float]* %17, i64 0, i64 1
%285 = load float, float* %284
%286 = getelementptr inbounds float, float* %8, i64 1
store float %285, float* %286
%287 = getelementptr inbounds [3 x float], [3 x float]* %17, i64 0, i64 2
%288 = load float, float* %287
%289 = getelementptr inbounds float, float* %8, i64 2
store float %288, float* %289
br label %358
290: ; preds = %264
%291 = load float, float* %216
store float %291, float* %8
%292 = getelementptr inbounds [3 x float], [3 x float]* %16, i64 0, i64 1
%293 = load float, float* %292
%294 = getelementptr inbounds float, float* %8, i64 1
store float %293, float* %294
%295 = getelementptr inbounds [3 x float], [3 x float]* %16, i64 0, i64 2
%296 = load float, float* %295
%297 = getelementptr inbounds float, float* %8, i64 2
store float %296, float* %297
br label %358
298: ; preds = %255
%299 = load float, float* %215
store float %299, float* %8
%300 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 1
%301 = load float, float* %300
%302 = getelementptr inbounds float, float* %8, i64 1
store float %301, float* %302
%303 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 2
%304 = load float, float* %303
%305 = getelementptr inbounds float, float* %8, i64 2
store float %304, float* %305
br label %358
306: ; preds = %252
br i1 %244, label %307, label %316
307: ; preds = %306
%308 = load float, float* %233
store float %308, float* %7
%309 = getelementptr inbounds [3 x float], [3 x float]* %18, i64 0, i64 1
%310 = load float, float* %309
%311 = getelementptr inbounds float, float* %7, i64 1
store float %310, float* %311
%312 = getelementptr inbounds [3 x float], [3 x float]* %18, i64 0, i64 2
%313 = load float, float* %312
%314 = getelementptr inbounds float, float* %7, i64 2
store float %313, float* %314
%315 = fcmp ogt float %247, %241
br i1 %315, label %325, label %350
316: ; preds = %306
%317 = load float, float* %232
store float %317, float* %7
%318 = getelementptr inbounds [3 x float], [3 x float]* %17, i64 0, i64 1
%319 = load float, float* %318
%320 = getelementptr inbounds float, float* %7, i64 1
store float %319, float* %320
%321 = getelementptr inbounds [3 x float], [3 x float]* %17, i64 0, i64 2
%322 = load float, float* %321
%323 = getelementptr inbounds float, float* %7, i64 2
store float %322, float* %323
%324 = fcmp ogt float %247, %241
br i1 %324, label %325, label %342
325: ; preds = %316, %307
br i1 %237, label %334, label %326
326: ; preds = %325
%327 = load float, float* %216
store float %327, float* %8
%328 = getelementptr inbounds [3 x float], [3 x float]* %16, i64 0, i64 1
%329 = load float, float* %328
%330 = getelementptr inbounds float, float* %8, i64 1
store float %329, float* %330
%331 = getelementptr inbounds [3 x float], [3 x float]* %16, i64 0, i64 2
%332 = load float, float* %331
%333 = getelementptr inbounds float, float* %8, i64 2
store float %332, float* %333
br label %358
334: ; preds = %325
%335 = load float, float* %215
store float %335, float* %8
%336 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 1
%337 = load float, float* %336
%338 = getelementptr inbounds float, float* %8, i64 1
store float %337, float* %338
%339 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 2
%340 = load float, float* %339
%341 = getelementptr inbounds float, float* %8, i64 2
store float %340, float* %341
br label %358
342: ; preds = %316
%343 = load float, float* %233
store float %343, float* %8
%344 = getelementptr inbounds [3 x float], [3 x float]* %18, i64 0, i64 1
%345 = load float, float* %344
%346 = getelementptr inbounds float, float* %8, i64 1
store float %345, float* %346
%347 = getelementptr inbounds [3 x float], [3 x float]* %18, i64 0, i64 2
%348 = load float, float* %347
%349 = getelementptr inbounds float, float* %8, i64 2
store float %348, float* %349
br label %358
350: ; preds = %307
%351 = load float, float* %232
store float %351, float* %8
%352 = getelementptr inbounds [3 x float], [3 x float]* %17, i64 0, i64 1
%353 = load float, float* %352
%354 = getelementptr inbounds float, float* %8, i64 1
store float %353, float* %354
%355 = getelementptr inbounds [3 x float], [3 x float]* %17, i64 0, i64 2
%356 = load float, float* %355
%357 = getelementptr inbounds float, float* %8, i64 2
store float %356, float* %357
br label %358
358: ; preds = %290, %298, %274, %282, %342, %350, %326, %334, %246, %116, %9, %219
%359 = phi i32 [ %220, %219 ], [ 0, %9 ], [ 0, %116 ], [ 0, %246 ], [ 1, %334 ], [ 1, %326 ], [ 1, %350 ], [ 1, %342 ], [ 1, %282 ], [ 1, %274 ], [ 1, %298 ], [ 1, %290 ]
ret i32 %359
}