#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 */
typedef int /*<<< orphan*/ z;
typedef int /*<<< orphan*/ g;
typedef int /*<<< orphan*/ c;
typedef int /*<<< orphan*/ b;
typedef int /*<<< orphan*/ a;

/* Variables and functions */
int RAND_MAX;
float *alloca(unsigned int);
double fabs(float);
int /*<<< orphan*/ frcholapply(float *, float *, float *, unsigned int);
scalar_t__ frcholfactor(float *, float *, unsigned int);
int /*<<< orphan*/ frmatprintf(char *, unsigned int, unsigned int, unsigned int,
                               int, float *);
int /*<<< orphan*/ frmul(float *, float *, float *, unsigned int, unsigned int,
                         unsigned int);
int /*<<< orphan*/ frtranspose(float *, float *, unsigned int, unsigned int);
int /*<<< orphan*/ memset(float *, int /*<<< orphan*/, unsigned int);
int /*<<< orphan*/ printf(char *);
int random();
int testfrchol(void) {
  unsigned int d;
  float *a, *b, *c, *g, *z;
  unsigned int i, j, err = 0;
  d = (random() & 15) + 1;
  a = alloca(d * d * sizeof(a[0]));
  b = alloca(d * d * sizeof(b[0]));
  c = alloca(d * d * sizeof(c[0]));
  g = alloca(d * d * sizeof(g[0]));
  for (i = 0; i < d; i++) {
    a[i * d + i] = (random() - RAND_MAX / 2) * (4.0 / RAND_MAX);
    a[i * d + i] *= a[i * d + i];
    for (j = i + 1; j < d; j++)
      a[i * d + i] += fabs(a[i * d + j] = a[j * d + i] =
                               (random() - RAND_MAX / 2) * (4.0 / RAND_MAX));
  }
  if (frcholfactor(a, g, d))
    return 1;
  for (i = 0; i < d; i++) {
    z = &b[i * d];
    memset(z, 0, d * sizeof(z[0]));
    z[i] = 1;
    frcholapply(g, z, z, d);
  }
  frtranspose(b, b, d, d);
  frmul(c, a, b, d, d, d);
  for (i = 0; i < d; i++)
    for (j = 0; j < d; j++)
      if (((i == j) && (fabs(c[i * d + j] - 1) > 0.0001)) ||
          ((i != j) && (fabs(c[i * d + j] - 0) > 0.0001)))
        err |= 1;
  if (err & 1) {
    printf("Cholesky inversion error!\n");
    frmatprintf("a", d, d, d, 1, a);
    frmatprintf("b", d, d, d, 1, b);
    frmatprintf("c", d, d, d, 1, c);
  }
  return err ? 1 : 0;
}


