#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 */
float **convert_matrix(float *, int, int, int, int);
int /*<<< orphan*/ free_convert_matrix(float **, int, int, int, int);
int /*<<< orphan*/ free_lvector(unsigned long *, int, int);
int /*<<< orphan*/ free_matrix(float **, int, int, int, int);
int /*<<< orphan*/ free_vector(float *, int, int);
unsigned long *lvector(int, int);
float **matrix(int, int, int, int);
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ sprsin(float **, int, double, int, float *, unsigned long *);
int /*<<< orphan*/ sprspm(float *, unsigned long *, float *, unsigned long *,
                          float *, unsigned long *);
int /*<<< orphan*/ sprstp(float *, unsigned long *, float *, unsigned long *);
float *vector(int, int);
int main(void) {
  unsigned long i, j, k, *ija, *ijb, *ijbt, *ijc;
  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);
  for (i = 1; i <= ija[ija[1] - 1] - 1; i++)
    ijc[i] = ija[i];
  sprspm(sa, ija, sbt, ijbt, 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("sprspm matrix (should show only tridiagonals):\n");
  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    $0x80,%rsp
movl   $0x0,-0x4(%rbp)
mov    $0x1,%edi
mov    $0x33,%esi
call   10e0 <lvector@plt>
mov    %rax,-0x28(%rbp)
mov    $0x1,%edi
mov    $0x33,%esi
call   10e0 <lvector@plt>
mov    %rax,-0x30(%rbp)
mov    $0x1,%edi
mov    $0x33,%esi
call   10e0 <lvector@plt>
mov    %rax,-0x38(%rbp)
mov    $0x1,%edi
mov    $0x33,%esi
call   10e0 <lvector@plt>
mov    %rax,-0x40(%rbp)
mov    $0x1,%edi
mov    $0x33,%esi
call   10b0 <vector@plt>
mov    %rax,-0x48(%rbp)
mov    $0x1,%edi
mov    $0x33,%esi
call   10b0 <vector@plt>
mov    %rax,-0x50(%rbp)
mov    $0x1,%edi
mov    $0x33,%esi
call   10b0 <vector@plt>
mov    %rax,-0x58(%rbp)
mov    $0x1,%edi
mov    $0x33,%esi
call   10b0 <vector@plt>
mov    %rax,-0x60(%rbp)
mov    $0x1,%edx
mov    $0x5,%ecx
mov    %edx,%edi
mov    %ecx,%esi
call   10a0 <matrix@plt>
mov    %rax,-0x78(%rbp)
mov    $0x1,%edx
mov    $0x5,%ecx
mov    %edx,%edi
mov    %ecx,%esi
call   10a0 <matrix@plt>
mov    %rax,-0x80(%rbp)
lea    0x2df1(%rip),%rdi
mov    $0x1,%ecx
mov    $0x5,%r8d
mov    %ecx,%esi
mov    %r8d,%edx
call   10d0 <convert_matrix@plt>
mov    %rax,-0x68(%rbp)
lea    0x2e41(%rip),%rdi
mov    $0x1,%ecx
mov    $0x5,%r8d
mov    %ecx,%esi
mov    %r8d,%edx
call   10d0 <convert_matrix@plt>
mov    %rax,-0x70(%rbp)
mov    -0x68(%rbp),%rdi
mov    -0x48(%rbp),%rcx
mov    -0x28(%rbp),%r8
mov    $0x5,%esi
movsd  0xd0f(%rip),%xmm0
mov    $0x33,%edx
call   10c0 <sprsin@plt>
mov    -0x70(%rbp),%rdi
mov    -0x50(%rbp),%rcx
mov    -0x30(%rbp),%r8
mov    $0x5,%esi
movsd  0xcec(%rip),%xmm0
mov    $0x33,%edx
call   10c0 <sprsin@plt>
mov    -0x50(%rbp),%rdi
mov    -0x30(%rbp),%rsi
mov    -0x58(%rbp),%rdx
mov    -0x38(%rbp),%rcx
call   1090 <sprstp@plt>
movq   $0x1,-0x10(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    -0x28(%rbp),%rdx
mov    0x8(%rdx),%rdx
sub    $0x1,%rdx
mov    (%rcx,%rdx,8),%rcx
sub    $0x1,%rcx
cmp    %rcx,%rax
ja     1389 <main+0x1c9>
mov    -0x28(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x40(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    133b <main+0x17b>
mov    -0x48(%rbp),%rdi
mov    -0x28(%rbp),%rsi
mov    -0x58(%rbp),%rdx
mov    -0x38(%rbp),%rcx
mov    -0x60(%rbp),%r8
mov    -0x40(%rbp),%r9
call   1080 <sprspm@plt>
movq   $0x1,-0x10(%rbp)
cmpq   $0x5,-0x10(%rbp)
ja     1490 <main+0x2d0>
movq   $0x1,-0x18(%rbp)
cmpq   $0x5,-0x18(%rbp)
ja     147a <main+0x2ba>
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)
movq   $0x1,-0x20(%rbp)
cmpq   $0x5,-0x20(%rbp)
ja     1464 <main+0x2a4>
mov    -0x80(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x18(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x68(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x70(%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    -0x80(%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    13ec <main+0x22c>
jmp    1469 <main+0x2a9>
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    13c1 <main+0x201>
jmp    147f <main+0x2bf>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    13ae <main+0x1ee>
lea    0xb71(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movq   $0x1,-0x10(%rbp)
cmpq   $0x5,-0x10(%rbp)
ja     151b <main+0x35b>
movq   $0x1,-0x18(%rbp)
cmpq   $0x5,-0x18(%rbp)
ja     14fc <main+0x33c>
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    0xb37(%rip),%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    14b9 <main+0x2f9>
lea    0xb4d(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    14a6 <main+0x2e6>
lea    0xb00(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
movq   $0x1,-0x10(%rbp)
cmpq   $0x5,-0x10(%rbp)
ja     158e <main+0x3ce>
movq   $0x1,-0x18(%rbp)
cmpq   $0x5,-0x18(%rbp)
ja     1578 <main+0x3b8>
mov    -0x78(%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    1544 <main+0x384>
jmp    157d <main+0x3bd>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    1531 <main+0x371>
movq   $0x1,-0x10(%rbp)
cmpq   $0x5,-0x10(%rbp)
ja     1642 <main+0x482>
mov    -0x60(%rbp),%rax
mov    -0x10(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x78(%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     162c <main+0x46c>
mov    -0x60(%rbp),%rax
mov    -0x18(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x78(%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    15d3 <main+0x413>
jmp    1631 <main+0x471>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    1596 <main+0x3d6>
movq   $0x1,-0x10(%rbp)
cmpq   $0x5,-0x10(%rbp)
ja     16bf <main+0x4ff>
movq   $0x1,-0x18(%rbp)
cmpq   $0x5,-0x18(%rbp)
ja     16a0 <main+0x4e0>
mov    -0x78(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x18(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0x993(%rip),%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    165d <main+0x49d>
lea    0x9a9(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    164a <main+0x48a>
mov    -0x70(%rbp),%rdi
mov    $0x1,%ecx
mov    $0x5,%r8d
mov    %ecx,%esi
mov    %r8d,%edx
call   1030 <free_convert_matrix@plt>
mov    -0x68(%rbp),%rdi
mov    $0x1,%ecx
mov    $0x5,%r8d
mov    %ecx,%esi
mov    %r8d,%edx
call   1030 <free_convert_matrix@plt>
mov    -0x80(%rbp),%rdi
mov    $0x1,%ecx
mov    $0x5,%r8d
mov    %ecx,%esi
mov    %r8d,%edx
call   1040 <free_matrix@plt>
mov    -0x78(%rbp),%rdi
mov    $0x1,%ecx
mov    $0x5,%r8d
mov    %ecx,%esi
mov    %r8d,%edx
call   1040 <free_matrix@plt>
mov    -0x60(%rbp),%rdi
mov    $0x1,%esi
mov    $0x33,%edx
call   1070 <free_vector@plt>
mov    -0x58(%rbp),%rdi
mov    $0x1,%esi
mov    $0x33,%edx
call   1070 <free_vector@plt>
mov    -0x50(%rbp),%rdi
mov    $0x1,%esi
mov    $0x33,%edx
call   1070 <free_vector@plt>
mov    -0x48(%rbp),%rdi
mov    $0x1,%esi
mov    $0x33,%edx
call   1070 <free_vector@plt>
mov    -0x40(%rbp),%rdi
mov    $0x1,%esi
mov    $0x33,%edx
call   1050 <free_lvector@plt>
mov    -0x38(%rbp),%rdi
mov    $0x1,%esi
mov    $0x33,%edx
call   1050 <free_lvector@plt>
mov    -0x30(%rbp),%rdi
mov    $0x1,%esi
mov    $0x33,%edx
call   1050 <free_lvector@plt>
mov    -0x28(%rbp),%rdi
mov    $0x1,%esi
mov    $0x33,%edx
call   1050 <free_lvector@plt>
xor    %eax,%eax
add    $0x80,%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
call   1100 <lvector@plt>
mov    %rax,%rbx
mov    $0x1,%edi
mov    $0x33,%esi
call   1100 <lvector@plt>
mov    %rax,0x40(%rsp)
mov    $0x1,%edi
mov    $0x33,%esi
call   1100 <lvector@plt>
mov    %rax,0x38(%rsp)
mov    $0x1,%edi
mov    $0x33,%esi
call   1100 <lvector@plt>
mov    %rax,%r14
mov    $0x1,%edi
mov    $0x33,%esi
call   10d0 <vector@plt>
mov    %rax,0x10(%rsp)
mov    $0x1,%edi
mov    $0x33,%esi
call   10d0 <vector@plt>
mov    %rax,0x30(%rsp)
mov    $0x1,%edi
mov    $0x33,%esi
call   10d0 <vector@plt>
mov    %rax,0x8(%rsp)
mov    $0x1,%edi
mov    $0x33,%esi
call   10d0 <vector@plt>
mov    %rax,%r15
mov    $0x1,%edi
mov    $0x5,%esi
mov    $0x1,%edx
mov    $0x5,%ecx
call   10c0 <matrix@plt>
mov    %rax,0x28(%rsp)
mov    $0x1,%edi
mov    $0x5,%esi
mov    $0x1,%edx
mov    $0x5,%ecx
call   10c0 <matrix@plt>
mov    %rax,0x48(%rsp)
lea    0x2dd5(%rip),%rdi
mov    $0x1,%esi
mov    $0x5,%edx
mov    $0x1,%ecx
mov    $0x5,%r8d
call   10f0 <convert_matrix@plt>
mov    %rax,%r12
lea    0x2e21(%rip),%rdi
mov    $0x1,%esi
mov    $0x5,%edx
mov    $0x1,%ecx
mov    $0x5,%r8d
call   10f0 <convert_matrix@plt>
mov    %rax,%rbp
movsd  0xcec(%rip),%xmm0
mov    %r12,0x20(%rsp)
mov    %r12,%rdi
mov    0x38(%rsp),%r13
mov    $0x5,%esi
mov    $0x33,%edx
mov    0x10(%rsp),%rcx
mov    %rbx,%r8
call   10e0 <sprsin@plt>
mov    %rbp,0x18(%rsp)
mov    %rbp,%rdi
mov    $0x5,%esi
movsd  0xcb3(%rip),%xmm0
mov    $0x33,%edx
mov    0x30(%rsp),%r12
mov    %r12,%rcx
mov    0x40(%rsp),%rbp
mov    %rbp,%r8
call   10e0 <sprsin@plt>
mov    %r12,%rdi
mov    %rbp,%rsi
mov    0x8(%rsp),%rdx
mov    %r13,%rbp
mov    %r13,%rcx
call   10b0 <sprstp@plt>
mov    0x8(%rbx),%rax
cmpq   $0x1,-0x8(%rbx,%rax,8)
je     13d0 <main+0x1f0>
mov    %rax,0x8(%r14)
mov    0x8(%rbx),%rax
mov    -0x8(%rbx,%rax,8),%rax
add    $0xfffffffffffffffd,%rax
cmp    $0xfffffffffffffffd,%rax
ja     13d0 <main+0x1f0>
mov    $0x1,%eax
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x8(%rbx,%rax,8),%rcx
mov    %rcx,0x8(%r14,%rax,8)
mov    0x8(%rbx),%rcx
mov    -0x8(%rbx,%rcx,8),%rcx
add    $0xffffffffffffffff,%rcx
add    $0x1,%rax
cmp    %rcx,%rax
jb     13b0 <main+0x1d0>
mov    0x10(%rsp),%rdi
mov    %rbx,0x50(%rsp)
mov    %rbx,%rsi
mov    0x8(%rsp),%rdx
mov    %rbp,%rcx
mov    %r15,%r8
mov    %r14,%r9
call   10a0 <sprspm@plt>
mov    0x18(%rsp),%rax
mov    0x8(%rax),%r8
mov    0x10(%rax),%rcx
mov    0x18(%rax),%rdx
mov    0x20(%rax),%rsi
mov    0x28(%rax),%rdi
mov    $0x1,%ebp
xorps  %xmm0,%xmm0
mov    0x20(%rsp),%r9
mov    0x48(%rsp),%r13
nopl   0x0(%rax,%rax,1)
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    1420 <main+0x240>
lea    0x9ce(%rip),%rdi
call   1050 <puts@plt>
mov    0x8(%r13),%rax
movss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0x9ae(%rip),%r12
mov    %r12,%rdi
mov    $0x1,%al
call   1080 <printf@plt>
mov    0x8(%r13),%rax
movss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1080 <printf@plt>
mov    0x8(%r13),%rax
movss  0xc(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1080 <printf@plt>
mov    0x8(%r13),%rax
movss  0x10(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1080 <printf@plt>
mov    0x8(%r13),%rax
movss  0x14(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1080 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    0x10(%r13),%rax
movss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1080 <printf@plt>
mov    0x10(%r13),%rax
movss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1080 <printf@plt>
mov    0x10(%r13),%rax
movss  0xc(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1080 <printf@plt>
mov    0x10(%r13),%rax
movss  0x10(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1080 <printf@plt>
mov    0x10(%r13),%rax
movss  0x14(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1080 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    0x18(%r13),%rax
movss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1080 <printf@plt>
mov    0x18(%r13),%rax
movss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1080 <printf@plt>
mov    0x18(%r13),%rax
movss  0xc(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1080 <printf@plt>
mov    0x18(%r13),%rax
movss  0x10(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1080 <printf@plt>
mov    0x18(%r13),%rax
movss  0x14(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1080 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    0x20(%r13),%rax
movss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1080 <printf@plt>
mov    0x20(%r13),%rax
movss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1080 <printf@plt>
mov    0x20(%r13),%rax
movss  0xc(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1080 <printf@plt>
mov    0x20(%r13),%rax
movss  0x10(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1080 <printf@plt>
mov    0x20(%r13),%rax
movss  0x14(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1080 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    0x28(%r13),%rax
movss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1080 <printf@plt>
mov    0x28(%r13),%rax
movss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1080 <printf@plt>
mov    0x28(%r13),%rax
movss  0xc(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1080 <printf@plt>
mov    0x28(%r13),%rax
movss  0x10(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1080 <printf@plt>
mov    0x28(%r13),%rax
movss  0x14(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1080 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x75c(%rip),%rdi
call   1050 <puts@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     1959 <main+0x779>
xchg   %ax,%ax
movss  (%r15,%rbx,4),%xmm0
mov    (%r14,%rbx,8),%rax
movss  %xmm0,(%r9,%rax,4)
add    $0x1,%rbx
cmp    %rcx,%rbx
jbe    1940 <main+0x760>
movss  0x8(%r15),%xmm0
movss  %xmm0,0x8(%rdi)
mov    0x18(%r14),%rbx
lea    -0x1(%rbx),%rcx
cmp    %rcx,%rbp
ja     1998 <main+0x7b8>
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    1980 <main+0x7a0>
movss  0xc(%r15),%xmm0
movss  %xmm0,0xc(%rsi)
mov    0x20(%r14),%rdi
lea    -0x1(%rdi),%rcx
cmp    %rcx,%rbx
ja     19c8 <main+0x7e8>
movss  (%r15,%rbx,4),%xmm0
mov    (%r14,%rbx,8),%rax
movss  %xmm0,(%rsi,%rax,4)
add    $0x1,%rbx
cmp    %rcx,%rbx
jbe    19b0 <main+0x7d0>
movss  0x10(%r15),%xmm0
movss  %xmm0,0x10(%rdx)
mov    0x28(%r14),%rsi
lea    -0x1(%rsi),%rcx
cmp    %rcx,%rdi
ja     19f8 <main+0x818>
movss  (%r15,%rdi,4),%xmm0
mov    (%r14,%rdi,8),%rax
movss  %xmm0,(%rdx,%rax,4)
add    $0x1,%rdi
cmp    %rcx,%rdi
jbe    19e0 <main+0x800>
add    $0x4,%r9
movss  0x14(%r15),%xmm0
movss  %xmm0,0x14(%r8)
mov    0x30(%r14),%rdx
add    $0xffffffffffffffff,%rdx
cmp    %rdx,%rsi
mov    0x50(%rsp),%rbx
ja     1a39 <main+0x859>
nopw   0x0(%rax,%rax,1)
movss  (%r15,%rsi,4),%xmm0
mov    (%r14,%rsi,8),%rax
movss  %xmm0,(%r8,%rax,4)
add    $0x1,%rsi
cmp    %rdx,%rsi
jbe    1a20 <main+0x840>
movss  (%r9),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0x5bf(%rip),%r12
mov    %r12,%rdi
mov    $0x1,%al
call   1080 <printf@plt>
mov    0x28(%rsp),%rbp
mov    0x8(%rbp),%rax
movss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1080 <printf@plt>
mov    0x8(%rbp),%rax
movss  0xc(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1080 <printf@plt>
mov    0x8(%rbp),%rax
movss  0x10(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1080 <printf@plt>
mov    0x8(%rbp),%rax
movss  0x14(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1080 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    0x10(%rbp),%rax
movss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1080 <printf@plt>
mov    0x10(%rbp),%rax
movss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1080 <printf@plt>
mov    0x10(%rbp),%rax
movss  0xc(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1080 <printf@plt>
mov    0x10(%rbp),%rax
movss  0x10(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1080 <printf@plt>
mov    0x10(%rbp),%rax
movss  0x14(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1080 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    0x18(%rbp),%rax
movss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1080 <printf@plt>
mov    0x18(%rbp),%rax
movss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1080 <printf@plt>
mov    0x18(%rbp),%rax
movss  0xc(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1080 <printf@plt>
mov    0x18(%rbp),%rax
movss  0x10(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1080 <printf@plt>
mov    0x18(%rbp),%rax
movss  0x14(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1080 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    0x20(%rbp),%rax
movss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1080 <printf@plt>
mov    0x20(%rbp),%rax
movss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1080 <printf@plt>
mov    0x20(%rbp),%rax
movss  0xc(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1080 <printf@plt>
mov    0x20(%rbp),%rax
movss  0x10(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1080 <printf@plt>
mov    0x20(%rbp),%rax
movss  0x14(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1080 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    0x28(%rbp),%rax
movss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1080 <printf@plt>
mov    0x28(%rbp),%rax
movss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1080 <printf@plt>
mov    0x28(%rbp),%rax
movss  0xc(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1080 <printf@plt>
mov    0x28(%rbp),%rax
movss  0x10(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1080 <printf@plt>
mov    0x28(%rbp),%rax
movss  0x14(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1080 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    0x18(%rsp),%rdi
mov    $0x1,%esi
mov    $0x5,%edx
mov    $0x1,%ecx
mov    $0x5,%r8d
call   1040 <free_convert_matrix@plt>
mov    0x20(%rsp),%rdi
mov    $0x1,%esi
mov    $0x5,%edx
mov    $0x1,%ecx
mov    $0x5,%r8d
call   1040 <free_convert_matrix@plt>
mov    %r13,%rdi
mov    $0x1,%esi
mov    $0x5,%edx
mov    $0x1,%ecx
mov    $0x5,%r8d
call   1060 <free_matrix@plt>
mov    %rbp,%rdi
mov    $0x1,%esi
mov    $0x5,%edx
mov    $0x1,%ecx
mov    $0x5,%r8d
call   1060 <free_matrix@plt>
mov    %r15,%rdi
mov    $0x1,%esi
mov    $0x33,%edx
call   1090 <free_vector@plt>
mov    0x8(%rsp),%rdi
mov    $0x1,%esi
mov    $0x33,%edx
call   1090 <free_vector@plt>
mov    0x30(%rsp),%rdi
mov    $0x1,%esi
mov    $0x33,%edx
call   1090 <free_vector@plt>
mov    0x10(%rsp),%rdi
mov    $0x1,%esi
mov    $0x33,%edx
call   1090 <free_vector@plt>
mov    %r14,%rdi
mov    $0x1,%esi
mov    $0x33,%edx
call   1070 <free_lvector@plt>
mov    0x38(%rsp),%rdi
mov    $0x1,%esi
mov    $0x33,%edx
call   1070 <free_lvector@plt>
mov    0x40(%rsp),%rdi
mov    $0x1,%esi
mov    $0x33,%edx
call   1070 <free_lvector@plt>
mov    %rbx,%rdi
mov    $0x1,%esi
mov    $0x33,%edx
call   1070 <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 = [48 x i8] c"sprspm matrix (should show only tridiagonals):\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 float*
%10 = alloca float*
%11 = alloca float*
%12 = alloca float*
%13 = alloca float**
%14 = alloca float**
%15 = alloca float**
%16 = alloca float**
store i32 0, i32* %1
%17 = call i64* @lvector(i32 1, i32 51)
store i64* %17, i64** %5
%18 = call i64* @lvector(i32 1, i32 51)
store i64* %18, i64** %6
%19 = call i64* @lvector(i32 1, i32 51)
store i64* %19, i64** %7
%20 = call i64* @lvector(i32 1, i32 51)
store i64* %20, i64** %8
%21 = call float* @vector(i32 1, i32 51)
store float* %21, float** %9
%22 = call float* @vector(i32 1, i32 51)
store float* %22, float** %10
%23 = call float* @vector(i32 1, i32 51)
store float* %23, float** %11
%24 = call float* @vector(i32 1, i32 51)
store float* %24, float** %12
%25 = call float** @matrix(i32 1, i32 5, i32 1, i32 5)
store float** %25, float*** %15
%26 = call float** @matrix(i32 1, i32 5, i32 1, i32 5)
store float** %26, float*** %16
%27 = call float** @convert_matrix(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)
store float** %27, float*** %13
%28 = call float** @convert_matrix(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)
store float** %28, float*** %14
%29 = load float**, float*** %13
%30 = load float*, float** %9
%31 = load i64*, i64** %5
%32 = call i32 @sprsin(float** %29, i32 5, double 5.000000e-01, i32 51, float* %30, i64* %31)
%33 = load float**, float*** %14
%34 = load float*, float** %10
%35 = load i64*, i64** %6
%36 = call i32 @sprsin(float** %33, i32 5, double 5.000000e-01, i32 51, float* %34, i64* %35)
%37 = load float*, float** %10
%38 = load i64*, i64** %6
%39 = load float*, float** %11
%40 = load i64*, i64** %7
%41 = call i32 @sprstp(float* %37, i64* %38, float* %39, i64* %40)
store i64 1, i64* %2
br label %42
42: ; preds = %61, %0
%43 = load i64, i64* %2
%44 = load i64*, i64** %5
%45 = load i64*, i64** %5
%46 = getelementptr inbounds i64, i64* %45, i64 1
%47 = load i64, i64* %46
%48 = sub i64 %47, 1
%49 = getelementptr inbounds i64, i64* %44, i64 %48
%50 = load i64, i64* %49
%51 = sub i64 %50, 1
%52 = icmp ule i64 %43, %51
br i1 %52, label %53, label %64
53: ; preds = %42
%54 = load i64*, i64** %5
%55 = load i64, i64* %2
%56 = getelementptr inbounds i64, i64* %54, i64 %55
%57 = load i64, i64* %56
%58 = load i64*, i64** %8
%59 = load i64, i64* %2
%60 = getelementptr inbounds i64, i64* %58, i64 %59
store i64 %57, i64* %60
br label %61
61: ; preds = %53
%62 = load i64, i64* %2
%63 = add i64 %62, 1
store i64 %63, i64* %2
br label %42
64: ; preds = %42
%65 = load float*, float** %9
%66 = load i64*, i64** %5
%67 = load float*, float** %11
%68 = load i64*, i64** %7
%69 = load float*, float** %12
%70 = load i64*, i64** %8
%71 = call i32 @sprspm(float* %65, i64* %66, float* %67, i64* %68, float* %69, i64* %70)
store i64 1, i64* %2
br label %72
72: ; preds = %126, %64
%73 = load i64, i64* %2
%74 = icmp ule i64 %73, 5
br i1 %74, label %75, label %129
75: ; preds = %72
store i64 1, i64* %3
br label %76
76: ; preds = %122, %75
%77 = load i64, i64* %3
%78 = icmp ule i64 %77, 5
br i1 %78, label %79, label %125
79: ; preds = %76
%80 = load float**, float*** %16
%81 = load i64, i64* %2
%82 = getelementptr inbounds float*, float** %80, i64 %81
%83 = load float*, float** %82
%84 = load i64, i64* %3
%85 = getelementptr inbounds float, float* %83, i64 %84
store float 0.000000e+00, float* %85
store i64 1, i64* %4
br label %86
86: ; preds = %118, %79
%87 = load i64, i64* %4
%88 = icmp ule i64 %87, 5
br i1 %88, label %89, label %121
89: ; preds = %86
%90 = load float**, float*** %16
%91 = load i64, i64* %2
%92 = getelementptr inbounds float*, float** %90, i64 %91
%93 = load float*, float** %92
%94 = load i64, i64* %3
%95 = getelementptr inbounds float, float* %93, i64 %94
%96 = load float, float* %95
%97 = load float**, float*** %13
%98 = load i64, i64* %2
%99 = getelementptr inbounds float*, float** %97, i64 %98
%100 = load float*, float** %99
%101 = load i64, i64* %4
%102 = getelementptr inbounds float, float* %100, i64 %101
%103 = load float, float* %102
%104 = load float**, float*** %14
%105 = load i64, i64* %4
%106 = getelementptr inbounds float*, float** %104, i64 %105
%107 = load float*, float** %106
%108 = load i64, i64* %3
%109 = getelementptr inbounds float, float* %107, i64 %108
%110 = load float, float* %109
%111 = call float @llvm.fmuladd.f32(float %103, float %110, float %96)
%112 = load float**, float*** %16
%113 = load i64, i64* %2
%114 = getelementptr inbounds float*, float** %112, i64 %113
%115 = load float*, float** %114
%116 = load i64, i64* %3
%117 = getelementptr inbounds float, float* %115, i64 %116
store float %111, float* %117
br label %118
118: ; preds = %89
%119 = load i64, i64* %4
%120 = add i64 %119, 1
store i64 %120, i64* %4
br label %86
121: ; preds = %86
br label %122
122: ; preds = %121
%123 = load i64, i64* %3
%124 = add i64 %123, 1
store i64 %124, i64* %3
br label %76
125: ; preds = %76
br label %126
126: ; preds = %125
%127 = load i64, i64* %2
%128 = add i64 %127, 1
store i64 %128, i64* %2
br label %72
129: ; preds = %72
%130 = 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 %131
131: ; preds = %153, %129
%132 = load i64, i64* %2
%133 = icmp ule i64 %132, 5
br i1 %133, label %134, label %156
134: ; preds = %131
store i64 1, i64* %3
br label %135
135: ; preds = %148, %134
%136 = load i64, i64* %3
%137 = icmp ule i64 %136, 5
br i1 %137, label %138, label %151
138: ; preds = %135
%139 = load float**, float*** %16
%140 = load i64, i64* %2
%141 = getelementptr inbounds float*, float** %139, i64 %140
%142 = load float*, float** %141
%143 = load i64, i64* %3
%144 = getelementptr inbounds float, float* %142, i64 %143
%145 = load float, float* %144
%146 = fpext float %145 to double
%147 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %146)
br label %148
148: ; preds = %138
%149 = load i64, i64* %3
%150 = add i64 %149, 1
store i64 %150, i64* %3
br label %135
151: ; preds = %135
%152 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
br label %153
153: ; preds = %151
%154 = load i64, i64* %2
%155 = add i64 %154, 1
store i64 %155, i64* %2
br label %131
156: ; preds = %131
%157 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([48 x i8], [48 x i8]* @.str.3, i64 0, i64 0))
store i64 1, i64* %2
br label %158
158: ; preds = %176, %156
%159 = load i64, i64* %2
%160 = icmp ule i64 %159, 5
br i1 %160, label %161, label %179
161: ; preds = %158
store i64 1, i64* %3
br label %162
162: ; preds = %172, %161
%163 = load i64, i64* %3
%164 = icmp ule i64 %163, 5
br i1 %164, label %165, label %175
165: ; preds = %162
%166 = load float**, float*** %15
%167 = load i64, i64* %2
%168 = getelementptr inbounds float*, float** %166, i64 %167
%169 = load float*, float** %168
%170 = load i64, i64* %3
%171 = getelementptr inbounds float, float* %169, i64 %170
store float 0.000000e+00, float* %171
br label %172
172: ; preds = %165
%173 = load i64, i64* %3
%174 = add i64 %173, 1
store i64 %174, i64* %3
br label %162
175: ; preds = %162
br label %176
176: ; preds = %175
%177 = load i64, i64* %2
%178 = add i64 %177, 1
store i64 %178, i64* %2
br label %158
179: ; preds = %158
store i64 1, i64* %2
br label %180
180: ; preds = %225, %179
%181 = load i64, i64* %2
%182 = icmp ule i64 %181, 5
br i1 %182, label %183, label %228
183: ; preds = %180
%184 = load float*, float** %12
%185 = load i64, i64* %2
%186 = getelementptr inbounds float, float* %184, i64 %185
%187 = load float, float* %186
%188 = load float**, float*** %15
%189 = load i64, i64* %2
%190 = getelementptr inbounds float*, float** %188, i64 %189
%191 = load float*, float** %190
%192 = load i64, i64* %2
%193 = getelementptr inbounds float, float* %191, i64 %192
store float %187, float* %193
%194 = load i64*, i64** %8
%195 = load i64, i64* %2
%196 = getelementptr inbounds i64, i64* %194, i64 %195
%197 = load i64, i64* %196
store i64 %197, i64* %3
br label %198
198: ; preds = %221, %183
%199 = load i64, i64* %3
%200 = load i64*, i64** %8
%201 = load i64, i64* %2
%202 = add i64 %201, 1
%203 = getelementptr inbounds i64, i64* %200, i64 %202
%204 = load i64, i64* %203
%205 = sub i64 %204, 1
%206 = icmp ule i64 %199, %205
br i1 %206, label %207, label %224
207: ; preds = %198
%208 = load float*, float** %12
%209 = load i64, i64* %3
%210 = getelementptr inbounds float, float* %208, i64 %209
%211 = load float, float* %210
%212 = load float**, float*** %15
%213 = load i64, i64* %2
%214 = getelementptr inbounds float*, float** %212, i64 %213
%215 = load float*, float** %214
%216 = load i64*, i64** %8
%217 = load i64, i64* %3
%218 = getelementptr inbounds i64, i64* %216, i64 %217
%219 = load i64, i64* %218
%220 = getelementptr inbounds float, float* %215, i64 %219
store float %211, float* %220
br label %221
221: ; preds = %207
%222 = load i64, i64* %3
%223 = add i64 %222, 1
store i64 %223, i64* %3
br label %198
224: ; preds = %198
br label %225
225: ; preds = %224
%226 = load i64, i64* %2
%227 = add i64 %226, 1
store i64 %227, i64* %2
br label %180
228: ; preds = %180
store i64 1, i64* %2
br label %229
229: ; preds = %251, %228
%230 = load i64, i64* %2
%231 = icmp ule i64 %230, 5
br i1 %231, label %232, label %254
232: ; preds = %229
store i64 1, i64* %3
br label %233
233: ; preds = %246, %232
%234 = load i64, i64* %3
%235 = icmp ule i64 %234, 5
br i1 %235, label %236, label %249
236: ; preds = %233
%237 = load float**, float*** %15
%238 = load i64, i64* %2
%239 = getelementptr inbounds float*, float** %237, i64 %238
%240 = load float*, float** %239
%241 = load i64, i64* %3
%242 = getelementptr inbounds float, float* %240, i64 %241
%243 = load float, float* %242
%244 = fpext float %243 to double
%245 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %244)
br label %246
246: ; preds = %236
%247 = load i64, i64* %3
%248 = add i64 %247, 1
store i64 %248, i64* %3
br label %233
249: ; preds = %233
%250 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
br label %251
251: ; preds = %249
%252 = load i64, i64* %2
%253 = add i64 %252, 1
store i64 %253, i64* %2
br label %229
254: ; preds = %229
%255 = load float**, float*** %14
%256 = call i32 @free_convert_matrix(float** %255, i32 1, i32 5, i32 1, i32 5)
%257 = load float**, float*** %13
%258 = call i32 @free_convert_matrix(float** %257, i32 1, i32 5, i32 1, i32 5)
%259 = load float**, float*** %16
%260 = call i32 @free_matrix(float** %259, i32 1, i32 5, i32 1, i32 5)
%261 = load float**, float*** %15
%262 = call i32 @free_matrix(float** %261, i32 1, i32 5, i32 1, i32 5)
%263 = load float*, float** %12
%264 = call i32 @free_vector(float* %263, i32 1, i32 51)
%265 = load float*, float** %11
%266 = call i32 @free_vector(float* %265, i32 1, i32 51)
%267 = load float*, float** %10
%268 = call i32 @free_vector(float* %267, i32 1, i32 51)
%269 = load float*, float** %9
%270 = call i32 @free_vector(float* %269, i32 1, i32 51)
%271 = load i64*, i64** %8
%272 = call i32 @free_lvector(i64* %271, i32 1, i32 51)
%273 = load i64*, i64** %7
%274 = call i32 @free_lvector(i64* %273, i32 1, i32 51)
%275 = load i64*, i64** %6
%276 = call i32 @free_lvector(i64* %275, i32 1, i32 51)
%277 = load i64*, i64** %5
%278 = call i32 @free_lvector(i64* %277, 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 = [18 x i8] c"Reference matrix:\00"
@str.4 = [47 x i8] c"sprspm matrix (should show only tridiagonals):\00"
define i32 @main() {
%1 = tail call i64* @lvector(i32 1, i32 51)
%2 = tail call i64* @lvector(i32 1, i32 51)
%3 = tail call i64* @lvector(i32 1, i32 51)
%4 = tail call i64* @lvector(i32 1, i32 51)
%5 = tail call float* @vector(i32 1, i32 51)
%6 = tail call float* @vector(i32 1, i32 51)
%7 = tail call float* @vector(i32 1, i32 51)
%8 = tail call float* @vector(i32 1, i32 51)
%9 = tail call float** @matrix(i32 1, i32 5, i32 1, i32 5)
%10 = tail call float** @matrix(i32 1, i32 5, i32 1, i32 5)
%11 = tail call float** @convert_matrix(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)
%12 = tail call float** @convert_matrix(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)
%13 = tail call i32 @sprsin(float** %11, i32 5, double 5.000000e-01, i32 51, float* %5, i64* %1)
%14 = tail call i32 @sprsin(float** %12, i32 5, double 5.000000e-01, i32 51, float* %6, i64* %2)
%15 = tail call i32 @sprstp(float* %6, i64* %2, float* %7, i64* %3)
%16 = getelementptr inbounds i64, i64* %1, i64 1
%17 = load i64, i64* %16
%18 = add i64 %17, -1
%19 = getelementptr inbounds i64, i64* %1, i64 %18
%20 = load i64, i64* %19
%21 = icmp eq i64 %20, 1
br i1 %21, label %42, label %22
22: ; preds = %0
%23 = getelementptr inbounds i64, i64* %4, i64 1
store i64 %17, i64* %23
%24 = load i64, i64* %16
%25 = add i64 %24, -1
%26 = getelementptr inbounds i64, i64* %1, i64 %25
%27 = load i64, i64* %26
%28 = add i64 %27, -3
%29 = icmp ult i64 %28, -2
br i1 %29, label %30, label %42
30: ; preds = %22, %30
%31 = phi i64 [ %35, %30 ], [ 2, %22 ]
%32 = getelementptr inbounds i64, i64* %1, i64 %31
%33 = load i64, i64* %32
%34 = getelementptr inbounds i64, i64* %4, i64 %31
store i64 %33, i64* %34
%35 = add nuw i64 %31, 1
%36 = load i64, i64* %16
%37 = add i64 %36, -1
%38 = getelementptr inbounds i64, i64* %1, i64 %37
%39 = load i64, i64* %38
%40 = add i64 %39, -1
%41 = icmp ult i64 %31, %40
br i1 %41, label %30, label %42
42: ; preds = %30, %22, %0
%43 = tail call i32 @sprspm(float* %5, i64* %1, float* %7, i64* %3, float* %8, i64* %4)
%44 = getelementptr inbounds float*, float** %12, i64 1
%45 = load float*, float** %44
%46 = getelementptr inbounds float*, float** %12, i64 2
%47 = load float*, float** %46
%48 = getelementptr inbounds float*, float** %12, i64 3
%49 = load float*, float** %48
%50 = getelementptr inbounds float*, float** %12, i64 4
%51 = load float*, float** %50
%52 = getelementptr inbounds float*, float** %12, i64 5
%53 = load float*, float** %52
%54 = getelementptr inbounds float, float* %45, i64 1
%55 = getelementptr inbounds float, float* %47, i64 1
%56 = getelementptr inbounds float, float* %49, i64 1
%57 = getelementptr inbounds float, float* %51, i64 1
%58 = getelementptr inbounds float, float* %53, i64 1
%59 = getelementptr inbounds float, float* %45, i64 2
%60 = getelementptr inbounds float, float* %47, i64 2
%61 = getelementptr inbounds float, float* %49, i64 2
%62 = getelementptr inbounds float, float* %51, i64 2
%63 = getelementptr inbounds float, float* %53, i64 2
%64 = getelementptr inbounds float, float* %45, i64 3
%65 = getelementptr inbounds float, float* %47, i64 3
%66 = getelementptr inbounds float, float* %49, i64 3
%67 = getelementptr inbounds float, float* %51, i64 3
%68 = getelementptr inbounds float, float* %53, i64 3
%69 = getelementptr inbounds float, float* %45, i64 4
%70 = getelementptr inbounds float, float* %47, i64 4
%71 = getelementptr inbounds float, float* %49, i64 4
%72 = getelementptr inbounds float, float* %51, i64 4
%73 = getelementptr inbounds float, float* %53, i64 4
%74 = getelementptr inbounds float, float* %45, i64 5
%75 = getelementptr inbounds float, float* %47, i64 5
%76 = getelementptr inbounds float, float* %49, i64 5
%77 = getelementptr inbounds float, float* %51, i64 5
%78 = getelementptr inbounds float, float* %53, i64 5
br label %79
79: ; preds = %42, %79
%80 = phi i64 [ 1, %42 ], [ %170, %79 ]
%81 = getelementptr inbounds float*, float** %10, i64 %80
%82 = load float*, float** %81
%83 = getelementptr inbounds float*, float** %11, i64 %80
%84 = load float*, float** %83
%85 = getelementptr inbounds float, float* %84, i64 1
%86 = getelementptr inbounds float, float* %84, i64 2
%87 = getelementptr inbounds float, float* %84, i64 3
%88 = getelementptr inbounds float, float* %84, i64 4
%89 = getelementptr inbounds float, float* %84, i64 5
%90 = getelementptr inbounds float, float* %82, i64 1
store float 0.000000e+00, float* %90
%91 = load float, float* %85
%92 = load float, float* %54
%93 = tail call float @llvm.fmuladd.f32(float %91, float %92, float 0.000000e+00)
store float %93, float* %90
%94 = load float, float* %86
%95 = load float, float* %55
%96 = tail call float @llvm.fmuladd.f32(float %94, float %95, float %93)
store float %96, float* %90
%97 = load float, float* %87
%98 = load float, float* %56
%99 = tail call float @llvm.fmuladd.f32(float %97, float %98, float %96)
store float %99, float* %90
%100 = load float, float* %88
%101 = load float, float* %57
%102 = tail call float @llvm.fmuladd.f32(float %100, float %101, float %99)
store float %102, float* %90
%103 = load float, float* %89
%104 = load float, float* %58
%105 = tail call float @llvm.fmuladd.f32(float %103, float %104, float %102)
store float %105, float* %90
%106 = getelementptr inbounds float, float* %82, i64 2
store float 0.000000e+00, float* %106
%107 = load float, float* %85
%108 = load float, float* %59
%109 = tail call float @llvm.fmuladd.f32(float %107, float %108, float 0.000000e+00)
store float %109, float* %106
%110 = load float, float* %86
%111 = load float, float* %60
%112 = tail call float @llvm.fmuladd.f32(float %110, float %111, float %109)
store float %112, float* %106
%113 = load float, float* %87
%114 = load float, float* %61
%115 = tail call float @llvm.fmuladd.f32(float %113, float %114, float %112)
store float %115, float* %106
%116 = load float, float* %88
%117 = load float, float* %62
%118 = tail call float @llvm.fmuladd.f32(float %116, float %117, float %115)
store float %118, float* %106
%119 = load float, float* %89
%120 = load float, float* %63
%121 = tail call float @llvm.fmuladd.f32(float %119, float %120, float %118)
store float %121, float* %106
%122 = getelementptr inbounds float, float* %82, i64 3
store float 0.000000e+00, float* %122
%123 = load float, float* %85
%124 = load float, float* %64
%125 = tail call float @llvm.fmuladd.f32(float %123, float %124, float 0.000000e+00)
store float %125, float* %122
%126 = load float, float* %86
%127 = load float, float* %65
%128 = tail call float @llvm.fmuladd.f32(float %126, float %127, float %125)
store float %128, float* %122
%129 = load float, float* %87
%130 = load float, float* %66
%131 = tail call float @llvm.fmuladd.f32(float %129, float %130, float %128)
store float %131, float* %122
%132 = load float, float* %88
%133 = load float, float* %67
%134 = tail call float @llvm.fmuladd.f32(float %132, float %133, float %131)
store float %134, float* %122
%135 = load float, float* %89
%136 = load float, float* %68
%137 = tail call float @llvm.fmuladd.f32(float %135, float %136, float %134)
store float %137, float* %122
%138 = getelementptr inbounds float, float* %82, i64 4
store float 0.000000e+00, float* %138
%139 = load float, float* %85
%140 = load float, float* %69
%141 = tail call float @llvm.fmuladd.f32(float %139, float %140, float 0.000000e+00)
store float %141, float* %138
%142 = load float, float* %86
%143 = load float, float* %70
%144 = tail call float @llvm.fmuladd.f32(float %142, float %143, float %141)
store float %144, float* %138
%145 = load float, float* %87
%146 = load float, float* %71
%147 = tail call float @llvm.fmuladd.f32(float %145, float %146, float %144)
store float %147, float* %138
%148 = load float, float* %88
%149 = load float, float* %72
%150 = tail call float @llvm.fmuladd.f32(float %148, float %149, float %147)
store float %150, float* %138
%151 = load float, float* %89
%152 = load float, float* %73
%153 = tail call float @llvm.fmuladd.f32(float %151, float %152, float %150)
store float %153, float* %138
%154 = getelementptr inbounds float, float* %82, i64 5
store float 0.000000e+00, float* %154
%155 = load float, float* %85
%156 = load float, float* %74
%157 = tail call float @llvm.fmuladd.f32(float %155, float %156, float 0.000000e+00)
store float %157, float* %154
%158 = load float, float* %86
%159 = load float, float* %75
%160 = tail call float @llvm.fmuladd.f32(float %158, float %159, float %157)
store float %160, float* %154
%161 = load float, float* %87
%162 = load float, float* %76
%163 = tail call float @llvm.fmuladd.f32(float %161, float %162, float %160)
store float %163, float* %154
%164 = load float, float* %88
%165 = load float, float* %77
%166 = tail call float @llvm.fmuladd.f32(float %164, float %165, float %163)
store float %166, float* %154
%167 = load float, float* %89
%168 = load float, float* %78
%169 = tail call float @llvm.fmuladd.f32(float %167, float %168, float %166)
store float %169, float* %154
%170 = add nuw nsw i64 %80, 1
%171 = icmp eq i64 %170, 6
br i1 %171, label %172, label %79
172: ; preds = %79
%173 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([18 x i8], [18 x i8]* @str, i64 0, i64 0))
%174 = getelementptr inbounds float*, float** %10, i64 1
%175 = load float*, float** %174
%176 = getelementptr inbounds float, float* %175, i64 1
%177 = load float, float* %176
%178 = fpext float %177 to double
%179 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %178)
%180 = load float*, float** %174
%181 = getelementptr inbounds float, float* %180, i64 2
%182 = load float, float* %181
%183 = fpext float %182 to double
%184 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %183)
%185 = load float*, float** %174
%186 = getelementptr inbounds float, float* %185, i64 3
%187 = load float, float* %186
%188 = fpext float %187 to double
%189 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %188)
%190 = load float*, float** %174
%191 = getelementptr inbounds float, float* %190, i64 4
%192 = load float, float* %191
%193 = fpext float %192 to double
%194 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %193)
%195 = load float*, float** %174
%196 = getelementptr inbounds float, float* %195, i64 5
%197 = load float, float* %196
%198 = fpext float %197 to double
%199 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %198)
%200 = tail call i32 @putchar(i32 10)
%201 = getelementptr inbounds float*, float** %10, i64 2
%202 = load float*, float** %201
%203 = getelementptr inbounds float, float* %202, i64 1
%204 = load float, float* %203
%205 = fpext float %204 to double
%206 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %205)
%207 = load float*, float** %201
%208 = getelementptr inbounds float, float* %207, i64 2
%209 = load float, float* %208
%210 = fpext float %209 to double
%211 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %210)
%212 = load float*, float** %201
%213 = getelementptr inbounds float, float* %212, i64 3
%214 = load float, float* %213
%215 = fpext float %214 to double
%216 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %215)
%217 = load float*, float** %201
%218 = getelementptr inbounds float, float* %217, i64 4
%219 = load float, float* %218
%220 = fpext float %219 to double
%221 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %220)
%222 = load float*, float** %201
%223 = getelementptr inbounds float, float* %222, i64 5
%224 = load float, float* %223
%225 = fpext float %224 to double
%226 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %225)
%227 = tail call i32 @putchar(i32 10)
%228 = getelementptr inbounds float*, float** %10, i64 3
%229 = load float*, float** %228
%230 = getelementptr inbounds float, float* %229, i64 1
%231 = load float, float* %230
%232 = fpext float %231 to double
%233 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %232)
%234 = load float*, float** %228
%235 = getelementptr inbounds float, float* %234, i64 2
%236 = load float, float* %235
%237 = fpext float %236 to double
%238 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %237)
%239 = load float*, float** %228
%240 = getelementptr inbounds float, float* %239, i64 3
%241 = load float, float* %240
%242 = fpext float %241 to double
%243 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %242)
%244 = load float*, float** %228
%245 = getelementptr inbounds float, float* %244, i64 4
%246 = load float, float* %245
%247 = fpext float %246 to double
%248 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %247)
%249 = load float*, float** %228
%250 = getelementptr inbounds float, float* %249, i64 5
%251 = load float, float* %250
%252 = fpext float %251 to double
%253 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %252)
%254 = tail call i32 @putchar(i32 10)
%255 = getelementptr inbounds float*, float** %10, i64 4
%256 = load float*, float** %255
%257 = getelementptr inbounds float, float* %256, i64 1
%258 = load float, float* %257
%259 = fpext float %258 to double
%260 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %259)
%261 = load float*, float** %255
%262 = getelementptr inbounds float, float* %261, i64 2
%263 = load float, float* %262
%264 = fpext float %263 to double
%265 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %264)
%266 = load float*, float** %255
%267 = getelementptr inbounds float, float* %266, i64 3
%268 = load float, float* %267
%269 = fpext float %268 to double
%270 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %269)
%271 = load float*, float** %255
%272 = getelementptr inbounds float, float* %271, i64 4
%273 = load float, float* %272
%274 = fpext float %273 to double
%275 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %274)
%276 = load float*, float** %255
%277 = getelementptr inbounds float, float* %276, i64 5
%278 = load float, float* %277
%279 = fpext float %278 to double
%280 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %279)
%281 = tail call i32 @putchar(i32 10)
%282 = getelementptr inbounds float*, float** %10, i64 5
%283 = load float*, float** %282
%284 = getelementptr inbounds float, float* %283, i64 1
%285 = load float, float* %284
%286 = fpext float %285 to double
%287 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %286)
%288 = load float*, float** %282
%289 = getelementptr inbounds float, float* %288, i64 2
%290 = load float, float* %289
%291 = fpext float %290 to double
%292 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %291)
%293 = load float*, float** %282
%294 = getelementptr inbounds float, float* %293, i64 3
%295 = load float, float* %294
%296 = fpext float %295 to double
%297 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %296)
%298 = load float*, float** %282
%299 = getelementptr inbounds float, float* %298, i64 4
%300 = load float, float* %299
%301 = fpext float %300 to double
%302 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %301)
%303 = load float*, float** %282
%304 = getelementptr inbounds float, float* %303, i64 5
%305 = load float, float* %304
%306 = fpext float %305 to double
%307 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %306)
%308 = tail call i32 @putchar(i32 10)
%309 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([47 x i8], [47 x i8]* @str.4, i64 0, i64 0))
%310 = getelementptr inbounds float*, float** %9, i64 1
%311 = load float*, float** %310
%312 = getelementptr float, float* %311, i64 1
%313 = bitcast float* %312 to i8*
%314 = getelementptr inbounds float*, float** %9, i64 2
%315 = load float*, float** %314
%316 = getelementptr float, float* %315, i64 1
%317 = bitcast float* %316 to i8*
%318 = getelementptr inbounds float*, float** %9, i64 3
%319 = load float*, float** %318
%320 = getelementptr float, float* %319, i64 1
%321 = bitcast float* %320 to i8*
%322 = getelementptr inbounds float*, float** %9, i64 4
%323 = load float*, float** %322
%324 = getelementptr float, float* %323, i64 1
%325 = bitcast float* %324 to i8*
%326 = getelementptr inbounds float*, float** %9, i64 5
%327 = load float*, float** %326
%328 = getelementptr float, float* %327, i64 1
%329 = bitcast float* %328 to i8*
%330 = getelementptr inbounds float, float* %8, i64 1
%331 = load float, float* %330
store float %331, float* %312
%332 = getelementptr inbounds i64, i64* %4, i64 1
%333 = load i64, i64* %332
%334 = getelementptr inbounds i64, i64* %4, i64 2
%335 = load i64, i64* %334
%336 = add i64 %335, -1
%337 = icmp ugt i64 %333, %336
br i1 %337, label %338, label %547
338: ; preds = %547, %172
%339 = getelementptr inbounds float, float* %8, i64 2
%340 = load float, float* %339
%341 = getelementptr inbounds float, float* %315, i64 2
store float %340, float* %341
%342 = getelementptr inbounds i64, i64* %4, i64 3
%343 = load i64, i64* %342
%344 = add i64 %343, -1
%345 = icmp ugt i64 %335, %344
br i1 %345, label %355, label %346
346: ; preds = %338, %346
%347 = phi i64 [ %353, %346 ], [ %335, %338 ]
%348 = getelementptr inbounds float, float* %8, i64 %347
%349 = load float, float* %348
%350 = getelementptr inbounds i64, i64* %4, i64 %347
%351 = load i64, i64* %350
%352 = getelementptr inbounds float, float* %315, i64 %351
store float %349, float* %352
%353 = add i64 %347, 1
%354 = icmp ugt i64 %353, %344
br i1 %354, label %355, label %346
355: ; preds = %346, %338
%356 = getelementptr inbounds float, float* %8, i64 3
%357 = load float, float* %356
%358 = getelementptr inbounds float, float* %319, i64 3
store float %357, float* %358
%359 = getelementptr inbounds i64, i64* %4, i64 4
%360 = load i64, i64* %359
%361 = add i64 %360, -1
%362 = icmp ugt i64 %343, %361
br i1 %362, label %372, label %363
363: ; preds = %355, %363
%364 = phi i64 [ %370, %363 ], [ %343, %355 ]
%365 = getelementptr inbounds float, float* %8, i64 %364
%366 = load float, float* %365
%367 = getelementptr inbounds i64, i64* %4, i64 %364
%368 = load i64, i64* %367
%369 = getelementptr inbounds float, float* %319, i64 %368
store float %366, float* %369
%370 = add i64 %364, 1
%371 = icmp ugt i64 %370, %361
br i1 %371, label %372, label %363
372: ; preds = %363, %355
%373 = getelementptr inbounds float, float* %8, i64 4
%374 = load float, float* %373
%375 = getelementptr inbounds float, float* %323, i64 4
store float %374, float* %375
%376 = getelementptr inbounds i64, i64* %4, i64 5
%377 = load i64, i64* %376
%378 = add i64 %377, -1
%379 = icmp ugt i64 %360, %378
br i1 %379, label %389, label %380
380: ; preds = %372, %380
%381 = phi i64 [ %387, %380 ], [ %360, %372 ]
%382 = getelementptr inbounds float, float* %8, i64 %381
%383 = load float, float* %382
%384 = getelementptr inbounds i64, i64* %4, i64 %381
%385 = load i64, i64* %384
%386 = getelementptr inbounds float, float* %323, i64 %385
store float %383, float* %386
%387 = add i64 %381, 1
%388 = icmp ugt i64 %387, %378
br i1 %388, label %389, label %380
389: ; preds = %380, %372
%390 = getelementptr inbounds float, float* %8, i64 5
%391 = load float, float* %390
%392 = getelementptr inbounds float, float* %327, i64 5
store float %391, float* %392
%393 = getelementptr inbounds i64, i64* %4, i64 6
%394 = load i64, i64* %393
%395 = add i64 %394, -1
%396 = icmp ugt i64 %377, %395
br i1 %396, label %406, label %397
397: ; preds = %389, %397
%398 = phi i64 [ %404, %397 ], [ %377, %389 ]
%399 = getelementptr inbounds float, float* %8, i64 %398
%400 = load float, float* %399
%401 = getelementptr inbounds i64, i64* %4, i64 %398
%402 = load i64, i64* %401
%403 = getelementptr inbounds float, float* %327, i64 %402
store float %400, float* %403
%404 = add i64 %398, 1
%405 = icmp ugt i64 %404, %395
br i1 %405, label %406, label %397
406: ; preds = %397, %389
%407 = load float, float* %312
%408 = fpext float %407 to double
%409 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %408)
%410 = load float*, float** %310
%411 = getelementptr inbounds float, float* %410, i64 2
%412 = load float, float* %411
%413 = fpext float %412 to double
%414 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %413)
%415 = load float*, float** %310
%416 = getelementptr inbounds float, float* %415, i64 3
%417 = load float, float* %416
%418 = fpext float %417 to double
%419 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %418)
%420 = load float*, float** %310
%421 = getelementptr inbounds float, float* %420, i64 4
%422 = load float, float* %421
%423 = fpext float %422 to double
%424 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %423)
%425 = load float*, float** %310
%426 = getelementptr inbounds float, float* %425, i64 5
%427 = load float, float* %426
%428 = fpext float %427 to double
%429 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %428)
%430 = tail call i32 @putchar(i32 10)
%431 = load float*, float** %314
%432 = getelementptr inbounds float, float* %431, i64 1
%433 = load float, float* %432
%434 = fpext float %433 to double
%435 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %434)
%436 = load float*, float** %314
%437 = getelementptr inbounds float, float* %436, i64 2
%438 = load float, float* %437
%439 = fpext float %438 to double
%440 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %439)
%441 = load float*, float** %314
%442 = getelementptr inbounds float, float* %441, i64 3
%443 = load float, float* %442
%444 = fpext float %443 to double
%445 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %444)
%446 = load float*, float** %314
%447 = getelementptr inbounds float, float* %446, i64 4
%448 = load float, float* %447
%449 = fpext float %448 to double
%450 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %449)
%451 = load float*, float** %314
%452 = getelementptr inbounds float, float* %451, i64 5
%453 = load float, float* %452
%454 = fpext float %453 to double
%455 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %454)
%456 = tail call i32 @putchar(i32 10)
%457 = load float*, float** %318
%458 = getelementptr inbounds float, float* %457, i64 1
%459 = load float, float* %458
%460 = fpext float %459 to double
%461 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %460)
%462 = load float*, float** %318
%463 = getelementptr inbounds float, float* %462, i64 2
%464 = load float, float* %463
%465 = fpext float %464 to double
%466 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %465)
%467 = load float*, float** %318
%468 = getelementptr inbounds float, float* %467, i64 3
%469 = load float, float* %468
%470 = fpext float %469 to double
%471 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %470)
%472 = load float*, float** %318
%473 = getelementptr inbounds float, float* %472, i64 4
%474 = load float, float* %473
%475 = fpext float %474 to double
%476 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %475)
%477 = load float*, float** %318
%478 = getelementptr inbounds float, float* %477, i64 5
%479 = load float, float* %478
%480 = fpext float %479 to double
%481 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %480)
%482 = tail call i32 @putchar(i32 10)
%483 = load float*, float** %322
%484 = getelementptr inbounds float, float* %483, i64 1
%485 = load float, float* %484
%486 = fpext float %485 to double
%487 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %486)
%488 = load float*, float** %322
%489 = getelementptr inbounds float, float* %488, i64 2
%490 = load float, float* %489
%491 = fpext float %490 to double
%492 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %491)
%493 = load float*, float** %322
%494 = getelementptr inbounds float, float* %493, i64 3
%495 = load float, float* %494
%496 = fpext float %495 to double
%497 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %496)
%498 = load float*, float** %322
%499 = getelementptr inbounds float, float* %498, i64 4
%500 = load float, float* %499
%501 = fpext float %500 to double
%502 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %501)
%503 = load float*, float** %322
%504 = getelementptr inbounds float, float* %503, i64 5
%505 = load float, float* %504
%506 = fpext float %505 to double
%507 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %506)
%508 = tail call i32 @putchar(i32 10)
%509 = load float*, float** %326
%510 = getelementptr inbounds float, float* %509, i64 1
%511 = load float, float* %510
%512 = fpext float %511 to double
%513 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %512)
%514 = load float*, float** %326
%515 = getelementptr inbounds float, float* %514, i64 2
%516 = load float, float* %515
%517 = fpext float %516 to double
%518 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %517)
%519 = load float*, float** %326
%520 = getelementptr inbounds float, float* %519, i64 3
%521 = load float, float* %520
%522 = fpext float %521 to double
%523 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %522)
%524 = load float*, float** %326
%525 = getelementptr inbounds float, float* %524, i64 4
%526 = load float, float* %525
%527 = fpext float %526 to double
%528 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %527)
%529 = load float*, float** %326
%530 = getelementptr inbounds float, float* %529, i64 5
%531 = load float, float* %530
%532 = fpext float %531 to double
%533 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %532)
%534 = tail call i32 @putchar(i32 10)
%535 = tail call i32 @free_convert_matrix(float** %12, i32 1, i32 5, i32 1, i32 5)
%536 = tail call i32 @free_convert_matrix(float** %11, i32 1, i32 5, i32 1, i32 5)
%537 = tail call i32 @free_matrix(float** %10, i32 1, i32 5, i32 1, i32 5)
%538 = tail call i32 @free_matrix(float** %9, i32 1, i32 5, i32 1, i32 5)
%539 = tail call i32 @free_vector(float* %8, i32 1, i32 51)
%540 = tail call i32 @free_vector(float* %7, i32 1, i32 51)
%541 = tail call i32 @free_vector(float* %6, i32 1, i32 51)
%542 = tail call i32 @free_vector(float* %5, i32 1, i32 51)
%543 = tail call i32 @free_lvector(i64* %4, i32 1, i32 51)
%544 = tail call i32 @free_lvector(i64* %3, i32 1, i32 51)
%545 = tail call i32 @free_lvector(i64* %2, i32 1, i32 51)
%546 = tail call i32 @free_lvector(i64* %1, i32 1, i32 51)
ret i32 0
547: ; preds = %172, %547
%548 = phi i64 [ %554, %547 ], [ %333, %172 ]
%549 = getelementptr inbounds float, float* %8, i64 %548
%550 = load float, float* %549
%551 = getelementptr inbounds i64, i64* %4, i64 %548
%552 = load i64, i64* %551
%553 = getelementptr inbounds float, float* %311, i64 %552
store float %550, float* %553
%554 = add i64 %548, 1
%555 = icmp ugt i64 %554, %336
br i1 %555, label %338, label %547
}