#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 */
double fabsf(double);
int /*<<< orphan*/ planeBoxOverlap(double *, double *, double *);
int triBoxOverlap(double boxcenter[3], double boxhalfsize[3],
                  double triverts[3][3]) {
  double v0[3], v1[3], v2[3];
  double min, max, p0, p1, p2, rad, fex, fey, fez;
  double 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    $0x140,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x10(%rbp),%rax
subsd  (%rax),%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x20(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
subsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x20(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
subsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x20(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x10(%rbp),%rax
subsd  (%rax),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x20(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    -0x10(%rbp),%rax
subsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x20(%rbp),%rax
movsd  0x28(%rax),%xmm0
mov    -0x10(%rbp),%rax
subsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x20(%rbp),%rax
movsd  0x30(%rax),%xmm0
mov    -0x10(%rbp),%rax
subsd  (%rax),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x20(%rbp),%rax
movsd  0x38(%rax),%xmm0
mov    -0x10(%rbp),%rax
subsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x20(%rbp),%rax
movsd  0x40(%rax),%xmm0
mov    -0x10(%rbp),%rax
subsd  0x10(%rax),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x60(%rbp),%xmm0
subsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
subsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
subsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
subsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x120(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
subsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x118(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
subsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
movsd  -0x40(%rbp),%xmm0
subsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x140(%rbp)
ff
movsd  -0x38(%rbp),%xmm0
subsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x138(%rbp)
ff
movsd  -0x30(%rbp),%xmm0
subsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0x100(%rbp),%xmm0
ff
call   1030 <fabsf@plt>
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0xf8(%rbp),%xmm0
ff
call   1030 <fabsf@plt>
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xf0(%rbp),%xmm0
ff
call   1030 <fabsf@plt>
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0xf0(%rbp),%xmm0
ff
movsd  -0x38(%rbp),%xmm2
movsd  -0xf8(%rbp),%xmm1
ff
mulsd  -0x30(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0xf0(%rbp),%xmm0
ff
movsd  -0x78(%rbp),%xmm2
movsd  -0xf8(%rbp),%xmm1
ff
mulsd  -0x70(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0x98(%rbp),%xmm1
ff
movsd  -0xa8(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    13a4 <triBoxOverlap+0x284>
movsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
jmp    13c4 <triBoxOverlap+0x2a4>
movsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movsd  0x8(%rax),%xmm2
movsd  -0xc0(%rbp),%xmm1
ff
mov    -0x18(%rbp),%rax
mulsd  0x10(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
ucomisd -0xb0(%rbp),%xmm0
ff
ja     143d <triBoxOverlap+0x31d>
movsd  -0x90(%rbp),%xmm1
ff
movsd  -0xb0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
ucomisd %xmm1,%xmm0
jbe    1449 <triBoxOverlap+0x329>
movl   $0x0,-0x4(%rbp)
jmp    23ca <triBoxOverlap+0x12aa>
movsd  -0xf0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  -0x40(%rbp),%xmm2
movsd  -0x100(%rbp),%xmm1
ff
mulsd  -0x30(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0xf0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  -0x80(%rbp),%xmm2
movsd  -0x100(%rbp),%xmm1
ff
mulsd  -0x70(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0x98(%rbp),%xmm1
ff
movsd  -0xa8(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    150a <triBoxOverlap+0x3ea>
movsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
jmp    152a <triBoxOverlap+0x40a>
movsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0xb8(%rbp),%xmm1
ff
mov    -0x18(%rbp),%rax
mulsd  0x10(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
ucomisd -0xb0(%rbp),%xmm0
ff
ja     15a2 <triBoxOverlap+0x482>
movsd  -0x90(%rbp),%xmm1
ff
movsd  -0xb0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
ucomisd %xmm1,%xmm0
jbe    15ae <triBoxOverlap+0x48e>
movl   $0x0,-0x4(%rbp)
jmp    23ca <triBoxOverlap+0x12aa>
movsd  -0xf8(%rbp),%xmm0
ff
movsd  -0x60(%rbp),%xmm2
movsd  -0x100(%rbp),%xmm1
ff
mulsd  -0x58(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xf8(%rbp),%xmm0
ff
movsd  -0x80(%rbp),%xmm2
movsd  -0x100(%rbp),%xmm1
ff
mulsd  -0x78(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xa8(%rbp),%xmm1
ff
movsd  -0xa0(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    166f <triBoxOverlap+0x54f>
movsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
jmp    168f <triBoxOverlap+0x56f>
movsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0xb8(%rbp),%xmm1
ff
mov    -0x18(%rbp),%rax
mulsd  0x8(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
ucomisd -0xb0(%rbp),%xmm0
ff
ja     1707 <triBoxOverlap+0x5e7>
movsd  -0x90(%rbp),%xmm1
ff
movsd  -0xb0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
ucomisd %xmm1,%xmm0
jbe    1713 <triBoxOverlap+0x5f3>
movl   $0x0,-0x4(%rbp)
jmp    23ca <triBoxOverlap+0x12aa>
movsd  -0x120(%rbp),%xmm0
ff
call   1030 <fabsf@plt>
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0x118(%rbp),%xmm0
ff
call   1030 <fabsf@plt>
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0x110(%rbp),%xmm0
ff
call   1030 <fabsf@plt>
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0x110(%rbp),%xmm0
ff
movsd  -0x38(%rbp),%xmm2
movsd  -0x118(%rbp),%xmm1
ff
mulsd  -0x30(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x110(%rbp),%xmm0
ff
movsd  -0x78(%rbp),%xmm2
movsd  -0x118(%rbp),%xmm1
ff
mulsd  -0x70(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0x98(%rbp),%xmm1
ff
movsd  -0xa8(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    1813 <triBoxOverlap+0x6f3>
movsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
jmp    1833 <triBoxOverlap+0x713>
movsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movsd  0x8(%rax),%xmm2
movsd  -0xc0(%rbp),%xmm1
ff
mov    -0x18(%rbp),%rax
mulsd  0x10(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
ucomisd -0xb0(%rbp),%xmm0
ff
ja     18ac <triBoxOverlap+0x78c>
movsd  -0x90(%rbp),%xmm1
ff
movsd  -0xb0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
ucomisd %xmm1,%xmm0
jbe    18b8 <triBoxOverlap+0x798>
movl   $0x0,-0x4(%rbp)
jmp    23ca <triBoxOverlap+0x12aa>
movsd  -0x110(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  -0x40(%rbp),%xmm2
movsd  -0x120(%rbp),%xmm1
ff
mulsd  -0x30(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x110(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  -0x80(%rbp),%xmm2
movsd  -0x120(%rbp),%xmm1
ff
mulsd  -0x70(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0x98(%rbp),%xmm1
ff
movsd  -0xa8(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    1979 <triBoxOverlap+0x859>
movsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
jmp    1999 <triBoxOverlap+0x879>
movsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0xb8(%rbp),%xmm1
ff
mov    -0x18(%rbp),%rax
mulsd  0x10(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
ucomisd -0xb0(%rbp),%xmm0
ff
ja     1a11 <triBoxOverlap+0x8f1>
movsd  -0x90(%rbp),%xmm1
ff
movsd  -0xb0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
ucomisd %xmm1,%xmm0
jbe    1a1d <triBoxOverlap+0x8fd>
movl   $0x0,-0x4(%rbp)
jmp    23ca <triBoxOverlap+0x12aa>
movsd  -0x118(%rbp),%xmm0
ff
movsd  -0x40(%rbp),%xmm2
movsd  -0x120(%rbp),%xmm1
ff
mulsd  -0x38(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x118(%rbp),%xmm0
ff
movsd  -0x60(%rbp),%xmm2
movsd  -0x120(%rbp),%xmm1
ff
mulsd  -0x58(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x98(%rbp),%xmm1
ff
movsd  -0xa0(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    1ade <triBoxOverlap+0x9be>
movsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
jmp    1afe <triBoxOverlap+0x9de>
movsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0xb8(%rbp),%xmm1
ff
mov    -0x18(%rbp),%rax
mulsd  0x8(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
ucomisd -0xb0(%rbp),%xmm0
ff
ja     1b76 <triBoxOverlap+0xa56>
movsd  -0x90(%rbp),%xmm1
ff
movsd  -0xb0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
ucomisd %xmm1,%xmm0
jbe    1b82 <triBoxOverlap+0xa62>
movl   $0x0,-0x4(%rbp)
jmp    23ca <triBoxOverlap+0x12aa>
movsd  -0x140(%rbp),%xmm0
ff
call   1030 <fabsf@plt>
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0x138(%rbp),%xmm0
ff
call   1030 <fabsf@plt>
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0x130(%rbp),%xmm0
ff
call   1030 <fabsf@plt>
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0x130(%rbp),%xmm0
ff
movsd  -0x38(%rbp),%xmm2
movsd  -0x138(%rbp),%xmm1
ff
mulsd  -0x30(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x130(%rbp),%xmm0
ff
movsd  -0x58(%rbp),%xmm2
movsd  -0x138(%rbp),%xmm1
ff
mulsd  -0x50(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x98(%rbp),%xmm1
ff
movsd  -0xa0(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    1c82 <triBoxOverlap+0xb62>
movsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
jmp    1ca2 <triBoxOverlap+0xb82>
movsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movsd  0x8(%rax),%xmm2
movsd  -0xc0(%rbp),%xmm1
ff
mov    -0x18(%rbp),%rax
mulsd  0x10(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
ucomisd -0xb0(%rbp),%xmm0
ff
ja     1d1b <triBoxOverlap+0xbfb>
movsd  -0x90(%rbp),%xmm1
ff
movsd  -0xb0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
ucomisd %xmm1,%xmm0
jbe    1d27 <triBoxOverlap+0xc07>
movl   $0x0,-0x4(%rbp)
jmp    23ca <triBoxOverlap+0x12aa>
movsd  -0x130(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  -0x40(%rbp),%xmm2
movsd  -0x140(%rbp),%xmm1
ff
mulsd  -0x30(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
movsd  -0x130(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  -0x60(%rbp),%xmm2
movsd  -0x140(%rbp),%xmm1
ff
mulsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x98(%rbp),%xmm1
ff
movsd  -0xa0(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    1de8 <triBoxOverlap+0xcc8>
movsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
jmp    1e08 <triBoxOverlap+0xce8>
movsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0xb8(%rbp),%xmm1
ff
mov    -0x18(%rbp),%rax
mulsd  0x10(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
ucomisd -0xb0(%rbp),%xmm0
ff
ja     1e80 <triBoxOverlap+0xd60>
movsd  -0x90(%rbp),%xmm1
ff
movsd  -0xb0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
ucomisd %xmm1,%xmm0
jbe    1e8c <triBoxOverlap+0xd6c>
movl   $0x0,-0x4(%rbp)
jmp    23ca <triBoxOverlap+0x12aa>
movsd  -0x138(%rbp),%xmm0
ff
movsd  -0x60(%rbp),%xmm2
movsd  -0x140(%rbp),%xmm1
ff
mulsd  -0x58(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x138(%rbp),%xmm0
ff
movsd  -0x80(%rbp),%xmm2
movsd  -0x140(%rbp),%xmm1
ff
mulsd  -0x78(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xa8(%rbp),%xmm1
ff
movsd  -0xa0(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    1f4d <triBoxOverlap+0xe2d>
movsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
jmp    1f6d <triBoxOverlap+0xe4d>
movsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm2
movsd  -0xb8(%rbp),%xmm1
ff
mov    -0x18(%rbp),%rax
mulsd  0x8(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
ucomisd -0xb0(%rbp),%xmm0
ff
ja     1fe5 <triBoxOverlap+0xec5>
movsd  -0x90(%rbp),%xmm1
ff
movsd  -0xb0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
ucomisd %xmm1,%xmm0
jbe    1ff1 <triBoxOverlap+0xed1>
movl   $0x0,-0x4(%rbp)
jmp    23ca <triBoxOverlap+0x12aa>
movsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  %xmm0,-0x88(%rbp)
movsd  -0x60(%rbp),%xmm1
movsd  -0x88(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    202a <triBoxOverlap+0xf0a>
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x60(%rbp),%xmm0
ucomisd -0x90(%rbp),%xmm0
ff
jbe    204a <triBoxOverlap+0xf2a>
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x80(%rbp),%xmm1
movsd  -0x88(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    206e <triBoxOverlap+0xf4e>
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x80(%rbp),%xmm0
ucomisd -0x90(%rbp),%xmm0
ff
jbe    208e <triBoxOverlap+0xf6e>
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
ucomisd (%rax),%xmm0
ja     20d5 <triBoxOverlap+0xfb5>
movsd  -0x90(%rbp),%xmm1
ff
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
ucomisd %xmm1,%xmm0
jbe    20e1 <triBoxOverlap+0xfc1>
movl   $0x0,-0x4(%rbp)
jmp    23ca <triBoxOverlap+0x12aa>
movsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x58(%rbp),%xmm1
movsd  -0x88(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    211a <triBoxOverlap+0xffa>
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x58(%rbp),%xmm0
ucomisd -0x90(%rbp),%xmm0
ff
jbe    213a <triBoxOverlap+0x101a>
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x78(%rbp),%xmm1
movsd  -0x88(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    215e <triBoxOverlap+0x103e>
movsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
ucomisd -0x90(%rbp),%xmm0
ff
jbe    217e <triBoxOverlap+0x105e>
movsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
ucomisd 0x8(%rax),%xmm0
ja     21c7 <triBoxOverlap+0x10a7>
movsd  -0x90(%rbp),%xmm1
ff
mov    -0x18(%rbp),%rax
movsd  0x8(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
ucomisd %xmm1,%xmm0
jbe    21d3 <triBoxOverlap+0x10b3>
movl   $0x0,-0x4(%rbp)
jmp    23ca <triBoxOverlap+0x12aa>
movsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x50(%rbp),%xmm1
movsd  -0x88(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    220c <triBoxOverlap+0x10ec>
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x50(%rbp),%xmm0
ucomisd -0x90(%rbp),%xmm0
ff
jbe    222c <triBoxOverlap+0x110c>
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x70(%rbp),%xmm1
movsd  -0x88(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jbe    2250 <triBoxOverlap+0x1130>
movsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x70(%rbp),%xmm0
ucomisd -0x90(%rbp),%xmm0
ff
jbe    2270 <triBoxOverlap+0x1150>
movsd  -0x70(%rbp),%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x18(%rbp),%rax
ucomisd 0x10(%rax),%xmm0
ja     22b9 <triBoxOverlap+0x1199>
movsd  -0x90(%rbp),%xmm1
ff
mov    -0x18(%rbp),%rax
movsd  0x10(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
ucomisd %xmm1,%xmm0
jbe    22c5 <triBoxOverlap+0x11a5>
movl   $0x0,-0x4(%rbp)
jmp    23ca <triBoxOverlap+0x12aa>
movsd  -0xf8(%rbp),%xmm0
ff
movsd  -0x110(%rbp),%xmm2
ff
movsd  -0xf0(%rbp),%xmm1
ff
mulsd  -0x118(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0xf0(%rbp),%xmm0
ff
movsd  -0x120(%rbp),%xmm2
ff
movsd  -0x100(%rbp),%xmm1
ff
mulsd  -0x110(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0x100(%rbp),%xmm0
ff
movsd  -0x118(%rbp),%xmm2
ff
movsd  -0xf8(%rbp),%xmm1
ff
mulsd  -0x120(%rbp),%xmm1
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
lea    -0xe0(%rbp),%rdi
lea    -0x40(%rbp),%rsi
mov    -0x18(%rbp),%rdx
call   1040 <planeBoxOverlap@plt>
cmp    $0x0,%eax
jne    23c3 <triBoxOverlap+0x12a3>
movl   $0x0,-0x4(%rbp)
jmp    23ca <triBoxOverlap+0x12aa>
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x140,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<triBoxOverlap>:
sub    $0x118,%rsp
movsd  (%rdx),%xmm8
movhpd 0x18(%rdx),%xmm8
movsd  (%rdi),%xmm0
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
subpd  %xmm1,%xmm8
movlpd %xmm8,0x100(%rsp)
movupd 0x8(%rdx),%xmm2
movupd 0x8(%rdi),%xmm1
subpd  %xmm1,%xmm2
movupd %xmm2,0x108(%rsp)
movupd 0x20(%rdx),%xmm11
subpd  %xmm1,%xmm11
movsd  0x38(%rdx),%xmm4
movsd  0x30(%rdx),%xmm3
movhpd 0x40(%rdx),%xmm3
subsd  %xmm1,%xmm4
movsd  %xmm0,%xmm1
subpd  %xmm1,%xmm3
movapd %xmm11,%xmm0
subpd  %xmm2,%xmm0
movapd 0xe75(%rip),%xmm5
movapd %xmm0,%xmm12
andpd  %xmm5,%xmm12
movapd %xmm0,%xmm1
unpckhpd %xmm0,%xmm1
movapd %xmm1,%xmm15
andpd  %xmm5,%xmm15
movapd %xmm2,%xmm14
movapd %xmm3,0x20(%rsp)
unpckhpd %xmm3,%xmm14
movapd %xmm0,%xmm9
unpcklpd %xmm0,%xmm9
movapd %xmm14,%xmm3
mulpd  %xmm9,%xmm3
movapd %xmm2,%xmm13
movapd %xmm4,0xd0(%rsp)
unpcklpd %xmm4,%xmm13
movapd %xmm1,%xmm6
mulpd  %xmm13,%xmm6
subpd  %xmm3,%xmm6
movsd  0x10(%rsi),%xmm10
movapd %xmm12,%xmm3
mulsd  %xmm10,%xmm3
movsd  0x8(%rsi),%xmm7
movapd %xmm15,%xmm4
mulsd  %xmm7,%xmm4
addsd  %xmm3,%xmm4
movapd %xmm6,%xmm3
unpckhpd %xmm6,%xmm3
movapd %xmm6,%xmm5
minsd  %xmm3,%xmm5
xor    %eax,%eax
ucomisd %xmm4,%xmm5
ja     184d <triBoxOverlap+0x73d>
maxsd  %xmm6,%xmm3
xorpd  0xddb(%rip),%xmm4
ucomisd %xmm3,%xmm4
ja     184d <triBoxOverlap+0x73d>
mov    %rsi,%rcx
movapd %xmm7,0x10(%rsp)
movapd %xmm2,0x40(%rsp)
movapd %xmm11,0x30(%rsp)
movapd %xmm0,0xb0(%rsp)
movapd %xmm8,%xmm7
unpckhpd %xmm8,%xmm7
movapd %xmm7,%xmm0
subsd  %xmm8,%xmm0
movapd %xmm10,%xmm2
movapd %xmm0,%xmm10
andpd  0xd7c(%rip),%xmm10
movapd %xmm0,%xmm11
unpcklpd %xmm0,%xmm11
movapd %xmm14,%xmm3
mulpd  %xmm11,%xmm3
movapd %xmm1,0xa0(%rsp)
movapd %xmm1,%xmm4
unpcklpd %xmm1,%xmm4
movapd %xmm8,%xmm5
movapd 0x20(%rsp),%xmm1
unpcklpd %xmm1,%xmm5
movapd %xmm5,0xc0(%rsp)
mulpd  %xmm5,%xmm4
subpd  %xmm4,%xmm3
movapd %xmm3,%xmm4
unpckhpd %xmm3,%xmm4
movsd  (%rsi),%xmm6
movapd %xmm10,%xmm5
movapd %xmm2,(%rsp)
mulsd  %xmm2,%xmm5
movapd %xmm6,0x50(%rsp)
mulsd  %xmm6,%xmm15
addsd  %xmm5,%xmm15
movapd %xmm3,%xmm5
minsd  %xmm4,%xmm5
ucomisd %xmm15,%xmm5
ja     184d <triBoxOverlap+0x73d>
maxsd  %xmm3,%xmm4
movapd 0xcfe(%rip),%xmm2
xorpd  %xmm2,%xmm15
ucomisd %xmm4,%xmm15
ja     184d <triBoxOverlap+0x73d>
movapd 0xd0(%rsp),%xmm15
movapd %xmm15,%xmm6
unpcklpd 0x30(%rsp),%xmm6
mulpd  %xmm6,%xmm11
movapd %xmm8,%xmm5
movsd  %xmm1,%xmm5
mulpd  %xmm5,%xmm9
subpd  %xmm11,%xmm9
movapd %xmm9,%xmm1
unpckhpd %xmm9,%xmm1
movapd %xmm9,%xmm3
minsd  %xmm1,%xmm3
movapd 0x10(%rsp),%xmm4
mulsd  %xmm4,%xmm10
mulsd  0x50(%rsp),%xmm12
addsd  %xmm10,%xmm12
ucomisd %xmm12,%xmm3
ja     184d <triBoxOverlap+0x73d>
maxsd  %xmm9,%xmm1
xorpd  %xmm2,%xmm12
ucomisd %xmm1,%xmm12
ja     184d <triBoxOverlap+0x73d>
movapd %xmm5,0x90(%rsp)
movapd %xmm7,0x80(%rsp)
movapd %xmm0,0x70(%rsp)
movapd %xmm15,%xmm12
movapd %xmm4,%xmm7
movapd 0x30(%rsp),%xmm11
subsd  %xmm11,%xmm12
movapd %xmm8,%xmm0
unpckhpd %xmm11,%xmm0
movapd 0x20(%rsp),%xmm3
subpd  %xmm0,%xmm3
movapd %xmm12,%xmm0
movapd 0xc19(%rip),%xmm2
andpd  %xmm2,%xmm0
movapd %xmm3,%xmm9
movapd %xmm3,%xmm1
unpckhpd %xmm3,%xmm1
movapd %xmm1,%xmm10
andpd  %xmm2,%xmm10
movapd %xmm12,%xmm2
unpcklpd %xmm12,%xmm2
movapd %xmm14,%xmm3
mulpd  %xmm2,%xmm3
mulpd  %xmm1,%xmm13
subpd  %xmm3,%xmm13
movapd %xmm13,%xmm3
unpckhpd %xmm13,%xmm3
movapd %xmm0,%xmm5
mulsd  (%rsp),%xmm5
movapd %xmm10,%xmm4
mulsd  %xmm7,%xmm4
addsd  %xmm5,%xmm4
movapd %xmm13,%xmm5
minsd  %xmm3,%xmm5
ucomisd %xmm4,%xmm5
ja     184d <triBoxOverlap+0x73d>
maxsd  %xmm13,%xmm3
xorpd  0xbb1(%rip),%xmm4
ucomisd %xmm3,%xmm4
ja     184d <triBoxOverlap+0x73d>
movapd %xmm6,0x60(%rsp)
movapd %xmm9,%xmm13
andpd  0xb83(%rip),%xmm13
movapd %xmm9,%xmm3
unpcklpd %xmm9,%xmm3
mulpd  %xmm14,%xmm3
unpcklpd %xmm1,%xmm1
mulpd  0xc0(%rsp),%xmm1
subpd  %xmm1,%xmm3
movapd %xmm3,%xmm1
unpckhpd %xmm3,%xmm1
movapd %xmm3,%xmm4
minsd  %xmm1,%xmm4
movapd %xmm13,%xmm5
mulsd  (%rsp),%xmm5
movapd 0x50(%rsp),%xmm6
mulsd  %xmm6,%xmm10
addsd  %xmm5,%xmm10
ucomisd %xmm10,%xmm4
ja     184d <triBoxOverlap+0x73d>
maxsd  %xmm3,%xmm1
xorpd  0xb31(%rip),%xmm10
ucomisd %xmm1,%xmm10
ja     184d <triBoxOverlap+0x73d>
movapd %xmm9,%xmm7
movapd 0x40(%rsp),%xmm5
movapd %xmm5,%xmm1
unpcklpd %xmm11,%xmm1
movapd %xmm9,%xmm3
unpcklpd %xmm7,%xmm3
mulpd  %xmm1,%xmm3
mulpd  %xmm8,%xmm2
subpd  %xmm3,%xmm2
movapd %xmm2,%xmm3
unpckhpd %xmm2,%xmm3
movapd %xmm2,%xmm4
minsd  %xmm3,%xmm4
mulsd  0x10(%rsp),%xmm13
mulsd  %xmm6,%xmm0
addsd  %xmm13,%xmm0
ucomisd %xmm0,%xmm4
ja     184d <triBoxOverlap+0x73d>
maxsd  %xmm2,%xmm3
xorpd  0xac6(%rip),%xmm0
ucomisd %xmm3,%xmm0
ja     184d <triBoxOverlap+0x73d>
movapd %xmm12,%xmm14
movapd %xmm5,%xmm10
subsd  %xmm15,%xmm10
movapd %xmm11,%xmm2
movapd %xmm5,%xmm11
unpckhpd %xmm5,%xmm11
movapd 0x20(%rsp),%xmm7
unpckhpd %xmm7,%xmm7
movapd %xmm11,%xmm3
subsd  %xmm7,%xmm3
movapd %xmm10,%xmm13
movapd 0xa6e(%rip),%xmm0
andpd  %xmm0,%xmm13
movapd %xmm3,%xmm12
andpd  %xmm0,%xmm12
movsd  %xmm11,%xmm2
unpcklpd %xmm10,%xmm10
movapd %xmm2,%xmm0
mulpd  %xmm10,%xmm0
unpcklpd %xmm3,%xmm3
mulpd  %xmm3,%xmm1
subpd  %xmm0,%xmm1
movapd %xmm1,%xmm4
unpckhpd %xmm1,%xmm4
movapd %xmm13,%xmm5
mulsd  (%rsp),%xmm5
movapd %xmm12,%xmm0
mulsd  0x10(%rsp),%xmm0
addsd  %xmm5,%xmm0
movapd %xmm1,%xmm5
minsd  %xmm4,%xmm5
ucomisd %xmm0,%xmm5
ja     184d <triBoxOverlap+0x73d>
maxsd  %xmm1,%xmm4
xorpd  0xa11(%rip),%xmm0
ucomisd %xmm4,%xmm0
ja     184d <triBoxOverlap+0x73d>
movapd %xmm8,%xmm1
subpd  0x20(%rsp),%xmm1
movapd 0x9e4(%rip),%xmm4
andpd  %xmm1,%xmm4
movapd %xmm1,%xmm0
unpcklpd %xmm1,%xmm0
mulpd  %xmm0,%xmm2
mulpd  %xmm8,%xmm3
subpd  %xmm3,%xmm2
movapd %xmm2,%xmm3
unpckhpd %xmm2,%xmm3
movapd %xmm2,%xmm0
minsd  %xmm3,%xmm0
movapd %xmm4,%xmm5
mulsd  (%rsp),%xmm4
mulsd  %xmm6,%xmm12
addsd  %xmm4,%xmm12
ucomisd %xmm12,%xmm0
ja     184d <triBoxOverlap+0x73d>
maxsd  %xmm2,%xmm3
xorpd  0x9a0(%rip),%xmm12
ucomisd %xmm3,%xmm12
ja     184d <triBoxOverlap+0x73d>
unpcklpd %xmm1,%xmm1
movapd 0x60(%rsp),%xmm0
mulpd  %xmm1,%xmm0
mulpd  0x90(%rsp),%xmm10
subpd  %xmm0,%xmm10
movapd %xmm10,%xmm0
unpckhpd %xmm10,%xmm0
movapd %xmm10,%xmm1
minsd  %xmm0,%xmm1
mulsd  0x10(%rsp),%xmm5
mulsd  %xmm6,%xmm13
addsd  %xmm5,%xmm13
ucomisd %xmm13,%xmm1
ja     184d <triBoxOverlap+0x73d>
maxsd  %xmm10,%xmm0
xorpd  0x93c(%rip),%xmm13
ucomisd %xmm0,%xmm13
ja     184d <triBoxOverlap+0x73d>
movapd 0x80(%rsp),%xmm3
movapd %xmm3,%xmm0
minsd  %xmm8,%xmm0
movapd 0x20(%rsp),%xmm2
movapd %xmm2,%xmm1
minsd  %xmm0,%xmm1
ucomisd %xmm6,%xmm1
ja     184d <triBoxOverlap+0x73d>
maxsd  %xmm8,%xmm3
maxsd  %xmm3,%xmm2
xorpd  0x8f6(%rip),%xmm6
ucomisd %xmm2,%xmm6
ja     184d <triBoxOverlap+0x73d>
movapd 0x30(%rsp),%xmm2
movapd %xmm2,%xmm0
movapd 0x40(%rsp),%xmm3
minsd  %xmm3,%xmm0
movapd %xmm15,%xmm1
minsd  %xmm0,%xmm1
movapd 0x10(%rsp),%xmm4
ucomisd %xmm4,%xmm1
ja     184d <triBoxOverlap+0x73d>
movapd %xmm2,%xmm0
maxsd  %xmm3,%xmm0
maxsd  %xmm0,%xmm15
xorpd  0x8aa(%rip),%xmm4
ucomisd %xmm15,%xmm4
ja     184d <triBoxOverlap+0x73d>
unpckhpd %xmm2,%xmm2
movapd %xmm2,%xmm0
minsd  %xmm11,%xmm0
movapd %xmm7,%xmm1
minsd  %xmm0,%xmm1
movapd (%rsp),%xmm0
ucomisd %xmm0,%xmm1
ja     184d <triBoxOverlap+0x73d>
maxsd  %xmm11,%xmm2
maxsd  %xmm2,%xmm7
xorpd  0x86a(%rip),%xmm0
ucomisd %xmm7,%xmm0
ja     184d <triBoxOverlap+0x73d>
movapd %xmm9,%xmm5
movapd %xmm9,%xmm0
shufpd $0x1,%xmm9,%xmm0
movapd 0xb0(%rsp),%xmm3
movapd %xmm3,%xmm1
movapd 0x83b(%rip),%xmm4
xorpd  %xmm4,%xmm1
movapd 0xa0(%rsp),%xmm6
xorpd  %xmm4,%xmm6
movapd 0x70(%rsp),%xmm9
xorpd  %xmm9,%xmm4
movapd %xmm5,%xmm2
movsd  %xmm14,%xmm2
unpcklpd %xmm4,%xmm6
mulpd  %xmm2,%xmm6
mulpd  %xmm3,%xmm0
addpd  %xmm6,%xmm0
movapd %xmm0,0xe0(%rsp)
mulsd  %xmm5,%xmm1
mulsd  %xmm14,%xmm9
addsd  %xmm1,%xmm9
movsd  %xmm9,0xf0(%rsp)
lea    0xe0(%rsp),%rdi
lea    0x100(%rsp),%rsi
mov    %rcx,%rdx
call   1030 <planeBoxOverlap@plt>
mov    %eax,%ecx
xor    %eax,%eax
test   %ecx,%ecx
setne  %al
add    $0x118,%rsp
ret

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