#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 */
float fabs(float);
int /*<<< orphan*/ planeBoxOverlap(float *, float, float *);
int triBoxOverlap(float boxcenter[3], float boxhalfsize[3],
                  float triverts[3][3]) {
  float v0[3], v1[3], v2[3];
  float min, max, d, 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 = fabs(e0[0]);
  fey = fabs(e0[1]);
  fez = fabs(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 = fabs(e1[0]);
  fey = fabs(e1[1]);
  fez = fabs(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 = fabs(e2[0]);
  fey = fabs(e2[1]);
  fez = fabs(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];
  ;
  d = -(normal[0] * v0[0] + normal[1] * v0[1] + normal[2] * v0[2]);
  if (!planeBoxOverlap(normal, d, 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,-0x84(%rbp)
ff
movss  -0x34(%rbp),%xmm0
subss  -0x28(%rbp),%xmm0
movss  %xmm0,-0x80(%rbp)
movss  -0x30(%rbp),%xmm0
subss  -0x24(%rbp),%xmm0
movss  %xmm0,-0x7c(%rbp)
movss  -0x44(%rbp),%xmm0
subss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x90(%rbp)
ff
movss  -0x40(%rbp),%xmm0
subss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x8c(%rbp)
ff
movss  -0x3c(%rbp),%xmm0
subss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x88(%rbp)
ff
movss  -0x2c(%rbp),%xmm0
subss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x9c(%rbp)
ff
movss  -0x28(%rbp),%xmm0
subss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x98(%rbp)
ff
movss  -0x24(%rbp),%xmm0
subss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x94(%rbp)
ff
movss  -0x84(%rbp),%xmm0
ff
call   1030 <fabs@plt>
movss  %xmm0,-0x64(%rbp)
movss  -0x80(%rbp),%xmm0
call   1030 <fabs@plt>
movss  %xmm0,-0x68(%rbp)
movss  -0x7c(%rbp),%xmm0
call   1030 <fabs@plt>
movss  %xmm0,-0x6c(%rbp)
movss  -0x7c(%rbp),%xmm0
movss  -0x28(%rbp),%xmm2
movss  -0x80(%rbp),%xmm1
mulss  -0x24(%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  -0x40(%rbp),%xmm2
movss  -0x80(%rbp),%xmm1
mulss  -0x3c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x54(%rbp),%xmm1
movss  -0x5c(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1356 <triBoxOverlap+0x236>
movss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
jmp    136a <triBoxOverlap+0x24a>
movss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x6c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm2
movss  -0x68(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x8(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x48(%rbp),%xmm0
ucomiss -0x60(%rbp),%xmm0
ja     13c2 <triBoxOverlap+0x2a2>
movss  -0x4c(%rbp),%xmm1
movss  -0x60(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
ucomiss %xmm1,%xmm0
jbe    13ce <triBoxOverlap+0x2ae>
movl   $0x0,-0x4(%rbp)
jmp    1fd0 <triBoxOverlap+0xeb0>
movss  -0x7c(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  -0x2c(%rbp),%xmm2
movss  -0x84(%rbp),%xmm1
ff
mulss  -0x24(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x7c(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x84(%rbp),%xmm1
ff
mulss  -0x3c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x54(%rbp),%xmm1
movss  -0x5c(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    145c <triBoxOverlap+0x33c>
movss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
jmp    1470 <triBoxOverlap+0x350>
movss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x6c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x64(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x8(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x48(%rbp),%xmm0
ucomiss -0x60(%rbp),%xmm0
ja     14c7 <triBoxOverlap+0x3a7>
movss  -0x4c(%rbp),%xmm1
movss  -0x60(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
ucomiss %xmm1,%xmm0
jbe    14d3 <triBoxOverlap+0x3b3>
movl   $0x0,-0x4(%rbp)
jmp    1fd0 <triBoxOverlap+0xeb0>
movss  -0x80(%rbp),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x84(%rbp),%xmm1
ff
mulss  -0x34(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x80(%rbp),%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x84(%rbp),%xmm1
ff
mulss  -0x40(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x5c(%rbp),%xmm1
movss  -0x58(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1561 <triBoxOverlap+0x441>
movss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
jmp    1575 <triBoxOverlap+0x455>
movss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x68(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x64(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x4(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x48(%rbp),%xmm0
ucomiss -0x60(%rbp),%xmm0
ja     15cc <triBoxOverlap+0x4ac>
movss  -0x4c(%rbp),%xmm1
movss  -0x60(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
ucomiss %xmm1,%xmm0
jbe    15d8 <triBoxOverlap+0x4b8>
movl   $0x0,-0x4(%rbp)
jmp    1fd0 <triBoxOverlap+0xeb0>
movss  -0x90(%rbp),%xmm0
ff
call   1030 <fabs@plt>
movss  %xmm0,-0x64(%rbp)
movss  -0x8c(%rbp),%xmm0
ff
call   1030 <fabs@plt>
movss  %xmm0,-0x68(%rbp)
movss  -0x88(%rbp),%xmm0
ff
call   1030 <fabs@plt>
movss  %xmm0,-0x6c(%rbp)
movss  -0x88(%rbp),%xmm0
ff
movss  -0x28(%rbp),%xmm2
movss  -0x8c(%rbp),%xmm1
ff
mulss  -0x24(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x88(%rbp),%xmm0
ff
movss  -0x40(%rbp),%xmm2
movss  -0x8c(%rbp),%xmm1
ff
mulss  -0x3c(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x54(%rbp),%xmm1
movss  -0x5c(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    16a2 <triBoxOverlap+0x582>
movss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
jmp    16b6 <triBoxOverlap+0x596>
movss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x6c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm2
movss  -0x68(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x8(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x48(%rbp),%xmm0
ucomiss -0x60(%rbp),%xmm0
ja     170e <triBoxOverlap+0x5ee>
movss  -0x4c(%rbp),%xmm1
movss  -0x60(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
ucomiss %xmm1,%xmm0
jbe    171a <triBoxOverlap+0x5fa>
movl   $0x0,-0x4(%rbp)
jmp    1fd0 <triBoxOverlap+0xeb0>
movss  -0x88(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  -0x2c(%rbp),%xmm2
movss  -0x90(%rbp),%xmm1
ff
mulss  -0x24(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x88(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  -0x44(%rbp),%xmm2
movss  -0x90(%rbp),%xmm1
ff
mulss  -0x3c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x54(%rbp),%xmm1
movss  -0x5c(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    17ae <triBoxOverlap+0x68e>
movss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
jmp    17c2 <triBoxOverlap+0x6a2>
movss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x6c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x64(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x8(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x48(%rbp),%xmm0
ucomiss -0x60(%rbp),%xmm0
ja     1819 <triBoxOverlap+0x6f9>
movss  -0x4c(%rbp),%xmm1
movss  -0x60(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
ucomiss %xmm1,%xmm0
jbe    1825 <triBoxOverlap+0x705>
movl   $0x0,-0x4(%rbp)
jmp    1fd0 <triBoxOverlap+0xeb0>
movss  -0x8c(%rbp),%xmm0
ff
movss  -0x2c(%rbp),%xmm2
movss  -0x90(%rbp),%xmm1
ff
mulss  -0x28(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x8c(%rbp),%xmm0
ff
movss  -0x38(%rbp),%xmm2
movss  -0x90(%rbp),%xmm1
ff
mulss  -0x34(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x54(%rbp),%xmm1
movss  -0x58(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    18b9 <triBoxOverlap+0x799>
movss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
jmp    18cd <triBoxOverlap+0x7ad>
movss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x68(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x64(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x4(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x48(%rbp),%xmm0
ucomiss -0x60(%rbp),%xmm0
ja     1924 <triBoxOverlap+0x804>
movss  -0x4c(%rbp),%xmm1
movss  -0x60(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
ucomiss %xmm1,%xmm0
jbe    1930 <triBoxOverlap+0x810>
movl   $0x0,-0x4(%rbp)
jmp    1fd0 <triBoxOverlap+0xeb0>
movss  -0x9c(%rbp),%xmm0
ff
call   1030 <fabs@plt>
movss  %xmm0,-0x64(%rbp)
movss  -0x98(%rbp),%xmm0
ff
call   1030 <fabs@plt>
movss  %xmm0,-0x68(%rbp)
movss  -0x94(%rbp),%xmm0
ff
call   1030 <fabs@plt>
movss  %xmm0,-0x6c(%rbp)
movss  -0x94(%rbp),%xmm0
ff
movss  -0x28(%rbp),%xmm2
movss  -0x98(%rbp),%xmm1
ff
mulss  -0x24(%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  -0x34(%rbp),%xmm2
movss  -0x98(%rbp),%xmm1
ff
mulss  -0x30(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x54(%rbp),%xmm1
movss  -0x58(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    19fa <triBoxOverlap+0x8da>
movss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
jmp    1a0e <triBoxOverlap+0x8ee>
movss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x6c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  0x4(%rax),%xmm2
movss  -0x68(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x8(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x48(%rbp),%xmm0
ucomiss -0x60(%rbp),%xmm0
ja     1a66 <triBoxOverlap+0x946>
movss  -0x4c(%rbp),%xmm1
movss  -0x60(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
ucomiss %xmm1,%xmm0
jbe    1a72 <triBoxOverlap+0x952>
movl   $0x0,-0x4(%rbp)
jmp    1fd0 <triBoxOverlap+0xeb0>
movss  -0x94(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  -0x2c(%rbp),%xmm2
movss  -0x9c(%rbp),%xmm1
ff
mulss  -0x24(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x54(%rbp)
movss  -0x94(%rbp),%xmm0
ff
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x9c(%rbp),%xmm1
ff
mulss  -0x30(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x54(%rbp),%xmm1
movss  -0x58(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1b06 <triBoxOverlap+0x9e6>
movss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
jmp    1b1a <triBoxOverlap+0x9fa>
movss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x54(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x6c(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x64(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x8(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x48(%rbp),%xmm0
ucomiss -0x60(%rbp),%xmm0
ja     1b71 <triBoxOverlap+0xa51>
movss  -0x4c(%rbp),%xmm1
movss  -0x60(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
ucomiss %xmm1,%xmm0
jbe    1b7d <triBoxOverlap+0xa5d>
movl   $0x0,-0x4(%rbp)
jmp    1fd0 <triBoxOverlap+0xeb0>
movss  -0x98(%rbp),%xmm0
ff
movss  -0x38(%rbp),%xmm2
movss  -0x9c(%rbp),%xmm1
ff
mulss  -0x34(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x58(%rbp)
movss  -0x98(%rbp),%xmm0
ff
movss  -0x44(%rbp),%xmm2
movss  -0x9c(%rbp),%xmm1
ff
mulss  -0x40(%rbp),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x5c(%rbp),%xmm1
movss  -0x58(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1c11 <triBoxOverlap+0xaf1>
movss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
jmp    1c25 <triBoxOverlap+0xb05>
movss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x68(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm2
movss  -0x64(%rbp),%xmm1
mov    -0x18(%rbp),%rax
mulss  0x4(%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x48(%rbp),%xmm0
ucomiss -0x60(%rbp),%xmm0
ja     1c7c <triBoxOverlap+0xb5c>
movss  -0x4c(%rbp),%xmm1
movss  -0x60(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
ucomiss %xmm1,%xmm0
jbe    1c88 <triBoxOverlap+0xb68>
movl   $0x0,-0x4(%rbp)
jmp    1fd0 <triBoxOverlap+0xeb0>
movss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  %xmm0,-0x48(%rbp)
movss  -0x38(%rbp),%xmm1
movss  -0x48(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1cb4 <triBoxOverlap+0xb94>
movss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x38(%rbp),%xmm0
ucomiss -0x4c(%rbp),%xmm0
jbe    1ccd <triBoxOverlap+0xbad>
movss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x44(%rbp),%xmm1
movss  -0x48(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1cea <triBoxOverlap+0xbca>
movss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x44(%rbp),%xmm0
ucomiss -0x4c(%rbp),%xmm0
jbe    1d03 <triBoxOverlap+0xbe3>
movss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
ucomiss (%rax),%xmm0
ja     1d38 <triBoxOverlap+0xc18>
movss  -0x4c(%rbp),%xmm1
mov    -0x18(%rbp),%rax
movss  (%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
ucomiss %xmm1,%xmm0
jbe    1d44 <triBoxOverlap+0xc24>
movl   $0x0,-0x4(%rbp)
jmp    1fd0 <triBoxOverlap+0xeb0>
movss  -0x28(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  %xmm0,-0x48(%rbp)
movss  -0x34(%rbp),%xmm1
movss  -0x48(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1d70 <triBoxOverlap+0xc50>
movss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x34(%rbp),%xmm0
ucomiss -0x4c(%rbp),%xmm0
jbe    1d89 <triBoxOverlap+0xc69>
movss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x40(%rbp),%xmm1
movss  -0x48(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1da6 <triBoxOverlap+0xc86>
movss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x40(%rbp),%xmm0
ucomiss -0x4c(%rbp),%xmm0
jbe    1dbf <triBoxOverlap+0xc9f>
movss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
ucomiss 0x4(%rax),%xmm0
ja     1df6 <triBoxOverlap+0xcd6>
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    1e02 <triBoxOverlap+0xce2>
movl   $0x0,-0x4(%rbp)
jmp    1fd0 <triBoxOverlap+0xeb0>
movss  -0x24(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  %xmm0,-0x48(%rbp)
movss  -0x30(%rbp),%xmm1
movss  -0x48(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1e2e <triBoxOverlap+0xd0e>
movss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x30(%rbp),%xmm0
ucomiss -0x4c(%rbp),%xmm0
jbe    1e47 <triBoxOverlap+0xd27>
movss  -0x30(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x3c(%rbp),%xmm1
movss  -0x48(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1e64 <triBoxOverlap+0xd44>
movss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movss  -0x3c(%rbp),%xmm0
ucomiss -0x4c(%rbp),%xmm0
jbe    1e7d <triBoxOverlap+0xd5d>
movss  -0x3c(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x48(%rbp),%xmm0
mov    -0x18(%rbp),%rax
ucomiss 0x8(%rax),%xmm0
ja     1eb4 <triBoxOverlap+0xd94>
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    1ec0 <triBoxOverlap+0xda0>
movl   $0x0,-0x4(%rbp)
jmp    1fd0 <triBoxOverlap+0xeb0>
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,-0x78(%rbp)
movss  -0x7c(%rbp),%xmm0
movss  -0x90(%rbp),%xmm2
movss  -0x84(%rbp),%xmm1
ff
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  -0x84(%rbp),%xmm0
ff
movss  -0x8c(%rbp),%xmm2
ff
movss  -0x80(%rbp),%xmm1
mulss  -0x90(%rbp),%xmm1
ff
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x70(%rbp)
movss  -0x78(%rbp),%xmm1
movss  -0x2c(%rbp),%xmm2
movss  -0x74(%rbp),%xmm0
mulss  -0x28(%rbp),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x70(%rbp),%xmm0
movss  -0x24(%rbp),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x50(%rbp)
lea    -0x78(%rbp),%rdi
movss  -0x50(%rbp),%xmm0
mov    -0x18(%rbp),%rsi
call   1040 <planeBoxOverlap@plt>
cmp    $0x0,%eax
jne    1fc9 <triBoxOverlap+0xea9>
movl   $0x0,-0x4(%rbp)
jmp    1fd0 <triBoxOverlap+0xeb0>
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0xa0,%rsp
pop    %rbp
ret

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

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