#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);
scalar_t__ fabs(float);
int /*<<< orphan*/ free_matrix(float **, int, int, int, int);
int /*<<< orphan*/ free_vector(float *, int, int);
float **matrix(int, int, int, int);
int /*<<< orphan*/ printf(char *, ...);
float *vector(int, int);
int main(void) {
  int i, j;
  float *c, *r, **a;
  c = vector(1, 5);
  r = vector(1, 5);
  a = matrix(1, 5, 1, 5);
  for (i = 1; i <= 5; i++)
    for (j = 1; j <= 5; j++)
      a[i][j] = (((i & 1) && !(j & 1)) ? 100.0 : 1.0);
  for (i = 1; i <= 5; i++) {
    r[i] = c[i] = 0.0;
    for (j = 1; j <= 5; j++) {
      r[i] += fabs(a[i][j]);
      c[i] += fabs(a[j][i]);
    }
  }
  printf("rows:\n");
  for (i = 1; i <= 5; i++)
    printf("%12.2f", r[i]);
  printf("\ncolumns:\n");
  for (i = 1; i <= 5; i++)
    printf("%12.2f", c[i]);
  printf("\n\n***** Balancing matrix *****\n\n");
  balanc(a, 5);
  for (i = 1; i <= 5; i++) {
    r[i] = c[i] = 0.0;
    for (j = 1; j <= 5; j++) {
      r[i] += fabs(a[i][j]);
      c[i] += fabs(a[j][i]);
    }
  }
  printf("rows:\n");
  for (i = 1; i <= 5; i++)
    printf("%12.2f", r[i]);
  printf("\ncolumns:\n");
  for (i = 1; i <= 5; i++)
    printf("%12.2f", c[i]);
  printf("\n");
  free_matrix(a, 1, 5, 1, 5);
  free_vector(r, 1, 5);
  free_vector(c, 1, 5);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
movl   $0x0,-0x4(%rbp)
mov    $0x1,%edi
mov    $0x5,%esi
call   1080 <vector@plt>
mov    %rax,-0x18(%rbp)
mov    $0x1,%edi
mov    $0x5,%esi
call   1080 <vector@plt>
mov    %rax,-0x20(%rbp)
mov    $0x1,%edx
mov    $0x5,%ecx
mov    %edx,%edi
mov    %ecx,%esi
call   1070 <matrix@plt>
mov    %rax,-0x28(%rbp)
movl   $0x1,-0x8(%rbp)
cmpl   $0x5,-0x8(%rbp)
jg     1271 <main+0x101>
movl   $0x1,-0xc(%rbp)
cmpl   $0x5,-0xc(%rbp)
jg     125e <main+0xee>
mov    -0x8(%rbp),%ecx
and    $0x1,%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x29(%rbp)
je     1203 <main+0x93>
mov    -0xc(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
setne  %al
xor    $0xff,%al
mov    %al,-0x29(%rbp)
mov    -0x29(%rbp),%al
movsd  0xdf2(%rip),%xmm0
movsd  0xdf2(%rip),%xmm1
movsd  %xmm1,-0x40(%rbp)
test   $0x1,%al
movsd  %xmm0,-0x38(%rbp)
jne    1232 <main+0xc2>
movsd  -0x40(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
movsd  -0x38(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x28(%rbp),%rax
movslq -0x8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xc(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    11d4 <main+0x64>
jmp    1263 <main+0xf3>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    11c3 <main+0x53>
movl   $0x1,-0x8(%rbp)
cmpl   $0x5,-0x8(%rbp)
jg     1336 <main+0x1c6>
mov    -0x18(%rbp),%rax
movslq -0x8(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
movslq -0x8(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movl   $0x1,-0xc(%rbp)
cmpl   $0x5,-0xc(%rbp)
jg     1323 <main+0x1b3>
mov    -0x28(%rbp),%rax
movslq -0x8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1060 <fabs@plt>
cvtsi2ss %rax,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x8(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x8(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1060 <fabs@plt>
cvtsi2ss %rax,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x8(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    12a9 <main+0x139>
jmp    1328 <main+0x1b8>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1278 <main+0x108>
lea    0xcd3(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x1,-0x8(%rbp)
cmpl   $0x5,-0x8(%rbp)
jg     1382 <main+0x212>
mov    -0x20(%rbp),%rax
movslq -0x8(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xcaa(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    134b <main+0x1db>
lea    0xc95(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x1,-0x8(%rbp)
cmpl   $0x5,-0x8(%rbp)
jg     13ce <main+0x25e>
mov    -0x18(%rbp),%rax
movslq -0x8(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xc5e(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1397 <main+0x227>
lea    0xc54(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x28(%rbp),%rdi
mov    $0x5,%esi
call   1090 <balanc@plt>
movl   $0x1,-0x8(%rbp)
cmpl   $0x5,-0x8(%rbp)
jg     14af <main+0x33f>
mov    -0x18(%rbp),%rax
movslq -0x8(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
movslq -0x8(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movl   $0x1,-0xc(%rbp)
cmpl   $0x5,-0xc(%rbp)
jg     149c <main+0x32c>
mov    -0x28(%rbp),%rax
movslq -0x8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1060 <fabs@plt>
cvtsi2ss %rax,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x8(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x8(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1060 <fabs@plt>
cvtsi2ss %rax,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x8(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1422 <main+0x2b2>
jmp    14a1 <main+0x331>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    13f1 <main+0x281>
lea    0xb5a(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x1,-0x8(%rbp)
cmpl   $0x5,-0x8(%rbp)
jg     14fb <main+0x38b>
mov    -0x20(%rbp),%rax
movslq -0x8(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xb31(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    14c4 <main+0x354>
lea    0xb1c(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x1,-0x8(%rbp)
cmpl   $0x5,-0x8(%rbp)
jg     1547 <main+0x3d7>
mov    -0x18(%rbp),%rax
movslq -0x8(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xae5(%rip),%rdi
mov    $0x1,%al
call   1040 <printf@plt>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1510 <main+0x3a0>
lea    0xafa(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x28(%rbp),%rdi
mov    $0x1,%ecx
mov    $0x5,%r8d
mov    %ecx,%esi
mov    %r8d,%edx
call   1030 <free_matrix@plt>
mov    -0x20(%rbp),%rdi
mov    $0x1,%esi
mov    $0x5,%edx
call   1050 <free_vector@plt>
mov    -0x18(%rbp),%rdi
mov    $0x1,%esi
mov    $0x5,%edx
call   1050 <free_vector@plt>
xor    %eax,%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    $0x1,%edi
mov    $0x5,%esi
call   10a0 <vector@plt>
mov    %rax,%r14
mov    $0x1,%edi
mov    $0x5,%esi
call   10a0 <vector@plt>
mov    %rax,%r13
mov    $0x1,%edi
mov    $0x5,%esi
mov    $0x1,%edx
mov    $0x5,%ecx
call   1090 <matrix@plt>
mov    %rax,%r15
mov    0x8(%rax),%rax
movaps 0xe1c(%rip),%xmm0
movups %xmm0,0x4(%rax)
movl   $0x3f800000,0x14(%rax)
mov    0x10(%r15),%rcx
movaps 0xe16(%rip),%xmm1
movups %xmm1,0x4(%rcx)
movl   $0x3f800000,0x14(%rcx)
mov    0x18(%r15),%rcx
movups %xmm0,0x4(%rcx)
movl   $0x3f800000,0x14(%rcx)
mov    0x20(%r15),%rcx
movups %xmm1,0x4(%rcx)
movl   $0x3f800000,0x14(%rcx)
mov    0x28(%r15),%rcx
movups %xmm0,0x4(%rcx)
movl   $0x3f800000,0x14(%rcx)
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movl   $0x0,0x4(%r14,%rbx,1)
movl   $0x0,0x4(%r13,%rbx,1)
movss  0x4(%rax),%xmm0
call   1080 <fabs@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
addss  0x4(%r13,%rbx,1),%xmm0
movss  %xmm0,0x4(%r13,%rbx,1)
mov    0x8(%r15),%rax
movss  0x4(%rax,%rbx,1),%xmm0
call   1080 <fabs@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
addss  0x4(%r14,%rbx,1),%xmm0
movss  %xmm0,0x4(%r14,%rbx,1)
mov    0x8(%r15,%rbx,2),%rax
movss  0x8(%rax),%xmm0
call   1080 <fabs@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
addss  0x4(%r13,%rbx,1),%xmm0
movss  %xmm0,0x4(%r13,%rbx,1)
mov    0x10(%r15),%rax
movss  0x4(%rax,%rbx,1),%xmm0
call   1080 <fabs@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
addss  0x4(%r14,%rbx,1),%xmm0
movss  %xmm0,0x4(%r14,%rbx,1)
mov    0x8(%r15,%rbx,2),%rax
movss  0xc(%rax),%xmm0
call   1080 <fabs@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
addss  0x4(%r13,%rbx,1),%xmm0
movss  %xmm0,0x4(%r13,%rbx,1)
mov    0x18(%r15),%rax
movss  0x4(%rax,%rbx,1),%xmm0
call   1080 <fabs@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
addss  0x4(%r14,%rbx,1),%xmm0
movss  %xmm0,0x4(%r14,%rbx,1)
mov    0x8(%r15,%rbx,2),%rax
movss  0x10(%rax),%xmm0
call   1080 <fabs@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
addss  0x4(%r13,%rbx,1),%xmm0
movss  %xmm0,0x4(%r13,%rbx,1)
mov    0x20(%r15),%rax
movss  0x4(%rax,%rbx,1),%xmm0
call   1080 <fabs@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
addss  0x4(%r14,%rbx,1),%xmm0
movss  %xmm0,0x4(%r14,%rbx,1)
mov    0x8(%r15,%rbx,2),%rax
movss  0x14(%rax),%xmm0
call   1080 <fabs@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
addss  0x4(%r13,%rbx,1),%xmm0
movss  %xmm0,0x4(%r13,%rbx,1)
mov    0x28(%r15),%rax
movss  0x4(%rax,%rbx,1),%xmm0
call   1080 <fabs@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
addss  0x4(%r14,%rbx,1),%xmm0
movss  %xmm0,0x4(%r14,%rbx,1)
cmp    $0x10,%rbx
je     13d3 <main+0x243>
mov    0x10(%r15,%rbx,2),%rax
add    $0x4,%rbx
jmp    1240 <main+0xb0>
lea    0xc6d(%rip),%rdi
call   1040 <puts@plt>
movss  0x4(%r13),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0xc30(%rip),%r12
mov    %r12,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
movss  0x8(%r13),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
movss  0xc(%r13),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
movss  0x10(%r13),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
movss  0x14(%r13),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
lea    0xbfc(%rip),%rdi
call   1040 <puts@plt>
movss  0x4(%r14),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
movss  0x8(%r14),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
movss  0xc(%r14),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
movss  0x10(%r14),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
movss  0x14(%r14),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
lea    0xb66(%rip),%rdi
call   1040 <puts@plt>
mov    %r15,%rdi
mov    $0x5,%esi
call   10b0 <balanc@plt>
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
movl   $0x0,0x4(%r14,%rbx,1)
movl   $0x0,0x4(%r13,%rbx,1)
mov    0x8(%r15,%rbx,2),%rax
movss  0x4(%rax),%xmm0
call   1080 <fabs@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
addss  0x4(%r13,%rbx,1),%xmm0
movss  %xmm0,0x4(%r13,%rbx,1)
mov    0x8(%r15),%rax
movss  0x4(%rax,%rbx,1),%xmm0
call   1080 <fabs@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
addss  0x4(%r14,%rbx,1),%xmm0
movss  %xmm0,0x4(%r14,%rbx,1)
mov    0x8(%r15,%rbx,2),%rax
movss  0x8(%rax),%xmm0
call   1080 <fabs@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
addss  0x4(%r13,%rbx,1),%xmm0
movss  %xmm0,0x4(%r13,%rbx,1)
mov    0x10(%r15),%rax
movss  0x4(%rax,%rbx,1),%xmm0
call   1080 <fabs@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
addss  0x4(%r14,%rbx,1),%xmm0
movss  %xmm0,0x4(%r14,%rbx,1)
mov    0x8(%r15,%rbx,2),%rax
movss  0xc(%rax),%xmm0
call   1080 <fabs@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
addss  0x4(%r13,%rbx,1),%xmm0
movss  %xmm0,0x4(%r13,%rbx,1)
mov    0x18(%r15),%rax
movss  0x4(%rax,%rbx,1),%xmm0
call   1080 <fabs@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
addss  0x4(%r14,%rbx,1),%xmm0
movss  %xmm0,0x4(%r14,%rbx,1)
mov    0x8(%r15,%rbx,2),%rax
movss  0x10(%rax),%xmm0
call   1080 <fabs@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
addss  0x4(%r13,%rbx,1),%xmm0
movss  %xmm0,0x4(%r13,%rbx,1)
mov    0x20(%r15),%rax
movss  0x4(%rax,%rbx,1),%xmm0
call   1080 <fabs@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
addss  0x4(%r14,%rbx,1),%xmm0
movss  %xmm0,0x4(%r14,%rbx,1)
mov    0x8(%r15,%rbx,2),%rax
movss  0x14(%rax),%xmm0
call   1080 <fabs@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
addss  0x4(%r13,%rbx,1),%xmm0
movss  %xmm0,0x4(%r13,%rbx,1)
mov    0x28(%r15),%rax
movss  0x4(%rax,%rbx,1),%xmm0
call   1080 <fabs@plt>
xorps  %xmm0,%xmm0
cvtsi2ss %rax,%xmm0
addss  0x4(%r14,%rbx,1),%xmm0
movss  %xmm0,0x4(%r14,%rbx,1)
add    $0x4,%rbx
cmp    $0x14,%rbx
jne    14e0 <main+0x350>
lea    0x9ce(%rip),%rdi
call   1040 <puts@plt>
movss  0x4(%r13),%xmm0
cvtss2sd %xmm0,%xmm0
lea    0x991(%rip),%r12
mov    %r12,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
movss  0x8(%r13),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
movss  0xc(%r13),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
movss  0x10(%r13),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
movss  0x14(%r13),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
lea    0x95d(%rip),%rdi
call   1040 <puts@plt>
movss  0x4(%r14),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
movss  0x8(%r14),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
movss  0xc(%r14),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
movss  0x10(%r14),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
movss  0x14(%r14),%xmm0
cvtss2sd %xmm0,%xmm0
mov    %r12,%rdi
mov    $0x1,%al
call   1060 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    %r15,%rdi
mov    $0x1,%esi
mov    $0x5,%edx
mov    $0x1,%ecx
mov    $0x5,%r8d
call   1050 <free_matrix@plt>
mov    %r13,%rdi
mov    $0x1,%esi
mov    $0x5,%edx
call   1070 <free_vector@plt>
mov    %r14,%rdi
mov    $0x1,%esi
mov    $0x5,%edx
call   1070 <free_vector@plt>
xor    %eax,%eax
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
ret

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

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