#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*/ memcpy(float *, float const *, size_t);
int /*<<< orphan*/ memset(float *, int /*<<< orphan*/, size_t);
float sqrt(float);
void qr(const float *a, size_t m, size_t n, float *q) {
  float s, r[n];
  size_t i;
  size_t j;
  size_t k;
  memcpy(q, a, m * n * sizeof(float));
  for (k = 0; k < n; k++) {
    memset(r, 0, k * sizeof(float));
    for (j = 0; j < m; j++)
      for (i = 0; i < k; i++)
        r[i] += q[j * n + i] * q[j * n + k];
    for (j = 0; j < m; j++)
      for (i = 0; i < k; i++)
        q[j * n + k] -= q[j * n + i] * r[i];
    s = 0.0;
    for (j = 0; j < m; j++)
      s += q[j * n + k] * q[j * n + k];
    r[k] = sqrt(s);
    for (j = 0; j < m; j++)
      q[j * n + k] /= r[k];
  }
}


x86 assembly (clang, -O0):
<qr>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    -0x18(%rbp),%rax
mov    %rsp,%rcx
mov    %rcx,-0x30(%rbp)
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x58(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x38(%rbp)
mov    -0x20(%rbp),%rdi
mov    -0x8(%rbp),%rsi
mov    -0x10(%rbp),%rdx
imul   -0x18(%rbp),%rdx
shl    $0x2,%rdx
call   1040 <memcpy@plt>
movq   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%rax
cmp    -0x18(%rbp),%rax
jae    13e0 <qr+0x2b0>
mov    -0x58(%rbp),%rdi
mov    -0x50(%rbp),%rdx
shl    $0x2,%rdx
xor    %esi,%esi
call   1030 <memset@plt>
movq   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%rax
cmp    -0x10(%rbp),%rax
jae    124c <qr+0x11c>
movq   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x50(%rbp),%rax
jae    1236 <qr+0x106>
mov    -0x58(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    -0x48(%rbp),%rdx
imul   -0x18(%rbp),%rdx
add    -0x40(%rbp),%rdx
movss  (%rcx,%rdx,4),%xmm0
mov    -0x20(%rbp),%rcx
mov    -0x48(%rbp),%rdx
imul   -0x18(%rbp),%rdx
add    -0x50(%rbp),%rdx
movss  (%rcx,%rdx,4),%xmm2
mov    -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    11d1 <qr+0xa1>
jmp    123b <qr+0x10b>
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
jmp    11bb <qr+0x8b>
movq   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%rax
cmp    -0x10(%rbp),%rax
jae    12f3 <qr+0x1c3>
movq   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%rax
cmp    -0x50(%rbp),%rax
jae    12dd <qr+0x1ad>
mov    -0x58(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    -0x48(%rbp),%rdx
imul   -0x18(%rbp),%rdx
add    -0x40(%rbp),%rdx
movss  (%rcx,%rdx,4),%xmm0
mov    -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x20(%rbp),%rax
mov    -0x48(%rbp),%rcx
imul   -0x18(%rbp),%rcx
add    -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
movd   %xmm0,%edx
xor    $0x80000000,%edx
movd   %edx,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
jmp    126a <qr+0x13a>
jmp    12e2 <qr+0x1b2>
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
jmp    1254 <qr+0x124>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x24(%rbp)
movq   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%rax
cmp    -0x10(%rbp),%rax
jae    1360 <qr+0x230>
mov    -0x20(%rbp),%rax
mov    -0x48(%rbp),%rcx
imul   -0x18(%rbp),%rcx
add    -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x48(%rbp),%rcx
imul   -0x18(%rbp),%rcx
add    -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x24(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
jmp    1303 <qr+0x1d3>
movss  -0x24(%rbp),%xmm0
call   1050 <sqrt@plt>
mov    -0x58(%rbp),%rax
mov    -0x50(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movq   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%rax
cmp    -0x10(%rbp),%rax
jae    13ca <qr+0x29a>
mov    -0x58(%rbp),%rax
mov    -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x20(%rbp),%rax
mov    -0x48(%rbp),%rcx
imul   -0x18(%rbp),%rcx
add    -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
jmp    137f <qr+0x24f>
jmp    13cf <qr+0x29f>
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
jmp    1192 <qr+0x62>
mov    -0x30(%rbp),%rax
mov    %rax,%rsp
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<qr>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x98,%rsp
mov    %rcx,%r12
mov    %rdx,%r14
mov    %rsi,%r15
mov    %rdi,%rsi
mov    %rsp,%rbx
lea    0xf(,%rdx,4),%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%rbx
mov    %rbx,%rsp
mov    %r15,%rdx
imul   %r14,%rdx
shl    $0x2,%rdx
mov    %rcx,%rdi
call   1040 <memcpy@plt>
test   %r14,%r14
je     16ba <qr+0x58a>
mov    %r14,%r8
lea    -0x1(%r15),%rax
mov    %rax,-0xa0(%rbp)
lea    -0x4(%r15),%rax
mov    %rax,-0x88(%rbp)
mov    %rax,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %r15d,%eax
and    $0x3,%eax
mov    %rax,-0x68(%rbp)
mov    %r15,%rax
and    $0xfffffffffffffffc,%rax
mov    %rax,-0x40(%rbp)
cmp    $0x4,%r15
setae  %al
cmp    $0x1,%r14
sete   %dl
and    %al,%dl
mov    %dl,-0x29(%rbp)
mov    %rcx,%rax
mov    %rcx,-0x80(%rbp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,-0x78(%rbp)
mov    %r15,%rax
neg    %rax
mov    %rax,-0x90(%rbp)
lea    0x30(%r12),%rax
mov    %rax,-0xb0(%rbp)
lea    0x0(,%r14,4),%r13
lea    0x4(%r12),%rax
mov    %rax,-0xa8(%rbp)
mov    %r14,%rdi
shl    $0x4,%rdi
mov    %r14,%r9
shl    $0x5,%r9
lea    0x0(,%r14,8),%r10
lea    0x0(,%r13,2),%rax
add    %r13,%rax
mov    %rax,-0x98(%rbp)
movq   $0xfffffffffffffff8,-0x70(%rbp)
ff
xor    %r14d,%r14d
mov    %r12,-0x38(%rbp)
mov    %r8,-0x58(%rbp)
mov    %rdi,-0x50(%rbp)
mov    %r9,-0x60(%rbp)
mov    %r10,-0x48(%rbp)
jmp    127f <qr+0x14f>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movl   $0x0,(%rbx,%r14,4)
add    $0x1,%r14
addq   $0x1,-0x70(%rbp)
addq   $0x4,-0x38(%rbp)
cmp    %r8,%r14
je     16ba <qr+0x58a>
lea    0x0(,%r14,4),%rdx
mov    %rbx,%rdi
xor    %esi,%esi
call   1030 <memset@plt>
mov    -0x58(%rbp),%r8
test   %r15,%r15
je     1260 <qr+0x130>
mov    %r14,%r9
and    $0xfffffffffffffffe,%r9
mov    -0x70(%rbp),%rax
shr    $0x3,%rax
add    $0x1,%rax
and    $0xfffffffffffffffe,%rax
mov    %rax,-0xb8(%rbp)
lea    -0x8(%r14),%r10
mov    %r10,-0xc0(%rbp)
shr    $0x3,%r10
add    $0x1,%r10
mov    %r14,%r11
and    $0xfffffffffffffff8,%r11
mov    %r12,%rcx
mov    -0xb0(%rbp),%rdx
xor    %esi,%esi
jmp    12f3 <qr+0x1c3>
add    $0x1,%rsi
add    %r13,%rdx
add    %r13,%rcx
cmp    %r15,%rsi
je     1410 <qr+0x2e0>
test   %r14,%r14
je     12e0 <qr+0x1b0>
mov    %rsi,%rdi
imul   %r8,%rdi
lea    (%rdi,%r14,1),%rax
movss  (%r12,%rax,4),%xmm0
cmp    $0x8,%r14
jae    1320 <qr+0x1f0>
xor    %eax,%eax
jmp    13e0 <qr+0x2b0>
cs nopw 0x0(%rax,%rax,1)
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
cmpq   $0x8,-0xc0(%rbp)
08
jae    1336 <qr+0x206>
xor    %r8d,%r8d
jmp    139b <qr+0x26b>
mov    -0xb8(%rbp),%rax
xor    %r8d,%r8d
movups -0x30(%rdx,%r8,4),%xmm2
movups -0x20(%rdx,%r8,4),%xmm3
mulps  %xmm1,%xmm2
addps  (%rbx,%r8,4),%xmm2
mulps  %xmm1,%xmm3
addps  0x10(%rbx,%r8,4),%xmm3
movaps %xmm2,(%rbx,%r8,4)
movaps %xmm3,0x10(%rbx,%r8,4)
movups -0x10(%rdx,%r8,4),%xmm2
mulps  %xmm1,%xmm2
addps  0x20(%rbx,%r8,4),%xmm2
movups (%rdx,%r8,4),%xmm3
mulps  %xmm1,%xmm3
addps  0x30(%rbx,%r8,4),%xmm3
movaps %xmm2,0x20(%rbx,%r8,4)
movaps %xmm3,0x30(%rbx,%r8,4)
add    $0x10,%r8
add    $0xfffffffffffffffe,%rax
jne    1340 <qr+0x210>
test   $0x1,%r10b
je     13cb <qr+0x29b>
add    %r8,%rdi
movups (%r12,%rdi,4),%xmm2
movups 0x10(%r12,%rdi,4),%xmm3
mulps  %xmm1,%xmm2
addps  (%rbx,%r8,4),%xmm2
mulps  %xmm1,%xmm3
addps  0x10(%rbx,%r8,4),%xmm3
movaps %xmm2,(%rbx,%r8,4)
movaps %xmm3,0x10(%rbx,%r8,4)
mov    %r11,%rax
cmp    %r11,%r14
mov    -0x58(%rbp),%r8
je     12e0 <qr+0x1b0>
nopl   0x0(%rax,%rax,1)
movss  (%rcx,%rax,4),%xmm1
mulss  %xmm0,%xmm1
addss  (%rbx,%rax,4),%xmm1
movss  %xmm1,(%rbx,%rax,4)
add    $0x1,%rax
cmp    %rax,%r14
jne    13e0 <qr+0x2b0>
jmp    12e0 <qr+0x1b0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
test   %r15,%r15
je     1260 <qr+0x130>
mov    -0xa8(%rbp),%rcx
xor    %edx,%edx
jmp    1440 <qr+0x310>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rdx
add    %r13,%rcx
cmp    %r15,%rdx
je     14c0 <qr+0x390>
test   %r14,%r14
je     1430 <qr+0x300>
mov    %rdx,%rdi
imul   %r8,%rdi
lea    (%rdi,%r14,1),%rsi
movss  (%r12,%rsi,4),%xmm0
xor    %eax,%eax
cmp    $0x1,%r14
je     1493 <qr+0x363>
xchg   %ax,%ax
movss  -0x4(%rcx,%rax,4),%xmm1
mulss  (%rbx,%rax,4),%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,(%r12,%rsi,4)
movss  (%rcx,%rax,4),%xmm1
mulss  0x4(%rbx,%rax,4),%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,(%r12,%rsi,4)
add    $0x2,%rax
cmp    %rax,%r9
jne    1460 <qr+0x330>
test   $0x1,%r14b
je     1430 <qr+0x300>
add    %rax,%rdi
movss  (%r12,%rdi,4),%xmm1
mulss  (%rbx,%rax,4),%xmm1
subss  %xmm1,%xmm0
movss  %xmm0,(%r12,%rsi,4)
jmp    1430 <qr+0x300>
cs nopw 0x0(%rax,%rax,1)
test   %r15,%r15
je     1260 <qr+0x130>
cmpq   $0x3,-0xa0(%rbp)
03
jae    14e2 <qr+0x3b2>
xorps  %xmm0,%xmm0
xor    %eax,%eax
mov    -0x50(%rbp),%rdi
mov    -0x48(%rbp),%r10
jmp    1541 <qr+0x411>
xorps  %xmm0,%xmm0
mov    -0x38(%rbp),%rcx
xor    %eax,%eax
mov    -0x40(%rbp),%rdx
mov    -0x50(%rbp),%rdi
mov    -0x48(%rbp),%r10
mov    -0x98(%rbp),%rsi
xchg   %ax,%ax
movss  (%rcx),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
movss  (%rcx,%r13,1),%xmm0
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  (%rcx,%r10,1),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
movss  (%rcx,%rsi,1),%xmm0
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
add    $0x4,%rax
add    %rdi,%rcx
cmp    %rax,%rdx
jne    1500 <qr+0x3d0>
cmpq   $0x0,-0x68(%rbp)
je     1575 <qr+0x445>
imul   %r8,%rax
add    %r14,%rax
lea    (%r12,%rax,4),%rax
mov    -0x68(%rbp),%rcx
nopw   0x0(%rax,%rax,1)
movss  (%rax),%xmm1
mulss  %xmm1,%xmm1
addss  %xmm1,%xmm0
add    %r13,%rax
add    $0xffffffffffffffff,%rcx
jne    1560 <qr+0x430>
ucomiss 0xa84(%rip),%xmm0
jb     1584 <qr+0x454>
sqrtss %xmm0,%xmm0
jmp    1595 <qr+0x465>
call   1050 <sqrt@plt>
mov    -0x48(%rbp),%r10
mov    -0x50(%rbp),%rdi
mov    -0x58(%rbp),%r8
mov    -0x60(%rbp),%r9
movss  %xmm0,(%rbx,%r14,4)
test   %r15,%r15
je     1268 <qr+0x138>
cmpb   $0x0,-0x29(%rbp)
je     15c7 <qr+0x497>
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
cmpq   $0x4,-0x88(%rbp)
04
jae    15cb <qr+0x49b>
xor    %eax,%eax
mov    -0x40(%rbp),%rsi
jmp    1601 <qr+0x4d1>
xor    %eax,%eax
jmp    1627 <qr+0x4f7>
mov    -0x78(%rbp),%rcx
mov    -0x38(%rbp),%rdx
xor    %eax,%eax
mov    -0x40(%rbp),%rsi
nopl   0x0(%rax)
movups (%rdx),%xmm2
divps  %xmm1,%xmm2
movups %xmm2,(%rdx)
movups (%rdx,%rdi,1),%xmm2
divps  %xmm1,%xmm2
movups %xmm2,(%rdx,%rdi,1)
add    $0x8,%rax
add    %r9,%rdx
add    $0xfffffffffffffffe,%rcx
jne    15e0 <qr+0x4b0>
testb  $0x1,-0x80(%rbp)
je     161b <qr+0x4eb>
imul   %r8,%rax
add    %r14,%rax
movups (%r12,%rax,4),%xmm2
divps  %xmm1,%xmm2
movups %xmm2,(%r12,%rax,4)
mov    %rsi,%rax
cmp    %r15,%rsi
je     1268 <qr+0x138>
mov    %rax,%rdx
test   $0x1,%r15b
je     1651 <qr+0x521>
mov    %rax,%rcx
imul   %r8,%rcx
add    %r14,%rcx
movss  (%r12,%rcx,4),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,(%r12,%rcx,4)
mov    %rax,%rdx
or     $0x1,%rdx
not    %rax
cmp    -0x90(%rbp),%rax
je     1268 <qr+0x138>
mov    %r15,%rax
sub    %rdx,%rax
lea    0x1(%rdx),%rcx
imul   %r8,%rcx
mov    -0x38(%rbp),%rsi
lea    (%rsi,%rcx,4),%rcx
imul   %r8,%rdx
lea    (%rsi,%rdx,4),%rdx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  (%rdx,%rsi,1),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,(%rdx,%rsi,1)
movss  (%rcx,%rsi,1),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,(%rcx,%rsi,1)
add    %r10,%rsi
add    $0xfffffffffffffffe,%rax
jne    1690 <qr+0x560>
jmp    1268 <qr+0x138>
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @qr(float* %0, i64 %1, i64 %2, float* %3) {
%5 = alloca float*
%6 = alloca i64
%7 = alloca i64
%8 = alloca float*
%9 = alloca float
%10 = alloca i8*
%11 = alloca i64
%12 = alloca i64
%13 = alloca i64
%14 = alloca i64
store float* %0, float** %5
store i64 %1, i64* %6
store i64 %2, i64* %7
store float* %3, float** %8
%15 = load i64, i64* %7
%16 = call i8* @llvm.stacksave()
store i8* %16, i8** %10
%17 = alloca float, i64 %15
store i64 %15, i64* %11
%18 = load float*, float** %8
%19 = load float*, float** %5
%20 = load i64, i64* %6
%21 = load i64, i64* %7
%22 = mul i64 %20, %21
%23 = mul i64 %22, 4
%24 = call i32 @memcpy(float* %18, float* %19, i64 %23)
store i64 0, i64* %14
br label %25
25: ; preds = %162, %4
%26 = load i64, i64* %14
%27 = load i64, i64* %7
%28 = icmp ult i64 %26, %27
br i1 %28, label %29, label %165
29: ; preds = %25
%30 = load i64, i64* %14
%31 = mul i64 %30, 4
%32 = call i32 @memset(float* %17, i32 0, i64 %31)
store i64 0, i64* %13
br label %33
33: ; preds = %67, %29
%34 = load i64, i64* %13
%35 = load i64, i64* %6
%36 = icmp ult i64 %34, %35
br i1 %36, label %37, label %70
37: ; preds = %33
store i64 0, i64* %12
br label %38
38: ; preds = %63, %37
%39 = load i64, i64* %12
%40 = load i64, i64* %14
%41 = icmp ult i64 %39, %40
br i1 %41, label %42, label %66
42: ; preds = %38
%43 = load float*, float** %8
%44 = load i64, i64* %13
%45 = load i64, i64* %7
%46 = mul i64 %44, %45
%47 = load i64, i64* %12
%48 = add i64 %46, %47
%49 = getelementptr inbounds float, float* %43, i64 %48
%50 = load float, float* %49
%51 = load float*, float** %8
%52 = load i64, i64* %13
%53 = load i64, i64* %7
%54 = mul i64 %52, %53
%55 = load i64, i64* %14
%56 = add i64 %54, %55
%57 = getelementptr inbounds float, float* %51, i64 %56
%58 = load float, float* %57
%59 = load i64, i64* %12
%60 = getelementptr inbounds float, float* %17, i64 %59
%61 = load float, float* %60
%62 = call float @llvm.fmuladd.f32(float %50, float %58, float %61)
store float %62, float* %60
br label %63
63: ; preds = %42
%64 = load i64, i64* %12
%65 = add i64 %64, 1
store i64 %65, i64* %12
br label %38
66: ; preds = %38
br label %67
67: ; preds = %66
%68 = load i64, i64* %13
%69 = add i64 %68, 1
store i64 %69, i64* %13
br label %33
70: ; preds = %33
store i64 0, i64* %13
br label %71
71: ; preds = %106, %70
%72 = load i64, i64* %13
%73 = load i64, i64* %6
%74 = icmp ult i64 %72, %73
br i1 %74, label %75, label %109
75: ; preds = %71
store i64 0, i64* %12
br label %76
76: ; preds = %102, %75
%77 = load i64, i64* %12
%78 = load i64, i64* %14
%79 = icmp ult i64 %77, %78
br i1 %79, label %80, label %105
80: ; preds = %76
%81 = load float*, float** %8
%82 = load i64, i64* %13
%83 = load i64, i64* %7
%84 = mul i64 %82, %83
%85 = load i64, i64* %12
%86 = add i64 %84, %85
%87 = getelementptr inbounds float, float* %81, i64 %86
%88 = load float, float* %87
%89 = load i64, i64* %12
%90 = getelementptr inbounds float, float* %17, i64 %89
%91 = load float, float* %90
%92 = load float*, float** %8
%93 = load i64, i64* %13
%94 = load i64, i64* %7
%95 = mul i64 %93, %94
%96 = load i64, i64* %14
%97 = add i64 %95, %96
%98 = getelementptr inbounds float, float* %92, i64 %97
%99 = load float, float* %98
%100 = fneg float %88
%101 = call float @llvm.fmuladd.f32(float %100, float %91, float %99)
store float %101, float* %98
br label %102
102: ; preds = %80
%103 = load i64, i64* %12
%104 = add i64 %103, 1
store i64 %104, i64* %12
br label %76
105: ; preds = %76
br label %106
106: ; preds = %105
%107 = load i64, i64* %13
%108 = add i64 %107, 1
store i64 %108, i64* %13
br label %71
109: ; preds = %71
store float 0.000000e+00, float* %9
store i64 0, i64* %13
br label %110
110: ; preds = %133, %109
%111 = load i64, i64* %13
%112 = load i64, i64* %6
%113 = icmp ult i64 %111, %112
br i1 %113, label %114, label %136
114: ; preds = %110
%115 = load float*, float** %8
%116 = load i64, i64* %13
%117 = load i64, i64* %7
%118 = mul i64 %116, %117
%119 = load i64, i64* %14
%120 = add i64 %118, %119
%121 = getelementptr inbounds float, float* %115, i64 %120
%122 = load float, float* %121
%123 = load float*, float** %8
%124 = load i64, i64* %13
%125 = load i64, i64* %7
%126 = mul i64 %124, %125
%127 = load i64, i64* %14
%128 = add i64 %126, %127
%129 = getelementptr inbounds float, float* %123, i64 %128
%130 = load float, float* %129
%131 = load float, float* %9
%132 = call float @llvm.fmuladd.f32(float %122, float %130, float %131)
store float %132, float* %9
br label %133
133: ; preds = %114
%134 = load i64, i64* %13
%135 = add i64 %134, 1
store i64 %135, i64* %13
br label %110
136: ; preds = %110
%137 = load float, float* %9
%138 = call float @sqrt(float %137)
%139 = load i64, i64* %14
%140 = getelementptr inbounds float, float* %17, i64 %139
store float %138, float* %140
store i64 0, i64* %13
br label %141
141: ; preds = %158, %136
%142 = load i64, i64* %13
%143 = load i64, i64* %6
%144 = icmp ult i64 %142, %143
br i1 %144, label %145, label %161
145: ; preds = %141
%146 = load i64, i64* %14
%147 = getelementptr inbounds float, float* %17, i64 %146
%148 = load float, float* %147
%149 = load float*, float** %8
%150 = load i64, i64* %13
%151 = load i64, i64* %7
%152 = mul i64 %150, %151
%153 = load i64, i64* %14
%154 = add i64 %152, %153
%155 = getelementptr inbounds float, float* %149, i64 %154
%156 = load float, float* %155
%157 = fdiv float %156, %148
store float %157, float* %155
br label %158
158: ; preds = %145
%159 = load i64, i64* %13
%160 = add i64 %159, 1
store i64 %160, i64* %13
br label %141
161: ; preds = %141
br label %162
162: ; preds = %161
%163 = load i64, i64* %14
%164 = add i64 %163, 1
store i64 %164, i64* %14
br label %25
165: ; preds = %25
%166 = load i8*, i8** %10
ret void
}

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