#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 */
scalar_t__ fabs(double);
double sqrt(double);
void qrsolv(int n, double **r, int ipvt[], double diag[], double qtb[],
            double x[], double sdiag[], double wa[]) {
  int i, j, jp1, k, kp1, l, nsing;
  double qtbpj, sum, temp, dsin, dcos, dtan, dcotan;
  for (j = 0; j < n; j++) {
    for (i = j; i < n; i++)
      r[j][i] = r[i][j];
    x[j] = r[j][j];
    wa[j] = qtb[j];
  }
  for (j = 0; j < n; j++) {
    l = ipvt[j];
    if (diag[l] != 0.0) {
      for (k = j; k < n; k++)
        sdiag[k] = 0.0;
      sdiag[j] = diag[l];
      qtbpj = 0.0;
      for (k = j; k < n; k++) {
        if (sdiag[k] == 0.0)
          continue;
        if (fabs(r[k][k]) < fabs(sdiag[k])) {
          dcotan = r[k][k] / sdiag[k];
          dsin = 1.0 / sqrt(1.0 + dcotan * dcotan);
          dcos = dsin * dcotan;
        } else {
          dtan = sdiag[k] / r[k][k];
          dcos = 1.0 / sqrt(1.0 + dtan * dtan);
          dsin = dcos * dtan;
        }
        r[k][k] = dcos * r[k][k] + dsin * sdiag[k];
        temp = dcos * wa[k] + dsin * qtbpj;
        qtbpj = -dsin * wa[k] + dcos * qtbpj;
        wa[k] = temp;
        kp1 = k + 1;
        if (n <= kp1)
          continue;
        for (i = kp1; i < n; i++) {
          temp = dcos * r[k][i] + dsin * sdiag[i];
          sdiag[i] = -dsin * r[k][i] + dcos * sdiag[i];
          r[k][i] = temp;
        }
      }
    }
    sdiag[j] = r[j][j];
    r[j][j] = x[j];
  }
  nsing = n;
  for (j = 0; j < n; j++) {
    if ((sdiag[j] == 0.0) && (nsing == n))
      nsing = j;
    if (nsing < n)
      wa[j] = 0.0;
  }
  if (nsing >= 1) {
    for (k = 0; k < nsing; k++) {
      j = nsing - k - 1;
      sum = 0.0;
      jp1 = j + 1;
      if (nsing > jp1) {
        for (i = jp1; i < nsing; i++)
          sum += r[j][i] * wa[i];
      }
      wa[j] = (wa[j] - sum) / sdiag[j];
    }
  }
  for (j = 0; j < n; j++) {
    l = ipvt[j];
    x[l] = wa[j];
  }
}


