#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*/ anneal(float *, float *, int *, int);
int /*<<< orphan*/ free_ivector(int *, int, int);
int /*<<< orphan*/ free_vector(float *, int, int);
int *ivector(int, int);
int /*<<< orphan*/ printf(char *, ...);
float ran3(long *);
float *vector(int, int);
int main(void) {
  int i, ii, *iorder;
  long idum = (-111);
  float *x, *y;
  iorder = ivector(1, 10);
  x = vector(1, 10);
  y = vector(1, 10);
  for (i = 1; i <= 10; i++) {
    x[i] = ran3(&idum);
    y[i] = ran3(&idum);
    iorder[i] = i;
  }
  anneal(x, y, iorder, 10);
  printf("*** System Frozen ***\n");
  printf("Final path:\n");
  printf("%8s %9s %12s\n", "city", "x", "y");
  for (i = 1; i <= 10; i++) {
    ii = iorder[i];
    printf("%4d %10.4f %10.4f\n", ii, x[ii], y[ii]);
  }
  free_vector(y, 1, 10);
  free_vector(x, 1, 10);
  free_ivector(iorder, 1, 10);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
movl   $0x0,-0x4(%rbp)
movq   $0xffffffffffffff91,-0x20(%rbp)
ff
mov    $0x1,%edi
mov    $0xa,%esi
call   1080 <ivector@plt>
mov    %rax,-0x18(%rbp)
mov    $0x1,%edi
mov    $0xa,%esi
call   1050 <vector@plt>
mov    %rax,-0x28(%rbp)
mov    $0x1,%edi
mov    $0xa,%esi
call   1050 <vector@plt>
mov    %rax,-0x30(%rbp)
movl   $0x1,-0x8(%rbp)
cmpl   $0xa,-0x8(%rbp)
jg     1219 <main+0xa9>
lea    -0x20(%rbp),%rdi
call   1070 <ran3@plt>
mov    -0x28(%rbp),%rax
movslq -0x8(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
lea    -0x20(%rbp),%rdi
call   1070 <ran3@plt>
mov    -0x30(%rbp),%rax
movslq -0x8(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x8(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    11c7 <main+0x57>
mov    -0x28(%rbp),%rdi
mov    -0x30(%rbp),%rsi
mov    -0x18(%rbp),%rdx
mov    $0xa,%ecx
call   1090 <anneal@plt>
lea    0xdca(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xdd3(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
lea    0xdd2(%rip),%rdi
lea    0xdd9(%rip),%rsi
lea    0xdd7(%rip),%rdx
lea    0xdce(%rip),%rcx
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x8(%rbp)
cmpl   $0xa,-0x8(%rbp)
jg     12ce <main+0x15e>
mov    -0x18(%rbp),%rax
movslq -0x8(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xc(%rbp)
mov    -0xc(%rbp),%esi
mov    -0x28(%rbp),%rax
movslq -0xc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x30(%rbp),%rax
movslq -0xc(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
lea    0xd80(%rip),%rdi
mov    $0x2,%al
call   1030 <printf@plt>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1275 <main+0x105>
mov    -0x30(%rbp),%rdi
mov    $0x1,%esi
mov    $0xa,%edx
call   1040 <free_vector@plt>
mov    -0x28(%rbp),%rdi
mov    $0x1,%esi
mov    $0xa,%edx
call   1040 <free_vector@plt>
mov    -0x18(%rbp),%rdi
mov    $0x1,%esi
mov    $0xa,%edx
call   1060 <free_ivector@plt>
xor    %eax,%eax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x10,%rsp
movq   $0xffffffffffffff91,0x8(%rsp)
ff ff
mov    $0x1,%edi
mov    $0xa,%esi
call   1090 <ivector@plt>
mov    %rax,%r14
mov    $0x1,%edi
mov    $0xa,%esi
call   1060 <vector@plt>
mov    %rax,%r15
mov    $0x1,%edi
mov    $0xa,%esi
call   1060 <vector@plt>
mov    %rax,%r13
lea    0x8(%rsp),%rbx
mov    %rbx,%rdi
call   1080 <ran3@plt>
movss  %xmm0,0x4(%r15)
mov    %rbx,%rdi
call   1080 <ran3@plt>
movss  %xmm0,0x4(%r13)
movl   $0x1,0x4(%r14)
mov    %rbx,%rdi
call   1080 <ran3@plt>
movss  %xmm0,0x8(%r15)
mov    %rbx,%rdi
call   1080 <ran3@plt>
movss  %xmm0,0x8(%r13)
movl   $0x2,0x8(%r14)
mov    %rbx,%rdi
call   1080 <ran3@plt>
movss  %xmm0,0xc(%r15)
mov    %rbx,%rdi
call   1080 <ran3@plt>
movss  %xmm0,0xc(%r13)
movl   $0x3,0xc(%r14)
mov    %rbx,%rdi
call   1080 <ran3@plt>
movss  %xmm0,0x10(%r15)
mov    %rbx,%rdi
call   1080 <ran3@plt>
movss  %xmm0,0x10(%r13)
movl   $0x4,0x10(%r14)
mov    %rbx,%rdi
call   1080 <ran3@plt>
movss  %xmm0,0x14(%r15)
mov    %rbx,%rdi
call   1080 <ran3@plt>
movss  %xmm0,0x14(%r13)
movl   $0x5,0x14(%r14)
mov    %rbx,%rdi
call   1080 <ran3@plt>
movss  %xmm0,0x18(%r15)
mov    %rbx,%rdi
call   1080 <ran3@plt>
movss  %xmm0,0x18(%r13)
movl   $0x6,0x18(%r14)
mov    %rbx,%rdi
call   1080 <ran3@plt>
movss  %xmm0,0x1c(%r15)
mov    %rbx,%rdi
call   1080 <ran3@plt>
movss  %xmm0,0x1c(%r13)
movl   $0x7,0x1c(%r14)
mov    %rbx,%rdi
call   1080 <ran3@plt>
movss  %xmm0,0x20(%r15)
mov    %rbx,%rdi
call   1080 <ran3@plt>
movss  %xmm0,0x20(%r13)
movl   $0x8,0x20(%r14)
mov    %rbx,%rdi
call   1080 <ran3@plt>
movss  %xmm0,0x24(%r15)
mov    %rbx,%rdi
call   1080 <ran3@plt>
movss  %xmm0,0x24(%r13)
movl   $0x9,0x24(%r14)
mov    %rbx,%rdi
call   1080 <ran3@plt>
movss  %xmm0,0x28(%r15)
mov    %rbx,%rdi
call   1080 <ran3@plt>
movss  %xmm0,0x28(%r13)
movl   $0xa,0x28(%r14)
mov    %r15,%rdi
mov    %r13,%rsi
mov    %r14,%rdx
mov    $0xa,%ecx
call   10a0 <anneal@plt>
lea    0xcd5(%rip),%rdi
call   1030 <puts@plt>
lea    0xcdf(%rip),%rdi
call   1030 <puts@plt>
lea    0xc95(%rip),%rdi
lea    0xc9c(%rip),%rsi
lea    0xc9a(%rip),%rdx
lea    0xc91(%rip),%rcx
xor    %eax,%eax
call   1040 <printf@plt>
movslq 0x4(%r14),%rsi
movss  (%r15,%rsi,4),%xmm0
cvtss2sd %xmm0,%xmm0
movss  0x0(%r13,%rsi,4),%xmm1
cvtss2sd %xmm1,%xmm1
lea    0xc6e(%rip),%r12
mov    %r12,%rdi
mov    $0x2,%al
call   1040 <printf@plt>
movslq 0x8(%r14),%rsi
movss  (%r15,%rsi,4),%xmm0
cvtss2sd %xmm0,%xmm0
movss  0x0(%r13,%rsi,4),%xmm1
cvtss2sd %xmm1,%xmm1
mov    %r12,%rdi
mov    $0x2,%al
call   1040 <printf@plt>
movslq 0xc(%r14),%rsi
movss  (%r15,%rsi,4),%xmm0
cvtss2sd %xmm0,%xmm0
movss  0x0(%r13,%rsi,4),%xmm1
cvtss2sd %xmm1,%xmm1
mov    %r12,%rdi
mov    $0x2,%al
call   1040 <printf@plt>
movslq 0x10(%r14),%rsi
movss  (%r15,%rsi,4),%xmm0
cvtss2sd %xmm0,%xmm0
movss  0x0(%r13,%rsi,4),%xmm1
cvtss2sd %xmm1,%xmm1
mov    %r12,%rdi
mov    $0x2,%al
call   1040 <printf@plt>
movslq 0x14(%r14),%rsi
movss  (%r15,%rsi,4),%xmm0
cvtss2sd %xmm0,%xmm0
movss  0x0(%r13,%rsi,4),%xmm1
cvtss2sd %xmm1,%xmm1
mov    %r12,%rdi
mov    $0x2,%al
call   1040 <printf@plt>
movslq 0x18(%r14),%rsi
movss  (%r15,%rsi,4),%xmm0
cvtss2sd %xmm0,%xmm0
movss  0x0(%r13,%rsi,4),%xmm1
cvtss2sd %xmm1,%xmm1
mov    %r12,%rdi
mov    $0x2,%al
call   1040 <printf@plt>
movslq 0x1c(%r14),%rsi
movss  (%r15,%rsi,4),%xmm0
cvtss2sd %xmm0,%xmm0
movss  0x0(%r13,%rsi,4),%xmm1
cvtss2sd %xmm1,%xmm1
mov    %r12,%rdi
mov    $0x2,%al
call   1040 <printf@plt>
movslq 0x20(%r14),%rsi
movss  (%r15,%rsi,4),%xmm0
cvtss2sd %xmm0,%xmm0
movss  0x0(%r13,%rsi,4),%xmm1
cvtss2sd %xmm1,%xmm1
mov    %r12,%rdi
mov    $0x2,%al
call   1040 <printf@plt>
movslq 0x24(%r14),%rsi
movss  (%r15,%rsi,4),%xmm0
cvtss2sd %xmm0,%xmm0
movss  0x0(%r13,%rsi,4),%xmm1
cvtss2sd %xmm1,%xmm1
mov    %r12,%rdi
mov    $0x2,%al
call   1040 <printf@plt>
movslq 0x28(%r14),%rsi
movss  (%r15,%rsi,4),%xmm0
cvtss2sd %xmm0,%xmm0
movss  0x0(%r13,%rsi,4),%xmm1
cvtss2sd %xmm1,%xmm1
mov    %r12,%rdi
mov    $0x2,%al
call   1040 <printf@plt>
mov    %r13,%rdi
mov    $0x1,%esi
mov    $0xa,%edx
call   1050 <free_vector@plt>
mov    %r15,%rdi
mov    $0x1,%esi
mov    $0xa,%edx
call   1050 <free_vector@plt>
mov    %r14,%rdi
mov    $0x1,%esi
mov    $0xa,%edx
call   1070 <free_ivector@plt>
xor    %eax,%eax
add    $0x10,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
@.str = [23 x i8] c"*** System Frozen ***\0A\00"
@.str.1 = [13 x i8] c"Final path:\0A\00"
@.str.2 = [14 x i8] c"%8s %9s %12s\0A\00"
@.str.3 = [5 x i8] c"city\00"
@.str.4 = [2 x i8] c"x\00"
@.str.5 = [2 x i8] c"y\00"
@.str.6 = [19 x i8] c"%4d %10.4f %10.4f\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca i32
%4 = alloca i32*
%5 = alloca i64
%6 = alloca float*
%7 = alloca float*
store i32 0, i32* %1
store i64 -111, i64* %5
%8 = call i32* @ivector(i32 1, i32 10)
store i32* %8, i32** %4
%9 = call float* @vector(i32 1, i32 10)
store float* %9, float** %6
%10 = call float* @vector(i32 1, i32 10)
store float* %10, float** %7
store i32 1, i32* %2
br label %11
11: ; preds = %30, %0
%12 = load i32, i32* %2
%13 = icmp sle i32 %12, 10
br i1 %13, label %14, label %33
14: ; preds = %11
%15 = call float @ran3(i64* %5)
%16 = load float*, float** %6
%17 = load i32, i32* %2
%18 = sext i32 %17 to i64
%19 = getelementptr inbounds float, float* %16, i64 %18
store float %15, float* %19
%20 = call float @ran3(i64* %5)
%21 = load float*, float** %7
%22 = load i32, i32* %2
%23 = sext i32 %22 to i64
%24 = getelementptr inbounds float, float* %21, i64 %23
store float %20, float* %24
%25 = load i32, i32* %2
%26 = load i32*, i32** %4
%27 = load i32, i32* %2
%28 = sext i32 %27 to i64
%29 = getelementptr inbounds i32, i32* %26, i64 %28
store i32 %25, i32* %29
br label %30
30: ; preds = %14
%31 = load i32, i32* %2
%32 = add nsw i32 %31, 1
store i32 %32, i32* %2
br label %11
33: ; preds = %11
%34 = load float*, float** %6
%35 = load float*, float** %7
%36 = load i32*, i32** %4
%37 = call i32 @anneal(float* %34, float* %35, i32* %36, i32 10)
%38 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str, i64 0, i64 0))
%39 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.1, i64 0, i64 0))
%40 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0))
store i32 1, i32* %2
br label %41
41: ; preds = %64, %33
%42 = load i32, i32* %2
%43 = icmp sle i32 %42, 10
br i1 %43, label %44, label %67
44: ; preds = %41
%45 = load i32*, i32** %4
%46 = load i32, i32* %2
%47 = sext i32 %46 to i64
%48 = getelementptr inbounds i32, i32* %45, i64 %47
%49 = load i32, i32* %48
store i32 %49, i32* %3
%50 = load i32, i32* %3
%51 = load float*, float** %6
%52 = load i32, i32* %3
%53 = sext i32 %52 to i64
%54 = getelementptr inbounds float, float* %51, i64 %53
%55 = load float, float* %54
%56 = fpext float %55 to double
%57 = load float*, float** %7
%58 = load i32, i32* %3
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds float, float* %57, i64 %59
%61 = load float, float* %60
%62 = fpext float %61 to double
%63 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.6, i64 0, i64 0), i32 %50, double %56, double %62)
br label %64
64: ; preds = %44
%65 = load i32, i32* %2
%66 = add nsw i32 %65, 1
store i32 %66, i32* %2
br label %41
67: ; preds = %41
%68 = load float*, float** %7
%69 = call i32 @free_vector(float* %68, i32 1, i32 10)
%70 = load float*, float** %6
%71 = call i32 @free_vector(float* %70, i32 1, i32 10)
%72 = load i32*, i32** %4
%73 = call i32 @free_ivector(i32* %72, i32 1, i32 10)
ret i32 0
}

