#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*/ banbks(float **, int, int, int, float **, unsigned long *,
                          float *);
int /*<<< orphan*/ bandec(float **, int, int, int, float **, unsigned long *,
                          float *);
int /*<<< orphan*/ banmul(float **, int, int, int, float *, float *);
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 *, unsigned long, float, float);
float ran1(long *);
float *vector(int, int);
int main(void) {
  float d, **a, **al, *b, *x;
  unsigned long i, j, *indx;
  long idum = (-1);
  a = matrix(1, 7, 1, 4);
  x = vector(1, 7);
  b = vector(1, 7);
  al = matrix(1, 7, 1, 2);
  indx = lvector(1, 7);
  for (i = 1; i <= 7; i++) {
    x[i] = ran1(&idum);
    for (j = 1; j <= 4; j++) {
      a[i][j] = ran1(&idum);
    }
  }
  banmul(a, 7, 2, 1, x, b);
  for (i = 1; i <= 7; i++)
    printf("%ld %12.6f %12.6f\n", i, b[i], x[i]);
  bandec(a, 7, 2, 1, al, indx, &d);
  banbks(a, 7, 2, 1, al, indx, b);
  for (i = 1; i <= 7; i++)
    printf("%ld %12.6f %12.6f\n", i, b[i], x[i]);
  free_lvector(indx, 1, 7);
  free_matrix(al, 1, 7, 1, 2);
  free_vector(b, 1, 7);
  free_vector(x, 1, 7);
  free_matrix(a, 1, 7, 1, 4);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
movl   $0x0,-0x4(%rbp)
movq   $0xffffffffffffffff,-0x48(%rbp)
ff
mov    $0x1,%edx
mov    $0x7,%esi
mov    $0x4,%ecx
mov    %edx,%edi
call   1080 <matrix@plt>
mov    %rax,-0x10(%rbp)
mov    $0x1,%edi
mov    $0x7,%esi
call   1090 <vector@plt>
mov    %rax,-0x28(%rbp)
mov    $0x1,%edi
mov    $0x7,%esi
call   1090 <vector@plt>
mov    %rax,-0x20(%rbp)
mov    $0x1,%edx
mov    $0x7,%esi
mov    $0x2,%ecx
mov    %edx,%edi
call   1080 <matrix@plt>
mov    %rax,-0x18(%rbp)
mov    $0x1,%edi
mov    $0x7,%esi
call   10d0 <lvector@plt>
mov    %rax,-0x40(%rbp)
movq   $0x1,-0x30(%rbp)
cmpq   $0x7,-0x30(%rbp)
ja     12b5 <main+0x105>
lea    -0x48(%rbp),%rdi
call   10c0 <ran1@plt>
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movq   $0x1,-0x38(%rbp)
cmpq   $0x4,-0x38(%rbp)
ja     129f <main+0xef>
lea    -0x48(%rbp),%rdi
call   10c0 <ran1@plt>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    1265 <main+0xb5>
jmp    12a4 <main+0xf4>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    123c <main+0x8c>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%r8
mov    -0x20(%rbp),%r9
mov    $0x7,%esi
mov    $0x2,%edx
mov    $0x1,%ecx
call   1030 <banmul@plt>
movq   $0x1,-0x30(%rbp)
cmpq   $0x7,-0x30(%rbp)
ja     1323 <main+0x173>
mov    -0x30(%rbp),%rsi
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
lea    0xcf3(%rip),%rdi
call   1060 <printf@plt>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    12dd <main+0x12d>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%r8
mov    -0x40(%rbp),%r9
mov    $0x7,%esi
mov    $0x2,%edx
mov    $0x1,%ecx
lea    -0x8(%rbp),%rax
mov    %rax,(%rsp)
call   10a0 <bandec@plt>
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%r8
mov    -0x40(%rbp),%r9
mov    -0x20(%rbp),%rax
mov    $0x7,%esi
mov    $0x2,%edx
mov    $0x1,%ecx
mov    %rax,(%rsp)
call   10b0 <banbks@plt>
movq   $0x1,-0x30(%rbp)
cmpq   $0x7,-0x30(%rbp)
ja     13c1 <main+0x211>
mov    -0x30(%rbp),%rsi
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
lea    0xc55(%rip),%rdi
call   1060 <printf@plt>
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    137b <main+0x1cb>
mov    -0x40(%rbp),%rdi
mov    $0x1,%esi
mov    $0x7,%edx
call   1050 <free_lvector@plt>
mov    -0x18(%rbp),%rdi
mov    $0x1,%ecx
mov    $0x7,%edx
mov    $0x2,%r8d
mov    %ecx,%esi
call   1040 <free_matrix@plt>
mov    -0x20(%rbp),%rdi
mov    $0x1,%esi
mov    $0x7,%edx
call   1070 <free_vector@plt>
mov    -0x28(%rbp),%rdi
mov    $0x1,%esi
mov    $0x7,%edx
call   1070 <free_vector@plt>
mov    -0x10(%rbp),%rdi
mov    $0x1,%ecx
mov    $0x7,%edx
mov    $0x4,%r8d
mov    %ecx,%esi
call   1040 <free_matrix@plt>
xor    %eax,%eax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
movq   $0xffffffffffffffff,0x8(%rsp)
ff ff
mov    $0x1,%edi
mov    $0x7,%esi
mov    $0x1,%edx
mov    $0x4,%ecx
call   1080 <matrix@plt>
mov    %rax,%rbx
mov    $0x1,%edi
mov    $0x7,%esi
call   1090 <vector@plt>
mov    %rax,%r14
mov    $0x1,%edi
mov    $0x7,%esi
call   1090 <vector@plt>
mov    %rax,%r15
mov    $0x1,%edi
mov    $0x7,%esi
mov    $0x1,%edx
mov    $0x2,%ecx
call   1080 <matrix@plt>
mov    %rax,%r12
mov    $0x1,%edi
mov    $0x7,%esi
call   10d0 <lvector@plt>
mov    %rax,%r13
lea    0x8(%rsp),%rbp
mov    %rbp,%rdi
call   10c0 <ran1@plt>
movss  %xmm0,0x4(%r14)
mov    %rbp,%rdi
call   10c0 <ran1@plt>
mov    0x8(%rbx),%rax
movss  %xmm0,0x4(%rax)
mov    %rbp,%rdi
call   10c0 <ran1@plt>
mov    0x8(%rbx),%rax
movss  %xmm0,0x8(%rax)
mov    %rbp,%rdi
call   10c0 <ran1@plt>
mov    0x8(%rbx),%rax
movss  %xmm0,0xc(%rax)
mov    %rbp,%rdi
call   10c0 <ran1@plt>
mov    0x8(%rbx),%rax
movss  %xmm0,0x10(%rax)
mov    %rbp,%rdi
call   10c0 <ran1@plt>
movss  %xmm0,0x8(%r14)
mov    %rbp,%rdi
call   10c0 <ran1@plt>
mov    0x10(%rbx),%rax
movss  %xmm0,0x4(%rax)
mov    %rbp,%rdi
call   10c0 <ran1@plt>
mov    0x10(%rbx),%rax
movss  %xmm0,0x8(%rax)
mov    %rbp,%rdi
call   10c0 <ran1@plt>
mov    0x10(%rbx),%rax
movss  %xmm0,0xc(%rax)
mov    %rbp,%rdi
call   10c0 <ran1@plt>
mov    0x10(%rbx),%rax
movss  %xmm0,0x10(%rax)
mov    %rbp,%rdi
call   10c0 <ran1@plt>
movss  %xmm0,0xc(%r14)
mov    %rbp,%rdi
call   10c0 <ran1@plt>
mov    0x18(%rbx),%rax
movss  %xmm0,0x4(%rax)
mov    %rbp,%rdi
call   10c0 <ran1@plt>
mov    0x18(%rbx),%rax
movss  %xmm0,0x8(%rax)
mov    %rbp,%rdi
call   10c0 <ran1@plt>
mov    0x18(%rbx),%rax
movss  %xmm0,0xc(%rax)
mov    %rbp,%rdi
call   10c0 <ran1@plt>
mov    0x18(%rbx),%rax
movss  %xmm0,0x10(%rax)
mov    %rbp,%rdi
call   10c0 <ran1@plt>
movss  %xmm0,0x10(%r14)
mov    %rbp,%rdi
call   10c0 <ran1@plt>
mov    0x20(%rbx),%rax
movss  %xmm0,0x4(%rax)
mov    %rbp,%rdi
call   10c0 <ran1@plt>
mov    0x20(%rbx),%rax
movss  %xmm0,0x8(%rax)
mov    %rbp,%rdi
call   10c0 <ran1@plt>
mov    0x20(%rbx),%rax
movss  %xmm0,0xc(%rax)
mov    %rbp,%rdi
call   10c0 <ran1@plt>
mov    0x20(%rbx),%rax
movss  %xmm0,0x10(%rax)
mov    %rbp,%rdi
call   10c0 <ran1@plt>
movss  %xmm0,0x14(%r14)
mov    %rbp,%rdi
call   10c0 <ran1@plt>
mov    0x28(%rbx),%rax
movss  %xmm0,0x4(%rax)
mov    %rbp,%rdi
call   10c0 <ran1@plt>
mov    0x28(%rbx),%rax
movss  %xmm0,0x8(%rax)
mov    %rbp,%rdi
call   10c0 <ran1@plt>
mov    0x28(%rbx),%rax
movss  %xmm0,0xc(%rax)
mov    %rbp,%rdi
call   10c0 <ran1@plt>
mov    0x28(%rbx),%rax
movss  %xmm0,0x10(%rax)
mov    %rbp,%rdi
call   10c0 <ran1@plt>
movss  %xmm0,0x18(%r14)
mov    %rbp,%rdi
call   10c0 <ran1@plt>
mov    0x30(%rbx),%rax
movss  %xmm0,0x4(%rax)
mov    %rbp,%rdi
call   10c0 <ran1@plt>
mov    0x30(%rbx),%rax
movss  %xmm0,0x8(%rax)
mov    %rbp,%rdi
call   10c0 <ran1@plt>
mov    0x30(%rbx),%rax
movss  %xmm0,0xc(%rax)
mov    %rbp,%rdi
call   10c0 <ran1@plt>
mov    0x30(%rbx),%rax
movss  %xmm0,0x10(%rax)
mov    %rbp,%rdi
call   10c0 <ran1@plt>
movss  %xmm0,0x1c(%r14)
mov    %rbp,%rdi
call   10c0 <ran1@plt>
mov    0x38(%rbx),%rax
movss  %xmm0,0x4(%rax)
mov    %rbp,%rdi
call   10c0 <ran1@plt>
mov    0x38(%rbx),%rax
movss  %xmm0,0x8(%rax)
mov    %rbp,%rdi
call   10c0 <ran1@plt>
mov    0x38(%rbx),%rax
movss  %xmm0,0xc(%rax)
mov    %rbp,%rdi
call   10c0 <ran1@plt>
mov    0x38(%rbx),%rax
movss  %xmm0,0x10(%rax)
mov    %rbx,%rdi
mov    $0x7,%esi
mov    $0x2,%edx
mov    $0x1,%ecx
mov    %r14,%r8
mov    %r15,%r9
call   1030 <banmul@plt>
movss  0x4(%r15),%xmm0
movss  0x4(%r14),%xmm1
lea    0xb58(%rip),%rbp
mov    $0x1,%esi
mov    %rbp,%rdi
call   1060 <printf@plt>
movss  0x8(%r15),%xmm0
movss  0x8(%r14),%xmm1
mov    $0x2,%esi
mov    %rbp,%rdi
call   1060 <printf@plt>
movss  0xc(%r15),%xmm0
movss  0xc(%r14),%xmm1
mov    $0x3,%esi
mov    %rbp,%rdi
call   1060 <printf@plt>
movss  0x10(%r15),%xmm0
movss  0x10(%r14),%xmm1
mov    $0x4,%esi
mov    %rbp,%rdi
call   1060 <printf@plt>
movss  0x14(%r15),%xmm0
movss  0x14(%r14),%xmm1
mov    $0x5,%esi
mov    %rbp,%rdi
call   1060 <printf@plt>
movss  0x18(%r15),%xmm0
movss  0x18(%r14),%xmm1
mov    $0x6,%esi
mov    %rbp,%rdi
call   1060 <printf@plt>
movss  0x1c(%r15),%xmm0
movss  0x1c(%r14),%xmm1
mov    $0x7,%esi
mov    %rbp,%rdi
call   1060 <printf@plt>
lea    0x14(%rsp),%rax
mov    %rax,(%rsp)
mov    %rbx,%rdi
mov    $0x7,%esi
mov    $0x2,%edx
mov    $0x1,%ecx
mov    %r12,%r8
mov    %r13,%r9
call   10a0 <bandec@plt>
mov    %r15,(%rsp)
mov    %rbx,%rdi
mov    $0x7,%esi
mov    $0x2,%edx
mov    $0x1,%ecx
mov    %r12,%r8
mov    %r13,%r9
call   10b0 <banbks@plt>
movss  0x4(%r15),%xmm0
movss  0x4(%r14),%xmm1
mov    $0x1,%esi
mov    %rbp,%rdi
call   1060 <printf@plt>
movss  0x8(%r15),%xmm0
movss  0x8(%r14),%xmm1
mov    $0x2,%esi
mov    %rbp,%rdi
call   1060 <printf@plt>
movss  0xc(%r15),%xmm0
movss  0xc(%r14),%xmm1
mov    $0x3,%esi
mov    %rbp,%rdi
call   1060 <printf@plt>
movss  0x10(%r15),%xmm0
movss  0x10(%r14),%xmm1
mov    $0x4,%esi
mov    %rbp,%rdi
call   1060 <printf@plt>
movss  0x14(%r15),%xmm0
movss  0x14(%r14),%xmm1
mov    $0x5,%esi
mov    %rbp,%rdi
call   1060 <printf@plt>
movss  0x18(%r15),%xmm0
movss  0x18(%r14),%xmm1
mov    $0x6,%esi
mov    %rbp,%rdi
call   1060 <printf@plt>
movss  0x1c(%r15),%xmm0
movss  0x1c(%r14),%xmm1
mov    $0x7,%esi
mov    %rbp,%rdi
call   1060 <printf@plt>
mov    %r13,%rdi
mov    $0x1,%esi
mov    $0x7,%edx
call   1050 <free_lvector@plt>
mov    %r12,%rdi
mov    $0x1,%esi
mov    $0x7,%edx
mov    $0x1,%ecx
mov    $0x2,%r8d
call   1040 <free_matrix@plt>
mov    %r15,%rdi
mov    $0x1,%esi
mov    $0x7,%edx
call   1070 <free_vector@plt>
mov    %r14,%rdi
mov    $0x1,%esi
mov    $0x7,%edx
call   1070 <free_vector@plt>
mov    %rbx,%rdi
mov    $0x1,%esi
mov    $0x7,%edx
mov    $0x1,%ecx
mov    $0x4,%r8d
call   1040 <free_matrix@plt>
xor    %eax,%eax
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [19 x i8] c"%ld %12.6f %12.6f\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca float
%3 = alloca float**
%4 = alloca float**
%5 = alloca float*
%6 = alloca float*
%7 = alloca i64
%8 = alloca i64
%9 = alloca i64*
%10 = alloca i64
store i32 0, i32* %1
store i64 -1, i64* %10
%11 = call float** @matrix(i32 1, i32 7, i32 1, i32 4)
store float** %11, float*** %3
%12 = call float* @vector(i32 1, i32 7)
store float* %12, float** %6
%13 = call float* @vector(i32 1, i32 7)
store float* %13, float** %5
%14 = call float** @matrix(i32 1, i32 7, i32 1, i32 2)
store float** %14, float*** %4
%15 = call i64* @lvector(i32 1, i32 7)
store i64* %15, i64** %9
store i64 1, i64* %7
br label %16
16: ; preds = %39, %0
%17 = load i64, i64* %7
%18 = icmp ule i64 %17, 7
br i1 %18, label %19, label %42
19: ; preds = %16
%20 = call float @ran1(i64* %10)
%21 = load float*, float** %6
%22 = load i64, i64* %7
%23 = getelementptr inbounds float, float* %21, i64 %22
store float %20, float* %23
store i64 1, i64* %8
br label %24
24: ; preds = %35, %19
%25 = load i64, i64* %8
%26 = icmp ule i64 %25, 4
br i1 %26, label %27, label %38
27: ; preds = %24
%28 = call float @ran1(i64* %10)
%29 = load float**, float*** %3
%30 = load i64, i64* %7
%31 = getelementptr inbounds float*, float** %29, i64 %30
%32 = load float*, float** %31
%33 = load i64, i64* %8
%34 = getelementptr inbounds float, float* %32, i64 %33
store float %28, float* %34
br label %35
35: ; preds = %27
%36 = load i64, i64* %8
%37 = add i64 %36, 1
store i64 %37, i64* %8
br label %24
38: ; preds = %24
br label %39
39: ; preds = %38
%40 = load i64, i64* %7
%41 = add i64 %40, 1
store i64 %41, i64* %7
br label %16
42: ; preds = %16
%43 = load float**, float*** %3
%44 = load float*, float** %6
%45 = load float*, float** %5
%46 = call i32 @banmul(float** %43, i32 7, i32 2, i32 1, float* %44, float* %45)
store i64 1, i64* %7
br label %47
47: ; preds = %61, %42
%48 = load i64, i64* %7
%49 = icmp ule i64 %48, 7
br i1 %49, label %50, label %64
50: ; preds = %47
%51 = load i64, i64* %7
%52 = load float*, float** %5
%53 = load i64, i64* %7
%54 = getelementptr inbounds float, float* %52, i64 %53
%55 = load float, float* %54
%56 = load float*, float** %6
%57 = load i64, i64* %7
%58 = getelementptr inbounds float, float* %56, i64 %57
%59 = load float, float* %58
%60 = call i32 @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str, i64 0, i64 0), i64 %51, float %55, float %59)
br label %61
61: ; preds = %50
%62 = load i64, i64* %7
%63 = add i64 %62, 1
store i64 %63, i64* %7
br label %47
64: ; preds = %47
%65 = load float**, float*** %3
%66 = load float**, float*** %4
%67 = load i64*, i64** %9
%68 = call i32 @bandec(float** %65, i32 7, i32 2, i32 1, float** %66, i64* %67, float* %2)
%69 = load float**, float*** %3
%70 = load float**, float*** %4
%71 = load i64*, i64** %9
%72 = load float*, float** %5
%73 = call i32 @banbks(float** %69, i32 7, i32 2, i32 1, float** %70, i64* %71, float* %72)
store i64 1, i64* %7
br label %74
74: ; preds = %88, %64
%75 = load i64, i64* %7
%76 = icmp ule i64 %75, 7
br i1 %76, label %77, label %91
77: ; preds = %74
%78 = load i64, i64* %7
%79 = load float*, float** %5
%80 = load i64, i64* %7
%81 = getelementptr inbounds float, float* %79, i64 %80
%82 = load float, float* %81
%83 = load float*, float** %6
%84 = load i64, i64* %7
%85 = getelementptr inbounds float, float* %83, i64 %84
%86 = load float, float* %85
%87 = call i32 @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str, i64 0, i64 0), i64 %78, float %82, float %86)
br label %88
88: ; preds = %77
%89 = load i64, i64* %7
%90 = add i64 %89, 1
store i64 %90, i64* %7
br label %74
91: ; preds = %74
%92 = load i64*, i64** %9
%93 = call i32 @free_lvector(i64* %92, i32 1, i32 7)
%94 = load float**, float*** %4
%95 = call i32 @free_matrix(float** %94, i32 1, i32 7, i32 1, i32 2)
%96 = load float*, float** %5
%97 = call i32 @free_vector(float* %96, i32 1, i32 7)
%98 = load float*, float** %6
%99 = call i32 @free_vector(float* %98, i32 1, i32 7)
%100 = load float**, float*** %3
%101 = call i32 @free_matrix(float** %100, i32 1, i32 7, i32 1, i32 4)
ret i32 0
}