x86 assembly (clang, -O0):
<qrsolv>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    11f1 <qrsolv+0xd1>
mov    -0x38(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    11a7 <qrsolv+0x87>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1163 <qrsolv+0x43>
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1151 <qrsolv+0x31>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    15fc <qrsolv+0x4dc>
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x48(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1237 <qrsolv+0x117>
jp     1237 <qrsolv+0x117>
jmp    15aa <qrsolv+0x48a>
mov    -0x38(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1267 <qrsolv+0x147>
mov    0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    123d <qrsolv+0x11d>
mov    -0x20(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    15a5 <qrsolv+0x485>
mov    0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    12c0 <qrsolv+0x1a0>
jp     12c0 <qrsolv+0x1a0>
jmp    1597 <qrsolv+0x477>
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1030 <fabs@plt>
mov    %rax,-0x90(%rbp)
mov    0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1030 <fabs@plt>
mov    %rax,%rcx
mov    -0x90(%rbp),%rax
cmp    %rcx,%rax
jge    1380 <qrsolv+0x260>
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
movsd  -0x88(%rbp),%xmm1
ff
mulsd  %xmm1,%xmm0
movsd  0xcb4(%rip),%xmm1
addsd  %xmm1,%xmm0
call   1040 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0xca0(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm0
mulsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x78(%rbp)
jmp    13e9 <qrsolv+0x2c9>
mov    0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x80(%rbp),%xmm0
movsd  -0x80(%rbp),%xmm1
mulsd  %xmm1,%xmm0
movsd  0xc43(%rip),%xmm1
addsd  %xmm1,%xmm0
call   1040 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0xc2f(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm0
mulsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x78(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x70(%rbp),%xmm1
mov    0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x78(%rbp),%xmm0
mov    0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x70(%rbp),%xmm1
mulsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x70(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x78(%rbp),%xmm1
mulsd  -0x58(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movsd  -0x68(%rbp),%xmm0
mov    0x18(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x4(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     14c7 <qrsolv+0x3a7>
jmp    1597 <qrsolv+0x477>
mov    -0x44(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1592 <qrsolv+0x472>
movsd  -0x78(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x70(%rbp),%xmm1
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x70(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x78(%rbp),%xmm1
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x68(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    14cd <qrsolv+0x3ad>
jmp    1597 <qrsolv+0x477>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    128f <qrsolv+0x16f>
jmp    15aa <qrsolv+0x48a>
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    11f8 <qrsolv+0xd8>
mov    -0x4(%rbp),%eax
mov    %eax,-0x4c(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1676 <qrsolv+0x556>
mov    0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1647 <qrsolv+0x527>
jp     1647 <qrsolv+0x527>
mov    -0x4c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jne    1647 <qrsolv+0x527>
mov    -0x38(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1663 <qrsolv+0x543>
mov    0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1668 <qrsolv+0x548>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1609 <qrsolv+0x4e9>
cmpl   $0x1,-0x4c(%rbp)
jl     1754 <qrsolv+0x634>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    174f <qrsolv+0x62f>
mov    -0x4c(%rbp),%eax
sub    -0x40(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x38(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jle    1715 <qrsolv+0x5f5>
mov    -0x3c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    1710 <qrsolv+0x5f0>
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    16c2 <qrsolv+0x5a2>
jmp    1715 <qrsolv+0x5f5>
mov    0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x60(%rbp),%xmm0
mov    0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1687 <qrsolv+0x567>
jmp    1754 <qrsolv+0x634>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    179d <qrsolv+0x67d>
mov    -0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x48(%rbp)
mov    0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    175b <qrsolv+0x63b>
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<qrsolv>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xd8,%rsp
mov    %rcx,0x88(%rsp)
test   %edi,%edi
jle    1a99 <qrsolv+0x969>
mov    %rsi,%r14
mov    %edi,0x8(%rsp)
mov    %edi,%r10d
xor    %eax,%eax
mov    %rsi,%r15
mov    %r10,%rcx
mov    %r10,0x10(%rsp)
mov    %rsi,0x30(%rsp)
jmp    11a9 <qrsolv+0x79>
nop
movsd  (%r10,%rax,8),%xmm0
movsd  %xmm0,(%r9,%rax,8)
movsd  (%r8,%rax,8),%xmm0
mov    0x118(%rsp),%rsi
movsd  %xmm0,(%rsi,%rax,8)
add    $0xffffffffffffffff,%rcx
add    $0x8,%r15
mov    %r11,%rax
mov    0x10(%rsp),%r10
cmp    %r10,%r11
mov    0x30(%rsp),%r14
je     11ea <qrsolv+0xba>
mov    %r10,%rdi
mov    (%r14,%rax,8),%r10
lea    0x1(%rax),%r11
cmp    %rdi,%r11
je     1170 <qrsolv+0x40>
lea    (%r10,%rax,8),%rbp
mov    $0x1,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%r15,%rbx,8),%rdi
movsd  (%rdi,%rax,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rbx,8)
add    $0x1,%rbx
cmp    %rbx,%rcx
jne    11d0 <qrsolv+0xa0>
jmp    1170 <qrsolv+0x40>
mov    0x8(%rsp),%esi
test   %esi,%esi
mov    0x110(%rsp),%rbp
jle    1a99 <qrsolv+0x969>
movslq %esi,%rax
mov    %rax,0xc8(%rsp)
lea    0x18(%rbp),%rax
mov    %rax,0x80(%rsp)
mov    $0x1,%eax
mov    %rax,0x78(%rsp)
mov    $0x3,%eax
mov    %rax,0x70(%rsp)
movl   $0x2,0x44(%rsp)
movl   $0xfffffffe,0x40(%rsp)
ff
xor    %ecx,%ecx
xorpd  %xmm8,%xmm8
mov    %r9,0xc0(%rsp)
mov    %rdx,0xb8(%rsp)
jmp    12c1 <qrsolv+0x191>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x68(%rsp),%rcx
mov    (%r14,%rcx,8),%rax
movsd  (%rax,%rcx,8),%xmm0
mov    0x90(%rsp),%rdx
movsd  %xmm0,(%rdx)
mov    0xc0(%rsp),%r9
movsd  (%r9,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
add    $0x1,%rcx
addq   $0x1,0x78(%rsp)
addq   $0x8,0x80(%rsp)
addq   $0x1,0x70(%rsp)
addl   $0x1,0x44(%rsp)
addl   $0xffffffff,0x40(%rsp)
cmp    %r10,%rcx
mov    0xb8(%rsp),%rdx
je     1881 <qrsolv+0x751>
lea    0x0(,%rcx,8),%rax
add    %rbp,%rax
mov    %rax,0x90(%rsp)
mov    %rcx,0x68(%rsp)
movslq (%rdx,%rcx,4),%rbx
mov    0x88(%rsp),%rax
movsd  (%rax,%rbx,8),%xmm0
ucomisd %xmm8,%xmm0
jne    12f7 <qrsolv+0x1c7>
jnp    1260 <qrsolv+0x130>
mov    0x68(%rsp),%r13
lea    0x2(%r13),%r15
mov    %r13d,%eax
not    %eax
add    %esi,%eax
lea    0x8(,%rax,8),%rdx
mov    0x90(%rsp),%rbp
mov    %rbp,%rdi
xor    %esi,%esi
call   1030 <memset@plt>
mov    %r15,%r9
xorpd  %xmm8,%xmm8
mov    0x30(%rsp),%r14
mov    0x8(%rsp),%esi
mov    0x10(%rsp),%r10
mov    0x88(%rsp),%rax
movsd  (%rax,%rbx,8),%xmm0
movsd  %xmm0,0x0(%rbp)
xorpd  %xmm9,%xmm9
mov    0x40(%rsp),%r11d
mov    0x44(%rsp),%eax
mov    0x70(%rsp),%rcx
mov    0x80(%rsp),%rdx
mov    %rdx,0x28(%rsp)
xor    %edx,%edx
mov    0x78(%rsp),%r8
mov    %r15,0x48(%rsp)
cs nopw 0x0(%rax,%rax,1)
nop
cmp    %eax,%esi
mov    %eax,%r15d
cmovg  %esi,%r15d
lea    (%r9,%rdx,1),%r12d
cmp    %r12d,%esi
cmovg  %esi,%r12d
lea    (%r9,%rdx,1),%edi
cmp    %edi,%esi
cmovg  %esi,%edi
lea    (%r9,%rdx,1),%rbx
cmp    %ebx,%esi
mov    %ebx,%ebp
cmovg  %esi,%ebp
ucomisd %xmm8,%xmm0
jne    13d0 <qrsolv+0x2a0>
jp     13d0 <qrsolv+0x2a0>
add    $0x1,%r13
mov    0x110(%rsp),%rbp
mov    0x28(%rsp),%rdi
jmp    1850 <qrsolv+0x720>
nopw   0x0(%rax,%rax,1)
mov    %rbp,0xd0(%rsp)
mov    %rbx,%rbp
mov    %rbx,0x98(%rsp)
mov    %rdi,0x38(%rsp)
mov    %r8,0x60(%rsp)
mov    %rdx,0x20(%rsp)
mov    %rcx,0x58(%rsp)
mov    %eax,0x1c(%rsp)
mov    %r11d,0xc(%rsp)
movsd  %xmm9,0x50(%rsp)
mov    (%r14,%r13,8),%rax
movsd  (%rax,%r13,8),%xmm0
mov    %r14,%rbp
call   1040 <fabs@plt>
mov    %rax,%r14
mov    0x110(%rsp),%rbx
movsd  (%rbx,%r13,8),%xmm0
call   1040 <fabs@plt>
cmp    %rax,%r14
jge    146f <qrsolv+0x33f>
mov    0x0(%rbp,%r13,8),%rax
movsd  (%rax,%r13,8),%xmm11
divsd  (%rbx,%r13,8),%xmm11
movapd %xmm11,%xmm0
mulsd  %xmm11,%xmm0
addsd  0xba9(%rip),%xmm0
xorpd  %xmm8,%xmm8
ucomisd %xmm8,%xmm0
jb     14ad <qrsolv+0x37d>
mov    %rbp,%r14
mov    %rbx,%rbp
sqrtsd %xmm0,%xmm0
jmp    14d8 <qrsolv+0x3a8>
movsd  (%rbx,%r13,8),%xmm10
mov    0x0(%rbp,%r13,8),%rax
divsd  (%rax,%r13,8),%xmm10
movapd %xmm10,%xmm0
mulsd  %xmm10,%xmm0
addsd  0xb6e(%rip),%xmm0
xorpd  %xmm8,%xmm8
ucomisd %xmm8,%xmm0
jb     150c <qrsolv+0x3dc>
mov    %rbp,%r14
mov    %rbx,%rbp
sqrtsd %xmm0,%xmm0
jmp    1537 <qrsolv+0x407>
movapd %xmm11,0xa0(%rsp)
call   1050 <sqrt@plt>
movapd 0xa0(%rsp),%xmm11
xorpd  %xmm8,%xmm8
mov    0x110(%rsp),%rbp
mov    0x30(%rsp),%r14
mov    0x10(%rsp),%r10
mov    0x8(%rsp),%esi
mov    0x48(%rsp),%r9
movsd  0x50(%rsp),%xmm9
mov    0xc(%rsp),%r11d
mov    0x20(%rsp),%rdx
movsd  0xb00(%rip),%xmm10
divsd  %xmm0,%xmm10
mulsd  %xmm10,%xmm11
jmp    1569 <qrsolv+0x439>
movapd %xmm10,0xa0(%rsp)
call   1050 <sqrt@plt>
movapd 0xa0(%rsp),%xmm10
xorpd  %xmm8,%xmm8
mov    0x110(%rsp),%rbp
mov    0x30(%rsp),%r14
mov    0x10(%rsp),%r10
mov    0x8(%rsp),%esi
mov    0x48(%rsp),%r9
movsd  0x50(%rsp),%xmm9
mov    0xc(%rsp),%r11d
mov    0x20(%rsp),%rdx
movsd  0xaa1(%rip),%xmm11
divsd  %xmm0,%xmm11
mulsd  %xmm11,%xmm10
mov    (%r14,%r13,8),%rax
movsd  0x0(%rbp,%r13,8),%xmm0
mulsd  %xmm10,%xmm0
movsd  (%rax,%r13,8),%xmm1
mulsd  %xmm11,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%rax,%r13,8)
mov    0x118(%rsp),%rcx
movsd  (%rcx,%r13,8),%xmm0
movapd %xmm9,%xmm1
mulsd  %xmm10,%xmm1
movapd %xmm11,%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm1,%xmm2
mulsd  %xmm11,%xmm9
mulsd  %xmm10,%xmm0
subsd  %xmm0,%xmm9
movsd  %xmm2,(%rcx,%r13,8)
add    $0x1,%r13
cmp    0xc8(%rsp),%r13
jge    1758 <qrsolv+0x628>
mov    0x68(%rsp),%rcx
add    %ecx,%edx
mov    $0xfffffffe,%r8d
sub    %edx,%r8d
movapd %xmm10,%xmm0
xorpd  0xa19(%rip),%xmm0
mov    0x60(%rsp),%rdi
mov    %rdi,%rcx
mov    0x38(%rsp),%rdx
add    %r8d,%edx
mov    %rdx,0x38(%rsp)
je     17f0 <qrsolv+0x6c0>
mov    0xd0(%rsp),%rbx
add    %r8d,%ebx
lea    0x0(,%rdi,8),%rdx
add    %rbp,%rdx
mov    0x98(%rsp),%rcx
add    %rbx,%rcx
lea    (%rax,%rcx,8),%rcx
cmp    %rcx,%rdx
jae    1666 <qrsolv+0x536>
mov    %rbx,%r10
mov    0x98(%rsp),%rcx
lea    0x0(,%rcx,8),%rdx
add    %rbp,%rdx
lea    (%rdx,%rbx,8),%rdx
lea    (%rax,%rdi,8),%rbx
mov    %rdi,%rcx
cmp    %rdx,%rbx
jb     17f0 <qrsolv+0x6c0>
add    %r8d,%r12d
add    $0x1,%r12
movabs $0x1fffffffe,%rcx
and    %rcx,%r12
add    $0xfffffffffffffffe,%r12
mov    %r12,%r8
shr    %r8
add    $0x1,%r8
addq   $0x1,0x38(%rsp)
movapd %xmm10,%xmm3
unpcklpd %xmm10,%xmm3
movapd %xmm11,%xmm1
unpcklpd %xmm11,%xmm1
movapd %xmm0,%xmm2
unpcklpd %xmm0,%xmm2
test   %r12,%r12
je     1770 <qrsolv+0x640>
add    %r11d,%r15d
add    $0x1,%r15
and    $0xfffffffffffffffe,%r15
add    $0xfffffffffffffffe,%r15
shr    %r15
add    $0x1,%r15
and    $0xfffffffffffffffe,%r15
mov    0x58(%rsp),%rcx
lea    (%rax,%rcx,8),%rcx
xor    %edx,%edx
mov    0x28(%rsp),%rdi
nopl   (%rax)
movupd -0x10(%rcx,%rdx,8),%xmm4
movupd -0x10(%rdi,%rdx,8),%xmm5
movapd %xmm3,%xmm6
mulpd  %xmm5,%xmm6
movapd %xmm1,%xmm7
mulpd  %xmm4,%xmm7
addpd  %xmm6,%xmm7
mulpd  %xmm1,%xmm5
mulpd  %xmm2,%xmm4
addpd  %xmm5,%xmm4
movupd %xmm4,-0x10(%rdi,%rdx,8)
movupd %xmm7,-0x10(%rcx,%rdx,8)
movupd (%rcx,%rdx,8),%xmm4
movupd (%rdi,%rdx,8),%xmm5
movapd %xmm3,%xmm6
mulpd  %xmm5,%xmm6
movapd %xmm1,%xmm7
mulpd  %xmm4,%xmm7
addpd  %xmm6,%xmm7
mulpd  %xmm1,%xmm5
mulpd  %xmm2,%xmm4
addpd  %xmm5,%xmm4
movupd %xmm4,(%rdi,%rdx,8)
movupd %xmm7,(%rcx,%rdx,8)
add    $0x4,%rdx
add    $0xfffffffffffffffe,%r15
jne    16e0 <qrsolv+0x5b0>
jmp    1777 <qrsolv+0x647>
mov    0x1c(%rsp),%eax
mov    0x58(%rsp),%rcx
mov    0x28(%rsp),%rdi
mov    0x60(%rsp),%r8
jmp    1850 <qrsolv+0x720>
xor    %edx,%edx
mov    0x28(%rsp),%rdi
mov    0x38(%rsp),%rcx
movabs $0x1fffffffe,%rbx
and    %rbx,%rcx
test   $0x1,%r8b
mov    0x60(%rsp),%r8
mov    0x10(%rsp),%r10
je     17ce <qrsolv+0x69e>
add    %r8,%rdx
movupd (%rax,%rdx,8),%xmm4
movupd 0x0(%rbp,%rdx,8),%xmm5
mulpd  %xmm5,%xmm3
movapd %xmm1,%xmm6
mulpd  %xmm4,%xmm6
addpd  %xmm3,%xmm6
mulpd  %xmm5,%xmm1
mulpd  %xmm4,%xmm2
addpd  %xmm1,%xmm2
movupd %xmm2,0x0(%rbp,%rdx,8)
movupd %xmm6,(%rax,%rdx,8)
cmp    %rcx,0x38(%rsp)
jne    17e5 <qrsolv+0x6b5>
mov    0x1c(%rsp),%eax
mov    0x58(%rsp),%rcx
mov    0x20(%rsp),%rdx
jmp    1850 <qrsolv+0x720>
add    %r8,%rcx
nopl   0x0(%rax,%rax,1)
movsd  (%rax,%rcx,8),%xmm1
movsd  0x0(%rbp,%rcx,8),%xmm2
movapd %xmm10,%xmm3
mulsd  %xmm2,%xmm3
movapd %xmm11,%xmm4
mulsd  %xmm1,%xmm4
addsd  %xmm3,%xmm4
mulsd  %xmm11,%xmm2
mulsd  %xmm0,%xmm1
addsd  %xmm2,%xmm1
movsd  %xmm1,0x0(%rbp,%rcx,8)
movsd  %xmm4,(%rax,%rcx,8)
add    $0x1,%rcx
cmp    %esi,%ecx
jl     17f0 <qrsolv+0x6c0>
mov    0x1c(%rsp),%eax
mov    0x58(%rsp),%rcx
mov    0x28(%rsp),%rdi
mov    0x20(%rsp),%rdx
mov    0x60(%rsp),%r8
mov    0x10(%rsp),%r10
xchg   %ax,%ax
cmp    %r10,%r13
je     1260 <qrsolv+0x130>
add    $0x1,%r8
movsd  0x0(%rbp,%r13,8),%xmm0
add    $0x1,%rdx
add    $0x8,%rdi
mov    %rdi,0x28(%rsp)
add    $0x1,%rcx
add    $0x1,%eax
add    $0xffffffff,%r11d
jmp    1380 <qrsolv+0x250>
test   %esi,%esi
jle    1a99 <qrsolv+0x969>
mov    %r10,%r8
add    $0xffffffffffffffff,%r8
je     1917 <qrsolv+0x7e7>
mov    %r10d,%r11d
and    $0xfffffffe,%r11d
xor    %eax,%eax
xorpd  %xmm0,%xmm0
mov    %esi,%edi
jmp    18b9 <qrsolv+0x789>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rax
cmp    %r11,%rax
je     1911 <qrsolv+0x7e1>
mov    %rax,%rbx
cmp    %esi,%edi
mov    %ebx,%ecx
cmovne %edi,%ecx
ucomisd 0x0(%rbp,%rax,8),%xmm0
cmovne %edi,%ecx
cmovp  %edi,%ecx
cmp    %esi,%ecx
jge    18e3 <qrsolv+0x7b3>
mov    0x118(%rsp),%rax
movq   $0x0,(%rax,%rbx,8)
lea    0x1(%rbx),%rax
cmp    %esi,%ecx
mov    %eax,%edi
cmovne %ecx,%edi
ucomisd 0x8(%rbp,%rbx,8),%xmm0
cmovne %ecx,%edi
cmovp  %ecx,%edi
cmp    %esi,%edi
jge    18b0 <qrsolv+0x780>
mov    0x118(%rsp),%rcx
movq   $0x0,0x8(%rcx,%rbx,8)
jmp    18b0 <qrsolv+0x780>
add    $0x2,%rbx
jmp    191b <qrsolv+0x7eb>
xor    %ebx,%ebx
mov    %esi,%edi
mov    %edi,%r11d
test   $0x1,%r10b
je     195b <qrsolv+0x82b>
cmp    %esi,%edi
mov    %ebx,%r11d
cmovne %edi,%r11d
xorpd  %xmm0,%xmm0
mov    0x110(%rsp),%rax
ucomisd (%rax,%rbx,8),%xmm0
cmovne %edi,%r11d
cmovp  %edi,%r11d
cmp    %esi,%r11d
jge    195b <qrsolv+0x82b>
mov    0x118(%rsp),%rax
movq   $0x0,(%rax,%rbx,8)
test   %r11d,%r11d
jle    19f1 <qrsolv+0x8c1>
mov    %r11d,%eax
xor    %r14d,%r14d
jmp    19a4 <qrsolv+0x874>
nopl   0x0(%rax)
xorpd  %xmm0,%xmm0
mov    0x118(%rsp),%rcx
movsd  (%rcx,%rdi,8),%xmm1
subsd  %xmm0,%xmm1
mov    0x110(%rsp),%rbx
divsd  (%rbx,%rdi,8),%xmm1
movsd  %xmm1,(%rcx,%rdi,8)
add    $0x1,%r14
add    $0xffffffff,%r11d
cmp    %rax,%r14
je     19f1 <qrsolv+0x8c1>
mov    %r14,%rdi
not    %rdi
add    %rax,%rdi
test   %r14,%r14
je     1970 <qrsolv+0x840>
movslq %r11d,%rbp
mov    0x30(%rsp),%rbx
mov    (%rbx,%rdi,8),%rbx
xorpd  %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rbx,%rbp,8),%xmm1
mov    0x118(%rsp),%rcx
mulsd  (%rcx,%rbp,8),%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rbp
cmp    %rax,%rbp
jl     19d0 <qrsolv+0x8a0>
jmp    1974 <qrsolv+0x844>
test   %esi,%esi
jle    1a99 <qrsolv+0x969>
mov    %r10d,%ecx
and    $0x3,%ecx
cmp    $0x3,%r8
jae    1a09 <qrsolv+0x8d9>
xor    %eax,%eax
jmp    1a63 <qrsolv+0x933>
and    $0xfffffffc,%r10d
xor    %eax,%eax
nop
movslq (%rdx,%rax,4),%rsi
mov    0x118(%rsp),%rdi
movsd  (%rdi,%rax,8),%xmm0
movsd  %xmm0,(%r9,%rsi,8)
movslq 0x4(%rdx,%rax,4),%rsi
movsd  0x8(%rdi,%rax,8),%xmm0
movsd  %xmm0,(%r9,%rsi,8)
movslq 0x8(%rdx,%rax,4),%rsi
movsd  0x10(%rdi,%rax,8),%xmm0
movsd  %xmm0,(%r9,%rsi,8)
movslq 0xc(%rdx,%rax,4),%rsi
movsd  0x18(%rdi,%rax,8),%xmm0
movsd  %xmm0,(%r9,%rsi,8)
add    $0x4,%rax
cmp    %rax,%r10
jne    1a10 <qrsolv+0x8e0>
test   %rcx,%rcx
je     1a99 <qrsolv+0x969>
mov    0x118(%rsp),%rsi
lea    (%rsi,%rax,8),%rbp
lea    (%rdx,%rax,4),%rax
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movslq (%rax,%rsi,4),%rdi
movsd  0x0(%rbp,%rsi,8),%xmm0
movsd  %xmm0,(%r9,%rdi,8)
add    $0x1,%rsi
cmp    %rsi,%rcx
jne    1a80 <qrsolv+0x950>
add    $0xd8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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