#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 */
int /*<<< orphan*/ free(float *);
float house(float *, int, float *);
scalar_t__ malloc(int);
int /*<<< orphan*/ mmult(float *, float *, float *, int, int, int);
int /*<<< orphan*/ scale(float *, int, int, float);
void francisQR(float *A, int N) {
  int m, n, k, q, r, t, u, i, j;
  float s, t2, beta;
  float *x, *v, *AT, *w;
  int NN;
  x = (float *)malloc(sizeof(float) * 3);
  v = (float *)malloc(sizeof(float) * 3);
  AT = (float *)malloc(sizeof(float) * 3 * N);
  w = (float *)malloc(sizeof(float) * N);
  n = N - 1;
  m = n - 1;
  NN = N * N;
  s = A[NN - 1] + A[NN - N - 2];
  t2 = A[NN - 1] * A[NN - N - 2] - A[NN - 2] * A[NN - N - 1];
  x[0] = A[0] * A[0] + A[1] * A[N] - s * A[0] + t2;
  x[1] = A[N] * (A[0] + A[N + 1] - s);
  x[2] = A[N] * A[N + N + 1];
  if (N <= 2) {
    return;
  }
  for (k = -1; k < N - 3; ++k) {
    beta = house(x, 3, v);
    if (k > 0) {
      q = k;
    } else {
      q = 0;
    }
    for (i = k + 1; i < k + 4; i++) {
      t = i * N;
      u = 0;
      for (j = q; j < N; j++) {
        AT[u + i - k - 1] = A[j + t];
        u += 3;
      }
    }
    mmult(AT, v, w, N - q, 3, 1);
    scale(w, N - q, 1, beta);
    mmult(v, w, AT, 3, 1, N - q);
    for (i = k + 1; i < k + 4; i++) {
      t = i * N;
      for (j = q; j < N; j++) {
        A[t + j] -= AT[(i - k - 1) * (N - q) + j - q];
      }
    }
    if (k + 4 >= n) {
      r = N;
    } else {
      r = k + 4 + 1;
    }
    for (i = 0; i < r; i++) {
      t = i * N;
      u = i * 3;
      for (j = k + 1; j < k + 4; j++) {
        AT[u + j - k - 1] = A[t + j];
      }
    }
    mmult(AT, v, w, r, 3, 1);
    scale(w, r, 1, beta);
    mmult(w, v, AT, r, 1, 3);
    for (i = 0; i < r; i++) {
      t = i * N;
      u = i * 3;
      for (j = k + 1; j < k + 4; j++) {
        A[t + j] -= AT[u + j - k - 1];
      }
    }
    x[0] = A[N * (k + 2) + k + 1];
    x[1] = A[N * (k + 3) + k + 1];
    if (k < n - 3) {
      x[2] = A[N * (k + 4) + k + 1];
    }
  }
  beta = house(x, 2, v);
  for (i = n - 1; i < N; i++) {
    t = i * N;
    u = 0;
    for (j = n - 2; j < N; j++) {
      AT[u + i - n + 1] = A[j + t];
      u += 2;
    }
  }
  mmult(AT, v, w, 3, 2, 1);
  scale(w, 3, 1, beta);
  mmult(v, w, AT, 2, 1, 3);
  for (i = n - 1; i < N; i++) {
    t = i * N;
    for (j = n - 2; j < N; j++) {
      A[t + j] -= AT[(i - n + 1) * 3 + j - n + 2];
    }
  }
  for (i = 0; i < N; i++) {
    t = i * N;
    u = i * 2;
    for (j = n - 1; j < N; j++) {
      AT[u + j - n + 1] = A[t + j];
    }
  }
  mmult(AT, v, w, N, 2, 1);
  scale(w, N, 1, beta);
  mmult(w, v, AT, N, 1, 2);
  for (i = 0; i < N; i++) {
    t = i * N;
    u = i * 2;
    for (j = n - 1; j < N; j++) {
      A[t + j] -= AT[u + j - n + 1];
    }
  }
  free(x);
  free(v);
  free(AT);
  free(w);
}


