int main(void) {
  unsigned long i, j, k, *ija, *ijb, *ijbt, *ijc, msize;
  float *sa, *sb, *sbt, *sc, **a, **b, **c, **ab;
  static float ainit[5][5] = {1.0, 0.5, 0.0, 0.0, 0.0, 0.5, 2.0, 0.5, 0.0,
                              0.0, 0.0, 0.5, 3.0, 0.5, 0.0, 0.0, 0.0, 0.5,
                              4.0, 0.5, 0.0, 0.0, 0.0, 0.5, 5.0};
  static float binit[5][5] = {1.0, 1.0, 0.0, 0.0, 0.0, 1.0, 2.0, 1.0, 0.0,
                              0.0, 0.0, 1.0, 3.0, 1.0, 0.0, 0.0, 0.0, 1.0,
                              4.0, 1.0, 0.0, 0.0, 0.0, 1.0, 5.0};
  ija = lvector(1, (2 * 5 * 5 + 1));
  ijb = lvector(1, (2 * 5 * 5 + 1));
  ijbt = lvector(1, (2 * 5 * 5 + 1));
  ijc = lvector(1, (2 * 5 * 5 + 1));
  sa = vector(1, (2 * 5 * 5 + 1));
  sb = vector(1, (2 * 5 * 5 + 1));
  sbt = vector(1, (2 * 5 * 5 + 1));
  sc = vector(1, (2 * 5 * 5 + 1));
  c = matrix(1, 5, 1, 5);
  ab = matrix(1, 5, 1, 5);
  a = convert_matrix(&ainit[0][0], 1, 5, 1, 5);
  b = convert_matrix(&binit[0][0], 1, 5, 1, 5);
  sprsin(a, 5, 0.5, (2 * 5 * 5 + 1), sa, ija);
  sprsin(b, 5, 0.5, (2 * 5 * 5 + 1), sb, ijb);
  sprstp(sb, ijb, sbt, ijbt);
  msize = ija[ija[1] - 1] - 1;
  sprstm(sa, ija, sbt, ijbt, 0.99, msize, sc, ijc);
  for (i = 1; i <= 5; i++) {
    for (j = 1; j <= 5; j++) {
      ab[i][j] = 0.0;
      for (k = 1; k <= 5; k++) {
        ab[i][j] = ab[i][j] + a[i][k] * b[k][j];
      }
    }
  }
  printf("Reference matrix:\n");
  for (i = 1; i <= 5; i++) {
    for (j = 1; j <= 5; j++)
      printf("%5.2f\t", ab[i][j]);
    printf("\n");
  }
  printf("sprstm matrix (off-diag. elements of mag >): %12.6f\n", 0.99);
  for (i = 1; i <= 5; i++)
    for (j = 1; j <= 5; j++)
      c[i][j] = 0.0;
  for (i = 1; i <= 5; i++) {
    c[i][i] = sc[i];
    for (j = ijc[i]; j <= ijc[i + 1] - 1; j++)
      c[i][ijc[j]] = sc[j];
  }
  for (i = 1; i <= 5; i++) {
    for (j = 1; j <= 5; j++)
      printf("%5.2f\t", c[i][j]);
    printf("\n");
  }
  free_convert_matrix(b, 1, 5, 1, 5);
  free_convert_matrix(a, 1, 5, 1, 5);
  free_matrix(ab, 1, 5, 1, 5);
  free_matrix(c, 1, 5, 1, 5);
  free_vector(sc, 1, (2 * 5 * 5 + 1));
  free_vector(sbt, 1, (2 * 5 * 5 + 1));
  free_vector(sb, 1, (2 * 5 * 5 + 1));
  free_vector(sa, 1, (2 * 5 * 5 + 1));
  free_lvector(ijc, 1, (2 * 5 * 5 + 1));
  free_lvector(ijbt, 1, (2 * 5 * 5 + 1));
  free_lvector(ijb, 1, (2 * 5 * 5 + 1));
  free_lvector(ija, 1, (2 * 5 * 5 + 1));
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
movl   $0x0,-0x4(%rbp)
mov    $0x1,%edi
mov    $0x33,%esi
mov    $0x0,%al
call   10e0 <lvector@plt>
cltq
mov    %rax,-0x28(%rbp)
mov    $0x1,%edi
mov    $0x33,%esi
mov    $0x0,%al
call   10e0 <lvector@plt>
cltq
mov    %rax,-0x30(%rbp)
mov    $0x1,%edi
mov    $0x33,%esi
mov    $0x0,%al
call   10e0 <lvector@plt>
cltq
mov    %rax,-0x38(%rbp)
mov    $0x1,%edi
mov    $0x33,%esi
mov    $0x0,%al
call   10e0 <lvector@plt>
cltq
mov    %rax,-0x40(%rbp)
mov    $0x1,%edi
mov    $0x33,%esi
mov    $0x0,%al
call   10b0 <vector@plt>
cltq
mov    %rax,-0x50(%rbp)
mov    $0x1,%edi
mov    $0x33,%esi
mov    $0x0,%al
call   10b0 <vector@plt>
cltq
mov    %rax,-0x58(%rbp)
mov    $0x1,%edi
mov    $0x33,%esi
mov    $0x0,%al
call   10b0 <vector@plt>
cltq
mov    %rax,-0x60(%rbp)
mov    $0x1,%edi
mov    $0x33,%esi
mov    $0x0,%al
call   10b0 <vector@plt>
cltq
mov    %rax,-0x68(%rbp)
mov    $0x1,%edx
mov    $0x5,%ecx
mov    %edx,%edi
mov    %ecx,%esi
mov    $0x0,%al
call   10a0 <matrix@plt>
cltq
mov    %rax,-0x80(%rbp)
mov    $0x1,%edx
mov    $0x5,%ecx
mov    %edx,%edi
mov    %ecx,%esi
mov    $0x0,%al
call   10a0 <matrix@plt>
cltq
mov    %rax,-0x88(%rbp)
lea    0x2dc6(%rip),%rdi
mov    $0x1,%ecx
mov    $0x5,%r8d
mov    %ecx,%esi
mov    %r8d,%edx
mov    $0x0,%al
call   10d0 <convert_matrix@plt>
cltq
mov    %rax,-0x70(%rbp)
lea    0x2e12(%rip),%rdi
mov    $0x1,%ecx
mov    $0x5,%r8d
mov    %ecx,%esi
mov    %r8d,%edx
mov    $0x0,%al
call   10d0 <convert_matrix@plt>
cltq
mov    %rax,-0x78(%rbp)
mov    -0x70(%rbp),%rdi
mov    -0x50(%rbp),%rcx
mov    -0x28(%rbp),%r8
mov    $0x5,%esi
movsd  0xce4(%rip),%xmm0
mov    $0x33,%edx
mov    $0x1,%al
call   10c0 <sprsin@plt>
mov    -0x78(%rbp),%rdi
mov    -0x58(%rbp),%rcx
mov    -0x30(%rbp),%r8
mov    $0x5,%esi
movsd  0xcbf(%rip),%xmm0
mov    $0x33,%edx
mov    $0x1,%al
call   10c0 <sprsin@plt>
mov    -0x58(%rbp),%rdi
mov    -0x30(%rbp),%rsi
mov    -0x60(%rbp),%rdx
mov    -0x38(%rbp),%rcx
mov    $0x0,%al
call   1090 <sprstp@plt>
mov    -0x28(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    0x8(%rcx),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rax
sub    $0x1,%rax
mov    %rax,-0x48(%rbp)
mov    -0x50(%rbp),%rdi
mov    -0x28(%rbp),%rsi
mov    -0x60(%rbp),%rdx
mov    -0x38(%rbp),%rcx
mov    -0x48(%rbp),%r8
mov    -0x68(%rbp),%r9
mov    -0x40(%rbp),%rax
movsd  0xc54(%rip),%xmm0
mov    %rax,(%rsp)
mov    $0x1,%al
call   1030 <sprstm@plt>
movq   $0x1,-0x10(%rbp)
cmpq   $0x5,-0x10(%rbp)
ja     14aa <main+0x2ea>
movq   $0x1,-0x18(%rbp)
cmpq   $0x5,-0x18(%rbp)
ja     1494 <main+0x2d4>
mov    -0x88(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x18(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movq   $0x1,-0x20(%rbp)
cmpq   $0x5,-0x20(%rbp)
ja     147e <main+0x2be>
mov    -0x88(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x18(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x70(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x78(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x18(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x88(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x18(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    1400 <main+0x240>
jmp    1483 <main+0x2c3>
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    13d2 <main+0x212>
jmp    1499 <main+0x2d9>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    13bf <main+0x1ff>
lea    0xb5f(%rip),%rdi
mov    $0x0,%al
call   1070 <printf@plt>
movq   $0x1,-0x10(%rbp)
cmpq   $0x5,-0x10(%rbp)
ja     1538 <main+0x378>
movq   $0x1,-0x18(%rbp)
cmpq   $0x5,-0x18(%rbp)
ja     1519 <main+0x359>
mov    -0x88(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x18(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xb22(%rip),%rdi
mov    $0x1,%al
call   1070 <printf@plt>
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    14d3 <main+0x313>
lea    0xb01(%rip),%rdi
mov    $0x0,%al
call   1070 <printf@plt>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    14c0 <main+0x300>
lea    0xaeb(%rip),%rdi
movsd  0xab9(%rip),%xmm0
mov    $0x1,%al
call   1070 <printf@plt>
movq   $0x1,-0x10(%rbp)
cmpq   $0x5,-0x10(%rbp)
ja     15b3 <main+0x3f3>
movq   $0x1,-0x18(%rbp)
cmpq   $0x5,-0x18(%rbp)
ja     159d <main+0x3dd>
mov    -0x80(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x18(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    1569 <main+0x3a9>
jmp    15a2 <main+0x3e2>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    1556 <main+0x396>
movq   $0x1,-0x10(%rbp)
cmpq   $0x5,-0x10(%rbp)
ja     1667 <main+0x4a7>
mov    -0x68(%rbp),%rax
mov    -0x10(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x80(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x10(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x40(%rbp),%rcx
mov    -0x10(%rbp),%rdx
mov    0x8(%rcx,%rdx,8),%rcx
sub    $0x1,%rcx
cmp    %rcx,%rax
ja     1651 <main+0x491>
mov    -0x68(%rbp),%rax
mov    -0x18(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x80(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%rcx
mov    -0x18(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    15f8 <main+0x438>
jmp    1656 <main+0x496>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    15bb <main+0x3fb>
movq   $0x1,-0x10(%rbp)
cmpq   $0x5,-0x10(%rbp)
ja     16e4 <main+0x524>
movq   $0x1,-0x18(%rbp)
cmpq   $0x5,-0x18(%rbp)
ja     16c5 <main+0x505>
mov    -0x80(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x18(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0x976(%rip),%rdi
mov    $0x1,%al
call   1070 <printf@plt>
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    1682 <main+0x4c2>
lea    0x955(%rip),%rdi
mov    $0x0,%al
call   1070 <printf@plt>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    166f <main+0x4af>
mov    -0x78(%rbp),%rdi
mov    $0x1,%ecx
mov    $0x5,%r8d
mov    %ecx,%esi
mov    %r8d,%edx
mov    $0x0,%al
call   1040 <free_convert_matrix@plt>
mov    -0x70(%rbp),%rdi
mov    $0x1,%ecx
mov    $0x5,%r8d
mov    %ecx,%esi
mov    %r8d,%edx
mov    $0x0,%al
call   1040 <free_convert_matrix@plt>
mov    -0x88(%rbp),%rdi
mov    $0x1,%ecx
mov    $0x5,%r8d
mov    %ecx,%esi
mov    %r8d,%edx
mov    $0x0,%al
call   1050 <free_matrix@plt>
mov    -0x80(%rbp),%rdi
mov    $0x1,%ecx
mov    $0x5,%r8d
mov    %ecx,%esi
mov    %r8d,%edx
mov    $0x0,%al
call   1050 <free_matrix@plt>
mov    -0x68(%rbp),%rdi
mov    $0x1,%esi
mov    $0x33,%edx
mov    $0x0,%al
call   1080 <free_vector@plt>
mov    -0x60(%rbp),%rdi
mov    $0x1,%esi
mov    $0x33,%edx
mov    $0x0,%al
call   1080 <free_vector@plt>
mov    -0x58(%rbp),%rdi
mov    $0x1,%esi
mov    $0x33,%edx
mov    $0x0,%al
call   1080 <free_vector@plt>
mov    -0x50(%rbp),%rdi
mov    $0x1,%esi
mov    $0x33,%edx
mov    $0x0,%al
call   1080 <free_vector@plt>
mov    -0x40(%rbp),%rdi
mov    $0x1,%esi
mov    $0x33,%edx
mov    $0x0,%al
call   1060 <free_lvector@plt>
mov    -0x38(%rbp),%rdi
mov    $0x1,%esi
mov    $0x33,%edx
mov    $0x0,%al
call   1060 <free_lvector@plt>
mov    -0x30(%rbp),%rdi
mov    $0x1,%esi
mov    $0x33,%edx
mov    $0x0,%al
call   1060 <free_lvector@plt>
mov    -0x28(%rbp),%rdi
mov    $0x1,%esi
mov    $0x33,%edx
mov    $0x0,%al
call   1060 <free_lvector@plt>
xor    %eax,%eax
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    $0x1,%edi
mov    $0x33,%esi
xor    %eax,%eax
call   1100 <lvector@plt>
cltq
mov    %rax,0x18(%rsp)
mov    $0x1,%edi
mov    $0x33,%esi
xor    %eax,%eax
call   1100 <lvector@plt>
cltq
mov    %rax,0x40(%rsp)
mov    $0x1,%edi
mov    $0x33,%esi
xor    %eax,%eax
call   1100 <lvector@plt>
cltq
mov    %rax,0x38(%rsp)
mov    $0x1,%edi
mov    $0x33,%esi
xor    %eax,%eax
call   1100 <lvector@plt>
movslq %eax,%r14
mov    $0x1,%edi
mov    $0x33,%esi
xor    %eax,%eax
call   10d0 <vector@plt>
cltq
mov    %rax,0x10(%rsp)
mov    $0x1,%edi
mov    $0x33,%esi
xor    %eax,%eax
call   10d0 <vector@plt>
movslq %eax,%r12
mov    $0x1,%edi
mov    $0x33,%esi
xor    %eax,%eax
call   10d0 <vector@plt>
cltq
mov    %rax,0x30(%rsp)
mov    $0x1,%edi
mov    $0x33,%esi
xor    %eax,%eax
call   10d0 <vector@plt>
movslq %eax,%r15
mov    $0x1,%edi
mov    $0x5,%esi
mov    $0x1,%edx
mov    $0x5,%ecx
xor    %eax,%eax
call   10c0 <matrix@plt>
cltq
mov    %rax,0x28(%rsp)
mov    $0x1,%edi
mov    $0x5,%esi
mov    $0x1,%edx
mov    $0x5,%ecx
xor    %eax,%eax
call   10c0 <matrix@plt>
movslq %eax,%r13
lea    0x2db7(%rip),%rdi
mov    $0x1,%esi
mov    $0x5,%edx
mov    $0x1,%ecx
mov    $0x5,%r8d
xor    %eax,%eax
call   10f0 <convert_matrix@plt>
movslq %eax,%rbp
mov    %rbp,0x20(%rsp)
lea    0x2dfc(%rip),%rdi
mov    $0x1,%esi
mov    $0x5,%edx
mov    $0x1,%ecx
mov    $0x5,%r8d
xor    %eax,%eax
call   10f0 <convert_matrix@plt>
movslq %eax,%rbx
movsd  0xcc5(%rip),%xmm0
mov    %rbp,%rdi
mov    $0x5,%esi
mov    $0x33,%edx
mov    0x10(%rsp),%rcx
mov    0x18(%rsp),%r8
mov    $0x1,%al
call   10e0 <sprsin@plt>
mov    %rbx,%rdi
mov    $0x5,%esi
movsd  0xc97(%rip),%xmm0
mov    $0x33,%edx
mov    %r12,%rbp
mov    %r12,%rcx
mov    0x40(%rsp),%r12
mov    %r12,%r8
mov    $0x1,%al
call   10e0 <sprsin@plt>
mov    %rbp,0x50(%rsp)
mov    %rbp,%rdi
mov    %r12,%rsi
mov    0x30(%rsp),%r12
mov    %r12,%rdx
mov    0x38(%rsp),%rbp
mov    %rbp,%rcx
xor    %eax,%eax
call   10b0 <sprstp@plt>
mov    0x18(%rsp),%rsi
mov    0x8(%rsi),%rax
mov    -0x8(%rsi,%rax,8),%r8
add    $0xffffffffffffffff,%r8
mov    %r14,(%rsp)
movsd  0xc45(%rip),%xmm0
mov    0x10(%rsp),%rdi
mov    %r12,%rdx
mov    %rbp,%rcx
mov    %r15,%r9
mov    $0x1,%al
call   1030 <sprstm@plt>
mov    0x20(%rsp),%r9
mov    0x8(%rbx),%r8
mov    0x10(%rbx),%rcx
mov    0x18(%rbx),%rdx
mov    0x20(%rbx),%rsi
mov    %rbx,0x48(%rsp)
mov    0x28(%rbx),%rdi
mov    $0x1,%ebp
xorps  %xmm0,%xmm0
xchg   %ax,%ax
mov    0x0(%r13,%rbp,8),%rbx
mov    (%r9,%rbp,8),%rax
movl   $0x0,0x4(%rbx)
movss  0x4(%rax),%xmm1
mulss  0x4(%r8),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,0x4(%rbx)
movss  0x8(%rax),%xmm2
mulss  0x4(%rcx),%xmm2
addss  %xmm1,%xmm2
movss  %xmm2,0x4(%rbx)
movss  0xc(%rax),%xmm1
mulss  0x4(%rdx),%xmm1
addss  %xmm2,%xmm1
movss  %xmm1,0x4(%rbx)
movss  0x10(%rax),%xmm2
mulss  0x4(%rsi),%xmm2
addss  %xmm1,%xmm2
movss  %xmm2,0x4(%rbx)
movss  0x14(%rax),%xmm1
mulss  0x4(%rdi),%xmm1
addss  %xmm2,%xmm1
movss  %xmm1,0x4(%rbx)
movl   $0x0,0x8(%rbx)
movss  0x4(%rax),%xmm1
mulss  0x8(%r8),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,0x8(%rbx)
movss  0x8(%rax),%xmm2
mulss  0x8(%rcx),%xmm2
addss  %xmm1,%xmm2
movss  %xmm2,0x8(%rbx)
movss  0xc(%rax),%xmm1
mulss  0x8(%rdx),%xmm1
addss  %xmm2,%xmm1
movss  %xmm1,0x8(%rbx)
movss  0x10(%rax),%xmm2
mulss  0x8(%rsi),%xmm2
addss  %xmm1,%xmm2
movss  %xmm2,0x8(%rbx)
movss  0x14(%rax),%xmm1
mulss  0x8(%rdi),%xmm1
addss  %xmm2,%xmm1
movss  %xmm1,0x8(%rbx)
movl   $0x0,0xc(%rbx)
movss  0x4(%rax),%xmm1
mulss  0xc(%r8),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,0xc(%rbx)
movss  0x8(%rax),%xmm2
mulss  0xc(%rcx),%xmm2
addss  %xmm1,%xmm2
movss  %xmm2,0xc(%rbx)
movss  0xc(%rax),%xmm1
mulss  0xc(%rdx),%xmm1
addss  %xmm2,%xmm1
movss  %xmm1,0xc(%rbx)
movss  0x10(%rax),%xmm2
mulss  0xc(%rsi),%xmm2
addss  %xmm1,%xmm2
movss  %xmm2,0xc(%rbx)
movss  0x14(%rax),%xmm1
mulss  0xc(%rdi),%xmm1
addss  %xmm2,%xmm1
movss  %xmm1,0xc(%rbx)
movl   $0x0,0x10(%rbx)
movss  0x4(%rax),%xmm1
mulss  0x10(%r8),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,0x10(%rbx)
movss  0x8(%rax),%xmm2
mulss  0x10(%rcx),%xmm2
addss  %xmm1,%xmm2
movss  %xmm2,0x10(%rbx)
movss  0xc(%rax),%xmm1
mulss  0x10(%rdx),%xmm1
addss  %xmm2,%xmm1
movss  %xmm1,0x10(%rbx)
movss  0x10(%rax),%xmm2
mulss  0x10(%rsi),%xmm2
addss  %xmm1,%xmm2
movss  %xmm2,0x10(%rbx)
movss  0x14(%rax),%xmm1
mulss  0x10(%rdi),%xmm1
addss  %xmm2,%xmm1
movss  %xmm1,0x10(%rbx)
movl   $0x0,0x14(%rbx)
movss  0x4(%rax),%xmm1
mulss  0x14(%r8),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,0x14(%rbx)
movss  0x8(%rax),%xmm2
mulss  0x14(%rcx),%xmm2
addss  %xmm1,%xmm2
movss  %xmm2,0x14(%rbx)
movss  0xc(%rax),%xmm1
mulss  0x14(%rdx),%xmm1
addss  %xmm2,%xmm1
movss  %xmm1,0x14(%rbx)
movss  0x10(%rax),%xmm2
mulss  0x14(%rsi),%xmm2
addss  %xmm1,%xmm2
movss  %xmm2,0x14(%rbx)
movss  0x14(%rax),%xmm1
mulss  0x14(%rdi),%xmm1
addss  %xmm2,%xmm1
movss  %xmm1,0x14(%rbx)
add    $0x1,%rbp
cmp    $0x6,%rbp
jne    1400 <main+0x220>
lea    0xa2b(%rip),%rdi
call   1060 <puts@plt>
mov    0x8(%r13),%rax
movss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0x9d6(%rip),%r12
mov    %r12,%rdi
mov    $0x1,%al
call   1090 <printf@plt>
mov    0x8(%r13),%rax
movss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1090 <printf@plt>
mov    0x8(%r13),%rax
movss  0xc(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1090 <printf@plt>
mov    0x8(%r13),%rax
movss  0x10(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1090 <printf@plt>
mov    0x8(%r13),%rax
movss  0x14(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1090 <printf@plt>
mov    $0xa,%edi
call   1040 <putchar@plt>
mov    0x10(%r13),%rax
movss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1090 <printf@plt>
mov    0x10(%r13),%rax
movss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1090 <printf@plt>
mov    0x10(%r13),%rax
movss  0xc(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1090 <printf@plt>
mov    0x10(%r13),%rax
movss  0x10(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1090 <printf@plt>
mov    0x10(%r13),%rax
movss  0x14(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1090 <printf@plt>
mov    $0xa,%edi
call   1040 <putchar@plt>
mov    0x18(%r13),%rax
movss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1090 <printf@plt>
mov    0x18(%r13),%rax
movss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1090 <printf@plt>
mov    0x18(%r13),%rax
movss  0xc(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1090 <printf@plt>
mov    0x18(%r13),%rax
movss  0x10(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1090 <printf@plt>
mov    0x18(%r13),%rax
movss  0x14(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1090 <printf@plt>
mov    $0xa,%edi
call   1040 <putchar@plt>
mov    0x20(%r13),%rax
movss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1090 <printf@plt>
mov    0x20(%r13),%rax
movss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1090 <printf@plt>
mov    0x20(%r13),%rax
movss  0xc(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1090 <printf@plt>
mov    0x20(%r13),%rax
movss  0x10(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1090 <printf@plt>
mov    0x20(%r13),%rax
movss  0x14(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1090 <printf@plt>
mov    $0xa,%edi
call   1040 <putchar@plt>
mov    0x28(%r13),%rax
movss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1090 <printf@plt>
mov    0x28(%r13),%rax
movss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1090 <printf@plt>
mov    0x28(%r13),%rax
movss  0xc(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1090 <printf@plt>
mov    0x28(%r13),%rax
movss  0x10(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1090 <printf@plt>
mov    0x28(%r13),%rax
movss  0x14(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1090 <printf@plt>
mov    $0xa,%edi
call   1040 <putchar@plt>
lea    0x772(%rip),%rdi
movsd  0x75b(%rip),%xmm0
mov    $0x1,%al
call   1090 <printf@plt>
mov    0x28(%rsp),%rax
mov    0x8(%rax),%r9
xorps  %xmm0,%xmm0
movups %xmm0,0x4(%r9)
movl   $0x0,0x14(%r9)
mov    0x10(%rax),%rdi
movups %xmm0,0x4(%rdi)
movl   $0x0,0x14(%rdi)
mov    0x18(%rax),%rsi
movups %xmm0,0x4(%rsi)
movl   $0x0,0x14(%rsi)
mov    0x20(%rax),%rdx
movups %xmm0,0x4(%rdx)
movl   $0x0,0x14(%rdx)
mov    0x28(%rax),%r8
movups %xmm0,0x4(%r8)
movl   $0x0,0x14(%r8)
movss  0x4(%r15),%xmm0
movss  %xmm0,0x4(%r9)
mov    0x8(%r14),%rbx
mov    0x10(%r14),%rbp
lea    -0x1(%rbp),%rcx
cmp    %rcx,%rbx
ja     1949 <main+0x769>
nopl   0x0(%rax,%rax,1)
movss  (%r15,%rbx,4),%xmm0
mov    (%r14,%rbx,8),%rax
movss  %xmm0,(%r9,%rax,4)
add    $0x1,%rbx
cmp    %rcx,%rbx
jbe    1930 <main+0x750>
movss  0x8(%r15),%xmm0
movss  %xmm0,0x8(%rdi)
mov    0x18(%r14),%rbx
lea    -0x1(%rbx),%rcx
cmp    %rcx,%rbp
ja     1988 <main+0x7a8>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  (%r15,%rbp,4),%xmm0
mov    (%r14,%rbp,8),%rax
movss  %xmm0,(%rdi,%rax,4)
add    $0x1,%rbp
cmp    %rcx,%rbp
jbe    1970 <main+0x790>
movss  0xc(%r15),%xmm0
movss  %xmm0,0xc(%rsi)
mov    0x20(%r14),%rdi
lea    -0x1(%rdi),%rcx
cmp    %rcx,%rbx
ja     19b8 <main+0x7d8>
movss  (%r15,%rbx,4),%xmm0
mov    (%r14,%rbx,8),%rax
movss  %xmm0,(%rsi,%rax,4)
add    $0x1,%rbx
cmp    %rcx,%rbx
jbe    19a0 <main+0x7c0>
movss  0x10(%r15),%xmm0
movss  %xmm0,0x10(%rdx)
mov    0x28(%r14),%rsi
lea    -0x1(%rsi),%rcx
cmp    %rcx,%rdi
ja     19e8 <main+0x808>
movss  (%r15,%rdi,4),%xmm0
mov    (%r14,%rdi,8),%rax
movss  %xmm0,(%rdx,%rax,4)
add    $0x1,%rdi
cmp    %rcx,%rdi
jbe    19d0 <main+0x7f0>
add    $0x4,%r9
movss  0x14(%r15),%xmm0
movss  %xmm0,0x14(%r8)
mov    0x30(%r14),%rdx
add    $0xffffffffffffffff,%rdx
cmp    %rdx,%rsi
ja     1a29 <main+0x849>
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%r15,%rsi,4),%xmm0
mov    (%r14,%rsi,8),%rax
movss  %xmm0,(%r8,%rax,4)
add    $0x1,%rsi
cmp    %rdx,%rsi
jbe    1a10 <main+0x830>
movss  (%r9),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0x5d7(%rip),%r12
mov    %r12,%rdi
mov    $0x1,%al
call   1090 <printf@plt>
mov    0x28(%rsp),%rbx
mov    0x8(%rbx),%rax
movss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1090 <printf@plt>
mov    0x8(%rbx),%rax
movss  0xc(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1090 <printf@plt>
mov    0x8(%rbx),%rax
movss  0x10(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1090 <printf@plt>
mov    0x8(%rbx),%rax
movss  0x14(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1090 <printf@plt>
mov    $0xa,%edi
call   1040 <putchar@plt>
mov    0x10(%rbx),%rax
movss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1090 <printf@plt>
mov    0x10(%rbx),%rax
movss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1090 <printf@plt>
mov    0x10(%rbx),%rax
movss  0xc(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1090 <printf@plt>
mov    0x10(%rbx),%rax
movss  0x10(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1090 <printf@plt>
mov    0x10(%rbx),%rax
movss  0x14(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1090 <printf@plt>
mov    $0xa,%edi
call   1040 <putchar@plt>
mov    0x18(%rbx),%rax
movss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1090 <printf@plt>
mov    0x18(%rbx),%rax
movss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1090 <printf@plt>
mov    0x18(%rbx),%rax
movss  0xc(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1090 <printf@plt>
mov    0x18(%rbx),%rax
movss  0x10(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1090 <printf@plt>
mov    0x18(%rbx),%rax
movss  0x14(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1090 <printf@plt>
mov    $0xa,%edi
call   1040 <putchar@plt>
mov    0x20(%rbx),%rax
movss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1090 <printf@plt>
mov    0x20(%rbx),%rax
movss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1090 <printf@plt>
mov    0x20(%rbx),%rax
movss  0xc(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1090 <printf@plt>
mov    0x20(%rbx),%rax
movss  0x10(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1090 <printf@plt>
mov    0x20(%rbx),%rax
movss  0x14(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1090 <printf@plt>
mov    $0xa,%edi
call   1040 <putchar@plt>
mov    0x28(%rbx),%rax
movss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1090 <printf@plt>
mov    0x28(%rbx),%rax
movss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1090 <printf@plt>
mov    0x28(%rbx),%rax
movss  0xc(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1090 <printf@plt>
mov    0x28(%rbx),%rax
movss  0x10(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1090 <printf@plt>
mov    0x28(%rbx),%rax
movss  0x14(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1090 <printf@plt>
mov    $0xa,%edi
call   1040 <putchar@plt>
mov    0x48(%rsp),%rdi
mov    $0x1,%esi
mov    $0x5,%edx
mov    $0x1,%ecx
mov    $0x5,%r8d
xor    %eax,%eax
call   1050 <free_convert_matrix@plt>
mov    0x20(%rsp),%rdi
mov    $0x1,%esi
mov    $0x5,%edx
mov    $0x1,%ecx
mov    $0x5,%r8d
xor    %eax,%eax
call   1050 <free_convert_matrix@plt>
mov    %r13,%rdi
mov    $0x1,%esi
mov    $0x5,%edx
mov    $0x1,%ecx
mov    $0x5,%r8d
xor    %eax,%eax
call   1070 <free_matrix@plt>
mov    %rbx,%rdi
mov    $0x1,%esi
mov    $0x5,%edx
mov    $0x1,%ecx
mov    $0x5,%r8d
xor    %eax,%eax
call   1070 <free_matrix@plt>
mov    %r15,%rdi
mov    $0x1,%esi
mov    $0x33,%edx
xor    %eax,%eax
call   10a0 <free_vector@plt>
mov    0x30(%rsp),%rdi
mov    $0x1,%esi
mov    $0x33,%edx
xor    %eax,%eax
call   10a0 <free_vector@plt>
mov    0x50(%rsp),%rdi
mov    $0x1,%esi
mov    $0x33,%edx
xor    %eax,%eax
call   10a0 <free_vector@plt>
mov    0x10(%rsp),%rdi
mov    $0x1,%esi
mov    $0x33,%edx
xor    %eax,%eax
call   10a0 <free_vector@plt>
mov    %r14,%rdi
mov    $0x1,%esi
mov    $0x33,%edx
xor    %eax,%eax
call   1080 <free_lvector@plt>
mov    0x38(%rsp),%rdi
mov    $0x1,%esi
mov    $0x33,%edx
xor    %eax,%eax
call   1080 <free_lvector@plt>
mov    0x40(%rsp),%rdi
mov    $0x1,%esi
mov    $0x33,%edx
xor    %eax,%eax
call   1080 <free_lvector@plt>
mov    0x18(%rsp),%rdi
mov    $0x1,%esi
mov    $0x33,%edx
xor    %eax,%eax
call   1080 <free_lvector@plt>
xor    %eax,%eax
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@main.ainit = internal global [5 x [5 x float]] [[5 x float] [float 1.000000e+00, float 5.000000e-01, float 0.000000e+00, float 0.000000e+00, float 0.000000e+00], [5 x float] [float 5.000000e-01, float 2.000000e+00, float 5.000000e-01, float 0.000000e+00, float 0.000000e+00], [5 x float] [float 0.000000e+00, float 5.000000e-01, float 3.000000e+00, float 5.000000e-01, float 0.000000e+00], [5 x float] [float 0.000000e+00, float 0.000000e+00, float 5.000000e-01, float 4.000000e+00, float 5.000000e-01], [5 x float] [float 0.000000e+00, float 0.000000e+00, float 0.000000e+00, float 5.000000e-01, float 5.000000e+00]]
@main.binit = internal global [5 x [5 x float]] [[5 x float] [float 1.000000e+00, float 1.000000e+00, float 0.000000e+00, float 0.000000e+00, float 0.000000e+00], [5 x float] [float 1.000000e+00, float 2.000000e+00, float 1.000000e+00, float 0.000000e+00, float 0.000000e+00], [5 x float] [float 0.000000e+00, float 1.000000e+00, float 3.000000e+00, float 1.000000e+00, float 0.000000e+00], [5 x float] [float 0.000000e+00, float 0.000000e+00, float 1.000000e+00, float 4.000000e+00, float 1.000000e+00], [5 x float] [float 0.000000e+00, float 0.000000e+00, float 0.000000e+00, float 1.000000e+00, float 5.000000e+00]]
@.str.1 = [7 x i8] c"%5.2f\09\00"
@.str.3 = [53 x i8] c"sprstm matrix (off-diag. elements of mag >): %12.6f\0A\00"
@str = [18 x i8] c"Reference matrix:\00"
define i32 @main() {
%1 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @lvector to i32 (i32, i32, ...)*)(i32 1, i32 51)
%2 = sext i32 %1 to i64
%3 = inttoptr i64 %2 to i64*
%4 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @lvector to i32 (i32, i32, ...)*)(i32 1, i32 51)
%5 = sext i32 %4 to i64
%6 = inttoptr i64 %5 to i64*
%7 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @lvector to i32 (i32, i32, ...)*)(i32 1, i32 51)
%8 = sext i32 %7 to i64
%9 = inttoptr i64 %8 to i64*
%10 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @lvector to i32 (i32, i32, ...)*)(i32 1, i32 51)
%11 = sext i32 %10 to i64
%12 = inttoptr i64 %11 to i64*
%13 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @vector to i32 (i32, i32, ...)*)(i32 1, i32 51)
%14 = sext i32 %13 to i64
%15 = inttoptr i64 %14 to float*
%16 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @vector to i32 (i32, i32, ...)*)(i32 1, i32 51)
%17 = sext i32 %16 to i64
%18 = inttoptr i64 %17 to float*
%19 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @vector to i32 (i32, i32, ...)*)(i32 1, i32 51)
%20 = sext i32 %19 to i64
%21 = inttoptr i64 %20 to float*
%22 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @vector to i32 (i32, i32, ...)*)(i32 1, i32 51)
%23 = sext i32 %22 to i64
%24 = inttoptr i64 %23 to float*
%25 = tail call i32 (i32, i32, i32, i32, ...) bitcast (i32 (...)* @matrix to i32 (i32, i32, i32, i32, ...)*)(i32 1, i32 5, i32 1, i32 5)
%26 = sext i32 %25 to i64
%27 = tail call i32 (i32, i32, i32, i32, ...) bitcast (i32 (...)* @matrix to i32 (i32, i32, i32, i32, ...)*)(i32 1, i32 5, i32 1, i32 5)
%28 = sext i32 %27 to i64
%29 = inttoptr i64 %28 to float**
%30 = tail call i32 (float*, i32, i32, i32, i32, ...) bitcast (i32 (...)* @convert_matrix to i32 (float*, i32, i32, i32, i32, ...)*)(float* getelementptr inbounds ([5 x [5 x float]], [5 x [5 x float]]* @main.ainit, i64 0, i64 0, i64 0), i32 1, i32 5, i32 1, i32 5)
%31 = sext i32 %30 to i64
%32 = inttoptr i64 %31 to float**
%33 = tail call i32 (float*, i32, i32, i32, i32, ...) bitcast (i32 (...)* @convert_matrix to i32 (float*, i32, i32, i32, i32, ...)*)(float* getelementptr inbounds ([5 x [5 x float]], [5 x [5 x float]]* @main.binit, i64 0, i64 0, i64 0), i32 1, i32 5, i32 1, i32 5)
%34 = sext i32 %33 to i64
%35 = inttoptr i64 %34 to float**
%36 = tail call i32 (float**, i32, double, i32, float*, i64*, ...) bitcast (i32 (...)* @sprsin to i32 (float**, i32, double, i32, float*, i64*, ...)*)(float** %32, i32 5, double 5.000000e-01, i32 51, float* %15, i64* %3)
%37 = tail call i32 (float**, i32, double, i32, float*, i64*, ...) bitcast (i32 (...)* @sprsin to i32 (float**, i32, double, i32, float*, i64*, ...)*)(float** %35, i32 5, double 5.000000e-01, i32 51, float* %18, i64* %6)
%38 = tail call i32 (float*, i64*, float*, i64*, ...) bitcast (i32 (...)* @sprstp to i32 (float*, i64*, float*, i64*, ...)*)(float* %18, i64* %6, float* %21, i64* %9)
%39 = getelementptr inbounds i64, i64* %3, i64 1
%40 = load i64, i64* %39
%41 = add i64 %40, -1
%42 = getelementptr inbounds i64, i64* %3, i64 %41
%43 = load i64, i64* %42
%44 = add i64 %43, -1
%45 = tail call i32 (float*, i64*, float*, i64*, double, i64, float*, i64*, ...) bitcast (i32 (...)* @sprstm to i32 (float*, i64*, float*, i64*, double, i64, float*, i64*, ...)*)(float* %15, i64* %3, float* %21, i64* %9, double 0x3FEFAE147AE147AE, i64 %44, float* %24, i64* %12)
%46 = getelementptr inbounds float*, float** %35, i64 1
%47 = load float*, float** %46
%48 = getelementptr inbounds float*, float** %35, i64 2
%49 = load float*, float** %48
%50 = getelementptr inbounds float*, float** %35, i64 3
%51 = load float*, float** %50
%52 = getelementptr inbounds float*, float** %35, i64 4
%53 = load float*, float** %52
%54 = getelementptr inbounds float*, float** %35, i64 5
%55 = load float*, float** %54
%56 = getelementptr inbounds float, float* %47, i64 1
%57 = getelementptr inbounds float, float* %49, i64 1
%58 = getelementptr inbounds float, float* %51, i64 1
%59 = getelementptr inbounds float, float* %53, i64 1
%60 = getelementptr inbounds float, float* %55, i64 1
%61 = getelementptr inbounds float, float* %47, i64 2
%62 = getelementptr inbounds float, float* %49, i64 2
%63 = getelementptr inbounds float, float* %51, i64 2
%64 = getelementptr inbounds float, float* %53, i64 2
%65 = getelementptr inbounds float, float* %55, i64 2
%66 = getelementptr inbounds float, float* %47, i64 3
%67 = getelementptr inbounds float, float* %49, i64 3
%68 = getelementptr inbounds float, float* %51, i64 3
%69 = getelementptr inbounds float, float* %53, i64 3
%70 = getelementptr inbounds float, float* %55, i64 3
%71 = getelementptr inbounds float, float* %47, i64 4
%72 = getelementptr inbounds float, float* %49, i64 4
%73 = getelementptr inbounds float, float* %51, i64 4
%74 = getelementptr inbounds float, float* %53, i64 4
%75 = getelementptr inbounds float, float* %55, i64 4
%76 = getelementptr inbounds float, float* %47, i64 5
%77 = getelementptr inbounds float, float* %49, i64 5
%78 = getelementptr inbounds float, float* %51, i64 5
%79 = getelementptr inbounds float, float* %53, i64 5
%80 = getelementptr inbounds float, float* %55, i64 5
br label %81
81: ; preds = %0, %81
%82 = phi i64 [ 1, %0 ], [ %172, %81 ]
%83 = getelementptr inbounds float*, float** %29, i64 %82
%84 = load float*, float** %83
%85 = getelementptr inbounds float*, float** %32, i64 %82
%86 = load float*, float** %85
%87 = getelementptr inbounds float, float* %86, i64 1
%88 = getelementptr inbounds float, float* %86, i64 2
%89 = getelementptr inbounds float, float* %86, i64 3
%90 = getelementptr inbounds float, float* %86, i64 4
%91 = getelementptr inbounds float, float* %86, i64 5
%92 = getelementptr inbounds float, float* %84, i64 1
store float 0.000000e+00, float* %92
%93 = load float, float* %87
%94 = load float, float* %56
%95 = tail call float @llvm.fmuladd.f32(float %93, float %94, float 0.000000e+00)
store float %95, float* %92
%96 = load float, float* %88
%97 = load float, float* %57
%98 = tail call float @llvm.fmuladd.f32(float %96, float %97, float %95)
store float %98, float* %92
%99 = load float, float* %89
%100 = load float, float* %58
%101 = tail call float @llvm.fmuladd.f32(float %99, float %100, float %98)
store float %101, float* %92
%102 = load float, float* %90
%103 = load float, float* %59
%104 = tail call float @llvm.fmuladd.f32(float %102, float %103, float %101)
store float %104, float* %92
%105 = load float, float* %91
%106 = load float, float* %60
%107 = tail call float @llvm.fmuladd.f32(float %105, float %106, float %104)
store float %107, float* %92
%108 = getelementptr inbounds float, float* %84, i64 2
store float 0.000000e+00, float* %108
%109 = load float, float* %87
%110 = load float, float* %61
%111 = tail call float @llvm.fmuladd.f32(float %109, float %110, float 0.000000e+00)
store float %111, float* %108
%112 = load float, float* %88
%113 = load float, float* %62
%114 = tail call float @llvm.fmuladd.f32(float %112, float %113, float %111)
store float %114, float* %108
%115 = load float, float* %89
%116 = load float, float* %63
%117 = tail call float @llvm.fmuladd.f32(float %115, float %116, float %114)
store float %117, float* %108
%118 = load float, float* %90
%119 = load float, float* %64
%120 = tail call float @llvm.fmuladd.f32(float %118, float %119, float %117)
store float %120, float* %108
%121 = load float, float* %91
%122 = load float, float* %65
%123 = tail call float @llvm.fmuladd.f32(float %121, float %122, float %120)
store float %123, float* %108
%124 = getelementptr inbounds float, float* %84, i64 3
store float 0.000000e+00, float* %124
%125 = load float, float* %87
%126 = load float, float* %66
%127 = tail call float @llvm.fmuladd.f32(float %125, float %126, float 0.000000e+00)
store float %127, float* %124
%128 = load float, float* %88
%129 = load float, float* %67
%130 = tail call float @llvm.fmuladd.f32(float %128, float %129, float %127)
store float %130, float* %124
%131 = load float, float* %89
%132 = load float, float* %68
%133 = tail call float @llvm.fmuladd.f32(float %131, float %132, float %130)
store float %133, float* %124
%134 = load float, float* %90
%135 = load float, float* %69
%136 = tail call float @llvm.fmuladd.f32(float %134, float %135, float %133)
store float %136, float* %124
%137 = load float, float* %91
%138 = load float, float* %70
%139 = tail call float @llvm.fmuladd.f32(float %137, float %138, float %136)
store float %139, float* %124
%140 = getelementptr inbounds float, float* %84, i64 4
store float 0.000000e+00, float* %140
%141 = load float, float* %87
%142 = load float, float* %71
%143 = tail call float @llvm.fmuladd.f32(float %141, float %142, float 0.000000e+00)
store float %143, float* %140
%144 = load float, float* %88
%145 = load float, float* %72
%146 = tail call float @llvm.fmuladd.f32(float %144, float %145, float %143)
store float %146, float* %140
%147 = load float, float* %89
%148 = load float, float* %73
%149 = tail call float @llvm.fmuladd.f32(float %147, float %148, float %146)
store float %149, float* %140
%150 = load float, float* %90
%151 = load float, float* %74
%152 = tail call float @llvm.fmuladd.f32(float %150, float %151, float %149)
store float %152, float* %140
%153 = load float, float* %91
%154 = load float, float* %75
%155 = tail call float @llvm.fmuladd.f32(float %153, float %154, float %152)
store float %155, float* %140
%156 = getelementptr inbounds float, float* %84, i64 5
store float 0.000000e+00, float* %156
%157 = load float, float* %87
%158 = load float, float* %76
%159 = tail call float @llvm.fmuladd.f32(float %157, float %158, float 0.000000e+00)
store float %159, float* %156
%160 = load float, float* %88
%161 = load float, float* %77
%162 = tail call float @llvm.fmuladd.f32(float %160, float %161, float %159)
store float %162, float* %156
%163 = load float, float* %89
%164 = load float, float* %78
%165 = tail call float @llvm.fmuladd.f32(float %163, float %164, float %162)
store float %165, float* %156
%166 = load float, float* %90
%167 = load float, float* %79
%168 = tail call float @llvm.fmuladd.f32(float %166, float %167, float %165)
store float %168, float* %156
%169 = load float, float* %91
%170 = load float, float* %80
%171 = tail call float @llvm.fmuladd.f32(float %169, float %170, float %168)
store float %171, float* %156
%172 = add nuw nsw i64 %82, 1
%173 = icmp eq i64 %172, 6
br i1 %173, label %174, label %81
174: ; preds = %81
%175 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([18 x i8], [18 x i8]* @str, i64 0, i64 0))
%176 = getelementptr inbounds float*, float** %29, i64 1
%177 = load float*, float** %176
%178 = getelementptr inbounds float, float* %177, i64 1
%179 = load float, float* %178
%180 = fpext float %179 to double
%181 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %180)
%182 = load float*, float** %176
%183 = getelementptr inbounds float, float* %182, i64 2
%184 = load float, float* %183
%185 = fpext float %184 to double
%186 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %185)
%187 = load float*, float** %176
%188 = getelementptr inbounds float, float* %187, i64 3
%189 = load float, float* %188
%190 = fpext float %189 to double
%191 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %190)
%192 = load float*, float** %176
%193 = getelementptr inbounds float, float* %192, i64 4
%194 = load float, float* %193
%195 = fpext float %194 to double
%196 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %195)
%197 = load float*, float** %176
%198 = getelementptr inbounds float, float* %197, i64 5
%199 = load float, float* %198
%200 = fpext float %199 to double
%201 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %200)
%202 = tail call i32 @putchar(i32 10)
%203 = getelementptr inbounds float*, float** %29, i64 2
%204 = load float*, float** %203
%205 = getelementptr inbounds float, float* %204, i64 1
%206 = load float, float* %205
%207 = fpext float %206 to double
%208 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %207)
%209 = load float*, float** %203
%210 = getelementptr inbounds float, float* %209, i64 2
%211 = load float, float* %210
%212 = fpext float %211 to double
%213 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %212)
%214 = load float*, float** %203
%215 = getelementptr inbounds float, float* %214, i64 3
%216 = load float, float* %215
%217 = fpext float %216 to double
%218 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %217)
%219 = load float*, float** %203
%220 = getelementptr inbounds float, float* %219, i64 4
%221 = load float, float* %220
%222 = fpext float %221 to double
%223 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %222)
%224 = load float*, float** %203
%225 = getelementptr inbounds float, float* %224, i64 5
%226 = load float, float* %225
%227 = fpext float %226 to double
%228 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %227)
%229 = tail call i32 @putchar(i32 10)
%230 = getelementptr inbounds float*, float** %29, i64 3
%231 = load float*, float** %230
%232 = getelementptr inbounds float, float* %231, i64 1
%233 = load float, float* %232
%234 = fpext float %233 to double
%235 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %234)
%236 = load float*, float** %230
%237 = getelementptr inbounds float, float* %236, i64 2
%238 = load float, float* %237
%239 = fpext float %238 to double
%240 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %239)
%241 = load float*, float** %230
%242 = getelementptr inbounds float, float* %241, i64 3
%243 = load float, float* %242
%244 = fpext float %243 to double
%245 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %244)
%246 = load float*, float** %230
%247 = getelementptr inbounds float, float* %246, i64 4
%248 = load float, float* %247
%249 = fpext float %248 to double
%250 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %249)
%251 = load float*, float** %230
%252 = getelementptr inbounds float, float* %251, i64 5
%253 = load float, float* %252
%254 = fpext float %253 to double
%255 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %254)
%256 = tail call i32 @putchar(i32 10)
%257 = getelementptr inbounds float*, float** %29, i64 4
%258 = load float*, float** %257
%259 = getelementptr inbounds float, float* %258, i64 1
%260 = load float, float* %259
%261 = fpext float %260 to double
%262 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %261)
%263 = load float*, float** %257
%264 = getelementptr inbounds float, float* %263, i64 2
%265 = load float, float* %264
%266 = fpext float %265 to double
%267 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %266)
%268 = load float*, float** %257
%269 = getelementptr inbounds float, float* %268, i64 3
%270 = load float, float* %269
%271 = fpext float %270 to double
%272 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %271)
%273 = load float*, float** %257
%274 = getelementptr inbounds float, float* %273, i64 4
%275 = load float, float* %274
%276 = fpext float %275 to double
%277 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %276)
%278 = load float*, float** %257
%279 = getelementptr inbounds float, float* %278, i64 5
%280 = load float, float* %279
%281 = fpext float %280 to double
%282 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %281)
%283 = tail call i32 @putchar(i32 10)
%284 = getelementptr inbounds float*, float** %29, i64 5
%285 = load float*, float** %284
%286 = getelementptr inbounds float, float* %285, i64 1
%287 = load float, float* %286
%288 = fpext float %287 to double
%289 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %288)
%290 = load float*, float** %284
%291 = getelementptr inbounds float, float* %290, i64 2
%292 = load float, float* %291
%293 = fpext float %292 to double
%294 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %293)
%295 = load float*, float** %284
%296 = getelementptr inbounds float, float* %295, i64 3
%297 = load float, float* %296
%298 = fpext float %297 to double
%299 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %298)
%300 = load float*, float** %284
%301 = getelementptr inbounds float, float* %300, i64 4
%302 = load float, float* %301
%303 = fpext float %302 to double
%304 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %303)
%305 = load float*, float** %284
%306 = getelementptr inbounds float, float* %305, i64 5
%307 = load float, float* %306
%308 = fpext float %307 to double
%309 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %308)
%310 = tail call i32 @putchar(i32 10)
%311 = inttoptr i64 %26 to float**
%312 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([53 x i8], [53 x i8]* @.str.3, i64 0, i64 0), double 0x3FEFAE147AE147AE)
%313 = getelementptr inbounds float*, float** %311, i64 1
%314 = load float*, float** %313
%315 = getelementptr float, float* %314, i64 1
%316 = bitcast float* %315 to i8*
%317 = getelementptr inbounds float*, float** %311, i64 2
%318 = load float*, float** %317
%319 = getelementptr float, float* %318, i64 1
%320 = bitcast float* %319 to i8*
%321 = getelementptr inbounds float*, float** %311, i64 3
%322 = load float*, float** %321
%323 = getelementptr float, float* %322, i64 1
%324 = bitcast float* %323 to i8*
%325 = getelementptr inbounds float*, float** %311, i64 4
%326 = load float*, float** %325
%327 = getelementptr float, float* %326, i64 1
%328 = bitcast float* %327 to i8*
%329 = getelementptr inbounds float*, float** %311, i64 5
%330 = load float*, float** %329
%331 = getelementptr float, float* %330, i64 1
%332 = bitcast float* %331 to i8*
%333 = getelementptr inbounds float, float* %24, i64 1
%334 = load float, float* %333
store float %334, float* %315
%335 = getelementptr inbounds i64, i64* %12, i64 1
%336 = load i64, i64* %335
%337 = getelementptr inbounds i64, i64* %12, i64 2
%338 = load i64, i64* %337
%339 = add i64 %338, -1
%340 = icmp ugt i64 %336, %339
br i1 %340, label %341, label %550
341: ; preds = %550, %174
%342 = getelementptr inbounds float, float* %24, i64 2
%343 = load float, float* %342
%344 = getelementptr inbounds float, float* %318, i64 2
store float %343, float* %344
%345 = getelementptr inbounds i64, i64* %12, i64 3
%346 = load i64, i64* %345
%347 = add i64 %346, -1
%348 = icmp ugt i64 %338, %347
br i1 %348, label %358, label %349
349: ; preds = %341, %349
%350 = phi i64 [ %356, %349 ], [ %338, %341 ]
%351 = getelementptr inbounds float, float* %24, i64 %350
%352 = load float, float* %351
%353 = getelementptr inbounds i64, i64* %12, i64 %350
%354 = load i64, i64* %353
%355 = getelementptr inbounds float, float* %318, i64 %354
store float %352, float* %355
%356 = add i64 %350, 1
%357 = icmp ugt i64 %356, %347
br i1 %357, label %358, label %349
358: ; preds = %349, %341
%359 = getelementptr inbounds float, float* %24, i64 3
%360 = load float, float* %359
%361 = getelementptr inbounds float, float* %322, i64 3
store float %360, float* %361
%362 = getelementptr inbounds i64, i64* %12, i64 4
%363 = load i64, i64* %362
%364 = add i64 %363, -1
%365 = icmp ugt i64 %346, %364
br i1 %365, label %375, label %366
366: ; preds = %358, %366
%367 = phi i64 [ %373, %366 ], [ %346, %358 ]
%368 = getelementptr inbounds float, float* %24, i64 %367
%369 = load float, float* %368
%370 = getelementptr inbounds i64, i64* %12, i64 %367
%371 = load i64, i64* %370
%372 = getelementptr inbounds float, float* %322, i64 %371
store float %369, float* %372
%373 = add i64 %367, 1
%374 = icmp ugt i64 %373, %364
br i1 %374, label %375, label %366
375: ; preds = %366, %358
%376 = getelementptr inbounds float, float* %24, i64 4
%377 = load float, float* %376
%378 = getelementptr inbounds float, float* %326, i64 4
store float %377, float* %378
%379 = getelementptr inbounds i64, i64* %12, i64 5
%380 = load i64, i64* %379
%381 = add i64 %380, -1
%382 = icmp ugt i64 %363, %381
br i1 %382, label %392, label %383
383: ; preds = %375, %383
%384 = phi i64 [ %390, %383 ], [ %363, %375 ]
%385 = getelementptr inbounds float, float* %24, i64 %384
%386 = load float, float* %385
%387 = getelementptr inbounds i64, i64* %12, i64 %384
%388 = load i64, i64* %387
%389 = getelementptr inbounds float, float* %326, i64 %388
store float %386, float* %389
%390 = add i64 %384, 1
%391 = icmp ugt i64 %390, %381
br i1 %391, label %392, label %383
392: ; preds = %383, %375
%393 = getelementptr inbounds float, float* %24, i64 5
%394 = load float, float* %393
%395 = getelementptr inbounds float, float* %330, i64 5
store float %394, float* %395
%396 = getelementptr inbounds i64, i64* %12, i64 6
%397 = load i64, i64* %396
%398 = add i64 %397, -1
%399 = icmp ugt i64 %380, %398
br i1 %399, label %409, label %400
400: ; preds = %392, %400
%401 = phi i64 [ %407, %400 ], [ %380, %392 ]
%402 = getelementptr inbounds float, float* %24, i64 %401
%403 = load float, float* %402
%404 = getelementptr inbounds i64, i64* %12, i64 %401
%405 = load i64, i64* %404
%406 = getelementptr inbounds float, float* %330, i64 %405
store float %403, float* %406
%407 = add i64 %401, 1
%408 = icmp ugt i64 %407, %398
br i1 %408, label %409, label %400
409: ; preds = %400, %392
%410 = load float, float* %315
%411 = fpext float %410 to double
%412 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %411)
%413 = load float*, float** %313
%414 = getelementptr inbounds float, float* %413, i64 2
%415 = load float, float* %414
%416 = fpext float %415 to double
%417 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %416)
%418 = load float*, float** %313
%419 = getelementptr inbounds float, float* %418, i64 3
%420 = load float, float* %419
%421 = fpext float %420 to double
%422 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %421)
%423 = load float*, float** %313
%424 = getelementptr inbounds float, float* %423, i64 4
%425 = load float, float* %424
%426 = fpext float %425 to double
%427 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %426)
%428 = load float*, float** %313
%429 = getelementptr inbounds float, float* %428, i64 5
%430 = load float, float* %429
%431 = fpext float %430 to double
%432 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %431)
%433 = tail call i32 @putchar(i32 10)
%434 = load float*, float** %317
%435 = getelementptr inbounds float, float* %434, i64 1
%436 = load float, float* %435
%437 = fpext float %436 to double
%438 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %437)
%439 = load float*, float** %317
%440 = getelementptr inbounds float, float* %439, i64 2
%441 = load float, float* %440
%442 = fpext float %441 to double
%443 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %442)
%444 = load float*, float** %317
%445 = getelementptr inbounds float, float* %444, i64 3
%446 = load float, float* %445
%447 = fpext float %446 to double
%448 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %447)
%449 = load float*, float** %317
%450 = getelementptr inbounds float, float* %449, i64 4
%451 = load float, float* %450
%452 = fpext float %451 to double
%453 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %452)
%454 = load float*, float** %317
%455 = getelementptr inbounds float, float* %454, i64 5
%456 = load float, float* %455
%457 = fpext float %456 to double
%458 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %457)
%459 = tail call i32 @putchar(i32 10)
%460 = load float*, float** %321
%461 = getelementptr inbounds float, float* %460, i64 1
%462 = load float, float* %461
%463 = fpext float %462 to double
%464 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %463)
%465 = load float*, float** %321
%466 = getelementptr inbounds float, float* %465, i64 2
%467 = load float, float* %466
%468 = fpext float %467 to double
%469 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %468)
%470 = load float*, float** %321
%471 = getelementptr inbounds float, float* %470, i64 3
%472 = load float, float* %471
%473 = fpext float %472 to double
%474 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %473)
%475 = load float*, float** %321
%476 = getelementptr inbounds float, float* %475, i64 4
%477 = load float, float* %476
%478 = fpext float %477 to double
%479 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %478)
%480 = load float*, float** %321
%481 = getelementptr inbounds float, float* %480, i64 5
%482 = load float, float* %481
%483 = fpext float %482 to double
%484 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %483)
%485 = tail call i32 @putchar(i32 10)
%486 = load float*, float** %325
%487 = getelementptr inbounds float, float* %486, i64 1
%488 = load float, float* %487
%489 = fpext float %488 to double
%490 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %489)
%491 = load float*, float** %325
%492 = getelementptr inbounds float, float* %491, i64 2
%493 = load float, float* %492
%494 = fpext float %493 to double
%495 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %494)
%496 = load float*, float** %325
%497 = getelementptr inbounds float, float* %496, i64 3
%498 = load float, float* %497
%499 = fpext float %498 to double
%500 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %499)
%501 = load float*, float** %325
%502 = getelementptr inbounds float, float* %501, i64 4
%503 = load float, float* %502
%504 = fpext float %503 to double
%505 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %504)
%506 = load float*, float** %325
%507 = getelementptr inbounds float, float* %506, i64 5
%508 = load float, float* %507
%509 = fpext float %508 to double
%510 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %509)
%511 = tail call i32 @putchar(i32 10)
%512 = load float*, float** %329
%513 = getelementptr inbounds float, float* %512, i64 1
%514 = load float, float* %513
%515 = fpext float %514 to double
%516 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %515)
%517 = load float*, float** %329
%518 = getelementptr inbounds float, float* %517, i64 2
%519 = load float, float* %518
%520 = fpext float %519 to double
%521 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %520)
%522 = load float*, float** %329
%523 = getelementptr inbounds float, float* %522, i64 3
%524 = load float, float* %523
%525 = fpext float %524 to double
%526 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %525)
%527 = load float*, float** %329
%528 = getelementptr inbounds float, float* %527, i64 4
%529 = load float, float* %528
%530 = fpext float %529 to double
%531 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %530)
%532 = load float*, float** %329
%533 = getelementptr inbounds float, float* %532, i64 5
%534 = load float, float* %533
%535 = fpext float %534 to double
%536 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %535)
%537 = tail call i32 @putchar(i32 10)
%538 = tail call i32 (float**, i32, i32, i32, i32, ...) bitcast (i32 (...)* @free_convert_matrix to i32 (float**, i32, i32, i32, i32, ...)*)(float** %35, i32 1, i32 5, i32 1, i32 5)
%539 = tail call i32 (float**, i32, i32, i32, i32, ...) bitcast (i32 (...)* @free_convert_matrix to i32 (float**, i32, i32, i32, i32, ...)*)(float** %32, i32 1, i32 5, i32 1, i32 5)
%540 = tail call i32 (float**, i32, i32, i32, i32, ...) bitcast (i32 (...)* @free_matrix to i32 (float**, i32, i32, i32, i32, ...)*)(float** %29, i32 1, i32 5, i32 1, i32 5)
%541 = tail call i32 (float**, i32, i32, i32, i32, ...) bitcast (i32 (...)* @free_matrix to i32 (float**, i32, i32, i32, i32, ...)*)(float** %311, i32 1, i32 5, i32 1, i32 5)
%542 = tail call i32 (float*, i32, i32, ...) bitcast (i32 (...)* @free_vector to i32 (float*, i32, i32, ...)*)(float* %24, i32 1, i32 51)
%543 = tail call i32 (float*, i32, i32, ...) bitcast (i32 (...)* @free_vector to i32 (float*, i32, i32, ...)*)(float* %21, i32 1, i32 51)
%544 = tail call i32 (float*, i32, i32, ...) bitcast (i32 (...)* @free_vector to i32 (float*, i32, i32, ...)*)(float* %18, i32 1, i32 51)
%545 = tail call i32 (float*, i32, i32, ...) bitcast (i32 (...)* @free_vector to i32 (float*, i32, i32, ...)*)(float* %15, i32 1, i32 51)
%546 = tail call i32 (i64*, i32, i32, ...) bitcast (i32 (...)* @free_lvector to i32 (i64*, i32, i32, ...)*)(i64* %12, i32 1, i32 51)
%547 = tail call i32 (i64*, i32, i32, ...) bitcast (i32 (...)* @free_lvector to i32 (i64*, i32, i32, ...)*)(i64* %9, i32 1, i32 51)
%548 = tail call i32 (i64*, i32, i32, ...) bitcast (i32 (...)* @free_lvector to i32 (i64*, i32, i32, ...)*)(i64* %6, i32 1, i32 51)
%549 = tail call i32 (i64*, i32, i32, ...) bitcast (i32 (...)* @free_lvector to i32 (i64*, i32, i32, ...)*)(i64* %3, i32 1, i32 51)
ret i32 0
550: ; preds = %174, %550
%551 = phi i64 [ %557, %550 ], [ %336, %174 ]
%552 = getelementptr inbounds float, float* %24, i64 %551
%553 = load float, float* %552
%554 = getelementptr inbounds i64, i64* %12, i64 %551
%555 = load i64, i64* %554
%556 = getelementptr inbounds float, float* %314, i64 %555
store float %553, float* %556
%557 = add i64 %551, 1
%558 = icmp ugt i64 %557, %339
br i1 %558, label %341, label %550
}