void kernel(float *g1, float *g2, float *k) {
  int x, y, z;
  for (z = 0; z < 32; ++z) {
    for (y = 0; y < 32; ++y) {
      for (x = 1; x < 32 - 1; ++x) {
        float v = g1[((x) + (y)*32 + (z)*32 * 32)] * k[(x)] +
                  g1[((x - 1) + (y)*32 + (z)*32 * 32)] * k[(x - 1)] +
                  g1[((x + 1) + (y)*32 + (z)*32 * 32)] * k[(x + 1)];
        g2[((x) + (y)*32 + (z)*32 * 32)] = v;
      }
    }
  }
  return;
}


x86 assembly (clang, -O0):
<kernel>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movl   $0x0,-0x24(%rbp)
cmpl   $0x20,-0x24(%rbp)
jge    1250 <kernel+0x150>
movl   $0x0,-0x20(%rbp)
cmpl   $0x20,-0x20(%rbp)
jge    123d <kernel+0x13d>
movl   $0x1,-0x1c(%rbp)
cmpl   $0x1f,-0x1c(%rbp)
jge    122a <kernel+0x12a>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    -0x20(%rbp),%edx
shl    $0x5,%edx
add    %edx,%ecx
mov    -0x24(%rbp),%edx
shl    $0x5,%edx
shl    $0x5,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x20(%rbp),%edx
shl    $0x5,%edx
add    %edx,%ecx
mov    -0x24(%rbp),%edx
shl    $0x5,%edx
shl    $0x5,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mulss  (%rax,%rcx,4),%xmm0
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
mov    -0x20(%rbp),%edx
shl    $0x5,%edx
add    %edx,%ecx
mov    -0x24(%rbp),%edx
shl    $0x5,%edx
shl    $0x5,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x28(%rbp)
movss  -0x28(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    -0x20(%rbp),%edx
shl    $0x5,%edx
add    %edx,%ecx
mov    -0x24(%rbp),%edx
shl    $0x5,%edx
shl    $0x5,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1139 <kernel+0x39>
jmp    122f <kernel+0x12f>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1128 <kernel+0x28>
jmp    1242 <kernel+0x142>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1117 <kernel+0x17>
pop    %rbp
ret

x86 assembly (clang, -O2):
<kernel>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
lea    0x80(%rdx),%rax
mov    %rax,-0x10(%rsp)
xor    %r13d,%r13d
mov    %rdi,%rbx
mov    %rsi,%rax
nop
mov    %r13,-0x18(%rsp)
shl    $0xa,%r13
lea    0x1(%r13),%rcx
mov    %rcx,-0x8(%rsp)
lea    0x1f(%r13),%r15
lea    0x20(%r13),%r12
mov    %rbx,-0x20(%rsp)
mov    %rax,-0x28(%rsp)
xor    %r8d,%r8d
nopw   0x0(%rax,%rax,1)
mov    %r8,%rcx
shl    $0x5,%rcx
mov    -0x8(%rsp),%rbp
add    %rcx,%rbp
lea    (%rsi,%rbp,4),%r9
lea    (%r15,%rcx,1),%rbp
lea    (%rsi,%rbp,4),%rbp
lea    (%r12,%rcx,1),%r10
add    %r13,%rcx
lea    (%rdi,%r10,4),%r10
lea    (%rdi,%rcx,4),%r11
cmp    %r10,%r9
setb   %r14b
cmp    %rbp,%r11
setb   %r11b
cmp    -0x10(%rsp),%r9
setb   %r9b
cmp    %rdx,%rbp
seta   %r10b
mov    $0x1,%ebp
test   %r11b,%r14b
jne    1380 <kernel+0x280>
and    %r10b,%r9b
jne    1380 <kernel+0x280>
lea    0x0(,%rcx,4),%r10
mov    %r10,%r9
or     $0x4,%r9
movups (%rdi,%r9,1),%xmm0
movups (%rdi,%rcx,4),%xmm1
movups (%rdx),%xmm2
mulps  %xmm1,%xmm2
movups 0x4(%rdx),%xmm1
mulps  %xmm0,%xmm1
addps  %xmm2,%xmm1
movups 0x8(%rdx),%xmm0
mov    %r10,%rcx
or     $0x8,%rcx
movups (%rdi,%rcx,1),%xmm2
mulps  %xmm0,%xmm2
addps  %xmm1,%xmm2
movups %xmm2,(%rsi,%r9,1)
mov    %r10,%rcx
or     $0x14,%rcx
movups (%rdi,%rcx,1),%xmm0
mov    %r10,%rbp
or     $0x10,%rbp
movups (%rdi,%rbp,1),%xmm1
movups 0x10(%rdx),%xmm2
mulps  %xmm1,%xmm2
movups 0x14(%rdx),%xmm1
mulps  %xmm0,%xmm1
addps  %xmm2,%xmm1
movups 0x18(%rdx),%xmm0
mov    %r10,%rbp
or     $0x18,%rbp
movups (%rdi,%rbp,1),%xmm2
mulps  %xmm0,%xmm2
addps  %xmm1,%xmm2
movups %xmm2,(%rsi,%rcx,1)
mov    %r10,%rcx
or     $0x24,%rcx
movups (%rdi,%rcx,1),%xmm0
mov    %r10,%rbp
or     $0x20,%rbp
movups (%rdi,%rbp,1),%xmm1
movups 0x20(%rdx),%xmm2
mulps  %xmm1,%xmm2
movups 0x24(%rdx),%xmm1
mulps  %xmm0,%xmm1
addps  %xmm2,%xmm1
movups 0x28(%rdx),%xmm0
mov    %r10,%rbp
or     $0x28,%rbp
movups (%rdi,%rbp,1),%xmm2
mulps  %xmm0,%xmm2
addps  %xmm1,%xmm2
movups %xmm2,(%rsi,%rcx,1)
mov    %r10,%rcx
or     $0x34,%rcx
movups (%rdi,%rcx,1),%xmm0
mov    %r10,%rbp
or     $0x30,%rbp
movups (%rdi,%rbp,1),%xmm1
movups 0x30(%rdx),%xmm2
mulps  %xmm1,%xmm2
movups 0x34(%rdx),%xmm1
mulps  %xmm0,%xmm1
addps  %xmm2,%xmm1
movups 0x38(%rdx),%xmm0
mov    %r10,%rbp
or     $0x38,%rbp
movups (%rdi,%rbp,1),%xmm2
mulps  %xmm0,%xmm2
addps  %xmm1,%xmm2
movups %xmm2,(%rsi,%rcx,1)
mov    %r10,%rcx
or     $0x44,%rcx
movups (%rdi,%rcx,1),%xmm0
mov    %r10,%rbp
or     $0x40,%rbp
movups (%rdi,%rbp,1),%xmm1
movups 0x40(%rdx),%xmm2
mulps  %xmm1,%xmm2
movups 0x44(%rdx),%xmm1
mulps  %xmm0,%xmm1
addps  %xmm2,%xmm1
movups 0x48(%rdx),%xmm0
mov    %r10,%rbp
or     $0x48,%rbp
movups (%rdi,%rbp,1),%xmm2
mulps  %xmm0,%xmm2
addps  %xmm1,%xmm2
movups %xmm2,(%rsi,%rcx,1)
mov    %r10,%rcx
or     $0x54,%rcx
movups (%rdi,%rcx,1),%xmm0
mov    %r10,%rbp
or     $0x50,%rbp
movups (%rdi,%rbp,1),%xmm1
movups 0x50(%rdx),%xmm2
mulps  %xmm1,%xmm2
movups 0x54(%rdx),%xmm1
mulps  %xmm0,%xmm1
addps  %xmm2,%xmm1
movups 0x58(%rdx),%xmm0
mov    %r10,%rbp
or     $0x58,%rbp
movups (%rdi,%rbp,1),%xmm2
mulps  %xmm0,%xmm2
addps  %xmm1,%xmm2
movups %xmm2,(%rsi,%rcx,1)
mov    %r10,%rcx
or     $0x64,%rcx
movups (%rdi,%rcx,1),%xmm0
mov    %r10,%rbp
or     $0x60,%rbp
movups (%rdi,%rbp,1),%xmm1
movups 0x60(%rdx),%xmm2
mulps  %xmm1,%xmm2
movups 0x64(%rdx),%xmm1
mulps  %xmm0,%xmm1
addps  %xmm2,%xmm1
movups 0x68(%rdx),%xmm0
or     $0x68,%r10
movups (%rdi,%r10,1),%xmm2
mulps  %xmm0,%xmm2
addps  %xmm1,%xmm2
movups %xmm2,(%rsi,%rcx,1)
mov    $0x1d,%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  -0x4(%rbx,%rbp,4),%xmm0
movss  (%rbx,%rbp,4),%xmm1
mulss  -0x4(%rdx,%rbp,4),%xmm0
mulss  (%rdx,%rbp,4),%xmm1
addss  %xmm0,%xmm1
movss  0x4(%rbx,%rbp,4),%xmm0
mulss  0x4(%rdx,%rbp,4),%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rbp,4)
lea    0x1(%rbp),%rcx
mov    %rcx,%rbp
cmp    $0x1f,%rcx
jne    1380 <kernel+0x280>
add    $0x1,%r8
sub    $0xffffffffffffff80,%rax
sub    $0xffffffffffffff80,%rbx
cmp    $0x20,%r8
jne    1150 <kernel+0x50>
mov    -0x18(%rsp),%r13
add    $0x1,%r13
mov    -0x28(%rsp),%rax
add    $0x1000,%rax
mov    -0x20(%rsp),%rbx
add    $0x1000,%rbx
cmp    $0x20,%r13
jne    1120 <kernel+0x20>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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