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 ((du0 >= 0 ? du0 : -du0) < 0.000001)
    du0 = 0.0;
  if ((du1 >= 0 ? du1 : -du1) < 0.000001)
    du1 = 0.0;
  if ((du2 >= 0 ? du2 : -du2) < 0.000001)
    du2 = 0.0;
  du0du1 = du0 * du1;
  du0du2 = du0 * du2;
  if (du0du1 > 0.0f && du0du2 > 0.0f)
    return 0;
  E1[0] = U1[0] - U0[0];
  E1[1] = U1[1] - U0[1];
  E1[2] = U1[2] - U0[2];
  ;
  E2[0] = U2[0] - U0[0];
  E2[1] = U2[1] - U0[1];
  E2[2] = U2[2] - U0[2];
  ;
  N2[0] = E1[1] * E2[2] - E1[2] * E2[1];
  N2[1] = E1[2] * E2[0] - E1[0] * E2[2];
  N2[2] = E1[0] * E2[1] - E1[1] * E2[0];
  ;
  d2 = -(N2[0] * U0[0] + N2[1] * U0[1] + N2[2] * U0[2]);
  dv0 = (N2[0] * V0[0] + N2[1] * V0[1] + N2[2] * V0[2]) + d2;
  dv1 = (N2[0] * V1[0] + N2[1] * V1[1] + N2[2] * V1[2]) + d2;
  dv2 = (N2[0] * V2[0] + N2[1] * V2[1] + N2[2] * V2[2]) + d2;
  if ((dv0 >= 0 ? dv0 : -dv0) < 0.000001)
    dv0 = 0.0;
  if ((dv1 >= 0 ? dv1 : -dv1) < 0.000001)
    dv1 = 0.0;
  if ((dv2 >= 0 ? dv2 : -dv2) < 0.000001)
    dv2 = 0.0;
  dv0dv1 = dv0 * dv1;
  dv0dv2 = dv0 * dv2;
  if (dv0dv1 > 0.0f && dv0dv2 > 0.0f)
    return 0;
  D[0] = N1[1] * N2[2] - N1[2] * N2[1];
  D[1] = N1[2] * N2[0] - N1[0] * N2[2];
  D[2] = N1[0] * N2[1] - N1[1] * N2[0];
  ;
  max = (D[0] >= 0 ? D[0] : -D[0]);
  index = 0;
  b = (D[1] >= 0 ? D[1] : -D[1]);
  c = (D[2] >= 0 ? D[2] : -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    $0x160,%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
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     1396 <tri_tri_intersect_with_isectline+0x276>
movss  -0x74(%rbp),%xmm0
movss  %xmm0,-0x130(%rbp)
ff
jmp    13b0 <tri_tri_intersect_with_isectline+0x290>
movss  -0x74(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x130(%rbp)
ff
movss  -0x130(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
movsd  0x1c3c(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    13d6 <tri_tri_intersect_with_isectline+0x2b6>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x78(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     13f9 <tri_tri_intersect_with_isectline+0x2d9>
movss  -0x78(%rbp),%xmm0
movss  %xmm0,-0x134(%rbp)
ff
jmp    1413 <tri_tri_intersect_with_isectline+0x2f3>
movss  -0x78(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x134(%rbp)
ff
movss  -0x134(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
movsd  0x1bd9(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1439 <tri_tri_intersect_with_isectline+0x319>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x7c(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     145c <tri_tri_intersect_with_isectline+0x33c>
movss  -0x7c(%rbp),%xmm0
movss  %xmm0,-0x138(%rbp)
ff
jmp    1476 <tri_tri_intersect_with_isectline+0x356>
movss  -0x7c(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x138(%rbp)
ff
movss  -0x138(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
movsd  0x1b76(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    149c <tri_tri_intersect_with_isectline+0x37c>
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    14f4 <tri_tri_intersect_with_isectline+0x3d4>
movss  -0xdc(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    14f4 <tri_tri_intersect_with_isectline+0x3d4>
movl   $0x0,-0x4(%rbp)
jmp    20dd <tri_tri_intersect_with_isectline+0xfbd>
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
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     1741 <tri_tri_intersect_with_isectline+0x621>
movss  -0x80(%rbp),%xmm0
movss  %xmm0,-0x13c(%rbp)
ff
jmp    175b <tri_tri_intersect_with_isectline+0x63b>
movss  -0x80(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x13c(%rbp)
ff
movss  -0x13c(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
movsd  0x1891(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1781 <tri_tri_intersect_with_isectline+0x661>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x84(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     17aa <tri_tri_intersect_with_isectline+0x68a>
movss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0x140(%rbp)
ff
jmp    17c7 <tri_tri_intersect_with_isectline+0x6a7>
movss  -0x84(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x140(%rbp)
ff
movss  -0x140(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
movsd  0x1825(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    17f0 <tri_tri_intersect_with_isectline+0x6d0>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x88(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     1819 <tri_tri_intersect_with_isectline+0x6f9>
movss  -0x88(%rbp),%xmm0
ff
movss  %xmm0,-0x144(%rbp)
ff
jmp    1836 <tri_tri_intersect_with_isectline+0x716>
movss  -0x88(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x144(%rbp)
ff
movss  -0x144(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
movsd  0x17b6(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    185f <tri_tri_intersect_with_isectline+0x73f>
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    18bd <tri_tri_intersect_with_isectline+0x79d>
movss  -0xe4(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    18bd <tri_tri_intersect_with_isectline+0x79d>
movl   $0x0,-0x4(%rbp)
jmp    20dd <tri_tri_intersect_with_isectline+0xfbd>
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
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     1979 <tri_tri_intersect_with_isectline+0x859>
movss  -0x94(%rbp),%xmm0
ff
movss  %xmm0,-0x148(%rbp)
ff
jmp    1996 <tri_tri_intersect_with_isectline+0x876>
movss  -0x94(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x148(%rbp)
ff
movss  -0x148(%rbp),%xmm0
ff
movss  %xmm0,-0x10c(%rbp)
ff
movw   $0x0,-0xe6(%rbp)
movss  -0x90(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     19d8 <tri_tri_intersect_with_isectline+0x8b8>
movss  -0x90(%rbp),%xmm0
ff
movss  %xmm0,-0x14c(%rbp)
ff
jmp    19f5 <tri_tri_intersect_with_isectline+0x8d5>
movss  -0x90(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x14c(%rbp)
ff
movss  -0x14c(%rbp),%xmm0
ff
movss  %xmm0,-0x104(%rbp)
ff
movss  -0x8c(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     1a2e <tri_tri_intersect_with_isectline+0x90e>
movss  -0x8c(%rbp),%xmm0
ff
movss  %xmm0,-0x150(%rbp)
ff
jmp    1a4b <tri_tri_intersect_with_isectline+0x92b>
movss  -0x8c(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x150(%rbp)
ff
movss  -0x150(%rbp),%xmm0
ff
movss  %xmm0,-0x108(%rbp)
ff
movss  -0x104(%rbp),%xmm0
ff
ucomiss -0x10c(%rbp),%xmm0
jbe    1a89 <tri_tri_intersect_with_isectline+0x969>
movss  -0x104(%rbp),%xmm0
ff
movss  %xmm0,-0x10c(%rbp)
ff
movw   $0x1,-0xe6(%rbp)
movss  -0x108(%rbp),%xmm0
ff
ucomiss -0x10c(%rbp),%xmm0
jbe    1ab7 <tri_tri_intersect_with_isectline+0x997>
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     1c25 <tri_tri_intersect_with_isectline+0xb05>
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    20dd <tri_tri_intersect_with_isectline+0xfbd>
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    1d07 <tri_tri_intersect_with_isectline+0xbe7>
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    1d11 <tri_tri_intersect_with_isectline+0xbf1>
movl   $0x0,-0x120(%rbp)
movss  -0xa4(%rbp),%xmm0
ff
ucomiss -0xa0(%rbp),%xmm0
jbe    1d65 <tri_tri_intersect_with_isectline+0xc45>
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    1d6f <tri_tri_intersect_with_isectline+0xc4f>
movl   $0x0,-0x124(%rbp)
movss  -0x98(%rbp),%xmm1
ff
movss  -0xa4(%rbp),%xmm0
ff
ucomiss %xmm1,%xmm0
ja     1da1 <tri_tri_intersect_with_isectline+0xc81>
movss  -0xa0(%rbp),%xmm1
ff
movss  -0x9c(%rbp),%xmm0
ff
ucomiss %xmm1,%xmm0
jbe    1dad <tri_tri_intersect_with_isectline+0xc8d>
movl   $0x0,-0x4(%rbp)
jmp    20dd <tri_tri_intersect_with_isectline+0xfbd>
movss  -0xa4(%rbp),%xmm1
ff
movss  -0x9c(%rbp),%xmm0
ff
ucomiss %xmm1,%xmm0
jbe    1f50 <tri_tri_intersect_with_isectline+0xe30>
cmpl   $0x0,-0x120(%rbp)
jne    1e0a <tri_tri_intersect_with_isectline+0xcea>
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    1e3c <tri_tri_intersect_with_isectline+0xd1c>
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    1ed0 <tri_tri_intersect_with_isectline+0xdb0>
cmpl   $0x0,-0x124(%rbp)
jne    1e99 <tri_tri_intersect_with_isectline+0xd79>
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    1ecb <tri_tri_intersect_with_isectline+0xdab>
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    1f4b <tri_tri_intersect_with_isectline+0xe2b>
cmpl   $0x0,-0x120(%rbp)
jne    1f14 <tri_tri_intersect_with_isectline+0xdf4>
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    1f46 <tri_tri_intersect_with_isectline+0xe26>
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    1f4b <tri_tri_intersect_with_isectline+0xe2b>
jmp    20d6 <tri_tri_intersect_with_isectline+0xfb6>
cmpl   $0x0,-0x124(%rbp)
jne    1f94 <tri_tri_intersect_with_isectline+0xe74>
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    1fc6 <tri_tri_intersect_with_isectline+0xea6>
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    2056 <tri_tri_intersect_with_isectline+0xf36>
cmpl   $0x0,-0x120(%rbp)
jne    201f <tri_tri_intersect_with_isectline+0xeff>
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    2051 <tri_tri_intersect_with_isectline+0xf31>
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    20d1 <tri_tri_intersect_with_isectline+0xfb1>
cmpl   $0x0,-0x124(%rbp)
jne    209a <tri_tri_intersect_with_isectline+0xf7a>
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    20cc <tri_tri_intersect_with_isectline+0xfac>
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    20d1 <tri_tri_intersect_with_isectline+0xfb1>
jmp    20d6 <tri_tri_intersect_with_isectline+0xfb6>
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x160,%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    $0x128,%rsp
mov    %r9,%r12
mov    %r8,%r14
mov    %rcx,%r15
mov    %rdx,%r13
mov    %rsi,%rbx
mov    %rdi,%rbp
movss  0x4(%rsi),%xmm0
movsd  (%rdi),%xmm5
movaps %xmm5,%xmm1
shufps $0x55,%xmm5,%xmm1
movaps %xmm0,0x60(%rsp)
subss  %xmm1,%xmm0
movss  0x8(%rsi),%xmm1
movss  0x8(%rdi),%xmm8
movss  (%rsi),%xmm2
movaps %xmm2,0x70(%rsp)
movaps %xmm1,0x80(%rsp)
unpcklps %xmm1,%xmm2
movaps %xmm8,%xmm4
movlhps %xmm5,%xmm4
shufps $0xe2,%xmm5,%xmm4
subps  %xmm4,%xmm2
movaps %xmm2,%xmm4
movaps %xmm0,%xmm3
movlhps %xmm2,%xmm0
shufps $0xe2,%xmm2,%xmm0
movaps %xmm2,%xmm6
shufps $0xe1,%xmm2,%xmm6
movsd  (%rdx),%xmm13
movaps %xmm13,0x100(%rsp)
subps  %xmm5,%xmm13
movss  0x8(%rdx),%xmm7
movaps %xmm7,0x110(%rsp)
subss  %xmm8,%xmm7
shufps $0x55,%xmm2,%xmm4
movaps %xmm13,%xmm2
shufps $0x55,%xmm13,%xmm2
mulss  %xmm4,%xmm2
mulss  %xmm7,%xmm3
subss  %xmm2,%xmm3
movss  %xmm3,0x54(%rsp)
unpcklps %xmm13,%xmm7
mulps  %xmm0,%xmm7
mulps  %xmm6,%xmm13
subps  %xmm7,%xmm13
movaps %xmm13,%xmm1
shufps $0x55,%xmm13,%xmm1
movss  %xmm13,0x58(%rsp)
movss  %xmm1,0x5c(%rsp)
movsd  (%rcx),%xmm2
movsd  (%r8),%xmm12
movaps %xmm5,%xmm0
shufps $0x1,%xmm13,%xmm0
shufps $0xe2,%xmm13,%xmm0
movaps %xmm13,%xmm6
shufps $0x10,%xmm12,%xmm6
shufps $0xe2,%xmm12,%xmm6
mulps  %xmm0,%xmm6
movaps %xmm3,0xe0(%rsp)
movaps %xmm3,%xmm7
shufps $0x0,%xmm3,%xmm7
movaps %xmm12,%xmm4
unpcklps %xmm5,%xmm4
mulps  %xmm7,%xmm4
addps  %xmm6,%xmm4
movss  0x8(%r8),%xmm14
movaps %xmm14,%xmm0
unpcklps %xmm8,%xmm0
mulps  %xmm1,%xmm0
addps  %xmm4,%xmm0
movaps %xmm13,%xmm4
shufps $0x0,%xmm13,%xmm4
movaps %xmm2,%xmm11
shufps $0x55,%xmm2,%xmm11
movsd  0x4(%r9),%xmm15
movaps %xmm11,%xmm6
unpcklps %xmm15,%xmm6
mulps  %xmm4,%xmm6
movss  (%r9),%xmm10
movaps %xmm10,%xmm4
movlhps %xmm2,%xmm4
shufps $0xe2,%xmm2,%xmm4
mulps  %xmm7,%xmm4
addps  %xmm6,%xmm4
movss  0x8(%rcx),%xmm3
movaps %xmm15,%xmm7
movaps %xmm3,0xf0(%rsp)
movss  %xmm3,%xmm7
movaps %xmm1,0xd0(%rsp)
mulps  %xmm1,%xmm7
addps  %xmm4,%xmm7
movaps %xmm0,%xmm4
shufps $0x55,%xmm0,%xmm4
subss  %xmm4,%xmm0
subps  %xmm4,%xmm7
movaps %xmm0,%xmm4
xorps  0xd30(%rip),%xmm4
xorps  %xmm6,%xmm6
cmpless %xmm0,%xmm6
movaps %xmm6,%xmm9
andnps %xmm4,%xmm6
andps  %xmm0,%xmm9
orps   %xmm9,%xmm6
xorps  %xmm4,%xmm4
cvtss2sd %xmm6,%xmm4
movsd  0xd2a(%rip),%xmm1
ucomisd %xmm4,%xmm1
xorps  %xmm3,%xmm3
ja     1302 <tri_tri_intersect_with_isectline+0x1e2>
movaps %xmm0,%xmm3
xorps  %xmm0,%xmm0
cmpleps %xmm7,%xmm0
movaps %xmm7,%xmm4
movaps 0xcec(%rip),%xmm9
xorps  %xmm9,%xmm4
movaps %xmm7,%xmm6
andps  %xmm0,%xmm6
andnps %xmm4,%xmm0
orps   %xmm6,%xmm0
cvtps2pd %xmm0,%xmm4
cmpltpd 0xce0(%rip),%xmm4
shufps $0xe8,%xmm4,%xmm4
andnps %xmm7,%xmm4
movaps %xmm4,%xmm6
mulss  %xmm3,%xmm6
pshufd $0x55,%xmm4,%xmm7
movaps %xmm4,%xmm1
mulss  %xmm7,%xmm1
xor    %eax,%eax
ucomiss 0xcd5(%rip),%xmm6
jbe    1361 <tri_tri_intersect_with_isectline+0x241>
xorps  %xmm0,%xmm0
ucomiss %xmm0,%xmm1
ja     1873 <tri_tri_intersect_with_isectline+0x753>
movaps %xmm7,0x90(%rsp)
movaps %xmm1,0xa0(%rsp)
movaps %xmm6,0xb0(%rsp)
movaps %xmm4,0xc0(%rsp)
movss  %xmm3,0x50(%rsp)
subps  %xmm2,%xmm12
movaps 0xf0(%rsp),%xmm7
subss  %xmm7,%xmm14
subss  %xmm2,%xmm10
movaps %xmm7,%xmm0
movlhps %xmm11,%xmm0
shufps $0xe2,%xmm11,%xmm0
subps  %xmm0,%xmm15
movaps %xmm15,%xmm4
shufps $0x55,%xmm15,%xmm4
mulss  %xmm12,%xmm4
movaps %xmm14,%xmm0
mulss  %xmm10,%xmm0
subss  %xmm4,%xmm0
shufps $0xd4,%xmm12,%xmm14
shufps $0x52,%xmm12,%xmm14
unpcklps %xmm15,%xmm10
mulps  %xmm14,%xmm10
mulps  %xmm12,%xmm15
subps  %xmm10,%xmm15
movaps 0x70(%rsp),%xmm3
unpcklps %xmm2,%xmm3
movaps 0x60(%rsp),%xmm1
movss  %xmm1,%xmm2
movaps %xmm0,%xmm6
shufps $0x0,%xmm0,%xmm6
mulps  %xmm6,%xmm2
movaps %xmm15,%xmm4
shufps $0x55,%xmm15,%xmm4
mulps  %xmm4,%xmm3
addps  %xmm2,%xmm3
movaps 0x80(%rsp),%xmm1
unpcklps %xmm7,%xmm1
movaps %xmm15,%xmm2
shufps $0x0,%xmm15,%xmm2
mulps  %xmm2,%xmm1
addps  %xmm3,%xmm1
movaps 0x100(%rsp),%xmm3
movaps %xmm3,%xmm7
shufps $0x11,%xmm5,%xmm7
shufps $0xe2,%xmm5,%xmm7
mulps  %xmm6,%xmm7
unpcklps %xmm3,%xmm5
mulps  %xmm4,%xmm5
addps  %xmm7,%xmm5
unpcklps 0x110(%rsp),%xmm8
movaps %xmm1,%xmm6
shufps $0x55,%xmm1,%xmm6
subss  %xmm6,%xmm1
mulps  %xmm2,%xmm8
addps  %xmm5,%xmm8
subps  %xmm6,%xmm8
movaps %xmm1,%xmm2
xorps  %xmm9,%xmm2
xorps  %xmm5,%xmm5
cmpless %xmm1,%xmm5
movaps %xmm5,%xmm6
andnps %xmm2,%xmm5
andps  %xmm1,%xmm6
orps   %xmm6,%xmm5
xorps  %xmm2,%xmm2
cvtss2sd %xmm5,%xmm2
movsd  0xb91(%rip),%xmm3
ucomisd %xmm2,%xmm3
xorps  %xmm7,%xmm7
xorps  %xmm10,%xmm10
ja     14a0 <tri_tri_intersect_with_isectline+0x380>
movaps %xmm1,%xmm10
xorps  %xmm2,%xmm2
cmpleps %xmm8,%xmm2
movaps %xmm8,%xmm3
movaps %xmm9,%xmm12
xorps  %xmm9,%xmm3
movaps %xmm8,%xmm5
andps  %xmm2,%xmm5
andnps %xmm3,%xmm2
orps   %xmm5,%xmm2
cvtps2pd %xmm2,%xmm3
cmpltpd 0xb43(%rip),%xmm3
xorps  %xmm5,%xmm5
shufps $0xe8,%xmm3,%xmm3
andnps %xmm8,%xmm3
movaps %xmm3,%xmm6
mulss  %xmm10,%xmm6
pshufd $0x55,%xmm3,%xmm11
movaps %xmm3,%xmm9
mulss  %xmm11,%xmm9
ucomiss %xmm7,%xmm6
jbe    1501 <tri_tri_intersect_with_isectline+0x3e1>
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm9
ja     1873 <tri_tri_intersect_with_isectline+0x753>
movaps 0xe0(%rsp),%xmm7
movaps %xmm7,%xmm1
movaps 0xd0(%rsp),%xmm2
movlhps %xmm2,%xmm1
shufps $0xe2,%xmm2,%xmm1
movaps %xmm0,%xmm2
unpcklps %xmm15,%xmm2
mulps  %xmm1,%xmm2
movaps %xmm13,%xmm1
mulps  %xmm15,%xmm1
subps  %xmm2,%xmm1
mulss  %xmm13,%xmm4
mulss  %xmm0,%xmm7
subss  %xmm4,%xmm7
cmpleps %xmm1,%xmm5
movaps %xmm1,%xmm0
xorps  %xmm12,%xmm0
andps  %xmm5,%xmm1
andnps %xmm0,%xmm5
orps   %xmm1,%xmm5
xorps  %xmm7,%xmm12
xorps  %xmm0,%xmm0
cmpless %xmm7,%xmm0
andps  %xmm0,%xmm7
andnps %xmm12,%xmm0
pshufd $0x55,%xmm5,%xmm1
xor    %eax,%eax
ucomiss %xmm5,%xmm1
seta   %al
orps   %xmm7,%xmm0
maxss  %xmm5,%xmm1
ucomiss %xmm1,%xmm0
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 %xmm10,%xmm4
xorps  %xmm5,%xmm5
cvtss2sd %xmm11,%xmm5
cvtss2sd %xmm6,%xmm6
xorps  %xmm7,%xmm7
cvtss2sd %xmm9,%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    0x160(%rsp),%rcx
mov    %eax,(%rcx)
test   %eax,%eax
je     1643 <tri_tri_intersect_with_isectline+0x523>
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    1873 <tri_tri_intersect_with_isectline+0x753>
movss  0x80(%rsp),%xmm0
cvtss2sd %xmm0,%xmm0
movss  0x70(%rsp),%xmm1
cvtss2sd %xmm1,%xmm1
movss  0x60(%rsp),%xmm2
cvtss2sd %xmm2,%xmm2
movaps 0xc0(%rsp),%xmm3
cvtss2sd %xmm3,%xmm3
movss  0x50(%rsp),%xmm4
cvtss2sd %xmm4,%xmm4
movaps 0x90(%rsp),%xmm5
cvtss2sd %xmm5,%xmm5
movaps 0xb0(%rsp),%xmm6
cvtss2sd %xmm6,%xmm6
movaps 0xa0(%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    16ef <tri_tri_intersect_with_isectline+0x5cf>
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    171d <tri_tri_intersect_with_isectline+0x5fd>
movss  %xmm5,0x40(%rsp)
movss  %xmm4,0x44(%rsp)
movaps %xmm4,%xmm3
movaps %xmm5,%xmm7
ucomiss %xmm0,%xmm7
ja     1873 <tri_tri_intersect_with_isectline+0x753>
ucomiss %xmm3,%xmm6
ja     1873 <tri_tri_intersect_with_isectline+0x753>
mov    0x170(%rsp),%rax
mov    0x168(%rsp),%rcx
ucomiss %xmm7,%xmm6
jbe    1773 <tri_tri_intersect_with_isectline+0x653>
ucomiss %xmm2,%xmm1
jbe    179f <tri_tri_intersect_with_isectline+0x67f>
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     17c8 <tri_tri_intersect_with_isectline+0x6a8>
jmp    1814 <tri_tri_intersect_with_isectline+0x6f4>
ucomiss %xmm5,%xmm4
jbe    17ea <tri_tri_intersect_with_isectline+0x6ca>
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    17cd <tri_tri_intersect_with_isectline+0x6ad>
jmp    180f <tri_tri_intersect_with_isectline+0x6ef>
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    184e <tri_tri_intersect_with_isectline+0x72e>
ucomiss %xmm5,%xmm4
jbe    1831 <tri_tri_intersect_with_isectline+0x711>
movss  0x1c(%rsp),%xmm0
movss  %xmm0,(%rax)
movss  0x20(%rsp),%xmm0
movss  %xmm0,0x4(%rax)
movss  0x24(%rsp),%xmm0
jmp    1869 <tri_tri_intersect_with_isectline+0x749>
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    1831 <tri_tri_intersect_with_isectline+0x711>
ucomiss %xmm2,%xmm1
jbe    184e <tri_tri_intersect_with_isectline+0x72e>
movss  0x34(%rsp),%xmm0
movss  %xmm0,(%rax)
movss  0x38(%rsp),%xmm0
movss  %xmm0,0x4(%rax)
movss  0x3c(%rsp),%xmm0
jmp    1869 <tri_tri_intersect_with_isectline+0x749>
movss  0x10(%rsp),%xmm0
movss  %xmm0,(%rax)
movss  0x14(%rsp),%xmm0
movss  %xmm0,0x4(%rax)
movss  0x18(%rsp),%xmm0
jmp    1869 <tri_tri_intersect_with_isectline+0x749>
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    $0x128,%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 = fcmp oge float %222, 0.000000e+00
br i1 %223, label %224, label %226
224: ; preds = %9
%225 = load float, float* %26
br label %229
226: ; preds = %9
%227 = load float, float* %26
%228 = fneg float %227
br label %229
229: ; preds = %226, %224
%230 = phi float [ %225, %224 ], [ %228, %226 ]
%231 = fpext float %230 to double
%232 = fcmp olt double %231, 0x3EB0C6F7A0B5ED8D
br i1 %232, label %233, label %234
233: ; preds = %229
store float 0.000000e+00, float* %26
br label %234
234: ; preds = %233, %229
%235 = load float, float* %27
%236 = fcmp oge float %235, 0.000000e+00
br i1 %236, label %237, label %239
237: ; preds = %234
%238 = load float, float* %27
br label %242
239: ; preds = %234
%240 = load float, float* %27
%241 = fneg float %240
br label %242
242: ; preds = %239, %237
%243 = phi float [ %238, %237 ], [ %241, %239 ]
%244 = fpext float %243 to double
%245 = fcmp olt double %244, 0x3EB0C6F7A0B5ED8D
br i1 %245, label %246, label %247
246: ; preds = %242
store float 0.000000e+00, float* %27
br label %247
247: ; preds = %246, %242
%248 = load float, float* %28
%249 = fcmp oge float %248, 0.000000e+00
br i1 %249, label %250, label %252
250: ; preds = %247
%251 = load float, float* %28
br label %255
252: ; preds = %247
%253 = load float, float* %28
%254 = fneg float %253
br label %255
255: ; preds = %252, %250
%256 = phi float [ %251, %250 ], [ %254, %252 ]
%257 = fpext float %256 to double
%258 = fcmp olt double %257, 0x3EB0C6F7A0B5ED8D
br i1 %258, label %259, label %260
259: ; preds = %255
store float 0.000000e+00, float* %28
br label %260
260: ; preds = %259, %255
%261 = load float, float* %26
%262 = load float, float* %27
%263 = fmul float %261, %262
store float %263, float* %39
%264 = load float, float* %26
%265 = load float, float* %28
%266 = fmul float %264, %265
store float %266, float* %40
%267 = load float, float* %39
%268 = fcmp ogt float %267, 0.000000e+00
br i1 %268, label %269, label %273
269: ; preds = %260
%270 = load float, float* %40
%271 = fcmp ogt float %270, 0.000000e+00
br i1 %271, label %272, label %273
272: ; preds = %269
store i32 0, i32* %10
br label %906
273: ; preds = %269, %260
%274 = load float*, float** %15
%275 = getelementptr inbounds float, float* %274, i64 0
%276 = load float, float* %275
%277 = load float*, float** %14
%278 = getelementptr inbounds float, float* %277, i64 0
%279 = load float, float* %278
%280 = fsub float %276, %279
%281 = getelementptr inbounds [3 x float], [3 x float]* %20, i64 0, i64 0
store float %280, float* %281
%282 = load float*, float** %15
%283 = getelementptr inbounds float, float* %282, i64 1
%284 = load float, float* %283
%285 = load float*, float** %14
%286 = getelementptr inbounds float, float* %285, i64 1
%287 = load float, float* %286
%288 = fsub float %284, %287
%289 = getelementptr inbounds [3 x float], [3 x float]* %20, i64 0, i64 1
store float %288, float* %289
%290 = load float*, float** %15
%291 = getelementptr inbounds float, float* %290, i64 2
%292 = load float, float* %291
%293 = load float*, float** %14
%294 = getelementptr inbounds float, float* %293, i64 2
%295 = load float, float* %294
%296 = fsub float %292, %295
%297 = getelementptr inbounds [3 x float], [3 x float]* %20, i64 0, i64 2
store float %296, float* %297
%298 = load float*, float** %16
%299 = getelementptr inbounds float, float* %298, i64 0
%300 = load float, float* %299
%301 = load float*, float** %14
%302 = getelementptr inbounds float, float* %301, i64 0
%303 = load float, float* %302
%304 = fsub float %300, %303
%305 = getelementptr inbounds [3 x float], [3 x float]* %21, i64 0, i64 0
store float %304, float* %305
%306 = load float*, float** %16
%307 = getelementptr inbounds float, float* %306, i64 1
%308 = load float, float* %307
%309 = load float*, float** %14
%310 = getelementptr inbounds float, float* %309, i64 1
%311 = load float, float* %310
%312 = fsub float %308, %311
%313 = getelementptr inbounds [3 x float], [3 x float]* %21, i64 0, i64 1
store float %312, float* %313
%314 = load float*, float** %16
%315 = getelementptr inbounds float, float* %314, i64 2
%316 = load float, float* %315
%317 = load float*, float** %14
%318 = getelementptr inbounds float, float* %317, i64 2
%319 = load float, float* %318
%320 = fsub float %316, %319
%321 = getelementptr inbounds [3 x float], [3 x float]* %21, i64 0, i64 2
store float %320, float* %321
%322 = getelementptr inbounds [3 x float], [3 x float]* %20, i64 0, i64 1
%323 = load float, float* %322
%324 = getelementptr inbounds [3 x float], [3 x float]* %21, i64 0, i64 2
%325 = load float, float* %324
%326 = getelementptr inbounds [3 x float], [3 x float]* %20, i64 0, i64 2
%327 = load float, float* %326
%328 = getelementptr inbounds [3 x float], [3 x float]* %21, i64 0, i64 1
%329 = load float, float* %328
%330 = fmul float %327, %329
%331 = fneg float %330
%332 = call float @llvm.fmuladd.f32(float %323, float %325, float %331)
%333 = getelementptr inbounds [3 x float], [3 x float]* %23, i64 0, i64 0
store float %332, float* %333
%334 = getelementptr inbounds [3 x float], [3 x float]* %20, i64 0, i64 2
%335 = load float, float* %334
%336 = getelementptr inbounds [3 x float], [3 x float]* %21, i64 0, i64 0
%337 = load float, float* %336
%338 = getelementptr inbounds [3 x float], [3 x float]* %20, i64 0, i64 0
%339 = load float, float* %338
%340 = getelementptr inbounds [3 x float], [3 x float]* %21, i64 0, i64 2
%341 = load float, float* %340
%342 = fmul float %339, %341
%343 = fneg float %342
%344 = call float @llvm.fmuladd.f32(float %335, float %337, float %343)
%345 = getelementptr inbounds [3 x float], [3 x float]* %23, i64 0, i64 1
store float %344, float* %345
%346 = getelementptr inbounds [3 x float], [3 x float]* %20, i64 0, i64 0
%347 = load float, float* %346
%348 = getelementptr inbounds [3 x float], [3 x float]* %21, i64 0, i64 1
%349 = load float, float* %348
%350 = getelementptr inbounds [3 x float], [3 x float]* %20, i64 0, i64 1
%351 = load float, float* %350
%352 = getelementptr inbounds [3 x float], [3 x float]* %21, i64 0, i64 0
%353 = load float, float* %352
%354 = fmul float %351, %353
%355 = fneg float %354
%356 = call float @llvm.fmuladd.f32(float %347, float %349, float %355)
%357 = getelementptr inbounds [3 x float], [3 x float]* %23, i64 0, i64 2
store float %356, float* %357
%358 = getelementptr inbounds [3 x float], [3 x float]* %23, i64 0, i64 0
%359 = load float, float* %358
%360 = load float*, float** %14
%361 = getelementptr inbounds float, float* %360, i64 0
%362 = load float, float* %361
%363 = getelementptr inbounds [3 x float], [3 x float]* %23, i64 0, i64 1
%364 = load float, float* %363
%365 = load float*, float** %14
%366 = getelementptr inbounds float, float* %365, i64 1
%367 = load float, float* %366
%368 = fmul float %364, %367
%369 = call float @llvm.fmuladd.f32(float %359, float %362, float %368)
%370 = getelementptr inbounds [3 x float], [3 x float]* %23, i64 0, i64 2
%371 = load float, float* %370
%372 = load float*, float** %14
%373 = getelementptr inbounds float, float* %372, i64 2
%374 = load float, float* %373
%375 = call float @llvm.fmuladd.f32(float %371, float %374, float %369)
%376 = fneg float %375
store float %376, float* %25
%377 = getelementptr inbounds [3 x float], [3 x float]* %23, i64 0, i64 0
%378 = load float, float* %377
%379 = load float*, float** %11
%380 = getelementptr inbounds float, float* %379, i64 0
%381 = load float, float* %380
%382 = getelementptr inbounds [3 x float], [3 x float]* %23, i64 0, i64 1
%383 = load float, float* %382
%384 = load float*, float** %11
%385 = getelementptr inbounds float, float* %384, i64 1
%386 = load float, float* %385
%387 = fmul float %383, %386
%388 = call float @llvm.fmuladd.f32(float %378, float %381, float %387)
%389 = getelementptr inbounds [3 x float], [3 x float]* %23, i64 0, i64 2
%390 = load float, float* %389
%391 = load float*, float** %11
%392 = getelementptr inbounds float, float* %391, i64 2
%393 = load float, float* %392
%394 = call float @llvm.fmuladd.f32(float %390, float %393, float %388)
%395 = load float, float* %25
%396 = fadd float %394, %395
store float %396, float* %29
%397 = getelementptr inbounds [3 x float], [3 x float]* %23, i64 0, i64 0
%398 = load float, float* %397
%399 = load float*, float** %12
%400 = getelementptr inbounds float, float* %399, i64 0
%401 = load float, float* %400
%402 = getelementptr inbounds [3 x float], [3 x float]* %23, i64 0, i64 1
%403 = load float, float* %402
%404 = load float*, float** %12
%405 = getelementptr inbounds float, float* %404, i64 1
%406 = load float, float* %405
%407 = fmul float %403, %406
%408 = call float @llvm.fmuladd.f32(float %398, float %401, float %407)
%409 = getelementptr inbounds [3 x float], [3 x float]* %23, i64 0, i64 2
%410 = load float, float* %409
%411 = load float*, float** %12
%412 = getelementptr inbounds float, float* %411, i64 2
%413 = load float, float* %412
%414 = call float @llvm.fmuladd.f32(float %410, float %413, float %408)
%415 = load float, float* %25
%416 = fadd float %414, %415
store float %416, float* %30
%417 = getelementptr inbounds [3 x float], [3 x float]* %23, i64 0, i64 0
%418 = load float, float* %417
%419 = load float*, float** %13
%420 = getelementptr inbounds float, float* %419, i64 0
%421 = load float, float* %420
%422 = getelementptr inbounds [3 x float], [3 x float]* %23, i64 0, i64 1
%423 = load float, float* %422
%424 = load float*, float** %13
%425 = getelementptr inbounds float, float* %424, i64 1
%426 = load float, float* %425
%427 = fmul float %423, %426
%428 = call float @llvm.fmuladd.f32(float %418, float %421, float %427)
%429 = getelementptr inbounds [3 x float], [3 x float]* %23, i64 0, i64 2
%430 = load float, float* %429
%431 = load float*, float** %13
%432 = getelementptr inbounds float, float* %431, i64 2
%433 = load float, float* %432
%434 = call float @llvm.fmuladd.f32(float %430, float %433, float %428)
%435 = load float, float* %25
%436 = fadd float %434, %435
store float %436, float* %31
%437 = load float, float* %29
%438 = fcmp oge float %437, 0.000000e+00
br i1 %438, label %439, label %441
439: ; preds = %273
%440 = load float, float* %29
br label %444
441: ; preds = %273
%442 = load float, float* %29
%443 = fneg float %442
br label %444
444: ; preds = %441, %439
%445 = phi float [ %440, %439 ], [ %443, %441 ]
%446 = fpext float %445 to double
%447 = fcmp olt double %446, 0x3EB0C6F7A0B5ED8D
br i1 %447, label %448, label %449
448: ; preds = %444
store float 0.000000e+00, float* %29
br label %449
449: ; preds = %448, %444
%450 = load float, float* %30
%451 = fcmp oge float %450, 0.000000e+00
br i1 %451, label %452, label %454
452: ; preds = %449
%453 = load float, float* %30
br label %457
454: ; preds = %449
%455 = load float, float* %30
%456 = fneg float %455
br label %457
457: ; preds = %454, %452
%458 = phi float [ %453, %452 ], [ %456, %454 ]
%459 = fpext float %458 to double
%460 = fcmp olt double %459, 0x3EB0C6F7A0B5ED8D
br i1 %460, label %461, label %462
461: ; preds = %457
store float 0.000000e+00, float* %30
br label %462
462: ; preds = %461, %457
%463 = load float, float* %31
%464 = fcmp oge float %463, 0.000000e+00
br i1 %464, label %465, label %467
465: ; preds = %462
%466 = load float, float* %31
br label %470
467: ; preds = %462
%468 = load float, float* %31
%469 = fneg float %468
br label %470
470: ; preds = %467, %465
%471 = phi float [ %466, %465 ], [ %469, %467 ]
%472 = fpext float %471 to double
%473 = fcmp olt double %472, 0x3EB0C6F7A0B5ED8D
br i1 %473, label %474, label %475
474: ; preds = %470
store float 0.000000e+00, float* %31
br label %475
475: ; preds = %474, %470
%476 = load float, float* %29
%477 = load float, float* %30
%478 = fmul float %476, %477
store float %478, float* %41
%479 = load float, float* %29
%480 = load float, float* %31
%481 = fmul float %479, %480
store float %481, float* %42
%482 = load float, float* %41
%483 = fcmp ogt float %482, 0.000000e+00
br i1 %483, label %484, label %488
484: ; preds = %475
%485 = load float, float* %42
%486 = fcmp ogt float %485, 0.000000e+00
br i1 %486, label %487, label %488
487: ; preds = %484
store i32 0, i32* %10
br label %906
488: ; preds = %484, %475
%489 = getelementptr inbounds [3 x float], [3 x float]* %22, i64 0, i64 1
%490 = load float, float* %489
%491 = getelementptr inbounds [3 x float], [3 x float]* %23, i64 0, i64 2
%492 = load float, float* %491
%493 = getelementptr inbounds [3 x float], [3 x float]* %22, i64 0, i64 2
%494 = load float, float* %493
%495 = getelementptr inbounds [3 x float], [3 x float]* %23, i64 0, i64 1
%496 = load float, float* %495
%497 = fmul float %494, %496
%498 = fneg float %497
%499 = call float @llvm.fmuladd.f32(float %490, float %492, float %498)
%500 = getelementptr inbounds [3 x float], [3 x float]* %32, i64 0, i64 0
store float %499, float* %500
%501 = getelementptr inbounds [3 x float], [3 x float]* %22, i64 0, i64 2
%502 = load float, float* %501
%503 = getelementptr inbounds [3 x float], [3 x float]* %23, i64 0, i64 0
%504 = load float, float* %503
%505 = getelementptr inbounds [3 x float], [3 x float]* %22, i64 0, i64 0
%506 = load float, float* %505
%507 = getelementptr inbounds [3 x float], [3 x float]* %23, i64 0, i64 2
%508 = load float, float* %507
%509 = fmul float %506, %508
%510 = fneg float %509
%511 = call float @llvm.fmuladd.f32(float %502, float %504, float %510)
%512 = getelementptr inbounds [3 x float], [3 x float]* %32, i64 0, i64 1
store float %511, float* %512
%513 = getelementptr inbounds [3 x float], [3 x float]* %22, i64 0, i64 0
%514 = load float, float* %513
%515 = getelementptr inbounds [3 x float], [3 x float]* %23, i64 0, i64 1
%516 = load float, float* %515
%517 = getelementptr inbounds [3 x float], [3 x float]* %22, i64 0, i64 1
%518 = load float, float* %517
%519 = getelementptr inbounds [3 x float], [3 x float]* %23, i64 0, i64 0
%520 = load float, float* %519
%521 = fmul float %518, %520
%522 = fneg float %521
%523 = call float @llvm.fmuladd.f32(float %514, float %516, float %522)
%524 = getelementptr inbounds [3 x float], [3 x float]* %32, i64 0, i64 2
store float %523, float* %524
%525 = getelementptr inbounds [3 x float], [3 x float]* %32, i64 0, i64 0
%526 = load float, float* %525
%527 = fcmp oge float %526, 0.000000e+00
br i1 %527, label %528, label %531
528: ; preds = %488
%529 = getelementptr inbounds [3 x float], [3 x float]* %32, i64 0, i64 0
%530 = load float, float* %529
br label %535
531: ; preds = %488
%532 = getelementptr inbounds [3 x float], [3 x float]* %32, i64 0, i64 0
%533 = load float, float* %532
%534 = fneg float %533
br label %535
535: ; preds = %531, %528
%536 = phi float [ %530, %528 ], [ %534, %531 ]
store float %536, float* %52
store i16 0, i16* %43
%537 = getelementptr inbounds [3 x float], [3 x float]* %32, i64 0, i64 1
%538 = load float, float* %537
%539 = fcmp oge float %538, 0.000000e+00
br i1 %539, label %540, label %543
540: ; preds = %535
%541 = getelementptr inbounds [3 x float], [3 x float]* %32, i64 0, i64 1
%542 = load float, float* %541
br label %547
543: ; preds = %535
%544 = getelementptr inbounds [3 x float], [3 x float]* %32, i64 0, i64 1
%545 = load float, float* %544
%546 = fneg float %545
br label %547
547: ; preds = %543, %540
%548 = phi float [ %542, %540 ], [ %546, %543 ]
store float %548, float* %50
%549 = getelementptr inbounds [3 x float], [3 x float]* %32, i64 0, i64 2
%550 = load float, float* %549
%551 = fcmp oge float %550, 0.000000e+00
br i1 %551, label %552, label %555
552: ; preds = %547
%553 = getelementptr inbounds [3 x float], [3 x float]* %32, i64 0, i64 2
%554 = load float, float* %553
br label %559
555: ; preds = %547
%556 = getelementptr inbounds [3 x float], [3 x float]* %32, i64 0, i64 2
%557 = load float, float* %556
%558 = fneg float %557
br label %559
559: ; preds = %555, %552
%560 = phi float [ %554, %552 ], [ %558, %555 ]
store float %560, float* %51
%561 = load float, float* %50
%562 = load float, float* %52
%563 = fcmp ogt float %561, %562
br i1 %563, label %564, label %566
564: ; preds = %559
%565 = load float, float* %50
store float %565, float* %52
store i16 1, i16* %43
br label %566
566: ; preds = %564, %559
%567 = load float, float* %51
%568 = load float, float* %52
%569 = fcmp ogt float %567, %568
br i1 %569, label %570, label %572
570: ; preds = %566
%571 = load float, float* %51
store float %571, float* %52
store i16 2, i16* %43
br label %572
572: ; preds = %570, %566
%573 = load float*, float** %11
%574 = load i16, i16* %43
%575 = sext i16 %574 to i64
%576 = getelementptr inbounds float, float* %573, i64 %575
%577 = load float, float* %576
store float %577, float* %44
%578 = load float*, float** %12
%579 = load i16, i16* %43
%580 = sext i16 %579 to i64
%581 = getelementptr inbounds float, float* %578, i64 %580
%582 = load float, float* %581
store float %582, float* %45
%583 = load float*, float** %13
%584 = load i16, i16* %43
%585 = sext i16 %584 to i64
%586 = getelementptr inbounds float, float* %583, i64 %585
%587 = load float, float* %586
store float %587, float* %46
%588 = load float*, float** %14
%589 = load i16, i16* %43
%590 = sext i16 %589 to i64
%591 = getelementptr inbounds float, float* %588, i64 %590
%592 = load float, float* %591
store float %592, float* %47
%593 = load float*, float** %15
%594 = load i16, i16* %43
%595 = sext i16 %594 to i64
%596 = getelementptr inbounds float, float* %593, i64 %595
%597 = load float, float* %596
store float %597, float* %48
%598 = load float*, float** %16
%599 = load i16, i16* %43
%600 = sext i16 %599 to i64
%601 = getelementptr inbounds float, float* %598, i64 %600
%602 = load float, float* %601
store float %602, float* %49
%603 = load float*, float** %11
%604 = load float*, float** %12
%605 = load float*, float** %13
%606 = load float, float* %44
%607 = fpext float %606 to double
%608 = load float, float* %45
%609 = fpext float %608 to double
%610 = load float, float* %46
%611 = fpext float %610 to double
%612 = load float, float* %29
%613 = fpext float %612 to double
%614 = load float, float* %30
%615 = fpext float %614 to double
%616 = load float, float* %31
%617 = fpext float %616 to double
%618 = load float, float* %41
%619 = fpext float %618 to double
%620 = load float, float* %42
%621 = fpext float %620 to double
%622 = getelementptr inbounds [2 x float], [2 x float]* %33, i64 0, i64 0
%623 = getelementptr inbounds [2 x float], [2 x float]* %33, i64 0, i64 1
%624 = getelementptr inbounds [3 x float], [3 x float]* %35, i64 0, i64 0
%625 = getelementptr inbounds [3 x float], [3 x float]* %36, i64 0, i64 0
%626 = 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* %603, float* %604, float* %605, double %607, double %609, double %611, double %613, double %615, double %617, double %619, double %621, float* %622, float* %623, float* %624, float* %625)
%627 = load i32*, i32** %17
store i32 %626, i32* %627
%628 = load i32*, i32** %17
%629 = load i32, i32* %628
%630 = icmp ne i32 %629, 0
br i1 %630, label %631, label %640
631: ; preds = %572
%632 = getelementptr inbounds [3 x float], [3 x float]* %22, i64 0, i64 0
%633 = load float*, float** %11
%634 = load float*, float** %12
%635 = load float*, float** %13
%636 = load float*, float** %14
%637 = load float*, float** %15
%638 = load float*, float** %16
%639 = call i32 (float*, float*, float*, float*, float*, float*, float*, ...) bitcast (i32 (...)* @coplanar_tri_tri to i32 (float*, float*, float*, float*, float*, float*, float*, ...)*)(float* %632, float* %633, float* %634, float* %635, float* %636, float* %637, float* %638)
store i32 %639, i32* %10
br label %906
640: ; preds = %572
%641 = load float*, float** %14
%642 = load float*, float** %15
%643 = load float*, float** %16
%644 = load float, float* %47
%645 = fpext float %644 to double
%646 = load float, float* %48
%647 = fpext float %646 to double
%648 = load float, float* %49
%649 = fpext float %648 to double
%650 = load float, float* %26
%651 = fpext float %650 to double
%652 = load float, float* %27
%653 = fpext float %652 to double
%654 = load float, float* %28
%655 = fpext float %654 to double
%656 = load float, float* %39
%657 = fpext float %656 to double
%658 = load float, float* %40
%659 = fpext float %658 to double
%660 = getelementptr inbounds [2 x float], [2 x float]* %34, i64 0, i64 0
%661 = getelementptr inbounds [2 x float], [2 x float]* %34, i64 0, i64 1
%662 = getelementptr inbounds [3 x float], [3 x float]* %37, i64 0, i64 0
%663 = getelementptr inbounds [3 x float], [3 x float]* %38, i64 0, i64 0
%664 = 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* %641, float* %642, float* %643, double %645, double %647, double %649, double %651, double %653, double %655, double %657, double %659, float* %660, float* %661, float* %662, float* %663)
%665 = getelementptr inbounds [2 x float], [2 x float]* %33, i64 0, i64 0
%666 = load float, float* %665
%667 = getelementptr inbounds [2 x float], [2 x float]* %33, i64 0, i64 1
%668 = load float, float* %667
%669 = fcmp ogt float %666, %668
br i1 %669, label %670, label %678
670: ; preds = %640
%671 = getelementptr inbounds [2 x float], [2 x float]* %33, i64 0, i64 0
%672 = load float, float* %671
store float %672, float* %57
%673 = getelementptr inbounds [2 x float], [2 x float]* %33, i64 0, i64 1
%674 = load float, float* %673
%675 = getelementptr inbounds [2 x float], [2 x float]* %33, i64 0, i64 0
store float %674, float* %675
%676 = load float, float* %57
%677 = getelementptr inbounds [2 x float], [2 x float]* %33, i64 0, i64 1
store float %676, float* %677
store i32 1, i32* %55
br label %679
678: ; preds = %640
store i32 0, i32* %55
br label %679
679: ; preds = %678, %670
%680 = getelementptr inbounds [2 x float], [2 x float]* %34, i64 0, i64 0
%681 = load float, float* %680
%682 = getelementptr inbounds [2 x float], [2 x float]* %34, i64 0, i64 1
%683 = load float, float* %682
%684 = fcmp ogt float %681, %683
br i1 %684, label %685, label %693
685: ; preds = %679
%686 = getelementptr inbounds [2 x float], [2 x float]* %34, i64 0, i64 0
%687 = load float, float* %686
store float %687, float* %58
%688 = getelementptr inbounds [2 x float], [2 x float]* %34, i64 0, i64 1
%689 = load float, float* %688
%690 = getelementptr inbounds [2 x float], [2 x float]* %34, i64 0, i64 0
store float %689, float* %690
%691 = load float, float* %58
%692 = getelementptr inbounds [2 x float], [2 x float]* %34, i64 0, i64 1
store float %691, float* %692
store i32 1, i32* %56
br label %694
693: ; preds = %679
store i32 0, i32* %56
br label %694
694: ; preds = %693, %685
%695 = getelementptr inbounds [2 x float], [2 x float]* %33, i64 0, i64 1
%696 = load float, float* %695
%697 = getelementptr inbounds [2 x float], [2 x float]* %34, i64 0, i64 0
%698 = load float, float* %697
%699 = fcmp olt float %696, %698
br i1 %699, label %706, label %700
700: ; preds = %694
%701 = getelementptr inbounds [2 x float], [2 x float]* %34, i64 0, i64 1
%702 = load float, float* %701
%703 = getelementptr inbounds [2 x float], [2 x float]* %33, i64 0, i64 0
%704 = load float, float* %703
%705 = fcmp olt float %702, %704
br i1 %705, label %706, label %707
706: ; preds = %700, %694
store i32 0, i32* %10
br label %906
707: ; preds = %700
%708 = getelementptr inbounds [2 x float], [2 x float]* %34, i64 0, i64 0
%709 = load float, float* %708
%710 = getelementptr inbounds [2 x float], [2 x float]* %33, i64 0, i64 0
%711 = load float, float* %710
%712 = fcmp olt float %709, %711
br i1 %712, label %713, label %809
713: ; preds = %707
%714 = load i32, i32* %55
%715 = icmp eq i32 %714, 0
br i1 %715, label %716, label %729
716: ; preds = %713
%717 = getelementptr inbounds [3 x float], [3 x float]* %35, i64 0, i64 0
%718 = load float, float* %717
%719 = load float*, float** %18
%720 = getelementptr inbounds float, float* %719, i64 0
store float %718, float* %720
%721 = getelementptr inbounds [3 x float], [3 x float]* %35, i64 0, i64 1
%722 = load float, float* %721
%723 = load float*, float** %18
%724 = getelementptr inbounds float, float* %723, i64 1
store float %722, float* %724
%725 = getelementptr inbounds [3 x float], [3 x float]* %35, i64 0, i64 2
%726 = load float, float* %725
%727 = load float*, float** %18
%728 = getelementptr inbounds float, float* %727, i64 2
store float %726, float* %728
br label %742
729: ; preds = %713
%730 = getelementptr inbounds [3 x float], [3 x float]* %36, i64 0, i64 0
%731 = load float, float* %730
%732 = load float*, float** %18
%733 = getelementptr inbounds float, float* %732, i64 0
store float %731, float* %733
%734 = getelementptr inbounds [3 x float], [3 x float]* %36, i64 0, i64 1
%735 = load float, float* %734
%736 = load float*, float** %18
%737 = getelementptr inbounds float, float* %736, i64 1
store float %735, float* %737
%738 = getelementptr inbounds [3 x float], [3 x float]* %36, i64 0, i64 2
%739 = load float, float* %738
%740 = load float*, float** %18
%741 = getelementptr inbounds float, float* %740, i64 2
store float %739, float* %741
br label %742
742: ; preds = %729, %716
%743 = getelementptr inbounds [2 x float], [2 x float]* %34, i64 0, i64 1
%744 = load float, float* %743
%745 = getelementptr inbounds [2 x float], [2 x float]* %33, i64 0, i64 1
%746 = load float, float* %745
%747 = fcmp olt float %744, %746
br i1 %747, label %748, label %778
748: ; preds = %742
%749 = load i32, i32* %56
%750 = icmp eq i32 %749, 0
br i1 %750, label %751, label %764
751: ; preds = %748
%752 = getelementptr inbounds [3 x float], [3 x float]* %38, i64 0, i64 0
%753 = load float, float* %752
%754 = load float*, float** %19
%755 = getelementptr inbounds float, float* %754, i64 0
store float %753, float* %755
%756 = getelementptr inbounds [3 x float], [3 x float]* %38, i64 0, i64 1
%757 = load float, float* %756
%758 = load float*, float** %19
%759 = getelementptr inbounds float, float* %758, i64 1
store float %757, float* %759
%760 = getelementptr inbounds [3 x float], [3 x float]* %38, i64 0, i64 2
%761 = load float, float* %760
%762 = load float*, float** %19
%763 = getelementptr inbounds float, float* %762, i64 2
store float %761, float* %763
br label %777
764: ; preds = %748
%765 = getelementptr inbounds [3 x float], [3 x float]* %37, i64 0, i64 0
%766 = load float, float* %765
%767 = load float*, float** %19
%768 = getelementptr inbounds float, float* %767, i64 0
store float %766, float* %768
%769 = getelementptr inbounds [3 x float], [3 x float]* %37, i64 0, i64 1
%770 = load float, float* %769
%771 = load float*, float** %19
%772 = getelementptr inbounds float, float* %771, i64 1
store float %770, float* %772
%773 = getelementptr inbounds [3 x float], [3 x float]* %37, i64 0, i64 2
%774 = load float, float* %773
%775 = load float*, float** %19
%776 = getelementptr inbounds float, float* %775, i64 2
store float %774, float* %776
br label %777
777: ; preds = %764, %751
br label %808
778: ; preds = %742
%779 = load i32, i32* %55
%780 = icmp eq i32 %779, 0
br i1 %780, label %781, label %794
781: ; preds = %778
%782 = getelementptr inbounds [3 x float], [3 x float]* %36, i64 0, i64 0
%783 = load float, float* %782
%784 = load float*, float** %19
%785 = getelementptr inbounds float, float* %784, i64 0
store float %783, float* %785
%786 = getelementptr inbounds [3 x float], [3 x float]* %36, i64 0, i64 1
%787 = load float, float* %786
%788 = load float*, float** %19
%789 = getelementptr inbounds float, float* %788, i64 1
store float %787, float* %789
%790 = getelementptr inbounds [3 x float], [3 x float]* %36, i64 0, i64 2
%791 = load float, float* %790
%792 = load float*, float** %19
%793 = getelementptr inbounds float, float* %792, i64 2
store float %791, float* %793
br label %807
794: ; preds = %778
%795 = getelementptr inbounds [3 x float], [3 x float]* %35, i64 0, i64 0
%796 = load float, float* %795
%797 = load float*, float** %19
%798 = getelementptr inbounds float, float* %797, i64 0
store float %796, float* %798
%799 = getelementptr inbounds [3 x float], [3 x float]* %35, i64 0, i64 1
%800 = load float, float* %799
%801 = load float*, float** %19
%802 = getelementptr inbounds float, float* %801, i64 1
store float %800, float* %802
%803 = getelementptr inbounds [3 x float], [3 x float]* %35, i64 0, i64 2
%804 = load float, float* %803
%805 = load float*, float** %19
%806 = getelementptr inbounds float, float* %805, i64 2
store float %804, float* %806
br label %807
807: ; preds = %794, %781
br label %808
808: ; preds = %807, %777
br label %905
809: ; preds = %707
%810 = load i32, i32* %56
%811 = icmp eq i32 %810, 0
br i1 %811, label %812, label %825
812: ; preds = %809
%813 = getelementptr inbounds [3 x float], [3 x float]* %37, i64 0, i64 0
%814 = load float, float* %813
%815 = load float*, float** %18
%816 = getelementptr inbounds float, float* %815, i64 0
store float %814, float* %816
%817 = getelementptr inbounds [3 x float], [3 x float]* %37, i64 0, i64 1
%818 = load float, float* %817
%819 = load float*, float** %18
%820 = getelementptr inbounds float, float* %819, i64 1
store float %818, float* %820
%821 = getelementptr inbounds [3 x float], [3 x float]* %37, i64 0, i64 2
%822 = load float, float* %821
%823 = load float*, float** %18
%824 = getelementptr inbounds float, float* %823, i64 2
store float %822, float* %824
br label %838
825: ; preds = %809
%826 = getelementptr inbounds [3 x float], [3 x float]* %38, i64 0, i64 0
%827 = load float, float* %826
%828 = load float*, float** %18
%829 = getelementptr inbounds float, float* %828, i64 0
store float %827, float* %829
%830 = getelementptr inbounds [3 x float], [3 x float]* %38, i64 0, i64 1
%831 = load float, float* %830
%832 = load float*, float** %18
%833 = getelementptr inbounds float, float* %832, i64 1
store float %831, float* %833
%834 = getelementptr inbounds [3 x float], [3 x float]* %38, i64 0, i64 2
%835 = load float, float* %834
%836 = load float*, float** %18
%837 = getelementptr inbounds float, float* %836, i64 2
store float %835, float* %837
br label %838
838: ; preds = %825, %812
%839 = getelementptr inbounds [2 x float], [2 x float]* %34, i64 0, i64 1
%840 = load float, float* %839
%841 = getelementptr inbounds [2 x float], [2 x float]* %33, i64 0, i64 1
%842 = load float, float* %841
%843 = fcmp ogt float %840, %842
br i1 %843, label %844, label %874
844: ; preds = %838
%845 = load i32, i32* %55
%846 = icmp eq i32 %845, 0
br i1 %846, label %847, label %860
847: ; preds = %844
%848 = getelementptr inbounds [3 x float], [3 x float]* %36, i64 0, i64 0
%849 = load float, float* %848
%850 = load float*, float** %19
%851 = getelementptr inbounds float, float* %850, i64 0
store float %849, float* %851
%852 = getelementptr inbounds [3 x float], [3 x float]* %36, i64 0, i64 1
%853 = load float, float* %852
%854 = load float*, float** %19
%855 = getelementptr inbounds float, float* %854, i64 1
store float %853, float* %855
%856 = getelementptr inbounds [3 x float], [3 x float]* %36, i64 0, i64 2
%857 = load float, float* %856
%858 = load float*, float** %19
%859 = getelementptr inbounds float, float* %858, i64 2
store float %857, float* %859
br label %873
860: ; preds = %844
%861 = getelementptr inbounds [3 x float], [3 x float]* %35, i64 0, i64 0
%862 = load float, float* %861
%863 = load float*, float** %19
%864 = getelementptr inbounds float, float* %863, i64 0
store float %862, float* %864
%865 = getelementptr inbounds [3 x float], [3 x float]* %35, i64 0, i64 1
%866 = load float, float* %865
%867 = load float*, float** %19
%868 = getelementptr inbounds float, float* %867, i64 1
store float %866, float* %868
%869 = getelementptr inbounds [3 x float], [3 x float]* %35, i64 0, i64 2
%870 = load float, float* %869
%871 = load float*, float** %19
%872 = getelementptr inbounds float, float* %871, i64 2
store float %870, float* %872
br label %873
873: ; preds = %860, %847
br label %904
874: ; preds = %838
%875 = load i32, i32* %56
%876 = icmp eq i32 %875, 0
br i1 %876, label %877, label %890
877: ; preds = %874
%878 = getelementptr inbounds [3 x float], [3 x float]* %38, i64 0, i64 0
%879 = load float, float* %878
%880 = load float*, float** %19
%881 = getelementptr inbounds float, float* %880, i64 0
store float %879, float* %881
%882 = getelementptr inbounds [3 x float], [3 x float]* %38, i64 0, i64 1
%883 = load float, float* %882
%884 = load float*, float** %19
%885 = getelementptr inbounds float, float* %884, i64 1
store float %883, float* %885
%886 = getelementptr inbounds [3 x float], [3 x float]* %38, i64 0, i64 2
%887 = load float, float* %886
%888 = load float*, float** %19
%889 = getelementptr inbounds float, float* %888, i64 2
store float %887, float* %889
br label %903
890: ; preds = %874
%891 = getelementptr inbounds [3 x float], [3 x float]* %37, i64 0, i64 0
%892 = load float, float* %891
%893 = load float*, float** %19
%894 = getelementptr inbounds float, float* %893, i64 0
store float %892, float* %894
%895 = getelementptr inbounds [3 x float], [3 x float]* %37, i64 0, i64 1
%896 = load float, float* %895
%897 = load float*, float** %19
%898 = getelementptr inbounds float, float* %897, i64 1
store float %896, float* %898
%899 = getelementptr inbounds [3 x float], [3 x float]* %37, i64 0, i64 2
%900 = load float, float* %899
%901 = load float*, float** %19
%902 = getelementptr inbounds float, float* %901, i64 2
store float %900, float* %902
br label %903
903: ; preds = %890, %877
br label %904
904: ; preds = %903, %873
br label %905
905: ; preds = %904, %808
store i32 1, i32* %10
br label %906
906: ; preds = %905, %706, %631, %487, %272
%907 = load i32, i32* %10
ret i32 %907
}

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