int tri_tri_intersect_with_isectline(const float V0[3], const float V1[3],
                                     const float V2[3], const float U0[3],
                                     const float U1[3], const 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], isect2[2];
  float isectpointA1[3], isectpointA2[3];
  float isectpointB1[3], isectpointB2[3];
  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.005)
    du0 = 0.0;
  if (fabs(du1) < 0.005)
    du1 = 0.0;
  if (fabs(du2) < 0.005)
    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.005)
    dv0 = 0.0;
  if (fabs(dv1) < 0.005)
    dv1 = 0.0;
  if (fabs(dv2) < 0.005)
    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)
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 0xc8d(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0xc71(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    13a1 <tri_tri_intersect_with_isectline+0x281>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x78(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movaps 0xc5f(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0xc43(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    13cf <tri_tri_intersect_with_isectline+0x2af>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x7c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movaps 0xc31(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0xc15(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    13fd <tri_tri_intersect_with_isectline+0x2dd>
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    1455 <tri_tri_intersect_with_isectline+0x335>
movss  -0xdc(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    1455 <tri_tri_intersect_with_isectline+0x335>
movl   $0x0,-0x4(%rbp)
jmp    1efa <tri_tri_intersect_with_isectline+0xdda>
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)
ff
movss  -0x80(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movaps 0x981(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0x965(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    16ad <tri_tri_intersect_with_isectline+0x58d>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x84(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
movaps 0x950(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0x934(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    16e1 <tri_tri_intersect_with_isectline+0x5c1>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x88(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
movaps 0x91c(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0x900(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1715 <tri_tri_intersect_with_isectline+0x5f5>
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    1773 <tri_tri_intersect_with_isectline+0x653>
movss  -0xe4(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    1773 <tri_tri_intersect_with_isectline+0x653>
movl   $0x0,-0x4(%rbp)
jmp    1efa <tri_tri_intersect_with_isectline+0xdda>
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 0x7f7(%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 0x7cb(%rip),%xmm1
pand   %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x104(%rbp)
ff
movss  -0x8c(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movaps 0x7a8(%rip),%xmm1
pand   %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x108(%rbp)
ff
movss  -0x104(%rbp),%xmm0
ff
ucomiss -0x10c(%rbp),%xmm0
jbe    18a6 <tri_tri_intersect_with_isectline+0x786>
movss  -0x104(%rbp),%xmm0
ff
movss  %xmm0,-0x10c(%rbp)
ff
movw   $0x1,-0xe6(%rbp)
movss  -0x108(%rbp),%xmm0
ff
ucomiss -0x10c(%rbp),%xmm0
jbe    18d4 <tri_tri_intersect_with_isectline+0x7b4>
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   1040 <compute_intervals_isectline@plt>
mov    %eax,%ecx
mov    0x10(%rbp),%rax
mov    %ecx,(%rax)
mov    0x10(%rbp),%rax
cmpl   $0x0,(%rax)
je     1a42 <tri_tri_intersect_with_isectline+0x922>
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    1efa <tri_tri_intersect_with_isectline+0xdda>
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   1040 <compute_intervals_isectline@plt>
movss  -0x9c(%rbp),%xmm0
ff
ucomiss -0x98(%rbp),%xmm0
jbe    1b24 <tri_tri_intersect_with_isectline+0xa04>
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    1b2e <tri_tri_intersect_with_isectline+0xa0e>
movl   $0x0,-0x110(%rbp)
movss  -0xa4(%rbp),%xmm0
ff
ucomiss -0xa0(%rbp),%xmm0
jbe    1b82 <tri_tri_intersect_with_isectline+0xa62>
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    1b8c <tri_tri_intersect_with_isectline+0xa6c>
movl   $0x0,-0x114(%rbp)
movss  -0x98(%rbp),%xmm1
ff
movss  -0xa4(%rbp),%xmm0
ff
ucomiss %xmm1,%xmm0
ja     1bbe <tri_tri_intersect_with_isectline+0xa9e>
movss  -0xa0(%rbp),%xmm1
ff
movss  -0x9c(%rbp),%xmm0
ff
ucomiss %xmm1,%xmm0
jbe    1bca <tri_tri_intersect_with_isectline+0xaaa>
movl   $0x0,-0x4(%rbp)
jmp    1efa <tri_tri_intersect_with_isectline+0xdda>
movss  -0xa4(%rbp),%xmm1
ff
movss  -0x9c(%rbp),%xmm0
ff
ucomiss %xmm1,%xmm0
jbe    1d6d <tri_tri_intersect_with_isectline+0xc4d>
cmpl   $0x0,-0x110(%rbp)
jne    1c27 <tri_tri_intersect_with_isectline+0xb07>
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    1c59 <tri_tri_intersect_with_isectline+0xb39>
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    1ced <tri_tri_intersect_with_isectline+0xbcd>
cmpl   $0x0,-0x114(%rbp)
jne    1cb6 <tri_tri_intersect_with_isectline+0xb96>
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    1ce8 <tri_tri_intersect_with_isectline+0xbc8>
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    1d68 <tri_tri_intersect_with_isectline+0xc48>
cmpl   $0x0,-0x110(%rbp)
jne    1d31 <tri_tri_intersect_with_isectline+0xc11>
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    1d63 <tri_tri_intersect_with_isectline+0xc43>
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    1d68 <tri_tri_intersect_with_isectline+0xc48>
jmp    1ef3 <tri_tri_intersect_with_isectline+0xdd3>
cmpl   $0x0,-0x114(%rbp)
jne    1db1 <tri_tri_intersect_with_isectline+0xc91>
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    1de3 <tri_tri_intersect_with_isectline+0xcc3>
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    1e73 <tri_tri_intersect_with_isectline+0xd53>
cmpl   $0x0,-0x110(%rbp)
jne    1e3c <tri_tri_intersect_with_isectline+0xd1c>
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    1e6e <tri_tri_intersect_with_isectline+0xd4e>
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    1eee <tri_tri_intersect_with_isectline+0xdce>
cmpl   $0x0,-0x114(%rbp)
jne    1eb7 <tri_tri_intersect_with_isectline+0xd97>
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    1ee9 <tri_tri_intersect_with_isectline+0xdc9>
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    1eee <tri_tri_intersect_with_isectline+0xdce>
jmp    1ef3 <tri_tri_intersect_with_isectline+0xdd3>
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    $0x108,%rsp
mov    %r9,%r12
mov    %r8,%r14
mov    %rcx,%r15
mov    %rdx,%r13
mov    %rsi,%rbx
mov    %rdi,%rbp
movss  0x4(%rsi),%xmm3
movsd  (%rdi),%xmm10
movaps %xmm10,%xmm0
shufps $0x55,%xmm10,%xmm0
movaps %xmm3,0x80(%rsp)
subss  %xmm0,%xmm3
movss  0x8(%rsi),%xmm2
movss  0x8(%rdi),%xmm1
movss  (%rsi),%xmm0
movaps %xmm0,0x60(%rsp)
movaps %xmm2,0x90(%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,0xf0(%rsp)
subps  %xmm10,%xmm11
movss  0x8(%rdx),%xmm6
movaps %xmm6,0x70(%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,0x54(%rsp)
unpcklps %xmm11,%xmm6
mulps  %xmm3,%xmm6
mulps  %xmm0,%xmm11
subps  %xmm6,%xmm11
movaps %xmm11,%xmm13
shufps $0x55,%xmm11,%xmm13
movss  %xmm11,0x58(%rsp)
movss  %xmm13,0x5c(%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,0xe0(%rsp)
movss  %xmm4,%xmm0
movaps %xmm13,0xd0(%rsp)
mulps  %xmm13,%xmm0
addps  %xmm2,%xmm0
movaps %xmm3,%xmm2
shufps $0x55,%xmm3,%xmm2
subss  %xmm2,%xmm3
subps  %xmm2,%xmm0
movaps 0xd33(%rip),%xmm4
movaps %xmm3,%xmm2
andps  %xmm4,%xmm2
cvtss2sd %xmm2,%xmm2
movsd  0xd41(%rip),%xmm6
ucomisd %xmm2,%xmm6
xorpd  %xmm6,%xmm6
ja     12ec <tri_tri_intersect_with_isectline+0x1cc>
movaps %xmm3,%xmm6
movaps %xmm0,%xmm2
andps  %xmm4,%xmm2
cvtps2pd %xmm2,%xmm2
cmpltpd 0xd12(%rip),%xmm2
shufps $0xe8,%xmm2,%xmm2
andnps %xmm0,%xmm2
movaps %xmm2,%xmm3
mulss  %xmm6,%xmm3
pshufd $0x55,%xmm2,%xmm0
movaps %xmm2,%xmm13
movdqa %xmm0,0xc0(%rsp)
mulss  %xmm0,%xmm13
xor    %eax,%eax
ucomiss 0xcfc(%rip),%xmm3
jbe    133b <tri_tri_intersect_with_isectline+0x21b>
xorps  %xmm0,%xmm0
ucomiss %xmm0,%xmm13
ja     17f5 <tri_tri_intersect_with_isectline+0x6d5>
movaps %xmm3,0xa0(%rsp)
movaps %xmm2,0xb0(%rsp)
movss  %xmm6,0x50(%rsp)
subps  %xmm12,%xmm5
movaps 0xe0(%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 0x60(%rsp),%xmm6
unpcklps %xmm12,%xmm6
movaps 0x80(%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 0x90(%rsp),%xmm4
unpcklps %xmm3,%xmm4
movaps %xmm7,%xmm3
shufps $0x0,%xmm7,%xmm3
mulps  %xmm3,%xmm4
addps  %xmm6,%xmm4
movaps 0xf0(%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 0x70(%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  0xbc7(%rip),%xmm2
cvtss2sd %xmm2,%xmm2
movsd  0xbdb(%rip),%xmm0
ucomisd %xmm2,%xmm0
xorps  %xmm10,%xmm10
xorps  %xmm12,%xmm12
ja     1457 <tri_tri_intersect_with_isectline+0x337>
movaps %xmm4,%xmm12
movaps %xmm1,%xmm2
andps  0xb9f(%rip),%xmm2
cvtps2pd %xmm2,%xmm3
cmpltpd 0xba3(%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    149e <tri_tri_intersect_with_isectline+0x37e>
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm8
ja     17f5 <tri_tri_intersect_with_isectline+0x6d5>
movaps %xmm13,0x90(%rsp)
movaps %xmm15,%xmm1
movaps 0xd0(%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 0xb1c(%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,0x80(%rsp)
movss  (%r14,%rcx,4),%xmm4
movss  %xmm4,0x70(%rsp)
movss  (%r12,%rcx,4),%xmm4
movss  %xmm4,0x60(%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    0x4c(%rsp),%r8
lea    0x28(%rsp),%rax
mov    %rax,(%rsp)
lea    0x48(%rsp),%rcx
lea    0x34(%rsp),%r9
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    %r13,%rdx
mov    $0x8,%al
call   1040 <compute_intervals_isectline@plt>
mov    0x140(%rsp),%rcx
mov    %eax,(%rcx)
test   %eax,%eax
je     15c5 <tri_tri_intersect_with_isectline+0x4a5>
mov    %r12,(%rsp)
lea    0x54(%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    17f5 <tri_tri_intersect_with_isectline+0x6d5>
movss  0x80(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  0x70(%rsp),%xmm1
cvtss2sd %xmm1,%xmm1
movss  0x60(%rsp),%xmm2
cvtss2sd %xmm2,%xmm2
movaps 0xb0(%rsp),%xmm3
cvtss2sd %xmm3,%xmm3
movss  0x50(%rsp),%xmm4
cvtss2sd %xmm4,%xmm4
movaps 0xc0(%rsp),%xmm5
cvtss2sd %xmm5,%xmm5
movaps 0xa0(%rsp),%xmm6
cvtss2sd %xmm6,%xmm6
movaps 0x90(%rsp),%xmm7
cvtss2sd %xmm7,%xmm7
lea    0x44(%rsp),%r8
lea    0x10(%rsp),%rax
mov    %rax,(%rsp)
lea    0x40(%rsp),%rcx
lea    0x1c(%rsp),%r9
mov    %r15,%rdi
mov    %r14,%rsi
mov    %r12,%rdx
mov    $0x8,%al
call   1040 <compute_intervals_isectline@plt>
movss  0x48(%rsp),%xmm1
movss  0x4c(%rsp),%xmm2
ucomiss %xmm2,%xmm1
movaps %xmm1,%xmm6
movaps %xmm2,%xmm0
jbe    1671 <tri_tri_intersect_with_isectline+0x551>
movss  %xmm2,0x48(%rsp)
movss  %xmm1,0x4c(%rsp)
movaps %xmm2,%xmm6
movaps %xmm1,%xmm0
movss  0x40(%rsp),%xmm4
movss  0x44(%rsp),%xmm5
ucomiss %xmm5,%xmm4
movaps %xmm5,%xmm3
movaps %xmm4,%xmm7
mov    $0x0,%eax
jbe    169f <tri_tri_intersect_with_isectline+0x57f>
movss  %xmm5,0x40(%rsp)
movss  %xmm4,0x44(%rsp)
movaps %xmm4,%xmm3
movaps %xmm5,%xmm7
ucomiss %xmm0,%xmm7
ja     17f5 <tri_tri_intersect_with_isectline+0x6d5>
ucomiss %xmm3,%xmm6
ja     17f5 <tri_tri_intersect_with_isectline+0x6d5>
mov    0x150(%rsp),%rax
mov    0x148(%rsp),%rcx
ucomiss %xmm7,%xmm6
jbe    16f5 <tri_tri_intersect_with_isectline+0x5d5>
ucomiss %xmm2,%xmm1
jbe    1721 <tri_tri_intersect_with_isectline+0x601>
movss  0x28(%rsp),%xmm1
movss  %xmm1,(%rcx)
movss  0x2c(%rsp),%xmm1
movss  %xmm1,0x4(%rcx)
movss  0x30(%rsp),%xmm1
movss  %xmm1,0x8(%rcx)
ucomiss %xmm3,%xmm0
ja     174a <tri_tri_intersect_with_isectline+0x62a>
jmp    1796 <tri_tri_intersect_with_isectline+0x676>
ucomiss %xmm5,%xmm4
jbe    176c <tri_tri_intersect_with_isectline+0x64c>
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    174f <tri_tri_intersect_with_isectline+0x62f>
jmp    1791 <tri_tri_intersect_with_isectline+0x671>
movss  0x34(%rsp),%xmm1
movss  %xmm1,(%rcx)
movss  0x38(%rsp),%xmm1
movss  %xmm1,0x4(%rcx)
movss  0x3c(%rsp),%xmm1
movss  %xmm1,0x8(%rcx)
ucomiss %xmm3,%xmm0
jbe    17d0 <tri_tri_intersect_with_isectline+0x6b0>
ucomiss %xmm5,%xmm4
jbe    17b3 <tri_tri_intersect_with_isectline+0x693>
movss  0x1c(%rsp),%xmm0
movss  %xmm0,(%rax)
movss  0x20(%rsp),%xmm0
movss  %xmm0,0x4(%rax)
movss  0x24(%rsp),%xmm0
jmp    17eb <tri_tri_intersect_with_isectline+0x6cb>
movss  0x1c(%rsp),%xmm4
movss  %xmm4,(%rcx)
movss  0x20(%rsp),%xmm4
movss  %xmm4,0x4(%rcx)
movss  0x24(%rsp),%xmm4
movss  %xmm4,0x8(%rcx)
ucomiss %xmm0,%xmm3
jbe    17b3 <tri_tri_intersect_with_isectline+0x693>
ucomiss %xmm2,%xmm1
jbe    17d0 <tri_tri_intersect_with_isectline+0x6b0>
movss  0x34(%rsp),%xmm0
movss  %xmm0,(%rax)
movss  0x38(%rsp),%xmm0
movss  %xmm0,0x4(%rax)
movss  0x3c(%rsp),%xmm0
jmp    17eb <tri_tri_intersect_with_isectline+0x6cb>
movss  0x10(%rsp),%xmm0
movss  %xmm0,(%rax)
movss  0x14(%rsp),%xmm0
movss  %xmm0,0x4(%rax)
movss  0x18(%rsp),%xmm0
jmp    17eb <tri_tri_intersect_with_isectline+0x6cb>
movss  0x28(%rsp),%xmm0
movss  %xmm0,(%rax)
movss  0x2c(%rsp),%xmm0
movss  %xmm0,0x4(%rax)
movss  0x30(%rsp),%xmm0
movss  %xmm0,0x8(%rax)
mov    $0x1,%eax
add    $0x108,%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 = load float*, float** %12
%58 = getelementptr inbounds float, float* %57, i64 0
%59 = load float, float* %58
%60 = load float*, float** %11
%61 = getelementptr inbounds float, float* %60, i64 0
%62 = load float, float* %61
%63 = fsub float %59, %62
%64 = getelementptr inbounds [3 x float], [3 x float]* %20, i64 0, i64 0
store float %63, float* %64
%65 = load float*, float** %12
%66 = getelementptr inbounds float, float* %65, i64 1
%67 = load float, float* %66
%68 = load float*, float** %11
%69 = getelementptr inbounds float, float* %68, i64 1
%70 = load float, float* %69
%71 = fsub float %67, %70
%72 = getelementptr inbounds [3 x float], [3 x float]* %20, i64 0, i64 1
store float %71, float* %72
%73 = load float*, float** %12
%74 = getelementptr inbounds float, float* %73, i64 2
%75 = load float, float* %74
%76 = load float*, float** %11
%77 = getelementptr inbounds float, float* %76, i64 2
%78 = load float, float* %77
%79 = fsub float %75, %78
%80 = getelementptr inbounds [3 x float], [3 x float]* %20, i64 0, i64 2
store float %79, float* %80
%81 = load float*, float** %13
%82 = getelementptr inbounds float, float* %81, i64 0
%83 = load float, float* %82
%84 = load float*, float** %11
%85 = getelementptr inbounds float, float* %84, i64 0
%86 = load float, float* %85
%87 = fsub float %83, %86
%88 = getelementptr inbounds [3 x float], [3 x float]* %21, i64 0, i64 0
store float %87, float* %88
%89 = load float*, float** %13
%90 = getelementptr inbounds float, float* %89, i64 1
%91 = load float, float* %90
%92 = load float*, float** %11
%93 = getelementptr inbounds float, float* %92, i64 1
%94 = load float, float* %93
%95 = fsub float %91, %94
%96 = getelementptr inbounds [3 x float], [3 x float]* %21, i64 0, i64 1
store float %95, float* %96
%97 = load float*, float** %13
%98 = getelementptr inbounds float, float* %97, i64 2
%99 = load float, float* %98
%100 = load float*, float** %11
%101 = getelementptr inbounds float, float* %100, i64 2
%102 = load float, float* %101
%103 = fsub float %99, %102
%104 = getelementptr inbounds [3 x float], [3 x float]* %21, i64 0, i64 2
store float %103, float* %104
%105 = getelementptr inbounds [3 x float], [3 x float]* %20, i64 0, i64 1
%106 = load float, float* %105
%107 = getelementptr inbounds [3 x float], [3 x float]* %21, i64 0, i64 2
%108 = load float, float* %107
%109 = getelementptr inbounds [3 x float], [3 x float]* %20, i64 0, i64 2
%110 = load float, float* %109
%111 = getelementptr inbounds [3 x float], [3 x float]* %21, i64 0, i64 1
%112 = load float, float* %111
%113 = fmul float %110, %112
%114 = fneg float %113
%115 = call float @llvm.fmuladd.f32(float %106, float %108, float %114)
%116 = getelementptr inbounds [3 x float], [3 x float]* %22, i64 0, i64 0
store float %115, float* %116
%117 = getelementptr inbounds [3 x float], [3 x float]* %20, i64 0, i64 2
%118 = load float, float* %117
%119 = getelementptr inbounds [3 x float], [3 x float]* %21, i64 0, i64 0
%120 = load float, float* %119
%121 = getelementptr inbounds [3 x float], [3 x float]* %20, i64 0, i64 0
%122 = load float, float* %121
%123 = getelementptr inbounds [3 x float], [3 x float]* %21, i64 0, i64 2
%124 = load float, float* %123
%125 = fmul float %122, %124
%126 = fneg float %125
%127 = call float @llvm.fmuladd.f32(float %118, float %120, float %126)
%128 = getelementptr inbounds [3 x float], [3 x float]* %22, i64 0, i64 1
store float %127, float* %128
%129 = getelementptr inbounds [3 x float], [3 x float]* %20, i64 0, i64 0
%130 = load float, float* %129
%131 = getelementptr inbounds [3 x float], [3 x float]* %21, i64 0, i64 1
%132 = load float, float* %131
%133 = getelementptr inbounds [3 x float], [3 x float]* %20, i64 0, i64 1
%134 = load float, float* %133
%135 = getelementptr inbounds [3 x float], [3 x float]* %21, i64 0, i64 0
%136 = load float, float* %135
%137 = fmul float %134, %136
%138 = fneg float %137
%139 = call float @llvm.fmuladd.f32(float %130, float %132, float %138)
%140 = getelementptr inbounds [3 x float], [3 x float]* %22, i64 0, i64 2
store float %139, float* %140
%141 = getelementptr inbounds [3 x float], [3 x float]* %22, i64 0, i64 0
%142 = load float, float* %141
%143 = load float*, float** %11
%144 = getelementptr inbounds float, float* %143, i64 0
%145 = load float, float* %144
%146 = getelementptr inbounds [3 x float], [3 x float]* %22, i64 0, i64 1
%147 = load float, float* %146
%148 = load float*, float** %11
%149 = getelementptr inbounds float, float* %148, i64 1
%150 = load float, float* %149
%151 = fmul float %147, %150
%152 = call float @llvm.fmuladd.f32(float %142, float %145, float %151)
%153 = getelementptr inbounds [3 x float], [3 x float]* %22, i64 0, i64 2
%154 = load float, float* %153
%155 = load float*, float** %11
%156 = getelementptr inbounds float, float* %155, i64 2
%157 = load float, float* %156
%158 = call float @llvm.fmuladd.f32(float %154, float %157, float %152)
%159 = fneg float %158
store float %159, float* %24
%160 = getelementptr inbounds [3 x float], [3 x float]* %22, i64 0, i64 0
%161 = load float, float* %160
%162 = load float*, float** %14
%163 = getelementptr inbounds float, float* %162, i64 0
%164 = load float, float* %163
%165 = getelementptr inbounds [3 x float], [3 x float]* %22, i64 0, i64 1
%166 = load float, float* %165
%167 = load float*, float** %14
%168 = getelementptr inbounds float, float* %167, i64 1
%169 = load float, float* %168
%170 = fmul float %166, %169
%171 = call float @llvm.fmuladd.f32(float %161, float %164, float %170)
%172 = getelementptr inbounds [3 x float], [3 x float]* %22, i64 0, i64 2
%173 = load float, float* %172
%174 = load float*, float** %14
%175 = getelementptr inbounds float, float* %174, i64 2
%176 = load float, float* %175
%177 = call float @llvm.fmuladd.f32(float %173, float %176, float %171)
%178 = load float, float* %24
%179 = fadd float %177, %178
store float %179, float* %26
%180 = getelementptr inbounds [3 x float], [3 x float]* %22, i64 0, i64 0
%181 = load float, float* %180
%182 = load float*, float** %15
%183 = getelementptr inbounds float, float* %182, i64 0
%184 = load float, float* %183
%185 = getelementptr inbounds [3 x float], [3 x float]* %22, i64 0, i64 1
%186 = load float, float* %185
%187 = load float*, float** %15
%188 = getelementptr inbounds float, float* %187, i64 1
%189 = load float, float* %188
%190 = fmul float %186, %189
%191 = call float @llvm.fmuladd.f32(float %181, float %184, float %190)
%192 = getelementptr inbounds [3 x float], [3 x float]* %22, i64 0, i64 2
%193 = load float, float* %192
%194 = load float*, float** %15
%195 = getelementptr inbounds float, float* %194, i64 2
%196 = load float, float* %195
%197 = call float @llvm.fmuladd.f32(float %193, float %196, float %191)
%198 = load float, float* %24
%199 = fadd float %197, %198
store float %199, float* %27
%200 = getelementptr inbounds [3 x float], [3 x float]* %22, i64 0, i64 0
%201 = load float, float* %200
%202 = load float*, float** %16
%203 = getelementptr inbounds float, float* %202, i64 0
%204 = load float, float* %203
%205 = getelementptr inbounds [3 x float], [3 x float]* %22, i64 0, i64 1
%206 = load float, float* %205
%207 = load float*, float** %16
%208 = getelementptr inbounds float, float* %207, i64 1
%209 = load float, float* %208
%210 = fmul float %206, %209
%211 = call float @llvm.fmuladd.f32(float %201, float %204, float %210)
%212 = getelementptr inbounds [3 x float], [3 x float]* %22, i64 0, i64 2
%213 = load float, float* %212
%214 = load float*, float** %16
%215 = getelementptr inbounds float, float* %214, i64 2
%216 = load float, float* %215
%217 = call float @llvm.fmuladd.f32(float %213, float %216, float %211)
%218 = load float, float* %24
%219 = fadd float %217, %218
store float %219, float* %28
%220 = load float, float* %26
%221 = fpext float %220 to double
%222 = call double @llvm.fabs.f64(double %221)
%223 = fcmp olt double %222, 5.000000e-03
br i1 %223, label %224, label %225
224: ; preds = %9
store float 0.000000e+00, float* %26
br label %225
225: ; preds = %224, %9
%226 = load float, float* %27
%227 = fpext float %226 to double
%228 = call double @llvm.fabs.f64(double %227)
%229 = fcmp olt double %228, 5.000000e-03
br i1 %229, label %230, label %231
230: ; preds = %225
store float 0.000000e+00, float* %27
br label %231
231: ; preds = %230, %225
%232 = load float, float* %28
%233 = fpext float %232 to double
%234 = call double @llvm.fabs.f64(double %233)
%235 = fcmp olt double %234, 5.000000e-03
br i1 %235, label %236, label %237
236: ; preds = %231
store float 0.000000e+00, float* %28
br label %237
237: ; preds = %236, %231
%238 = load float, float* %26
%239 = load float, float* %27
%240 = fmul float %238, %239
store float %240, float* %39
%241 = load float, float* %26
%242 = load float, float* %28
%243 = fmul float %241, %242
store float %243, float* %40
%244 = load float, float* %39
%245 = fcmp ogt float %244, 0.000000e+00
br i1 %245, label %246, label %250
246: ; preds = %237
%247 = load float, float* %40
%248 = fcmp ogt float %247, 0.000000e+00
br i1 %248, label %249, label %250
249: ; preds = %246
store i32 0, i32* %10
br label %841
250: ; preds = %246, %237
%251 = load float*, float** %15
%252 = getelementptr inbounds float, float* %251, i64 0
%253 = load float, float* %252
%254 = load float*, float** %14
%255 = getelementptr inbounds float, float* %254, i64 0
%256 = load float, float* %255
%257 = fsub float %253, %256
%258 = getelementptr inbounds [3 x float], [3 x float]* %20, i64 0, i64 0
store float %257, float* %258
%259 = load float*, float** %15
%260 = getelementptr inbounds float, float* %259, i64 1
%261 = load float, float* %260
%262 = load float*, float** %14
%263 = getelementptr inbounds float, float* %262, i64 1
%264 = load float, float* %263
%265 = fsub float %261, %264
%266 = getelementptr inbounds [3 x float], [3 x float]* %20, i64 0, i64 1
store float %265, float* %266
%267 = load float*, float** %15
%268 = getelementptr inbounds float, float* %267, i64 2
%269 = load float, float* %268
%270 = load float*, float** %14
%271 = getelementptr inbounds float, float* %270, i64 2
%272 = load float, float* %271
%273 = fsub float %269, %272
%274 = getelementptr inbounds [3 x float], [3 x float]* %20, i64 0, i64 2
store float %273, float* %274
%275 = load float*, float** %16
%276 = getelementptr inbounds float, float* %275, i64 0
%277 = load float, float* %276
%278 = load float*, float** %14
%279 = getelementptr inbounds float, float* %278, i64 0
%280 = load float, float* %279
%281 = fsub float %277, %280
%282 = getelementptr inbounds [3 x float], [3 x float]* %21, i64 0, i64 0
store float %281, float* %282
%283 = load float*, float** %16
%284 = getelementptr inbounds float, float* %283, i64 1
%285 = load float, float* %284
%286 = load float*, float** %14
%287 = getelementptr inbounds float, float* %286, i64 1
%288 = load float, float* %287
%289 = fsub float %285, %288
%290 = getelementptr inbounds [3 x float], [3 x float]* %21, i64 0, i64 1
store float %289, float* %290
%291 = load float*, float** %16
%292 = getelementptr inbounds float, float* %291, i64 2
%293 = load float, float* %292
%294 = load float*, float** %14
%295 = getelementptr inbounds float, float* %294, i64 2
%296 = load float, float* %295
%297 = fsub float %293, %296
%298 = getelementptr inbounds [3 x float], [3 x float]* %21, i64 0, i64 2
store float %297, float* %298
%299 = getelementptr inbounds [3 x float], [3 x float]* %20, i64 0, i64 1
%300 = load float, float* %299
%301 = getelementptr inbounds [3 x float], [3 x float]* %21, i64 0, i64 2
%302 = load float, float* %301
%303 = getelementptr inbounds [3 x float], [3 x float]* %20, i64 0, i64 2
%304 = load float, float* %303
%305 = getelementptr inbounds [3 x float], [3 x float]* %21, i64 0, i64 1
%306 = load float, float* %305
%307 = fmul float %304, %306
%308 = fneg float %307
%309 = call float @llvm.fmuladd.f32(float %300, float %302, float %308)
%310 = getelementptr inbounds [3 x float], [3 x float]* %23, i64 0, i64 0
store float %309, float* %310
%311 = getelementptr inbounds [3 x float], [3 x float]* %20, i64 0, i64 2
%312 = load float, float* %311
%313 = getelementptr inbounds [3 x float], [3 x float]* %21, i64 0, i64 0
%314 = load float, float* %313
%315 = getelementptr inbounds [3 x float], [3 x float]* %20, i64 0, i64 0
%316 = load float, float* %315
%317 = getelementptr inbounds [3 x float], [3 x float]* %21, i64 0, i64 2
%318 = load float, float* %317
%319 = fmul float %316, %318
%320 = fneg float %319
%321 = call float @llvm.fmuladd.f32(float %312, float %314, float %320)
%322 = getelementptr inbounds [3 x float], [3 x float]* %23, i64 0, i64 1
store float %321, float* %322
%323 = getelementptr inbounds [3 x float], [3 x float]* %20, i64 0, i64 0
%324 = load float, float* %323
%325 = getelementptr inbounds [3 x float], [3 x float]* %21, i64 0, i64 1
%326 = load float, float* %325
%327 = getelementptr inbounds [3 x float], [3 x float]* %20, i64 0, i64 1
%328 = load float, float* %327
%329 = getelementptr inbounds [3 x float], [3 x float]* %21, i64 0, i64 0
%330 = load float, float* %329
%331 = fmul float %328, %330
%332 = fneg float %331
%333 = call float @llvm.fmuladd.f32(float %324, float %326, float %332)
%334 = getelementptr inbounds [3 x float], [3 x float]* %23, i64 0, i64 2
store float %333, float* %334
%335 = getelementptr inbounds [3 x float], [3 x float]* %23, i64 0, i64 0
%336 = load float, float* %335
%337 = load float*, float** %14
%338 = getelementptr inbounds float, float* %337, i64 0
%339 = load float, float* %338
%340 = getelementptr inbounds [3 x float], [3 x float]* %23, i64 0, i64 1
%341 = load float, float* %340
%342 = load float*, float** %14
%343 = getelementptr inbounds float, float* %342, i64 1
%344 = load float, float* %343
%345 = fmul float %341, %344
%346 = call float @llvm.fmuladd.f32(float %336, float %339, float %345)
%347 = getelementptr inbounds [3 x float], [3 x float]* %23, i64 0, i64 2
%348 = load float, float* %347
%349 = load float*, float** %14
%350 = getelementptr inbounds float, float* %349, i64 2
%351 = load float, float* %350
%352 = call float @llvm.fmuladd.f32(float %348, float %351, float %346)
%353 = fneg float %352
store float %353, float* %25
%354 = getelementptr inbounds [3 x float], [3 x float]* %23, i64 0, i64 0
%355 = load float, float* %354
%356 = load float*, float** %11
%357 = getelementptr inbounds float, float* %356, i64 0
%358 = load float, float* %357
%359 = getelementptr inbounds [3 x float], [3 x float]* %23, i64 0, i64 1
%360 = load float, float* %359
%361 = load float*, float** %11
%362 = getelementptr inbounds float, float* %361, i64 1
%363 = load float, float* %362
%364 = fmul float %360, %363
%365 = call float @llvm.fmuladd.f32(float %355, float %358, float %364)
%366 = getelementptr inbounds [3 x float], [3 x float]* %23, i64 0, i64 2
%367 = load float, float* %366
%368 = load float*, float** %11
%369 = getelementptr inbounds float, float* %368, i64 2
%370 = load float, float* %369
%371 = call float @llvm.fmuladd.f32(float %367, float %370, float %365)
%372 = load float, float* %25
%373 = fadd float %371, %372
store float %373, float* %29
%374 = getelementptr inbounds [3 x float], [3 x float]* %23, i64 0, i64 0
%375 = load float, float* %374
%376 = load float*, float** %12
%377 = getelementptr inbounds float, float* %376, i64 0
%378 = load float, float* %377
%379 = getelementptr inbounds [3 x float], [3 x float]* %23, i64 0, i64 1
%380 = load float, float* %379
%381 = load float*, float** %12
%382 = getelementptr inbounds float, float* %381, i64 1
%383 = load float, float* %382
%384 = fmul float %380, %383
%385 = call float @llvm.fmuladd.f32(float %375, float %378, float %384)
%386 = getelementptr inbounds [3 x float], [3 x float]* %23, i64 0, i64 2
%387 = load float, float* %386
%388 = load float*, float** %12
%389 = getelementptr inbounds float, float* %388, i64 2
%390 = load float, float* %389
%391 = call float @llvm.fmuladd.f32(float %387, float %390, float %385)
%392 = load float, float* %25
%393 = fadd float %391, %392
store float %393, float* %30
%394 = getelementptr inbounds [3 x float], [3 x float]* %23, i64 0, i64 0
%395 = load float, float* %394
%396 = load float*, float** %13
%397 = getelementptr inbounds float, float* %396, i64 0
%398 = load float, float* %397
%399 = getelementptr inbounds [3 x float], [3 x float]* %23, i64 0, i64 1
%400 = load float, float* %399
%401 = load float*, float** %13
%402 = getelementptr inbounds float, float* %401, i64 1
%403 = load float, float* %402
%404 = fmul float %400, %403
%405 = call float @llvm.fmuladd.f32(float %395, float %398, float %404)
%406 = getelementptr inbounds [3 x float], [3 x float]* %23, i64 0, i64 2
%407 = load float, float* %406
%408 = load float*, float** %13
%409 = getelementptr inbounds float, float* %408, i64 2
%410 = load float, float* %409
%411 = call float @llvm.fmuladd.f32(float %407, float %410, float %405)
%412 = load float, float* %25
%413 = fadd float %411, %412
store float %413, float* %31
%414 = load float, float* %29
%415 = fpext float %414 to double
%416 = call double @llvm.fabs.f64(double %415)
%417 = fcmp olt double %416, 5.000000e-03
br i1 %417, label %418, label %419
418: ; preds = %250
store float 0.000000e+00, float* %29
br label %419
419: ; preds = %418, %250
%420 = load float, float* %30
%421 = fpext float %420 to double
%422 = call double @llvm.fabs.f64(double %421)
%423 = fcmp olt double %422, 5.000000e-03
br i1 %423, label %424, label %425
424: ; preds = %419
store float 0.000000e+00, float* %30
br label %425
425: ; preds = %424, %419
%426 = load float, float* %31
%427 = fpext float %426 to double
%428 = call double @llvm.fabs.f64(double %427)
%429 = fcmp olt double %428, 5.000000e-03
br i1 %429, label %430, label %431
430: ; preds = %425
store float 0.000000e+00, float* %31
br label %431
431: ; preds = %430, %425
%432 = load float, float* %29
%433 = load float, float* %30
%434 = fmul float %432, %433
store float %434, float* %41
%435 = load float, float* %29
%436 = load float, float* %31
%437 = fmul float %435, %436
store float %437, float* %42
%438 = load float, float* %41
%439 = fcmp ogt float %438, 0.000000e+00
br i1 %439, label %440, label %444
440: ; preds = %431
%441 = load float, float* %42
%442 = fcmp ogt float %441, 0.000000e+00
br i1 %442, label %443, label %444
443: ; preds = %440
store i32 0, i32* %10
br label %841
444: ; preds = %440, %431
%445 = getelementptr inbounds [3 x float], [3 x float]* %22, i64 0, i64 1
%446 = load float, float* %445
%447 = getelementptr inbounds [3 x float], [3 x float]* %23, i64 0, i64 2
%448 = load float, float* %447
%449 = getelementptr inbounds [3 x float], [3 x float]* %22, i64 0, i64 2
%450 = load float, float* %449
%451 = getelementptr inbounds [3 x float], [3 x float]* %23, i64 0, i64 1
%452 = load float, float* %451
%453 = fmul float %450, %452
%454 = fneg float %453
%455 = call float @llvm.fmuladd.f32(float %446, float %448, float %454)
%456 = getelementptr inbounds [3 x float], [3 x float]* %32, i64 0, i64 0
store float %455, float* %456
%457 = getelementptr inbounds [3 x float], [3 x float]* %22, i64 0, i64 2
%458 = load float, float* %457
%459 = getelementptr inbounds [3 x float], [3 x float]* %23, i64 0, i64 0
%460 = load float, float* %459
%461 = getelementptr inbounds [3 x float], [3 x float]* %22, i64 0, i64 0
%462 = load float, float* %461
%463 = getelementptr inbounds [3 x float], [3 x float]* %23, i64 0, i64 2
%464 = load float, float* %463
%465 = fmul float %462, %464
%466 = fneg float %465
%467 = call float @llvm.fmuladd.f32(float %458, float %460, float %466)
%468 = getelementptr inbounds [3 x float], [3 x float]* %32, i64 0, i64 1
store float %467, float* %468
%469 = getelementptr inbounds [3 x float], [3 x float]* %22, i64 0, i64 0
%470 = load float, float* %469
%471 = getelementptr inbounds [3 x float], [3 x float]* %23, i64 0, i64 1
%472 = load float, float* %471
%473 = getelementptr inbounds [3 x float], [3 x float]* %22, i64 0, i64 1
%474 = load float, float* %473
%475 = getelementptr inbounds [3 x float], [3 x float]* %23, i64 0, i64 0
%476 = load float, float* %475
%477 = fmul float %474, %476
%478 = fneg float %477
%479 = call float @llvm.fmuladd.f32(float %470, float %472, float %478)
%480 = getelementptr inbounds [3 x float], [3 x float]* %32, i64 0, i64 2
store float %479, float* %480
%481 = getelementptr inbounds [3 x float], [3 x float]* %32, i64 0, i64 0
%482 = load float, float* %481
%483 = fpext float %482 to double
%484 = call double @llvm.fabs.f64(double %483)
%485 = fptrunc double %484 to float
store float %485, float* %52
store i16 0, i16* %43
%486 = getelementptr inbounds [3 x float], [3 x float]* %32, i64 0, i64 1
%487 = load float, float* %486
%488 = fpext float %487 to double
%489 = call double @llvm.fabs.f64(double %488)
%490 = fptrunc double %489 to float
store float %490, float* %50
%491 = getelementptr inbounds [3 x float], [3 x float]* %32, i64 0, i64 2
%492 = load float, float* %491
%493 = fpext float %492 to double
%494 = call double @llvm.fabs.f64(double %493)
%495 = fptrunc double %494 to float
store float %495, float* %51
%496 = load float, float* %50
%497 = load float, float* %52
%498 = fcmp ogt float %496, %497
br i1 %498, label %499, label %501
499: ; preds = %444
%500 = load float, float* %50
store float %500, float* %52
store i16 1, i16* %43
br label %501
501: ; preds = %499, %444
%502 = load float, float* %51
%503 = load float, float* %52
%504 = fcmp ogt float %502, %503
br i1 %504, label %505, label %507
505: ; preds = %501
%506 = load float, float* %51
store float %506, float* %52
store i16 2, i16* %43
br label %507
507: ; preds = %505, %501
%508 = load float*, float** %11
%509 = load i16, i16* %43
%510 = sext i16 %509 to i64
%511 = getelementptr inbounds float, float* %508, i64 %510
%512 = load float, float* %511
store float %512, float* %44
%513 = load float*, float** %12
%514 = load i16, i16* %43
%515 = sext i16 %514 to i64
%516 = getelementptr inbounds float, float* %513, i64 %515
%517 = load float, float* %516
store float %517, float* %45
%518 = load float*, float** %13
%519 = load i16, i16* %43
%520 = sext i16 %519 to i64
%521 = getelementptr inbounds float, float* %518, i64 %520
%522 = load float, float* %521
store float %522, float* %46
%523 = load float*, float** %14
%524 = load i16, i16* %43
%525 = sext i16 %524 to i64
%526 = getelementptr inbounds float, float* %523, i64 %525
%527 = load float, float* %526
store float %527, float* %47
%528 = load float*, float** %15
%529 = load i16, i16* %43
%530 = sext i16 %529 to i64
%531 = getelementptr inbounds float, float* %528, i64 %530
%532 = load float, float* %531
store float %532, float* %48
%533 = load float*, float** %16
%534 = load i16, i16* %43
%535 = sext i16 %534 to i64
%536 = getelementptr inbounds float, float* %533, i64 %535
%537 = load float, float* %536
store float %537, float* %49
%538 = load float*, float** %11
%539 = load float*, float** %12
%540 = load float*, float** %13
%541 = load float, float* %44
%542 = fpext float %541 to double
%543 = load float, float* %45
%544 = fpext float %543 to double
%545 = load float, float* %46
%546 = fpext float %545 to double
%547 = load float, float* %29
%548 = fpext float %547 to double
%549 = load float, float* %30
%550 = fpext float %549 to double
%551 = load float, float* %31
%552 = fpext float %551 to double
%553 = load float, float* %41
%554 = fpext float %553 to double
%555 = load float, float* %42
%556 = fpext float %555 to double
%557 = getelementptr inbounds [2 x float], [2 x float]* %33, i64 0, i64 0
%558 = getelementptr inbounds [2 x float], [2 x float]* %33, i64 0, i64 1
%559 = getelementptr inbounds [3 x float], [3 x float]* %35, i64 0, i64 0
%560 = getelementptr inbounds [3 x float], [3 x float]* %36, i64 0, i64 0
%561 = 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* %538, float* %539, float* %540, double %542, double %544, double %546, double %548, double %550, double %552, double %554, double %556, float* %557, float* %558, float* %559, float* %560)
%562 = load i32*, i32** %17
store i32 %561, i32* %562
%563 = load i32*, i32** %17
%564 = load i32, i32* %563
%565 = icmp ne i32 %564, 0
br i1 %565, label %566, label %575
566: ; preds = %507
%567 = getelementptr inbounds [3 x float], [3 x float]* %22, i64 0, i64 0
%568 = load float*, float** %11
%569 = load float*, float** %12
%570 = load float*, float** %13
%571 = load float*, float** %14
%572 = load float*, float** %15
%573 = load float*, float** %16
%574 = call i32 (float*, float*, float*, float*, float*, float*, float*, ...) bitcast (i32 (...)* @coplanar_tri_tri to i32 (float*, float*, float*, float*, float*, float*, float*, ...)*)(float* %567, float* %568, float* %569, float* %570, float* %571, float* %572, float* %573)
store i32 %574, i32* %10
br label %841
575: ; preds = %507
%576 = load float*, float** %14
%577 = load float*, float** %15
%578 = load float*, float** %16
%579 = load float, float* %47
%580 = fpext float %579 to double
%581 = load float, float* %48
%582 = fpext float %581 to double
%583 = load float, float* %49
%584 = fpext float %583 to double
%585 = load float, float* %26
%586 = fpext float %585 to double
%587 = load float, float* %27
%588 = fpext float %587 to double
%589 = load float, float* %28
%590 = fpext float %589 to double
%591 = load float, float* %39
%592 = fpext float %591 to double
%593 = load float, float* %40
%594 = fpext float %593 to double
%595 = getelementptr inbounds [2 x float], [2 x float]* %34, i64 0, i64 0
%596 = getelementptr inbounds [2 x float], [2 x float]* %34, i64 0, i64 1
%597 = getelementptr inbounds [3 x float], [3 x float]* %37, i64 0, i64 0
%598 = getelementptr inbounds [3 x float], [3 x float]* %38, i64 0, i64 0
%599 = 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* %576, float* %577, float* %578, double %580, double %582, double %584, double %586, double %588, double %590, double %592, double %594, float* %595, float* %596, float* %597, float* %598)
%600 = getelementptr inbounds [2 x float], [2 x float]* %33, i64 0, i64 0
%601 = load float, float* %600
%602 = getelementptr inbounds [2 x float], [2 x float]* %33, i64 0, i64 1
%603 = load float, float* %602
%604 = fcmp ogt float %601, %603
br i1 %604, label %605, label %613
605: ; preds = %575
%606 = getelementptr inbounds [2 x float], [2 x float]* %33, i64 0, i64 0
%607 = load float, float* %606
store float %607, float* %55
%608 = getelementptr inbounds [2 x float], [2 x float]* %33, i64 0, i64 1
%609 = load float, float* %608
%610 = getelementptr inbounds [2 x float], [2 x float]* %33, i64 0, i64 0
store float %609, float* %610
%611 = load float, float* %55
%612 = getelementptr inbounds [2 x float], [2 x float]* %33, i64 0, i64 1
store float %611, float* %612
store i32 1, i32* %53
br label %614
613: ; preds = %575
store i32 0, i32* %53
br label %614
614: ; preds = %613, %605
%615 = getelementptr inbounds [2 x float], [2 x float]* %34, i64 0, i64 0
%616 = load float, float* %615
%617 = getelementptr inbounds [2 x float], [2 x float]* %34, i64 0, i64 1
%618 = load float, float* %617
%619 = fcmp ogt float %616, %618
br i1 %619, label %620, label %628
620: ; preds = %614
%621 = getelementptr inbounds [2 x float], [2 x float]* %34, i64 0, i64 0
%622 = load float, float* %621
store float %622, float* %56
%623 = getelementptr inbounds [2 x float], [2 x float]* %34, i64 0, i64 1
%624 = load float, float* %623
%625 = getelementptr inbounds [2 x float], [2 x float]* %34, i64 0, i64 0
store float %624, float* %625
%626 = load float, float* %56
%627 = getelementptr inbounds [2 x float], [2 x float]* %34, i64 0, i64 1
store float %626, float* %627
store i32 1, i32* %54
br label %629
628: ; preds = %614
store i32 0, i32* %54
br label %629
629: ; preds = %628, %620
%630 = getelementptr inbounds [2 x float], [2 x float]* %33, i64 0, i64 1
%631 = load float, float* %630
%632 = getelementptr inbounds [2 x float], [2 x float]* %34, i64 0, i64 0
%633 = load float, float* %632
%634 = fcmp olt float %631, %633
br i1 %634, label %641, label %635
635: ; preds = %629
%636 = getelementptr inbounds [2 x float], [2 x float]* %34, i64 0, i64 1
%637 = load float, float* %636
%638 = getelementptr inbounds [2 x float], [2 x float]* %33, i64 0, i64 0
%639 = load float, float* %638
%640 = fcmp olt float %637, %639
br i1 %640, label %641, label %642
641: ; preds = %635, %629
store i32 0, i32* %10
br label %841
642: ; preds = %635
%643 = getelementptr inbounds [2 x float], [2 x float]* %34, i64 0, i64 0
%644 = load float, float* %643
%645 = getelementptr inbounds [2 x float], [2 x float]* %33, i64 0, i64 0
%646 = load float, float* %645
%647 = fcmp olt float %644, %646
br i1 %647, label %648, label %744
648: ; preds = %642
%649 = load i32, i32* %53
%650 = icmp eq i32 %649, 0
br i1 %650, label %651, label %664
651: ; preds = %648
%652 = getelementptr inbounds [3 x float], [3 x float]* %35, i64 0, i64 0
%653 = load float, float* %652
%654 = load float*, float** %18
%655 = getelementptr inbounds float, float* %654, i64 0
store float %653, float* %655
%656 = getelementptr inbounds [3 x float], [3 x float]* %35, i64 0, i64 1
%657 = load float, float* %656
%658 = load float*, float** %18
%659 = getelementptr inbounds float, float* %658, i64 1
store float %657, float* %659
%660 = getelementptr inbounds [3 x float], [3 x float]* %35, i64 0, i64 2
%661 = load float, float* %660
%662 = load float*, float** %18
%663 = getelementptr inbounds float, float* %662, i64 2
store float %661, float* %663
br label %677
664: ; preds = %648
%665 = getelementptr inbounds [3 x float], [3 x float]* %36, i64 0, i64 0
%666 = load float, float* %665
%667 = load float*, float** %18
%668 = getelementptr inbounds float, float* %667, i64 0
store float %666, float* %668
%669 = getelementptr inbounds [3 x float], [3 x float]* %36, i64 0, i64 1
%670 = load float, float* %669
%671 = load float*, float** %18
%672 = getelementptr inbounds float, float* %671, i64 1
store float %670, float* %672
%673 = getelementptr inbounds [3 x float], [3 x float]* %36, i64 0, i64 2
%674 = load float, float* %673
%675 = load float*, float** %18
%676 = getelementptr inbounds float, float* %675, i64 2
store float %674, float* %676
br label %677
677: ; preds = %664, %651
%678 = getelementptr inbounds [2 x float], [2 x float]* %34, i64 0, i64 1
%679 = load float, float* %678
%680 = getelementptr inbounds [2 x float], [2 x float]* %33, i64 0, i64 1
%681 = load float, float* %680
%682 = fcmp olt float %679, %681
br i1 %682, label %683, label %713
683: ; preds = %677
%684 = load i32, i32* %54
%685 = icmp eq i32 %684, 0
br i1 %685, label %686, label %699
686: ; preds = %683
%687 = getelementptr inbounds [3 x float], [3 x float]* %38, i64 0, i64 0
%688 = load float, float* %687
%689 = load float*, float** %19
%690 = getelementptr inbounds float, float* %689, i64 0
store float %688, float* %690
%691 = getelementptr inbounds [3 x float], [3 x float]* %38, i64 0, i64 1
%692 = load float, float* %691
%693 = load float*, float** %19
%694 = getelementptr inbounds float, float* %693, i64 1
store float %692, float* %694
%695 = getelementptr inbounds [3 x float], [3 x float]* %38, i64 0, i64 2
%696 = load float, float* %695
%697 = load float*, float** %19
%698 = getelementptr inbounds float, float* %697, i64 2
store float %696, float* %698
br label %712
699: ; preds = %683
%700 = getelementptr inbounds [3 x float], [3 x float]* %37, i64 0, i64 0
%701 = load float, float* %700
%702 = load float*, float** %19
%703 = getelementptr inbounds float, float* %702, i64 0
store float %701, float* %703
%704 = getelementptr inbounds [3 x float], [3 x float]* %37, i64 0, i64 1
%705 = load float, float* %704
%706 = load float*, float** %19
%707 = getelementptr inbounds float, float* %706, i64 1
store float %705, float* %707
%708 = getelementptr inbounds [3 x float], [3 x float]* %37, i64 0, i64 2
%709 = load float, float* %708
%710 = load float*, float** %19
%711 = getelementptr inbounds float, float* %710, i64 2
store float %709, float* %711
br label %712
712: ; preds = %699, %686
br label %743
713: ; preds = %677
%714 = load i32, i32* %53
%715 = icmp eq i32 %714, 0
br i1 %715, label %716, label %729
716: ; preds = %713
%717 = getelementptr inbounds [3 x float], [3 x float]* %36, i64 0, i64 0
%718 = load float, float* %717
%719 = load float*, float** %19
%720 = getelementptr inbounds float, float* %719, i64 0
store float %718, float* %720
%721 = getelementptr inbounds [3 x float], [3 x float]* %36, i64 0, i64 1
%722 = load float, float* %721
%723 = load float*, float** %19
%724 = getelementptr inbounds float, float* %723, i64 1
store float %722, float* %724
%725 = getelementptr inbounds [3 x float], [3 x float]* %36, i64 0, i64 2
%726 = load float, float* %725
%727 = load float*, float** %19
%728 = getelementptr inbounds float, float* %727, i64 2
store float %726, float* %728
br label %742
729: ; preds = %713
%730 = getelementptr inbounds [3 x float], [3 x float]* %35, i64 0, i64 0
%731 = load float, float* %730
%732 = load float*, float** %19
%733 = getelementptr inbounds float, float* %732, i64 0
store float %731, float* %733
%734 = getelementptr inbounds [3 x float], [3 x float]* %35, i64 0, i64 1
%735 = load float, float* %734
%736 = load float*, float** %19
%737 = getelementptr inbounds float, float* %736, i64 1
store float %735, float* %737
%738 = getelementptr inbounds [3 x float], [3 x float]* %35, i64 0, i64 2
%739 = load float, float* %738
%740 = load float*, float** %19
%741 = getelementptr inbounds float, float* %740, i64 2
store float %739, float* %741
br label %742
742: ; preds = %729, %716
br label %743
743: ; preds = %742, %712
br label %840
744: ; preds = %642
%745 = load i32, i32* %54
%746 = icmp eq i32 %745, 0
br i1 %746, label %747, label %760
747: ; preds = %744
%748 = getelementptr inbounds [3 x float], [3 x float]* %37, i64 0, i64 0
%749 = load float, float* %748
%750 = load float*, float** %18
%751 = getelementptr inbounds float, float* %750, i64 0
store float %749, float* %751
%752 = getelementptr inbounds [3 x float], [3 x float]* %37, i64 0, i64 1
%753 = load float, float* %752
%754 = load float*, float** %18
%755 = getelementptr inbounds float, float* %754, i64 1
store float %753, float* %755
%756 = getelementptr inbounds [3 x float], [3 x float]* %37, i64 0, i64 2
%757 = load float, float* %756
%758 = load float*, float** %18
%759 = getelementptr inbounds float, float* %758, i64 2
store float %757, float* %759
br label %773
760: ; preds = %744
%761 = getelementptr inbounds [3 x float], [3 x float]* %38, i64 0, i64 0
%762 = load float, float* %761
%763 = load float*, float** %18
%764 = getelementptr inbounds float, float* %763, i64 0
store float %762, float* %764
%765 = getelementptr inbounds [3 x float], [3 x float]* %38, i64 0, i64 1
%766 = load float, float* %765
%767 = load float*, float** %18
%768 = getelementptr inbounds float, float* %767, i64 1
store float %766, float* %768
%769 = getelementptr inbounds [3 x float], [3 x float]* %38, i64 0, i64 2
%770 = load float, float* %769
%771 = load float*, float** %18
%772 = getelementptr inbounds float, float* %771, i64 2
store float %770, float* %772
br label %773
773: ; preds = %760, %747
%774 = getelementptr inbounds [2 x float], [2 x float]* %34, i64 0, i64 1
%775 = load float, float* %774
%776 = getelementptr inbounds [2 x float], [2 x float]* %33, i64 0, i64 1
%777 = load float, float* %776
%778 = fcmp ogt float %775, %777
br i1 %778, label %779, label %809
779: ; preds = %773
%780 = load i32, i32* %53
%781 = icmp eq i32 %780, 0
br i1 %781, label %782, label %795
782: ; preds = %779
%783 = getelementptr inbounds [3 x float], [3 x float]* %36, i64 0, i64 0
%784 = load float, float* %783
%785 = load float*, float** %19
%786 = getelementptr inbounds float, float* %785, i64 0
store float %784, float* %786
%787 = getelementptr inbounds [3 x float], [3 x float]* %36, i64 0, i64 1
%788 = load float, float* %787
%789 = load float*, float** %19
%790 = getelementptr inbounds float, float* %789, i64 1
store float %788, float* %790
%791 = getelementptr inbounds [3 x float], [3 x float]* %36, i64 0, i64 2
%792 = load float, float* %791
%793 = load float*, float** %19
%794 = getelementptr inbounds float, float* %793, i64 2
store float %792, float* %794
br label %808
795: ; preds = %779
%796 = getelementptr inbounds [3 x float], [3 x float]* %35, i64 0, i64 0
%797 = load float, float* %796
%798 = load float*, float** %19
%799 = getelementptr inbounds float, float* %798, i64 0
store float %797, float* %799
%800 = getelementptr inbounds [3 x float], [3 x float]* %35, i64 0, i64 1
%801 = load float, float* %800
%802 = load float*, float** %19
%803 = getelementptr inbounds float, float* %802, i64 1
store float %801, float* %803
%804 = getelementptr inbounds [3 x float], [3 x float]* %35, i64 0, i64 2
%805 = load float, float* %804
%806 = load float*, float** %19
%807 = getelementptr inbounds float, float* %806, i64 2
store float %805, float* %807
br label %808
808: ; preds = %795, %782
br label %839
809: ; preds = %773
%810 = load i32, i32* %54
%811 = icmp eq i32 %810, 0
br i1 %811, label %812, label %825
812: ; preds = %809
%813 = getelementptr inbounds [3 x float], [3 x float]* %38, i64 0, i64 0
%814 = load float, float* %813
%815 = load float*, float** %19
%816 = getelementptr inbounds float, float* %815, i64 0
store float %814, float* %816
%817 = getelementptr inbounds [3 x float], [3 x float]* %38, i64 0, i64 1
%818 = load float, float* %817
%819 = load float*, float** %19
%820 = getelementptr inbounds float, float* %819, i64 1
store float %818, float* %820
%821 = getelementptr inbounds [3 x float], [3 x float]* %38, i64 0, i64 2
%822 = load float, float* %821
%823 = load float*, float** %19
%824 = getelementptr inbounds float, float* %823, i64 2
store float %822, float* %824
br label %838
825: ; preds = %809
%826 = getelementptr inbounds [3 x float], [3 x float]* %37, i64 0, i64 0
%827 = load float, float* %826
%828 = load float*, float** %19
%829 = getelementptr inbounds float, float* %828, i64 0
store float %827, float* %829
%830 = getelementptr inbounds [3 x float], [3 x float]* %37, i64 0, i64 1
%831 = load float, float* %830
%832 = load float*, float** %19
%833 = getelementptr inbounds float, float* %832, i64 1
store float %831, float* %833
%834 = getelementptr inbounds [3 x float], [3 x float]* %37, i64 0, i64 2
%835 = load float, float* %834
%836 = load float*, float** %19
%837 = getelementptr inbounds float, float* %836, i64 2
store float %835, float* %837
br label %838
838: ; preds = %825, %812
br label %839
839: ; preds = %838, %808
br label %840
840: ; preds = %839, %743
store i32 1, i32* %10
br label %841
841: ; preds = %840, %641, %566, %443, %249
%842 = load i32, i32* %10
ret i32 %842
}

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