#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 DBL_MAX;
int /*<<< orphan*/ abort();
double fabs(double);
void RSimplex(double **A, double *b, int jStrt, int jEnd, int m, double *xb,
              double *sb, int *ib, double **binv, int *info) {
  int i, j, k, ell;
  int ibrk;
  double sigb, sum, vkmin;
  double eps = 1.0e-6;
  double tol = 1.0e-10;
  *info = -1;
  for (i = 0; i < m; i++) {
    if (ib[i] == jStrt) {
      *info = i;
      break;
    }
  }
  while (1) {
    if (*info == -1) {
      k = jStrt;
      vkmin = -1.0e0;
    } else {
      k = -1;
      vkmin = DBL_MAX;
      for (i = jStrt; i <= jEnd; i++) {
        ibrk = 0;
        for (j = 0; j < m; j++) {
          if (i == ib[j]) {
            ibrk = 1;
            break;
          }
        }
        if (ibrk)
          continue;
        sum = 0.0e0;
        for (j = 0; j < m; j++)
          sum += A[i][j] * binv[*info][j];
        if (sum < vkmin) {
          vkmin = sum;
          k = i;
        }
      }
      if (vkmin > -eps)
        return;
    }
    for (i = 0; i < m; i++) {
      sum = 0.0e0;
      for (j = 0; j < m; j++)
        sum += binv[i][j] * A[k][j];
      sb[i] = sum;
    }
    ell = 0;
    sigb = DBL_MAX;
    for (i = 0; i < m; i++) {
      if (sb[i] > eps && (xb[i] / sb[i]) < sigb) {
        sigb = (xb[i] / sb[i]);
        ell = i;
      }
    }
    sum = 0.0e0;
    for (i = 0; i < m; i++)
      sum += binv[ell][i] * A[k][i];
    if (fabs(sum) <= eps)
      abort();
    sum = 1.0e0 / sum;
    for (i = 0; i < m; i++)
      binv[ell][i] *= sum;
    for (j = 0; j < m; j++) {
      if (j != ell) {
        sum = 0.0e0;
        for (i = 0; i < m; i++)
          sum += binv[j][i] * A[k][i];
        for (i = 0; i < m; i++)
          binv[j][i] -= sum * binv[ell][i];
      }
    }
    for (i = 0; i < m; i++) {
      sum = 0.0e0;
      for (j = 0; j < m; j++)
        sum += binv[i][j] * b[j];
      xb[i] = sum;
    }
    if (ib[ell] == jStrt)
      *info = 0;
    ib[ell] = k;
    if (k == jStrt) {
      *info = ell;
      if (xb[*info] > tol)
        return;
    }
  }
}


