void convolution_3_x_3(float **matrix, float **kernel, float **out, int size) {
  int i, j;
  float sum;
  float zeropad[224 + 2][224 + 2] = {0.0};
  for (i = 0; i < size; i++) {
    for (j = 0; j < size; j++) {
      zeropad[i + 1][j + 1] = matrix[i][j];
    }
  }
  for (i = 0; i < size; i++) {
    for (j = 0; j < size; j++) {
      sum = zeropad[i][j] * kernel[0][0] + zeropad[i + 1][j] * kernel[1][0] +
            zeropad[i + 2][j] * kernel[2][0] +
            zeropad[i][j + 1] * kernel[0][1] +
            zeropad[i + 1][j + 1] * kernel[1][1] +
            zeropad[i + 2][j + 1] * kernel[2][1] +
            zeropad[i][j + 2] * kernel[0][2] +
            zeropad[i + 1][j + 2] * kernel[1][2] +
            zeropad[i + 2][j + 2] * kernel[2][2];
      out[i][j] += sum;
    }
  }
}


x86 assembly (clang, -O0):
<convolution_3_x_3>:
push   %rbp
mov    %rsp,%rbp
sub    $0x31e40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
lea    -0x31e40(%rbp),%rdi
xor    %esi,%esi
mov    $0x31e10,%edx
call   1030 <memset@plt>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    11c1 <convolution_3_x_3+0xb1>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    11ae <convolution_3_x_3+0x9e>
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x31e40(%rbp),%rax
imul   $0x388,%rcx,%rcx
add    %rcx,%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1157 <convolution_3_x_3+0x47>
jmp    11b3 <convolution_3_x_3+0xa3>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1144 <convolution_3_x_3+0x34>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1425 <convolution_3_x_3+0x315>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    1412 <convolution_3_x_3+0x302>
movslq -0x20(%rbp),%rcx
lea    -0x31e40(%rbp),%rax
imul   $0x388,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movss  (%rax),%xmm2
mov    -0x20(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x31e40(%rbp),%rax
imul   $0x388,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
mulss  (%rax),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x20(%rbp),%eax
add    $0x2,%eax
movslq %eax,%rcx
lea    -0x31e40(%rbp),%rax
imul   $0x388,%rcx,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
movss  (%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movslq -0x20(%rbp),%rcx
lea    -0x31e40(%rbp),%rax
imul   $0x388,%rcx,%rcx
add    %rcx,%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movss  0x4(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x20(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x31e40(%rbp),%rax
imul   $0x388,%rcx,%rcx
add    %rcx,%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
movss  0x4(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x20(%rbp),%eax
add    $0x2,%eax
movslq %eax,%rcx
lea    -0x31e40(%rbp),%rax
imul   $0x388,%rcx,%rcx
add    %rcx,%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
movss  0x4(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
movslq -0x20(%rbp),%rcx
lea    -0x31e40(%rbp),%rax
imul   $0x388,%rcx,%rcx
add    %rcx,%rax
mov    -0x24(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x20(%rbp),%eax
add    $0x1,%eax
movslq %eax,%rcx
lea    -0x31e40(%rbp),%rax
imul   $0x388,%rcx,%rcx
add    %rcx,%rax
mov    -0x24(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x20(%rbp),%eax
add    $0x2,%eax
movslq %eax,%rcx
lea    -0x31e40(%rbp),%rax
imul   $0x388,%rcx,%rcx
add    %rcx,%rax
mov    -0x24(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
movss  0x8(%rax),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x28(%rbp)
movss  -0x28(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11db <convolution_3_x_3+0xcb>
jmp    1417 <convolution_3_x_3+0x307>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    11c8 <convolution_3_x_3+0xb8>
add    $0x31e40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<convolution_3_x_3>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x31e38,%rsp
mov    %ecx,%r15d
mov    %rdx,%r14
mov    %rsi,%rbx
mov    %rdi,%rbp
lea    0x20(%rsp),%rdi
mov    $0x31e10,%edx
xor    %esi,%esi
call   1030 <memset@plt>
test   %r15d,%r15d
jle    132c <convolution_3_x_3+0x20c>
mov    %rbx,0x10(%rsp)
mov    %r14,0x18(%rsp)
mov    %r15d,%r14d
lea    0x0(,%r14,4),%rbx
mov    %r15d,0xc(%rsp)
cmp    $0x1,%r15d
jne    117c <convolution_3_x_3+0x5c>
xor    %r15d,%r15d
jmp    11c5 <convolution_3_x_3+0xa5>
mov    %r14d,%r13d
and    $0xfffffffe,%r13d
lea    0x734(%rsp),%r12
xor    %r15d,%r15d
xchg   %ax,%ax
lea    -0x388(%r12),%rdi
ff
mov    0x0(%rbp,%r15,8),%rsi
mov    %rbx,%rdx
call   1040 <memcpy@plt>
mov    0x8(%rbp,%r15,8),%rsi
add    $0x2,%r15
mov    %r12,%rdi
mov    %rbx,%rdx
call   1040 <memcpy@plt>
add    $0x710,%r12
cmp    %r15,%r13
jne    1190 <convolution_3_x_3+0x70>
test   $0x1,%r14b
je     11ef <convolution_3_x_3+0xcf>
imul   $0x388,%r15,%rax
lea    0x20(%rsp),%rcx
lea    (%rax,%rcx,1),%rdi
add    $0x38c,%rdi
mov    0x0(%rbp,%r15,8),%rsi
mov    %rbx,%rdx
call   1040 <memcpy@plt>
cmpl   $0x0,0xc(%rsp)
mov    0x18(%rsp),%r9
mov    0x10(%rsp),%rdx
jle    132c <convolution_3_x_3+0x20c>
mov    (%rdx),%rax
mov    0x8(%rdx),%rcx
mov    0x10(%rdx),%rdx
lea    0x738(%rsp),%rsi
xor    %edi,%edi
nopl   0x0(%rax)
mov    (%r9,%rdi,8),%r8
imul   $0x388,%rdi,%rbx
add    $0x1,%rdi
movss  0x20(%rsp,%rbx,1),%xmm7
movss  0x24(%rsp,%rbx,1),%xmm0
movss  0x3a8(%rsp,%rbx,1),%xmm2
movss  0x730(%rsp,%rbx,1),%xmm6
movss  0x3ac(%rsp,%rbx,1),%xmm3
movss  0x734(%rsp,%rbx,1),%xmm5
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mulss  (%rcx),%xmm2
mulss  (%rax),%xmm7
movaps %xmm0,%xmm8
movaps %xmm3,%xmm9
movaps %xmm5,%xmm4
addss  %xmm2,%xmm7
mulss  (%rdx),%xmm6
addss  %xmm7,%xmm6
movss  0x4(%rax),%xmm0
mulss  %xmm8,%xmm0
addss  %xmm6,%xmm0
movss  0x4(%rcx),%xmm2
mulss  %xmm3,%xmm2
addss  %xmm0,%xmm2
movss  0x4(%rdx),%xmm3
mulss  %xmm5,%xmm3
addss  %xmm2,%xmm3
movss  -0x710(%rsi,%rbp,4),%xmm0
ff ff
movss  0x8(%rax),%xmm2
mulss  %xmm0,%xmm2
addss  %xmm3,%xmm2
movss  -0x388(%rsi,%rbp,4),%xmm3
ff ff
movss  0x8(%rcx),%xmm6
mulss  %xmm3,%xmm6
addss  %xmm2,%xmm6
movss  (%rsi,%rbp,4),%xmm5
movss  0x8(%rdx),%xmm1
mulss  %xmm5,%xmm1
addss  %xmm6,%xmm1
addss  (%r8,%rbp,4),%xmm1
movaps %xmm4,%xmm6
movaps %xmm9,%xmm2
movaps %xmm8,%xmm7
movss  %xmm1,(%r8,%rbp,4)
lea    0x1(%rbp),%rbx
mov    %rbx,%rbp
cmp    %rbx,%r14
jne    1270 <convolution_3_x_3+0x150>
add    $0x388,%rsi
cmp    %r14,%rdi
jne    1220 <convolution_3_x_3+0x100>
add    $0x31e38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @convolution_3_x_3(float** %0, float** %1, float** %2, i32 %3) {
%5 = alloca float**
%6 = alloca float**
%7 = alloca float**
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca float
%12 = alloca [226 x [226 x float]]
store float** %0, float*** %5
store float** %1, float*** %6
store float** %2, float*** %7
store i32 %3, i32* %8
%13 = bitcast [226 x [226 x float]]* %12 to i8*
store i32 0, i32* %9
br label %14
14: ; preds = %45, %4
%15 = load i32, i32* %9
%16 = load i32, i32* %8
%17 = icmp slt i32 %15, %16
br i1 %17, label %18, label %48
18: ; preds = %14
store i32 0, i32* %10
br label %19
19: ; preds = %41, %18
%20 = load i32, i32* %10
%21 = load i32, i32* %8
%22 = icmp slt i32 %20, %21
br i1 %22, label %23, label %44
23: ; preds = %19
%24 = load float**, float*** %5
%25 = load i32, i32* %9
%26 = sext i32 %25 to i64
%27 = getelementptr inbounds float*, float** %24, i64 %26
%28 = load float*, float** %27
%29 = load i32, i32* %10
%30 = sext i32 %29 to i64
%31 = getelementptr inbounds float, float* %28, i64 %30
%32 = load float, float* %31
%33 = load i32, i32* %9
%34 = add nsw i32 %33, 1
%35 = sext i32 %34 to i64
%36 = getelementptr inbounds [226 x [226 x float]], [226 x [226 x float]]* %12, i64 0, i64 %35
%37 = load i32, i32* %10
%38 = add nsw i32 %37, 1
%39 = sext i32 %38 to i64
%40 = getelementptr inbounds [226 x float], [226 x float]* %36, i64 0, i64 %39
store float %32, float* %40
br label %41
41: ; preds = %23
%42 = load i32, i32* %10
%43 = add nsw i32 %42, 1
store i32 %43, i32* %10
br label %19
44: ; preds = %19
br label %45
45: ; preds = %44
%46 = load i32, i32* %9
%47 = add nsw i32 %46, 1
store i32 %47, i32* %9
br label %14
48: ; preds = %14
store i32 0, i32* %9
br label %49
49: ; preds = %203, %48
%50 = load i32, i32* %9
%51 = load i32, i32* %8
%52 = icmp slt i32 %50, %51
br i1 %52, label %53, label %206
53: ; preds = %49
store i32 0, i32* %10
br label %54
54: ; preds = %199, %53
%55 = load i32, i32* %10
%56 = load i32, i32* %8
%57 = icmp slt i32 %55, %56
br i1 %57, label %58, label %202
58: ; preds = %54
%59 = load i32, i32* %9
%60 = sext i32 %59 to i64
%61 = getelementptr inbounds [226 x [226 x float]], [226 x [226 x float]]* %12, i64 0, i64 %60
%62 = load i32, i32* %10
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds [226 x float], [226 x float]* %61, i64 0, i64 %63
%65 = load float, float* %64
%66 = load float**, float*** %6
%67 = getelementptr inbounds float*, float** %66, i64 0
%68 = load float*, float** %67
%69 = getelementptr inbounds float, float* %68, i64 0
%70 = load float, float* %69
%71 = load i32, i32* %9
%72 = add nsw i32 %71, 1
%73 = sext i32 %72 to i64
%74 = getelementptr inbounds [226 x [226 x float]], [226 x [226 x float]]* %12, i64 0, i64 %73
%75 = load i32, i32* %10
%76 = sext i32 %75 to i64
%77 = getelementptr inbounds [226 x float], [226 x float]* %74, i64 0, i64 %76
%78 = load float, float* %77
%79 = load float**, float*** %6
%80 = getelementptr inbounds float*, float** %79, i64 1
%81 = load float*, float** %80
%82 = getelementptr inbounds float, float* %81, i64 0
%83 = load float, float* %82
%84 = fmul float %78, %83
%85 = call float @llvm.fmuladd.f32(float %65, float %70, float %84)
%86 = load i32, i32* %9
%87 = add nsw i32 %86, 2
%88 = sext i32 %87 to i64
%89 = getelementptr inbounds [226 x [226 x float]], [226 x [226 x float]]* %12, i64 0, i64 %88
%90 = load i32, i32* %10
%91 = sext i32 %90 to i64
%92 = getelementptr inbounds [226 x float], [226 x float]* %89, i64 0, i64 %91
%93 = load float, float* %92
%94 = load float**, float*** %6
%95 = getelementptr inbounds float*, float** %94, i64 2
%96 = load float*, float** %95
%97 = getelementptr inbounds float, float* %96, i64 0
%98 = load float, float* %97
%99 = call float @llvm.fmuladd.f32(float %93, float %98, float %85)
%100 = load i32, i32* %9
%101 = sext i32 %100 to i64
%102 = getelementptr inbounds [226 x [226 x float]], [226 x [226 x float]]* %12, i64 0, i64 %101
%103 = load i32, i32* %10
%104 = add nsw i32 %103, 1
%105 = sext i32 %104 to i64
%106 = getelementptr inbounds [226 x float], [226 x float]* %102, i64 0, i64 %105
%107 = load float, float* %106
%108 = load float**, float*** %6
%109 = getelementptr inbounds float*, float** %108, i64 0
%110 = load float*, float** %109
%111 = getelementptr inbounds float, float* %110, i64 1
%112 = load float, float* %111
%113 = call float @llvm.fmuladd.f32(float %107, float %112, float %99)
%114 = load i32, i32* %9
%115 = add nsw i32 %114, 1
%116 = sext i32 %115 to i64
%117 = getelementptr inbounds [226 x [226 x float]], [226 x [226 x float]]* %12, i64 0, i64 %116
%118 = load i32, i32* %10
%119 = add nsw i32 %118, 1
%120 = sext i32 %119 to i64
%121 = getelementptr inbounds [226 x float], [226 x float]* %117, i64 0, i64 %120
%122 = load float, float* %121
%123 = load float**, float*** %6
%124 = getelementptr inbounds float*, float** %123, i64 1
%125 = load float*, float** %124
%126 = getelementptr inbounds float, float* %125, i64 1
%127 = load float, float* %126
%128 = call float @llvm.fmuladd.f32(float %122, float %127, float %113)
%129 = load i32, i32* %9
%130 = add nsw i32 %129, 2
%131 = sext i32 %130 to i64
%132 = getelementptr inbounds [226 x [226 x float]], [226 x [226 x float]]* %12, i64 0, i64 %131
%133 = load i32, i32* %10
%134 = add nsw i32 %133, 1
%135 = sext i32 %134 to i64
%136 = getelementptr inbounds [226 x float], [226 x float]* %132, i64 0, i64 %135
%137 = load float, float* %136
%138 = load float**, float*** %6
%139 = getelementptr inbounds float*, float** %138, i64 2
%140 = load float*, float** %139
%141 = getelementptr inbounds float, float* %140, i64 1
%142 = load float, float* %141
%143 = call float @llvm.fmuladd.f32(float %137, float %142, float %128)
%144 = load i32, i32* %9
%145 = sext i32 %144 to i64
%146 = getelementptr inbounds [226 x [226 x float]], [226 x [226 x float]]* %12, i64 0, i64 %145
%147 = load i32, i32* %10
%148 = add nsw i32 %147, 2
%149 = sext i32 %148 to i64
%150 = getelementptr inbounds [226 x float], [226 x float]* %146, i64 0, i64 %149
%151 = load float, float* %150
%152 = load float**, float*** %6
%153 = getelementptr inbounds float*, float** %152, i64 0
%154 = load float*, float** %153
%155 = getelementptr inbounds float, float* %154, i64 2
%156 = load float, float* %155
%157 = call float @llvm.fmuladd.f32(float %151, float %156, float %143)
%158 = load i32, i32* %9
%159 = add nsw i32 %158, 1
%160 = sext i32 %159 to i64
%161 = getelementptr inbounds [226 x [226 x float]], [226 x [226 x float]]* %12, i64 0, i64 %160
%162 = load i32, i32* %10
%163 = add nsw i32 %162, 2
%164 = sext i32 %163 to i64
%165 = getelementptr inbounds [226 x float], [226 x float]* %161, i64 0, i64 %164
%166 = load float, float* %165
%167 = load float**, float*** %6
%168 = getelementptr inbounds float*, float** %167, i64 1
%169 = load float*, float** %168
%170 = getelementptr inbounds float, float* %169, i64 2
%171 = load float, float* %170
%172 = call float @llvm.fmuladd.f32(float %166, float %171, float %157)
%173 = load i32, i32* %9
%174 = add nsw i32 %173, 2
%175 = sext i32 %174 to i64
%176 = getelementptr inbounds [226 x [226 x float]], [226 x [226 x float]]* %12, i64 0, i64 %175
%177 = load i32, i32* %10
%178 = add nsw i32 %177, 2
%179 = sext i32 %178 to i64
%180 = getelementptr inbounds [226 x float], [226 x float]* %176, i64 0, i64 %179
%181 = load float, float* %180
%182 = load float**, float*** %6
%183 = getelementptr inbounds float*, float** %182, i64 2
%184 = load float*, float** %183
%185 = getelementptr inbounds float, float* %184, i64 2
%186 = load float, float* %185
%187 = call float @llvm.fmuladd.f32(float %181, float %186, float %172)
store float %187, float* %11
%188 = load float, float* %11
%189 = load float**, float*** %7
%190 = load i32, i32* %9
%191 = sext i32 %190 to i64
%192 = getelementptr inbounds float*, float** %189, i64 %191
%193 = load float*, float** %192
%194 = load i32, i32* %10
%195 = sext i32 %194 to i64
%196 = getelementptr inbounds float, float* %193, i64 %195
%197 = load float, float* %196
%198 = fadd float %197, %188
store float %198, float* %196
br label %199
199: ; preds = %58
%200 = load i32, i32* %10
%201 = add nsw i32 %200, 1
store i32 %201, i32* %10
br label %54
202: ; preds = %54
br label %203
203: ; preds = %202
%204 = load i32, i32* %9
%205 = add nsw i32 %204, 1
store i32 %205, i32* %9
br label %49
206: ; preds = %49
ret void
}

LLVM IR (-O2):
define void @convolution_3_x_3(float** nocapture %0, float** nocapture %1, float** nocapture %2, i32 %3) {
%5 = alloca [226 x [226 x float]]
%6 = bitcast [226 x [226 x float]]* %5 to i8*
%7 = icmp sgt i32 %3, 0
br i1 %7, label %8, label %114
8: ; preds = %4
%9 = zext i32 %3 to i64
%10 = shl nuw nsw i64 %9, 2
%11 = and i64 %9, 1
%12 = icmp eq i32 %3, 1
br i1 %12, label %15, label %13
13: ; preds = %8
%14 = and i64 %9, 4294967294
br label %39
15: ; preds = %39, %8
%16 = phi i64 [ 0, %8 ], [ %48, %39 ]
%17 = icmp eq i64 %11, 0
br i1 %17, label %25, label %18
18: ; preds = %15
%19 = add nuw nsw i64 %16, 1
%20 = getelementptr [226 x [226 x float]], [226 x [226 x float]]* %5, i64 0, i64 %19, i64 1
%21 = bitcast float* %20 to i8*
%22 = getelementptr inbounds float*, float** %0, i64 %16
%23 = bitcast float** %22 to i8**
%24 = load i8*, i8** %23
br label %25
25: ; preds = %15, %18
br i1 %7, label %26, label %114
26: ; preds = %25
%27 = getelementptr inbounds float*, float** %1, i64 1
%28 = getelementptr inbounds float*, float** %1, i64 2
%29 = zext i32 %3 to i64
%30 = load float*, float** %1
%31 = load float*, float** %27
%32 = load float*, float** %28
%33 = getelementptr inbounds float, float* %30, i64 1
%34 = getelementptr inbounds float, float* %31, i64 1
%35 = getelementptr inbounds float, float* %32, i64 1
%36 = getelementptr inbounds float, float* %30, i64 2
%37 = getelementptr inbounds float, float* %31, i64 2
%38 = getelementptr inbounds float, float* %32, i64 2
br label %56
39: ; preds = %39, %13
%40 = phi i64 [ 0, %13 ], [ %48, %39 ]
%41 = phi i64 [ 0, %13 ], [ %54, %39 ]
%42 = or i64 %40, 1
%43 = getelementptr [226 x [226 x float]], [226 x [226 x float]]* %5, i64 0, i64 %42, i64 1
%44 = bitcast float* %43 to i8*
%45 = getelementptr inbounds float*, float** %0, i64 %40
%46 = bitcast float** %45 to i8**
%47 = load i8*, i8** %46
%48 = add nuw nsw i64 %40, 2
%49 = getelementptr [226 x [226 x float]], [226 x [226 x float]]* %5, i64 0, i64 %48, i64 1
%50 = bitcast float* %49 to i8*
%51 = getelementptr inbounds float*, float** %0, i64 %42
%52 = bitcast float** %51 to i8**
%53 = load i8*, i8** %52
%54 = add i64 %41, 2
%55 = icmp eq i64 %54, %14
br i1 %55, label %15, label %39
56: ; preds = %112, %26
%57 = phi i64 [ 0, %26 ], [ %58, %112 ]
%58 = add nuw nsw i64 %57, 1
%59 = add nuw nsw i64 %57, 2
%60 = getelementptr inbounds float*, float** %2, i64 %57
%61 = load float*, float** %60
%62 = getelementptr inbounds [226 x [226 x float]], [226 x [226 x float]]* %5, i64 0, i64 %57, i64 0
%63 = load float, float* %62
%64 = getelementptr inbounds [226 x [226 x float]], [226 x [226 x float]]* %5, i64 0, i64 %58, i64 0
%65 = load float, float* %64
%66 = getelementptr inbounds [226 x [226 x float]], [226 x [226 x float]]* %5, i64 0, i64 %59, i64 0
%67 = load float, float* %66
%68 = getelementptr inbounds [226 x [226 x float]], [226 x [226 x float]]* %5, i64 0, i64 %57, i64 1
%69 = load float, float* %68
%70 = getelementptr inbounds [226 x [226 x float]], [226 x [226 x float]]* %5, i64 0, i64 %58, i64 1
%71 = load float, float* %70
%72 = getelementptr inbounds [226 x [226 x float]], [226 x [226 x float]]* %5, i64 0, i64 %59, i64 1
%73 = load float, float* %72
br label %74
74: ; preds = %56, %74
%75 = phi float [ %73, %56 ], [ %105, %74 ]
%76 = phi float [ %71, %56 ], [ %101, %74 ]
%77 = phi float [ %69, %56 ], [ %97, %74 ]
%78 = phi float [ %67, %56 ], [ %75, %74 ]
%79 = phi float [ %65, %56 ], [ %76, %74 ]
%80 = phi float [ %63, %56 ], [ %77, %74 ]
%81 = phi i64 [ 0, %56 ], [ %88, %74 ]
%82 = load float, float* %30
%83 = load float, float* %31
%84 = fmul float %79, %83
%85 = tail call float @llvm.fmuladd.f32(float %80, float %82, float %84)
%86 = load float, float* %32
%87 = tail call float @llvm.fmuladd.f32(float %78, float %86, float %85)
%88 = add nuw nsw i64 %81, 1
%89 = load float, float* %33
%90 = tail call float @llvm.fmuladd.f32(float %77, float %89, float %87)
%91 = load float, float* %34
%92 = tail call float @llvm.fmuladd.f32(float %76, float %91, float %90)
%93 = load float, float* %35
%94 = tail call float @llvm.fmuladd.f32(float %75, float %93, float %92)
%95 = add nuw nsw i64 %81, 2
%96 = getelementptr inbounds [226 x [226 x float]], [226 x [226 x float]]* %5, i64 0, i64 %57, i64 %95
%97 = load float, float* %96
%98 = load float, float* %36
%99 = tail call float @llvm.fmuladd.f32(float %97, float %98, float %94)
%100 = getelementptr inbounds [226 x [226 x float]], [226 x [226 x float]]* %5, i64 0, i64 %58, i64 %95
%101 = load float, float* %100
%102 = load float, float* %37
%103 = tail call float @llvm.fmuladd.f32(float %101, float %102, float %99)
%104 = getelementptr inbounds [226 x [226 x float]], [226 x [226 x float]]* %5, i64 0, i64 %59, i64 %95
%105 = load float, float* %104
%106 = load float, float* %38
%107 = tail call float @llvm.fmuladd.f32(float %105, float %106, float %103)
%108 = getelementptr inbounds float, float* %61, i64 %81
%109 = load float, float* %108
%110 = fadd float %107, %109
store float %110, float* %108
%111 = icmp eq i64 %88, %29
br i1 %111, label %112, label %74
112: ; preds = %74
%113 = icmp eq i64 %58, %29
br i1 %113, label %114, label %56
114: ; preds = %112, %4, %25
ret void
}