int inside_(double *p, int *lv, double *xv, double *yv, double *zv, int *nv,
            int *listv, int *ier) {
  static double eps = .001;
  int i__1;
  int ret_val = 0;
  static double b[3], d__;
  static int k, n;
  static double q[3];
  static int i1, i2, k0;
  static double v1[3], v2[3], cn[3], bp, bq;
  static int ni;
  static double pn[3], qn[3], vn[3];
  static int imx;
  static int lft1, lft2, even;
  static int ierr;
  static int pinr, qinr;
  static double qnrm, vnrm;
  --p;
  --zv;
  --yv;
  --xv;
  --listv;
  imx = *lv;
  n = *nv;
  if (n < 3 || n > imx) {
    goto L11;
  }
  k0 = 0;
  i1 = listv[1];
  if (i1 < 1 || i1 > imx) {
    goto L12;
  }
L1:
  ++k0;
  if (k0 > n) {
    goto L14;
  }
  i1 = listv[k0];
  if (k0 < n) {
    i2 = listv[k0 + 1];
  } else {
    i2 = listv[1];
  }
  if (i2 < 1 || i2 > imx) {
    goto L12;
  }
  vn[0] = yv[i1] * zv[i2] - zv[i1] * yv[i2];
  vn[1] = zv[i1] * xv[i2] - xv[i1] * zv[i2];
  vn[2] = xv[i1] * yv[i2] - yv[i1] * xv[i2];
  vnrm = sqrt(vn[0] * vn[0] + vn[1] * vn[1] + vn[2] * vn[2]);
  if (vnrm == 0.) {
    goto L1;
  }
  q[0] = xv[i1] + xv[i2] + eps * vn[0] / vnrm;
  q[1] = yv[i1] + yv[i2] + eps * vn[1] / vnrm;
  q[2] = zv[i1] + zv[i2] + eps * vn[2] / vnrm;
  qnrm = sqrt(q[0] * q[0] + q[1] * q[1] + q[2] * q[2]);
  q[0] /= qnrm;
  q[1] /= qnrm;
  q[2] /= qnrm;
  cn[0] = q[1] * p[3] - q[2] * p[2];
  cn[1] = q[2] * p[1] - q[0] * p[3];
  cn[2] = q[0] * p[2] - q[1] * p[1];
  if (cn[0] == 0. && cn[1] == 0. && cn[2] == 0.) {
    goto L1;
  }
  pn[0] = p[2] * cn[2] - p[3] * cn[1];
  pn[1] = p[3] * cn[0] - p[1] * cn[2];
  pn[2] = p[1] * cn[1] - p[2] * cn[0];
  qn[0] = cn[1] * q[2] - cn[2] * q[1];
  qn[1] = cn[2] * q[0] - cn[0] * q[2];
  qn[2] = cn[0] * q[1] - cn[1] * q[0];
  ni = 0;
  even = (1);
  bp = -2.;
  bq = -2.;
  pinr = (1);
  qinr = (1);
  i2 = listv[n];
  if (i2 < 1 || i2 > imx) {
    goto L12;
  }
  lft2 = cn[0] * xv[i2] + cn[1] * yv[i2] + cn[2] * zv[i2] > 0.;
  i__1 = n;
  for (k = 1; k <= i__1; ++k) {
    i1 = i2;
    lft1 = lft2;
    i2 = listv[k];
    if (i2 < 1 || i2 > imx) {
      goto L12;
    }
    lft2 = cn[0] * xv[i2] + cn[1] * yv[i2] + cn[2] * zv[i2] > 0.;
    if (lft1 == lft2) {
      goto L2;
    }
    ++ni;
    v1[0] = xv[i1];
    v1[1] = yv[i1];
    v1[2] = zv[i1];
    v2[0] = xv[i2];
    v2[1] = yv[i2];
    v2[2] = zv[i2];
    intrsc_(v1, v2, cn, b, &ierr);
    if (b[0] * qn[0] + b[1] * qn[1] + b[2] * qn[2] > 0. &&
        b[0] * pn[0] + b[1] * pn[1] + b[2] * pn[2] > 0.) {
      even = !even;
      d__ = b[0] * q[0] + b[1] * q[1] + b[2] * q[2];
      if (d__ > bq) {
        bq = d__;
        qinr = lft2;
      }
      d__ = b[0] * p[1] + b[1] * p[2] + b[2] * p[3];
      if (d__ > bp) {
        bp = d__;
        pinr = lft1;
      }
    }
  L2:;
  }
  if (ni != ni / 2 << 1 || !qinr) {
    goto L1;
  }
  if (pinr != even) {
    goto L13;
  }
  *ier = 0;
  ret_val = even;
  return ret_val;
L11:
  *ier = 1;
  return ret_val;
L12:
  *ier = 2;
  return ret_val;
L13:
  *ier = 3;
  return ret_val;
L14:
  *ier = 4;
  return ret_val;
}


