#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 fabs(double);
double sqrt(double);
int find_point_depth(double fp[3][3], double point_o[3], double view_point_d[3],
                     double n_f[4], double point[3], int normal_flag) {
  int i, j, flag_inside;
  double v_f[3], t, n_norm, v_norm, nv_sign;
  flag_inside = 0;
  if (normal_flag == 1) {
    n_f[0] = (fp[1][1] - fp[0][1]) * (fp[2][2] - fp[0][2]) -
             (fp[2][1] - fp[0][1]) * (fp[1][2] - fp[0][2]);
    n_f[1] = -(fp[1][0] - fp[0][0]) * (fp[2][2] - fp[0][2]) +
             (fp[2][0] - fp[0][0]) * (fp[1][2] - fp[0][2]);
    n_f[2] = (fp[1][0] - fp[0][0]) * (fp[2][1] - fp[0][1]) -
             (fp[2][0] - fp[0][0]) * (fp[1][1] - fp[0][1]);
    n_norm = sqrt(n_f[0] * n_f[0] + n_f[1] * n_f[1] + n_f[2] * n_f[2]);
    if (fabs(n_norm) > 0.00000001) {
      for (j = 0; j < 3; j++)
        n_f[j] /= n_norm;
    }
  }
  for (i = 0; i < 3; i++)
    v_f[i] = view_point_d[i] - point_o[i];
  v_norm = sqrt(v_f[0] * v_f[0] + v_f[1] * v_f[1] + v_f[2] * v_f[2]);
  if (fabs(v_norm) > 0.00000001) {
    for (i = 0; i < 3; i++)
      v_f[i] /= v_norm;
  }
  nv_sign = n_f[0] * v_f[0] + n_f[1] * v_f[1] + n_f[2] * v_f[2];
  if (nv_sign < 0.0) {
    for (i = 0; i < 3; i++)
      n_f[i] = -n_f[i];
  }
  if (normal_flag == 1)
    n_f[3] = -n_f[0] * fp[0][0] - n_f[1] * fp[0][1] - n_f[2] * fp[0][2];
  if (fabs(n_f[0] * (point_o[0] - view_point_d[0]) +
           n_f[1] * (point_o[1] - view_point_d[1]) +
           n_f[2] * (point_o[2] - view_point_d[2])) > 0.00000001) {
    t = (-n_f[3] - n_f[0] * view_point_d[0] - n_f[1] * view_point_d[1] -
         n_f[2] * view_point_d[2]) /
        (n_f[0] * (point_o[0] - view_point_d[0]) +
         n_f[1] * (point_o[1] - view_point_d[1]) +
         n_f[2] * (point_o[2] - view_point_d[2]));
    if (t > -0.00000001) {
      for (j = 0; j < 3; j++)
        point[j] = view_point_d[j] + t * (point_o[j] - view_point_d[j]);
      flag_inside = 1;
    }
  }
  return (flag_inside);
}


