void kernel(float *g1, float *g2, float *i, float *j, float *k) {
  int x, y, z;
  for (z = 1; z < 32 - 1; ++z) {
    for (y = 1; y < 32 - 1; ++y) {
      for (x = 1; x < 32 - 1; ++x) {
        float v = g1[((x) + (y)*32 + (z)*32 * 32)] +
                  g1[((x - 1) + (y)*32 + (z)*32 * 32)] * i[(x - 1)] +
                  g1[((x + 1) + (y)*32 + (z)*32 * 32)] * i[(x + 1)] +
                  g1[((x) + (y - 1) * 32 + (z)*32 * 32)] * j[(y - 1)] +
                  g1[((x) + (y + 1) * 32 + (z)*32 * 32)] * j[(y + 1)] +
                  g1[((x) + (y)*32 + (z - 1) * 32 * 32)] * k[(z - 1)] +
                  g1[((x) + (y)*32 + (z + 1) * 32 * 32)] * k[(z + 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)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
movl   $0x1,-0x34(%rbp)
cmpl   $0x1f,-0x34(%rbp)
jge    1347 <kernel+0x247>
movl   $0x1,-0x30(%rbp)
cmpl   $0x1f,-0x30(%rbp)
jge    1334 <kernel+0x234>
movl   $0x1,-0x2c(%rbp)
cmpl   $0x1f,-0x2c(%rbp)
jge    1321 <kernel+0x221>
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x30(%rbp),%edx
shl    $0x5,%edx
add    %edx,%ecx
mov    -0x34(%rbp),%edx
shl    $0x5,%edx
shl    $0x5,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x30(%rbp),%edx
shl    $0x5,%edx
add    %edx,%ecx
mov    -0x34(%rbp),%edx
shl    $0x5,%edx
shl    $0x5,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
mov    -0x30(%rbp),%edx
shl    $0x5,%edx
add    %edx,%ecx
mov    -0x34(%rbp),%edx
shl    $0x5,%edx
shl    $0x5,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x30(%rbp),%edx
sub    $0x1,%edx
shl    $0x5,%edx
add    %edx,%ecx
mov    -0x34(%rbp),%edx
shl    $0x5,%edx
shl    $0x5,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x30(%rbp),%edx
add    $0x1,%edx
shl    $0x5,%edx
add    %edx,%ecx
mov    -0x34(%rbp),%edx
shl    $0x5,%edx
shl    $0x5,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x30(%rbp),%edx
shl    $0x5,%edx
add    %edx,%ecx
mov    -0x34(%rbp),%edx
sub    $0x1,%edx
shl    $0x5,%edx
shl    $0x5,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x28(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm1
addss  %xmm0,%xmm1
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x30(%rbp),%edx
shl    $0x5,%edx
add    %edx,%ecx
mov    -0x34(%rbp),%edx
add    $0x1,%edx
shl    $0x5,%edx
shl    $0x5,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x38(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    -0x30(%rbp),%edx
shl    $0x5,%edx
add    %edx,%ecx
mov    -0x34(%rbp),%edx
shl    $0x5,%edx
shl    $0x5,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1141 <kernel+0x41>
jmp    1326 <kernel+0x226>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1130 <kernel+0x30>
jmp    1339 <kernel+0x239>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    111f <kernel+0x1f>
pop    %rbp
ret

x86 assembly (clang, -O2):
<kernel>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %rsi,%r9
mov    %rdi,%r14
lea    0x80(%rdx),%rax
mov    %rax,-0x48(%rsp)
mov    $0x1,%r11d
xor    %eax,%eax
mov    %rsi,-0x38(%rsp)
mov    %rdi,-0x40(%rsp)
xchg   %ax,%ax
mov    %rax,%rsi
shl    $0xa,%rsi
lea    0x421(%rsi),%rdi
mov    %rdi,-0x10(%rsp)
lea    0x43f(%rsi),%rdi
mov    %rdi,-0x18(%rsp)
lea    0x21(%rsi),%rdi
mov    %rdi,-0x20(%rsp)
add    $0x83f,%rsi
mov    %rsi,-0x8(%rsp)
lea    (%r8,%rax,4),%rsi
mov    %rsi,-0x28(%rsp)
mov    %rax,-0x50(%rsp)
lea    0xc(%r8,%rax,4),%rax
mov    %rax,-0x30(%rsp)
lea    0x1(%r11),%rbx
mov    %r9,-0x58(%rsp)
mov    %r14,-0x60(%rsp)
xor    %edi,%edi
mov    $0x1,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %rdi,%rax
shl    $0x5,%rax
mov    -0x10(%rsp),%rsi
add    %rax,%rsi
mov    %rdi,%r13
mov    -0x38(%rsp),%rdi
lea    (%rdi,%rsi,4),%r12
mov    -0x18(%rsp),%rsi
add    %rax,%rsi
lea    (%rdi,%rsi,4),%r10
lea    0xc(%rcx,%r13,4),%r15
mov    -0x8(%rsp),%rsi
add    %rax,%rsi
mov    -0x40(%rsp),%rdi
lea    (%rdi,%rsi,4),%rsi
add    -0x20(%rsp),%rax
lea    (%rdi,%rax,4),%rax
mov    %r13,%rdi
cmp    %rsi,%r12
setb   -0x61(%rsp)
cmp    %r10,%rax
setb   -0x62(%rsp)
cmp    -0x48(%rsp),%r12
setb   %sil
cmp    %rdx,%r10
seta   -0x63(%rsp)
lea    (%rcx,%r13,4),%rax
cmp    %r15,%r12
setb   %r15b
cmp    %r10,%rax
lea    0x1(%rbp),%r13
setb   -0x64(%rsp)
cmp    -0x30(%rsp),%r12
setb   %r12b
cmp    %r10,-0x28(%rsp)
setb   -0x65(%rsp)
mov    $0x1,%r10d
mov    -0x62(%rsp),%al
test   %al,-0x61(%rsp)
jne    1320 <kernel+0x220>
and    -0x63(%rsp),%sil
jne    1320 <kernel+0x220>
and    -0x64(%rsp),%r15b
jne    1320 <kernel+0x220>
and    -0x65(%rsp),%r12b
jne    1320 <kernel+0x220>
movss  -0x4(%rcx,%rbp,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movss  (%rcx,%r13,4),%xmm1
shufps $0x0,%xmm1,%xmm1
movss  -0x4(%r8,%r11,4),%xmm2
shufps $0x0,%xmm2,%xmm2
movss  (%r8,%rbx,4),%xmm3
shufps $0x0,%xmm3,%xmm3
mov    $0x421,%eax
nopw   0x0(%rax,%rax,1)
movups (%r14,%rax,4),%xmm4
movups -0x4(%r14,%rax,4),%xmm5
movups -0x1084(%rdx,%rax,4),%xmm6
ff
mulps  %xmm5,%xmm6
addps  %xmm4,%xmm6
movups -0x107c(%rdx,%rax,4),%xmm4
ff
movups 0x4(%r14,%rax,4),%xmm5
mulps  %xmm4,%xmm5
addps  %xmm6,%xmm5
movups -0x80(%r14,%rax,4),%xmm4
mulps  %xmm0,%xmm4
addps  %xmm5,%xmm4
movups 0x80(%r14,%rax,4),%xmm5
mulps  %xmm1,%xmm5
addps  %xmm4,%xmm5
movups -0x1000(%r14,%rax,4),%xmm4
ff ff
mulps  %xmm2,%xmm4
addps  %xmm5,%xmm4
movups 0x1000(%r14,%rax,4),%xmm5
mulps  %xmm3,%xmm5
addps  %xmm4,%xmm5
movups %xmm5,(%r9,%rax,4)
add    $0x4,%rax
cmp    $0x43d,%rax
jne    12a0 <kernel+0x1a0>
mov    $0x1d,%r10d
nopl   (%rax)
movss  0x107c(%r14,%r10,4),%xmm0
mulss  -0x4(%rdx,%r10,4),%xmm0
addss  0x1080(%r14,%r10,4),%xmm0
movss  0x1084(%r14,%r10,4),%xmm1
mulss  0x4(%rdx,%r10,4),%xmm1
addss  %xmm0,%xmm1
movss  0x1000(%r14,%r10,4),%xmm0
mulss  -0x4(%rcx,%rbp,4),%xmm0
addss  %xmm1,%xmm0
movss  0x1100(%r14,%r10,4),%xmm1
mulss  (%rcx,%r13,4),%xmm1
addss  %xmm0,%xmm1
movss  0x80(%r14,%r10,4),%xmm0
mulss  -0x4(%r8,%r11,4),%xmm0
addss  %xmm1,%xmm0
movss  0x2080(%r14,%r10,4),%xmm1
mulss  (%r8,%rbx,4),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,0x1080(%r9,%r10,4)
lea    0x1(%r10),%rax
mov    %rax,%r10
cmp    $0x1f,%rax
jne    1320 <kernel+0x220>
add    $0x1,%rdi
sub    $0xffffffffffffff80,%r14
sub    $0xffffffffffffff80,%r9
mov    %r13,%rbp
cmp    $0x1f,%r13
jne    11a0 <kernel+0xa0>
mov    -0x50(%rsp),%rax
add    $0x1,%rax
mov    -0x60(%rsp),%r14
add    $0x1000,%r14
mov    -0x58(%rsp),%r9
add    $0x1000,%r9
mov    %rbx,%r11
cmp    $0x1f,%rbx
jne    1130 <kernel+0x30>
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, float* %3, float* %4) {
%6 = alloca float*
%7 = alloca float*
%8 = alloca float*
%9 = alloca float*
%10 = alloca float*
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca float
store float* %0, float** %6
store float* %1, float** %7
store float* %2, float** %8
store float* %3, float** %9
store float* %4, float** %10
store i32 1, i32* %13
br label %15
15: ; preds = %179, %5
%16 = load i32, i32* %13
%17 = icmp slt i32 %16, 31
br i1 %17, label %18, label %182
18: ; preds = %15
store i32 1, i32* %12
br label %19
19: ; preds = %175, %18
%20 = load i32, i32* %12
%21 = icmp slt i32 %20, 31
br i1 %21, label %22, label %178
22: ; preds = %19
store i32 1, i32* %11
br label %23
23: ; preds = %171, %22
%24 = load i32, i32* %11
%25 = icmp slt i32 %24, 31
br i1 %25, label %26, label %174
26: ; preds = %23
%27 = load float*, float** %6
%28 = load i32, i32* %11
%29 = load i32, i32* %12
%30 = mul nsw i32 %29, 32
%31 = add nsw i32 %28, %30
%32 = load i32, i32* %13
%33 = mul nsw i32 %32, 32
%34 = mul nsw i32 %33, 32
%35 = add nsw i32 %31, %34
%36 = sext i32 %35 to i64
%37 = getelementptr inbounds float, float* %27, i64 %36
%38 = load float, float* %37
%39 = load float*, float** %6
%40 = load i32, i32* %11
%41 = sub nsw i32 %40, 1
%42 = load i32, i32* %12
%43 = mul nsw i32 %42, 32
%44 = add nsw i32 %41, %43
%45 = load i32, i32* %13
%46 = mul nsw i32 %45, 32
%47 = mul nsw i32 %46, 32
%48 = add nsw i32 %44, %47
%49 = sext i32 %48 to i64
%50 = getelementptr inbounds float, float* %39, i64 %49
%51 = load float, float* %50
%52 = load float*, float** %8
%53 = load i32, i32* %11
%54 = sub nsw i32 %53, 1
%55 = sext i32 %54 to i64
%56 = getelementptr inbounds float, float* %52, i64 %55
%57 = load float, float* %56
%58 = call float @llvm.fmuladd.f32(float %51, float %57, float %38)
%59 = load float*, float** %6
%60 = load i32, i32* %11
%61 = add nsw i32 %60, 1
%62 = load i32, i32* %12
%63 = mul nsw i32 %62, 32
%64 = add nsw i32 %61, %63
%65 = load i32, i32* %13
%66 = mul nsw i32 %65, 32
%67 = mul nsw i32 %66, 32
%68 = add nsw i32 %64, %67
%69 = sext i32 %68 to i64
%70 = getelementptr inbounds float, float* %59, i64 %69
%71 = load float, float* %70
%72 = load float*, float** %8
%73 = load i32, i32* %11
%74 = add nsw i32 %73, 1
%75 = sext i32 %74 to i64
%76 = getelementptr inbounds float, float* %72, i64 %75
%77 = load float, float* %76
%78 = call float @llvm.fmuladd.f32(float %71, float %77, float %58)
%79 = load float*, float** %6
%80 = load i32, i32* %11
%81 = load i32, i32* %12
%82 = sub nsw i32 %81, 1
%83 = mul nsw i32 %82, 32
%84 = add nsw i32 %80, %83
%85 = load i32, i32* %13
%86 = mul nsw i32 %85, 32
%87 = mul nsw i32 %86, 32
%88 = add nsw i32 %84, %87
%89 = sext i32 %88 to i64
%90 = getelementptr inbounds float, float* %79, i64 %89
%91 = load float, float* %90
%92 = load float*, float** %9
%93 = load i32, i32* %12
%94 = sub nsw i32 %93, 1
%95 = sext i32 %94 to i64
%96 = getelementptr inbounds float, float* %92, i64 %95
%97 = load float, float* %96
%98 = call float @llvm.fmuladd.f32(float %91, float %97, float %78)
%99 = load float*, float** %6
%100 = load i32, i32* %11
%101 = load i32, i32* %12
%102 = add nsw i32 %101, 1
%103 = mul nsw i32 %102, 32
%104 = add nsw i32 %100, %103
%105 = load i32, i32* %13
%106 = mul nsw i32 %105, 32
%107 = mul nsw i32 %106, 32
%108 = add nsw i32 %104, %107
%109 = sext i32 %108 to i64
%110 = getelementptr inbounds float, float* %99, i64 %109
%111 = load float, float* %110
%112 = load float*, float** %9
%113 = load i32, i32* %12
%114 = add nsw i32 %113, 1
%115 = sext i32 %114 to i64
%116 = getelementptr inbounds float, float* %112, i64 %115
%117 = load float, float* %116
%118 = call float @llvm.fmuladd.f32(float %111, float %117, float %98)
%119 = load float*, float** %6
%120 = load i32, i32* %11
%121 = load i32, i32* %12
%122 = mul nsw i32 %121, 32
%123 = add nsw i32 %120, %122
%124 = load i32, i32* %13
%125 = sub nsw i32 %124, 1
%126 = mul nsw i32 %125, 32
%127 = mul nsw i32 %126, 32
%128 = add nsw i32 %123, %127
%129 = sext i32 %128 to i64
%130 = getelementptr inbounds float, float* %119, i64 %129
%131 = load float, float* %130
%132 = load float*, float** %10
%133 = load i32, i32* %13
%134 = sub nsw i32 %133, 1
%135 = sext i32 %134 to i64
%136 = getelementptr inbounds float, float* %132, i64 %135
%137 = load float, float* %136
%138 = call float @llvm.fmuladd.f32(float %131, float %137, float %118)
%139 = load float*, float** %6
%140 = load i32, i32* %11
%141 = load i32, i32* %12
%142 = mul nsw i32 %141, 32
%143 = add nsw i32 %140, %142
%144 = load i32, i32* %13
%145 = add nsw i32 %144, 1
%146 = mul nsw i32 %145, 32
%147 = mul nsw i32 %146, 32
%148 = add nsw i32 %143, %147
%149 = sext i32 %148 to i64
%150 = getelementptr inbounds float, float* %139, i64 %149
%151 = load float, float* %150
%152 = load float*, float** %10
%153 = load i32, i32* %13
%154 = add nsw i32 %153, 1
%155 = sext i32 %154 to i64
%156 = getelementptr inbounds float, float* %152, i64 %155
%157 = load float, float* %156
%158 = call float @llvm.fmuladd.f32(float %151, float %157, float %138)
store float %158, float* %14
%159 = load float, float* %14
%160 = load float*, float** %7
%161 = load i32, i32* %11
%162 = load i32, i32* %12
%163 = mul nsw i32 %162, 32
%164 = add nsw i32 %161, %163
%165 = load i32, i32* %13
%166 = mul nsw i32 %165, 32
%167 = mul nsw i32 %166, 32
%168 = add nsw i32 %164, %167
%169 = sext i32 %168 to i64
%170 = getelementptr inbounds float, float* %160, i64 %169
store float %159, float* %170
br label %171
171: ; preds = %26
%172 = load i32, i32* %11
%173 = add nsw i32 %172, 1
store i32 %173, i32* %11
br label %23
174: ; preds = %23
br label %175
175: ; preds = %174
%176 = load i32, i32* %12
%177 = add nsw i32 %176, 1
store i32 %177, i32* %12
br label %19
178: ; preds = %19
br label %179
179: ; preds = %178
%180 = load i32, i32* %13
%181 = add nsw i32 %180, 1
store i32 %181, i32* %13
br label %15
182: ; preds = %15
ret void
}

LLVM IR (-O2):
define void @kernel(float* nocapture %0, float* nocapture writeonly %1, float* nocapture %2, float* nocapture %3, float* nocapture %4) {
%6 = getelementptr float, float* %2, i64 32
br label %7
7: ; preds = %5, %174
%8 = phi i64 [ 0, %5 ], [ %176, %174 ]
%9 = phi i64 [ 1, %5 ], [ %22, %174 ]
%10 = shl nuw nsw i64 %8, 10
%11 = add i64 %10, 1057
%12 = add i64 %10, 1087
%13 = or i64 %10, 33
%14 = add i64 %10, 2111
%15 = getelementptr float, float* %4, i64 %8
%16 = add i64 %8, 3
%17 = getelementptr float, float* %4, i64 %16
%18 = shl nsw i64 %9, 10
%19 = add nsw i64 %9, -1
%20 = shl nsw i64 %19, 10
%21 = getelementptr inbounds float, float* %4, i64 %19
%22 = add nuw nsw i64 %9, 1
%23 = shl nsw i64 %22, 10
%24 = getelementptr inbounds float, float* %4, i64 %22
br label %25
25: ; preds = %7, %171
%26 = phi i64 [ 0, %7 ], [ %173, %171 ]
%27 = phi i64 [ 1, %7 ], [ %38, %171 ]
%28 = shl nuw nsw i64 %26, 5
%29 = add i64 %11, %28
%30 = getelementptr float, float* %1, i64 %29
%31 = add i64 %12, %28
%32 = getelementptr float, float* %1, i64 %31
%33 = shl nsw i64 %27, 5
%34 = add nuw nsw i64 %33, %18
%35 = add nsw i64 %27, -1
%36 = shl nsw i64 %35, 5
%37 = getelementptr inbounds float, float* %3, i64 %35
%38 = add nuw nsw i64 %27, 1
%39 = shl nsw i64 %38, 5
%40 = getelementptr inbounds float, float* %3, i64 %38
%41 = add i64 %26, 3
%42 = getelementptr float, float* %3, i64 %41
%43 = getelementptr float, float* %3, i64 %26
%44 = add i64 %14, %28
%45 = getelementptr float, float* %0, i64 %44
%46 = add i64 %13, %28
%47 = getelementptr float, float* %0, i64 %46
%48 = icmp ult float* %30, %45
%49 = icmp ult float* %47, %32
%50 = and i1 %48, %49
%51 = icmp ult float* %30, %6
%52 = icmp ugt float* %32, %2
%53 = and i1 %51, %52
%54 = or i1 %50, %53
%55 = icmp ult float* %30, %42
%56 = icmp ult float* %43, %32
%57 = and i1 %55, %56
%58 = or i1 %54, %57
%59 = icmp ult float* %30, %17
%60 = icmp ult float* %15, %32
%61 = and i1 %59, %60
%62 = or i1 %58, %61
br i1 %62, label %126, label %63
63: ; preds = %25
%64 = load float, float* %37
%65 = insertelement <4 x float> poison, float %64, i64 0
%66 = shufflevector <4 x float> %65, <4 x float> poison, <4 x i32> zeroinitializer
%67 = load float, float* %40
%68 = insertelement <4 x float> poison, float %67, i64 0
%69 = shufflevector <4 x float> %68, <4 x float> poison, <4 x i32> zeroinitializer
%70 = load float, float* %21
%71 = insertelement <4 x float> poison, float %70, i64 0
%72 = shufflevector <4 x float> %71, <4 x float> poison, <4 x i32> zeroinitializer
%73 = load float, float* %24
%74 = insertelement <4 x float> poison, float %73, i64 0
%75 = shufflevector <4 x float> %74, <4 x float> poison, <4 x i32> zeroinitializer
br label %76
76: ; preds = %63, %76
%77 = phi i64 [ %124, %76 ], [ 0, %63 ]
%78 = or i64 %77, 1
%79 = add nuw nsw i64 %78, %33
%80 = add nuw nsw i64 %79, %18
%81 = getelementptr inbounds float, float* %0, i64 %80
%82 = bitcast float* %81 to <4 x float>*
%83 = load <4 x float>, <4 x float>* %82
%84 = add nuw nsw i64 %34, %77
%85 = getelementptr inbounds float, float* %0, i64 %84
%86 = bitcast float* %85 to <4 x float>*
%87 = load <4 x float>, <4 x float>* %86
%88 = getelementptr inbounds float, float* %2, i64 %77
%89 = bitcast float* %88 to <4 x float>*
%90 = load <4 x float>, <4 x float>* %89
%91 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %87, <4 x float> %90, <4 x float> %83)
%92 = or i64 %77, 2
%93 = add nuw nsw i64 %34, %92
%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 = getelementptr inbounds float, float* %2, i64 %92
%98 = bitcast float* %97 to <4 x float>*
%99 = load <4 x float>, <4 x float>* %98
%100 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %96, <4 x float> %99, <4 x float> %91)
%101 = add nuw nsw i64 %78, %18
%102 = add nuw nsw i64 %101, %36
%103 = getelementptr inbounds float, float* %0, i64 %102
%104 = bitcast float* %103 to <4 x float>*
%105 = load <4 x float>, <4 x float>* %104
%106 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %105, <4 x float> %66, <4 x float> %100)
%107 = add nuw nsw i64 %101, %39
%108 = getelementptr inbounds float, float* %0, i64 %107
%109 = bitcast float* %108 to <4 x float>*
%110 = load <4 x float>, <4 x float>* %109
%111 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %110, <4 x float> %69, <4 x float> %106)
%112 = add nuw nsw i64 %79, %20
%113 = getelementptr inbounds float, float* %0, i64 %112
%114 = bitcast float* %113 to <4 x float>*
%115 = load <4 x float>, <4 x float>* %114
%116 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %115, <4 x float> %72, <4 x float> %111)
%117 = add nuw nsw i64 %79, %23
%118 = getelementptr inbounds float, float* %0, i64 %117
%119 = bitcast float* %118 to <4 x float>*
%120 = load <4 x float>, <4 x float>* %119
%121 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %120, <4 x float> %75, <4 x float> %116)
%122 = getelementptr inbounds float, float* %1, i64 %80
%123 = bitcast float* %122 to <4 x float>*
store <4 x float> %121, <4 x float>* %123
%124 = add nuw i64 %77, 4
%125 = icmp eq i64 %124, 28
br i1 %125, label %126, label %76
126: ; preds = %76, %25
%127 = phi i64 [ 1, %25 ], [ 29, %76 ]
br label %128
128: ; preds = %126, %128
%129 = phi i64 [ %141, %128 ], [ %127, %126 ]
%130 = add nuw nsw i64 %129, %33
%131 = add nuw nsw i64 %130, %18
%132 = getelementptr inbounds float, float* %0, i64 %131
%133 = load float, float* %132
%134 = add nsw i64 %129, -1
%135 = add nuw nsw i64 %34, %134
%136 = getelementptr inbounds float, float* %0, i64 %135
%137 = load float, float* %136
%138 = getelementptr inbounds float, float* %2, i64 %134
%139 = load float, float* %138
%140 = tail call float @llvm.fmuladd.f32(float %137, float %139, float %133)
%141 = add nuw nsw i64 %129, 1
%142 = add nuw nsw i64 %34, %141
%143 = getelementptr inbounds float, float* %0, i64 %142
%144 = load float, float* %143
%145 = getelementptr inbounds float, float* %2, i64 %141
%146 = load float, float* %145
%147 = tail call float @llvm.fmuladd.f32(float %144, float %146, float %140)
%148 = add nuw nsw i64 %129, %18
%149 = add nuw nsw i64 %148, %36
%150 = getelementptr inbounds float, float* %0, i64 %149
%151 = load float, float* %150
%152 = load float, float* %37
%153 = tail call float @llvm.fmuladd.f32(float %151, float %152, float %147)
%154 = add nuw nsw i64 %148, %39
%155 = getelementptr inbounds float, float* %0, i64 %154
%156 = load float, float* %155
%157 = load float, float* %40
%158 = tail call float @llvm.fmuladd.f32(float %156, float %157, float %153)
%159 = add nuw nsw i64 %130, %20
%160 = getelementptr inbounds float, float* %0, i64 %159
%161 = load float, float* %160
%162 = load float, float* %21
%163 = tail call float @llvm.fmuladd.f32(float %161, float %162, float %158)
%164 = add nuw nsw i64 %130, %23
%165 = getelementptr inbounds float, float* %0, i64 %164
%166 = load float, float* %165
%167 = load float, float* %24
%168 = tail call float @llvm.fmuladd.f32(float %166, float %167, float %163)
%169 = getelementptr inbounds float, float* %1, i64 %131
store float %168, float* %169
%170 = icmp eq i64 %141, 31
br i1 %170, label %171, label %128
171: ; preds = %128
%172 = icmp eq i64 %38, 31
%173 = add i64 %26, 1
br i1 %172, label %174, label %25
174: ; preds = %171
%175 = icmp eq i64 %22, 31
%176 = add i64 %8, 1
br i1 %175, label %177, label %7
177: ; preds = %174
ret void
}