#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 ldr, int ipvt[], double diag[], double qtb[],
            double x[], double sdiag[], double wa[]) {
  int i;
  int ij;
  int ik;
  int kk;
  int j;
  int jp1;
  int k;
  int kp1;
  int l;
  int nsing;
  double cos;
  double cotan;
  double qtbpj;
  double sin;
  double sum;
  double tan;
  double temp;
  static double zero = 0.0;
  static double p25 = 0.25;
  static double p5 = 0.5;
  kk = 0;
  for (j = 0; j < n; j++) {
    ij = kk;
    ik = kk;
    for (i = j; i < n; i++) {
      r[ij] = r[ik];
      ij += 1;
      ik += ldr;
    }
    x[j] = r[kk];
    wa[j] = qtb[j];
    kk += ldr + 1;
  }
  for (j = 0; j < n; j++) {
    l = ipvt[j];
    if (diag[l] == zero)
      goto L90;
    for (k = j; k < n; k++)
      sdiag[k] = zero;
    sdiag[j] = diag[l];
    qtbpj = zero;
    for (k = j; k < n; k++) {
      if (sdiag[k] == zero)
        continue;
      kk = k + ldr * k;
      if (fabs(r[kk]) < fabs(sdiag[k])) {
        cotan = r[kk] / sdiag[k];
        sin = p5 / sqrt(p25 + p25 * cotan * cotan);
        cos = sin * cotan;
      } else {
        tan = sdiag[k] / r[kk];
        cos = p5 / sqrt(p25 + p25 * tan * tan);
        sin = cos * tan;
      }
      r[kk] = cos * r[kk] + sin * sdiag[k];
      temp = cos * wa[k] + sin * qtbpj;
      qtbpj = -sin * wa[k] + cos * qtbpj;
      wa[k] = temp;
      kp1 = k + 1;
      if (n > kp1) {
        ik = kk + 1;
        for (i = kp1; i < n; i++) {
          temp = cos * r[ik] + sin * sdiag[i];
          sdiag[i] = -sin * r[ik] + cos * sdiag[i];
          r[ik] = temp;
          ik += 1;
        }
      }
    }
  L90:
    kk = j + ldr * j;
    sdiag[j] = r[kk];
    r[kk] = x[j];
  }
  nsing = n;
  for (j = 0; j < n; j++) {
    if ((sdiag[j] == zero) && (nsing == n))
      nsing = j;
    if (nsing < n)
      wa[j] = zero;
  }
  if (nsing < 1)
    goto L150;
  for (k = 0; k < nsing; k++) {
    j = nsing - k - 1;
    sum = zero;
    jp1 = j + 1;
    if (nsing > jp1) {
      ij = jp1 + ldr * j;
      for (i = jp1; i < nsing; i++) {
        sum += r[ij] * wa[i];
        ij += 1;
      }
    }
    wa[j] = (wa[j] - sum) / sdiag[j];
  }
L150:
  for (j = 0; j < n; j++) {
    l = ipvt[j];
    x[l] = wa[j];
  }
}


