#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 compute_intervals_isectline(float *, float *, float *, float, float, float,
                                float, float, float, float, float, float *,
                                float *, float *, float *);
int coplanar_tri_tri(float *, float *, float *, float *, float *, float *,
                     float *);
double fabs(float);
int tri_tri_intersect_with_isectline(float V0[3], float V1[3], float V2[3],
                                     float U0[3], float U1[3], float U2[3],
                                     int *coplanar, float isectpt1[3],
                                     float isectpt2[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 isectpointA1[3], isectpointA2[3];
  float isectpointB1[3], isectpointB2[3];
  float du0du1, du0du2, dv0dv1, dv0dv2;
  short index;
  float vp0, vp1, vp2;
  float up0, up1, up2;
  float b, c, max;
  float tmp, diff[3];
  int smallest1, smallest2;
  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];
  *coplanar = compute_intervals_isectline(
      V0, V1, V2, vp0, vp1, vp2, dv0, dv1, dv2, dv0dv1, dv0dv2, &isect1[0],
      &isect1[1], isectpointA1, isectpointA2);
  if (*coplanar)
    return coplanar_tri_tri(N1, V0, V1, V2, U0, U1, U2);
  compute_intervals_isectline(U0, U1, U2, up0, up1, up2, du0, du1, du2, du0du1,
                              du0du2, &isect2[0], &isect2[1], isectpointB1,
                              isectpointB2);
  if (isect1[0] > isect1[1]) {
    float c;
    c = isect1[0];
    isect1[0] = isect1[1];
    isect1[1] = c;
    smallest1 = 1;
  } else
    smallest1 = 0;
  ;
  if (isect2[0] > isect2[1]) {
    float c;
    c = isect2[0];
    isect2[0] = isect2[1];
    isect2[1] = c;
    smallest2 = 1;
  } else
    smallest2 = 0;
  ;
  if (isect1[1] < isect2[0] || isect2[1] < isect1[0])
    return 0;
  if (isect2[0] < isect1[0]) {
    if (smallest1 == 0) {
      isectpt1[0] = isectpointA1[0];
      isectpt1[1] = isectpointA1[1];
      isectpt1[2] = isectpointA1[2];
      ;
    } else {
      isectpt1[0] = isectpointA2[0];
      isectpt1[1] = isectpointA2[1];
      isectpt1[2] = isectpointA2[2];
      ;
    }
    if (isect2[1] < isect1[1]) {
      if (smallest2 == 0) {
        isectpt2[0] = isectpointB2[0];
        isectpt2[1] = isectpointB2[1];
        isectpt2[2] = isectpointB2[2];
        ;
      } else {
        isectpt2[0] = isectpointB1[0];
        isectpt2[1] = isectpointB1[1];
        isectpt2[2] = isectpointB1[2];
        ;
      }
    } else {
      if (smallest1 == 0) {
        isectpt2[0] = isectpointA2[0];
        isectpt2[1] = isectpointA2[1];
        isectpt2[2] = isectpointA2[2];
        ;
      } else {
        isectpt2[0] = isectpointA1[0];
        isectpt2[1] = isectpointA1[1];
        isectpt2[2] = isectpointA1[2];
        ;
      }
    }
  } else {
    if (smallest2 == 0) {
      isectpt1[0] = isectpointB1[0];
      isectpt1[1] = isectpointB1[1];
      isectpt1[2] = isectpointB1[2];
      ;
    } else {
      isectpt1[0] = isectpointB2[0];
      isectpt1[1] = isectpointB2[1];
      isectpt1[2] = isectpointB2[2];
      ;
    }
    if (isect2[1] > isect1[1]) {
      if (smallest1 == 0) {
        isectpt2[0] = isectpointA2[0];
        isectpt2[1] = isectpointA2[1];
        isectpt2[2] = isectpointA2[2];
        ;
      } else {
        isectpt2[0] = isectpointA1[0];
        isectpt2[1] = isectpointA1[1];
        isectpt2[2] = isectpointA1[2];
        ;
      }
    } else {
      if (smallest2 == 0) {
        isectpt2[0] = isectpointB2[0];
        isectpt2[1] = isectpointB2[1];
        isectpt2[2] = isectpointB2[2];
        ;
      } else {
        isectpt2[0] = isectpointB1[0];
        isectpt2[1] = isectpointB1[1];
        isectpt2[2] = isectpointB1[2];
        ;
      }
    }
  }
  return 1;
}


