#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
double enorm(int, double *);
double sqrt(double);
void qrfac(int m, int n, double *a, int lda, int pivot, int *ipvt, int lipvt,
           double *rdiag, double *acnorm, double *wa) {
  double d1;
  int i, j, k, jp1;
  double sum;
  double temp;
  int minmn;
  double epsmch;
  double ajnorm;
  (void)lipvt;
  epsmch = 2.2204460492503131e-16;
  for (j = 0; j < n; ++j) {
    acnorm[j] = enorm(m, &a[j * lda + 0]);
    rdiag[j] = acnorm[j];
    wa[j] = rdiag[j];
    if (pivot) {
      ipvt[j] = j + 1;
    }
  }
  minmn = ((m) <= (n) ? (m) : (n));
  for (j = 0; j < minmn; ++j) {
    if (pivot) {
      int kmax = j;
      for (k = j; k < n; ++k) {
        if (rdiag[k] > rdiag[kmax]) {
          kmax = k;
        }
      }
      if (kmax != j) {
        for (i = 0; i < m; ++i) {
          temp = a[i + j * lda];
          a[i + j * lda] = a[i + kmax * lda];
          a[i + kmax * lda] = temp;
        }
        rdiag[kmax] = rdiag[j];
        wa[kmax] = wa[j];
        k = ipvt[j];
        ipvt[j] = ipvt[kmax];
        ipvt[kmax] = k;
      }
    }
    ajnorm = enorm(m - (j + 1) + 1, &a[j + j * lda]);
    if (ajnorm != 0.) {
      if (a[j + j * lda] < 0.) {
        ajnorm = -ajnorm;
      }
      for (i = j; i < m; ++i) {
        a[i + j * lda] /= ajnorm;
      }
      a[j + j * lda] += 1.;
      jp1 = j + 1;
      if (n > jp1) {
        for (k = jp1; k < n; ++k) {
          sum = 0.;
          for (i = j; i < m; ++i) {
            sum += a[i + j * lda] * a[i + k * lda];
          }
          temp = sum / a[j + j * lda];
          for (i = j; i < m; ++i) {
            a[i + k * lda] -= temp * a[i + j * lda];
          }
          if (pivot && rdiag[k] != 0.) {
            temp = a[j + k * lda] / rdiag[k];
            d1 = 1. - temp * temp;
            rdiag[k] *= sqrt(((((double)0.) >= (d1) ? ((double)0.) : (d1))));
            d1 = rdiag[k] / wa[k];
            if (.05 * (d1 * d1) <= epsmch) {
              rdiag[k] = enorm(m - (j + 1), &a[jp1 + k * lda]);
              wa[k] = rdiag[k];
            }
          }
        }
      }
    }
    rdiag[j] = -ajnorm;
  }
}


