#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*/ exit(int);
int /*<<< orphan*/ free(float *);
float house(float *, int, float *);
scalar_t__ malloc(int);
int /*<<< orphan*/ mmult(float *, float *, float *, int, int, int);
int /*<<< orphan*/ printf(char *);
int /*<<< orphan*/ scale(float *, int, int, float);
void qrdecomp(float *A, int M, int N, float *bvec) {
  int j, i, k, u, t;
  float *x, *v, *AT, *w;
  float beta;
  if (M < N) {
    printf("M should be greater than or equal to N");
    exit(1);
  }
  x = (float *)malloc(sizeof(float) * M);
  v = (float *)malloc(sizeof(float) * M);
  AT = (float *)malloc(sizeof(float) * M * N);
  w = (float *)malloc(sizeof(float) * M * M);
  for (j = 0; j < N; ++j) {
    for (i = j; i < M; ++i) {
      x[i - j] = A[i * N + j];
    }
    beta = house(x, M - j, v);
    bvec[j] = beta;
    for (i = j; i < M; i++) {
      t = i * N;
      u = 0;
      for (k = j; k < N; k++) {
        AT[u + i - j] = A[k + t];
        u += (M - j);
      }
    }
    mmult(AT, v, w, N - j, M - j, 1);
    scale(w, N - j, 1, beta);
    mmult(v, w, AT, M - j, 1, N - j);
    for (i = j; i < M; i++) {
      t = i * N;
      for (k = j; k < N; k++) {
        A[t + k] -= AT[(i - j) * (N - j) + k - j];
      }
    }
    if (j < M) {
      for (i = j + 1; i < M; ++i) {
        A[i * N + j] = v[i - j];
      }
    }
  }
  free(x);
  free(v);
  free(AT);
  free(w);
}


