void conjugateGradientMethod(double *A, double *b, double *x, int n,
                             int maxIter, double *doubleVals) {
  int i, j, itr;
  double rsstart, rsold, rsnew, alpha;
  rsstart = 0.0;
  for (i = 0; i < n; i++) {
    doubleVals[i] = b[i];
    doubleVals[i + 2 * n] = b[i];
    rsstart += b[i] * b[i];
  }
  rsold = rsstart;
  alpha = 0.0;
  for (i = 0; i < n; i++) {
    doubleVals[i + n] = 0.0;
    for (j = 0; j < n; j++) {
      doubleVals[i + n] += A[i * n + j] * doubleVals[j];
    }
    alpha += doubleVals[i + n] * doubleVals[i];
  }
  if (1e10 * alpha < rsold || rsstart < 1e-30) {
    for (i = 0; i < n; i++) {
      x[i] = 0.0;
    }
    return;
  }
  alpha = rsold / alpha;
  for (i = 0; i < n; i++) {
    x[i] = alpha * doubleVals[i];
  }
  rsnew = 0.0;
  for (i = 0; i < n; i++) {
    doubleVals[i + 2 * n] -= alpha * doubleVals[i + n];
    rsnew += doubleVals[i + 2 * n] * doubleVals[i + 2 * n];
  }
  if (1e12 * rsnew < rsstart) {
    return;
  }
  alpha = rsnew / rsold;
  for (i = 0; i < n; i++) {
    doubleVals[i] = doubleVals[i + 2 * n] + alpha * doubleVals[i];
  }
  rsold = rsnew;
  for (itr = 0; itr < maxIter; itr++) {
    alpha = 0.0;
    for (i = 0; i < n; i++) {
      doubleVals[i + n] = 0.0;
      for (j = 0; j < n; j++) {
        doubleVals[i + n] += A[i * n + j] * doubleVals[j];
      }
      alpha += doubleVals[i + n] * doubleVals[i];
    }
    if (1e4 * alpha < rsold) {
      break;
    }
    alpha = rsold / alpha;
    rsnew = 0.0;
    for (i = 0; i < n; i++) {
      doubleVals[i + 2 * n] -= alpha * doubleVals[i + n];
      rsnew += doubleVals[i + 2 * n] * doubleVals[i + 2 * n];
    }
    if (rsnew < 1.3 * rsold) {
      for (i = 0; i < n; i++) {
        x[i] += alpha * doubleVals[i];
      }
    } else {
      break;
    }
    if (1e4 * rsnew < rsstart) {
      break;
    }
    alpha = rsnew / rsold;
    for (i = 0; i < n; i++) {
      doubleVals[i] = doubleVals[i + 2 * n] + alpha * doubleVals[i];
    }
    rsold = rsnew;
  }
  return;
}


