#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(double *, int);
int /*<<< orphan*/ exit(int);
int /*<<< orphan*/ free(double *);
scalar_t__ malloc(int);
int /*<<< orphan*/ mtranspose(double *, int, int, double *);
double pmax(double, double);
int /*<<< orphan*/ printf(char *);
double sqrt(double);
void qrfac(double *A, int M, int N, int lda, int pivot, int *ipvt, int lipvt,
           double *rdiag, double *acnorm, double eps) {
  int i, j, jp1, k, kmax, minmn, t;
  double ajnorm, epsmch, one, p05, sum, temp, zero, temp2, pmaxval;
  double *AT, *wa, *wa2;
  if (pivot != 0 && pivot != 1) {
    printf("Pivot only takes binary values 0 and 1 \n");
    exit(-1);
  }
  AT = (double *)malloc(sizeof(double) * N * M);
  wa = (double *)malloc(sizeof(double) * N);
  wa2 = (double *)malloc(sizeof(double) * M);
  one = 1.0;
  zero = 0.0;
  p05 = 5.0e-02;
  epsmch = eps;
  mtranspose(A, M, N, AT);
  for (j = 0; j < N; ++j) {
    acnorm[j] = enorm(AT + j * M, M);
    rdiag[j] = acnorm[j];
    wa[j] = rdiag[j];
    if (pivot == 1) {
      ipvt[j] = j;
    }
  }
  if (M < N) {
    minmn = M;
  } else {
    minmn = N;
  }
  for (j = 0; j < minmn; ++j) {
    if (pivot == 1) {
      kmax = j;
      for (k = j; k < N; ++k) {
        if (rdiag[k] > rdiag[kmax]) {
          kmax = k;
        }
      }
      if (kmax != j) {
        for (i = 0; i < M; ++i) {
          t = i * N;
          temp = A[t + j];
          A[t + j] = A[t + kmax];
          A[t + kmax] = temp;
        }
        rdiag[kmax] = rdiag[j];
        wa[kmax] = wa[j];
        k = ipvt[j];
        ipvt[j] = ipvt[kmax];
        ipvt[kmax] = k;
      }
    }
    t = j * N + j;
    for (i = 0; i < M - j; ++i) {
      wa2[i] = A[t + i * N];
    }
    ajnorm = enorm(wa2, M - j);
    if (ajnorm != zero) {
      if (A[t] < zero) {
        ajnorm = -ajnorm;
      }
      for (i = j; i < M; ++i) {
        A[i * N + j] /= ajnorm;
      }
      A[t] += one;
      jp1 = j + 1;
      if (N >= jp1 + 1) {
        for (k = jp1; k < N; ++k) {
          sum = zero;
          for (i = j; i < M; ++i) {
            sum += (A[i * N + j] * A[i * N + k]);
          }
          temp = sum / A[t];
          for (i = j; i < M; ++i) {
            A[i * N + k] -= (temp * A[i * N + j]);
          }
          if (pivot == 1 && rdiag[k] != zero) {
            temp = A[j * N + k] / rdiag[k];
            pmaxval = pmax(zero, one - temp * temp);
            rdiag[k] = rdiag[k] * sqrt(pmaxval);
            temp2 = (p05 * (rdiag[k] / wa[k]));
            temp2 = temp2 * temp2;
            if (temp2 <= epsmch) {
              for (i = 0; i < M - j - 1; ++i) {
                wa2[i] = A[jp1 * N + k + i * N];
              }
              rdiag[k] = enorm(wa2, M - j - 1);
              wa[k] = rdiag[k];
            }
          }
        }
      }
    }
    rdiag[j] = -ajnorm;
  }
  free(AT);
  free(wa);
  free(wa2);
}