x86 assembly (clang, -O0):
<testfrchol>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
movl   $0x0,-0x3c(%rbp)
mov    $0x0,%al
call   10a0 <random@plt>
and    $0xf,%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
mov    -0x8(%rbp),%eax
imul   -0x8(%rbp),%eax
mov    %eax,%eax
shl    $0x2,%rax
mov    %eax,%edi
call   1090 <alloca@plt>
mov    %rax,-0x10(%rbp)
mov    -0x8(%rbp),%eax
imul   -0x8(%rbp),%eax
mov    %eax,%eax
shl    $0x2,%rax
mov    %eax,%edi
call   1090 <alloca@plt>
mov    %rax,-0x18(%rbp)
mov    -0x8(%rbp),%eax
imul   -0x8(%rbp),%eax
mov    %eax,%eax
shl    $0x2,%rax
mov    %eax,%edi
call   1090 <alloca@plt>
mov    %rax,-0x20(%rbp)
mov    -0x8(%rbp),%eax
imul   -0x8(%rbp),%eax
mov    %eax,%eax
shl    $0x2,%rax
mov    %eax,%edi
call   1090 <alloca@plt>
mov    %rax,-0x28(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jae    138e <testfrchol+0x1ee>
mov    $0x0,%al
call   10a0 <random@plt>
mov    %eax,-0x40(%rbp)
mov    0x2da5(%rip),%rax
mov    (%rax),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x40(%rbp),%eax
sub    %ecx,%eax
cvtsi2sd %eax,%xmm0
mov    0x2d89(%rip),%rax
cvtsi2sdl (%rax),%xmm2
movsd  0xd9d(%rip),%xmm1
divsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x34(%rbp),%ecx
mov    %ecx,%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x34(%rbp),%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x34(%rbp),%ecx
mov    %ecx,%ecx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x8(%rbp),%eax
jae    137b <testfrchol+0x1db>
mov    $0x0,%al
call   10a0 <random@plt>
mov    %eax,-0x44(%rbp)
mov    0x2d07(%rip),%rax
mov    (%rax),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x44(%rbp),%eax
sub    %ecx,%eax
cvtsi2sd %eax,%xmm0
mov    0x2ceb(%rip),%rax
cvtsi2sdl (%rax),%xmm2
movsd  0xcff(%rip),%xmm1
divsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x34(%rbp),%ecx
mov    %ecx,%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x38(%rbp),%ecx
mov    %ecx,%ecx
movss  %xmm0,(%rax,%rcx,4)
call   1080 <fabs@plt>
movaps %xmm0,%xmm1
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x34(%rbp),%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    12c4 <testfrchol+0x124>
jmp    1380 <testfrchol+0x1e0>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1226 <testfrchol+0x86>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%rsi
mov    -0x8(%rbp),%edx
call   1040 <frcholfactor@plt>
cmp    $0x0,%rax
je     13b4 <testfrchol+0x214>
movl   $0x1,-0x4(%rbp)
jmp    15bb <testfrchol+0x41b>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jae    1429 <testfrchol+0x289>
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x8(%rbp),%ecx
mov    %ecx,%ecx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rdi
mov    -0x8(%rbp),%eax
shl    $0x2,%rax
mov    %eax,%edx
xor    %esi,%esi
call   1070 <memset@plt>
mov    -0x30(%rbp),%rax
mov    -0x34(%rbp),%ecx
movss  0xc0e(%rip),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%rdi
mov    -0x30(%rbp),%rsi
mov    -0x30(%rbp),%rdx
mov    -0x8(%rbp),%ecx
call   1030 <frcholapply@plt>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    13bb <testfrchol+0x21b>
mov    -0x18(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x8(%rbp),%edx
mov    -0x8(%rbp),%ecx
call   10c0 <frtranspose@plt>
mov    -0x20(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    -0x8(%rbp),%ecx
mov    -0x8(%rbp),%r8d
mov    -0x8(%rbp),%r9d
call   10b0 <frmul@plt>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jae    1530 <testfrchol+0x390>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x8(%rbp),%eax
jae    151d <testfrchol+0x37d>
mov    -0x34(%rbp),%eax
cmp    -0x38(%rbp),%eax
jne    14c2 <testfrchol+0x322>
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x38(%rbp),%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm0
movss  0xb69(%rip),%xmm1
subss  %xmm1,%xmm0
call   1080 <fabs@plt>
movsd  0xb48(%rip),%xmm1
ucomisd %xmm1,%xmm0
ja     1501 <testfrchol+0x361>
mov    -0x34(%rbp),%eax
cmp    -0x38(%rbp),%eax
je     150a <testfrchol+0x36a>
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
imul   -0x8(%rbp),%ecx
add    -0x38(%rbp),%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm0
xorps  %xmm1,%xmm1
subss  %xmm1,%xmm0
call   1080 <fabs@plt>
movsd  0xb09(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    150a <testfrchol+0x36a>
mov    -0x3c(%rbp),%eax
or     $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    150f <testfrchol+0x36f>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1472 <testfrchol+0x2d2>
jmp    1522 <testfrchol+0x382>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    145f <testfrchol+0x2bf>
mov    -0x3c(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     15a8 <testfrchol+0x408>
lea    0xace(%rip),%rdi
call   1060 <printf@plt>
mov    -0x8(%rbp),%esi
mov    -0x8(%rbp),%edx
mov    -0x8(%rbp),%ecx
mov    -0x10(%rbp),%r9
lea    0xad0(%rip),%rdi
mov    $0x1,%r8d
call   1050 <frmatprintf@plt>
mov    -0x8(%rbp),%esi
mov    -0x8(%rbp),%edx
mov    -0x8(%rbp),%ecx
mov    -0x18(%rbp),%r9
lea    0xab3(%rip),%rdi
mov    $0x1,%r8d
call   1050 <frmatprintf@plt>
mov    -0x8(%rbp),%esi
mov    -0x8(%rbp),%edx
mov    -0x8(%rbp),%ecx
mov    -0x20(%rbp),%r9
lea    0xa96(%rip),%rdi
mov    $0x1,%r8d
call   1050 <frmatprintf@plt>
mov    -0x3c(%rbp),%edx
xor    %eax,%eax
mov    $0x1,%ecx
cmp    $0x0,%edx
cmovne %ecx,%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<testfrchol>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
xor    %eax,%eax
call   10a0 <random@plt>
mov    %eax,%r15d
and    $0xf,%r15d
lea    0x1(%r15),%rbx
lea    0x1(%r15),%ebp
lea    0x4(,%r15,4),%eax
mov    %eax,0x34(%rsp)
imul   %eax,%ebp
mov    %ebp,%edi
call   1090 <alloca@plt>
mov    %rax,%r13
mov    %ebp,%edi
call   1090 <alloca@plt>
mov    %rax,0x20(%rsp)
mov    %ebp,%edi
call   1090 <alloca@plt>
mov    %rax,0x28(%rsp)
mov    %ebp,%edi
call   1090 <alloca@plt>
mov    %rbx,%rcx
mov    %rax,0x38(%rsp)
mov    %r13,%rbp
add    $0x4,%rbp
lea    0x8(,%r15,4),%rax
mov    %rax,0x40(%rsp)
mov    0x2dc9(%rip),%rbx
mov    %r15,0x10(%rsp)
xor    %edx,%edx
mov    %rcx,0x8(%rsp)
jmp    1258 <testfrchol+0xb8>
nopl   (%rax)
add    0x40(%rsp),%rbp
mov    (%rsp),%rax
add    $0xffffffffffffffff,%rax
mov    0x18(%rsp),%rdx
cmp    %rcx,%rdx
mov    %rbx,%r13
mov    0x2d99(%rip),%rbx
mov    %rax,%r15
je     136a <testfrchol+0x1ca>
mov    %r15,(%rsp)
mov    %rdx,%r15
xor    %eax,%eax
call   10a0 <random@plt>
mov    (%rbx),%ecx
mov    %ecx,%edx
shr    $0x1f,%edx
add    %ecx,%edx
sar    %edx
sub    %edx,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
xorps  %xmm1,%xmm1
cvtsi2sd %ecx,%xmm1
movsd  0xd77(%rip),%xmm2
divsd  %xmm1,%xmm2
mulsd  %xmm0,%xmm2
xorps  %xmm0,%xmm0
cvtsd2ss %xmm2,%xmm0
mov    %r15d,%r14d
imul   0x8(%rsp),%r14d
add    %r15,%r14
mulss  %xmm0,%xmm0
movss  %xmm0,0x0(%r13,%r14,4)
lea    0x1(%r15),%rax
mov    %rax,0x18(%rsp)
cmp    0x10(%rsp),%r15
mov    0x8(%rsp),%rcx
mov    %r13,%rbx
jae    1230 <testfrchol+0x90>
mov    0x10(%rsp),%r13
xor    %r12d,%r12d
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xor    %eax,%eax
mov    %rcx,%r15
call   10a0 <random@plt>
mov    0x2cf7(%rip),%rcx
mov    (%rcx),%ecx
mov    %ecx,%edx
shr    $0x1f,%edx
add    %ecx,%edx
sar    %edx
sub    %edx,%eax
xorps  %xmm0,%xmm0
cvtsi2sd %eax,%xmm0
xorps  %xmm1,%xmm1
cvtsi2sd %ecx,%xmm1
movsd  0xcec(%rip),%xmm2
divsd  %xmm1,%xmm2
mulsd  %xmm0,%xmm2
xorps  %xmm0,%xmm0
cvtsd2ss %xmm2,%xmm0
movss  %xmm0,0x0(%rbp,%r13,4)
movss  %xmm0,0x0(%rbp,%r12,4)
call   1080 <fabs@plt>
mov    %r15,%rcx
movss  (%rbx,%r14,4),%xmm1
cvtss2sd %xmm1,%xmm1
addsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
movss  %xmm0,(%rbx,%r14,4)
add    $0x1,%r12
add    %r15,%r13
cmp    %r12,(%rsp)
jne    12e0 <testfrchol+0x140>
jmp    1230 <testfrchol+0x90>
mov    %r13,%rdi
mov    0x38(%rsp),%r14
mov    %r14,%rsi
mov    %rcx,%rbx
mov    %ebx,%edx
call   1040 <frcholfactor@plt>
mov    %rax,%rcx
mov    $0x1,%eax
test   %rcx,%rcx
jne    1548 <testfrchol+0x3a8>
lea    0x0(,%rbx,4),%rax
mov    %rax,0x18(%rsp)
lea    0x4(,%rbx,4),%rax
mov    %rax,(%rsp)
mov    %rbx,%r15
mov    0x20(%rsp),%rax
mov    %rax,%rbp
mov    %rax,%rbx
mov    0x34(%rsp),%r12d
nopl   0x0(%rax)
mov    %rbp,%rdi
xor    %esi,%esi
mov    %r12d,%edx
call   1070 <memset@plt>
movl   $0x3f800000,(%rbx)
mov    %r14,%rdi
mov    %rbp,%rsi
mov    %rbp,%rdx
mov    0x8(%rsp),%rcx
call   1030 <frcholapply@plt>
add    (%rsp),%rbx
add    0x18(%rsp),%rbp
add    $0xffffffffffffffff,%r15
jne    13c0 <testfrchol+0x220>
mov    0x20(%rsp),%rbx
mov    %rbx,%rdi
mov    %rbx,%rsi
mov    0x8(%rsp),%r12
mov    %r12d,%edx
mov    %r12d,%ecx
call   10c0 <frtranspose@plt>
mov    0x28(%rsp),%r14
mov    %r14,%rdi
mov    %r13,0x10(%rsp)
mov    %r13,%rsi
mov    %rbx,%rdx
mov    %r12d,%ecx
mov    %r12d,%r8d
mov    %r12d,%r9d
call   10b0 <frmul@plt>
xor    %ebp,%ebp
mov    %r14,(%rsp)
xor    %r14d,%r14d
mov    0x18(%rsp),%r13
jmp    1462 <testfrchol+0x2c2>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%rbp
add    %rax,(%rsp)
mov    0x8(%rsp),%r12
cmp    %r12,%rbp
je     14ce <testfrchol+0x32e>
mov    %rbp,%r15
imul   %r12,%r15
add    %rbp,%r15
xor    %ebx,%ebx
mov    0x28(%rsp),%r12
jmp    148e <testfrchol+0x2ee>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r13,%rax
add    $0x1,%rbx
cmp    %rbx,0x8(%rsp)
je     1450 <testfrchol+0x2b0>
cmp    %rbx,%rbp
jne    14b0 <testfrchol+0x310>
movss  (%r12,%r15,4),%xmm0
addss  0xb6f(%rip),%xmm0
jmp    14b9 <testfrchol+0x319>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%rsp),%rax
movss  (%rax,%rbx,4),%xmm0
call   1080 <fabs@plt>
ucomisd 0xb42(%rip),%xmm0
jbe    1480 <testfrchol+0x2e0>
or     $0x1,%r14d
jmp    1480 <testfrchol+0x2e0>
test   $0x1,%r14b
je     1540 <testfrchol+0x3a0>
lea    0xb3f(%rip),%rdi
call   1050 <puts@plt>
lea    0xb2d(%rip),%rdi
mov    %r12d,%esi
mov    %r12d,%edx
mov    %r12d,%ecx
mov    $0x1,%r8d
mov    0x10(%rsp),%r9
call   1060 <frmatprintf@plt>
lea    0xb0f(%rip),%rdi
mov    %r12d,%esi
mov    %r12d,%edx
mov    %r12d,%ecx
mov    $0x1,%r8d
mov    0x20(%rsp),%r9
call   1060 <frmatprintf@plt>
lea    0xaf1(%rip),%rdi
mov    %r12d,%esi
mov    %r12d,%edx
mov    %r12d,%ecx
mov    $0x1,%r8d
mov    0x28(%rsp),%r9
call   1060 <frmatprintf@plt>
xor    %eax,%eax
test   %r14d,%r14d
setne  %al
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@RAND_MAX = global i32 0
@.str = [27 x i8] c"Cholesky inversion error!\0A\00"
@.str.1 = [2 x i8] c"a\00"
@.str.2 = [2 x i8] c"b\00"
@.str.3 = [2 x i8] c"c\00"
define i32 @testfrchol() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca float*
%4 = alloca float*
%5 = alloca float*
%6 = alloca float*
%7 = alloca float*
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
store i32 0, i32* %10
%11 = call i32 (...) @random()
%12 = and i32 %11, 15
%13 = add nsw i32 %12, 1
store i32 %13, i32* %2
%14 = load i32, i32* %2
%15 = load i32, i32* %2
%16 = mul i32 %14, %15
%17 = zext i32 %16 to i64
%18 = mul i64 %17, 4
%19 = trunc i64 %18 to i32
%20 = call float* @alloca(i32 %19)
store float* %20, float** %3
%21 = load i32, i32* %2
%22 = load i32, i32* %2
%23 = mul i32 %21, %22
%24 = zext i32 %23 to i64
%25 = mul i64 %24, 4
%26 = trunc i64 %25 to i32
%27 = call float* @alloca(i32 %26)
store float* %27, float** %4
%28 = load i32, i32* %2
%29 = load i32, i32* %2
%30 = mul i32 %28, %29
%31 = zext i32 %30 to i64
%32 = mul i64 %31, 4
%33 = trunc i64 %32 to i32
%34 = call float* @alloca(i32 %33)
store float* %34, float** %5
%35 = load i32, i32* %2
%36 = load i32, i32* %2
%37 = mul i32 %35, %36
%38 = zext i32 %37 to i64
%39 = mul i64 %38, 4
%40 = trunc i64 %39 to i32
%41 = call float* @alloca(i32 %40)
store float* %41, float** %6
store i32 0, i32* %8
br label %42
42: ; preds = %134, %0
%43 = load i32, i32* %8
%44 = load i32, i32* %2
%45 = icmp ult i32 %43, %44
br i1 %45, label %46, label %137
46: ; preds = %42
%47 = call i32 (...) @random()
%48 = load i32, i32* @RAND_MAX
%49 = sdiv i32 %48, 2
%50 = sub nsw i32 %47, %49
%51 = sitofp i32 %50 to double
%52 = load i32, i32* @RAND_MAX
%53 = sitofp i32 %52 to double
%54 = fdiv double 4.000000e+00, %53
%55 = fmul double %51, %54
%56 = fptrunc double %55 to float
%57 = load float*, float** %3
%58 = load i32, i32* %8
%59 = load i32, i32* %2
%60 = mul i32 %58, %59
%61 = load i32, i32* %8
%62 = add i32 %60, %61
%63 = zext i32 %62 to i64
%64 = getelementptr inbounds float, float* %57, i64 %63
store float %56, float* %64
%65 = load float*, float** %3
%66 = load i32, i32* %8
%67 = load i32, i32* %2
%68 = mul i32 %66, %67
%69 = load i32, i32* %8
%70 = add i32 %68, %69
%71 = zext i32 %70 to i64
%72 = getelementptr inbounds float, float* %65, i64 %71
%73 = load float, float* %72
%74 = load float*, float** %3
%75 = load i32, i32* %8
%76 = load i32, i32* %2
%77 = mul i32 %75, %76
%78 = load i32, i32* %8
%79 = add i32 %77, %78
%80 = zext i32 %79 to i64
%81 = getelementptr inbounds float, float* %74, i64 %80
%82 = load float, float* %81
%83 = fmul float %82, %73
store float %83, float* %81
%84 = load i32, i32* %8
%85 = add i32 %84, 1
store i32 %85, i32* %9
br label %86
86: ; preds = %130, %46
%87 = load i32, i32* %9
%88 = load i32, i32* %2
%89 = icmp ult i32 %87, %88
br i1 %89, label %90, label %133
90: ; preds = %86
%91 = call i32 (...) @random()
%92 = load i32, i32* @RAND_MAX
%93 = sdiv i32 %92, 2
%94 = sub nsw i32 %91, %93
%95 = sitofp i32 %94 to double
%96 = load i32, i32* @RAND_MAX
%97 = sitofp i32 %96 to double
%98 = fdiv double 4.000000e+00, %97
%99 = fmul double %95, %98
%100 = fptrunc double %99 to float
%101 = load float*, float** %3
%102 = load i32, i32* %9
%103 = load i32, i32* %2
%104 = mul i32 %102, %103
%105 = load i32, i32* %8
%106 = add i32 %104, %105
%107 = zext i32 %106 to i64
%108 = getelementptr inbounds float, float* %101, i64 %107
store float %100, float* %108
%109 = load float*, float** %3
%110 = load i32, i32* %8
%111 = load i32, i32* %2
%112 = mul i32 %110, %111
%113 = load i32, i32* %9
%114 = add i32 %112, %113
%115 = zext i32 %114 to i64
%116 = getelementptr inbounds float, float* %109, i64 %115
store float %100, float* %116
%117 = call double @fabs(float %100)
%118 = load float*, float** %3
%119 = load i32, i32* %8
%120 = load i32, i32* %2
%121 = mul i32 %119, %120
%122 = load i32, i32* %8
%123 = add i32 %121, %122
%124 = zext i32 %123 to i64
%125 = getelementptr inbounds float, float* %118, i64 %124
%126 = load float, float* %125
%127 = fpext float %126 to double
%128 = fadd double %127, %117
%129 = fptrunc double %128 to float
store float %129, float* %125
br label %130
130: ; preds = %90
%131 = load i32, i32* %9
%132 = add i32 %131, 1
store i32 %132, i32* %9
br label %86
133: ; preds = %86
br label %134
134: ; preds = %133
%135 = load i32, i32* %8
%136 = add i32 %135, 1
store i32 %136, i32* %8
br label %42
137: ; preds = %42
%138 = load float*, float** %3
%139 = load float*, float** %6
%140 = load i32, i32* %2
%141 = call i64 @frcholfactor(float* %138, float* %139, i32 %140)
%142 = icmp ne i64 %141, 0
br i1 %142, label %143, label %144
143: ; preds = %137
store i32 1, i32* %1
br label %267
144: ; preds = %137
store i32 0, i32* %8
br label %145
145: ; preds = %171, %144
%146 = load i32, i32* %8
%147 = load i32, i32* %2
%148 = icmp ult i32 %146, %147
br i1 %148, label %149, label %174
149: ; preds = %145
%150 = load float*, float** %4
%151 = load i32, i32* %8
%152 = load i32, i32* %2
%153 = mul i32 %151, %152
%154 = zext i32 %153 to i64
%155 = getelementptr inbounds float, float* %150, i64 %154
store float* %155, float** %7
%156 = load float*, float** %7
%157 = load i32, i32* %2
%158 = zext i32 %157 to i64
%159 = mul i64 %158, 4
%160 = trunc i64 %159 to i32
%161 = call i32 @memset(float* %156, i32 0, i32 %160)
%162 = load float*, float** %7
%163 = load i32, i32* %8
%164 = zext i32 %163 to i64
%165 = getelementptr inbounds float, float* %162, i64 %164
store float 1.000000e+00, float* %165
%166 = load float*, float** %6
%167 = load float*, float** %7
%168 = load float*, float** %7
%169 = load i32, i32* %2
%170 = call i32 @frcholapply(float* %166, float* %167, float* %168, i32 %169)
br label %171
171: ; preds = %149
%172 = load i32, i32* %8
%173 = add i32 %172, 1
store i32 %173, i32* %8
br label %145
174: ; preds = %145
%175 = load float*, float** %4
%176 = load float*, float** %4
%177 = load i32, i32* %2
%178 = load i32, i32* %2
%179 = call i32 @frtranspose(float* %175, float* %176, i32 %177, i32 %178)
%180 = load float*, float** %5
%181 = load float*, float** %3
%182 = load float*, float** %4
%183 = load i32, i32* %2
%184 = load i32, i32* %2
%185 = load i32, i32* %2
%186 = call i32 @frmul(float* %180, float* %181, float* %182, i32 %183, i32 %184, i32 %185)
store i32 0, i32* %8
br label %187
187: ; preds = %238, %174
%188 = load i32, i32* %8
%189 = load i32, i32* %2
%190 = icmp ult i32 %188, %189
br i1 %190, label %191, label %241
191: ; preds = %187
store i32 0, i32* %9
br label %192
192: ; preds = %234, %191
%193 = load i32, i32* %9
%194 = load i32, i32* %2
%195 = icmp ult i32 %193, %194
br i1 %195, label %196, label %237
196: ; preds = %192
%197 = load i32, i32* %8
%198 = load i32, i32* %9
%199 = icmp eq i32 %197, %198
br i1 %199, label %200, label %213
200: ; preds = %196
%201 = load float*, float** %5
%202 = load i32, i32* %8
%203 = load i32, i32* %2
%204 = mul i32 %202, %203
%205 = load i32, i32* %9
%206 = add i32 %204, %205
%207 = zext i32 %206 to i64
%208 = getelementptr inbounds float, float* %201, i64 %207
%209 = load float, float* %208
%210 = fsub float %209, 1.000000e+00
%211 = call double @fabs(float %210)
%212 = fcmp ogt double %211, 1.000000e-04
br i1 %212, label %230, label %213
213: ; preds = %200, %196
%214 = load i32, i32* %8
%215 = load i32, i32* %9
%216 = icmp ne i32 %214, %215
br i1 %216, label %217, label %233
217: ; preds = %213
%218 = load float*, float** %5
%219 = load i32, i32* %8
%220 = load i32, i32* %2
%221 = mul i32 %219, %220
%222 = load i32, i32* %9
%223 = add i32 %221, %222
%224 = zext i32 %223 to i64
%225 = getelementptr inbounds float, float* %218, i64 %224
%226 = load float, float* %225
%227 = fsub float %226, 0.000000e+00
%228 = call double @fabs(float %227)
%229 = fcmp ogt double %228, 1.000000e-04
br i1 %229, label %230, label %233
230: ; preds = %217, %200
%231 = load i32, i32* %10
%232 = or i32 %231, 1
store i32 %232, i32* %10
br label %233
233: ; preds = %230, %217, %213
br label %234
234: ; preds = %233
%235 = load i32, i32* %9
%236 = add i32 %235, 1
store i32 %236, i32* %9
br label %192
237: ; preds = %192
br label %238
238: ; preds = %237
%239 = load i32, i32* %8
%240 = add i32 %239, 1
store i32 %240, i32* %8
br label %187
241: ; preds = %187
%242 = load i32, i32* %10
%243 = and i32 %242, 1
%244 = icmp ne i32 %243, 0
br i1 %244, label %245, label %262
245: ; preds = %241
%246 = call i32 @printf(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str, i64 0, i64 0))
%247 = load i32, i32* %2
%248 = load i32, i32* %2
%249 = load i32, i32* %2
%250 = load float*, float** %3
%251 = call i32 @frmatprintf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0), i32 %247, i32 %248, i32 %249, i32 1, float* %250)
%252 = load i32, i32* %2
%253 = load i32, i32* %2
%254 = load i32, i32* %2
%255 = load float*, float** %4
%256 = call i32 @frmatprintf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i32 %252, i32 %253, i32 %254, i32 1, float* %255)
%257 = load i32, i32* %2
%258 = load i32, i32* %2
%259 = load i32, i32* %2
%260 = load float*, float** %5
%261 = call i32 @frmatprintf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.3, i64 0, i64 0), i32 %257, i32 %258, i32 %259, i32 1, float* %260)
br label %262
262: ; preds = %245, %241
%263 = load i32, i32* %10
%264 = icmp ne i32 %263, 0
%265 = zext i1 %264 to i64
%266 = select i1 %264, i32 1, i32 0
store i32 %266, i32* %1
br label %267
267: ; preds = %262, %143
%268 = load i32, i32* %1
ret i32 %268
}

