void kernel(float *g1, float *g2) {
  int x, y, z;
  int halo_width = 1;
  for (z = halo_width; z < 32 - halo_width; ++z) {
    for (y = halo_width; y < 32 - halo_width; ++y) {
      for (x = halo_width; x < 32 - halo_width; ++x) {
        float v = g1[((x) + (y)*32 + (z)*32 * 32)] +
                  g1[((x + 1) + (y)*32 + (z)*32 * 32)] +
                  g1[((x - 1) + (y)*32 + (z)*32 * 32)] +
                  g1[((x) + (y + 1) * 32 + (z)*32 * 32)] +
                  g1[((x) + (y - 1) * 32 + (z)*32 * 32)] +
                  g1[((x) + (y)*32 + (z - 1) * 32 * 32)] +
                  g1[((x) + (y)*32 + (z + 1) * 32 * 32)];
        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)
movl   $0x1,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    $0x20,%ecx
sub    -0x20(%rbp),%ecx
cmp    %ecx,%eax
jge    12be <kernel+0x1be>
mov    -0x20(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
mov    $0x20,%ecx
sub    -0x20(%rbp),%ecx
cmp    %ecx,%eax
jge    12ab <kernel+0x1ab>
mov    -0x20(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x20,%ecx
sub    -0x20(%rbp),%ecx
cmp    %ecx,%eax
jge    1298 <kernel+0x198>
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x18(%rbp),%edx
shl    $0x5,%edx
add    %edx,%ecx
mov    -0x1c(%rbp),%edx
shl    $0x5,%edx
shl    $0x5,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
mov    -0x18(%rbp),%edx
shl    $0x5,%edx
add    %edx,%ecx
mov    -0x1c(%rbp),%edx
shl    $0x5,%edx
shl    $0x5,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x18(%rbp),%edx
shl    $0x5,%edx
add    %edx,%ecx
mov    -0x1c(%rbp),%edx
shl    $0x5,%edx
shl    $0x5,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x18(%rbp),%edx
add    $0x1,%edx
shl    $0x5,%edx
add    %edx,%ecx
mov    -0x1c(%rbp),%edx
shl    $0x5,%edx
shl    $0x5,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
shl    $0x5,%edx
add    %edx,%ecx
mov    -0x1c(%rbp),%edx
shl    $0x5,%edx
shl    $0x5,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x18(%rbp),%edx
shl    $0x5,%edx
add    %edx,%ecx
mov    -0x1c(%rbp),%edx
sub    $0x1,%edx
shl    $0x5,%edx
shl    $0x5,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x18(%rbp),%edx
shl    $0x5,%edx
add    %edx,%ecx
mov    -0x1c(%rbp),%edx
add    $0x1,%edx
shl    $0x5,%edx
shl    $0x5,%edx
add    %edx,%ecx
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x24(%rbp),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x18(%rbp),%edx
shl    $0x5,%edx
add    %edx,%ecx
mov    -0x1c(%rbp),%edx
shl    $0x5,%edx
shl    $0x5,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    114b <kernel+0x4b>
jmp    129d <kernel+0x19d>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1132 <kernel+0x32>
jmp    12b0 <kernel+0x1b0>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1119 <kernel+0x19>
pop    %rbp
ret

x86 assembly (clang, -O2):
<kernel>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
lea    0x107c(%rdi),%rcx
lea    0x1080(%rsi),%rbx
mov    $0x1,%r14d
xor    %r13d,%r13d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r13,-0x28(%rsp)
shl    $0xa,%r13
lea    0x421(%r13),%r12
lea    0x43f(%r13),%rax
mov    %rax,-0x8(%rsp)
lea    0x21(%r13),%r15
add    $0x83f,%r13
mov    %r14,-0x20(%rsp)
shl    $0xa,%r14
mov    %rbx,-0x18(%rsp)
mov    %rcx,-0x10(%rsp)
xor    %r11d,%r11d
mov    $0x1,%r8d
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %r11,%rax
shl    $0x5,%rax
lea    (%rax,%r13,1),%rbp
lea    (%rdi,%rbp,4),%rbp
lea    (%r12,%rax,1),%rdx
lea    (%rsi,%rdx,4),%rdx
cmp    %rbp,%rdx
jae    11bb <kernel+0xbb>
lea    (%r15,%rax,1),%rdx
lea    (%rdi,%rdx,4),%rdx
add    -0x8(%rsp),%rax
lea    (%rsi,%rax,4),%rax
mov    $0x1,%ebp
cmp    %rax,%rdx
jb     1440 <kernel+0x340>
mov    %r8,%rbp
shl    $0x5,%rbp
lea    (%r14,%rbp,1),%r9
mov    %rbp,%rax
or     $0x1,%rax
add    %r14,%rax
movups (%rdi,%rax,4),%xmm0
lea    0x0(,%r9,4),%r10
mov    %r10,%rdx
or     $0x8,%rdx
movups (%rdi,%rdx,1),%xmm1
addps  %xmm0,%xmm1
movups -0x7c(%rdi,%r9,4),%xmm0
movups (%rdi,%r9,4),%xmm2
addps  %xmm1,%xmm2
movups 0x84(%rdi,%r9,4),%xmm1
addps  %xmm2,%xmm1
addps  %xmm0,%xmm1
movups -0x1000(%rdi,%rax,4),%xmm0
ff
addps  %xmm1,%xmm0
movups 0x1000(%rdi,%rax,4),%xmm1
addps  %xmm0,%xmm1
movups %xmm1,(%rsi,%rax,4)
mov    %rbp,%rax
or     $0x5,%rax
add    %r14,%rax
movups (%rdi,%rax,4),%xmm0
mov    %r10,%rdx
or     $0x18,%rdx
movups (%rdi,%rdx,1),%xmm1
addps  %xmm0,%xmm1
mov    %r10,%rdx
or     $0x10,%rdx
movups (%rdi,%rdx,1),%xmm0
addps  %xmm1,%xmm0
movups -0x6c(%rdi,%r9,4),%xmm1
movups 0x94(%rdi,%r9,4),%xmm2
addps  %xmm0,%xmm2
addps  %xmm1,%xmm2
movups -0x1000(%rdi,%rax,4),%xmm0
ff
addps  %xmm2,%xmm0
movups 0x1000(%rdi,%rax,4),%xmm1
addps  %xmm0,%xmm1
movups %xmm1,(%rsi,%rax,4)
mov    %rbp,%rax
or     $0x9,%rax
add    %r14,%rax
movups (%rdi,%rax,4),%xmm0
mov    %r10,%rdx
or     $0x28,%rdx
movups (%rdi,%rdx,1),%xmm1
addps  %xmm0,%xmm1
mov    %r10,%rdx
or     $0x20,%rdx
movups (%rdi,%rdx,1),%xmm0
addps  %xmm1,%xmm0
movups -0x5c(%rdi,%r9,4),%xmm1
movups 0xa4(%rdi,%r9,4),%xmm2
addps  %xmm0,%xmm2
addps  %xmm1,%xmm2
movups -0x1000(%rdi,%rax,4),%xmm0
ff
addps  %xmm2,%xmm0
movups 0x1000(%rdi,%rax,4),%xmm1
addps  %xmm0,%xmm1
movups %xmm1,(%rsi,%rax,4)
mov    %rbp,%rax
or     $0xd,%rax
add    %r14,%rax
movups (%rdi,%rax,4),%xmm0
mov    %r10,%rdx
or     $0x38,%rdx
movups (%rdi,%rdx,1),%xmm1
addps  %xmm0,%xmm1
mov    %r10,%rdx
or     $0x30,%rdx
movups (%rdi,%rdx,1),%xmm0
addps  %xmm1,%xmm0
movups -0x4c(%rdi,%r9,4),%xmm1
movups 0xb4(%rdi,%r9,4),%xmm2
addps  %xmm0,%xmm2
addps  %xmm1,%xmm2
movups -0x1000(%rdi,%rax,4),%xmm0
ff
addps  %xmm2,%xmm0
movups 0x1000(%rdi,%rax,4),%xmm1
addps  %xmm0,%xmm1
movups %xmm1,(%rsi,%rax,4)
mov    %rbp,%rax
or     $0x11,%rax
add    %r14,%rax
movups (%rdi,%rax,4),%xmm0
mov    %r10,%rdx
or     $0x48,%rdx
movups (%rdi,%rdx,1),%xmm1
addps  %xmm0,%xmm1
mov    %r10,%rdx
or     $0x40,%rdx
movups (%rdi,%rdx,1),%xmm0
addps  %xmm1,%xmm0
movups -0x3c(%rdi,%r9,4),%xmm1
movups 0xc4(%rdi,%r9,4),%xmm2
addps  %xmm0,%xmm2
addps  %xmm1,%xmm2
movups -0x1000(%rdi,%rax,4),%xmm0
ff
addps  %xmm2,%xmm0
movups 0x1000(%rdi,%rax,4),%xmm1
addps  %xmm0,%xmm1
movups %xmm1,(%rsi,%rax,4)
mov    %rbp,%rax
or     $0x15,%rax
add    %r14,%rax
movups (%rdi,%rax,4),%xmm0
mov    %r10,%rdx
or     $0x58,%rdx
movups (%rdi,%rdx,1),%xmm1
addps  %xmm0,%xmm1
mov    %r10,%rdx
or     $0x50,%rdx
movups (%rdi,%rdx,1),%xmm0
addps  %xmm1,%xmm0
movups -0x2c(%rdi,%r9,4),%xmm1
movups 0xd4(%rdi,%r9,4),%xmm2
addps  %xmm0,%xmm2
addps  %xmm1,%xmm2
movups -0x1000(%rdi,%rax,4),%xmm0
ff
addps  %xmm2,%xmm0
movups 0x1000(%rdi,%rax,4),%xmm1
addps  %xmm0,%xmm1
movups %xmm1,(%rsi,%rax,4)
or     $0x19,%rbp
add    %r14,%rbp
movups (%rdi,%rbp,4),%xmm0
mov    %r10,%rax
or     $0x68,%rax
movups (%rdi,%rax,1),%xmm1
addps  %xmm0,%xmm1
or     $0x60,%r10
movups (%rdi,%r10,1),%xmm0
addps  %xmm1,%xmm0
movups -0x1c(%rdi,%r9,4),%xmm1
movups 0xe4(%rdi,%r9,4),%xmm2
addps  %xmm0,%xmm2
addps  %xmm1,%xmm2
movups -0x1000(%rdi,%rbp,4),%xmm0
ff
addps  %xmm2,%xmm0
movups 0x1000(%rdi,%rbp,4),%xmm1
addps  %xmm0,%xmm1
movups %xmm1,(%rsi,%rbp,4)
mov    $0x1d,%ebp
nopw   0x0(%rax,%rax,1)
movss  0x4(%rcx,%rbp,4),%xmm0
addss  0x8(%rcx,%rbp,4),%xmm0
addss  (%rcx,%rbp,4),%xmm0
addss  0x84(%rcx,%rbp,4),%xmm0
addss  -0x7c(%rcx,%rbp,4),%xmm0
addss  -0xffc(%rcx,%rbp,4),%xmm0
ff ff
addss  0x1004(%rcx,%rbp,4),%xmm0
movss  %xmm0,(%rbx,%rbp,4)
lea    0x1(%rbp),%rax
mov    %rax,%rbp
cmp    $0x1f,%rax
jne    1440 <kernel+0x340>
add    $0x1,%r8
add    $0x1,%r11
sub    $0xffffffffffffff80,%rcx
sub    $0xffffffffffffff80,%rbx
cmp    $0x1f,%r8
jne    1180 <kernel+0x80>
mov    -0x20(%rsp),%r14
add    $0x1,%r14
mov    -0x28(%rsp),%r13
add    $0x1,%r13
mov    -0x10(%rsp),%rcx
add    $0x1000,%rcx
mov    -0x18(%rsp),%rbx
add    $0x1000,%rbx
cmp    $0x1f,%r14
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) {
%3 = alloca float*
%4 = alloca float*
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca float
store float* %0, float** %3
store float* %1, float** %4
store i32 1, i32* %8
%10 = load i32, i32* %8
store i32 %10, i32* %7
br label %11
11: ; preds = %147, %2
%12 = load i32, i32* %7
%13 = load i32, i32* %8
%14 = sub nsw i32 32, %13
%15 = icmp slt i32 %12, %14
br i1 %15, label %16, label %150
16: ; preds = %11
%17 = load i32, i32* %8
store i32 %17, i32* %6
br label %18
18: ; preds = %143, %16
%19 = load i32, i32* %6
%20 = load i32, i32* %8
%21 = sub nsw i32 32, %20
%22 = icmp slt i32 %19, %21
br i1 %22, label %23, label %146
23: ; preds = %18
%24 = load i32, i32* %8
store i32 %24, i32* %5
br label %25
25: ; preds = %139, %23
%26 = load i32, i32* %5
%27 = load i32, i32* %8
%28 = sub nsw i32 32, %27
%29 = icmp slt i32 %26, %28
br i1 %29, label %30, label %142
30: ; preds = %25
%31 = load float*, float** %3
%32 = load i32, i32* %5
%33 = load i32, i32* %6
%34 = mul nsw i32 %33, 32
%35 = add nsw i32 %32, %34
%36 = load i32, i32* %7
%37 = mul nsw i32 %36, 32
%38 = mul nsw i32 %37, 32
%39 = add nsw i32 %35, %38
%40 = sext i32 %39 to i64
%41 = getelementptr inbounds float, float* %31, i64 %40
%42 = load float, float* %41
%43 = load float*, float** %3
%44 = load i32, i32* %5
%45 = add nsw i32 %44, 1
%46 = load i32, i32* %6
%47 = mul nsw i32 %46, 32
%48 = add nsw i32 %45, %47
%49 = load i32, i32* %7
%50 = mul nsw i32 %49, 32
%51 = mul nsw i32 %50, 32
%52 = add nsw i32 %48, %51
%53 = sext i32 %52 to i64
%54 = getelementptr inbounds float, float* %43, i64 %53
%55 = load float, float* %54
%56 = fadd float %42, %55
%57 = load float*, float** %3
%58 = load i32, i32* %5
%59 = sub nsw i32 %58, 1
%60 = load i32, i32* %6
%61 = mul nsw i32 %60, 32
%62 = add nsw i32 %59, %61
%63 = load i32, i32* %7
%64 = mul nsw i32 %63, 32
%65 = mul nsw i32 %64, 32
%66 = add nsw i32 %62, %65
%67 = sext i32 %66 to i64
%68 = getelementptr inbounds float, float* %57, i64 %67
%69 = load float, float* %68
%70 = fadd float %56, %69
%71 = load float*, float** %3
%72 = load i32, i32* %5
%73 = load i32, i32* %6
%74 = add nsw i32 %73, 1
%75 = mul nsw i32 %74, 32
%76 = add nsw i32 %72, %75
%77 = load i32, i32* %7
%78 = mul nsw i32 %77, 32
%79 = mul nsw i32 %78, 32
%80 = add nsw i32 %76, %79
%81 = sext i32 %80 to i64
%82 = getelementptr inbounds float, float* %71, i64 %81
%83 = load float, float* %82
%84 = fadd float %70, %83
%85 = load float*, float** %3
%86 = load i32, i32* %5
%87 = load i32, i32* %6
%88 = sub nsw i32 %87, 1
%89 = mul nsw i32 %88, 32
%90 = add nsw i32 %86, %89
%91 = load i32, i32* %7
%92 = mul nsw i32 %91, 32
%93 = mul nsw i32 %92, 32
%94 = add nsw i32 %90, %93
%95 = sext i32 %94 to i64
%96 = getelementptr inbounds float, float* %85, i64 %95
%97 = load float, float* %96
%98 = fadd float %84, %97
%99 = load float*, float** %3
%100 = load i32, i32* %5
%101 = load i32, i32* %6
%102 = mul nsw i32 %101, 32
%103 = add nsw i32 %100, %102
%104 = load i32, i32* %7
%105 = sub nsw i32 %104, 1
%106 = mul nsw i32 %105, 32
%107 = mul nsw i32 %106, 32
%108 = add nsw i32 %103, %107
%109 = sext i32 %108 to i64
%110 = getelementptr inbounds float, float* %99, i64 %109
%111 = load float, float* %110
%112 = fadd float %98, %111
%113 = load float*, float** %3
%114 = load i32, i32* %5
%115 = load i32, i32* %6
%116 = mul nsw i32 %115, 32
%117 = add nsw i32 %114, %116
%118 = load i32, i32* %7
%119 = add nsw i32 %118, 1
%120 = mul nsw i32 %119, 32
%121 = mul nsw i32 %120, 32
%122 = add nsw i32 %117, %121
%123 = sext i32 %122 to i64
%124 = getelementptr inbounds float, float* %113, i64 %123
%125 = load float, float* %124
%126 = fadd float %112, %125
store float %126, float* %9
%127 = load float, float* %9
%128 = load float*, float** %4
%129 = load i32, i32* %5
%130 = load i32, i32* %6
%131 = mul nsw i32 %130, 32
%132 = add nsw i32 %129, %131
%133 = load i32, i32* %7
%134 = mul nsw i32 %133, 32
%135 = mul nsw i32 %134, 32
%136 = add nsw i32 %132, %135
%137 = sext i32 %136 to i64
%138 = getelementptr inbounds float, float* %128, i64 %137
store float %127, float* %138
br label %139
139: ; preds = %30
%140 = load i32, i32* %5
%141 = add nsw i32 %140, 1
store i32 %141, i32* %5
br label %25
142: ; preds = %25
br label %143
143: ; preds = %142
%144 = load i32, i32* %6
%145 = add nsw i32 %144, 1
store i32 %145, i32* %6
br label %18
146: ; preds = %18
br label %147
147: ; preds = %146
%148 = load i32, i32* %7
%149 = add nsw i32 %148, 1
store i32 %149, i32* %7
br label %11
150: ; preds = %11
ret void
}

LLVM IR (-O2):
define void @kernel(float* nocapture %0, float* nocapture writeonly %1) {
br label %3
3: ; preds = %2, %330
%4 = phi i64 [ 0, %2 ], [ %333, %330 ]
%5 = phi i64 [ 1, %2 ], [ %331, %330 ]
%6 = shl nuw nsw i64 %4, 10
%7 = add i64 %6, 1057
%8 = add i64 %6, 1087
%9 = or i64 %6, 33
%10 = add i64 %6, 2111
%11 = shl nsw i64 %5, 10
br label %12
12: ; preds = %3, %326
%13 = phi i64 [ 0, %3 ], [ %329, %326 ]
%14 = phi i64 [ 1, %3 ], [ %327, %326 ]
%15 = shl nuw nsw i64 %13, 5
%16 = shl nsw i64 %14, 5
%17 = add nuw nsw i64 %16, %11
%18 = add nsw i64 %17, -1
%19 = add nuw nsw i64 %17, 32
%20 = add nsw i64 %17, -32
%21 = add i64 %10, %15
%22 = getelementptr float, float* %0, i64 %21
%23 = add i64 %9, %15
%24 = getelementptr float, float* %0, i64 %23
%25 = add i64 %8, %15
%26 = getelementptr float, float* %1, i64 %25
%27 = add i64 %7, %15
%28 = getelementptr float, float* %1, i64 %27
%29 = icmp ult float* %28, %22
%30 = icmp ult float* %24, %26
%31 = and i1 %29, %30
br i1 %31, label %291, label %32
32: ; preds = %12
%33 = or i64 %16, 1
%34 = add nuw nsw i64 %33, %11
%35 = getelementptr inbounds float, float* %0, i64 %34
%36 = bitcast float* %35 to <4 x float>*
%37 = load <4 x float>, <4 x float>* %36
%38 = or i64 %17, 2
%39 = getelementptr inbounds float, float* %0, i64 %38
%40 = bitcast float* %39 to <4 x float>*
%41 = load <4 x float>, <4 x float>* %40
%42 = fadd <4 x float> %37, %41
%43 = getelementptr inbounds float, float* %0, i64 %17
%44 = bitcast float* %43 to <4 x float>*
%45 = load <4 x float>, <4 x float>* %44
%46 = fadd <4 x float> %42, %45
%47 = add nuw nsw i64 %17, 33
%48 = getelementptr inbounds float, float* %0, i64 %47
%49 = bitcast float* %48 to <4 x float>*
%50 = load <4 x float>, <4 x float>* %49
%51 = fadd <4 x float> %46, %50
%52 = add nsw i64 %17, -31
%53 = getelementptr inbounds float, float* %0, i64 %52
%54 = bitcast float* %53 to <4 x float>*
%55 = load <4 x float>, <4 x float>* %54
%56 = fadd <4 x float> %51, %55
%57 = add nsw i64 %34, -1024
%58 = getelementptr inbounds float, float* %0, i64 %57
%59 = bitcast float* %58 to <4 x float>*
%60 = load <4 x float>, <4 x float>* %59
%61 = fadd <4 x float> %56, %60
%62 = add nuw nsw i64 %34, 1024
%63 = getelementptr inbounds float, float* %0, i64 %62
%64 = bitcast float* %63 to <4 x float>*
%65 = load <4 x float>, <4 x float>* %64
%66 = fadd <4 x float> %61, %65
%67 = getelementptr inbounds float, float* %1, i64 %34
%68 = bitcast float* %67 to <4 x float>*
store <4 x float> %66, <4 x float>* %68
%69 = or i64 %16, 5
%70 = add nuw nsw i64 %69, %11
%71 = getelementptr inbounds float, float* %0, i64 %70
%72 = bitcast float* %71 to <4 x float>*
%73 = load <4 x float>, <4 x float>* %72
%74 = or i64 %17, 6
%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 = fadd <4 x float> %73, %77
%79 = or i64 %17, 4
%80 = getelementptr inbounds float, float* %0, i64 %79
%81 = bitcast float* %80 to <4 x float>*
%82 = load <4 x float>, <4 x float>* %81
%83 = fadd <4 x float> %78, %82
%84 = add nuw nsw i64 %17, 37
%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 = fadd <4 x float> %83, %87
%89 = add nsw i64 %17, -27
%90 = getelementptr inbounds float, float* %0, i64 %89
%91 = bitcast float* %90 to <4 x float>*
%92 = load <4 x float>, <4 x float>* %91
%93 = fadd <4 x float> %88, %92
%94 = add nsw i64 %70, -1024
%95 = getelementptr inbounds float, float* %0, i64 %94
%96 = bitcast float* %95 to <4 x float>*
%97 = load <4 x float>, <4 x float>* %96
%98 = fadd <4 x float> %93, %97
%99 = add nuw nsw i64 %70, 1024
%100 = getelementptr inbounds float, float* %0, i64 %99
%101 = bitcast float* %100 to <4 x float>*
%102 = load <4 x float>, <4 x float>* %101
%103 = fadd <4 x float> %98, %102
%104 = getelementptr inbounds float, float* %1, i64 %70
%105 = bitcast float* %104 to <4 x float>*
store <4 x float> %103, <4 x float>* %105
%106 = or i64 %16, 9
%107 = add nuw nsw i64 %106, %11
%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 = or i64 %17, 10
%112 = getelementptr inbounds float, float* %0, i64 %111
%113 = bitcast float* %112 to <4 x float>*
%114 = load <4 x float>, <4 x float>* %113
%115 = fadd <4 x float> %110, %114
%116 = or i64 %17, 8
%117 = getelementptr inbounds float, float* %0, i64 %116
%118 = bitcast float* %117 to <4 x float>*
%119 = load <4 x float>, <4 x float>* %118
%120 = fadd <4 x float> %115, %119
%121 = add nuw nsw i64 %17, 41
%122 = getelementptr inbounds float, float* %0, i64 %121
%123 = bitcast float* %122 to <4 x float>*
%124 = load <4 x float>, <4 x float>* %123
%125 = fadd <4 x float> %120, %124
%126 = add nsw i64 %17, -23
%127 = getelementptr inbounds float, float* %0, i64 %126
%128 = bitcast float* %127 to <4 x float>*
%129 = load <4 x float>, <4 x float>* %128
%130 = fadd <4 x float> %125, %129
%131 = add nsw i64 %107, -1024
%132 = getelementptr inbounds float, float* %0, i64 %131
%133 = bitcast float* %132 to <4 x float>*
%134 = load <4 x float>, <4 x float>* %133
%135 = fadd <4 x float> %130, %134
%136 = add nuw nsw i64 %107, 1024
%137 = getelementptr inbounds float, float* %0, i64 %136
%138 = bitcast float* %137 to <4 x float>*
%139 = load <4 x float>, <4 x float>* %138
%140 = fadd <4 x float> %135, %139
%141 = getelementptr inbounds float, float* %1, i64 %107
%142 = bitcast float* %141 to <4 x float>*
store <4 x float> %140, <4 x float>* %142
%143 = or i64 %16, 13
%144 = add nuw nsw i64 %143, %11
%145 = getelementptr inbounds float, float* %0, i64 %144
%146 = bitcast float* %145 to <4 x float>*
%147 = load <4 x float>, <4 x float>* %146
%148 = or i64 %17, 14
%149 = getelementptr inbounds float, float* %0, i64 %148
%150 = bitcast float* %149 to <4 x float>*
%151 = load <4 x float>, <4 x float>* %150
%152 = fadd <4 x float> %147, %151
%153 = or i64 %17, 12
%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 = fadd <4 x float> %152, %156
%158 = add nuw nsw i64 %17, 45
%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 = fadd <4 x float> %157, %161
%163 = add nsw i64 %17, -19
%164 = getelementptr inbounds float, float* %0, i64 %163
%165 = bitcast float* %164 to <4 x float>*
%166 = load <4 x float>, <4 x float>* %165
%167 = fadd <4 x float> %162, %166
%168 = add nsw i64 %144, -1024
%169 = getelementptr inbounds float, float* %0, i64 %168
%170 = bitcast float* %169 to <4 x float>*
%171 = load <4 x float>, <4 x float>* %170
%172 = fadd <4 x float> %167, %171
%173 = add nuw nsw i64 %144, 1024
%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 = fadd <4 x float> %172, %176
%178 = getelementptr inbounds float, float* %1, i64 %144
%179 = bitcast float* %178 to <4 x float>*
store <4 x float> %177, <4 x float>* %179
%180 = or i64 %16, 17
%181 = add nuw nsw i64 %180, %11
%182 = getelementptr inbounds float, float* %0, i64 %181
%183 = bitcast float* %182 to <4 x float>*
%184 = load <4 x float>, <4 x float>* %183
%185 = or i64 %17, 18
%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 = fadd <4 x float> %184, %188
%190 = or i64 %17, 16
%191 = getelementptr inbounds float, float* %0, i64 %190
%192 = bitcast float* %191 to <4 x float>*
%193 = load <4 x float>, <4 x float>* %192
%194 = fadd <4 x float> %189, %193
%195 = add nuw nsw i64 %17, 49
%196 = getelementptr inbounds float, float* %0, i64 %195
%197 = bitcast float* %196 to <4 x float>*
%198 = load <4 x float>, <4 x float>* %197
%199 = fadd <4 x float> %194, %198
%200 = add nsw i64 %17, -15
%201 = getelementptr inbounds float, float* %0, i64 %200
%202 = bitcast float* %201 to <4 x float>*
%203 = load <4 x float>, <4 x float>* %202
%204 = fadd <4 x float> %199, %203
%205 = add nsw i64 %181, -1024
%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 = fadd <4 x float> %204, %208
%210 = add nuw nsw i64 %181, 1024
%211 = getelementptr inbounds float, float* %0, i64 %210
%212 = bitcast float* %211 to <4 x float>*
%213 = load <4 x float>, <4 x float>* %212
%214 = fadd <4 x float> %209, %213
%215 = getelementptr inbounds float, float* %1, i64 %181
%216 = bitcast float* %215 to <4 x float>*
store <4 x float> %214, <4 x float>* %216
%217 = or i64 %16, 21
%218 = add nuw nsw i64 %217, %11
%219 = getelementptr inbounds float, float* %0, i64 %218
%220 = bitcast float* %219 to <4 x float>*
%221 = load <4 x float>, <4 x float>* %220
%222 = or i64 %17, 22
%223 = getelementptr inbounds float, float* %0, i64 %222
%224 = bitcast float* %223 to <4 x float>*
%225 = load <4 x float>, <4 x float>* %224
%226 = fadd <4 x float> %221, %225
%227 = or i64 %17, 20
%228 = getelementptr inbounds float, float* %0, i64 %227
%229 = bitcast float* %228 to <4 x float>*
%230 = load <4 x float>, <4 x float>* %229
%231 = fadd <4 x float> %226, %230
%232 = add nuw nsw i64 %17, 53
%233 = getelementptr inbounds float, float* %0, i64 %232
%234 = bitcast float* %233 to <4 x float>*
%235 = load <4 x float>, <4 x float>* %234
%236 = fadd <4 x float> %231, %235
%237 = add nsw i64 %17, -11
%238 = getelementptr inbounds float, float* %0, i64 %237
%239 = bitcast float* %238 to <4 x float>*
%240 = load <4 x float>, <4 x float>* %239
%241 = fadd <4 x float> %236, %240
%242 = add nsw i64 %218, -1024
%243 = getelementptr inbounds float, float* %0, i64 %242
%244 = bitcast float* %243 to <4 x float>*
%245 = load <4 x float>, <4 x float>* %244
%246 = fadd <4 x float> %241, %245
%247 = add nuw nsw i64 %218, 1024
%248 = getelementptr inbounds float, float* %0, i64 %247
%249 = bitcast float* %248 to <4 x float>*
%250 = load <4 x float>, <4 x float>* %249
%251 = fadd <4 x float> %246, %250
%252 = getelementptr inbounds float, float* %1, i64 %218
%253 = bitcast float* %252 to <4 x float>*
store <4 x float> %251, <4 x float>* %253
%254 = or i64 %16, 25
%255 = add nuw nsw i64 %254, %11
%256 = getelementptr inbounds float, float* %0, i64 %255
%257 = bitcast float* %256 to <4 x float>*
%258 = load <4 x float>, <4 x float>* %257
%259 = or i64 %17, 26
%260 = getelementptr inbounds float, float* %0, i64 %259
%261 = bitcast float* %260 to <4 x float>*
%262 = load <4 x float>, <4 x float>* %261
%263 = fadd <4 x float> %258, %262
%264 = or i64 %17, 24
%265 = getelementptr inbounds float, float* %0, i64 %264
%266 = bitcast float* %265 to <4 x float>*
%267 = load <4 x float>, <4 x float>* %266
%268 = fadd <4 x float> %263, %267
%269 = add nuw nsw i64 %17, 57
%270 = getelementptr inbounds float, float* %0, i64 %269
%271 = bitcast float* %270 to <4 x float>*
%272 = load <4 x float>, <4 x float>* %271
%273 = fadd <4 x float> %268, %272
%274 = add nsw i64 %17, -7
%275 = getelementptr inbounds float, float* %0, i64 %274
%276 = bitcast float* %275 to <4 x float>*
%277 = load <4 x float>, <4 x float>* %276
%278 = fadd <4 x float> %273, %277
%279 = add nsw i64 %255, -1024
%280 = getelementptr inbounds float, float* %0, i64 %279
%281 = bitcast float* %280 to <4 x float>*
%282 = load <4 x float>, <4 x float>* %281
%283 = fadd <4 x float> %278, %282
%284 = add nuw nsw i64 %255, 1024
%285 = getelementptr inbounds float, float* %0, i64 %284
%286 = bitcast float* %285 to <4 x float>*
%287 = load <4 x float>, <4 x float>* %286
%288 = fadd <4 x float> %283, %287
%289 = getelementptr inbounds float, float* %1, i64 %255
%290 = bitcast float* %289 to <4 x float>*
store <4 x float> %288, <4 x float>* %290
br label %291
291: ; preds = %32, %12
%292 = phi i64 [ 1, %12 ], [ 29, %32 ]
br label %293
293: ; preds = %291, %293
%294 = phi i64 [ %299, %293 ], [ %292, %291 ]
%295 = add nuw nsw i64 %294, %16
%296 = add nuw nsw i64 %295, %11
%297 = getelementptr inbounds float, float* %0, i64 %296
%298 = load float, float* %297
%299 = add nuw nsw i64 %294, 1
%300 = add nuw nsw i64 %17, %299
%301 = getelementptr inbounds float, float* %0, i64 %300
%302 = load float, float* %301
%303 = fadd float %298, %302
%304 = add nuw nsw i64 %18, %294
%305 = getelementptr inbounds float, float* %0, i64 %304
%306 = load float, float* %305
%307 = fadd float %303, %306
%308 = add nuw nsw i64 %19, %294
%309 = getelementptr inbounds float, float* %0, i64 %308
%310 = load float, float* %309
%311 = fadd float %307, %310
%312 = add nuw nsw i64 %20, %294
%313 = getelementptr inbounds float, float* %0, i64 %312
%314 = load float, float* %313
%315 = fadd float %311, %314
%316 = add nsw i64 %296, -1024
%317 = getelementptr inbounds float, float* %0, i64 %316
%318 = load float, float* %317
%319 = fadd float %315, %318
%320 = add nuw nsw i64 %296, 1024
%321 = getelementptr inbounds float, float* %0, i64 %320
%322 = load float, float* %321
%323 = fadd float %319, %322
%324 = getelementptr inbounds float, float* %1, i64 %296
store float %323, float* %324
%325 = icmp eq i64 %299, 31
br i1 %325, label %326, label %293
326: ; preds = %293
%327 = add nuw nsw i64 %14, 1
%328 = icmp eq i64 %327, 31
%329 = add i64 %13, 1
br i1 %328, label %330, label %12
330: ; preds = %326
%331 = add nuw nsw i64 %5, 1
%332 = icmp eq i64 %331, 31
%333 = add i64 %4, 1
br i1 %332, label %334, label %3
334: ; preds = %330
ret void
}