#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)64;
  bb = bs * bs;
  if (N <= 64) {
    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   $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    $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    $0xa8,%rsp
mov    %rdi,%r14
cmp    $0x40,%esi
jg     118f <rbcholu+0x2f>
mov    %r14,%rdi
call   1080 <rcholu@plt>
cmp    $0xffffffff,%eax
jne    1a60 <rbcholu+0x900>
jmp    1a5b <rbcholu+0x8fb>
mov    %r8,%r12
lea    -0x40(%rsi),%ebx
mov    $0x200,%edi
mov    %rsi,0x60(%rsp)
mov    %rdx,0x18(%rsp)
mov    %rcx,%r15
call   1060 <malloc@plt>
mov    %rax,%rbp
mov    $0x200,%edi
call   1060 <malloc@plt>
mov    %rax,%r13
mov    %ebx,0x14(%rsp)
shl    $0x9,%ebx
mov    %ebx,%edi
call   1060 <malloc@plt>
mov    %rax,0x50(%rsp)
mov    %ebx,%edi
call   1060 <malloc@plt>
mov    %rax,0x58(%rsp)
mov    %r14,%rdi
mov    $0x40,%esi
mov    0x18(%rsp),%rdx
mov    %r15,0x68(%rsp)
mov    %r15,%rcx
mov    0x18(%rsp),%rbx
call   1080 <rcholu@plt>
mov    0x60(%rsp),%r11
movslq %ebx,%rax
mov    %r11d,%r8d
mov    %r8d,%ecx
and    $0xfffffffe,%ecx
lea    0x8(%r14),%rsi
mov    %rax,0x38(%rsp)
lea    0x0(,%rax,8),%r9
xor    %r10d,%r10d
mov    %r12,%rdi
jmp    1241 <rbcholu+0xe1>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%r10
add    $0x8,%rdi
add    %r9,%rsi
cmp    $0x40,%r10
je     12c0 <rbcholu+0x160>
cmp    $0x1,%r11d
jne    1260 <rbcholu+0x100>
xor    %ebx,%ebx
xor    %edx,%edx
test   $0x1,%r8b
je     1230 <rbcholu+0xd0>
jmp    12a0 <rbcholu+0x140>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    $0x40,%ebx
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movsd  -0x8(%rsi,%rdx,8),%xmm0
movsd  %xmm0,-0x200(%rdi,%rbx,8)
ff ff
movsd  (%rsi,%rdx,8),%xmm0
movsd  %xmm0,(%rdi,%rbx,8)
add    $0x2,%rdx
sub    $0xffffffffffffff80,%rbx
cmp    %rdx,%rcx
jne    1270 <rbcholu+0x110>
add    $0xffffffffffffffc0,%rbx
test   $0x1,%r8b
je     1230 <rbcholu+0xd0>
mov    %r10,%rax
imul   0x38(%rsp),%rax
add    %rax,%rdx
movsd  (%r14,%rdx,8),%xmm0
add    %r10,%rbx
movsd  %xmm0,(%r12,%rbx,8)
jmp    1230 <rbcholu+0xd0>
cmp    $0x41,%r11d
mov    %r14,0x48(%rsp)
mov    %r12,0x8(%rsp)
jl     1713 <rbcholu+0x5b3>
mov    0x14(%rsp),%eax
mov    %rax,0x20(%rsp)
lea    0x200(%rbp),%rax
lea    0x200(%r13),%rcx
mov    %rax,0x30(%rsp)
cmp    %rax,%r13
setb   %al
mov    %rcx,0x80(%rsp)
cmp    %rcx,%rbp
setb   %cl
and    %al,%cl
mov    %cl,0x7(%rsp)
lea    0x8030(%r12),%rdi
mov    %r14,%rax
lea    0x8008(%r12),%r14
lea    0x18(%r12),%rcx
mov    %rcx,0x78(%rsp)
mov    0x38(%rsp),%rcx
mov    %rcx,%r15
shl    $0x4,%r15
lea    0x200(%rax),%rsi
shl    $0x5,%rcx
mov    %rcx,0x70(%rsp)
mov    0x50(%rsp),%rax
lea    0x10(%rax),%r9
lea    0x8(%rax),%r10
xor    %r8d,%r8d
xorpd  %xmm0,%xmm0
jmp    138f <rbcholu+0x22f>
nopl   0x0(%rax)
add    $0x1,%r8
add    $0x200,%rdi
add    $0x200,%r14
add    $0x8,%rsi
add    $0x200,%r9
add    $0x200,%r10
cmp    0x20(%rsp),%r8
je     1771 <rbcholu+0x611>
mov    %rsi,0x28(%rsp)
mov    %r8,%rcx
shl    $0x9,%rcx
lea    (%rcx,%r12,1),%rdx
add    $0x8000,%rdx
lea    (%rcx,%r12,1),%rax
add    $0x8200,%rax
cmp    %rax,%r13
setb   %sil
cmp    0x80(%rsp),%rdx
setb   %bl
and    %sil,%bl
or     0x7(%rsp),%bl
cmp    %rax,%rbp
setb   %al
cmp    0x30(%rsp),%rdx
setb   %dl
test   %bl,%bl
jne    1450 <rbcholu+0x2f0>
and    %dl,%al
jne    1450 <rbcholu+0x2f0>
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups -0x30(%rdi,%rdx,8),%xmm1
movups %xmm1,0x0(%r13,%rdx,8)
movupd %xmm0,0x0(%rbp,%rdx,8)
movups -0x20(%rdi,%rdx,8),%xmm1
movups %xmm1,0x10(%r13,%rdx,8)
movupd %xmm0,0x10(%rbp,%rdx,8)
movups -0x10(%rdi,%rdx,8),%xmm1
movups %xmm1,0x20(%r13,%rdx,8)
movupd %xmm0,0x20(%rbp,%rdx,8)
movupd (%rdi,%rdx,8),%xmm1
movupd %xmm1,0x30(%r13,%rdx,8)
movupd %xmm0,0x30(%rbp,%rdx,8)
add    $0x8,%rdx
cmp    $0x40,%rdx
jne    13f0 <rbcholu+0x290>
jmp    1497 <rbcholu+0x337>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  -0x8(%r14,%rax,8),%xmm1
movsd  %xmm1,0x0(%r13,%rax,8)
movq   $0x0,0x0(%rbp,%rax,8)
movsd  (%r14,%rax,8),%xmm1
movsd  %xmm1,0x8(%r13,%rax,8)
movq   $0x0,0x8(%rbp,%rax,8)
add    $0x2,%rax
cmp    $0x40,%rax
jne    1460 <rbcholu+0x300>
mov    0x48(%rsp),%rax
lea    (%rax,%r8,8),%rdx
add    $0x200,%rdx
mov    %rdx,0x88(%rsp)
mov    %r8,0x40(%rsp)
lea    0x400(%rax,%r8,8),%rax
mov    %rax,0x90(%rsp)
mov    0x50(%rsp),%rax
lea    (%rax,%rcx,1),%rdx
mov    %rdx,0x98(%rsp)
add    %rcx,%rax
add    $0x200,%rax
mov    %rax,0xa0(%rsp)
mov    0x78(%rsp),%r11
xor    %ebx,%ebx
jmp    1536 <rbcholu+0x3d6>
nop
xorpd  %xmm1,%xmm1
movsd  0x0(%r13,%rbx,8),%xmm2
subsd  %xmm1,%xmm2
mov    %rbx,%rax
shl    $0x9,%rax
lea    (%rax,%rbx,8),%rax
mov    0x8(%rsp),%rcx
divsd  (%rcx,%rax,1),%xmm2
movsd  %xmm2,0x0(%rbp,%rbx,8)
add    $0x1,%rbx
add    $0x200,%r11
add    $0x200,%r12
cmp    $0x40,%rbx
je     15f0 <rbcholu+0x490>
test   %rbx,%rbx
je     14f0 <rbcholu+0x390>
lea    -0x1(%rbx),%rax
cmp    $0x3,%rax
jae    1550 <rbcholu+0x3f0>
xorpd  %xmm1,%xmm1
xor    %r8d,%r8d
jmp    15b0 <rbcholu+0x450>
xchg   %ax,%ax
mov    %rbx,%rcx
and    $0xfffffffffffffffc,%rcx
xorpd  %xmm1,%xmm1
xor    %r8d,%r8d
xchg   %ax,%ax
movsd  -0x18(%r11,%r8,8),%xmm2
movsd  -0x10(%r11,%r8,8),%xmm3
mulsd  0x0(%rbp,%r8,8),%xmm2
mulsd  0x8(%rbp,%r8,8),%xmm3
addsd  %xmm1,%xmm2
movsd  -0x8(%r11,%r8,8),%xmm4
mulsd  0x10(%rbp,%r8,8),%xmm4
addsd  %xmm2,%xmm3
movsd  (%r11,%r8,8),%xmm1
mulsd  0x18(%rbp,%r8,8),%xmm1
addsd  %xmm3,%xmm4
addsd  %xmm4,%xmm1
add    $0x4,%r8
cmp    %r8,%rcx
jne    1560 <rbcholu+0x400>
test   $0x3,%bl
je     14f4 <rbcholu+0x394>
mov    %ebx,%ecx
and    $0x3,%ecx
lea    0x0(,%r8,8),%rdx
add    %rbp,%rdx
lea    (%r12,%r8,8),%rax
xor    %esi,%esi
nop
movsd  (%rax,%rsi,8),%xmm2
mulsd  (%rdx,%rsi,8),%xmm2
addsd  %xmm2,%xmm1
add    $0x1,%rsi
cmp    %rsi,%rcx
jne    15d0 <rbcholu+0x470>
jmp    14f4 <rbcholu+0x394>
nopl   0x0(%rax)
cmpl   $0x1,0x18(%rsp)
jne    16b0 <rbcholu+0x550>
mov    0xa0(%rsp),%rsi
mov    0x88(%rsp),%rcx
cmp    %rsi,%rcx
setb   %r11b
mov    0x98(%rsp),%rdx
mov    0x90(%rsp),%rbx
cmp    %rbx,%rdx
setb   %r12b
mov    0x30(%rsp),%rax
cmp    %rax,%rcx
setb   %cl
cmp    %rbx,%rbp
setb   %r8b
cmp    %rax,%rdx
setb   %al
cmp    %rsi,%rbp
setb   %sil
test   %r12b,%r11b
jne    16b0 <rbcholu+0x550>
and    %r8b,%cl
jne    16b0 <rbcholu+0x550>
and    %sil,%al
jne    16b0 <rbcholu+0x550>
xor    %eax,%eax
mov    0x28(%rsp),%rsi
mov    %rsi,%rcx
mov    0x8(%rsp),%r12
mov    0x70(%rsp),%rdx
mov    0x40(%rsp),%r8
movups 0x0(%rbp,%rax,1),%xmm1
movups %xmm1,(%rcx)
movups %xmm1,-0x10(%r9,%rax,1)
movupd 0x10(%rbp,%rax,1),%xmm1
movupd %xmm1,(%rcx,%r15,1)
movupd %xmm1,(%r9,%rax,1)
add    %rdx,%rcx
add    $0x20,%rax
cmp    $0x200,%rax
jne    1670 <rbcholu+0x510>
jmp    1360 <rbcholu+0x200>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
xor    %ecx,%ecx
mov    0x28(%rsp),%rsi
mov    %rsi,%rdx
mov    0x8(%rsp),%r12
mov    0x38(%rsp),%rax
mov    0x40(%rsp),%r8
nopl   0x0(%rax)
movsd  0x0(%rbp,%rcx,1),%xmm1
movsd  %xmm1,(%rdx)
movsd  0x0(%rbp,%rcx,1),%xmm1
movsd  %xmm1,-0x8(%r10,%rcx,1)
movsd  0x8(%rbp,%rcx,1),%xmm1
movsd  %xmm1,(%rdx,%rax,8)
movsd  0x8(%rbp,%rcx,1),%xmm1
movsd  %xmm1,(%r10,%rcx,1)
add    %r15,%rdx
add    $0x10,%rcx
cmp    $0x200,%rcx
jne    16d0 <rbcholu+0x570>
jmp    1360 <rbcholu+0x200>
mov    0x50(%rsp),%r15
mov    %r15,%rdi
mov    0x14(%rsp),%ebx
mov    %ebx,%esi
mov    $0x40,%edx
mov    0x58(%rsp),%r14
mov    %r14,%rcx
call   1050 <mtranspose@plt>
mov    %r15,%rdi
mov    %r14,%rsi
mov    %r12,%rdx
mov    %ebx,%ecx
mov    $0x40,%r8d
mov    %ebx,%r9d
call   1040 <mmult@plt>
mov    %r15,%rdi
call   1030 <free@plt>
mov    %r14,%rdi
call   1030 <free@plt>
mov    %r13,%rdi
call   1030 <free@plt>
mov    %rbp,%rdi
call   1030 <free@plt>
jmp    1a27 <rbcholu+0x8c7>
mov    0x50(%rsp),%r15
mov    %r15,%rdi
mov    0x14(%rsp),%ebx
mov    %ebx,%esi
mov    $0x40,%edx
mov    0x58(%rsp),%r14
mov    %r14,%rcx
call   1050 <mtranspose@plt>
mov    %r15,%rdi
mov    %r14,%rsi
mov    %r12,%rdx
mov    %ebx,%ecx
mov    $0x40,%r8d
mov    %ebx,%r9d
call   1040 <mmult@plt>
mov    %r15,%rdi
call   1030 <free@plt>
mov    %r14,%rdi
call   1030 <free@plt>
mov    %r13,%rdi
call   1030 <free@plt>
mov    %rbp,%rdi
call   1030 <free@plt>
cmpl   $0x41,0x60(%rsp)
mov    0x20(%rsp),%r9
jl     1a27 <rbcholu+0x8c7>
mov    0x18(%rsp),%rax
mov    %eax,%r15d
shl    $0x6,%r15d
lea    0x40(%r15),%r14d
add    $0x1,%eax
mov    %rax,0x28(%rsp)
lea    0x8(,%r9,8),%rax
mov    %rax,0x40(%rsp)
mov    %r9,%rax
neg    %rax
mov    %rax,0x38(%rsp)
mov    0x8(%rsp),%rax
lea    0x10(%rax),%rbp
add    $0x41,%r15d
mov    $0x1,%r13d
xor    %ecx,%ecx
mov    %r14d,%r10d
mov    %r14,0x30(%rsp)
mov    %r9,%r12
mov    0x48(%rsp),%r11
jmp    186e <rbcholu+0x70e>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%rcx
add    $0xffffffffffffffff,%r12
add    0x28(%rsp),%r14
add    0x40(%rsp),%rbp
mov    0x18(%rsp),%rax
add    %eax,%r10d
mov    0x20(%rsp),%r9
add    %r9,%r13
add    %eax,%r15d
cmp    %r9,%rcx
je     1a27 <rbcholu+0x8c7>
sub    %rcx,%r9
mov    %rcx,%rdi
cmp    $0x4,%r9
mov    0x48(%rsp),%rdx
jae    1940 <rbcholu+0x7e0>
mov    0x20(%rsp),%rdx
mov    %edx,%eax
sub    %edi,%eax
mov    %rdi,%rbx
test   $0x1,%al
je     18ca <rbcholu+0x76a>
mov    %rcx,%rax
imul   %rdx,%rax
lea    0x40(%rcx),%esi
imul   0x18(%rsp),%esi
add    %rdi,%rax
add    %edi,%esi
add    $0x40,%esi
movslq %esi,%rsi
mov    0x48(%rsp),%rdx
movsd  (%rdx,%rsi,8),%xmm0
mov    0x8(%rsp),%rbx
subsd  (%rbx,%rax,8),%xmm0
movsd  %xmm0,(%rdx,%rsi,8)
lea    0x1(%rdi),%rbx
not    %rdi
cmp    0x38(%rsp),%rdi
je     1840 <rbcholu+0x6e0>
mov    0x20(%rsp),%rax
sub    %rbx,%rax
lea    (%r10,%rbx,1),%edi
mov    %rbx,%rsi
add    %r13,%rsi
mov    0x8(%rsp),%rdx
lea    (%rdx,%rsi,8),%r8
lea    (%r15,%rbx,1),%r9d
nopw   0x0(%rax,%rax,1)
movslq %edi,%rdi
movsd  (%r11,%rdi,8),%xmm0
subsd  -0x8(%r8),%xmm0
movsd  %xmm0,(%r11,%rdi,8)
movslq %r9d,%r9
movsd  (%r11,%r9,8),%xmm0
subsd  (%r8),%xmm0
movsd  %xmm0,(%r11,%r9,8)
add    $0x2,%edi
add    $0x10,%r8
add    $0x2,%r9d
add    $0xfffffffffffffffe,%rax
jne    1900 <rbcholu+0x7a0>
jmp    1840 <rbcholu+0x6e0>
nop
mov    %rcx,%rsi
not    %rsi
add    0x20(%rsp),%rsi
mov    0x28(%rsp),%rbx
imul   %ecx,%ebx
add    0x30(%rsp),%ebx
lea    (%rsi,%rbx,1),%r8d
mov    %rcx,%rdi
cmp    %ebx,%r8d
jl     1883 <rbcholu+0x723>
shr    $0x20,%rsi
mov    %rcx,%rdi
jne    1883 <rbcholu+0x723>
mov    0x40(%rsp),%rdi
imul   %rcx,%rdi
add    0x8(%rsp),%rdi
mov    0x28(%rsp),%rax
mov    %eax,%esi
imul   %ecx,%esi
add    0x30(%rsp),%esi
movslq %esi,%rsi
lea    (%rdx,%r9,8),%rbx
lea    (%rbx,%rsi,8),%rbx
cmp    %rbx,%rdi
jae    19c8 <rbcholu+0x868>
mov    %rcx,%rdi
mov    0x20(%rsp),%rax
imul   %rax,%rdi
add    %rax,%rdi
mov    0x8(%rsp),%rax
lea    (%rax,%rdi,8),%rbx
lea    (%rdx,%rsi,8),%rsi
mov    %rcx,%rdi
cmp    %rbx,%rsi
jb     1883 <rbcholu+0x723>
mov    %r12,%rbx
and    $0xfffffffffffffffc,%rbx
mov    %r9,%r8
and    $0xfffffffffffffffc,%r8
lea    (%rcx,%r8,1),%rdi
xor    %esi,%esi
nopl   0x0(%rax)
movupd -0x10(%rbp,%rsi,8),%xmm0
movupd 0x0(%rbp,%rsi,8),%xmm1
lea    (%r14,%rsi,1),%eax
cltq
movupd (%rdx,%rax,8),%xmm2
subpd  %xmm0,%xmm2
movupd 0x10(%rdx,%rax,8),%xmm0
subpd  %xmm1,%xmm0
movupd %xmm2,(%rdx,%rax,8)
movupd %xmm0,0x10(%rdx,%rax,8)
add    $0x4,%rsi
cmp    %rsi,%rbx
jne    19e0 <rbcholu+0x880>
cmp    %r8,%r9
je     1840 <rbcholu+0x6e0>
jmp    1883 <rbcholu+0x723>
mov    0x18(%rsp),%rdx
mov    %edx,%eax
shl    $0x6,%eax
cltq
mov    0x48(%rsp),%rcx
lea    (%rcx,%rax,8),%rdi
add    $0x200,%rdi
mov    0x14(%rsp),%esi
mov    0x68(%rsp),%rcx
mov    0x8(%rsp),%r8
call   1070 <rbcholu@plt>
cmp    $0xffffffff,%eax
jne    1a60 <rbcholu+0x900>
mov    $0xffffffff,%eax
add    $0xa8,%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 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 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, 65
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 %454, label %452
11: ; preds = %5
%12 = add nsw i32 %1, -64
%13 = tail call i64 @malloc(i32 512)
%14 = tail call i64 @malloc(i32 512)
%15 = shl i32 %12, 9
%16 = tail call i64 @malloc(i32 %15)
%17 = tail call i64 @malloc(i32 %15)
%18 = tail call i32 @rcholu(double* %0, i32 64, 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 %44
25: ; preds = %76
%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, 64
br i1 %32, label %33, label %438
33: ; preds = %25
%34 = zext i32 %12 to i64
%35 = getelementptr double, double* %26, i64 64
%36 = getelementptr double, double* %28, i64 64
%37 = bitcast double* %36 to i8*
%38 = getelementptr double, double* %26, i64 64
%39 = bitcast double* %38 to i8*
%40 = icmp ult i8* %29, %39
%41 = icmp ult i8* %27, %37
%42 = and i1 %40, %41
%43 = icmp eq i32 %2, 1
br label %79
44: ; preds = %76, %11
%45 = phi i64 [ 0, %11 ], [ %77, %76 ]
%46 = mul nsw i64 %45, %19
br i1 %22, label %67, label %47
47: ; preds = %44, %47
%48 = phi i64 [ %63, %47 ], [ 0, %44 ]
%49 = phi i64 [ %64, %47 ], [ 0, %44 ]
%50 = phi i64 [ %65, %47 ], [ 0, %44 ]
%51 = add nsw i64 %49, %46
%52 = getelementptr inbounds double, double* %0, i64 %51
%53 = load double, double* %52
%54 = add nuw nsw i64 %48, %45
%55 = getelementptr inbounds double, double* %4, i64 %54
store double %53, double* %55
%56 = or i64 %48, 64
%57 = or i64 %49, 1
%58 = add nsw i64 %57, %46
%59 = getelementptr inbounds double, double* %0, i64 %58
%60 = load double, double* %59
%61 = add nuw nsw i64 %56, %45
%62 = getelementptr inbounds double, double* %4, i64 %61
store double %60, double* %62
%63 = add nuw nsw i64 %48, 128
%64 = add nuw nsw i64 %49, 2
%65 = add nuw nsw i64 %50, 2
%66 = icmp eq i64 %65, %23
br i1 %66, label %67, label %47
67: ; preds = %47, %44
%68 = phi i64 [ 0, %44 ], [ %63, %47 ]
%69 = phi i64 [ 0, %44 ], [ %64, %47 ]
br i1 %24, label %76, label %70
70: ; preds = %67
%71 = add nsw i64 %69, %46
%72 = getelementptr inbounds double, double* %0, i64 %71
%73 = load double, double* %72
%74 = add nuw nsw i64 %68, %45
%75 = getelementptr inbounds double, double* %4, i64 %74
store double %73, double* %75
br label %76
76: ; preds = %67, %70
%77 = add nuw nsw i64 %45, 1
%78 = icmp eq i64 %77, 64
br i1 %78, label %25, label %44
79: ; preds = %33, %297
%80 = phi i64 [ 0, %33 ], [ %298, %297 ]
%81 = phi i32 [ 64, %33 ], [ %299, %297 ]
%82 = shl nuw nsw i64 %80, 6
%83 = add nuw i64 %82, 4096
%84 = getelementptr double, double* %4, i64 %83
%85 = add nuw i64 %82, 4160
%86 = getelementptr double, double* %4, i64 %85
%87 = bitcast double* %86 to i8*
%88 = add nuw i64 %80, 64
%89 = getelementptr double, double* %0, i64 %88
%90 = add nuw i64 %80, 128
%91 = getelementptr double, double* %0, i64 %90
%92 = bitcast double* %91 to i8*
%93 = shl nuw nsw i64 %80, 6
%94 = getelementptr double, double* %30, i64 %93
%95 = add nuw i64 %93, 64
%96 = getelementptr double, double* %30, i64 %95
%97 = bitcast double* %96 to i8*
%98 = sext i32 %81 to i64
%99 = shl nsw i64 %80, 6
%100 = add nuw nsw i64 %99, 4096
%101 = icmp ult i8* %29, %87
%102 = icmp ult double* %84, %36
%103 = and i1 %101, %102
%104 = or i1 %42, %103
%105 = icmp ult i8* %27, %87
%106 = icmp ult double* %84, %38
%107 = and i1 %105, %106
%108 = or i1 %104, %107
br i1 %108, label %148, label %109
109: ; preds = %79, %109
%110 = phi i64 [ %146, %109 ], [ 0, %79 ]
%111 = add nuw nsw i64 %100, %110
%112 = getelementptr inbounds double, double* %4, i64 %111
%113 = bitcast double* %112 to <2 x double>*
%114 = load <2 x double>, <2 x double>* %113
%115 = getelementptr inbounds double, double* %28, i64 %110
%116 = bitcast double* %115 to <2 x double>*
store <2 x double> %114, <2 x double>* %116
%117 = getelementptr inbounds double, double* %26, i64 %110
%118 = bitcast double* %117 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %118
%119 = or i64 %110, 2
%120 = add nuw nsw i64 %100, %119
%121 = getelementptr inbounds double, double* %4, i64 %120
%122 = bitcast double* %121 to <2 x double>*
%123 = load <2 x double>, <2 x double>* %122
%124 = getelementptr inbounds double, double* %28, i64 %119
%125 = bitcast double* %124 to <2 x double>*
store <2 x double> %123, <2 x double>* %125
%126 = getelementptr inbounds double, double* %26, i64 %119
%127 = bitcast double* %126 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %127
%128 = or i64 %110, 4
%129 = add nuw nsw i64 %100, %128
%130 = getelementptr inbounds double, double* %4, i64 %129
%131 = bitcast double* %130 to <2 x double>*
%132 = load <2 x double>, <2 x double>* %131
%133 = getelementptr inbounds double, double* %28, i64 %128
%134 = bitcast double* %133 to <2 x double>*
store <2 x double> %132, <2 x double>* %134
%135 = getelementptr inbounds double, double* %26, i64 %128
%136 = bitcast double* %135 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %136
%137 = or i64 %110, 6
%138 = add nuw nsw i64 %100, %137
%139 = getelementptr inbounds double, double* %4, i64 %138
%140 = bitcast double* %139 to <2 x double>*
%141 = load <2 x double>, <2 x double>* %140
%142 = getelementptr inbounds double, double* %28, i64 %137
%143 = bitcast double* %142 to <2 x double>*
store <2 x double> %141, <2 x double>* %143
%144 = getelementptr inbounds double, double* %26, i64 %137
%145 = bitcast double* %144 to <2 x double>*
store <2 x double> zeroinitializer, <2 x double>* %145
%146 = add nuw nsw i64 %110, 8
%147 = icmp eq i64 %146, 64
br i1 %147, label %163, label %109
148: ; preds = %79, %148
%149 = phi i64 [ %161, %148 ], [ 0, %79 ]
%150 = add nuw nsw i64 %100, %149
%151 = getelementptr inbounds double, double* %4, i64 %150
%152 = load double, double* %151
%153 = getelementptr inbounds double, double* %28, i64 %149
store double %152, double* %153
%154 = getelementptr inbounds double, double* %26, i64 %149
store double 0.000000e+00, double* %154
%155 = or i64 %149, 1
%156 = add nuw nsw i64 %100, %155
%157 = getelementptr inbounds double, double* %4, i64 %156
%158 = load double, double* %157
%159 = getelementptr inbounds double, double* %28, i64 %155
store double %158, double* %159
%160 = getelementptr inbounds double, double* %26, i64 %155
store double 0.000000e+00, double* %160
%161 = add nuw nsw i64 %149, 2
%162 = icmp eq i64 %161, 64
br i1 %162, label %163, label %148
163: ; preds = %109, %148
br label %164
164: ; preds = %163, %226
%165 = phi i64 [ %236, %226 ], [ 0, %163 ]
%166 = shl nuw nsw i64 %165, 6
%167 = icmp eq i64 %165, 0
br i1 %167, label %226, label %168
168: ; preds = %164
%169 = add nsw i64 %165, -1
%170 = and i64 %165, 3
%171 = icmp ult i64 %169, 3
br i1 %171, label %208, label %172
172: ; preds = %168
%173 = and i64 %165, 9223372036854775804
br label %174
174: ; preds = %174, %172
%175 = phi i64 [ 0, %172 ], [ %205, %174 ]
%176 = phi double [ 0.000000e+00, %172 ], [ %204, %174 ]
%177 = phi i64 [ 0, %172 ], [ %206, %174 ]
%178 = add nuw nsw i64 %175, %166
%179 = getelementptr inbounds double, double* %4, i64 %178
%180 = load double, double* %179
%181 = getelementptr inbounds double, double* %26, i64 %175
%182 = load double, double* %181
%183 = tail call double @llvm.fmuladd.f64(double %180, double %182, double %176)
%184 = or i64 %175, 1
%185 = add nuw nsw i64 %184, %166
%186 = getelementptr inbounds double, double* %4, i64 %185
%187 = load double, double* %186
%188 = getelementptr inbounds double, double* %26, i64 %184
%189 = load double, double* %188
%190 = tail call double @llvm.fmuladd.f64(double %187, double %189, double %183)
%191 = or i64 %175, 2
%192 = add nuw nsw i64 %191, %166
%193 = getelementptr inbounds double, double* %4, i64 %192
%194 = load double, double* %193
%195 = getelementptr inbounds double, double* %26, i64 %191
%196 = load double, double* %195
%197 = tail call double @llvm.fmuladd.f64(double %194, double %196, double %190)
%198 = or i64 %175, 3
%199 = add nuw nsw i64 %198, %166
%200 = getelementptr inbounds double, double* %4, i64 %199
%201 = load double, double* %200
%202 = getelementptr inbounds double, double* %26, i64 %198
%203 = load double, double* %202
%204 = tail call double @llvm.fmuladd.f64(double %201, double %203, double %197)
%205 = add nuw nsw i64 %175, 4
%206 = add i64 %177, 4
%207 = icmp eq i64 %206, %173
br i1 %207, label %208, label %174
208: ; preds = %174, %168
%209 = phi double [ undef, %168 ], [ %204, %174 ]
%210 = phi i64 [ 0, %168 ], [ %205, %174 ]
%211 = phi double [ 0.000000e+00, %168 ], [ %204, %174 ]
%212 = icmp eq i64 %170, 0
br i1 %212, label %226, label %213
213: ; preds = %208, %213
%214 = phi i64 [ %223, %213 ], [ %210, %208 ]
%215 = phi double [ %222, %213 ], [ %211, %208 ]
%216 = phi i64 [ %224, %213 ], [ 0, %208 ]
%217 = add nuw nsw i64 %214, %166
%218 = getelementptr inbounds double, double* %4, i64 %217
%219 = load double, double* %218
%220 = getelementptr inbounds double, double* %26, i64 %214
%221 = load double, double* %220
%222 = tail call double @llvm.fmuladd.f64(double %219, double %221, double %215)
%223 = add nuw nsw i64 %214, 1
%224 = add i64 %216, 1
%225 = icmp eq i64 %224, %170
br i1 %225, label %226, label %213
226: ; preds = %208, %213, %164
%227 = phi double [ 0.000000e+00, %164 ], [ %209, %208 ], [ %222, %213 ]
%228 = getelementptr inbounds double, double* %28, i64 %165
%229 = load double, double* %228
%230 = fsub double %229, %227
%231 = mul nuw nsw i64 %165, 65
%232 = getelementptr inbounds double, double* %4, i64 %231
%233 = load double, double* %232
%234 = fdiv double %230, %233
%235 = getelementptr inbounds double, double* %26, i64 %165
store double %234, double* %235
%236 = add nuw nsw i64 %165, 1
%237 = icmp eq i64 %236, 64
br i1 %237, label %238, label %164
238: ; preds = %226
br i1 %43, label %240, label %239
239: ; preds = %240, %238
br label %277
240: ; preds = %238
%241 = icmp ult double* %89, %96
%242 = icmp ult double* %94, %91
%243 = and i1 %241, %242
%244 = icmp ult double* %89, %35
%245 = icmp ult i8* %27, %92
%246 = and i1 %244, %245
%247 = or i1 %243, %246
%248 = icmp ult double* %94, %35
%249 = icmp ult i8* %27, %97
%250 = and i1 %248, %249
%251 = or i1 %247, %250
br i1 %251, label %239, label %252
252: ; preds = %240, %252
%253 = phi i64 [ %275, %252 ], [ 0, %240 ]
%254 = mul i64 %253, %19
%255 = add nsw i64 %254, %98
%256 = getelementptr inbounds double, double* %26, i64 %253
%257 = bitcast double* %256 to <2 x double>*
%258 = load <2 x double>, <2 x double>* %257
%259 = getelementptr inbounds double, double* %0, i64 %255
%260 = bitcast double* %259 to <2 x double>*
store <2 x double> %258, <2 x double>* %260
%261 = add nuw nsw i64 %253, %99
%262 = getelementptr inbounds double, double* %30, i64 %261
%263 = bitcast double* %262 to <2 x double>*
store <2 x double> %258, <2 x double>* %263
%264 = or i64 %253, 2
%265 = mul i64 %264, %19
%266 = add nsw i64 %265, %98
%267 = getelementptr inbounds double, double* %26, i64 %264
%268 = bitcast double* %267 to <2 x double>*
%269 = load <2 x double>, <2 x double>* %268
%270 = getelementptr inbounds double, double* %0, i64 %266
%271 = bitcast double* %270 to <2 x double>*
store <2 x double> %269, <2 x double>* %271
%272 = add nuw nsw i64 %264, %99
%273 = getelementptr inbounds double, double* %30, i64 %272
%274 = bitcast double* %273 to <2 x double>*
store <2 x double> %269, <2 x double>* %274
%275 = add nuw nsw i64 %253, 4
%276 = icmp eq i64 %275, 64
br i1 %276, label %297, label %252
277: ; preds = %277, %239
%278 = phi i64 [ %98, %239 ], [ %294, %277 ]
%279 = phi i64 [ 0, %239 ], [ %295, %277 ]
%280 = getelementptr inbounds double, double* %26, i64 %279
%281 = load double, double* %280
%282 = getelementptr inbounds double, double* %0, i64 %278
store double %281, double* %282
%283 = load double, double* %280
%284 = add nuw nsw i64 %279, %99
%285 = getelementptr inbounds double, double* %30, i64 %284
store double %283, double* %285
%286 = add nsw i64 %278, %19
%287 = or i64 %279, 1
%288 = getelementptr inbounds double, double* %26, i64 %287
%289 = load double, double* %288
%290 = getelementptr inbounds double, double* %0, i64 %286
store double %289, double* %290
%291 = load double, double* %288
%292 = add nuw nsw i64 %287, %99
%293 = getelementptr inbounds double, double* %30, i64 %292
store double %291, double* %293
%294 = add nsw i64 %286, %19
%295 = add nuw nsw i64 %279, 2
%296 = icmp eq i64 %295, 64
br i1 %296, label %297, label %277
297: ; preds = %252, %277
%298 = add nuw nsw i64 %80, 1
%299 = add nuw i32 %81, 1
%300 = icmp eq i64 %298, %34
br i1 %300, label %301, label %79
301: ; preds = %297
%302 = tail call i32 @mtranspose(double* %30, i32 %12, i32 64, double* %31)
%303 = tail call i32 @mmult(double* %30, double* %31, double* %4, i32 %12, i32 64, i32 %12)
%304 = tail call i32 @free(double* %30)
%305 = tail call i32 @free(double* %31)
%306 = tail call i32 @free(double* %28)
%307 = tail call i32 @free(double* %26)
br i1 %32, label %308, label %445
308: ; preds = %301
%309 = zext i32 %12 to i64
%310 = zext i32 %12 to i64
%311 = shl i32 %2, 6
%312 = add i32 %311, 64
%313 = add i32 %2, 1
%314 = shl nuw nsw i64 %34, 3
%315 = add nuw nsw i64 %314, 8
%316 = shl i32 %2, 6
%317 = add i32 %316, 64
%318 = add i32 %2, 1
%319 = sub nsw i64 0, %34
br label %320
320: ; preds = %435, %308
%321 = phi i64 [ 0, %308 ], [ %436, %435 ]
%322 = sub nsw i64 %34, %321
%323 = mul i64 %315, %321
%324 = getelementptr i8, i8* %6, i64 %323
%325 = mul i64 %321, %34
%326 = add i64 %325, %34
%327 = getelementptr double, double* %4, i64 %326
%328 = trunc i64 %321 to i32
%329 = mul i32 %318, %328
%330 = add i32 %329, %317
%331 = sext i32 %330 to i64
%332 = getelementptr double, double* %0, i64 %331
%333 = sub nsw i64 %34, %321
%334 = getelementptr double, double* %0, i64 %333
%335 = getelementptr double, double* %334, i64 %331
%336 = bitcast double* %335 to i8*
%337 = xor i64 %321, -1
%338 = add nsw i64 %337, %34
%339 = trunc i64 %321 to i32
%340 = mul i32 %313, %339
%341 = add i32 %340, %312
%342 = mul nsw i64 %321, %309
%343 = trunc i64 %321 to i32
%344 = add i32 %343, 64
%345 = mul i32 %344, %2
%346 = icmp ult i64 %322, 4
br i1 %346, label %389, label %347
347: ; preds = %320
%348 = trunc i64 %338 to i32
%349 = add i32 %341, %348
%350 = icmp slt i32 %349, %341
%351 = icmp ugt i64 %338, 4294967295
%352 = or i1 %350, %351
br i1 %352, label %389, label %353
353: ; preds = %347
%354 = icmp ult i8* %324, %336
%355 = icmp ult double* %332, %327
%356 = and i1 %354, %355
br i1 %356, label %389, label %357
357: ; preds = %353
%358 = and i64 %322, -4
%359 = add i64 %321, %358
br label %360
360: ; preds = %360, %357
%361 = phi i64 [ 0, %357 ], [ %385, %360 ]
%362 = add i64 %321, %361
%363 = add i64 %321, %361
%364 = trunc i64 %363 to i32
%365 = add nuw nsw i64 %362, %342
%366 = getelementptr inbounds double, double* %4, i64 %365
%367 = bitcast double* %366 to <2 x double>*
%368 = load <2 x double>, <2 x double>* %367
%369 = getelementptr inbounds double, double* %366, i64 2
%370 = bitcast double* %369 to <2 x double>*
%371 = load <2 x double>, <2 x double>* %370
%372 = add i32 %364, 64
%373 = add i32 %372, %345
%374 = sext i32 %373 to i64
%375 = getelementptr inbounds double, double* %0, i64 %374
%376 = bitcast double* %375 to <2 x double>*
%377 = load <2 x double>, <2 x double>* %376
%378 = getelementptr inbounds double, double* %375, i64 2
%379 = bitcast double* %378 to <2 x double>*
%380 = load <2 x double>, <2 x double>* %379
%381 = fsub <2 x double> %377, %368
%382 = fsub <2 x double> %380, %371
%383 = bitcast double* %375 to <2 x double>*
store <2 x double> %381, <2 x double>* %383
%384 = bitcast double* %378 to <2 x double>*
store <2 x double> %382, <2 x double>* %384
%385 = add nuw i64 %361, 4
%386 = icmp eq i64 %385, %358
br i1 %386, label %387, label %360
387: ; preds = %360
%388 = icmp eq i64 %322, %358
br i1 %388, label %435, label %389
389: ; preds = %353, %347, %320, %387
%390 = phi i64 [ %321, %353 ], [ %321, %347 ], [ %321, %320 ], [ %359, %387 ]
%391 = sub i64 %34, %390
%392 = xor i64 %390, -1
%393 = and i64 %391, 1
%394 = icmp eq i64 %393, 0
br i1 %394, label %407, label %395
395: ; preds = %389
%396 = add nuw nsw i64 %390, %342
%397 = getelementptr inbounds double, double* %4, i64 %396
%398 = load double, double* %397
%399 = trunc i64 %390 to i32
%400 = add i32 %399, 64
%401 = add i32 %400, %345
%402 = sext i32 %401 to i64
%403 = getelementptr inbounds double, double* %0, i64 %402
%404 = load double, double* %403
%405 = fsub double %404, %398
store double %405, double* %403
%406 = add nuw nsw i64 %390, 1
br label %407
407: ; preds = %395, %389
%408 = phi i64 [ %390, %389 ], [ %406, %395 ]
%409 = icmp eq i64 %392, %319
br i1 %409, label %435, label %410
410: ; preds = %407, %410
%411 = phi i64 [ %433, %410 ], [ %408, %407 ]
%412 = add nuw nsw i64 %411, %342
%413 = getelementptr inbounds double, double* %4, i64 %412
%414 = load double, double* %413
%415 = trunc i64 %411 to i32
%416 = add i32 %415, 64
%417 = add i32 %416, %345
%418 = sext i32 %417 to i64
%419 = getelementptr inbounds double, double* %0, i64 %418
%420 = load double, double* %419
%421 = fsub double %420, %414
store double %421, double* %419
%422 = add nuw nsw i64 %411, 1
%423 = add nuw nsw i64 %422, %342
%424 = getelementptr inbounds double, double* %4, i64 %423
%425 = load double, double* %424
%426 = trunc i64 %422 to i32
%427 = add i32 %426, 64
%428 = add i32 %427, %345
%429 = sext i32 %428 to i64
%430 = getelementptr inbounds double, double* %0, i64 %429
%431 = load double, double* %430
%432 = fsub double %431, %425
store double %432, double* %430
%433 = add nuw nsw i64 %411, 2
%434 = icmp eq i64 %433, %310
br i1 %434, label %435, label %410
435: ; preds = %407, %410, %387
%436 = add nuw nsw i64 %321, 1
%437 = icmp eq i64 %436, %310
br i1 %437, label %445, label %320
438: ; preds = %25
%439 = tail call i32 @mtranspose(double* %30, i32 %12, i32 64, double* %31)
%440 = tail call i32 @mmult(double* %30, double* %31, double* %4, i32 %12, i32 64, i32 %12)
%441 = tail call i32 @free(double* %30)
%442 = tail call i32 @free(double* %31)
%443 = tail call i32 @free(double* %28)
%444 = tail call i32 @free(double* %26)
br label %445
445: ; preds = %435, %438, %301
%446 = shl nsw i32 %2, 6
%447 = sext i32 %446 to i64
%448 = getelementptr inbounds double, double* %0, i64 %447
%449 = getelementptr inbounds double, double* %448, i64 64
%450 = tail call i32 @rbcholu(double* %449, i32 %12, i32 %2, double* %3, double* %4)
%451 = icmp eq i32 %450, -1
br i1 %451, label %454, label %452
452: ; preds = %445, %8
%453 = phi i32 [ %9, %8 ], [ %450, %445 ]
br label %454
454: ; preds = %445, %8, %452
%455 = phi i32 [ %453, %452 ], [ -1, %8 ], [ -1, %445 ]
ret i32 %455
}