x86 assembly (clang, -O0):
<qrsolv>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movl   $0x0,-0x40(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    120d <qrsolv+0xed>
mov    -0x40(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x40(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x44(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    11bf <qrsolv+0x9f>
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x14(%rbp),%eax
add    -0x3c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1179 <qrsolv+0x59>
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
add    -0x40(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    115b <qrsolv+0x3b>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1640 <qrsolv+0x520>
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x54(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd 0x2e05(%rip),%xmm0
jne    1254 <qrsolv+0x134>
jp     1254 <qrsolv+0x134>
jmp    15ef <qrsolv+0x4cf>
mov    -0x44(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1289 <qrsolv+0x169>
movsd  0x2dda(%rip),%xmm0
mov    0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    125a <qrsolv+0x13a>
mov    -0x28(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x2d9d(%rip),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x44(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    15ea <qrsolv+0x4ca>
mov    0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd 0x2d71(%rip),%xmm0
jne    12e8 <qrsolv+0x1c8>
jp     12e8 <qrsolv+0x1c8>
jmp    15dc <qrsolv+0x4bc>
mov    -0x4c(%rbp),%eax
mov    -0x14(%rbp),%ecx
imul   -0x4c(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1030 <fabs@plt>
mov    %rax,-0x98(%rbp)
mov    0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   1030 <fabs@plt>
mov    %rax,%rcx
mov    -0x98(%rbp),%rax
cmp    %rcx,%rax
jge    13b3 <qrsolv+0x293>
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  0x2cdc(%rip),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  0x2cc4(%rip),%xmm1
movsd  0x2cbc(%rip),%xmm0
mulsd  -0x68(%rbp),%xmm0
movsd  -0x68(%rbp),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1040 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0xa0(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x78(%rbp),%xmm0
mulsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
jmp    1438 <qrsolv+0x318>
mov    0x18(%rbp),%rax
movslq -0x4c(%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  0x2c5b(%rip),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  0x2c43(%rip),%xmm1
movsd  0x2c3b(%rip),%xmm0
mulsd  -0x88(%rbp),%xmm0
ff
movsd  -0x88(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
call   1040 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0xa8(%rbp),%xmm0
ff
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
mulsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x78(%rbp)
movsd  -0x60(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x78(%rbp),%xmm1
mov    0x18(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x60(%rbp),%xmm0
mov    0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x78(%rbp),%xmm1
mulsd  -0x70(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x60(%rbp),%xmm1
mulsd  -0x70(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x90(%rbp),%xmm0
ff
mov    0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    -0x4(%rbp),%eax
cmp    -0x50(%rbp),%eax
jle    15d7 <qrsolv+0x4b7>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x50(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    15d2 <qrsolv+0x4b2>
movsd  -0x60(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x78(%rbp),%xmm1
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
movsd  -0x78(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x60(%rbp),%xmm1
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x90(%rbp),%xmm0
ff
mov    -0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1516 <qrsolv+0x3f6>
jmp    15d7 <qrsolv+0x4b7>
jmp    15dc <qrsolv+0x4bc>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    12b6 <qrsolv+0x196>
jmp    15ef <qrsolv+0x4cf>
mov    -0x44(%rbp),%eax
mov    -0x14(%rbp),%ecx
imul   -0x44(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1214 <qrsolv+0xf4>
mov    -0x4(%rbp),%eax
mov    %eax,-0x58(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    16c0 <qrsolv+0x5a0>
mov    0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd 0x29da(%rip),%xmm0
jne    168c <qrsolv+0x56c>
jp     168c <qrsolv+0x56c>
mov    -0x58(%rbp),%eax
cmp    -0x4(%rbp),%eax
jne    168c <qrsolv+0x56c>
mov    -0x44(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    16ad <qrsolv+0x58d>
movsd  0x29a8(%rip),%xmm0
mov    0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    16b2 <qrsolv+0x592>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    164d <qrsolv+0x52d>
cmpl   $0x1,-0x58(%rbp)
jge    16cf <qrsolv+0x5af>
jmp    17b8 <qrsolv+0x698>
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x58(%rbp),%eax
jge    17b3 <qrsolv+0x693>
mov    -0x58(%rbp),%eax
sub    -0x4c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x44(%rbp)
movsd  0x2952(%rip),%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x48(%rbp),%eax
jle    1779 <qrsolv+0x659>
mov    -0x48(%rbp),%eax
mov    -0x14(%rbp),%ecx
imul   -0x44(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x38(%rbp)
mov    -0x48(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x58(%rbp),%eax
jge    1774 <qrsolv+0x654>
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x80(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1725 <qrsolv+0x605>
jmp    1779 <qrsolv+0x659>
mov    0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x80(%rbp),%xmm0
mov    0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    16d6 <qrsolv+0x5b6>
jmp    17b8 <qrsolv+0x698>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1801 <qrsolv+0x6e1>
mov    -0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x54(%rbp)
mov    0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rax
movslq -0x54(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    17bf <qrsolv+0x69f>
add    $0xb0,%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    %r9,0x78(%rsp)
mov    %r8,0x98(%rsp)
mov    %rdx,0x68(%rsp)
test   %edi,%edi
jle    1b28 <qrsolv+0x9f8>
mov    %rsi,%r12
mov    %rcx,0x80(%rsp)
mov    0x68(%rsp),%rax
lea    0x1(%rax),%ecx
mov    %ecx,0x8(%rsp)
movslq %ecx,%rcx
movslq %eax,%r11
mov    %edi,%eax
mov    %rax,0x70(%rsp)
mov    %rcx,0x28(%rsp)
lea    0x0(,%rcx,8),%rax
mov    %rax,0x38(%rsp)
lea    (%r11,%r11,2),%rax
mov    %rax,0x20(%rsp)
lea    0x0(,%r11,4),%rsi
lea    (%r11,%r11,1),%rax
mov    %rax,0x18(%rsp)
xor    %r10d,%r10d
mov    %edi,%edx
mov    %r12,%rbx
xor    %eax,%eax
mov    %rax,0x48(%rsp)
xor    %r15d,%r15d
xor    %r14d,%r14d
mov    %edi,0x4(%rsp)
jmp    1231 <qrsolv+0x101>
cs nopw 0x0(%rax,%rax,1)
movsd  (%r12,%r14,8),%xmm0
mov    0x110(%rsp),%rax
movsd  %xmm0,(%rax,%r15,8)
mov    0x78(%rsp),%rax
movsd  (%rax,%r15,8),%xmm0
mov    0x120(%rsp),%rax
movsd  %xmm0,(%rax,%r15,8)
mov    0x28(%rsp),%rax
add    %rax,%r14
add    $0x1,%r15
sub    %rax,0x48(%rsp)
add    0x38(%rsp),%rbx
mov    0x10(%rsp),%r10
add    $0xffffffffffffffff,%r10
add    $0x3,%dl
cmp    0x70(%rsp),%r15
mov    0x4(%rsp),%edi
mov    %r13,%r11
je     1317 <qrsolv+0x1e7>
movzbl %dl,%edx
and    $0x3,%edx
mov    %edi,%r9d
sub    %r15d,%r9d
mov    %r15d,%r8d
not    %r8d
add    %edi,%r8d
mov    %r14,%rax
mov    %r14,%rbp
mov    %r15d,%ecx
test   $0x3,%r9b
je     1286 <qrsolv+0x156>
xor    %ecx,%ecx
xor    %eax,%eax
nopl   0x0(%rax)
movsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,(%rbx,%rcx,8)
add    %r11,%rax
add    $0x1,%rcx
cmp    %ecx,%edx
jne    1260 <qrsolv+0x130>
mov    0x48(%rsp),%r9
sub    %r9,%rax
mov    %rcx,%rbp
sub    %r9,%rbp
sub    %r10d,%ecx
mov    %r10,0x10(%rsp)
cmp    $0x3,%r8d
mov    %r11,%r13
jb     11d0 <qrsolv+0xa0>
mov    0x20(%rsp),%rdi
lea    (%rdi,%rax,1),%r8
mov    0x18(%rsp),%rdi
lea    (%rdi,%rax,1),%r10
lea    (%rax,%r13,1),%r11
add    $0x3,%rbp
mov    0x4(%rsp),%r9d
sub    %ecx,%r9d
nopw   0x0(%rax,%rax,1)
movsd  (%r12,%rax,8),%xmm0
movsd  %xmm0,-0x18(%r12,%rbp,8)
add    %r13,%rax
movsd  (%r12,%r11,8),%xmm0
movsd  %xmm0,-0x10(%r12,%rbp,8)
add    %r13,%rax
movsd  (%r12,%r10,8),%xmm0
movsd  %xmm0,-0x8(%r12,%rbp,8)
add    %r13,%rax
movsd  (%r12,%r8,8),%xmm0
movsd  %xmm0,(%r12,%rbp,8)
add    %r13,%rax
add    %rsi,%r8
add    %rsi,%r10
add    %rsi,%r11
add    $0x4,%rbp
add    $0xfffffffc,%r9d
jne    12c0 <qrsolv+0x190>
jmp    11d0 <qrsolv+0xa0>
test   %edi,%edi
mov    0x80(%rsp),%r10
mov    0x70(%rsp),%r15
jle    1b28 <qrsolv+0x9f8>
lea    0x8(%r12),%rax
mov    %rax,0xa8(%rsp)
lea    0x10(%r12),%rax
mov    %rax,0xc0(%rsp)
mov    0x118(%rsp),%rsi
lea    0x8(%rsi),%rax
mov    %rax,0x90(%rsp)
xor    %eax,%eax
mov    %rax,0x58(%rsp)
mov    $0x1,%eax
mov    %rax,0x88(%rsp)
movl   $0x2,0x54(%rsp)
movl   $0xfffffffe,0x50(%rsp)
ff
xorpd  %xmm8,%xmm8
xor    %ecx,%ecx
mov    0x8(%rsp),%r8d
mov    %r11,0x40(%rsp)
jmp    1413 <qrsolv+0x2e3>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x60(%rsp),%rcx
mov    %rcx,%rax
imul   %r11,%rax
add    %rcx,%rax
movsd  (%r12,%rax,8),%xmm0
mov    0xa0(%rsp),%rdx
movsd  %xmm0,(%rdx)
mov    0x110(%rsp),%r9
movsd  (%r9,%rcx,8),%xmm0
movsd  %xmm0,(%r12,%rax,8)
add    $0x1,%rcx
mov    0x58(%rsp),%rax
add    %r8d,%eax
mov    %rax,0x58(%rsp)
addq   $0x1,0x88(%rsp)
addl   $0x1,0x54(%rsp)
addl   $0xffffffff,0x50(%rsp)
addq   $0x8,0x90(%rsp)
cmp    %r15,%rcx
mov    0x80(%rsp),%r10
je     18fb <qrsolv+0x7cb>
lea    (%rsi,%rcx,8),%rax
mov    %rax,0xa0(%rsp)
mov    %rcx,0x60(%rsp)
movslq (%r10,%rcx,4),%rbx
mov    0x98(%rsp),%rax
movsd  (%rax,%rbx,8),%xmm0
ucomisd %xmm8,%xmm0
jne    1442 <qrsolv+0x312>
jnp    13a0 <qrsolv+0x270>
mov    0x60(%rsp),%r13
lea    0x2(%r13),%rax
mov    %rax,0x78(%rsp)
mov    %r13d,%eax
not    %eax
add    %edi,%eax
lea    0x8(,%rax,8),%rdx
mov    0xa0(%rsp),%rbp
mov    %rbp,%rdi
xor    %esi,%esi
call   1030 <memset@plt>
xorpd  %xmm8,%xmm8
mov    0x40(%rsp),%r11
mov    0x8(%rsp),%r8d
mov    0x4(%rsp),%edi
mov    0x98(%rsp),%rax
movsd  (%rax,%rbx,8),%xmm0
movsd  %xmm0,0x0(%rbp)
xorpd  %xmm9,%xmm9
mov    0x90(%rsp),%rbp
mov    0x50(%rsp),%r10d
mov    0x54(%rsp),%edx
xor    %ecx,%ecx
mov    %r13,%rbx
mov    0x88(%rsp),%r9
mov    0x58(%rsp),%rax
mov    %eax,0x48(%rsp)
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmp    %edx,%edi
mov    %edx,%r13d
cmovg  %edi,%r13d
mov    0x78(%rsp),%rax
lea    (%rax,%rcx,1),%esi
cmp    %esi,%edi
cmovg  %edi,%esi
lea    (%rax,%rcx,1),%r14
cmp    %r14d,%edi
mov    %r14d,%eax
cmovg  %edi,%eax
ucomisd %xmm8,%xmm0
jne    1510 <qrsolv+0x3e0>
jp     1510 <qrsolv+0x3e0>
add    $0x1,%rbx
mov    0x118(%rsp),%rsi
jmp    18d0 <qrsolv+0x7a0>
nopl   (%rax)
mov    %rax,0xd0(%rsp)
mov    %r14,0xc8(%rsp)
mov    %rsi,0x38(%rsp)
mov    %r9,0x10(%rsp)
mov    %rcx,0x28(%rsp)
mov    %edx,0xc(%rsp)
mov    %r10d,0x18(%rsp)
mov    %rbp,0x20(%rsp)
movsd  %xmm9,0x30(%rsp)
mov    %ebx,%eax
imul   0x68(%rsp),%eax
movslq %eax,%r15
add    %rbx,%r15
movsd  (%r12,%r15,8),%xmm0
call   1040 <fabs@plt>
mov    %rax,%r14
mov    0x118(%rsp),%rbp
movsd  0x0(%rbp,%rbx,8),%xmm0
call   1040 <fabs@plt>
cmp    %rax,%r14
jge    15b3 <qrsolv+0x483>
movsd  (%r12,%r15,8),%xmm10
divsd  0x0(%rbp,%rbx,8),%xmm10
movapd %xmm10,%xmm0
movsd  0xa6f(%rip),%xmm1
mulsd  %xmm1,%xmm0
mulsd  %xmm10,%xmm0
addsd  %xmm1,%xmm0
xorpd  %xmm8,%xmm8
ucomisd %xmm8,%xmm0
jb     15f2 <qrsolv+0x4c2>
mov    %rbp,%rsi
sqrtsd %xmm0,%xmm0
jmp    1618 <qrsolv+0x4e8>
movsd  0x0(%rbp,%rbx,8),%xmm11
divsd  (%r12,%r15,8),%xmm11
movapd %xmm11,%xmm0
movsd  0xa33(%rip),%xmm1
mulsd  %xmm1,%xmm0
mulsd  %xmm11,%xmm0
addsd  %xmm1,%xmm0
xorpd  %xmm8,%xmm8
ucomisd %xmm8,%xmm0
jb     165a <qrsolv+0x52a>
mov    %rbp,%rsi
sqrtsd %xmm0,%xmm0
jmp    1680 <qrsolv+0x550>
movapd %xmm10,0xb0(%rsp)
call   1050 <sqrt@plt>
movapd 0xb0(%rsp),%xmm10
xorpd  %xmm8,%xmm8
mov    0x118(%rsp),%rsi
mov    0x4(%rsp),%edi
mov    0x8(%rsp),%r8d
mov    0x40(%rsp),%r11
movsd  0x30(%rsp),%xmm9
mov    0x20(%rsp),%rbp
mov    0x18(%rsp),%r10d
mov    0xc(%rsp),%edx
mov    0x28(%rsp),%rcx
mov    0x10(%rsp),%r9
movsd  0x9ba(%rip),%xmm11
divsd  %xmm0,%xmm11
mulsd  %xmm11,%xmm10
jmp    16c0 <qrsolv+0x590>
movapd %xmm11,0xb0(%rsp)
call   1050 <sqrt@plt>
movapd 0xb0(%rsp),%xmm11
xorpd  %xmm8,%xmm8
mov    0x118(%rsp),%rsi
mov    0x4(%rsp),%edi
mov    0x8(%rsp),%r8d
mov    0x40(%rsp),%r11
movsd  0x30(%rsp),%xmm9
mov    0x20(%rsp),%rbp
mov    0x18(%rsp),%r10d
mov    0xc(%rsp),%edx
mov    0x28(%rsp),%rcx
mov    0x10(%rsp),%r9
movsd  0x952(%rip),%xmm10
divsd  %xmm0,%xmm10
mulsd  %xmm10,%xmm11
movsd  (%rsi,%rbx,8),%xmm0
mulsd  %xmm11,%xmm0
movsd  (%r12,%r15,8),%xmm1
mulsd  %xmm10,%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%r12,%r15,8)
mov    0x120(%rsp),%rax
movsd  (%rax,%rbx,8),%xmm0
movapd %xmm9,%xmm1
mulsd  %xmm11,%xmm1
movapd %xmm10,%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm1,%xmm2
mulsd  %xmm10,%xmm9
mulsd  %xmm11,%xmm0
subsd  %xmm0,%xmm9
movsd  %xmm2,(%rax,%rbx,8)
add    $0x1,%rbx
mov    0x70(%rsp),%r15
cmp    %r15,%rbx
jge    18d0 <qrsolv+0x7a0>
mov    %rbx,0x30(%rsp)
mov    0x60(%rsp),%rax
add    %ecx,%eax
mov    $0xfffffffe,%ecx
sub    %eax,%ecx
movslq 0x48(%rsp),%r9
movapd %xmm11,%xmm0
xorpd  0x8c2(%rip),%xmm0
mov    0x38(%rsp),%rax
add    %ecx,%eax
mov    %rax,0x38(%rsp)
je     17bd <qrsolv+0x68d>
mov    0xd0(%rsp),%rbx
add    %ecx,%ebx
lea    (%r9,%rbx,1),%r10
mov    0xa8(%rsp),%rax
lea    (%rax,%r9,8),%rdx
mov    0x10(%rsp),%rax
lea    (%rsi,%rax,8),%rax
mov    0xc0(%rsp),%rcx
lea    (%rcx,%r10,8),%rcx
cmp    %rcx,%rax
jae    17c7 <qrsolv+0x697>
mov    0xc8(%rsp),%rax
lea    (%rsi,%rax,8),%rcx
lea    (%rcx,%rbx,8),%rcx
cmp    %rcx,%rdx
jae    17c7 <qrsolv+0x697>
mov    0x10(%rsp),%rcx
mov    0x20(%rsp),%rbp
mov    0x18(%rsp),%r10d
mov    0xc(%rsp),%edx
jmp    186f <qrsolv+0x73f>
mov    0x10(%rsp),%rcx
jmp    186f <qrsolv+0x73f>
mov    0x18(%rsp),%r10d
add    %r10d,%r13d
add    $0x1,%r13
and    $0xfffffffffffffffe,%r13
mov    0x38(%rsp),%r8
add    $0x1,%r8
mov    %r8,0x38(%rsp)
and    $0xfffffffffffffffe,%r8
mov    0x10(%rsp),%rax
lea    (%rax,%r8,1),%rcx
add    %r8,%r9
movapd %xmm11,%xmm1
unpcklpd %xmm11,%xmm1
movapd %xmm10,%xmm2
unpcklpd %xmm10,%xmm2
movapd %xmm0,%xmm3
unpcklpd %xmm0,%xmm3
xor    %ebx,%ebx
mov    0x20(%rsp),%rbp
nopl   0x0(%rax,%rax,1)
movupd (%rdx,%rbx,8),%xmm4
movupd 0x0(%rbp,%rbx,8),%xmm5
movapd %xmm1,%xmm6
mulpd  %xmm5,%xmm6
movapd %xmm2,%xmm7
mulpd  %xmm4,%xmm7
addpd  %xmm6,%xmm7
mulpd  %xmm2,%xmm5
mulpd  %xmm3,%xmm4
addpd  %xmm5,%xmm4
movupd %xmm4,0x0(%rbp,%rbx,8)
movupd %xmm7,(%rdx,%rbx,8)
add    $0x2,%rbx
cmp    %rbx,%r13
jne    1820 <qrsolv+0x6f0>
cmp    %r8,0x38(%rsp)
mov    0x8(%rsp),%r8d
mov    0xc(%rsp),%edx
je     18c1 <qrsolv+0x791>
mov    0xa8(%rsp),%rax
lea    (%rax,%r9,8),%rax
nopl   0x0(%rax,%rax,1)
movsd  (%rax),%xmm1
movsd  (%rsi,%rcx,8),%xmm2
movapd %xmm11,%xmm3
mulsd  %xmm2,%xmm3
movapd %xmm10,%xmm4
mulsd  %xmm1,%xmm4
addsd  %xmm3,%xmm4
mulsd  %xmm10,%xmm2
mulsd  %xmm0,%xmm1
addsd  %xmm2,%xmm1
movsd  %xmm1,(%rsi,%rcx,8)
movsd  %xmm4,(%rax)
add    $0x1,%rcx
add    $0x8,%rax
cmp    %edi,%ecx
jl     1880 <qrsolv+0x750>
mov    0x28(%rsp),%rcx
mov    0x30(%rsp),%rbx
mov    0x10(%rsp),%r9
cmp    %r15,%rbx
je     13a0 <qrsolv+0x270>
add    $0x1,%r9
add    %r8d,0x48(%rsp)
movsd  (%rsi,%rbx,8),%xmm0
add    $0x1,%rcx
add    $0x1,%edx
add    $0xffffffff,%r10d
add    $0x8,%rbp
jmp    14d0 <qrsolv+0x3a0>
test   %edi,%edi
jle    1b28 <qrsolv+0x9f8>
mov    %r15,%r8
add    $0xffffffffffffffff,%r8
je     198e <qrsolv+0x85e>
mov    %r15d,%ebp
and    $0xfffffffe,%ebp
xor    %edx,%edx
xorpd  %xmm0,%xmm0
mov    %edi,%esi
jmp    1929 <qrsolv+0x7f9>
add    $0x1,%rdx
cmp    %rbp,%rdx
je     1988 <qrsolv+0x858>
mov    %rdx,%rcx
cmp    %edi,%esi
mov    %ecx,%eax
cmovne %esi,%eax
mov    0x118(%rsp),%rbx
ucomisd (%rbx,%rdx,8),%xmm0
cmovne %esi,%eax
cmovp  %esi,%eax
cmp    %edi,%eax
jge    195a <qrsolv+0x82a>
mov    0x120(%rsp),%rdx
movq   $0x0,(%rdx,%rcx,8)
lea    0x1(%rcx),%rdx
cmp    %edi,%eax
mov    %edx,%esi
cmovne %eax,%esi
ucomisd 0x8(%rbx,%rcx,8),%xmm0
cmovne %eax,%esi
cmovp  %eax,%esi
cmp    %edi,%esi
jge    1920 <qrsolv+0x7f0>
mov    0x120(%rsp),%rax
movq   $0x0,0x8(%rax,%rcx,8)
jmp    1920 <qrsolv+0x7f0>
add    $0x2,%rcx
jmp    1992 <qrsolv+0x862>
xor    %ecx,%ecx
mov    %edi,%esi
mov    %esi,%r13d
test   $0x1,%r15b
je     19d2 <qrsolv+0x8a2>
cmp    %edi,%esi
mov    %ecx,%r13d
cmovne %esi,%r13d
xorpd  %xmm0,%xmm0
mov    0x118(%rsp),%rax
ucomisd (%rax,%rcx,8),%xmm0
cmovne %esi,%r13d
cmovp  %esi,%r13d
cmp    %edi,%r13d
jge    19d2 <qrsolv+0x8a2>
mov    0x120(%rsp),%rax
movq   $0x0,(%rax,%rcx,8)
test   %r13d,%r13d
mov    0x120(%rsp),%rcx
jle    1a6c <qrsolv+0x93c>
mov    %r13d,%edx
lea    -0x1(%r13),%esi
mov    0x68(%rsp),%r11
imul   %r11d,%esi
add    %r13d,%esi
not    %r11d
xor    %ebp,%ebp
jmp    1a2f <qrsolv+0x8ff>
nopl   (%rax)
xorpd  %xmm0,%xmm0
movsd  (%rcx,%rdi,8),%xmm1
subsd  %xmm0,%xmm1
mov    0x118(%rsp),%rax
divsd  (%rax,%rdi,8),%xmm1
movsd  %xmm1,(%rcx,%rdi,8)
add    $0x1,%rbp
add    $0xffffffff,%r13d
add    %r11d,%esi
cmp    %rdx,%rbp
je     1a6c <qrsolv+0x93c>
mov    %rbp,%rdi
not    %rdi
add    %rdx,%rdi
test   %rbp,%rbp
je     1a00 <qrsolv+0x8d0>
movslq %esi,%rax
lea    (%r12,%rax,8),%rbx
movslq %r13d,%rax
xorpd  %xmm0,%xmm0
nopl   0x0(%rax,%rax,1)
movsd  (%rbx),%xmm1
mulsd  (%rcx,%rax,8),%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rax
add    $0x8,%rbx
cmp    %rdx,%rax
jl     1a50 <qrsolv+0x920>
jmp    1a04 <qrsolv+0x8d4>
cmpl   $0x0,0x4(%rsp)
jle    1b28 <qrsolv+0x9f8>
mov    %r15d,%ecx
and    $0x3,%ecx
cmp    $0x3,%r8
jae    1a87 <qrsolv+0x957>
xor    %eax,%eax
jmp    1aeb <qrsolv+0x9bb>
and    $0xfffffffc,%r15d
xor    %eax,%eax
mov    0x120(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
nop
movslq (%r10,%rax,4),%rdx
movsd  (%rsi,%rax,8),%xmm0
movsd  %xmm0,(%r9,%rdx,8)
movslq 0x4(%r10,%rax,4),%rdx
movsd  0x8(%rsi,%rax,8),%xmm0
movsd  %xmm0,(%r9,%rdx,8)
movslq 0x8(%r10,%rax,4),%rdx
movsd  0x10(%rsi,%rax,8),%xmm0
movsd  %xmm0,(%r9,%rdx,8)
movslq 0xc(%r10,%rax,4),%rdx
movsd  0x18(%rsi,%rax,8),%xmm0
movsd  %xmm0,(%r9,%rdx,8)
add    $0x4,%rax
cmp    %rax,%r15
jne    1aa0 <qrsolv+0x970>
test   %rcx,%rcx
je     1b28 <qrsolv+0x9f8>
mov    0x120(%rsp),%rdx
lea    (%rdx,%rax,8),%rdx
lea    (%r10,%rax,4),%rax
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movslq (%rax,%rsi,4),%rdi
movsd  (%rdx,%rsi,8),%xmm0
movsd  %xmm0,(%r9,%rdi,8)
add    $0x1,%rsi
cmp    %rsi,%rcx
jne    1b10 <qrsolv+0x9e0>
add    $0xd8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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