x86 assembly (clang, -O0):
<find_point_depth>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9d,-0x2c(%rbp)
movl   $0x0,-0x38(%rbp)
cmpl   $0x1,-0x2c(%rbp)
jne    134c <find_point_depth+0x23c>
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm0
mov    -0x8(%rbp),%rax
subsd  0x8(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x40(%rax),%xmm2
mov    -0x8(%rbp),%rax
subsd  0x10(%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x38(%rax),%xmm1
mov    -0x8(%rbp),%rax
subsd  0x8(%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm3
mov    -0x8(%rbp),%rax
subsd  0x10(%rax),%xmm3
mulsd  %xmm3,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x8(%rbp),%rax
subsd  (%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x8(%rbp),%rax
movsd  0x40(%rax),%xmm2
mov    -0x8(%rbp),%rax
subsd  0x10(%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x30(%rax),%xmm1
mov    -0x8(%rbp),%rax
subsd  (%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x28(%rax),%xmm3
mov    -0x8(%rbp),%rax
subsd  0x10(%rax),%xmm3
mulsd  %xmm3,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x8(%rax)
mov    -0x8(%rbp),%rax
movsd  0x18(%rax),%xmm0
mov    -0x8(%rbp),%rax
subsd  (%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x38(%rax),%xmm2
mov    -0x8(%rbp),%rax
subsd  0x8(%rax),%xmm2
mov    -0x8(%rbp),%rax
movsd  0x30(%rax),%xmm1
mov    -0x8(%rbp),%rax
subsd  (%rax),%xmm1
mov    -0x8(%rbp),%rax
movsd  0x20(%rax),%xmm3
mov    -0x8(%rbp),%rax
subsd  0x8(%rax),%xmm3
mulsd  %xmm3,%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x10(%rax)
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x20(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x20(%rbp),%rax
mulsd  0x8(%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x20(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x20(%rbp),%rax
movsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1030 <sqrt@plt>
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
movaps 0xd1e(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  0xd02(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1347 <find_point_depth+0x237>
movl   $0x0,-0x34(%rbp)
cmpl   $0x3,-0x34(%rbp)
jge    1342 <find_point_depth+0x232>
movsd  -0x60(%rbp),%xmm1
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    130f <find_point_depth+0x1ff>
jmp    1347 <find_point_depth+0x237>
jmp    134c <find_point_depth+0x23c>
movl   $0x0,-0x30(%rbp)
cmpl   $0x3,-0x30(%rbp)
jge    138f <find_point_depth+0x27f>
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm0
movslq -0x30(%rbp),%rax
movsd  %xmm0,-0x50(%rbp,%rax,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1353 <find_point_depth+0x243>
movsd  -0x50(%rbp),%xmm1
movsd  -0x50(%rbp),%xmm2
movsd  -0x48(%rbp),%xmm0
mulsd  -0x48(%rbp),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x40(%rbp),%xmm0
movsd  -0x40(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1030 <sqrt@plt>
movsd  %xmm0,-0x68(%rbp)
movsd  -0x68(%rbp),%xmm0
movaps 0xc3d(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  0xc21(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1426 <find_point_depth+0x316>
movl   $0x0,-0x30(%rbp)
cmpl   $0x3,-0x30(%rbp)
jge    1421 <find_point_depth+0x311>
movsd  -0x68(%rbp),%xmm1
movslq -0x30(%rbp),%rax
movsd  -0x50(%rbp,%rax,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp,%rax,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    13f0 <find_point_depth+0x2e0>
jmp    1426 <find_point_depth+0x316>
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm1
movsd  -0x50(%rbp),%xmm2
mov    -0x20(%rbp),%rax
movsd  0x8(%rax),%xmm0
mulsd  -0x48(%rbp),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x20(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  -0x40(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
xorps  %xmm0,%xmm0
ucomisd -0x70(%rbp),%xmm0
jbe    14c7 <find_point_depth+0x3b7>
movl   $0x0,-0x30(%rbp)
cmpl   $0x3,-0x30(%rbp)
jge    14c2 <find_point_depth+0x3b2>
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1479 <find_point_depth+0x369>
jmp    14c7 <find_point_depth+0x3b7>
cmpl   $0x1,-0x2c(%rbp)
jne    1563 <find_point_depth+0x453>
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mov    -0x8(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x20(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x8(%rbp),%rax
mulsd  0x8(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x20(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x8(%rbp),%rax
movsd  0x10(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x18(%rax)
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x18(%rbp),%rax
subsd  (%rax),%xmm2
mov    -0x20(%rbp),%rax
movsd  0x8(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm3
mov    -0x18(%rbp),%rax
subsd  0x8(%rax),%xmm3
mulsd  %xmm3,%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x20(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
mov    -0x18(%rbp),%rax
subsd  0x10(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movaps 0xa44(%rip),%xmm1
pand   %xmm1,%xmm0
movsd  0xa28(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    1781 <find_point_depth+0x671>
mov    -0x20(%rbp),%rax
movsd  0x18(%rax),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  (%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x18(%rbp),%rax
movsd  0x8(%rax),%xmm2
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x20(%rbp),%rax
movsd  0x10(%rax),%xmm0
mov    -0x18(%rbp),%rax
movsd  0x10(%rax),%xmm2
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movsd  (%rax),%xmm2
mov    -0x10(%rbp),%rax
movsd  (%rax),%xmm3
mov    -0x18(%rbp),%rax
subsd  (%rax),%xmm3
mov    -0x20(%rbp),%rax
movsd  0x8(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm4
mov    -0x18(%rbp),%rax
subsd  0x8(%rax),%xmm4
mulsd  %xmm4,%xmm1
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
mov    -0x20(%rbp),%rax
movsd  0x10(%rax),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm3
mov    -0x18(%rbp),%rax
subsd  0x10(%rax),%xmm3
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x58(%rbp),%xmm0
movsd  0x8fd(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    177c <find_point_depth+0x66c>
movl   $0x0,-0x34(%rbp)
cmpl   $0x3,-0x34(%rbp)
jge    1775 <find_point_depth+0x665>
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x58(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    171c <find_point_depth+0x60c>
movl   $0x1,-0x38(%rbp)
jmp    1781 <find_point_depth+0x671>
mov    -0x38(%rbp),%eax
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<find_point_depth>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %r9d,%ebp
mov    %r8,%r14
mov    %rcx,%r13
mov    %rdx,%r15
mov    %rsi,%r12
mov    %rdi,%rbx
cmp    $0x1,%r9d
jne    1262 <find_point_depth+0x152>
movsd  0x20(%rbx),%xmm0
movsd  0x8(%rbx),%xmm2
movsd  0x10(%rbx),%xmm3
subsd  %xmm2,%xmm0
movsd  0x40(%rbx),%xmm1
subsd  %xmm3,%xmm1
mulsd  %xmm0,%xmm1
movsd  0x38(%rbx),%xmm0
subsd  %xmm2,%xmm0
movsd  0x28(%rbx),%xmm2
subsd  %xmm3,%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
movsd  %xmm1,0x0(%r13)
movsd  0x18(%rbx),%xmm0
movsd  (%rbx),%xmm2
movsd  0x10(%rbx),%xmm3
subsd  %xmm2,%xmm0
movsd  0x40(%rbx),%xmm4
subsd  %xmm3,%xmm4
mulsd  %xmm0,%xmm4
movupd 0x28(%rbx),%xmm0
unpcklpd %xmm2,%xmm3
subpd  %xmm3,%xmm0
movapd %xmm0,%xmm2
unpckhpd %xmm0,%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm4,%xmm2
movsd  %xmm2,0x8(%r13)
movsd  0x18(%rbx),%xmm3
movsd  (%rbx),%xmm4
movsd  0x8(%rbx),%xmm5
subsd  %xmm4,%xmm3
movsd  0x38(%rbx),%xmm0
subsd  %xmm5,%xmm0
mulsd  %xmm3,%xmm0
movsd  0x30(%rbx),%xmm3
subsd  %xmm4,%xmm3
movsd  0x20(%rbx),%xmm4
subsd  %xmm5,%xmm4
mulsd  %xmm3,%xmm4
subsd  %xmm4,%xmm0
movsd  %xmm0,0x10(%r13)
mulsd  %xmm2,%xmm2
mulsd  %xmm1,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     121f <find_point_depth+0x10f>
sqrtsd %xmm0,%xmm0
jmp    1224 <find_point_depth+0x114>
call   1030 <sqrt@plt>
movapd 0xdd4(%rip),%xmm1
andpd  %xmm0,%xmm1
ucomisd 0xde8(%rip),%xmm1
jbe    1262 <find_point_depth+0x152>
movupd 0x0(%r13),%xmm1
movapd %xmm0,%xmm2
unpcklpd %xmm0,%xmm2
divpd  %xmm2,%xmm1
movupd %xmm1,0x0(%r13)
movsd  0x10(%r13),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%r13)
movsd  (%r15),%xmm3
subsd  (%r12),%xmm3
movupd 0x8(%r15),%xmm4
movupd 0x8(%r12),%xmm0
subpd  %xmm0,%xmm4
movapd %xmm4,%xmm0
mulsd  %xmm4,%xmm0
movapd %xmm3,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm0,%xmm1
movapd %xmm4,%xmm0
unpckhpd %xmm4,%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     12b2 <find_point_depth+0x1a2>
sqrtsd %xmm0,%xmm0
jmp    12cf <find_point_depth+0x1bf>
movsd  %xmm3,0x8(%rsp)
movapd %xmm4,0x10(%rsp)
call   1030 <sqrt@plt>
movapd 0x10(%rsp),%xmm4
movsd  0x8(%rsp),%xmm3
movapd 0xd29(%rip),%xmm1
andpd  %xmm0,%xmm1
ucomisd 0xd3d(%rip),%xmm1
jbe    12f1 <find_point_depth+0x1e1>
divsd  %xmm0,%xmm3
unpcklpd %xmm0,%xmm0
divpd  %xmm0,%xmm4
movupd 0x0(%r13),%xmm2
movapd %xmm2,%xmm5
unpckhpd %xmm2,%xmm5
movapd %xmm5,%xmm1
mulsd  %xmm4,%xmm1
mulsd  %xmm2,%xmm3
addsd  %xmm1,%xmm3
movsd  0x10(%r13),%xmm1
unpckhpd %xmm4,%xmm4
mulsd  %xmm1,%xmm4
addsd  %xmm3,%xmm4
xorpd  %xmm3,%xmm3
ucomisd %xmm4,%xmm3
jbe    134c <find_point_depth+0x23c>
movapd 0xcdd(%rip),%xmm0
xorpd  %xmm0,%xmm2
movupd %xmm2,0x0(%r13)
xorpd  %xmm0,%xmm1
movlpd %xmm1,0x10(%r13)
pshufd $0xee,%xmm2,%xmm5
cmp    $0x1,%ebp
jne    1381 <find_point_depth+0x271>
movapd 0xcb7(%rip),%xmm3
xorpd  %xmm2,%xmm3
movsd  0x8(%rbx),%xmm4
mulsd  %xmm5,%xmm4
mulsd  (%rbx),%xmm3
subsd  %xmm4,%xmm3
movsd  0x10(%rbx),%xmm4
mulsd  %xmm1,%xmm4
subsd  %xmm4,%xmm3
movsd  %xmm3,0x18(%r13)
movsd  (%r15),%xmm8
movsd  0x8(%r15),%xmm3
movsd  (%r12),%xmm4
movsd  0x8(%r12),%xmm6
subsd  %xmm8,%xmm4
subsd  %xmm3,%xmm6
mulsd  %xmm5,%xmm6
movapd %xmm2,%xmm0
mulsd  %xmm4,%xmm0
addsd  %xmm6,%xmm0
movsd  0x10(%r12),%xmm6
movsd  0x10(%r15),%xmm7
subsd  %xmm7,%xmm6
mulsd  %xmm1,%xmm6
addsd  %xmm0,%xmm6
movapd 0xc2d(%rip),%xmm0
andpd  %xmm6,%xmm0
xor    %eax,%eax
ucomisd 0xc3f(%rip),%xmm0
jbe    1469 <find_point_depth+0x359>
xorpd  0xc21(%rip),%xmm2
mulsd  %xmm8,%xmm2
subsd  0x18(%r13),%xmm2
mulsd  %xmm3,%xmm5
subsd  %xmm5,%xmm2
mulsd  %xmm7,%xmm1
subsd  %xmm1,%xmm2
divsd  %xmm6,%xmm2
ucomisd 0xc12(%rip),%xmm2
jbe    1469 <find_point_depth+0x359>
mulsd  %xmm2,%xmm4
addsd  %xmm8,%xmm4
movsd  %xmm4,(%r14)
movsd  0x8(%r15),%xmm0
movsd  0x8(%r12),%xmm1
subsd  %xmm0,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x8(%r14)
movsd  0x10(%r15),%xmm0
movsd  0x10(%r12),%xmm1
subsd  %xmm0,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,0x10(%r14)
mov    $0x1,%eax
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define i32 @find_point_depth([3 x double]* %0, double* %1, double* %2, double* %3, double* %4, i32 %5) {
%7 = alloca [3 x double]*
%8 = alloca double*
%9 = alloca double*
%10 = alloca double*
%11 = alloca double*
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca [3 x double]
%17 = alloca double
%18 = alloca double
%19 = alloca double
%20 = alloca double
store [3 x double]* %0, [3 x double]** %7
store double* %1, double** %8
store double* %2, double** %9
store double* %3, double** %10
store double* %4, double** %11
store i32 %5, i32* %12
store i32 0, i32* %15
%21 = load i32, i32* %12
%22 = icmp eq i32 %21, 1
br i1 %22, label %23, label %189
23: ; preds = %6
%24 = load [3 x double]*, [3 x double]** %7
%25 = getelementptr inbounds [3 x double], [3 x double]* %24, i64 1
%26 = getelementptr inbounds [3 x double], [3 x double]* %25, i64 0, i64 1
%27 = load double, double* %26
%28 = load [3 x double]*, [3 x double]** %7
%29 = getelementptr inbounds [3 x double], [3 x double]* %28, i64 0
%30 = getelementptr inbounds [3 x double], [3 x double]* %29, i64 0, i64 1
%31 = load double, double* %30
%32 = fsub double %27, %31
%33 = load [3 x double]*, [3 x double]** %7
%34 = getelementptr inbounds [3 x double], [3 x double]* %33, i64 2
%35 = getelementptr inbounds [3 x double], [3 x double]* %34, i64 0, i64 2
%36 = load double, double* %35
%37 = load [3 x double]*, [3 x double]** %7
%38 = getelementptr inbounds [3 x double], [3 x double]* %37, i64 0
%39 = getelementptr inbounds [3 x double], [3 x double]* %38, i64 0, i64 2
%40 = load double, double* %39
%41 = fsub double %36, %40
%42 = load [3 x double]*, [3 x double]** %7
%43 = getelementptr inbounds [3 x double], [3 x double]* %42, i64 2
%44 = getelementptr inbounds [3 x double], [3 x double]* %43, i64 0, i64 1
%45 = load double, double* %44
%46 = load [3 x double]*, [3 x double]** %7
%47 = getelementptr inbounds [3 x double], [3 x double]* %46, i64 0
%48 = getelementptr inbounds [3 x double], [3 x double]* %47, i64 0, i64 1
%49 = load double, double* %48
%50 = fsub double %45, %49
%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 2
%54 = load double, double* %53
%55 = load [3 x double]*, [3 x double]** %7
%56 = getelementptr inbounds [3 x double], [3 x double]* %55, i64 0
%57 = getelementptr inbounds [3 x double], [3 x double]* %56, i64 0, i64 2
%58 = load double, double* %57
%59 = fsub double %54, %58
%60 = fmul double %50, %59
%61 = fneg double %60
%62 = call double @llvm.fmuladd.f64(double %32, double %41, double %61)
%63 = load double*, double** %10
%64 = getelementptr inbounds double, double* %63, i64 0
store double %62, double* %64
%65 = load [3 x double]*, [3 x double]** %7
%66 = getelementptr inbounds [3 x double], [3 x double]* %65, i64 1
%67 = getelementptr inbounds [3 x double], [3 x double]* %66, i64 0, i64 0
%68 = load double, double* %67
%69 = load [3 x double]*, [3 x double]** %7
%70 = getelementptr inbounds [3 x double], [3 x double]* %69, i64 0
%71 = getelementptr inbounds [3 x double], [3 x double]* %70, i64 0, i64 0
%72 = load double, double* %71
%73 = fsub double %68, %72
%74 = fneg double %73
%75 = load [3 x double]*, [3 x double]** %7
%76 = getelementptr inbounds [3 x double], [3 x double]* %75, i64 2
%77 = getelementptr inbounds [3 x double], [3 x double]* %76, i64 0, i64 2
%78 = load double, double* %77
%79 = load [3 x double]*, [3 x double]** %7
%80 = getelementptr inbounds [3 x double], [3 x double]* %79, i64 0
%81 = getelementptr inbounds [3 x double], [3 x double]* %80, i64 0, i64 2
%82 = load double, double* %81
%83 = fsub double %78, %82
%84 = load [3 x double]*, [3 x double]** %7
%85 = getelementptr inbounds [3 x double], [3 x double]* %84, i64 2
%86 = getelementptr inbounds [3 x double], [3 x double]* %85, i64 0, i64 0
%87 = load double, double* %86
%88 = load [3 x double]*, [3 x double]** %7
%89 = getelementptr inbounds [3 x double], [3 x double]* %88, i64 0
%90 = getelementptr inbounds [3 x double], [3 x double]* %89, i64 0, i64 0
%91 = load double, double* %90
%92 = fsub double %87, %91
%93 = load [3 x double]*, [3 x double]** %7
%94 = getelementptr inbounds [3 x double], [3 x double]* %93, i64 1
%95 = getelementptr inbounds [3 x double], [3 x double]* %94, i64 0, i64 2
%96 = load double, double* %95
%97 = load [3 x double]*, [3 x double]** %7
%98 = getelementptr inbounds [3 x double], [3 x double]* %97, i64 0
%99 = getelementptr inbounds [3 x double], [3 x double]* %98, i64 0, i64 2
%100 = load double, double* %99
%101 = fsub double %96, %100
%102 = fmul double %92, %101
%103 = call double @llvm.fmuladd.f64(double %74, double %83, double %102)
%104 = load double*, double** %10
%105 = getelementptr inbounds double, double* %104, i64 1
store double %103, double* %105
%106 = load [3 x double]*, [3 x double]** %7
%107 = getelementptr inbounds [3 x double], [3 x double]* %106, i64 1
%108 = getelementptr inbounds [3 x double], [3 x double]* %107, i64 0, i64 0
%109 = load double, double* %108
%110 = load [3 x double]*, [3 x double]** %7
%111 = getelementptr inbounds [3 x double], [3 x double]* %110, i64 0
%112 = getelementptr inbounds [3 x double], [3 x double]* %111, i64 0, i64 0
%113 = load double, double* %112
%114 = fsub double %109, %113
%115 = load [3 x double]*, [3 x double]** %7
%116 = getelementptr inbounds [3 x double], [3 x double]* %115, i64 2
%117 = getelementptr inbounds [3 x double], [3 x double]* %116, i64 0, i64 1
%118 = load double, double* %117
%119 = load [3 x double]*, [3 x double]** %7
%120 = getelementptr inbounds [3 x double], [3 x double]* %119, i64 0
%121 = getelementptr inbounds [3 x double], [3 x double]* %120, i64 0, i64 1
%122 = load double, double* %121
%123 = fsub double %118, %122
%124 = load [3 x double]*, [3 x double]** %7
%125 = getelementptr inbounds [3 x double], [3 x double]* %124, i64 2
%126 = getelementptr inbounds [3 x double], [3 x double]* %125, i64 0, i64 0
%127 = load double, double* %126
%128 = load [3 x double]*, [3 x double]** %7
%129 = getelementptr inbounds [3 x double], [3 x double]* %128, i64 0
%130 = getelementptr inbounds [3 x double], [3 x double]* %129, i64 0, i64 0
%131 = load double, double* %130
%132 = fsub double %127, %131
%133 = load [3 x double]*, [3 x double]** %7
%134 = getelementptr inbounds [3 x double], [3 x double]* %133, i64 1
%135 = getelementptr inbounds [3 x double], [3 x double]* %134, i64 0, i64 1
%136 = load double, double* %135
%137 = load [3 x double]*, [3 x double]** %7
%138 = getelementptr inbounds [3 x double], [3 x double]* %137, i64 0
%139 = getelementptr inbounds [3 x double], [3 x double]* %138, i64 0, i64 1
%140 = load double, double* %139
%141 = fsub double %136, %140
%142 = fmul double %132, %141
%143 = fneg double %142
%144 = call double @llvm.fmuladd.f64(double %114, double %123, double %143)
%145 = load double*, double** %10
%146 = getelementptr inbounds double, double* %145, i64 2
store double %144, double* %146
%147 = load double*, double** %10
%148 = getelementptr inbounds double, double* %147, i64 0
%149 = load double, double* %148
%150 = load double*, double** %10
%151 = getelementptr inbounds double, double* %150, i64 0
%152 = load double, double* %151
%153 = load double*, double** %10
%154 = getelementptr inbounds double, double* %153, i64 1
%155 = load double, double* %154
%156 = load double*, double** %10
%157 = getelementptr inbounds double, double* %156, i64 1
%158 = load double, double* %157
%159 = fmul double %155, %158
%160 = call double @llvm.fmuladd.f64(double %149, double %152, double %159)
%161 = load double*, double** %10
%162 = getelementptr inbounds double, double* %161, i64 2
%163 = load double, double* %162
%164 = load double*, double** %10
%165 = getelementptr inbounds double, double* %164, i64 2
%166 = load double, double* %165
%167 = call double @llvm.fmuladd.f64(double %163, double %166, double %160)
%168 = call double @sqrt(double %167)
store double %168, double* %18
%169 = load double, double* %18
%170 = call double @llvm.fabs.f64(double %169)
%171 = fcmp ogt double %170, 1.000000e-08
br i1 %171, label %172, label %188
172: ; preds = %23
store i32 0, i32* %14
br label %173
173: ; preds = %184, %172
%174 = load i32, i32* %14
%175 = icmp slt i32 %174, 3
br i1 %175, label %176, label %187
176: ; preds = %173
%177 = load double, double* %18
%178 = load double*, double** %10
%179 = load i32, i32* %14
%180 = sext i32 %179 to i64
%181 = getelementptr inbounds double, double* %178, i64 %180
%182 = load double, double* %181
%183 = fdiv double %182, %177
store double %183, double* %181
br label %184
184: ; preds = %176
%185 = load i32, i32* %14
%186 = add nsw i32 %185, 1
store i32 %186, i32* %14
br label %173
187: ; preds = %173
br label %188
188: ; preds = %187, %23
br label %189
189: ; preds = %188, %6
store i32 0, i32* %13
br label %190
190: ; preds = %208, %189
%191 = load i32, i32* %13
%192 = icmp slt i32 %191, 3
br i1 %192, label %193, label %211
193: ; preds = %190
%194 = load double*, double** %9
%195 = load i32, i32* %13
%196 = sext i32 %195 to i64
%197 = getelementptr inbounds double, double* %194, i64 %196
%198 = load double, double* %197
%199 = load double*, double** %8
%200 = load i32, i32* %13
%201 = sext i32 %200 to i64
%202 = getelementptr inbounds double, double* %199, i64 %201
%203 = load double, double* %202
%204 = fsub double %198, %203
%205 = load i32, i32* %13
%206 = sext i32 %205 to i64
%207 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 %206
store double %204, double* %207
br label %208
208: ; preds = %193
%209 = load i32, i32* %13
%210 = add nsw i32 %209, 1
store i32 %210, i32* %13
br label %190
211: ; preds = %190
%212 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 0
%213 = load double, double* %212
%214 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 0
%215 = load double, double* %214
%216 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 1
%217 = load double, double* %216
%218 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 1
%219 = load double, double* %218
%220 = fmul double %217, %219
%221 = call double @llvm.fmuladd.f64(double %213, double %215, double %220)
%222 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 2
%223 = load double, double* %222
%224 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 2
%225 = load double, double* %224
%226 = call double @llvm.fmuladd.f64(double %223, double %225, double %221)
%227 = call double @sqrt(double %226)
store double %227, double* %19
%228 = load double, double* %19
%229 = call double @llvm.fabs.f64(double %228)
%230 = fcmp ogt double %229, 1.000000e-08
br i1 %230, label %231, label %246
231: ; preds = %211
store i32 0, i32* %13
br label %232
232: ; preds = %242, %231
%233 = load i32, i32* %13
%234 = icmp slt i32 %233, 3
br i1 %234, label %235, label %245
235: ; preds = %232
%236 = load double, double* %19
%237 = load i32, i32* %13
%238 = sext i32 %237 to i64
%239 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 %238
%240 = load double, double* %239
%241 = fdiv double %240, %236
store double %241, double* %239
br label %242
242: ; preds = %235
%243 = load i32, i32* %13
%244 = add nsw i32 %243, 1
store i32 %244, i32* %13
br label %232
245: ; preds = %232
br label %246
246: ; preds = %245, %211
%247 = load double*, double** %10
%248 = getelementptr inbounds double, double* %247, i64 0
%249 = load double, double* %248
%250 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 0
%251 = load double, double* %250
%252 = load double*, double** %10
%253 = getelementptr inbounds double, double* %252, i64 1
%254 = load double, double* %253
%255 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 1
%256 = load double, double* %255
%257 = fmul double %254, %256
%258 = call double @llvm.fmuladd.f64(double %249, double %251, double %257)
%259 = load double*, double** %10
%260 = getelementptr inbounds double, double* %259, i64 2
%261 = load double, double* %260
%262 = getelementptr inbounds [3 x double], [3 x double]* %16, i64 0, i64 2
%263 = load double, double* %262
%264 = call double @llvm.fmuladd.f64(double %261, double %263, double %258)
store double %264, double* %20
%265 = load double, double* %20
%266 = fcmp olt double %265, 0.000000e+00
br i1 %266, label %267, label %286
267: ; preds = %246
store i32 0, i32* %13
br label %268
268: ; preds = %282, %267
%269 = load i32, i32* %13
%270 = icmp slt i32 %269, 3
br i1 %270, label %271, label %285
271: ; preds = %268
%272 = load double*, double** %10
%273 = load i32, i32* %13
%274 = sext i32 %273 to i64
%275 = getelementptr inbounds double, double* %272, i64 %274
%276 = load double, double* %275
%277 = fneg double %276
%278 = load double*, double** %10
%279 = load i32, i32* %13
%280 = sext i32 %279 to i64
%281 = getelementptr inbounds double, double* %278, i64 %280
store double %277, double* %281
br label %282
282: ; preds = %271
%283 = load i32, i32* %13
%284 = add nsw i32 %283, 1
store i32 %284, i32* %13
br label %268
285: ; preds = %268
br label %286
286: ; preds = %285, %246
%287 = load i32, i32* %12
%288 = icmp eq i32 %287, 1
br i1 %288, label %289, label %319
289: ; preds = %286
%290 = load double*, double** %10
%291 = getelementptr inbounds double, double* %290, i64 0
%292 = load double, double* %291
%293 = fneg double %292
%294 = load [3 x double]*, [3 x double]** %7
%295 = getelementptr inbounds [3 x double], [3 x double]* %294, i64 0
%296 = getelementptr inbounds [3 x double], [3 x double]* %295, i64 0, i64 0
%297 = load double, double* %296
%298 = load double*, double** %10
%299 = getelementptr inbounds double, double* %298, i64 1
%300 = load double, double* %299
%301 = load [3 x double]*, [3 x double]** %7
%302 = getelementptr inbounds [3 x double], [3 x double]* %301, i64 0
%303 = getelementptr inbounds [3 x double], [3 x double]* %302, i64 0, i64 1
%304 = load double, double* %303
%305 = fmul double %300, %304
%306 = fneg double %305
%307 = call double @llvm.fmuladd.f64(double %293, double %297, double %306)
%308 = load double*, double** %10
%309 = getelementptr inbounds double, double* %308, i64 2
%310 = load double, double* %309
%311 = load [3 x double]*, [3 x double]** %7
%312 = getelementptr inbounds [3 x double], [3 x double]* %311, i64 0
%313 = getelementptr inbounds [3 x double], [3 x double]* %312, i64 0, i64 2
%314 = load double, double* %313
%315 = fneg double %310
%316 = call double @llvm.fmuladd.f64(double %315, double %314, double %307)
%317 = load double*, double** %10
%318 = getelementptr inbounds double, double* %317, i64 3
store double %316, double* %318
br label %319
319: ; preds = %289, %286
%320 = load double*, double** %10
%321 = getelementptr inbounds double, double* %320, i64 0
%322 = load double, double* %321
%323 = load double*, double** %8
%324 = getelementptr inbounds double, double* %323, i64 0
%325 = load double, double* %324
%326 = load double*, double** %9
%327 = getelementptr inbounds double, double* %326, i64 0
%328 = load double, double* %327
%329 = fsub double %325, %328
%330 = load double*, double** %10
%331 = getelementptr inbounds double, double* %330, i64 1
%332 = load double, double* %331
%333 = load double*, double** %8
%334 = getelementptr inbounds double, double* %333, i64 1
%335 = load double, double* %334
%336 = load double*, double** %9
%337 = getelementptr inbounds double, double* %336, i64 1
%338 = load double, double* %337
%339 = fsub double %335, %338
%340 = fmul double %332, %339
%341 = call double @llvm.fmuladd.f64(double %322, double %329, double %340)
%342 = load double*, double** %10
%343 = getelementptr inbounds double, double* %342, i64 2
%344 = load double, double* %343
%345 = load double*, double** %8
%346 = getelementptr inbounds double, double* %345, i64 2
%347 = load double, double* %346
%348 = load double*, double** %9
%349 = getelementptr inbounds double, double* %348, i64 2
%350 = load double, double* %349
%351 = fsub double %347, %350
%352 = call double @llvm.fmuladd.f64(double %344, double %351, double %341)
%353 = call double @llvm.fabs.f64(double %352)
%354 = fcmp ogt double %353, 1.000000e-08
br i1 %354, label %355, label %452
355: ; preds = %319
%356 = load double*, double** %10
%357 = getelementptr inbounds double, double* %356, i64 3
%358 = load double, double* %357
%359 = fneg double %358
%360 = load double*, double** %10
%361 = getelementptr inbounds double, double* %360, i64 0
%362 = load double, double* %361
%363 = load double*, double** %9
%364 = getelementptr inbounds double, double* %363, i64 0
%365 = load double, double* %364
%366 = fneg double %362
%367 = call double @llvm.fmuladd.f64(double %366, double %365, double %359)
%368 = load double*, double** %10
%369 = getelementptr inbounds double, double* %368, i64 1
%370 = load double, double* %369
%371 = load double*, double** %9
%372 = getelementptr inbounds double, double* %371, i64 1
%373 = load double, double* %372
%374 = fneg double %370
%375 = call double @llvm.fmuladd.f64(double %374, double %373, double %367)
%376 = load double*, double** %10
%377 = getelementptr inbounds double, double* %376, i64 2
%378 = load double, double* %377
%379 = load double*, double** %9
%380 = getelementptr inbounds double, double* %379, i64 2
%381 = load double, double* %380
%382 = fneg double %378
%383 = call double @llvm.fmuladd.f64(double %382, double %381, double %375)
%384 = load double*, double** %10
%385 = getelementptr inbounds double, double* %384, i64 0
%386 = load double, double* %385
%387 = load double*, double** %8
%388 = getelementptr inbounds double, double* %387, i64 0
%389 = load double, double* %388
%390 = load double*, double** %9
%391 = getelementptr inbounds double, double* %390, i64 0
%392 = load double, double* %391
%393 = fsub double %389, %392
%394 = load double*, double** %10
%395 = getelementptr inbounds double, double* %394, i64 1
%396 = load double, double* %395
%397 = load double*, double** %8
%398 = getelementptr inbounds double, double* %397, i64 1
%399 = load double, double* %398
%400 = load double*, double** %9
%401 = getelementptr inbounds double, double* %400, i64 1
%402 = load double, double* %401
%403 = fsub double %399, %402
%404 = fmul double %396, %403
%405 = call double @llvm.fmuladd.f64(double %386, double %393, double %404)
%406 = load double*, double** %10
%407 = getelementptr inbounds double, double* %406, i64 2
%408 = load double, double* %407
%409 = load double*, double** %8
%410 = getelementptr inbounds double, double* %409, i64 2
%411 = load double, double* %410
%412 = load double*, double** %9
%413 = getelementptr inbounds double, double* %412, i64 2
%414 = load double, double* %413
%415 = fsub double %411, %414
%416 = call double @llvm.fmuladd.f64(double %408, double %415, double %405)
%417 = fdiv double %383, %416
store double %417, double* %17
%418 = load double, double* %17
%419 = fcmp ogt double %418, -1.000000e-08
br i1 %419, label %420, label %451
420: ; preds = %355
store i32 0, i32* %14
br label %421
421: ; preds = %447, %420
%422 = load i32, i32* %14
%423 = icmp slt i32 %422, 3
br i1 %423, label %424, label %450
424: ; preds = %421
%425 = load double*, double** %9
%426 = load i32, i32* %14
%427 = sext i32 %426 to i64
%428 = getelementptr inbounds double, double* %425, i64 %427
%429 = load double, double* %428
%430 = load double, double* %17
%431 = load double*, double** %8
%432 = load i32, i32* %14
%433 = sext i32 %432 to i64
%434 = getelementptr inbounds double, double* %431, i64 %433
%435 = load double, double* %434
%436 = load double*, double** %9
%437 = load i32, i32* %14
%438 = sext i32 %437 to i64
%439 = getelementptr inbounds double, double* %436, i64 %438
%440 = load double, double* %439
%441 = fsub double %435, %440
%442 = call double @llvm.fmuladd.f64(double %430, double %441, double %429)
%443 = load double*, double** %11
%444 = load i32, i32* %14
%445 = sext i32 %444 to i64
%446 = getelementptr inbounds double, double* %443, i64 %445
store double %442, double* %446
br label %447
447: ; preds = %424
%448 = load i32, i32* %14
%449 = add nsw i32 %448, 1
store i32 %449, i32* %14
br label %421
450: ; preds = %421
store i32 1, i32* %15
br label %451
451: ; preds = %450, %355
br label %452
452: ; preds = %451, %319
%453 = load i32, i32* %15
ret i32 %453
}

LLVM IR (-O2):
define i32 @find_point_depth([3 x double]* nocapture %0, double* nocapture %1, double* nocapture %2, double* nocapture %3, double* nocapture writeonly %4, i32 %5) {
%7 = icmp eq i32 %5, 1
br i1 %7, label %8, label %77
8: ; preds = %6
%9 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 1, i64 1
%10 = load double, double* %9
%11 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 0, i64 1
%12 = load double, double* %11
%13 = fsub double %10, %12
%14 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 2, i64 2
%15 = load double, double* %14
%16 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 0, i64 2
%17 = load double, double* %16
%18 = fsub double %15, %17
%19 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 2, i64 1
%20 = load double, double* %19
%21 = fsub double %20, %12
%22 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 1, i64 2
%23 = load double, double* %22
%24 = fsub double %23, %17
%25 = fneg double %21
%26 = fmul double %24, %25
%27 = tail call double @llvm.fmuladd.f64(double %13, double %18, double %26)
store double %27, double* %3
%28 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 1, i64 0
%29 = load double, double* %28
%30 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 0, i64 0
%31 = load double, double* %30
%32 = fsub double %29, %31
%33 = fneg double %32
%34 = load double, double* %14
%35 = load double, double* %16
%36 = fsub double %34, %35
%37 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 2, i64 0
%38 = bitcast double* %22 to <2 x double>*
%39 = load <2 x double>, <2 x double>* %38
%40 = insertelement <2 x double> poison, double %35, i64 0
%41 = insertelement <2 x double> %40, double %31, i64 1
%42 = fsub <2 x double> %39, %41
%43 = shufflevector <2 x double> %42, <2 x double> poison, <2 x i32> <i32 1, i32 undef>
%44 = fmul <2 x double> %43, %42
%45 = extractelement <2 x double> %44, i64 0
%46 = tail call double @llvm.fmuladd.f64(double %33, double %36, double %45)
%47 = getelementptr inbounds double, double* %3, i64 1
store double %46, double* %47
%48 = load double, double* %28
%49 = load double, double* %30
%50 = fsub double %48, %49
%51 = load double, double* %19
%52 = load double, double* %11
%53 = fsub double %51, %52
%54 = load double, double* %37
%55 = fsub double %54, %49
%56 = load double, double* %9
%57 = fsub double %56, %52
%58 = fneg double %55
%59 = fmul double %57, %58
%60 = tail call double @llvm.fmuladd.f64(double %50, double %53, double %59)
%61 = getelementptr inbounds double, double* %3, i64 2
store double %60, double* %61
%62 = fmul double %46, %46
%63 = tail call double @llvm.fmuladd.f64(double %27, double %27, double %62)
%64 = tail call double @llvm.fmuladd.f64(double %60, double %60, double %63)
%65 = tail call double @sqrt(double %64)
%66 = tail call double @llvm.fabs.f64(double %65)
%67 = fcmp ogt double %66, 1.000000e-08
br i1 %67, label %68, label %77
68: ; preds = %8
%69 = bitcast double* %3 to <2 x double>*
%70 = load <2 x double>, <2 x double>* %69
%71 = insertelement <2 x double> poison, double %65, i64 0
%72 = shufflevector <2 x double> %71, <2 x double> poison, <2 x i32> zeroinitializer
%73 = fdiv <2 x double> %70, %72
%74 = bitcast double* %3 to <2 x double>*
store <2 x double> %73, <2 x double>* %74
%75 = load double, double* %61
%76 = fdiv double %75, %65
store double %76, double* %61
br label %77
77: ; preds = %68, %8, %6
%78 = load double, double* %2
%79 = load double, double* %1
%80 = fsub double %78, %79
%81 = getelementptr inbounds double, double* %2, i64 1
%82 = getelementptr inbounds double, double* %1, i64 1
%83 = getelementptr inbounds double, double* %2, i64 2
%84 = bitcast double* %81 to <2 x double>*
%85 = load <2 x double>, <2 x double>* %84
%86 = getelementptr inbounds double, double* %1, i64 2
%87 = bitcast double* %82 to <2 x double>*
%88 = load <2 x double>, <2 x double>* %87
%89 = fsub <2 x double> %85, %88
%90 = fmul <2 x double> %89, %89
%91 = extractelement <2 x double> %90, i64 0
%92 = tail call double @llvm.fmuladd.f64(double %80, double %80, double %91)
%93 = extractelement <2 x double> %89, i64 1
%94 = tail call double @llvm.fmuladd.f64(double %93, double %93, double %92)
%95 = tail call double @sqrt(double %94)
%96 = tail call double @llvm.fabs.f64(double %95)
%97 = fcmp ogt double %96, 1.000000e-08
br i1 %97, label %98, label %103
98: ; preds = %77
%99 = fdiv double %80, %95
%100 = insertelement <2 x double> poison, double %95, i64 0
%101 = shufflevector <2 x double> %100, <2 x double> poison, <2 x i32> zeroinitializer
%102 = fdiv <2 x double> %89, %101
br label %103
103: ; preds = %98, %77
%104 = phi double [ %99, %98 ], [ %80, %77 ]
%105 = phi <2 x double> [ %102, %98 ], [ %89, %77 ]
%106 = bitcast double* %3 to <2 x double>*
%107 = load <2 x double>, <2 x double>* %106
%108 = extractelement <2 x double> %107, i64 1
%109 = extractelement <2 x double> %105, i64 0
%110 = fmul double %108, %109
%111 = extractelement <2 x double> %107, i64 0
%112 = tail call double @llvm.fmuladd.f64(double %111, double %104, double %110)
%113 = getelementptr inbounds double, double* %3, i64 2
%114 = load double, double* %113
%115 = extractelement <2 x double> %105, i64 1
%116 = tail call double @llvm.fmuladd.f64(double %114, double %115, double %112)
%117 = fcmp olt double %116, 0.000000e+00
br i1 %117, label %118, label %124
118: ; preds = %103
%119 = fneg <2 x double> %107
%120 = bitcast double* %3 to <2 x double>*
store <2 x double> %119, <2 x double>* %120
%121 = fneg double %114
store double %121, double* %113
%122 = extractelement <2 x double> %119, i64 0
%123 = extractelement <2 x double> %119, i64 1
br label %124
124: ; preds = %118, %103
%125 = phi double [ %121, %118 ], [ %114, %103 ]
%126 = phi double [ %123, %118 ], [ %108, %103 ]
%127 = phi double [ %122, %118 ], [ %111, %103 ]
br i1 %7, label %128, label %142
128: ; preds = %124
%129 = fneg double %127
%130 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 0, i64 0
%131 = load double, double* %130
%132 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 0, i64 1
%133 = load double, double* %132
%134 = fneg double %126
%135 = fmul double %133, %134
%136 = tail call double @llvm.fmuladd.f64(double %129, double %131, double %135)
%137 = getelementptr inbounds [3 x double], [3 x double]* %0, i64 0, i64 2
%138 = load double, double* %137
%139 = fneg double %125
%140 = tail call double @llvm.fmuladd.f64(double %139, double %138, double %136)
%141 = getelementptr inbounds double, double* %3, i64 3
store double %140, double* %141
br label %142
142: ; preds = %128, %124
%143 = load double, double* %1
%144 = load double, double* %2
%145 = fsub double %143, %144
%146 = load double, double* %82
%147 = load double, double* %81
%148 = fsub double %146, %147
%149 = fmul double %126, %148
%150 = tail call double @llvm.fmuladd.f64(double %127, double %145, double %149)
%151 = load double, double* %86
%152 = load double, double* %83
%153 = fsub double %151, %152
%154 = tail call double @llvm.fmuladd.f64(double %125, double %153, double %150)
%155 = tail call double @llvm.fabs.f64(double %154)
%156 = fcmp ogt double %155, 1.000000e-08
br i1 %156, label %157, label %181
157: ; preds = %142
%158 = getelementptr inbounds double, double* %3, i64 3
%159 = load double, double* %158
%160 = fneg double %159
%161 = fneg double %127
%162 = tail call double @llvm.fmuladd.f64(double %161, double %144, double %160)
%163 = fneg double %126
%164 = tail call double @llvm.fmuladd.f64(double %163, double %147, double %162)
%165 = fneg double %125
%166 = tail call double @llvm.fmuladd.f64(double %165, double %152, double %164)
%167 = fdiv double %166, %154
%168 = fcmp ogt double %167, -1.000000e-08
br i1 %168, label %169, label %181
169: ; preds = %157
%170 = tail call double @llvm.fmuladd.f64(double %167, double %145, double %144)
store double %170, double* %4
%171 = load double, double* %81
%172 = load double, double* %82
%173 = fsub double %172, %171
%174 = tail call double @llvm.fmuladd.f64(double %167, double %173, double %171)
%175 = getelementptr inbounds double, double* %4, i64 1
store double %174, double* %175
%176 = load double, double* %83
%177 = load double, double* %86
%178 = fsub double %177, %176
%179 = tail call double @llvm.fmuladd.f64(double %167, double %178, double %176)
%180 = getelementptr inbounds double, double* %4, i64 2
store double %179, double* %180
br label %181
181: ; preds = %169, %157, %142
%182 = phi i32 [ 0, %157 ], [ 0, %142 ], [ 1, %169 ]
ret i32 %182
}