int NoDivTriTriIsect(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 bb, cc, max;
  float a, b, c, x0, x1;
  float d, e, f, y0, y1;
  float xx, yy, xxyy, tmp;
  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 (((float)fabs(du0)) < 0.005)
    du0 = 0.0;
  if (((float)fabs(du1)) < 0.005)
    du1 = 0.0;
  if (((float)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 (((float)fabs(dv0)) < 0.005)
    dv0 = 0.0;
  if (((float)fabs(dv1)) < 0.005)
    dv1 = 0.0;
  if (((float)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 = (float)((float)fabs(D[0]));
  index = 0;
  bb = (float)((float)fabs(D[1]));
  cc = (float)((float)fabs(D[2]));
  if (bb > max)
    max = bb, index = 1;
  if (cc > max)
    max = cc, index = 2;
  vp0 = V0[index];
  vp1 = V1[index];
  vp2 = V2[index];
  up0 = U0[index];
  up1 = U1[index];
  up2 = U2[index];
  {
    if (dv0dv1 > 0.0f) {
      a = vp2;
      b = (vp0 - vp2) * dv2;
      c = (vp1 - vp2) * dv2;
      x0 = dv2 - dv0;
      x1 = dv2 - dv1;
    } else if (dv0dv2 > 0.0f) {
      a = vp1;
      b = (vp0 - vp1) * dv1;
      c = (vp2 - vp1) * dv1;
      x0 = dv1 - dv0;
      x1 = dv1 - dv2;
    } else if (dv1 * dv2 > 0.0f || dv0 != 0.0f) {
      a = vp0;
      b = (vp1 - vp0) * dv0;
      c = (vp2 - vp0) * dv0;
      x0 = dv0 - dv1;
      x1 = dv0 - dv2;
    } else if (dv1 != 0.0f) {
      a = vp1;
      b = (vp0 - vp1) * dv1;
      c = (vp2 - vp1) * dv1;
      x0 = dv1 - dv0;
      x1 = dv1 - dv2;
    } else if (dv2 != 0.0f) {
      a = vp2;
      b = (vp0 - vp2) * dv2;
      c = (vp1 - vp2) * dv2;
      x0 = dv2 - dv0;
      x1 = dv2 - dv1;
    } else {
      return coplanar_tri_tri(N1, V0, V1, V2, U0, U1, U2);
    }
  };
  {
    if (du0du1 > 0.0f) {
      d = up2;
      e = (up0 - up2) * du2;
      f = (up1 - up2) * du2;
      y0 = du2 - du0;
      y1 = du2 - du1;
    } else if (du0du2 > 0.0f) {
      d = up1;
      e = (up0 - up1) * du1;
      f = (up2 - up1) * du1;
      y0 = du1 - du0;
      y1 = du1 - du2;
    } else if (du1 * du2 > 0.0f || du0 != 0.0f) {
      d = up0;
      e = (up1 - up0) * du0;
      f = (up2 - up0) * du0;
      y0 = du0 - du1;
      y1 = du0 - du2;
    } else if (du1 != 0.0f) {
      d = up1;
      e = (up0 - up1) * du1;
      f = (up2 - up1) * du1;
      y0 = du1 - du0;
      y1 = du1 - du2;
    } else if (du2 != 0.0f) {
      d = up2;
      e = (up0 - up2) * du2;
      f = (up1 - up2) * du2;
      y0 = du2 - du0;
      y1 = du2 - du1;
    } else {
      return coplanar_tri_tri(N1, V0, V1, V2, U0, U1, U2);
    }
  };
  xx = x0 * x1;
  yy = y0 * y1;
  xxyy = xx * yy;
  tmp = a * xxyy;
  isect1[0] = tmp + b * x1 * yy;
  isect1[1] = tmp + c * x0 * yy;
  tmp = d * xxyy;
  isect2[0] = tmp + e * xx * y1;
  isect2[1] = tmp + f * xx * y0;
  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):
<NoDivTriTriIsect>:
push   %rbp
mov    %rsp,%rbp
sub    $0x130,%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,%xmm0
movaps 0x1ca9(%rip),%xmm1
pand   %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x1c85(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    138d <NoDivTriTriIsect+0x27d>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x78(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movaps 0x1c73(%rip),%xmm1
pand   %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x1c4f(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    13c3 <NoDivTriTriIsect+0x2b3>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x7c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movaps 0x1c3d(%rip),%xmm1
pand   %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x1c19(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    13f9 <NoDivTriTriIsect+0x2e9>
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    1451 <NoDivTriTriIsect+0x341>
movss  -0xac(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    1451 <NoDivTriTriIsect+0x341>
movl   $0x0,-0x4(%rbp)
jmp    21fb <NoDivTriTriIsect+0x10eb>
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,%xmm0
movaps 0x1985(%rip),%xmm1
pand   %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x1961(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    16b1 <NoDivTriTriIsect+0x5a1>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x84(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movaps 0x194c(%rip),%xmm1
pand   %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x1928(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    16ed <NoDivTriTriIsect+0x5dd>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x88(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movaps 0x1910(%rip),%xmm1
pand   %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x18ec(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1729 <NoDivTriTriIsect+0x619>
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    1787 <NoDivTriTriIsect+0x677>
movss  -0xb4(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    1787 <NoDivTriTriIsect+0x677>
movl   $0x0,-0x4(%rbp)
jmp    21fb <NoDivTriTriIsect+0x10eb>
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 0x17e3(%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 0x17b7(%rip),%xmm1
pand   %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0xd4(%rbp)
ff
movss  -0x8c(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm0
movaps 0x1794(%rip),%xmm1
pand   %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0xd8(%rbp)
ff
movss  -0xd4(%rbp),%xmm0
ff
ucomiss -0xdc(%rbp),%xmm0
jbe    18ba <NoDivTriTriIsect+0x7aa>
movss  -0xd4(%rbp),%xmm0
ff
movss  %xmm0,-0xdc(%rbp)
ff
movw   $0x1,-0xb6(%rbp)
movss  -0xd8(%rbp),%xmm0
ff
ucomiss -0xdc(%rbp),%xmm0
jbe    18e8 <NoDivTriTriIsect+0x7d8>
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)
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    1a14 <NoDivTriTriIsect+0x904>
movss  -0xc4(%rbp),%xmm0
ff
movss  %xmm0,-0xe0(%rbp)
ff
movss  -0xbc(%rbp),%xmm0
ff
subss  -0xc4(%rbp),%xmm0
ff
mulss  -0x88(%rbp),%xmm0
ff
movss  %xmm0,-0xe4(%rbp)
ff
movss  -0xc0(%rbp),%xmm0
ff
subss  -0xc4(%rbp),%xmm0
ff
mulss  -0x88(%rbp),%xmm0
ff
movss  %xmm0,-0xe8(%rbp)
ff
movss  -0x88(%rbp),%xmm0
ff
subss  -0x80(%rbp),%xmm0
movss  %xmm0,-0xec(%rbp)
ff
movss  -0x88(%rbp),%xmm0
ff
subss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0xf0(%rbp)
ff
jmp    1ce0 <NoDivTriTriIsect+0xbd0>
movss  -0xb4(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    1aaa <NoDivTriTriIsect+0x99a>
movss  -0xc0(%rbp),%xmm0
ff
movss  %xmm0,-0xe0(%rbp)
ff
movss  -0xbc(%rbp),%xmm0
ff
subss  -0xc0(%rbp),%xmm0
ff
mulss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0xe4(%rbp)
ff
movss  -0xc4(%rbp),%xmm0
ff
subss  -0xc0(%rbp),%xmm0
ff
mulss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0xe8(%rbp)
ff
movss  -0x84(%rbp),%xmm0
ff
subss  -0x80(%rbp),%xmm0
movss  %xmm0,-0xec(%rbp)
ff
movss  -0x84(%rbp),%xmm0
ff
subss  -0x88(%rbp),%xmm0
ff
movss  %xmm0,-0xf0(%rbp)
ff
jmp    1cdb <NoDivTriTriIsect+0xbcb>
movss  -0x84(%rbp),%xmm0
ff
mulss  -0x88(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
ja     1ae2 <NoDivTriTriIsect+0x9d2>
movss  -0x80(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1ae2 <NoDivTriTriIsect+0x9d2>
jp     1ae2 <NoDivTriTriIsect+0x9d2>
jmp    1b5b <NoDivTriTriIsect+0xa4b>
movss  -0xbc(%rbp),%xmm0
ff
movss  %xmm0,-0xe0(%rbp)
ff
movss  -0xc0(%rbp),%xmm0
ff
subss  -0xbc(%rbp),%xmm0
ff
mulss  -0x80(%rbp),%xmm0
movss  %xmm0,-0xe4(%rbp)
ff
movss  -0xc4(%rbp),%xmm0
ff
subss  -0xbc(%rbp),%xmm0
ff
mulss  -0x80(%rbp),%xmm0
movss  %xmm0,-0xe8(%rbp)
ff
movss  -0x80(%rbp),%xmm0
subss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0xec(%rbp)
ff
movss  -0x80(%rbp),%xmm0
subss  -0x88(%rbp),%xmm0
ff
movss  %xmm0,-0xf0(%rbp)
ff
jmp    1cd6 <NoDivTriTriIsect+0xbc6>
movss  -0x84(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1b7a <NoDivTriTriIsect+0xa6a>
jp     1b7a <NoDivTriTriIsect+0xa6a>
jmp    1bfc <NoDivTriTriIsect+0xaec>
movss  -0xc0(%rbp),%xmm0
ff
movss  %xmm0,-0xe0(%rbp)
ff
movss  -0xbc(%rbp),%xmm0
ff
subss  -0xc0(%rbp),%xmm0
ff
mulss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0xe4(%rbp)
ff
movss  -0xc4(%rbp),%xmm0
ff
subss  -0xc0(%rbp),%xmm0
ff
mulss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0xe8(%rbp)
ff
movss  -0x84(%rbp),%xmm0
ff
subss  -0x80(%rbp),%xmm0
movss  %xmm0,-0xec(%rbp)
ff
movss  -0x84(%rbp),%xmm0
ff
subss  -0x88(%rbp),%xmm0
ff
movss  %xmm0,-0xf0(%rbp)
ff
jmp    1cd1 <NoDivTriTriIsect+0xbc1>
movss  -0x88(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1c1b <NoDivTriTriIsect+0xb0b>
jp     1c1b <NoDivTriTriIsect+0xb0b>
jmp    1c9d <NoDivTriTriIsect+0xb8d>
movss  -0xc4(%rbp),%xmm0
ff
movss  %xmm0,-0xe0(%rbp)
ff
movss  -0xbc(%rbp),%xmm0
ff
subss  -0xc4(%rbp),%xmm0
ff
mulss  -0x88(%rbp),%xmm0
ff
movss  %xmm0,-0xe4(%rbp)
ff
movss  -0xc0(%rbp),%xmm0
ff
subss  -0xc4(%rbp),%xmm0
ff
mulss  -0x88(%rbp),%xmm0
ff
movss  %xmm0,-0xe8(%rbp)
ff
movss  -0x88(%rbp),%xmm0
ff
subss  -0x80(%rbp),%xmm0
movss  %xmm0,-0xec(%rbp)
ff
movss  -0x88(%rbp),%xmm0
ff
subss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0xf0(%rbp)
ff
jmp    1ccc <NoDivTriTriIsect+0xbbc>
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    21fb <NoDivTriTriIsect+0x10eb>
jmp    1cd1 <NoDivTriTriIsect+0xbc1>
jmp    1cd6 <NoDivTriTriIsect+0xbc6>
jmp    1cdb <NoDivTriTriIsect+0xbcb>
jmp    1ce0 <NoDivTriTriIsect+0xbd0>
movss  -0xa8(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    1d67 <NoDivTriTriIsect+0xc57>
movss  -0xd0(%rbp),%xmm0
ff
movss  %xmm0,-0xf4(%rbp)
ff
movss  -0xc8(%rbp),%xmm0
ff
subss  -0xd0(%rbp),%xmm0
ff
mulss  -0x7c(%rbp),%xmm0
movss  %xmm0,-0xf8(%rbp)
ff
movss  -0xcc(%rbp),%xmm0
ff
subss  -0xd0(%rbp),%xmm0
ff
mulss  -0x7c(%rbp),%xmm0
movss  %xmm0,-0xfc(%rbp)
ff
movss  -0x7c(%rbp),%xmm0
subss  -0x74(%rbp),%xmm0
movss  %xmm0,-0x100(%rbp)
ff
movss  -0x7c(%rbp),%xmm0
subss  -0x78(%rbp),%xmm0
movss  %xmm0,-0x104(%rbp)
ff
jmp    1ff4 <NoDivTriTriIsect+0xee4>
movss  -0xac(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    1dee <NoDivTriTriIsect+0xcde>
movss  -0xcc(%rbp),%xmm0
ff
movss  %xmm0,-0xf4(%rbp)
ff
movss  -0xc8(%rbp),%xmm0
ff
subss  -0xcc(%rbp),%xmm0
ff
mulss  -0x78(%rbp),%xmm0
movss  %xmm0,-0xf8(%rbp)
ff
movss  -0xd0(%rbp),%xmm0
ff
subss  -0xcc(%rbp),%xmm0
ff
mulss  -0x78(%rbp),%xmm0
movss  %xmm0,-0xfc(%rbp)
ff
movss  -0x78(%rbp),%xmm0
subss  -0x74(%rbp),%xmm0
movss  %xmm0,-0x100(%rbp)
ff
movss  -0x78(%rbp),%xmm0
subss  -0x7c(%rbp),%xmm0
movss  %xmm0,-0x104(%rbp)
ff
jmp    1fef <NoDivTriTriIsect+0xedf>
movss  -0x78(%rbp),%xmm0
mulss  -0x7c(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
ja     1e20 <NoDivTriTriIsect+0xd10>
movss  -0x74(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1e20 <NoDivTriTriIsect+0xd10>
jp     1e20 <NoDivTriTriIsect+0xd10>
jmp    1e93 <NoDivTriTriIsect+0xd83>
movss  -0xc8(%rbp),%xmm0
ff
movss  %xmm0,-0xf4(%rbp)
ff
movss  -0xcc(%rbp),%xmm0
ff
subss  -0xc8(%rbp),%xmm0
ff
mulss  -0x74(%rbp),%xmm0
movss  %xmm0,-0xf8(%rbp)
ff
movss  -0xd0(%rbp),%xmm0
ff
subss  -0xc8(%rbp),%xmm0
ff
mulss  -0x74(%rbp),%xmm0
movss  %xmm0,-0xfc(%rbp)
ff
movss  -0x74(%rbp),%xmm0
subss  -0x78(%rbp),%xmm0
movss  %xmm0,-0x100(%rbp)
ff
movss  -0x74(%rbp),%xmm0
subss  -0x7c(%rbp),%xmm0
movss  %xmm0,-0x104(%rbp)
ff
jmp    1fea <NoDivTriTriIsect+0xeda>
movss  -0x78(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1eaf <NoDivTriTriIsect+0xd9f>
jp     1eaf <NoDivTriTriIsect+0xd9f>
jmp    1f22 <NoDivTriTriIsect+0xe12>
movss  -0xcc(%rbp),%xmm0
ff
movss  %xmm0,-0xf4(%rbp)
ff
movss  -0xc8(%rbp),%xmm0
ff
subss  -0xcc(%rbp),%xmm0
ff
mulss  -0x78(%rbp),%xmm0
movss  %xmm0,-0xf8(%rbp)
ff
movss  -0xd0(%rbp),%xmm0
ff
subss  -0xcc(%rbp),%xmm0
ff
mulss  -0x78(%rbp),%xmm0
movss  %xmm0,-0xfc(%rbp)
ff
movss  -0x78(%rbp),%xmm0
subss  -0x74(%rbp),%xmm0
movss  %xmm0,-0x100(%rbp)
ff
movss  -0x78(%rbp),%xmm0
subss  -0x7c(%rbp),%xmm0
movss  %xmm0,-0x104(%rbp)
ff
jmp    1fe5 <NoDivTriTriIsect+0xed5>
movss  -0x7c(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1f3e <NoDivTriTriIsect+0xe2e>
jp     1f3e <NoDivTriTriIsect+0xe2e>
jmp    1fb1 <NoDivTriTriIsect+0xea1>
movss  -0xd0(%rbp),%xmm0
ff
movss  %xmm0,-0xf4(%rbp)
ff
movss  -0xc8(%rbp),%xmm0
ff
subss  -0xd0(%rbp),%xmm0
ff
mulss  -0x7c(%rbp),%xmm0
movss  %xmm0,-0xf8(%rbp)
ff
movss  -0xcc(%rbp),%xmm0
ff
subss  -0xd0(%rbp),%xmm0
ff
mulss  -0x7c(%rbp),%xmm0
movss  %xmm0,-0xfc(%rbp)
ff
movss  -0x7c(%rbp),%xmm0
subss  -0x74(%rbp),%xmm0
movss  %xmm0,-0x100(%rbp)
ff
movss  -0x7c(%rbp),%xmm0
subss  -0x78(%rbp),%xmm0
movss  %xmm0,-0x104(%rbp)
ff
jmp    1fe0 <NoDivTriTriIsect+0xed0>
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    21fb <NoDivTriTriIsect+0x10eb>
jmp    1fe5 <NoDivTriTriIsect+0xed5>
jmp    1fea <NoDivTriTriIsect+0xeda>
jmp    1fef <NoDivTriTriIsect+0xedf>
jmp    1ff4 <NoDivTriTriIsect+0xee4>
movss  -0xec(%rbp),%xmm0
ff
mulss  -0xf0(%rbp),%xmm0
movss  %xmm0,-0x108(%rbp)
movss  -0x100(%rbp),%xmm0
ff
mulss  -0x104(%rbp),%xmm0
ff
movss  %xmm0,-0x10c(%rbp)
ff
movss  -0x108(%rbp),%xmm0
ff
mulss  -0x10c(%rbp),%xmm0
ff
movss  %xmm0,-0x110(%rbp)
ff
movss  -0xe0(%rbp),%xmm0
ff
mulss  -0x110(%rbp),%xmm0
ff
movss  %xmm0,-0x114(%rbp)
ff
movss  -0x114(%rbp),%xmm1
ff
movss  -0xe4(%rbp),%xmm0
ff
mulss  -0xf0(%rbp),%xmm0
ff
movss  -0x10c(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
movss  -0x114(%rbp),%xmm1
ff
movss  -0xe8(%rbp),%xmm0
ff
mulss  -0xec(%rbp),%xmm0
ff
movss  -0x10c(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x98(%rbp)
ff
movss  -0xf4(%rbp),%xmm0
ff
mulss  -0x110(%rbp),%xmm0
ff
movss  %xmm0,-0x114(%rbp)
ff
movss  -0x114(%rbp),%xmm1
ff
movss  -0xf8(%rbp),%xmm0
ff
mulss  -0x108(%rbp),%xmm0
ff
movss  -0x104(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xa4(%rbp)
ff
movss  -0x114(%rbp),%xmm1
ff
movss  -0xfc(%rbp),%xmm0
ff
mulss  -0x108(%rbp),%xmm0
ff
movss  -0x100(%rbp),%xmm2
ff
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0xa0(%rbp)
ff
movss  -0x9c(%rbp),%xmm0
ff
ucomiss -0x98(%rbp),%xmm0
jbe    2171 <NoDivTriTriIsect+0x1061>
movss  -0x9c(%rbp),%xmm0
ff
movss  %xmm0,-0x118(%rbp)
ff
movss  -0x98(%rbp),%xmm0
ff
movss  %xmm0,-0x9c(%rbp)
ff
movss  -0x118(%rbp),%xmm0
ff
movss  %xmm0,-0x98(%rbp)
ff
movss  -0xa4(%rbp),%xmm0
ff
ucomiss -0xa0(%rbp),%xmm0
jbe    21b6 <NoDivTriTriIsect+0x10a6>
movss  -0xa4(%rbp),%xmm0
ff
movss  %xmm0,-0x11c(%rbp)
ff
movss  -0xa0(%rbp),%xmm0
ff
movss  %xmm0,-0xa4(%rbp)
ff
movss  -0x11c(%rbp),%xmm0
ff
movss  %xmm0,-0xa0(%rbp)
ff
movss  -0x98(%rbp),%xmm1
ff
movss  -0xa4(%rbp),%xmm0
ff
ucomiss %xmm1,%xmm0
ja     21e8 <NoDivTriTriIsect+0x10d8>
movss  -0xa0(%rbp),%xmm1
ff
movss  -0x9c(%rbp),%xmm0
ff
ucomiss %xmm1,%xmm0
jbe    21f4 <NoDivTriTriIsect+0x10e4>
movl   $0x0,-0x4(%rbp)
jmp    21fb <NoDivTriTriIsect+0x10eb>
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x130,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<NoDivTriTriIsect>:
sub    $0xe8,%rsp
mov    %r8,%r10
mov    %rcx,%r8
mov    %rdx,%rcx
mov    %rsi,%rdx
mov    %rdi,%rsi
movss  0x4(%rdx),%xmm0
movsd  (%rdi),%xmm5
movaps %xmm5,%xmm1
shufps $0x55,%xmm5,%xmm1
movaps %xmm0,0xa0(%rsp)
subss  %xmm1,%xmm0
movss  0x8(%rdx),%xmm2
movss  0x8(%rdi),%xmm11
movss  (%rdx),%xmm1
movaps %xmm1,0xd0(%rsp)
movaps %xmm2,0xb0(%rsp)
unpcklps %xmm2,%xmm1
movaps %xmm11,%xmm2
movlhps %xmm5,%xmm2
shufps $0xe2,%xmm5,%xmm2
subps  %xmm2,%xmm1
movaps %xmm1,%xmm3
movaps %xmm0,%xmm4
movlhps %xmm1,%xmm0
shufps $0xe2,%xmm1,%xmm0
shufps $0xe1,%xmm1,%xmm1
movsd  (%rcx),%xmm2
movaps %xmm2,%xmm14
subps  %xmm5,%xmm14
movss  0x8(%rcx),%xmm8
movaps %xmm8,%xmm6
subss  %xmm11,%xmm6
shufps $0x55,%xmm3,%xmm3
movaps %xmm14,%xmm7
shufps $0x55,%xmm14,%xmm7
mulss  %xmm3,%xmm7
mulss  %xmm6,%xmm4
subss  %xmm7,%xmm4
movss  %xmm4,0x34(%rsp)
unpcklps %xmm14,%xmm6
mulps  %xmm0,%xmm6
mulps  %xmm1,%xmm14
subps  %xmm6,%xmm14
movaps %xmm14,%xmm7
shufps $0x55,%xmm14,%xmm7
movss  %xmm14,0x38(%rsp)
movss  %xmm7,0x3c(%rsp)
movsd  (%r8),%xmm9
movss  0x8(%r8),%xmm3
movsd  (%r10),%xmm12
movaps %xmm14,%xmm0
shufps $0x0,%xmm14,%xmm0
movaps %xmm12,%xmm1
shufps $0x55,%xmm9,%xmm1
shufps $0x52,%xmm9,%xmm1
mulps  %xmm0,%xmm1
movaps %xmm4,0x70(%rsp)
movaps %xmm4,%xmm6
shufps $0x0,%xmm4,%xmm6
movaps %xmm9,%xmm0
unpcklps %xmm12,%xmm0
mulps  %xmm6,%xmm0
addps  %xmm1,%xmm0
movss  0x8(%r10),%xmm10
movaps %xmm3,0x90(%rsp)
unpcklps %xmm10,%xmm3
mulps  %xmm7,%xmm3
addps  %xmm0,%xmm3
movaps %xmm5,%xmm1
shufps $0x1,%xmm14,%xmm1
shufps $0xe2,%xmm14,%xmm1
movsd  0x4(%r9),%xmm13
movaps %xmm13,%xmm0
unpcklps %xmm14,%xmm0
mulps  %xmm1,%xmm0
movss  (%r9),%xmm15
movaps %xmm15,%xmm1
unpcklps %xmm5,%xmm1
mulps  %xmm6,%xmm1
addps  %xmm0,%xmm1
movaps %xmm11,0xc0(%rsp)
shufps $0xd4,%xmm13,%xmm11
shufps $0x52,%xmm13,%xmm11
movaps %xmm7,0x80(%rsp)
mulps  %xmm7,%xmm11
addps  %xmm1,%xmm11
movaps %xmm11,%xmm0
shufps $0x55,%xmm11,%xmm0
subps  %xmm0,%xmm3
movaps 0xd5c(%rip),%xmm4
movaps %xmm3,%xmm1
andps  %xmm4,%xmm1
cvtps2pd %xmm1,%xmm1
subss  %xmm0,%xmm11
cmpltpd 0xd55(%rip),%xmm1
shufps $0xe8,%xmm1,%xmm1
xorps  %xmm7,%xmm7
andps  %xmm1,%xmm7
andnps %xmm3,%xmm1
movaps %xmm11,%xmm0
andps  %xmm4,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xd45(%rip),%xmm3
ucomisd %xmm0,%xmm3
movaps %xmm7,%xmm0
orps   %xmm1,%xmm0
pshufd $0x55,%xmm1,%xmm1
xorpd  %xmm3,%xmm3
xorps  %xmm4,%xmm4
ja     12f7 <NoDivTriTriIsect+0x1e7>
movaps %xmm11,%xmm4
movaps %xmm0,%xmm7
mulss  %xmm1,%xmm7
movaps %xmm0,0x20(%rsp)
movaps %xmm0,%xmm6
mulss  %xmm4,%xmm6
xor    %eax,%eax
movaps %xmm7,0x40(%rsp)
ucomiss %xmm3,%xmm7
jbe    1326 <NoDivTriTriIsect+0x216>
xorps  %xmm0,%xmm0
ucomiss %xmm0,%xmm6
jbe    1326 <NoDivTriTriIsect+0x216>
add    $0xe8,%rsp
ret
movaps %xmm4,0x60(%rsp)
movaps %xmm6,0x50(%rsp)
movaps %xmm1,0x10(%rsp)
movaps %xmm9,%xmm0
shufps $0x55,%xmm9,%xmm0
subps  %xmm9,%xmm12
movaps 0x90(%rsp),%xmm11
subss  %xmm11,%xmm10
subss  %xmm9,%xmm15
movaps %xmm11,%xmm1
movlhps %xmm0,%xmm1
shufps $0xe2,%xmm0,%xmm1
subps  %xmm1,%xmm13
movaps %xmm13,%xmm1
shufps $0x55,%xmm13,%xmm1
mulss  %xmm12,%xmm1
movaps %xmm10,%xmm0
mulss  %xmm15,%xmm0
subss  %xmm1,%xmm0
shufps $0xd4,%xmm12,%xmm10
shufps $0x52,%xmm12,%xmm10
unpcklps %xmm13,%xmm15
mulps  %xmm10,%xmm15
mulps  %xmm12,%xmm13
subps  %xmm15,%xmm13
movaps 0xd0(%rsp),%xmm6
unpcklps %xmm5,%xmm6
movaps 0xa0(%rsp),%xmm1
movss  %xmm1,%xmm5
movaps %xmm0,%xmm3
shufps $0x0,%xmm0,%xmm3
mulps  %xmm3,%xmm5
movaps %xmm13,%xmm1
shufps $0x55,%xmm13,%xmm1
mulps  %xmm1,%xmm6
addps  %xmm5,%xmm6
movaps 0xb0(%rsp),%xmm7
unpcklps 0xc0(%rsp),%xmm7
movaps %xmm13,%xmm5
shufps $0x0,%xmm13,%xmm5
mulps  %xmm5,%xmm7
addps  %xmm6,%xmm7
movaps %xmm9,%xmm6
shufps $0x11,%xmm2,%xmm6
shufps $0xe2,%xmm2,%xmm6
mulps  %xmm3,%xmm6
unpcklps %xmm9,%xmm2
mulps  %xmm1,%xmm2
addps  %xmm6,%xmm2
unpcklps %xmm11,%xmm8
mulps  %xmm5,%xmm8
addps  %xmm2,%xmm8
movaps %xmm8,%xmm2
shufps $0x55,%xmm8,%xmm2
subps  %xmm2,%xmm7
subss  %xmm2,%xmm8
movaps %xmm7,%xmm2
movaps 0xbd8(%rip),%xmm4
andps  %xmm4,%xmm2
cvtps2pd %xmm2,%xmm3
cmpltpd 0xbd9(%rip),%xmm3
shufps $0xe8,%xmm3,%xmm3
xorps  %xmm12,%xmm12
andps  %xmm3,%xmm12
andnps %xmm7,%xmm3
orps   %xmm3,%xmm12
pshufd $0x55,%xmm3,%xmm5
movaps %xmm8,%xmm3
andps  %xmm4,%xmm3
cvtss2sd %xmm3,%xmm3
movsd  0xbbe(%rip),%xmm2
ucomisd %xmm3,%xmm2
xorps  %xmm6,%xmm6
xorps  %xmm9,%xmm9
ja     1473 <NoDivTriTriIsect+0x363>
movaps %xmm8,%xmm9
movdqa %xmm5,%xmm3
mulss  %xmm12,%xmm3
movdqa %xmm5,%xmm4
mulss  %xmm9,%xmm4
ucomiss %xmm6,%xmm3
jbe    1496 <NoDivTriTriIsect+0x386>
xorps  %xmm6,%xmm6
ucomiss %xmm6,%xmm4
ja     131e <NoDivTriTriIsect+0x20e>
movaps 0xb62(%rip),%xmm10
movaps 0x60(%rsp),%xmm11
movaps 0x70(%rsp),%xmm2
movaps %xmm2,%xmm6
movaps 0x80(%rsp),%xmm7
movlhps %xmm7,%xmm6
shufps $0xe2,%xmm7,%xmm6
movaps %xmm0,%xmm7
unpcklps %xmm13,%xmm7
mulps  %xmm6,%xmm7
movaps %xmm14,%xmm6
mulps  %xmm13,%xmm6
subps  %xmm7,%xmm6
mulss  %xmm14,%xmm1
mulss  %xmm0,%xmm2
subss  %xmm1,%xmm2
andps  %xmm10,%xmm6
andps  %xmm10,%xmm2
pshufd $0x55,%xmm6,%xmm0
xor    %eax,%eax
ucomiss %xmm6,%xmm0
seta   %al
maxss  %xmm6,%xmm0
ucomiss %xmm0,%xmm2
mov    $0x2,%edi
cmovbe %rax,%rdi
xorps  %xmm0,%xmm0
ucomiss %xmm0,%xmm3
movss  (%rsi,%rdi,4),%xmm6
movss  (%rdx,%rdi,4),%xmm7
movss  (%rcx,%rdi,4),%xmm1
movss  (%r8,%rdi,4),%xmm10
movss  (%r10,%rdi,4),%xmm3
movss  (%r9,%rdi,4),%xmm8
jbe    1551 <NoDivTriTriIsect+0x441>
unpcklps %xmm7,%xmm6
movaps %xmm1,%xmm0
shufps $0x0,%xmm1,%xmm0
subps  %xmm0,%xmm6
shufps $0x0,%xmm9,%xmm9
movaps %xmm6,%xmm7
mulps  %xmm9,%xmm7
subps  %xmm12,%xmm9
movaps %xmm1,%xmm6
movaps %xmm9,%xmm12
jmp    15cc <NoDivTriTriIsect+0x4bc>
ucomiss %xmm0,%xmm4
ja     157d <NoDivTriTriIsect+0x46d>
movaps %xmm12,%xmm4
mulss  %xmm9,%xmm4
xorps  %xmm0,%xmm0
ucomiss %xmm0,%xmm4
ja     15ae <NoDivTriTriIsect+0x49e>
ucomiss %xmm0,%xmm5
jne    15ae <NoDivTriTriIsect+0x49e>
jp     15ae <NoDivTriTriIsect+0x49e>
xorps  %xmm0,%xmm0
ucomiss %xmm0,%xmm12
jne    157d <NoDivTriTriIsect+0x46d>
jnp    1728 <NoDivTriTriIsect+0x618>
unpcklps %xmm1,%xmm6
movaps %xmm7,%xmm0
shufps $0x0,%xmm7,%xmm0
subps  %xmm0,%xmm6
movaps %xmm12,%xmm0
shufps $0x0,%xmm12,%xmm0
movaps %xmm6,%xmm1
mulps  %xmm0,%xmm1
movss  %xmm9,%xmm12
subps  %xmm12,%xmm0
movaps %xmm7,%xmm6
movaps %xmm1,%xmm7
movaps %xmm0,%xmm12
jmp    15cc <NoDivTriTriIsect+0x4bc>
unpcklps %xmm1,%xmm7
movaps %xmm6,%xmm0
shufps $0x0,%xmm6,%xmm0
subps  %xmm0,%xmm7
unpcklps %xmm12,%xmm9
shufps $0x55,%xmm12,%xmm12
mulps  %xmm12,%xmm7
subps  %xmm9,%xmm12
movaps 0x10(%rsp),%xmm1
movaps 0x40(%rsp),%xmm4
xorps  %xmm0,%xmm0
ucomiss %xmm0,%xmm4
jbe    1609 <NoDivTriTriIsect+0x4f9>
unpcklps %xmm10,%xmm3
movaps %xmm8,%xmm10
shufps $0x0,%xmm8,%xmm8
subps  %xmm8,%xmm3
movaps %xmm11,%xmm1
shufps $0x0,%xmm11,%xmm1
mulps  %xmm1,%xmm3
subps  0x20(%rsp),%xmm1
movaps %xmm3,%xmm8
jmp    16a0 <NoDivTriTriIsect+0x590>
movaps 0x50(%rsp),%xmm4
ucomiss %xmm0,%xmm4
ja     163f <NoDivTriTriIsect+0x52f>
mulss  %xmm11,%xmm1
xorps  %xmm0,%xmm0
ucomiss %xmm0,%xmm1
ja     1671 <NoDivTriTriIsect+0x561>
movaps 0x20(%rsp),%xmm1
ucomiss %xmm0,%xmm1
jne    1671 <NoDivTriTriIsect+0x561>
jp     1671 <NoDivTriTriIsect+0x561>
xorps  %xmm0,%xmm0
movaps 0x10(%rsp),%xmm1
ucomiss %xmm0,%xmm1
jne    163f <NoDivTriTriIsect+0x52f>
jnp    173a <NoDivTriTriIsect+0x62a>
unpcklps %xmm10,%xmm8
movaps %xmm3,%xmm0
shufps $0x0,%xmm3,%xmm0
subps  %xmm0,%xmm8
movaps 0x20(%rsp),%xmm0
movaps %xmm0,%xmm1
shufps $0x55,%xmm0,%xmm1
mulps  %xmm1,%xmm8
movlhps %xmm0,%xmm11
shufps $0xe2,%xmm0,%xmm11
subps  %xmm11,%xmm1
movaps %xmm3,%xmm10
jmp    16a0 <NoDivTriTriIsect+0x590>
unpcklps %xmm3,%xmm8
movaps %xmm10,%xmm0
shufps $0x0,%xmm10,%xmm0
subps  %xmm0,%xmm8
movaps 0x20(%rsp),%xmm0
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
mulps  %xmm1,%xmm8
shufps $0xd4,%xmm0,%xmm11
shufps $0xe2,%xmm0,%xmm11
subps  %xmm11,%xmm1
movaps %xmm12,%xmm0
shufps $0x55,%xmm12,%xmm0
mulps  %xmm12,%xmm0
movaps %xmm1,%xmm3
shufps $0x55,%xmm1,%xmm3
mulps  %xmm1,%xmm3
movaps %xmm0,%xmm4
mulss  %xmm3,%xmm4
mulss  %xmm4,%xmm6
mulps  %xmm12,%xmm7
shufps $0x0,%xmm3,%xmm3
mulps  %xmm7,%xmm3
shufps $0x0,%xmm6,%xmm6
addps  %xmm3,%xmm6
mulss  %xmm10,%xmm4
shufps $0x0,%xmm0,%xmm0
mulps  %xmm8,%xmm0
shufps $0x0,%xmm4,%xmm4
mulps  %xmm1,%xmm0
addps  %xmm4,%xmm0
movaps %xmm6,%xmm1
shufps $0x55,%xmm6,%xmm1
movaps %xmm1,%xmm2
minss  %xmm6,%xmm2
maxss  %xmm1,%xmm6
movaps %xmm0,%xmm1
shufps $0x55,%xmm0,%xmm1
movaps %xmm0,%xmm3
minss  %xmm1,%xmm3
maxss  %xmm0,%xmm1
ucomiss %xmm6,%xmm3
setbe  %al
ucomiss %xmm1,%xmm2
setbe  %cl
and    %al,%cl
movzbl %cl,%eax
add    $0xe8,%rsp
ret
ucomiss %xmm0,%xmm9
jne    152b <NoDivTriTriIsect+0x41b>
jp     152b <NoDivTriTriIsect+0x41b>
jmp    176b <NoDivTriTriIsect+0x65b>
ucomiss %xmm0,%xmm11
jne    1742 <NoDivTriTriIsect+0x632>
jnp    176b <NoDivTriTriIsect+0x65b>
unpcklps %xmm10,%xmm3
movaps %xmm8,%xmm10
shufps $0x0,%xmm8,%xmm8
subps  %xmm8,%xmm3
shufps $0x0,%xmm11,%xmm11
mulps  %xmm11,%xmm3
subps  0x20(%rsp),%xmm11
movaps %xmm11,%xmm1
jmp    1600 <NoDivTriTriIsect+0x4f0>
mov    %r9,(%rsp)
lea    0x34(%rsp),%rdi
mov    %r10,%r9
xor    %eax,%eax
call   1030 <coplanar_tri_tri@plt>
add    $0xe8,%rsp
ret

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

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