LLVM IR (-O2):
@.str = [19 x i8] c"%ld %12.6f %12.6f\0A\00"
define i32 @main() {
%1 = alloca float
%2 = alloca i64
%3 = bitcast float* %1 to i8*
%4 = bitcast i64* %2 to i8*
store i64 -1, i64* %2
%5 = tail call float** @matrix(i32 1, i32 7, i32 1, i32 4)
%6 = tail call float* @vector(i32 1, i32 7)
%7 = tail call float* @vector(i32 1, i32 7)
%8 = tail call float** @matrix(i32 1, i32 7, i32 1, i32 2)
%9 = tail call i64* @lvector(i32 1, i32 7)
%10 = call float @ran1(i64* %2)
%11 = getelementptr inbounds float, float* %6, i64 1
store float %10, float* %11
%12 = getelementptr inbounds float*, float** %5, i64 1
%13 = call float @ran1(i64* %2)
%14 = load float*, float** %12
%15 = getelementptr inbounds float, float* %14, i64 1
store float %13, float* %15
%16 = call float @ran1(i64* %2)
%17 = load float*, float** %12
%18 = getelementptr inbounds float, float* %17, i64 2
store float %16, float* %18
%19 = call float @ran1(i64* %2)
%20 = load float*, float** %12
%21 = getelementptr inbounds float, float* %20, i64 3
store float %19, float* %21
%22 = call float @ran1(i64* %2)
%23 = load float*, float** %12
%24 = getelementptr inbounds float, float* %23, i64 4
store float %22, float* %24
%25 = call float @ran1(i64* %2)
%26 = getelementptr inbounds float, float* %6, i64 2
store float %25, float* %26
%27 = getelementptr inbounds float*, float** %5, i64 2
%28 = call float @ran1(i64* %2)
%29 = load float*, float** %27
%30 = getelementptr inbounds float, float* %29, i64 1
store float %28, float* %30
%31 = call float @ran1(i64* %2)
%32 = load float*, float** %27
%33 = getelementptr inbounds float, float* %32, i64 2
store float %31, float* %33
%34 = call float @ran1(i64* %2)
%35 = load float*, float** %27
%36 = getelementptr inbounds float, float* %35, i64 3
store float %34, float* %36
%37 = call float @ran1(i64* %2)
%38 = load float*, float** %27
%39 = getelementptr inbounds float, float* %38, i64 4
store float %37, float* %39
%40 = call float @ran1(i64* %2)
%41 = getelementptr inbounds float, float* %6, i64 3
store float %40, float* %41
%42 = getelementptr inbounds float*, float** %5, i64 3
%43 = call float @ran1(i64* %2)
%44 = load float*, float** %42
%45 = getelementptr inbounds float, float* %44, i64 1
store float %43, float* %45
%46 = call float @ran1(i64* %2)
%47 = load float*, float** %42
%48 = getelementptr inbounds float, float* %47, i64 2
store float %46, float* %48
%49 = call float @ran1(i64* %2)
%50 = load float*, float** %42
%51 = getelementptr inbounds float, float* %50, i64 3
store float %49, float* %51
%52 = call float @ran1(i64* %2)
%53 = load float*, float** %42
%54 = getelementptr inbounds float, float* %53, i64 4
store float %52, float* %54
%55 = call float @ran1(i64* %2)
%56 = getelementptr inbounds float, float* %6, i64 4
store float %55, float* %56
%57 = getelementptr inbounds float*, float** %5, i64 4
%58 = call float @ran1(i64* %2)
%59 = load float*, float** %57
%60 = getelementptr inbounds float, float* %59, i64 1
store float %58, float* %60
%61 = call float @ran1(i64* %2)
%62 = load float*, float** %57
%63 = getelementptr inbounds float, float* %62, i64 2
store float %61, float* %63
%64 = call float @ran1(i64* %2)
%65 = load float*, float** %57
%66 = getelementptr inbounds float, float* %65, i64 3
store float %64, float* %66
%67 = call float @ran1(i64* %2)
%68 = load float*, float** %57
%69 = getelementptr inbounds float, float* %68, i64 4
store float %67, float* %69
%70 = call float @ran1(i64* %2)
%71 = getelementptr inbounds float, float* %6, i64 5
store float %70, float* %71
%72 = getelementptr inbounds float*, float** %5, i64 5
%73 = call float @ran1(i64* %2)
%74 = load float*, float** %72
%75 = getelementptr inbounds float, float* %74, i64 1
store float %73, float* %75
%76 = call float @ran1(i64* %2)
%77 = load float*, float** %72
%78 = getelementptr inbounds float, float* %77, i64 2
store float %76, float* %78
%79 = call float @ran1(i64* %2)
%80 = load float*, float** %72
%81 = getelementptr inbounds float, float* %80, i64 3
store float %79, float* %81
%82 = call float @ran1(i64* %2)
%83 = load float*, float** %72
%84 = getelementptr inbounds float, float* %83, i64 4
store float %82, float* %84
%85 = call float @ran1(i64* %2)
%86 = getelementptr inbounds float, float* %6, i64 6
store float %85, float* %86
%87 = getelementptr inbounds float*, float** %5, i64 6
%88 = call float @ran1(i64* %2)
%89 = load float*, float** %87
%90 = getelementptr inbounds float, float* %89, i64 1
store float %88, float* %90
%91 = call float @ran1(i64* %2)
%92 = load float*, float** %87
%93 = getelementptr inbounds float, float* %92, i64 2
store float %91, float* %93
%94 = call float @ran1(i64* %2)
%95 = load float*, float** %87
%96 = getelementptr inbounds float, float* %95, i64 3
store float %94, float* %96
%97 = call float @ran1(i64* %2)
%98 = load float*, float** %87
%99 = getelementptr inbounds float, float* %98, i64 4
store float %97, float* %99
%100 = call float @ran1(i64* %2)
%101 = getelementptr inbounds float, float* %6, i64 7
store float %100, float* %101
%102 = getelementptr inbounds float*, float** %5, i64 7
%103 = call float @ran1(i64* %2)
%104 = load float*, float** %102
%105 = getelementptr inbounds float, float* %104, i64 1
store float %103, float* %105
%106 = call float @ran1(i64* %2)
%107 = load float*, float** %102
%108 = getelementptr inbounds float, float* %107, i64 2
store float %106, float* %108
%109 = call float @ran1(i64* %2)
%110 = load float*, float** %102
%111 = getelementptr inbounds float, float* %110, i64 3
store float %109, float* %111
%112 = call float @ran1(i64* %2)
%113 = load float*, float** %102
%114 = getelementptr inbounds float, float* %113, i64 4
store float %112, float* %114
%115 = call i32 @banmul(float** %5, i32 7, i32 2, i32 1, float* %6, float* %7)
%116 = getelementptr inbounds float, float* %7, i64 1
%117 = load float, float* %116
%118 = getelementptr inbounds float, float* %6, i64 1
%119 = load float, float* %118
%120 = call i32 @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str, i64 0, i64 0), i64 1, float %117, float %119)
%121 = getelementptr inbounds float, float* %7, i64 2
%122 = load float, float* %121
%123 = getelementptr inbounds float, float* %6, i64 2
%124 = load float, float* %123
%125 = call i32 @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str, i64 0, i64 0), i64 2, float %122, float %124)
%126 = getelementptr inbounds float, float* %7, i64 3
%127 = load float, float* %126
%128 = getelementptr inbounds float, float* %6, i64 3
%129 = load float, float* %128
%130 = call i32 @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str, i64 0, i64 0), i64 3, float %127, float %129)
%131 = getelementptr inbounds float, float* %7, i64 4
%132 = load float, float* %131
%133 = getelementptr inbounds float, float* %6, i64 4
%134 = load float, float* %133
%135 = call i32 @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str, i64 0, i64 0), i64 4, float %132, float %134)
%136 = getelementptr inbounds float, float* %7, i64 5
%137 = load float, float* %136
%138 = getelementptr inbounds float, float* %6, i64 5
%139 = load float, float* %138
%140 = call i32 @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str, i64 0, i64 0), i64 5, float %137, float %139)
%141 = getelementptr inbounds float, float* %7, i64 6
%142 = load float, float* %141
%143 = getelementptr inbounds float, float* %6, i64 6
%144 = load float, float* %143
%145 = call i32 @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str, i64 0, i64 0), i64 6, float %142, float %144)
%146 = getelementptr inbounds float, float* %7, i64 7
%147 = load float, float* %146
%148 = getelementptr inbounds float, float* %6, i64 7
%149 = load float, float* %148
%150 = call i32 @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str, i64 0, i64 0), i64 7, float %147, float %149)
%151 = call i32 @bandec(float** %5, i32 7, i32 2, i32 1, float** %8, i64* %9, float* %1)
%152 = call i32 @banbks(float** %5, i32 7, i32 2, i32 1, float** %8, i64* %9, float* %7)
%153 = load float, float* %116
%154 = load float, float* %118
%155 = call i32 @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str, i64 0, i64 0), i64 1, float %153, float %154)
%156 = load float, float* %121
%157 = load float, float* %123
%158 = call i32 @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str, i64 0, i64 0), i64 2, float %156, float %157)
%159 = load float, float* %126
%160 = load float, float* %128
%161 = call i32 @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str, i64 0, i64 0), i64 3, float %159, float %160)
%162 = load float, float* %131
%163 = load float, float* %133
%164 = call i32 @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str, i64 0, i64 0), i64 4, float %162, float %163)
%165 = load float, float* %136
%166 = load float, float* %138
%167 = call i32 @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str, i64 0, i64 0), i64 5, float %165, float %166)
%168 = load float, float* %141
%169 = load float, float* %143
%170 = call i32 @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str, i64 0, i64 0), i64 6, float %168, float %169)
%171 = load float, float* %146
%172 = load float, float* %148
%173 = call i32 @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str, i64 0, i64 0), i64 7, float %171, float %172)
%174 = call i32 @free_lvector(i64* %9, i32 1, i32 7)
%175 = call i32 @free_matrix(float** %8, i32 1, i32 7, i32 1, i32 2)
%176 = call i32 @free_vector(float* %7, i32 1, i32 7)
%177 = call i32 @free_vector(float* %6, i32 1, i32 7)
%178 = call i32 @free_matrix(float** %5, i32 1, i32 7, i32 1, i32 4)
ret i32 0
}