#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(double *);
scalar_t__ malloc(int);
int /*<<< orphan*/ mmult(double *, double *, double *, int, int, int);
int /*<<< orphan*/ mtranspose(double *, int, int, double *);
int rcholu(double *, int, int, double *);
int rbcholu(double *A, int N, int stride, double *UB, double *UT) {
  int bs, bb, i, j, Nb, t, k, u, v, w, sc;
  double *b, *x, *U12, *U12T;
  double sum;
  bs = (int)32;
  bb = bs * bs;
  if (N <= 32) {
    sc = rcholu(A, N, stride, UB);
    if (sc == -1) {
      return -1;
    }
  } else {
    Nb = N - bs;
    x = (double *)malloc(sizeof(double) * bs);
    b = (double *)malloc(sizeof(double) * bs);
    U12T = (double *)malloc(sizeof(double) * Nb * bs);
    U12 = (double *)malloc(sizeof(double) * 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   $0x20,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
imul   -0x2c(%rbp),%eax
mov    %eax,-0x30(%rbp)
cmpl   $0x20,-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    $0x3,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x68(%rbp)
movslq -0x2c(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x60(%rbp)
movslq -0x3c(%rbp),%rax
shl    $0x3,%rax
movslq -0x2c(%rbp),%rcx
imul   %rcx,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x78(%rbp)
movslq -0x3c(%rbp),%rax
shl    $0x3,%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
movsd  (%rax,%rcx,8),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
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
movsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%rax
movslq -0x34(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
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
movsd  %xmm0,-0x80(%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
movsd  (%rax,%rcx,8),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x38(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x80(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1362 <rbcholu+0x202>
mov    -0x60(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  -0x80(%rbp),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x40(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
divsd  (%rax,%rcx,8),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
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
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x68(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x78(%rbp),%rax
mov    -0x48(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
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
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
subsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
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    $0x3,%rax
add    %rax,%rdi
movslq -0x2c(%rbp),%rax
shl    $0x3,%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    $0x118,%rsp
mov    %edx,%ebx
mov    %rdi,%r14
cmp    $0x20,%esi
jg     1193 <rbcholu+0x33>
mov    %r14,%rdi
mov    %ebx,%edx
call   1080 <rcholu@plt>
cmp    $0xffffffff,%eax
jne    1dfa <rbcholu+0xc9a>
jmp    1df5 <rbcholu+0xc95>
lea    -0x20(%rsi),%r15d
mov    $0x100,%edi
mov    %r8,0x8(%rsp)
mov    %rsi,0x58(%rsp)
mov    %rcx,%r12
call   1060 <malloc@plt>
mov    %rax,%rbp
mov    $0x100,%edi
call   1060 <malloc@plt>
mov    %rax,%r13
mov    %r15d,0x14(%rsp)
shl    $0x8,%r15d
mov    %r15d,%edi
call   1060 <malloc@plt>
mov    %rax,0x20(%rsp)
mov    %r15d,%edi
call   1060 <malloc@plt>
mov    %rax,0x50(%rsp)
mov    %r14,%rdi
mov    $0x20,%esi
mov    %ebx,%edx
mov    %r12,0x68(%rsp)
mov    %r12,%rcx
call   1080 <rcholu@plt>
mov    0x58(%rsp),%r11
mov    %rbx,0x30(%rsp)
movslq %ebx,%r10
mov    %r11d,%r8d
mov    %r8d,%ecx
and    $0xfffffffe,%ecx
lea    0x8(%r14),%rdx
lea    0x0(,%r10,8),%r15
xor    %r9d,%r9d
mov    0x8(%rsp),%rdi
jmp    1245 <rbcholu+0xe5>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r9
add    $0x8,%rdi
add    %r15,%rdx
cmp    $0x20,%r9
je     12c2 <rbcholu+0x162>
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    $0x20,%eax
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
movsd  -0x8(%rdx,%rbx,8),%xmm0
movsd  %xmm0,-0x100(%rdi,%rax,8)
ff ff
movsd  (%rdx,%rbx,8),%xmm0
movsd  %xmm0,(%rdi,%rax,8)
add    $0x2,%rbx
add    $0x40,%rax
cmp    %rbx,%rcx
jne    1270 <rbcholu+0x110>
add    $0xffffffffffffffe0,%rax
test   $0x1,%r8b
je     1230 <rbcholu+0xd0>
mov    %r9,%rsi
imul   %r10,%rsi
add    %rsi,%rbx
movsd  (%r14,%rbx,8),%xmm0
add    %r9,%rax
mov    0x8(%rsp),%rsi
movsd  %xmm0,(%rsi,%rax,8)
jmp    1230 <rbcholu+0xd0>
cmp    $0x21,%r11d
jl     1ab2 <rbcholu+0x952>
mov    0x14(%rsp),%eax
mov    %rax,0x40(%rsp)
lea    0x100(%rbp),%rax
lea    0x100(%r13),%rcx
mov    %rax,0x60(%rsp)
cmp    %rax,%r13
setb   %al
mov    %rcx,0xe8(%rsp)
cmp    %rcx,%rbp
setb   %cl
and    %al,%cl
mov    %cl,0x7(%rsp)
lea    (%r10,%r10,1),%rcx
lea    0x0(,%r10,4),%rdx
lea    (%rcx,%rcx,2),%rax
mov    %rax,0xc0(%rsp)
lea    (%rcx,%rcx,4),%rax
mov    %rax,0xb8(%rsp)
lea    (%rdx,%rdx,2),%rax
mov    %rax,0xb0(%rsp)
mov    %r10,%r11
shl    $0x4,%r11
mov    %r11,%rax
sub    %r10,%rax
sub    %r10,%rax
mov    %rax,0xa8(%rsp)
lea    (%r10,%r10,4),%rax
lea    (%r10,%rax,4),%rsi
add    %r10,%rsi
mov    %rsi,0xa0(%rsp)
lea    (%rax,%rax,4),%rax
add    %r10,%rax
mov    %rax,0x98(%rsp)
lea    (%r10,%r10,8),%rax
lea    (%rax,%rax,2),%rax
add    %r10,%rax
mov    %rax,0x90(%rsp)
mov    %r10,%rax
shl    $0x5,%rax
sub    %r10,%rax
sub    %r10,%rax
mov    %rax,0x88(%rsp)
xorpd  %xmm0,%xmm0
mov    %rcx,0xd0(%rsp)
lea    (%rcx,%rcx,8),%rax
mov    %rax,0x80(%rsp)
mov    %rdx,0xc8(%rsp)
lea    (%rdx,%rdx,4),%rax
mov    %rax,0x78(%rsp)
lea    (%r15,%r15,2),%rax
mov    %rax,0x70(%rsp)
mov    0x8(%rsp),%r9
lea    0x2008(%r9),%r8
lea    0x18(%r9),%rax
mov    %rax,0xe0(%rsp)
lea    0x100(%r14),%rcx
mov    0x20(%rsp),%rax
lea    0x8(%rax),%rsi
mov    $0x20,%r12d
mov    %r15,0xd8(%rsp)
xor    %ebx,%ebx
jmp    1656 <rbcholu+0x4f6>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups 0x0(%rbp),%xmm1
mov    0xf0(%rsp),%rdi
movups %xmm1,(%r14,%rdi,8)
mov    0x20(%rsp),%rcx
mov    0x28(%rsp),%rdx
movups %xmm1,(%rcx,%rdx,8)
shl    $0x3,%rdx
mov    0xd0(%rsp),%rax
add    %rdi,%rax
movups 0x10(%rbp),%xmm1
movups %xmm1,(%r14,%rax,8)
mov    %rdx,%rax
or     $0x10,%rax
movups %xmm1,(%rcx,%rax,1)
mov    0xc8(%rsp),%rax
add    %rdi,%rax
movups 0x20(%rbp),%xmm1
movups %xmm1,(%r14,%rax,8)
mov    %rdx,%rax
or     $0x20,%rax
movups %xmm1,(%rcx,%rax,1)
mov    0xc0(%rsp),%rax
add    %rdi,%rax
movups 0x30(%rbp),%xmm1
movups %xmm1,(%r14,%rax,8)
mov    %rdx,%rax
or     $0x30,%rax
movups %xmm1,(%rcx,%rax,1)
mov    0xd8(%rsp),%rax
add    %rdi,%rax
movups 0x40(%rbp),%xmm1
movups %xmm1,(%r14,%rax,8)
mov    %rdx,%rax
or     $0x40,%rax
movups %xmm1,(%rcx,%rax,1)
mov    0xb8(%rsp),%rax
add    %rdi,%rax
movups 0x50(%rbp),%xmm1
movups %xmm1,(%r14,%rax,8)
mov    %rdx,%rax
or     $0x50,%rax
movups %xmm1,(%rcx,%rax,1)
mov    0xb0(%rsp),%rax
add    %rdi,%rax
movups 0x60(%rbp),%xmm1
movups %xmm1,(%r14,%rax,8)
mov    %rdx,%rax
or     $0x60,%rax
movups %xmm1,(%rcx,%rax,1)
mov    0xa8(%rsp),%rax
add    %rdi,%rax
movups 0x70(%rbp),%xmm1
movups %xmm1,(%r14,%rax,8)
mov    %rdx,%rax
or     $0x70,%rax
movups %xmm1,(%rcx,%rax,1)
lea    (%r11,%rdi,1),%rax
movups 0x80(%rbp),%xmm1
movups %xmm1,(%r14,%rax,8)
mov    %rdx,%rax
or     $0x80,%rax
movups %xmm1,(%rcx,%rax,1)
mov    0x80(%rsp),%rax
add    %rdi,%rax
movups 0x90(%rbp),%xmm1
movups %xmm1,(%r14,%rax,8)
mov    %rdx,%rax
or     $0x90,%rax
movups %xmm1,(%rcx,%rax,1)
mov    0x78(%rsp),%rax
add    %rdi,%rax
movups 0xa0(%rbp),%xmm1
movups %xmm1,(%r14,%rax,8)
mov    %rdx,%rax
or     $0xa0,%rax
movups %xmm1,(%rcx,%rax,1)
mov    0xa0(%rsp),%rax
add    %rdi,%rax
movups 0xb0(%rbp),%xmm1
movups %xmm1,(%r14,%rax,8)
mov    %rdx,%rax
or     $0xb0,%rax
movups %xmm1,(%rcx,%rax,1)
mov    0x70(%rsp),%rax
add    %rdi,%rax
movups 0xc0(%rbp),%xmm1
movups %xmm1,(%r14,%rax,8)
mov    %rdx,%rax
or     $0xc0,%rax
movups %xmm1,(%rcx,%rax,1)
mov    0x98(%rsp),%rax
add    %rdi,%rax
movups 0xd0(%rbp),%xmm1
movups %xmm1,(%r14,%rax,8)
mov    %rdx,%rax
or     $0xd0,%rax
movups %xmm1,(%rcx,%rax,1)
mov    0x90(%rsp),%rax
add    %rdi,%rax
movups 0xe0(%rbp),%xmm1
movups %xmm1,(%r14,%rax,8)
mov    %rdx,%rax
or     $0xe0,%rax
movups %xmm1,(%rcx,%rax,1)
add    0x88(%rsp),%rdi
movupd 0xf0(%rbp),%xmm1
movupd %xmm1,(%r14,%rdi,8)
or     $0xf0,%rdx
movupd %xmm1,(%rcx,%rdx,1)
mov    0x18(%rsp),%rcx
mov    0x38(%rsp),%r12d
mov    0x48(%rsp),%rbx
add    $0x1,%rbx
add    $0x1,%r12d
add    $0x100,%r8
add    $0x8,%rcx
add    $0x100,%rsi
cmp    0x40(%rsp),%rbx
mov    0x8(%rsp),%r9
je     1b17 <rbcholu+0x9b7>
mov    %rcx,0x18(%rsp)
mov    %rbx,%rax
shl    $0x5,%rax
mov    %rax,0x28(%rsp)
mov    %rbx,%rdi
shl    $0x8,%rdi
lea    (%rdi,%r9,1),%rcx
add    $0x2000,%rcx
lea    (%rdi,%r9,1),%rax
add    $0x2100,%rax
cmp    %rax,%r13
setb   %r15b
cmp    0xe8(%rsp),%rcx
setb   %dl
and    %r15b,%dl
or     0x7(%rsp),%dl
cmp    %rax,%rbp
setb   %al
cmp    0x60(%rsp),%rcx
setb   %cl
test   %dl,%dl
jne    1830 <rbcholu+0x6d0>
and    %cl,%al
jne    1830 <rbcholu+0x6d0>
mov    0x28(%rsp),%rax
movups 0x2000(%r9,%rax,8),%xmm1
movups %xmm1,0x0(%r13)
movupd %xmm0,0x0(%rbp)
movups 0x2010(%r9,%rax,8),%xmm1
movups %xmm1,0x10(%r13)
movupd %xmm0,0x10(%rbp)
movups 0x2020(%r9,%rax,8),%xmm1
movups %xmm1,0x20(%r13)
movupd %xmm0,0x20(%rbp)
movups 0x2030(%r9,%rax,8),%xmm1
movups %xmm1,0x30(%r13)
movupd %xmm0,0x30(%rbp)
movups 0x2040(%r9,%rax,8),%xmm1
movups %xmm1,0x40(%r13)
movupd %xmm0,0x40(%rbp)
movups 0x2050(%r9,%rax,8),%xmm1
movups %xmm1,0x50(%r13)
movupd %xmm0,0x50(%rbp)
movups 0x2060(%r9,%rax,8),%xmm1
movups %xmm1,0x60(%r13)
movupd %xmm0,0x60(%rbp)
movups 0x2070(%r9,%rax,8),%xmm1
movups %xmm1,0x70(%r13)
movupd %xmm0,0x70(%rbp)
movups 0x2080(%r9,%rax,8),%xmm1
movups %xmm1,0x80(%r13)
movupd %xmm0,0x80(%rbp)
movups 0x2090(%r9,%rax,8),%xmm1
movups %xmm1,0x90(%r13)
movupd %xmm0,0x90(%rbp)
movups 0x20a0(%r9,%rax,8),%xmm1
movups %xmm1,0xa0(%r13)
movupd %xmm0,0xa0(%rbp)
movups 0x20b0(%r9,%rax,8),%xmm1
movups %xmm1,0xb0(%r13)
movupd %xmm0,0xb0(%rbp)
movups 0x20c0(%r9,%rax,8),%xmm1
movups %xmm1,0xc0(%r13)
movupd %xmm0,0xc0(%rbp)
movups 0x20d0(%r9,%rax,8),%xmm1
movups %xmm1,0xd0(%r13)
movupd %xmm0,0xd0(%rbp)
movups 0x20e0(%r9,%rax,8),%xmm1
movups %xmm1,0xe0(%r13)
movupd %xmm0,0xe0(%rbp)
movupd 0x20f0(%r9,%rax,8),%xmm1
movupd %xmm1,0xf0(%r13)
movupd %xmm0,0xf0(%rbp)
jmp    1877 <rbcholu+0x717>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  -0x8(%r8,%rax,8),%xmm1
movsd  %xmm1,0x0(%r13,%rax,8)
movq   $0x0,0x0(%rbp,%rax,8)
movsd  (%r8,%rax,8),%xmm1
movsd  %xmm1,0x8(%r13,%rax,8)
movq   $0x0,0x8(%rbp,%rax,8)
add    $0x2,%rax
cmp    $0x20,%rax
jne    1840 <rbcholu+0x6e0>
lea    (%r14,%rbx,8),%rax
add    $0x100,%rax
mov    %rax,0xf8(%rsp)
mov    %rbx,0x48(%rsp)
lea    0x200(%r14,%rbx,8),%rax
mov    %rax,0x100(%rsp)
mov    0x20(%rsp),%rax
lea    (%rax,%rdi,1),%rcx
mov    %rcx,0x108(%rsp)
lea    0x100(%rax,%rdi,1),%rax
mov    %rax,0x110(%rsp)
mov    %r12d,0x38(%rsp)
movslq %r12d,%rax
mov    %rax,0xf0(%rsp)
mov    %r9,%r12
mov    0xe0(%rsp),%r15
xor    %ebx,%ebx
jmp    1922 <rbcholu+0x7c2>
xchg   %ax,%ax
xorpd  %xmm1,%xmm1
movsd  0x0(%r13,%rbx,8),%xmm2
subsd  %xmm1,%xmm2
mov    %rbx,%rax
shl    $0x8,%rax
lea    (%rax,%rbx,8),%rax
divsd  (%r9,%rax,1),%xmm2
movsd  %xmm2,0x0(%rbp,%rbx,8)
add    $0x1,%rbx
add    $0x100,%r15
add    $0x100,%r12
cmp    $0x20,%rbx
je     19e0 <rbcholu+0x880>
test   %rbx,%rbx
je     18e0 <rbcholu+0x780>
lea    -0x1(%rbx),%rax
cmp    $0x3,%rax
jae    1940 <rbcholu+0x7e0>
xorpd  %xmm1,%xmm1
xor    %edi,%edi
jmp    199c <rbcholu+0x83c>
nopl   0x0(%rax)
mov    %rbx,%r9
and    $0xfffffffffffffffc,%r9
xorpd  %xmm1,%xmm1
xor    %edi,%edi
nopl   (%rax)
movsd  -0x18(%r15,%rdi,8),%xmm2
movsd  -0x10(%r15,%rdi,8),%xmm3
mulsd  0x0(%rbp,%rdi,8),%xmm2
mulsd  0x8(%rbp,%rdi,8),%xmm3
addsd  %xmm1,%xmm2
movsd  -0x8(%r15,%rdi,8),%xmm4
mulsd  0x10(%rbp,%rdi,8),%xmm4
addsd  %xmm2,%xmm3
movsd  (%r15,%rdi,8),%xmm1
mulsd  0x18(%rbp,%rdi,8),%xmm1
addsd  %xmm3,%xmm4
addsd  %xmm4,%xmm1
add    $0x4,%rdi
cmp    %rdi,%r9
jne    1950 <rbcholu+0x7f0>
test   $0x3,%bl
mov    0x8(%rsp),%r9
je     18e4 <rbcholu+0x784>
mov    %ebx,%edx
and    $0x3,%edx
lea    0x0(,%rdi,8),%rcx
add    %rbp,%rcx
lea    (%r12,%rdi,8),%rdi
xor    %eax,%eax
movsd  (%rdi,%rax,8),%xmm2
mulsd  (%rcx,%rax,8),%xmm2
addsd  %xmm2,%xmm1
add    $0x1,%rax
cmp    %rax,%rdx
jne    19c0 <rbcholu+0x860>
jmp    18e4 <rbcholu+0x784>
nopl   0x0(%rax)
cmpl   $0x1,0x30(%rsp)
jne    1a50 <rbcholu+0x8f0>
mov    0x110(%rsp),%rdi
mov    0xf8(%rsp),%rcx
cmp    %rdi,%rcx
setb   %r15b
mov    0x108(%rsp),%rdx
mov    0x100(%rsp),%rbx
cmp    %rbx,%rdx
setb   %r12b
mov    0x60(%rsp),%rax
cmp    %rax,%rcx
setb   %cl
cmp    %rbx,%rbp
setb   %r9b
cmp    %rax,%rdx
setb   %al
cmp    %rdi,%rbp
setb   %dil
test   %r12b,%r15b
jne    1a50 <rbcholu+0x8f0>
and    %r9b,%cl
jne    1a50 <rbcholu+0x8f0>
and    %dil,%al
je     1410 <rbcholu+0x2b0>
nopw   0x0(%rax,%rax,1)
xor    %edx,%edx
mov    0x18(%rsp),%rcx
mov    %rcx,%rdi
mov    0x38(%rsp),%r12d
mov    0x48(%rsp),%rbx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  0x0(%rbp,%rdx,1),%xmm1
movsd  %xmm1,(%rdi)
movsd  0x0(%rbp,%rdx,1),%xmm1
movsd  %xmm1,-0x8(%rsi,%rdx,1)
movsd  0x8(%rbp,%rdx,1),%xmm1
movsd  %xmm1,(%rdi,%r10,8)
movsd  0x8(%rbp,%rdx,1),%xmm1
movsd  %xmm1,(%rsi,%rdx,1)
add    %r11,%rdi
add    $0x10,%rdx
cmp    $0x100,%rdx
jne    1a70 <rbcholu+0x910>
jmp    162c <rbcholu+0x4cc>
mov    0x20(%rsp),%r12
mov    %r12,%rdi
mov    0x14(%rsp),%ebx
mov    %ebx,%esi
mov    $0x20,%edx
mov    0x50(%rsp),%r15
mov    %r15,%rcx
call   1050 <mtranspose@plt>
mov    %r12,%rdi
mov    %r15,%rsi
mov    0x8(%rsp),%rdx
mov    %ebx,%ecx
mov    $0x20,%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    1dcb <rbcholu+0xc6b>
mov    0x20(%rsp),%r15
mov    %r15,%rdi
mov    0x14(%rsp),%ebx
mov    %ebx,%esi
mov    $0x20,%edx
mov    0x50(%rsp),%r12
mov    %r12,%rcx
call   1050 <mtranspose@plt>
mov    %r15,%rdi
mov    %r12,%rsi
mov    0x8(%rsp),%rdx
mov    %ebx,%ecx
mov    $0x20,%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   $0x21,0x58(%rsp)
mov    0x30(%rsp),%rdx
mov    0x40(%rsp),%rsi
jl     1dcb <rbcholu+0xc6b>
mov    %edx,%r15d
shl    $0x5,%r15d
lea    0x20(%r15),%r11d
lea    0x1(%rdx),%eax
mov    %rax,0x18(%rsp)
lea    0x8(,%rsi,8),%rax
mov    %rax,0x38(%rsp)
mov    %rsi,%rax
neg    %rax
mov    %rax,0x48(%rsp)
mov    0x8(%rsp),%rax
lea    0x10(%rax),%rbp
add    $0x21,%r15d
mov    $0x1,%r13d
xor    %ecx,%ecx
mov    %r11d,%r10d
mov    %r11,0x28(%rsp)
mov    %rsi,%r12
jmp    1c0c <rbcholu+0xaac>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rcx
add    $0xffffffffffffffff,%r12
add    0x18(%rsp),%r11
add    0x38(%rsp),%rbp
mov    %rdx,%rsi
mov    0x30(%rsp),%rdx
add    %edx,%r10d
add    %rsi,%r13
add    %edx,%r15d
cmp    %rsi,%rcx
je     1dcb <rbcholu+0xc6b>
mov    %rsi,%r9
sub    %rcx,%r9
mov    %rcx,%rdi
cmp    $0x4,%r9
mov    %rsi,%rdx
jae    1ce0 <rbcholu+0xb80>
mov    %edx,%eax
sub    %edi,%eax
mov    %rdi,%rbx
test   $0x1,%al
je     1c66 <rbcholu+0xb06>
mov    %rcx,%rax
imul   %rdx,%rax
lea    0x20(%rcx),%esi
imul   0x30(%rsp),%esi
add    %rdi,%rax
add    %edi,%esi
add    $0x20,%esi
movslq %esi,%rsi
movsd  (%r14,%rsi,8),%xmm0
mov    0x8(%rsp),%rdx
subsd  (%rdx,%rax,8),%xmm0
mov    0x40(%rsp),%rdx
movsd  %xmm0,(%r14,%rsi,8)
lea    0x1(%rdi),%rbx
not    %rdi
cmp    0x48(%rsp),%rdi
je     1be0 <rbcholu+0xa80>
mov    %rdx,%rax
sub    %rbx,%rax
lea    (%r10,%rbx,1),%edi
mov    %rbx,%rsi
add    %r13,%rsi
mov    0x8(%rsp),%rdx
lea    (%rdx,%rsi,8),%r8
mov    0x40(%rsp),%rdx
lea    (%r15,%rbx,1),%r9d
cs nopw 0x0(%rax,%rax,1)
movslq %edi,%rdi
movsd  (%r14,%rdi,8),%xmm0
subsd  -0x8(%r8),%xmm0
movsd  %xmm0,(%r14,%rdi,8)
movslq %r9d,%r9
movsd  (%r14,%r9,8),%xmm0
subsd  (%r8),%xmm0
movsd  %xmm0,(%r14,%r9,8)
add    $0x2,%edi
add    $0x10,%r8
add    $0x2,%r9d
add    $0xfffffffffffffffe,%rax
jne    1ca0 <rbcholu+0xb40>
jmp    1be0 <rbcholu+0xa80>
nop
mov    %rcx,%rsi
not    %rsi
add    %rdx,%rsi
mov    0x18(%rsp),%rbx
imul   %ecx,%ebx
add    0x28(%rsp),%ebx
lea    (%rsi,%rbx,1),%r8d
mov    %rcx,%rdi
cmp    %ebx,%r8d
jl     1c22 <rbcholu+0xac2>
shr    $0x20,%rsi
mov    %rcx,%rdi
jne    1c22 <rbcholu+0xac2>
mov    0x38(%rsp),%rdi
imul   %rcx,%rdi
add    0x8(%rsp),%rdi
mov    0x18(%rsp),%rax
mov    %eax,%esi
imul   %ecx,%esi
add    0x28(%rsp),%esi
movslq %esi,%rsi
lea    (%r14,%r9,8),%rbx
lea    (%rbx,%rsi,8),%rbx
cmp    %rbx,%rdi
jae    1d61 <rbcholu+0xc01>
mov    %rcx,%rdi
imul   %rdx,%rdi
add    %rdx,%rdi
mov    0x8(%rsp),%rax
lea    (%rax,%rdi,8),%rbx
lea    (%r14,%rsi,8),%rsi
mov    %rcx,%rdi
cmp    %rbx,%rsi
jb     1c22 <rbcholu+0xac2>
mov    %r12,%rbx
and    $0xfffffffffffffffc,%rbx
mov    %r9,%r8
and    $0xfffffffffffffffc,%r8
lea    (%rcx,%r8,1),%rdi
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nop
movupd -0x10(%rbp,%rsi,8),%xmm0
movupd 0x0(%rbp,%rsi,8),%xmm1
lea    (%r11,%rsi,1),%eax
cltq
movupd (%r14,%rax,8),%xmm2
subpd  %xmm0,%xmm2
movupd 0x10(%r14,%rax,8),%xmm0
subpd  %xmm1,%xmm0
movupd %xmm2,(%r14,%rax,8)
movupd %xmm0,0x10(%r14,%rax,8)
add    $0x4,%rsi
cmp    %rsi,%rbx
jne    1d80 <rbcholu+0xc20>
cmp    %r8,%r9
je     1be0 <rbcholu+0xa80>
jmp    1c22 <rbcholu+0xac2>
mov    %edx,%eax
shl    $0x5,%eax
cltq
lea    (%r14,%rax,8),%rdi
add    $0x100,%rdi
mov    0x14(%rsp),%esi
mov    0x68(%rsp),%rcx
mov    0x8(%rsp),%r8
call   1070 <rbcholu@plt>
cmp    $0xffffffff,%eax
jne    1dfa <rbcholu+0xc9a>
mov    $0xffffffff,%eax
add    $0x118,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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