x86 assembly (clang, -O0):
<qrfac>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%eax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8d,-0x18(%rbp)
mov    %r9,-0x20(%rbp)
movsd  0xeac(%rip),%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    11fa <qrfac+0xda>
mov    -0x4(%rbp),%edi
mov    -0x10(%rbp),%rsi
mov    -0x30(%rbp),%eax
imul   -0x14(%rbp),%eax
add    $0x0,%eax
cltq
shl    $0x3,%rax
add    %rax,%rsi
call   1030 <enorm@plt>
mov    0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x0,-0x18(%rbp)
je     11e7 <qrfac+0xc7>
mov    -0x30(%rbp),%edx
add    $0x1,%edx
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    11ec <qrfac+0xcc>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1160 <qrfac+0x40>
mov    -0x4(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     1211 <qrfac+0xf1>
mov    -0x4(%rbp),%eax
mov    %eax,-0x68(%rbp)
jmp    1217 <qrfac+0xf7>
mov    -0x8(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x68(%rbp),%eax
mov    %eax,-0x4c(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jge    1771 <qrfac+0x651>
cmpl   $0x0,-0x18(%rbp)
je     138d <qrfac+0x26d>
mov    -0x30(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    128b <qrfac+0x16b>
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x64(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jbe    1278 <qrfac+0x158>
mov    -0x34(%rbp),%eax
mov    %eax,-0x64(%rbp)
jmp    127d <qrfac+0x15d>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1246 <qrfac+0x126>
mov    -0x64(%rbp),%eax
cmp    -0x30(%rbp),%eax
je     1388 <qrfac+0x268>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1322 <qrfac+0x202>
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x64(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x64(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    129e <qrfac+0x17e>
mov    0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x28(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x34(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x34(%rbp),%edx
mov    -0x20(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    138d <qrfac+0x26d>
mov    -0x4(%rbp),%edi
mov    -0x30(%rbp),%eax
add    $0x1,%eax
sub    %eax,%edi
add    $0x1,%edi
mov    -0x10(%rbp),%rsi
mov    -0x30(%rbp),%eax
mov    -0x30(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    %ecx,%eax
cltq
shl    $0x3,%rax
add    %rax,%rsi
call   1030 <enorm@plt>
movsd  %xmm0,-0x60(%rbp)
movsd  -0x60(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    13db <qrfac+0x2bb>
jp     13db <qrfac+0x2bb>
jmp    173a <qrfac+0x61a>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
ucomisd (%rax,%rcx,8),%xmm0
jbe    141d <qrfac+0x2fd>
movsd  -0x60(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1463 <qrfac+0x343>
movsd  -0x60(%rbp),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1423 <qrfac+0x303>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  0xb8a(%rip),%xmm0
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x8(%rbp),%eax
cmp    -0x38(%rbp),%eax
jle    1735 <qrfac+0x615>
mov    -0x38(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1730 <qrfac+0x610>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    1519 <qrfac+0x3f9>
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x40(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    14bd <qrfac+0x39d>
movsd  -0x40(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    15b4 <qrfac+0x494>
movsd  -0x48(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x30(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x34(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
movq   %xmm0,%rdx
movabs $0x8000000000000000,%rsi
xor    %rsi,%rdx
movq   %rdx,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1541 <qrfac+0x421>
cmpl   $0x0,-0x18(%rbp)
je     171d <qrfac+0x5fd>
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    15e3 <qrfac+0x4c3>
jp     15e3 <qrfac+0x4c3>
jmp    171d <qrfac+0x5fd>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
mov    -0x34(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x48(%rbp),%xmm0
movsd  -0x48(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm1,%xmm0
movsd  0x9ce(%rip),%xmm1
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x28(%rbp)
xorps  %xmm0,%xmm0
ucomisd -0x28(%rbp),%xmm0
jb     165e <qrfac+0x53e>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
jmp    1668 <qrfac+0x548>
movsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x70(%rbp),%xmm0
call   1040 <sqrt@plt>
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x28(%rbp)
movsd  -0x28(%rbp),%xmm0
mulsd  -0x28(%rbp),%xmm0
movsd  0x95b(%rip),%xmm1
mulsd  %xmm0,%xmm1
movsd  -0x58(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     1718 <qrfac+0x5f8>
mov    -0x4(%rbp),%edi
mov    -0x30(%rbp),%eax
add    $0x1,%eax
sub    %eax,%edi
mov    -0x10(%rbp),%rsi
mov    -0x38(%rbp),%eax
mov    -0x34(%rbp),%ecx
imul   -0x14(%rbp),%ecx
add    %ecx,%eax
cltq
shl    $0x3,%rax
add    %rax,%rsi
call   1030 <enorm@plt>
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    171d <qrfac+0x5fd>
jmp    1722 <qrfac+0x602>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    14a3 <qrfac+0x383>
jmp    1735 <qrfac+0x615>
jmp    173a <qrfac+0x61a>
movsd  -0x60(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1224 <qrfac+0x104>
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<qrfac>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x178,%rsp
mov    %r9,%r13
mov    %r8d,(%rsp)
mov    %rdx,0x30(%rsp)
mov    %esi,%r14d
mov    %edi,0x4(%rsp)
mov    %ecx,0x54(%rsp)
movslq %ecx,%rax
mov    %rax,0x28(%rsp)
mov    %esi,%edi
test   %esi,%esi
mov    %rdi,0x48(%rsp)
jle    11d0 <qrfac+0xb0>
mov    0x1c0(%rsp),%r15
mov    0x28(%rsp),%rax
lea    0x0(,%rax,8),%r12
xor    %ebp,%ebp
mov    0x30(%rsp),%rbx
jmp    1190 <qrfac+0x70>
nopl   0x0(%rax)
add    %r12,%rbx
mov    %rax,%rbp
mov    0x48(%rsp),%rdi
cmp    %rax,%rdi
je     11d0 <qrfac+0xb0>
mov    0x4(%rsp),%edi
mov    %rbx,%rsi
call   1030 <enorm@plt>
lea    0x1(%rbp),%rax
movsd  %xmm0,(%r15,%rbp,8)
mov    0x1b8(%rsp),%rcx
movsd  %xmm0,(%rcx,%rbp,8)
mov    0x1c8(%rsp),%rcx
movsd  %xmm0,(%rcx,%rbp,8)
cmpl   $0x0,(%rsp)
je     1180 <qrfac+0x60>
lea    0x1(%rbp),%ecx
mov    %ecx,0x0(%r13,%rbp,4)
jmp    1180 <qrfac+0x60>
mov    %r13,0xf0(%rsp)
mov    0x4(%rsp),%eax
cmp    %r14d,%eax
cmovg  %r14d,%eax
test   %eax,%eax
mov    (%rsp),%r10d
mov    0x30(%rsp),%r8
mov    0x1b8(%rsp),%r9
mov    0x28(%rsp),%rsi
jle    1c47 <qrfac+0xb27>
mov    0x4(%rsp),%ebx
movslq %r14d,%rcx
mov    %rcx,0x108(%rsp)
mov    %eax,%eax
mov    %rax,0x110(%rsp)
lea    0x0(,%rsi,8),%r11
lea    0x8(,%rsi,8),%rax
mov    %rax,0x80(%rsp)
lea    (%rsi,%rbx,1),%rax
mov    %rax,0xe8(%rsp)
lea    (%r8,%rbx,8),%rax
mov    %rax,0xe0(%rsp)
mov    %ebx,%eax
and    $0xfffffffc,%eax
mov    %rax,0xd0(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0xc8(%rsp)
mov    %rax,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
lea    -0x1(%rbx),%rax
mov    %rax,0x98(%rsp)
mov    %rcx,%rax
mov    %rcx,0xc0(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0xb8(%rsp)
mov    %rbx,%rax
neg    %rax
mov    %rax,0x158(%rsp)
lea    0x30(%r8),%rax
lea    0x8(%r8),%rcx
lea    0x10(%r8),%rdx
mov    %rdx,0x20(%rsp)
lea    -0x2(%rbx),%r13
lea    (%r8,%rsi,8),%r15
add    $0x8,%r15
lea    (%r8,%rsi,8),%rbp
add    $0x10,%rbp
mov    $0x1,%edx
xor    %r14d,%r14d
mov    %rbx,0x78(%rsp)
mov    %r8,%r12
mov    %rcx,0xd8(%rsp)
mov    %rcx,0x70(%rsp)
mov    %rax,0xb0(%rsp)
mov    %rax,0x18(%rsp)
mov    %r11,0x60(%rsp)
jmp    1399 <qrfac+0x279>
nopl   0x0(%rax,%rax,1)
mov    (%rsp),%r10d
mov    0x30(%rsp),%r8
mov    0x1b8(%rsp),%r9
mov    0x28(%rsp),%rsi
mov    0x48(%rsp),%rdi
mov    0x60(%rsp),%r11
movapd 0xcd8(%rip),%xmm7
mov    0x20(%rsp),%rcx
mov    0x18(%rsp),%rax
mov    %r14,%rdx
mov    0x40(%rsp),%r14
mov    %r13,%r15
mov    %rbp,%r13
mov    0x58(%rsp),%rbp
xorpd  %xmm7,%xmm0
movlpd %xmm0,(%r9,%rdx,8)
mov    0x88(%rsp),%rdx
add    $0x1,%rdx
add    %r11,%rax
mov    %rax,0x18(%rsp)
add    %r11,0x70(%rsp)
mov    0x80(%rsp),%rax
add    %rax,%rcx
mov    %rcx,0x20(%rsp)
add    $0xffffffffffffffff,%r13
add    %r11,%r12
add    %r11,%r15
addq   $0xffffffffffffffff,0x78(%rsp)
add    %rax,%rbp
cmp    0x110(%rsp),%r14
je     1c47 <qrfac+0xb27>
mov    %rdx,0x88(%rsp)
mov    %r14,%rax
imul   %rsi,%rax
mov    %rax,%rcx
mov    %rax,0x38(%rsp)
add    %rbx,%rax
lea    (%r8,%rax,8),%rax
mov    %rax,0x90(%rsp)
test   %r10d,%r10d
mov    %r14,0x8(%rsp)
je     162c <qrfac+0x50c>
mov    0x38(%rsp),%rax
lea    (%r8,%rax,8),%rdx
mov    %r14,%rcx
mov    %r14d,%esi
jmp    13eb <qrfac+0x2cb>
xchg   %ax,%ax
add    $0x1,%rcx
mov    %eax,%esi
cmp    %rcx,%rdi
je     1410 <qrfac+0x2f0>
movsd  (%r9,%rcx,8),%xmm0
movslq %esi,%rax
ucomisd (%r9,%rax,8),%xmm0
mov    %ecx,%eax
ja     13e0 <qrfac+0x2c0>
mov    %esi,%eax
jmp    13e0 <qrfac+0x2c0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %eax,%ecx
mov    0x8(%rsp),%r14
cmp    %rcx,%r14
je     162c <qrfac+0x50c>
cmpl   $0x0,0x4(%rsp)
mov    0x70(%rsp),%r10
jle    15f0 <qrfac+0x4d0>
mov    %eax,%ecx
imul   0x54(%rsp),%ecx
movslq %ecx,%r14
cmpl   $0x4,0x4(%rsp)
jb     1468 <qrfac+0x348>
mov    0xe0(%rsp),%rsi
lea    (%rsi,%r14,8),%rsi
cmp    %rsi,%rdx
jae    14fe <qrfac+0x3de>
lea    (%r8,%r14,8),%rdx
cmp    0x90(%rsp),%rdx
jae    14fe <qrfac+0x3de>
xor    %esi,%esi
mov    %rsi,%rdx
test   $0x1,%bl
je     149e <qrfac+0x37e>
mov    0x38(%rsp),%rcx
lea    (%rsi,%rcx,1),%rdx
movsd  (%r8,%rdx,8),%xmm0
lea    (%rsi,%r14,1),%rdi
movsd  (%r8,%rdi,8),%xmm1
movsd  %xmm1,(%r8,%rdx,8)
movsd  %xmm0,(%r8,%rdi,8)
mov    %rsi,%rdx
or     $0x1,%rdx
cmp    %rsi,0x98(%rsp)
je     15f0 <qrfac+0x4d0>
mov    0xd8(%rsp),%rsi
lea    (%rsi,%r14,8),%rcx
nopl   0x0(%rax,%rax,1)
movsd  -0x8(%r10,%rdx,8),%xmm0
movsd  -0x8(%rcx,%rdx,8),%xmm1
movsd  %xmm1,-0x8(%r10,%rdx,8)
movsd  %xmm0,-0x8(%rcx,%rdx,8)
movsd  (%r10,%rdx,8),%xmm0
movsd  (%rcx,%rdx,8),%xmm1
movsd  %xmm1,(%r10,%rdx,8)
movsd  %xmm0,(%rcx,%rdx,8)
add    $0x2,%rdx
cmp    %rdx,%rbx
jne    14c0 <qrfac+0x3a0>
jmp    15f0 <qrfac+0x4d0>
cmpq   $0x0,0xc8(%rsp)
je     1c32 <qrfac+0xb12>
mov    0xb0(%rsp),%rdx
lea    (%rdx,%r14,8),%rsi
mov    0xb8(%rsp),%rdi
xor    %edx,%edx
mov    0x18(%rsp),%rcx
nopl   0x0(%rax,%rax,1)
movups -0x30(%rcx,%rdx,8),%xmm0
movups -0x20(%rcx,%rdx,8),%xmm1
movups -0x30(%rsi,%rdx,8),%xmm2
movups -0x20(%rsi,%rdx,8),%xmm3
movups %xmm2,-0x30(%rcx,%rdx,8)
movups %xmm3,-0x20(%rcx,%rdx,8)
movups %xmm0,-0x30(%rsi,%rdx,8)
movups %xmm1,-0x20(%rsi,%rdx,8)
movupd -0x10(%rcx,%rdx,8),%xmm0
movupd (%rcx,%rdx,8),%xmm1
movupd -0x10(%rsi,%rdx,8),%xmm2
movupd (%rsi,%rdx,8),%xmm3
movupd %xmm2,-0x10(%rcx,%rdx,8)
movupd %xmm3,(%rcx,%rdx,8)
movupd %xmm0,-0x10(%rsi,%rdx,8)
movupd %xmm1,(%rsi,%rdx,8)
add    $0x8,%rdx
add    $0xfffffffffffffffe,%rdi
jne    1530 <qrfac+0x410>
testb  $0x1,0xc0(%rsp)
01
je     15d8 <qrfac+0x4b8>
mov    0x38(%rsp),%rcx
lea    (%rdx,%rcx,1),%rsi
movupd (%r8,%rsi,8),%xmm0
movupd 0x10(%r8,%rsi,8),%xmm1
add    %r14,%rdx
movupd (%r8,%rdx,8),%xmm2
movupd 0x10(%r8,%rdx,8),%xmm3
movupd %xmm2,(%r8,%rsi,8)
movupd %xmm3,0x10(%r8,%rsi,8)
movupd %xmm0,(%r8,%rdx,8)
movupd %xmm1,0x10(%r8,%rdx,8)
mov    0xd0(%rsp),%rdx
mov    %rdx,%rsi
cmp    %rbx,%rdx
jne    146a <qrfac+0x34a>
nopl   0x0(%rax)
mov    0x8(%rsp),%r14
movsd  (%r9,%r14,8),%xmm0
cltq
movsd  %xmm0,(%r9,%rax,8)
mov    0x1c8(%rsp),%rcx
movsd  (%rcx,%r14,8),%xmm0
movsd  %xmm0,(%rcx,%rax,8)
mov    0xf0(%rsp),%rsi
mov    (%rsi,%r14,4),%ecx
mov    (%rsi,%rax,4),%edx
mov    %edx,(%rsi,%r14,4)
mov    %ecx,(%rsi,%rax,4)
mov    %rbp,0x58(%rsp)
mov    %r13,%rbp
mov    %r15,%r13
lea    0x1(%r14),%rax
mov    %rbx,%rcx
mov    %rax,0x40(%rsp)
sub    %rax,%rcx
mov    %r14d,%eax
imul   0x54(%rsp),%eax
cltq
add    %r14,%rax
lea    (%r8,%rax,8),%r15
mov    %rcx,0x128(%rsp)
lea    0x1(%rcx),%edi
mov    %r15,%rsi
call   1030 <enorm@plt>
xorpd  %xmm6,%xmm6
ucomisd %xmm6,%xmm0
jne    167a <qrfac+0x55a>
jnp    1300 <qrfac+0x1e0>
mov    %rbx,%rax
sub    %r14,%rax
mov    %r15,0xa0(%rsp)
movsd  (%r15),%xmm2
movapd %xmm0,%xmm1
movapd 0x967(%rip),%xmm7
xorpd  %xmm7,%xmm1
cmpltsd %xmm6,%xmm2
andpd  %xmm2,%xmm1
andnpd %xmm0,%xmm2
movapd %xmm2,%xmm0
orpd   %xmm1,%xmm0
mov    %r14,%rcx
mov    %rax,%rdx
mov    %rax,0x10(%rsp)
cmp    $0x2,%rax
mov    (%rsp),%r10d
mov    0x30(%rsp),%r8
mov    0x1b8(%rsp),%r9
mov    0x28(%rsp),%rsi
mov    0x48(%rsp),%rdi
mov    0x60(%rsp),%r11
mov    0x18(%rsp),%rax
mov    %r14,%rdx
mov    %r13,%r15
jb     17b6 <qrfac+0x696>
mov    %r15,%r13
mov    0x10(%rsp),%rax
lea    -0x2(%rax),%rcx
mov    %rcx,%rax
shr    %rax
add    $0x1,%rax
movapd %xmm0,%xmm3
unpcklpd %xmm0,%xmm0
cmp    $0x2,%rcx
jae    171d <qrfac+0x5fd>
mov    %rbp,%r15
xor    %edx,%edx
jmp    176c <qrfac+0x64c>
mov    %rbp,%r15
shr    %rbp
add    $0x1,%rbp
and    $0xfffffffffffffffe,%rbp
xor    %edx,%edx
mov    0x20(%rsp),%r14
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movupd -0x10(%r14,%rdx,8),%xmm1
movupd (%r14,%rdx,8),%xmm2
divpd  %xmm0,%xmm1
movupd %xmm1,-0x10(%r14,%rdx,8)
divpd  %xmm0,%xmm2
movupd %xmm2,(%r14,%rdx,8)
add    $0x4,%rdx
add    $0xfffffffffffffffe,%rbp
jne    1740 <qrfac+0x620>
mov    0x10(%rsp),%rcx
and    $0xfffffffffffffffe,%rcx
test   $0x1,%al
je     1793 <qrfac+0x673>
add    0x8(%rsp),%rdx
add    0x38(%rsp),%rdx
movupd (%r8,%rdx,8),%xmm1
divpd  %xmm0,%xmm1
movupd %xmm1,(%r8,%rdx,8)
cmp    %rcx,0x10(%rsp)
mov    %r15,%rbp
mov    %r13,%r15
mov    0x18(%rsp),%rax
mov    0x8(%rsp),%rdx
mov    0x40(%rsp),%r14
movapd %xmm3,%xmm0
je     17d9 <qrfac+0x6b9>
add    %rdx,%rcx
mov    0x40(%rsp),%r14
nopl   0x0(%rax,%rax,1)
movsd  (%r12,%rcx,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%r12,%rcx,8)
add    $0x1,%rcx
cmp    %rcx,%rbx
jne    17c0 <qrfac+0x6a0>
mov    0xa0(%rsp),%rcx
movsd  (%rcx),%xmm1
addsd  0x823(%rip),%xmm1
movsd  %xmm1,(%rcx)
mov    0x108(%rsp),%rcx
cmp    %rcx,%r14
jge    1bf0 <qrfac+0xad0>
movapd %xmm0,0x160(%rsp)
mov    %rbp,0x100(%rsp)
mov    0x80(%rsp),%rbp
imul   %rdx,%rbp
mov    0x78(%rsp),%r13
and    $0xfffffffffffffffc,%r13
mov    0xe8(%rsp),%rax
mov    0x38(%rsp),%rcx
add    %rcx,%rax
mov    %rax,0x138(%rsp)
mov    %rbp,0x150(%rsp)
lea    (%r8,%rbp,1),%rax
mov    %rax,0x130(%rsp)
lea    (%rdx,%rcx,1),%rax
mov    %rax,0x148(%rsp)
lea    0x1(%rdx),%rax
mov    %rax,0x140(%rsp)
mov    0x10(%rsp),%rax
and    $0xfffffffffffffffc,%rax
mov    %rax,0x120(%rsp)
add    %rdx,%rax
mov    %rax,0x118(%rsp)
mov    0x58(%rsp),%rbp
mov    %r15,0xf8(%rsp)
xor    %eax,%eax
mov    %rax,0xa8(%rsp)
mov    0x88(%rsp),%r14
jmp    18cc <qrfac+0x7ac>
nopl   0x0(%rax)
add    $0x1,%r14
addq   $0x1,0xa8(%rsp)
add    %r11,%r15
add    %r11,%rbp
cmp    %rdi,%r14
je     1c00 <qrfac+0xae0>
mov    %r14,%rax
imul   %rsi,%rax
mov    %rax,0x68(%rsp)
xorpd  %xmm1,%xmm1
mov    %rdx,%rax
testb  $0x1,0x10(%rsp)
mov    0xa0(%rsp),%rcx
je     191a <qrfac+0x7fa>
mov    0x148(%rsp),%rax
movsd  (%r8,%rax,8),%xmm0
mov    0x68(%rsp),%rax
add    %rdx,%rax
mulsd  (%r8,%rax,8),%xmm0
addsd  %xmm6,%xmm0
mov    0x140(%rsp),%rax
movapd %xmm0,%xmm1
cmp    %rdx,0x98(%rsp)
je     195f <qrfac+0x83f>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%r12,%rax,8),%xmm2
movsd  0x8(%r12,%rax,8),%xmm0
mulsd  -0x8(%r15,%rax,8),%xmm2
mulsd  (%r15,%rax,8),%xmm0
addsd  %xmm1,%xmm2
addsd  %xmm2,%xmm0
add    $0x2,%rax
movapd %xmm0,%xmm1
cmp    %rax,%rbx
jne    1930 <qrfac+0x810>
xorpd  %xmm7,%xmm0
divsd  (%rcx),%xmm0
mov    %rdx,%rax
cmpq   $0x4,0x10(%rsp)
jb     1a30 <qrfac+0x910>
mov    0xa8(%rsp),%rax
imul   %rsi,%rax
lea    (%rax,%rsi,1),%rcx
lea    (%r8,%rcx,8),%rcx
add    0x150(%rsp),%rcx
cmp    0x90(%rsp),%rcx
jae    19b5 <qrfac+0x895>
add    0x138(%rsp),%rax
lea    (%r8,%rax,8),%rcx
mov    %rdx,%rax
cmp    %rcx,0x130(%rsp)
jb     1a30 <qrfac+0x910>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
xor    %eax,%eax
mov    0x20(%rsp),%rcx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movupd -0x10(%rcx,%rax,8),%xmm2
movupd (%rcx,%rax,8),%xmm3
movupd -0x10(%rbp,%rax,8),%xmm4
movupd 0x0(%rbp,%rax,8),%xmm5
mulpd  %xmm1,%xmm2
addpd  %xmm4,%xmm2
mulpd  %xmm1,%xmm3
addpd  %xmm5,%xmm3
movupd %xmm2,-0x10(%rbp,%rax,8)
movupd %xmm3,0x0(%rbp,%rax,8)
add    $0x4,%rax
cmp    %rax,%r13
jne    19d0 <qrfac+0x8b0>
mov    0x118(%rsp),%rax
mov    0x120(%rsp),%rcx
cmp    %rcx,0x10(%rsp)
je     1ab8 <qrfac+0x998>
nopw   0x0(%rax,%rax,1)
mov    %ebx,%edx
sub    %eax,%edx
mov    %rax,%rcx
test   $0x1,%dl
je     1a66 <qrfac+0x946>
mov    0x38(%rsp),%rcx
add    %rax,%rcx
mov    0x68(%rsp),%rdx
add    %rax,%rdx
movsd  (%r8,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%r8,%rdx,8),%xmm1
movsd  %xmm1,(%r8,%rdx,8)
lea    0x1(%rax),%rcx
not    %rax
cmp    0x158(%rsp),%rax
mov    0x8(%rsp),%rdx
je     1ab8 <qrfac+0x998>
nopl   0x0(%rax,%rax,1)
movsd  (%r12,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  -0x8(%r15,%rcx,8),%xmm1
movsd  %xmm1,-0x8(%r15,%rcx,8)
movsd  0x8(%r12,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%r15,%rcx,8),%xmm1
movsd  %xmm1,(%r15,%rcx,8)
add    $0x2,%rcx
cmp    %rcx,%rbx
jne    1a80 <qrfac+0x960>
test   %r10d,%r10d
je     18b0 <qrfac+0x790>
movsd  (%r9,%r14,8),%xmm0
ucomisd %xmm6,%xmm0
jne    1ad3 <qrfac+0x9b3>
jnp    18b0 <qrfac+0x790>
mov    0x68(%rsp),%rax
add    %rdx,%rax
movsd  (%r8,%rax,8),%xmm1
divsd  %xmm0,%xmm1
mulsd  %xmm1,%xmm1
movsd  0x51f(%rip),%xmm2
subsd  %xmm1,%xmm2
movapd %xmm2,%xmm0
cmplesd %xmm6,%xmm0
andnpd %xmm2,%xmm0
ucomisd %xmm6,%xmm0
jb     1b0e <qrfac+0x9ee>
sqrtsd %xmm0,%xmm0
jmp    1b44 <qrfac+0xa24>
call   1040 <sqrt@plt>
mov    0x8(%rsp),%rdx
movapd 0x4e0(%rip),%xmm7
xorpd  %xmm6,%xmm6
mov    0x60(%rsp),%r11
mov    0x48(%rsp),%rdi
mov    0x28(%rsp),%rsi
mov    0x1b8(%rsp),%r9
mov    0x30(%rsp),%r8
mov    (%rsp),%r10d
mulsd  (%r9,%r14,8),%xmm0
movsd  %xmm0,(%r9,%r14,8)
mov    0x1c8(%rsp),%rax
divsd  (%rax,%r14,8),%xmm0
mulsd  %xmm0,%xmm0
mulsd  0x4ae(%rip),%xmm0
movsd  0x4ae(%rip),%xmm1
ucomisd %xmm0,%xmm1
jb     18b0 <qrfac+0x790>
mov    0x68(%rsp),%rax
add    0x40(%rsp),%rax
lea    (%r8,%rax,8),%rsi
mov    0x128(%rsp),%rdi
call   1030 <enorm@plt>
mov    0x8(%rsp),%rdx
movapd 0x45c(%rip),%xmm7
xorpd  %xmm6,%xmm6
mov    0x60(%rsp),%r11
mov    0x48(%rsp),%rdi
mov    0x28(%rsp),%rsi
mov    0x1b8(%rsp),%r9
mov    0x30(%rsp),%r8
mov    (%rsp),%r10d
movsd  %xmm0,(%r9,%r14,8)
mov    0x1c8(%rsp),%rax
movsd  %xmm0,(%rax,%r14,8)
jmp    18b0 <qrfac+0x790>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x20(%rsp),%rcx
jmp    133d <qrfac+0x21d>
nopw   0x0(%rax,%rax,1)
mov    0x20(%rsp),%rcx
mov    0x100(%rsp),%r13
mov    0xf8(%rsp),%r15
mov    0x58(%rsp),%rbp
mov    0x18(%rsp),%rax
mov    0x40(%rsp),%r14
movapd 0x160(%rsp),%xmm0
jmp    1345 <qrfac+0x225>
xor    %edx,%edx
testb  $0x1,0xc0(%rsp)
01
jne    1598 <qrfac+0x478>
jmp    15d8 <qrfac+0x4b8>
add    $0x178,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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