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 ((du0 >= 0 ? du0 : -du0) < 0.000001)
    du0 = 0.0;
  if ((du1 >= 0 ? du1 : -du1) < 0.000001)
    du1 = 0.0;
  if ((du2 >= 0 ? du2 : -du2) < 0.000001)
    du2 = 0.0;
  du0du1 = du0 * du1;
  du0du2 = du0 * du2;
  if (du0du1 > 0.0f && du0du2 > 0.0f)
    return 0;
  E1[0] = U1[0] - U0[0];
  E1[1] = U1[1] - U0[1];
  E1[2] = U1[2] - U0[2];
  ;
  E2[0] = U2[0] - U0[0];
  E2[1] = U2[1] - U0[1];
  E2[2] = U2[2] - U0[2];
  ;
  N2[0] = E1[1] * E2[2] - E1[2] * E2[1];
  N2[1] = E1[2] * E2[0] - E1[0] * E2[2];
  N2[2] = E1[0] * E2[1] - E1[1] * E2[0];
  ;
  d2 = -(N2[0] * U0[0] + N2[1] * U0[1] + N2[2] * U0[2]);
  dv0 = (N2[0] * V0[0] + N2[1] * V0[1] + N2[2] * V0[2]) + d2;
  dv1 = (N2[0] * V1[0] + N2[1] * V1[1] + N2[2] * V1[2]) + d2;
  dv2 = (N2[0] * V2[0] + N2[1] * V2[1] + N2[2] * V2[2]) + d2;
  if ((dv0 >= 0 ? dv0 : -dv0) < 0.000001)
    dv0 = 0.0;
  if ((dv1 >= 0 ? dv1 : -dv1) < 0.000001)
    dv1 = 0.0;
  if ((dv2 >= 0 ? dv2 : -dv2) < 0.000001)
    dv2 = 0.0;
  dv0dv1 = dv0 * dv1;
  dv0dv2 = dv0 * dv2;
  if (dv0dv1 > 0.0f && dv0dv2 > 0.0f)
    return 0;
  D[0] = N1[1] * N2[2] - N1[2] * N2[1];
  D[1] = N1[2] * N2[0] - N1[0] * N2[2];
  D[2] = N1[0] * N2[1] - N1[1] * N2[0];
  ;
  max = (float)(D[0] >= 0 ? D[0] : -D[0]);
  index = 0;
  bb = (float)(D[1] >= 0 ? D[1] : -D[1]);
  cc = (float)(D[2] >= 0 ? D[2] : -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    $0x150,%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
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     137a <NoDivTriTriIsect+0x26a>
movss  -0x74(%rbp),%xmm0
movss  %xmm0,-0x120(%rbp)
ff
jmp    1394 <NoDivTriTriIsect+0x284>
movss  -0x74(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x120(%rbp)
ff
movss  -0x120(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
movsd  0x1c58(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    13ba <NoDivTriTriIsect+0x2aa>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x78(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     13dd <NoDivTriTriIsect+0x2cd>
movss  -0x78(%rbp),%xmm0
movss  %xmm0,-0x124(%rbp)
ff
jmp    13f7 <NoDivTriTriIsect+0x2e7>
movss  -0x78(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x124(%rbp)
ff
movss  -0x124(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
movsd  0x1bf5(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    141d <NoDivTriTriIsect+0x30d>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x7c(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     1440 <NoDivTriTriIsect+0x330>
movss  -0x7c(%rbp),%xmm0
movss  %xmm0,-0x128(%rbp)
ff
jmp    145a <NoDivTriTriIsect+0x34a>
movss  -0x7c(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x128(%rbp)
ff
movss  -0x128(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
movsd  0x1b92(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1480 <NoDivTriTriIsect+0x370>
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    14d8 <NoDivTriTriIsect+0x3c8>
movss  -0xac(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    14d8 <NoDivTriTriIsect+0x3c8>
movl   $0x0,-0x4(%rbp)
jmp    23ae <NoDivTriTriIsect+0x129e>
mov    -0x30(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x28(%rbp),%rax
subss  (%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x30(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x28(%rbp),%rax
subss  0x4(%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x30(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x28(%rbp),%rax
subss  0x8(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x38(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x28(%rbp),%rax
subss  (%rax),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x38(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x28(%rbp),%rax
subss  0x4(%rax),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x38(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x28(%rbp),%rax
subss  0x8(%rax),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x40(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x3c(%rbp),%xmm1
mulss  -0x4c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  -0x48(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x44(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  -0x50(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x68(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x64(%rbp),%xmm0
mov    -0x28(%rbp),%rax
mulss  0x4(%rax),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x60(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x68(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x64(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x4(%rax),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x60(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
addss  -0x70(%rbp),%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x68(%rbp),%xmm1
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x64(%rbp),%xmm0
mov    -0x18(%rbp),%rax
mulss  0x4(%rax),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x60(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
addss  -0x70(%rbp),%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x68(%rbp),%xmm1
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x64(%rbp),%xmm0
mov    -0x20(%rbp),%rax
mulss  0x4(%rax),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x60(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
addss  -0x70(%rbp),%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x80(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     1725 <NoDivTriTriIsect+0x615>
movss  -0x80(%rbp),%xmm0
movss  %xmm0,-0x12c(%rbp)
ff
jmp    173f <NoDivTriTriIsect+0x62f>
movss  -0x80(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x12c(%rbp)
ff
movss  -0x12c(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
movsd  0x18ad(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1765 <NoDivTriTriIsect+0x655>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x84(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     178e <NoDivTriTriIsect+0x67e>
movss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0x130(%rbp)
ff
jmp    17ab <NoDivTriTriIsect+0x69b>
movss  -0x84(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x130(%rbp)
ff
movss  -0x130(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
movsd  0x1841(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    17d4 <NoDivTriTriIsect+0x6c4>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x88(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     17fd <NoDivTriTriIsect+0x6ed>
movss  -0x88(%rbp),%xmm0
ff
movss  %xmm0,-0x134(%rbp)
ff
jmp    181a <NoDivTriTriIsect+0x70a>
movss  -0x88(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x134(%rbp)
ff
movss  -0x134(%rbp),%xmm0
ff
cvtss2sd %xmm0,%xmm1
movsd  0x17d2(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1843 <NoDivTriTriIsect+0x733>
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    18a1 <NoDivTriTriIsect+0x791>
movss  -0xb4(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    18a1 <NoDivTriTriIsect+0x791>
movl   $0x0,-0x4(%rbp)
jmp    23ae <NoDivTriTriIsect+0x129e>
movss  -0x58(%rbp),%xmm0
movss  -0x60(%rbp),%xmm2
movss  -0x54(%rbp),%xmm1
mulss  -0x64(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x94(%rbp)
ff
movss  -0x54(%rbp),%xmm0
movss  -0x68(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
mulss  -0x60(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x90(%rbp)
ff
movss  -0x5c(%rbp),%xmm0
movss  -0x64(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
mulss  -0x68(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
movss  -0x94(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     195d <NoDivTriTriIsect+0x84d>
movss  -0x94(%rbp),%xmm0
ff
movss  %xmm0,-0x138(%rbp)
ff
jmp    197a <NoDivTriTriIsect+0x86a>
movss  -0x94(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x138(%rbp)
ff
movss  -0x138(%rbp),%xmm0
ff
movss  %xmm0,-0xdc(%rbp)
ff
movw   $0x0,-0xb6(%rbp)
movss  -0x90(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     19bc <NoDivTriTriIsect+0x8ac>
movss  -0x90(%rbp),%xmm0
ff
movss  %xmm0,-0x13c(%rbp)
ff
jmp    19d9 <NoDivTriTriIsect+0x8c9>
movss  -0x90(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x13c(%rbp)
ff
movss  -0x13c(%rbp),%xmm0
ff
movss  %xmm0,-0xd4(%rbp)
ff
movss  -0x8c(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     1a12 <NoDivTriTriIsect+0x902>
movss  -0x8c(%rbp),%xmm0
ff
movss  %xmm0,-0x140(%rbp)
ff
jmp    1a2f <NoDivTriTriIsect+0x91f>
movss  -0x8c(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x140(%rbp)
ff
movss  -0x140(%rbp),%xmm0
ff
movss  %xmm0,-0xd8(%rbp)
ff
movss  -0xd4(%rbp),%xmm0
ff
ucomiss -0xdc(%rbp),%xmm0
jbe    1a6d <NoDivTriTriIsect+0x95d>
movss  -0xd4(%rbp),%xmm0
ff
movss  %xmm0,-0xdc(%rbp)
ff
movw   $0x1,-0xb6(%rbp)
movss  -0xd8(%rbp),%xmm0
ff
ucomiss -0xdc(%rbp),%xmm0
jbe    1a9b <NoDivTriTriIsect+0x98b>
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    1bc7 <NoDivTriTriIsect+0xab7>
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    1e93 <NoDivTriTriIsect+0xd83>
movss  -0xb4(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    1c5d <NoDivTriTriIsect+0xb4d>
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    1e8e <NoDivTriTriIsect+0xd7e>
movss  -0x84(%rbp),%xmm0
ff
mulss  -0x88(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
ja     1c95 <NoDivTriTriIsect+0xb85>
movss  -0x80(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1c95 <NoDivTriTriIsect+0xb85>
jp     1c95 <NoDivTriTriIsect+0xb85>
jmp    1d0e <NoDivTriTriIsect+0xbfe>
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
movss  %xmm0,-0xf0(%rbp)
ff
jmp    1e89 <NoDivTriTriIsect+0xd79>
movss  -0x84(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1d2d <NoDivTriTriIsect+0xc1d>
jp     1d2d <NoDivTriTriIsect+0xc1d>
jmp    1daf <NoDivTriTriIsect+0xc9f>
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    1e84 <NoDivTriTriIsect+0xd74>
movss  -0x88(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1dce <NoDivTriTriIsect+0xcbe>
jp     1dce <NoDivTriTriIsect+0xcbe>
jmp    1e50 <NoDivTriTriIsect+0xd40>
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    1e7f <NoDivTriTriIsect+0xd6f>
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    23ae <NoDivTriTriIsect+0x129e>
jmp    1e84 <NoDivTriTriIsect+0xd74>
jmp    1e89 <NoDivTriTriIsect+0xd79>
jmp    1e8e <NoDivTriTriIsect+0xd7e>
jmp    1e93 <NoDivTriTriIsect+0xd83>
movss  -0xa8(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    1f1a <NoDivTriTriIsect+0xe0a>
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    21a7 <NoDivTriTriIsect+0x1097>
movss  -0xac(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    1fa1 <NoDivTriTriIsect+0xe91>
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    21a2 <NoDivTriTriIsect+0x1092>
movss  -0x78(%rbp),%xmm0
mulss  -0x7c(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
ja     1fd3 <NoDivTriTriIsect+0xec3>
movss  -0x74(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1fd3 <NoDivTriTriIsect+0xec3>
jp     1fd3 <NoDivTriTriIsect+0xec3>
jmp    2046 <NoDivTriTriIsect+0xf36>
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
subss  -0xc8(%rbp),%xmm0
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    219d <NoDivTriTriIsect+0x108d>
movss  -0x78(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    2062 <NoDivTriTriIsect+0xf52>
jp     2062 <NoDivTriTriIsect+0xf52>
jmp    20d5 <NoDivTriTriIsect+0xfc5>
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    2198 <NoDivTriTriIsect+0x1088>
movss  -0x7c(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    20f1 <NoDivTriTriIsect+0xfe1>
jp     20f1 <NoDivTriTriIsect+0xfe1>
jmp    2164 <NoDivTriTriIsect+0x1054>
movss  -0xd0(%rbp),%xmm0
ff
movss  %xmm0,-0xf4(%rbp)
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    2193 <NoDivTriTriIsect+0x1083>
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    23ae <NoDivTriTriIsect+0x129e>
jmp    2198 <NoDivTriTriIsect+0x1088>
jmp    219d <NoDivTriTriIsect+0x108d>
jmp    21a2 <NoDivTriTriIsect+0x1092>
jmp    21a7 <NoDivTriTriIsect+0x1097>
movss  -0xec(%rbp),%xmm0
ff
mulss  -0xf0(%rbp),%xmm0
ff
movss  %xmm0,-0x108(%rbp)
ff
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    2324 <NoDivTriTriIsect+0x1214>
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    2369 <NoDivTriTriIsect+0x1259>
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     239b <NoDivTriTriIsect+0x128b>
movss  -0xa0(%rbp),%xmm1
ff
movss  -0x9c(%rbp),%xmm0
ff
ucomiss %xmm1,%xmm0
jbe    23a7 <NoDivTriTriIsect+0x1297>
movl   $0x0,-0x4(%rbp)
jmp    23ae <NoDivTriTriIsect+0x129e>
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x150,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<NoDivTriTriIsect>:
sub    $0xf8,%rsp
mov    %r8,%r10
mov    %rcx,%r8
mov    %rdx,%rcx
mov    %rsi,%rdx
mov    %rdi,%rsi
movss  0x4(%rdx),%xmm3
movsd  (%rdi),%xmm11
movaps %xmm11,%xmm1
shufps $0x55,%xmm11,%xmm1
movaps %xmm3,0xa0(%rsp)
subss  %xmm1,%xmm3
movss  0x8(%rdx),%xmm0
movss  0x8(%rdi),%xmm2
movss  (%rdx),%xmm1
movaps %xmm1,0xd0(%rsp)
movaps %xmm0,0xe0(%rsp)
unpcklps %xmm0,%xmm1
movaps %xmm2,%xmm4
movlhps %xmm11,%xmm4
shufps $0xe2,%xmm11,%xmm4
subps  %xmm4,%xmm1
movaps %xmm1,%xmm5
movaps %xmm3,%xmm0
movlhps %xmm1,%xmm3
shufps $0xe2,%xmm1,%xmm3
shufps $0xe1,%xmm1,%xmm1
movsd  (%rcx),%xmm12
movaps %xmm12,0x90(%rsp)
subps  %xmm11,%xmm12
movss  0x8(%rcx),%xmm6
movaps %xmm6,0xb0(%rsp)
subss  %xmm2,%xmm6
shufps $0x55,%xmm5,%xmm5
movaps %xmm12,%xmm7
shufps $0x55,%xmm12,%xmm7
mulss  %xmm5,%xmm7
mulss  %xmm6,%xmm0
subss  %xmm7,%xmm0
movss  %xmm0,0x14(%rsp)
unpcklps %xmm12,%xmm6
mulps  %xmm3,%xmm6
mulps  %xmm1,%xmm12
subps  %xmm6,%xmm12
movaps %xmm12,%xmm3
shufps $0x55,%xmm12,%xmm3
movss  %xmm12,0x18(%rsp)
movss  %xmm3,0x1c(%rsp)
movsd  (%r8),%xmm4
movss  0x8(%r8),%xmm7
movsd  (%r10),%xmm15
movaps %xmm12,%xmm5
shufps $0x0,%xmm12,%xmm5
movaps %xmm15,%xmm1
shufps $0x55,%xmm4,%xmm1
shufps $0x52,%xmm4,%xmm1
mulps  %xmm5,%xmm1
movaps %xmm0,0x70(%rsp)
movaps %xmm0,%xmm6
shufps $0x0,%xmm0,%xmm6
movaps %xmm4,%xmm0
unpcklps %xmm15,%xmm0
mulps  %xmm6,%xmm0
addps  %xmm1,%xmm0
movss  0x8(%r10),%xmm13
movaps %xmm7,0x80(%rsp)
movaps %xmm7,%xmm1
unpcklps %xmm13,%xmm1
mulps  %xmm3,%xmm1
addps  %xmm0,%xmm1
movaps %xmm11,%xmm0
shufps $0x1,%xmm12,%xmm0
shufps $0xe2,%xmm12,%xmm0
movsd  0x4(%r9),%xmm14
movaps %xmm14,%xmm5
unpcklps %xmm12,%xmm5
mulps  %xmm0,%xmm5
movss  (%r9),%xmm10
movaps %xmm10,%xmm0
unpcklps %xmm11,%xmm0
mulps  %xmm6,%xmm0
addps  %xmm5,%xmm0
movaps %xmm2,0xc0(%rsp)
movaps %xmm2,%xmm6
shufps $0xd4,%xmm14,%xmm6
shufps $0x52,%xmm14,%xmm6
mulps  %xmm3,%xmm6
addps  %xmm0,%xmm6
movaps %xmm6,%xmm0
shufps $0x55,%xmm6,%xmm0
subps  %xmm0,%xmm1
subss  %xmm0,%xmm6
xorps  %xmm0,%xmm0
cmpleps %xmm1,%xmm0
movaps 0xd4d(%rip),%xmm9
movaps %xmm1,%xmm5
xorps  %xmm9,%xmm5
movaps %xmm1,%xmm7
andps  %xmm0,%xmm7
andnps %xmm5,%xmm0
orps   %xmm7,%xmm0
cvtps2pd %xmm0,%xmm0
cmpltpd 0xd3e(%rip),%xmm0
shufps $0xe8,%xmm0,%xmm0
xorps  %xmm8,%xmm8
andps  %xmm0,%xmm8
andnps %xmm1,%xmm0
movaps %xmm6,%xmm1
xorps  %xmm9,%xmm1
xorps  %xmm5,%xmm5
cmpless %xmm6,%xmm5
movaps %xmm5,%xmm7
andnps %xmm1,%xmm5
andps  %xmm6,%xmm7
orps   %xmm7,%xmm5
xorps  %xmm1,%xmm1
cvtss2sd %xmm5,%xmm1
movaps %xmm8,%xmm5
movsd  0xd11(%rip),%xmm2
ucomisd %xmm1,%xmm2
orps   %xmm0,%xmm5
pshufd $0x55,%xmm0,%xmm7
xorps  %xmm1,%xmm1
xorps  %xmm8,%xmm8
ja     1328 <NoDivTriTriIsect+0x218>
movaps %xmm6,%xmm8
movaps %xmm5,%xmm0
mulss  %xmm7,%xmm0
movaps %xmm5,%xmm6
mulss  %xmm8,%xmm6
xor    %eax,%eax
movaps %xmm0,0x30(%rsp)
ucomiss %xmm1,%xmm0
jbe    1353 <NoDivTriTriIsect+0x243>
xorps  %xmm0,%xmm0
ucomiss %xmm0,%xmm6
jbe    1353 <NoDivTriTriIsect+0x243>
add    $0xf8,%rsp
ret
movaps %xmm3,0x60(%rsp)
movaps %xmm6,0x50(%rsp)
movaps %xmm7,0x40(%rsp)
movaps %xmm5,0x20(%rsp)
movaps %xmm4,%xmm0
shufps $0x55,%xmm4,%xmm0
subps  %xmm4,%xmm15
movaps 0x80(%rsp),%xmm5
subss  %xmm5,%xmm13
subss  %xmm4,%xmm10
movaps %xmm5,%xmm1
movlhps %xmm0,%xmm1
shufps $0xe2,%xmm0,%xmm1
subps  %xmm1,%xmm14
movaps %xmm14,%xmm0
shufps $0x55,%xmm14,%xmm0
mulss  %xmm15,%xmm0
movaps %xmm13,%xmm9
mulss  %xmm10,%xmm9
subss  %xmm0,%xmm9
shufps $0xd4,%xmm15,%xmm13
shufps $0x52,%xmm15,%xmm13
unpcklps %xmm14,%xmm10
mulps  %xmm13,%xmm10
mulps  %xmm15,%xmm14
subps  %xmm10,%xmm14
movaps 0xd0(%rsp),%xmm6
unpcklps %xmm11,%xmm6
movaps 0xa0(%rsp),%xmm0
movss  %xmm0,%xmm11
movaps %xmm9,%xmm1
shufps $0x0,%xmm9,%xmm1
mulps  %xmm1,%xmm11
movaps %xmm14,%xmm0
shufps $0x55,%xmm14,%xmm0
mulps  %xmm0,%xmm6
addps  %xmm11,%xmm6
movaps 0xe0(%rsp),%xmm3
unpcklps 0xc0(%rsp),%xmm3
movapd %xmm2,%xmm11
movaps %xmm14,%xmm2
shufps $0x0,%xmm14,%xmm2
mulps  %xmm2,%xmm3
addps  %xmm6,%xmm3
movaps %xmm4,%xmm6
movaps 0x90(%rsp),%xmm7
shufps $0x11,%xmm7,%xmm6
shufps $0xe2,%xmm7,%xmm6
mulps  %xmm1,%xmm6
unpcklps %xmm4,%xmm7
mulps  %xmm0,%xmm7
addps  %xmm6,%xmm7
movaps 0xb0(%rsp),%xmm4
unpcklps %xmm5,%xmm4
mulps  %xmm2,%xmm4
addps  %xmm7,%xmm4
movaps %xmm4,%xmm1
shufps $0x55,%xmm4,%xmm1
subps  %xmm1,%xmm3
subss  %xmm1,%xmm4
xorps  %xmm13,%xmm13
xorps  %xmm2,%xmm2
cmpleps %xmm3,%xmm2
movaps %xmm3,%xmm6
movaps 0xb8a(%rip),%xmm10
xorps  %xmm10,%xmm6
movaps %xmm3,%xmm7
andps  %xmm2,%xmm7
andnps %xmm6,%xmm2
orps   %xmm7,%xmm2
cvtps2pd %xmm2,%xmm2
cmpltpd 0xb7e(%rip),%xmm2
shufps $0xe8,%xmm2,%xmm2
andps  %xmm2,%xmm13
andnps %xmm3,%xmm2
movaps %xmm4,%xmm3
xorps  %xmm10,%xmm3
xorps  %xmm6,%xmm6
cmpless %xmm4,%xmm6
movaps %xmm6,%xmm7
andnps %xmm3,%xmm6
andps  %xmm4,%xmm7
orps   %xmm7,%xmm6
orps   %xmm2,%xmm13
pshufd $0x55,%xmm2,%xmm2
xorps  %xmm3,%xmm3
cvtss2sd %xmm6,%xmm3
ucomisd %xmm3,%xmm11
xorps  %xmm6,%xmm6
xorps  %xmm15,%xmm15
ja     14da <NoDivTriTriIsect+0x3ca>
movaps %xmm4,%xmm15
movdqa %xmm2,%xmm3
mulss  %xmm13,%xmm3
movdqa %xmm2,%xmm4
mulss  %xmm15,%xmm4
ucomiss %xmm6,%xmm3
jbe    14fd <NoDivTriTriIsect+0x3ed>
xorps  %xmm6,%xmm6
ucomiss %xmm6,%xmm4
ja     134b <NoDivTriTriIsect+0x23b>
movaps %xmm8,%xmm11
movaps 0x70(%rsp),%xmm1
movaps %xmm1,%xmm6
movaps 0x60(%rsp),%xmm7
movlhps %xmm7,%xmm6
shufps $0xe2,%xmm7,%xmm6
movaps %xmm9,%xmm7
unpcklps %xmm14,%xmm7
mulps  %xmm6,%xmm7
movaps %xmm12,%xmm6
mulps  %xmm14,%xmm6
subps  %xmm7,%xmm6
mulss  %xmm12,%xmm0
mulss  %xmm9,%xmm1
subss  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cmpleps %xmm6,%xmm0
movaps %xmm6,%xmm5
xorps  %xmm10,%xmm5
andps  %xmm0,%xmm6
andnps %xmm5,%xmm0
orps   %xmm6,%xmm0
xorps  %xmm1,%xmm10
xorps  %xmm5,%xmm5
xorps  %xmm6,%xmm6
cmpless %xmm1,%xmm6
andps  %xmm6,%xmm1
andnps %xmm10,%xmm6
pshufd $0x55,%xmm0,%xmm7
xor    %eax,%eax
ucomiss %xmm0,%xmm7
seta   %al
orps   %xmm1,%xmm6
maxss  %xmm0,%xmm7
ucomiss %xmm7,%xmm6
mov    $0x2,%edi
cmovbe %rax,%rdi
ucomiss %xmm5,%xmm3
movss  (%rsi,%rdi,4),%xmm6
movss  (%rdx,%rdi,4),%xmm7
movss  (%rcx,%rdi,4),%xmm3
movss  (%r8,%rdi,4),%xmm10
movss  (%r10,%rdi,4),%xmm0
movss  (%r9,%rdi,4),%xmm8
jbe    15da <NoDivTriTriIsect+0x4ca>
unpcklps %xmm7,%xmm6
movaps %xmm3,%xmm2
shufps $0x0,%xmm3,%xmm2
subps  %xmm2,%xmm6
shufps $0x0,%xmm15,%xmm15
movaps %xmm6,%xmm7
mulps  %xmm15,%xmm7
subps  %xmm13,%xmm15
movaps %xmm3,%xmm6
movaps %xmm15,%xmm13
movaps 0x20(%rsp),%xmm4
jmp    1692 <NoDivTriTriIsect+0x582>
ucomiss %xmm5,%xmm4
ja     1602 <NoDivTriTriIsect+0x4f2>
movaps %xmm13,%xmm5
mulss  %xmm15,%xmm5
xorps  %xmm4,%xmm4
ucomiss %xmm4,%xmm5
ja     1638 <NoDivTriTriIsect+0x528>
ucomiss %xmm4,%xmm2
jne    1638 <NoDivTriTriIsect+0x528>
jp     1638 <NoDivTriTriIsect+0x528>
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm13
jne    1602 <NoDivTriTriIsect+0x4f2>
jnp    165d <NoDivTriTriIsect+0x54d>
unpcklps %xmm3,%xmm6
movaps %xmm7,%xmm2
shufps $0x0,%xmm7,%xmm2
subps  %xmm2,%xmm6
movaps %xmm13,%xmm2
shufps $0x0,%xmm13,%xmm2
movaps %xmm6,%xmm3
mulps  %xmm2,%xmm3
movss  %xmm15,%xmm13
subps  %xmm13,%xmm2
movaps %xmm7,%xmm6
movaps %xmm3,%xmm7
movaps %xmm2,%xmm13
movaps 0x20(%rsp),%xmm4
jmp    1692 <NoDivTriTriIsect+0x582>
unpcklps %xmm3,%xmm7
movaps %xmm6,%xmm2
shufps $0x0,%xmm6,%xmm2
subps  %xmm2,%xmm7
unpcklps %xmm13,%xmm15
shufps $0x55,%xmm13,%xmm13
mulps  %xmm13,%xmm7
subps  %xmm15,%xmm13
movaps 0x20(%rsp),%xmm4
jmp    1692 <NoDivTriTriIsect+0x582>
ucomiss %xmm2,%xmm15
movaps 0x20(%rsp),%xmm4
jne    166e <NoDivTriTriIsect+0x55e>
jnp    180c <NoDivTriTriIsect+0x6fc>
unpcklps %xmm7,%xmm6
movaps %xmm3,%xmm2
shufps $0x0,%xmm3,%xmm2
subps  %xmm2,%xmm6
shufps $0x0,%xmm15,%xmm15
movaps %xmm6,%xmm7
mulps  %xmm15,%xmm7
subps  %xmm13,%xmm15
movaps %xmm3,%xmm6
movaps %xmm15,%xmm13
movaps 0x30(%rsp),%xmm3
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm3
jbe    16c8 <NoDivTriTriIsect+0x5b8>
unpcklps %xmm10,%xmm0
movaps %xmm8,%xmm10
shufps $0x0,%xmm8,%xmm8
subps  %xmm8,%xmm0
movaps %xmm11,%xmm2
shufps $0x0,%xmm11,%xmm2
mulps  %xmm2,%xmm0
subps  %xmm4,%xmm2
movaps %xmm0,%xmm8
jmp    1755 <NoDivTriTriIsect+0x645>
movaps 0x50(%rsp),%xmm3
ucomiss %xmm2,%xmm3
ja     16fe <NoDivTriTriIsect+0x5ee>
movaps 0x40(%rsp),%xmm3
mulss  %xmm11,%xmm3
xorps  %xmm2,%xmm2
ucomiss %xmm2,%xmm3
ja     172b <NoDivTriTriIsect+0x61b>
ucomiss %xmm2,%xmm4
jne    172b <NoDivTriTriIsect+0x61b>
jp     172b <NoDivTriTriIsect+0x61b>
xorps  %xmm2,%xmm2
movaps 0x40(%rsp),%xmm3
ucomiss %xmm2,%xmm3
jne    16fe <NoDivTriTriIsect+0x5ee>
jnp    17dd <NoDivTriTriIsect+0x6cd>
unpcklps %xmm10,%xmm8
movaps %xmm0,%xmm2
shufps $0x0,%xmm0,%xmm2
subps  %xmm2,%xmm8
movaps %xmm4,%xmm2
shufps $0x55,%xmm4,%xmm2
mulps  %xmm2,%xmm8
movlhps %xmm4,%xmm11
shufps $0xe2,%xmm4,%xmm11
subps  %xmm11,%xmm2
movaps %xmm0,%xmm10
jmp    1755 <NoDivTriTriIsect+0x645>
unpcklps %xmm0,%xmm8
movaps %xmm10,%xmm0
shufps $0x0,%xmm10,%xmm0
subps  %xmm0,%xmm8
movaps %xmm4,%xmm2
shufps $0x0,%xmm4,%xmm2
mulps  %xmm2,%xmm8
shufps $0xd4,%xmm4,%xmm11
shufps $0xe2,%xmm4,%xmm11
subps  %xmm11,%xmm2
movaps %xmm13,%xmm0
shufps $0x55,%xmm13,%xmm0
mulps  %xmm13,%xmm0
movaps %xmm2,%xmm3
shufps $0x55,%xmm2,%xmm3
mulps  %xmm2,%xmm3
movaps %xmm0,%xmm4
mulss  %xmm3,%xmm4
mulss  %xmm4,%xmm6
mulps  %xmm13,%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  %xmm2,%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    $0xf8,%rsp
ret
ucomiss %xmm2,%xmm11
jne    17e5 <NoDivTriTriIsect+0x6d5>
jnp    180c <NoDivTriTriIsect+0x6fc>
unpcklps %xmm10,%xmm0
movaps %xmm8,%xmm10
shufps $0x0,%xmm8,%xmm8
subps  %xmm8,%xmm0
shufps $0x0,%xmm11,%xmm11
mulps  %xmm11,%xmm0
subps  %xmm4,%xmm11
movaps %xmm11,%xmm2
jmp    16bf <NoDivTriTriIsect+0x5af>
mov    %r9,(%rsp)
lea    0x14(%rsp),%rdi
mov    %r10,%r9
xor    %eax,%eax
call   1030 <coplanar_tri_tri@plt>
add    $0xf8,%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 = fcmp oge float %222, 0.000000e+00
br i1 %223, label %224, label %226
224: ; preds = %6
%225 = load float, float* %20
br label %229
226: ; preds = %6
%227 = load float, float* %20
%228 = fneg float %227
br label %229
229: ; preds = %226, %224
%230 = phi float [ %225, %224 ], [ %228, %226 ]
%231 = fpext float %230 to double
%232 = fcmp olt double %231, 0x3EB0C6F7A0B5ED8D
br i1 %232, label %233, label %234
233: ; preds = %229
store float 0.000000e+00, float* %20
br label %234
234: ; preds = %233, %229
%235 = load float, float* %21
%236 = fcmp oge float %235, 0.000000e+00
br i1 %236, label %237, label %239
237: ; preds = %234
%238 = load float, float* %21
br label %242
239: ; preds = %234
%240 = load float, float* %21
%241 = fneg float %240
br label %242
242: ; preds = %239, %237
%243 = phi float [ %238, %237 ], [ %241, %239 ]
%244 = fpext float %243 to double
%245 = fcmp olt double %244, 0x3EB0C6F7A0B5ED8D
br i1 %245, label %246, label %247
246: ; preds = %242
store float 0.000000e+00, float* %21
br label %247
247: ; preds = %246, %242
%248 = load float, float* %22
%249 = fcmp oge float %248, 0.000000e+00
br i1 %249, label %250, label %252
250: ; preds = %247
%251 = load float, float* %22
br label %255
252: ; preds = %247
%253 = load float, float* %22
%254 = fneg float %253
br label %255
255: ; preds = %252, %250
%256 = phi float [ %251, %250 ], [ %254, %252 ]
%257 = fpext float %256 to double
%258 = fcmp olt double %257, 0x3EB0C6F7A0B5ED8D
br i1 %258, label %259, label %260
259: ; preds = %255
store float 0.000000e+00, float* %22
br label %260
260: ; preds = %259, %255
%261 = load float, float* %20
%262 = load float, float* %21
%263 = fmul float %261, %262
store float %263, float* %29
%264 = load float, float* %20
%265 = load float, float* %22
%266 = fmul float %264, %265
store float %266, float* %30
%267 = load float, float* %29
%268 = fcmp ogt float %267, 0.000000e+00
br i1 %268, label %269, label %273
269: ; preds = %260
%270 = load float, float* %30
%271 = fcmp ogt float %270, 0.000000e+00
br i1 %271, label %272, label %273
272: ; preds = %269
store i32 0, i32* %7
br label %933
273: ; preds = %269, %260
%274 = load float*, float** %12
%275 = getelementptr inbounds float, float* %274, i64 0
%276 = load float, float* %275
%277 = load float*, float** %11
%278 = getelementptr inbounds float, float* %277, i64 0
%279 = load float, float* %278
%280 = fsub float %276, %279
%281 = getelementptr inbounds [3 x float], [3 x float]* %14, i64 0, i64 0
store float %280, float* %281
%282 = load float*, float** %12
%283 = getelementptr inbounds float, float* %282, i64 1
%284 = load float, float* %283
%285 = load float*, float** %11
%286 = getelementptr inbounds float, float* %285, i64 1
%287 = load float, float* %286
%288 = fsub float %284, %287
%289 = getelementptr inbounds [3 x float], [3 x float]* %14, i64 0, i64 1
store float %288, float* %289
%290 = load float*, float** %12
%291 = getelementptr inbounds float, float* %290, i64 2
%292 = load float, float* %291
%293 = load float*, float** %11
%294 = getelementptr inbounds float, float* %293, i64 2
%295 = load float, float* %294
%296 = fsub float %292, %295
%297 = getelementptr inbounds [3 x float], [3 x float]* %14, i64 0, i64 2
store float %296, float* %297
%298 = load float*, float** %13
%299 = getelementptr inbounds float, float* %298, i64 0
%300 = load float, float* %299
%301 = load float*, float** %11
%302 = getelementptr inbounds float, float* %301, i64 0
%303 = load float, float* %302
%304 = fsub float %300, %303
%305 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 0
store float %304, float* %305
%306 = load float*, float** %13
%307 = getelementptr inbounds float, float* %306, i64 1
%308 = load float, float* %307
%309 = load float*, float** %11
%310 = getelementptr inbounds float, float* %309, i64 1
%311 = load float, float* %310
%312 = fsub float %308, %311
%313 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 1
store float %312, float* %313
%314 = load float*, float** %13
%315 = getelementptr inbounds float, float* %314, i64 2
%316 = load float, float* %315
%317 = load float*, float** %11
%318 = getelementptr inbounds float, float* %317, i64 2
%319 = load float, float* %318
%320 = fsub float %316, %319
%321 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 2
store float %320, float* %321
%322 = getelementptr inbounds [3 x float], [3 x float]* %14, i64 0, i64 1
%323 = load float, float* %322
%324 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 2
%325 = load float, float* %324
%326 = getelementptr inbounds [3 x float], [3 x float]* %14, i64 0, i64 2
%327 = load float, float* %326
%328 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 1
%329 = load float, float* %328
%330 = fmul float %327, %329
%331 = fneg float %330
%332 = call float @llvm.fmuladd.f32(float %323, float %325, float %331)
%333 = getelementptr inbounds [3 x float], [3 x float]* %17, i64 0, i64 0
store float %332, float* %333
%334 = getelementptr inbounds [3 x float], [3 x float]* %14, i64 0, i64 2
%335 = load float, float* %334
%336 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 0
%337 = load float, float* %336
%338 = getelementptr inbounds [3 x float], [3 x float]* %14, i64 0, i64 0
%339 = load float, float* %338
%340 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 2
%341 = load float, float* %340
%342 = fmul float %339, %341
%343 = fneg float %342
%344 = call float @llvm.fmuladd.f32(float %335, float %337, float %343)
%345 = getelementptr inbounds [3 x float], [3 x float]* %17, i64 0, i64 1
store float %344, float* %345
%346 = getelementptr inbounds [3 x float], [3 x float]* %14, i64 0, i64 0
%347 = load float, float* %346
%348 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 1
%349 = load float, float* %348
%350 = getelementptr inbounds [3 x float], [3 x float]* %14, i64 0, i64 1
%351 = load float, float* %350
%352 = getelementptr inbounds [3 x float], [3 x float]* %15, i64 0, i64 0
%353 = load float, float* %352
%354 = fmul float %351, %353
%355 = fneg float %354
%356 = call float @llvm.fmuladd.f32(float %347, float %349, float %355)
%357 = getelementptr inbounds [3 x float], [3 x float]* %17, i64 0, i64 2
store float %356, float* %357
%358 = getelementptr inbounds [3 x float], [3 x float]* %17, i64 0, i64 0
%359 = load float, float* %358
%360 = load float*, float** %11
%361 = getelementptr inbounds float, float* %360, i64 0
%362 = load float, float* %361
%363 = getelementptr inbounds [3 x float], [3 x float]* %17, i64 0, i64 1
%364 = load float, float* %363
%365 = load float*, float** %11
%366 = getelementptr inbounds float, float* %365, i64 1
%367 = load float, float* %366
%368 = fmul float %364, %367
%369 = call float @llvm.fmuladd.f32(float %359, float %362, float %368)
%370 = getelementptr inbounds [3 x float], [3 x float]* %17, i64 0, i64 2
%371 = load float, float* %370
%372 = load float*, float** %11
%373 = getelementptr inbounds float, float* %372, i64 2
%374 = load float, float* %373
%375 = call float @llvm.fmuladd.f32(float %371, float %374, float %369)
%376 = fneg float %375
store float %376, float* %19
%377 = getelementptr inbounds [3 x float], [3 x float]* %17, i64 0, i64 0
%378 = load float, float* %377
%379 = load float*, float** %8
%380 = getelementptr inbounds float, float* %379, i64 0
%381 = load float, float* %380
%382 = getelementptr inbounds [3 x float], [3 x float]* %17, i64 0, i64 1
%383 = load float, float* %382
%384 = load float*, float** %8
%385 = getelementptr inbounds float, float* %384, i64 1
%386 = load float, float* %385
%387 = fmul float %383, %386
%388 = call float @llvm.fmuladd.f32(float %378, float %381, float %387)
%389 = getelementptr inbounds [3 x float], [3 x float]* %17, i64 0, i64 2
%390 = load float, float* %389
%391 = load float*, float** %8
%392 = getelementptr inbounds float, float* %391, i64 2
%393 = load float, float* %392
%394 = call float @llvm.fmuladd.f32(float %390, float %393, float %388)
%395 = load float, float* %19
%396 = fadd float %394, %395
store float %396, float* %23
%397 = getelementptr inbounds [3 x float], [3 x float]* %17, i64 0, i64 0
%398 = load float, float* %397
%399 = load float*, float** %9
%400 = getelementptr inbounds float, float* %399, i64 0
%401 = load float, float* %400
%402 = getelementptr inbounds [3 x float], [3 x float]* %17, i64 0, i64 1
%403 = load float, float* %402
%404 = load float*, float** %9
%405 = getelementptr inbounds float, float* %404, i64 1
%406 = load float, float* %405
%407 = fmul float %403, %406
%408 = call float @llvm.fmuladd.f32(float %398, float %401, float %407)
%409 = getelementptr inbounds [3 x float], [3 x float]* %17, i64 0, i64 2
%410 = load float, float* %409
%411 = load float*, float** %9
%412 = getelementptr inbounds float, float* %411, i64 2
%413 = load float, float* %412
%414 = call float @llvm.fmuladd.f32(float %410, float %413, float %408)
%415 = load float, float* %19
%416 = fadd float %414, %415
store float %416, float* %24
%417 = getelementptr inbounds [3 x float], [3 x float]* %17, i64 0, i64 0
%418 = load float, float* %417
%419 = load float*, float** %10
%420 = getelementptr inbounds float, float* %419, i64 0
%421 = load float, float* %420
%422 = getelementptr inbounds [3 x float], [3 x float]* %17, i64 0, i64 1
%423 = load float, float* %422
%424 = load float*, float** %10
%425 = getelementptr inbounds float, float* %424, i64 1
%426 = load float, float* %425
%427 = fmul float %423, %426
%428 = call float @llvm.fmuladd.f32(float %418, float %421, float %427)
%429 = getelementptr inbounds [3 x float], [3 x float]* %17, i64 0, i64 2
%430 = load float, float* %429
%431 = load float*, float** %10
%432 = getelementptr inbounds float, float* %431, i64 2
%433 = load float, float* %432
%434 = call float @llvm.fmuladd.f32(float %430, float %433, float %428)
%435 = load float, float* %19
%436 = fadd float %434, %435
store float %436, float* %25
%437 = load float, float* %23
%438 = fcmp oge float %437, 0.000000e+00
br i1 %438, label %439, label %441
439: ; preds = %273
%440 = load float, float* %23
br label %444
441: ; preds = %273
%442 = load float, float* %23
%443 = fneg float %442
br label %444
444: ; preds = %441, %439
%445 = phi float [ %440, %439 ], [ %443, %441 ]
%446 = fpext float %445 to double
%447 = fcmp olt double %446, 0x3EB0C6F7A0B5ED8D
br i1 %447, label %448, label %449
448: ; preds = %444
store float 0.000000e+00, float* %23
br label %449
449: ; preds = %448, %444
%450 = load float, float* %24
%451 = fcmp oge float %450, 0.000000e+00
br i1 %451, label %452, label %454
452: ; preds = %449
%453 = load float, float* %24
br label %457
454: ; preds = %449
%455 = load float, float* %24
%456 = fneg float %455
br label %457
457: ; preds = %454, %452
%458 = phi float [ %453, %452 ], [ %456, %454 ]
%459 = fpext float %458 to double
%460 = fcmp olt double %459, 0x3EB0C6F7A0B5ED8D
br i1 %460, label %461, label %462
461: ; preds = %457
store float 0.000000e+00, float* %24
br label %462
462: ; preds = %461, %457
%463 = load float, float* %25
%464 = fcmp oge float %463, 0.000000e+00
br i1 %464, label %465, label %467
465: ; preds = %462
%466 = load float, float* %25
br label %470
467: ; preds = %462
%468 = load float, float* %25
%469 = fneg float %468
br label %470
470: ; preds = %467, %465
%471 = phi float [ %466, %465 ], [ %469, %467 ]
%472 = fpext float %471 to double
%473 = fcmp olt double %472, 0x3EB0C6F7A0B5ED8D
br i1 %473, label %474, label %475
474: ; preds = %470
store float 0.000000e+00, float* %25
br label %475
475: ; preds = %474, %470
%476 = load float, float* %23
%477 = load float, float* %24
%478 = fmul float %476, %477
store float %478, float* %31
%479 = load float, float* %23
%480 = load float, float* %25
%481 = fmul float %479, %480
store float %481, float* %32
%482 = load float, float* %31
%483 = fcmp ogt float %482, 0.000000e+00
br i1 %483, label %484, label %488
484: ; preds = %475
%485 = load float, float* %32
%486 = fcmp ogt float %485, 0.000000e+00
br i1 %486, label %487, label %488
487: ; preds = %484
store i32 0, i32* %7
br label %933
488: ; preds = %484, %475
%489 = getelementptr inbounds [3 x float], [3 x float]* %16, i64 0, i64 1
%490 = load float, float* %489
%491 = getelementptr inbounds [3 x float], [3 x float]* %17, i64 0, i64 2
%492 = load float, float* %491
%493 = getelementptr inbounds [3 x float], [3 x float]* %16, i64 0, i64 2
%494 = load float, float* %493
%495 = getelementptr inbounds [3 x float], [3 x float]* %17, i64 0, i64 1
%496 = load float, float* %495
%497 = fmul float %494, %496
%498 = fneg float %497
%499 = call float @llvm.fmuladd.f32(float %490, float %492, float %498)
%500 = getelementptr inbounds [3 x float], [3 x float]* %26, i64 0, i64 0
store float %499, float* %500
%501 = getelementptr inbounds [3 x float], [3 x float]* %16, i64 0, i64 2
%502 = load float, float* %501
%503 = getelementptr inbounds [3 x float], [3 x float]* %17, i64 0, i64 0
%504 = load float, float* %503
%505 = getelementptr inbounds [3 x float], [3 x float]* %16, i64 0, i64 0
%506 = load float, float* %505
%507 = getelementptr inbounds [3 x float], [3 x float]* %17, i64 0, i64 2
%508 = load float, float* %507
%509 = fmul float %506, %508
%510 = fneg float %509
%511 = call float @llvm.fmuladd.f32(float %502, float %504, float %510)
%512 = getelementptr inbounds [3 x float], [3 x float]* %26, i64 0, i64 1
store float %511, float* %512
%513 = getelementptr inbounds [3 x float], [3 x float]* %16, i64 0, i64 0
%514 = load float, float* %513
%515 = getelementptr inbounds [3 x float], [3 x float]* %17, i64 0, i64 1
%516 = load float, float* %515
%517 = getelementptr inbounds [3 x float], [3 x float]* %16, i64 0, i64 1
%518 = load float, float* %517
%519 = getelementptr inbounds [3 x float], [3 x float]* %17, i64 0, i64 0
%520 = load float, float* %519
%521 = fmul float %518, %520
%522 = fneg float %521
%523 = call float @llvm.fmuladd.f32(float %514, float %516, float %522)
%524 = getelementptr inbounds [3 x float], [3 x float]* %26, i64 0, i64 2
store float %523, float* %524
%525 = getelementptr inbounds [3 x float], [3 x float]* %26, i64 0, i64 0
%526 = load float, float* %525
%527 = fcmp oge float %526, 0.000000e+00
br i1 %527, label %528, label %531
528: ; preds = %488
%529 = getelementptr inbounds [3 x float], [3 x float]* %26, i64 0, i64 0
%530 = load float, float* %529
br label %535
531: ; preds = %488
%532 = getelementptr inbounds [3 x float], [3 x float]* %26, i64 0, i64 0
%533 = load float, float* %532
%534 = fneg float %533
br label %535
535: ; preds = %531, %528
%536 = phi float [ %530, %528 ], [ %534, %531 ]
store float %536, float* %42
store i16 0, i16* %33
%537 = getelementptr inbounds [3 x float], [3 x float]* %26, i64 0, i64 1
%538 = load float, float* %537
%539 = fcmp oge float %538, 0.000000e+00
br i1 %539, label %540, label %543
540: ; preds = %535
%541 = getelementptr inbounds [3 x float], [3 x float]* %26, i64 0, i64 1
%542 = load float, float* %541
br label %547
543: ; preds = %535
%544 = getelementptr inbounds [3 x float], [3 x float]* %26, i64 0, i64 1
%545 = load float, float* %544
%546 = fneg float %545
br label %547
547: ; preds = %543, %540
%548 = phi float [ %542, %540 ], [ %546, %543 ]
store float %548, float* %40
%549 = getelementptr inbounds [3 x float], [3 x float]* %26, i64 0, i64 2
%550 = load float, float* %549
%551 = fcmp oge float %550, 0.000000e+00
br i1 %551, label %552, label %555
552: ; preds = %547
%553 = getelementptr inbounds [3 x float], [3 x float]* %26, i64 0, i64 2
%554 = load float, float* %553
br label %559
555: ; preds = %547
%556 = getelementptr inbounds [3 x float], [3 x float]* %26, i64 0, i64 2
%557 = load float, float* %556
%558 = fneg float %557
br label %559
559: ; preds = %555, %552
%560 = phi float [ %554, %552 ], [ %558, %555 ]
store float %560, float* %41
%561 = load float, float* %40
%562 = load float, float* %42
%563 = fcmp ogt float %561, %562
br i1 %563, label %564, label %566
564: ; preds = %559
%565 = load float, float* %40
store float %565, float* %42
store i16 1, i16* %33
br label %566
566: ; preds = %564, %559
%567 = load float, float* %41
%568 = load float, float* %42
%569 = fcmp ogt float %567, %568
br i1 %569, label %570, label %572
570: ; preds = %566
%571 = load float, float* %41
store float %571, float* %42
store i16 2, i16* %33
br label %572
572: ; preds = %570, %566
%573 = load float*, float** %8
%574 = load i16, i16* %33
%575 = sext i16 %574 to i64
%576 = getelementptr inbounds float, float* %573, i64 %575
%577 = load float, float* %576
store float %577, float* %34
%578 = load float*, float** %9
%579 = load i16, i16* %33
%580 = sext i16 %579 to i64
%581 = getelementptr inbounds float, float* %578, i64 %580
%582 = load float, float* %581
store float %582, float* %35
%583 = load float*, float** %10
%584 = load i16, i16* %33
%585 = sext i16 %584 to i64
%586 = getelementptr inbounds float, float* %583, i64 %585
%587 = load float, float* %586
store float %587, float* %36
%588 = load float*, float** %11
%589 = load i16, i16* %33
%590 = sext i16 %589 to i64
%591 = getelementptr inbounds float, float* %588, i64 %590
%592 = load float, float* %591
store float %592, float* %37
%593 = load float*, float** %12
%594 = load i16, i16* %33
%595 = sext i16 %594 to i64
%596 = getelementptr inbounds float, float* %593, i64 %595
%597 = load float, float* %596
store float %597, float* %38
%598 = load float*, float** %13
%599 = load i16, i16* %33
%600 = sext i16 %599 to i64
%601 = getelementptr inbounds float, float* %598, i64 %600
%602 = load float, float* %601
store float %602, float* %39
%603 = load float, float* %31
%604 = fcmp ogt float %603, 0.000000e+00
br i1 %604, label %605, label %623
605: ; preds = %572
%606 = load float, float* %36
store float %606, float* %43
%607 = load float, float* %34
%608 = load float, float* %36
%609 = fsub float %607, %608
%610 = load float, float* %25
%611 = fmul float %609, %610
store float %611, float* %44
%612 = load float, float* %35
%613 = load float, float* %36
%614 = fsub float %612, %613
%615 = load float, float* %25
%616 = fmul float %614, %615
store float %616, float* %45
%617 = load float, float* %25
%618 = load float, float* %23
%619 = fsub float %617, %618
store float %619, float* %46
%620 = load float, float* %25
%621 = load float, float* %24
%622 = fsub float %620, %621
store float %622, float* %47
br label %725
623: ; preds = %572
%624 = load float, float* %32
%625 = fcmp ogt float %624, 0.000000e+00
br i1 %625, label %626, label %644
626: ; preds = %623
%627 = load float, float* %35
store float %627, float* %43
%628 = load float, float* %34
%629 = load float, float* %35
%630 = fsub float %628, %629
%631 = load float, float* %24
%632 = fmul float %630, %631
store float %632, float* %44
%633 = load float, float* %36
%634 = load float, float* %35
%635 = fsub float %633, %634
%636 = load float, float* %24
%637 = fmul float %635, %636
store float %637, float* %45
%638 = load float, float* %24
%639 = load float, float* %23
%640 = fsub float %638, %639
store float %640, float* %46
%641 = load float, float* %24
%642 = load float, float* %25
%643 = fsub float %641, %642
store float %643, float* %47
br label %724
644: ; preds = %623
%645 = load float, float* %24
%646 = load float, float* %25
%647 = fmul float %645, %646
%648 = fcmp ogt float %647, 0.000000e+00
br i1 %648, label %652, label %649
649: ; preds = %644
%650 = load float, float* %23
%651 = fcmp une float %650, 0.000000e+00
br i1 %651, label %652, label %670
652: ; preds = %649, %644
%653 = load float, float* %34
store float %653, float* %43
%654 = load float, float* %35
%655 = load float, float* %34
%656 = fsub float %654, %655
%657 = load float, float* %23
%658 = fmul float %656, %657
store float %658, float* %44
%659 = load float, float* %36
%660 = load float, float* %34
%661 = fsub float %659, %660
%662 = load float, float* %23
%663 = fmul float %661, %662
store float %663, float* %45
%664 = load float, float* %23
%665 = load float, float* %24
%666 = fsub float %664, %665
store float %666, float* %46
%667 = load float, float* %23
%668 = load float, float* %25
%669 = fsub float %667, %668
store float %669, float* %47
br label %723
670: ; preds = %649
%671 = load float, float* %24
%672 = fcmp une float %671, 0.000000e+00
br i1 %672, label %673, label %691
673: ; preds = %670
%674 = load float, float* %35
store float %674, float* %43
%675 = load float, float* %34
%676 = load float, float* %35
%677 = fsub float %675, %676
%678 = load float, float* %24
%679 = fmul float %677, %678
store float %679, float* %44
%680 = load float, float* %36
%681 = load float, float* %35
%682 = fsub float %680, %681
%683 = load float, float* %24
%684 = fmul float %682, %683
store float %684, float* %45
%685 = load float, float* %24
%686 = load float, float* %23
%687 = fsub float %685, %686
store float %687, float* %46
%688 = load float, float* %24
%689 = load float, float* %25
%690 = fsub float %688, %689
store float %690, float* %47
br label %722
691: ; preds = %670
%692 = load float, float* %25
%693 = fcmp une float %692, 0.000000e+00
br i1 %693, label %694, label %712
694: ; preds = %691
%695 = load float, float* %36
store float %695, float* %43
%696 = load float, float* %34
%697 = load float, float* %36
%698 = fsub float %696, %697
%699 = load float, float* %25
%700 = fmul float %698, %699
store float %700, float* %44
%701 = load float, float* %35
%702 = load float, float* %36
%703 = fsub float %701, %702
%704 = load float, float* %25
%705 = fmul float %703, %704
store float %705, float* %45
%706 = load float, float* %25
%707 = load float, float* %23
%708 = fsub float %706, %707
store float %708, float* %46
%709 = load float, float* %25
%710 = load float, float* %24
%711 = fsub float %709, %710
store float %711, float* %47
br label %721
712: ; preds = %691
%713 = getelementptr inbounds [3 x float], [3 x float]* %16, i64 0, i64 0
%714 = load float*, float** %8
%715 = load float*, float** %9
%716 = load float*, float** %10
%717 = load float*, float** %11
%718 = load float*, float** %12
%719 = load float*, float** %13
%720 = call i32 (float*, float*, float*, float*, float*, float*, float*, ...) bitcast (i32 (...)* @coplanar_tri_tri to i32 (float*, float*, float*, float*, float*, float*, float*, ...)*)(float* %713, float* %714, float* %715, float* %716, float* %717, float* %718, float* %719)
store i32 %720, i32* %7
br label %933
721: ; preds = %694
br label %722
722: ; preds = %721, %673
br label %723
723: ; preds = %722, %652
br label %724
724: ; preds = %723, %626
br label %725
725: ; preds = %724, %605
%726 = load float, float* %29
%727 = fcmp ogt float %726, 0.000000e+00
br i1 %727, label %728, label %746
728: ; preds = %725
%729 = load float, float* %39
store float %729, float* %48
%730 = load float, float* %37
%731 = load float, float* %39
%732 = fsub float %730, %731
%733 = load float, float* %22
%734 = fmul float %732, %733
store float %734, float* %49
%735 = load float, float* %38
%736 = load float, float* %39
%737 = fsub float %735, %736
%738 = load float, float* %22
%739 = fmul float %737, %738
store float %739, float* %50
%740 = load float, float* %22
%741 = load float, float* %20
%742 = fsub float %740, %741
store float %742, float* %51
%743 = load float, float* %22
%744 = load float, float* %21
%745 = fsub float %743, %744
store float %745, float* %52
br label %848
746: ; preds = %725
%747 = load float, float* %30
%748 = fcmp ogt float %747, 0.000000e+00
br i1 %748, label %749, label %767
749: ; preds = %746
%750 = load float, float* %38
store float %750, float* %48
%751 = load float, float* %37
%752 = load float, float* %38
%753 = fsub float %751, %752
%754 = load float, float* %21
%755 = fmul float %753, %754
store float %755, float* %49
%756 = load float, float* %39
%757 = load float, float* %38
%758 = fsub float %756, %757
%759 = load float, float* %21
%760 = fmul float %758, %759
store float %760, float* %50
%761 = load float, float* %21
%762 = load float, float* %20
%763 = fsub float %761, %762
store float %763, float* %51
%764 = load float, float* %21
%765 = load float, float* %22
%766 = fsub float %764, %765
store float %766, float* %52
br label %847
767: ; preds = %746
%768 = load float, float* %21
%769 = load float, float* %22
%770 = fmul float %768, %769
%771 = fcmp ogt float %770, 0.000000e+00
br i1 %771, label %775, label %772
772: ; preds = %767
%773 = load float, float* %20
%774 = fcmp une float %773, 0.000000e+00
br i1 %774, label %775, label %793
775: ; preds = %772, %767
%776 = load float, float* %37
store float %776, float* %48
%777 = load float, float* %38
%778 = load float, float* %37
%779 = fsub float %777, %778
%780 = load float, float* %20
%781 = fmul float %779, %780
store float %781, float* %49
%782 = load float, float* %39
%783 = load float, float* %37
%784 = fsub float %782, %783
%785 = load float, float* %20
%786 = fmul float %784, %785
store float %786, float* %50
%787 = load float, float* %20
%788 = load float, float* %21
%789 = fsub float %787, %788
store float %789, float* %51
%790 = load float, float* %20
%791 = load float, float* %22
%792 = fsub float %790, %791
store float %792, float* %52
br label %846
793: ; preds = %772
%794 = load float, float* %21
%795 = fcmp une float %794, 0.000000e+00
br i1 %795, label %796, label %814
796: ; preds = %793
%797 = load float, float* %38
store float %797, float* %48
%798 = load float, float* %37
%799 = load float, float* %38
%800 = fsub float %798, %799
%801 = load float, float* %21
%802 = fmul float %800, %801
store float %802, float* %49
%803 = load float, float* %39
%804 = load float, float* %38
%805 = fsub float %803, %804
%806 = load float, float* %21
%807 = fmul float %805, %806
store float %807, float* %50
%808 = load float, float* %21
%809 = load float, float* %20
%810 = fsub float %808, %809
store float %810, float* %51
%811 = load float, float* %21
%812 = load float, float* %22
%813 = fsub float %811, %812
store float %813, float* %52
br label %845
814: ; preds = %793
%815 = load float, float* %22
%816 = fcmp une float %815, 0.000000e+00
br i1 %816, label %817, label %835
817: ; preds = %814
%818 = load float, float* %39
store float %818, float* %48
%819 = load float, float* %37
%820 = load float, float* %39
%821 = fsub float %819, %820
%822 = load float, float* %22
%823 = fmul float %821, %822
store float %823, float* %49
%824 = load float, float* %38
%825 = load float, float* %39
%826 = fsub float %824, %825
%827 = load float, float* %22
%828 = fmul float %826, %827
store float %828, float* %50
%829 = load float, float* %22
%830 = load float, float* %20
%831 = fsub float %829, %830
store float %831, float* %51
%832 = load float, float* %22
%833 = load float, float* %21
%834 = fsub float %832, %833
store float %834, float* %52
br label %844
835: ; preds = %814
%836 = getelementptr inbounds [3 x float], [3 x float]* %16, i64 0, i64 0
%837 = load float*, float** %8
%838 = load float*, float** %9
%839 = load float*, float** %10
%840 = load float*, float** %11
%841 = load float*, float** %12
%842 = load float*, float** %13
%843 = call i32 (float*, float*, float*, float*, float*, float*, float*, ...) bitcast (i32 (...)* @coplanar_tri_tri to i32 (float*, float*, float*, float*, float*, float*, float*, ...)*)(float* %836, float* %837, float* %838, float* %839, float* %840, float* %841, float* %842)
store i32 %843, i32* %7
br label %933
844: ; preds = %817
br label %845
845: ; preds = %844, %796
br label %846
846: ; preds = %845, %775
br label %847
847: ; preds = %846, %749
br label %848
848: ; preds = %847, %728
%849 = load float, float* %46
%850 = load float, float* %47
%851 = fmul float %849, %850
store float %851, float* %53
%852 = load float, float* %51
%853 = load float, float* %52
%854 = fmul float %852, %853
store float %854, float* %54
%855 = load float, float* %53
%856 = load float, float* %54
%857 = fmul float %855, %856
store float %857, float* %55
%858 = load float, float* %43
%859 = load float, float* %55
%860 = fmul float %858, %859
store float %860, float* %56
%861 = load float, float* %56
%862 = load float, float* %44
%863 = load float, float* %47
%864 = fmul float %862, %863
%865 = load float, float* %54
%866 = call float @llvm.fmuladd.f32(float %864, float %865, float %861)
%867 = getelementptr inbounds [2 x float], [2 x float]* %27, i64 0, i64 0
store float %866, float* %867
%868 = load float, float* %56
%869 = load float, float* %45
%870 = load float, float* %46
%871 = fmul float %869, %870
%872 = load float, float* %54
%873 = call float @llvm.fmuladd.f32(float %871, float %872, float %868)
%874 = getelementptr inbounds [2 x float], [2 x float]* %27, i64 0, i64 1
store float %873, float* %874
%875 = load float, float* %48
%876 = load float, float* %55
%877 = fmul float %875, %876
store float %877, float* %56
%878 = load float, float* %56
%879 = load float, float* %49
%880 = load float, float* %53
%881 = fmul float %879, %880
%882 = load float, float* %52
%883 = call float @llvm.fmuladd.f32(float %881, float %882, float %878)
%884 = getelementptr inbounds [2 x float], [2 x float]* %28, i64 0, i64 0
store float %883, float* %884
%885 = load float, float* %56
%886 = load float, float* %50
%887 = load float, float* %53
%888 = fmul float %886, %887
%889 = load float, float* %51
%890 = call float @llvm.fmuladd.f32(float %888, float %889, float %885)
%891 = getelementptr inbounds [2 x float], [2 x float]* %28, i64 0, i64 1
store float %890, float* %891
%892 = getelementptr inbounds [2 x float], [2 x float]* %27, i64 0, i64 0
%893 = load float, float* %892
%894 = getelementptr inbounds [2 x float], [2 x float]* %27, i64 0, i64 1
%895 = load float, float* %894
%896 = fcmp ogt float %893, %895
br i1 %896, label %897, label %905
897: ; preds = %848
%898 = getelementptr inbounds [2 x float], [2 x float]* %27, i64 0, i64 0
%899 = load float, float* %898
store float %899, float* %57
%900 = getelementptr inbounds [2 x float], [2 x float]* %27, i64 0, i64 1
%901 = load float, float* %900
%902 = getelementptr inbounds [2 x float], [2 x float]* %27, i64 0, i64 0
store float %901, float* %902
%903 = load float, float* %57
%904 = getelementptr inbounds [2 x float], [2 x float]* %27, i64 0, i64 1
store float %903, float* %904
br label %905
905: ; preds = %897, %848
%906 = getelementptr inbounds [2 x float], [2 x float]* %28, i64 0, i64 0
%907 = load float, float* %906
%908 = getelementptr inbounds [2 x float], [2 x float]* %28, i64 0, i64 1
%909 = load float, float* %908
%910 = fcmp ogt float %907, %909
br i1 %910, label %911, label %919
911: ; preds = %905
%912 = getelementptr inbounds [2 x float], [2 x float]* %28, i64 0, i64 0
%913 = load float, float* %912
store float %913, float* %58
%914 = getelementptr inbounds [2 x float], [2 x float]* %28, i64 0, i64 1
%915 = load float, float* %914
%916 = getelementptr inbounds [2 x float], [2 x float]* %28, i64 0, i64 0
store float %915, float* %916
%917 = load float, float* %58
%918 = getelementptr inbounds [2 x float], [2 x float]* %28, i64 0, i64 1
store float %917, float* %918
br label %919
919: ; preds = %911, %905
%920 = getelementptr inbounds [2 x float], [2 x float]* %27, i64 0, i64 1
%921 = load float, float* %920
%922 = getelementptr inbounds [2 x float], [2 x float]* %28, i64 0, i64 0
%923 = load float, float* %922
%924 = fcmp olt float %921, %923
br i1 %924, label %931, label %925
925: ; preds = %919
%926 = getelementptr inbounds [2 x float], [2 x float]* %28, i64 0, i64 1
%927 = load float, float* %926
%928 = getelementptr inbounds [2 x float], [2 x float]* %27, i64 0, i64 0
%929 = load float, float* %928
%930 = fcmp olt float %927, %929
br i1 %930, label %931, label %932
931: ; preds = %925, %919
store i32 0, i32* %7
br label %933
932: ; preds = %925
store i32 1, i32* %7
br label %933
933: ; preds = %932, %931, %835, %712, %487, %272
%934 = load i32, i32* %7
ret i32 %934
}

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