LLVM IR (-O2):
@.str.2 = [14 x i8] c"%8s %9s %12s\0A\00"
@.str.3 = [5 x i8] c"city\00"
@.str.4 = [2 x i8] c"x\00"
@.str.5 = [2 x i8] c"y\00"
@.str.6 = [19 x i8] c"%4d %10.4f %10.4f\0A\00"
@str = [22 x i8] c"*** System Frozen ***\00"
@str.7 = [12 x i8] c"Final path:\00"
define i32 @main() {
%1 = alloca i64
%2 = bitcast i64* %1 to i8*
store i64 -111, i64* %1
%3 = tail call i32* @ivector(i32 1, i32 10)
%4 = tail call float* @vector(i32 1, i32 10)
%5 = tail call float* @vector(i32 1, i32 10)
%6 = call float @ran3(i64* %1)
%7 = getelementptr inbounds float, float* %4, i64 1
store float %6, float* %7
%8 = call float @ran3(i64* %1)
%9 = getelementptr inbounds float, float* %5, i64 1
store float %8, float* %9
%10 = getelementptr inbounds i32, i32* %3, i64 1
store i32 1, i32* %10
%11 = call float @ran3(i64* %1)
%12 = getelementptr inbounds float, float* %4, i64 2
store float %11, float* %12
%13 = call float @ran3(i64* %1)
%14 = getelementptr inbounds float, float* %5, i64 2
store float %13, float* %14
%15 = getelementptr inbounds i32, i32* %3, i64 2
store i32 2, i32* %15
%16 = call float @ran3(i64* %1)
%17 = getelementptr inbounds float, float* %4, i64 3
store float %16, float* %17
%18 = call float @ran3(i64* %1)
%19 = getelementptr inbounds float, float* %5, i64 3
store float %18, float* %19
%20 = getelementptr inbounds i32, i32* %3, i64 3
store i32 3, i32* %20
%21 = call float @ran3(i64* %1)
%22 = getelementptr inbounds float, float* %4, i64 4
store float %21, float* %22
%23 = call float @ran3(i64* %1)
%24 = getelementptr inbounds float, float* %5, i64 4
store float %23, float* %24
%25 = getelementptr inbounds i32, i32* %3, i64 4
store i32 4, i32* %25
%26 = call float @ran3(i64* %1)
%27 = getelementptr inbounds float, float* %4, i64 5
store float %26, float* %27
%28 = call float @ran3(i64* %1)
%29 = getelementptr inbounds float, float* %5, i64 5
store float %28, float* %29
%30 = getelementptr inbounds i32, i32* %3, i64 5
store i32 5, i32* %30
%31 = call float @ran3(i64* %1)
%32 = getelementptr inbounds float, float* %4, i64 6
store float %31, float* %32
%33 = call float @ran3(i64* %1)
%34 = getelementptr inbounds float, float* %5, i64 6
store float %33, float* %34
%35 = getelementptr inbounds i32, i32* %3, i64 6
store i32 6, i32* %35
%36 = call float @ran3(i64* %1)
%37 = getelementptr inbounds float, float* %4, i64 7
store float %36, float* %37
%38 = call float @ran3(i64* %1)
%39 = getelementptr inbounds float, float* %5, i64 7
store float %38, float* %39
%40 = getelementptr inbounds i32, i32* %3, i64 7
store i32 7, i32* %40
%41 = call float @ran3(i64* %1)
%42 = getelementptr inbounds float, float* %4, i64 8
store float %41, float* %42
%43 = call float @ran3(i64* %1)
%44 = getelementptr inbounds float, float* %5, i64 8
store float %43, float* %44
%45 = getelementptr inbounds i32, i32* %3, i64 8
store i32 8, i32* %45
%46 = call float @ran3(i64* %1)
%47 = getelementptr inbounds float, float* %4, i64 9
store float %46, float* %47
%48 = call float @ran3(i64* %1)
%49 = getelementptr inbounds float, float* %5, i64 9
store float %48, float* %49
%50 = getelementptr inbounds i32, i32* %3, i64 9
store i32 9, i32* %50
%51 = call float @ran3(i64* %1)
%52 = getelementptr inbounds float, float* %4, i64 10
store float %51, float* %52
%53 = call float @ran3(i64* %1)
%54 = getelementptr inbounds float, float* %5, i64 10
store float %53, float* %54
%55 = getelementptr inbounds i32, i32* %3, i64 10
store i32 10, i32* %55
%56 = call i32 @anneal(float* %4, float* %5, i32* %3, i32 10)
%57 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([22 x i8], [22 x i8]* @str, i64 0, i64 0))
%58 = call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([12 x i8], [12 x i8]* @str.7, i64 0, i64 0))
%59 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([14 x i8], [14 x i8]* @.str.2, i64 0, i64 0), i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.3, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.4, i64 0, i64 0), i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.5, i64 0, i64 0))
%60 = load i32, i32* %10
%61 = sext i32 %60 to i64
%62 = getelementptr inbounds float, float* %4, i64 %61
%63 = load float, float* %62
%64 = fpext float %63 to double
%65 = getelementptr inbounds float, float* %5, i64 %61
%66 = load float, float* %65
%67 = fpext float %66 to double
%68 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([19 x i8], [19 x i8]* @.str.6, i64 0, i64 0), i32 %60, double %64, double %67)
%69 = load i32, i32* %15
%70 = sext i32 %69 to i64
%71 = getelementptr inbounds float, float* %4, i64 %70
%72 = load float, float* %71
%73 = fpext float %72 to double
%74 = getelementptr inbounds float, float* %5, i64 %70
%75 = load float, float* %74
%76 = fpext float %75 to double
%77 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([19 x i8], [19 x i8]* @.str.6, i64 0, i64 0), i32 %69, double %73, double %76)
%78 = load i32, i32* %20
%79 = sext i32 %78 to i64
%80 = getelementptr inbounds float, float* %4, i64 %79
%81 = load float, float* %80
%82 = fpext float %81 to double
%83 = getelementptr inbounds float, float* %5, i64 %79
%84 = load float, float* %83
%85 = fpext float %84 to double
%86 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([19 x i8], [19 x i8]* @.str.6, i64 0, i64 0), i32 %78, double %82, double %85)
%87 = load i32, i32* %25
%88 = sext i32 %87 to i64
%89 = getelementptr inbounds float, float* %4, i64 %88
%90 = load float, float* %89
%91 = fpext float %90 to double
%92 = getelementptr inbounds float, float* %5, i64 %88
%93 = load float, float* %92
%94 = fpext float %93 to double
%95 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([19 x i8], [19 x i8]* @.str.6, i64 0, i64 0), i32 %87, double %91, double %94)
%96 = load i32, i32* %30
%97 = sext i32 %96 to i64
%98 = getelementptr inbounds float, float* %4, i64 %97
%99 = load float, float* %98
%100 = fpext float %99 to double
%101 = getelementptr inbounds float, float* %5, i64 %97
%102 = load float, float* %101
%103 = fpext float %102 to double
%104 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([19 x i8], [19 x i8]* @.str.6, i64 0, i64 0), i32 %96, double %100, double %103)
%105 = load i32, i32* %35
%106 = sext i32 %105 to i64
%107 = getelementptr inbounds float, float* %4, i64 %106
%108 = load float, float* %107
%109 = fpext float %108 to double
%110 = getelementptr inbounds float, float* %5, i64 %106
%111 = load float, float* %110
%112 = fpext float %111 to double
%113 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([19 x i8], [19 x i8]* @.str.6, i64 0, i64 0), i32 %105, double %109, double %112)
%114 = load i32, i32* %40
%115 = sext i32 %114 to i64
%116 = getelementptr inbounds float, float* %4, i64 %115
%117 = load float, float* %116
%118 = fpext float %117 to double
%119 = getelementptr inbounds float, float* %5, i64 %115
%120 = load float, float* %119
%121 = fpext float %120 to double
%122 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([19 x i8], [19 x i8]* @.str.6, i64 0, i64 0), i32 %114, double %118, double %121)
%123 = load i32, i32* %45
%124 = sext i32 %123 to i64
%125 = getelementptr inbounds float, float* %4, i64 %124
%126 = load float, float* %125
%127 = fpext float %126 to double
%128 = getelementptr inbounds float, float* %5, i64 %124
%129 = load float, float* %128
%130 = fpext float %129 to double
%131 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([19 x i8], [19 x i8]* @.str.6, i64 0, i64 0), i32 %123, double %127, double %130)
%132 = load i32, i32* %50
%133 = sext i32 %132 to i64
%134 = getelementptr inbounds float, float* %4, i64 %133
%135 = load float, float* %134
%136 = fpext float %135 to double
%137 = getelementptr inbounds float, float* %5, i64 %133
%138 = load float, float* %137
%139 = fpext float %138 to double
%140 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([19 x i8], [19 x i8]* @.str.6, i64 0, i64 0), i32 %132, double %136, double %139)
%141 = load i32, i32* %55
%142 = sext i32 %141 to i64
%143 = getelementptr inbounds float, float* %4, i64 %142
%144 = load float, float* %143
%145 = fpext float %144 to double
%146 = getelementptr inbounds float, float* %5, i64 %142
%147 = load float, float* %146
%148 = fpext float %147 to double
%149 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([19 x i8], [19 x i8]* @.str.6, i64 0, i64 0), i32 %141, double %145, double %148)
%150 = call i32 @free_vector(float* %5, i32 1, i32 10)
%151 = call i32 @free_vector(float* %4, i32 1, i32 10)
%152 = call i32 @free_ivector(i32* %3, i32 1, i32 10)
ret i32 0
}