#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*/ choldc(float **, int, float *);
int /*<<< orphan*/ cholsl(float **, int, float *, float *, float *);
int /*<<< orphan*/ free_matrix(float **, int, int, int, int);
int /*<<< orphan*/ free_vector(float *, int, int);
float **matrix(int, int, int, int);
int /*<<< orphan*/ printf(char *, ...);
float *vector(int, int);
int main(void) {
  int i, j, k;
  float sum, **a, **atest, **chol, *p, *x;
  static float aorig[3 + 1][3 + 1] = {0.0,  0.0,  0.0,  0.0,  0.0, 100.0,
                                      15.0, 0.01, 0.0,  15.0, 2.3, 0.01,
                                      0.0,  0.01, 0.01, 1.0};
  static float b[3 + 1] = {0.0, 0.4, 0.02, 99.0};
  a = matrix(1, 3, 1, 3);
  atest = matrix(1, 3, 1, 3);
  chol = matrix(1, 3, 1, 3);
  p = vector(1, 3);
  x = vector(1, 3);
  for (i = 1; i <= 3; i++)
    for (j = 1; j <= 3; j++)
      a[i][j] = aorig[i][j];
  choldc(a, 3, p);
  printf("Original matrix:\n");
  for (i = 1; i <= 3; i++) {
    for (j = 1; j <= 3; j++) {
      chol[i][j] = ((i > j) ? a[i][j] : (i == j ? p[i] : 0.0));
      if (i > j)
        chol[i][j] = a[i][j];
      else
        chol[i][j] = (i == j ? p[i] : 0.0);
      printf("%16.6e", aorig[i][j]);
    }
    printf("\n");
  }
  printf("\n");
  printf("Product of Cholesky factors:\n");
  for (i = 1; i <= 3; i++) {
    for (j = 1; j <= 3; j++) {
      for (sum = 0.0, k = 1; k <= 3; k++)
        sum += chol[i][k] * chol[j][k];
      atest[i][j] = sum;
      printf("%16.6e", atest[i][j]);
    }
    printf("\n");
  }
  printf("\n");
  printf("Check solution vector:\n");
  cholsl(a, 3, p, b, x);
  for (i = 1; i <= 3; i++) {
    for (sum = 0.0, j = 1; j <= 3; j++)
      sum += aorig[i][j] * x[j];
    p[i] = sum;
    printf("%16.6e%16.6e\n", p[i], b[i]);
  }
  free_vector(x, 1, 3);
  free_vector(p, 1, 3);
  free_matrix(chol, 1, 3, 1, 3);
  free_matrix(atest, 1, 3, 1, 3);
  free_matrix(a, 1, 3, 1, 3);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
movl   $0x0,-0x4(%rbp)
mov    $0x1,%edx
mov    $0x3,%ecx
mov    %edx,%edi
mov    %ecx,%esi
call   1070 <matrix@plt>
mov    %rax,-0x20(%rbp)
mov    $0x1,%edx
mov    $0x3,%ecx
mov    %edx,%edi
mov    %ecx,%esi
call   1070 <matrix@plt>
mov    %rax,-0x28(%rbp)
mov    $0x1,%edx
mov    $0x3,%ecx
mov    %edx,%edi
mov    %ecx,%esi
call   1070 <matrix@plt>
mov    %rax,-0x30(%rbp)
mov    $0x1,%edi
mov    $0x3,%esi
call   1080 <vector@plt>
mov    %rax,-0x38(%rbp)
mov    $0x1,%edi
mov    $0x3,%esi
call   1080 <vector@plt>
mov    %rax,-0x40(%rbp)
movl   $0x1,-0x8(%rbp)
cmpl   $0x3,-0x8(%rbp)
jg     125d <main+0xed>
movl   $0x1,-0xc(%rbp)
cmpl   $0x3,-0xc(%rbp)
jg     124a <main+0xda>
movslq -0x8(%rbp),%rcx
lea    0x2e49(%rip),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0xc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xc(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1202 <main+0x92>
jmp    124f <main+0xdf>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    11f1 <main+0x81>
mov    -0x20(%rbp),%rdi
mov    -0x38(%rbp),%rdx
mov    $0x3,%esi
call   1030 <choldc@plt>
lea    0xd8a(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x1,-0x8(%rbp)
cmpl   $0x3,-0x8(%rbp)
jg     140e <main+0x29e>
movl   $0x1,-0xc(%rbp)
cmpl   $0x3,-0xc(%rbp)
jg     13f2 <main+0x282>
mov    -0x8(%rbp),%eax
cmp    -0xc(%rbp),%eax
jle    12ce <main+0x15e>
mov    -0x20(%rbp),%rax
movslq -0x8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x48(%rbp)
jmp    130c <main+0x19c>
mov    -0x8(%rbp),%eax
cmp    -0xc(%rbp),%eax
jne    12f5 <main+0x185>
mov    -0x38(%rbp),%rax
movslq -0x8(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
jmp    1302 <main+0x192>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
jmp    1302 <main+0x192>
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x48(%rbp)
movsd  -0x48(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x30(%rbp),%rax
movslq -0x8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xc(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%eax
cmp    -0xc(%rbp),%eax
jle    1365 <main+0x1f5>
mov    -0x20(%rbp),%rax
movslq -0x8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xc(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    13b7 <main+0x247>
mov    -0x8(%rbp),%eax
cmp    -0xc(%rbp),%eax
jne    138c <main+0x21c>
mov    -0x38(%rbp),%rax
movslq -0x8(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
jmp    1399 <main+0x229>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
jmp    1399 <main+0x229>
movsd  -0x58(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x30(%rbp),%rax
movslq -0x8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xc(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movslq -0x8(%rbp),%rcx
lea    0x2c9e(%rip),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0xc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xc35(%rip),%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1295 <main+0x125>
lea    0xc54(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1284 <main+0x114>
lea    0xc38(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0xbf6(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0x1,-0x8(%rbp)
cmpl   $0x3,-0x8(%rbp)
jg     151a <main+0x3aa>
movl   $0x1,-0xc(%rbp)
cmpl   $0x3,-0xc(%rbp)
jg     14fe <main+0x38e>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x14(%rbp)
movl   $0x1,-0x10(%rbp)
cmpl   $0x3,-0x10(%rbp)
jg     14af <main+0x33f>
mov    -0x30(%rbp),%rax
movslq -0x8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x10(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x10(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x14(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x14(%rbp)
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    145b <main+0x2eb>
movss  -0x14(%rbp),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xc(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
movslq -0x8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xb29(%rip),%rdi
mov    $0x1,%al
call   1050 <printf@plt>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1442 <main+0x2d2>
lea    0xb48(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1431 <main+0x2c1>
lea    0xb2c(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0xb08(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x20(%rbp),%rdi
mov    -0x38(%rbp),%rdx
mov    -0x40(%rbp),%r8
mov    $0x3,%esi
lea    0x2b52(%rip),%rcx
call   1090 <cholsl@plt>
movl   $0x1,-0x8(%rbp)
cmpl   $0x3,-0x8(%rbp)
jg     1618 <main+0x4a8>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x14(%rbp)
movl   $0x1,-0xc(%rbp)
cmpl   $0x3,-0xc(%rbp)
jg     15c5 <main+0x455>
movslq -0x8(%rbp),%rcx
lea    0x2ad8(%rip),%rax
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0xc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x40(%rbp),%rax
movslq -0xc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x14(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x14(%rbp)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1573 <main+0x403>
movss  -0x14(%rbp),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x8(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%rax
movslq -0x8(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movslq -0x8(%rbp),%rcx
lea    0x2aad(%rip),%rax
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
lea    0xa4c(%rip),%rdi
mov    $0x2,%al
call   1050 <printf@plt>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    155a <main+0x3ea>
mov    -0x40(%rbp),%rdi
mov    $0x1,%esi
mov    $0x3,%edx
call   1060 <free_vector@plt>
mov    -0x38(%rbp),%rdi
mov    $0x1,%esi
mov    $0x3,%edx
call   1060 <free_vector@plt>
mov    -0x30(%rbp),%rdi
mov    $0x1,%ecx
mov    $0x3,%r8d
mov    %ecx,%esi
mov    %r8d,%edx
call   1040 <free_matrix@plt>
mov    -0x28(%rbp),%rdi
mov    $0x1,%ecx
mov    $0x3,%r8d
mov    %ecx,%esi
mov    %r8d,%edx
call   1040 <free_matrix@plt>
mov    -0x20(%rbp),%rdi
mov    $0x1,%ecx
mov    $0x3,%r8d
mov    %ecx,%esi
mov    %r8d,%edx
call   1040 <free_matrix@plt>
xor    %eax,%eax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    $0x1,%edi
mov    $0x3,%esi
mov    $0x1,%edx
mov    $0x3,%ecx
call   1090 <matrix@plt>
mov    %rax,%rbp
mov    $0x1,%edi
mov    $0x3,%esi
mov    $0x1,%edx
mov    $0x3,%ecx
call   1090 <matrix@plt>
mov    %rax,%r15
mov    $0x1,%edi
mov    $0x3,%esi
mov    $0x1,%edx
mov    $0x3,%ecx
call   1090 <matrix@plt>
mov    %rax,%rbx
mov    $0x1,%edi
mov    $0x3,%esi
call   10a0 <vector@plt>
mov    %rax,%r14
mov    $0x1,%edi
mov    $0x3,%esi
call   10a0 <vector@plt>
mov    %rax,0x10(%rsp)
mov    0x8(%rbp),%rax
mov    0xe11(%rip),%rcx
mov    %rcx,0x4(%rax)
mov    0xe0f(%rip),%ecx
mov    %ecx,0xc(%rax)
mov    0x10(%rbp),%rax
mov    0xe09(%rip),%rcx
mov    %rcx,0x4(%rax)
mov    0xe07(%rip),%ecx
mov    %ecx,0xc(%rax)
mov    0x18(%rbp),%rax
mov    0xe01(%rip),%rcx
mov    %rcx,0x4(%rax)
mov    0xdff(%rip),%ecx
mov    %ecx,0xc(%rax)
mov    %rbp,0x8(%rsp)
mov    %rbp,%rdi
mov    $0x3,%esi
mov    %r14,(%rsp)
mov    %r14,%rdx
call   1040 <choldc@plt>
lea    0xdf5(%rip),%rdi
call   1050 <puts@plt>
lea    0xdb0(%rip),%r13
xor    %r14d,%r14d
lea    0xdca(%rip),%rbp
jmp    12fb <main+0x16b>
nopl   0x0(%rax,%rax,1)
mov    (%rsp),%rcx
movss  0x4(%rcx,%r14,4),%xmm0
mov    0x8(%rbx,%r14,8),%rax
movss  %xmm0,0xc(%rax)
add    $0xc,%rax
movss  0x4(%rcx,%r14,4),%xmm0
cvtss2sd %xmm0,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rax)
movss  0x0(%r13),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbp,%rdi
mov    $0x1,%al
call   1070 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
add    $0x10,%r13
mov    %r12,%r14
cmp    $0x3,%r12
je     1441 <main+0x2b1>
lea    0x1(%r14),%r12
cmp    $0x1,%r12
jbe    1330 <main+0x1a0>
mov    0x8(%rsp),%rax
mov    0x8(%rax,%r14,8),%rax
movss  0x4(%rax),%xmm0
mov    0x8(%rbx,%r14,8),%rcx
movss  %xmm0,0x4(%rcx)
movss  0x4(%rax),%xmm0
movss  %xmm0,0x4(%rcx)
jmp    1376 <main+0x1e6>
nopw   0x0(%rax,%rax,1)
test   %r14,%r14
je     134a <main+0x1ba>
mov    0x8(%rbx,%r14,8),%rax
movl   $0x0,0x4(%rax)
add    $0x4,%rax
xorps  %xmm0,%xmm0
jmp    136e <main+0x1de>
mov    (%rsp),%rcx
movss  0x4(%rcx,%r14,4),%xmm0
mov    0x8(%rbx,%r14,8),%rax
movss  %xmm0,0x4(%rax)
add    $0x4,%rax
movss  0x4(%rcx,%r14,4),%xmm0
cvtss2sd %xmm0,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rax)
movss  -0x8(%r13),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbp,%rdi
mov    $0x1,%al
call   1070 <printf@plt>
cmp    $0x2,%r12
jbe    13c0 <main+0x230>
mov    0x8(%rsp),%rax
mov    0x8(%rax,%r14,8),%rax
movss  0x8(%rax),%xmm0
mov    0x8(%rbx,%r14,8),%rcx
movss  %xmm0,0x8(%rcx)
movss  0x8(%rax),%xmm0
movss  %xmm0,0x8(%rcx)
jmp    140b <main+0x27b>
cs nopw 0x0(%rax,%rax,1)
nop
cmp    $0x1,%r14
jne    13f0 <main+0x260>
mov    (%rsp),%rcx
movss  0x4(%rcx,%r14,4),%xmm0
mov    0x8(%rbx,%r14,8),%rax
movss  %xmm0,0x8(%rax)
add    $0x8,%rax
movss  0x4(%rcx,%r14,4),%xmm0
cvtss2sd %xmm0,%xmm0
jmp    1403 <main+0x273>
nopl   0x0(%rax)
mov    0x8(%rbx,%r14,8),%rax
movl   $0x0,0x8(%rax)
add    $0x8,%rax
xorps  %xmm0,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rax)
movss  -0x4(%r13),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %rbp,%rdi
mov    $0x1,%al
call   1070 <printf@plt>
cmp    $0x2,%r14
je     12a0 <main+0x110>
mov    0x8(%rbx,%r14,8),%rax
movl   $0x0,0xc(%rax)
add    $0xc,%rax
xorps  %xmm0,%xmm0
jmp    12c4 <main+0x134>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0xc34(%rip),%rdi
call   1050 <puts@plt>
mov    $0x1,%ebp
lea    0xbfd(%rip),%r14
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%rbx,%rbp,8),%rax
mov    0x8(%rbx),%rcx
movss  0x4(%rax),%xmm0
mulss  0x4(%rcx),%xmm0
movss  0x8(%rax),%xmm1
xorps  %xmm2,%xmm2
addss  %xmm2,%xmm0
mulss  0x8(%rcx),%xmm1
addss  %xmm0,%xmm1
movss  0xc(%rax),%xmm0
mulss  0xc(%rcx),%xmm0
addss  %xmm1,%xmm0
mov    (%r15,%rbp,8),%rax
movss  %xmm0,0x4(%rax)
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1070 <printf@plt>
mov    (%rbx,%rbp,8),%rax
mov    0x10(%rbx),%rcx
movss  0x4(%rax),%xmm0
mulss  0x4(%rcx),%xmm0
movss  0x8(%rax),%xmm1
addss  0xb35(%rip),%xmm0
mulss  0x8(%rcx),%xmm1
addss  %xmm0,%xmm1
movss  0xc(%rax),%xmm0
mulss  0xc(%rcx),%xmm0
addss  %xmm1,%xmm0
mov    (%r15,%rbp,8),%rax
movss  %xmm0,0x8(%rax)
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1070 <printf@plt>
mov    (%rbx,%rbp,8),%rax
mov    0x18(%rbx),%rcx
movss  0x4(%rax),%xmm0
mulss  0x4(%rcx),%xmm0
movss  0x8(%rax),%xmm1
addss  0xae8(%rip),%xmm0
mulss  0x8(%rcx),%xmm1
addss  %xmm0,%xmm1
movss  0xc(%rax),%xmm0
mulss  0xc(%rcx),%xmm0
addss  %xmm1,%xmm0
mov    (%r15,%rbp,8),%rax
movss  %xmm0,0xc(%rax)
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1070 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
add    $0x1,%rbp
cmp    $0x4,%rbp
jne    1470 <main+0x2e0>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0xb24(%rip),%rdi
call   1050 <puts@plt>
lea    0x2ae5(%rip),%rcx
mov    0x8(%rsp),%r14
mov    %r14,%rdi
mov    $0x3,%esi
mov    (%rsp),%r13
mov    %r13,%rdx
mov    0x10(%rsp),%rbp
mov    %rbp,%r8
call   10b0 <cholsl@plt>
movss  0x4(%rbp),%xmm0
mulss  0xa47(%rip),%xmm0
xorps  %xmm1,%xmm1
addss  %xmm1,%xmm0
movss  0x8(%rbp),%xmm1
mulss  0xa37(%rip),%xmm1
addss  %xmm0,%xmm1
movss  0xc(%rbp),%xmm0
mulss  0xa2a(%rip),%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x4(%r13)
cvtss2sd %xmm0,%xmm0
movss  0x2a80(%rip),%xmm1
cvtss2sd %xmm1,%xmm1
lea    0xa68(%rip),%r12
mov    %r12,%rdi
mov    $0x2,%al
call   1070 <printf@plt>
movss  0x9f3(%rip),%xmm0
mulss  0x4(%rbp),%xmm0
addss  0x9f2(%rip),%xmm0
movaps %xmm0,%xmm1
movss  0x8(%rbp),%xmm0
mulss  0x9de(%rip),%xmm0
addss  %xmm1,%xmm0
movss  0xc(%rbp),%xmm1
mulss  0x9c9(%rip),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,0x8(%r13)
xorps  %xmm0,%xmm0
cvtss2sd %xmm1,%xmm0
movss  0x2a20(%rip),%xmm1
cvtss2sd %xmm1,%xmm1
mov    %r12,%rdi
mov    $0x2,%al
call   1070 <printf@plt>
movss  0x4(%rbp),%xmm0
movss  0x995(%rip),%xmm1
mulss  %xmm1,%xmm0
mulss  0x8(%rbp),%xmm1
addss  0x98c(%rip),%xmm0
addss  %xmm0,%xmm1
addss  0xc(%rbp),%xmm1
movss  %xmm1,0xc(%r13)
xorps  %xmm0,%xmm0
cvtss2sd %xmm1,%xmm0
movss  0x29da(%rip),%xmm1
cvtss2sd %xmm1,%xmm1
mov    %r12,%rdi
mov    $0x2,%al
call   1070 <printf@plt>
mov    %rbp,%rdi
mov    $0x1,%esi
mov    $0x3,%edx
call   1080 <free_vector@plt>
mov    %r13,%rdi
mov    $0x1,%esi
mov    $0x3,%edx
call   1080 <free_vector@plt>
mov    %rbx,%rdi
mov    $0x1,%esi
mov    $0x3,%edx
mov    $0x1,%ecx
mov    $0x3,%r8d
call   1060 <free_matrix@plt>
mov    %r15,%rdi
mov    $0x1,%esi
mov    $0x3,%edx
mov    $0x1,%ecx
mov    $0x3,%r8d
call   1060 <free_matrix@plt>
mov    %r14,%rdi
mov    $0x1,%esi
mov    $0x3,%edx
mov    $0x1,%ecx
mov    $0x3,%r8d
call   1060 <free_matrix@plt>
xor    %eax,%eax
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@main.aorig = internal global [4 x [4 x float]] [[4 x float] zeroinitializer, [4 x float] [float 0.000000e+00, float 1.000000e+02, float 1.500000e+01, float 0x3F847AE140000000], [4 x float] [float 0.000000e+00, float 1.500000e+01, float 0x4002666660000000, float 0x3F847AE140000000], [4 x float] [float 0.000000e+00, float 0x3F847AE140000000, float 0x3F847AE140000000, float 1.000000e+00]]
@main.b = internal global [4 x float] [float 0.000000e+00, float 0x3FD99999A0000000, float 0x3F947AE140000000, float 9.900000e+01]
@.str = [18 x i8] c"Original matrix:\0A\00"
@.str.1 = [7 x i8] c"%16.6e\00"
@.str.2 = [2 x i8] c"\0A\00"
@.str.3 = [30 x i8] c"Product of Cholesky factors:\0A\00"
@.str.4 = [24 x i8] c"Check solution vector:\0A\00"
@.str.5 = [14 x i8] c"%16.6e%16.6e\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca i32
%4 = alloca i32
%5 = alloca float
%6 = alloca float**
%7 = alloca float**
%8 = alloca float**
%9 = alloca float*
%10 = alloca float*
store i32 0, i32* %1
%11 = call float** @matrix(i32 1, i32 3, i32 1, i32 3)
store float** %11, float*** %6
%12 = call float** @matrix(i32 1, i32 3, i32 1, i32 3)
store float** %12, float*** %7
%13 = call float** @matrix(i32 1, i32 3, i32 1, i32 3)
store float** %13, float*** %8
%14 = call float* @vector(i32 1, i32 3)
store float* %14, float** %9
%15 = call float* @vector(i32 1, i32 3)
store float* %15, float** %10
store i32 1, i32* %2
br label %16
16: ; preds = %43, %0
%17 = load i32, i32* %2
%18 = icmp sle i32 %17, 3
br i1 %18, label %19, label %46
19: ; preds = %16
store i32 1, i32* %3
br label %20
20: ; preds = %39, %19
%21 = load i32, i32* %3
%22 = icmp sle i32 %21, 3
br i1 %22, label %23, label %42
23: ; preds = %20
%24 = load i32, i32* %2
%25 = sext i32 %24 to i64
%26 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* @main.aorig, i64 0, i64 %25
%27 = load i32, i32* %3
%28 = sext i32 %27 to i64
%29 = getelementptr inbounds [4 x float], [4 x float]* %26, i64 0, i64 %28
%30 = load float, float* %29
%31 = load float**, float*** %6
%32 = load i32, i32* %2
%33 = sext i32 %32 to i64
%34 = getelementptr inbounds float*, float** %31, i64 %33
%35 = load float*, float** %34
%36 = load i32, i32* %3
%37 = sext i32 %36 to i64
%38 = getelementptr inbounds float, float* %35, i64 %37
store float %30, float* %38
br label %39
39: ; preds = %23
%40 = load i32, i32* %3
%41 = add nsw i32 %40, 1
store i32 %41, i32* %3
br label %20
42: ; preds = %20
br label %43
43: ; preds = %42
%44 = load i32, i32* %2
%45 = add nsw i32 %44, 1
store i32 %45, i32* %2
br label %16
46: ; preds = %16
%47 = load float**, float*** %6
%48 = load float*, float** %9
%49 = call i32 @choldc(float** %47, i32 3, float* %48)
%50 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([18 x i8], [18 x i8]* @.str, i64 0, i64 0))
store i32 1, i32* %2
br label %51
51: ; preds = %157, %46
%52 = load i32, i32* %2
%53 = icmp sle i32 %52, 3
br i1 %53, label %54, label %160
54: ; preds = %51
store i32 1, i32* %3
br label %55
55: ; preds = %152, %54
%56 = load i32, i32* %3
%57 = icmp sle i32 %56, 3
br i1 %57, label %58, label %155
58: ; preds = %55
%59 = load i32, i32* %2
%60 = load i32, i32* %3
%61 = icmp sgt i32 %59, %60
br i1 %61, label %62, label %73
62: ; preds = %58
%63 = load float**, float*** %6
%64 = load i32, i32* %2
%65 = sext i32 %64 to i64
%66 = getelementptr inbounds float*, float** %63, i64 %65
%67 = load float*, float** %66
%68 = load i32, i32* %3
%69 = sext i32 %68 to i64
%70 = getelementptr inbounds float, float* %67, i64 %69
%71 = load float, float* %70
%72 = fpext float %71 to double
br label %87
73: ; preds = %58
%74 = load i32, i32* %2
%75 = load i32, i32* %3
%76 = icmp eq i32 %74, %75
br i1 %76, label %77, label %84
77: ; preds = %73
%78 = load float*, float** %9
%79 = load i32, i32* %2
%80 = sext i32 %79 to i64
%81 = getelementptr inbounds float, float* %78, i64 %80
%82 = load float, float* %81
%83 = fpext float %82 to double
br label %85
84: ; preds = %73
br label %85
85: ; preds = %84, %77
%86 = phi double [ %83, %77 ], [ 0.000000e+00, %84 ]
br label %87
87: ; preds = %85, %62
%88 = phi double [ %72, %62 ], [ %86, %85 ]
%89 = fptrunc double %88 to float
%90 = load float**, float*** %8
%91 = load i32, i32* %2
%92 = sext i32 %91 to i64
%93 = getelementptr inbounds float*, float** %90, i64 %92
%94 = load float*, float** %93
%95 = load i32, i32* %3
%96 = sext i32 %95 to i64
%97 = getelementptr inbounds float, float* %94, i64 %96
store float %89, float* %97
%98 = load i32, i32* %2
%99 = load i32, i32* %3
%100 = icmp sgt i32 %98, %99
br i1 %100, label %101, label %119
101: ; preds = %87
%102 = load float**, float*** %6
%103 = load i32, i32* %2
%104 = sext i32 %103 to i64
%105 = getelementptr inbounds float*, float** %102, i64 %104
%106 = load float*, float** %105
%107 = load i32, i32* %3
%108 = sext i32 %107 to i64
%109 = getelementptr inbounds float, float* %106, i64 %108
%110 = load float, float* %109
%111 = load float**, float*** %8
%112 = load i32, i32* %2
%113 = sext i32 %112 to i64
%114 = getelementptr inbounds float*, float** %111, i64 %113
%115 = load float*, float** %114
%116 = load i32, i32* %3
%117 = sext i32 %116 to i64
%118 = getelementptr inbounds float, float* %115, i64 %117
store float %110, float* %118
br label %142
119: ; preds = %87
%120 = load i32, i32* %2
%121 = load i32, i32* %3
%122 = icmp eq i32 %120, %121
br i1 %122, label %123, label %130
123: ; preds = %119
%124 = load float*, float** %9
%125 = load i32, i32* %2
%126 = sext i32 %125 to i64
%127 = getelementptr inbounds float, float* %124, i64 %126
%128 = load float, float* %127
%129 = fpext float %128 to double
br label %131
130: ; preds = %119
br label %131
131: ; preds = %130, %123
%132 = phi double [ %129, %123 ], [ 0.000000e+00, %130 ]
%133 = fptrunc double %132 to float
%134 = load float**, float*** %8
%135 = load i32, i32* %2
%136 = sext i32 %135 to i64
%137 = getelementptr inbounds float*, float** %134, i64 %136
%138 = load float*, float** %137
%139 = load i32, i32* %3
%140 = sext i32 %139 to i64
%141 = getelementptr inbounds float, float* %138, i64 %140
store float %133, float* %141
br label %142
142: ; preds = %131, %101
%143 = load i32, i32* %2
%144 = sext i32 %143 to i64
%145 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* @main.aorig, i64 0, i64 %144
%146 = load i32, i32* %3
%147 = sext i32 %146 to i64
%148 = getelementptr inbounds [4 x float], [4 x float]* %145, i64 0, i64 %147
%149 = load float, float* %148
%150 = fpext float %149 to double
%151 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %150)
br label %152
152: ; preds = %142
%153 = load i32, i32* %3
%154 = add nsw i32 %153, 1
store i32 %154, i32* %3
br label %55
155: ; preds = %55
%156 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
br label %157
157: ; preds = %155
%158 = load i32, i32* %2
%159 = add nsw i32 %158, 1
store i32 %159, i32* %2
br label %51
160: ; preds = %51
%161 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%162 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([30 x i8], [30 x i8]* @.str.3, i64 0, i64 0))
store i32 1, i32* %2
br label %163
163: ; preds = %224, %160
%164 = load i32, i32* %2
%165 = icmp sle i32 %164, 3
br i1 %165, label %166, label %227
166: ; preds = %163
store i32 1, i32* %3
br label %167
167: ; preds = %219, %166
%168 = load i32, i32* %3
%169 = icmp sle i32 %168, 3
br i1 %169, label %170, label %222
170: ; preds = %167
store float 0.000000e+00, float* %5
store i32 1, i32* %4
br label %171
171: ; preds = %195, %170
%172 = load i32, i32* %4
%173 = icmp sle i32 %172, 3
br i1 %173, label %174, label %198
174: ; preds = %171
%175 = load float**, float*** %8
%176 = load i32, i32* %2
%177 = sext i32 %176 to i64
%178 = getelementptr inbounds float*, float** %175, i64 %177
%179 = load float*, float** %178
%180 = load i32, i32* %4
%181 = sext i32 %180 to i64
%182 = getelementptr inbounds float, float* %179, i64 %181
%183 = load float, float* %182
%184 = load float**, float*** %8
%185 = load i32, i32* %3
%186 = sext i32 %185 to i64
%187 = getelementptr inbounds float*, float** %184, i64 %186
%188 = load float*, float** %187
%189 = load i32, i32* %4
%190 = sext i32 %189 to i64
%191 = getelementptr inbounds float, float* %188, i64 %190
%192 = load float, float* %191
%193 = load float, float* %5
%194 = call float @llvm.fmuladd.f32(float %183, float %192, float %193)
store float %194, float* %5
br label %195
195: ; preds = %174
%196 = load i32, i32* %4
%197 = add nsw i32 %196, 1
store i32 %197, i32* %4
br label %171
198: ; preds = %171
%199 = load float, float* %5
%200 = load float**, float*** %7
%201 = load i32, i32* %2
%202 = sext i32 %201 to i64
%203 = getelementptr inbounds float*, float** %200, i64 %202
%204 = load float*, float** %203
%205 = load i32, i32* %3
%206 = sext i32 %205 to i64
%207 = getelementptr inbounds float, float* %204, i64 %206
store float %199, float* %207
%208 = load float**, float*** %7
%209 = load i32, i32* %2
%210 = sext i32 %209 to i64
%211 = getelementptr inbounds float*, float** %208, i64 %210
%212 = load float*, float** %211
%213 = load i32, i32* %3
%214 = sext i32 %213 to i64
%215 = getelementptr inbounds float, float* %212, i64 %214
%216 = load float, float* %215
%217 = fpext float %216 to double
%218 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %217)
br label %219
219: ; preds = %198
%220 = load i32, i32* %3
%221 = add nsw i32 %220, 1
store i32 %221, i32* %3
br label %167
222: ; preds = %167
%223 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
br label %224
224: ; preds = %222
%225 = load i32, i32* %2
%226 = add nsw i32 %225, 1
store i32 %226, i32* %2
br label %163
227: ; preds = %163
%228 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
%229 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.4, i64 0, i64 0))
%230 = load float**, float*** %6
%231 = load float*, float** %9
%232 = load float*, float** %10
%233 = call i32 @cholsl(float** %230, i32 3, float* %231, float* getelementptr inbounds ([4 x float], [4 x float]* @main.b, i64 0, i64 0), float* %232)
store i32 1, i32* %2
br label %234
234: ; preds = %277, %227
%235 = load i32, i32* %2
%236 = icmp sle i32 %235, 3
br i1 %236, label %237, label %280
237: ; preds = %234
store float 0.000000e+00, float* %5
store i32 1, i32* %3
br label %238
238: ; preds = %256, %237
%239 = load i32, i32* %3
%240 = icmp sle i32 %239, 3
br i1 %240, label %241, label %259
241: ; preds = %238
%242 = load i32, i32* %2
%243 = sext i32 %242 to i64
%244 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* @main.aorig, i64 0, i64 %243
%245 = load i32, i32* %3
%246 = sext i32 %245 to i64
%247 = getelementptr inbounds [4 x float], [4 x float]* %244, i64 0, i64 %246
%248 = load float, float* %247
%249 = load float*, float** %10
%250 = load i32, i32* %3
%251 = sext i32 %250 to i64
%252 = getelementptr inbounds float, float* %249, i64 %251
%253 = load float, float* %252
%254 = load float, float* %5
%255 = call float @llvm.fmuladd.f32(float %248, float %253, float %254)
store float %255, float* %5
br label %256
256: ; preds = %241
%257 = load i32, i32* %3
%258 = add nsw i32 %257, 1
store i32 %258, i32* %3
br label %238
259: ; preds = %238
%260 = load float, float* %5
%261 = load float*, float** %9
%262 = load i32, i32* %2
%263 = sext i32 %262 to i64
%264 = getelementptr inbounds float, float* %261, i64 %263
store float %260, float* %264
%265 = load float*, float** %9
%266 = load i32, i32* %2
%267 = sext i32 %266 to i64
%268 = getelementptr inbounds float, float* %265, i64 %267
%269 = load float, float* %268
%270 = fpext float %269 to double
%271 = load i32, i32* %2
%272 = sext i32 %271 to i64
%273 = getelementptr inbounds [4 x float], [4 x float]* @main.b, i64 0, i64 %272
%274 = load float, float* %273
%275 = fpext float %274 to double
%276 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.5, i64 0, i64 0), double %270, double %275)
br label %277
277: ; preds = %259
%278 = load i32, i32* %2
%279 = add nsw i32 %278, 1
store i32 %279, i32* %2
br label %234
280: ; preds = %234
%281 = load float*, float** %10
%282 = call i32 @free_vector(float* %281, i32 1, i32 3)
%283 = load float*, float** %9
%284 = call i32 @free_vector(float* %283, i32 1, i32 3)
%285 = load float**, float*** %8
%286 = call i32 @free_matrix(float** %285, i32 1, i32 3, i32 1, i32 3)
%287 = load float**, float*** %7
%288 = call i32 @free_matrix(float** %287, i32 1, i32 3, i32 1, i32 3)
%289 = load float**, float*** %6
%290 = call i32 @free_matrix(float** %289, i32 1, i32 3, i32 1, i32 3)
ret i32 0
}

LLVM IR (-O2):
@main.aorig = internal unnamed_addr constant [4 x [4 x float]] [[4 x float] zeroinitializer, [4 x float] [float 0.000000e+00, float 1.000000e+02, float 1.500000e+01, float 0x3F847AE140000000], [4 x float] [float 0.000000e+00, float 1.500000e+01, float 0x4002666660000000, float 0x3F847AE140000000], [4 x float] [float 0.000000e+00, float 0x3F847AE140000000, float 0x3F847AE140000000, float 1.000000e+00]]
@main.b = internal global [4 x float] [float 0.000000e+00, float 0x3FD99999A0000000, float 0x3F947AE140000000, float 9.900000e+01]
@.str.1 = [7 x i8] c"%16.6e\00"
@.str.5 = [14 x i8] c"%16.6e%16.6e\0A\00"
@str = [17 x i8] c"Original matrix:\00"
@str.6 = [29 x i8] c"Product of Cholesky factors:\00"
@str.7 = [23 x i8] c"Check solution vector:\00"
define i32 @main() {
%1 = tail call float** @matrix(i32 1, i32 3, i32 1, i32 3)
%2 = tail call float** @matrix(i32 1, i32 3, i32 1, i32 3)
%3 = tail call float** @matrix(i32 1, i32 3, i32 1, i32 3)
%4 = tail call float* @vector(i32 1, i32 3)
%5 = tail call float* @vector(i32 1, i32 3)
%6 = getelementptr inbounds float*, float** %1, i64 1
%7 = load float*, float** %6
%8 = getelementptr float, float* %7, i64 1
%9 = bitcast float* %8 to i8*
%10 = getelementptr inbounds float*, float** %1, i64 2
%11 = load float*, float** %10
%12 = getelementptr float, float* %11, i64 1
%13 = bitcast float* %12 to i8*
%14 = getelementptr inbounds float*, float** %1, i64 3
%15 = load float*, float** %14
%16 = getelementptr float, float* %15, i64 1
%17 = bitcast float* %16 to i8*
%18 = tail call i32 @choldc(float** %1, i32 3, float* %4)
%19 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @str, i64 0, i64 0))
br label %20
20: ; preds = %0, %91
%21 = phi i64 [ 1, %0 ], [ %100, %91 ]
%22 = getelementptr inbounds float, float* %4, i64 %21
%23 = getelementptr inbounds float*, float** %3, i64 %21
%24 = getelementptr inbounds float*, float** %1, i64 %21
%25 = icmp ugt i64 %21, 1
br i1 %25, label %28, label %26
26: ; preds = %20
%27 = icmp eq i64 %21, 1
br i1 %27, label %38, label %35
28: ; preds = %20
%29 = load float*, float** %24
%30 = getelementptr inbounds float, float* %29, i64 1
%31 = load float, float* %30
%32 = load float*, float** %23
%33 = getelementptr inbounds float, float* %32, i64 1
store float %31, float* %33
%34 = load float, float* %30
store float %34, float* %33
br label %48
35: ; preds = %26
%36 = load float*, float** %23
%37 = getelementptr inbounds float, float* %36, i64 1
store float 0.000000e+00, float* %37
br label %44
38: ; preds = %26
%39 = load float, float* %22
%40 = load float*, float** %23
%41 = getelementptr inbounds float, float* %40, i64 1
store float %39, float* %41
%42 = load float, float* %22
%43 = fpext float %42 to double
br label %44
44: ; preds = %35, %38
%45 = phi float* [ %41, %38 ], [ %37, %35 ]
%46 = phi double [ %43, %38 ], [ 0.000000e+00, %35 ]
%47 = fptrunc double %46 to float
store float %47, float* %45
br label %48
48: ; preds = %44, %28
%49 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* @main.aorig, i64 0, i64 %21, i64 1
%50 = load float, float* %49
%51 = fpext float %50 to double
%52 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %51)
%53 = icmp ugt i64 %21, 2
br i1 %53, label %69, label %54
54: ; preds = %48
%55 = icmp eq i64 %21, 2
br i1 %55, label %59, label %56
56: ; preds = %54
%57 = load float*, float** %23
%58 = getelementptr inbounds float, float* %57, i64 2
store float 0.000000e+00, float* %58
br label %65
59: ; preds = %54
%60 = load float, float* %22
%61 = load float*, float** %23
%62 = getelementptr inbounds float, float* %61, i64 2
store float %60, float* %62
%63 = load float, float* %22
%64 = fpext float %63 to double
br label %65
65: ; preds = %56, %59
%66 = phi float* [ %62, %59 ], [ %58, %56 ]
%67 = phi double [ %64, %59 ], [ 0.000000e+00, %56 ]
%68 = fptrunc double %67 to float
store float %68, float* %66
br label %76
69: ; preds = %48
%70 = load float*, float** %24
%71 = getelementptr inbounds float, float* %70, i64 2
%72 = load float, float* %71
%73 = load float*, float** %23
%74 = getelementptr inbounds float, float* %73, i64 2
store float %72, float* %74
%75 = load float, float* %71
store float %75, float* %74
br label %76
76: ; preds = %65, %69
%77 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* @main.aorig, i64 0, i64 %21, i64 2
%78 = load float, float* %77
%79 = fpext float %78 to double
%80 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %79)
%81 = icmp eq i64 %21, 3
br i1 %81, label %85, label %82
82: ; preds = %76
%83 = load float*, float** %23
%84 = getelementptr inbounds float, float* %83, i64 3
store float 0.000000e+00, float* %84
br label %91
85: ; preds = %76
%86 = load float, float* %22
%87 = load float*, float** %23
%88 = getelementptr inbounds float, float* %87, i64 3
store float %86, float* %88
%89 = load float, float* %22
%90 = fpext float %89 to double
br label %91
91: ; preds = %85, %82
%92 = phi float* [ %88, %85 ], [ %84, %82 ]
%93 = phi double [ %90, %85 ], [ 0.000000e+00, %82 ]
%94 = fptrunc double %93 to float
store float %94, float* %92
%95 = getelementptr inbounds [4 x [4 x float]], [4 x [4 x float]]* @main.aorig, i64 0, i64 %21, i64 3
%96 = load float, float* %95
%97 = fpext float %96 to double
%98 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %97)
%99 = tail call i32 @putchar(i32 10)
%100 = add nuw nsw i64 %21, 1
%101 = icmp eq i64 %100, 4
br i1 %101, label %102, label %20
102: ; preds = %91
%103 = tail call i32 @putchar(i32 10)
%104 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([29 x i8], [29 x i8]* @str.6, i64 0, i64 0))
%105 = getelementptr inbounds float*, float** %3, i64 1
%106 = getelementptr inbounds float*, float** %3, i64 2
%107 = getelementptr inbounds float*, float** %3, i64 3
br label %108
108: ; preds = %102, %108
%109 = phi i64 [ 1, %102 ], [ %176, %108 ]
%110 = getelementptr inbounds float*, float** %3, i64 %109
%111 = getelementptr inbounds float*, float** %2, i64 %109
%112 = load float*, float** %110
%113 = load float*, float** %105
%114 = getelementptr inbounds float, float* %112, i64 1
%115 = load float, float* %114
%116 = getelementptr inbounds float, float* %113, i64 1
%117 = load float, float* %116
%118 = tail call float @llvm.fmuladd.f32(float %115, float %117, float 0.000000e+00)
%119 = getelementptr inbounds float, float* %112, i64 2
%120 = load float, float* %119
%121 = getelementptr inbounds float, float* %113, i64 2
%122 = load float, float* %121
%123 = tail call float @llvm.fmuladd.f32(float %120, float %122, float %118)
%124 = getelementptr inbounds float, float* %112, i64 3
%125 = load float, float* %124
%126 = getelementptr inbounds float, float* %113, i64 3
%127 = load float, float* %126
%128 = tail call float @llvm.fmuladd.f32(float %125, float %127, float %123)
%129 = load float*, float** %111
%130 = getelementptr inbounds float, float* %129, i64 1
store float %128, float* %130
%131 = fpext float %128 to double
%132 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %131)
%133 = load float*, float** %110
%134 = load float*, float** %106
%135 = getelementptr inbounds float, float* %133, i64 1
%136 = load float, float* %135
%137 = getelementptr inbounds float, float* %134, i64 1
%138 = load float, float* %137
%139 = tail call float @llvm.fmuladd.f32(float %136, float %138, float 0.000000e+00)
%140 = getelementptr inbounds float, float* %133, i64 2
%141 = load float, float* %140
%142 = getelementptr inbounds float, float* %134, i64 2
%143 = load float, float* %142
%144 = tail call float @llvm.fmuladd.f32(float %141, float %143, float %139)
%145 = getelementptr inbounds float, float* %133, i64 3
%146 = load float, float* %145
%147 = getelementptr inbounds float, float* %134, i64 3
%148 = load float, float* %147
%149 = tail call float @llvm.fmuladd.f32(float %146, float %148, float %144)
%150 = load float*, float** %111
%151 = getelementptr inbounds float, float* %150, i64 2
store float %149, float* %151
%152 = fpext float %149 to double
%153 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %152)
%154 = load float*, float** %110
%155 = load float*, float** %107
%156 = getelementptr inbounds float, float* %154, i64 1
%157 = load float, float* %156
%158 = getelementptr inbounds float, float* %155, i64 1
%159 = load float, float* %158
%160 = tail call float @llvm.fmuladd.f32(float %157, float %159, float 0.000000e+00)
%161 = getelementptr inbounds float, float* %154, i64 2
%162 = load float, float* %161
%163 = getelementptr inbounds float, float* %155, i64 2
%164 = load float, float* %163
%165 = tail call float @llvm.fmuladd.f32(float %162, float %164, float %160)
%166 = getelementptr inbounds float, float* %154, i64 3
%167 = load float, float* %166
%168 = getelementptr inbounds float, float* %155, i64 3
%169 = load float, float* %168
%170 = tail call float @llvm.fmuladd.f32(float %167, float %169, float %165)
%171 = load float*, float** %111
%172 = getelementptr inbounds float, float* %171, i64 3
store float %170, float* %172
%173 = fpext float %170 to double
%174 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %173)
%175 = tail call i32 @putchar(i32 10)
%176 = add nuw nsw i64 %109, 1
%177 = icmp eq i64 %176, 4
br i1 %177, label %178, label %108
178: ; preds = %108
%179 = tail call i32 @putchar(i32 10)
%180 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([23 x i8], [23 x i8]* @str.7, i64 0, i64 0))
%181 = tail call i32 @cholsl(float** %1, i32 3, float* %4, float* getelementptr inbounds ([4 x float], [4 x float]* @main.b, i64 0, i64 0), float* %5)
%182 = getelementptr inbounds float, float* %5, i64 1
%183 = load float, float* %182
%184 = tail call float @llvm.fmuladd.f32(float %183, float 1.000000e+02, float 0.000000e+00)
%185 = getelementptr inbounds float, float* %5, i64 2
%186 = load float, float* %185
%187 = tail call float @llvm.fmuladd.f32(float %186, float 1.500000e+01, float %184)
%188 = getelementptr inbounds float, float* %5, i64 3
%189 = load float, float* %188
%190 = tail call float @llvm.fmuladd.f32(float %189, float 0x3F847AE140000000, float %187)
%191 = getelementptr inbounds float, float* %4, i64 1
store float %190, float* %191
%192 = fpext float %190 to double
%193 = load float, float* getelementptr inbounds ([4 x float], [4 x float]* @main.b, i64 0, i64 1)
%194 = fpext float %193 to double
%195 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([14 x i8], [14 x i8]* @.str.5, i64 0, i64 0), double %192, double %194)
%196 = load float, float* %182
%197 = tail call float @llvm.fmuladd.f32(float %196, float 1.500000e+01, float 0.000000e+00)
%198 = load float, float* %185
%199 = tail call float @llvm.fmuladd.f32(float %198, float 0x4002666660000000, float %197)
%200 = load float, float* %188
%201 = tail call float @llvm.fmuladd.f32(float %200, float 0x3F847AE140000000, float %199)
%202 = getelementptr inbounds float, float* %4, i64 2
store float %201, float* %202
%203 = fpext float %201 to double
%204 = load float, float* getelementptr inbounds ([4 x float], [4 x float]* @main.b, i64 0, i64 2)
%205 = fpext float %204 to double
%206 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([14 x i8], [14 x i8]* @.str.5, i64 0, i64 0), double %203, double %205)
%207 = load float, float* %182
%208 = tail call float @llvm.fmuladd.f32(float %207, float 0x3F847AE140000000, float 0.000000e+00)
%209 = load float, float* %185
%210 = tail call float @llvm.fmuladd.f32(float %209, float 0x3F847AE140000000, float %208)
%211 = load float, float* %188
%212 = fadd float %211, %210
%213 = getelementptr inbounds float, float* %4, i64 3
store float %212, float* %213
%214 = fpext float %212 to double
%215 = load float, float* getelementptr inbounds ([4 x float], [4 x float]* @main.b, i64 0, i64 3)
%216 = fpext float %215 to double
%217 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([14 x i8], [14 x i8]* @.str.5, i64 0, i64 0), double %214, double %216)
%218 = tail call i32 @free_vector(float* %5, i32 1, i32 3)
%219 = tail call i32 @free_vector(float* %4, i32 1, i32 3)
%220 = tail call i32 @free_matrix(float** %3, i32 1, i32 3, i32 1, i32 3)
%221 = tail call i32 @free_matrix(float** %2, i32 1, i32 3, i32 1, i32 3)
%222 = tail call i32 @free_matrix(float** %1, i32 1, i32 3, i32 1, i32 3)
ret i32 0
}