x86 assembly (clang, -O0):
<RSimplex>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
mov    %r9,-0x28(%rbp)
movsd  0xec2(%rip),%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  0xead(%rip),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    0x28(%rbp),%rax
movl   $0xffffffff,(%rax)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    11aa <RSimplex+0x9a>
mov    0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x14(%rbp),%eax
jne    1197 <RSimplex+0x87>
mov    -0x2c(%rbp),%ecx
mov    0x28(%rbp),%rax
mov    %ecx,(%rax)
jmp    11aa <RSimplex+0x9a>
jmp    119c <RSimplex+0x8c>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1169 <RSimplex+0x59>
jmp    11af <RSimplex+0x9f>
mov    0x28(%rbp),%rax
cmpl   $0xffffffff,(%rax)
jne    11d4 <RSimplex+0xc4>
mov    -0x14(%rbp),%eax
mov    %eax,-0x34(%rbp)
movsd  0xe46(%rip),%xmm0
movsd  %xmm0,-0x58(%rbp)
jmp    132d <RSimplex+0x21d>
movl   $0xffffffff,-0x34(%rbp)
mov    0x2dfe(%rip),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jg     12f8 <RSimplex+0x1e8>
movl   $0x0,-0x3c(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    124a <RSimplex+0x13a>
mov    -0x2c(%rbp),%eax
mov    0x18(%rbp),%rcx
movslq -0x30(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jne    1237 <RSimplex+0x127>
movl   $0x1,-0x3c(%rbp)
jmp    124a <RSimplex+0x13a>
jmp    123c <RSimplex+0x12c>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    120b <RSimplex+0xfb>
cmpl   $0x0,-0x3c(%rbp)
je     1259 <RSimplex+0x149>
jmp    12ea <RSimplex+0x1da>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    12c1 <RSimplex+0x1b1>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
mov    0x28(%rbp),%rcx
movslq (%rcx),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1268 <RSimplex+0x158>
movsd  -0x50(%rbp),%xmm1
movsd  -0x58(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    12e5 <RSimplex+0x1d5>
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    12ea <RSimplex+0x1da>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11f1 <RSimplex+0xe1>
movsd  -0x58(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm1
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
ucomisd %xmm1,%xmm0
jbe    1328 <RSimplex+0x218>
jmp    1750 <RSimplex+0x640>
jmp    132d <RSimplex+0x21d>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    13c5 <RSimplex+0x2b5>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    13a5 <RSimplex+0x295>
mov    0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    134f <RSimplex+0x23f>
movsd  -0x50(%rbp),%xmm0
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1334 <RSimplex+0x224>
movl   $0x0,-0x38(%rbp)
mov    0x2c0d(%rip),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x48(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1468 <RSimplex+0x358>
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0x60(%rbp),%xmm0
jbe    1455 <RSimplex+0x345>
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm1
movsd  -0x48(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    1455 <RSimplex+0x345>
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x38(%rbp)
jmp    145a <RSimplex+0x34a>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    13e3 <RSimplex+0x2d3>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    14cd <RSimplex+0x3bd>
mov    0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1477 <RSimplex+0x367>
movsd  -0x50(%rbp),%xmm1
movaps 0xb47(%rip),%xmm0
pand   %xmm0,%xmm1
movsd  -0x60(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     14f3 <RSimplex+0x3e3>
mov    $0x0,%al
call   1030 <abort@plt>
movsd  0xb1d(%rip),%xmm0
divsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1545 <RSimplex+0x435>
movsd  -0x50(%rbp),%xmm0
mov    0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    150c <RSimplex+0x3fc>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1655 <RSimplex+0x545>
mov    -0x30(%rbp),%eax
cmp    -0x38(%rbp),%eax
je     1642 <RSimplex+0x532>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    15c9 <RSimplex+0x4b9>
mov    0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1573 <RSimplex+0x463>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    163d <RSimplex+0x52d>
movsd  -0x50(%rbp),%xmm0
mov    0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    15d0 <RSimplex+0x4c0>
jmp    1642 <RSimplex+0x532>
jmp    1647 <RSimplex+0x537>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    154c <RSimplex+0x43c>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    16e5 <RSimplex+0x5d5>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    16c5 <RSimplex+0x5b5>
mov    0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x50(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1677 <RSimplex+0x567>
movsd  -0x50(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    165c <RSimplex+0x54c>
mov    0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x14(%rbp),%eax
jne    1703 <RSimplex+0x5f3>
mov    0x28(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x34(%rbp),%edx
mov    0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jne    174b <RSimplex+0x63b>
mov    -0x38(%rbp),%ecx
mov    0x28(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x28(%rbp),%rax
mov    0x28(%rbp),%rcx
movslq (%rcx),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0x68(%rbp),%xmm0
jbe    1746 <RSimplex+0x636>
jmp    1750 <RSimplex+0x640>
jmp    174b <RSimplex+0x63b>
jmp    11af <RSimplex+0x9f>
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<RSimplex>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
mov    %r9,%r15
mov    %r8d,%r14d
mov    %rcx,0x38(%rsp)
mov    %rdi,0x18(%rsp)
mov    0xc8(%rsp),%rax
mov    0xb8(%rsp),%r8
movl   $0xffffffff,(%rax)
mov    $0xffffffff,%r12d
mov    %r14d,%r9d
test   %r14d,%r14d
jle    117e <RSimplex+0x6e>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
cmp    %edx,(%r8,%rax,4)
je     1171 <RSimplex+0x61>
add    $0x1,%rax
cmp    %rax,%r9
jne    1160 <RSimplex+0x50>
jmp    117e <RSimplex+0x6e>
mov    0xc8(%rsp),%rcx
mov    %eax,(%rcx)
mov    %eax,%r12d
movslq %edx,%rax
mov    %rax,0x60(%rsp)
mov    0x38(%rsp),%rax
add    $0x1,%eax
mov    %eax,0x34(%rsp)
lea    -0x1(%r9),%rax
mov    %rax,0x10(%rsp)
mov    %r9d,%r13d
and    $0xfffffffc,%r13d
lea    -0x4(%r13),%rax
mov    %rax,0x50(%rsp)
mov    %rax,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %r9d,%r11d
and    $0x3,%r11d
mov    %r9d,%eax
and    $0xfffffffe,%eax
mov    %rax,0x58(%rsp)
mov    %rcx,%rax
mov    %rcx,0x48(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x40(%rsp)
mov    %r9,%rax
neg    %rax
mov    %rax,0x70(%rsp)
movsd  0xe1c(%rip),%xmm0
movapd 0xe2b(%rip),%xmm11
movsd  0xe12(%rip),%xmm9
movapd 0xe29(%rip),%xmm12
movsd  0xe08(%rip),%xmm8
movsd  0xde7(%rip),%xmm10
mov    %r15,0x68(%rsp)
mov    %edx,0xc(%rsp)
jmp    1233 <RSimplex+0x123>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%rax),%r12d
mov    %edx,%r10d
cmp    $0xffffffff,%r12d
je     1262 <RSimplex+0x152>
mov    0x2d9d(%rip),%rax
movsd  (%rax),%xmm6
cmp    0x38(%rsp),%edx
jle    1430 <RSimplex+0x320>
mov    $0xffffffff,%r10d
ucomisd %xmm10,%xmm6
ja     1b46 <RSimplex+0xa36>
xor    %r12d,%r12d
movslq %r10d,%rbx
test   %r14d,%r14d
jle    1420 <RSimplex+0x310>
mov    0x18(%rsp),%rdi
mov    %rbx,%rdx
mov    (%rdi,%rbx,8),%rbx
xor    %edi,%edi
jmp    12aa <RSimplex+0x19a>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0xb0(%rsp),%rax
movsd  %xmm6,(%rax,%rdi,8)
add    $0x1,%rdi
cmp    %r9,%rdi
je     1370 <RSimplex+0x260>
mov    0xc0(%rsp),%rax
mov    (%rax,%rdi,8),%rbp
cmpq   $0x3,0x10(%rsp)
jae    12d0 <RSimplex+0x1c0>
xorpd  %xmm6,%xmm6
xor    %ecx,%ecx
jmp    1328 <RSimplex+0x218>
cs nopw 0x0(%rax,%rax,1)
xorpd  %xmm6,%xmm6
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rcx,8),%xmm2
movsd  0x8(%rbp,%rcx,8),%xmm4
mulsd  (%rbx,%rcx,8),%xmm2
mulsd  0x8(%rbx,%rcx,8),%xmm4
addsd  %xmm6,%xmm2
movsd  0x10(%rbp,%rcx,8),%xmm5
mulsd  0x10(%rbx,%rcx,8),%xmm5
addsd  %xmm2,%xmm4
movsd  0x18(%rbp,%rcx,8),%xmm6
mulsd  0x18(%rbx,%rcx,8),%xmm6
addsd  %xmm4,%xmm5
addsd  %xmm5,%xmm6
add    $0x4,%rcx
cmp    %rcx,%r13
jne    12e0 <RSimplex+0x1d0>
test   $0x3,%r9b
je     1290 <RSimplex+0x180>
lea    (%rbx,%rcx,8),%rax
lea    0x0(,%rcx,8),%rcx
add    %rbp,%rcx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rcx,%rbp,8),%xmm2
mulsd  (%rax,%rbp,8),%xmm2
addsd  %xmm2,%xmm6
add    $0x1,%rbp
cmp    %rbp,%r11
jne    1350 <RSimplex+0x240>
jmp    1290 <RSimplex+0x180>
nopl   0x0(%rax)
xorpd  %xmm6,%xmm6
test   %r14d,%r14d
jle    1550 <RSimplex+0x440>
mov    0x2c5c(%rip),%rax
movsd  (%rax),%xmm4
cmpq   $0x0,0x10(%rsp)
mov    %rdx,%rbx
je     155f <RSimplex+0x44f>
xor    %eax,%eax
mov    0x58(%rsp),%rbp
xor    %r12d,%r12d
mov    0xc(%rsp),%edx
jmp    13bd <RSimplex+0x2ad>
nopw   0x0(%rax,%rax,1)
add    $0x2,%rax
cmp    %rax,%rbp
je     1568 <RSimplex+0x458>
mov    0xb0(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm2
ucomisd %xmm0,%xmm2
jbe    13e7 <RSimplex+0x2d7>
movsd  (%r15,%rax,8),%xmm7
divsd  %xmm2,%xmm7
ucomisd %xmm7,%xmm4
jbe    13e7 <RSimplex+0x2d7>
mov    %eax,%r12d
movapd %xmm7,%xmm4
mov    0xb0(%rsp),%rcx
movsd  0x8(%rcx,%rax,8),%xmm2
ucomisd %xmm0,%xmm2
jbe    13b0 <RSimplex+0x2a0>
movsd  0x8(%r15,%rax,8),%xmm7
divsd  %xmm2,%xmm7
ucomisd %xmm7,%xmm4
jbe    13b0 <RSimplex+0x2a0>
lea    0x1(%rax),%r12d
movapd %xmm7,%xmm4
jmp    13b0 <RSimplex+0x2a0>
cs nopw 0x0(%rax,%rax,1)
xorpd  %xmm6,%xmm6
jmp    1660 <RSimplex+0x550>
nopl   0x0(%rax)
movslq %r12d,%r12
mov    $0xffffffff,%r10d
mov    0x60(%rsp),%rbx
jmp    144e <RSimplex+0x33e>
add    $0x1,%rbx
cmp    %ebx,0x34(%rsp)
je     1257 <RSimplex+0x147>
xorpd  %xmm7,%xmm7
test   %r14d,%r14d
jle    1530 <RSimplex+0x420>
xor    %eax,%eax
nopl   (%rax)
cmp    %ebx,(%r8,%rax,4)
je     1440 <RSimplex+0x330>
add    $0x1,%rax
cmp    %rax,%r9
jne    1460 <RSimplex+0x350>
test   %r14d,%r14d
jle    1530 <RSimplex+0x420>
mov    0x18(%rsp),%rax
mov    (%rax,%rbx,8),%rax
mov    0xc0(%rsp),%rcx
mov    (%rcx,%r12,8),%rbp
cmpq   $0x3,0x10(%rsp)
jae    149d <RSimplex+0x38d>
xorpd  %xmm7,%xmm7
xor    %ecx,%ecx
jmp    14f8 <RSimplex+0x3e8>
xorpd  %xmm7,%xmm7
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rax,%rcx,8),%xmm2
movsd  0x8(%rax,%rcx,8),%xmm4
mulsd  0x0(%rbp,%rcx,8),%xmm2
mulsd  0x8(%rbp,%rcx,8),%xmm4
addsd  %xmm7,%xmm2
movsd  0x10(%rax,%rcx,8),%xmm5
mulsd  0x10(%rbp,%rcx,8),%xmm5
addsd  %xmm2,%xmm4
movsd  0x18(%rax,%rcx,8),%xmm7
mulsd  0x18(%rbp,%rcx,8),%xmm7
addsd  %xmm4,%xmm5
addsd  %xmm5,%xmm7
add    $0x4,%rcx
cmp    %rcx,%r13
jne    14b0 <RSimplex+0x3a0>
test   %r11,%r11
je     1530 <RSimplex+0x420>
lea    0x0(%rbp,%rcx,8),%rbp
lea    (%rax,%rcx,8),%rax
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movsd  (%rax,%rcx,8),%xmm2
mulsd  0x0(%rbp,%rcx,8),%xmm2
addsd  %xmm2,%xmm7
add    $0x1,%rcx
cmp    %rcx,%r11
jne    1510 <RSimplex+0x400>
nopl   0x0(%rax,%rax,1)
ucomisd %xmm7,%xmm6
jbe    1440 <RSimplex+0x330>
mov    %ebx,%r10d
movapd %xmm7,%xmm6
jmp    1440 <RSimplex+0x330>
cs nopw 0x0(%rax,%rax,1)
xor    %r12d,%r12d
mov    %rdx,%rbx
mov    0xc(%rsp),%edx
jmp    1660 <RSimplex+0x550>
xor    %eax,%eax
xor    %r12d,%r12d
mov    0xc(%rsp),%edx
test   $0x1,%r9b
je     15a0 <RSimplex+0x490>
mov    0xb0(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm7
ucomisd %xmm0,%xmm7
jbe    15a0 <RSimplex+0x490>
movsd  (%r15,%rax,8),%xmm2
divsd  %xmm7,%xmm2
ucomisd %xmm2,%xmm4
jbe    15a0 <RSimplex+0x490>
mov    %eax,%r12d
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
test   %r14d,%r14d
jle    1660 <RSimplex+0x550>
movslq %r12d,%rax
mov    0xc0(%rsp),%rcx
mov    (%rcx,%rax,8),%rbp
mov    0x18(%rsp),%rax
mov    (%rax,%rbx,8),%rax
cmpq   $0x3,0x10(%rsp)
jae    15d1 <RSimplex+0x4c1>
xorpd  %xmm6,%xmm6
xor    %ecx,%ecx
jmp    1628 <RSimplex+0x518>
xorpd  %xmm6,%xmm6
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rcx,8),%xmm2
movsd  0x8(%rbp,%rcx,8),%xmm4
mulsd  (%rax,%rcx,8),%xmm2
mulsd  0x8(%rax,%rcx,8),%xmm4
addsd  %xmm6,%xmm2
movsd  0x10(%rbp,%rcx,8),%xmm5
mulsd  0x10(%rax,%rcx,8),%xmm5
addsd  %xmm2,%xmm4
movsd  0x18(%rbp,%rcx,8),%xmm6
mulsd  0x18(%rax,%rcx,8),%xmm6
addsd  %xmm4,%xmm5
addsd  %xmm5,%xmm6
add    $0x4,%rcx
cmp    %rcx,%r13
jne    15e0 <RSimplex+0x4d0>
test   $0x3,%r9b
je     1660 <RSimplex+0x550>
lea    (%rax,%rcx,8),%rax
lea    0x0(,%rcx,8),%rcx
add    %rbp,%rcx
xor    %ebp,%ebp
nop
movsd  (%rcx,%rbp,8),%xmm2
mulsd  (%rax,%rbp,8),%xmm2
addsd  %xmm2,%xmm6
add    $0x1,%rbp
cmp    %rbp,%r11
jne    1640 <RSimplex+0x530>
nopw   0x0(%rax,%rax,1)
movapd %xmm6,%xmm2
andpd  %xmm11,%xmm2
ucomisd %xmm2,%xmm0
jae    1b55 <RSimplex+0xa45>
movslq %r12d,%rax
mov    %rax,0x20(%rsp)
test   %r14d,%r14d
jle    1af0 <RSimplex+0x9e0>
movapd %xmm9,%xmm7
divsd  %xmm6,%xmm7
mov    0xc0(%rsp),%rax
mov    0x20(%rsp),%rcx
mov    (%rax,%rcx,8),%rbp
cmp    $0x4,%r14d
jae    16b0 <RSimplex+0x5a0>
xor    %eax,%eax
jmp    1750 <RSimplex+0x640>
nopl   0x0(%rax,%rax,1)
movapd %xmm7,%xmm6
unpcklpd %xmm7,%xmm6
cmpq   $0x0,0x50(%rsp)
je     1b34 <RSimplex+0xa24>
mov    0x40(%rsp),%rax
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movupd 0x0(%rbp,%rcx,8),%xmm2
movupd 0x10(%rbp,%rcx,8),%xmm4
movupd 0x20(%rbp,%rcx,8),%xmm5
movupd 0x30(%rbp,%rcx,8),%xmm1
mulpd  %xmm6,%xmm2
mulpd  %xmm6,%xmm4
movupd %xmm2,0x0(%rbp,%rcx,8)
movupd %xmm4,0x10(%rbp,%rcx,8)
mulpd  %xmm6,%xmm5
mulpd  %xmm6,%xmm1
movupd %xmm5,0x20(%rbp,%rcx,8)
movupd %xmm1,0x30(%rbp,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rax
jne    16d0 <RSimplex+0x5c0>
testb  $0x1,0x48(%rsp)
je     1741 <RSimplex+0x631>
movupd 0x0(%rbp,%rcx,8),%xmm1
movupd 0x10(%rbp,%rcx,8),%xmm2
mulpd  %xmm6,%xmm1
mulpd  %xmm6,%xmm2
movupd %xmm1,0x0(%rbp,%rcx,8)
movupd %xmm2,0x10(%rbp,%rcx,8)
mov    %r13,%rax
cmp    %r9,%r13
je     1769 <RSimplex+0x659>
nopl   0x0(%rax)
movsd  0x0(%rbp,%rax,8),%xmm1
mulsd  %xmm7,%xmm1
movsd  %xmm1,0x0(%rbp,%rax,8)
add    $0x1,%rax
cmp    %rax,%r9
jne    1750 <RSimplex+0x640>
test   %r14d,%r14d
jle    1af0 <RSimplex+0x9e0>
mov    %r10d,0x30(%rsp)
mov    %r12d,0x2c(%rsp)
mov    %r12d,%edi
xor    %r12d,%r12d
jmp    179d <RSimplex+0x68d>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r12
cmp    %r9,%r12
je     1a00 <RSimplex+0x8f0>
cmp    %rdi,%r12
je     1790 <RSimplex+0x680>
mov    0xc0(%rsp),%rax
mov    (%rax,%r12,8),%rdx
mov    0x18(%rsp),%rax
mov    (%rax,%rbx,8),%rbp
cmpq   $0x3,0x10(%rsp)
jae    17d0 <RSimplex+0x6c0>
xorpd  %xmm6,%xmm6
xor    %ecx,%ecx
jmp    1828 <RSimplex+0x718>
nopw   0x0(%rax,%rax,1)
xorpd  %xmm6,%xmm6
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
movsd  (%rdx,%rcx,8),%xmm1
movsd  0x8(%rdx,%rcx,8),%xmm2
mulsd  0x0(%rbp,%rcx,8),%xmm1
mulsd  0x8(%rbp,%rcx,8),%xmm2
addsd  %xmm6,%xmm1
movsd  0x10(%rdx,%rcx,8),%xmm3
mulsd  0x10(%rbp,%rcx,8),%xmm3
addsd  %xmm1,%xmm2
movsd  0x18(%rdx,%rcx,8),%xmm6
mulsd  0x18(%rbp,%rcx,8),%xmm6
addsd  %xmm2,%xmm3
addsd  %xmm3,%xmm6
add    $0x4,%rcx
cmp    %rcx,%r13
jne    17e0 <RSimplex+0x6d0>
test   $0x3,%r9b
je     1857 <RSimplex+0x747>
lea    0x0(,%rcx,8),%rax
add    %rbp,%rax
lea    (%rdx,%rcx,8),%rcx
xor    %edx,%edx
nop
movsd  (%rcx,%rdx,8),%xmm1
mulsd  (%rax,%rdx,8),%xmm1
addsd  %xmm1,%xmm6
add    $0x1,%rdx
cmp    %rdx,%r11
jne    1840 <RSimplex+0x730>
xorpd  %xmm12,%xmm6
mov    0xc0(%rsp),%rax
mov    0x20(%rsp),%rcx
mov    (%rax,%rcx,8),%r15
mov    (%rax,%r12,8),%r10
cmp    $0x4,%r14d
jb     1889 <RSimplex+0x779>
lea    (%r15,%r9,8),%rax
cmp    %rax,%r10
jae    18fd <RSimplex+0x7ed>
lea    (%r10,%r9,8),%rax
cmp    %rax,%r15
jae    18fd <RSimplex+0x7ed>
xor    %edx,%edx
mov    %rdx,%rcx
test   $0x1,%r9b
je     18b1 <RSimplex+0x7a1>
movsd  (%r15,%rdx,8),%xmm1
mulsd  %xmm6,%xmm1
addsd  (%r10,%rdx,8),%xmm1
movsd  %xmm1,(%r10,%rdx,8)
mov    %rdx,%rcx
or     $0x1,%rcx
not    %rdx
cmp    0x70(%rsp),%rdx
je     1790 <RSimplex+0x680>
nop
movsd  (%r15,%rcx,8),%xmm1
mulsd  %xmm6,%xmm1
addsd  (%r10,%rcx,8),%xmm1
movsd  %xmm1,(%r10,%rcx,8)
movsd  0x8(%r15,%rcx,8),%xmm1
mulsd  %xmm6,%xmm1
addsd  0x8(%r10,%rcx,8),%xmm1
movsd  %xmm1,0x8(%r10,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%r9
jne    18c0 <RSimplex+0x7b0>
jmp    1790 <RSimplex+0x680>
mov    %r14d,%eax
movapd %xmm6,%xmm7
unpcklpd %xmm6,%xmm7
cmpq   $0x0,0x50(%rsp)
je     19ed <RSimplex+0x8dd>
mov    0x40(%rsp),%rcx
xor    %r14d,%r14d
nopl   0x0(%rax)
movupd (%r15,%r14,8),%xmm1
movupd 0x10(%r15,%r14,8),%xmm2
mulpd  %xmm7,%xmm1
movupd (%r10,%r14,8),%xmm4
addpd  %xmm1,%xmm4
movupd 0x10(%r10,%r14,8),%xmm1
movupd 0x20(%r10,%r14,8),%xmm5
movupd 0x30(%r10,%r14,8),%xmm3
mulpd  %xmm7,%xmm2
addpd  %xmm1,%xmm2
movupd %xmm4,(%r10,%r14,8)
movupd %xmm2,0x10(%r10,%r14,8)
movupd 0x20(%r15,%r14,8),%xmm1
movupd 0x30(%r15,%r14,8),%xmm2
mulpd  %xmm7,%xmm1
addpd  %xmm5,%xmm1
mulpd  %xmm7,%xmm2
addpd  %xmm3,%xmm2
movupd %xmm1,0x20(%r10,%r14,8)
movupd %xmm2,0x30(%r10,%r14,8)
add    $0x8,%r14
add    $0xfffffffffffffffe,%rcx
jne    1920 <RSimplex+0x810>
testb  $0x1,0x48(%rsp)
je     19d9 <RSimplex+0x8c9>
movupd (%r15,%r14,8),%xmm1
movupd 0x10(%r15,%r14,8),%xmm2
movupd (%r10,%r14,8),%xmm3
movupd 0x10(%r10,%r14,8),%xmm4
mulpd  %xmm7,%xmm1
addpd  %xmm3,%xmm1
mulpd  %xmm7,%xmm2
addpd  %xmm4,%xmm2
movupd %xmm1,(%r10,%r14,8)
movupd %xmm2,0x10(%r10,%r14,8)
mov    %r13,%rdx
cmp    %r9,%r13
mov    %eax,%r14d
je     1790 <RSimplex+0x680>
jmp    188b <RSimplex+0x77b>
xor    %r14d,%r14d
testb  $0x1,0x48(%rsp)
jne    19a2 <RSimplex+0x892>
jmp    19d9 <RSimplex+0x8c9>
nopl   0x0(%rax)
test   %r14d,%r14d
mov    0x68(%rsp),%r15
mov    0xc(%rsp),%edx
mov    0x30(%rsp),%r10d
mov    0x2c(%rsp),%r12d
jle    1af0 <RSimplex+0x9e0>
xor    %ebx,%ebx
jmp    1a33 <RSimplex+0x923>
movsd  %xmm6,(%r15,%rbx,8)
add    $0x1,%rbx
cmp    %r9,%rbx
je     1af0 <RSimplex+0x9e0>
mov    0xc0(%rsp),%rax
mov    (%rax,%rbx,8),%rbp
cmpq   $0x3,0x10(%rsp)
jae    1a50 <RSimplex+0x940>
xorpd  %xmm6,%xmm6
xor    %ecx,%ecx
jmp    1aa8 <RSimplex+0x998>
nop
xorpd  %xmm6,%xmm6
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
movsd  0x0(%rbp,%rcx,8),%xmm1
movsd  0x8(%rbp,%rcx,8),%xmm2
mulsd  (%rsi,%rcx,8),%xmm1
mulsd  0x8(%rsi,%rcx,8),%xmm2
addsd  %xmm6,%xmm1
movsd  0x10(%rbp,%rcx,8),%xmm3
mulsd  0x10(%rsi,%rcx,8),%xmm3
addsd  %xmm1,%xmm2
movsd  0x18(%rbp,%rcx,8),%xmm6
mulsd  0x18(%rsi,%rcx,8),%xmm6
addsd  %xmm2,%xmm3
addsd  %xmm3,%xmm6
add    $0x4,%rcx
cmp    %rcx,%r13
jne    1a60 <RSimplex+0x950>
test   $0x3,%r9b
je     1a20 <RSimplex+0x910>
lea    (%rsi,%rcx,8),%rax
lea    0x0(,%rcx,8),%rcx
add    %rbp,%rcx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movsd  (%rcx,%rbp,8),%xmm1
mulsd  (%rax,%rbp,8),%xmm1
addsd  %xmm1,%xmm6
add    $0x1,%rbp
cmp    %rbp,%r11
jne    1ad0 <RSimplex+0x9c0>
jmp    1a20 <RSimplex+0x910>
nopl   0x0(%rax)
mov    0x20(%rsp),%rdi
cmp    %edx,(%r8,%rdi,4)
jne    1b09 <RSimplex+0x9f9>
mov    0xc8(%rsp),%rax
movl   $0x0,(%rax)
mov    %r10d,(%r8,%rdi,4)
mov    0xc8(%rsp),%rax
cmp    %edx,%r10d
jne    1230 <RSimplex+0x120>
mov    %r12d,(%rax)
movsd  (%r15,%rdi,8),%xmm1
ucomisd %xmm8,%xmm1
jbe    1233 <RSimplex+0x123>
jmp    1b46 <RSimplex+0xa36>
xor    %ecx,%ecx
testb  $0x1,0x48(%rsp)
jne    1721 <RSimplex+0x611>
jmp    1741 <RSimplex+0x631>
add    $0x78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %eax,%eax
call   1030 <abort@plt>

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

LLVM IR (-O2):
@DBL_MAX = global double 0.000000e+00
define void @RSimplex(double** nocapture %0, double* nocapture %1, i32 %2, i32 %3, i32 %4, double* nocapture %5, double* nocapture %6, i32* nocapture %7, double** nocapture %8, i32* nocapture %9) {
store i32 -1, i32* %9
%11 = icmp sgt i32 %4, 0
br i1 %11, label %12, label %24
12: ; preds = %10
%13 = zext i32 %4 to i64
br label %14
14: ; preds = %12, %21
%15 = phi i64 [ 0, %12 ], [ %22, %21 ]
%16 = getelementptr inbounds i32, i32* %7, i64 %15
%17 = load i32, i32* %16
%18 = icmp eq i32 %17, %2
br i1 %18, label %19, label %21
19: ; preds = %14
%20 = trunc i64 %15 to i32
store i32 %20, i32* %9
br label %24
21: ; preds = %14
%22 = add nuw nsw i64 %15, 1
%23 = icmp eq i64 %22, %13
br i1 %23, label %24, label %14
24: ; preds = %21, %10, %19
%25 = phi i32 [ -1, %10 ], [ %20, %19 ], [ -1, %21 ]
%26 = icmp sgt i32 %2, %3
%27 = sext i32 %2 to i64
%28 = add i32 %3, 1
%29 = zext i32 %4 to i64
%30 = zext i32 %4 to i64
%31 = zext i32 %4 to i64
%32 = zext i32 %4 to i64
%33 = zext i32 %4 to i64
%34 = add nsw i64 %32, -1
%35 = and i64 %32, 4294967292
%36 = add nsw i64 %35, -4
%37 = lshr exact i64 %36, 2
%38 = add nuw nsw i64 %37, 1
%39 = and i64 %32, 3
%40 = icmp ult i64 %34, 3
%41 = and i64 %32, 4294967292
%42 = icmp eq i64 %39, 0
%43 = and i64 %32, 3
%44 = icmp ult i64 %34, 3
%45 = and i64 %32, 4294967292
%46 = icmp eq i64 %43, 0
%47 = and i64 %32, 1
%48 = icmp eq i64 %34, 0
%49 = and i64 %32, 4294967294
%50 = icmp eq i64 %47, 0
%51 = and i64 %32, 3
%52 = icmp ult i64 %34, 3
%53 = and i64 %32, 4294967292
%54 = icmp eq i64 %51, 0
%55 = icmp ult i32 %4, 4
%56 = and i64 %29, 4294967292
%57 = and i64 %38, 1
%58 = icmp eq i64 %36, 0
%59 = and i64 %38, 9223372036854775806
%60 = icmp eq i64 %57, 0
%61 = icmp eq i64 %56, %29
%62 = and i64 %32, 3
%63 = icmp ult i64 %34, 3
%64 = and i64 %32, 4294967292
%65 = icmp eq i64 %62, 0
%66 = icmp ult i32 %4, 4
%67 = and i64 %29, 4294967292
%68 = and i64 %38, 1
%69 = icmp eq i64 %36, 0
%70 = and i64 %38, 9223372036854775806
%71 = icmp eq i64 %68, 0
%72 = icmp eq i64 %67, %29
%73 = and i64 %32, 1
%74 = icmp eq i64 %73, 0
%75 = sub nsw i64 0, %32
%76 = and i64 %32, 3
%77 = icmp ult i64 %34, 3
%78 = and i64 %32, 4294967292
%79 = icmp eq i64 %76, 0
br label %80
80: ; preds = %639, %24
%81 = phi i32 [ %25, %24 ], [ %640, %639 ]
%82 = icmp eq i32 %81, -1
br i1 %82, label %168, label %83
83: ; preds = %80
%84 = load double, double* @DBL_MAX
br i1 %26, label %164, label %85
85: ; preds = %83
%86 = sext i32 %81 to i64
%87 = getelementptr inbounds double*, double** %8, i64 %86
br label %88
88: ; preds = %85, %158
%89 = phi i64 [ %27, %85 ], [ %161, %158 ]
%90 = phi double [ %84, %85 ], [ %160, %158 ]
%91 = phi i32 [ -1, %85 ], [ %159, %158 ]
br i1 %11, label %92, label %153
92: ; preds = %88
%93 = trunc i64 %89 to i32
br label %101
94: ; preds = %101
%95 = icmp eq i64 %106, %29
br i1 %95, label %96, label %101
96: ; preds = %94
br i1 %11, label %97, label %153
97: ; preds = %96
%98 = getelementptr inbounds double*, double** %0, i64 %89
%99 = load double*, double** %98
%100 = load double*, double** %87
br i1 %40, label %137, label %107
101: ; preds = %92, %94
%102 = phi i64 [ 0, %92 ], [ %106, %94 ]
%103 = getelementptr inbounds i32, i32* %7, i64 %102
%104 = load i32, i32* %103
%105 = icmp eq i32 %104, %93
%106 = add nuw nsw i64 %102, 1
br i1 %105, label %158, label %94
107: ; preds = %97, %107
%108 = phi i64 [ %134, %107 ], [ 0, %97 ]
%109 = phi double [ %133, %107 ], [ 0.000000e+00, %97 ]
%110 = phi i64 [ %135, %107 ], [ 0, %97 ]
%111 = getelementptr inbounds double, double* %99, i64 %108
%112 = load double, double* %111
%113 = getelementptr inbounds double, double* %100, i64 %108
%114 = load double, double* %113
%115 = tail call double @llvm.fmuladd.f64(double %112, double %114, double %109)
%116 = or i64 %108, 1
%117 = getelementptr inbounds double, double* %99, i64 %116
%118 = load double, double* %117
%119 = getelementptr inbounds double, double* %100, i64 %116
%120 = load double, double* %119
%121 = tail call double @llvm.fmuladd.f64(double %118, double %120, double %115)
%122 = or i64 %108, 2
%123 = getelementptr inbounds double, double* %99, i64 %122
%124 = load double, double* %123
%125 = getelementptr inbounds double, double* %100, i64 %122
%126 = load double, double* %125
%127 = tail call double @llvm.fmuladd.f64(double %124, double %126, double %121)
%128 = or i64 %108, 3
%129 = getelementptr inbounds double, double* %99, i64 %128
%130 = load double, double* %129
%131 = getelementptr inbounds double, double* %100, i64 %128
%132 = load double, double* %131
%133 = tail call double @llvm.fmuladd.f64(double %130, double %132, double %127)
%134 = add nuw nsw i64 %108, 4
%135 = add i64 %110, 4
%136 = icmp eq i64 %135, %41
br i1 %136, label %137, label %107
137: ; preds = %107, %97
%138 = phi double [ undef, %97 ], [ %133, %107 ]
%139 = phi i64 [ 0, %97 ], [ %134, %107 ]
%140 = phi double [ 0.000000e+00, %97 ], [ %133, %107 ]
br i1 %42, label %153, label %141
141: ; preds = %137, %141
%142 = phi i64 [ %150, %141 ], [ %139, %137 ]
%143 = phi double [ %149, %141 ], [ %140, %137 ]
%144 = phi i64 [ %151, %141 ], [ 0, %137 ]
%145 = getelementptr inbounds double, double* %99, i64 %142
%146 = load double, double* %145
%147 = getelementptr inbounds double, double* %100, i64 %142
%148 = load double, double* %147
%149 = tail call double @llvm.fmuladd.f64(double %146, double %148, double %143)
%150 = add nuw nsw i64 %142, 1
%151 = add i64 %144, 1
%152 = icmp eq i64 %151, %39
br i1 %152, label %153, label %141
153: ; preds = %137, %141, %88, %96
%154 = phi double [ 0.000000e+00, %96 ], [ 0.000000e+00, %88 ], [ %138, %137 ], [ %149, %141 ]
%155 = fcmp olt double %154, %90
br i1 %155, label %156, label %158
156: ; preds = %153
%157 = trunc i64 %89 to i32
br label %158
158: ; preds = %101, %153, %156
%159 = phi i32 [ %157, %156 ], [ %91, %153 ], [ %91, %101 ]
%160 = phi double [ %154, %156 ], [ %90, %153 ], [ %90, %101 ]
%161 = add nsw i64 %89, 1
%162 = trunc i64 %161 to i32
%163 = icmp eq i32 %28, %162
br i1 %163, label %164, label %88
164: ; preds = %158, %83
%165 = phi i32 [ -1, %83 ], [ %159, %158 ]
%166 = phi double [ %84, %83 ], [ %160, %158 ]
%167 = fcmp ogt double %166, 0xBEB0C6F7A0B5ED8D
br i1 %167, label %645, label %168
168: ; preds = %80, %164
%169 = phi i32 [ %165, %164 ], [ %2, %80 ]
br i1 %11, label %170, label %338
170: ; preds = %168
%171 = sext i32 %169 to i64
%172 = getelementptr inbounds double*, double** %0, i64 %171
%173 = load double*, double** %172
br label %174
174: ; preds = %224, %170
%175 = phi i64 [ 0, %170 ], [ %227, %224 ]
%176 = getelementptr inbounds double*, double** %8, i64 %175
%177 = load double*, double** %176
br i1 %44, label %208, label %178
178: ; preds = %174, %178
%179 = phi i64 [ %205, %178 ], [ 0, %174 ]
%180 = phi double [ %204, %178 ], [ 0.000000e+00, %174 ]
%181 = phi i64 [ %206, %178 ], [ 0, %174 ]
%182 = getelementptr inbounds double, double* %177, i64 %179
%183 = load double, double* %182
%184 = getelementptr inbounds double, double* %173, i64 %179
%185 = load double, double* %184
%186 = tail call double @llvm.fmuladd.f64(double %183, double %185, double %180)
%187 = or i64 %179, 1
%188 = getelementptr inbounds double, double* %177, i64 %187
%189 = load double, double* %188
%190 = getelementptr inbounds double, double* %173, i64 %187
%191 = load double, double* %190
%192 = tail call double @llvm.fmuladd.f64(double %189, double %191, double %186)
%193 = or i64 %179, 2
%194 = getelementptr inbounds double, double* %177, i64 %193
%195 = load double, double* %194
%196 = getelementptr inbounds double, double* %173, i64 %193
%197 = load double, double* %196
%198 = tail call double @llvm.fmuladd.f64(double %195, double %197, double %192)
%199 = or i64 %179, 3
%200 = getelementptr inbounds double, double* %177, i64 %199
%201 = load double, double* %200
%202 = getelementptr inbounds double, double* %173, i64 %199
%203 = load double, double* %202
%204 = tail call double @llvm.fmuladd.f64(double %201, double %203, double %198)
%205 = add nuw nsw i64 %179, 4
%206 = add i64 %181, 4
%207 = icmp eq i64 %206, %45
br i1 %207, label %208, label %178
208: ; preds = %178, %174
%209 = phi double [ undef, %174 ], [ %204, %178 ]
%210 = phi i64 [ 0, %174 ], [ %205, %178 ]
%211 = phi double [ 0.000000e+00, %174 ], [ %204, %178 ]
br i1 %46, label %224, label %212
212: ; preds = %208, %212
%213 = phi i64 [ %221, %212 ], [ %210, %208 ]
%214 = phi double [ %220, %212 ], [ %211, %208 ]
%215 = phi i64 [ %222, %212 ], [ 0, %208 ]
%216 = getelementptr inbounds double, double* %177, i64 %213
%217 = load double, double* %216
%218 = getelementptr inbounds double, double* %173, i64 %213
%219 = load double, double* %218
%220 = tail call double @llvm.fmuladd.f64(double %217, double %219, double %214)
%221 = add nuw nsw i64 %213, 1
%222 = add i64 %215, 1
%223 = icmp eq i64 %222, %43
br i1 %223, label %224, label %212
224: ; preds = %212, %208
%225 = phi double [ %209, %208 ], [ %220, %212 ]
%226 = getelementptr inbounds double, double* %6, i64 %175
store double %225, double* %226
%227 = add nuw nsw i64 %175, 1
%228 = icmp eq i64 %227, %30
br i1 %228, label %229, label %174
229: ; preds = %224
br i1 %11, label %230, label %338
230: ; preds = %229
%231 = load double, double* @DBL_MAX
br i1 %48, label %232, label %257
232: ; preds = %286, %230
%233 = phi i32 [ undef, %230 ], [ %287, %286 ]
%234 = phi i64 [ 0, %230 ], [ %289, %286 ]
%235 = phi double [ %231, %230 ], [ %288, %286 ]
%236 = phi i32 [ 0, %230 ], [ %287, %286 ]
br i1 %50, label %248, label %237
237: ; preds = %232
%238 = getelementptr inbounds double, double* %6, i64 %234
%239 = load double, double* %238
%240 = fcmp ogt double %239, 0x3EB0C6F7A0B5ED8D
br i1 %240, label %241, label %248
241: ; preds = %237
%242 = getelementptr inbounds double, double* %5, i64 %234
%243 = load double, double* %242
%244 = fdiv double %243, %239
%245 = fcmp olt double %244, %235
br i1 %245, label %246, label %248
246: ; preds = %241
%247 = trunc i64 %234 to i32
br label %248
248: ; preds = %237, %241, %246, %232
%249 = phi i32 [ %233, %232 ], [ %247, %246 ], [ %236, %241 ], [ %236, %237 ]
br i1 %11, label %250, label %338
250: ; preds = %248
%251 = sext i32 %249 to i64
%252 = getelementptr inbounds double*, double** %8, i64 %251
%253 = load double*, double** %252
%254 = sext i32 %169 to i64
%255 = getelementptr inbounds double*, double** %0, i64 %254
%256 = load double*, double** %255
br i1 %52, label %322, label %292
257: ; preds = %230, %286
%258 = phi i64 [ %289, %286 ], [ 0, %230 ]
%259 = phi double [ %288, %286 ], [ %231, %230 ]
%260 = phi i32 [ %287, %286 ], [ 0, %230 ]
%261 = phi i64 [ %290, %286 ], [ 0, %230 ]
%262 = getelementptr inbounds double, double* %6, i64 %258
%263 = load double, double* %262
%264 = fcmp ogt double %263, 0x3EB0C6F7A0B5ED8D
br i1 %264, label %265, label %272
265: ; preds = %257
%266 = getelementptr inbounds double, double* %5, i64 %258
%267 = load double, double* %266
%268 = fdiv double %267, %263
%269 = fcmp olt double %268, %259
br i1 %269, label %270, label %272
270: ; preds = %265
%271 = trunc i64 %258 to i32
br label %272
272: ; preds = %257, %265, %270
%273 = phi i32 [ %271, %270 ], [ %260, %265 ], [ %260, %257 ]
%274 = phi double [ %268, %270 ], [ %259, %265 ], [ %259, %257 ]
%275 = or i64 %258, 1
%276 = getelementptr inbounds double, double* %6, i64 %275
%277 = load double, double* %276
%278 = fcmp ogt double %277, 0x3EB0C6F7A0B5ED8D
br i1 %278, label %279, label %286
279: ; preds = %272
%280 = getelementptr inbounds double, double* %5, i64 %275
%281 = load double, double* %280
%282 = fdiv double %281, %277
%283 = fcmp olt double %282, %274
br i1 %283, label %284, label %286
284: ; preds = %279
%285 = trunc i64 %275 to i32
br label %286
286: ; preds = %284, %279, %272
%287 = phi i32 [ %285, %284 ], [ %273, %279 ], [ %273, %272 ]
%288 = phi double [ %282, %284 ], [ %274, %279 ], [ %274, %272 ]
%289 = add nuw nsw i64 %258, 2
%290 = add i64 %261, 2
%291 = icmp eq i64 %290, %49
br i1 %291, label %232, label %257
292: ; preds = %250, %292
%293 = phi i64 [ %319, %292 ], [ 0, %250 ]
%294 = phi double [ %318, %292 ], [ 0.000000e+00, %250 ]
%295 = phi i64 [ %320, %292 ], [ 0, %250 ]
%296 = getelementptr inbounds double, double* %253, i64 %293
%297 = load double, double* %296
%298 = getelementptr inbounds double, double* %256, i64 %293
%299 = load double, double* %298
%300 = tail call double @llvm.fmuladd.f64(double %297, double %299, double %294)
%301 = or i64 %293, 1
%302 = getelementptr inbounds double, double* %253, i64 %301
%303 = load double, double* %302
%304 = getelementptr inbounds double, double* %256, i64 %301
%305 = load double, double* %304
%306 = tail call double @llvm.fmuladd.f64(double %303, double %305, double %300)
%307 = or i64 %293, 2
%308 = getelementptr inbounds double, double* %253, i64 %307
%309 = load double, double* %308
%310 = getelementptr inbounds double, double* %256, i64 %307
%311 = load double, double* %310
%312 = tail call double @llvm.fmuladd.f64(double %309, double %311, double %306)
%313 = or i64 %293, 3
%314 = getelementptr inbounds double, double* %253, i64 %313
%315 = load double, double* %314
%316 = getelementptr inbounds double, double* %256, i64 %313
%317 = load double, double* %316
%318 = tail call double @llvm.fmuladd.f64(double %315, double %317, double %312)
%319 = add nuw nsw i64 %293, 4
%320 = add i64 %295, 4
%321 = icmp eq i64 %320, %53
br i1 %321, label %322, label %292
322: ; preds = %292, %250
%323 = phi double [ undef, %250 ], [ %318, %292 ]
%324 = phi i64 [ 0, %250 ], [ %319, %292 ]
%325 = phi double [ 0.000000e+00, %250 ], [ %318, %292 ]
br i1 %54, label %338, label %326
326: ; preds = %322, %326
%327 = phi i64 [ %335, %326 ], [ %324, %322 ]
%328 = phi double [ %334, %326 ], [ %325, %322 ]
%329 = phi i64 [ %336, %326 ], [ 0, %322 ]
%330 = getelementptr inbounds double, double* %253, i64 %327
%331 = load double, double* %330
%332 = getelementptr inbounds double, double* %256, i64 %327
%333 = load double, double* %332
%334 = tail call double @llvm.fmuladd.f64(double %331, double %333, double %328)
%335 = add nuw nsw i64 %327, 1
%336 = add i64 %329, 1
%337 = icmp eq i64 %336, %51
br i1 %337, label %338, label %326
338: ; preds = %322, %326, %168, %229, %248
%339 = phi i32 [ %249, %248 ], [ 0, %229 ], [ 0, %168 ], [ %249, %326 ], [ %249, %322 ]
%340 = phi double [ 0.000000e+00, %248 ], [ 0.000000e+00, %229 ], [ 0.000000e+00, %168 ], [ %323, %322 ], [ %334, %326 ]
%341 = tail call double @llvm.fabs.f64(double %340)
%342 = fcmp ugt double %341, 0x3EB0C6F7A0B5ED8D
br i1 %342, label %345, label %343
343: ; preds = %338
%344 = tail call i32 (...) @abort()
unreachable
345: ; preds = %338
%346 = fdiv double 1.000000e+00, %340
br i1 %11, label %347, label %629
347: ; preds = %345
%348 = sext i32 %339 to i64
%349 = getelementptr inbounds double*, double** %8, i64 %348
%350 = load double*, double** %349
br i1 %55, label %397, label %351
351: ; preds = %347
%352 = insertelement <2 x double> poison, double %346, i64 0
%353 = shufflevector <2 x double> %352, <2 x double> poison, <2 x i32> zeroinitializer
%354 = insertelement <2 x double> poison, double %346, i64 0
%355 = shufflevector <2 x double> %354, <2 x double> poison, <2 x i32> zeroinitializer
br i1 %58, label %383, label %356
356: ; preds = %351, %356
%357 = phi i64 [ %380, %356 ], [ 0, %351 ]
%358 = phi i64 [ %381, %356 ], [ 0, %351 ]
%359 = getelementptr inbounds double, double* %350, i64 %357
%360 = bitcast double* %359 to <2 x double>*
%361 = load <2 x double>, <2 x double>* %360
%362 = getelementptr inbounds double, double* %359, i64 2
%363 = bitcast double* %362 to <2 x double>*
%364 = load <2 x double>, <2 x double>* %363
%365 = fmul <2 x double> %353, %361
%366 = fmul <2 x double> %355, %364
%367 = bitcast double* %359 to <2 x double>*
store <2 x double> %365, <2 x double>* %367
%368 = bitcast double* %362 to <2 x double>*
store <2 x double> %366, <2 x double>* %368
%369 = or i64 %357, 4
%370 = getelementptr inbounds double, double* %350, i64 %369
%371 = bitcast double* %370 to <2 x double>*
%372 = load <2 x double>, <2 x double>* %371
%373 = getelementptr inbounds double, double* %370, i64 2
%374 = bitcast double* %373 to <2 x double>*
%375 = load <2 x double>, <2 x double>* %374
%376 = fmul <2 x double> %353, %372
%377 = fmul <2 x double> %355, %375
%378 = bitcast double* %370 to <2 x double>*
store <2 x double> %376, <2 x double>* %378
%379 = bitcast double* %373 to <2 x double>*
store <2 x double> %377, <2 x double>* %379
%380 = add nuw i64 %357, 8
%381 = add i64 %358, 2
%382 = icmp eq i64 %381, %59
br i1 %382, label %383, label %356
383: ; preds = %356, %351
%384 = phi i64 [ 0, %351 ], [ %380, %356 ]
br i1 %60, label %396, label %385
385: ; preds = %383
%386 = getelementptr inbounds double, double* %350, i64 %384
%387 = bitcast double* %386 to <2 x double>*
%388 = load <2 x double>, <2 x double>* %387
%389 = getelementptr inbounds double, double* %386, i64 2
%390 = bitcast double* %389 to <2 x double>*
%391 = load <2 x double>, <2 x double>* %390
%392 = fmul <2 x double> %353, %388
%393 = fmul <2 x double> %355, %391
%394 = bitcast double* %386 to <2 x double>*
store <2 x double> %392, <2 x double>* %394
%395 = bitcast double* %389 to <2 x double>*
store <2 x double> %393, <2 x double>* %395
br label %396
396: ; preds = %383, %385
br i1 %61, label %399, label %397
397: ; preds = %347, %396
%398 = phi i64 [ 0, %347 ], [ %56, %396 ]
br label %406
399: ; preds = %406, %396
br i1 %11, label %400, label %629
400: ; preds = %399
%401 = sext i32 %169 to i64
%402 = getelementptr inbounds double*, double** %0, i64 %401
%403 = sext i32 %339 to i64
%404 = getelementptr inbounds double*, double** %8, i64 %403
%405 = zext i32 %339 to i64
br label %414
406: ; preds = %397, %406
%407 = phi i64 [ %411, %406 ], [ %398, %397 ]
%408 = getelementptr inbounds double, double* %350, i64 %407
%409 = load double, double* %408
%410 = fmul double %346, %409
store double %410, double* %408
%411 = add nuw nsw i64 %407, 1
%412 = icmp eq i64 %411, %31
br i1 %412, label %399, label %406
413: ; preds = %571
br i1 %11, label %574, label %629
414: ; preds = %400, %571
%415 = phi i64 [ 0, %400 ], [ %572, %571 ]
%416 = icmp eq i64 %415, %405
br i1 %416, label %571, label %417
417: ; preds = %414
%418 = getelementptr inbounds double*, double** %8, i64 %415
%419 = load double*, double** %418
%420 = load double*, double** %402
br i1 %63, label %421, label %526
421: ; preds = %526, %417
%422 = phi double [ undef, %417 ], [ %552, %526 ]
%423 = phi i64 [ 0, %417 ], [ %553, %526 ]
%424 = phi double [ 0.000000e+00, %417 ], [ %552, %526 ]
br i1 %65, label %437, label %425
425: ; preds = %421, %425
%426 = phi i64 [ %434, %425 ], [ %423, %421 ]
%427 = phi double [ %433, %425 ], [ %424, %421 ]
%428 = phi i64 [ %435, %425 ], [ 0, %421 ]
%429 = getelementptr inbounds double, double* %419, i64 %426
%430 = load double, double* %429
%431 = getelementptr inbounds double, double* %420, i64 %426
%432 = load double, double* %431
%433 = tail call double @llvm.fmuladd.f64(double %430, double %432, double %427)
%434 = add nuw nsw i64 %426, 1
%435 = add i64 %428, 1
%436 = icmp eq i64 %435, %62
br i1 %436, label %437, label %425
437: ; preds = %425, %421
%438 = phi double [ %422, %421 ], [ %433, %425 ]
%439 = load double*, double** %404
%440 = getelementptr inbounds double*, double** %8, i64 %415
%441 = load double*, double** %440
%442 = fneg double %438
br i1 %66, label %513, label %443
443: ; preds = %437
%444 = getelementptr double, double* %441, i64 %29
%445 = getelementptr double, double* %439, i64 %29
%446 = icmp ult double* %441, %445
%447 = icmp ult double* %439, %444
%448 = and i1 %446, %447
br i1 %448, label %513, label %449
449: ; preds = %443
%450 = insertelement <2 x double> poison, double %442, i64 0
%451 = shufflevector <2 x double> %450, <2 x double> poison, <2 x i32> zeroinitializer
%452 = insertelement <2 x double> poison, double %442, i64 0
%453 = shufflevector <2 x double> %452, <2 x double> poison, <2 x i32> zeroinitializer
br i1 %69, label %493, label %454
454: ; preds = %449, %454
%455 = phi i64 [ %490, %454 ], [ 0, %449 ]
%456 = phi i64 [ %491, %454 ], [ 0, %449 ]
%457 = getelementptr inbounds double, double* %439, i64 %455
%458 = bitcast double* %457 to <2 x double>*
%459 = load <2 x double>, <2 x double>* %458
%460 = getelementptr inbounds double, double* %457, i64 2
%461 = bitcast double* %460 to <2 x double>*
%462 = load <2 x double>, <2 x double>* %461
%463 = getelementptr inbounds double, double* %441, i64 %455
%464 = bitcast double* %463 to <2 x double>*
%465 = load <2 x double>, <2 x double>* %464
%466 = getelementptr inbounds double, double* %463, i64 2
%467 = bitcast double* %466 to <2 x double>*
%468 = load <2 x double>, <2 x double>* %467
%469 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %451, <2 x double> %459, <2 x double> %465)
%470 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %453, <2 x double> %462, <2 x double> %468)
%471 = bitcast double* %463 to <2 x double>*
store <2 x double> %469, <2 x double>* %471
%472 = bitcast double* %466 to <2 x double>*
store <2 x double> %470, <2 x double>* %472
%473 = or i64 %455, 4
%474 = getelementptr inbounds double, double* %439, i64 %473
%475 = bitcast double* %474 to <2 x double>*
%476 = load <2 x double>, <2 x double>* %475
%477 = getelementptr inbounds double, double* %474, i64 2
%478 = bitcast double* %477 to <2 x double>*
%479 = load <2 x double>, <2 x double>* %478
%480 = getelementptr inbounds double, double* %441, i64 %473
%481 = bitcast double* %480 to <2 x double>*
%482 = load <2 x double>, <2 x double>* %481
%483 = getelementptr inbounds double, double* %480, i64 2
%484 = bitcast double* %483 to <2 x double>*
%485 = load <2 x double>, <2 x double>* %484
%486 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %451, <2 x double> %476, <2 x double> %482)
%487 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %453, <2 x double> %479, <2 x double> %485)
%488 = bitcast double* %480 to <2 x double>*
store <2 x double> %486, <2 x double>* %488
%489 = bitcast double* %483 to <2 x double>*
store <2 x double> %487, <2 x double>* %489
%490 = add nuw i64 %455, 8
%491 = add i64 %456, 2
%492 = icmp eq i64 %491, %70
br i1 %492, label %493, label %454
493: ; preds = %454, %449
%494 = phi i64 [ 0, %449 ], [ %490, %454 ]
br i1 %71, label %512, label %495
495: ; preds = %493
%496 = getelementptr inbounds double, double* %439, i64 %494
%497 = bitcast double* %496 to <2 x double>*
%498 = load <2 x double>, <2 x double>* %497
%499 = getelementptr inbounds double, double* %496, i64 2
%500 = bitcast double* %499 to <2 x double>*
%501 = load <2 x double>, <2 x double>* %500
%502 = getelementptr inbounds double, double* %441, i64 %494
%503 = bitcast double* %502 to <2 x double>*
%504 = load <2 x double>, <2 x double>* %503
%505 = getelementptr inbounds double, double* %502, i64 2
%506 = bitcast double* %505 to <2 x double>*
%507 = load <2 x double>, <2 x double>* %506
%508 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %451, <2 x double> %498, <2 x double> %504)
%509 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %453, <2 x double> %501, <2 x double> %507)
%510 = bitcast double* %502 to <2 x double>*
store <2 x double> %508, <2 x double>* %510
%511 = bitcast double* %505 to <2 x double>*
store <2 x double> %509, <2 x double>* %511
br label %512
512: ; preds = %493, %495
br i1 %72, label %571, label %513
513: ; preds = %443, %437, %512
%514 = phi i64 [ 0, %443 ], [ 0, %437 ], [ %67, %512 ]
%515 = xor i64 %514, -1
br i1 %74, label %523, label %516
516: ; preds = %513
%517 = getelementptr inbounds double, double* %439, i64 %514
%518 = load double, double* %517
%519 = getelementptr inbounds double, double* %441, i64 %514
%520 = load double, double* %519
%521 = tail call double @llvm.fmuladd.f64(double %442, double %518, double %520)
store double %521, double* %519
%522 = or i64 %514, 1
br label %523
523: ; preds = %516, %513
%524 = phi i64 [ %514, %513 ], [ %522, %516 ]
%525 = icmp eq i64 %515, %75
br i1 %525, label %571, label %556
526: ; preds = %417, %526
%527 = phi i64 [ %553, %526 ], [ 0, %417 ]
%528 = phi double [ %552, %526 ], [ 0.000000e+00, %417 ]
%529 = phi i64 [ %554, %526 ], [ 0, %417 ]
%530 = getelementptr inbounds double, double* %419, i64 %527
%531 = load double, double* %530
%532 = getelementptr inbounds double, double* %420, i64 %527
%533 = load double, double* %532
%534 = tail call double @llvm.fmuladd.f64(double %531, double %533, double %528)
%535 = or i64 %527, 1
%536 = getelementptr inbounds double, double* %419, i64 %535
%537 = load double, double* %536
%538 = getelementptr inbounds double, double* %420, i64 %535
%539 = load double, double* %538
%540 = tail call double @llvm.fmuladd.f64(double %537, double %539, double %534)
%541 = or i64 %527, 2
%542 = getelementptr inbounds double, double* %419, i64 %541
%543 = load double, double* %542
%544 = getelementptr inbounds double, double* %420, i64 %541
%545 = load double, double* %544
%546 = tail call double @llvm.fmuladd.f64(double %543, double %545, double %540)
%547 = or i64 %527, 3
%548 = getelementptr inbounds double, double* %419, i64 %547
%549 = load double, double* %548
%550 = getelementptr inbounds double, double* %420, i64 %547
%551 = load double, double* %550
%552 = tail call double @llvm.fmuladd.f64(double %549, double %551, double %546)
%553 = add nuw nsw i64 %527, 4
%554 = add i64 %529, 4
%555 = icmp eq i64 %554, %64
br i1 %555, label %421, label %526
556: ; preds = %523, %556
%557 = phi i64 [ %569, %556 ], [ %524, %523 ]
%558 = getelementptr inbounds double, double* %439, i64 %557
%559 = load double, double* %558
%560 = getelementptr inbounds double, double* %441, i64 %557
%561 = load double, double* %560
%562 = tail call double @llvm.fmuladd.f64(double %442, double %559, double %561)
store double %562, double* %560
%563 = add nuw nsw i64 %557, 1
%564 = getelementptr inbounds double, double* %439, i64 %563
%565 = load double, double* %564
%566 = getelementptr inbounds double, double* %441, i64 %563
%567 = load double, double* %566
%568 = tail call double @llvm.fmuladd.f64(double %442, double %565, double %567)
store double %568, double* %566
%569 = add nuw nsw i64 %557, 2
%570 = icmp eq i64 %569, %32
br i1 %570, label %571, label %556
571: ; preds = %523, %556, %512, %414
%572 = add nuw nsw i64 %415, 1
%573 = icmp eq i64 %572, %32
br i1 %573, label %413, label %414
574: ; preds = %413, %624
%575 = phi i64 [ %627, %624 ], [ 0, %413 ]
%576 = getelementptr inbounds double*, double** %8, i64 %575
%577 = load double*, double** %576
br i1 %77, label %608, label %578
578: ; preds = %574, %578
%579 = phi i64 [ %605, %578 ], [ 0, %574 ]
%580 = phi double [ %604, %578 ], [ 0.000000e+00, %574 ]
%581 = phi i64 [ %606, %578 ], [ 0, %574 ]
%582 = getelementptr inbounds double, double* %577, i64 %579
%583 = load double, double* %582
%584 = getelementptr inbounds double, double* %1, i64 %579
%585 = load double, double* %584
%586 = tail call double @llvm.fmuladd.f64(double %583, double %585, double %580)
%587 = or i64 %579, 1
%588 = getelementptr inbounds double, double* %577, i64 %587
%589 = load double, double* %588
%590 = getelementptr inbounds double, double* %1, i64 %587
%591 = load double, double* %590
%592 = tail call double @llvm.fmuladd.f64(double %589, double %591, double %586)
%593 = or i64 %579, 2
%594 = getelementptr inbounds double, double* %577, i64 %593
%595 = load double, double* %594
%596 = getelementptr inbounds double, double* %1, i64 %593
%597 = load double, double* %596
%598 = tail call double @llvm.fmuladd.f64(double %595, double %597, double %592)
%599 = or i64 %579, 3
%600 = getelementptr inbounds double, double* %577, i64 %599
%601 = load double, double* %600
%602 = getelementptr inbounds double, double* %1, i64 %599
%603 = load double, double* %602
%604 = tail call double @llvm.fmuladd.f64(double %601, double %603, double %598)
%605 = add nuw nsw i64 %579, 4
%606 = add i64 %581, 4
%607 = icmp eq i64 %606, %78
br i1 %607, label %608, label %578
608: ; preds = %578, %574
%609 = phi double [ undef, %574 ], [ %604, %578 ]
%610 = phi i64 [ 0, %574 ], [ %605, %578 ]
%611 = phi double [ 0.000000e+00, %574 ], [ %604, %578 ]
br i1 %79, label %624, label %612
612: ; preds = %608, %612
%613 = phi i64 [ %621, %612 ], [ %610, %608 ]
%614 = phi double [ %620, %612 ], [ %611, %608 ]
%615 = phi i64 [ %622, %612 ], [ 0, %608 ]
%616 = getelementptr inbounds double, double* %577, i64 %613
%617 = load double, double* %616
%618 = getelementptr inbounds double, double* %1, i64 %613
%619 = load double, double* %618
%620 = tail call double @llvm.fmuladd.f64(double %617, double %619, double %614)
%621 = add nuw nsw i64 %613, 1
%622 = add i64 %615, 1
%623 = icmp eq i64 %622, %76
br i1 %623, label %624, label %612
624: ; preds = %612, %608
%625 = phi double [ %609, %608 ], [ %620, %612 ]
%626 = getelementptr inbounds double, double* %5, i64 %575
store double %625, double* %626
%627 = add nuw nsw i64 %575, 1
%628 = icmp eq i64 %627, %33
br i1 %628, label %629, label %574
629: ; preds = %624, %345, %399, %413
%630 = sext i32 %339 to i64
%631 = getelementptr inbounds i32, i32* %7, i64 %630
%632 = load i32, i32* %631
%633 = icmp eq i32 %632, %2
br i1 %633, label %634, label %635
634: ; preds = %629
store i32 0, i32* %9
br label %635
635: ; preds = %634, %629
store i32 %169, i32* %631
%636 = icmp eq i32 %169, %2
br i1 %636, label %641, label %637
637: ; preds = %635
%638 = load i32, i32* %9
br label %639
639: ; preds = %637, %641
%640 = phi i32 [ %638, %637 ], [ %339, %641 ]
br label %80
641: ; preds = %635
store i32 %339, i32* %9
%642 = getelementptr inbounds double, double* %5, i64 %630
%643 = load double, double* %642
%644 = fcmp ogt double %643, 1.000000e-10
br i1 %644, label %645, label %639
645: ; preds = %641, %164
ret void
}