x86 assembly (clang, -O0):
<francisQR>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    $0xc,%edi
call   1050 <malloc@plt>
mov    %rax,-0x48(%rbp)
mov    $0xc,%edi
call   1050 <malloc@plt>
mov    %rax,-0x50(%rbp)
movslq -0xc(%rbp),%rax
imul   $0xc,%rax,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x58(%rbp)
movslq -0xc(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x60(%rbp)
mov    -0xc(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0xc(%rbp),%eax
imul   -0xc(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x64(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x64(%rbp),%ecx
sub    -0xc(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x64(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x64(%rbp),%ecx
sub    -0xc(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x64(%rbp),%ecx
sub    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x64(%rbp),%ecx
sub    -0xc(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x38(%rbp)
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movss  0x4(%rax),%xmm0
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movss  -0x34(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
addss  -0x38(%rbp),%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm1
subss  -0x34(%rbp),%xmm1
mulss  %xmm1,%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    -0xc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x8(%rax)
cmpl   $0x2,-0xc(%rbp)
jg     1321 <francisQR+0x1d1>
jmp    1a44 <francisQR+0x8f4>
movl   $0xffffffff,-0x18(%rbp)
mov    -0x18(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x3,%ecx
cmp    %ecx,%eax
jge    1722 <francisQR+0x5d2>
mov    -0x48(%rbp),%rdi
mov    -0x50(%rbp),%rdx
mov    $0x3,%esi
call   1070 <house@plt>
movss  %xmm0,-0x3c(%rbp)
cmpl   $0x0,-0x18(%rbp)
jle    1365 <francisQR+0x215>
mov    -0x18(%rbp),%eax
mov    %eax,-0x1c(%rbp)
jmp    136c <francisQR+0x21c>
movl   $0x0,-0x1c(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    $0x4,%ecx
cmp    %ecx,%eax
jge    13fd <francisQR+0x2ad>
mov    -0x2c(%rbp),%eax
imul   -0xc(%rbp),%eax
mov    %eax,-0x24(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    13ea <francisQR+0x29a>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x58(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    -0x2c(%rbp),%ecx
sub    -0x18(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x3,%eax
mov    %eax,-0x28(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    139d <francisQR+0x24d>
jmp    13ef <francisQR+0x29f>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1375 <francisQR+0x225>
mov    -0x58(%rbp),%rdi
mov    -0x50(%rbp),%rsi
mov    -0x60(%rbp),%rdx
mov    -0xc(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
mov    $0x3,%r8d
mov    $0x1,%r9d
call   1040 <mmult@plt>
mov    -0x60(%rbp),%rdi
mov    -0xc(%rbp),%esi
sub    -0x1c(%rbp),%esi
movss  -0x3c(%rbp),%xmm0
mov    $0x1,%edx
call   1060 <scale@plt>
mov    -0x50(%rbp),%rdi
mov    -0x60(%rbp),%rsi
mov    -0x58(%rbp),%rdx
mov    -0xc(%rbp),%r9d
sub    -0x1c(%rbp),%r9d
mov    $0x3,%ecx
mov    $0x1,%r8d
call   1040 <mmult@plt>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    $0x4,%ecx
cmp    %ecx,%eax
jge    14f3 <francisQR+0x3a3>
mov    -0x2c(%rbp),%eax
imul   -0xc(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    14e0 <francisQR+0x390>
mov    -0x58(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    -0x18(%rbp),%ecx
sub    $0x1,%ecx
mov    -0xc(%rbp),%edx
sub    -0x1c(%rbp),%edx
imul   %edx,%ecx
add    -0x30(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1487 <francisQR+0x337>
jmp    14e5 <francisQR+0x395>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1466 <francisQR+0x316>
mov    -0x18(%rbp),%eax
add    $0x4,%eax
cmp    -0x14(%rbp),%eax
jl     150d <francisQR+0x3bd>
mov    -0xc(%rbp),%eax
mov    %eax,-0x20(%rbp)
jmp    1519 <francisQR+0x3c9>
mov    -0x18(%rbp),%eax
add    $0x4,%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    15a2 <francisQR+0x452>
mov    -0x2c(%rbp),%eax
imul   -0xc(%rbp),%eax
mov    %eax,-0x24(%rbp)
imul   $0x3,-0x2c(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    $0x4,%ecx
cmp    %ecx,%eax
jge    158f <francisQR+0x43f>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x58(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    -0x30(%rbp),%ecx
sub    -0x18(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1546 <francisQR+0x3f6>
jmp    1594 <francisQR+0x444>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1520 <francisQR+0x3d0>
mov    -0x58(%rbp),%rdi
mov    -0x50(%rbp),%rsi
mov    -0x60(%rbp),%rdx
mov    -0x20(%rbp),%ecx
mov    $0x3,%r8d
mov    $0x1,%r9d
call   1040 <mmult@plt>
mov    -0x60(%rbp),%rdi
mov    -0x20(%rbp),%esi
movss  -0x3c(%rbp),%xmm0
mov    $0x1,%edx
call   1060 <scale@plt>
mov    -0x60(%rbp),%rdi
mov    -0x50(%rbp),%rsi
mov    -0x58(%rbp),%rdx
mov    -0x20(%rbp),%ecx
mov    $0x1,%r8d
mov    $0x3,%r9d
call   1040 <mmult@plt>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    168a <francisQR+0x53a>
mov    -0x2c(%rbp),%eax
imul   -0xc(%rbp),%eax
mov    %eax,-0x24(%rbp)
imul   $0x3,-0x2c(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x18(%rbp),%ecx
add    $0x4,%ecx
cmp    %ecx,%eax
jge    1677 <francisQR+0x527>
mov    -0x58(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    -0x30(%rbp),%ecx
sub    -0x18(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1625 <francisQR+0x4d5>
jmp    167c <francisQR+0x52c>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    15ff <francisQR+0x4af>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
mov    -0x18(%rbp),%edx
add    $0x2,%edx
imul   %edx,%ecx
add    -0x18(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
mov    -0x18(%rbp),%edx
add    $0x3,%edx
imul   %edx,%ecx
add    -0x18(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x4(%rax)
mov    -0x18(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x3,%ecx
cmp    %ecx,%eax
jge    170f <francisQR+0x5bf>
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%ecx
mov    -0x18(%rbp),%edx
add    $0x4,%edx
imul   %edx,%ecx
add    -0x18(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
movss  %xmm0,0x8(%rax)
jmp    1714 <francisQR+0x5c4>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1328 <francisQR+0x1d8>
mov    -0x48(%rbp),%rdi
mov    -0x50(%rbp),%rdx
mov    $0x2,%esi
call   1070 <house@plt>
movss  %xmm0,-0x3c(%rbp)
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    17c8 <francisQR+0x678>
mov    -0x2c(%rbp),%eax
imul   -0xc(%rbp),%eax
mov    %eax,-0x24(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x14(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    17b5 <francisQR+0x665>
mov    -0x8(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x58(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    -0x2c(%rbp),%ecx
sub    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x28(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1768 <francisQR+0x618>
jmp    17ba <francisQR+0x66a>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1742 <francisQR+0x5f2>
mov    -0x58(%rbp),%rdi
mov    -0x50(%rbp),%rsi
mov    -0x60(%rbp),%rdx
mov    $0x3,%ecx
mov    $0x2,%r8d
mov    $0x1,%r9d
call   1040 <mmult@plt>
mov    -0x60(%rbp),%rdi
movss  -0x3c(%rbp),%xmm0
mov    $0x3,%esi
mov    $0x1,%edx
call   1060 <scale@plt>
mov    -0x50(%rbp),%rdi
mov    -0x60(%rbp),%rsi
mov    -0x58(%rbp),%rdx
mov    $0x2,%ecx
mov    $0x1,%r8d
mov    $0x3,%r9d
call   1040 <mmult@plt>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    18b5 <francisQR+0x765>
mov    -0x2c(%rbp),%eax
imul   -0xc(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x14(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    18a2 <francisQR+0x752>
mov    -0x58(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    -0x14(%rbp),%ecx
add    $0x1,%ecx
imul   $0x3,%ecx,%ecx
add    -0x30(%rbp),%ecx
sub    -0x14(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    184c <francisQR+0x6fc>
jmp    18a7 <francisQR+0x757>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    182d <francisQR+0x6dd>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    193b <francisQR+0x7eb>
mov    -0x2c(%rbp),%eax
imul   -0xc(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x2c(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1928 <francisQR+0x7d8>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x58(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    -0x30(%rbp),%ecx
sub    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    18e4 <francisQR+0x794>
jmp    192d <francisQR+0x7dd>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    18bc <francisQR+0x76c>
mov    -0x58(%rbp),%rdi
mov    -0x50(%rbp),%rsi
mov    -0x60(%rbp),%rdx
mov    -0xc(%rbp),%ecx
mov    $0x2,%r8d
mov    $0x1,%r9d
call   1040 <mmult@plt>
mov    -0x60(%rbp),%rdi
mov    -0xc(%rbp),%esi
movss  -0x3c(%rbp),%xmm0
mov    $0x1,%edx
call   1060 <scale@plt>
mov    -0x60(%rbp),%rdi
mov    -0x50(%rbp),%rsi
mov    -0x58(%rbp),%rdx
mov    -0xc(%rbp),%ecx
mov    $0x1,%r8d
mov    $0x2,%r9d
call   1040 <mmult@plt>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1a20 <francisQR+0x8d0>
mov    -0x2c(%rbp),%eax
imul   -0xc(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x2c(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1a0d <francisQR+0x8bd>
mov    -0x58(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    -0x30(%rbp),%ecx
sub    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    19c0 <francisQR+0x870>
jmp    1a12 <francisQR+0x8c2>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1998 <francisQR+0x848>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
mov    -0x58(%rbp),%rdi
call   1030 <free@plt>
mov    -0x60(%rbp),%rdi
call   1030 <free@plt>
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<francisQR>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xe8,%rsp
mov    %esi,%ebx
mov    %rdi,%r15
mov    $0xc,%edi
call   1050 <malloc@plt>
mov    %rax,%rbp
mov    $0xc,%edi
call   1050 <malloc@plt>
mov    %rax,0x8(%rsp)
mov    %rbx,0x28(%rsp)
movslq %ebx,%rbx
lea    0x0(,%rbx,4),%r14d
lea    (%r14,%r14,2),%edi
call   1050 <malloc@plt>
mov    %rax,%r12
mov    %r14d,%edi
call   1050 <malloc@plt>
mov    %ebx,%ecx
imul   %ebx,%ecx
movslq %ecx,%rcx
movss  -0x4(%r15,%rcx,4),%xmm0
mov    %ecx,%edx
sub    %ebx,%edx
movslq %edx,%rdx
movss  -0x8(%r15,%rdx,4),%xmm1
movss  -0x4(%r15,%rdx,4),%xmm2
movaps %xmm0,%xmm3
mulss  -0x8(%r15,%rcx,4),%xmm2
addss  %xmm1,%xmm3
mulss  %xmm1,%xmm0
subss  %xmm2,%xmm0
movss  (%r15),%xmm1
movss  0x4(%r15),%xmm2
mulss  (%r15,%rbx,4),%xmm2
movaps %xmm3,%xmm4
mulss  %xmm1,%xmm4
mulss  %xmm1,%xmm1
addss  %xmm2,%xmm1
subss  %xmm4,%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,0x0(%rbp)
movss  (%r15),%xmm0
addss  0x4(%r15,%rbx,4),%xmm0
mov    %rax,0x38(%rsp)
subss  %xmm3,%xmm0
mulss  (%r15,%rbx,4),%xmm0
movss  %xmm0,0x4(%rbp)
movss  (%r15,%rbx,4),%xmm0
lea    0x1(%rbx,%rbx,1),%eax
cltq
mulss  (%r15,%rax,4),%xmm0
movss  %xmm0,0x8(%rbp)
cmp    $0x3,%ebx
jge    125b <francisQR+0x10b>
add    $0xe8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %rbp,%rdi
lea    -0x1(%rbx),%ecx
lea    -0x3(%rbx),%eax
mov    %eax,0xb4(%rsp)
lea    -0x4(%rbx),%eax
mov    %ecx,0x4c(%rsp)
mov    %ecx,%ecx
mov    %rcx,0xe0(%rsp)
cltq
mov    %rax,0xd8(%rsp)
lea    -0x2(%rbx),%eax
mov    %rax,0xb8(%rsp)
lea    (%rbx,%rbx,1),%eax
mov    %eax,0x48(%rsp)
lea    0x10(%r15),%rax
mov    %rax,0x98(%rsp)
mov    %rbx,0x20(%rsp)
lea    0x0(,%rbx,4),%rax
mov    %rax,0x80(%rsp)
mov    $0x3,%r9d
mov    $0xffffffffffffffff,%rcx
xor    %eax,%eax
mov    %rax,0x58(%rsp)
xor    %r8d,%r8d
xor    %r14d,%r14d
mov    %rbp,0xa0(%rsp)
mov    %r15,(%rsp)
jmp    1319 <francisQR+0x1c9>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%r9d
add    $0x1,%r8d
mov    0x58(%rsp),%rax
add    $0xffffffff,%eax
mov    %rax,0x58(%rsp)
mov    %r11,%rcx
mov    %rbp,%r14
cmp    0xb8(%rsp),%rbp
je     1c4a <francisQR+0xafa>
mov    0x4c(%rsp),%eax
cmp    %eax,%r9d
mov    %eax,%r13d
mov    %r9d,0x7c(%rsp)
cmovl  %r9d,%r13d
test   %rcx,%rcx
mov    $0x0,%eax
cmovg  %rcx,%rax
mov    %rax,0x90(%rsp)
mov    $0x0,%r15d
cmovg  %ecx,%r15d
test   %ecx,%ecx
mov    $0x0,%ebx
mov    %rcx,0x10(%rsp)
cmovg  %ecx,%ebx
lea    0x1(%rbx),%rcx
mov    0x20(%rsp),%rax
cmp    %rax,%rcx
cmovle %rax,%rcx
mov    %rcx,0x60(%rsp)
mov    %r8,0xc0(%rsp)
lea    -0x1(%r8),%edx
test   %edx,%edx
mov    $0x0,%ecx
cmovle %ecx,%edx
mov    %rdx,0x30(%rsp)
lea    0x1(%rdx),%rcx
cmp    %rax,%rcx
cmovle %rax,%rcx
mov    %rcx,0xa8(%rsp)
mov    %rax,%rbp
mov    $0x3,%esi
mov    0x8(%rsp),%rdx
call   1070 <house@plt>
movss  %xmm0,0x68(%rsp)
mov    %r14,%rax
imul   %rbp,%rax
mov    0x28(%rsp),%r11
mov    %r15d,0x50(%rsp)
cmp    %r11d,%r15d
mov    %rbx,0x18(%rsp)
mov    %r13,0x70(%rsp)
mov    %rax,0x88(%rsp)
jge    14c0 <francisQR+0x370>
mov    (%rsp),%r15
lea    (%r15,%rax,4),%rax
xor    %ecx,%ecx
mov    %rbx,%rdx
movabs $0x300000000,%rdi
mov    %rbx,%r9
nopw   0x0(%rax,%rax,1)
movss  (%rax,%rdx,4),%xmm0
mov    %rcx,%rsi
sar    $0x1e,%rsi
movss  %xmm0,(%r12,%rsi,1)
add    $0x1,%rdx
add    %rdi,%rcx
cmp    %rbp,%rdx
jl     1400 <francisQR+0x2b0>
lea    0x1(%r14),%r10
mov    0x50(%rsp),%ebx
cmp    %r11d,%ebx
mov    %r10,0x40(%rsp)
jge    14ae <francisQR+0x35e>
mov    %r10,%rax
imul   %rbp,%rax
lea    (%r15,%rax,4),%rax
movabs $0x100000000,%rcx
mov    %r9,%rdx
nopl   0x0(%rax,%rax,1)
movss  (%rax,%rdx,4),%xmm0
mov    %rcx,%rsi
sar    $0x1e,%rsi
movss  %xmm0,(%r12,%rsi,1)
add    $0x1,%rdx
add    %rdi,%rcx
cmp    %rbp,%rdx
jl     1450 <francisQR+0x300>
cmp    %r11d,%ebx
jge    14ae <francisQR+0x35e>
lea    0x2(%r14),%rax
imul   %rbp,%rax
lea    (%r15,%rax,4),%rax
movabs $0x200000000,%rcx
mov    %r9,%rdx
nopl   0x0(%rax)
movss  (%rax,%rdx,4),%xmm0
mov    %rcx,%rsi
sar    $0x1e,%rsi
movss  %xmm0,(%r12,%rsi,1)
add    $0x1,%rdx
add    %rdi,%rcx
cmp    %rbp,%rdx
jl     1490 <francisQR+0x340>
mov    0x10(%rsp),%rax
jmp    14d2 <francisQR+0x382>
cs nopw 0x0(%rax,%rax,1)
nop
lea    0x1(%r14),%rax
mov    %rax,0x40(%rsp)
mov    0x10(%rsp),%rax
mov    0x50(%rsp),%ebx
add    $0x4,%rax
mov    %rax,0xc8(%rsp)
mov    %r11d,%ebp
sub    %ebx,%ebp
mov    %r12,%rdi
mov    0x8(%rsp),%r15
mov    %r15,%rsi
mov    0x38(%rsp),%r13
mov    %r13,%rdx
mov    %ebp,%ecx
mov    $0x3,%r8d
mov    $0x1,%r9d
call   1040 <mmult@plt>
mov    %r13,%rdi
mov    %ebp,%esi
mov    $0x1,%edx
movss  0x68(%rsp),%xmm0
call   1060 <scale@plt>
mov    %r15,%rdi
mov    0x28(%rsp),%r15
mov    %r13,%rsi
mov    %r12,%rdx
mov    $0x3,%ecx
mov    $0x1,%r8d
mov    %ebp,%r9d
call   1040 <mmult@plt>
mov    %r15,%r8
cmp    %ebx,%r8d
mov    0x20(%rsp),%rbp
mov    0x18(%rsp),%rbx
mov    0xa8(%rsp),%r15
jle    16b0 <francisQR+0x560>
mov    0x60(%rsp),%rax
sub    %rbx,%rax
mov    0x90(%rsp),%rdx
shl    $0x20,%rdx
mov    0x30(%rsp),%rcx
mov    %rcx,%r11
not    %r11
add    %r15,%r11
and    $0xfffffffffffffff8,%rax
mov    %rax,0x60(%rsp)
mov    %r15,%r10
sub    %rcx,%r10
mov    %rbx,%rsi
cmp    $0x8,%r10
mov    (%rsp),%r9
movabs $0x100000000,%r13
mov    0x88(%rsp),%rcx
jae    1960 <francisQR+0x810>
mov    %rsi,%rax
shl    $0x20,%rax
sub    %rdx,%rax
lea    (%r9,%rcx,4),%rdx
nop
mov    %rax,%rcx
sar    $0x1e,%rcx
movss  (%rdx,%rsi,4),%xmm0
subss  (%r12,%rcx,1),%xmm0
movss  %xmm0,(%rdx,%rsi,4)
add    $0x1,%rsi
add    %r13,%rax
cmp    %rbp,%rsi
jl     15c0 <francisQR+0x470>
cmp    %r8d,0x50(%rsp)
jge    16b0 <francisQR+0x560>
mov    0x90(%rsp),%rax
lea    (%rax,%rax,1),%r9d
mov    0x40(%rsp),%rdx
imul   %rbp,%rdx
mov    %rbx,%rdi
cmp    $0x8,%r10
mov    (%rsp),%r13
jae    1a7a <francisQR+0x92a>
mov    %r8d,%eax
sub    %r9d,%eax
lea    0x0(,%rdx,4),%rdx
add    %r13,%rdx
cs nopw 0x0(%rax,%rax,1)
nop
lea    (%rax,%rdi,1),%ecx
movslq %ecx,%rcx
movss  (%rdx,%rdi,4),%xmm0
subss  (%r12,%rcx,4),%xmm0
movss  %xmm0,(%rdx,%rdi,4)
add    $0x1,%rdi
cmp    %rbp,%rdi
jl     1630 <francisQR+0x4e0>
cmp    %r8d,0x50(%rsp)
jge    16b0 <francisQR+0x560>
mov    0x90(%rsp),%rax
lea    (%rax,%rax,2),%r9d
lea    0x2(%r14),%r15
imul   %rbp,%r15
cmp    $0x8,%r10
jae    1b6a <francisQR+0xa1a>
mov    0x18(%rsp),%rcx
mov    0x48(%rsp),%eax
sub    %r9d,%eax
mov    (%rsp),%rsi
lea    (%rsi,%r15,4),%rdx
nopl   0x0(%rax,%rax,1)
lea    (%rax,%rcx,1),%esi
movslq %esi,%rsi
movss  (%rdx,%rcx,4),%xmm0
subss  (%r12,%rsi,4),%xmm0
movss  %xmm0,(%rdx,%rcx,4)
add    $0x1,%rcx
cmp    %rbp,%rcx
jl     1690 <francisQR+0x540>
nop
mov    0x10(%rsp),%rax
lea    0x1(%rax),%rbx
lea    0x5(%rax),%r13d
mov    0xc8(%rsp),%rax
cmp    0xe0(%rsp),%rax
cmovge %r8d,%r13d
test   %r13d,%r13d
mov    0x70(%rsp),%rdx
jle    1870 <francisQR+0x720>
mov    %rbx,0x50(%rsp)
add    $0x1,%edx
lea    0x2(%r14),%eax
mov    %rax,0x18(%rsp)
mov    0x58(%rsp),%rcx
lea    (%r14,%rcx,1),%eax
add    $0x2,%eax
add    $0xfffffffe,%eax
mov    0x40(%rsp),%rbx
add    %ebx,%ecx
mov    %rdx,0x70(%rsp)
mov    (%rsp),%rsi
mov    0x80(%rsp),%rbp
nopw   0x0(%rax,%rax,1)
movss  (%rsi,%r14,4),%xmm0
cltq
movss  %xmm0,(%r12,%rax,4)
movss  (%rsi,%rbx,4),%xmm0
movslq %ecx,%rcx
movss  %xmm0,(%r12,%rcx,4)
movss  0x8(%rsi,%r14,4),%xmm0
lea    0x2(%rax),%edi
movslq %edi,%rdi
movss  %xmm0,(%r12,%rdi,4)
add    $0x3,%eax
add    $0x3,%ecx
add    %rbp,%rsi
add    $0xffffffffffffffff,%rdx
jne    1720 <francisQR+0x5d0>
mov    %r12,%rdi
mov    0x8(%rsp),%r15
mov    %r15,%rsi
mov    0x38(%rsp),%rbp
mov    %rbp,%rdx
mov    %r13d,%ecx
mov    $0x3,%r8d
mov    $0x1,%r9d
call   1040 <mmult@plt>
mov    %rbp,%rdi
mov    %r13d,%esi
mov    $0x1,%edx
movss  0x68(%rsp),%xmm0
call   1060 <scale@plt>
mov    %rbp,%rdi
mov    %r15,%rsi
mov    %r12,%rdx
mov    %r13d,%ecx
mov    $0x1,%r8d
mov    $0x3,%r9d
call   1040 <mmult@plt>
mov    0x40(%rsp),%rbp
mov    0x80(%rsp),%r10
test   %r13d,%r13d
mov    0xa0(%rsp),%rdi
mov    0x28(%rsp),%r13
mov    (%rsp),%r15
mov    0x7c(%rsp),%r9d
mov    0xc0(%rsp),%r8
mov    0x70(%rsp),%rbx
mov    0x50(%rsp),%r11
jle    18f1 <francisQR+0x7a1>
mov    0x58(%rsp),%rcx
mov    0x18(%rsp),%rax
add    %ecx,%eax
add    $0xfffffffe,%eax
add    %ebp,%ecx
mov    %r15,%rdx
nopw   0x0(%rax,%rax,1)
cltq
movss  (%rdx,%r14,4),%xmm0
subss  (%r12,%rax,4),%xmm0
movss  %xmm0,(%rdx,%r14,4)
movslq %ecx,%rcx
movss  (%rdx,%rbp,4),%xmm0
subss  (%r12,%rcx,4),%xmm0
movss  %xmm0,(%rdx,%rbp,4)
lea    0x2(%rax),%esi
movslq %esi,%rsi
movss  0x8(%rdx,%r14,4),%xmm0
subss  (%r12,%rsi,4),%xmm0
movss  %xmm0,0x8(%rdx,%r14,4)
add    $0x3,%eax
add    $0x3,%ecx
add    %r10,%rdx
add    $0xffffffffffffffff,%rbx
jne    1810 <francisQR+0x6c0>
jmp    18f1 <francisQR+0x7a1>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r12,%rdi
mov    0x8(%rsp),%r14
mov    %r14,%rsi
mov    0x38(%rsp),%rbp
mov    %rbp,%rdx
mov    %r13d,%ecx
mov    %r8,%r15
mov    $0x3,%r8d
mov    $0x1,%r9d
call   1040 <mmult@plt>
mov    %rbp,%rdi
mov    %r13d,%esi
mov    $0x1,%edx
movss  0x68(%rsp),%xmm0
call   1060 <scale@plt>
mov    %rbp,%rdi
mov    %r14,%rsi
mov    %r12,%rdx
mov    %r13d,%ecx
mov    $0x1,%r8d
mov    $0x3,%r9d
call   1040 <mmult@plt>
mov    %rbx,%r11
mov    %r15,%r13
mov    0xa0(%rsp),%rdi
mov    (%rsp),%r15
mov    0x7c(%rsp),%r9d
mov    0xc0(%rsp),%r8
mov    0x40(%rsp),%rbp
mov    0x10(%rsp),%rcx
lea    0x2(%rcx),%eax
imul   %r13d,%eax
add    %r11d,%eax
cltq
movss  (%r15,%rax,4),%xmm0
movss  %xmm0,(%rdi)
lea    0x3(%rcx),%eax
imul   %r13d,%eax
add    %r11d,%eax
cltq
movss  (%r15,%rax,4),%xmm0
movss  %xmm0,0x4(%rdi)
cmp    0xd8(%rsp),%rcx
jge    12f0 <francisQR+0x1a0>
mov    0xc8(%rsp),%rax
imul   %r13d,%eax
add    %ecx,%eax
add    $0x1,%eax
cltq
movss  (%r15,%rax,4),%xmm0
movss  %xmm0,0x8(%rdi)
jmp    12f0 <francisQR+0x1a0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x30(%rsp),%rax
sub    0x90(%rsp),%eax
lea    (%r11,%rax,1),%edi
mov    %rbx,%rsi
cmp    %eax,%edi
jl     15b1 <francisQR+0x461>
mov    %r11,%rsi
shr    $0x20,%rsi
mov    %rbx,%rsi
jne    15b1 <francisQR+0x461>
cltq
lea    (%r15,%rax,1),%rsi
mov    0x30(%rsp),%rcx
sub    %rcx,%rsi
lea    (%r12,%rsi,4),%rsi
mov    0x88(%rsp),%rdi
add    %rcx,%rdi
mov    0x88(%rsp),%rcx
lea    (%r9,%rdi,4),%rdi
cmp    %rsi,%rdi
jae    19d1 <francisQR+0x881>
lea    (%r12,%rax,4),%rax
lea    (%r15,%rcx,1),%rsi
lea    (%r9,%rsi,4),%rdi
mov    %rbx,%rsi
cmp    %rdi,%rax
jb     15b1 <francisQR+0x461>
mov    %rcx,%rax
mov    %rbx,%rcx
shl    $0x20,%rcx
sub    %rdx,%rcx
mov    %r10,%rsi
and    $0xfffffffffffffff8,%rsi
mov    %rsi,0xd0(%rsp)
add    %rbx,%rsi
add    %rbx,%rax
mov    0x98(%rsp),%rdi
lea    (%rdi,%rax,4),%rbp
xor    %eax,%eax
movabs $0x800000000,%r15
mov    0x60(%rsp),%r8
mov    %rcx,%rdi
sar    $0x1e,%rdi
movups (%r12,%rdi,1),%xmm0
movups 0x10(%r12,%rdi,1),%xmm1
movups -0x10(%rbp,%rax,4),%xmm2
subps  %xmm0,%xmm2
movups 0x0(%rbp,%rax,4),%xmm0
subps  %xmm1,%xmm0
movups %xmm2,-0x10(%rbp,%rax,4)
movups %xmm0,0x0(%rbp,%rax,4)
add    $0x8,%rax
add    %r15,%rcx
cmp    %rax,%r8
jne    1a10 <francisQR+0x8c0>
cmp    0xd0(%rsp),%r10
mov    0x20(%rsp),%rbp
mov    0x28(%rsp),%r8
mov    0x18(%rsp),%rbx
mov    0xa8(%rsp),%r15
mov    0x88(%rsp),%rcx
jne    15b1 <francisQR+0x461>
jmp    15e3 <francisQR+0x493>
mov    0x30(%rsp),%rax
add    %r8d,%eax
sub    %r9d,%eax
lea    (%r11,%rax,1),%ecx
mov    %rbx,%rdi
cmp    %eax,%ecx
jl     1614 <francisQR+0x4c4>
mov    %r11,%rcx
shr    $0x20,%rcx
mov    %rbx,%rdi
jne    1614 <francisQR+0x4c4>
cltq
lea    (%r15,%rax,1),%rcx
mov    0x30(%rsp),%rsi
sub    %rsi,%rcx
lea    (%r12,%rcx,4),%rcx
add    %rdx,%rsi
lea    0x0(,%rsi,4),%rsi
add    %r13,%rsi
cmp    %rcx,%rsi
jae    1ae8 <francisQR+0x998>
lea    (%r12,%rax,4),%rax
lea    (%r15,%rdx,1),%rcx
lea    0x0(,%rcx,4),%rcx
add    %r13,%rcx
mov    %rbx,%rdi
cmp    %rcx,%rax
jb     1614 <francisQR+0x4c4>
lea    (%r8,%rbx,1),%ebp
sub    %r9d,%ebp
mov    %r10,%r8
and    $0xfffffffffffffff8,%r8
lea    (%r8,%rbx,1),%rdi
lea    (%rdx,%rbx,1),%rax
mov    0x98(%rsp),%rcx
lea    (%rcx,%rax,4),%rsi
xor    %eax,%eax
mov    0x60(%rsp),%r15
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    (%rax,%rbp,1),%ecx
movslq %ecx,%rcx
movups (%r12,%rcx,4),%xmm0
movups 0x10(%r12,%rcx,4),%xmm1
movups -0x10(%rsi,%rax,4),%xmm2
subps  %xmm0,%xmm2
movups (%rsi,%rax,4),%xmm0
subps  %xmm1,%xmm0
movups %xmm2,-0x10(%rsi,%rax,4)
movups %xmm0,(%rsi,%rax,4)
add    $0x8,%rax
cmp    %rax,%r15
jne    1b20 <francisQR+0x9d0>
cmp    %r8,%r10
mov    0x20(%rsp),%rbp
mov    0x28(%rsp),%r8
jne    1614 <francisQR+0x4c4>
jmp    164f <francisQR+0x4ff>
mov    0x30(%rsp),%rax
add    0x48(%rsp),%eax
sub    %r9d,%eax
lea    (%r11,%rax,1),%ecx
cmp    %eax,%ecx
jl     1674 <francisQR+0x524>
shr    $0x20,%r11
jne    1674 <francisQR+0x524>
cltq
mov    0xa8(%rsp),%rdx
lea    (%rdx,%rax,1),%rcx
mov    0x30(%rsp),%rsi
sub    %rsi,%rcx
lea    (%r12,%rcx,4),%rcx
lea    (%r15,%rsi,1),%rdi
mov    (%rsp),%rsi
lea    (%rsi,%rdi,4),%rdi
cmp    %rcx,%rdi
jae    1bcb <francisQR+0xa7b>
lea    (%r12,%rax,4),%rax
add    %r15,%rdx
lea    (%rsi,%rdx,4),%rcx
cmp    %rcx,%rax
jb     1674 <francisQR+0x524>
mov    %r8,%r11
mov    0x18(%rsp),%rax
mov    %eax,%edi
add    0x48(%rsp),%edi
sub    %r9d,%edi
mov    %r10,%r8
and    $0xfffffffffffffff8,%r8
lea    (%r8,%rax,1),%rcx
add    %r15,%rax
mov    0x98(%rsp),%rsi
lea    (%rsi,%rax,4),%rbp
xor    %eax,%eax
mov    0x60(%rsp),%rdx
nopl   (%rax)
lea    (%rdi,%rax,1),%esi
movslq %esi,%rsi
movups (%r12,%rsi,4),%xmm0
movups 0x10(%r12,%rsi,4),%xmm1
movups -0x10(%rbp,%rax,4),%xmm2
subps  %xmm0,%xmm2
movups 0x0(%rbp,%rax,4),%xmm0
subps  %xmm1,%xmm0
movups %xmm2,-0x10(%rbp,%rax,4)
movups %xmm0,0x0(%rbp,%rax,4)
add    $0x8,%rax
cmp    %rax,%rdx
jne    1c00 <francisQR+0xab0>
cmp    %r8,%r10
mov    0x20(%rsp),%rbp
mov    %r11,%r8
je     16b0 <francisQR+0x560>
jmp    1679 <francisQR+0x529>
mov    $0x2,%ebx
mov    $0x2,%esi
mov    0x8(%rsp),%rdx
call   1070 <house@plt>
movss  %xmm0,0x10(%rsp)
movslq 0xb4(%rsp),%r9
movslq 0xb8(%rsp),%rbp
mov    0x4c(%rsp),%r14d
mov    0x28(%rsp),%rdx
cmp    %r14d,%edx
cmovg  %edx,%r14d
mov    %rbp,%rsi
mov    0x20(%rsp),%rax
imul   %rax,%rsi
lea    (%rsi,%r9,1),%rdi
movss  (%r15,%rdi,4),%xmm0
movss  %xmm0,(%r12)
lea    0x1(%r9),%r10
cmp    %rax,%r10
jge    1ccb <francisQR+0xb7b>
lea    (%r10,%rsi,1),%rax
mov    (%rsp),%rcx
movss  (%rcx,%rax,4),%xmm0
movss  %xmm0,0x8(%r12)
movss  0x8(%rcx,%rdi,4),%xmm0
movss  %xmm0,0x10(%r12)
mov    %rdi,0x68(%rsp)
mov    %rsi,0x40(%rsp)
add    $0x1,%rbp
cmp    %ebp,%r14d
mov    (%rsp),%r13
je     1d2a <francisQR+0xbda>
sub    %edx,%ebx
mov    %rbp,%rax
mov    0x20(%rsp),%rsi
imul   %rsi,%rax
add    %ebp,%ebx
lea    (%rax,%r9,1),%rcx
movslq %ebx,%rdx
movss  0x0(%r13,%rcx,4),%xmm0
movss  %xmm0,(%r12,%rdx,4)
cmp    %rsi,%r10
jge    1d2a <francisQR+0xbda>
add    %r10,%rax
movss  0x0(%r13,%rax,4),%xmm0
movss  %xmm0,0x8(%r12,%rdx,4)
movss  0x8(%r13,%rcx,4),%xmm0
movss  %xmm0,0x10(%r12,%rdx,4)
mov    %r12,%rdi
mov    0x8(%rsp),%r15
mov    %r15,%rsi
mov    0x38(%rsp),%rbx
mov    %rbx,%rdx
mov    $0x3,%ecx
mov    $0x2,%r8d
mov    %r9,0x70(%rsp)
mov    $0x1,%r9d
mov    %r10,0x58(%rsp)
call   1040 <mmult@plt>
mov    %rbx,%rdi
mov    $0x3,%esi
mov    $0x1,%edx
movss  0x10(%rsp),%xmm0
call   1060 <scale@plt>
mov    %r15,%rdi
mov    0x28(%rsp),%r15
mov    %rbx,%rsi
mov    %r12,%rdx
mov    $0x2,%ecx
mov    $0x1,%r8d
mov    $0x3,%r9d
call   1040 <mmult@plt>
mov    0x58(%rsp),%rbx
mov    0x70(%rsp),%r9
mov    0x68(%rsp),%rax
movss  0x0(%r13,%rax,4),%xmm0
subss  (%r12),%xmm0
movss  %xmm0,0x0(%r13,%rax,4)
cmp    %r15d,%ebx
je     1e0f <francisQR+0xcbf>
mov    $0x3,%edi
sub    %r15d,%edi
lea    (%rdi,%rbx,1),%eax
cltq
mov    0x40(%rsp),%rdx
lea    (%rbx,%rdx,1),%rcx
movss  0x0(%r13,%rcx,4),%xmm0
subss  (%r12,%rax,4),%xmm0
movss  %xmm0,0x0(%r13,%rcx,4)
lea    0x2(%r9),%rax
add    %edi,%eax
cltq
lea    (%r9,%rdx,1),%rcx
add    $0x2,%rcx
movss  0x0(%r13,%rcx,4),%xmm0
subss  (%r12,%rax,4),%xmm0
movss  %xmm0,0x0(%r13,%rcx,4)
cmp    %ebp,%r14d
mov    0x80(%rsp),%rdi
je     1ea4 <francisQR+0xd54>
mov    0x20(%rsp),%rcx
imul   %rbp,%rcx
mov    %ebp,%eax
sub    0x4c(%rsp),%eax
mov    %rcx,%r8
add    %r9,%rcx
lea    0x3(%rax,%rax,2),%edx
movslq %edx,%rdx
movss  0x0(%r13,%rcx,4),%xmm0
subss  (%r12,%rdx,4),%xmm0
movss  %xmm0,0x0(%r13,%rcx,4)
cmp    %r15d,%ebx
je     1ea4 <francisQR+0xd54>
mov    $0x6,%ecx
sub    %r15d,%ecx
lea    (%rax,%rax,2),%eax
add    %ecx,%eax
lea    (%rax,%rbx,1),%ecx
movslq %ecx,%rcx
add    %r8,%rbx
movss  0x0(%r13,%rbx,4),%xmm0
subss  (%r12,%rcx,4),%xmm0
movss  %xmm0,0x0(%r13,%rbx,4)
lea    0x2(%r9),%rcx
add    %eax,%ecx
movslq %ecx,%rax
lea    (%r9,%r8,1),%rcx
add    $0x2,%rcx
movss  0x0(%r13,%rcx,4),%xmm0
subss  (%r12,%rax,4),%xmm0
movss  %xmm0,0x0(%r13,%rcx,4)
test   %r15d,%r15d
jle    1fbb <francisQR+0xe6b>
mov    %r15d,%r15d
lea    0x0(,%rbp,4),%rax
add    %r13,%rax
lea    (%r15,%r15,1),%rcx
xor    %edx,%edx
jmp    1edc <francisQR+0xd8c>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x2,%rdx
add    %rdi,%rax
cmp    %rdx,%rcx
je     1efe <francisQR+0xdae>
movss  -0x4(%rax),%xmm0
movss  %xmm0,(%r12,%rdx,4)
cmp    %ebp,%r14d
je     1ed0 <francisQR+0xd80>
movss  (%rax),%xmm0
lea    0x1(%rdx),%esi
movslq %esi,%rsi
movss  %xmm0,(%r12,%rsi,4)
jmp    1ed0 <francisQR+0xd80>
mov    %r12,%rdi
mov    0x8(%rsp),%rsi
mov    0x38(%rsp),%rbx
mov    %rbx,%rdx
mov    0x28(%rsp),%r13
mov    %r13d,%ecx
mov    $0x2,%r8d
mov    $0x1,%r9d
call   1040 <mmult@plt>
mov    %rbx,%rdi
mov    %r13d,%esi
mov    $0x1,%edx
movss  0x10(%rsp),%xmm0
call   1060 <scale@plt>
mov    %rbx,%rdi
mov    0x8(%rsp),%rsi
mov    %r12,%rdx
mov    %r13d,%ecx
mov    $0x1,%r8d
mov    $0x2,%r9d
call   1040 <mmult@plt>
mov    0x80(%rsp),%rsi
test   %r13d,%r13d
jle    2015 <francisQR+0xec5>
mov    (%rsp),%rax
lea    (%rax,%rbp,4),%rax
add    %r15,%r15
xor    %ecx,%ecx
jmp    1f90 <francisQR+0xe40>
nopl   0x0(%rax)
add    $0x2,%rcx
add    %rsi,%rax
cmp    %rcx,%r15
je     2015 <francisQR+0xec5>
movss  -0x4(%rax),%xmm0
subss  (%r12,%rcx,4),%xmm0
movss  %xmm0,-0x4(%rax)
cmp    %ebp,%r14d
je     1f80 <francisQR+0xe30>
lea    0x1(%rcx),%edx
movslq %edx,%rdx
movss  (%rax),%xmm0
subss  (%r12,%rdx,4),%xmm0
movss  %xmm0,(%rax)
jmp    1f80 <francisQR+0xe30>
mov    %r12,%rdi
mov    0x8(%rsp),%r14
mov    %r14,%rsi
mov    0x38(%rsp),%rbp
mov    %rbp,%rdx
mov    %r15d,%ecx
mov    $0x2,%r8d
mov    $0x1,%r9d
call   1040 <mmult@plt>
mov    %rbp,%rdi
mov    %r15d,%esi
mov    $0x1,%edx
movss  0x10(%rsp),%xmm0
call   1060 <scale@plt>
mov    %rbp,%rdi
mov    %r14,%rsi
mov    %r12,%rdx
mov    %r15d,%ecx
mov    $0x1,%r8d
mov    $0x2,%r9d
call   1040 <mmult@plt>
mov    0xa0(%rsp),%rdi
call   1030 <free@plt>
mov    0x8(%rsp),%rdi
call   1030 <free@plt>
mov    %r12,%rdi
call   1030 <free@plt>
mov    0x38(%rsp),%rdi
add    $0xe8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>

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

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