#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 *);
scalar_t__ malloc(int);
int /*<<< orphan*/ mmult(float *, float *, float *, int, int, int);
int /*<<< orphan*/ mtranspose(float *, int, int, float *);
int rcholu(float *, int, int, float *);
int rbcholu(float *A, int N, int stride, float *UB, float *UT) {
  int bs, bb, i, j, Nb, t, k, u, v, w, sc;
  float *b, *x, *U12, *U12T;
  float sum;
  bs = (int)64;
  bb = bs * bs;
  if (N <= 64) {
    sc = rcholu(A, N, stride, UB);
    if (sc == -1) {
      return -1;
    }
  } else {
    Nb = N - bs;
    x = (float *)malloc(sizeof(float) * bs);
    b = (float *)malloc(sizeof(float) * bs);
    U12T = (float *)malloc(sizeof(float) * Nb * bs);
    U12 = (float *)malloc(sizeof(float) * Nb * bs);
    rcholu(A, bs, stride, UB);
    for (i = 0; i < bs; ++i) {
      t = i * stride;
      u = 0;
      for (j = 0; j < N; ++j) {
        UT[u + i] = A[j + t];
        u += bs;
      }
    }
    for (k = 0; k < Nb; ++k) {
      u = k * bs;
      for (i = 0; i < bs; ++i) {
        b[i] = UT[bb + u + i];
        x[i] = 0.;
      }
      for (i = 0; i < bs; ++i) {
        t = i * bs;
        sum = 0;
        for (j = 0; j < i; ++j) {
          sum += UT[t + j] * x[j];
        }
        x[i] = (b[i] - sum) / UT[t + i];
      }
      v = bs + k;
      for (i = 0; i < bs; ++i) {
        A[v] = x[i];
        U12T[u + i] = x[i];
        v += stride;
      }
    }
    mtranspose(U12T, Nb, bs, U12);
    mmult(U12T, U12, UT, Nb, bs, Nb);
    free(U12T);
    free(U12);
    free(b);
    free(x);
    for (i = 0; i < Nb; ++i) {
      u = bs * stride + bs + i * stride;
      w = i * Nb;
      for (j = i; j < Nb; j++) {
        A[j + u] -= UT[j + w];
      }
    }
    sc = rbcholu(A + bs * stride + bs, Nb, stride, UB, UT);
    if (sc == -1) {
      return -1;
    }
  }
  return sc;
}