LLVM IR (-O2):
@RAND_MAX = global i32 0
@.str.1 = [2 x i8] c"a\00"
@.str.2 = [2 x i8] c"b\00"
@.str.3 = [2 x i8] c"c\00"
@str = [26 x i8] c"Cholesky inversion error!\00"
define i32 @testfrchol() {
%1 = tail call i32 (...) @random()
%2 = and i32 %1, 15
%3 = add nuw nsw i32 %2, 1
%4 = shl nuw nsw i32 %3, 2
%5 = mul nuw nsw i32 %4, %3
%6 = tail call float* @alloca(i32 %5)
%7 = tail call float* @alloca(i32 %5)
%8 = tail call float* @alloca(i32 %5)
%9 = tail call float* @alloca(i32 %5)
%10 = zext i32 %3 to i64
%11 = zext i32 %2 to i64
br label %15
12: ; preds = %36, %15
%13 = add nuw nsw i64 %17, 1
%14 = icmp eq i64 %34, %10
br i1 %14, label %59, label %15
15: ; preds = %0, %12
%16 = phi i64 [ 0, %0 ], [ %34, %12 ]
%17 = phi i64 [ 1, %0 ], [ %13, %12 ]
%18 = trunc i64 %16 to i32
%19 = tail call i32 (...) @random()
%20 = load i32, i32* @RAND_MAX
%21 = sdiv i32 %20, -2
%22 = add i32 %21, %19
%23 = sitofp i32 %22 to double
%24 = sitofp i32 %20 to double
%25 = fdiv double 4.000000e+00, %24
%26 = fmul double %25, %23
%27 = fptrunc double %26 to float
%28 = mul nuw nsw i64 %16, %10
%29 = mul nuw nsw i32 %3, %18
%30 = zext i32 %29 to i64
%31 = add nuw nsw i64 %16, %30
%32 = getelementptr inbounds float, float* %6, i64 %31
%33 = fmul float %27, %27
store float %33, float* %32
%34 = add nuw nsw i64 %16, 1
%35 = icmp ult i64 %16, %11
br i1 %35, label %36, label %12
36: ; preds = %15, %36
%37 = phi i64 [ %57, %36 ], [ %17, %15 ]
%38 = tail call i32 (...) @random()
%39 = load i32, i32* @RAND_MAX
%40 = sdiv i32 %39, -2
%41 = add i32 %40, %38
%42 = sitofp i32 %41 to double
%43 = sitofp i32 %39 to double
%44 = fdiv double 4.000000e+00, %43
%45 = fmul double %44, %42
%46 = fptrunc double %45 to float
%47 = mul nuw nsw i64 %37, %10
%48 = add nuw nsw i64 %47, %16
%49 = getelementptr inbounds float, float* %6, i64 %48
store float %46, float* %49
%50 = add nuw nsw i64 %37, %28
%51 = getelementptr inbounds float, float* %6, i64 %50
store float %46, float* %51
%52 = tail call double @fabs(float %46)
%53 = load float, float* %32
%54 = fpext float %53 to double
%55 = fadd double %52, %54
%56 = fptrunc double %55 to float
store float %56, float* %32
%57 = add nuw nsw i64 %37, 1
%58 = icmp eq i64 %57, %10
br i1 %58, label %12, label %36
59: ; preds = %12
%60 = tail call i64 @frcholfactor(float* %6, float* %9, i32 %3)
%61 = icmp eq i64 %60, 0
br i1 %61, label %62, label %115
62: ; preds = %59, %62
%63 = phi i64 [ %69, %62 ], [ 0, %59 ]
%64 = mul nuw nsw i64 %63, %10
%65 = getelementptr inbounds float, float* %7, i64 %64
%66 = tail call i32 @memset(float* %65, i32 0, i32 %4)
%67 = getelementptr inbounds float, float* %65, i64 %63
store float 1.000000e+00, float* %67
%68 = tail call i32 @frcholapply(float* %9, float* %65, float* %65, i32 %3)
%69 = add nuw nsw i64 %63, 1
%70 = icmp eq i64 %69, %10
br i1 %70, label %71, label %62
71: ; preds = %62
%72 = tail call i32 @frtranspose(float* %7, float* %7, i32 %3, i32 %3)
%73 = tail call i32 @frmul(float* %8, float* %6, float* %7, i32 %3, i32 %3, i32 %3)
br label %74
74: ; preds = %71, %101
%75 = phi i64 [ 0, %71 ], [ %102, %101 ]
%76 = phi i32 [ 0, %71 ], [ %98, %101 ]
%77 = mul nuw nsw i64 %75, %10
%78 = add nuw nsw i64 %75, %77
%79 = getelementptr inbounds float, float* %8, i64 %78
br label %80
80: ; preds = %74, %97
%81 = phi i64 [ 0, %74 ], [ %99, %97 ]
%82 = phi i32 [ %76, %74 ], [ %98, %97 ]
%83 = icmp eq i64 %75, %81
br i1 %83, label %84, label %89
84: ; preds = %80
%85 = load float, float* %79
%86 = fadd float %85, -1.000000e+00
%87 = tail call double @fabs(float %86)
%88 = fcmp ogt double %87, 1.000000e-04
br i1 %88, label %95, label %97
89: ; preds = %80
%90 = add nuw nsw i64 %81, %77
%91 = getelementptr inbounds float, float* %8, i64 %90
%92 = load float, float* %91
%93 = tail call double @fabs(float %92)
%94 = fcmp ogt double %93, 1.000000e-04
br i1 %94, label %95, label %97
95: ; preds = %89, %84
%96 = or i32 %82, 1
br label %97
97: ; preds = %84, %89, %95
%98 = phi i32 [ %96, %95 ], [ %82, %89 ], [ %82, %84 ]
%99 = add nuw nsw i64 %81, 1
%100 = icmp eq i64 %99, %10
br i1 %100, label %101, label %80
101: ; preds = %97
%102 = add nuw nsw i64 %75, 1
%103 = icmp eq i64 %102, %10
br i1 %103, label %104, label %74
104: ; preds = %101
%105 = and i32 %98, 1
%106 = icmp eq i32 %105, 0
br i1 %106, label %112, label %107
107: ; preds = %104
%108 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([26 x i8], [26 x i8]* @str, i64 0, i64 0))
%109 = tail call i32 @frmatprintf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0), i32 %3, i32 %3, i32 %3, i32 1, float* %6)
%110 = tail call i32 @frmatprintf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0), i32 %3, i32 %3, i32 %3, i32 1, float* %7)
%111 = tail call i32 @frmatprintf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.3, i64 0, i64 0), i32 %3, i32 %3, i32 %3, i32 1, float* %8)
br label %112
112: ; preds = %107, %104
%113 = icmp ne i32 %98, 0
%114 = zext i1 %113 to i32
br label %115
115: ; preds = %59, %112
%116 = phi i32 [ %114, %112 ], [ 1, %59 ]
ret i32 %116
}