int tri_tri_intersect(float V0[3], float V1[3], float V2[3], float U0[3],
                      float U1[3], float U2[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 du0du1, du0du2, dv0dv1, dv0dv2;
  short index;
  float vp0, vp1, vp2;
  float up0, up1, up2;
  float b, c, max;
  E1[0] = V1[0] - V0[0];
  E1[1] = V1[1] - V0[1];
  E1[2] = V1[2] - V0[2];
  ;
  E2[0] = V2[0] - V0[0];
  E2[1] = V2[1] - V0[1];
  E2[2] = V2[2] - V0[2];
  ;
  N1[0] = E1[1] * E2[2] - E1[2] * E2[1];
  N1[1] = E1[2] * E2[0] - E1[0] * E2[2];
  N1[2] = E1[0] * E2[1] - E1[1] * E2[0];
  ;
  d1 = -(N1[0] * V0[0] + N1[1] * V0[1] + N1[2] * V0[2]);
  du0 = (N1[0] * U0[0] + N1[1] * U0[1] + N1[2] * U0[2]) + d1;
  du1 = (N1[0] * U1[0] + N1[1] * U1[1] + N1[2] * U1[2]) + d1;
  du2 = (N1[0] * U2[0] + N1[1] * U2[1] + N1[2] * U2[2]) + d1;
  if (fabs(du0) < 0.005)
    du0 = 0.0;
  if (fabs(du1) < 0.005)
    du1 = 0.0;
  if (fabs(du2) < 0.005)
    du2 = 0.0;
  du0du1 = du0 * du1;
  du0du2 = du0 * du2;
  if (du0du1 > 0.0f && du0du2 > 0.0f)
    return 0;
  E1[0] = U1[0] - U0[0];
  E1[1] = U1[1] - U0[1];
  E1[2] = U1[2] - U0[2];
  ;
  E2[0] = U2[0] - U0[0];
  E2[1] = U2[1] - U0[1];
  E2[2] = U2[2] - U0[2];
  ;
  N2[0] = E1[1] * E2[2] - E1[2] * E2[1];
  N2[1] = E1[2] * E2[0] - E1[0] * E2[2];
  N2[2] = E1[0] * E2[1] - E1[1] * E2[0];
  ;
  d2 = -(N2[0] * U0[0] + N2[1] * U0[1] + N2[2] * U0[2]);
  dv0 = (N2[0] * V0[0] + N2[1] * V0[1] + N2[2] * V0[2]) + d2;
  dv1 = (N2[0] * V1[0] + N2[1] * V1[1] + N2[2] * V1[2]) + d2;
  dv2 = (N2[0] * V2[0] + N2[1] * V2[1] + N2[2] * V2[2]) + d2;
  if (fabs(dv0) < 0.005)
    dv0 = 0.0;
  if (fabs(dv1) < 0.005)
    dv1 = 0.0;
  if (fabs(dv2) < 0.005)
    dv2 = 0.0;
  dv0dv1 = dv0 * dv1;
  dv0dv2 = dv0 * dv2;
  if (dv0dv1 > 0.0f && dv0dv2 > 0.0f)
    return 0;
  D[0] = N1[1] * N2[2] - N1[2] * N2[1];
  D[1] = N1[2] * N2[0] - N1[0] * N2[2];
  D[2] = N1[0] * N2[1] - N1[1] * N2[0];
  ;
  max = fabs(D[0]);
  index = 0;
  b = fabs(D[1]);
  c = fabs(D[2]);
  if (b > max)
    max = b, index = 1;
  if (c > max)
    max = c, index = 2;
  vp0 = V0[index];
  vp1 = V1[index];
  vp2 = V2[index];
  up0 = U0[index];
  up1 = U1[index];
  up2 = U2[index];
  if (dv0dv1 > 0.0f) {
    isect1[0] = vp2 + (vp0 - vp2) * dv2 / (dv2 - dv0);
    isect1[1] = vp2 + (vp1 - vp2) * dv2 / (dv2 - dv1);
    ;
  } else if (dv0dv2 > 0.0f) {
    isect1[0] = vp1 + (vp0 - vp1) * dv1 / (dv1 - dv0);
    isect1[1] = vp1 + (vp2 - vp1) * dv1 / (dv1 - dv2);
    ;
  } else if (dv1 * dv2 > 0.0f || dv0 != 0.0f) {
    isect1[0] = vp0 + (vp1 - vp0) * dv0 / (dv0 - dv1);
    isect1[1] = vp0 + (vp2 - vp0) * dv0 / (dv0 - dv2);
    ;
  } else if (dv1 != 0.0f) {
    isect1[0] = vp1 + (vp0 - vp1) * dv1 / (dv1 - dv0);
    isect1[1] = vp1 + (vp2 - vp1) * dv1 / (dv1 - dv2);
    ;
  } else if (dv2 != 0.0f) {
    isect1[0] = vp2 + (vp0 - vp2) * dv2 / (dv2 - dv0);
    isect1[1] = vp2 + (vp1 - vp2) * dv2 / (dv2 - dv1);
    ;
  } else {
    return coplanar_tri_tri(N1, V0, V1, V2, U0, U1, U2);
  };
  if (du0du1 > 0.0f) {
    isect2[0] = up2 + (up0 - up2) * du2 / (du2 - du0);
    isect2[1] = up2 + (up1 - up2) * du2 / (du2 - du1);
    ;
  } else if (du0du2 > 0.0f) {
    isect2[0] = up1 + (up0 - up1) * du1 / (du1 - du0);
    isect2[1] = up1 + (up2 - up1) * du1 / (du1 - du2);
    ;
  } else if (du1 * du2 > 0.0f || du0 != 0.0f) {
    isect2[0] = up0 + (up1 - up0) * du0 / (du0 - du1);
    isect2[1] = up0 + (up2 - up0) * du0 / (du0 - du2);
    ;
  } else if (du1 != 0.0f) {
    isect2[0] = up1 + (up0 - up1) * du1 / (du1 - du0);
    isect2[1] = up1 + (up2 - up1) * du1 / (du1 - du2);
    ;
  } else if (du2 != 0.0f) {
    isect2[0] = up2 + (up0 - up2) * du2 / (du2 - du0);
    isect2[1] = up2 + (up1 - up2) * du2 / (du2 - du1);
    ;
  } else {
    return coplanar_tri_tri(N1, V0, V1, V2, U0, U1, U2);
  };
  if (isect1[0] > isect1[1]) {
    float c;
    c = isect1[0];
    isect1[0] = isect1[1];
    isect1[1] = c;
  };
  if (isect2[0] > isect2[1]) {
    float c;
    c = isect2[0];
    isect2[0] = isect2[1];
    isect2[1] = c;
  };
  if (isect1[1] < isect2[0] || isect2[1] < isect1[0])
    return 0;
  return 1;
}


x86 assembly (clang, -O0):
<tri_tri_intersect>:
push   %rbp
mov    %rsp,%rbp
sub    $0xf0,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
mov    %r9,-0x38(%rbp)
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
subss  (%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x10(%rbp),%rax
subss  0x4(%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
subss  0x8(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
subss  (%rax),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x10(%rbp),%rax
subss  0x4(%rax),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
subss  0x8(%rax),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x40(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x3c(%rbp),%xmm1
mulss  -0x4c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  -0x48(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x44(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  -0x50(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x5c(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x58(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x4(%rax),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x54(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x5c(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x58(%rbp),%xmm0
mov    -0x28(%rbp),%rax
mulss  0x4(%rax),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x54(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
addss  -0x6c(%rbp),%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x5c(%rbp),%xmm1
mov    -0x30(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x58(%rbp),%xmm0
mov    -0x30(%rbp),%rax
mulss  0x4(%rax),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x54(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
addss  -0x6c(%rbp),%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x5c(%rbp),%xmm1
mov    -0x38(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x58(%rbp),%xmm0
mov    -0x38(%rbp),%rax
mulss  0x4(%rax),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x54(%rbp),%xmm0
mov    -0x38(%rbp),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
addss  -0x6c(%rbp),%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x74(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movaps 0x1ca9(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0x1c8d(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1385 <tri_tri_intersect+0x275>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x78(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movaps 0x1c7b(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0x1c5f(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    13b3 <tri_tri_intersect+0x2a3>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x7c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movaps 0x1c4d(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0x1c31(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    13e1 <tri_tri_intersect+0x2d1>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x74(%rbp),%xmm0
mulss  -0x78(%rbp),%xmm0
movss  %xmm0,-0xa8(%rbp)
ff
movss  -0x74(%rbp),%xmm0
mulss  -0x7c(%rbp),%xmm0
movss  %xmm0,-0xac(%rbp)
ff
movss  -0xa8(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    1439 <tri_tri_intersect+0x329>
movss  -0xac(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    1439 <tri_tri_intersect+0x329>
movl   $0x0,-0x4(%rbp)
jmp    2093 <tri_tri_intersect+0xf83>
mov    -0x30(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x28(%rbp),%rax
subss  (%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x30(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x28(%rbp),%rax
subss  0x4(%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x30(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x28(%rbp),%rax
subss  0x8(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x38(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x28(%rbp),%rax
subss  (%rax),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x38(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x28(%rbp),%rax
subss  0x4(%rax),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x38(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x28(%rbp),%rax
subss  0x8(%rax),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x40(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x3c(%rbp),%xmm1
mulss  -0x4c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  -0x48(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x44(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  -0x50(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x68(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x64(%rbp),%xmm0
mov    -0x28(%rbp),%rax
mulss  0x4(%rax),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x60(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x68(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x64(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x4(%rax),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x60(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
addss  -0x70(%rbp),%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x68(%rbp),%xmm1
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x64(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mulss  0x4(%rax),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x60(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
addss  -0x70(%rbp),%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x68(%rbp),%xmm1
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x64(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mulss  0x4(%rax),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x60(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
addss  -0x70(%rbp),%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x80(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movaps 0x199d(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0x1981(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1691 <tri_tri_intersect+0x581>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x84(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
movaps 0x196c(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0x1950(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    16c5 <tri_tri_intersect+0x5b5>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x88(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
movaps 0x1938(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  0x191c(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    16f9 <tri_tri_intersect+0x5e9>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x80(%rbp),%xmm0
mulss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0xb0(%rbp)
ff
movss  -0x80(%rbp),%xmm0
mulss  -0x88(%rbp),%xmm0
ff
movss  %xmm0,-0xb4(%rbp)
ff
movss  -0xb0(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    1757 <tri_tri_intersect+0x647>
movss  -0xb4(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    1757 <tri_tri_intersect+0x647>
movl   $0x0,-0x4(%rbp)
jmp    2093 <tri_tri_intersect+0xf83>
movss  -0x58(%rbp),%xmm0
movss  -0x60(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  -0x64(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x94(%rbp)
ff
movss  -0x54(%rbp),%xmm0
movss  -0x68(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  -0x60(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x90(%rbp)
ff
movss  -0x5c(%rbp),%xmm0
movss  -0x64(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  -0x68(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
movss  -0x94(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movaps 0x1813(%rip),%xmm1
pand   %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0xdc(%rbp)
ff
movw   $0x0,-0xb6(%rbp)
movss  -0x90(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movaps 0x17e7(%rip),%xmm1
pand   %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0xd4(%rbp)
ff
movss  -0x8c(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movaps 0x17c4(%rip),%xmm1
pand   %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0xd8(%rbp)
ff
movss  -0xd4(%rbp),%xmm0
ff
ucomiss -0xdc(%rbp),%xmm0
jbe    188a <tri_tri_intersect+0x77a>
movss  -0xd4(%rbp),%xmm0
ff
movss  %xmm0,-0xdc(%rbp)
ff
movw   $0x1,-0xb6(%rbp)
movss  -0xd8(%rbp),%xmm0
ff
ucomiss -0xdc(%rbp),%xmm0
jbe    18b8 <tri_tri_intersect+0x7a8>
movss  -0xd8(%rbp),%xmm0
ff
movss  %xmm0,-0xdc(%rbp)
ff
movw   $0x2,-0xb6(%rbp)
mov    -0x10(%rbp),%rax
movswq -0xb6(%rbp),%rcx
ff
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xbc(%rbp)
ff
mov    -0x18(%rbp),%rax
movswq -0xb6(%rbp),%rcx
ff
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xc0(%rbp)
ff
mov    -0x20(%rbp),%rax
movswq -0xb6(%rbp),%rcx
ff
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xc4(%rbp)
ff
mov    -0x28(%rbp),%rax
movswq -0xb6(%rbp),%rcx
ff
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xc8(%rbp)
ff
mov    -0x30(%rbp),%rax
movswq -0xb6(%rbp),%rcx
ff
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xcc(%rbp)
ff
mov    -0x38(%rbp),%rax
movswq -0xb6(%rbp),%rcx
ff
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xd0(%rbp)
ff
movss  -0xb0(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    19e4 <tri_tri_intersect+0x8d4>
movss  -0xc4(%rbp),%xmm0
ff
movss  -0xbc(%rbp),%xmm1
ff
subss  -0xc4(%rbp),%xmm1
ff
mulss  -0x88(%rbp),%xmm1
ff
movss  -0x88(%rbp),%xmm2
ff
subss  -0x80(%rbp),%xmm2
divss  %xmm2,%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
movss  -0xc4(%rbp),%xmm0
ff
movss  -0xc0(%rbp),%xmm1
ff
subss  -0xc4(%rbp),%xmm1
ff
mulss  -0x88(%rbp),%xmm1
ff
movss  -0x88(%rbp),%xmm2
ff
subss  -0x84(%rbp),%xmm2
ff
divss  %xmm2,%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,-0x98(%rbp)
ff
jmp    1cb0 <tri_tri_intersect+0xba0>
movss  -0xb4(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    1a7a <tri_tri_intersect+0x96a>
movss  -0xc0(%rbp),%xmm0
ff
movss  -0xbc(%rbp),%xmm1
ff
subss  -0xc0(%rbp),%xmm1
ff
mulss  -0x84(%rbp),%xmm1
ff
movss  -0x84(%rbp),%xmm2
ff
subss  -0x80(%rbp),%xmm2
divss  %xmm2,%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
movss  -0xc0(%rbp),%xmm0
ff
movss  -0xc4(%rbp),%xmm1
ff
subss  -0xc0(%rbp),%xmm1
ff
mulss  -0x84(%rbp),%xmm1
ff
movss  -0x84(%rbp),%xmm2
ff
subss  -0x88(%rbp),%xmm2
ff
divss  %xmm2,%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,-0x98(%rbp)
ff
jmp    1cab <tri_tri_intersect+0xb9b>
movss  -0x84(%rbp),%xmm0
ff
mulss  -0x88(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
ja     1ab2 <tri_tri_intersect+0x9a2>
movss  -0x80(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1ab2 <tri_tri_intersect+0x9a2>
jp     1ab2 <tri_tri_intersect+0x9a2>
jmp    1b2b <tri_tri_intersect+0xa1b>
movss  -0xbc(%rbp),%xmm0
ff
movss  -0xc0(%rbp),%xmm1
ff
subss  -0xbc(%rbp),%xmm1
ff
mulss  -0x80(%rbp),%xmm1
movss  -0x80(%rbp),%xmm2
subss  -0x84(%rbp),%xmm2
ff
divss  %xmm2,%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
movss  -0xbc(%rbp),%xmm0
ff
movss  -0xc4(%rbp),%xmm1
ff
subss  -0xbc(%rbp),%xmm1
ff
mulss  -0x80(%rbp),%xmm1
movss  -0x80(%rbp),%xmm2
subss  -0x88(%rbp),%xmm2
ff
divss  %xmm2,%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,-0x98(%rbp)
ff
jmp    1ca6 <tri_tri_intersect+0xb96>
movss  -0x84(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1b4a <tri_tri_intersect+0xa3a>
jp     1b4a <tri_tri_intersect+0xa3a>
jmp    1bcc <tri_tri_intersect+0xabc>
movss  -0xc0(%rbp),%xmm0
ff
movss  -0xbc(%rbp),%xmm1
ff
subss  -0xc0(%rbp),%xmm1
ff
mulss  -0x84(%rbp),%xmm1
ff
movss  -0x84(%rbp),%xmm2
ff
subss  -0x80(%rbp),%xmm2
divss  %xmm2,%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
movss  -0xc0(%rbp),%xmm0
ff
movss  -0xc4(%rbp),%xmm1
ff
subss  -0xc0(%rbp),%xmm1
ff
mulss  -0x84(%rbp),%xmm1
ff
movss  -0x84(%rbp),%xmm2
ff
subss  -0x88(%rbp),%xmm2
ff
divss  %xmm2,%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,-0x98(%rbp)
ff
jmp    1ca1 <tri_tri_intersect+0xb91>
movss  -0x88(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1beb <tri_tri_intersect+0xadb>
jp     1beb <tri_tri_intersect+0xadb>
jmp    1c6d <tri_tri_intersect+0xb5d>
movss  -0xc4(%rbp),%xmm0
ff
movss  -0xbc(%rbp),%xmm1
ff
subss  -0xc4(%rbp),%xmm1
ff
mulss  -0x88(%rbp),%xmm1
ff
movss  -0x88(%rbp),%xmm2
ff
subss  -0x80(%rbp),%xmm2
divss  %xmm2,%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
movss  -0xc4(%rbp),%xmm0
ff
movss  -0xc0(%rbp),%xmm1
ff
subss  -0xc4(%rbp),%xmm1
ff
mulss  -0x88(%rbp),%xmm1
ff
movss  -0x88(%rbp),%xmm2
ff
subss  -0x84(%rbp),%xmm2
ff
divss  %xmm2,%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,-0x98(%rbp)
ff
jmp    1c9c <tri_tri_intersect+0xb8c>
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    2093 <tri_tri_intersect+0xf83>
jmp    1ca1 <tri_tri_intersect+0xb91>
jmp    1ca6 <tri_tri_intersect+0xb96>
jmp    1cab <tri_tri_intersect+0xb9b>
jmp    1cb0 <tri_tri_intersect+0xba0>
movss  -0xa8(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    1d37 <tri_tri_intersect+0xc27>
movss  -0xd0(%rbp),%xmm0
ff
movss  -0xc8(%rbp),%xmm1
ff
subss  -0xd0(%rbp),%xmm1
ff
mulss  -0x7c(%rbp),%xmm1
movss  -0x7c(%rbp),%xmm2
subss  -0x74(%rbp),%xmm2
divss  %xmm2,%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,-0xa4(%rbp)
ff
movss  -0xd0(%rbp),%xmm0
ff
movss  -0xcc(%rbp),%xmm1
ff
subss  -0xd0(%rbp),%xmm1
ff
mulss  -0x7c(%rbp),%xmm1
movss  -0x7c(%rbp),%xmm2
subss  -0x78(%rbp),%xmm2
divss  %xmm2,%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,-0xa0(%rbp)
ff
jmp    1fc4 <tri_tri_intersect+0xeb4>
movss  -0xac(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    1dbe <tri_tri_intersect+0xcae>
movss  -0xcc(%rbp),%xmm0
ff
movss  -0xc8(%rbp),%xmm1
ff
subss  -0xcc(%rbp),%xmm1
ff
mulss  -0x78(%rbp),%xmm1
movss  -0x78(%rbp),%xmm2
subss  -0x74(%rbp),%xmm2
divss  %xmm2,%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,-0xa4(%rbp)
ff
movss  -0xcc(%rbp),%xmm0
ff
movss  -0xd0(%rbp),%xmm1
ff
subss  -0xcc(%rbp),%xmm1
ff
mulss  -0x78(%rbp),%xmm1
movss  -0x78(%rbp),%xmm2
subss  -0x7c(%rbp),%xmm2
divss  %xmm2,%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,-0xa0(%rbp)
ff
jmp    1fbf <tri_tri_intersect+0xeaf>
movss  -0x78(%rbp),%xmm0
mulss  -0x7c(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
ja     1df0 <tri_tri_intersect+0xce0>
movss  -0x74(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1df0 <tri_tri_intersect+0xce0>
jp     1df0 <tri_tri_intersect+0xce0>
jmp    1e63 <tri_tri_intersect+0xd53>
movss  -0xc8(%rbp),%xmm0
ff
movss  -0xcc(%rbp),%xmm1
ff
subss  -0xc8(%rbp),%xmm1
ff
mulss  -0x74(%rbp),%xmm1
movss  -0x74(%rbp),%xmm2
subss  -0x78(%rbp),%xmm2
divss  %xmm2,%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,-0xa4(%rbp)
ff
movss  -0xc8(%rbp),%xmm0
ff
movss  -0xd0(%rbp),%xmm1
ff
subss  -0xc8(%rbp),%xmm1
ff
mulss  -0x74(%rbp),%xmm1
movss  -0x74(%rbp),%xmm2
subss  -0x7c(%rbp),%xmm2
divss  %xmm2,%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,-0xa0(%rbp)
ff
jmp    1fba <tri_tri_intersect+0xeaa>
movss  -0x78(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1e7f <tri_tri_intersect+0xd6f>
jp     1e7f <tri_tri_intersect+0xd6f>
jmp    1ef2 <tri_tri_intersect+0xde2>
movss  -0xcc(%rbp),%xmm0
ff
movss  -0xc8(%rbp),%xmm1
ff
subss  -0xcc(%rbp),%xmm1
ff
mulss  -0x78(%rbp),%xmm1
movss  -0x78(%rbp),%xmm2
subss  -0x74(%rbp),%xmm2
divss  %xmm2,%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,-0xa4(%rbp)
ff
movss  -0xcc(%rbp),%xmm0
ff
movss  -0xd0(%rbp),%xmm1
ff
subss  -0xcc(%rbp),%xmm1
ff
mulss  -0x78(%rbp),%xmm1
movss  -0x78(%rbp),%xmm2
subss  -0x7c(%rbp),%xmm2
divss  %xmm2,%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,-0xa0(%rbp)
ff
jmp    1fb5 <tri_tri_intersect+0xea5>
movss  -0x7c(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1f0e <tri_tri_intersect+0xdfe>
jp     1f0e <tri_tri_intersect+0xdfe>
jmp    1f81 <tri_tri_intersect+0xe71>
movss  -0xd0(%rbp),%xmm0
ff
movss  -0xc8(%rbp),%xmm1
ff
subss  -0xd0(%rbp),%xmm1
ff
mulss  -0x7c(%rbp),%xmm1
movss  -0x7c(%rbp),%xmm2
subss  -0x74(%rbp),%xmm2
divss  %xmm2,%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,-0xa4(%rbp)
ff
movss  -0xd0(%rbp),%xmm0
ff
movss  -0xcc(%rbp),%xmm1
ff
subss  -0xd0(%rbp),%xmm1
ff
mulss  -0x7c(%rbp),%xmm1
movss  -0x7c(%rbp),%xmm2
subss  -0x78(%rbp),%xmm2
divss  %xmm2,%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,-0xa0(%rbp)
ff
jmp    1fb0 <tri_tri_intersect+0xea0>
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    2093 <tri_tri_intersect+0xf83>
jmp    1fb5 <tri_tri_intersect+0xea5>
jmp    1fba <tri_tri_intersect+0xeaa>
jmp    1fbf <tri_tri_intersect+0xeaf>
jmp    1fc4 <tri_tri_intersect+0xeb4>
movss  -0x9c(%rbp),%xmm0
ff
ucomiss -0x98(%rbp),%xmm0
jbe    2009 <tri_tri_intersect+0xef9>
movss  -0x9c(%rbp),%xmm0
ff
movss  %xmm0,-0xe0(%rbp)
ff
movss  -0x98(%rbp),%xmm0
ff
movss  %xmm0,-0x9c(%rbp)
ff
movss  -0xe0(%rbp),%xmm0
movss  %xmm0,-0x98(%rbp)
movss  -0xa4(%rbp),%xmm0
ff
ucomiss -0xa0(%rbp),%xmm0
jbe    204e <tri_tri_intersect+0xf3e>
movss  -0xa4(%rbp),%xmm0
ff
movss  %xmm0,-0xe4(%rbp)
ff
movss  -0xa0(%rbp),%xmm0
ff
movss  %xmm0,-0xa4(%rbp)
ff
movss  -0xe4(%rbp),%xmm0
ff
movss  %xmm0,-0xa0(%rbp)
ff
movss  -0x98(%rbp),%xmm1
ff
movss  -0xa4(%rbp),%xmm0
ff
ucomiss %xmm1,%xmm0
ja     2080 <tri_tri_intersect+0xf70>
movss  -0xa0(%rbp),%xmm1
ff
movss  -0x9c(%rbp),%xmm0
ff
ucomiss %xmm1,%xmm0
jbe    208c <tri_tri_intersect+0xf7c>
movl   $0x0,-0x4(%rbp)
jmp    2093 <tri_tri_intersect+0xf83>
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0xf0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<tri_tri_intersect>:
sub    $0xe8,%rsp
mov    %r8,%r10
mov    %rcx,%r8
mov    %rdx,%rcx
mov    %rsi,%rdx
mov    %rdi,%rsi
movss  (%rdx),%xmm2
movss  0x4(%rdx),%xmm5
movsd  (%rdi),%xmm0
movaps %xmm0,%xmm1
shufps $0x55,%xmm0,%xmm1
movaps %xmm5,0x90(%rsp)
movaps %xmm1,0xa0(%rsp)
subss  %xmm1,%xmm5
movss  0x8(%rdx),%xmm1
movss  0x8(%rdi),%xmm11
movaps %xmm2,0xc0(%rsp)
movaps %xmm1,0xb0(%rsp)
unpcklps %xmm1,%xmm2
movaps %xmm11,%xmm3
movlhps %xmm0,%xmm3
shufps $0xe2,%xmm0,%xmm3
subps  %xmm3,%xmm2
movaps %xmm2,%xmm4
movaps %xmm5,%xmm1
movlhps %xmm2,%xmm5
shufps $0xe2,%xmm2,%xmm5
movaps %xmm2,%xmm7
shufps $0xe1,%xmm2,%xmm7
movsd  (%rcx),%xmm14
movaps %xmm14,%xmm15
subps  %xmm0,%xmm15
movss  0x8(%rcx),%xmm2
movaps %xmm2,0xd0(%rsp)
subss  %xmm11,%xmm2
shufps $0x55,%xmm4,%xmm4
movaps %xmm15,%xmm6
shufps $0x55,%xmm15,%xmm6
mulss  %xmm4,%xmm6
mulss  %xmm2,%xmm1
subss  %xmm6,%xmm1
movss  %xmm1,0x24(%rsp)
unpcklps %xmm15,%xmm2
mulps  %xmm5,%xmm2
mulps  %xmm7,%xmm15
subps  %xmm2,%xmm15
movaps %xmm15,%xmm3
shufps $0x55,%xmm15,%xmm3
movss  %xmm15,0x28(%rsp)
movss  %xmm3,0x2c(%rsp)
movsd  (%r8),%xmm9
movsd  (%r10),%xmm10
movaps %xmm15,%xmm4
shufps $0x0,%xmm15,%xmm4
movaps %xmm9,%xmm2
shufps $0x11,%xmm10,%xmm2
shufps $0xe2,%xmm10,%xmm2
mulps  %xmm4,%xmm2
movaps %xmm1,0x70(%rsp)
movaps %xmm1,%xmm6
shufps $0x0,%xmm1,%xmm6
movaps %xmm10,%xmm4
unpcklps %xmm9,%xmm4
mulps  %xmm6,%xmm4
addps  %xmm2,%xmm4
movss  0x8(%r8),%xmm2
movss  0x8(%r10),%xmm8
movaps %xmm8,%xmm1
movaps %xmm2,%xmm5
unpcklps %xmm2,%xmm1
mulps  %xmm3,%xmm1
addps  %xmm4,%xmm1
movaps %xmm0,%xmm2
shufps $0x1,%xmm15,%xmm2
shufps $0xe2,%xmm15,%xmm2
movsd  0x4(%r9),%xmm4
movaps %xmm4,%xmm7
unpcklps %xmm15,%xmm7
mulps  %xmm2,%xmm7
movss  (%r9),%xmm13
movaps %xmm13,%xmm2
unpcklps %xmm0,%xmm2
mulps  %xmm6,%xmm2
addps  %xmm7,%xmm2
movaps %xmm11,%xmm7
shufps $0xd4,%xmm4,%xmm7
shufps $0x52,%xmm4,%xmm7
movaps %xmm3,0x80(%rsp)
mulps  %xmm3,%xmm7
addps  %xmm2,%xmm7
movaps %xmm7,%xmm2
shufps $0x55,%xmm7,%xmm2
subps  %xmm2,%xmm1
movaps 0xd5b(%rip),%xmm3
movaps %xmm1,%xmm6
andps  %xmm3,%xmm6
cvtps2pd %xmm6,%xmm6
subss  %xmm2,%xmm7
cmpltpd 0xd55(%rip),%xmm6
shufps $0xe8,%xmm6,%xmm6
xorps  %xmm2,%xmm2
andps  %xmm6,%xmm2
andnps %xmm1,%xmm6
movaps %xmm7,%xmm1
andps  %xmm3,%xmm1
cvtss2sd %xmm1,%xmm1
movsd  0xd46(%rip),%xmm3
ucomisd %xmm1,%xmm3
orps   %xmm6,%xmm2
pshufd $0x55,%xmm6,%xmm12
xorpd  %xmm3,%xmm3
xorps  %xmm6,%xmm6
ja     12f3 <tri_tri_intersect+0x1e3>
movaps %xmm7,%xmm6
movdqa %xmm12,%xmm1
mulss  %xmm2,%xmm1
movdqa %xmm12,%xmm7
mulss  %xmm6,%xmm7
xor    %eax,%eax
movaps %xmm1,0x50(%rsp)
ucomiss %xmm3,%xmm1
jbe    1321 <tri_tri_intersect+0x211>
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm7
jbe    1321 <tri_tri_intersect+0x211>
add    $0xe8,%rsp
ret
movdqa %xmm12,0x60(%rsp)
movaps %xmm7,0x30(%rsp)
movaps %xmm6,0x40(%rsp)
movaps %xmm2,0x10(%rsp)
subps  %xmm9,%xmm10
subss  %xmm5,%xmm8
subss  %xmm9,%xmm13
movaps %xmm5,%xmm1
shufps $0xd4,%xmm9,%xmm1
shufps $0x52,%xmm9,%xmm1
subps  %xmm1,%xmm4
movaps %xmm4,%xmm1
shufps $0x55,%xmm4,%xmm1
mulss  %xmm10,%xmm1
movaps %xmm8,%xmm2
mulss  %xmm13,%xmm2
subss  %xmm1,%xmm2
shufps $0xd4,%xmm10,%xmm8
shufps $0x52,%xmm10,%xmm8
unpcklps %xmm4,%xmm13
mulps  %xmm8,%xmm13
mulps  %xmm10,%xmm4
subps  %xmm13,%xmm4
movaps %xmm2,%xmm13
movaps 0xa0(%rsp),%xmm2
unpcklps 0x90(%rsp),%xmm2
movaps %xmm13,%xmm1
shufps $0x0,%xmm13,%xmm1
mulps  %xmm1,%xmm2
movaps 0xc0(%rsp),%xmm3
movlhps %xmm0,%xmm3
shufps $0xe2,%xmm0,%xmm3
movaps %xmm4,%xmm0
shufps $0x55,%xmm4,%xmm0
mulps  %xmm0,%xmm3
addps  %xmm2,%xmm3
unpcklps 0xb0(%rsp),%xmm11
movaps %xmm4,%xmm2
shufps $0x0,%xmm4,%xmm2
mulps  %xmm2,%xmm11
addps  %xmm3,%xmm11
movaps %xmm9,%xmm6
shufps $0x11,%xmm14,%xmm6
shufps $0xe2,%xmm14,%xmm6
mulps  %xmm1,%xmm6
unpcklps %xmm9,%xmm14
mulps  %xmm0,%xmm14
addps  %xmm6,%xmm14
movaps 0xd0(%rsp),%xmm3
unpcklps %xmm5,%xmm3
mulps  %xmm2,%xmm3
addps  %xmm14,%xmm3
movaps %xmm3,%xmm1
shufps $0x55,%xmm3,%xmm1
subps  %xmm1,%xmm11
subss  %xmm1,%xmm3
movaps %xmm11,%xmm1
movaps 0xbdb(%rip),%xmm2
andps  %xmm2,%xmm1
cvtps2pd %xmm1,%xmm1
cmpltpd 0xbdc(%rip),%xmm1
shufps $0xe8,%xmm1,%xmm1
pxor   %xmm12,%xmm12
pand   %xmm1,%xmm12
andnps %xmm11,%xmm1
por    %xmm1,%xmm12
pshufd $0x55,%xmm1,%xmm9
movaps %xmm3,%xmm1
andps  %xmm2,%xmm1
cvtss2sd %xmm1,%xmm1
movsd  0xbbd(%rip),%xmm2
ucomisd %xmm1,%xmm2
xorps  %xmm8,%xmm8
xorps  %xmm10,%xmm10
ja     1475 <tri_tri_intersect+0x365>
movaps %xmm3,%xmm10
movdqa %xmm12,%xmm2
mulss  %xmm9,%xmm2
movdqa %xmm12,%xmm1
mulss  %xmm10,%xmm1
ucomiss %xmm8,%xmm2
jbe    149b <tri_tri_intersect+0x38b>
xorps  %xmm6,%xmm6
ucomiss %xmm6,%xmm1
ja     1319 <tri_tri_intersect+0x209>
movaps 0x60(%rsp),%xmm11
movaps 0xb57(%rip),%xmm8
movaps 0x70(%rsp),%xmm5
movaps %xmm5,%xmm6
movaps 0x80(%rsp),%xmm3
movlhps %xmm3,%xmm6
shufps $0xe2,%xmm3,%xmm6
movaps %xmm13,%xmm7
unpcklps %xmm4,%xmm7
mulps  %xmm6,%xmm7
movaps %xmm15,%xmm6
mulps  %xmm4,%xmm6
subps  %xmm7,%xmm6
mulss  %xmm15,%xmm0
mulss  %xmm13,%xmm5
subss  %xmm0,%xmm5
andps  %xmm8,%xmm6
andps  %xmm8,%xmm5
pshufd $0x55,%xmm6,%xmm0
xor    %eax,%eax
ucomiss %xmm6,%xmm0
seta   %al
maxss  %xmm6,%xmm0
ucomiss %xmm0,%xmm5
mov    $0x2,%edi
cmovbe %rax,%rdi
xorps  %xmm7,%xmm7
ucomiss %xmm7,%xmm2
movss  (%rsi,%rdi,4),%xmm2
movss  (%rdx,%rdi,4),%xmm3
movss  (%rcx,%rdi,4),%xmm4
movss  (%r8,%rdi,4),%xmm8
movss  (%r10,%rdi,4),%xmm0
movss  (%r9,%rdi,4),%xmm5
jbe    1553 <tri_tri_intersect+0x443>
unpcklps %xmm3,%xmm2
shufps $0x0,%xmm4,%xmm4
subps  %xmm4,%xmm2
shufps $0x0,%xmm10,%xmm10
mulps  %xmm10,%xmm2
subps  %xmm12,%xmm10
divps  %xmm10,%xmm2
addps  %xmm4,%xmm2
movaps %xmm2,%xmm3
jmp    15ca <tri_tri_intersect+0x4ba>
ucomiss %xmm7,%xmm1
ja     1580 <tri_tri_intersect+0x470>
movaps %xmm9,%xmm6
mulss  %xmm10,%xmm6
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm6
ja     15a8 <tri_tri_intersect+0x498>
ucomiss %xmm1,%xmm12
jne    15a8 <tri_tri_intersect+0x498>
jp     15a8 <tri_tri_intersect+0x498>
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm9
jne    1580 <tri_tri_intersect+0x470>
jnp    16b2 <tri_tri_intersect+0x5a2>
unpcklps %xmm4,%xmm2
shufps $0x0,%xmm3,%xmm3
subps  %xmm3,%xmm2
movaps %xmm12,%xmm1
shufps $0x55,%xmm12,%xmm1
mulps  %xmm1,%xmm2
movlhps %xmm12,%xmm10
shufps $0xe2,%xmm12,%xmm10
subps  %xmm10,%xmm1
divps  %xmm1,%xmm2
jmp    15c7 <tri_tri_intersect+0x4b7>
unpcklps %xmm4,%xmm3
shufps $0x0,%xmm2,%xmm2
subps  %xmm2,%xmm3
shufps $0x0,%xmm12,%xmm12
mulps  %xmm12,%xmm3
unpcklps %xmm10,%xmm9
subps  %xmm9,%xmm12
divps  %xmm12,%xmm3
addps  %xmm2,%xmm3
movaps 0x10(%rsp),%xmm2
movaps 0x40(%rsp),%xmm6
movaps 0x30(%rsp),%xmm4
movaps 0x50(%rsp),%xmm7
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm7
jbe    1600 <tri_tri_intersect+0x4f0>
unpcklps %xmm8,%xmm0
shufps $0x0,%xmm5,%xmm5
subps  %xmm5,%xmm0
shufps $0x0,%xmm6,%xmm6
mulps  %xmm6,%xmm0
subps  %xmm2,%xmm6
divps  %xmm6,%xmm0
jmp    164b <tri_tri_intersect+0x53b>
ucomiss %xmm1,%xmm4
ja     162c <tri_tri_intersect+0x51c>
mulss  %xmm6,%xmm2
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm2
ja     168b <tri_tri_intersect+0x57b>
ucomiss %xmm1,%xmm11
jne    168b <tri_tri_intersect+0x57b>
jp     168b <tri_tri_intersect+0x57b>
xorps  %xmm1,%xmm1
movaps 0x10(%rsp),%xmm2
ucomiss %xmm1,%xmm2
jne    162c <tri_tri_intersect+0x51c>
jnp    16ea <tri_tri_intersect+0x5da>
unpcklps %xmm8,%xmm5
shufps $0x0,%xmm0,%xmm0
subps  %xmm0,%xmm5
movaps %xmm2,%xmm1
shufps $0x0,%xmm2,%xmm1
mulps  %xmm1,%xmm5
movss  %xmm6,%xmm2
subps  %xmm2,%xmm1
divps  %xmm1,%xmm5
addps  %xmm0,%xmm5
movaps %xmm3,%xmm0
shufps $0x55,%xmm3,%xmm0
movaps %xmm0,%xmm1
minss  %xmm3,%xmm1
maxss  %xmm0,%xmm3
movaps %xmm5,%xmm0
shufps $0x55,%xmm5,%xmm0
movaps %xmm0,%xmm2
maxss  %xmm5,%xmm2
minss  %xmm0,%xmm5
ucomiss %xmm3,%xmm5
setbe  %al
ucomiss %xmm2,%xmm1
setbe  %cl
and    %al,%cl
movzbl %cl,%eax
add    $0xe8,%rsp
ret
unpcklps %xmm0,%xmm5
shufps $0x0,%xmm8,%xmm8
subps  %xmm8,%xmm5
movaps 0x10(%rsp),%xmm0
unpcklps %xmm0,%xmm6
shufps $0x55,%xmm0,%xmm0
mulps  %xmm0,%xmm5
subps  %xmm6,%xmm0
divps  %xmm0,%xmm5
addps  %xmm8,%xmm5
jmp    164e <tri_tri_intersect+0x53e>
ucomiss %xmm1,%xmm10
movaps 0x40(%rsp),%xmm6
jne    16bf <tri_tri_intersect+0x5af>
jnp    16f9 <tri_tri_intersect+0x5e9>
unpcklps %xmm3,%xmm2
shufps $0x0,%xmm4,%xmm4
subps  %xmm4,%xmm2
shufps $0x0,%xmm10,%xmm10
mulps  %xmm10,%xmm2
subps  %xmm12,%xmm10
divps  %xmm10,%xmm2
addps  %xmm4,%xmm2
movaps %xmm2,%xmm3
movaps 0x10(%rsp),%xmm2
jmp    15d4 <tri_tri_intersect+0x4c4>
ucomiss %xmm1,%xmm6
jne    15e6 <tri_tri_intersect+0x4d6>
jp     15e6 <tri_tri_intersect+0x4d6>
mov    %r9,(%rsp)
lea    0x24(%rsp),%rdi
mov    %r10,%r9
xor    %eax,%eax
call   1030 <coplanar_tri_tri@plt>
add    $0xe8,%rsp
ret

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

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