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


x86 assembly (clang, -O0):
<tri_tri_intersect>:
push   %rbp
mov    %rsp,%rbp
sub    $0xf0,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
mov    %r9,-0x38(%rbp)
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
subss  (%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x10(%rbp),%rax
subss  0x4(%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
subss  0x8(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
subss  (%rax),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x10(%rbp),%rax
subss  0x4(%rax),%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
subss  0x8(%rax),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x40(%rbp),%xmm0
movss  -0x48(%rbp),%xmm2
movss  -0x3c(%rbp),%xmm1
mulss  -0x4c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  -0x48(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x44(%rbp),%xmm0
movss  -0x4c(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  -0x50(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x5c(%rbp),%xmm1
mov    -0x10(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x58(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mulss  0x4(%rax),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x54(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  -0x5c(%rbp),%xmm1
mov    -0x28(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x58(%rbp),%xmm0
mov    -0x28(%rbp),%rax
mulss  0x4(%rax),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x54(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
addss  -0x6c(%rbp),%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x5c(%rbp),%xmm1
mov    -0x30(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x58(%rbp),%xmm0
mov    -0x30(%rbp),%rax
mulss  0x4(%rax),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x54(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
addss  -0x6c(%rbp),%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x5c(%rbp),%xmm1
mov    -0x38(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x58(%rbp),%xmm0
mov    -0x38(%rbp),%rax
mulss  0x4(%rax),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x54(%rbp),%xmm0
mov    -0x38(%rbp),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
addss  -0x6c(%rbp),%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x74(%rbp),%xmm0
call   1040 <fabs@plt>
movaps %xmm0,%xmm1
movsd  0x1c84(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    138e <tri_tri_intersect+0x26e>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x78(%rbp),%xmm0
call   1040 <fabs@plt>
movaps %xmm0,%xmm1
movsd  0x1c5d(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    13b5 <tri_tri_intersect+0x295>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x7c(%rbp),%xmm0
call   1040 <fabs@plt>
movaps %xmm0,%xmm1
movsd  0x1c36(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    13dc <tri_tri_intersect+0x2bc>
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    1434 <tri_tri_intersect+0x314>
movss  -0xac(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    1434 <tri_tri_intersect+0x314>
movl   $0x0,-0x4(%rbp)
jmp    2057 <tri_tri_intersect+0xf37>
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>
movaps %xmm0,%xmm1
movsd  0x198d(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    1685 <tri_tri_intersect+0x565>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x84(%rbp),%xmm0
ff
call   1040 <fabs@plt>
movaps %xmm0,%xmm1
movsd  0x1963(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    16b2 <tri_tri_intersect+0x592>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x88(%rbp),%xmm0
ff
call   1040 <fabs@plt>
movaps %xmm0,%xmm1
movsd  0x1936(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    16df <tri_tri_intersect+0x5bf>
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
movss  %xmm0,-0xb4(%rbp)
ff
movss  -0xb0(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    173d <tri_tri_intersect+0x61d>
movss  -0xb4(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    173d <tri_tri_intersect+0x61d>
movl   $0x0,-0x4(%rbp)
jmp    2057 <tri_tri_intersect+0xf37>
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>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0xdc(%rbp)
ff
movw   $0x0,-0xb6(%rbp)
movss  -0x90(%rbp),%xmm0
ff
call   1040 <fabs@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0xd4(%rbp)
ff
movss  -0x8c(%rbp),%xmm0
ff
call   1040 <fabs@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0xd8(%rbp)
ff
movss  -0xd4(%rbp),%xmm0
ff
ucomiss -0xdc(%rbp),%xmm0
jbe    1852 <tri_tri_intersect+0x732>
movss  -0xd4(%rbp),%xmm0
ff
movss  %xmm0,-0xdc(%rbp)
ff
movw   $0x1,-0xb6(%rbp)
movss  -0xd8(%rbp),%xmm0
ff
ucomiss -0xdc(%rbp),%xmm0
jbe    1880 <tri_tri_intersect+0x760>
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    19ac <tri_tri_intersect+0x88c>
movss  -0xc4(%rbp),%xmm0
ff
movss  -0xbc(%rbp),%xmm1
ff
subss  -0xc4(%rbp),%xmm1
ff
mulss  -0x88(%rbp),%xmm1
ff
movss  -0x88(%rbp),%xmm2
ff
subss  -0x80(%rbp),%xmm2
divss  %xmm2,%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
movss  -0xc4(%rbp),%xmm0
ff
movss  -0xc0(%rbp),%xmm1
ff
subss  -0xc4(%rbp),%xmm1
ff
mulss  -0x88(%rbp),%xmm1
ff
movss  -0x88(%rbp),%xmm2
ff
subss  -0x84(%rbp),%xmm2
ff
divss  %xmm2,%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,-0x98(%rbp)
ff
jmp    1c76 <tri_tri_intersect+0xb56>
movss  -0xb4(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    1a42 <tri_tri_intersect+0x922>
movss  -0xc0(%rbp),%xmm0
ff
movss  -0xbc(%rbp),%xmm1
ff
subss  -0xc0(%rbp),%xmm1
ff
mulss  -0x84(%rbp),%xmm1
ff
movss  -0x84(%rbp),%xmm2
ff
subss  -0x80(%rbp),%xmm2
divss  %xmm2,%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
movss  -0xc0(%rbp),%xmm0
ff
movss  -0xc4(%rbp),%xmm1
ff
subss  -0xc0(%rbp),%xmm1
ff
mulss  -0x84(%rbp),%xmm1
ff
movss  -0x84(%rbp),%xmm2
ff
subss  -0x88(%rbp),%xmm2
ff
divss  %xmm2,%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,-0x98(%rbp)
ff
jmp    1c71 <tri_tri_intersect+0xb51>
movss  -0x84(%rbp),%xmm0
ff
mulss  -0x88(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
ja     1a7a <tri_tri_intersect+0x95a>
movss  -0x80(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1a7a <tri_tri_intersect+0x95a>
jp     1a7a <tri_tri_intersect+0x95a>
jmp    1af3 <tri_tri_intersect+0x9d3>
movss  -0xbc(%rbp),%xmm0
ff
movss  -0xc0(%rbp),%xmm1
ff
subss  -0xbc(%rbp),%xmm1
ff
mulss  -0x80(%rbp),%xmm1
movss  -0x80(%rbp),%xmm2
subss  -0x84(%rbp),%xmm2
ff
divss  %xmm2,%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
movss  -0xbc(%rbp),%xmm0
ff
movss  -0xc4(%rbp),%xmm1
ff
subss  -0xbc(%rbp),%xmm1
ff
mulss  -0x80(%rbp),%xmm1
movss  -0x80(%rbp),%xmm2
subss  -0x88(%rbp),%xmm2
ff
divss  %xmm2,%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,-0x98(%rbp)
ff
jmp    1c6c <tri_tri_intersect+0xb4c>
movss  -0x84(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1b12 <tri_tri_intersect+0x9f2>
jp     1b12 <tri_tri_intersect+0x9f2>
jmp    1b94 <tri_tri_intersect+0xa74>
movss  -0xc0(%rbp),%xmm0
ff
movss  -0xbc(%rbp),%xmm1
ff
subss  -0xc0(%rbp),%xmm1
ff
mulss  -0x84(%rbp),%xmm1
ff
movss  -0x84(%rbp),%xmm2
ff
subss  -0x80(%rbp),%xmm2
divss  %xmm2,%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
movss  -0xc0(%rbp),%xmm0
ff
movss  -0xc4(%rbp),%xmm1
ff
subss  -0xc0(%rbp),%xmm1
ff
mulss  -0x84(%rbp),%xmm1
ff
movss  -0x84(%rbp),%xmm2
ff
subss  -0x88(%rbp),%xmm2
ff
divss  %xmm2,%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,-0x98(%rbp)
ff
jmp    1c67 <tri_tri_intersect+0xb47>
movss  -0x88(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1bb3 <tri_tri_intersect+0xa93>
jp     1bb3 <tri_tri_intersect+0xa93>
jmp    1c35 <tri_tri_intersect+0xb15>
movss  -0xc4(%rbp),%xmm0
ff
movss  -0xbc(%rbp),%xmm1
ff
subss  -0xc4(%rbp),%xmm1
ff
mulss  -0x88(%rbp),%xmm1
ff
movss  -0x88(%rbp),%xmm2
ff
subss  -0x80(%rbp),%xmm2
divss  %xmm2,%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
movss  -0xc4(%rbp),%xmm0
ff
movss  -0xc0(%rbp),%xmm1
ff
subss  -0xc4(%rbp),%xmm1
ff
mulss  -0x88(%rbp),%xmm1
ff
movss  -0x88(%rbp),%xmm2
ff
subss  -0x84(%rbp),%xmm2
ff
divss  %xmm2,%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,-0x98(%rbp)
ff
jmp    1c62 <tri_tri_intersect+0xb42>
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    2057 <tri_tri_intersect+0xf37>
jmp    1c67 <tri_tri_intersect+0xb47>
jmp    1c6c <tri_tri_intersect+0xb4c>
jmp    1c71 <tri_tri_intersect+0xb51>
jmp    1c76 <tri_tri_intersect+0xb56>
movss  -0xa8(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    1cfd <tri_tri_intersect+0xbdd>
movss  -0xd0(%rbp),%xmm0
ff
movss  -0xc8(%rbp),%xmm1
ff
subss  -0xd0(%rbp),%xmm1
ff
mulss  -0x7c(%rbp),%xmm1
movss  -0x7c(%rbp),%xmm2
subss  -0x74(%rbp),%xmm2
divss  %xmm2,%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,-0xa4(%rbp)
ff
movss  -0xd0(%rbp),%xmm0
ff
movss  -0xcc(%rbp),%xmm1
ff
subss  -0xd0(%rbp),%xmm1
ff
mulss  -0x7c(%rbp),%xmm1
movss  -0x7c(%rbp),%xmm2
subss  -0x78(%rbp),%xmm2
divss  %xmm2,%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,-0xa0(%rbp)
ff
jmp    1f88 <tri_tri_intersect+0xe68>
movss  -0xac(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    1d84 <tri_tri_intersect+0xc64>
movss  -0xcc(%rbp),%xmm0
ff
movss  -0xc8(%rbp),%xmm1
ff
subss  -0xcc(%rbp),%xmm1
ff
mulss  -0x78(%rbp),%xmm1
movss  -0x78(%rbp),%xmm2
subss  -0x74(%rbp),%xmm2
divss  %xmm2,%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,-0xa4(%rbp)
ff
movss  -0xcc(%rbp),%xmm0
ff
movss  -0xd0(%rbp),%xmm1
ff
subss  -0xcc(%rbp),%xmm1
ff
mulss  -0x78(%rbp),%xmm1
movss  -0x78(%rbp),%xmm2
subss  -0x7c(%rbp),%xmm2
divss  %xmm2,%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,-0xa0(%rbp)
ff
jmp    1f83 <tri_tri_intersect+0xe63>
movss  -0x78(%rbp),%xmm0
mulss  -0x7c(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
ja     1db6 <tri_tri_intersect+0xc96>
movss  -0x74(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1db6 <tri_tri_intersect+0xc96>
jp     1db6 <tri_tri_intersect+0xc96>
jmp    1e29 <tri_tri_intersect+0xd09>
movss  -0xc8(%rbp),%xmm0
ff
movss  -0xcc(%rbp),%xmm1
ff
subss  -0xc8(%rbp),%xmm1
ff
mulss  -0x74(%rbp),%xmm1
movss  -0x74(%rbp),%xmm2
subss  -0x78(%rbp),%xmm2
divss  %xmm2,%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,-0xa4(%rbp)
ff
movss  -0xc8(%rbp),%xmm0
ff
movss  -0xd0(%rbp),%xmm1
ff
subss  -0xc8(%rbp),%xmm1
ff
mulss  -0x74(%rbp),%xmm1
movss  -0x74(%rbp),%xmm2
subss  -0x7c(%rbp),%xmm2
divss  %xmm2,%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,-0xa0(%rbp)
ff
jmp    1f7e <tri_tri_intersect+0xe5e>
movss  -0x78(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1e45 <tri_tri_intersect+0xd25>
jp     1e45 <tri_tri_intersect+0xd25>
jmp    1eb8 <tri_tri_intersect+0xd98>
movss  -0xcc(%rbp),%xmm0
ff
movss  -0xc8(%rbp),%xmm1
ff
subss  -0xcc(%rbp),%xmm1
ff
mulss  -0x78(%rbp),%xmm1
movss  -0x78(%rbp),%xmm2
subss  -0x74(%rbp),%xmm2
divss  %xmm2,%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,-0xa4(%rbp)
ff
movss  -0xcc(%rbp),%xmm0
ff
movss  -0xd0(%rbp),%xmm1
ff
subss  -0xcc(%rbp),%xmm1
ff
mulss  -0x78(%rbp),%xmm1
movss  -0x78(%rbp),%xmm2
subss  -0x7c(%rbp),%xmm2
divss  %xmm2,%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,-0xa0(%rbp)
ff
jmp    1f79 <tri_tri_intersect+0xe59>
movss  -0x7c(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1ed4 <tri_tri_intersect+0xdb4>
jp     1ed4 <tri_tri_intersect+0xdb4>
jmp    1f47 <tri_tri_intersect+0xe27>
movss  -0xd0(%rbp),%xmm0
ff
movss  -0xc8(%rbp),%xmm1
ff
subss  -0xd0(%rbp),%xmm1
ff
mulss  -0x7c(%rbp),%xmm1
movss  -0x7c(%rbp),%xmm2
subss  -0x74(%rbp),%xmm2
divss  %xmm2,%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,-0xa4(%rbp)
ff
movss  -0xd0(%rbp),%xmm0
ff
movss  -0xcc(%rbp),%xmm1
ff
subss  -0xd0(%rbp),%xmm1
ff
mulss  -0x7c(%rbp),%xmm1
movss  -0x7c(%rbp),%xmm2
subss  -0x78(%rbp),%xmm2
divss  %xmm2,%xmm1
addss  %xmm1,%xmm0
movss  %xmm0,-0xa0(%rbp)
ff
jmp    1f74 <tri_tri_intersect+0xe54>
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    2057 <tri_tri_intersect+0xf37>
jmp    1f79 <tri_tri_intersect+0xe59>
jmp    1f7e <tri_tri_intersect+0xe5e>
jmp    1f83 <tri_tri_intersect+0xe63>
jmp    1f88 <tri_tri_intersect+0xe68>
movss  -0x9c(%rbp),%xmm0
ff
ucomiss -0x98(%rbp),%xmm0
jbe    1fcd <tri_tri_intersect+0xead>
movss  -0x9c(%rbp),%xmm0
ff
movss  %xmm0,-0xe0(%rbp)
ff
movss  -0x98(%rbp),%xmm0
ff
movss  %xmm0,-0x9c(%rbp)
ff
movss  -0xe0(%rbp),%xmm0
ff
movss  %xmm0,-0x98(%rbp)
ff
movss  -0xa4(%rbp),%xmm0
ff
ucomiss -0xa0(%rbp),%xmm0
jbe    2012 <tri_tri_intersect+0xef2>
movss  -0xa4(%rbp),%xmm0
ff
movss  %xmm0,-0xe4(%rbp)
ff
movss  -0xa0(%rbp),%xmm0
ff
movss  %xmm0,-0xa4(%rbp)
movss  -0xe4(%rbp),%xmm0
movss  %xmm0,-0xa0(%rbp)
ff
movss  -0x98(%rbp),%xmm1
ff
movss  -0xa4(%rbp),%xmm0
ff
ucomiss %xmm1,%xmm0
ja     2044 <tri_tri_intersect+0xf24>
movss  -0xa0(%rbp),%xmm1
ff
movss  -0x9c(%rbp),%xmm0
ff
ucomiss %xmm1,%xmm0
jbe    2050 <tri_tri_intersect+0xf30>
movl   $0x0,-0x4(%rbp)
jmp    2057 <tri_tri_intersect+0xf37>
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0xf0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<tri_tri_intersect>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x138,%rsp
mov    %r9,%rbp
mov    %rcx,%r15
mov    %rdx,%r12
mov    %rsi,%r13
mov    %rdi,%rbx
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,0xc0(%rsp)
shufps $0x0,%xmm3,%xmm3
movss  (%rcx),%xmm1
movss  0x4(%rcx),%xmm5
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,0xd0(%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>
movaps %xmm0,0xa0(%rsp)
movapd 0x20(%rsp),%xmm0
call   1040 <fabs@plt>
unpcklpd 0xa0(%rsp),%xmm0
cmpltpd 0xd64(%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,0xa0(%rsp)
movapd 0x10(%rsp),%xmm0
call   1040 <fabs@plt>
movsd  0xd3c(%rip),%xmm1
ucomisd %xmm0,%xmm1
xorpd  %xmm0,%xmm0
xorps  %xmm2,%xmm2
ja     12e6 <tri_tri_intersect+0x1c6>
movaps 0x10(%rsp),%xmm2
movaps 0xa0(%rsp),%xmm4
movaps %xmm4,%xmm5
movaps 0x20(%rsp),%xmm1
mulss  %xmm1,%xmm5
mulss  %xmm2,%xmm4
xor    %r14d,%r14d
ucomiss %xmm0,%xmm5
jbe    1312 <tri_tri_intersect+0x1f2>
xorps  %xmm0,%xmm0
ucomiss %xmm0,%xmm4
ja     17cf <tri_tri_intersect+0x6af>
movaps %xmm5,0x50(%rsp)
movaps %xmm4,0xf0(%rsp)
movaps %xmm2,0x60(%rsp)
mov    0x38(%rsp),%rax
movss  (%rax),%xmm3
movss  0x4(%rax),%xmm0
movss  (%r15),%xmm8
movss  0x4(%r15),%xmm2
subss  %xmm8,%xmm3
subss  %xmm2,%xmm0
movss  0x8(%rax),%xmm4
movss  0x8(%r15),%xmm9
subss  %xmm9,%xmm4
movss  0x0(%rbp),%xmm5
movss  0x4(%rbp),%xmm7
subss  %xmm8,%xmm5
subss  %xmm2,%xmm7
movss  0x8(%rbp),%xmm6
subss  %xmm9,%xmm6
movaps %xmm7,%xmm1
mulss  %xmm4,%xmm1
mulss  %xmm5,%xmm4
mulss  %xmm0,%xmm5
mulss  %xmm6,%xmm0
subss  %xmm1,%xmm0
mulss  %xmm3,%xmm6
subss  %xmm6,%xmm4
mulss  %xmm3,%xmm7
subss  %xmm5,%xmm7
movss  0x0(%r13),%xmm3
movss  0x4(%r13),%xmm1
movss  0x8(%r13),%xmm5
movss  (%rbx),%xmm6
unpcklps %xmm3,%xmm6
movss  0x4(%rbx),%xmm3
unpcklps %xmm1,%xmm3
movss  0x8(%rbx),%xmm1
unpcklps %xmm5,%xmm1
movaps %xmm4,0x120(%rsp)
shufps $0x0,%xmm4,%xmm4
mulps  %xmm4,%xmm3
movaps %xmm0,0x100(%rsp)
movaps %xmm0,%xmm5
shufps $0x0,%xmm0,%xmm5
mulps  %xmm5,%xmm6
addps  %xmm3,%xmm6
movaps %xmm7,0x110(%rsp)
movaps %xmm7,%xmm3
shufps $0x0,%xmm7,%xmm3
mulps  %xmm3,%xmm1
addps  %xmm6,%xmm1
movaps %xmm1,%xmm10
movss  (%r12),%xmm6
movss  0x4(%r12),%xmm7
movss  0x8(%r12),%xmm1
unpcklps %xmm2,%xmm7
mulps  %xmm4,%xmm7
unpcklps %xmm8,%xmm6
mulps  %xmm5,%xmm6
addps  %xmm7,%xmm6
unpcklps %xmm9,%xmm1
mulps  %xmm3,%xmm1
addps  %xmm6,%xmm1
movaps %xmm1,%xmm0
shufps $0x55,%xmm1,%xmm0
subps  %xmm0,%xmm10
movaps %xmm10,0x10(%rsp)
subss  %xmm0,%xmm1
movaps %xmm1,0x90(%rsp)
movaps %xmm10,%xmm0
call   1040 <fabs@plt>
movaps %xmm0,0x80(%rsp)
movaps 0x10(%rsp),%xmm0
shufps $0x55,%xmm0,%xmm0
call   1040 <fabs@plt>
movaps 0x80(%rsp),%xmm1
movlhps %xmm0,%xmm1
cmpltpd 0xb82(%rip),%xmm1
shufps $0xe8,%xmm1,%xmm1
xorps  %xmm0,%xmm0
andps  %xmm1,%xmm0
andnps 0x10(%rsp),%xmm1
orps   %xmm1,%xmm0
movaps %xmm0,0x10(%rsp)
pshufd $0x55,%xmm1,%xmm0
movdqa %xmm0,0x80(%rsp)
movapd 0x90(%rsp),%xmm0
call   1040 <fabs@plt>
movsd  0xb57(%rip),%xmm1
ucomisd %xmm0,%xmm1
xorpd  %xmm0,%xmm0
xorps  %xmm2,%xmm2
ja     14ce <tri_tri_intersect+0x3ae>
movaps 0x90(%rsp),%xmm2
movaps 0x10(%rsp),%xmm1
movaps %xmm1,%xmm3
mulss  0x80(%rsp),%xmm3
mulss  %xmm2,%xmm1
ucomiss %xmm0,%xmm3
jbe    14f4 <tri_tri_intersect+0x3d4>
xorps  %xmm0,%xmm0
ucomiss %xmm0,%xmm1
ja     17cf <tri_tri_intersect+0x6af>
movaps %xmm1,0xe0(%rsp)
movaps %xmm2,0xb0(%rsp)
movaps %xmm3,0x90(%rsp)
movaps 0x120(%rsp),%xmm3
movaps %xmm3,%xmm1
movaps 0x70(%rsp),%xmm5
mulss  %xmm5,%xmm1
movaps 0xc0(%rsp),%xmm2
movaps %xmm2,%xmm0
movaps 0x110(%rsp),%xmm4
mulss  %xmm4,%xmm0
subss  %xmm1,%xmm0
movaps 0xd0(%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,0xd0(%rsp)
call   1040 <fabs@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0xc0(%rsp)
movaps 0x70(%rsp),%xmm0
call   1040 <fabs@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x70(%rsp)
movaps 0xd0(%rsp),%xmm0
call   1040 <fabs@plt>
cvtsd2ss %xmm0,%xmm0
xor    %eax,%eax
movss  0xc0(%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 0x90(%rsp),%xmm0
ucomiss %xmm6,%xmm0
movss  (%rbx,%rcx,4),%xmm4
movss  0x0(%r13,%rcx,4),%xmm1
movss  (%r12,%rcx,4),%xmm5
movss  (%r15,%rcx,4),%xmm8
mov    0x38(%rsp),%rax
movss  (%rax,%rcx,4),%xmm2
movss  0x0(%rbp,%rcx,4),%xmm0
jbe    1632 <tri_tri_intersect+0x512>
unpcklps %xmm1,%xmm4
shufps $0x0,%xmm5,%xmm5
subps  %xmm5,%xmm4
movaps 0xb0(%rsp),%xmm1
shufps $0x0,%xmm1,%xmm1
mulps  %xmm1,%xmm4
subps  0x10(%rsp),%xmm1
divps  %xmm1,%xmm4
addps  %xmm5,%xmm4
movaps %xmm4,%xmm1
jmp    16e8 <tri_tri_intersect+0x5c8>
movaps 0xe0(%rsp),%xmm3
ucomiss %xmm6,%xmm3
jbe    1662 <tri_tri_intersect+0x542>
unpcklps %xmm5,%xmm4
shufps $0x0,%xmm1,%xmm1
subps  %xmm1,%xmm4
movaps 0x10(%rsp),%xmm6
movaps %xmm6,%xmm5
shufps $0x55,%xmm6,%xmm5
mulps  %xmm5,%xmm4
movaps 0xb0(%rsp),%xmm3
jmp    16b7 <tri_tri_intersect+0x597>
xorps  %xmm9,%xmm9
movaps 0x10(%rsp),%xmm7
ucomiss %xmm9,%xmm7
movaps 0xb0(%rsp),%xmm3
movaps 0x80(%rsp),%xmm6
jne    16c6 <tri_tri_intersect+0x5a6>
jp     16c6 <tri_tri_intersect+0x5a6>
movaps %xmm6,%xmm7
mulss  %xmm3,%xmm7
ucomiss %xmm9,%xmm7
ja     16c6 <tri_tri_intersect+0x5a6>
xorps  %xmm7,%xmm7
ucomiss %xmm7,%xmm6
jne    169e <tri_tri_intersect+0x57e>
jnp    17e4 <tri_tri_intersect+0x6c4>
unpcklps %xmm5,%xmm4
shufps $0x0,%xmm1,%xmm1
subps  %xmm1,%xmm4
movaps 0x10(%rsp),%xmm6
movaps %xmm6,%xmm5
shufps $0x55,%xmm6,%xmm5
mulps  %xmm5,%xmm4
movlhps %xmm6,%xmm3
shufps $0xe2,%xmm6,%xmm3
subps  %xmm3,%xmm5
divps  %xmm5,%xmm4
jmp    16e5 <tri_tri_intersect+0x5c5>
unpcklps %xmm5,%xmm1
shufps $0x0,%xmm4,%xmm4
subps  %xmm4,%xmm1
movaps 0x10(%rsp),%xmm5
shufps $0x0,%xmm5,%xmm5
mulps  %xmm5,%xmm1
unpcklps %xmm3,%xmm6
subps  %xmm6,%xmm5
divps  %xmm5,%xmm1
addps  %xmm4,%xmm1
movaps 0x20(%rsp),%xmm6
movaps 0x60(%rsp),%xmm7
movaps 0x50(%rsp),%xmm5
xorps  %xmm4,%xmm4
ucomiss %xmm4,%xmm5
jbe    171c <tri_tri_intersect+0x5fc>
unpcklps %xmm8,%xmm2
shufps $0x0,%xmm0,%xmm0
subps  %xmm0,%xmm2
shufps $0x0,%xmm7,%xmm7
mulps  %xmm7,%xmm2
subps  %xmm6,%xmm7
divps  %xmm7,%xmm2
addps  %xmm2,%xmm0
jmp    1799 <tri_tri_intersect+0x679>
movaps 0xf0(%rsp),%xmm5
ucomiss %xmm4,%xmm5
ja     1755 <tri_tri_intersect+0x635>
xorps  %xmm4,%xmm4
movaps 0xa0(%rsp),%xmm5
ucomiss %xmm4,%xmm5
jne    1779 <tri_tri_intersect+0x659>
jp     1779 <tri_tri_intersect+0x659>
movaps %xmm6,%xmm5
mulss  %xmm7,%xmm5
ucomiss %xmm4,%xmm5
ja     1779 <tri_tri_intersect+0x659>
xorps  %xmm4,%xmm4
ucomiss %xmm4,%xmm6
jne    1755 <tri_tri_intersect+0x635>
jnp    1819 <tri_tri_intersect+0x6f9>
unpcklps %xmm8,%xmm0
shufps $0x0,%xmm2,%xmm2
subps  %xmm2,%xmm0
movaps %xmm6,%xmm3
shufps $0x0,%xmm6,%xmm3
mulps  %xmm3,%xmm0
movss  %xmm7,%xmm6
subps  %xmm6,%xmm3
divps  %xmm3,%xmm0
addps  %xmm2,%xmm0
jmp    1799 <tri_tri_intersect+0x679>
unpcklps %xmm2,%xmm0
shufps $0x0,%xmm8,%xmm8
subps  %xmm8,%xmm0
unpcklps %xmm6,%xmm7
shufps $0x55,%xmm6,%xmm6
mulps  %xmm6,%xmm0
subps  %xmm7,%xmm6
divps  %xmm6,%xmm0
addps  %xmm8,%xmm0
movaps %xmm1,%xmm2
shufps $0x55,%xmm1,%xmm2
movaps %xmm2,%xmm3
minss  %xmm1,%xmm3
maxss  %xmm2,%xmm1
movaps %xmm0,%xmm2
shufps $0x55,%xmm0,%xmm2
movaps %xmm2,%xmm4
maxss  %xmm0,%xmm4
minss  %xmm2,%xmm0
ucomiss %xmm1,%xmm0
setbe  %al
ucomiss %xmm4,%xmm3
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 %xmm7,%xmm3
movaps 0x60(%rsp),%xmm7
jne    17f0 <tri_tri_intersect+0x6d0>
jnp    1828 <tri_tri_intersect+0x708>
unpcklps %xmm1,%xmm4
shufps $0x0,%xmm5,%xmm5
subps  %xmm5,%xmm4
shufps $0x0,%xmm3,%xmm3
mulps  %xmm3,%xmm4
subps  0x10(%rsp),%xmm3
divps  %xmm3,%xmm4
addps  %xmm5,%xmm4
movaps %xmm4,%xmm1
movaps 0x20(%rsp),%xmm6
jmp    16f2 <tri_tri_intersect+0x5d2>
ucomiss %xmm4,%xmm7
jne    16ff <tri_tri_intersect+0x5df>
jp     16ff <tri_tri_intersect+0x5df>
mov    %rbp,(%rsp)
lea    0x44(%rsp),%rdi
mov    %rbx,%rsi
mov    %r13,%rdx
mov    %r12,%rcx
mov    %r15,%r8
mov    0x38(%rsp),%r9
call   1030 <coplanar_tri_tri@plt>
mov    %eax,%r14d
jmp    17cf <tri_tri_intersect+0x6af>

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

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