x86 assembly (clang, -O0):
<qrfac>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8d,-0x18(%rbp)
mov    %r9,-0x20(%rbp)
movsd  %xmm0,-0x28(%rbp)
cmpl   $0x0,-0x18(%rbp)
je     11da <qrfac+0x5a>
cmpl   $0x1,-0x18(%rbp)
je     11da <qrfac+0x5a>
lea    0xe45(%rip),%rdi
call   1050 <printf@plt>
mov    $0xffffffff,%edi
call   10a0 <exit@plt>
movslq -0x10(%rbp),%rax
shl    $0x3,%rax
movslq -0xc(%rbp),%rcx
imul   %rcx,%rax
mov    %eax,%edi
call   1080 <malloc@plt>
mov    %rax,-0x98(%rbp)
movslq -0x10(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1080 <malloc@plt>
mov    %rax,-0xa0(%rbp)
movslq -0xc(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1080 <malloc@plt>
mov    %rax,-0xa8(%rbp)
movsd  0xddc(%rip),%xmm0
movsd  %xmm0,-0x60(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  0xdbf(%rip),%xmm0
movsd  %xmm0,-0x68(%rbp)
movsd  -0x28(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0xc(%rbp),%esi
mov    -0x10(%rbp),%edx
mov    -0x98(%rbp),%rcx
call   1060 <mtranspose@plt>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1307 <qrfac+0x187>
mov    -0x98(%rbp),%rdi
mov    -0x30(%rbp),%eax
imul   -0xc(%rbp),%eax
cltq
shl    $0x3,%rax
add    %rax,%rdi
mov    -0xc(%rbp),%esi
call   1070 <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    -0xa0(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
cmpl   $0x1,-0x18(%rbp)
jne    12f4 <qrfac+0x174>
mov    -0x30(%rbp),%edx
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    12f9 <qrfac+0x179>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    126d <qrfac+0xed>
mov    -0xc(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    131e <qrfac+0x19e>
mov    -0xc(%rbp),%eax
mov    %eax,-0x40(%rbp)
jmp    1324 <qrfac+0x1a4>
mov    -0x10(%rbp),%eax
mov    %eax,-0x40(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    18f1 <qrfac+0x771>
cmpl   $0x1,-0x18(%rbp)
jne    148c <qrfac+0x30c>
mov    -0x30(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1392 <qrfac+0x212>
mov    0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jbe    137f <qrfac+0x1ff>
mov    -0x38(%rbp),%eax
mov    %eax,-0x3c(%rbp)
jmp    1384 <qrfac+0x204>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    134d <qrfac+0x1cd>
mov    -0x3c(%rbp),%eax
cmp    -0x30(%rbp),%eax
je     1487 <qrfac+0x307>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    141b <qrfac+0x29b>
mov    -0x2c(%rbp),%eax
imul   -0x10(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x78(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    13a5 <qrfac+0x225>
mov    0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0xa0(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xa0(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x38(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x38(%rbp),%edx
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    148c <qrfac+0x30c>
mov    -0x30(%rbp),%eax
imul   -0x10(%rbp),%eax
add    -0x30(%rbp),%eax
mov    %eax,-0x44(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    -0x30(%rbp),%ecx
cmp    %ecx,%eax
jge    14e7 <qrfac+0x367>
mov    -0x8(%rbp),%rax
mov    -0x44(%rbp),%ecx
mov    -0x2c(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xa8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    14a0 <qrfac+0x320>
mov    -0xa8(%rbp),%rdi
mov    -0xc(%rbp),%esi
sub    -0x30(%rbp),%esi
call   1070 <enorm@plt>
movsd  %xmm0,-0x50(%rbp)
movsd  -0x50(%rbp),%xmm0
ucomisd -0x80(%rbp),%xmm0
jne    1519 <qrfac+0x399>
jp     1519 <qrfac+0x399>
jmp    18ba <qrfac+0x73a>
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
movsd  -0x80(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jbe    1556 <qrfac+0x3d6>
movsd  -0x50(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    159a <qrfac+0x41a>
movsd  -0x50(%rbp),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x30(%rbp),%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    155c <qrfac+0x3dc>
movsd  -0x60(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0x10(%rbp),%eax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jl     18b5 <qrfac+0x735>
mov    -0x34(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    18b0 <qrfac+0x730>
movsd  -0x80(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1645 <qrfac+0x4c5>
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x70(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    15ed <qrfac+0x46d>
movsd  -0x70(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    16d1 <qrfac+0x551>
movsd  -0x78(%rbp),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x38(%rbp),%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    1662 <qrfac+0x4e2>
cmpl   $0x1,-0x18(%rbp)
jne    189d <qrfac+0x71d>
mov    0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0x80(%rbp),%xmm0
jne    16fe <qrfac+0x57e>
jp     16fe <qrfac+0x57e>
jmp    189d <qrfac+0x71d>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x80(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm2
movsd  -0x78(%rbp),%xmm1
movsd  -0x78(%rbp),%xmm3
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
call   1040 <pmax@plt>
movsd  %xmm0,-0x90(%rbp)
ff
mov    0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0x90(%rbp),%xmm0
ff
call   1090 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  -0xb0(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x68(%rbp),%xmm0
mov    0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0xa0(%rbp),%rax
movslq -0x38(%rbp),%rcx
divsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x88(%rbp),%xmm0
ff
mulsd  -0x88(%rbp),%xmm0
ff
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x88(%rbp),%xmm1
ff
movsd  -0x58(%rbp),%xmm0
ucomisd %xmm1,%xmm0
jb     1898 <qrfac+0x718>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    -0x30(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1859 <qrfac+0x6d9>
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x38(%rbp),%ecx
mov    -0x2c(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xa8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1808 <qrfac+0x688>
mov    -0xa8(%rbp),%rdi
mov    -0xc(%rbp),%esi
sub    -0x30(%rbp),%esi
sub    $0x1,%esi
call   1070 <enorm@plt>
mov    0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x18(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0xa0(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    189d <qrfac+0x71d>
jmp    18a2 <qrfac+0x722>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    15d1 <qrfac+0x451>
jmp    18b5 <qrfac+0x735>
jmp    18ba <qrfac+0x73a>
movsd  -0x50(%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    132b <qrfac+0x1ab>
mov    -0x98(%rbp),%rdi
call   1030 <free@plt>
mov    -0xa0(%rbp),%rdi
call   1030 <free@plt>
mov    -0xa8(%rbp),%rdi
call   1030 <free@plt>
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<qrfac>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1a8,%rsp
movsd  %xmm0,0x188(%rsp)
mov    %rdi,0x20(%rsp)
mov    %r8d,0x14(%rsp)
cmp    $0x2,%r8d
jae    1eb6 <qrfac+0xd36>
mov    %r9,%r12
mov    %edx,%r13d
mov    %esi,%ebx
mov    0x1f0(%rsp),%r14
mov    0x1e8(%rsp),%rax
mov    %rax,(%rsp)
lea    0x0(,%r13,8),%ebp
mov    %ebp,%edi
imul   %esi,%edi
call   1080 <malloc@plt>
mov    %rax,%r15
mov    %ebp,0xc0(%rsp)
mov    %ebp,%edi
call   1080 <malloc@plt>
mov    %rax,0x48(%rsp)
lea    0x0(,%rbx,8),%edi
call   1080 <malloc@plt>
mov    %rax,0x40(%rsp)
mov    0x20(%rsp),%rdi
mov    %ebx,%esi
mov    %r13d,%edx
mov    %r15,0xc8(%rsp)
mov    %r15,%rcx
call   1060 <mtranspose@plt>
mov    %rbx,0x38(%rsp)
movslq %ebx,%rax
mov    %rax,0x88(%rsp)
mov    %r13d,%r9d
test   %r13d,%r13d
mov    %r9,0x50(%rsp)
jle    12a4 <qrfac+0x124>
mov    0x88(%rsp),%rax
lea    0x0(,%rax,8),%r15
xor    %ebx,%ebx
mov    0xc8(%rsp),%rbp
jmp    1271 <qrfac+0xf1>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rbx
add    %r15,%rbp
mov    0x50(%rsp),%r9
cmp    %rbx,%r9
je     12a4 <qrfac+0x124>
mov    %rbp,%rdi
mov    0x38(%rsp),%rsi
call   1070 <enorm@plt>
movsd  %xmm0,(%r14,%rbx,8)
mov    (%rsp),%rax
movsd  %xmm0,(%rax,%rbx,8)
mov    0x48(%rsp),%rax
movsd  %xmm0,(%rax,%rbx,8)
cmpl   $0x1,0x14(%rsp)
jne    1260 <qrfac+0xe0>
mov    %ebx,(%r12,%rbx,4)
jmp    1260 <qrfac+0xe0>
mov    0x38(%rsp),%rcx
cmp    %r13d,%ecx
mov    %r13d,%eax
cmovl  %ecx,%eax
test   %eax,%eax
mov    0x20(%rsp),%r10
mov    (%rsp),%r8
mov    0x40(%rsp),%r11
mov    0x88(%rsp),%r15
jle    1e83 <qrfac+0xd03>
movslq %r13d,%rcx
mov    %rcx,0x8(%rsp)
mov    %eax,%eax
mov    %rax,0x170(%rsp)
mov    0x38(%rsp),%rdi
mov    %edi,%eax
lea    -0x1(%rdi),%edx
mov    %rax,0x58(%rsp)
and    $0xfffffffe,%eax
mov    %rax,0x100(%rsp)
mov    %rcx,%rbp
shl    $0x4,%rbp
lea    (%rcx,%rcx,1),%rax
mov    %rax,0x118(%rsp)
mov    %rcx,%rax
shl    $0x5,%rax
lea    (%rcx,%rcx,2),%rsi
mov    %rsi,0x108(%rsp)
lea    0x0(,%rcx,8),%r14
lea    0x8(%r10),%rcx
mov    %rcx,0xe0(%rsp)
lea    0x0(%r13,%r13,1),%ecx
mov    %ecx,0xbc(%rsp)
mov    $0x1,%ecx
mov    %rcx,0xd8(%rsp)
xor    %ecx,%ecx
mov    %rcx,0xa0(%rsp)
movl   $0x1,0x70(%rsp)
mov    %edx,0xb8(%rsp)
mov    %edx,%ecx
mov    %rcx,0x28(%rsp)
mov    %edi,%ecx
mov    %rcx,0x78(%rsp)
xor    %ebx,%ebx
mov    %r14,0xd0(%rsp)
mov    %r12,0x120(%rsp)
mov    %r13,0x18(%rsp)
mov    %rax,0x110(%rsp)
jmp    141e <qrfac+0x29e>
nopw   0x0(%rax,%rax,1)
lea    0x1(%rbx),%rdx
mov    0x20(%rsp),%r10
mov    (%rsp),%r8
mov    0x40(%rsp),%r11
mov    0x50(%rsp),%r9
movapd 0xc41(%rip),%xmm3
mov    0x78(%rsp),%rcx
add    $0xffffffff,%ecx
mov    %rcx,0x78(%rsp)
xorpd  %xmm3,%xmm0
movlpd %xmm0,(%r8,%rbx,8)
addq   $0x1,0xd8(%rsp)
mov    0xa0(%rsp),%rcx
add    $0x1,%ecx
mov    %rcx,0xa0(%rsp)
addq   $0x8,0xe0(%rsp)
addl   $0x1,0x70(%rsp)
mov    0x28(%rsp),%rcx
add    $0xffffffff,%ecx
mov    %rcx,0x28(%rsp)
mov    %rdx,%rbx
cmp    0x170(%rsp),%rdx
je     1e83 <qrfac+0xd03>
mov    %rbx,%rax
not    %rax
mov    %rax,0x68(%rsp)
cmpl   $0x1,0x14(%rsp)
jne    15de <qrfac+0x45e>
mov    %r9d,%ecx
sub    %ebx,%ecx
mov    0x68(%rsp),%rax
lea    (%rax,%r9,1),%rsi
mov    %rbx,%rax
mov    %ebx,%edx
and    $0x3,%rcx
je     1490 <qrfac+0x310>
mov    %rbx,%rax
mov    %ebx,%edi
jmp    146c <qrfac+0x2ec>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rax
mov    %edx,%edi
add    $0xffffffffffffffff,%rcx
je     1490 <qrfac+0x310>
movsd  (%r8,%rax,8),%xmm0
movslq %edi,%rdx
ucomisd (%r8,%rdx,8),%xmm0
mov    %eax,%edx
ja     1460 <qrfac+0x2e0>
mov    %edi,%edx
jmp    1460 <qrfac+0x2e0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %edx,%ecx
cmp    $0x3,%rsi
mov    0x8(%rsp),%rsi
jae    14db <qrfac+0x35b>
mov    %ecx,%eax
cmp    %rax,%rbx
je     15de <qrfac+0x45e>
movslq %ecx,%rax
cmpl   $0x0,0x38(%rsp)
jle    15b3 <qrfac+0x433>
cmpl   $0x1,0x38(%rsp)
jne    1531 <qrfac+0x3b1>
xor    %ecx,%ecx
jmp    1584 <qrfac+0x404>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x4,%rax
mov    %ecx,%edx
cmp    %r9,%rax
je     149d <qrfac+0x31d>
movslq %edx,%rcx
movsd  (%r8,%rax,8),%xmm0
ucomisd (%r8,%rcx,8),%xmm0
mov    %eax,%ecx
ja     14f0 <qrfac+0x370>
mov    %edx,%ecx
movsd  0x8(%r8,%rax,8),%xmm0
movslq %ecx,%rdx
ucomisd (%r8,%rdx,8),%xmm0
jbe    1505 <qrfac+0x385>
lea    0x1(%rax),%ecx
movsd  0x10(%r8,%rax,8),%xmm0
movslq %ecx,%rdx
ucomisd (%r8,%rdx,8),%xmm0
jbe    151a <qrfac+0x39a>
lea    0x2(%rax),%ecx
movsd  0x18(%r8,%rax,8),%xmm0
movslq %ecx,%rdx
ucomisd (%r8,%rdx,8),%xmm0
jbe    14d0 <qrfac+0x350>
lea    0x3(%rax),%ecx
jmp    14d0 <qrfac+0x350>
lea    (%rsi,%rax,1),%rdx
add    %rbx,%rsi
mov    %r10,%rdi
xor    %ecx,%ecx
mov    0x100(%rsp),%r9
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rdi,%rbx,8),%xmm0
movsd  (%rdi,%rax,8),%xmm1
movsd  %xmm1,(%rdi,%rbx,8)
movsd  %xmm0,(%rdi,%rax,8)
movsd  (%rdi,%rsi,8),%xmm0
movsd  (%rdi,%rdx,8),%xmm1
movsd  %xmm1,(%rdi,%rsi,8)
movsd  %xmm0,(%rdi,%rdx,8)
add    $0x2,%rcx
add    %rbp,%rdi
cmp    %rcx,%r9
jne    1550 <qrfac+0x3d0>
testb  $0x1,0x58(%rsp)
mov    0x8(%rsp),%rdx
je     15b3 <qrfac+0x433>
imul   %rdx,%rcx
lea    (%rcx,%rbx,1),%rdx
movsd  (%r10,%rdx,8),%xmm0
add    %rax,%rcx
movsd  (%r10,%rcx,8),%xmm1
movsd  %xmm1,(%r10,%rdx,8)
movsd  %xmm0,(%r10,%rcx,8)
movsd  (%r8,%rbx,8),%xmm0
movsd  %xmm0,(%r8,%rax,8)
mov    0x48(%rsp),%rcx
movsd  (%rcx,%rbx,8),%xmm0
movsd  %xmm0,(%rcx,%rax,8)
mov    (%r12,%rbx,4),%ecx
mov    (%r12,%rax,4),%edx
mov    %edx,(%r12,%rbx,4)
mov    %ecx,(%r12,%rax,4)
mov    %ebx,%eax
imul   %r13d,%eax
movslq %eax,%r9
lea    (%rbx,%r9,1),%rax
mov    %rax,0x80(%rsp)
mov    %r15,%rax
sub    %rbx,%rax
mov    %rax,0xa8(%rsp)
mov    %rbx,0x30(%rsp)
jle    1715 <qrfac+0x595>
mov    %r12,%r13
mov    %r15,%r12
mov    0x78(%rsp),%r8d
lea    -0x1(%r8),%rax
cmp    $0x3,%rax
jae    1630 <qrfac+0x4b0>
xor    %edx,%edx
jmp    16bc <qrfac+0x53c>
nopl   0x0(%rax,%rax,1)
mov    %r8d,%esi
and    $0xfffffffc,%esi
mov    0x118(%rsp),%rax
lea    (%rax,%rbx,1),%rdi
add    %r9,%rdi
mov    0x8(%rsp),%rax
mov    %rbx,%rcx
add    %rax,%rbx
add    %r9,%rbx
mov    0x108(%rsp),%rax
add    %rax,%rcx
add    %r9,%rcx
mov    %r10,%rax
xor    %edx,%edx
mov    0x110(%rsp),%r14
mov    0x80(%rsp),%r15
cs nopw 0x0(%rax,%rax,1)
movsd  (%rax,%r15,8),%xmm0
movsd  %xmm0,(%r11,%rdx,8)
movsd  (%rax,%rbx,8),%xmm0
movsd  %xmm0,0x8(%r11,%rdx,8)
movsd  (%rax,%rdi,8),%xmm0
movsd  %xmm0,0x10(%r11,%rdx,8)
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,0x18(%r11,%rdx,8)
add    $0x4,%rdx
add    %r14,%rax
cmp    %rdx,%rsi
jne    1680 <qrfac+0x500>
test   $0x3,%r8b
mov    0xd0(%rsp),%r14
mov    0x30(%rsp),%rbx
mov    %r12,%r15
mov    %r13,%r12
mov    0x18(%rsp),%r13
je     1715 <qrfac+0x595>
mov    0x78(%rsp),%rcx
and    $0x3,%ecx
lea    (%r11,%rdx,8),%rsi
imul   0x8(%rsp),%rdx
add    %rbx,%rdx
add    %r9,%rdx
lea    (%r10,%rdx,8),%rax
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movsd  (%rax),%xmm0
movsd  %xmm0,(%rsi,%rdx,8)
add    $0x1,%rdx
add    %r14,%rax
cmp    %rdx,%rcx
jne    1700 <qrfac+0x580>
mov    0x28(%rsp),%rax
mov    %eax,%eax
mov    %rax,0x28(%rsp)
mov    %r11,%rdi
mov    0xa8(%rsp),%rsi
call   1070 <enorm@plt>
xorpd  %xmm2,%xmm2
ucomisd %xmm2,%xmm0
jne    1741 <qrfac+0x5c1>
jnp    13a0 <qrfac+0x220>
mov    %rbx,%rax
mov    0x8(%rsp),%rdi
imul   %rdi,%rax
mov    %rax,0x60(%rsp)
mov    0x20(%rsp),%r10
mov    0x80(%rsp),%rax
movsd  (%r10,%rax,8),%xmm4
movapd %xmm0,%xmm1
movapd 0x88f(%rip),%xmm3
xorpd  %xmm3,%xmm1
cmpltsd %xmm2,%xmm4
andpd  %xmm4,%xmm1
andnpd %xmm0,%xmm4
orpd   %xmm1,%xmm4
movapd %xmm4,%xmm0
mov    0x58(%rsp),%rax
mov    %rax,%rcx
sub    %rbx,%rcx
add    %rax,0x68(%rsp)
mov    %rbx,%rdx
mov    %rcx,0xf8(%rsp)
test   $0x1,%cl
mov    (%rsp),%r8
mov    0x50(%rsp),%r9
je     17cf <qrfac+0x64f>
mov    0x60(%rsp),%rax
add    %rbx,%rax
movsd  (%r10,%rax,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%r10,%rax,8)
lea    0x1(%rbx),%rdx
cmpq   $0x0,0x68(%rsp)
mov    0x40(%rsp),%r11
je     1825 <qrfac+0x6a5>
mov    0x58(%rsp),%rax
sub    %rdx,%rax
mov    %rdi,%rcx
imul   %rdx,%rcx
add    %rbx,%rcx
add    $0x1,%rdx
imul   %r14,%rdx
lea    (%rdx,%rbx,8),%rdx
mov    %r10,%rsi
nopl   (%rax)
movsd  (%rsi,%rcx,8),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%rsi,%rcx,8)
movsd  (%rsi,%rdx,1),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%rsi,%rdx,1)
add    %rbp,%rsi
add    $0xfffffffffffffffe,%rax
jne    1800 <qrfac+0x680>
mov    0x80(%rsp),%rax
movsd  (%r10,%rax,8),%xmm1
addsd  0x7d5(%rip),%xmm1
movsd  %xmm1,(%r10,%rax,8)
lea    0x1(%rbx),%rdx
lea    0x2(%rbx),%rax
mov    %rax,0x168(%rsp)
cmp    %rdi,%rax
jg     13bf <qrfac+0x23f>
cmp    %rdi,%rdx
jge    13bf <qrfac+0x23f>
mov    %rdx,0x90(%rsp)
movapd %xmm0,0x190(%rsp)
mov    0x28(%rsp),%rax
mov    %eax,%ecx
and    $0xfffffffc,%ecx
mov    0xb8(%rsp),%eax
mov    %eax,%edx
mov    0xa0(%rsp),%rax
sub    %eax,%edx
add    $0xfffffffffffffffc,%rcx
mov    %edx,%esi
and    $0xfffffffc,%esi
shr    $0x2,%rcx
add    $0xfffffffffffffffc,%rsi
add    $0x1,%rcx
mov    %rsi,0x140(%rsp)
shr    $0x2,%rsi
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x128(%rsp)
add    $0x1,%rsi
mov    %rsi,0x138(%rsp)
add    $0x2,%eax
lea    -0x1(%rdx),%rcx
mov    %rcx,0x160(%rsp)
lea    (%r11,%rdx,8),%rcx
mov    %rcx,0x148(%rsp)
mov    0xa8(%rsp),%rcx
lea    -0x1(%rcx),%ecx
mov    %ecx,0xc4(%rsp)
lea    (%rbx,%rax,1),%eax
mov    %rax,0x158(%rsp)
lea    (%r10,%rdx,8),%rax
mov    %rax,0x150(%rsp)
mov    0x60(%rsp),%rax
add    %rbx,%rax
mov    %rax,0xe8(%rsp)
lea    0x1(%rbx),%rax
mov    %rax,0xb0(%rsp)
mov    %edx,%eax
and    $0xfffffffc,%eax
mov    %rax,0x130(%rsp)
mov    %rdx,0x98(%rsp)
neg    %rdx
mov    %rdx,0x178(%rsp)
lea    0x5(%rbx),%ecx
imul   %r13d,%ecx
mov    0x70(%rsp),%eax
add    %eax,%ecx
lea    0x1(%rbx),%r12d
imul   %r13d,%r12d
add    %eax,%r12d
lea    (%r10,%rbx,8),%rax
mov    %rax,0xf0(%rsp)
xor    %r15d,%r15d
mov    0xe0(%rsp),%r14
mov    0xd8(%rsp),%r13
jmp    19f0 <qrfac+0x870>
mov    %r11,%rdi
mov    0xc4(%rsp),%esi
call   1070 <enorm@plt>
mov    0x40(%rsp),%r11
mov    0x20(%rsp),%r10
mov    (%rsp),%r8
movsd  %xmm0,(%r8,%r13,8)
mov    0x48(%rsp),%rax
movsd  %xmm0,(%rax,%r13,8)
mov    0x50(%rsp),%r9
xorpd  %xmm2,%xmm2
movapd 0x63e(%rip),%xmm3
mov    0x30(%rsp),%rbx
nopw   0x0(%rax,%rax,1)
add    $0x1,%r13
add    $0x1,%r15d
add    $0x8,%r14
mov    0x74(%rsp),%ecx
add    $0x1,%ecx
add    $0x1,%r12d
cmp    %r9,%r13
je     1e50 <qrfac+0xcd0>
mov    %ecx,0x74(%rsp)
xorpd  %xmm0,%xmm0
mov    %rbx,%rdi
testb  $0x1,0xf8(%rsp)
01
je     1a2d <qrfac+0x8ad>
mov    0xe8(%rsp),%rax
movsd  (%r10,%rax,8),%xmm0
mov    0x60(%rsp),%rax
add    %r13,%rax
mulsd  (%r10,%rax,8),%xmm0
addsd  %xmm2,%xmm0
mov    0xb0(%rsp),%rdi
cmpq   $0x0,0x68(%rsp)
je     1aa5 <qrfac+0x925>
mov    0x58(%rsp),%rax
sub    %rdi,%rax
mov    0x8(%rsp),%rsi
mov    %rsi,%rdx
imul   %rdi,%rdx
lea    (%rdx,%r13,1),%rcx
lea    (%r10,%rcx,8),%rcx
add    0x30(%rsp),%rdx
lea    (%r10,%rdx,8),%rdx
add    $0x1,%rdi
imul   %rsi,%rdi
lea    (%r14,%rdi,8),%rsi
mov    0xf0(%rsp),%rbx
lea    (%rbx,%rdi,8),%rdi
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rdx,%rbx,1),%xmm1
mulsd  (%rcx,%rbx,1),%xmm1
addsd  %xmm0,%xmm1
movsd  (%rdi,%rbx,1),%xmm0
mulsd  (%rsi,%rbx,1),%xmm0
addsd  %xmm1,%xmm0
add    %rbp,%rbx
add    $0xfffffffffffffffe,%rax
jne    1a80 <qrfac+0x900>
xorpd  %xmm3,%xmm0
mov    0x80(%rsp),%rax
divsd  (%r10,%rax,8),%xmm0
mov    0x30(%rsp),%rdi
testb  $0x1,0xf8(%rsp)
01
je     1af4 <qrfac+0x974>
mov    0x60(%rsp),%rax
add    %r13,%rax
mov    0xe8(%rsp),%rcx
movsd  (%r10,%rcx,8),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%r10,%rax,8),%xmm1
movsd  %xmm1,(%r10,%rax,8)
mov    0xb0(%rsp),%rdi
cmpq   $0x0,0x68(%rsp)
je     1b6f <qrfac+0x9ef>
mov    0x58(%rsp),%rax
sub    %rdi,%rax
mov    0x8(%rsp),%rsi
mov    %rsi,%rdx
imul   %rdi,%rdx
lea    (%rdx,%r13,1),%rcx
lea    (%r10,%rcx,8),%rcx
add    0x30(%rsp),%rdx
lea    (%r10,%rdx,8),%rdx
add    $0x1,%rdi
imul   %rsi,%rdi
lea    (%r14,%rdi,8),%rsi
mov    0xf0(%rsp),%rbx
lea    (%rbx,%rdi,8),%rdi
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movsd  (%rdx,%rbx,1),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rcx,%rbx,1),%xmm1
movsd  %xmm1,(%rcx,%rbx,1)
movsd  (%rdi,%rbx,1),%xmm1
mulsd  %xmm0,%xmm1
addsd  (%rsi,%rbx,1),%xmm1
movsd  %xmm1,(%rsi,%rbx,1)
add    %rbp,%rbx
add    $0xfffffffffffffffe,%rax
jne    1b40 <qrfac+0x9c0>
cmpl   $0x1,0x14(%rsp)
mov    0x30(%rsp),%rbx
jne    19d0 <qrfac+0x850>
movsd  (%r8,%r13,8),%xmm0
ucomisd %xmm2,%xmm0
jne    1b91 <qrfac+0xa11>
jnp    19d0 <qrfac+0x850>
mov    0x60(%rsp),%rax
add    %r13,%rax
movsd  (%r10,%rax,8),%xmm2
divsd  %xmm0,%xmm2
mulsd  %xmm2,%xmm2
movsd  0x461(%rip),%xmm1
subsd  %xmm2,%xmm1
xorpd  %xmm0,%xmm0
call   1050 <pmax@plt>
xorpd  %xmm2,%xmm2
mov    (%rsp),%r8
movsd  (%r8,%r13,8),%xmm1
ucomisd %xmm2,%xmm0
jb     1bd6 <qrfac+0xa56>
sqrtsd %xmm0,%xmm0
jmp    1bf5 <qrfac+0xa75>
movsd  %xmm1,0x180(%rsp)
call   1090 <sqrt@plt>
movsd  0x180(%rsp),%xmm1
xorpd  %xmm2,%xmm2
mov    (%rsp),%r8
mulsd  %xmm0,%xmm1
movsd  %xmm1,(%r8,%r13,8)
mov    0x48(%rsp),%rax
divsd  (%rax,%r13,8),%xmm1
mulsd  0x406(%rip),%xmm1
mulsd  %xmm1,%xmm1
movsd  0x188(%rsp),%xmm0
ucomisd %xmm1,%xmm0
mov    0x20(%rsp),%r10
mov    0x40(%rsp),%r11
mov    0x50(%rsp),%r9
movapd 0x3c6(%rip),%xmm3
jb     19d0 <qrfac+0x850>
cmpq   $0x2,0xa8(%rsp)
mov    0xc0(%rsp),%r8d
mov    0xbc(%rsp),%ebx
mov    0x28(%rsp),%rdi
jl     1983 <qrfac+0x803>
cmpl   $0x4,0x98(%rsp)
04
jb     1cc5 <qrfac+0xb45>
cmpl   $0x1,0x18(%rsp)
jne    1cc5 <qrfac+0xb45>
mov    0x158(%rsp),%rax
add    %r15d,%eax
mov    0x160(%rsp),%rdx
lea    (%rax,%rdx,1),%ecx
cmp    %eax,%ecx
jl     1cc5 <qrfac+0xb45>
mov    %rdx,%rcx
shr    $0x20,%rcx
mov    $0x0,%ecx
jne    1cc7 <qrfac+0xb47>
cltq
mov    0x150(%rsp),%rcx
lea    (%rcx,%rax,8),%rcx
cmp    %rcx,%r11
jae    1d71 <qrfac+0xbf1>
lea    (%r10,%rax,8),%rax
cmp    0x148(%rsp),%rax
jae    1d71 <qrfac+0xbf1>
xor    %ecx,%ecx
mov    %rcx,%rax
testb  $0x1,0x98(%rsp)
01
je     1cfb <qrfac+0xb7b>
mov    0x90(%rsp),%rax
add    %ecx,%eax
imul   0x18(%rsp),%eax
add    %r13d,%eax
cltq
movsd  (%r10,%rax,8),%xmm0
movsd  %xmm0,(%r11,%rcx,8)
mov    %rcx,%rax
or     $0x1,%rax
not    %rcx
cmp    0x178(%rsp),%rcx
je     1983 <qrfac+0x803>
mov    0xb0(%rsp),%rcx
add    %eax,%ecx
mov    0x18(%rsp),%rsi
imul   %esi,%ecx
add    %r13d,%ecx
mov    0x168(%rsp),%rdx
add    %eax,%edx
imul   %esi,%edx
add    %r13d,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movslq %ecx,%rcx
movsd  (%r10,%rcx,8),%xmm0
movsd  %xmm0,(%r11,%rax,8)
movslq %edx,%rdx
movsd  (%r10,%rdx,8),%xmm0
movsd  %xmm0,0x8(%r11,%rax,8)
add    $0x2,%rax
add    %ebx,%ecx
add    %ebx,%edx
cmp    %rax,%rdi
jne    1d40 <qrfac+0xbc0>
jmp    1983 <qrfac+0x803>
cmpq   $0x0,0x140(%rsp)
je     1e3e <qrfac+0xcbe>
mov    0x128(%rsp),%rcx
mov    %r12d,%edx
mov    0x74(%rsp),%eax
mov    %eax,%esi
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movslq %edx,%rdx
movups (%r10,%rdx,8),%xmm0
movups 0x10(%r10,%rdx,8),%xmm1
movups %xmm0,(%r11,%rax,8)
movups %xmm1,0x10(%r11,%rax,8)
movslq %esi,%rsi
movupd (%r10,%rsi,8),%xmm0
movupd 0x10(%r10,%rsi,8),%xmm1
movupd %xmm0,0x20(%r11,%rax,8)
movupd %xmm1,0x30(%r11,%rax,8)
add    $0x8,%rax
add    %r8d,%esi
add    %r8d,%edx
add    $0xfffffffffffffffe,%rcx
jne    1da0 <qrfac+0xc20>
testb  $0x1,0x138(%rsp)
01
je     1e20 <qrfac+0xca0>
mov    0x90(%rsp),%rcx
add    %eax,%ecx
imul   0x18(%rsp),%ecx
add    %r13d,%ecx
movslq %ecx,%rcx
movupd (%r10,%rcx,8),%xmm0
movupd 0x10(%r10,%rcx,8),%xmm1
movupd %xmm0,(%r11,%rax,8)
movupd %xmm1,0x10(%r11,%rax,8)
mov    0x130(%rsp),%rax
mov    %rax,%rcx
cmp    0x98(%rsp),%rax
je     1983 <qrfac+0x803>
jmp    1cc7 <qrfac+0xb47>
xor    %eax,%eax
testb  $0x1,0x138(%rsp)
01
jne    1df1 <qrfac+0xc71>
jmp    1e20 <qrfac+0xca0>
nopl   0x0(%rax)
mov    0x120(%rsp),%r12
mov    0x18(%rsp),%r13
mov    0x88(%rsp),%r15
mov    0xd0(%rsp),%r14
movapd 0x190(%rsp),%xmm0
mov    0x90(%rsp),%rdx
jmp    13bf <qrfac+0x23f>
mov    0xc8(%rsp),%rdi
mov    %r11,%rbx
call   1030 <free@plt>
mov    0x48(%rsp),%rdi
call   1030 <free@plt>
mov    %rbx,%rdi
add    $0x1a8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>
lea    0x163(%rip),%rdi
call   1040 <puts@plt>
mov    $0xffffffff,%edi
call   10a0 <exit@plt>

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

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