x86 assembly (clang, -O0):
<tri_tri_intersect_with_isectline>:
push   %rbp
mov    %rsp,%rbp
sub    $0x140,%rsp
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
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  0xc68(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    13aa <tri_tri_intersect_with_isectline+0x27a>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x78(%rbp),%xmm0
call   1040 <fabs@plt>
movaps %xmm0,%xmm1
movsd  0xc41(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    13d1 <tri_tri_intersect_with_isectline+0x2a1>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x7c(%rbp),%xmm0
call   1040 <fabs@plt>
movaps %xmm0,%xmm1
movsd  0xc1a(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    13f8 <tri_tri_intersect_with_isectline+0x2c8>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x74(%rbp),%xmm0
mulss  -0x78(%rbp),%xmm0
movss  %xmm0,-0xd8(%rbp)
ff
movss  -0x74(%rbp),%xmm0
mulss  -0x7c(%rbp),%xmm0
movss  %xmm0,-0xdc(%rbp)
ff
movss  -0xd8(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    1450 <tri_tri_intersect_with_isectline+0x320>
movss  -0xdc(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    1450 <tri_tri_intersect_with_isectline+0x320>
movl   $0x0,-0x4(%rbp)
jmp    1e7c <tri_tri_intersect_with_isectline+0xd4c>
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  0x971(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    16a1 <tri_tri_intersect_with_isectline+0x571>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x84(%rbp),%xmm0
ff
call   1040 <fabs@plt>
movaps %xmm0,%xmm1
movsd  0x947(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    16ce <tri_tri_intersect_with_isectline+0x59e>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x88(%rbp),%xmm0
ff
call   1040 <fabs@plt>
movaps %xmm0,%xmm1
movsd  0x91a(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    16fb <tri_tri_intersect_with_isectline+0x5cb>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x80(%rbp),%xmm0
mulss  -0x84(%rbp),%xmm0
ff
movss  %xmm0,-0xe0(%rbp)
ff
movss  -0x80(%rbp),%xmm0
mulss  -0x88(%rbp),%xmm0
ff
movss  %xmm0,-0xe4(%rbp)
ff
movss  -0xe0(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    1759 <tri_tri_intersect_with_isectline+0x629>
movss  -0xe4(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jbe    1759 <tri_tri_intersect_with_isectline+0x629>
movl   $0x0,-0x4(%rbp)
jmp    1e7c <tri_tri_intersect_with_isectline+0xd4c>
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,-0x10c(%rbp)
ff
movw   $0x0,-0xe6(%rbp)
movss  -0x90(%rbp),%xmm0
ff
call   1040 <fabs@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x104(%rbp)
ff
movss  -0x8c(%rbp),%xmm0
ff
call   1040 <fabs@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x108(%rbp)
ff
movss  -0x104(%rbp),%xmm0
ff
ucomiss -0x10c(%rbp),%xmm0
jbe    186e <tri_tri_intersect_with_isectline+0x73e>
movss  -0x104(%rbp),%xmm0
ff
movss  %xmm0,-0x10c(%rbp)
ff
movw   $0x1,-0xe6(%rbp)
movss  -0x108(%rbp),%xmm0
ff
ucomiss -0x10c(%rbp),%xmm0
jbe    189c <tri_tri_intersect_with_isectline+0x76c>
movss  -0x108(%rbp),%xmm0
ff
movss  %xmm0,-0x10c(%rbp)
ff
movw   $0x2,-0xe6(%rbp)
mov    -0x10(%rbp),%rax
movswq -0xe6(%rbp),%rcx
ff
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xec(%rbp)
ff
mov    -0x18(%rbp),%rax
movswq -0xe6(%rbp),%rcx
ff
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xf0(%rbp)
ff
mov    -0x20(%rbp),%rax
movswq -0xe6(%rbp),%rcx
ff
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xf4(%rbp)
ff
mov    -0x28(%rbp),%rax
movswq -0xe6(%rbp),%rcx
ff
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xf8(%rbp)
ff
mov    -0x30(%rbp),%rax
movswq -0xe6(%rbp),%rcx
ff
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0xfc(%rbp)
ff
mov    -0x38(%rbp),%rax
movswq -0xe6(%rbp),%rcx
ff
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x100(%rbp)
ff
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdx
movss  -0xec(%rbp),%xmm0
ff
movss  -0xf0(%rbp),%xmm1
ff
movss  -0xf4(%rbp),%xmm2
ff
movss  -0x80(%rbp),%xmm3
movss  -0x84(%rbp),%xmm4
ff
movss  -0x88(%rbp),%xmm5
ff
movss  -0xe0(%rbp),%xmm6
ff
movss  -0xe4(%rbp),%xmm7
ff
lea    -0x9c(%rbp),%rcx
lea    -0x9c(%rbp),%r8
add    $0x4,%r8
lea    -0xb0(%rbp),%r9
lea    -0xbc(%rbp),%rax
mov    %rax,(%rsp)
call   1050 <compute_intervals_isectline@plt>
mov    %eax,%ecx
mov    0x10(%rbp),%rax
mov    %ecx,(%rax)
mov    0x10(%rbp),%rax
cmpl   $0x0,(%rax)
je     19e6 <tri_tri_intersect_with_isectline+0x8b6>
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    1e7c <tri_tri_intersect_with_isectline+0xd4c>
mov    -0x28(%rbp),%rdi
mov    -0x30(%rbp),%rsi
mov    -0x38(%rbp),%rdx
movss  -0xf8(%rbp),%xmm0
ff
movss  -0xfc(%rbp),%xmm1
ff
movss  -0x100(%rbp),%xmm2
ff
movss  -0x74(%rbp),%xmm3
movss  -0x78(%rbp),%xmm4
movss  -0x7c(%rbp),%xmm5
movss  -0xd8(%rbp),%xmm6
ff
movss  -0xdc(%rbp),%xmm7
ff
lea    -0xa4(%rbp),%rcx
lea    -0xa4(%rbp),%r8
add    $0x4,%r8
lea    -0xc8(%rbp),%r9
lea    -0xd4(%rbp),%rax
mov    %rax,(%rsp)
call   1050 <compute_intervals_isectline@plt>
movss  -0x9c(%rbp),%xmm0
ff
ucomiss -0x98(%rbp),%xmm0
jbe    1aa6 <tri_tri_intersect_with_isectline+0x976>
movss  -0x9c(%rbp),%xmm0
ff
movss  %xmm0,-0x128(%rbp)
ff
movss  -0x98(%rbp),%xmm0
ff
movss  %xmm0,-0x9c(%rbp)
ff
movss  -0x128(%rbp),%xmm0
ff
movss  %xmm0,-0x98(%rbp)
ff
movl   $0x1,-0x120(%rbp)
jmp    1ab0 <tri_tri_intersect_with_isectline+0x980>
movl   $0x0,-0x120(%rbp)
movss  -0xa4(%rbp),%xmm0
ff
ucomiss -0xa0(%rbp),%xmm0
jbe    1b04 <tri_tri_intersect_with_isectline+0x9d4>
movss  -0xa4(%rbp),%xmm0
ff
movss  %xmm0,-0x12c(%rbp)
ff
movss  -0xa0(%rbp),%xmm0
ff
movss  %xmm0,-0xa4(%rbp)
ff
movss  -0x12c(%rbp),%xmm0
ff
movss  %xmm0,-0xa0(%rbp)
ff
movl   $0x1,-0x124(%rbp)
jmp    1b0e <tri_tri_intersect_with_isectline+0x9de>
movl   $0x0,-0x124(%rbp)
movss  -0x98(%rbp),%xmm1
ff
movss  -0xa4(%rbp),%xmm0
ff
ucomiss %xmm1,%xmm0
ja     1b40 <tri_tri_intersect_with_isectline+0xa10>
movss  -0xa0(%rbp),%xmm1
ff
movss  -0x9c(%rbp),%xmm0
ff
ucomiss %xmm1,%xmm0
jbe    1b4c <tri_tri_intersect_with_isectline+0xa1c>
movl   $0x0,-0x4(%rbp)
jmp    1e7c <tri_tri_intersect_with_isectline+0xd4c>
movss  -0xa4(%rbp),%xmm1
ff
movss  -0x9c(%rbp),%xmm0
ff
ucomiss %xmm1,%xmm0
jbe    1cef <tri_tri_intersect_with_isectline+0xbbf>
cmpl   $0x0,-0x120(%rbp)
jne    1ba9 <tri_tri_intersect_with_isectline+0xa79>
movss  -0xb0(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0xac(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0xa8(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movss  %xmm0,0x8(%rax)
jmp    1bdb <tri_tri_intersect_with_isectline+0xaab>
movss  -0xbc(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0xb8(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0xb4(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0xa0(%rbp),%xmm1
ff
movss  -0x98(%rbp),%xmm0
ff
ucomiss %xmm1,%xmm0
jbe    1c6f <tri_tri_intersect_with_isectline+0xb3f>
cmpl   $0x0,-0x124(%rbp)
jne    1c38 <tri_tri_intersect_with_isectline+0xb08>
movss  -0xd4(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0xd0(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0xcc(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
movss  %xmm0,0x8(%rax)
jmp    1c6a <tri_tri_intersect_with_isectline+0xb3a>
movss  -0xc8(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0xc4(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0xc0(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
movss  %xmm0,0x8(%rax)
jmp    1cea <tri_tri_intersect_with_isectline+0xbba>
cmpl   $0x0,-0x120(%rbp)
jne    1cb3 <tri_tri_intersect_with_isectline+0xb83>
movss  -0xbc(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0xb8(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0xb4(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
movss  %xmm0,0x8(%rax)
jmp    1ce5 <tri_tri_intersect_with_isectline+0xbb5>
movss  -0xb0(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0xac(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0xa8(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
movss  %xmm0,0x8(%rax)
jmp    1cea <tri_tri_intersect_with_isectline+0xbba>
jmp    1e75 <tri_tri_intersect_with_isectline+0xd45>
cmpl   $0x0,-0x124(%rbp)
jne    1d33 <tri_tri_intersect_with_isectline+0xc03>
movss  -0xc8(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0xc4(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0xc0(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movss  %xmm0,0x8(%rax)
jmp    1d65 <tri_tri_intersect_with_isectline+0xc35>
movss  -0xd4(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0xd0(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0xcc(%rbp),%xmm0
ff
mov    0x18(%rbp),%rax
movss  %xmm0,0x8(%rax)
movss  -0xa0(%rbp),%xmm0
ff
ucomiss -0x98(%rbp),%xmm0
jbe    1df5 <tri_tri_intersect_with_isectline+0xcc5>
cmpl   $0x0,-0x120(%rbp)
jne    1dbe <tri_tri_intersect_with_isectline+0xc8e>
movss  -0xbc(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0xb8(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0xb4(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
movss  %xmm0,0x8(%rax)
jmp    1df0 <tri_tri_intersect_with_isectline+0xcc0>
movss  -0xb0(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0xac(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0xa8(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
movss  %xmm0,0x8(%rax)
jmp    1e70 <tri_tri_intersect_with_isectline+0xd40>
cmpl   $0x0,-0x124(%rbp)
jne    1e39 <tri_tri_intersect_with_isectline+0xd09>
movss  -0xd4(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0xd0(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0xcc(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
movss  %xmm0,0x8(%rax)
jmp    1e6b <tri_tri_intersect_with_isectline+0xd3b>
movss  -0xc8(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0xc4(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
movss  %xmm0,0x4(%rax)
movss  -0xc0(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
movss  %xmm0,0x8(%rax)
jmp    1e70 <tri_tri_intersect_with_isectline+0xd40>
jmp    1e75 <tri_tri_intersect_with_isectline+0xd45>
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x140,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<tri_tri_intersect_with_isectline>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x148,%rsp
mov    %r9,%r12
mov    %r8,%r14
mov    %rcx,%r15
mov    %rdx,%r13
mov    %rsi,%rbx
mov    %rdi,%rbp
movss  (%rsi),%xmm1
movss  0x4(%rsi),%xmm4
movss  (%rdi),%xmm9
movss  0x4(%rdi),%xmm2
subss  %xmm9,%xmm1
subss  %xmm2,%xmm4
movss  0x8(%rsi),%xmm3
movss  0x8(%rdi),%xmm8
subss  %xmm8,%xmm3
movss  (%rdx),%xmm5
movss  0x4(%rdx),%xmm7
subss  %xmm9,%xmm5
subss  %xmm2,%xmm7
movss  0x8(%rdx),%xmm6
subss  %xmm8,%xmm6
movaps %xmm7,%xmm0
mulss  %xmm3,%xmm0
mulss  %xmm5,%xmm3
mulss  %xmm4,%xmm5
mulss  %xmm6,%xmm4
subss  %xmm0,%xmm4
movss  %xmm4,0xb4(%rsp)
mulss  %xmm1,%xmm6
subss  %xmm6,%xmm3
movss  %xmm3,0xb8(%rsp)
mulss  %xmm1,%xmm7
subss  %xmm5,%xmm7
movss  %xmm7,0xbc(%rsp)
movaps %xmm3,0xe0(%rsp)
shufps $0x0,%xmm3,%xmm3
movss  (%r8),%xmm0
movss  0x4(%r8),%xmm5
movss  0x8(%r8),%xmm6
unpcklps %xmm2,%xmm5
mulps  %xmm3,%xmm5
movaps %xmm4,0x90(%rsp)
movaps %xmm4,%xmm2
shufps $0x0,%xmm4,%xmm2
unpcklps %xmm9,%xmm0
mulps  %xmm2,%xmm0
addps  %xmm5,%xmm0
movaps %xmm7,0x50(%rsp)
movaps %xmm7,%xmm1
shufps $0x0,%xmm7,%xmm1
movaps %xmm6,%xmm4
unpcklps %xmm8,%xmm4
mulps  %xmm1,%xmm4
addps  %xmm0,%xmm4
movaps %xmm4,%xmm6
shufps $0x55,%xmm4,%xmm6
subss  %xmm6,%xmm4
movaps %xmm4,0xa0(%rsp)
movss  (%r9),%xmm4
movss  0x4(%r9),%xmm5
movss  0x8(%r9),%xmm8
movss  (%rcx),%xmm7
unpcklps %xmm4,%xmm7
movss  0x4(%rcx),%xmm4
unpcklps %xmm5,%xmm4
movss  0x8(%rcx),%xmm0
unpcklps %xmm8,%xmm0
mulps  %xmm3,%xmm4
mulps  %xmm2,%xmm7
addps  %xmm4,%xmm7
mulps  %xmm1,%xmm0
addps  %xmm7,%xmm0
subps  %xmm6,%xmm0
movaps %xmm0,0x60(%rsp)
call   1040 <fabs@plt>
movaps %xmm0,0xf0(%rsp)
movapd 0xa0(%rsp),%xmm0
call   1040 <fabs@plt>
movsd  0xd58(%rip),%xmm1
ucomisd %xmm0,%xmm1
xorpd  %xmm0,%xmm0
ja     12bb <tri_tri_intersect_with_isectline+0x18b>
movapd 0xa0(%rsp),%xmm0
movss  %xmm0,0xa0(%rsp)
movaps 0x60(%rsp),%xmm0
shufps $0x55,%xmm0,%xmm0
call   1040 <fabs@plt>
movaps 0xf0(%rsp),%xmm1
movlhps %xmm0,%xmm1
cmpltpd 0xd2a(%rip),%xmm1
shufps $0xe8,%xmm1,%xmm1
andnps 0x60(%rsp),%xmm1
movaps %xmm1,%xmm2
mulss  0xa0(%rsp),%xmm2
pshufd $0x55,%xmm1,%xmm4
movaps %xmm1,%xmm3
mulss  %xmm4,%xmm3
xor    %eax,%eax
ucomiss 0xd10(%rip),%xmm2
jbe    131e <tri_tri_intersect_with_isectline+0x1ee>
xorps  %xmm0,%xmm0
ucomiss %xmm0,%xmm3
ja     18a1 <tri_tri_intersect_with_isectline+0x771>
movaps %xmm4,0x100(%rsp)
movaps %xmm3,0x110(%rsp)
movaps %xmm2,0x120(%rsp)
movaps %xmm1,0xf0(%rsp)
movss  (%r14),%xmm0
movss  0x4(%r14),%xmm4
movss  (%r15),%xmm9
movss  0x4(%r15),%xmm2
subss  %xmm9,%xmm0
subss  %xmm2,%xmm4
movss  0x8(%r14),%xmm3
movss  0x8(%r15),%xmm8
subss  %xmm8,%xmm3
movss  (%r12),%xmm5
movss  0x4(%r12),%xmm7
subss  %xmm9,%xmm5
subss  %xmm2,%xmm7
movss  0x8(%r12),%xmm6
subss  %xmm8,%xmm6
movaps %xmm7,%xmm1
mulss  %xmm3,%xmm1
mulss  %xmm5,%xmm3
mulss  %xmm4,%xmm5
mulss  %xmm6,%xmm4
subss  %xmm1,%xmm4
mulss  %xmm0,%xmm6
subss  %xmm6,%xmm3
mulss  %xmm0,%xmm7
subss  %xmm5,%xmm7
movaps %xmm3,0xd0(%rsp)
shufps $0x0,%xmm3,%xmm3
movss  (%rbx),%xmm0
movss  0x4(%rbx),%xmm5
movss  0x8(%rbx),%xmm6
unpcklps %xmm2,%xmm5
mulps  %xmm3,%xmm5
movaps %xmm4,0x130(%rsp)
movaps %xmm4,%xmm2
shufps $0x0,%xmm4,%xmm2
unpcklps %xmm9,%xmm0
mulps  %xmm2,%xmm0
addps  %xmm5,%xmm0
movaps %xmm7,0x70(%rsp)
movaps %xmm7,%xmm1
shufps $0x0,%xmm7,%xmm1
movaps %xmm6,%xmm4
unpcklps %xmm8,%xmm4
mulps  %xmm1,%xmm4
addps  %xmm0,%xmm4
movaps %xmm4,%xmm6
shufps $0x55,%xmm4,%xmm6
subss  %xmm6,%xmm4
movaps %xmm4,0x80(%rsp)
movss  0x0(%r13),%xmm4
movss  0x4(%r13),%xmm5
movss  0x8(%r13),%xmm8
movss  0x0(%rbp),%xmm7
unpcklps %xmm4,%xmm7
movss  0x4(%rbp),%xmm4
unpcklps %xmm5,%xmm4
movss  0x8(%rbp),%xmm0
unpcklps %xmm8,%xmm0
mulps  %xmm3,%xmm4
mulps  %xmm2,%xmm7
addps  %xmm4,%xmm7
mulps  %xmm1,%xmm0
addps  %xmm7,%xmm0
subps  %xmm6,%xmm0
movaps %xmm0,0xc0(%rsp)
call   1040 <fabs@plt>
movaps %xmm0,0x60(%rsp)
movapd 0x80(%rsp),%xmm0
call   1040 <fabs@plt>
movsd  0xb7f(%rip),%xmm1
ucomisd %xmm0,%xmm1
xorpd  %xmm0,%xmm0
ja     1494 <tri_tri_intersect_with_isectline+0x364>
movapd 0x80(%rsp),%xmm0
movss  %xmm0,0x80(%rsp)
movaps 0xc0(%rsp),%xmm0
shufps $0x55,%xmm0,%xmm0
call   1040 <fabs@plt>
movss  0x80(%rsp),%xmm4
movaps 0x60(%rsp),%xmm1
movlhps %xmm0,%xmm1
cmpltpd 0xb48(%rip),%xmm1
shufps $0xe8,%xmm1,%xmm1
andnps 0xc0(%rsp),%xmm1
movaps %xmm1,%xmm5
mulss  %xmm4,%xmm5
pshufd $0x55,%xmm1,%xmm2
movaps %xmm1,%xmm6
mulss  %xmm2,%xmm6
ucomiss 0xb32(%rip),%xmm5
jbe    14ff <tri_tri_intersect_with_isectline+0x3cf>
xorps  %xmm0,%xmm0
ucomiss %xmm0,%xmm6
jbe    14ff <tri_tri_intersect_with_isectline+0x3cf>
xor    %eax,%eax
jmp    18a1 <tri_tri_intersect_with_isectline+0x771>
movaps %xmm1,0x60(%rsp)
movaps 0xd0(%rsp),%xmm8
movaps %xmm8,%xmm1
movaps 0x50(%rsp),%xmm7
mulss  %xmm7,%xmm1
movaps %xmm2,0xc0(%rsp)
movaps 0xe0(%rsp),%xmm2
movaps %xmm2,%xmm0
movaps 0x70(%rsp),%xmm4
mulss  %xmm4,%xmm0
subss  %xmm1,%xmm0
movaps 0x90(%rsp),%xmm3
mulss  %xmm3,%xmm4
movaps 0x130(%rsp),%xmm1
mulss  %xmm1,%xmm7
subss  %xmm4,%xmm7
movaps %xmm7,0x50(%rsp)
mulss  %xmm2,%xmm1
mulss  %xmm8,%xmm3
subss  %xmm1,%xmm3
movaps %xmm3,0x90(%rsp)
movaps %xmm5,0xd0(%rsp)
movaps %xmm6,0xe0(%rsp)
call   1040 <fabs@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x70(%rsp)
movaps 0x50(%rsp),%xmm0
call   1040 <fabs@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x50(%rsp)
movaps 0x90(%rsp),%xmm0
call   1040 <fabs@plt>
cvtsd2ss %xmm0,%xmm0
xor    %eax,%eax
movss  0x70(%rsp),%xmm1
movss  0x50(%rsp),%xmm2
ucomiss %xmm1,%xmm2
seta   %al
maxss  %xmm1,%xmm2
ucomiss %xmm2,%xmm0
mov    $0x2,%ecx
cmovbe %rax,%rcx
movss  0x0(%rbp,%rcx,4),%xmm0
movss  (%rbx,%rcx,4),%xmm1
movss  0x0(%r13,%rcx,4),%xmm2
movss  (%r15,%rcx,4),%xmm3
movss  %xmm3,0x50(%rsp)
movss  (%r14,%rcx,4),%xmm3
movss  %xmm3,0x90(%rsp)
movss  (%r12,%rcx,4),%xmm3
movss  %xmm3,0x70(%rsp)
lea    0x4c(%rsp),%r8
lea    0x28(%rsp),%rax
mov    %rax,(%rsp)
lea    0x48(%rsp),%rcx
lea    0x34(%rsp),%r9
mov    %rbp,%rdi
mov    %rbx,%rsi
mov    %r13,%rdx
movaps 0x60(%rsp),%xmm3
movss  0x80(%rsp),%xmm4
movaps 0xc0(%rsp),%xmm5
movaps 0xd0(%rsp),%xmm6
movaps 0xe0(%rsp),%xmm7
call   1050 <compute_intervals_isectline@plt>
mov    0x180(%rsp),%rcx
mov    %eax,(%rcx)
test   %eax,%eax
je     1690 <tri_tri_intersect_with_isectline+0x560>
mov    %r12,(%rsp)
lea    0xb4(%rsp),%rdi
mov    %rbp,%rsi
mov    %rbx,%rdx
mov    %r13,%rcx
mov    %r15,%r8
mov    %r14,%r9
call   1030 <coplanar_tri_tri@plt>
jmp    18a1 <tri_tri_intersect_with_isectline+0x771>
lea    0x44(%rsp),%r8
lea    0x10(%rsp),%rax
mov    %rax,(%rsp)
lea    0x40(%rsp),%rcx
lea    0x1c(%rsp),%r9
mov    %r15,%rdi
mov    %r14,%rsi
mov    %r12,%rdx
movss  0x50(%rsp),%xmm0
movss  0x90(%rsp),%xmm1
movss  0x70(%rsp),%xmm2
movaps 0xf0(%rsp),%xmm3
movss  0xa0(%rsp),%xmm4
movaps 0x100(%rsp),%xmm5
movaps 0x120(%rsp),%xmm6
movaps 0x110(%rsp),%xmm7
call   1050 <compute_intervals_isectline@plt>
movss  0x48(%rsp),%xmm1
movss  0x4c(%rsp),%xmm2
ucomiss %xmm2,%xmm1
movaps %xmm1,%xmm6
movaps %xmm2,%xmm0
jbe    171d <tri_tri_intersect_with_isectline+0x5ed>
movss  %xmm2,0x48(%rsp)
movss  %xmm1,0x4c(%rsp)
movaps %xmm2,%xmm6
movaps %xmm1,%xmm0
movss  0x40(%rsp),%xmm4
movss  0x44(%rsp),%xmm5
ucomiss %xmm5,%xmm4
movaps %xmm5,%xmm3
movaps %xmm4,%xmm7
mov    $0x0,%eax
jbe    174b <tri_tri_intersect_with_isectline+0x61b>
movss  %xmm5,0x40(%rsp)
movss  %xmm4,0x44(%rsp)
movaps %xmm4,%xmm3
movaps %xmm5,%xmm7
ucomiss %xmm0,%xmm7
ja     18a1 <tri_tri_intersect_with_isectline+0x771>
ucomiss %xmm3,%xmm6
ja     18a1 <tri_tri_intersect_with_isectline+0x771>
mov    0x190(%rsp),%rax
mov    0x188(%rsp),%rcx
ucomiss %xmm7,%xmm6
jbe    17a1 <tri_tri_intersect_with_isectline+0x671>
ucomiss %xmm2,%xmm1
jbe    17cd <tri_tri_intersect_with_isectline+0x69d>
movss  0x28(%rsp),%xmm1
movss  %xmm1,(%rcx)
movss  0x2c(%rsp),%xmm1
movss  %xmm1,0x4(%rcx)
movss  0x30(%rsp),%xmm1
movss  %xmm1,0x8(%rcx)
ucomiss %xmm3,%xmm0
ja     17f6 <tri_tri_intersect_with_isectline+0x6c6>
jmp    1842 <tri_tri_intersect_with_isectline+0x712>
ucomiss %xmm5,%xmm4
jbe    1818 <tri_tri_intersect_with_isectline+0x6e8>
movss  0x10(%rsp),%xmm4
movss  %xmm4,(%rcx)
movss  0x14(%rsp),%xmm4
movss  %xmm4,0x4(%rcx)
movss  0x18(%rsp),%xmm4
movss  %xmm4,0x8(%rcx)
ucomiss %xmm0,%xmm3
jbe    17fb <tri_tri_intersect_with_isectline+0x6cb>
jmp    183d <tri_tri_intersect_with_isectline+0x70d>
movss  0x34(%rsp),%xmm1
movss  %xmm1,(%rcx)
movss  0x38(%rsp),%xmm1
movss  %xmm1,0x4(%rcx)
movss  0x3c(%rsp),%xmm1
movss  %xmm1,0x8(%rcx)
ucomiss %xmm3,%xmm0
jbe    187c <tri_tri_intersect_with_isectline+0x74c>
ucomiss %xmm5,%xmm4
jbe    185f <tri_tri_intersect_with_isectline+0x72f>
movss  0x1c(%rsp),%xmm0
movss  %xmm0,(%rax)
movss  0x20(%rsp),%xmm0
movss  %xmm0,0x4(%rax)
movss  0x24(%rsp),%xmm0
jmp    1897 <tri_tri_intersect_with_isectline+0x767>
movss  0x1c(%rsp),%xmm4
movss  %xmm4,(%rcx)
movss  0x20(%rsp),%xmm4
movss  %xmm4,0x4(%rcx)
movss  0x24(%rsp),%xmm4
movss  %xmm4,0x8(%rcx)
ucomiss %xmm0,%xmm3
jbe    185f <tri_tri_intersect_with_isectline+0x72f>
ucomiss %xmm2,%xmm1
jbe    187c <tri_tri_intersect_with_isectline+0x74c>
movss  0x34(%rsp),%xmm0
movss  %xmm0,(%rax)
movss  0x38(%rsp),%xmm0
movss  %xmm0,0x4(%rax)
movss  0x3c(%rsp),%xmm0
jmp    1897 <tri_tri_intersect_with_isectline+0x767>
movss  0x10(%rsp),%xmm0
movss  %xmm0,(%rax)
movss  0x14(%rsp),%xmm0
movss  %xmm0,0x4(%rax)
movss  0x18(%rsp),%xmm0
jmp    1897 <tri_tri_intersect_with_isectline+0x767>
movss  0x28(%rsp),%xmm0
movss  %xmm0,(%rax)
movss  0x2c(%rsp),%xmm0
movss  %xmm0,0x4(%rax)
movss  0x30(%rsp),%xmm0
movss  %xmm0,0x8(%rax)
mov    $0x1,%eax
add    $0x148,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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