#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int coplanar_tri_tri(float *, float *, float *, float *, float *, float *,
                     float *);
scalar_t__ fabs(float);
int NoDivTriTriIsect(float V0[3], float V1[3], float V2[3], float U0[3],
                     float U1[3], float U2[3]) {
  float E1[3], E2[3];
  float N1[3], N2[3], d1, d2;
  float du0, du1, du2, dv0, dv1, dv2;
  float D[3];
  float isect1[2], isect2[2];
  float du0du1, du0du2, dv0dv1, dv0dv2;
  short index;
  float vp0, vp1, vp2;
  float up0, up1, up2;
  float bb, cc, max;
  float a, b, c, x0, x1;
  float d, e, f, y0, y1;
  float xx, yy, xxyy, tmp;
  E1[0] = V1[0] - V0[0];
  E1[1] = V1[1] - V0[1];
  E1[2] = V1[2] - V0[2];
  ;
  E2[0] = V2[0] - V0[0];
  E2[1] = V2[1] - V0[1];
  E2[2] = V2[2] - V0[2];
  ;
  N1[0] = E1[1] * E2[2] - E1[2] * E2[1];
  N1[1] = E1[2] * E2[0] - E1[0] * E2[2];
  N1[2] = E1[0] * E2[1] - E1[1] * E2[0];
  ;
  d1 = -(N1[0] * V0[0] + N1[1] * V0[1] + N1[2] * V0[2]);
  du0 = (N1[0] * U0[0] + N1[1] * U0[1] + N1[2] * U0[2]) + d1;
  du1 = (N1[0] * U1[0] + N1[1] * U1[1] + N1[2] * U1[2]) + d1;
  du2 = (N1[0] * U2[0] + N1[1] * U2[1] + N1[2] * U2[2]) + d1;
  if (((float)fabs(du0)) < 0.000001)
    du0 = 0.0;
  if (((float)fabs(du1)) < 0.000001)
    du1 = 0.0;
  if (((float)fabs(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 (((float)fabs(dv0)) < 0.000001)
    dv0 = 0.0;
  if (((float)fabs(dv1)) < 0.000001)
    dv1 = 0.0;
  if (((float)fabs(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)((float)fabs(D[0]));
  index = 0;
  bb = (float)((float)fabs(D[1]));
  cc = (float)((float)fabs(D[2]));
  if (bb > max)
    max = bb, index = 1;
  if (cc > max)
    max = cc, index = 2;
  vp0 = V0[index];
  vp1 = V1[index];
  vp2 = V2[index];
  up0 = U0[index];
  up1 = U1[index];
  up2 = U2[index];
  {
    if (dv0dv1 > 0.0f) {
      a = vp2;
      b = (vp0 - vp2) * dv2;
      c = (vp1 - vp2) * dv2;
      x0 = dv2 - dv0;
      x1 = dv2 - dv1;
    } else if (dv0dv2 > 0.0f) {
      a = vp1;
      b = (vp0 - vp1) * dv1;
      c = (vp2 - vp1) * dv1;
      x0 = dv1 - dv0;
      x1 = dv1 - dv2;
    } else if (dv1 * dv2 > 0.0f || dv0 != 0.0f) {
      a = vp0;
      b = (vp1 - vp0) * dv0;
      c = (vp2 - vp0) * dv0;
      x0 = dv0 - dv1;
      x1 = dv0 - dv2;
    } else if (dv1 != 0.0f) {
      a = vp1;
      b = (vp0 - vp1) * dv1;
      c = (vp2 - vp1) * dv1;
      x0 = dv1 - dv0;
      x1 = dv1 - dv2;
    } else if (dv2 != 0.0f) {
      a = vp2;
      b = (vp0 - vp2) * dv2;
      c = (vp1 - vp2) * dv2;
      x0 = dv2 - dv0;
      x1 = dv2 - dv1;
    } else {
      return coplanar_tri_tri(N1, V0, V1, V2, U0, U1, U2);
    }
  };
  {
    if (du0du1 > 0.0f) {
      d = up2;
      e = (up0 - up2) * du2;
      f = (up1 - up2) * du2;
      y0 = du2 - du0;
      y1 = du2 - du1;
    } else if (du0du2 > 0.0f) {
      d = up1;
      e = (up0 - up1) * du1;
      f = (up2 - up1) * du1;
      y0 = du1 - du0;
      y1 = du1 - du2;
    } else if (du1 * du2 > 0.0f || du0 != 0.0f) {
      d = up0;
      e = (up1 - up0) * du0;
      f = (up2 - up0) * du0;
      y0 = du0 - du1;
      y1 = du0 - du2;
    } else if (du1 != 0.0f) {
      d = up1;
      e = (up0 - up1) * du1;
      f = (up2 - up1) * du1;
      y0 = du1 - du0;
      y1 = du1 - du2;
    } else if (du2 != 0.0f) {
      d = up2;
      e = (up0 - up2) * du2;
      f = (up1 - up2) * du2;
      y0 = du2 - du0;
      y1 = du2 - du1;
    } else {
      return coplanar_tri_tri(N1, V0, V1, V2, U0, U1, U2);
    }
  };
  xx = x0 * x1;
  yy = y0 * y1;
  xxyy = xx * yy;
  tmp = a * xxyy;
  isect1[0] = tmp + b * x1 * yy;
  isect1[1] = tmp + c * x0 * yy;
  tmp = d * xxyy;
  isect2[0] = tmp + e * xx * y1;
  isect2[1] = tmp + f * xx * y0;
  if (isect1[0] > isect1[1]) {
    float c;
    c = isect1[0];
    isect1[0] = isect1[1];
    isect1[1] = c;
  };
  if (isect2[0] > isect2[1]) {
    float c;
    c = isect2[0];
    isect2[0] = isect2[1];
    isect2[1] = c;
  };
  if (isect1[1] < isect2[0] || isect2[1] < isect1[0])
    return 0;
  return 1;
}


x86 assembly (clang, -O0):
<NoDivTriTriIsect>:
push   %rbp
mov    %rsp,%rbp
sub    $0x130,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
mov    %r9,-0x38(%rbp)
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
subss  (%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x10(%rbp),%rax
subss  0x4(%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
subss  0x8(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
subss  (%rax),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x10(%rbp),%rax
subss  0x4(%rax),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
subss  0x8(%rax),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x40(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x3c(%rbp),%xmm1
mulss  -0x4c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  -0x48(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x44(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  -0x50(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x5c(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x58(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x4(%rax),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x54(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x5c(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x58(%rbp),%xmm0
mov    -0x28(%rbp),%rax
mulss  0x4(%rax),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x54(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
addss  -0x6c(%rbp),%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x5c(%rbp),%xmm1
mov    -0x30(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x58(%rbp),%xmm0
mov    -0x30(%rbp),%rax
mulss  0x4(%rax),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x54(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
addss  -0x6c(%rbp),%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x5c(%rbp),%xmm1
mov    -0x38(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x58(%rbp),%xmm0
mov    -0x38(%rbp),%rax
mulss  0x4(%rax),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x54(%rbp),%xmm0
mov    -0x38(%rbp),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
addss  -0x6c(%rbp),%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x74(%rbp),%xmm0
call   1040 <fabs@plt>
cvtsi2ss %rax,%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x1c7e(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1394 <NoDivTriTriIsect+0x274>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x78(%rbp),%xmm0
call   1040 <fabs@plt>
cvtsi2ss %rax,%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x1c51(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    13c1 <NoDivTriTriIsect+0x2a1>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x7c(%rbp),%xmm0
call   1040 <fabs@plt>
cvtsi2ss %rax,%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x1c24(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    13ee <NoDivTriTriIsect+0x2ce>
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    1446 <NoDivTriTriIsect+0x326>
movss  -0xac(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    1446 <NoDivTriTriIsect+0x326>
movl   $0x0,-0x4(%rbp)
jmp    21b6 <NoDivTriTriIsect+0x1096>
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
call   1040 <fabs@plt>
cvtsi2ss %rax,%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x1975(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    169d <NoDivTriTriIsect+0x57d>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x84(%rbp),%xmm0
ff
call   1040 <fabs@plt>
cvtsi2ss %rax,%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x1945(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    16d0 <NoDivTriTriIsect+0x5b0>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x88(%rbp),%xmm0
ff
call   1040 <fabs@plt>
cvtsi2ss %rax,%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x1912(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1703 <NoDivTriTriIsect+0x5e3>
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    1761 <NoDivTriTriIsect+0x641>
movss  -0xb4(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    1761 <NoDivTriTriIsect+0x641>
movl   $0x0,-0x4(%rbp)
jmp    21b6 <NoDivTriTriIsect+0x1096>
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
call   1040 <fabs@plt>
cvtsi2ss %rax,%xmm0
movss  %xmm0,-0xdc(%rbp)
ff
movw   $0x0,-0xb6(%rbp)
movss  -0x90(%rbp),%xmm0
ff
call   1040 <fabs@plt>
cvtsi2ss %rax,%xmm0
movss  %xmm0,-0xd4(%rbp)
ff
movss  -0x8c(%rbp),%xmm0
ff
call   1040 <fabs@plt>
cvtsi2ss %rax,%xmm0
movss  %xmm0,-0xd8(%rbp)
ff
movss  -0xd4(%rbp),%xmm0
ff
ucomiss -0xdc(%rbp),%xmm0
jbe    1879 <NoDivTriTriIsect+0x759>
movss  -0xd4(%rbp),%xmm0
ff
movss  %xmm0,-0xdc(%rbp)
ff
movw   $0x1,-0xb6(%rbp)
movss  -0xd8(%rbp),%xmm0
ff
ucomiss -0xdc(%rbp),%xmm0
jbe    18a7 <NoDivTriTriIsect+0x787>
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    19d3 <NoDivTriTriIsect+0x8b3>
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    1c9d <NoDivTriTriIsect+0xb7d>
movss  -0xb4(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    1a69 <NoDivTriTriIsect+0x949>
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    1c98 <NoDivTriTriIsect+0xb78>
movss  -0x84(%rbp),%xmm0
ff
mulss  -0x88(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
ja     1aa1 <NoDivTriTriIsect+0x981>
movss  -0x80(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1aa1 <NoDivTriTriIsect+0x981>
jp     1aa1 <NoDivTriTriIsect+0x981>
jmp    1b1a <NoDivTriTriIsect+0x9fa>
movss  -0xbc(%rbp),%xmm0
ff
movss  %xmm0,-0xe0(%rbp)
ff
movss  -0xc0(%rbp),%xmm0
ff
subss  -0xbc(%rbp),%xmm0
ff
mulss  -0x80(%rbp),%xmm0
movss  %xmm0,-0xe4(%rbp)
ff
movss  -0xc4(%rbp),%xmm0
ff
subss  -0xbc(%rbp),%xmm0
ff
mulss  -0x80(%rbp),%xmm0
movss  %xmm0,-0xe8(%rbp)
ff
movss  -0x80(%rbp),%xmm0
subss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0xec(%rbp)
ff
movss  -0x80(%rbp),%xmm0
subss  -0x88(%rbp),%xmm0
ff
movss  %xmm0,-0xf0(%rbp)
ff
jmp    1c93 <NoDivTriTriIsect+0xb73>
movss  -0x84(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1b39 <NoDivTriTriIsect+0xa19>
jp     1b39 <NoDivTriTriIsect+0xa19>
jmp    1bbb <NoDivTriTriIsect+0xa9b>
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    1c8e <NoDivTriTriIsect+0xb6e>
movss  -0x88(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1bda <NoDivTriTriIsect+0xaba>
jp     1bda <NoDivTriTriIsect+0xaba>
jmp    1c5c <NoDivTriTriIsect+0xb3c>
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    1c89 <NoDivTriTriIsect+0xb69>
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)
call   1030 <coplanar_tri_tri@plt>
mov    %eax,-0x4(%rbp)
jmp    21b6 <NoDivTriTriIsect+0x1096>
jmp    1c8e <NoDivTriTriIsect+0xb6e>
jmp    1c93 <NoDivTriTriIsect+0xb73>
jmp    1c98 <NoDivTriTriIsect+0xb78>
jmp    1c9d <NoDivTriTriIsect+0xb7d>
movss  -0xa8(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    1d24 <NoDivTriTriIsect+0xc04>
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    1faf <NoDivTriTriIsect+0xe8f>
movss  -0xac(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    1dab <NoDivTriTriIsect+0xc8b>
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    1faa <NoDivTriTriIsect+0xe8a>
movss  -0x78(%rbp),%xmm0
mulss  -0x7c(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
ja     1ddd <NoDivTriTriIsect+0xcbd>
movss  -0x74(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1ddd <NoDivTriTriIsect+0xcbd>
jp     1ddd <NoDivTriTriIsect+0xcbd>
jmp    1e50 <NoDivTriTriIsect+0xd30>
movss  -0xc8(%rbp),%xmm0
ff
movss  %xmm0,-0xf4(%rbp)
ff
movss  -0xcc(%rbp),%xmm0
ff
subss  -0xc8(%rbp),%xmm0
ff
mulss  -0x74(%rbp),%xmm0
movss  %xmm0,-0xf8(%rbp)
ff
movss  -0xd0(%rbp),%xmm0
ff
subss  -0xc8(%rbp),%xmm0
ff
mulss  -0x74(%rbp),%xmm0
movss  %xmm0,-0xfc(%rbp)
ff
movss  -0x74(%rbp),%xmm0
subss  -0x78(%rbp),%xmm0
movss  %xmm0,-0x100(%rbp)
ff
movss  -0x74(%rbp),%xmm0
subss  -0x7c(%rbp),%xmm0
movss  %xmm0,-0x104(%rbp)
ff
jmp    1fa5 <NoDivTriTriIsect+0xe85>
movss  -0x78(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1e6c <NoDivTriTriIsect+0xd4c>
jp     1e6c <NoDivTriTriIsect+0xd4c>
jmp    1edf <NoDivTriTriIsect+0xdbf>
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    1fa0 <NoDivTriTriIsect+0xe80>
movss  -0x7c(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1efb <NoDivTriTriIsect+0xddb>
jp     1efb <NoDivTriTriIsect+0xddb>
jmp    1f6e <NoDivTriTriIsect+0xe4e>
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    1f9b <NoDivTriTriIsect+0xe7b>
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)
call   1030 <coplanar_tri_tri@plt>
mov    %eax,-0x4(%rbp)
jmp    21b6 <NoDivTriTriIsect+0x1096>
jmp    1fa0 <NoDivTriTriIsect+0xe80>
jmp    1fa5 <NoDivTriTriIsect+0xe85>
jmp    1faa <NoDivTriTriIsect+0xe8a>
jmp    1faf <NoDivTriTriIsect+0xe8f>
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
movss  %xmm0,-0x114(%rbp)
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    212c <NoDivTriTriIsect+0x100c>
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    2171 <NoDivTriTriIsect+0x1051>
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     21a3 <NoDivTriTriIsect+0x1083>
movss  -0xa0(%rbp),%xmm1
ff
movss  -0x9c(%rbp),%xmm0
ff
ucomiss %xmm1,%xmm0
jbe    21af <NoDivTriTriIsect+0x108f>
movl   $0x0,-0x4(%rbp)
jmp    21b6 <NoDivTriTriIsect+0x1096>
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x130,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<NoDivTriTriIsect>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x138,%rsp
mov    %r9,%rbp
mov    %rdx,%r12
mov    %rsi,%r13
mov    %rdi,%r15
movss  (%rsi),%xmm1
movss  0x4(%rsi),%xmm4
movss  (%rdi),%xmm8
movss  0x4(%rdi),%xmm10
subss  %xmm8,%xmm1
subss  %xmm10,%xmm4
movss  0x8(%rsi),%xmm3
movss  0x8(%rdi),%xmm9
subss  %xmm9,%xmm3
movss  (%rdx),%xmm5
movss  0x4(%rdx),%xmm0
subss  %xmm8,%xmm5
subss  %xmm10,%xmm0
movss  0x8(%rdx),%xmm6
subss  %xmm9,%xmm6
movaps %xmm0,%xmm7
mulss  %xmm3,%xmm7
mulss  %xmm5,%xmm3
mulss  %xmm4,%xmm5
mulss  %xmm6,%xmm4
subss  %xmm7,%xmm4
movss  %xmm4,0x44(%rsp)
mulss  %xmm1,%xmm6
subss  %xmm6,%xmm3
movss  %xmm3,0x48(%rsp)
mulss  %xmm1,%xmm0
subss  %xmm5,%xmm0
movss  %xmm0,0x4c(%rsp)
movaps %xmm3,0xa0(%rsp)
shufps $0x0,%xmm3,%xmm3
movss  (%rcx),%xmm1
movss  0x4(%rcx),%xmm5
mov    %rcx,0x30(%rsp)
movss  0x8(%rcx),%xmm6
movss  (%r8),%xmm7
unpcklps %xmm1,%xmm7
movss  0x4(%r8),%xmm1
unpcklps %xmm5,%xmm1
mov    %r8,0x38(%rsp)
movss  0x8(%r8),%xmm2
unpcklps %xmm6,%xmm2
mulps  %xmm3,%xmm1
movaps %xmm4,0xb0(%rsp)
movaps %xmm4,%xmm5
shufps $0x0,%xmm4,%xmm5
mulps  %xmm5,%xmm7
addps  %xmm1,%xmm7
movaps %xmm0,0x70(%rsp)
movaps %xmm0,%xmm4
shufps $0x0,%xmm0,%xmm4
mulps  %xmm4,%xmm2
addps  %xmm7,%xmm2
movss  (%r9),%xmm6
movss  0x4(%r9),%xmm7
movss  0x8(%r9),%xmm1
unpcklps %xmm10,%xmm7
mulps  %xmm3,%xmm7
unpcklps %xmm8,%xmm6
mulps  %xmm5,%xmm6
addps  %xmm7,%xmm6
unpcklps %xmm9,%xmm1
mulps  %xmm4,%xmm1
addps  %xmm6,%xmm1
movaps %xmm1,%xmm0
shufps $0x55,%xmm1,%xmm0
subps  %xmm0,%xmm2
movaps %xmm2,0x20(%rsp)
subss  %xmm0,%xmm1
movaps %xmm1,0x10(%rsp)
movaps %xmm2,%xmm0
shufps $0x55,%xmm2,%xmm0
call   1040 <fabs@plt>
mov    %rax,%rbx
movaps 0x20(%rsp),%xmm0
call   1040 <fabs@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rbx,%xmm0
xorps  %xmm1,%xmm1
cvtsi2ss %rax,%xmm1
unpcklps %xmm0,%xmm1
cvtps2pd %xmm1,%xmm0
cmpltpd 0xd5b(%rip),%xmm0
shufps $0xe8,%xmm0,%xmm0
xorps  %xmm1,%xmm1
andps  %xmm0,%xmm1
andnps 0x20(%rsp),%xmm0
orps   %xmm0,%xmm1
movaps %xmm1,0x20(%rsp)
pshufd $0x55,%xmm0,%xmm0
movdqa %xmm0,0xd0(%rsp)
movaps 0x10(%rsp),%xmm0
call   1040 <fabs@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xd28(%rip),%xmm1
ucomisd %xmm0,%xmm1
xorps  %xmm0,%xmm0
xorps  %xmm2,%xmm2
ja     12f9 <NoDivTriTriIsect+0x1d9>
movaps 0x10(%rsp),%xmm2
movaps 0xd0(%rsp),%xmm4
movaps %xmm4,%xmm5
movaps 0x20(%rsp),%xmm1
mulss  %xmm1,%xmm5
mulss  %xmm2,%xmm4
xor    %r14d,%r14d
ucomiss %xmm0,%xmm5
jbe    1325 <NoDivTriTriIsect+0x205>
xorps  %xmm0,%xmm0
ucomiss %xmm0,%xmm4
ja     1887 <NoDivTriTriIsect+0x767>
movaps %xmm5,0x50(%rsp)
movaps %xmm4,0xf0(%rsp)
movaps %xmm2,0x60(%rsp)
mov    0x38(%rsp),%rax
movss  (%rax),%xmm0
movss  0x4(%rax),%xmm4
mov    0x30(%rsp),%rcx
movss  (%rcx),%xmm8
movss  0x4(%rcx),%xmm10
subss  %xmm8,%xmm0
subss  %xmm10,%xmm4
movss  0x8(%rax),%xmm3
movss  0x8(%rcx),%xmm9
subss  %xmm9,%xmm3
movss  0x0(%rbp),%xmm2
movss  0x4(%rbp),%xmm1
subss  %xmm8,%xmm2
subss  %xmm10,%xmm1
movss  0x8(%rbp),%xmm6
subss  %xmm9,%xmm6
movaps %xmm1,%xmm7
mulss  %xmm3,%xmm7
mulss  %xmm2,%xmm3
mulss  %xmm4,%xmm2
movaps %xmm4,%xmm5
mulss  %xmm6,%xmm5
subss  %xmm7,%xmm5
mulss  %xmm0,%xmm6
subss  %xmm6,%xmm3
mulss  %xmm0,%xmm1
subss  %xmm2,%xmm1
movaps %xmm3,0x120(%rsp)
shufps $0x0,%xmm3,%xmm3
movss  (%r15),%xmm4
movss  0x4(%r15),%xmm0
movss  0x8(%r15),%xmm6
movss  0x0(%r13),%xmm7
unpcklps %xmm4,%xmm7
movss  0x4(%r13),%xmm4
unpcklps %xmm0,%xmm4
movss  0x8(%r13),%xmm0
unpcklps %xmm6,%xmm0
mulps  %xmm3,%xmm4
movaps %xmm5,0x100(%rsp)
shufps $0x0,%xmm5,%xmm5
mulps  %xmm5,%xmm7
addps  %xmm4,%xmm7
movaps %xmm1,0x110(%rsp)
movaps %xmm1,%xmm4
shufps $0x0,%xmm1,%xmm4
mulps  %xmm4,%xmm0
addps  %xmm7,%xmm0
movaps %xmm0,%xmm2
movss  (%r12),%xmm6
movss  0x4(%r12),%xmm7
movss  0x8(%r12),%xmm1
unpcklps %xmm10,%xmm7
mulps  %xmm3,%xmm7
unpcklps %xmm8,%xmm6
mulps  %xmm5,%xmm6
addps  %xmm7,%xmm6
unpcklps %xmm9,%xmm1
mulps  %xmm4,%xmm1
addps  %xmm6,%xmm1
movaps %xmm1,%xmm0
shufps $0x55,%xmm1,%xmm0
subps  %xmm0,%xmm2
movaps %xmm2,0x10(%rsp)
subss  %xmm0,%xmm1
movaps %xmm1,0x80(%rsp)
movaps %xmm2,%xmm0
shufps $0x55,%xmm2,%xmm0
call   1040 <fabs@plt>
mov    %rax,%rbx
movaps 0x10(%rsp),%xmm0
call   1040 <fabs@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rbx,%xmm0
xorps  %xmm1,%xmm1
cvtsi2ss %rax,%xmm1
unpcklps %xmm0,%xmm1
cvtps2pd %xmm1,%xmm0
cmpltpd 0xb62(%rip),%xmm0
shufps $0xe8,%xmm0,%xmm0
xorps  %xmm1,%xmm1
andps  %xmm0,%xmm1
andnps 0x10(%rsp),%xmm0
orps   %xmm0,%xmm1
movaps %xmm1,0x10(%rsp)
pshufd $0x55,%xmm0,%xmm0
movdqa %xmm0,0xc0(%rsp)
movaps 0x80(%rsp),%xmm0
call   1040 <fabs@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xb2c(%rip),%xmm1
ucomisd %xmm0,%xmm1
xorps  %xmm0,%xmm0
xorpd  %xmm1,%xmm1
ja     14fa <NoDivTriTriIsect+0x3da>
movapd 0x80(%rsp),%xmm1
movaps 0xc0(%rsp),%xmm2
movaps %xmm2,%xmm3
mulss  0x10(%rsp),%xmm3
mulss  %xmm1,%xmm2
ucomiss %xmm0,%xmm3
jbe    1520 <NoDivTriTriIsect+0x400>
xorps  %xmm0,%xmm0
ucomiss %xmm0,%xmm2
ja     1887 <NoDivTriTriIsect+0x767>
movaps %xmm2,0xe0(%rsp)
movaps %xmm1,0x90(%rsp)
movaps %xmm3,0x80(%rsp)
movaps 0x120(%rsp),%xmm3
movaps %xmm3,%xmm1
movaps 0x70(%rsp),%xmm5
mulss  %xmm5,%xmm1
movaps 0xa0(%rsp),%xmm2
movaps %xmm2,%xmm0
movaps 0x110(%rsp),%xmm4
mulss  %xmm4,%xmm0
subss  %xmm1,%xmm0
movaps 0xb0(%rsp),%xmm6
mulss  %xmm6,%xmm4
movaps 0x100(%rsp),%xmm1
mulss  %xmm1,%xmm5
subss  %xmm4,%xmm5
movaps %xmm5,0x70(%rsp)
mulss  %xmm2,%xmm1
mulss  %xmm3,%xmm6
subss  %xmm1,%xmm6
movaps %xmm6,0xb0(%rsp)
call   1040 <fabs@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
movss  %xmm0,0xa0(%rsp)
movaps 0x70(%rsp),%xmm0
call   1040 <fabs@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
movss  %xmm0,0x70(%rsp)
movaps 0xb0(%rsp),%xmm0
call   1040 <fabs@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
xor    %eax,%eax
movss  0xa0(%rsp),%xmm1
movss  0x70(%rsp),%xmm2
ucomiss %xmm1,%xmm2
seta   %al
maxss  %xmm1,%xmm2
ucomiss %xmm2,%xmm0
mov    $0x2,%ecx
cmovbe %rax,%rcx
xorps  %xmm6,%xmm6
movaps 0x80(%rsp),%xmm0
ucomiss %xmm6,%xmm0
movss  (%r15,%rcx,4),%xmm0
movss  0x0(%r13,%rcx,4),%xmm2
movss  (%r12,%rcx,4),%xmm5
mov    0x30(%rsp),%rax
movss  (%rax,%rcx,4),%xmm8
mov    0x38(%rsp),%rax
movss  (%rax,%rcx,4),%xmm1
movss  0x0(%rbp,%rcx,4),%xmm4
jbe    1674 <NoDivTriTriIsect+0x554>
unpcklps %xmm2,%xmm0
movaps %xmm5,%xmm2
shufps $0x0,%xmm5,%xmm2
subps  %xmm2,%xmm0
movaps 0x90(%rsp),%xmm9
shufps $0x0,%xmm9,%xmm9
movaps %xmm0,%xmm2
mulps  %xmm9,%xmm2
subps  0x10(%rsp),%xmm9
movaps %xmm5,%xmm0
jmp    1742 <NoDivTriTriIsect+0x622>
movaps 0xe0(%rsp),%xmm3
ucomiss %xmm6,%xmm3
jbe    16b7 <NoDivTriTriIsect+0x597>
unpcklps %xmm5,%xmm0
movaps %xmm2,%xmm5
shufps $0x0,%xmm2,%xmm5
subps  %xmm5,%xmm0
movaps 0x10(%rsp),%xmm3
movaps %xmm3,%xmm5
shufps $0x0,%xmm3,%xmm5
movaps %xmm0,%xmm6
mulps  %xmm5,%xmm6
movaps 0x90(%rsp),%xmm0
movss  %xmm0,%xmm3
subps  %xmm3,%xmm5
movaps %xmm2,%xmm0
movaps %xmm6,%xmm2
jmp    171e <NoDivTriTriIsect+0x5fe>
xorps  %xmm3,%xmm3
movaps 0xc0(%rsp),%xmm6
ucomiss %xmm3,%xmm6
movaps 0x10(%rsp),%xmm9
movaps 0x90(%rsp),%xmm6
jne    1724 <NoDivTriTriIsect+0x604>
jp     1724 <NoDivTriTriIsect+0x604>
movaps %xmm9,%xmm7
mulss  %xmm6,%xmm7
ucomiss %xmm3,%xmm7
ja     1724 <NoDivTriTriIsect+0x604>
xorps  %xmm3,%xmm3
ucomiss %xmm3,%xmm9
jne    16f3 <NoDivTriTriIsect+0x5d3>
jnp    189c <NoDivTriTriIsect+0x77c>
unpcklps %xmm5,%xmm0
movaps %xmm2,%xmm5
shufps $0x0,%xmm2,%xmm5
subps  %xmm5,%xmm0
movaps %xmm9,%xmm5
shufps $0x0,%xmm9,%xmm5
movaps %xmm0,%xmm3
mulps  %xmm5,%xmm3
movss  %xmm6,%xmm9
subps  %xmm9,%xmm5
movaps %xmm2,%xmm0
movaps %xmm3,%xmm2
movaps %xmm5,%xmm9
jmp    1742 <NoDivTriTriIsect+0x622>
unpcklps %xmm5,%xmm2
movaps %xmm0,%xmm5
shufps $0x0,%xmm0,%xmm5
subps  %xmm5,%xmm2
unpcklps %xmm9,%xmm6
shufps $0x55,%xmm9,%xmm9
mulps  %xmm9,%xmm2
subps  %xmm6,%xmm9
movaps 0x20(%rsp),%xmm7
movaps 0x60(%rsp),%xmm3
movaps 0x50(%rsp),%xmm6
xorps  %xmm5,%xmm5
ucomiss %xmm5,%xmm6
jbe    1782 <NoDivTriTriIsect+0x662>
unpcklps %xmm1,%xmm8
movaps %xmm4,%xmm1
shufps $0x0,%xmm4,%xmm1
subps  %xmm1,%xmm8
shufps $0x0,%xmm3,%xmm3
movaps %xmm8,%xmm1
mulps  %xmm3,%xmm1
subps  %xmm7,%xmm3
movaps %xmm4,%xmm8
movaps %xmm3,%xmm7
jmp    1807 <NoDivTriTriIsect+0x6e7>
movaps 0xf0(%rsp),%xmm6
ucomiss %xmm5,%xmm6
ja     17bb <NoDivTriTriIsect+0x69b>
xorps  %xmm5,%xmm5
movaps 0xd0(%rsp),%xmm6
ucomiss %xmm5,%xmm6
jne    17eb <NoDivTriTriIsect+0x6cb>
jp     17eb <NoDivTriTriIsect+0x6cb>
movaps %xmm7,%xmm6
mulss  %xmm3,%xmm6
ucomiss %xmm5,%xmm6
ja     17eb <NoDivTriTriIsect+0x6cb>
xorps  %xmm5,%xmm5
ucomiss %xmm5,%xmm7
jne    17bb <NoDivTriTriIsect+0x69b>
jnp    18d4 <NoDivTriTriIsect+0x7b4>
unpcklps %xmm4,%xmm8
movaps %xmm1,%xmm4
shufps $0x0,%xmm1,%xmm4
subps  %xmm4,%xmm8
movaps %xmm7,%xmm4
shufps $0x0,%xmm7,%xmm4
movaps %xmm8,%xmm5
mulps  %xmm4,%xmm5
movss  %xmm3,%xmm7
subps  %xmm7,%xmm4
movaps %xmm1,%xmm8
movaps %xmm5,%xmm1
movaps %xmm4,%xmm7
jmp    1807 <NoDivTriTriIsect+0x6e7>
unpcklps %xmm4,%xmm1
movaps %xmm8,%xmm4
shufps $0x0,%xmm8,%xmm4
subps  %xmm4,%xmm1
unpcklps %xmm7,%xmm3
shufps $0x55,%xmm7,%xmm7
mulps  %xmm7,%xmm1
subps  %xmm3,%xmm7
movaps %xmm9,%xmm4
shufps $0x55,%xmm9,%xmm4
mulps  %xmm9,%xmm4
movaps %xmm7,%xmm5
shufps $0x55,%xmm7,%xmm5
mulps  %xmm7,%xmm5
movaps %xmm4,%xmm6
mulss  %xmm5,%xmm6
mulss  %xmm6,%xmm0
mulps  %xmm9,%xmm2
shufps $0x0,%xmm5,%xmm5
mulps  %xmm2,%xmm5
shufps $0x0,%xmm0,%xmm0
addps  %xmm5,%xmm0
mulss  %xmm8,%xmm6
shufps $0x0,%xmm4,%xmm4
mulps  %xmm1,%xmm4
shufps $0x0,%xmm6,%xmm6
mulps  %xmm7,%xmm4
addps  %xmm6,%xmm4
movaps %xmm0,%xmm1
shufps $0x55,%xmm0,%xmm1
movaps %xmm1,%xmm2
minss  %xmm0,%xmm2
maxss  %xmm1,%xmm0
movaps %xmm4,%xmm1
shufps $0x55,%xmm4,%xmm1
movaps %xmm1,%xmm3
minss  %xmm4,%xmm3
maxss  %xmm1,%xmm4
ucomiss %xmm0,%xmm3
setbe  %al
ucomiss %xmm4,%xmm2
setbe  %cl
and    %al,%cl
movzbl %cl,%r14d
mov    %r14d,%eax
add    $0x138,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
ucomiss %xmm3,%xmm6
movaps 0x20(%rsp),%xmm7
movaps 0x60(%rsp),%xmm3
jne    18ad <NoDivTriTriIsect+0x78d>
jnp    18e3 <NoDivTriTriIsect+0x7c3>
unpcklps %xmm2,%xmm0
movaps %xmm5,%xmm2
shufps $0x0,%xmm5,%xmm2
subps  %xmm2,%xmm0
shufps $0x0,%xmm6,%xmm6
movaps %xmm0,%xmm2
mulps  %xmm6,%xmm2
subps  %xmm9,%xmm6
movaps %xmm5,%xmm0
movaps %xmm6,%xmm9
jmp    174c <NoDivTriTriIsect+0x62c>
ucomiss %xmm5,%xmm3
jne    1759 <NoDivTriTriIsect+0x639>
jp     1759 <NoDivTriTriIsect+0x639>
mov    %rbp,(%rsp)
lea    0x44(%rsp),%rdi
mov    %r15,%rsi
mov    %r13,%rdx
mov    %r12,%rcx
mov    0x30(%rsp),%r8
mov    0x38(%rsp),%r9
call   1030 <coplanar_tri_tri@plt>
mov    %eax,%r14d
jmp    1887 <NoDivTriTriIsect+0x767>

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

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