x86 assembly (clang, -O0):
<inside_>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
mov    %r9,-0x38(%rbp)
movl   $0x0,-0x40(%rbp)
mov    -0x10(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x10(%rbp)
mov    -0x30(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x20(%rbp)
mov    0x10(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,0x10(%rbp)
mov    -0x18(%rbp),%rax
mov    (%rax),%eax
mov    %eax,0x2fe1(%rip)
mov    -0x38(%rbp),%rax
mov    (%rax),%eax
mov    %eax,0x2ed1(%rip)
cmpl   $0x3,0x2eca(%rip)
jl     11c2 <inside_+0xa2>
mov    0x2ebe(%rip),%eax
cmp    0x2fbc(%rip),%eax
jle    11c7 <inside_+0xa7>
jmp    1d77 <inside_+0xc57>
movl   $0x0,0x2ecf(%rip)
mov    0x10(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,0x2eba(%rip)
cmpl   $0x1,0x2eb3(%rip)
jl     11fd <inside_+0xdd>
mov    0x2ea7(%rip),%eax
cmp    0x2f81(%rip),%eax
jle    1202 <inside_+0xe2>
jmp    1d8c <inside_+0xc6c>
jmp    1207 <inside_+0xe7>
mov    0x2e93(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2e8a(%rip)
mov    0x2e84(%rip),%eax
cmp    0x2e52(%rip),%eax
jle    122d <inside_+0x10d>
jmp    1db6 <inside_+0xc96>
mov    0x10(%rbp),%rax
movslq 0x2e68(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x2e57(%rip)
mov    0x2e59(%rip),%eax
cmp    0x2e27(%rip),%eax
jge    1271 <inside_+0x151>
mov    0x10(%rbp),%rax
mov    0x2e43(%rip),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x2e30(%rip)
jmp    127e <inside_+0x15e>
mov    0x10(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,0x2e1e(%rip)
cmpl   $0x1,0x2e17(%rip)
jl     129d <inside_+0x17d>
mov    0x2e0b(%rip),%eax
cmp    0x2ee1(%rip),%eax
jle    12a2 <inside_+0x182>
jmp    1d8c <inside_+0xc6c>
mov    -0x28(%rbp),%rax
movslq 0x2deb(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movslq 0x2ddf(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x30(%rbp),%rax
movslq 0x2dcb(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x28(%rbp),%rax
movslq 0x2dbf(%rip),%rcx
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x2e57(%rip)
mov    -0x30(%rbp),%rax
movslq 0x2d84(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq 0x2d78(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x20(%rbp),%rax
movslq 0x2d64(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x30(%rbp),%rax
movslq 0x2d58(%rip),%rcx
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x2df8(%rip)
mov    -0x20(%rbp),%rax
movslq 0x2d1d(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq 0x2d11(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
movslq 0x2cfd(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x20(%rbp),%rax
movslq 0x2cf1(%rip),%rcx
mulsd  (%rax,%rcx,8),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x2d99(%rip)
movsd  0x2d81(%rip),%xmm1
movsd  0x2d79(%rip),%xmm2
movsd  0x2d79(%rip),%xmm0
mulsd  0x2d71(%rip),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x2d69(%rip),%xmm0
movsd  0x2d61(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1040 <sqrt@plt>
movsd  %xmm0,0x2d7c(%rip)
movsd  0x2d74(%rip),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1444 <inside_+0x324>
jp     1444 <inside_+0x324>
jmp    1207 <inside_+0xe7>
mov    -0x20(%rbp),%rax
movslq 0x2c49(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rax
movslq 0x2c3d(%rip),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  0x2bc4(%rip),%xmm1
mulsd  0x2cec(%rip),%xmm1
divsd  0x2d24(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,0x2bf8(%rip)
mov    -0x28(%rbp),%rax
movslq 0x2c05(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq 0x2bf9(%rip),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  0x2b80(%rip),%xmm1
mulsd  0x2cb0(%rip),%xmm1
divsd  0x2ce0(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,0x2bbc(%rip)
mov    -0x30(%rbp),%rax
movslq 0x2bc1(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movslq 0x2bb5(%rip),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  0x2b3c(%rip),%xmm1
mulsd  0x2c74(%rip),%xmm1
divsd  0x2c9c(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,0x2b80(%rip)
movsd  0x2b68(%rip),%xmm1
movsd  0x2b60(%rip),%xmm2
movsd  0x2b60(%rip),%xmm0
mulsd  0x2b58(%rip),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x2b50(%rip),%xmm0
movsd  0x2b48(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1040 <sqrt@plt>
movsd  %xmm0,0x2c3b(%rip)
movsd  0x2c33(%rip),%xmm1
movsd  0x2b13(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x2b07(%rip)
movsd  0x2c17(%rip),%xmm1
movsd  0x2aff(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x2af3(%rip)
movsd  0x2bfb(%rip),%xmm1
movsd  0x2aeb(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,0x2adf(%rip)
movsd  0x2acf(%rip),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm2
movsd  0x2ac6(%rip),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x10(%rax),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x2af6(%rip)
movsd  0x2a8e(%rip),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm2
movsd  0x2a6d(%rip),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x18(%rax),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x2ab5(%rip)
movsd  0x2a35(%rip),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm2
movsd  0x2a2c(%rip),%xmm1
mov    -0x10(%rbp),%rax
mulsd  0x8(%rax),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x2a74(%rip)
movsd  0x2a5c(%rip),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    16e2 <inside_+0x5c2>
jp     16e2 <inside_+0x5c2>
movsd  0x2a49(%rip),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    16e2 <inside_+0x5c2>
jp     16e2 <inside_+0x5c2>
movsd  0x2a36(%rip),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    16e2 <inside_+0x5c2>
jp     16e2 <inside_+0x5c2>
jmp    1207 <inside_+0xe7>
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm0
movsd  0x2a0d(%rip),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm1
mulsd  0x29f4(%rip),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x29f5(%rip)
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm0
movsd  0x29b4(%rip),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm1
mulsd  0x29b3(%rip),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x29b4(%rip)
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm0
movsd  0x2973(%rip),%xmm2
mov    -0x10(%rbp),%rax
movsd  0x10(%rax),%xmm1
mulsd  0x295a(%rip),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x2973(%rip)
movsd  0x2933(%rip),%xmm0
movsd  0x28c3(%rip),%xmm2
movsd  0x292b(%rip),%xmm1
mulsd  0x28ab(%rip),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x293c(%rip)
movsd  0x28f4(%rip),%xmm0
movsd  0x286c(%rip),%xmm2
movsd  0x28d4(%rip),%xmm1
mulsd  0x286c(%rip),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x28fd(%rip)
movsd  0x289d(%rip),%xmm0
movsd  0x282d(%rip),%xmm2
movsd  0x2895(%rip),%xmm1
mulsd  0x2815(%rip),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x28be(%rip)
movl   $0x0,0x287c(%rip)
movl   $0x1,0x28de(%rip)
movsd  0x752(%rip),%xmm0
movsd  %xmm0,0x2852(%rip)
movsd  0x742(%rip),%xmm0
movsd  %xmm0,0x284a(%rip)
movl   $0x1,0x28bc(%rip)
movl   $0x1,0x28b6(%rip)
mov    0x10(%rbp),%rax
movslq 0x278f(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x27ae(%rip)
cmpl   $0x1,0x27a7(%rip)
jl     190d <inside_+0x7ed>
mov    0x279b(%rip),%eax
cmp    0x2871(%rip),%eax
jle    1912 <inside_+0x7f2>
jmp    1d8c <inside_+0xc6c>
movsd  0x27d6(%rip),%xmm1
mov    -0x20(%rbp),%rax
movslq 0x2777(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x27c6(%rip),%xmm0
mov    -0x28(%rbp),%rax
movslq 0x275f(%rip),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x27ae(%rip),%xmm0
mov    -0x30(%rbp),%rax
movslq 0x273f(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
seta   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,0x2801(%rip)
mov    0x26ef(%rip),%eax
mov    %eax,-0x3c(%rbp)
movl   $0x1,0x26de(%rip)
mov    0x26d8(%rip),%eax
cmp    -0x3c(%rbp),%eax
jg     1d09 <inside_+0xbe9>
mov    0x26f5(%rip),%eax
mov    %eax,0x26eb(%rip)
mov    0x27cd(%rip),%eax
mov    %eax,0x27c3(%rip)
mov    0x10(%rbp),%rax
movslq 0x26ac(%rip),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,0x26cf(%rip)
cmpl   $0x1,0x26c8(%rip)
jl     19ec <inside_+0x8cc>
mov    0x26bc(%rip),%eax
cmp    0x2792(%rip),%eax
jle    19f1 <inside_+0x8d1>
jmp    1d8c <inside_+0xc6c>
movsd  0x26f7(%rip),%xmm1
mov    -0x20(%rbp),%rax
movslq 0x2698(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  0x26e7(%rip),%xmm0
mov    -0x28(%rbp),%rax
movslq 0x2680(%rip),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x26cf(%rip),%xmm0
mov    -0x30(%rbp),%rax
movslq 0x2660(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
seta   %al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,0x2722(%rip)
mov    0x2718(%rip),%eax
cmp    0x2716(%rip),%eax
jne    1a75 <inside_+0x955>
jmp    1cf0 <inside_+0xbd0>
mov    0x269d(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2694(%rip)
mov    -0x20(%rbp),%rax
movslq 0x2609(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x2614(%rip)
mov    -0x28(%rbp),%rax
movslq 0x25f1(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x2604(%rip)
mov    -0x30(%rbp),%rax
movslq 0x25d9(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x25f4(%rip)
mov    -0x20(%rbp),%rax
movslq 0x25c5(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x25ec(%rip)
mov    -0x28(%rbp),%rax
movslq 0x25ad(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x25dc(%rip)
mov    -0x30(%rbp),%rax
movslq 0x2595(%rip),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x25cc(%rip)
lea    0x2595(%rip),%rdi
lea    0x25ae(%rip),%rsi
lea    0x25c7(%rip),%rdx
lea    0x2520(%rip),%rcx
lea    0x2651(%rip),%r8
mov    $0x0,%al
call   1030 <intrsc_@plt>
movsd  0x250a(%rip),%xmm1
movsd  0x25f2(%rip),%xmm2
movsd  0x2502(%rip),%xmm0
mulsd  0x25ea(%rip),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x24f2(%rip),%xmm0
movsd  0x25da(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1ceb <inside_+0xbcb>
movsd  0x24bd(%rip),%xmm1
movsd  0x2585(%rip),%xmm2
movsd  0x24b5(%rip),%xmm0
mulsd  0x257d(%rip),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x24a5(%rip),%xmm0
movsd  0x256d(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jbe    1ceb <inside_+0xbcb>
cmpl   $0x0,0x25a5(%rip)
setne  %al
xor    $0xff,%al
and    $0x1,%al
movzbl %al,%eax
mov    %eax,0x2595(%rip)
movsd  0x2459(%rip),%xmm1
movsd  0x2481(%rip),%xmm2
movsd  0x2451(%rip),%xmm0
mulsd  0x2479(%rip),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x2441(%rip),%xmm0
movsd  0x2469(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x2431(%rip)
movsd  0x2429(%rip),%xmm0
ucomisd 0x24c9(%rip),%xmm0
jbe    1c69 <inside_+0xb49>
movsd  0x2413(%rip),%xmm0
movsd  %xmm0,0x24b3(%rip)
mov    0x251d(%rip),%eax
mov    %eax,0x2527(%rip)
movsd  0x23df(%rip),%xmm1
mov    -0x10(%rbp),%rax
movsd  0x8(%rax),%xmm2
movsd  0x23d6(%rip),%xmm0
mov    -0x10(%rbp),%rax
mulsd  0x10(%rax),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  0x23c5(%rip),%xmm0
mov    -0x10(%rbp),%rax
movsd  0x18(%rax),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x23b4(%rip)
movsd  0x23ac(%rip),%xmm0
ucomisd 0x2444(%rip),%xmm0
jbe    1ce6 <inside_+0xbc6>
movsd  0x2396(%rip),%xmm0
movsd  %xmm0,0x242e(%rip)
mov    0x249c(%rip),%eax
mov    %eax,0x24a6(%rip)
jmp    1ceb <inside_+0xbcb>
jmp    1cf0 <inside_+0xbd0>
jmp    1cf5 <inside_+0xbd5>
mov    0x2375(%rip),%eax
add    $0x1,%eax
mov    %eax,0x236c(%rip)
jmp    1992 <inside_+0x872>
mov    0x2409(%rip),%eax
mov    %eax,-0x44(%rbp)
mov    0x2400(%rip),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x44(%rbp),%eax
shl    $0x1,%ecx
cmp    %ecx,%eax
jne    1d3d <inside_+0xc1d>
cmpl   $0x0,0x2459(%rip)
jne    1d42 <inside_+0xc22>
jmp    1207 <inside_+0xe7>
mov    0x2444(%rip),%eax
cmp    0x2436(%rip),%eax
je     1d59 <inside_+0xc39>
jmp    1da1 <inside_+0xc81>
mov    0x18(%rbp),%rax
movl   $0x0,(%rax)
mov    0x241b(%rip),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    1dc6 <inside_+0xca6>
mov    0x18(%rbp),%rax
movl   $0x1,(%rax)
mov    -0x40(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    1dc6 <inside_+0xca6>
mov    0x18(%rbp),%rax
movl   $0x2,(%rax)
mov    -0x40(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    1dc6 <inside_+0xca6>
mov    0x18(%rbp),%rax
movl   $0x3,(%rax)
mov    -0x40(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    1dc6 <inside_+0xca6>
mov    0x18(%rbp),%rax
movl   $0x4,(%rax)
mov    -0x40(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<inside_>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %rdx,%r12
mov    %rdi,0x8(%rsp)
mov    0x58(%rsp),%r13
mov    (%rsi),%edx
mov    %edx,0x3055(%rip)
mov    (%r9),%esi
mov    %esi,0x2f10(%rip)
xor    %eax,%eax
cmp    $0x3,%esi
jl     1866 <inside_+0x746>
cmp    %edx,%esi
jg     1866 <inside_+0x746>
mov    %rcx,%r15
mov    0x50(%rsp),%rcx
movl   $0x0,0x2f1f(%rip)
mov    (%rcx),%ecx
mov    %ecx,0x2f0f(%rip)
test   %ecx,%ecx
jle    1872 <inside_+0x752>
cmp    %edx,%ecx
jg     1872 <inside_+0x752>
movl   $0x1,0x2efd(%rip)
mov    0x50(%rsp),%rbp
mov    0x0(%rbp),%ecx
mov    %ecx,0x2ee7(%rip)
xor    %edi,%edi
cmp    $0x2,%esi
setge  %dil
mov    0x0(%rbp,%rdi,4),%esi
mov    %esi,0x2ed8(%rip)
test   %esi,%esi
jle    1872 <inside_+0x752>
cmp    %edx,%esi
jg     1872 <inside_+0x752>
mov    %r8,%r14
mov    0x50(%rsp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,0x10(%rsp)
xorpd  %xmm11,%xmm11
nopw   0x0(%rax,%rax,1)
movslq %ecx,%rax
movsd  -0x8(%r15,%rax,8),%xmm1
mov    %esi,%ecx
movsd  -0x8(%r14,%rcx,8),%xmm2
movsd  -0x8(%r14,%rax,8),%xmm3
movsd  -0x8(%r15,%rcx,8),%xmm4
movapd %xmm4,%xmm0
mulsd  %xmm3,%xmm0
movapd %xmm1,%xmm5
mulsd  %xmm2,%xmm5
subsd  %xmm0,%xmm5
movsd  %xmm5,0x2f53(%rip)
movsd  -0x8(%r12,%rcx,8),%xmm6
movsd  -0x8(%r12,%rax,8),%xmm0
mulsd  %xmm0,%xmm2
mulsd  %xmm6,%xmm3
subsd  %xmm2,%xmm3
movsd  %xmm3,0x2f41(%rip)
mulsd  %xmm1,%xmm6
mulsd  %xmm4,%xmm0
subsd  %xmm6,%xmm0
movsd  %xmm0,0x2f3d(%rip)
mulsd  %xmm3,%xmm3
mulsd  %xmm5,%xmm5
addsd  %xmm3,%xmm5
mulsd  %xmm0,%xmm0
addsd  %xmm5,%xmm0
ucomisd %xmm11,%xmm0
jb     1280 <inside_+0x160>
sqrtsd %xmm0,%xmm0
jmp    128a <inside_+0x16a>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
call   1040 <sqrt@plt>
xorpd  %xmm11,%xmm11
ucomisd %xmm11,%xmm0
jne    1297 <inside_+0x177>
jnp    1810 <inside_+0x6f0>
movslq 0x2dea(%rip),%rax
movsd  -0x8(%r12,%rax,8),%xmm1
movslq 0x2de0(%rip),%rcx
addsd  -0x8(%r12,%rcx,8),%xmm1
movsd  0x2eb5(%rip),%xmm2
movsd  0xd3d(%rip),%xmm5
mulsd  %xmm5,%xmm2
divsd  %xmm0,%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,0x2d89(%rip)
movsd  -0x8(%r15,%rax,8),%xmm1
addsd  -0x8(%r15,%rcx,8),%xmm1
movsd  0x2e93(%rip),%xmm3
mulsd  %xmm5,%xmm3
divsd  %xmm0,%xmm3
addsd  %xmm1,%xmm3
movsd  %xmm3,0x2d6f(%rip)
movsd  -0x8(%r14,%rax,8),%xmm4
addsd  -0x8(%r14,%rcx,8),%xmm4
movsd  0x2e79(%rip),%xmm1
mulsd  %xmm5,%xmm1
divsd  %xmm0,%xmm1
addsd  %xmm4,%xmm1
movsd  %xmm1,0x2d55(%rip)
mulsd  %xmm3,%xmm3
mulsd  %xmm2,%xmm2
addsd  %xmm3,%xmm2
mulsd  %xmm1,%xmm1
addsd  %xmm2,%xmm1
ucomisd %xmm11,%xmm1
jb     134f <inside_+0x22f>
xorps  %xmm0,%xmm0
sqrtsd %xmm1,%xmm0
jmp    135d <inside_+0x23d>
movapd %xmm1,%xmm0
call   1040 <sqrt@plt>
xorpd  %xmm11,%xmm11
movsd  0x2cfa(%rip),%xmm10
divsd  %xmm0,%xmm10
movsd  %xmm10,0x2cec(%rip)
movsd  0x2cf4(%rip),%xmm5
divsd  %xmm0,%xmm5
movsd  %xmm5,0x2ce8(%rip)
movsd  0x2cf0(%rip),%xmm4
divsd  %xmm0,%xmm4
movsd  %xmm4,0x2ce4(%rip)
mov    0x8(%rsp),%rax
movsd  0x10(%rax),%xmm2
movsd  0x8(%rax),%xmm1
mulsd  %xmm4,%xmm1
movapd %xmm5,%xmm0
mulsd  %xmm2,%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,0x2d1d(%rip)
mulsd  %xmm10,%xmm2
movsd  (%rax),%xmm1
mulsd  %xmm4,%xmm1
subsd  %xmm2,%xmm1
movsd  %xmm1,0x2d0c(%rip)
movsd  (%rax),%xmm6
mulsd  %xmm5,%xmm6
movsd  0x8(%rax),%xmm2
mulsd  %xmm10,%xmm2
subsd  %xmm6,%xmm2
movsd  %xmm2,0x2cf6(%rip)
ucomisd %xmm11,%xmm0
jne    1419 <inside_+0x2f9>
jp     1419 <inside_+0x2f9>
ucomisd %xmm11,%xmm1
jne    1419 <inside_+0x2f9>
jp     1419 <inside_+0x2f9>
ucomisd %xmm11,%xmm2
jne    1419 <inside_+0x2f9>
jnp    1810 <inside_+0x6f0>
mov    0x8(%rsp),%rax
movsd  0x8(%rax),%xmm6
movsd  0x10(%rax),%xmm7
movapd %xmm1,%xmm8
mulsd  %xmm7,%xmm8
movapd %xmm0,%xmm9
mulsd  %xmm6,%xmm9
mulsd  %xmm2,%xmm6
subsd  %xmm8,%xmm6
movsd  %xmm6,0x2cc3(%rip)
movsd  (%rax),%xmm6
movapd %xmm2,%xmm3
mulsd  %xmm6,%xmm3
mulsd  %xmm0,%xmm7
subsd  %xmm3,%xmm7
movsd  %xmm7,0x2cb7(%rip)
mulsd  %xmm1,%xmm6
subsd  %xmm9,%xmm6
movsd  %xmm6,0x2cb6(%rip)
movapd %xmm0,%xmm3
mulsd  %xmm5,%xmm3
mulsd  %xmm2,%xmm5
movapd %xmm1,%xmm6
mulsd  %xmm4,%xmm6
subsd  %xmm5,%xmm6
movsd  %xmm6,0x2ca6(%rip)
mulsd  %xmm0,%xmm4
movapd %xmm2,%xmm5
mulsd  %xmm10,%xmm5
subsd  %xmm4,%xmm5
movsd  %xmm5,0x2c9d(%rip)
mulsd  %xmm1,%xmm10
subsd  %xmm10,%xmm3
movsd  %xmm3,0x2c9b(%rip)
movl   $0x0,0x2c39(%rip)
movl   $0x1,0x2ccb(%rip)
movabs $0xc000000000000000,%rax
mov    %rax,0x2c0e(%rip)
mov    %rax,0x2c0f(%rip)
movl   $0x1,0x2cb1(%rip)
movl   $0x1,0x2cab(%rip)
movslq 0x2b50(%rip),%r13
mov    0x10(%rsp),%rax
mov    (%rax,%r13,4),%edi
mov    %edi,0x2b71(%rip)
xor    %eax,%eax
test   %edi,%edi
jle    186d <inside_+0x74d>
mov    0x2c6d(%rip),%ecx
cmp    %ecx,%edi
jg     186d <inside_+0x74d>
mulsd  -0x8(%r15,%rdi,8),%xmm1
mulsd  -0x8(%r12,%rdi,8),%xmm0
addsd  %xmm1,%xmm0
mulsd  -0x8(%r14,%rdi,8),%xmm2
addsd  %xmm0,%xmm2
xor    %edx,%edx
ucomisd %xmm11,%xmm2
seta   %dl
mov    %edx,0x2c40(%rip)
movl   $0x1,0x2aee(%rip)
test   %r13d,%r13d
jle    17d8 <inside_+0x6b8>
mov    $0x1,%eax
jmp    159a <inside_+0x47a>
nopw   0x0(%rax,%rax,1)
mov    0x2ad2(%rip),%ebp
lea    0x1(%rbp),%eax
mov    %eax,0x2ac9(%rip)
mov    %esi,%edi
cmp    %r13d,%ebp
jge    17e1 <inside_+0x6c1>
mov    %edi,0x2ae8(%rip)
mov    %edx,0x2bf6(%rip)
cltq
mov    0x10(%rsp),%rsi
mov    (%rsi,%rax,4),%esi
mov    %esi,0x2ad6(%rip)
xor    %eax,%eax
test   %esi,%esi
jle    186d <inside_+0x74d>
cmp    %ecx,%esi
jg     186d <inside_+0x74d>
movsd  0x2b10(%rip),%xmm0
movsd  0x2b10(%rip),%xmm1
mulsd  -0x8(%r15,%rsi,8),%xmm1
mulsd  -0x8(%r12,%rsi,8),%xmm0
addsd  %xmm1,%xmm0
movsd  0x2afe(%rip),%xmm1
mulsd  -0x8(%r14,%rsi,8),%xmm1
addsd  %xmm0,%xmm1
xor    %eax,%eax
ucomisd %xmm11,%xmm1
seta   %al
mov    %eax,0x2b93(%rip)
cmp    %eax,%edx
je     1580 <inside_+0x460>
addl   $0x1,0x2aec(%rip)
movslq %edi,%rax
movsd  -0x8(%r12,%rax,8),%xmm0
movsd  %xmm0,0x2a72(%rip)
movsd  -0x8(%r15,%rax,8),%xmm0
movsd  %xmm0,0x2a6b(%rip)
movsd  -0x8(%r14,%rax,8),%xmm0
movsd  %xmm0,0x2a64(%rip)
movsd  -0x8(%r12,%rsi,8),%xmm0
movsd  %xmm0,0x2a65(%rip)
movsd  -0x8(%r15,%rsi,8),%xmm0
movsd  %xmm0,0x2a5e(%rip)
movsd  -0x8(%r14,%rsi,8),%xmm0
movsd  %xmm0,0x2a57(%rip)
lea    0x2a20(%rip),%rdi
lea    0x2a39(%rip),%rsi
lea    0x2a52(%rip),%rdx
lea    0x29ab(%rip),%rcx
lea    0x2b0c(%rip),%r8
xor    %eax,%eax
call   1030 <intrsc_@plt>
xorpd  %xmm11,%xmm11
movsd  0x2990(%rip),%xmm0
movsd  0x2990(%rip),%xmm1
movsd  0x2a90(%rip),%xmm2
mulsd  %xmm1,%xmm2
movsd  0x2a74(%rip),%xmm3
mulsd  %xmm0,%xmm3
addsd  %xmm2,%xmm3
movsd  0x2974(%rip),%xmm2
movsd  0x2a7c(%rip),%xmm4
mulsd  %xmm2,%xmm4
addsd  %xmm3,%xmm4
ucomisd %xmm11,%xmm4
mov    0x2995(%rip),%esi
mov    0x2aa3(%rip),%edx
mov    0x2a95(%rip),%ecx
jbe    1580 <inside_+0x460>
movsd  0x2a0f(%rip),%xmm3
mulsd  %xmm1,%xmm3
movsd  0x29f3(%rip),%xmm4
mulsd  %xmm0,%xmm4
addsd  %xmm3,%xmm4
movsd  0x2a03(%rip),%xmm3
mulsd  %xmm2,%xmm3
addsd  %xmm4,%xmm3
ucomisd %xmm11,%xmm3
jbe    1580 <inside_+0x460>
xor    %eax,%eax
cmpl   $0x0,0x2a5b(%rip)
sete   %al
mov    %eax,0x2a52(%rip)
movsd  0x2916(%rip),%xmm3
mulsd  %xmm1,%xmm3
movsd  0x28fa(%rip),%xmm4
mulsd  %xmm0,%xmm4
addsd  %xmm3,%xmm4
movsd  0x290a(%rip),%xmm3
mulsd  %xmm2,%xmm3
addsd  %xmm4,%xmm3
ucomisd 0x297a(%rip),%xmm3
jbe    1796 <inside_+0x676>
movsd  %xmm3,0x2970(%rip)
mov    %edx,0x2a1a(%rip)
mov    0x8(%rsp),%rax
mulsd  0x8(%rax),%xmm1
mulsd  (%rax),%xmm0
addsd  %xmm1,%xmm0
mulsd  0x10(%rax),%xmm2
addsd  %xmm0,%xmm2
ucomisd 0x293f(%rip),%xmm2
jbe    1580 <inside_+0x460>
movsd  %xmm2,0x2931(%rip)
mov    0x29cf(%rip),%eax
mov    %eax,0x29d9(%rip)
jmp    1580 <inside_+0x460>
xor    %ecx,%ecx
mov    $0x1,%eax
jmp    17ed <inside_+0x6cd>
mov    0x2921(%rip),%ecx
mov    0x29c3(%rip),%eax
mov    %ecx,%edx
shr    $0x1f,%edx
add    %ecx,%edx
and    $0xfffffffe,%edx
cmp    %edx,%ecx
mov    0x58(%rsp),%r13
jne    1810 <inside_+0x6f0>
test   %eax,%eax
jne    1891 <inside_+0x771>
nopl   0x0(%rax,%rax,1)
movslq 0x2879(%rip),%rdx
lea    0x1(%rdx),%esi
mov    %esi,0x2870(%rip)
mov    0x2836(%rip),%ebp
xor    %eax,%eax
cmp    %ebp,%edx
jge    188a <inside_+0x76a>
mov    0x2966(%rip),%edi
mov    0x50(%rsp),%rbx
mov    (%rbx,%rdx,4),%ecx
cmp    %ebp,%esi
mov    0x10(%rsp),%rsi
lea    0x8(%rsi,%rdx,4),%rdx
cmovge %rbx,%rdx
mov    %ecx,0x2838(%rip)
mov    (%rdx),%esi
mov    %esi,0x2834(%rip)
test   %esi,%esi
jle    1872 <inside_+0x752>
cmp    %edi,%esi
jle    11e0 <inside_+0xc0>
jmp    1872 <inside_+0x752>
mov    $0x1,%edx
jmp    1877 <inside_+0x757>
mov    0x58(%rsp),%r13
mov    $0x2,%edx
mov    %edx,0x0(%r13)
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    $0x4,%edx
jmp    1877 <inside_+0x757>
mov    0x2915(%rip),%ecx
xor    %eax,%eax
xor    %edx,%edx
cmp    0x2903(%rip),%ecx
setne  %dl
lea    (%rdx,%rdx,2),%edx
cmove  %ecx,%eax
jmp    1877 <inside_+0x757>

LLVM IR (-O0):
@inside_.eps = internal global double 1.000000e-03
@inside_.b = internal global [3 x double] zeroinitializer
@inside_.d__ = internal global double 0.000000e+00
@inside_.k = internal global i32 0
@inside_.n = internal global i32 0
@inside_.q = internal global [3 x double] zeroinitializer
@inside_.i1 = internal global i32 0
@inside_.i2 = internal global i32 0
@inside_.k0 = internal global i32 0
@inside_.v1 = internal global [3 x double] zeroinitializer
@inside_.v2 = internal global [3 x double] zeroinitializer
@inside_.cn = internal global [3 x double] zeroinitializer
@inside_.bp = internal global double 0.000000e+00
@inside_.bq = internal global double 0.000000e+00
@inside_.ni = internal global i32 0
@inside_.pn = internal global [3 x double] zeroinitializer
@inside_.qn = internal global [3 x double] zeroinitializer
@inside_.vn = internal global [3 x double] zeroinitializer
@inside_.imx = internal global i32 0
@inside_.lft1 = internal global i32 0
@inside_.lft2 = internal global i32 0
@inside_.even = internal global i32 0
@inside_.ierr = internal global i32 0
@inside_.pinr = internal global i32 0
@inside_.qinr = internal global i32 0
@inside_.qnrm = internal global double 0.000000e+00
@inside_.vnrm = internal global double 0.000000e+00
define i32 @inside_(double* %0, i32* %1, double* %2, double* %3, double* %4, i32* %5, i32* %6, i32* %7) {
%9 = alloca i32
%10 = alloca double*
%11 = alloca i32*
%12 = alloca double*
%13 = alloca double*
%14 = alloca double*
%15 = alloca i32*
%16 = alloca i32*
%17 = alloca i32*
%18 = alloca i32
%19 = alloca i32
store double* %0, double** %10
store i32* %1, i32** %11
store double* %2, double** %12
store double* %3, double** %13
store double* %4, double** %14
store i32* %5, i32** %15
store i32* %6, i32** %16
store i32* %7, i32** %17
store i32 0, i32* %19
%20 = load double*, double** %10
%21 = getelementptr inbounds double, double* %20, i32 -1
store double* %21, double** %10
%22 = load double*, double** %14
%23 = getelementptr inbounds double, double* %22, i32 -1
store double* %23, double** %14
%24 = load double*, double** %13
%25 = getelementptr inbounds double, double* %24, i32 -1
store double* %25, double** %13
%26 = load double*, double** %12
%27 = getelementptr inbounds double, double* %26, i32 -1
store double* %27, double** %12
%28 = load i32*, i32** %16
%29 = getelementptr inbounds i32, i32* %28, i32 -1
store i32* %29, i32** %16
%30 = load i32*, i32** %11
%31 = load i32, i32* %30
store i32 %31, i32* @inside_.imx
%32 = load i32*, i32** %15
%33 = load i32, i32* %32
store i32 %33, i32* @inside_.n
%34 = load i32, i32* @inside_.n
%35 = icmp slt i32 %34, 3
br i1 %35, label %40, label %36
36: ; preds = %8
%37 = load i32, i32* @inside_.n
%38 = load i32, i32* @inside_.imx
%39 = icmp sgt i32 %37, %38
br i1 %39, label %40, label %41
40: ; preds = %36, %8
br label %545
41: ; preds = %36
store i32 0, i32* @inside_.k0
%42 = load i32*, i32** %16
%43 = getelementptr inbounds i32, i32* %42, i64 1
%44 = load i32, i32* %43
store i32 %44, i32* @inside_.i1
%45 = load i32, i32* @inside_.i1
%46 = icmp slt i32 %45, 1
br i1 %46, label %51, label %47
47: ; preds = %41
%48 = load i32, i32* @inside_.i1
%49 = load i32, i32* @inside_.imx
%50 = icmp sgt i32 %48, %49
br i1 %50, label %51, label %52
51: ; preds = %47, %41
br label %548
52: ; preds = %47
br label %53
53: ; preds = %535, %283, %170, %52
%54 = load i32, i32* @inside_.k0
%55 = add nsw i32 %54, 1
store i32 %55, i32* @inside_.k0
%56 = load i32, i32* @inside_.k0
%57 = load i32, i32* @inside_.n
%58 = icmp sgt i32 %56, %57
br i1 %58, label %59, label %60
59: ; preds = %53
br label %554
60: ; preds = %53
%61 = load i32*, i32** %16
%62 = load i32, i32* @inside_.k0
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds i32, i32* %61, i64 %63
%65 = load i32, i32* %64
store i32 %65, i32* @inside_.i1
%66 = load i32, i32* @inside_.k0
%67 = load i32, i32* @inside_.n
%68 = icmp slt i32 %66, %67
br i1 %68, label %69, label %76
69: ; preds = %60
%70 = load i32*, i32** %16
%71 = load i32, i32* @inside_.k0
%72 = add nsw i32 %71, 1
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds i32, i32* %70, i64 %73
%75 = load i32, i32* %74
store i32 %75, i32* @inside_.i2
br label %80
76: ; preds = %60
%77 = load i32*, i32** %16
%78 = getelementptr inbounds i32, i32* %77, i64 1
%79 = load i32, i32* %78
store i32 %79, i32* @inside_.i2
br label %80
80: ; preds = %76, %69
%81 = load i32, i32* @inside_.i2
%82 = icmp slt i32 %81, 1
br i1 %82, label %87, label %83
83: ; preds = %80
%84 = load i32, i32* @inside_.i2
%85 = load i32, i32* @inside_.imx
%86 = icmp sgt i32 %84, %85
br i1 %86, label %87, label %88
87: ; preds = %83, %80
br label %548
88: ; preds = %83
%89 = load double*, double** %13
%90 = load i32, i32* @inside_.i1
%91 = sext i32 %90 to i64
%92 = getelementptr inbounds double, double* %89, i64 %91
%93 = load double, double* %92
%94 = load double*, double** %14
%95 = load i32, i32* @inside_.i2
%96 = sext i32 %95 to i64
%97 = getelementptr inbounds double, double* %94, i64 %96
%98 = load double, double* %97
%99 = load double*, double** %14
%100 = load i32, i32* @inside_.i1
%101 = sext i32 %100 to i64
%102 = getelementptr inbounds double, double* %99, i64 %101
%103 = load double, double* %102
%104 = load double*, double** %13
%105 = load i32, i32* @inside_.i2
%106 = sext i32 %105 to i64
%107 = getelementptr inbounds double, double* %104, i64 %106
%108 = load double, double* %107
%109 = fmul double %103, %108
%110 = fneg double %109
%111 = call double @llvm.fmuladd.f64(double %93, double %98, double %110)
store double %111, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.vn, i64 0, i64 0)
%112 = load double*, double** %14
%113 = load i32, i32* @inside_.i1
%114 = sext i32 %113 to i64
%115 = getelementptr inbounds double, double* %112, i64 %114
%116 = load double, double* %115
%117 = load double*, double** %12
%118 = load i32, i32* @inside_.i2
%119 = sext i32 %118 to i64
%120 = getelementptr inbounds double, double* %117, i64 %119
%121 = load double, double* %120
%122 = load double*, double** %12
%123 = load i32, i32* @inside_.i1
%124 = sext i32 %123 to i64
%125 = getelementptr inbounds double, double* %122, i64 %124
%126 = load double, double* %125
%127 = load double*, double** %14
%128 = load i32, i32* @inside_.i2
%129 = sext i32 %128 to i64
%130 = getelementptr inbounds double, double* %127, i64 %129
%131 = load double, double* %130
%132 = fmul double %126, %131
%133 = fneg double %132
%134 = call double @llvm.fmuladd.f64(double %116, double %121, double %133)
store double %134, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.vn, i64 0, i64 1)
%135 = load double*, double** %12
%136 = load i32, i32* @inside_.i1
%137 = sext i32 %136 to i64
%138 = getelementptr inbounds double, double* %135, i64 %137
%139 = load double, double* %138
%140 = load double*, double** %13
%141 = load i32, i32* @inside_.i2
%142 = sext i32 %141 to i64
%143 = getelementptr inbounds double, double* %140, i64 %142
%144 = load double, double* %143
%145 = load double*, double** %13
%146 = load i32, i32* @inside_.i1
%147 = sext i32 %146 to i64
%148 = getelementptr inbounds double, double* %145, i64 %147
%149 = load double, double* %148
%150 = load double*, double** %12
%151 = load i32, i32* @inside_.i2
%152 = sext i32 %151 to i64
%153 = getelementptr inbounds double, double* %150, i64 %152
%154 = load double, double* %153
%155 = fmul double %149, %154
%156 = fneg double %155
%157 = call double @llvm.fmuladd.f64(double %139, double %144, double %156)
store double %157, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.vn, i64 0, i64 2)
%158 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.vn, i64 0, i64 0)
%159 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.vn, i64 0, i64 0)
%160 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.vn, i64 0, i64 1)
%161 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.vn, i64 0, i64 1)
%162 = fmul double %160, %161
%163 = call double @llvm.fmuladd.f64(double %158, double %159, double %162)
%164 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.vn, i64 0, i64 2)
%165 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.vn, i64 0, i64 2)
%166 = call double @llvm.fmuladd.f64(double %164, double %165, double %163)
%167 = call double @sqrt(double %166)
store double %167, double* @inside_.vnrm
%168 = load double, double* @inside_.vnrm
%169 = fcmp oeq double %168, 0.000000e+00
br i1 %169, label %170, label %171
170: ; preds = %88
br label %53
171: ; preds = %88
%172 = load double*, double** %12
%173 = load i32, i32* @inside_.i1
%174 = sext i32 %173 to i64
%175 = getelementptr inbounds double, double* %172, i64 %174
%176 = load double, double* %175
%177 = load double*, double** %12
%178 = load i32, i32* @inside_.i2
%179 = sext i32 %178 to i64
%180 = getelementptr inbounds double, double* %177, i64 %179
%181 = load double, double* %180
%182 = fadd double %176, %181
%183 = load double, double* @inside_.eps
%184 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.vn, i64 0, i64 0)
%185 = fmul double %183, %184
%186 = load double, double* @inside_.vnrm
%187 = fdiv double %185, %186
%188 = fadd double %182, %187
store double %188, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.q, i64 0, i64 0)
%189 = load double*, double** %13
%190 = load i32, i32* @inside_.i1
%191 = sext i32 %190 to i64
%192 = getelementptr inbounds double, double* %189, i64 %191
%193 = load double, double* %192
%194 = load double*, double** %13
%195 = load i32, i32* @inside_.i2
%196 = sext i32 %195 to i64
%197 = getelementptr inbounds double, double* %194, i64 %196
%198 = load double, double* %197
%199 = fadd double %193, %198
%200 = load double, double* @inside_.eps
%201 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.vn, i64 0, i64 1)
%202 = fmul double %200, %201
%203 = load double, double* @inside_.vnrm
%204 = fdiv double %202, %203
%205 = fadd double %199, %204
store double %205, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.q, i64 0, i64 1)
%206 = load double*, double** %14
%207 = load i32, i32* @inside_.i1
%208 = sext i32 %207 to i64
%209 = getelementptr inbounds double, double* %206, i64 %208
%210 = load double, double* %209
%211 = load double*, double** %14
%212 = load i32, i32* @inside_.i2
%213 = sext i32 %212 to i64
%214 = getelementptr inbounds double, double* %211, i64 %213
%215 = load double, double* %214
%216 = fadd double %210, %215
%217 = load double, double* @inside_.eps
%218 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.vn, i64 0, i64 2)
%219 = fmul double %217, %218
%220 = load double, double* @inside_.vnrm
%221 = fdiv double %219, %220
%222 = fadd double %216, %221
store double %222, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.q, i64 0, i64 2)
%223 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.q, i64 0, i64 0)
%224 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.q, i64 0, i64 0)
%225 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.q, i64 0, i64 1)
%226 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.q, i64 0, i64 1)
%227 = fmul double %225, %226
%228 = call double @llvm.fmuladd.f64(double %223, double %224, double %227)
%229 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.q, i64 0, i64 2)
%230 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.q, i64 0, i64 2)
%231 = call double @llvm.fmuladd.f64(double %229, double %230, double %228)
%232 = call double @sqrt(double %231)
store double %232, double* @inside_.qnrm
%233 = load double, double* @inside_.qnrm
%234 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.q, i64 0, i64 0)
%235 = fdiv double %234, %233
store double %235, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.q, i64 0, i64 0)
%236 = load double, double* @inside_.qnrm
%237 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.q, i64 0, i64 1)
%238 = fdiv double %237, %236
store double %238, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.q, i64 0, i64 1)
%239 = load double, double* @inside_.qnrm
%240 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.q, i64 0, i64 2)
%241 = fdiv double %240, %239
store double %241, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.q, i64 0, i64 2)
%242 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.q, i64 0, i64 1)
%243 = load double*, double** %10
%244 = getelementptr inbounds double, double* %243, i64 3
%245 = load double, double* %244
%246 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.q, i64 0, i64 2)
%247 = load double*, double** %10
%248 = getelementptr inbounds double, double* %247, i64 2
%249 = load double, double* %248
%250 = fmul double %246, %249
%251 = fneg double %250
%252 = call double @llvm.fmuladd.f64(double %242, double %245, double %251)
store double %252, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.cn, i64 0, i64 0)
%253 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.q, i64 0, i64 2)
%254 = load double*, double** %10
%255 = getelementptr inbounds double, double* %254, i64 1
%256 = load double, double* %255
%257 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.q, i64 0, i64 0)
%258 = load double*, double** %10
%259 = getelementptr inbounds double, double* %258, i64 3
%260 = load double, double* %259
%261 = fmul double %257, %260
%262 = fneg double %261
%263 = call double @llvm.fmuladd.f64(double %253, double %256, double %262)
store double %263, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.cn, i64 0, i64 1)
%264 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.q, i64 0, i64 0)
%265 = load double*, double** %10
%266 = getelementptr inbounds double, double* %265, i64 2
%267 = load double, double* %266
%268 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.q, i64 0, i64 1)
%269 = load double*, double** %10
%270 = getelementptr inbounds double, double* %269, i64 1
%271 = load double, double* %270
%272 = fmul double %268, %271
%273 = fneg double %272
%274 = call double @llvm.fmuladd.f64(double %264, double %267, double %273)
store double %274, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.cn, i64 0, i64 2)
%275 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.cn, i64 0, i64 0)
%276 = fcmp oeq double %275, 0.000000e+00
br i1 %276, label %277, label %284
277: ; preds = %171
%278 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.cn, i64 0, i64 1)
%279 = fcmp oeq double %278, 0.000000e+00
br i1 %279, label %280, label %284
280: ; preds = %277
%281 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.cn, i64 0, i64 2)
%282 = fcmp oeq double %281, 0.000000e+00
br i1 %282, label %283, label %284
283: ; preds = %280
br label %53
284: ; preds = %280, %277, %171
%285 = load double*, double** %10
%286 = getelementptr inbounds double, double* %285, i64 2
%287 = load double, double* %286
%288 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.cn, i64 0, i64 2)
%289 = load double*, double** %10
%290 = getelementptr inbounds double, double* %289, i64 3
%291 = load double, double* %290
%292 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.cn, i64 0, i64 1)
%293 = fmul double %291, %292
%294 = fneg double %293
%295 = call double @llvm.fmuladd.f64(double %287, double %288, double %294)
store double %295, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.pn, i64 0, i64 0)
%296 = load double*, double** %10
%297 = getelementptr inbounds double, double* %296, i64 3
%298 = load double, double* %297
%299 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.cn, i64 0, i64 0)
%300 = load double*, double** %10
%301 = getelementptr inbounds double, double* %300, i64 1
%302 = load double, double* %301
%303 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.cn, i64 0, i64 2)
%304 = fmul double %302, %303
%305 = fneg double %304
%306 = call double @llvm.fmuladd.f64(double %298, double %299, double %305)
store double %306, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.pn, i64 0, i64 1)
%307 = load double*, double** %10
%308 = getelementptr inbounds double, double* %307, i64 1
%309 = load double, double* %308
%310 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.cn, i64 0, i64 1)
%311 = load double*, double** %10
%312 = getelementptr inbounds double, double* %311, i64 2
%313 = load double, double* %312
%314 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.cn, i64 0, i64 0)
%315 = fmul double %313, %314
%316 = fneg double %315
%317 = call double @llvm.fmuladd.f64(double %309, double %310, double %316)
store double %317, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.pn, i64 0, i64 2)
%318 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.cn, i64 0, i64 1)
%319 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.q, i64 0, i64 2)
%320 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.cn, i64 0, i64 2)
%321 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.q, i64 0, i64 1)
%322 = fmul double %320, %321
%323 = fneg double %322
%324 = call double @llvm.fmuladd.f64(double %318, double %319, double %323)
store double %324, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.qn, i64 0, i64 0)
%325 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.cn, i64 0, i64 2)
%326 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.q, i64 0, i64 0)
%327 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.cn, i64 0, i64 0)
%328 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.q, i64 0, i64 2)
%329 = fmul double %327, %328
%330 = fneg double %329
%331 = call double @llvm.fmuladd.f64(double %325, double %326, double %330)
store double %331, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.qn, i64 0, i64 1)
%332 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.cn, i64 0, i64 0)
%333 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.q, i64 0, i64 1)
%334 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.cn, i64 0, i64 1)
%335 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.q, i64 0, i64 0)
%336 = fmul double %334, %335
%337 = fneg double %336
%338 = call double @llvm.fmuladd.f64(double %332, double %333, double %337)
store double %338, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.qn, i64 0, i64 2)
store i32 0, i32* @inside_.ni
store i32 1, i32* @inside_.even
store double -2.000000e+00, double* @inside_.bp
store double -2.000000e+00, double* @inside_.bq
store i32 1, i32* @inside_.pinr
store i32 1, i32* @inside_.qinr
%339 = load i32*, i32** %16
%340 = load i32, i32* @inside_.n
%341 = sext i32 %340 to i64
%342 = getelementptr inbounds i32, i32* %339, i64 %341
%343 = load i32, i32* %342
store i32 %343, i32* @inside_.i2
%344 = load i32, i32* @inside_.i2
%345 = icmp slt i32 %344, 1
br i1 %345, label %350, label %346
346: ; preds = %284
%347 = load i32, i32* @inside_.i2
%348 = load i32, i32* @inside_.imx
%349 = icmp sgt i32 %347, %348
br i1 %349, label %350, label %351
350: ; preds = %346, %284
br label %548
351: ; preds = %346
%352 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.cn, i64 0, i64 0)
%353 = load double*, double** %12
%354 = load i32, i32* @inside_.i2
%355 = sext i32 %354 to i64
%356 = getelementptr inbounds double, double* %353, i64 %355
%357 = load double, double* %356
%358 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.cn, i64 0, i64 1)
%359 = load double*, double** %13
%360 = load i32, i32* @inside_.i2
%361 = sext i32 %360 to i64
%362 = getelementptr inbounds double, double* %359, i64 %361
%363 = load double, double* %362
%364 = fmul double %358, %363
%365 = call double @llvm.fmuladd.f64(double %352, double %357, double %364)
%366 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.cn, i64 0, i64 2)
%367 = load double*, double** %14
%368 = load i32, i32* @inside_.i2
%369 = sext i32 %368 to i64
%370 = getelementptr inbounds double, double* %367, i64 %369
%371 = load double, double* %370
%372 = call double @llvm.fmuladd.f64(double %366, double %371, double %365)
%373 = fcmp ogt double %372, 0.000000e+00
%374 = zext i1 %373 to i32
store i32 %374, i32* @inside_.lft2
%375 = load i32, i32* @inside_.n
store i32 %375, i32* %18
store i32 1, i32* @inside_.k
br label %376
376: ; preds = %523, %351
%377 = load i32, i32* @inside_.k
%378 = load i32, i32* %18
%379 = icmp sle i32 %377, %378
br i1 %379, label %380, label %526
380: ; preds = %376
%381 = load i32, i32* @inside_.i2
store i32 %381, i32* @inside_.i1
%382 = load i32, i32* @inside_.lft2
store i32 %382, i32* @inside_.lft1
%383 = load i32*, i32** %16
%384 = load i32, i32* @inside_.k
%385 = sext i32 %384 to i64
%386 = getelementptr inbounds i32, i32* %383, i64 %385
%387 = load i32, i32* %386
store i32 %387, i32* @inside_.i2
%388 = load i32, i32* @inside_.i2
%389 = icmp slt i32 %388, 1
br i1 %389, label %394, label %390
390: ; preds = %380
%391 = load i32, i32* @inside_.i2
%392 = load i32, i32* @inside_.imx
%393 = icmp sgt i32 %391, %392
br i1 %393, label %394, label %395
394: ; preds = %390, %380
br label %548
395: ; preds = %390
%396 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.cn, i64 0, i64 0)
%397 = load double*, double** %12
%398 = load i32, i32* @inside_.i2
%399 = sext i32 %398 to i64
%400 = getelementptr inbounds double, double* %397, i64 %399
%401 = load double, double* %400
%402 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.cn, i64 0, i64 1)
%403 = load double*, double** %13
%404 = load i32, i32* @inside_.i2
%405 = sext i32 %404 to i64
%406 = getelementptr inbounds double, double* %403, i64 %405
%407 = load double, double* %406
%408 = fmul double %402, %407
%409 = call double @llvm.fmuladd.f64(double %396, double %401, double %408)
%410 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.cn, i64 0, i64 2)
%411 = load double*, double** %14
%412 = load i32, i32* @inside_.i2
%413 = sext i32 %412 to i64
%414 = getelementptr inbounds double, double* %411, i64 %413
%415 = load double, double* %414
%416 = call double @llvm.fmuladd.f64(double %410, double %415, double %409)
%417 = fcmp ogt double %416, 0.000000e+00
%418 = zext i1 %417 to i32
store i32 %418, i32* @inside_.lft2
%419 = load i32, i32* @inside_.lft1
%420 = load i32, i32* @inside_.lft2
%421 = icmp eq i32 %419, %420
br i1 %421, label %422, label %423
422: ; preds = %395
br label %522
423: ; preds = %395
%424 = load i32, i32* @inside_.ni
%425 = add nsw i32 %424, 1
store i32 %425, i32* @inside_.ni
%426 = load double*, double** %12
%427 = load i32, i32* @inside_.i1
%428 = sext i32 %427 to i64
%429 = getelementptr inbounds double, double* %426, i64 %428
%430 = load double, double* %429
store double %430, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.v1, i64 0, i64 0)
%431 = load double*, double** %13
%432 = load i32, i32* @inside_.i1
%433 = sext i32 %432 to i64
%434 = getelementptr inbounds double, double* %431, i64 %433
%435 = load double, double* %434
store double %435, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.v1, i64 0, i64 1)
%436 = load double*, double** %14
%437 = load i32, i32* @inside_.i1
%438 = sext i32 %437 to i64
%439 = getelementptr inbounds double, double* %436, i64 %438
%440 = load double, double* %439
store double %440, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.v1, i64 0, i64 2)
%441 = load double*, double** %12
%442 = load i32, i32* @inside_.i2
%443 = sext i32 %442 to i64
%444 = getelementptr inbounds double, double* %441, i64 %443
%445 = load double, double* %444
store double %445, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.v2, i64 0, i64 0)
%446 = load double*, double** %13
%447 = load i32, i32* @inside_.i2
%448 = sext i32 %447 to i64
%449 = getelementptr inbounds double, double* %446, i64 %448
%450 = load double, double* %449
store double %450, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.v2, i64 0, i64 1)
%451 = load double*, double** %14
%452 = load i32, i32* @inside_.i2
%453 = sext i32 %452 to i64
%454 = getelementptr inbounds double, double* %451, i64 %453
%455 = load double, double* %454
store double %455, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.v2, i64 0, i64 2)
%456 = call i32 (double*, double*, double*, double*, i32*, ...) bitcast (i32 (...)* @intrsc_ to i32 (double*, double*, double*, double*, i32*, ...)*)(double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.v1, i64 0, i64 0), double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.v2, i64 0, i64 0), double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.cn, i64 0, i64 0), double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.b, i64 0, i64 0), i32* @inside_.ierr)
%457 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.b, i64 0, i64 0)
%458 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.qn, i64 0, i64 0)
%459 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.b, i64 0, i64 1)
%460 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.qn, i64 0, i64 1)
%461 = fmul double %459, %460
%462 = call double @llvm.fmuladd.f64(double %457, double %458, double %461)
%463 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.b, i64 0, i64 2)
%464 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.qn, i64 0, i64 2)
%465 = call double @llvm.fmuladd.f64(double %463, double %464, double %462)
%466 = fcmp ogt double %465, 0.000000e+00
br i1 %466, label %467, label %521
467: ; preds = %423
%468 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.b, i64 0, i64 0)
%469 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.pn, i64 0, i64 0)
%470 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.b, i64 0, i64 1)
%471 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.pn, i64 0, i64 1)
%472 = fmul double %470, %471
%473 = call double @llvm.fmuladd.f64(double %468, double %469, double %472)
%474 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.b, i64 0, i64 2)
%475 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.pn, i64 0, i64 2)
%476 = call double @llvm.fmuladd.f64(double %474, double %475, double %473)
%477 = fcmp ogt double %476, 0.000000e+00
br i1 %477, label %478, label %521
478: ; preds = %467
%479 = load i32, i32* @inside_.even
%480 = icmp ne i32 %479, 0
%481 = xor i1 %480, true
%482 = zext i1 %481 to i32
store i32 %482, i32* @inside_.even
%483 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.b, i64 0, i64 0)
%484 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.q, i64 0, i64 0)
%485 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.b, i64 0, i64 1)
%486 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.q, i64 0, i64 1)
%487 = fmul double %485, %486
%488 = call double @llvm.fmuladd.f64(double %483, double %484, double %487)
%489 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.b, i64 0, i64 2)
%490 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.q, i64 0, i64 2)
%491 = call double @llvm.fmuladd.f64(double %489, double %490, double %488)
store double %491, double* @inside_.d__
%492 = load double, double* @inside_.d__
%493 = load double, double* @inside_.bq
%494 = fcmp ogt double %492, %493
br i1 %494, label %495, label %498
495: ; preds = %478
%496 = load double, double* @inside_.d__
store double %496, double* @inside_.bq
%497 = load i32, i32* @inside_.lft2
store i32 %497, i32* @inside_.qinr
br label %498
498: ; preds = %495, %478
%499 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.b, i64 0, i64 0)
%500 = load double*, double** %10
%501 = getelementptr inbounds double, double* %500, i64 1
%502 = load double, double* %501
%503 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.b, i64 0, i64 1)
%504 = load double*, double** %10
%505 = getelementptr inbounds double, double* %504, i64 2
%506 = load double, double* %505
%507 = fmul double %503, %506
%508 = call double @llvm.fmuladd.f64(double %499, double %502, double %507)
%509 = load double, double* getelementptr inbounds ([3 x double], [3 x double]* @inside_.b, i64 0, i64 2)
%510 = load double*, double** %10
%511 = getelementptr inbounds double, double* %510, i64 3
%512 = load double, double* %511
%513 = call double @llvm.fmuladd.f64(double %509, double %512, double %508)
store double %513, double* @inside_.d__
%514 = load double, double* @inside_.d__
%515 = load double, double* @inside_.bp
%516 = fcmp ogt double %514, %515
br i1 %516, label %517, label %520
517: ; preds = %498
%518 = load double, double* @inside_.d__
store double %518, double* @inside_.bp
%519 = load i32, i32* @inside_.lft1
store i32 %519, i32* @inside_.pinr
br label %520
520: ; preds = %517, %498
br label %521
521: ; preds = %520, %467, %423
br label %522
522: ; preds = %521, %422
br label %523
523: ; preds = %522
%524 = load i32, i32* @inside_.k
%525 = add nsw i32 %524, 1
store i32 %525, i32* @inside_.k
br label %376
526: ; preds = %376
%527 = load i32, i32* @inside_.ni
%528 = load i32, i32* @inside_.ni
%529 = sdiv i32 %528, 2
%530 = shl i32 %529, 1
%531 = icmp ne i32 %527, %530
br i1 %531, label %535, label %532
532: ; preds = %526
%533 = load i32, i32* @inside_.qinr
%534 = icmp ne i32 %533, 0
br i1 %534, label %536, label %535
535: ; preds = %532, %526
br label %53
536: ; preds = %532
%537 = load i32, i32* @inside_.pinr
%538 = load i32, i32* @inside_.even
%539 = icmp ne i32 %537, %538
br i1 %539, label %540, label %541
540: ; preds = %536
br label %551
541: ; preds = %536
%542 = load i32*, i32** %17
store i32 0, i32* %542
%543 = load i32, i32* @inside_.even
store i32 %543, i32* %19
%544 = load i32, i32* %19
store i32 %544, i32* %9
br label %557
545: ; preds = %40
%546 = load i32*, i32** %17
store i32 1, i32* %546
%547 = load i32, i32* %19
store i32 %547, i32* %9
br label %557
548: ; preds = %394, %350, %87, %51
%549 = load i32*, i32** %17
store i32 2, i32* %549
%550 = load i32, i32* %19
store i32 %550, i32* %9
br label %557
551: ; preds = %540
%552 = load i32*, i32** %17
store i32 3, i32* %552
%553 = load i32, i32* %19
store i32 %553, i32* %9
br label %557
554: ; preds = %59
%555 = load i32*, i32** %17
store i32 4, i32* %555
%556 = load i32, i32* %19
store i32 %556, i32* %9
br label %557
557: ; preds = %554, %551, %548, %545, %541
%558 = load i32, i32* %9
ret i32 %558
}

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