x86 assembly (clang, -O0):
<qrdecomp>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    -0xc(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    11a8 <qrdecomp+0x38>
lea    0xe67(%rip),%rdi
call   1050 <printf@plt>
mov    $0x1,%edi
call   1090 <exit@plt>
movslq -0xc(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x38(%rbp)
movslq -0xc(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x40(%rbp)
movslq -0xc(%rbp),%rax
shl    $0x2,%rax
movslq -0x10(%rbp),%rcx
imul   %rcx,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x48(%rbp)
movslq -0xc(%rbp),%rax
shl    $0x2,%rax
movslq -0xc(%rbp),%rcx
imul   %rcx,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x50(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    146f <qrdecomp+0x2ff>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    125f <qrdecomp+0xef>
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    121d <qrdecomp+0xad>
mov    -0x38(%rbp),%rdi
mov    -0xc(%rbp),%esi
sub    -0x1c(%rbp),%esi
mov    -0x40(%rbp),%rdx
call   1080 <house@plt>
movss  %xmm0,-0x54(%rbp)
movss  -0x54(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1312 <qrdecomp+0x1a2>
mov    -0x20(%rbp),%eax
imul   -0x10(%rbp),%eax
mov    %eax,-0x2c(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    12ff <qrdecomp+0x18f>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    -0x20(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0xc(%rbp),%eax
sub    -0x1c(%rbp),%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    12b2 <qrdecomp+0x142>
jmp    1304 <qrdecomp+0x194>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    128f <qrdecomp+0x11f>
mov    -0x48(%rbp),%rdi
mov    -0x40(%rbp),%rsi
mov    -0x50(%rbp),%rdx
mov    -0x10(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
mov    -0xc(%rbp),%r8d
sub    -0x1c(%rbp),%r8d
mov    $0x1,%r9d
call   1040 <mmult@plt>
mov    -0x50(%rbp),%rdi
mov    -0x10(%rbp),%esi
sub    -0x1c(%rbp),%esi
movss  -0x54(%rbp),%xmm0
mov    $0x1,%edx
call   1070 <scale@plt>
mov    -0x40(%rbp),%rdi
mov    -0x50(%rbp),%rsi
mov    -0x48(%rbp),%rdx
mov    -0xc(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
mov    -0x10(%rbp),%r9d
sub    -0x1c(%rbp),%r9d
mov    $0x1,%r8d
call   1040 <mmult@plt>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1400 <qrdecomp+0x290>
mov    -0x20(%rbp),%eax
imul   -0x10(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    13ed <qrdecomp+0x27d>
mov    -0x48(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
mov    -0x10(%rbp),%edx
sub    -0x1c(%rbp),%edx
imul   %edx,%ecx
add    -0x24(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1397 <qrdecomp+0x227>
jmp    13f2 <qrdecomp+0x282>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    137b <qrdecomp+0x20b>
mov    -0x1c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    145c <qrdecomp+0x2ec>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1457 <qrdecomp+0x2e7>
mov    -0x40(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1415 <qrdecomp+0x2a5>
jmp    145c <qrdecomp+0x2ec>
jmp    1461 <qrdecomp+0x2f1>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    120b <qrdecomp+0x9b>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<qrdecomp>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x118,%rsp
mov    %rcx,0x90(%rsp)
mov    %rdi,0x18(%rsp)
cmp    %edx,%esi
jl     19a3 <qrdecomp+0x833>
mov    %edx,%ebx
lea    0x0(,%rsi,4),%ebp
mov    %ebp,%edi
mov    %rsi,%r15
call   1060 <malloc@plt>
mov    %rax,0x28(%rsp)
mov    %ebp,%edi
call   1060 <malloc@plt>
mov    %rax,0x20(%rsp)
mov    %ebp,%edi
imul   %ebx,%edi
call   1060 <malloc@plt>
mov    %rax,%r14
imul   %r15d,%ebp
mov    %ebp,%edi
call   1060 <malloc@plt>
mov    %rax,0x98(%rsp)
mov    %ebx,0x14(%rsp)
test   %ebx,%ebx
jle    1969 <qrdecomp+0x7f9>
mov    %r15,%r11
mov    0x14(%rsp),%r15d
movslq %r11d,%r12
mov    %r11d,%r8d
lea    0x1(%r15),%rax
mov    %rax,0x80(%rsp)
mov    %r8,%rax
neg    %rax
mov    %rax,0xe0(%rsp)
mov    %r15,%rax
neg    %rax
mov    %rax,0xc8(%rsp)
mov    0x28(%rsp),%rax
add    $0x4,%rax
mov    %rax,0xd0(%rsp)
lea    (%r15,%r15,1),%r9
mov    0x18(%rsp),%rax
lea    0x4(%rax),%rcx
mov    %rcx,0x78(%rsp)
lea    0x0(,%r15,4),%rcx
mov    %rcx,0x50(%rsp)
add    $0x10,%rax
mov    %rax,0xd8(%rsp)
xor    %eax,%eax
mov    %rax,0x68(%rsp)
mov    $0x1,%eax
mov    %rax,0xa0(%rsp)
mov    %r8,%rbp
mov    %r15,%r10
mov    0x20(%rsp),%rbx
xor    %eax,%eax
mov    %rax,0x30(%rsp)
xor    %edx,%edx
mov    %r11,0x58(%rsp)
mov    %r12,0xa8(%rsp)
mov    %r8,0x40(%rsp)
mov    %r9,0x88(%rsp)
jmp    1301 <qrdecomp+0x191>
nopl   0x0(%rax)
add    $0x1,%rdi
mov    %rdi,%rax
mov    0x40(%rsp),%r8
mov    0x88(%rsp),%r9
mov    0x60(%rsp),%rbp
mov    0xb8(%rsp),%r10
mov    0xb0(%rsp),%rbx
mov    0x58(%rsp),%r11
addq   $0xffffffffffffffff,0x30(%rsp)
add    $0xffffffffffffffff,%rbp
mov    0x68(%rsp),%rcx
add    $0x1,%ecx
mov    %rcx,0x68(%rsp)
addq   $0xffffffffffffffff,0xa0(%rsp)
add    $0x4,%rbx
add    %r15,%r10
mov    %rax,%rdx
cmp    %r15,%rax
je     1969 <qrdecomp+0x7f9>
cmp    %r12,%rdx
mov    %rdx,0x8(%rsp)
mov    %rbp,0x60(%rsp)
mov    %r10,0xb8(%rsp)
mov    %rbx,0xb0(%rsp)
jge    1520 <qrdecomp+0x3b0>
mov    %r8d,%ecx
sub    %edx,%ecx
mov    %rdx,%rax
test   $0x1,%cl
je     1352 <qrdecomp+0x1e2>
mov    %rdx,%rax
imul   %r15,%rax
add    %rdx,%rax
mov    0x18(%rsp),%rcx
movss  (%rcx,%rax,4),%xmm0
mov    0x28(%rsp),%rax
movss  %xmm0,(%rax)
lea    0x1(%rdx),%rax
not    %rdx
mov    %rdx,%rcx
mov    %rdx,0x38(%rsp)
cmp    0xe0(%rsp),%rdx
je     13c1 <qrdecomp+0x251>
mov    0xd0(%rsp),%rcx
mov    0x38(%rsp),%rdx
lea    (%rcx,%rdx,4),%rcx
add    $0x4,%rcx
mov    %r15,%rdx
imul   %rax,%rdx
mov    0x18(%rsp),%rdi
lea    (%rdi,%rdx,4),%rdx
lea    0x1(%rax),%rsi
imul   %r15,%rsi
lea    (%rdi,%rsi,4),%rsi
mov    0x8(%rsp),%rdi
nopl   (%rax)
movss  (%rdx,%rdi,4),%xmm0
movss  %xmm0,-0x4(%rcx,%rax,4)
movss  (%rsi,%rdi,4),%xmm0
movss  %xmm0,(%rcx,%rax,4)
add    $0x2,%rax
add    %r9,%rdi
cmp    %rax,%r8
jne    13a0 <qrdecomp+0x230>
mov    %r11d,%ebx
mov    0x8(%rsp),%r13
sub    %r13d,%ebx
mov    0x28(%rsp),%rdi
mov    %ebx,%esi
mov    0x20(%rsp),%rdx
call   1080 <house@plt>
mov    %r13,%r11
mov    0x90(%rsp),%rax
movss  %xmm0,(%rax,%r13,4)
cmp    %r12,%r13
movss  %xmm0,0x10(%rsp)
jge    1560 <qrdecomp+0x3f0>
mov    %ebx,0x48(%rsp)
mov    %ebp,%eax
mov    %rax,%rcx
shl    $0x21,%rcx
mov    %r15,%r8
sub    %r11,%r8
mov    %r8,%r13
and    $0xfffffffffffffffe,%r13
mov    0x30(%rsp),%rdx
lea    (%r11,%rdx,1),%r12
lea    (%rax,%r12,1),%r9d
shl    $0x20,%r12
shl    $0x20,%r9
mov    0x80(%rsp),%rdx
imul   %r11,%rdx
mov    0x78(%rsp),%rsi
lea    (%rsi,%rdx,4),%rdx
mov    0x50(%rsp),%r10
jmp    1472 <qrdecomp+0x302>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r11
movabs $0x100000000,%rsi
add    %rsi,%r12
add    %rsi,%r9
add    %r10,%rdx
cmp    0x40(%rsp),%r11
je     1570 <qrdecomp+0x400>
mov    0x38(%rsp),%rsi
cmp    0xc8(%rsp),%rsi
jne    1490 <qrdecomp+0x320>
xor    %edi,%edi
mov    0x8(%rsp),%rbp
test   $0x1,%r8b
je     1450 <qrdecomp+0x2e0>
jmp    14ee <qrdecomp+0x37e>
mov    %r9,%rbx
mov    %r12,%r10
xor    %edi,%edi
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movss  -0x4(%rdx,%rbp,4),%xmm1
mov    %r10,%rsi
sar    $0x1e,%rsi
movss  %xmm1,(%r14,%rsi,1)
add    %rax,%rdi
movss  (%rdx,%rbp,4),%xmm1
mov    %rbx,%rsi
sar    $0x1e,%rsi
movss  %xmm1,(%r14,%rsi,1)
add    %rax,%rdi
add    $0x2,%rbp
add    %rcx,%r10
add    %rcx,%rbx
cmp    %rbp,%r13
jne    14a0 <qrdecomp+0x330>
add    0x8(%rsp),%rbp
mov    0x50(%rsp),%r10
test   $0x1,%r8b
je     1450 <qrdecomp+0x2e0>
mov    %r11,%rsi
imul   %r15,%rsi
mov    0x30(%rsp),%rbx
add    %r11,%rbx
add    %rsi,%rbp
mov    0x18(%rsp),%rsi
movss  (%rsi,%rbp,4),%xmm1
add    %edi,%ebx
movslq %ebx,%rsi
movss  %xmm1,(%r14,%rsi,4)
jmp    1450 <qrdecomp+0x2e0>
nopw   0x0(%rax,%rax,1)
mov    %r11d,%ebx
sub    %edx,%ebx
mov    0x28(%rsp),%rdi
mov    %ebx,%esi
mov    0x20(%rsp),%r12
mov    %r12,%rdx
call   1080 <house@plt>
mov    0x8(%rsp),%r11
mov    0x90(%rsp),%rax
movss  %xmm0,0x10(%rsp)
movss  %xmm0,(%rax,%r11,4)
mov    0x14(%rsp),%r13d
jmp    1583 <qrdecomp+0x413>
nopl   0x0(%rax)
mov    0x14(%rsp),%r13d
mov    0x20(%rsp),%r12
jmp    1583 <qrdecomp+0x413>
nopl   0x0(%rax)
mov    0x14(%rsp),%r13d
mov    0x20(%rsp),%r12
mov    0x8(%rsp),%r11
mov    0x48(%rsp),%ebx
mov    %r13d,%ebp
sub    %r11d,%ebp
mov    %r14,%rdi
mov    %r12,%rsi
mov    0x98(%rsp),%r12
mov    %r12,%rdx
mov    %ebp,%ecx
mov    %ebx,%r8d
mov    $0x1,%r9d
call   1040 <mmult@plt>
sub    0x8(%rsp),%r13d
mov    %r12,%rdi
mov    %r13d,%esi
mov    $0x1,%edx
movss  0x10(%rsp),%xmm0
call   1070 <scale@plt>
mov    0x20(%rsp),%rdi
mov    %r12,%rsi
mov    %r14,%rdx
mov    %ebx,%ecx
mov    $0x1,%r8d
mov    %ebp,%r9d
call   1040 <mmult@plt>
mov    0x8(%rsp),%rdi
mov    0xa8(%rsp),%r12
cmp    %r12,%rdi
jge    12a0 <qrdecomp+0x130>
mov    %rdi,%rax
not    %rax
mov    %rax,%rcx
mov    %rax,0xe8(%rsp)
add    %r15,%rax
mov    %rax,0x48(%rsp)
mov    %edi,%eax
sub    0x68(%rsp),%eax
mov    %eax,0x74(%rsp)
mov    0x80(%rsp),%rdx
imul   %rdi,%rdx
lea    0x0(,%rdi,4),%rax
lea    0x4(,%rdi,4),%rcx
imul   %r15,%rcx
mov    %rcx,0x100(%rsp)
mov    %r14,%rcx
sub    %rax,%rcx
mov    %rcx,0x108(%rsp)
mov    %r15,%rcx
sub    %rdi,%rcx
mov    %rcx,0x38(%rsp)
and    $0xfffffffffffffff8,%rcx
mov    %rcx,0xf8(%rsp)
lea    (%rdi,%rcx,1),%rax
mov    %rax,0xf0(%rsp)
mov    0x30(%rsp),%r11
lea    (%r11,%rdi,1),%ebp
mov    %r13d,0x10(%rsp)
mov    %r13d,%eax
mov    0xd8(%rsp),%rcx
mov    %rdx,0x110(%rsp)
lea    (%rcx,%rdx,4),%r10
mov    %r15,%rcx
imul   %rdi,%rcx
mov    0x78(%rsp),%rdx
lea    (%rdx,%rcx,4),%r9
mov    0xa0(%rsp),%rsi
xor    %ecx,%ecx
mov    %rdi,%r12
mov    0x40(%rsp),%r8
mov    %rax,0xc0(%rsp)
jmp    16f5 <qrdecomp+0x585>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r12
add    $0x1,%rcx
add    %rax,%rbp
mov    0x50(%rsp),%rdx
add    %rdx,%r10
add    %rax,%rsi
add    %rax,%r11
add    %rdx,%r9
cmp    %r8,%r12
je     18d0 <qrdecomp+0x760>
mov    %rdi,%r13
cmpq   $0x8,0x38(%rsp)
jae    17c0 <qrdecomp+0x650>
mov    %r15d,%edx
sub    %r13d,%edx
mov    %r13,%rbx
test   $0x1,%dl
je     1750 <qrdecomp+0x5e0>
mov    %r12,%rdx
imul   %r15,%rdx
mov    %r12d,%edi
sub    0x8(%rsp),%edi
imul   0x10(%rsp),%edi
add    0x30(%rsp),%edi
add    %r13d,%edi
movslq %edi,%rdi
add    %r13,%rdx
mov    0x18(%rsp),%rbx
movss  (%rbx,%rdx,4),%xmm0
subss  (%r14,%rdi,4),%xmm0
mov    0x8(%rsp),%rdi
movss  %xmm0,(%rbx,%rdx,4)
lea    0x1(%r13),%rbx
not    %r13
cmp    0xc8(%rsp),%r13
je     16d0 <qrdecomp+0x560>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    (%r11,%rbx,1),%edx
movslq %edx,%rdx
movss  -0x4(%r9,%rbx,4),%xmm0
movss  (%r9,%rbx,4),%xmm1
subss  (%r14,%rdx,4),%xmm0
movss  %xmm0,-0x4(%r9,%rbx,4)
lea    (%rsi,%rbx,1),%edx
movslq %edx,%rdx
subss  (%r14,%rdx,4),%xmm1
movss  %xmm1,(%r9,%rbx,4)
add    $0x2,%rbx
cmp    %rbx,%r15
jne    1770 <qrdecomp+0x600>
jmp    16d0 <qrdecomp+0x560>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x10(%rsp),%edx
mov    %edx,%ebx
imul   %ecx,%ebx
add    0x74(%rsp),%ebx
mov    0x48(%rsp),%rdx
add    %ebx,%edx
mov    %rdi,%r13
cmp    %ebx,%edx
jl     1704 <qrdecomp+0x594>
mov    0x48(%rsp),%rdx
shr    $0x20,%rdx
mov    %rdi,%r13
jne    1704 <qrdecomp+0x594>
mov    %rcx,%rdx
imul   %r15,%rdx
mov    0x110(%rsp),%rdi
lea    (%rdi,%rdx,1),%r13
movslq %ebx,%rbx
lea    (%r15,%rbx,1),%rdi
mov    0x18(%rsp),%r8
lea    (%r8,%r13,4),%r13
mov    0x40(%rsp),%rax
mov    0x108(%rsp),%r8
lea    (%r8,%rdi,4),%rdi
mov    %rax,%r8
mov    0xc0(%rsp),%rax
cmp    %rdi,%r13
mov    0x8(%rsp),%rdi
jae    1862 <qrdecomp+0x6f2>
mov    0x18(%rsp),%rdi
lea    (%rdi,%rdx,4),%rdx
add    0x100(%rsp),%rdx
lea    (%r14,%rbx,4),%rdi
mov    0x8(%rsp),%r13
cmp    %rdi,%rdx
mov    0x8(%rsp),%rdi
ja     1704 <qrdecomp+0x594>
xor    %ebx,%ebx
mov    0xf8(%rsp),%rax
nopl   0x0(%rax)
lea    (%rbx,%rbp,1),%edx
movslq %edx,%rdx
movups (%r14,%rdx,4),%xmm0
movups 0x10(%r14,%rdx,4),%xmm1
movups -0x10(%r10,%rbx,4),%xmm2
subps  %xmm0,%xmm2
movups (%r10,%rbx,4),%xmm0
subps  %xmm1,%xmm0
movups %xmm2,-0x10(%r10,%rbx,4)
movups %xmm0,(%r10,%rbx,4)
add    $0x8,%rbx
cmp    %rbx,%rax
jne    1870 <qrdecomp+0x700>
mov    0xf0(%rsp),%r13
cmp    %rax,0x38(%rsp)
mov    0xc0(%rsp),%rax
je     16d0 <qrdecomp+0x560>
jmp    1704 <qrdecomp+0x594>
cs nopw 0x0(%rax,%rax,1)
lea    0x1(%rdi),%rax
mov    0xa8(%rsp),%r12
cmp    %r12,%rdi
mov    0x88(%rsp),%r9
mov    0xb8(%rsp),%r10
mov    0xb0(%rsp),%rbx
jge    195a <qrdecomp+0x7ea>
cmp    %r12,%rax
mov    0x58(%rsp),%r11
mov    0x50(%rsp),%rdi
mov    0x60(%rsp),%rbp
jge    12ce <qrdecomp+0x15e>
mov    0xe8(%rsp),%rcx
lea    (%rbx,%rcx,4),%rcx
add    $0x4,%rcx
mov    0x8(%rsp),%rsi
add    %r10,%rsi
mov    0x18(%rsp),%rdx
lea    (%rdx,%rsi,4),%rdx
mov    $0x1,%esi
nopw   0x0(%rax,%rax,1)
movss  (%rcx,%rsi,4),%xmm0
movss  %xmm0,(%rdx)
add    $0x1,%rsi
add    %rdi,%rdx
cmp    %rsi,%rbp
jne    1940 <qrdecomp+0x7d0>
jmp    12ce <qrdecomp+0x15e>
mov    0x58(%rsp),%r11
mov    0x60(%rsp),%rbp
jmp    12ce <qrdecomp+0x15e>
mov    0x28(%rsp),%rdi
call   1030 <free@plt>
mov    0x20(%rsp),%rdi
call   1030 <free@plt>
mov    %r14,%rdi
call   1030 <free@plt>
mov    0x98(%rsp),%rdi
add    $0x118,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>
lea    0x656(%rip),%rdi
call   1050 <printf@plt>
mov    $0x1,%edi
call   1090 <exit@plt>

LLVM IR (-O0):
@.str = [39 x i8] c"M should be greater than or equal to N\00"
define void @qrdecomp(float* %0, i32 %1, i32 %2, float* %3) {
%5 = alloca float*
%6 = alloca i32
%7 = alloca i32
%8 = alloca float*
%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
store float* %0, float** %5
store i32 %1, i32* %6
store i32 %2, i32* %7
store float* %3, float** %8
%19 = load i32, i32* %6
%20 = load i32, i32* %7
%21 = icmp slt i32 %19, %20
br i1 %21, label %22, label %25
22: ; preds = %4
%23 = call i32 @printf(i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str, i64 0, i64 0))
%24 = call i32 @exit(i32 1)
unreachable
25: ; preds = %4
%26 = load i32, i32* %6
%27 = sext i32 %26 to i64
%28 = mul i64 4, %27
%29 = trunc i64 %28 to i32
%30 = call i64 @malloc(i32 %29)
%31 = inttoptr i64 %30 to float*
store float* %31, float** %14
%32 = load i32, i32* %6
%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** %15
%38 = load i32, i32* %6
%39 = sext i32 %38 to i64
%40 = mul i64 4, %39
%41 = load i32, i32* %7
%42 = sext i32 %41 to i64
%43 = mul i64 %40, %42
%44 = trunc i64 %43 to i32
%45 = call i64 @malloc(i32 %44)
%46 = inttoptr i64 %45 to float*
store float* %46, float** %16
%47 = load i32, i32* %6
%48 = sext i32 %47 to i64
%49 = mul i64 4, %48
%50 = load i32, i32* %6
%51 = sext i32 %50 to i64
%52 = mul i64 %49, %51
%53 = trunc i64 %52 to i32
%54 = call i64 @malloc(i32 %53)
%55 = inttoptr i64 %54 to float*
store float* %55, float** %17
store i32 0, i32* %9
br label %56
56: ; preds = %243, %25
%57 = load i32, i32* %9
%58 = load i32, i32* %7
%59 = icmp slt i32 %57, %58
br i1 %59, label %60, label %246
60: ; preds = %56
%61 = load i32, i32* %9
store i32 %61, i32* %10
br label %62
62: ; preds = %82, %60
%63 = load i32, i32* %10
%64 = load i32, i32* %6
%65 = icmp slt i32 %63, %64
br i1 %65, label %66, label %85
66: ; preds = %62
%67 = load float*, float** %5
%68 = load i32, i32* %10
%69 = load i32, i32* %7
%70 = mul nsw i32 %68, %69
%71 = load i32, i32* %9
%72 = add nsw i32 %70, %71
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds float, float* %67, i64 %73
%75 = load float, float* %74
%76 = load float*, float** %14
%77 = load i32, i32* %10
%78 = load i32, i32* %9
%79 = sub nsw i32 %77, %78
%80 = sext i32 %79 to i64
%81 = getelementptr inbounds float, float* %76, i64 %80
store float %75, float* %81
br label %82
82: ; preds = %66
%83 = load i32, i32* %10
%84 = add nsw i32 %83, 1
store i32 %84, i32* %10
br label %62
85: ; preds = %62
%86 = load float*, float** %14
%87 = load i32, i32* %6
%88 = load i32, i32* %9
%89 = sub nsw i32 %87, %88
%90 = load float*, float** %15
%91 = call float @house(float* %86, i32 %89, float* %90)
store float %91, float* %18
%92 = load float, float* %18
%93 = load float*, float** %8
%94 = load i32, i32* %9
%95 = sext i32 %94 to i64
%96 = getelementptr inbounds float, float* %93, i64 %95
store float %92, float* %96
%97 = load i32, i32* %9
store i32 %97, i32* %10
br label %98
98: ; preds = %136, %85
%99 = load i32, i32* %10
%100 = load i32, i32* %6
%101 = icmp slt i32 %99, %100
br i1 %101, label %102, label %139
102: ; preds = %98
%103 = load i32, i32* %10
%104 = load i32, i32* %7
%105 = mul nsw i32 %103, %104
store i32 %105, i32* %13
store i32 0, i32* %12
%106 = load i32, i32* %9
store i32 %106, i32* %11
br label %107
107: ; preds = %132, %102
%108 = load i32, i32* %11
%109 = load i32, i32* %7
%110 = icmp slt i32 %108, %109
br i1 %110, label %111, label %135
111: ; preds = %107
%112 = load float*, float** %5
%113 = load i32, i32* %11
%114 = load i32, i32* %13
%115 = add nsw i32 %113, %114
%116 = sext i32 %115 to i64
%117 = getelementptr inbounds float, float* %112, i64 %116
%118 = load float, float* %117
%119 = load float*, float** %16
%120 = load i32, i32* %12
%121 = load i32, i32* %10
%122 = add nsw i32 %120, %121
%123 = load i32, i32* %9
%124 = sub nsw i32 %122, %123
%125 = sext i32 %124 to i64
%126 = getelementptr inbounds float, float* %119, i64 %125
store float %118, float* %126
%127 = load i32, i32* %6
%128 = load i32, i32* %9
%129 = sub nsw i32 %127, %128
%130 = load i32, i32* %12
%131 = add nsw i32 %130, %129
store i32 %131, i32* %12
br label %132
132: ; preds = %111
%133 = load i32, i32* %11
%134 = add nsw i32 %133, 1
store i32 %134, i32* %11
br label %107
135: ; preds = %107
br label %136
136: ; preds = %135
%137 = load i32, i32* %10
%138 = add nsw i32 %137, 1
store i32 %138, i32* %10
br label %98
139: ; preds = %98
%140 = load float*, float** %16
%141 = load float*, float** %15
%142 = load float*, float** %17
%143 = load i32, i32* %7
%144 = load i32, i32* %9
%145 = sub nsw i32 %143, %144
%146 = load i32, i32* %6
%147 = load i32, i32* %9
%148 = sub nsw i32 %146, %147
%149 = call i32 @mmult(float* %140, float* %141, float* %142, i32 %145, i32 %148, i32 1)
%150 = load float*, float** %17
%151 = load i32, i32* %7
%152 = load i32, i32* %9
%153 = sub nsw i32 %151, %152
%154 = load float, float* %18
%155 = call i32 @scale(float* %150, i32 %153, i32 1, float %154)
%156 = load float*, float** %15
%157 = load float*, float** %17
%158 = load float*, float** %16
%159 = load i32, i32* %6
%160 = load i32, i32* %9
%161 = sub nsw i32 %159, %160
%162 = load i32, i32* %7
%163 = load i32, i32* %9
%164 = sub nsw i32 %162, %163
%165 = call i32 @mmult(float* %156, float* %157, float* %158, i32 %161, i32 1, i32 %164)
%166 = load i32, i32* %9
store i32 %166, i32* %10
br label %167
167: ; preds = %208, %139
%168 = load i32, i32* %10
%169 = load i32, i32* %6
%170 = icmp slt i32 %168, %169
br i1 %170, label %171, label %211
171: ; preds = %167
%172 = load i32, i32* %10
%173 = load i32, i32* %7
%174 = mul nsw i32 %172, %173
store i32 %174, i32* %13
%175 = load i32, i32* %9
store i32 %175, i32* %11
br label %176
176: ; preds = %204, %171
%177 = load i32, i32* %11
%178 = load i32, i32* %7
%179 = icmp slt i32 %177, %178
br i1 %179, label %180, label %207
180: ; preds = %176
%181 = load float*, float** %16
%182 = load i32, i32* %10
%183 = load i32, i32* %9
%184 = sub nsw i32 %182, %183
%185 = load i32, i32* %7
%186 = load i32, i32* %9
%187 = sub nsw i32 %185, %186
%188 = mul nsw i32 %184, %187
%189 = load i32, i32* %11
%190 = add nsw i32 %188, %189
%191 = load i32, i32* %9
%192 = sub nsw i32 %190, %191
%193 = sext i32 %192 to i64
%194 = getelementptr inbounds float, float* %181, i64 %193
%195 = load float, float* %194
%196 = load float*, float** %5
%197 = load i32, i32* %13
%198 = load i32, i32* %11
%199 = add nsw i32 %197, %198
%200 = sext i32 %199 to i64
%201 = getelementptr inbounds float, float* %196, i64 %200
%202 = load float, float* %201
%203 = fsub float %202, %195
store float %203, float* %201
br label %204
204: ; preds = %180
%205 = load i32, i32* %11
%206 = add nsw i32 %205, 1
store i32 %206, i32* %11
br label %176
207: ; preds = %176
br label %208
208: ; preds = %207
%209 = load i32, i32* %10
%210 = add nsw i32 %209, 1
store i32 %210, i32* %10
br label %167
211: ; preds = %167
%212 = load i32, i32* %9
%213 = load i32, i32* %6
%214 = icmp slt i32 %212, %213
br i1 %214, label %215, label %242
215: ; preds = %211
%216 = load i32, i32* %9
%217 = add nsw i32 %216, 1
store i32 %217, i32* %10
br label %218
218: ; preds = %238, %215
%219 = load i32, i32* %10
%220 = load i32, i32* %6
%221 = icmp slt i32 %219, %220
br i1 %221, label %222, label %241
222: ; preds = %218
%223 = load float*, float** %15
%224 = load i32, i32* %10
%225 = load i32, i32* %9
%226 = sub nsw i32 %224, %225
%227 = sext i32 %226 to i64
%228 = getelementptr inbounds float, float* %223, i64 %227
%229 = load float, float* %228
%230 = load float*, float** %5
%231 = load i32, i32* %10
%232 = load i32, i32* %7
%233 = mul nsw i32 %231, %232
%234 = load i32, i32* %9
%235 = add nsw i32 %233, %234
%236 = sext i32 %235 to i64
%237 = getelementptr inbounds float, float* %230, i64 %236
store float %229, float* %237
br label %238
238: ; preds = %222
%239 = load i32, i32* %10
%240 = add nsw i32 %239, 1
store i32 %240, i32* %10
br label %218
241: ; preds = %218
br label %242
242: ; preds = %241, %211
br label %243
243: ; preds = %242
%244 = load i32, i32* %9
%245 = add nsw i32 %244, 1
store i32 %245, i32* %9
br label %56
246: ; preds = %56
%247 = load float*, float** %14
%248 = call i32 @free(float* %247)
%249 = load float*, float** %15
%250 = call i32 @free(float* %249)
%251 = load float*, float** %16
%252 = call i32 @free(float* %251)
%253 = load float*, float** %17
%254 = call i32 @free(float* %253)
ret void
}

LLVM IR (-O2):
@.str = [39 x i8] c"M should be greater than or equal to N\00"
define void @qrdecomp(float* nocapture %0, i32 %1, i32 %2, float* nocapture writeonly %3) {
%5 = icmp slt i32 %1, %2
br i1 %5, label %6, label %9
6: ; preds = %4
%7 = tail call i32 @printf(i8* dereferenceable(1) getelementptr inbounds ([39 x i8], [39 x i8]* @.str, i64 0, i64 0))
%8 = tail call i32 @exit(i32 1)
unreachable
9: ; preds = %4
%10 = shl i32 %1, 2
%11 = tail call i64 @malloc(i32 %10)
%12 = inttoptr i64 %11 to float*
%13 = tail call i64 @malloc(i32 %10)
%14 = inttoptr i64 %13 to float*
%15 = mul i32 %10, %2
%16 = tail call i64 @malloc(i32 %15)
%17 = inttoptr i64 %16 to float*
%18 = mul i32 %10, %1
%19 = tail call i64 @malloc(i32 %18)
%20 = inttoptr i64 %19 to float*
%21 = icmp sgt i32 %2, 0
br i1 %21, label %22, label %292
22: ; preds = %9
%23 = zext i32 %2 to i64
%24 = sext i32 %1 to i64
%25 = zext i32 %2 to i64
%26 = zext i32 %1 to i64
%27 = zext i32 %1 to i64
%28 = zext i32 %1 to i64
%29 = zext i32 %1 to i64
%30 = add nuw nsw i64 %25, 1
%31 = sub nsw i64 0, %28
%32 = sub nsw i64 0, %25
%33 = sub nsw i64 0, %25
br label %34
34: ; preds = %22, %285
%35 = phi i32 [ 0, %22 ], [ %291, %285 ]
%36 = phi i64 [ 0, %22 ], [ %287, %285 ]
%37 = phi i64 [ 1, %22 ], [ %289, %285 ]
%38 = phi i32 [ %1, %22 ], [ %288, %285 ]
%39 = phi i64 [ 0, %22 ], [ %286, %285 ]
%40 = trunc i64 %39 to i32
%41 = zext i32 %38 to i64
%42 = icmp slt i64 %39, %24
br i1 %42, label %43, label %57
43: ; preds = %34
%44 = sub i64 %28, %39
%45 = xor i64 %39, -1
%46 = and i64 %44, 1
%47 = icmp eq i64 %46, 0
br i1 %47, label %54, label %48
48: ; preds = %43
%49 = mul nsw i64 %39, %23
%50 = add nsw i64 %49, %39
%51 = getelementptr inbounds float, float* %0, i64 %50
%52 = load float, float* %51
store float %52, float* %12
%53 = add nuw nsw i64 %39, 1
br label %54
54: ; preds = %48, %43
%55 = phi i64 [ %39, %43 ], [ %53, %48 ]
%56 = icmp eq i64 %45, %31
br i1 %56, label %79, label %62
57: ; preds = %34
%58 = trunc i64 %39 to i32
%59 = sub i32 %1, %58
%60 = tail call float @house(float* %12, i32 %59, float* %14)
%61 = getelementptr inbounds float, float* %3, i64 %39
store float %60, float* %61
br label %133
62: ; preds = %54, %62
%63 = phi i64 [ %77, %62 ], [ %55, %54 ]
%64 = mul nsw i64 %63, %23
%65 = add nsw i64 %64, %39
%66 = getelementptr inbounds float, float* %0, i64 %65
%67 = load float, float* %66
%68 = sub nuw nsw i64 %63, %39
%69 = getelementptr inbounds float, float* %12, i64 %68
store float %67, float* %69
%70 = add nuw nsw i64 %63, 1
%71 = mul nsw i64 %70, %23
%72 = add nsw i64 %71, %39
%73 = getelementptr inbounds float, float* %0, i64 %72
%74 = load float, float* %73
%75 = sub nuw nsw i64 %70, %39
%76 = getelementptr inbounds float, float* %12, i64 %75
store float %74, float* %76
%77 = add nuw nsw i64 %63, 2
%78 = icmp eq i64 %77, %26
br i1 %78, label %79, label %62
79: ; preds = %62, %54
%80 = trunc i64 %39 to i32
%81 = sub i32 %1, %80
%82 = tail call float @house(float* %12, i32 %81, float* %14)
%83 = getelementptr inbounds float, float* %3, i64 %39
store float %82, float* %83
br i1 %42, label %84, label %133
84: ; preds = %79
%85 = sub i64 %25, %39
%86 = xor i64 %39, -1
%87 = and i64 %85, 1
%88 = icmp eq i64 %86, %32
%89 = and i64 %85, -2
%90 = icmp eq i64 %87, 0
br label %91
91: ; preds = %84, %130
%92 = phi i64 [ %131, %130 ], [ %39, %84 ]
%93 = mul nsw i64 %92, %23
%94 = add nsw i64 %92, %36
br i1 %88, label %119, label %95
95: ; preds = %91, %95
%96 = phi i64 [ %115, %95 ], [ 0, %91 ]
%97 = phi i64 [ %116, %95 ], [ %39, %91 ]
%98 = phi i64 [ %117, %95 ], [ 0, %91 ]
%99 = add nsw i64 %97, %93
%100 = getelementptr inbounds float, float* %0, i64 %99
%101 = load float, float* %100
%102 = add i64 %94, %96
%103 = shl i64 %102, 32
%104 = ashr exact i64 %103, 32
%105 = getelementptr inbounds float, float* %17, i64 %104
store float %101, float* %105
%106 = add i64 %96, %41
%107 = add nuw nsw i64 %97, 1
%108 = add nsw i64 %107, %93
%109 = getelementptr inbounds float, float* %0, i64 %108
%110 = load float, float* %109
%111 = add i64 %94, %106
%112 = shl i64 %111, 32
%113 = ashr exact i64 %112, 32
%114 = getelementptr inbounds float, float* %17, i64 %113
store float %110, float* %114
%115 = add i64 %106, %41
%116 = add nuw nsw i64 %97, 2
%117 = add i64 %98, 2
%118 = icmp eq i64 %117, %89
br i1 %118, label %119, label %95
119: ; preds = %95, %91
%120 = phi i64 [ 0, %91 ], [ %115, %95 ]
%121 = phi i64 [ %39, %91 ], [ %116, %95 ]
br i1 %90, label %130, label %122
122: ; preds = %119
%123 = add nsw i64 %121, %93
%124 = getelementptr inbounds float, float* %0, i64 %123
%125 = load float, float* %124
%126 = add i64 %94, %120
%127 = shl i64 %126, 32
%128 = ashr exact i64 %127, 32
%129 = getelementptr inbounds float, float* %17, i64 %128
store float %125, float* %129
br label %130
130: ; preds = %119, %122
%131 = add nuw nsw i64 %92, 1
%132 = icmp eq i64 %131, %27
br i1 %132, label %133, label %91
133: ; preds = %130, %57, %79
%134 = phi float [ %60, %57 ], [ %82, %79 ], [ %82, %130 ]
%135 = phi i32 [ %59, %57 ], [ %81, %79 ], [ %81, %130 ]
%136 = sub nsw i32 %2, %40
%137 = tail call i32 @mmult(float* %17, float* %14, float* %20, i32 %136, i32 %135, i32 1)
%138 = trunc i64 %39 to i32
%139 = sub i32 %2, %138
%140 = tail call i32 @scale(float* %20, i32 %139, i32 1, float %134)
%141 = tail call i32 @mmult(float* %14, float* %20, float* %17, i32 %135, i32 1, i32 %136)
br i1 %42, label %144, label %142
142: ; preds = %133
%143 = add nuw nsw i64 %39, 1
br label %285
144: ; preds = %133
%145 = trunc i64 %36 to i32
%146 = xor i64 %39, -1
%147 = add i64 %146, %25
%148 = sub i32 %40, %35
%149 = mul i64 %30, %39
%150 = shl i64 %39, 2
%151 = add i64 %150, 4
%152 = mul i64 %151, %25
%153 = sub i32 %40, %35
%154 = sub i64 0, %39
%155 = getelementptr float, float* %17, i64 %154
%156 = sub i64 %25, %39
%157 = icmp ult i64 %156, 8
%158 = trunc i64 %147 to i32
%159 = icmp ugt i64 %147, 4294967295
%160 = and i64 %156, -8
%161 = add i64 %39, %160
%162 = icmp eq i64 %156, %160
br label %163
163: ; preds = %266, %144
%164 = phi i64 [ %270, %266 ], [ 0, %144 ]
%165 = phi i32 [ %269, %266 ], [ 0, %144 ]
%166 = phi i64 [ %267, %266 ], [ %39, %144 ]
%167 = mul i64 %164, %25
%168 = add i64 %149, %167
%169 = getelementptr float, float* %0, i64 %168
%170 = getelementptr float, float* %0, i64 %167
%171 = bitcast float* %170 to i8*
%172 = getelementptr i8, i8* %171, i64 %152
%173 = trunc i64 %164 to i32
%174 = mul i32 %139, %173
%175 = add i32 %174, %153
%176 = sext i32 %175 to i64
%177 = getelementptr float, float* %17, i64 %176
%178 = bitcast float* %177 to i8*
%179 = add nsw i64 %25, %176
%180 = getelementptr float, float* %155, i64 %179
%181 = mul i32 %139, %165
%182 = add i32 %148, %181
%183 = mul nsw i64 %166, %23
%184 = trunc i64 %166 to i32
%185 = sub nuw nsw i32 %184, %40
%186 = mul nsw i32 %185, %139
%187 = add i32 %186, %145
br i1 %157, label %223, label %188
188: ; preds = %163
%189 = add i32 %182, %158
%190 = icmp slt i32 %189, %182
%191 = or i1 %190, %159
br i1 %191, label %223, label %192
192: ; preds = %188
%193 = icmp ult float* %169, %180
%194 = icmp ugt i8* %172, %178
%195 = and i1 %193, %194
br i1 %195, label %223, label %196
196: ; preds = %192, %196
%197 = phi i64 [ %220, %196 ], [ 0, %192 ]
%198 = add i64 %39, %197
%199 = add i64 %39, %197
%200 = trunc i64 %199 to i32
%201 = add i32 %187, %200
%202 = sext i32 %201 to i64
%203 = getelementptr inbounds float, float* %17, i64 %202
%204 = bitcast float* %203 to <4 x float>*
%205 = load <4 x float>, <4 x float>* %204
%206 = getelementptr inbounds float, float* %203, i64 4
%207 = bitcast float* %206 to <4 x float>*
%208 = load <4 x float>, <4 x float>* %207
%209 = add nsw i64 %198, %183
%210 = getelementptr inbounds float, float* %0, i64 %209
%211 = bitcast float* %210 to <4 x float>*
%212 = load <4 x float>, <4 x float>* %211
%213 = getelementptr inbounds float, float* %210, i64 4
%214 = bitcast float* %213 to <4 x float>*
%215 = load <4 x float>, <4 x float>* %214
%216 = fsub <4 x float> %212, %205
%217 = fsub <4 x float> %215, %208
%218 = bitcast float* %210 to <4 x float>*
store <4 x float> %216, <4 x float>* %218
%219 = bitcast float* %213 to <4 x float>*
store <4 x float> %217, <4 x float>* %219
%220 = add nuw i64 %197, 8
%221 = icmp eq i64 %220, %160
br i1 %221, label %222, label %196
222: ; preds = %196
br i1 %162, label %266, label %223
223: ; preds = %192, %188, %163, %222
%224 = phi i64 [ %39, %192 ], [ %39, %188 ], [ %39, %163 ], [ %161, %222 ]
%225 = sub i64 %25, %224
%226 = xor i64 %224, -1
%227 = and i64 %225, 1
%228 = icmp eq i64 %227, 0
br i1 %228, label %240, label %229
229: ; preds = %223
%230 = trunc i64 %224 to i32
%231 = add i32 %187, %230
%232 = sext i32 %231 to i64
%233 = getelementptr inbounds float, float* %17, i64 %232
%234 = load float, float* %233
%235 = add nsw i64 %224, %183
%236 = getelementptr inbounds float, float* %0, i64 %235
%237 = load float, float* %236
%238 = fsub float %237, %234
store float %238, float* %236
%239 = add nuw nsw i64 %224, 1
br label %240
240: ; preds = %229, %223
%241 = phi i64 [ %224, %223 ], [ %239, %229 ]
%242 = icmp eq i64 %226, %33
br i1 %242, label %266, label %243
243: ; preds = %240, %243
%244 = phi i64 [ %264, %243 ], [ %241, %240 ]
%245 = trunc i64 %244 to i32
%246 = add i32 %187, %245
%247 = sext i32 %246 to i64
%248 = getelementptr inbounds float, float* %17, i64 %247
%249 = load float, float* %248
%250 = add nsw i64 %244, %183
%251 = getelementptr inbounds float, float* %0, i64 %250
%252 = load float, float* %251
%253 = fsub float %252, %249
store float %253, float* %251
%254 = add nuw nsw i64 %244, 1
%255 = trunc i64 %254 to i32
%256 = add i32 %187, %255
%257 = sext i32 %256 to i64
%258 = getelementptr inbounds float, float* %17, i64 %257
%259 = load float, float* %258
%260 = add nsw i64 %254, %183
%261 = getelementptr inbounds float, float* %0, i64 %260
%262 = load float, float* %261
%263 = fsub float %262, %259
store float %263, float* %261
%264 = add nuw nsw i64 %244, 2
%265 = icmp eq i64 %264, %25
br i1 %265, label %266, label %243
266: ; preds = %240, %243, %222
%267 = add nuw nsw i64 %166, 1
%268 = icmp eq i64 %267, %28
%269 = add i32 %165, 1
%270 = add i64 %164, 1
br i1 %268, label %271, label %163
271: ; preds = %266
%272 = add nuw nsw i64 %39, 1
%273 = icmp slt i64 %272, %24
%274 = select i1 %42, i1 %273, i1 false
br i1 %274, label %275, label %285
275: ; preds = %271, %275
%276 = phi i64 [ %283, %275 ], [ %37, %271 ]
%277 = sub nuw nsw i64 %276, %39
%278 = getelementptr inbounds float, float* %14, i64 %277
%279 = load float, float* %278
%280 = mul nsw i64 %276, %23
%281 = add nsw i64 %280, %39
%282 = getelementptr inbounds float, float* %0, i64 %281
store float %279, float* %282
%283 = add nuw nsw i64 %276, 1
%284 = icmp eq i64 %283, %29
br i1 %284, label %285, label %275
285: ; preds = %275, %142, %271
%286 = phi i64 [ %143, %142 ], [ %272, %271 ], [ %272, %275 ]
%287 = add nsw i64 %36, -1
%288 = add i32 %38, -1
%289 = add nuw nsw i64 %37, 1
%290 = icmp eq i64 %286, %25
%291 = add i32 %35, 1
br i1 %290, label %292, label %34
292: ; preds = %285, %9
%293 = tail call i32 @free(float* %12)
%294 = tail call i32 @free(float* %14)
%295 = tail call i32 @free(float* %17)
%296 = tail call i32 @free(float* %20)
ret void
}