#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*/ check_alloc(double *);
int /*<<< orphan*/ exit(int);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *);
int /*<<< orphan*/ free(double *);
scalar_t__ malloc(int);
int /*<<< orphan*/ stderr;
int /*<<< orphan*/ tql2(int *, int *, double *, double *, double *, int *);
int /*<<< orphan*/ tred2(int *, int *, double *, double *, double *, double *);
void my_eigen(double **mat, unsigned long n, double *eig) {
  double *trans, *off, *matarr;
  int ierr, i, j, nm = (int)n;
  check_alloc(trans = (double *)malloc(sizeof(double) * nm * nm));
  check_alloc(matarr = (double *)malloc(sizeof(double) * nm * nm));
  check_alloc(off = (double *)malloc(sizeof(double) * nm));
  for (i = 0; i < nm; i++)
    for (j = 0; j < nm; j++)
      matarr[i + j * nm] = mat[i][j];
  tred2(&nm, &nm, matarr, eig, off, trans);
  tql2(&nm, &nm, eig, off, trans, &ierr);
  if (ierr != 0) {
    fprintf(stderr, "Non converging eigenvalues! Exiting\n");
    exit(23);
  }
  for (i = 0; i < nm; i++)
    for (j = 0; j < nm; j++)
      mat[i][j] = trans[i + nm * j];
  free(trans);
  free(matarr);
  free(off);
}