x86 assembly (clang, -O0):
<rbcholu>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %edx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
movl   $0x40,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
imul   -0x2c(%rbp),%eax
mov    %eax,-0x30(%rbp)
cmpl   $0x40,-0x14(%rbp)
jg     11c9 <rbcholu+0x69>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
mov    -0x20(%rbp),%rcx
call   1080 <rcholu@plt>
mov    %eax,-0x54(%rbp)
cmpl   $0xffffffff,-0x54(%rbp)
jne    11c4 <rbcholu+0x64>
movl   $0xffffffff,-0x4(%rbp)
jmp    15a7 <rbcholu+0x447>
jmp    15a1 <rbcholu+0x441>
mov    -0x14(%rbp),%eax
sub    -0x2c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
movslq -0x2c(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x68(%rbp)
movslq -0x2c(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x60(%rbp)
movslq -0x3c(%rbp),%rax
shl    $0x2,%rax
movslq -0x2c(%rbp),%rcx
imul   %rcx,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x78(%rbp)
movslq -0x3c(%rbp),%rax
shl    $0x2,%rax
movslq -0x2c(%rbp),%rcx
imul   %rcx,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x70(%rbp)
mov    -0x10(%rbp),%rdi
mov    -0x2c(%rbp),%esi
mov    -0x18(%rbp),%edx
mov    -0x20(%rbp),%rcx
call   1080 <rcholu@plt>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    12c6 <rbcholu+0x166>
mov    -0x34(%rbp),%eax
imul   -0x18(%rbp),%eax
mov    %eax,-0x40(%rbp)
movl   $0x0,-0x48(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    12b3 <rbcholu+0x153>
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    -0x40(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    126c <rbcholu+0x10c>
jmp    12b8 <rbcholu+0x158>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1248 <rbcholu+0xe8>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    146b <rbcholu+0x30b>
mov    -0x44(%rbp),%eax
imul   -0x2c(%rbp),%eax
mov    %eax,-0x48(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1336 <rbcholu+0x1d6>
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    -0x48(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x60(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%rax
movslq -0x34(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    12ea <rbcholu+0x18a>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    13ec <rbcholu+0x28c>
mov    -0x34(%rbp),%eax
imul   -0x2c(%rbp),%eax
mov    %eax,-0x40(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x7c(%rbp)
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x34(%rbp),%eax
jge    13ad <rbcholu+0x24d>
mov    -0x28(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    -0x38(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x7c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x7c(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1362 <rbcholu+0x202>
mov    -0x60(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x7c(%rbp),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
divss  (%rax,%rcx,4),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    133d <rbcholu+0x1dd>
mov    -0x2c(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x4c(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jge    1458 <rbcholu+0x2f8>
mov    -0x68(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x78(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    -0x4c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    13fc <rbcholu+0x29c>
jmp    145d <rbcholu+0x2fd>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    12cd <rbcholu+0x16d>
mov    -0x78(%rbp),%rdi
mov    -0x3c(%rbp),%esi
mov    -0x2c(%rbp),%edx
mov    -0x70(%rbp),%rcx
call   1050 <mtranspose@plt>
mov    -0x78(%rbp),%rdi
mov    -0x70(%rbp),%rsi
mov    -0x28(%rbp),%rdx
mov    -0x3c(%rbp),%ecx
mov    -0x2c(%rbp),%r8d
mov    -0x3c(%rbp),%r9d
call   1040 <mmult@plt>
mov    -0x78(%rbp),%rdi
call   1030 <free@plt>
mov    -0x70(%rbp),%rdi
call   1030 <free@plt>
mov    -0x60(%rbp),%rdi
call   1030 <free@plt>
mov    -0x68(%rbp),%rdi
call   1030 <free@plt>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    1551 <rbcholu+0x3f1>
mov    -0x2c(%rbp),%eax
imul   -0x18(%rbp),%eax
add    -0x2c(%rbp),%eax
mov    -0x34(%rbp),%ecx
imul   -0x18(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x48(%rbp)
mov    -0x34(%rbp),%eax
imul   -0x3c(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    153e <rbcholu+0x3de>
mov    -0x28(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    14f7 <rbcholu+0x397>
jmp    1543 <rbcholu+0x3e3>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    14c5 <rbcholu+0x365>
mov    -0x10(%rbp),%rdi
mov    -0x2c(%rbp),%eax
imul   -0x18(%rbp),%eax
cltq
shl    $0x2,%rax
add    %rax,%rdi
movslq -0x2c(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x3c(%rbp),%esi
mov    -0x18(%rbp),%edx
mov    -0x20(%rbp),%rcx
mov    -0x28(%rbp),%r8
call   1070 <rbcholu@plt>
mov    %eax,-0x54(%rbp)
cmpl   $0xffffffff,-0x54(%rbp)
jne    159c <rbcholu+0x43c>
movl   $0xffffffff,-0x4(%rbp)
jmp    15a7 <rbcholu+0x447>
jmp    15a1 <rbcholu+0x441>
mov    -0x54(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<rbcholu>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x128,%rsp
mov    %edx,%ebx
mov    %rdi,%r14
cmp    $0x40,%esi
jg     1193 <rbcholu+0x33>
mov    %r14,%rdi
mov    %ebx,%edx
call   1080 <rcholu@plt>
cmp    $0xffffffff,%eax
jne    1de2 <rbcholu+0xc82>
jmp    1ddd <rbcholu+0xc7d>
lea    -0x40(%rsi),%r15d
mov    $0x100,%edi
mov    %r8,0x10(%rsp)
mov    %rsi,0x60(%rsp)
mov    %rcx,%r12
call   1060 <malloc@plt>
mov    %rax,%rbp
mov    $0x100,%edi
call   1060 <malloc@plt>
mov    %rax,%r13
mov    %r15d,0x1c(%rsp)
shl    $0x8,%r15d
mov    %r15d,%edi
call   1060 <malloc@plt>
mov    %rax,0x28(%rsp)
mov    %r15d,%edi
call   1060 <malloc@plt>
mov    %rax,0x58(%rsp)
mov    %r14,%rdi
mov    $0x40,%esi
mov    %ebx,%edx
mov    %r12,0x70(%rsp)
mov    %r12,%rcx
call   1080 <rcholu@plt>
mov    0x60(%rsp),%r11
mov    %rbx,0x30(%rsp)
movslq %ebx,%rax
mov    %r11d,%r8d
mov    %r8d,%edx
and    $0xfffffffe,%edx
lea    0x4(%r14),%rsi
mov    %rax,0x20(%rsp)
lea    0x0(,%rax,4),%r15
xor    %r10d,%r10d
mov    0x10(%rsp),%rcx
jmp    1245 <rbcholu+0xe5>
nopl   0x0(%rax)
add    $0x1,%r10
add    $0x4,%rcx
add    %r15,%rsi
cmp    $0x40,%r10
je     12c4 <rbcholu+0x164>
cmp    $0x1,%r11d
jne    1260 <rbcholu+0x100>
xor    %eax,%eax
xor    %ebx,%ebx
test   $0x1,%r8b
je     1230 <rbcholu+0xd0>
jmp    12a0 <rbcholu+0x140>
nopw   0x0(%rax,%rax,1)
mov    $0x40,%eax
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
movss  -0x4(%rsi,%rbx,4),%xmm0
movss  %xmm0,-0x100(%rcx,%rax,4)
ff ff
movss  (%rsi,%rbx,4),%xmm0
movss  %xmm0,(%rcx,%rax,4)
add    $0x2,%rbx
sub    $0xffffffffffffff80,%rax
cmp    %rbx,%rdx
jne    1270 <rbcholu+0x110>
add    $0xffffffffffffffc0,%rax
test   $0x1,%r8b
je     1230 <rbcholu+0xd0>
mov    %r10,%rdi
imul   0x20(%rsp),%rdi
add    %rdi,%rbx
movss  (%r14,%rbx,4),%xmm0
add    %r10,%rax
mov    0x10(%rsp),%rdi
movss  %xmm0,(%rdi,%rax,4)
jmp    1230 <rbcholu+0xd0>
cmp    $0x41,%r11d
jl     1aa2 <rbcholu+0x942>
mov    0x1c(%rsp),%eax
mov    %rax,0x48(%rsp)
lea    0x100(%rbp),%rax
lea    0x100(%r13),%rcx
mov    %rax,0x68(%rsp)
cmp    %rax,%r13
setb   %al
mov    %rcx,0xf0(%rsp)
cmp    %rcx,%rbp
setb   %cl
and    %al,%cl
mov    %cl,0xf(%rsp)
mov    0x20(%rsp),%rdx
lea    0x0(,%rdx,8),%r9
lea    (%r15,%r15,2),%rax
mov    %rax,0xd8(%rsp)
mov    %rdx,%rcx
shl    $0x4,%rcx
lea    (%r15,%r15,4),%rax
mov    %rax,0xc8(%rsp)
lea    (%r9,%r9,2),%rax
mov    %rax,0xc0(%rsp)
lea    (%rdx,%rdx,8),%rax
lea    (%rax,%rax,2),%rax
add    %rdx,%rax
mov    %rax,0xb8(%rsp)
mov    %rdx,%rax
shl    $0x5,%rax
mov    %rax,0xb0(%rsp)
lea    (%r15,%r15,8),%rax
mov    %rax,0xa8(%rsp)
lea    (%r9,%r9,4),%rax
mov    %rax,0xa0(%rsp)
imul   $0x2c,%rdx,%rax
mov    %rax,0x98(%rsp)
mov    %rcx,0xd0(%rsp)
lea    (%rcx,%rcx,2),%rax
mov    %rax,0x90(%rsp)
xorps  %xmm0,%xmm0
imul   $0x34,%rdx,%rax
mov    %rax,0x88(%rsp)
imul   $0x38,%rdx,%rax
mov    %rax,0x80(%rsp)
imul   $0x3c,%rdx,%rax
mov    %rax,0x78(%rsp)
mov    0x10(%rsp),%r10
lea    0x4004(%r10),%r11
lea    0xc(%r10),%rax
mov    %rax,0xe8(%rsp)
lea    0x100(%r14),%rcx
mov    0x28(%rsp),%rax
lea    0x4(%rax),%r8
mov    $0x40,%r12d
mov    %r15,0xe0(%rsp)
xor    %ebx,%ebx
jmp    1649 <rbcholu+0x4e9>
nopw   0x0(%rax,%rax,1)
movups 0x0(%rbp),%xmm1
mov    0xf8(%rsp),%rsi
movups %xmm1,(%r14,%rsi,4)
mov    0x28(%rsp),%rcx
mov    0x100(%rsp),%rdx
movups %xmm1,(%rcx,%rdx,4)
shl    $0x2,%rdx
mov    0xe0(%rsp),%rax
add    %rsi,%rax
movups 0x10(%rbp),%xmm1
movups %xmm1,(%r14,%rax,4)
mov    %rdx,%rax
or     $0x10,%rax
movups %xmm1,(%rcx,%rax,1)
lea    (%r9,%rsi,1),%rax
movups 0x20(%rbp),%xmm1
movups %xmm1,(%r14,%rax,4)
mov    %rdx,%rax
or     $0x20,%rax
movups %xmm1,(%rcx,%rax,1)
mov    0xd8(%rsp),%rax
add    %rsi,%rax
movups 0x30(%rbp),%xmm1
movups %xmm1,(%r14,%rax,4)
mov    %rdx,%rax
or     $0x30,%rax
movups %xmm1,(%rcx,%rax,1)
mov    0xd0(%rsp),%rax
add    %rsi,%rax
movups 0x40(%rbp),%xmm1
movups %xmm1,(%r14,%rax,4)
mov    %rdx,%rax
or     $0x40,%rax
movups %xmm1,(%rcx,%rax,1)
mov    0xc8(%rsp),%rax
add    %rsi,%rax
movups 0x50(%rbp),%xmm1
movups %xmm1,(%r14,%rax,4)
mov    %rdx,%rax
or     $0x50,%rax
movups %xmm1,(%rcx,%rax,1)
mov    0xc0(%rsp),%rax
add    %rsi,%rax
movups 0x60(%rbp),%xmm1
movups %xmm1,(%r14,%rax,4)
mov    %rdx,%rax
or     $0x60,%rax
movups %xmm1,(%rcx,%rax,1)
mov    0xb8(%rsp),%rax
add    %rsi,%rax
movups 0x70(%rbp),%xmm1
movups %xmm1,(%r14,%rax,4)
mov    %rdx,%rax
or     $0x70,%rax
movups %xmm1,(%rcx,%rax,1)
mov    0xb0(%rsp),%rax
add    %rsi,%rax
movups 0x80(%rbp),%xmm1
movups %xmm1,(%r14,%rax,4)
mov    %rdx,%rax
or     $0x80,%rax
movups %xmm1,(%rcx,%rax,1)
mov    0xa8(%rsp),%rax
add    %rsi,%rax
movups 0x90(%rbp),%xmm1
movups %xmm1,(%r14,%rax,4)
mov    %rdx,%rax
or     $0x90,%rax
movups %xmm1,(%rcx,%rax,1)
mov    0xa0(%rsp),%rax
add    %rsi,%rax
movups 0xa0(%rbp),%xmm1
movups %xmm1,(%r14,%rax,4)
mov    %rdx,%rax
or     $0xa0,%rax
movups %xmm1,(%rcx,%rax,1)
mov    0x98(%rsp),%rax
add    %rsi,%rax
movups 0xb0(%rbp),%xmm1
movups %xmm1,(%r14,%rax,4)
mov    %rdx,%rax
or     $0xb0,%rax
movups %xmm1,(%rcx,%rax,1)
mov    0x90(%rsp),%rax
add    %rsi,%rax
movups 0xc0(%rbp),%xmm1
movups %xmm1,(%r14,%rax,4)
mov    %rdx,%rax
or     $0xc0,%rax
movups %xmm1,(%rcx,%rax,1)
mov    0x88(%rsp),%rax
add    %rsi,%rax
movups 0xd0(%rbp),%xmm1
movups %xmm1,(%r14,%rax,4)
mov    %rdx,%rax
or     $0xd0,%rax
movups %xmm1,(%rcx,%rax,1)
mov    0x80(%rsp),%rax
add    %rsi,%rax
movups 0xe0(%rbp),%xmm1
movups %xmm1,(%r14,%rax,4)
mov    %rdx,%rax
or     $0xe0,%rax
movups %xmm1,(%rcx,%rax,1)
add    0x78(%rsp),%rsi
movups 0xf0(%rbp),%xmm1
movups %xmm1,(%r14,%rsi,4)
or     $0xf0,%rdx
movups %xmm1,(%rcx,%rdx,1)
mov    0x40(%rsp),%rcx
mov    0x50(%rsp),%r12d
mov    0x38(%rsp),%rbx
add    $0x1,%rbx
add    $0x1,%r12d
add    $0x100,%r11
add    $0x4,%rcx
add    $0x100,%r8
cmp    0x48(%rsp),%rbx
mov    0x10(%rsp),%r10
je     1b07 <rbcholu+0x9a7>
mov    %rcx,0x40(%rsp)
mov    %rbx,%rdi
shl    $0x6,%rdi
mov    %rbx,%rsi
shl    $0x8,%rsi
lea    (%rsi,%r10,1),%rcx
add    $0x4000,%rcx
lea    (%rsi,%r10,1),%rax
add    $0x4100,%rax
cmp    %rax,%r13
setb   %r15b
cmp    0xf0(%rsp),%rcx
setb   %dl
and    %r15b,%dl
or     0xf(%rsp),%dl
cmp    %rax,%rbp
setb   %al
cmp    0x68(%rsp),%rcx
setb   %cl
test   %dl,%dl
mov    %rdi,0x100(%rsp)
jne    1810 <rbcholu+0x6b0>
and    %cl,%al
jne    1810 <rbcholu+0x6b0>
movups 0x4000(%r10,%rdi,4),%xmm1
movups %xmm1,0x0(%r13)
movups %xmm0,0x0(%rbp)
movups 0x4010(%r10,%rdi,4),%xmm1
movups %xmm1,0x10(%r13)
movups %xmm0,0x10(%rbp)
movups 0x4020(%r10,%rdi,4),%xmm1
movups %xmm1,0x20(%r13)
movups %xmm0,0x20(%rbp)
movups 0x4030(%r10,%rdi,4),%xmm1
movups %xmm1,0x30(%r13)
movups %xmm0,0x30(%rbp)
movups 0x4040(%r10,%rdi,4),%xmm1
movups %xmm1,0x40(%r13)
movups %xmm0,0x40(%rbp)
movups 0x4050(%r10,%rdi,4),%xmm1
movups %xmm1,0x50(%r13)
movups %xmm0,0x50(%rbp)
movups 0x4060(%r10,%rdi,4),%xmm1
movups %xmm1,0x60(%r13)
movups %xmm0,0x60(%rbp)
movups 0x4070(%r10,%rdi,4),%xmm1
movups %xmm1,0x70(%r13)
movups %xmm0,0x70(%rbp)
movups 0x4080(%r10,%rdi,4),%xmm1
movups %xmm1,0x80(%r13)
movups %xmm0,0x80(%rbp)
movups 0x4090(%r10,%rdi,4),%xmm1
movups %xmm1,0x90(%r13)
movups %xmm0,0x90(%rbp)
movups 0x40a0(%r10,%rdi,4),%xmm1
movups %xmm1,0xa0(%r13)
movups %xmm0,0xa0(%rbp)
movups 0x40b0(%r10,%rdi,4),%xmm1
movups %xmm1,0xb0(%r13)
movups %xmm0,0xb0(%rbp)
movups 0x40c0(%r10,%rdi,4),%xmm1
movups %xmm1,0xc0(%r13)
movups %xmm0,0xc0(%rbp)
movups 0x40d0(%r10,%rdi,4),%xmm1
movups %xmm1,0xd0(%r13)
movups %xmm0,0xd0(%rbp)
movups 0x40e0(%r10,%rdi,4),%xmm1
movups %xmm1,0xe0(%r13)
movups %xmm0,0xe0(%rbp)
movups 0x40f0(%r10,%rdi,4),%xmm1
movups %xmm1,0xf0(%r13)
movups %xmm0,0xf0(%rbp)
jmp    1855 <rbcholu+0x6f5>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  -0x4(%r11,%rax,4),%xmm1
movss  %xmm1,0x0(%r13,%rax,4)
movl   $0x0,0x0(%rbp,%rax,4)
movss  (%r11,%rax,4),%xmm1
movss  %xmm1,0x4(%r13,%rax,4)
movl   $0x0,0x4(%rbp,%rax,4)
add    $0x2,%rax
cmp    $0x40,%rax
jne    1820 <rbcholu+0x6c0>
lea    (%r14,%rbx,4),%rax
add    $0x100,%rax
mov    %rax,0x108(%rsp)
mov    %rbx,0x38(%rsp)
lea    0x200(%r14,%rbx,4),%rax
mov    %rax,0x110(%rsp)
mov    0x28(%rsp),%rax
lea    (%rax,%rsi,1),%rcx
mov    %rcx,0x118(%rsp)
lea    0x100(%rax,%rsi,1),%rax
mov    %rax,0x120(%rsp)
mov    %r12d,0x50(%rsp)
movslq %r12d,%rax
mov    %rax,0xf8(%rsp)
mov    %r10,%r12
mov    0xe8(%rsp),%r15
xor    %ebx,%ebx
mov    0x20(%rsp),%rsi
jmp    1911 <rbcholu+0x7b1>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xorps  %xmm1,%xmm1
movss  0x0(%r13,%rbx,4),%xmm2
subss  %xmm1,%xmm2
mov    %rbx,%rax
shl    $0x8,%rax
lea    (%rax,%rbx,4),%rax
divss  (%r10,%rax,1),%xmm2
movss  %xmm2,0x0(%rbp,%rbx,4)
add    $0x1,%rbx
add    $0x100,%r15
add    $0x100,%r12
cmp    $0x40,%rbx
je     19d0 <rbcholu+0x870>
test   %rbx,%rbx
je     18d0 <rbcholu+0x770>
lea    -0x1(%rbx),%rax
cmp    $0x3,%rax
jae    1930 <rbcholu+0x7d0>
xorps  %xmm1,%xmm1
xor    %edi,%edi
jmp    198c <rbcholu+0x82c>
nopw   0x0(%rax,%rax,1)
mov    %rbx,%r10
and    $0xfffffffffffffffc,%r10
xorps  %xmm1,%xmm1
xor    %edi,%edi
nopl   0x0(%rax)
movss  -0xc(%r15,%rdi,4),%xmm2
movss  -0x8(%r15,%rdi,4),%xmm3
mulss  0x0(%rbp,%rdi,4),%xmm2
mulss  0x4(%rbp,%rdi,4),%xmm3
addss  %xmm1,%xmm2
movss  -0x4(%r15,%rdi,4),%xmm4
mulss  0x8(%rbp,%rdi,4),%xmm4
addss  %xmm2,%xmm3
movss  (%r15,%rdi,4),%xmm1
mulss  0xc(%rbp,%rdi,4),%xmm1
addss  %xmm3,%xmm4
addss  %xmm4,%xmm1
add    $0x4,%rdi
cmp    %rdi,%r10
jne    1940 <rbcholu+0x7e0>
test   $0x3,%bl
mov    0x10(%rsp),%r10
je     18d3 <rbcholu+0x773>
mov    %ebx,%edx
and    $0x3,%edx
lea    0x0(,%rdi,4),%rcx
add    %rbp,%rcx
lea    (%r12,%rdi,4),%rdi
xor    %eax,%eax
movss  (%rdi,%rax,4),%xmm2
mulss  (%rcx,%rax,4),%xmm2
addss  %xmm2,%xmm1
add    $0x1,%rax
cmp    %rax,%rdx
jne    19b0 <rbcholu+0x850>
jmp    18d3 <rbcholu+0x773>
nopl   0x0(%rax)
cmpl   $0x1,0x30(%rsp)
jne    1a40 <rbcholu+0x8e0>
mov    0x120(%rsp),%rdi
mov    0x108(%rsp),%rcx
cmp    %rdi,%rcx
setb   %r15b
mov    0x118(%rsp),%rdx
mov    0x110(%rsp),%rbx
cmp    %rbx,%rdx
setb   %r12b
mov    0x68(%rsp),%rax
cmp    %rax,%rcx
setb   %cl
cmp    %rbx,%rbp
setb   %r10b
cmp    %rax,%rdx
setb   %al
cmp    %rdi,%rbp
setb   %dil
test   %r12b,%r15b
jne    1a40 <rbcholu+0x8e0>
and    %r10b,%cl
jne    1a40 <rbcholu+0x8e0>
and    %dil,%al
je     1400 <rbcholu+0x2a0>
nopw   0x0(%rax,%rax,1)
xor    %eax,%eax
mov    0x40(%rsp),%rcx
mov    %rcx,%rdx
mov    0x50(%rsp),%r12d
mov    0x38(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  0x0(%rbp,%rax,1),%xmm1
movss  %xmm1,(%rdx)
movss  0x0(%rbp,%rax,1),%xmm1
movss  %xmm1,-0x4(%r8,%rax,1)
movss  0x4(%rbp,%rax,1),%xmm1
movss  %xmm1,(%rdx,%rsi,4)
movss  0x4(%rbp,%rax,1),%xmm1
movss  %xmm1,(%r8,%rax,1)
add    %r9,%rdx
add    $0x8,%rax
cmp    $0x100,%rax
jne    1a60 <rbcholu+0x900>
jmp    161f <rbcholu+0x4bf>
mov    0x28(%rsp),%r12
mov    %r12,%rdi
mov    0x1c(%rsp),%ebx
mov    %ebx,%esi
mov    $0x40,%edx
mov    0x58(%rsp),%r15
mov    %r15,%rcx
call   1050 <mtranspose@plt>
mov    %r12,%rdi
mov    %r15,%rsi
mov    0x10(%rsp),%rdx
mov    %ebx,%ecx
mov    $0x40,%r8d
mov    %ebx,%r9d
call   1040 <mmult@plt>
mov    %r12,%rdi
call   1030 <free@plt>
mov    %r15,%rdi
call   1030 <free@plt>
mov    %r13,%rdi
call   1030 <free@plt>
mov    %rbp,%rdi
call   1030 <free@plt>
mov    0x30(%rsp),%rdx
jmp    1db3 <rbcholu+0xc53>
mov    0x28(%rsp),%r15
mov    %r15,%rdi
mov    0x1c(%rsp),%ebx
mov    %ebx,%esi
mov    $0x40,%edx
mov    0x58(%rsp),%r12
mov    %r12,%rcx
call   1050 <mtranspose@plt>
mov    %r15,%rdi
mov    %r12,%rsi
mov    0x10(%rsp),%rdx
mov    %ebx,%ecx
mov    $0x40,%r8d
mov    %ebx,%r9d
call   1040 <mmult@plt>
mov    %r15,%rdi
call   1030 <free@plt>
mov    %r12,%rdi
call   1030 <free@plt>
mov    %r13,%rdi
call   1030 <free@plt>
mov    %rbp,%rdi
call   1030 <free@plt>
cmpl   $0x41,0x60(%rsp)
mov    0x30(%rsp),%rdx
mov    0x48(%rsp),%rsi
jl     1db3 <rbcholu+0xc53>
mov    %edx,%r15d
shl    $0x6,%r15d
lea    0x40(%r15),%r11d
lea    0x1(%rdx),%eax
mov    %rax,0x20(%rsp)
lea    0x4(,%rsi,4),%rax
mov    %rax,0x40(%rsp)
mov    %rsi,%rax
neg    %rax
mov    %rax,0x50(%rsp)
mov    0x10(%rsp),%rax
lea    0x10(%rax),%rbp
add    $0x41,%r15d
mov    $0x1,%r13d
xor    %ecx,%ecx
mov    %r11d,%r10d
mov    %r11,0x38(%rsp)
mov    %rsi,%r12
jmp    1bfc <rbcholu+0xa9c>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rcx
add    $0xffffffffffffffff,%r12
add    0x20(%rsp),%r11
add    0x40(%rsp),%rbp
mov    %rdx,%rsi
mov    0x30(%rsp),%rdx
add    %edx,%r10d
add    %rsi,%r13
add    %edx,%r15d
cmp    %rsi,%rcx
je     1db3 <rbcholu+0xc53>
mov    %rsi,%r9
sub    %rcx,%r9
mov    %rcx,%rdi
cmp    $0x8,%r9
mov    %rsi,%rdx
jae    1cd0 <rbcholu+0xb70>
mov    %edx,%eax
sub    %edi,%eax
mov    %rdi,%rbx
test   $0x1,%al
je     1c56 <rbcholu+0xaf6>
mov    %rcx,%rax
imul   %rdx,%rax
lea    0x40(%rcx),%esi
imul   0x30(%rsp),%esi
add    %rdi,%rax
add    %edi,%esi
add    $0x40,%esi
movslq %esi,%rsi
movss  (%r14,%rsi,4),%xmm0
mov    0x10(%rsp),%rdx
subss  (%rdx,%rax,4),%xmm0
mov    0x48(%rsp),%rdx
movss  %xmm0,(%r14,%rsi,4)
lea    0x1(%rdi),%rbx
not    %rdi
cmp    0x50(%rsp),%rdi
je     1bd0 <rbcholu+0xa70>
mov    %rdx,%rax
sub    %rbx,%rax
lea    (%r10,%rbx,1),%edi
mov    %rbx,%rsi
add    %r13,%rsi
mov    0x10(%rsp),%rdx
lea    (%rdx,%rsi,4),%r8
mov    0x48(%rsp),%rdx
lea    (%r15,%rbx,1),%r9d
cs nopw 0x0(%rax,%rax,1)
movslq %edi,%rdi
movss  (%r14,%rdi,4),%xmm0
subss  -0x4(%r8),%xmm0
movss  %xmm0,(%r14,%rdi,4)
movslq %r9d,%r9
movss  (%r14,%r9,4),%xmm0
subss  (%r8),%xmm0
movss  %xmm0,(%r14,%r9,4)
add    $0x2,%edi
add    $0x8,%r8
add    $0x2,%r9d
add    $0xfffffffffffffffe,%rax
jne    1c90 <rbcholu+0xb30>
jmp    1bd0 <rbcholu+0xa70>
nop
mov    %rcx,%rsi
not    %rsi
add    %rdx,%rsi
mov    0x20(%rsp),%rbx
imul   %ecx,%ebx
add    0x38(%rsp),%ebx
lea    (%rsi,%rbx,1),%r8d
mov    %rcx,%rdi
cmp    %ebx,%r8d
jl     1c12 <rbcholu+0xab2>
shr    $0x20,%rsi
mov    %rcx,%rdi
jne    1c12 <rbcholu+0xab2>
mov    0x40(%rsp),%rdi
imul   %rcx,%rdi
add    0x10(%rsp),%rdi
mov    0x20(%rsp),%rax
mov    %eax,%esi
imul   %ecx,%esi
add    0x38(%rsp),%esi
movslq %esi,%rsi
lea    (%r14,%r9,4),%rbx
lea    (%rbx,%rsi,4),%rbx
cmp    %rbx,%rdi
jae    1d51 <rbcholu+0xbf1>
mov    %rcx,%rdi
imul   %rdx,%rdi
add    %rdx,%rdi
mov    0x10(%rsp),%rax
lea    (%rax,%rdi,4),%rbx
lea    (%r14,%rsi,4),%rsi
mov    %rcx,%rdi
cmp    %rbx,%rsi
jb     1c12 <rbcholu+0xab2>
mov    %r12,%rbx
and    $0xfffffffffffffff8,%rbx
mov    %r9,%r8
and    $0xfffffffffffffff8,%r8
lea    (%rcx,%r8,1),%rdi
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nop
movups -0x10(%rbp,%rsi,4),%xmm0
movups 0x0(%rbp,%rsi,4),%xmm1
lea    (%r11,%rsi,1),%eax
cltq
movups (%r14,%rax,4),%xmm2
subps  %xmm0,%xmm2
movups 0x10(%r14,%rax,4),%xmm0
subps  %xmm1,%xmm0
movups %xmm2,(%r14,%rax,4)
movups %xmm0,0x10(%r14,%rax,4)
add    $0x8,%rsi
cmp    %rsi,%rbx
jne    1d70 <rbcholu+0xc10>
cmp    %r8,%r9
je     1bd0 <rbcholu+0xa70>
jmp    1c12 <rbcholu+0xab2>
mov    %edx,%eax
shl    $0x6,%eax
cltq
lea    (%r14,%rax,4),%rdi
add    $0x100,%rdi
mov    0x1c(%rsp),%esi
mov    0x70(%rsp),%rcx
mov    0x10(%rsp),%r8
call   1070 <rbcholu@plt>
cmp    $0xffffffff,%eax
jne    1de2 <rbcholu+0xc82>
mov    $0xffffffff,%eax
add    $0x128,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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