#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ balanc(float **, int);
float **convert_matrix(float *, int, int, int, int);
int /*<<< orphan*/ elmhes(float **, int);
int /*<<< orphan*/ free_convert_matrix(float **, int, int, int, int);
int /*<<< orphan*/ printf(char *, ...);
int main(void) {
  int i, j;
  static float b[5][5] = {1.0, 2.0, 300.0, 4.0, 5.0,   2.0, 3.0, 400.0, 5.0,
                          6.0, 3.0, 4.0,   5.0, 6.0,   7.0, 4.0, 5.0,   600.0,
                          7.0, 8.0, 5.0,   6.0, 700.0, 8.0, 9.0};
  float **a;
  a = convert_matrix(&b[0][0], 1, 5, 1, 5);
  printf("***** original matrix *****\n");
  for (i = 1; i <= 5; i++) {
    for (j = 1; j <= 5; j++)
      printf("%12.2f", a[i][j]);
    printf("\n");
  }
  printf("***** balance matrix *****\n");
  balanc(a, 5);
  for (i = 1; i <= 5; i++) {
    for (j = 1; j <= 5; j++)
      printf("%12.2f", a[i][j]);
    printf("\n");
  }
  printf("***** reduce to hessenberg form *****\n");
  elmhes(a, 5);
  for (j = 1; j <= 5 - 2; j++)
    for (i = j + 2; i <= 5; i++)
      a[i][j] = 0.0;
  for (i = 1; i <= 5; i++) {
    for (j = 1; j <= 5; j++)
      printf("%12.2e", a[i][j]);
    printf("\n");
  }
  free_convert_matrix(a, 1, 5, 1, 5);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
movl   $0x0,-0x4(%rbp)
lea    0x2eea(%rip),%rdi
mov    $0x1,%ecx
mov    $0x5,%r8d
mov    %ecx,%esi
mov    %r8d,%edx
call   1060 <convert_matrix@plt>
mov    %rax,-0x18(%rbp)
lea    0xe7a(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x1,-0x8(%rbp)
cmpl   $0x5,-0x8(%rbp)
jg     1200 <main+0xb0>
movl   $0x1,-0xc(%rbp)
cmpl   $0x5,-0xc(%rbp)
jg     11e4 <main+0x94>
mov    -0x18(%rbp),%rax
movslq -0x8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xe4e(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    11a5 <main+0x55>
lea    0xe7a(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1194 <main+0x44>
lea    0xe1d(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x18(%rbp),%rdi
mov    $0x5,%esi
call   1070 <balanc@plt>
movl   $0x1,-0x8(%rbp)
cmpl   $0x5,-0x8(%rbp)
jg     128f <main+0x13f>
movl   $0x1,-0xc(%rbp)
cmpl   $0x5,-0xc(%rbp)
jg     1273 <main+0x123>
mov    -0x18(%rbp),%rax
movslq -0x8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xdbf(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1234 <main+0xe4>
lea    0xdeb(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1223 <main+0xd3>
lea    0xdaa(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x18(%rbp),%rdi
mov    $0x5,%esi
call   1050 <elmhes@plt>
movl   $0x1,-0xc(%rbp)
cmpl   $0x3,-0xc(%rbp)
jg     1308 <main+0x1b8>
mov    -0xc(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x8(%rbp)
cmpl   $0x5,-0x8(%rbp)
jg     12f5 <main+0x1a5>
mov    -0x18(%rbp),%rax
movslq -0x8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xc(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    12c5 <main+0x175>
jmp    12fa <main+0x1aa>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    12b2 <main+0x162>
movl   $0x1,-0x8(%rbp)
cmpl   $0x5,-0x8(%rbp)
jg     137b <main+0x22b>
movl   $0x1,-0xc(%rbp)
cmpl   $0x5,-0xc(%rbp)
jg     135f <main+0x20f>
mov    -0x18(%rbp),%rax
movslq -0x8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xd1d(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1320 <main+0x1d0>
lea    0xcff(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    130f <main+0x1bf>
mov    -0x18(%rbp),%rdi
mov    $0x1,%ecx
mov    $0x5,%r8d
mov    %ecx,%esi
mov    %r8d,%edx
call   1030 <free_convert_matrix@plt>
xor    %eax,%eax
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %r14
push   %rbx
push   %rax
lea    0x2ee5(%rip),%rdi
mov    $0x1,%esi
mov    $0x5,%edx
mov    $0x1,%ecx
mov    $0x5,%r8d
call   1080 <convert_matrix@plt>
mov    %rax,%rbx
lea    0xe6f(%rip),%rdi
call   1050 <puts@plt>
mov    0x8(%rbx),%rax
movss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xe48(%rip),%r14
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    0x8(%rbx),%rax
movss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    0x8(%rbx),%rax
movss  0xc(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    0x8(%rbx),%rax
movss  0x10(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    0x8(%rbx),%rax
movss  0x14(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    0x10(%rbx),%rax
movss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    0x10(%rbx),%rax
movss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    0x10(%rbx),%rax
movss  0xc(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    0x10(%rbx),%rax
movss  0x10(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    0x10(%rbx),%rax
movss  0x14(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    0x18(%rbx),%rax
movss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    0x18(%rbx),%rax
movss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    0x18(%rbx),%rax
movss  0xc(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    0x18(%rbx),%rax
movss  0x10(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    0x18(%rbx),%rax
movss  0x14(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    0x20(%rbx),%rax
movss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    0x20(%rbx),%rax
movss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    0x20(%rbx),%rax
movss  0xc(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    0x20(%rbx),%rax
movss  0x10(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    0x20(%rbx),%rax
movss  0x14(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    0x28(%rbx),%rax
movss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    0x28(%rbx),%rax
movss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    0x28(%rbx),%rax
movss  0xc(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    0x28(%rbx),%rax
movss  0x10(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    0x28(%rbx),%rax
movss  0x14(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0xc07(%rip),%rdi
call   1050 <puts@plt>
mov    %rbx,%rdi
mov    $0x5,%esi
call   1090 <balanc@plt>
mov    0x8(%rbx),%rax
movss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    0x8(%rbx),%rax
movss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    0x8(%rbx),%rax
movss  0xc(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    0x8(%rbx),%rax
movss  0x10(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    0x8(%rbx),%rax
movss  0x14(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    0x10(%rbx),%rax
movss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    0x10(%rbx),%rax
movss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    0x10(%rbx),%rax
movss  0xc(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    0x10(%rbx),%rax
movss  0x10(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    0x10(%rbx),%rax
movss  0x14(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    0x18(%rbx),%rax
movss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    0x18(%rbx),%rax
movss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    0x18(%rbx),%rax
movss  0xc(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    0x18(%rbx),%rax
movss  0x10(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    0x18(%rbx),%rax
movss  0x14(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    0x20(%rbx),%rax
movss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    0x20(%rbx),%rax
movss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    0x20(%rbx),%rax
movss  0xc(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    0x20(%rbx),%rax
movss  0x10(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    0x20(%rbx),%rax
movss  0x14(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    0x28(%rbx),%rax
movss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    0x28(%rbx),%rax
movss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    0x28(%rbx),%rax
movss  0xc(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    0x28(%rbx),%rax
movss  0x10(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    0x28(%rbx),%rax
movss  0x14(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    0x998(%rip),%rdi
call   1050 <puts@plt>
mov    %rbx,%rdi
mov    $0x5,%esi
call   1070 <elmhes@plt>
mov    0x18(%rbx),%rax
movl   $0x0,0x4(%rax)
mov    0x20(%rbx),%rax
movl   $0x0,0x4(%rax)
mov    0x28(%rbx),%rcx
movl   $0x0,0x4(%rcx)
movl   $0x0,0x8(%rax)
movl   $0x0,0x8(%rcx)
mov    0x28(%rbx),%rax
movl   $0x0,0xc(%rax)
mov    0x8(%rbx),%rax
movss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0x8fa(%rip),%r14
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    0x8(%rbx),%rax
movss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    0x8(%rbx),%rax
movss  0xc(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    0x8(%rbx),%rax
movss  0x10(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    0x8(%rbx),%rax
movss  0x14(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    0x10(%rbx),%rax
movss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    0x10(%rbx),%rax
movss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    0x10(%rbx),%rax
movss  0xc(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    0x10(%rbx),%rax
movss  0x10(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    0x10(%rbx),%rax
movss  0x14(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    0x18(%rbx),%rax
movss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    0x18(%rbx),%rax
movss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    0x18(%rbx),%rax
movss  0xc(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    0x18(%rbx),%rax
movss  0x10(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    0x18(%rbx),%rax
movss  0x14(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    0x20(%rbx),%rax
movss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    0x20(%rbx),%rax
movss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    0x20(%rbx),%rax
movss  0xc(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    0x20(%rbx),%rax
movss  0x10(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    0x20(%rbx),%rax
movss  0x14(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    0x28(%rbx),%rax
movss  0x4(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    0x28(%rbx),%rax
movss  0x8(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    0x28(%rbx),%rax
movss  0xc(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    0x28(%rbx),%rax
movss  0x10(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    0x28(%rbx),%rax
movss  0x14(%rax),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r14,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    %rbx,%rdi
mov    $0x1,%esi
mov    $0x5,%edx
mov    $0x1,%ecx
mov    $0x5,%r8d
call   1040 <free_convert_matrix@plt>
xor    %eax,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r14
ret

LLVM IR (-O0):
@main.b = internal global [5 x [5 x float]] [[5 x float] [float 1.000000e+00, float 2.000000e+00, float 3.000000e+02, float 4.000000e+00, float 5.000000e+00], [5 x float] [float 2.000000e+00, float 3.000000e+00, float 4.000000e+02, float 5.000000e+00, float 6.000000e+00], [5 x float] [float 3.000000e+00, float 4.000000e+00, float 5.000000e+00, float 6.000000e+00, float 7.000000e+00], [5 x float] [float 4.000000e+00, float 5.000000e+00, float 6.000000e+02, float 7.000000e+00, float 8.000000e+00], [5 x float] [float 5.000000e+00, float 6.000000e+00, float 7.000000e+02, float 8.000000e+00, float 9.000000e+00]]
@.str = [29 x i8] c"***** original matrix *****\0A\00"
@.str.1 = [7 x i8] c"%12.2f\00"
@.str.2 = [2 x i8] c"\0A\00"
@.str.3 = [28 x i8] c"***** balance matrix *****\0A\00"
@.str.4 = [39 x i8] c"***** reduce to hessenberg form *****\0A\00"
@.str.5 = [7 x i8] c"%12.2e\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca i32
%4 = alloca float**
store i32 0, i32* %1
%5 = call float** @convert_matrix(float* getelementptr inbounds ([5 x [5 x float]], [5 x [5 x float]]* @main.b, i64 0, i64 0, i64 0), i32 1, i32 5, i32 1, i32 5)
store float** %5, float*** %4
%6 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([29 x i8], [29 x i8]* @.str, i64 0, i64 0))
store i32 1, i32* %2
br label %7
7: ; preds = %31, %0
%8 = load i32, i32* %2
%9 = icmp sle i32 %8, 5
br i1 %9, label %10, label %34
10: ; preds = %7
store i32 1, i32* %3
br label %11
11: ; preds = %26, %10
%12 = load i32, i32* %3
%13 = icmp sle i32 %12, 5
br i1 %13, label %14, label %29
14: ; preds = %11
%15 = load float**, float*** %4
%16 = load i32, i32* %2
%17 = sext i32 %16 to i64
%18 = getelementptr inbounds float*, float** %15, i64 %17
%19 = load float*, float** %18
%20 = load i32, i32* %3
%21 = sext i32 %20 to i64
%22 = getelementptr inbounds float, float* %19, i64 %21
%23 = load float, float* %22
%24 = fpext float %23 to double
%25 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %24)
br label %26
26: ; preds = %14
%27 = load i32, i32* %3
%28 = add nsw i32 %27, 1
store i32 %28, i32* %3
br label %11
29: ; preds = %11
%30 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
br label %31
31: ; preds = %29
%32 = load i32, i32* %2
%33 = add nsw i32 %32, 1
store i32 %33, i32* %2
br label %7
34: ; preds = %7
%35 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([28 x i8], [28 x i8]* @.str.3, i64 0, i64 0))
%36 = load float**, float*** %4
%37 = call i32 @balanc(float** %36, i32 5)
store i32 1, i32* %2
br label %38
38: ; preds = %62, %34
%39 = load i32, i32* %2
%40 = icmp sle i32 %39, 5
br i1 %40, label %41, label %65
41: ; preds = %38
store i32 1, i32* %3
br label %42
42: ; preds = %57, %41
%43 = load i32, i32* %3
%44 = icmp sle i32 %43, 5
br i1 %44, label %45, label %60
45: ; preds = %42
%46 = load float**, float*** %4
%47 = load i32, i32* %2
%48 = sext i32 %47 to i64
%49 = getelementptr inbounds float*, float** %46, i64 %48
%50 = load float*, float** %49
%51 = load i32, i32* %3
%52 = sext i32 %51 to i64
%53 = getelementptr inbounds float, float* %50, i64 %52
%54 = load float, float* %53
%55 = fpext float %54 to double
%56 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %55)
br label %57
57: ; preds = %45
%58 = load i32, i32* %3
%59 = add nsw i32 %58, 1
store i32 %59, i32* %3
br label %42
60: ; preds = %42
%61 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
br label %62
62: ; preds = %60
%63 = load i32, i32* %2
%64 = add nsw i32 %63, 1
store i32 %64, i32* %2
br label %38
65: ; preds = %38
%66 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([39 x i8], [39 x i8]* @.str.4, i64 0, i64 0))
%67 = load float**, float*** %4
%68 = call i32 @elmhes(float** %67, i32 5)
store i32 1, i32* %3
br label %69
69: ; preds = %91, %65
%70 = load i32, i32* %3
%71 = icmp sle i32 %70, 3
br i1 %71, label %72, label %94
72: ; preds = %69
%73 = load i32, i32* %3
%74 = add nsw i32 %73, 2
store i32 %74, i32* %2
br label %75
75: ; preds = %87, %72
%76 = load i32, i32* %2
%77 = icmp sle i32 %76, 5
br i1 %77, label %78, label %90
78: ; preds = %75
%79 = load float**, float*** %4
%80 = load i32, i32* %2
%81 = sext i32 %80 to i64
%82 = getelementptr inbounds float*, float** %79, i64 %81
%83 = load float*, float** %82
%84 = load i32, i32* %3
%85 = sext i32 %84 to i64
%86 = getelementptr inbounds float, float* %83, i64 %85
store float 0.000000e+00, float* %86
br label %87
87: ; preds = %78
%88 = load i32, i32* %2
%89 = add nsw i32 %88, 1
store i32 %89, i32* %2
br label %75
90: ; preds = %75
br label %91
91: ; preds = %90
%92 = load i32, i32* %3
%93 = add nsw i32 %92, 1
store i32 %93, i32* %3
br label %69
94: ; preds = %69
store i32 1, i32* %2
br label %95
95: ; preds = %119, %94
%96 = load i32, i32* %2
%97 = icmp sle i32 %96, 5
br i1 %97, label %98, label %122
98: ; preds = %95
store i32 1, i32* %3
br label %99
99: ; preds = %114, %98
%100 = load i32, i32* %3
%101 = icmp sle i32 %100, 5
br i1 %101, label %102, label %117
102: ; preds = %99
%103 = load float**, float*** %4
%104 = load i32, i32* %2
%105 = sext i32 %104 to i64
%106 = getelementptr inbounds float*, float** %103, i64 %105
%107 = load float*, float** %106
%108 = load i32, i32* %3
%109 = sext i32 %108 to i64
%110 = getelementptr inbounds float, float* %107, i64 %109
%111 = load float, float* %110
%112 = fpext float %111 to double
%113 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([7 x i8], [7 x i8]* @.str.5, i64 0, i64 0), double %112)
br label %114
114: ; preds = %102
%115 = load i32, i32* %3
%116 = add nsw i32 %115, 1
store i32 %116, i32* %3
br label %99
117: ; preds = %99
%118 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.2, i64 0, i64 0))
br label %119
119: ; preds = %117
%120 = load i32, i32* %2
%121 = add nsw i32 %120, 1
store i32 %121, i32* %2
br label %95
122: ; preds = %95
%123 = load float**, float*** %4
%124 = call i32 @free_convert_matrix(float** %123, i32 1, i32 5, i32 1, i32 5)
ret i32 0
}

LLVM IR (-O2):
@main.b = internal global [5 x [5 x float]] [[5 x float] [float 1.000000e+00, float 2.000000e+00, float 3.000000e+02, float 4.000000e+00, float 5.000000e+00], [5 x float] [float 2.000000e+00, float 3.000000e+00, float 4.000000e+02, float 5.000000e+00, float 6.000000e+00], [5 x float] [float 3.000000e+00, float 4.000000e+00, float 5.000000e+00, float 6.000000e+00, float 7.000000e+00], [5 x float] [float 4.000000e+00, float 5.000000e+00, float 6.000000e+02, float 7.000000e+00, float 8.000000e+00], [5 x float] [float 5.000000e+00, float 6.000000e+00, float 7.000000e+02, float 8.000000e+00, float 9.000000e+00]]
@.str.1 = [7 x i8] c"%12.2f\00"
@.str.5 = [7 x i8] c"%12.2e\00"
@str = [28 x i8] c"***** original matrix *****\00"
@str.6 = [27 x i8] c"***** balance matrix *****\00"
@str.7 = [38 x i8] c"***** reduce to hessenberg form *****\00"
define i32 @main() {
%1 = tail call float** @convert_matrix(float* getelementptr inbounds ([5 x [5 x float]], [5 x [5 x float]]* @main.b, i64 0, i64 0, i64 0), i32 1, i32 5, i32 1, i32 5)
%2 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([28 x i8], [28 x i8]* @str, i64 0, i64 0))
%3 = getelementptr inbounds float*, float** %1, i64 1
%4 = load float*, float** %3
%5 = getelementptr inbounds float, float* %4, i64 1
%6 = load float, float* %5
%7 = fpext float %6 to double
%8 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %7)
%9 = load float*, float** %3
%10 = getelementptr inbounds float, float* %9, i64 2
%11 = load float, float* %10
%12 = fpext float %11 to double
%13 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %12)
%14 = load float*, float** %3
%15 = getelementptr inbounds float, float* %14, i64 3
%16 = load float, float* %15
%17 = fpext float %16 to double
%18 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %17)
%19 = load float*, float** %3
%20 = getelementptr inbounds float, float* %19, i64 4
%21 = load float, float* %20
%22 = fpext float %21 to double
%23 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %22)
%24 = load float*, float** %3
%25 = getelementptr inbounds float, float* %24, i64 5
%26 = load float, float* %25
%27 = fpext float %26 to double
%28 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %27)
%29 = tail call i32 @putchar(i32 10)
%30 = getelementptr inbounds float*, float** %1, i64 2
%31 = load float*, float** %30
%32 = getelementptr inbounds float, float* %31, i64 1
%33 = load float, float* %32
%34 = fpext float %33 to double
%35 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %34)
%36 = load float*, float** %30
%37 = getelementptr inbounds float, float* %36, i64 2
%38 = load float, float* %37
%39 = fpext float %38 to double
%40 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %39)
%41 = load float*, float** %30
%42 = getelementptr inbounds float, float* %41, i64 3
%43 = load float, float* %42
%44 = fpext float %43 to double
%45 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %44)
%46 = load float*, float** %30
%47 = getelementptr inbounds float, float* %46, i64 4
%48 = load float, float* %47
%49 = fpext float %48 to double
%50 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %49)
%51 = load float*, float** %30
%52 = getelementptr inbounds float, float* %51, i64 5
%53 = load float, float* %52
%54 = fpext float %53 to double
%55 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %54)
%56 = tail call i32 @putchar(i32 10)
%57 = getelementptr inbounds float*, float** %1, i64 3
%58 = load float*, float** %57
%59 = getelementptr inbounds float, float* %58, i64 1
%60 = load float, float* %59
%61 = fpext float %60 to double
%62 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %61)
%63 = load float*, float** %57
%64 = getelementptr inbounds float, float* %63, i64 2
%65 = load float, float* %64
%66 = fpext float %65 to double
%67 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %66)
%68 = load float*, float** %57
%69 = getelementptr inbounds float, float* %68, i64 3
%70 = load float, float* %69
%71 = fpext float %70 to double
%72 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %71)
%73 = load float*, float** %57
%74 = getelementptr inbounds float, float* %73, i64 4
%75 = load float, float* %74
%76 = fpext float %75 to double
%77 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %76)
%78 = load float*, float** %57
%79 = getelementptr inbounds float, float* %78, i64 5
%80 = load float, float* %79
%81 = fpext float %80 to double
%82 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %81)
%83 = tail call i32 @putchar(i32 10)
%84 = getelementptr inbounds float*, float** %1, i64 4
%85 = load float*, float** %84
%86 = getelementptr inbounds float, float* %85, i64 1
%87 = load float, float* %86
%88 = fpext float %87 to double
%89 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %88)
%90 = load float*, float** %84
%91 = getelementptr inbounds float, float* %90, i64 2
%92 = load float, float* %91
%93 = fpext float %92 to double
%94 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %93)
%95 = load float*, float** %84
%96 = getelementptr inbounds float, float* %95, i64 3
%97 = load float, float* %96
%98 = fpext float %97 to double
%99 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %98)
%100 = load float*, float** %84
%101 = getelementptr inbounds float, float* %100, i64 4
%102 = load float, float* %101
%103 = fpext float %102 to double
%104 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %103)
%105 = load float*, float** %84
%106 = getelementptr inbounds float, float* %105, i64 5
%107 = load float, float* %106
%108 = fpext float %107 to double
%109 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %108)
%110 = tail call i32 @putchar(i32 10)
%111 = getelementptr inbounds float*, float** %1, i64 5
%112 = load float*, float** %111
%113 = getelementptr inbounds float, float* %112, i64 1
%114 = load float, float* %113
%115 = fpext float %114 to double
%116 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %115)
%117 = load float*, float** %111
%118 = getelementptr inbounds float, float* %117, i64 2
%119 = load float, float* %118
%120 = fpext float %119 to double
%121 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %120)
%122 = load float*, float** %111
%123 = getelementptr inbounds float, float* %122, i64 3
%124 = load float, float* %123
%125 = fpext float %124 to double
%126 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %125)
%127 = load float*, float** %111
%128 = getelementptr inbounds float, float* %127, i64 4
%129 = load float, float* %128
%130 = fpext float %129 to double
%131 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %130)
%132 = load float*, float** %111
%133 = getelementptr inbounds float, float* %132, i64 5
%134 = load float, float* %133
%135 = fpext float %134 to double
%136 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %135)
%137 = tail call i32 @putchar(i32 10)
%138 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([27 x i8], [27 x i8]* @str.6, i64 0, i64 0))
%139 = tail call i32 @balanc(float** %1, i32 5)
%140 = load float*, float** %3
%141 = getelementptr inbounds float, float* %140, i64 1
%142 = load float, float* %141
%143 = fpext float %142 to double
%144 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %143)
%145 = load float*, float** %3
%146 = getelementptr inbounds float, float* %145, i64 2
%147 = load float, float* %146
%148 = fpext float %147 to double
%149 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %148)
%150 = load float*, float** %3
%151 = getelementptr inbounds float, float* %150, i64 3
%152 = load float, float* %151
%153 = fpext float %152 to double
%154 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %153)
%155 = load float*, float** %3
%156 = getelementptr inbounds float, float* %155, i64 4
%157 = load float, float* %156
%158 = fpext float %157 to double
%159 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %158)
%160 = load float*, float** %3
%161 = getelementptr inbounds float, float* %160, i64 5
%162 = load float, float* %161
%163 = fpext float %162 to double
%164 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %163)
%165 = tail call i32 @putchar(i32 10)
%166 = load float*, float** %30
%167 = getelementptr inbounds float, float* %166, i64 1
%168 = load float, float* %167
%169 = fpext float %168 to double
%170 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %169)
%171 = load float*, float** %30
%172 = getelementptr inbounds float, float* %171, i64 2
%173 = load float, float* %172
%174 = fpext float %173 to double
%175 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %174)
%176 = load float*, float** %30
%177 = getelementptr inbounds float, float* %176, i64 3
%178 = load float, float* %177
%179 = fpext float %178 to double
%180 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %179)
%181 = load float*, float** %30
%182 = getelementptr inbounds float, float* %181, i64 4
%183 = load float, float* %182
%184 = fpext float %183 to double
%185 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %184)
%186 = load float*, float** %30
%187 = getelementptr inbounds float, float* %186, i64 5
%188 = load float, float* %187
%189 = fpext float %188 to double
%190 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %189)
%191 = tail call i32 @putchar(i32 10)
%192 = load float*, float** %57
%193 = getelementptr inbounds float, float* %192, i64 1
%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** %57
%198 = getelementptr inbounds float, float* %197, i64 2
%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 = load float*, float** %57
%203 = getelementptr inbounds float, float* %202, i64 3
%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** %57
%208 = getelementptr inbounds float, float* %207, i64 4
%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** %57
%213 = getelementptr inbounds float, float* %212, i64 5
%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 = tail call i32 @putchar(i32 10)
%218 = load float*, float** %84
%219 = getelementptr inbounds float, float* %218, i64 1
%220 = load float, float* %219
%221 = fpext float %220 to double
%222 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %221)
%223 = load float*, float** %84
%224 = getelementptr inbounds float, float* %223, i64 2
%225 = load float, float* %224
%226 = fpext float %225 to double
%227 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %226)
%228 = load float*, float** %84
%229 = getelementptr inbounds float, float* %228, i64 3
%230 = load float, float* %229
%231 = fpext float %230 to double
%232 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %231)
%233 = load float*, float** %84
%234 = getelementptr inbounds float, float* %233, i64 4
%235 = load float, float* %234
%236 = fpext float %235 to double
%237 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %236)
%238 = load float*, float** %84
%239 = getelementptr inbounds float, float* %238, i64 5
%240 = load float, float* %239
%241 = fpext float %240 to double
%242 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %241)
%243 = tail call i32 @putchar(i32 10)
%244 = load float*, float** %111
%245 = getelementptr inbounds float, float* %244, i64 1
%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** %111
%250 = getelementptr inbounds float, float* %249, i64 2
%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 = load float*, float** %111
%255 = getelementptr inbounds float, float* %254, i64 3
%256 = load float, float* %255
%257 = fpext float %256 to double
%258 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %257)
%259 = load float*, float** %111
%260 = getelementptr inbounds float, float* %259, i64 4
%261 = load float, float* %260
%262 = fpext float %261 to double
%263 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %262)
%264 = load float*, float** %111
%265 = getelementptr inbounds float, float* %264, i64 5
%266 = load float, float* %265
%267 = fpext float %266 to double
%268 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.1, i64 0, i64 0), double %267)
%269 = tail call i32 @putchar(i32 10)
%270 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([38 x i8], [38 x i8]* @str.7, i64 0, i64 0))
%271 = tail call i32 @elmhes(float** %1, i32 5)
%272 = load float*, float** %57
%273 = getelementptr inbounds float, float* %272, i64 1
store float 0.000000e+00, float* %273
%274 = load float*, float** %84
%275 = getelementptr inbounds float, float* %274, i64 1
store float 0.000000e+00, float* %275
%276 = load float*, float** %111
%277 = getelementptr inbounds float, float* %276, i64 1
store float 0.000000e+00, float* %277
%278 = getelementptr inbounds float, float* %274, i64 2
store float 0.000000e+00, float* %278
%279 = getelementptr inbounds float, float* %276, i64 2
store float 0.000000e+00, float* %279
%280 = load float*, float** %111
%281 = getelementptr inbounds float, float* %280, i64 3
store float 0.000000e+00, float* %281
%282 = load float*, float** %3
%283 = getelementptr inbounds float, float* %282, i64 1
%284 = load float, float* %283
%285 = fpext float %284 to double
%286 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.5, i64 0, i64 0), double %285)
%287 = load float*, float** %3
%288 = getelementptr inbounds float, float* %287, i64 2
%289 = load float, float* %288
%290 = fpext float %289 to double
%291 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.5, i64 0, i64 0), double %290)
%292 = load float*, float** %3
%293 = getelementptr inbounds float, float* %292, i64 3
%294 = load float, float* %293
%295 = fpext float %294 to double
%296 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.5, i64 0, i64 0), double %295)
%297 = load float*, float** %3
%298 = getelementptr inbounds float, float* %297, i64 4
%299 = load float, float* %298
%300 = fpext float %299 to double
%301 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.5, i64 0, i64 0), double %300)
%302 = load float*, float** %3
%303 = getelementptr inbounds float, float* %302, i64 5
%304 = load float, float* %303
%305 = fpext float %304 to double
%306 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.5, i64 0, i64 0), double %305)
%307 = tail call i32 @putchar(i32 10)
%308 = load float*, float** %30
%309 = getelementptr inbounds float, float* %308, i64 1
%310 = load float, float* %309
%311 = fpext float %310 to double
%312 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.5, i64 0, i64 0), double %311)
%313 = load float*, float** %30
%314 = getelementptr inbounds float, float* %313, i64 2
%315 = load float, float* %314
%316 = fpext float %315 to double
%317 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.5, i64 0, i64 0), double %316)
%318 = load float*, float** %30
%319 = getelementptr inbounds float, float* %318, i64 3
%320 = load float, float* %319
%321 = fpext float %320 to double
%322 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.5, i64 0, i64 0), double %321)
%323 = load float*, float** %30
%324 = getelementptr inbounds float, float* %323, i64 4
%325 = load float, float* %324
%326 = fpext float %325 to double
%327 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.5, i64 0, i64 0), double %326)
%328 = load float*, float** %30
%329 = getelementptr inbounds float, float* %328, i64 5
%330 = load float, float* %329
%331 = fpext float %330 to double
%332 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.5, i64 0, i64 0), double %331)
%333 = tail call i32 @putchar(i32 10)
%334 = load float*, float** %57
%335 = getelementptr inbounds float, float* %334, i64 1
%336 = load float, float* %335
%337 = fpext float %336 to double
%338 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.5, i64 0, i64 0), double %337)
%339 = load float*, float** %57
%340 = getelementptr inbounds float, float* %339, i64 2
%341 = load float, float* %340
%342 = fpext float %341 to double
%343 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.5, i64 0, i64 0), double %342)
%344 = load float*, float** %57
%345 = getelementptr inbounds float, float* %344, i64 3
%346 = load float, float* %345
%347 = fpext float %346 to double
%348 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.5, i64 0, i64 0), double %347)
%349 = load float*, float** %57
%350 = getelementptr inbounds float, float* %349, i64 4
%351 = load float, float* %350
%352 = fpext float %351 to double
%353 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.5, i64 0, i64 0), double %352)
%354 = load float*, float** %57
%355 = getelementptr inbounds float, float* %354, i64 5
%356 = load float, float* %355
%357 = fpext float %356 to double
%358 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.5, i64 0, i64 0), double %357)
%359 = tail call i32 @putchar(i32 10)
%360 = load float*, float** %84
%361 = getelementptr inbounds float, float* %360, i64 1
%362 = load float, float* %361
%363 = fpext float %362 to double
%364 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.5, i64 0, i64 0), double %363)
%365 = load float*, float** %84
%366 = getelementptr inbounds float, float* %365, i64 2
%367 = load float, float* %366
%368 = fpext float %367 to double
%369 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.5, i64 0, i64 0), double %368)
%370 = load float*, float** %84
%371 = getelementptr inbounds float, float* %370, i64 3
%372 = load float, float* %371
%373 = fpext float %372 to double
%374 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.5, i64 0, i64 0), double %373)
%375 = load float*, float** %84
%376 = getelementptr inbounds float, float* %375, i64 4
%377 = load float, float* %376
%378 = fpext float %377 to double
%379 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.5, i64 0, i64 0), double %378)
%380 = load float*, float** %84
%381 = getelementptr inbounds float, float* %380, i64 5
%382 = load float, float* %381
%383 = fpext float %382 to double
%384 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.5, i64 0, i64 0), double %383)
%385 = tail call i32 @putchar(i32 10)
%386 = load float*, float** %111
%387 = getelementptr inbounds float, float* %386, i64 1
%388 = load float, float* %387
%389 = fpext float %388 to double
%390 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.5, i64 0, i64 0), double %389)
%391 = load float*, float** %111
%392 = getelementptr inbounds float, float* %391, i64 2
%393 = load float, float* %392
%394 = fpext float %393 to double
%395 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.5, i64 0, i64 0), double %394)
%396 = load float*, float** %111
%397 = getelementptr inbounds float, float* %396, i64 3
%398 = load float, float* %397
%399 = fpext float %398 to double
%400 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.5, i64 0, i64 0), double %399)
%401 = load float*, float** %111
%402 = getelementptr inbounds float, float* %401, i64 4
%403 = load float, float* %402
%404 = fpext float %403 to double
%405 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.5, i64 0, i64 0), double %404)
%406 = load float*, float** %111
%407 = getelementptr inbounds float, float* %406, i64 5
%408 = load float, float* %407
%409 = fpext float %408 to double
%410 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str.5, i64 0, i64 0), double %409)
%411 = tail call i32 @putchar(i32 10)
%412 = tail call i32 @free_convert_matrix(float** %1, i32 1, i32 5, i32 1, i32 5)
ret i32 0
}