x86 assembly (clang, -O0):
<conjugateGradientMethod>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8d,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    11ae <conjugateGradientMethod+0xae>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x1c(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x40(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    112a <conjugateGradientMethod+0x2a>
movsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    128a <conjugateGradientMethod+0x18a>
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    124b <conjugateGradientMethod+0x14b>
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11ef <conjugateGradientMethod+0xef>
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11c7 <conjugateGradientMethod+0xc7>
movsd  0xd6e(%rip),%xmm1
mulsd  -0x58(%rbp),%xmm1
movsd  -0x48(%rbp),%xmm0
ucomisd %xmm1,%xmm0
ja     12b9 <conjugateGradientMethod+0x1b9>
movsd  0xd5a(%rip),%xmm0
ucomisd -0x40(%rbp),%xmm0
jbe    12ef <conjugateGradientMethod+0x1ef>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    12ea <conjugateGradientMethod+0x1ea>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    12c0 <conjugateGradientMethod+0x1c0>
jmp    1781 <conjugateGradientMethod+0x681>
movsd  -0x48(%rbp),%xmm0
divsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    133e <conjugateGradientMethod+0x23e>
movsd  -0x58(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1305 <conjugateGradientMethod+0x205>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    13f9 <conjugateGradientMethod+0x2f9>
movsd  -0x58(%rbp),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x1c(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%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    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x1c(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x1c(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%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    134d <conjugateGradientMethod+0x24d>
movsd  0xc0f(%rip),%xmm1
mulsd  -0x50(%rbp),%xmm1
movsd  -0x40(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    141a <conjugateGradientMethod+0x31a>
jmp    1781 <conjugateGradientMethod+0x681>
movsd  -0x50(%rbp),%xmm0
divsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1488 <conjugateGradientMethod+0x388>
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x1c(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x58(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%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    1430 <conjugateGradientMethod+0x330>
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    177c <conjugateGradientMethod+0x67c>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1577 <conjugateGradientMethod+0x477>
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1538 <conjugateGradientMethod+0x438>
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x1c(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    14dc <conjugateGradientMethod+0x3dc>
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    14b4 <conjugateGradientMethod+0x3b4>
movsd  0xa99(%rip),%xmm1
mulsd  -0x58(%rbp),%xmm1
movsd  -0x48(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    1598 <conjugateGradientMethod+0x498>
jmp    177c <conjugateGradientMethod+0x67c>
movsd  -0x48(%rbp),%xmm0
divsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1662 <conjugateGradientMethod+0x562>
movsd  -0x58(%rbp),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x1c(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%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    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x1c(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x1c(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%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    15b6 <conjugateGradientMethod+0x4b6>
movsd  -0x50(%rbp),%xmm1
movsd  0x9b1(%rip),%xmm0
mulsd  -0x48(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    16d0 <conjugateGradientMethod+0x5d0>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    16cb <conjugateGradientMethod+0x5cb>
movsd  -0x58(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1685 <conjugateGradientMethod+0x585>
jmp    16d5 <conjugateGradientMethod+0x5d5>
jmp    177c <conjugateGradientMethod+0x67c>
movsd  0x93b(%rip),%xmm1
mulsd  -0x50(%rbp),%xmm1
movsd  -0x40(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    16f6 <conjugateGradientMethod+0x5f6>
jmp    177c <conjugateGradientMethod+0x67c>
movsd  -0x50(%rbp),%xmm0
divsd  -0x48(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1764 <conjugateGradientMethod+0x664>
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x1c(%rbp),%edx
shl    $0x1,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x58(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%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    170c <conjugateGradientMethod+0x60c>
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1499 <conjugateGradientMethod+0x399>
jmp    1781 <conjugateGradientMethod+0x681>
pop    %rbp
ret

x86 assembly (clang, -O2):
<conjugateGradientMethod>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
mov    %rdi,0x10(%rsp)
test   %ecx,%ecx
jle    1da1 <conjugateGradientMethod+0xc91>
mov    %r8d,%r13d
mov    %ecx,%r12d
mov    %rdx,%r10
lea    (%r12,%r12,1),%eax
movslq %eax,%r8
mov    %ecx,%edx
mov    %rdx,%r11
add    $0xffffffffffffffff,%r11
je     13a4 <conjugateGradientMethod+0x294>
mov    %edx,%ecx
and    $0xfffffffe,%ecx
lea    0x8(%r9),%rbp
lea    (%r9,%r8,8),%rbx
add    $0x8,%rbx
xorpd  %xmm0,%xmm0
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rsi,%rax,8),%xmm1
movsd  %xmm1,-0x8(%rbp,%rax,8)
movsd  (%rsi,%rax,8),%xmm1
movsd  %xmm1,-0x8(%rbx,%rax,8)
movsd  (%rsi,%rax,8),%xmm1
movsd  0x8(%rsi,%rax,8),%xmm2
mulsd  %xmm1,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm2,0x0(%rbp,%rax,8)
movsd  0x8(%rsi,%rax,8),%xmm0
movsd  %xmm0,(%rbx,%rax,8)
movsd  0x8(%rsi,%rax,8),%xmm0
mulsd  %xmm0,%xmm0
addsd  %xmm1,%xmm0
add    $0x2,%rax
cmp    %rax,%rcx
jne    1170 <conjugateGradientMethod+0x60>
test   $0x1,%dl
je     11ed <conjugateGradientMethod+0xdd>
movsd  (%rsi,%rax,8),%xmm1
movsd  %xmm1,(%r9,%rax,8)
movsd  (%rsi,%rax,8),%xmm1
lea    (%rax,%r8,1),%rcx
movsd  %xmm1,(%r9,%rcx,8)
movsd  (%rsi,%rax,8),%xmm1
mulsd  %xmm1,%xmm1
addsd  %xmm1,%xmm0
test   %r12d,%r12d
jle    13b8 <conjugateGradientMethod+0x2a8>
mov    %edx,%eax
and    $0xfffffffe,%eax
mov    0x10(%rsp),%rcx
lea    0x8(%rcx),%rsi
lea    0x0(,%rdx,8),%r15
xorpd  %xmm3,%xmm3
xor    %r14d,%r14d
mov    0x10(%rsp),%rdi
jmp    1236 <conjugateGradientMethod+0x126>
nopw   0x0(%rax,%rax,1)
mulsd  (%r9,%r14,8),%xmm1
addsd  %xmm1,%xmm3
add    $0x1,%r14
add    %r15,%rsi
cmp    %rdx,%r14
je     12ae <conjugateGradientMethod+0x19e>
lea    (%r14,%rdx,1),%rbp
movq   $0x0,(%r9,%rbp,8)
xorpd  %xmm1,%xmm1
xor    %ecx,%ecx
test   %r11,%r11
je     1285 <conjugateGradientMethod+0x175>
nopl   (%rax)
movsd  -0x8(%rsi,%rcx,8),%xmm2
mulsd  (%r9,%rcx,8),%xmm2
addsd  %xmm1,%xmm2
movsd  %xmm2,(%r9,%rbp,8)
movsd  (%rsi,%rcx,8),%xmm1
mulsd  0x8(%r9,%rcx,8),%xmm1
addsd  %xmm2,%xmm1
movsd  %xmm1,(%r9,%rbp,8)
add    $0x2,%rcx
cmp    %rcx,%rax
jne    1250 <conjugateGradientMethod+0x140>
test   $0x1,%dl
je     1220 <conjugateGradientMethod+0x110>
mov    %r14,%rbx
imul   %rdx,%rbx
add    %rcx,%rbx
movsd  (%rdi,%rbx,8),%xmm2
mulsd  (%r9,%rcx,8),%xmm2
addsd  %xmm2,%xmm1
movsd  %xmm1,(%r9,%rbp,8)
jmp    1220 <conjugateGradientMethod+0x110>
movsd  0xd4a(%rip),%xmm1
ucomisd %xmm0,%xmm1
ja     13e1 <conjugateGradientMethod+0x2d1>
movsd  0xd40(%rip),%xmm1
mulsd  %xmm3,%xmm1
ucomisd %xmm1,%xmm0
ja     13e1 <conjugateGradientMethod+0x2d1>
xorpd  %xmm1,%xmm1
test   %r12d,%r12d
jle    155a <conjugateGradientMethod+0x44a>
movapd %xmm0,%xmm2
divsd  %xmm3,%xmm2
cmp    $0x4,%r12d
jb     130b <conjugateGradientMethod+0x1fb>
lea    (%r9,%rdx,8),%rax
cmp    %r10,%rax
jbe    13fd <conjugateGradientMethod+0x2ed>
lea    (%r10,%rdx,8),%rax
cmp    %r9,%rax
jbe    13fd <conjugateGradientMethod+0x2ed>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
add    %rdx,%rcx
mov    %rdx,%rsi
and    $0x3,%rsi
je     133a <conjugateGradientMethod+0x22a>
nop
movsd  (%r9,%rax,8),%xmm3
mulsd  %xmm2,%xmm3
movsd  %xmm3,(%r10,%rax,8)
add    $0x1,%rax
add    $0xffffffffffffffff,%rsi
jne    1320 <conjugateGradientMethod+0x210>
cmp    $0x3,%rcx
jb     14b5 <conjugateGradientMethod+0x3a5>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%r9,%rax,8),%xmm3
mulsd  %xmm2,%xmm3
movsd  %xmm3,(%r10,%rax,8)
movsd  0x8(%r9,%rax,8),%xmm3
mulsd  %xmm2,%xmm3
movsd  %xmm3,0x8(%r10,%rax,8)
movsd  0x10(%r9,%rax,8),%xmm3
mulsd  %xmm2,%xmm3
movsd  %xmm3,0x10(%r10,%rax,8)
movsd  0x18(%r9,%rax,8),%xmm3
mulsd  %xmm2,%xmm3
movsd  %xmm3,0x18(%r10,%rax,8)
add    $0x4,%rax
cmp    %rax,%rdx
jne    1350 <conjugateGradientMethod+0x240>
jmp    14b5 <conjugateGradientMethod+0x3a5>
xor    %eax,%eax
xorpd  %xmm0,%xmm0
test   $0x1,%dl
jne    11c6 <conjugateGradientMethod+0xb6>
jmp    11ed <conjugateGradientMethod+0xdd>
movsd  0xc40(%rip),%xmm1
ucomisd %xmm0,%xmm1
ja     1da1 <conjugateGradientMethod+0xc91>
xorpd  %xmm1,%xmm1
xorpd  %xmm2,%xmm2
ucomisd %xmm2,%xmm0
jbe    155a <conjugateGradientMethod+0x44a>
jmp    1da1 <conjugateGradientMethod+0xc91>
test   %r12d,%r12d
jle    1da1 <conjugateGradientMethod+0xc91>
shl    $0x3,%rdx
mov    %r10,%rdi
xor    %esi,%esi
call   1030 <memset@plt>
jmp    1da1 <conjugateGradientMethod+0xc91>
mov    %edx,%eax
and    $0xfffffffc,%eax
movapd %xmm2,%xmm3
unpcklpd %xmm2,%xmm3
lea    -0x4(%rax),%rcx
mov    %rcx,%rbp
shr    $0x2,%rbp
add    $0x1,%rbp
test   %rcx,%rcx
je     1482 <conjugateGradientMethod+0x372>
mov    %rbp,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
movupd (%r9,%rcx,8),%xmm4
movupd 0x10(%r9,%rcx,8),%xmm5
mulpd  %xmm3,%xmm4
mulpd  %xmm3,%xmm5
movupd %xmm4,(%r10,%rcx,8)
movupd %xmm5,0x10(%r10,%rcx,8)
movupd 0x20(%r9,%rcx,8),%xmm4
movupd 0x30(%r9,%rcx,8),%xmm5
mulpd  %xmm3,%xmm4
mulpd  %xmm3,%xmm5
movupd %xmm4,0x20(%r10,%rcx,8)
movupd %xmm5,0x30(%r10,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%rsi
jne    1430 <conjugateGradientMethod+0x320>
jmp    1484 <conjugateGradientMethod+0x374>
xor    %ecx,%ecx
test   $0x1,%bpl
je     14ac <conjugateGradientMethod+0x39c>
movupd (%r9,%rcx,8),%xmm4
movupd 0x10(%r9,%rcx,8),%xmm5
mulpd  %xmm3,%xmm4
mulpd  %xmm3,%xmm5
movupd %xmm4,(%r10,%rcx,8)
movupd %xmm5,0x10(%r10,%rcx,8)
cmp    %rdx,%rax
jne    130d <conjugateGradientMethod+0x1fd>
test   %r12d,%r12d
jle    155a <conjugateGradientMethod+0x44a>
xorpd  0xb6a(%rip),%xmm2
test   %r11,%r11
je     162d <conjugateGradientMethod+0x51d>
mov    %edx,%ecx
and    $0xfffffffe,%ecx
lea    (%r9,%rdx,8),%rsi
add    $0x8,%rsi
lea    (%r9,%r8,8),%rbp
add    $0x8,%rbp
xorpd  %xmm1,%xmm1
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movsd  -0x8(%rsi,%rax,8),%xmm3
mulsd  %xmm2,%xmm3
addsd  -0x8(%rbp,%rax,8),%xmm3
movsd  %xmm3,-0x8(%rbp,%rax,8)
mulsd  %xmm3,%xmm3
addsd  %xmm1,%xmm3
movsd  (%rsi,%rax,8),%xmm1
mulsd  %xmm2,%xmm1
addsd  0x0(%rbp,%rax,8),%xmm1
movsd  %xmm1,0x0(%rbp,%rax,8)
mulsd  %xmm1,%xmm1
addsd  %xmm3,%xmm1
add    $0x2,%rax
cmp    %rax,%rcx
jne    14f0 <conjugateGradientMethod+0x3e0>
test   $0x1,%dl
je     155a <conjugateGradientMethod+0x44a>
lea    (%rax,%rdx,1),%rcx
add    %r8,%rax
mulsd  (%r9,%rcx,8),%xmm2
addsd  (%r9,%rax,8),%xmm2
movsd  %xmm2,(%r9,%rax,8)
mulsd  %xmm2,%xmm2
addsd  %xmm2,%xmm1
movsd  0xaae(%rip),%xmm2
mulsd  %xmm1,%xmm2
ucomisd %xmm2,%xmm0
ja     1da1 <conjugateGradientMethod+0xc91>
test   %r12d,%r12d
mov    %r8,%rdi
jle    174b <conjugateGradientMethod+0x63b>
movapd %xmm1,%xmm8
divsd  %xmm0,%xmm8
cmp    $0x4,%r12d
jb     15ae <conjugateGradientMethod+0x49e>
lea    (%rdi,%rdx,1),%rax
lea    (%r9,%rax,8),%rax
cmp    %r9,%rax
jbe    1641 <conjugateGradientMethod+0x531>
lea    (%r9,%rdx,8),%rax
lea    (%r9,%rdi,8),%rcx
cmp    %rax,%rcx
jae    1641 <conjugateGradientMethod+0x531>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
test   $0x1,%dl
je     15da <conjugateGradientMethod+0x4ca>
lea    (%rax,%rdi,1),%rsi
movsd  (%r9,%rax,8),%xmm2
mulsd  %xmm8,%xmm2
addsd  (%r9,%rsi,8),%xmm2
movsd  %xmm2,(%r9,%rax,8)
or     $0x1,%rax
add    %rdx,%rcx
je     174b <conjugateGradientMethod+0x63b>
lea    (%r9,%rdi,8),%rcx
add    $0x8,%rcx
nopl   0x0(%rax,%rax,1)
movsd  (%r9,%rax,8),%xmm2
mulsd  %xmm8,%xmm2
addsd  -0x8(%rcx,%rax,8),%xmm2
movsd  %xmm2,(%r9,%rax,8)
movsd  0x8(%r9,%rax,8),%xmm2
mulsd  %xmm8,%xmm2
addsd  (%rcx,%rax,8),%xmm2
movsd  %xmm2,0x8(%r9,%rax,8)
add    $0x2,%rax
cmp    %rax,%rdx
jne    15f0 <conjugateGradientMethod+0x4e0>
jmp    174b <conjugateGradientMethod+0x63b>
xorpd  %xmm1,%xmm1
xor    %eax,%eax
test   $0x1,%dl
jne    1539 <conjugateGradientMethod+0x429>
jmp    155a <conjugateGradientMethod+0x44a>
mov    %edx,%eax
and    $0xfffffffc,%eax
movapd %xmm8,%xmm9
unpcklpd %xmm8,%xmm9
lea    -0x4(%rax),%rcx
mov    %rcx,%rbp
shr    $0x2,%rbp
add    $0x1,%rbp
test   %rcx,%rcx
je     16fd <conjugateGradientMethod+0x5ed>
mov    %rbp,%rcx
and    $0xfffffffffffffffe,%rcx
lea    (%r9,%rdi,8),%rbx
add    $0x30,%rbx
xor    %esi,%esi
nopl   0x0(%rax)
movupd -0x30(%rbx,%rsi,8),%xmm4
movupd -0x20(%rbx,%rsi,8),%xmm5
movupd (%r9,%rsi,8),%xmm6
movupd 0x10(%r9,%rsi,8),%xmm7
movupd 0x20(%r9,%rsi,8),%xmm2
movupd 0x30(%r9,%rsi,8),%xmm3
mulpd  %xmm9,%xmm6
addpd  %xmm4,%xmm6
mulpd  %xmm9,%xmm7
addpd  %xmm5,%xmm7
movupd %xmm6,(%r9,%rsi,8)
movupd %xmm7,0x10(%r9,%rsi,8)
movupd -0x10(%rbx,%rsi,8),%xmm4
movupd (%rbx,%rsi,8),%xmm5
mulpd  %xmm9,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm9,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm2,0x20(%r9,%rsi,8)
movupd %xmm3,0x30(%r9,%rsi,8)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rcx
jne    1680 <conjugateGradientMethod+0x570>
jmp    16ff <conjugateGradientMethod+0x5ef>
xor    %esi,%esi
test   $0x1,%bpl
je     1742 <conjugateGradientMethod+0x632>
lea    (%rsi,%rdi,1),%rcx
movupd (%r9,%rcx,8),%xmm2
movupd 0x10(%r9,%rcx,8),%xmm3
movupd (%r9,%rsi,8),%xmm4
movupd 0x10(%r9,%rsi,8),%xmm5
mulpd  %xmm9,%xmm4
addpd  %xmm2,%xmm4
mulpd  %xmm9,%xmm5
addpd  %xmm3,%xmm5
movupd %xmm4,(%r9,%rsi,8)
movupd %xmm5,0x10(%r9,%rsi,8)
cmp    %rdx,%rax
jne    15b0 <conjugateGradientMethod+0x4a0>
mov    %rdi,0x8(%rsp)
test   %r13d,%r13d
jle    1da1 <conjugateGradientMethod+0xc91>
movslq %r12d,%rsi
lea    (%r9,%rdx,8),%r15
mov    0x8(%rsp),%rdi
lea    (%r9,%rdi,8),%rbp
lea    (%rdi,%rdx,1),%rax
lea    (%r9,%rax,8),%r8
lea    (%r10,%rdx,8),%rbx
mov    %edx,%eax
and    $0xfffffffc,%eax
mov    %rax,0x38(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0x30(%rsp)
mov    %rax,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %edx,%eax
and    $0xfffffffe,%eax
cmp    %r10,%r15
mov    %r13d,%r14d
seta   %r13b
cmp    %r9,%rbx
seta   %bl
and    %r13b,%bl
mov    %bl,0x7(%rsp)
mov    %rcx,%rbx
mov    %rcx,0x28(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x20(%rsp)
mov    %rdx,%rcx
neg    %rcx
mov    %rcx,0x40(%rsp)
cmp    %r9,%r8
seta   %bl
cmp    %r15,%rbp
setb   %cl
and    %bl,%cl
mov    %cl,0x6(%rsp)
mov    0x10(%rsp),%rcx
add    $0x8,%rcx
mov    %rcx,0x50(%rsp)
lea    0x0(,%rsi,8),%r8
lea    (%r9,%rsi,8),%r15
add    $0x8,%r15
lea    (%r9,%rdi,8),%rdi
add    $0x8,%rdi
xor    %r13d,%r13d
movsd  0x809(%rip),%xmm11
movapd 0x818(%rip),%xmm9
movsd  0x7ff(%rip),%xmm10
xorpd  %xmm8,%xmm8
mov    %r12,0x58(%rsp)
mov    %r14d,0x1c(%rsp)
mov    %r15,0x48(%rsp)
jmp    1860 <conjugateGradientMethod+0x750>
nopw   0x0(%rax,%rax,1)
movapd %xmm1,%xmm2
mulsd  %xmm11,%xmm2
ucomisd %xmm2,%xmm0
ja     1da1 <conjugateGradientMethod+0xc91>
add    $0x1,%r13d
cmp    %r14d,%r13d
je     1da1 <conjugateGradientMethod+0xc91>
movapd %xmm1,%xmm12
test   %r12d,%r12d
jle    1a00 <conjugateGradientMethod+0x8f0>
mov    %r13,0x60(%rsp)
xorpd  %xmm1,%xmm1
mov    0x50(%rsp),%rbx
xor    %r13d,%r13d
jmp    18aa <conjugateGradientMethod+0x79a>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mulsd  (%r9,%r13,8),%xmm6
addsd  %xmm6,%xmm1
add    $0x1,%r13
add    %r8,%rbx
cmp    %rdx,%r13
je     1940 <conjugateGradientMethod+0x830>
lea    (%rsi,%r13,1),%r12
movq   $0x0,(%r9,%r12,8)
xorpd  %xmm6,%xmm6
xor    %ecx,%ecx
test   %r11,%r11
je     1905 <conjugateGradientMethod+0x7f5>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%rbx,%rcx,8),%xmm7
mulsd  (%r9,%rcx,8),%xmm7
addsd  %xmm6,%xmm7
movsd  %xmm7,(%r9,%r12,8)
movsd  (%rbx,%rcx,8),%xmm6
mulsd  0x8(%r9,%rcx,8),%xmm6
addsd  %xmm7,%xmm6
movsd  %xmm6,(%r9,%r12,8)
add    $0x2,%rcx
cmp    %rcx,%rax
jne    18d0 <conjugateGradientMethod+0x7c0>
test   $0x1,%dl
je     1890 <conjugateGradientMethod+0x780>
mov    %r13,%r14
imul   %rsi,%r14
add    %rcx,%r14
mov    0x10(%rsp),%r15
movsd  (%r15,%r14,8),%xmm7
mulsd  (%r9,%rcx,8),%xmm7
addsd  %xmm7,%xmm6
movsd  %xmm6,(%r9,%r12,8)
jmp    1890 <conjugateGradientMethod+0x780>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movapd %xmm1,%xmm6
mulsd  %xmm11,%xmm6
ucomisd %xmm6,%xmm12
mov    0x58(%rsp),%r12
mov    0x1c(%rsp),%r14d
mov    0x48(%rsp),%r15
mov    0x60(%rsp),%r13
ja     1da1 <conjugateGradientMethod+0xc91>
movapd %xmm12,%xmm13
divsd  %xmm1,%xmm13
test   %r12d,%r12d
jle    1a20 <conjugateGradientMethod+0x910>
movapd %xmm13,%xmm7
xorpd  %xmm9,%xmm7
xorpd  %xmm1,%xmm1
xor    %ebx,%ebx
test   %r11,%r11
je     19d4 <conjugateGradientMethod+0x8c4>
movsd  -0x8(%r15,%rbx,8),%xmm3
mulsd  %xmm7,%xmm3
addsd  -0x8(%rdi,%rbx,8),%xmm3
movsd  %xmm3,-0x8(%rdi,%rbx,8)
mulsd  %xmm3,%xmm3
addsd  %xmm1,%xmm3
movsd  (%r15,%rbx,8),%xmm1
mulsd  %xmm7,%xmm1
addsd  (%rdi,%rbx,8),%xmm1
movsd  %xmm1,(%rdi,%rbx,8)
mulsd  %xmm1,%xmm1
addsd  %xmm3,%xmm1
add    $0x2,%rbx
cmp    %rbx,%rax
jne    1990 <conjugateGradientMethod+0x880>
test   $0x1,%dl
je     1a24 <conjugateGradientMethod+0x914>
lea    (%rbx,%rsi,1),%rcx
add    0x8(%rsp),%rbx
mulsd  (%r9,%rcx,8),%xmm7
addsd  (%r9,%rbx,8),%xmm7
movsd  %xmm7,(%r9,%rbx,8)
mulsd  %xmm7,%xmm7
addsd  %xmm7,%xmm1
jmp    1a24 <conjugateGradientMethod+0x914>
xchg   %ax,%ax
ucomisd %xmm8,%xmm12
ja     1da1 <conjugateGradientMethod+0xc91>
xorpd  %xmm1,%xmm1
movapd %xmm12,%xmm13
divsd  %xmm1,%xmm13
jmp    1a24 <conjugateGradientMethod+0x914>
nopl   0x0(%rax,%rax,1)
xorpd  %xmm1,%xmm1
movapd %xmm12,%xmm3
mulsd  %xmm10,%xmm3
ucomisd %xmm1,%xmm3
jbe    1da1 <conjugateGradientMethod+0xc91>
test   %r12d,%r12d
jle    1840 <conjugateGradientMethod+0x730>
cmp    $0x4,%r12d
setb   %cl
or     0x7(%rsp),%cl
je     1a60 <conjugateGradientMethod+0x950>
xor    %ebx,%ebx
jmp    1b46 <conjugateGradientMethod+0xa36>
cs nopw 0x0(%rax,%rax,1)
nop
movapd %xmm13,%xmm7
unpcklpd %xmm13,%xmm7
cmpq   $0x0,0x30(%rsp)
je     1d7d <conjugateGradientMethod+0xc6d>
mov    0x20(%rsp),%rcx
xor    %ebx,%ebx
nopl   (%rax)
movupd (%r9,%rbx,8),%xmm3
movupd 0x10(%r9,%rbx,8),%xmm4
mulpd  %xmm7,%xmm3
movupd (%r10,%rbx,8),%xmm2
addpd  %xmm3,%xmm2
movupd 0x10(%r10,%rbx,8),%xmm3
movupd 0x20(%r10,%rbx,8),%xmm5
movupd 0x30(%r10,%rbx,8),%xmm6
mulpd  %xmm7,%xmm4
addpd  %xmm3,%xmm4
movupd %xmm2,(%r10,%rbx,8)
movupd %xmm4,0x10(%r10,%rbx,8)
movupd 0x20(%r9,%rbx,8),%xmm2
movupd 0x30(%r9,%rbx,8),%xmm3
mulpd  %xmm7,%xmm2
addpd  %xmm5,%xmm2
mulpd  %xmm7,%xmm3
addpd  %xmm6,%xmm3
movupd %xmm2,0x20(%r10,%rbx,8)
movupd %xmm3,0x30(%r10,%rbx,8)
add    $0x8,%rbx
add    $0xfffffffffffffffe,%rcx
jne    1a80 <conjugateGradientMethod+0x970>
testb  $0x1,0x28(%rsp)
je     1b39 <conjugateGradientMethod+0xa29>
movupd (%r9,%rbx,8),%xmm2
movupd 0x10(%r9,%rbx,8),%xmm3
movupd (%r10,%rbx,8),%xmm4
movupd 0x10(%r10,%rbx,8),%xmm5
mulpd  %xmm7,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm7,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm2,(%r10,%rbx,8)
movupd %xmm3,0x10(%r10,%rbx,8)
mov    0x38(%rsp),%rcx
mov    %rcx,%rbx
cmp    %rdx,%rcx
je     1bba <conjugateGradientMethod+0xaaa>
mov    %rbx,%rcx
test   $0x1,%dl
je     1b6c <conjugateGradientMethod+0xa5c>
movsd  (%r9,%rbx,8),%xmm2
mulsd  %xmm13,%xmm2
addsd  (%r10,%rbx,8),%xmm2
movsd  %xmm2,(%r10,%rbx,8)
mov    %rbx,%rcx
or     $0x1,%rcx
not    %rbx
cmp    0x40(%rsp),%rbx
je     1bba <conjugateGradientMethod+0xaaa>
cs nopw 0x0(%rax,%rax,1)
movsd  (%r9,%rcx,8),%xmm2
mulsd  %xmm13,%xmm2
addsd  (%r10,%rcx,8),%xmm2
movsd  %xmm2,(%r10,%rcx,8)
movsd  0x8(%r9,%rcx,8),%xmm2
mulsd  %xmm13,%xmm2
addsd  0x8(%r10,%rcx,8),%xmm2
movsd  %xmm2,0x8(%r10,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rdx
jne    1b80 <conjugateGradientMethod+0xa70>
movapd %xmm1,%xmm2
mulsd  %xmm11,%xmm2
ucomisd %xmm2,%xmm0
ja     1da1 <conjugateGradientMethod+0xc91>
test   %r12d,%r12d
jle    1853 <conjugateGradientMethod+0x743>
movapd %xmm1,%xmm13
divsd  %xmm12,%xmm13
cmp    $0x4,%r12d
setb   %cl
or     0x6(%rsp),%cl
je     1bf4 <conjugateGradientMethod+0xae4>
xor    %ebx,%ebx
jmp    1cf5 <conjugateGradientMethod+0xbe5>
movapd %xmm13,%xmm12
unpcklpd %xmm13,%xmm12
cmpq   $0x0,0x30(%rsp)
je     1d8f <conjugateGradientMethod+0xc7f>
mov    0x20(%rsp),%rcx
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movupd 0x0(%rbp,%rbx,8),%xmm2
movupd 0x10(%rbp,%rbx,8),%xmm3
movupd (%r9,%rbx,8),%xmm4
movupd 0x10(%r9,%rbx,8),%xmm6
movupd 0x20(%r9,%rbx,8),%xmm7
movupd 0x30(%r9,%rbx,8),%xmm5
mulpd  %xmm12,%xmm4
addpd  %xmm2,%xmm4
mulpd  %xmm12,%xmm6
addpd  %xmm3,%xmm6
movupd %xmm4,(%r9,%rbx,8)
movupd %xmm6,0x10(%r9,%rbx,8)
movupd 0x20(%rbp,%rbx,8),%xmm2
movupd 0x30(%rbp,%rbx,8),%xmm3
mulpd  %xmm12,%xmm7
addpd  %xmm2,%xmm7
mulpd  %xmm12,%xmm5
addpd  %xmm3,%xmm5
movupd %xmm7,0x20(%r9,%rbx,8)
movupd %xmm5,0x30(%r9,%rbx,8)
add    $0x8,%rbx
add    $0xfffffffffffffffe,%rcx
jne    1c20 <conjugateGradientMethod+0xb10>
testb  $0x1,0x28(%rsp)
je     1ce4 <conjugateGradientMethod+0xbd4>
mov    0x8(%rsp),%rcx
add    %rbx,%rcx
movupd (%r9,%rcx,8),%xmm2
movupd 0x10(%r9,%rcx,8),%xmm3
movupd (%r9,%rbx,8),%xmm4
movupd 0x10(%r9,%rbx,8),%xmm5
mulpd  %xmm12,%xmm4
addpd  %xmm2,%xmm4
mulpd  %xmm12,%xmm5
addpd  %xmm3,%xmm5
movupd %xmm4,(%r9,%rbx,8)
movupd %xmm5,0x10(%r9,%rbx,8)
mov    0x38(%rsp),%rcx
mov    %rcx,%rbx
cmp    %rdx,%rcx
je     1853 <conjugateGradientMethod+0x743>
mov    %rbx,%rcx
test   $0x1,%dl
je     1d23 <conjugateGradientMethod+0xc13>
mov    0x8(%rsp),%rcx
add    %rbx,%rcx
movsd  (%r9,%rbx,8),%xmm2
mulsd  %xmm13,%xmm2
addsd  (%r9,%rcx,8),%xmm2
movsd  %xmm2,(%r9,%rbx,8)
mov    %rbx,%rcx
or     $0x1,%rcx
not    %rbx
cmp    0x40(%rsp),%rbx
je     1853 <conjugateGradientMethod+0x743>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%r9,%rcx,8),%xmm2
mulsd  %xmm13,%xmm2
addsd  -0x8(%rdi,%rcx,8),%xmm2
movsd  %xmm2,(%r9,%rcx,8)
movsd  0x8(%r9,%rcx,8),%xmm2
mulsd  %xmm13,%xmm2
addsd  (%rdi,%rcx,8),%xmm2
movsd  %xmm2,0x8(%r9,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rdx
jne    1d40 <conjugateGradientMethod+0xc30>
jmp    1853 <conjugateGradientMethod+0x743>
xor    %ebx,%ebx
testb  $0x1,0x28(%rsp)
jne    1b02 <conjugateGradientMethod+0x9f2>
jmp    1b39 <conjugateGradientMethod+0xa29>
xor    %ebx,%ebx
testb  $0x1,0x28(%rsp)
jne    1ca3 <conjugateGradientMethod+0xb93>
jmp    1ce4 <conjugateGradientMethod+0xbd4>
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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