int triBoxOverlap(float boxcenter[3], float boxhalfsize[3],
                  float triverts[3][3]) {
  float v0[3], v1[3], v2[3];
  float min, max, p0, p1, p2, rad, fex, fey, fez;
  float normal[3], e0[3], e1[3], e2[3];
  v0[0] = triverts[0][0] - boxcenter[0];
  v0[1] = triverts[0][1] - boxcenter[1];
  v0[2] = triverts[0][2] - boxcenter[2];
  ;
  v1[0] = triverts[1][0] - boxcenter[0];
  v1[1] = triverts[1][1] - boxcenter[1];
  v1[2] = triverts[1][2] - boxcenter[2];
  ;
  v2[0] = triverts[2][0] - boxcenter[0];
  v2[1] = triverts[2][1] - boxcenter[1];
  v2[2] = triverts[2][2] - boxcenter[2];
  ;
  e0[0] = v1[0] - v0[0];
  e0[1] = v1[1] - v0[1];
  e0[2] = v1[2] - v0[2];
  ;
  e1[0] = v2[0] - v1[0];
  e1[1] = v2[1] - v1[1];
  e1[2] = v2[2] - v1[2];
  ;
  e2[0] = v0[0] - v2[0];
  e2[1] = v0[1] - v2[1];
  e2[2] = v0[2] - v2[2];
  ;
  fex = fabsf(e0[0]);
  fey = fabsf(e0[1]);
  fez = fabsf(e0[2]);
  p0 = e0[2] * v0[1] - e0[1] * v0[2];
  p2 = e0[2] * v2[1] - e0[1] * v2[2];
  if (p0 < p2) {
    min = p0;
    max = p2;
  } else {
    min = p2;
    max = p0;
  }
  rad = fez * boxhalfsize[1] + fey * boxhalfsize[2];
  if (min > rad || max < -rad)
    return 0;
  ;
  p0 = -e0[2] * v0[0] + e0[0] * v0[2];
  p2 = -e0[2] * v2[0] + e0[0] * v2[2];
  if (p0 < p2) {
    min = p0;
    max = p2;
  } else {
    min = p2;
    max = p0;
  }
  rad = fez * boxhalfsize[0] + fex * boxhalfsize[2];
  if (min > rad || max < -rad)
    return 0;
  ;
  p1 = e0[1] * v1[0] - e0[0] * v1[1];
  p2 = e0[1] * v2[0] - e0[0] * v2[1];
  if (p2 < p1) {
    min = p2;
    max = p1;
  } else {
    min = p1;
    max = p2;
  }
  rad = fey * boxhalfsize[0] + fex * boxhalfsize[1];
  if (min > rad || max < -rad)
    return 0;
  ;
  fex = fabsf(e1[0]);
  fey = fabsf(e1[1]);
  fez = fabsf(e1[2]);
  p0 = e1[2] * v0[1] - e1[1] * v0[2];
  p2 = e1[2] * v2[1] - e1[1] * v2[2];
  if (p0 < p2) {
    min = p0;
    max = p2;
  } else {
    min = p2;
    max = p0;
  }
  rad = fez * boxhalfsize[1] + fey * boxhalfsize[2];
  if (min > rad || max < -rad)
    return 0;
  ;
  p0 = -e1[2] * v0[0] + e1[0] * v0[2];
  p2 = -e1[2] * v2[0] + e1[0] * v2[2];
  if (p0 < p2) {
    min = p0;
    max = p2;
  } else {
    min = p2;
    max = p0;
  }
  rad = fez * boxhalfsize[0] + fex * boxhalfsize[2];
  if (min > rad || max < -rad)
    return 0;
  ;
  p0 = e1[1] * v0[0] - e1[0] * v0[1];
  p1 = e1[1] * v1[0] - e1[0] * v1[1];
  if (p0 < p1) {
    min = p0;
    max = p1;
  } else {
    min = p1;
    max = p0;
  }
  rad = fey * boxhalfsize[0] + fex * boxhalfsize[1];
  if (min > rad || max < -rad)
    return 0;
  ;
  fex = fabsf(e2[0]);
  fey = fabsf(e2[1]);
  fez = fabsf(e2[2]);
  p0 = e2[2] * v0[1] - e2[1] * v0[2];
  p1 = e2[2] * v1[1] - e2[1] * v1[2];
  if (p0 < p1) {
    min = p0;
    max = p1;
  } else {
    min = p1;
    max = p0;
  }
  rad = fez * boxhalfsize[1] + fey * boxhalfsize[2];
  if (min > rad || max < -rad)
    return 0;
  ;
  p0 = -e2[2] * v0[0] + e2[0] * v0[2];
  p1 = -e2[2] * v1[0] + e2[0] * v1[2];
  if (p0 < p1) {
    min = p0;
    max = p1;
  } else {
    min = p1;
    max = p0;
  }
  rad = fez * boxhalfsize[0] + fex * boxhalfsize[2];
  if (min > rad || max < -rad)
    return 0;
  ;
  p1 = e2[1] * v1[0] - e2[0] * v1[1];
  p2 = e2[1] * v2[0] - e2[0] * v2[1];
  if (p2 < p1) {
    min = p2;
    max = p1;
  } else {
    min = p1;
    max = p2;
  }
  rad = fey * boxhalfsize[0] + fex * boxhalfsize[1];
  if (min > rad || max < -rad)
    return 0;
  ;
  min = max = v0[0];
  if (v1[0] < min)
    min = v1[0];
  if (v1[0] > max)
    max = v1[0];
  if (v2[0] < min)
    min = v2[0];
  if (v2[0] > max)
    max = v2[0];
  ;
  if (min > boxhalfsize[0] || max < -boxhalfsize[0])
    return 0;
  min = max = v0[1];
  if (v1[1] < min)
    min = v1[1];
  if (v1[1] > max)
    max = v1[1];
  if (v2[1] < min)
    min = v2[1];
  if (v2[1] > max)
    max = v2[1];
  ;
  if (min > boxhalfsize[1] || max < -boxhalfsize[1])
    return 0;
  min = max = v0[2];
  if (v1[2] < min)
    min = v1[2];
  if (v1[2] > max)
    max = v1[2];
  if (v2[2] < min)
    min = v2[2];
  if (v2[2] > max)
    max = v2[2];
  ;
  if (min > boxhalfsize[2] || max < -boxhalfsize[2])
    return 0;
  normal[0] = e0[1] * e1[2] - e0[2] * e1[1];
  normal[1] = e0[2] * e1[0] - e0[0] * e1[2];
  normal[2] = e0[0] * e1[1] - e0[1] * e1[0];
  ;
  if (!planeBoxOverlap(normal, v0, boxhalfsize))
    return 0;
  return 1;
}


