#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 */
unsigned int atoi(char *);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *);
int /*<<< orphan*/ free(double **);
scalar_t__ malloc(unsigned int);
int /*<<< orphan*/ matrixMult(double **, double **, double **, unsigned int);
int /*<<< orphan*/ stderr;
int main(int argc, char *argv[]) {
  unsigned int i, j, N;
  double **A;
  double **B;
  double **C;
  if (argc == 2) {
    N = atoi(argv[1]);
  } else {
    fprintf(stderr, "Sorry, I need matrix width as command line argument\n");
    return 1;
  }
  A = (double **)malloc(N * sizeof(double *));
  B = (double **)malloc(N * sizeof(double *));
  C = (double **)malloc(N * sizeof(double *));
  for (i = 0; i < N; ++i) {
    A[i] = (double *)malloc(N * sizeof(double));
    B[i] = (double *)malloc(N * sizeof(double));
    C[i] = (double *)malloc(N * sizeof(double));
  }
  for (i = 0; i < N; ++i) {
    for (j = 0; j < N; ++j) {
      A[i][j] = 2.0;
      B[i][j] = (double)N * j + i;
    }
  }
  matrixMult(A, B, C, N);
  free(A);
  free(B);
  free(C);
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
movl   $0x0,-0x4(%rbp)
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
cmpl   $0x2,-0x8(%rbp)
jne    1185 <main+0x35>
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rdi
call   1070 <atoi@plt>
mov    %eax,-0x1c(%rbp)
jmp    11a6 <main+0x56>
mov    0x2e54(%rip),%rax
mov    (%rax),%edi
lea    0xe6b(%rip),%rsi
call   1050 <fprintf@plt>
movl   $0x1,-0x4(%rbp)
jmp    131d <main+0x1cd>
mov    -0x1c(%rbp),%eax
shl    $0x3,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x28(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x3,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x30(%rbp)
mov    -0x1c(%rbp),%eax
shl    $0x3,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,-0x38(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jae    1251 <main+0x101>
mov    -0x1c(%rbp),%eax
shl    $0x3,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,%rdx
mov    -0x28(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    %rdx,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
shl    $0x3,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,%rdx
mov    -0x30(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    %rdx,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
shl    $0x3,%rax
mov    %eax,%edi
call   1060 <malloc@plt>
mov    %rax,%rdx
mov    -0x38(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    %rdx,(%rax,%rcx,8)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    11e3 <main+0x93>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jae    12e7 <main+0x197>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jae    12d4 <main+0x184>
mov    -0x28(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x18(%rbp),%ecx
movabs $0x4000000000000000,%rdx
mov    %rdx,(%rax,%rcx,8)
mov    -0x1c(%rbp),%eax
cvtsi2sd %rax,%xmm0
mov    -0x18(%rbp),%eax
cvtsi2sd %rax,%xmm2
mov    -0x14(%rbp),%eax
cvtsi2sd %rax,%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x30(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x18(%rbp),%ecx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    126b <main+0x11b>
jmp    12d9 <main+0x189>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1258 <main+0x108>
mov    -0x28(%rbp),%rdi
mov    -0x30(%rbp),%rsi
mov    -0x38(%rbp),%rdx
mov    -0x1c(%rbp),%ecx
call   1040 <matrixMult@plt>
mov    -0x28(%rbp),%rdi
call   1030 <free@plt>
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
cmp    $0x2,%edi
jne    1497 <main+0x347>
mov    0x8(%rsi),%rdi
call   1070 <atoi@plt>
mov    %eax,%ebx
lea    0x0(,%rbx,8),%ebp
mov    %ebp,%edi
call   1060 <malloc@plt>
mov    %rax,%r15
mov    %ebp,%edi
call   1060 <malloc@plt>
mov    %rax,%r13
mov    %ebp,%edi
call   1060 <malloc@plt>
mov    %rbx,%rcx
mov    %rax,%r12
test   %ecx,%ecx
je     14b3 <main+0x363>
mov    %rcx,(%rsp)
mov    %ecx,%ebx
xor    %r14d,%r14d
nopl   0x0(%rax,%rax,1)
mov    %ebp,%edi
call   1060 <malloc@plt>
mov    %rax,(%r15,%r14,8)
mov    %ebp,%edi
call   1060 <malloc@plt>
mov    %rax,0x0(%r13,%r14,8)
mov    %ebp,%edi
call   1060 <malloc@plt>
mov    %rax,(%r12,%r14,8)
add    $0x1,%r14
cmp    %r14,%rbx
jne    11b0 <main+0x60>
mov    (%rsp),%rcx
test   %ecx,%ecx
je     14b3 <main+0x363>
cvtsi2sd %rbx,%xmm0
mov    %ebx,%r10d
and    $0xfffffffc,%r10d
add    $0xfffffffffffffffc,%r10
mov    %r10,0x10(%rsp)
shr    $0x2,%r10
add    $0x1,%r10
mov    %ebx,%r11d
and    $0xfffffffc,%r11d
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
mov    %r10,%rax
and    $0xfffffffffffffffe,%rax
mov    %rax,0x8(%rsp)
mov    %rbx,%r14
neg    %r14
xor    %ebp,%ebp
movabs $0x4000000000000000,%rsi
movdqa 0xdc6(%rip),%xmm8
movdqa 0xdcd(%rip),%xmm12
movaps 0xdd5(%rip),%xmm13
pxor   %xmm14,%xmm14
movdqa 0xdd8(%rip),%xmm6
movdqa 0xddf(%rip),%xmm9
movdqa 0xde6(%rip),%xmm10
movdqa 0xded(%rip),%xmm11
jmp    128d <main+0x13d>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rbp
cmp    %rbx,%rbp
je     14b3 <main+0x363>
mov    (%r15,%rbp,8),%rax
mov    %ebp,%edx
xorps  %xmm7,%xmm7
cvtsi2sd %rdx,%xmm7
mov    0x0(%r13,%rbp,8),%r9
cmp    $0x4,%ecx
jb     12bf <main+0x16f>
lea    (%r9,%rbx,8),%rdx
cmp    %rdx,%rax
jae    1350 <main+0x200>
lea    (%rax,%rbx,8),%rdx
cmp    %rdx,%r9
jae    1350 <main+0x200>
xor    %edi,%edi
mov    %rdi,%rdx
test   $0x1,%bl
je     12ea <main+0x19a>
mov    %rsi,(%rax,%rdi,8)
xorps  %xmm2,%xmm2
cvtsi2sd %rdi,%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm7,%xmm2
movsd  %xmm2,(%r9,%rdi,8)
mov    %rdi,%rdx
or     $0x1,%rdx
not    %rdi
cmp    %r14,%rdi
je     1280 <main+0x130>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %rsi,(%rax,%rdx,8)
mov    %edx,%edi
xorps  %xmm2,%xmm2
cvtsi2sd %rdi,%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm7,%xmm2
movsd  %xmm2,(%r9,%rdx,8)
mov    %rsi,0x8(%rax,%rdx,8)
lea    0x1(%rdx),%edi
xorps  %xmm2,%xmm2
cvtsi2sd %rdi,%xmm2
mulsd  %xmm0,%xmm2
addsd  %xmm7,%xmm2
movsd  %xmm2,0x8(%r9,%rdx,8)
add    $0x2,%rdx
cmp    %rbx,%rdx
jne    1300 <main+0x1b0>
jmp    1280 <main+0x130>
nopl   0x0(%rax)
movapd %xmm7,%xmm2
unpcklpd %xmm7,%xmm2
cmpq   $0x0,0x10(%rsp)
je     142a <main+0x2da>
mov    0x8(%rsp),%r8
xor    %edx,%edx
movdqa %xmm8,%xmm5
movdqa %xmm5,%xmm3
paddd  %xmm12,%xmm3
movups %xmm13,(%rax,%rdx,8)
movups %xmm13,0x10(%rax,%rdx,8)
movdqa %xmm5,%xmm4
punpckldq %xmm14,%xmm4
por    %xmm6,%xmm4
subpd  %xmm6,%xmm4
punpckldq %xmm14,%xmm3
por    %xmm6,%xmm3
subpd  %xmm6,%xmm3
mulpd  %xmm1,%xmm4
addpd  %xmm2,%xmm4
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm4,(%r9,%rdx,8)
movupd %xmm3,0x10(%r9,%rdx,8)
movdqa %xmm5,%xmm3
paddd  %xmm9,%xmm3
movdqa %xmm5,%xmm4
paddd  %xmm10,%xmm4
movups %xmm13,0x20(%rax,%rdx,8)
movups %xmm13,0x30(%rax,%rdx,8)
punpckldq %xmm14,%xmm3
por    %xmm6,%xmm3
subpd  %xmm6,%xmm3
punpckldq %xmm14,%xmm4
por    %xmm6,%xmm4
subpd  %xmm6,%xmm4
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
mulpd  %xmm1,%xmm4
addpd  %xmm2,%xmm4
movupd %xmm3,0x20(%r9,%rdx,8)
movupd %xmm4,0x30(%r9,%rdx,8)
add    $0x8,%rdx
paddd  %xmm11,%xmm5
add    $0xfffffffffffffffe,%r8
jne    1370 <main+0x220>
jmp    1431 <main+0x2e1>
xor    %edx,%edx
movdqa %xmm8,%xmm5
test   $0x1,%r10b
mov    (%rsp),%rcx
je     1486 <main+0x336>
movdqa %xmm5,%xmm3
paddd  %xmm12,%xmm3
movups %xmm13,(%rax,%rdx,8)
movups %xmm13,0x10(%rax,%rdx,8)
punpckldq %xmm14,%xmm5
por    %xmm6,%xmm5
subpd  %xmm6,%xmm5
punpckldq %xmm14,%xmm3
por    %xmm6,%xmm3
subpd  %xmm6,%xmm3
mulpd  %xmm1,%xmm5
addpd  %xmm2,%xmm5
mulpd  %xmm1,%xmm3
addpd  %xmm2,%xmm3
movupd %xmm5,(%r9,%rdx,8)
movupd %xmm3,0x10(%r9,%rdx,8)
mov    %r11,%rdi
cmp    %rbx,%r11
je     1280 <main+0x130>
jmp    12c1 <main+0x171>
mov    0x2b42(%rip),%rax
mov    (%rax),%edi
lea    0xbc9(%rip),%rsi
call   1050 <fprintf@plt>
mov    $0x1,%eax
jmp    14db <main+0x38b>
mov    %r15,%rdi
mov    %r13,%rsi
mov    %r12,%rdx
call   1040 <matrixMult@plt>
mov    %r15,%rdi
call   1030 <free@plt>
mov    %r13,%rdi
call   1030 <free@plt>
mov    %r12,%rdi
call   1030 <free@plt>
xor    %eax,%eax
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@stderr = global i32 0
@.str = [53 x i8] c"Sorry, I need matrix width as command line argument\0A\00"
define i32 @main(i32 %0, i8** nocapture %1) {
%3 = icmp eq i32 %0, 2
br i1 %3, label %4, label %18
4: ; preds = %2
%5 = getelementptr inbounds i8*, i8** %1, i64 1
%6 = load i8*, i8** %5
%7 = tail call i32 @atoi(i8* %6)
%8 = shl i32 %7, 3
%9 = tail call i64 @malloc(i32 %8)
%10 = inttoptr i64 %9 to double**
%11 = tail call i64 @malloc(i32 %8)
%12 = inttoptr i64 %11 to double**
%13 = tail call i64 @malloc(i32 %8)
%14 = inttoptr i64 %13 to double**
%15 = icmp eq i32 %7, 0
br i1 %15, label %160, label %16
16: ; preds = %4
%17 = zext i32 %7 to i64
br label %43
18: ; preds = %2
%19 = load i32, i32* @stderr
%20 = tail call i32 @fprintf(i32 %19, i8* getelementptr inbounds ([53 x i8], [53 x i8]* @.str, i64 0, i64 0))
br label %165
21: ; preds = %43
br i1 %15, label %160, label %22
22: ; preds = %21
%23 = uitofp i32 %7 to double
%24 = zext i32 %7 to i64
%25 = and i64 %24, 4294967292
%26 = add nsw i64 %25, -4
%27 = lshr exact i64 %26, 2
%28 = add nuw nsw i64 %27, 1
%29 = icmp ult i32 %7, 4
%30 = and i64 %17, 4294967292
%31 = insertelement <2 x double> poison, double %23, i64 0
%32 = shufflevector <2 x double> %31, <2 x double> poison, <2 x i32> zeroinitializer
%33 = insertelement <2 x double> poison, double %23, i64 0
%34 = shufflevector <2 x double> %33, <2 x double> poison, <2 x i32> zeroinitializer
%35 = and i64 %28, 1
%36 = icmp eq i64 %26, 0
%37 = and i64 %28, 9223372036854775806
%38 = icmp eq i64 %35, 0
%39 = icmp eq i64 %30, %17
%40 = and i64 %24, 1
%41 = icmp eq i64 %40, 0
%42 = sub nsw i64 0, %24
br label %56
43: ; preds = %16, %43
%44 = phi i64 [ 0, %16 ], [ %54, %43 ]
%45 = tail call i64 @malloc(i32 %8)
%46 = inttoptr i64 %45 to double*
%47 = getelementptr inbounds double*, double** %10, i64 %44
store double* %46, double** %47
%48 = tail call i64 @malloc(i32 %8)
%49 = inttoptr i64 %48 to double*
%50 = getelementptr inbounds double*, double** %12, i64 %44
store double* %49, double** %50
%51 = tail call i64 @malloc(i32 %8)
%52 = inttoptr i64 %51 to double*
%53 = getelementptr inbounds double*, double** %14, i64 %44
store double* %52, double** %53
%54 = add nuw nsw i64 %44, 1
%55 = icmp eq i64 %54, %17
br i1 %55, label %21, label %43
56: ; preds = %22, %157
%57 = phi i64 [ 0, %22 ], [ %158, %157 ]
%58 = getelementptr inbounds double*, double** %10, i64 %57
%59 = load double*, double** %58
%60 = trunc i64 %57 to i32
%61 = uitofp i32 %60 to double
%62 = getelementptr inbounds double*, double** %12, i64 %57
%63 = load double*, double** %62
br i1 %29, label %129, label %64
64: ; preds = %56
%65 = getelementptr double, double* %59, i64 %17
%66 = getelementptr double, double* %63, i64 %17
%67 = icmp ult double* %59, %66
%68 = icmp ult double* %63, %65
%69 = and i1 %67, %68
br i1 %69, label %129, label %70
70: ; preds = %64
%71 = insertelement <2 x double> poison, double %61, i64 0
%72 = shufflevector <2 x double> %71, <2 x double> poison, <2 x i32> zeroinitializer
%73 = insertelement <2 x double> poison, double %61, i64 0
%74 = shufflevector <2 x double> %73, <2 x double> poison, <2 x i32> zeroinitializer
br i1 %36, label %111, label %75
75: ; preds = %70, %75
%76 = phi i64 [ %107, %75 ], [ 0, %70 ]
%77 = phi <2 x i32> [ %108, %75 ], [ <i32 0, i32 1>, %70 ]
%78 = phi i64 [ %109, %75 ], [ 0, %70 ]
%79 = add <2 x i32> %77, <i32 2, i32 2>
%80 = getelementptr inbounds double, double* %59, i64 %76
%81 = bitcast double* %80 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %81
%82 = getelementptr inbounds double, double* %80, i64 2
%83 = bitcast double* %82 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %83
%84 = uitofp <2 x i32> %77 to <2 x double>
%85 = uitofp <2 x i32> %79 to <2 x double>
%86 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %32, <2 x double> %84, <2 x double> %72)
%87 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %34, <2 x double> %85, <2 x double> %74)
%88 = getelementptr inbounds double, double* %63, i64 %76
%89 = bitcast double* %88 to <2 x double>*
store <2 x double> %86, <2 x double>* %89
%90 = getelementptr inbounds double, double* %88, i64 2
%91 = bitcast double* %90 to <2 x double>*
store <2 x double> %87, <2 x double>* %91
%92 = or i64 %76, 4
%93 = add <2 x i32> %77, <i32 4, i32 4>
%94 = add <2 x i32> %77, <i32 6, i32 6>
%95 = getelementptr inbounds double, double* %59, i64 %92
%96 = bitcast double* %95 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %96
%97 = getelementptr inbounds double, double* %95, i64 2
%98 = bitcast double* %97 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %98
%99 = uitofp <2 x i32> %93 to <2 x double>
%100 = uitofp <2 x i32> %94 to <2 x double>
%101 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %32, <2 x double> %99, <2 x double> %72)
%102 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %34, <2 x double> %100, <2 x double> %74)
%103 = getelementptr inbounds double, double* %63, i64 %92
%104 = bitcast double* %103 to <2 x double>*
store <2 x double> %101, <2 x double>* %104
%105 = getelementptr inbounds double, double* %103, i64 2
%106 = bitcast double* %105 to <2 x double>*
store <2 x double> %102, <2 x double>* %106
%107 = add nuw i64 %76, 8
%108 = add <2 x i32> %77, <i32 8, i32 8>
%109 = add i64 %78, 2
%110 = icmp eq i64 %109, %37
br i1 %110, label %111, label %75
111: ; preds = %75, %70
%112 = phi i64 [ 0, %70 ], [ %107, %75 ]
%113 = phi <2 x i32> [ <i32 0, i32 1>, %70 ], [ %108, %75 ]
br i1 %38, label %128, label %114
114: ; preds = %111
%115 = add <2 x i32> %113, <i32 2, i32 2>
%116 = getelementptr inbounds double, double* %59, i64 %112
%117 = bitcast double* %116 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %117
%118 = getelementptr inbounds double, double* %116, i64 2
%119 = bitcast double* %118 to <2 x double>*
store <2 x double> <double 2.000000e+00, double 2.000000e+00>, <2 x double>* %119
%120 = uitofp <2 x i32> %113 to <2 x double>
%121 = uitofp <2 x i32> %115 to <2 x double>
%122 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %32, <2 x double> %120, <2 x double> %72)
%123 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %34, <2 x double> %121, <2 x double> %74)
%124 = getelementptr inbounds double, double* %63, i64 %112
%125 = bitcast double* %124 to <2 x double>*
store <2 x double> %122, <2 x double>* %125
%126 = getelementptr inbounds double, double* %124, i64 2
%127 = bitcast double* %126 to <2 x double>*
store <2 x double> %123, <2 x double>* %127
br label %128
128: ; preds = %111, %114
br i1 %39, label %157, label %129
129: ; preds = %64, %56, %128
%130 = phi i64 [ 0, %64 ], [ 0, %56 ], [ %30, %128 ]
%131 = xor i64 %130, -1
br i1 %41, label %139, label %132
132: ; preds = %129
%133 = getelementptr inbounds double, double* %59, i64 %130
store double 2.000000e+00, double* %133
%134 = trunc i64 %130 to i32
%135 = uitofp i32 %134 to double
%136 = tail call double @llvm.fmuladd.f64(double %23, double %135, double %61)
%137 = getelementptr inbounds double, double* %63, i64 %130
store double %136, double* %137
%138 = or i64 %130, 1
br label %139
139: ; preds = %132, %129
%140 = phi i64 [ %130, %129 ], [ %138, %132 ]
%141 = icmp eq i64 %131, %42
br i1 %141, label %157, label %142
142: ; preds = %139, %142
%143 = phi i64 [ %155, %142 ], [ %140, %139 ]
%144 = getelementptr inbounds double, double* %59, i64 %143
store double 2.000000e+00, double* %144
%145 = trunc i64 %143 to i32
%146 = uitofp i32 %145 to double
%147 = tail call double @llvm.fmuladd.f64(double %23, double %146, double %61)
%148 = getelementptr inbounds double, double* %63, i64 %143
store double %147, double* %148
%149 = add nuw nsw i64 %143, 1
%150 = getelementptr inbounds double, double* %59, i64 %149
store double 2.000000e+00, double* %150
%151 = trunc i64 %149 to i32
%152 = uitofp i32 %151 to double
%153 = tail call double @llvm.fmuladd.f64(double %23, double %152, double %61)
%154 = getelementptr inbounds double, double* %63, i64 %149
store double %153, double* %154
%155 = add nuw nsw i64 %143, 2
%156 = icmp eq i64 %155, %24
br i1 %156, label %157, label %142
157: ; preds = %139, %142, %128
%158 = add nuw nsw i64 %57, 1
%159 = icmp eq i64 %158, %24
br i1 %159, label %160, label %56
160: ; preds = %157, %4, %21
%161 = tail call i32 @matrixMult(double** %10, double** %12, double** %14, i32 %7)
%162 = tail call i32 @free(double** %10)
%163 = tail call i32 @free(double** %12)
%164 = tail call i32 @free(double** %14)
br label %165
165: ; preds = %160, %18
%166 = phi i32 [ 0, %160 ], [ 1, %18 ]
ret i32 %166
}