x86 assembly (clang, -O0):
<my_eigen>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x10(%rbp),%rax
mov    %eax,-0x40(%rbp)
movslq -0x40(%rbp),%rax
shl    $0x3,%rax
movslq -0x40(%rbp),%rcx
imul   %rcx,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,%rdi
mov    %rdi,-0x20(%rbp)
call   1090 <check_alloc@plt>
movslq -0x40(%rbp),%rax
shl    $0x3,%rax
movslq -0x40(%rbp),%rcx
imul   %rcx,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,%rdi
mov    %rdi,-0x30(%rbp)
call   1090 <check_alloc@plt>
movslq -0x40(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,%rdi
mov    %rdi,-0x28(%rbp)
call   1090 <check_alloc@plt>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    1260 <my_eigen+0xf0>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    124d <my_eigen+0xdd>
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    -0x3c(%rbp),%edx
imul   -0x40(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1206 <my_eigen+0x96>
jmp    1252 <my_eigen+0xe2>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    11f3 <my_eigen+0x83>
mov    -0x30(%rbp),%rdx
mov    -0x18(%rbp),%rcx
mov    -0x28(%rbp),%r8
mov    -0x20(%rbp),%r9
lea    -0x40(%rbp),%rsi
mov    %rsi,%rdi
call   1060 <tred2@plt>
mov    -0x18(%rbp),%rdx
mov    -0x28(%rbp),%rcx
mov    -0x20(%rbp),%r8
lea    -0x40(%rbp),%rsi
lea    -0x34(%rbp),%r9
mov    %rsi,%rdi
call   1070 <tql2@plt>
cmpl   $0x0,-0x34(%rbp)
je     12c1 <my_eigen+0x151>
mov    0x2d37(%rip),%rax
mov    (%rax),%edi
lea    0xd4e(%rip),%rsi
call   1040 <fprintf@plt>
mov    $0x17,%edi
call   1080 <exit@plt>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    1335 <my_eigen+0x1c5>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    1322 <my_eigen+0x1b2>
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    -0x40(%rbp),%edx
imul   -0x3c(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    12db <my_eigen+0x16b>
jmp    1327 <my_eigen+0x1b7>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    12c8 <my_eigen+0x158>
mov    -0x20(%rbp),%rdi
call   1030 <free@plt>
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
mov    -0x28(%rbp),%rdi
call   1030 <free@plt>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<my_eigen>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %rdx,0x20(%rsp)
mov    %rsi,%rbp
mov    %rdi,0x18(%rsp)
mov    %ebp,0x4(%rsp)
mov    %ebp,%edi
imul   %ebp,%edi
shl    $0x3,%edi
call   1050 <malloc@plt>
mov    %rax,0x30(%rsp)
mov    %rax,%rdi
call   1090 <check_alloc@plt>
lea    0x0(,%rbp,8),%r12d
mov    %r12d,%edi
imul   %ebp,%edi
call   1050 <malloc@plt>
mov    %rax,0x8(%rsp)
mov    %rax,%rdi
call   1090 <check_alloc@plt>
mov    %r12d,%edi
call   1050 <malloc@plt>
mov    %rax,0x28(%rsp)
mov    %rax,%rdi
call   1090 <check_alloc@plt>
test   %ebp,%ebp
jle    12ea <my_eigen+0x17a>
movslq %ebp,%r8
mov    %r8d,%r9d
lea    -0x1(%r9),%rax
mov    %rax,0x38(%rsp)
mov    %r8d,%esi
and    $0x3,%esi
mov    %r9,0x40(%rsp)
sub    %rsi,%r9
mov    %r8,%r13
shl    $0x4,%r13
mov    %r8,%rbp
shl    $0x5,%rbp
lea    0x0(,%r8,8),%rdx
lea    (%rdx,%rdx,2),%rcx
xor    %r10d,%r10d
mov    0x8(%rsp),%r14
jmp    1243 <my_eigen+0xd3>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r10
add    $0x8,%r14
cmp    0x40(%rsp),%r10
je     12ea <my_eigen+0x17a>
mov    0x18(%rsp),%rax
mov    (%rax,%r10,8),%r12
cmpq   $0x3,0x38(%rsp)
jae    1260 <my_eigen+0xf0>
xor    %r15d,%r15d
jmp    12ae <my_eigen+0x13e>
nopl   0x0(%rax)
mov    %r14,%r11
xor    %r15d,%r15d
cs nopw 0x0(%rax,%rax,1)
movsd  (%r12,%r15,8),%xmm0
movsd  %xmm0,(%r11)
movsd  0x8(%r12,%r15,8),%xmm0
movsd  %xmm0,(%r11,%r8,8)
movsd  0x10(%r12,%r15,8),%xmm0
movsd  %xmm0,(%r11,%r13,1)
movsd  0x18(%r12,%r15,8),%xmm0
movsd  %xmm0,(%r11,%rcx,1)
add    $0x4,%r15
add    %rbp,%r11
cmp    %r15,%r9
jne    1270 <my_eigen+0x100>
test   %rsi,%rsi
je     1230 <my_eigen+0xc0>
mov    %r8,%rax
imul   %r15,%rax
add    %r10,%rax
mov    0x8(%rsp),%rdi
lea    (%rdi,%rax,8),%rbx
lea    (%r12,%r15,8),%rdi
xor    %eax,%eax
movsd  (%rdi,%rax,8),%xmm0
movsd  %xmm0,(%rbx)
add    $0x1,%rax
add    %rdx,%rbx
cmp    %rax,%rsi
jne    12d0 <my_eigen+0x160>
jmp    1230 <my_eigen+0xc0>
lea    0x4(%rsp),%rbp
mov    %rbp,%rdi
mov    %rbp,%rsi
mov    0x8(%rsp),%rdx
mov    0x20(%rsp),%rbx
mov    %rbx,%rcx
mov    0x28(%rsp),%r13
mov    %r13,%r8
mov    0x30(%rsp),%r12
mov    %r12,%r9
call   1060 <tred2@plt>
lea    0x14(%rsp),%r9
mov    %rbp,%rdi
mov    %rbp,%rsi
mov    %rbx,%rdx
mov    %r13,%rcx
mov    %r12,%r8
call   1070 <tql2@plt>
cmpl   $0x0,0x14(%rsp)
jne    1454 <my_eigen+0x2e4>
mov    0x4(%rsp),%r11d
test   %r11d,%r11d
jle    142b <my_eigen+0x2bb>
lea    -0x1(%r11),%r8
mov    %r11d,%edx
and    $0x3,%edx
mov    %r11d,%r15d
and    $0xfffffffc,%r15d
mov    %r11,%r14
shl    $0x4,%r14
mov    %r11,%rax
shl    $0x5,%rax
lea    0x0(,%r11,8),%rbx
lea    (%rbx,%rbx,2),%rcx
xor    %r9d,%r9d
mov    %r12,%r10
jmp    1391 <my_eigen+0x221>
nopl   0x0(%rax)
add    $0x1,%r9
add    $0x8,%r10
cmp    %r11,%r9
je     142b <my_eigen+0x2bb>
mov    0x18(%rsp),%rsi
mov    (%rsi,%r9,8),%rbp
cmp    $0x3,%r8
jae    13b0 <my_eigen+0x240>
xor    %esi,%esi
jmp    13f9 <my_eigen+0x289>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %r10,%rdi
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rdi),%xmm0
movsd  %xmm0,0x0(%rbp,%rsi,8)
movsd  (%rdi,%r11,8),%xmm0
movsd  %xmm0,0x8(%rbp,%rsi,8)
movsd  (%rdi,%r14,1),%xmm0
movsd  %xmm0,0x10(%rbp,%rsi,8)
movsd  (%rdi,%rcx,1),%xmm0
movsd  %xmm0,0x18(%rbp,%rsi,8)
add    $0x4,%rsi
add    %rax,%rdi
cmp    %rsi,%r15
jne    13c0 <my_eigen+0x250>
test   %rdx,%rdx
je     1380 <my_eigen+0x210>
lea    0x0(%rbp,%rsi,8),%rbp
imul   %r11,%rsi
add    %r9,%rsi
lea    (%r12,%rsi,8),%rsi
xor    %edi,%edi
movsd  (%rsi),%xmm0
movsd  %xmm0,0x0(%rbp,%rdi,8)
add    $0x1,%rdi
add    %rbx,%rsi
cmp    %rdi,%rdx
jne    1410 <my_eigen+0x2a0>
jmp    1380 <my_eigen+0x210>
mov    %r12,%rdi
call   1030 <free@plt>
mov    0x8(%rsp),%rdi
call   1030 <free@plt>
mov    %r13,%rdi
call   1030 <free@plt>
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0x2b85(%rip),%rax
mov    (%rax),%edi
lea    0xb9c(%rip),%rsi
call   1040 <fprintf@plt>
mov    $0x17,%edi
call   1080 <exit@plt>

LLVM IR (-O0):
@stderr = global i32 0
@.str = [37 x i8] c"Non converging eigenvalues! Exiting\0A\00"
define void @my_eigen(double** %0, i64 %1, double* %2) {
%4 = alloca double**
%5 = alloca i64
%6 = alloca double*
%7 = alloca double*
%8 = alloca double*
%9 = alloca double*
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
store double** %0, double*** %4
store i64 %1, i64* %5
store double* %2, double** %6
%14 = load i64, i64* %5
%15 = trunc i64 %14 to i32
store i32 %15, i32* %13
%16 = load i32, i32* %13
%17 = sext i32 %16 to i64
%18 = mul i64 8, %17
%19 = load i32, i32* %13
%20 = sext i32 %19 to i64
%21 = mul i64 %18, %20
%22 = trunc i64 %21 to i32
%23 = call i64 @malloc(i32 %22)
%24 = inttoptr i64 %23 to double*
store double* %24, double** %7
%25 = call i32 @check_alloc(double* %24)
%26 = load i32, i32* %13
%27 = sext i32 %26 to i64
%28 = mul i64 8, %27
%29 = load i32, i32* %13
%30 = sext i32 %29 to i64
%31 = mul i64 %28, %30
%32 = trunc i64 %31 to i32
%33 = call i64 @malloc(i32 %32)
%34 = inttoptr i64 %33 to double*
store double* %34, double** %9
%35 = call i32 @check_alloc(double* %34)
%36 = load i32, i32* %13
%37 = sext i32 %36 to i64
%38 = mul i64 8, %37
%39 = trunc i64 %38 to i32
%40 = call i64 @malloc(i32 %39)
%41 = inttoptr i64 %40 to double*
store double* %41, double** %8
%42 = call i32 @check_alloc(double* %41)
store i32 0, i32* %11
br label %43
43: ; preds = %74, %3
%44 = load i32, i32* %11
%45 = load i32, i32* %13
%46 = icmp slt i32 %44, %45
br i1 %46, label %47, label %77
47: ; preds = %43
store i32 0, i32* %12
br label %48
48: ; preds = %70, %47
%49 = load i32, i32* %12
%50 = load i32, i32* %13
%51 = icmp slt i32 %49, %50
br i1 %51, label %52, label %73
52: ; preds = %48
%53 = load double**, double*** %4
%54 = load i32, i32* %11
%55 = sext i32 %54 to i64
%56 = getelementptr inbounds double*, double** %53, i64 %55
%57 = load double*, double** %56
%58 = load i32, i32* %12
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds double, double* %57, i64 %59
%61 = load double, double* %60
%62 = load double*, double** %9
%63 = load i32, i32* %11
%64 = load i32, i32* %12
%65 = load i32, i32* %13
%66 = mul nsw i32 %64, %65
%67 = add nsw i32 %63, %66
%68 = sext i32 %67 to i64
%69 = getelementptr inbounds double, double* %62, i64 %68
store double %61, double* %69
br label %70
70: ; preds = %52
%71 = load i32, i32* %12
%72 = add nsw i32 %71, 1
store i32 %72, i32* %12
br label %48
73: ; preds = %48
br label %74
74: ; preds = %73
%75 = load i32, i32* %11
%76 = add nsw i32 %75, 1
store i32 %76, i32* %11
br label %43
77: ; preds = %43
%78 = load double*, double** %9
%79 = load double*, double** %6
%80 = load double*, double** %8
%81 = load double*, double** %7
%82 = call i32 @tred2(i32* %13, i32* %13, double* %78, double* %79, double* %80, double* %81)
%83 = load double*, double** %6
%84 = load double*, double** %8
%85 = load double*, double** %7
%86 = call i32 @tql2(i32* %13, i32* %13, double* %83, double* %84, double* %85, i32* %10)
%87 = load i32, i32* %10
%88 = icmp ne i32 %87, 0
br i1 %88, label %89, label %93
89: ; preds = %77
%90 = load i32, i32* @stderr
%91 = call i32 @fprintf(i32 %90, i8* getelementptr inbounds ([37 x i8], [37 x i8]* @.str, i64 0, i64 0))
%92 = call i32 @exit(i32 23)
unreachable
93: ; preds = %77
store i32 0, i32* %11
br label %94
94: ; preds = %125, %93
%95 = load i32, i32* %11
%96 = load i32, i32* %13
%97 = icmp slt i32 %95, %96
br i1 %97, label %98, label %128
98: ; preds = %94
store i32 0, i32* %12
br label %99
99: ; preds = %121, %98
%100 = load i32, i32* %12
%101 = load i32, i32* %13
%102 = icmp slt i32 %100, %101
br i1 %102, label %103, label %124
103: ; preds = %99
%104 = load double*, double** %7
%105 = load i32, i32* %11
%106 = load i32, i32* %13
%107 = load i32, i32* %12
%108 = mul nsw i32 %106, %107
%109 = add nsw i32 %105, %108
%110 = sext i32 %109 to i64
%111 = getelementptr inbounds double, double* %104, i64 %110
%112 = load double, double* %111
%113 = load double**, double*** %4
%114 = load i32, i32* %11
%115 = sext i32 %114 to i64
%116 = getelementptr inbounds double*, double** %113, i64 %115
%117 = load double*, double** %116
%118 = load i32, i32* %12
%119 = sext i32 %118 to i64
%120 = getelementptr inbounds double, double* %117, i64 %119
store double %112, double* %120
br label %121
121: ; preds = %103
%122 = load i32, i32* %12
%123 = add nsw i32 %122, 1
store i32 %123, i32* %12
br label %99
124: ; preds = %99
br label %125
125: ; preds = %124
%126 = load i32, i32* %11
%127 = add nsw i32 %126, 1
store i32 %127, i32* %11
br label %94
128: ; preds = %94
%129 = load double*, double** %7
%130 = call i32 @free(double* %129)
%131 = load double*, double** %9
%132 = call i32 @free(double* %131)
%133 = load double*, double** %8
%134 = call i32 @free(double* %133)
ret void
}

LLVM IR (-O2):
@stderr = global i32 0
@.str = [37 x i8] c"Non converging eigenvalues! Exiting\0A\00"
define void @my_eigen(double** nocapture %0, i64 %1, double* %2) {
%4 = alloca i32
%5 = alloca i32
%6 = bitcast i32* %4 to i8*
%7 = bitcast i32* %5 to i8*
%8 = trunc i64 %1 to i32
store i32 %8, i32* %5
%9 = shl i64 %1, 32
%10 = ashr exact i64 %9, 32
%11 = ashr exact i64 %9, 29
%12 = mul i64 %11, %10
%13 = trunc i64 %12 to i32
%14 = tail call i64 @malloc(i32 %13)
%15 = inttoptr i64 %14 to double*
%16 = tail call i32 @check_alloc(double* %15)
%17 = shl i32 %8, 3
%18 = mul i32 %17, %8
%19 = tail call i64 @malloc(i32 %18)
%20 = inttoptr i64 %19 to double*
%21 = tail call i32 @check_alloc(double* %20)
%22 = tail call i64 @malloc(i32 %17)
%23 = inttoptr i64 %22 to double*
%24 = tail call i32 @check_alloc(double* %23)
%25 = icmp sgt i32 %8, 0
br i1 %25, label %26, label %84
26: ; preds = %3
%27 = shl i64 %1, 32
%28 = ashr exact i64 %27, 32
%29 = and i64 %1, 4294967295
%30 = add nsw i64 %29, -1
%31 = and i64 %1, 3
%32 = icmp ult i64 %30, 3
%33 = sub nsw i64 %29, %31
%34 = icmp eq i64 %31, 0
br label %35
35: ; preds = %81, %26
%36 = phi i64 [ 0, %26 ], [ %82, %81 ]
%37 = getelementptr inbounds double*, double** %0, i64 %36
%38 = load double*, double** %37
br i1 %32, label %68, label %39
39: ; preds = %35, %39
%40 = phi i64 [ %65, %39 ], [ 0, %35 ]
%41 = phi i64 [ %66, %39 ], [ 0, %35 ]
%42 = getelementptr inbounds double, double* %38, i64 %40
%43 = load double, double* %42
%44 = mul nsw i64 %40, %28
%45 = add nsw i64 %44, %36
%46 = getelementptr inbounds double, double* %20, i64 %45
store double %43, double* %46
%47 = or i64 %40, 1
%48 = getelementptr inbounds double, double* %38, i64 %47
%49 = load double, double* %48
%50 = mul nsw i64 %47, %28
%51 = add nsw i64 %50, %36
%52 = getelementptr inbounds double, double* %20, i64 %51
store double %49, double* %52
%53 = or i64 %40, 2
%54 = getelementptr inbounds double, double* %38, i64 %53
%55 = load double, double* %54
%56 = mul nsw i64 %53, %28
%57 = add nsw i64 %56, %36
%58 = getelementptr inbounds double, double* %20, i64 %57
store double %55, double* %58
%59 = or i64 %40, 3
%60 = getelementptr inbounds double, double* %38, i64 %59
%61 = load double, double* %60
%62 = mul nsw i64 %59, %28
%63 = add nsw i64 %62, %36
%64 = getelementptr inbounds double, double* %20, i64 %63
store double %61, double* %64
%65 = add nuw nsw i64 %40, 4
%66 = add i64 %41, 4
%67 = icmp eq i64 %66, %33
br i1 %67, label %68, label %39
68: ; preds = %39, %35
%69 = phi i64 [ 0, %35 ], [ %65, %39 ]
br i1 %34, label %81, label %70
70: ; preds = %68, %70
%71 = phi i64 [ %78, %70 ], [ %69, %68 ]
%72 = phi i64 [ %79, %70 ], [ 0, %68 ]
%73 = getelementptr inbounds double, double* %38, i64 %71
%74 = load double, double* %73
%75 = mul nsw i64 %71, %28
%76 = add nsw i64 %75, %36
%77 = getelementptr inbounds double, double* %20, i64 %76
store double %74, double* %77
%78 = add nuw nsw i64 %71, 1
%79 = add i64 %72, 1
%80 = icmp eq i64 %79, %31
br i1 %80, label %81, label %70
81: ; preds = %70, %68
%82 = add nuw nsw i64 %36, 1
%83 = icmp eq i64 %82, %29
br i1 %83, label %84, label %35
84: ; preds = %81, %3
%85 = call i32 @tred2(i32* %5, i32* %5, double* %20, double* %2, double* %23, double* %15)
%86 = call i32 @tql2(i32* %5, i32* %5, double* %2, double* %23, double* %15, i32* %4)
%87 = load i32, i32* %4
%88 = icmp eq i32 %87, 0
br i1 %88, label %89, label %100
89: ; preds = %84
%90 = load i32, i32* %5
%91 = icmp sgt i32 %90, 0
br i1 %91, label %92, label %153
92: ; preds = %89
%93 = zext i32 %90 to i64
%94 = zext i32 %90 to i64
%95 = add nsw i64 %94, -1
%96 = and i64 %94, 3
%97 = icmp ult i64 %95, 3
%98 = and i64 %94, 4294967292
%99 = icmp eq i64 %96, 0
br label %104
100: ; preds = %84
%101 = load i32, i32* @stderr
%102 = call i32 @fprintf(i32 %101, i8* getelementptr inbounds ([37 x i8], [37 x i8]* @.str, i64 0, i64 0))
%103 = call i32 @exit(i32 23)
unreachable
104: ; preds = %150, %92
%105 = phi i64 [ 0, %92 ], [ %151, %150 ]
%106 = getelementptr inbounds double*, double** %0, i64 %105
%107 = load double*, double** %106
br i1 %97, label %137, label %108
108: ; preds = %104, %108
%109 = phi i64 [ %134, %108 ], [ 0, %104 ]
%110 = phi i64 [ %135, %108 ], [ 0, %104 ]
%111 = mul nsw i64 %109, %93
%112 = add nuw nsw i64 %111, %105
%113 = getelementptr inbounds double, double* %15, i64 %112
%114 = load double, double* %113
%115 = getelementptr inbounds double, double* %107, i64 %109
store double %114, double* %115
%116 = or i64 %109, 1
%117 = mul nsw i64 %116, %93
%118 = add nuw nsw i64 %117, %105
%119 = getelementptr inbounds double, double* %15, i64 %118
%120 = load double, double* %119
%121 = getelementptr inbounds double, double* %107, i64 %116
store double %120, double* %121
%122 = or i64 %109, 2
%123 = mul nsw i64 %122, %93
%124 = add nuw nsw i64 %123, %105
%125 = getelementptr inbounds double, double* %15, i64 %124
%126 = load double, double* %125
%127 = getelementptr inbounds double, double* %107, i64 %122
store double %126, double* %127
%128 = or i64 %109, 3
%129 = mul nsw i64 %128, %93
%130 = add nuw nsw i64 %129, %105
%131 = getelementptr inbounds double, double* %15, i64 %130
%132 = load double, double* %131
%133 = getelementptr inbounds double, double* %107, i64 %128
store double %132, double* %133
%134 = add nuw nsw i64 %109, 4
%135 = add i64 %110, 4
%136 = icmp eq i64 %135, %98
br i1 %136, label %137, label %108
137: ; preds = %108, %104
%138 = phi i64 [ 0, %104 ], [ %134, %108 ]
br i1 %99, label %150, label %139
139: ; preds = %137, %139
%140 = phi i64 [ %147, %139 ], [ %138, %137 ]
%141 = phi i64 [ %148, %139 ], [ 0, %137 ]
%142 = mul nsw i64 %140, %93
%143 = add nuw nsw i64 %142, %105
%144 = getelementptr inbounds double, double* %15, i64 %143
%145 = load double, double* %144
%146 = getelementptr inbounds double, double* %107, i64 %140
store double %145, double* %146
%147 = add nuw nsw i64 %140, 1
%148 = add i64 %141, 1
%149 = icmp eq i64 %148, %96
br i1 %149, label %150, label %139
150: ; preds = %139, %137
%151 = add nuw nsw i64 %105, 1
%152 = icmp eq i64 %151, %94
br i1 %152, label %153, label %104
153: ; preds = %150, %89
%154 = call i32 @free(double* %15)
%155 = call i32 @free(double* %20)
%156 = call i32 @free(double* %23)
ret void
}