x86 assembly (clang, -O0):
<triBoxOverlap>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x10(%rbp),%rax
subss  (%rax),%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x20(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x10(%rbp),%rax
subss  0x4(%rax),%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x20(%rbp),%rax
movss  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
subss  0x8(%rax),%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x20(%rbp),%rax
movss  0xc(%rax),%xmm0
mov    -0x10(%rbp),%rax
subss  (%rax),%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x20(%rbp),%rax
movss  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
subss  0x4(%rax),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x20(%rbp),%rax
movss  0x14(%rax),%xmm0
mov    -0x10(%rbp),%rax
subss  0x8(%rax),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x20(%rbp),%rax
movss  0x18(%rax),%xmm0
mov    -0x10(%rbp),%rax
subss  (%rax),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x20(%rbp),%rax
movss  0x1c(%rax),%xmm0
mov    -0x10(%rbp),%rax
subss  0x4(%rax),%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x20(%rbp),%rax
movss  0x20(%rax),%xmm0
mov    -0x10(%rbp),%rax
subss  0x8(%rax),%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x38(%rbp),%xmm0
subss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x34(%rbp),%xmm0
subss  -0x28(%rbp),%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x30(%rbp),%xmm0
subss  -0x24(%rbp),%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x44(%rbp),%xmm0
subss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
movss  -0x40(%rbp),%xmm0
subss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x3c(%rbp),%xmm0
subss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x84(%rbp)
ff
movss  -0x2c(%rbp),%xmm0
subss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x98(%rbp)
ff
movss  -0x28(%rbp),%xmm0
subss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x94(%rbp)
ff
movss  -0x24(%rbp),%xmm0
subss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x90(%rbp)
ff
movss  -0x80(%rbp),%xmm0
movaps 0xd69(%rip),%xmm1
pand   %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x7c(%rbp),%xmm0
movaps 0xd54(%rip),%xmm1
pand   %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x78(%rbp),%xmm0
movaps 0xd3f(%rip),%xmm1
pand   %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x78(%rbp),%xmm0
movss  -0x28(%rbp),%xmm2
movss  -0x7c(%rbp),%xmm1
mulss  -0x24(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x78(%rbp),%xmm0
movss  -0x40(%rbp),%xmm2
movss  -0x7c(%rbp),%xmm1
mulss  -0x3c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x50(%rbp),%xmm1
movss  -0x58(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1352 <triBoxOverlap+0x242>
movss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
jmp    1366 <triBoxOverlap+0x256>
movss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x68(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm2
movss  -0x64(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x8(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x48(%rbp),%xmm0
ucomiss -0x5c(%rbp),%xmm0
ja     13be <triBoxOverlap+0x2ae>
movss  -0x4c(%rbp),%xmm1
movss  -0x5c(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
ucomiss %xmm1,%xmm0
jbe    13ca <triBoxOverlap+0x2ba>
movl   $0x0,-0x4(%rbp)
jmp    1f9f <triBoxOverlap+0xe8f>
movss  -0x78(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  -0x2c(%rbp),%xmm2
movss  -0x80(%rbp),%xmm1
mulss  -0x24(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x78(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x80(%rbp),%xmm1
mulss  -0x3c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x50(%rbp),%xmm1
movss  -0x58(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1452 <triBoxOverlap+0x342>
movss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
jmp    1466 <triBoxOverlap+0x356>
movss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x68(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x60(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x8(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x48(%rbp),%xmm0
ucomiss -0x5c(%rbp),%xmm0
ja     14bd <triBoxOverlap+0x3ad>
movss  -0x4c(%rbp),%xmm1
movss  -0x5c(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
ucomiss %xmm1,%xmm0
jbe    14c9 <triBoxOverlap+0x3b9>
movl   $0x0,-0x4(%rbp)
jmp    1f9f <triBoxOverlap+0xe8f>
movss  -0x7c(%rbp),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x80(%rbp),%xmm1
mulss  -0x34(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x7c(%rbp),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x80(%rbp),%xmm1
mulss  -0x40(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x58(%rbp),%xmm1
movss  -0x54(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1551 <triBoxOverlap+0x441>
movss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
jmp    1565 <triBoxOverlap+0x455>
movss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x64(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x60(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x4(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x48(%rbp),%xmm0
ucomiss -0x5c(%rbp),%xmm0
ja     15bc <triBoxOverlap+0x4ac>
movss  -0x4c(%rbp),%xmm1
movss  -0x5c(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
ucomiss %xmm1,%xmm0
jbe    15c8 <triBoxOverlap+0x4b8>
movl   $0x0,-0x4(%rbp)
jmp    1f9f <triBoxOverlap+0xe8f>
movss  -0x8c(%rbp),%xmm0
ff
movaps 0xa29(%rip),%xmm1
pand   %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x88(%rbp),%xmm0
ff
movaps 0xa11(%rip),%xmm1
pand   %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x84(%rbp),%xmm0
ff
movaps 0x9f9(%rip),%xmm1
pand   %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x84(%rbp),%xmm0
ff
movss  -0x28(%rbp),%xmm2
movss  -0x88(%rbp),%xmm1
ff
mulss  -0x24(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x84(%rbp),%xmm0
ff
movss  -0x40(%rbp),%xmm2
movss  -0x88(%rbp),%xmm1
ff
mulss  -0x3c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x50(%rbp),%xmm1
movss  -0x58(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    16a4 <triBoxOverlap+0x594>
movss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
jmp    16b8 <triBoxOverlap+0x5a8>
movss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x68(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm2
movss  -0x64(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x8(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x48(%rbp),%xmm0
ucomiss -0x5c(%rbp),%xmm0
ja     1710 <triBoxOverlap+0x600>
movss  -0x4c(%rbp),%xmm1
movss  -0x5c(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
ucomiss %xmm1,%xmm0
jbe    171c <triBoxOverlap+0x60c>
movl   $0x0,-0x4(%rbp)
jmp    1f9f <triBoxOverlap+0xe8f>
movss  -0x84(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  -0x2c(%rbp),%xmm2
movss  -0x8c(%rbp),%xmm1
ff
mulss  -0x24(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x84(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x8c(%rbp),%xmm1
ff
mulss  -0x3c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x50(%rbp),%xmm1
movss  -0x58(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    17b0 <triBoxOverlap+0x6a0>
movss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
jmp    17c4 <triBoxOverlap+0x6b4>
movss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x68(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x60(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x8(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x48(%rbp),%xmm0
ucomiss -0x5c(%rbp),%xmm0
ja     181b <triBoxOverlap+0x70b>
movss  -0x4c(%rbp),%xmm1
movss  -0x5c(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
ucomiss %xmm1,%xmm0
jbe    1827 <triBoxOverlap+0x717>
movl   $0x0,-0x4(%rbp)
jmp    1f9f <triBoxOverlap+0xe8f>
movss  -0x88(%rbp),%xmm0
ff
movss  -0x2c(%rbp),%xmm2
movss  -0x8c(%rbp),%xmm1
ff
mulss  -0x28(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x88(%rbp),%xmm0
ff
movss  -0x38(%rbp),%xmm2
movss  -0x8c(%rbp),%xmm1
ff
mulss  -0x34(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x50(%rbp),%xmm1
movss  -0x54(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    18bb <triBoxOverlap+0x7ab>
movss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
jmp    18cf <triBoxOverlap+0x7bf>
movss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x64(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x60(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x4(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x48(%rbp),%xmm0
ucomiss -0x5c(%rbp),%xmm0
ja     1926 <triBoxOverlap+0x816>
movss  -0x4c(%rbp),%xmm1
movss  -0x5c(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
ucomiss %xmm1,%xmm0
jbe    1932 <triBoxOverlap+0x822>
movl   $0x0,-0x4(%rbp)
jmp    1f9f <triBoxOverlap+0xe8f>
movss  -0x98(%rbp),%xmm0
ff
movaps 0x6bf(%rip),%xmm1
pand   %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x94(%rbp),%xmm0
ff
movaps 0x6a7(%rip),%xmm1
pand   %xmm1,%xmm0
movss  %xmm0,-0x64(%rbp)
movss  -0x90(%rbp),%xmm0
ff
movaps 0x68f(%rip),%xmm1
pand   %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
movss  -0x90(%rbp),%xmm0
ff
movss  -0x28(%rbp),%xmm2
movss  -0x94(%rbp),%xmm1
ff
mulss  -0x24(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x90(%rbp),%xmm0
ff
movss  -0x34(%rbp),%xmm2
movss  -0x94(%rbp),%xmm1
ff
mulss  -0x30(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x50(%rbp),%xmm1
movss  -0x54(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1a0e <triBoxOverlap+0x8fe>
movss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
jmp    1a22 <triBoxOverlap+0x912>
movss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x68(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm2
movss  -0x64(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x8(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x48(%rbp),%xmm0
ucomiss -0x5c(%rbp),%xmm0
ja     1a7a <triBoxOverlap+0x96a>
movss  -0x4c(%rbp),%xmm1
movss  -0x5c(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
ucomiss %xmm1,%xmm0
jbe    1a86 <triBoxOverlap+0x976>
movl   $0x0,-0x4(%rbp)
jmp    1f9f <triBoxOverlap+0xe8f>
movss  -0x90(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  -0x2c(%rbp),%xmm2
movss  -0x98(%rbp),%xmm1
ff
mulss  -0x24(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x90(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x98(%rbp),%xmm1
ff
mulss  -0x30(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x50(%rbp),%xmm1
movss  -0x54(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1b1a <triBoxOverlap+0xa0a>
movss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
jmp    1b2e <triBoxOverlap+0xa1e>
movss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x68(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x60(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x8(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x48(%rbp),%xmm0
ucomiss -0x5c(%rbp),%xmm0
ja     1b85 <triBoxOverlap+0xa75>
movss  -0x4c(%rbp),%xmm1
movss  -0x5c(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
ucomiss %xmm1,%xmm0
jbe    1b91 <triBoxOverlap+0xa81>
movl   $0x0,-0x4(%rbp)
jmp    1f9f <triBoxOverlap+0xe8f>
movss  -0x94(%rbp),%xmm0
ff
movss  -0x38(%rbp),%xmm2
movss  -0x98(%rbp),%xmm1
ff
mulss  -0x34(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x94(%rbp),%xmm0
ff
movss  -0x44(%rbp),%xmm2
movss  -0x98(%rbp),%xmm1
ff
mulss  -0x40(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x58(%rbp),%xmm1
movss  -0x54(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1c25 <triBoxOverlap+0xb15>
movss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
jmp    1c39 <triBoxOverlap+0xb29>
movss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x64(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x60(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x4(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x48(%rbp),%xmm0
ucomiss -0x5c(%rbp),%xmm0
ja     1c90 <triBoxOverlap+0xb80>
movss  -0x4c(%rbp),%xmm1
movss  -0x5c(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
ucomiss %xmm1,%xmm0
jbe    1c9c <triBoxOverlap+0xb8c>
movl   $0x0,-0x4(%rbp)
jmp    1f9f <triBoxOverlap+0xe8f>
movss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  %xmm0,-0x48(%rbp)
movss  -0x38(%rbp),%xmm1
movss  -0x48(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1cc8 <triBoxOverlap+0xbb8>
movss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x38(%rbp),%xmm0
ucomiss -0x4c(%rbp),%xmm0
jbe    1ce1 <triBoxOverlap+0xbd1>
movss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x44(%rbp),%xmm1
movss  -0x48(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1cfe <triBoxOverlap+0xbee>
movss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
ucomiss -0x4c(%rbp),%xmm0
jbe    1d17 <triBoxOverlap+0xc07>
movss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
ucomiss (%rax),%xmm0
ja     1d4c <triBoxOverlap+0xc3c>
movss  -0x4c(%rbp),%xmm1
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
ucomiss %xmm1,%xmm0
jbe    1d58 <triBoxOverlap+0xc48>
movl   $0x0,-0x4(%rbp)
jmp    1f9f <triBoxOverlap+0xe8f>
movss  -0x28(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  %xmm0,-0x48(%rbp)
movss  -0x34(%rbp),%xmm1
movss  -0x48(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1d84 <triBoxOverlap+0xc74>
movss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x34(%rbp),%xmm0
ucomiss -0x4c(%rbp),%xmm0
jbe    1d9d <triBoxOverlap+0xc8d>
movss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x40(%rbp),%xmm1
movss  -0x48(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1dba <triBoxOverlap+0xcaa>
movss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x40(%rbp),%xmm0
ucomiss -0x4c(%rbp),%xmm0
jbe    1dd3 <triBoxOverlap+0xcc3>
movss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
ucomiss 0x4(%rax),%xmm0
ja     1e0a <triBoxOverlap+0xcfa>
movss  -0x4c(%rbp),%xmm1
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
ucomiss %xmm1,%xmm0
jbe    1e16 <triBoxOverlap+0xd06>
movl   $0x0,-0x4(%rbp)
jmp    1f9f <triBoxOverlap+0xe8f>
movss  -0x24(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  %xmm0,-0x48(%rbp)
movss  -0x30(%rbp),%xmm1
movss  -0x48(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1e42 <triBoxOverlap+0xd32>
movss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x30(%rbp),%xmm0
ucomiss -0x4c(%rbp),%xmm0
jbe    1e5b <triBoxOverlap+0xd4b>
movss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x3c(%rbp),%xmm1
movss  -0x48(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1e78 <triBoxOverlap+0xd68>
movss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x3c(%rbp),%xmm0
ucomiss -0x4c(%rbp),%xmm0
jbe    1e91 <triBoxOverlap+0xd81>
movss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
ucomiss 0x8(%rax),%xmm0
ja     1ec8 <triBoxOverlap+0xdb8>
movss  -0x4c(%rbp),%xmm1
mov    -0x18(%rbp),%rax
movss  0x8(%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
ucomiss %xmm1,%xmm0
jbe    1ed4 <triBoxOverlap+0xdc4>
movl   $0x0,-0x4(%rbp)
jmp    1f9f <triBoxOverlap+0xe8f>
movss  -0x7c(%rbp),%xmm0
movss  -0x84(%rbp),%xmm2
ff
movss  -0x78(%rbp),%xmm1
mulss  -0x88(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x78(%rbp),%xmm0
movss  -0x8c(%rbp),%xmm2
ff
movss  -0x80(%rbp),%xmm1
mulss  -0x84(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x80(%rbp),%xmm0
movss  -0x88(%rbp),%xmm2
ff
movss  -0x7c(%rbp),%xmm1
mulss  -0x8c(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x6c(%rbp)
lea    -0x74(%rbp),%rdi
lea    -0x2c(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    $0x0,%al
call   1030 <planeBoxOverlap@plt>
cmp    $0x0,%eax
jne    1f98 <triBoxOverlap+0xe88>
movl   $0x0,-0x4(%rbp)
jmp    1f9f <triBoxOverlap+0xe8f>
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<triBoxOverlap>:
sub    $0x138,%rsp
movss  (%rdx),%xmm0
movss  (%rdi),%xmm8
subss  %xmm8,%xmm0
movaps %xmm0,0x50(%rsp)
movss  %xmm0,0x34(%rsp)
movss  0x4(%rdx),%xmm13
movss  0x4(%rdi),%xmm0
subss  %xmm0,%xmm13
movss  %xmm13,0x38(%rsp)
movss  0x8(%rdi),%xmm1
movss  0x8(%rdx),%xmm7
movss  0x14(%rdx),%xmm3
unpcklps %xmm3,%xmm7
movaps %xmm1,%xmm3
shufps $0x0,%xmm1,%xmm3
subps  %xmm3,%xmm7
movaps %xmm7,%xmm11
shufps $0x55,%xmm7,%xmm11
movss  %xmm7,0x3c(%rsp)
movss  0x10(%rdx),%xmm3
movss  0x1c(%rdx),%xmm2
unpcklps %xmm3,%xmm2
shufps $0x0,%xmm0,%xmm0
subps  %xmm0,%xmm2
movaps %xmm2,%xmm0
shufps $0x55,%xmm2,%xmm0
movss  0x20(%rdx),%xmm12
subss  %xmm1,%xmm12
movaps %xmm0,0xa0(%rsp)
movaps %xmm0,%xmm1
subss  %xmm13,%xmm1
movaps %xmm11,%xmm4
subss  %xmm7,%xmm4
movaps %xmm12,0x120(%rsp)
movlhps %xmm7,%xmm12
shufps $0xe2,%xmm7,%xmm12
movaps %xmm1,%xmm15
shufps $0x0,%xmm1,%xmm15
movaps %xmm12,%xmm0
mulps  %xmm15,%xmm0
movaps %xmm4,%xmm9
shufps $0x0,%xmm4,%xmm9
movaps %xmm13,%xmm10
movaps %xmm2,0x70(%rsp)
unpcklps %xmm2,%xmm10
movaps %xmm9,%xmm6
mulps  %xmm10,%xmm6
subps  %xmm0,%xmm6
movaps 0xe05(%rip),%xmm0
movaps %xmm1,%xmm14
andps  %xmm0,%xmm14
movaps %xmm4,%xmm3
andps  %xmm0,%xmm3
movss  0x8(%rsi),%xmm0
movaps %xmm14,%xmm5
movaps %xmm0,0x40(%rsp)
mulss  %xmm0,%xmm5
movss  0x4(%rsi),%xmm2
movaps %xmm3,%xmm0
movaps %xmm2,0xb0(%rsp)
mulss  %xmm2,%xmm0
addss  %xmm5,%xmm0
movaps %xmm6,%xmm5
shufps $0x55,%xmm6,%xmm5
movaps %xmm6,%xmm2
minss  %xmm5,%xmm2
xor    %eax,%eax
ucomiss %xmm0,%xmm2
ja     17c1 <triBoxOverlap+0x6b1>
maxss  %xmm6,%xmm5
xorps  0xdb9(%rip),%xmm0
ucomiss %xmm5,%xmm0
ja     17c1 <triBoxOverlap+0x6b1>
mov    %rsi,%rcx
movaps %xmm13,0x60(%rsp)
movaps %xmm11,0x90(%rsp)
movaps %xmm7,0x110(%rsp)
movaps %xmm1,0xf0(%rsp)
movaps %xmm4,0x100(%rsp)
movss  0xc(%rdx),%xmm0
movss  0x18(%rdx),%xmm1
unpcklps %xmm0,%xmm1
shufps $0x0,%xmm8,%xmm8
subps  %xmm8,%xmm1
movaps %xmm1,%xmm4
shufps $0x55,%xmm1,%xmm4
movaps %xmm4,0x80(%rsp)
movaps 0x50(%rsp),%xmm7
subss  %xmm7,%xmm4
movaps %xmm4,%xmm11
andps  0xd3c(%rip),%xmm11
movaps %xmm4,%xmm8
shufps $0x0,%xmm4,%xmm8
movaps %xmm12,%xmm13
mulps  %xmm8,%xmm13
movaps %xmm1,0x10(%rsp)
unpcklps %xmm1,%xmm7
mulps  %xmm7,%xmm9
subps  %xmm9,%xmm13
movaps %xmm13,%xmm5
shufps $0x55,%xmm13,%xmm5
movaps %xmm13,%xmm0
minss  %xmm5,%xmm0
movss  (%rsi),%xmm6
movaps %xmm11,%xmm2
movaps 0x40(%rsp),%xmm9
mulss  %xmm9,%xmm2
mulss  %xmm6,%xmm3
addss  %xmm2,%xmm3
ucomiss %xmm3,%xmm0
ja     17c1 <triBoxOverlap+0x6b1>
maxss  %xmm13,%xmm5
movaps 0xcea(%rip),%xmm1
xorps  %xmm1,%xmm3
ucomiss %xmm5,%xmm3
ja     17c1 <triBoxOverlap+0x6b1>
movaps 0x70(%rsp),%xmm13
mulps  %xmm13,%xmm8
movaps %xmm6,%xmm3
movaps 0x10(%rsp),%xmm6
mulps  %xmm6,%xmm15
subps  %xmm8,%xmm15
movaps %xmm15,%xmm0
shufps $0x55,%xmm15,%xmm0
movaps %xmm15,%xmm2
minss  %xmm0,%xmm2
movaps 0xb0(%rsp),%xmm8
mulss  %xmm8,%xmm11
movaps %xmm3,(%rsp)
mulss  %xmm3,%xmm14
addss  %xmm11,%xmm14
ucomiss %xmm14,%xmm2
ja     17c1 <triBoxOverlap+0x6b1>
maxss  %xmm15,%xmm0
xorps  %xmm1,%xmm14
ucomiss %xmm0,%xmm14
ja     17c1 <triBoxOverlap+0x6b1>
movaps %xmm13,%xmm11
subss  0xa0(%rsp),%xmm11
movaps 0x120(%rsp),%xmm15
movaps %xmm15,%xmm3
subss  0x90(%rsp),%xmm3
movaps %xmm11,%xmm14
movaps 0xc3b(%rip),%xmm1
andps  %xmm1,%xmm14
movaps %xmm3,%xmm0
andps  %xmm1,%xmm0
movaps %xmm11,0xe0(%rsp)
shufps $0x0,%xmm11,%xmm11
movaps %xmm12,%xmm2
mulps  %xmm11,%xmm2
movaps %xmm3,0xd0(%rsp)
movaps %xmm3,%xmm1
shufps $0x0,%xmm3,%xmm1
mulps  %xmm1,%xmm10
subps  %xmm2,%xmm10
movaps %xmm10,%xmm5
shufps $0x55,%xmm10,%xmm5
movaps %xmm14,%xmm2
mulss  %xmm9,%xmm2
movaps %xmm0,%xmm3
mulss  %xmm8,%xmm3
addss  %xmm2,%xmm3
movaps %xmm10,%xmm2
minss  %xmm5,%xmm2
ucomiss %xmm3,%xmm2
ja     17c1 <triBoxOverlap+0x6b1>
maxss  %xmm10,%xmm5
xorps  0xbd9(%rip),%xmm3
ucomiss %xmm5,%xmm3
ja     17c1 <triBoxOverlap+0x6b1>
movaps %xmm4,0xc0(%rsp)
movaps %xmm6,%xmm5
subss  0x80(%rsp),%xmm5
movaps %xmm5,%xmm4
andps  0xba2(%rip),%xmm4
movaps %xmm9,%xmm6
movaps %xmm5,%xmm9
shufps $0x0,%xmm5,%xmm9
mulps  %xmm9,%xmm12
mulps  %xmm7,%xmm1
subps  %xmm1,%xmm12
movaps %xmm12,%xmm1
shufps $0x55,%xmm12,%xmm1
movaps %xmm12,%xmm2
minss  %xmm1,%xmm2
movaps %xmm4,%xmm3
mulss  %xmm6,%xmm3
mulss  (%rsp),%xmm0
addss  %xmm3,%xmm0
ucomiss %xmm0,%xmm2
ja     17c1 <triBoxOverlap+0x6b1>
maxss  %xmm12,%xmm1
xorps  0xb64(%rip),%xmm0
ucomiss %xmm1,%xmm0
ja     17c1 <triBoxOverlap+0x6b1>
movaps %xmm13,%xmm7
movaps 0x60(%rsp),%xmm0
movss  %xmm0,%xmm7
mulps  %xmm7,%xmm9
movaps 0x10(%rsp),%xmm13
movaps 0x50(%rsp),%xmm0
movss  %xmm0,%xmm13
mulps  %xmm13,%xmm11
subps  %xmm9,%xmm11
movaps %xmm11,%xmm0
shufps $0x55,%xmm11,%xmm0
movaps %xmm11,%xmm1
minss  %xmm0,%xmm1
mulss  %xmm8,%xmm4
mulss  (%rsp),%xmm14
addss  %xmm4,%xmm14
ucomiss %xmm14,%xmm1
ja     17c1 <triBoxOverlap+0x6b1>
maxss  %xmm11,%xmm0
xorps  0xafa(%rip),%xmm14
ucomiss %xmm0,%xmm14
ja     17c1 <triBoxOverlap+0x6b1>
movaps %xmm5,%xmm11
movaps 0x60(%rsp),%xmm1
subss  0x70(%rsp),%xmm1
movaps 0x110(%rsp),%xmm10
movaps %xmm10,%xmm4
subss  %xmm15,%xmm4
movaps %xmm1,%xmm9
movaps 0xab4(%rip),%xmm2
andps  %xmm2,%xmm9
movaps %xmm4,%xmm0
andps  %xmm2,%xmm0
shufps $0x0,%xmm1,%xmm1
movaps %xmm10,%xmm2
mulps  %xmm1,%xmm2
shufps $0x0,%xmm4,%xmm4
mulps  %xmm4,%xmm7
subps  %xmm2,%xmm7
movaps %xmm7,%xmm5
shufps $0x55,%xmm7,%xmm5
movaps %xmm7,%xmm2
minss  %xmm5,%xmm2
movaps %xmm9,%xmm6
mulss  0x40(%rsp),%xmm6
movaps %xmm0,%xmm3
mulss  %xmm8,%xmm3
addss  %xmm6,%xmm3
ucomiss %xmm3,%xmm2
ja     17c1 <triBoxOverlap+0x6b1>
maxss  %xmm7,%xmm5
xorps  0xa6d(%rip),%xmm3
ucomiss %xmm5,%xmm3
ja     17c1 <triBoxOverlap+0x6b1>
movaps 0x50(%rsp),%xmm8
subss  0x10(%rsp),%xmm8
movaps 0xa40(%rip),%xmm3
andps  %xmm8,%xmm3
shufps $0x0,%xmm8,%xmm8
movaps %xmm10,%xmm7
mulps  %xmm8,%xmm7
mulps  %xmm13,%xmm4
subps  %xmm4,%xmm7
movaps %xmm7,%xmm4
shufps $0x55,%xmm7,%xmm4
movaps %xmm7,%xmm2
minss  %xmm4,%xmm2
movaps %xmm3,%xmm6
mulss  0x40(%rsp),%xmm3
mulss  (%rsp),%xmm0
addss  %xmm3,%xmm0
ucomiss %xmm0,%xmm2
ja     17c1 <triBoxOverlap+0x6b1>
maxss  %xmm7,%xmm4
xorps  0xa04(%rip),%xmm0
ucomiss %xmm4,%xmm0
ja     17c1 <triBoxOverlap+0x6b1>
movaps 0x70(%rsp),%xmm3
mulps  %xmm3,%xmm8
mulps  0x10(%rsp),%xmm1
subps  %xmm8,%xmm1
movaps %xmm1,%xmm0
shufps $0x55,%xmm1,%xmm0
movaps %xmm1,%xmm2
minss  %xmm0,%xmm2
movaps 0xb0(%rsp),%xmm5
mulss  %xmm5,%xmm6
mulss  (%rsp),%xmm9
addss  %xmm6,%xmm9
ucomiss %xmm9,%xmm2
ja     17c1 <triBoxOverlap+0x6b1>
maxss  %xmm1,%xmm0
xorps  0x9ae(%rip),%xmm9
ucomiss %xmm0,%xmm9
ja     17c1 <triBoxOverlap+0x6b1>
movaps 0x80(%rsp),%xmm6
movaps %xmm6,%xmm0
movaps 0x50(%rsp),%xmm2
minss  %xmm2,%xmm0
movaps 0x10(%rsp),%xmm4
movaps %xmm4,%xmm1
minss  %xmm0,%xmm1
movaps (%rsp),%xmm0
ucomiss %xmm0,%xmm1
ja     17c1 <triBoxOverlap+0x6b1>
maxss  %xmm2,%xmm6
maxss  %xmm6,%xmm4
xorps  0x968(%rip),%xmm0
ucomiss %xmm4,%xmm0
ja     17c1 <triBoxOverlap+0x6b1>
movaps 0xa0(%rsp),%xmm4
movaps %xmm4,%xmm0
movaps 0x60(%rsp),%xmm2
minss  %xmm2,%xmm0
movaps %xmm3,%xmm1
minss  %xmm0,%xmm1
ucomiss %xmm5,%xmm1
ja     17c1 <triBoxOverlap+0x6b1>
maxss  %xmm2,%xmm4
maxss  %xmm4,%xmm3
xorps  0x92c(%rip),%xmm5
ucomiss %xmm3,%xmm5
ja     17c1 <triBoxOverlap+0x6b1>
movaps 0x90(%rsp),%xmm2
movaps %xmm2,%xmm0
minss  %xmm10,%xmm0
movaps %xmm15,%xmm1
minss  %xmm0,%xmm1
movaps 0x40(%rsp),%xmm0
ucomiss %xmm0,%xmm1
ja     17c1 <triBoxOverlap+0x6b1>
maxss  %xmm10,%xmm2
maxss  %xmm2,%xmm15
xorps  0x8ec(%rip),%xmm0
ucomiss %xmm15,%xmm0
ja     17c1 <triBoxOverlap+0x6b1>
movaps 0xf0(%rsp),%xmm3
movaps %xmm3,%xmm0
movaps 0x8d0(%rip),%xmm4
xorps  %xmm4,%xmm0
movaps 0x100(%rsp),%xmm2
movaps %xmm2,%xmm1
xorps  %xmm4,%xmm1
movaps 0xc0(%rsp),%xmm5
xorps  %xmm5,%xmm4
movaps 0xe0(%rsp),%xmm6
mulss  %xmm6,%xmm1
movaps 0xd0(%rsp),%xmm7
mulss  %xmm7,%xmm3
addss  %xmm1,%xmm3
movss  %xmm3,0x28(%rsp)
mulss  %xmm7,%xmm4
mulss  %xmm11,%xmm2
addss  %xmm4,%xmm2
movss  %xmm2,0x2c(%rsp)
mulss  %xmm11,%xmm0
mulss  %xmm6,%xmm5
addss  %xmm0,%xmm5
movss  %xmm5,0x30(%rsp)
lea    0x28(%rsp),%rdi
lea    0x34(%rsp),%rsi
mov    %rcx,%rdx
xor    %eax,%eax
call   1030 <planeBoxOverlap@plt>
mov    %eax,%ecx
xor    %eax,%eax
test   %ecx,%ecx
setne  %al
add    $0x138,%rsp
ret

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

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