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

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
}