void kernel(int *g1, int *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) {
        int 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    12aa <kernel+0x1aa>
mov    -0x20(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
mov    $0x20,%ecx
sub    -0x20(%rbp),%ecx
cmp    %ecx,%eax
jge    1297 <kernel+0x197>
mov    -0x20(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x20,%ecx
sub    -0x20(%rbp),%ecx
cmp    %ecx,%eax
jge    1284 <kernel+0x184>
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
mov    (%rax,%rcx,4),%eax
mov    -0x8(%rbp),%rcx
mov    -0x14(%rbp),%edx
add    $0x1,%edx
mov    -0x18(%rbp),%esi
shl    $0x5,%esi
add    %esi,%edx
mov    -0x1c(%rbp),%esi
shl    $0x5,%esi
shl    $0x5,%esi
add    %esi,%edx
movslq %edx,%rdx
add    (%rcx,%rdx,4),%eax
mov    -0x8(%rbp),%rcx
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
mov    -0x18(%rbp),%esi
shl    $0x5,%esi
add    %esi,%edx
mov    -0x1c(%rbp),%esi
shl    $0x5,%esi
shl    $0x5,%esi
add    %esi,%edx
movslq %edx,%rdx
add    (%rcx,%rdx,4),%eax
mov    -0x8(%rbp),%rcx
mov    -0x14(%rbp),%edx
mov    -0x18(%rbp),%esi
add    $0x1,%esi
shl    $0x5,%esi
add    %esi,%edx
mov    -0x1c(%rbp),%esi
shl    $0x5,%esi
shl    $0x5,%esi
add    %esi,%edx
movslq %edx,%rdx
add    (%rcx,%rdx,4),%eax
mov    -0x8(%rbp),%rcx
mov    -0x14(%rbp),%edx
mov    -0x18(%rbp),%esi
sub    $0x1,%esi
shl    $0x5,%esi
add    %esi,%edx
mov    -0x1c(%rbp),%esi
shl    $0x5,%esi
shl    $0x5,%esi
add    %esi,%edx
movslq %edx,%rdx
add    (%rcx,%rdx,4),%eax
mov    -0x8(%rbp),%rcx
mov    -0x14(%rbp),%edx
mov    -0x18(%rbp),%esi
shl    $0x5,%esi
add    %esi,%edx
mov    -0x1c(%rbp),%esi
sub    $0x1,%esi
shl    $0x5,%esi
shl    $0x5,%esi
add    %esi,%edx
movslq %edx,%rdx
add    (%rcx,%rdx,4),%eax
mov    -0x8(%rbp),%rcx
mov    -0x14(%rbp),%edx
mov    -0x18(%rbp),%esi
shl    $0x5,%esi
add    %esi,%edx
mov    -0x1c(%rbp),%esi
add    $0x1,%esi
shl    $0x5,%esi
shl    $0x5,%esi
add    %esi,%edx
movslq %edx,%rdx
add    (%rcx,%rdx,4),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%edx
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    -0x18(%rbp),%esi
shl    $0x5,%esi
add    %esi,%ecx
mov    -0x1c(%rbp),%esi
shl    $0x5,%esi
shl    $0x5,%esi
add    %esi,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    114b <kernel+0x4b>
jmp    1289 <kernel+0x189>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1132 <kernel+0x32>
jmp    129c <kernel+0x19c>
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     14a0 <kernel+0x3a0>
mov    %r8,%rbp
shl    $0x5,%rbp
lea    (%r14,%rbp,1),%r9
mov    %rbp,%rax
or     $0x1,%rax
add    %r14,%rax
movdqu (%rdi,%rax,4),%xmm0
lea    0x0(,%r9,4),%r10
mov    %r10,%rdx
or     $0x8,%rdx
movdqu (%rdi,%rdx,1),%xmm1
movdqu -0x7c(%rdi,%r9,4),%xmm2
movdqu (%rdi,%r9,4),%xmm3
paddd  %xmm0,%xmm3
paddd  %xmm1,%xmm3
movdqu 0x84(%rdi,%r9,4),%xmm0
paddd  %xmm2,%xmm0
movdqu -0x1000(%rdi,%rax,4),%xmm1
ff ff
paddd  %xmm0,%xmm1
movdqu 0x1000(%rdi,%rax,4),%xmm0
paddd  %xmm1,%xmm0
paddd  %xmm3,%xmm0
movdqu %xmm0,(%rsi,%rax,4)
mov    %rbp,%rax
or     $0x5,%rax
add    %r14,%rax
movdqu (%rdi,%rax,4),%xmm0
mov    %r10,%rdx
or     $0x18,%rdx
movdqu (%rdi,%rdx,1),%xmm1
paddd  %xmm0,%xmm1
mov    %r10,%rdx
or     $0x10,%rdx
movdqu (%rdi,%rdx,1),%xmm0
movdqu -0x6c(%rdi,%r9,4),%xmm2
movdqu 0x94(%rdi,%r9,4),%xmm3
paddd  %xmm0,%xmm3
paddd  %xmm1,%xmm3
movdqu -0x1000(%rdi,%rax,4),%xmm0
ff ff
paddd  %xmm2,%xmm0
movdqu 0x1000(%rdi,%rax,4),%xmm1
paddd  %xmm0,%xmm1
paddd  %xmm3,%xmm1
movdqu %xmm1,(%rsi,%rax,4)
mov    %rbp,%rax
or     $0x9,%rax
add    %r14,%rax
movdqu (%rdi,%rax,4),%xmm0
mov    %r10,%rdx
or     $0x28,%rdx
movdqu (%rdi,%rdx,1),%xmm1
paddd  %xmm0,%xmm1
mov    %r10,%rdx
or     $0x20,%rdx
movdqu (%rdi,%rdx,1),%xmm0
movdqu -0x5c(%rdi,%r9,4),%xmm2
movdqu 0xa4(%rdi,%r9,4),%xmm3
paddd  %xmm0,%xmm3
paddd  %xmm1,%xmm3
movdqu -0x1000(%rdi,%rax,4),%xmm0
ff ff
paddd  %xmm2,%xmm0
movdqu 0x1000(%rdi,%rax,4),%xmm1
paddd  %xmm0,%xmm1
paddd  %xmm3,%xmm1
movdqu %xmm1,(%rsi,%rax,4)
mov    %rbp,%rax
or     $0xd,%rax
add    %r14,%rax
movdqu (%rdi,%rax,4),%xmm0
mov    %r10,%rdx
or     $0x38,%rdx
movdqu (%rdi,%rdx,1),%xmm1
paddd  %xmm0,%xmm1
mov    %r10,%rdx
or     $0x30,%rdx
movdqu (%rdi,%rdx,1),%xmm0
movdqu -0x4c(%rdi,%r9,4),%xmm2
movdqu 0xb4(%rdi,%r9,4),%xmm3
paddd  %xmm0,%xmm3
paddd  %xmm1,%xmm3
movdqu -0x1000(%rdi,%rax,4),%xmm0
ff ff
paddd  %xmm2,%xmm0
movdqu 0x1000(%rdi,%rax,4),%xmm1
paddd  %xmm0,%xmm1
paddd  %xmm3,%xmm1
movdqu %xmm1,(%rsi,%rax,4)
mov    %rbp,%rax
or     $0x11,%rax
add    %r14,%rax
movdqu (%rdi,%rax,4),%xmm0
mov    %r10,%rdx
or     $0x48,%rdx
movdqu (%rdi,%rdx,1),%xmm1
paddd  %xmm0,%xmm1
mov    %r10,%rdx
or     $0x40,%rdx
movdqu (%rdi,%rdx,1),%xmm0
movdqu -0x3c(%rdi,%r9,4),%xmm2
movdqu 0xc4(%rdi,%r9,4),%xmm3
paddd  %xmm0,%xmm3
paddd  %xmm1,%xmm3
movdqu -0x1000(%rdi,%rax,4),%xmm0
ff ff
paddd  %xmm2,%xmm0
movdqu 0x1000(%rdi,%rax,4),%xmm1
paddd  %xmm0,%xmm1
paddd  %xmm3,%xmm1
movdqu %xmm1,(%rsi,%rax,4)
mov    %rbp,%rax
or     $0x15,%rax
add    %r14,%rax
movdqu (%rdi,%rax,4),%xmm0
mov    %r10,%rdx
or     $0x58,%rdx
movdqu (%rdi,%rdx,1),%xmm1
paddd  %xmm0,%xmm1
mov    %r10,%rdx
or     $0x50,%rdx
movdqu (%rdi,%rdx,1),%xmm0
movdqu -0x2c(%rdi,%r9,4),%xmm2
movdqu 0xd4(%rdi,%r9,4),%xmm3
paddd  %xmm0,%xmm3
paddd  %xmm1,%xmm3
movdqu -0x1000(%rdi,%rax,4),%xmm0
ff ff
paddd  %xmm2,%xmm0
movdqu 0x1000(%rdi,%rax,4),%xmm1
paddd  %xmm0,%xmm1
paddd  %xmm3,%xmm1
movdqu %xmm1,(%rsi,%rax,4)
or     $0x19,%rbp
add    %r14,%rbp
movdqu (%rdi,%rbp,4),%xmm0
mov    %r10,%rax
or     $0x68,%rax
movdqu (%rdi,%rax,1),%xmm1
paddd  %xmm0,%xmm1
or     $0x60,%r10
movdqu (%rdi,%r10,1),%xmm0
movdqu -0x1c(%rdi,%r9,4),%xmm2
movdqu 0xe4(%rdi,%r9,4),%xmm3
paddd  %xmm0,%xmm3
paddd  %xmm1,%xmm3
movdqu -0x1000(%rdi,%rbp,4),%xmm0
ff ff
paddd  %xmm2,%xmm0
movdqu 0x1000(%rdi,%rbp,4),%xmm1
paddd  %xmm0,%xmm1
paddd  %xmm3,%xmm1
movdqu %xmm1,(%rsi,%rbp,4)
mov    $0x1d,%ebp
nopl   0x0(%rax)
mov    0x8(%rcx,%rbp,4),%eax
add    0x4(%rcx,%rbp,4),%eax
add    (%rcx,%rbp,4),%eax
add    0x84(%rcx,%rbp,4),%eax
add    -0x7c(%rcx,%rbp,4),%eax
add    -0xffc(%rcx,%rbp,4),%eax
add    0x1004(%rcx,%rbp,4),%eax
mov    %eax,(%rbx,%rbp,4)
lea    0x1(%rbp),%rax
mov    %rax,%rbp
cmp    $0x1f,%rax
jne    14a0 <kernel+0x3a0>
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(i32* %0, i32* %1) {
%3 = alloca i32*
%4 = alloca i32*
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
store i32* %0, i32** %3
store i32* %1, i32** %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 i32*, i32** %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 i32, i32* %31, i64 %40
%42 = load i32, i32* %41
%43 = load i32*, i32** %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 i32, i32* %43, i64 %53
%55 = load i32, i32* %54
%56 = add nsw i32 %42, %55
%57 = load i32*, i32** %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 i32, i32* %57, i64 %67
%69 = load i32, i32* %68
%70 = add nsw i32 %56, %69
%71 = load i32*, i32** %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 i32, i32* %71, i64 %81
%83 = load i32, i32* %82
%84 = add nsw i32 %70, %83
%85 = load i32*, i32** %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 i32, i32* %85, i64 %95
%97 = load i32, i32* %96
%98 = add nsw i32 %84, %97
%99 = load i32*, i32** %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 i32, i32* %99, i64 %109
%111 = load i32, i32* %110
%112 = add nsw i32 %98, %111
%113 = load i32*, i32** %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 i32, i32* %113, i64 %123
%125 = load i32, i32* %124
%126 = add nsw i32 %112, %125
store i32 %126, i32* %9
%127 = load i32, i32* %9
%128 = load i32*, i32** %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 i32, i32* %128, i64 %137
store i32 %127, i32* %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(i32* nocapture %0, i32* 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 i32, i32* %0, i64 %21
%23 = add i64 %9, %15
%24 = getelementptr i32, i32* %0, i64 %23
%25 = add i64 %8, %15
%26 = getelementptr i32, i32* %1, i64 %25
%27 = add i64 %7, %15
%28 = getelementptr i32, i32* %1, i64 %27
%29 = icmp ult i32* %28, %22
%30 = icmp ult i32* %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 i32, i32* %0, i64 %34
%36 = bitcast i32* %35 to <4 x i32>*
%37 = load <4 x i32>, <4 x i32>* %36
%38 = or i64 %17, 2
%39 = getelementptr inbounds i32, i32* %0, i64 %38
%40 = bitcast i32* %39 to <4 x i32>*
%41 = load <4 x i32>, <4 x i32>* %40
%42 = add nsw <4 x i32> %41, %37
%43 = getelementptr inbounds i32, i32* %0, i64 %17
%44 = bitcast i32* %43 to <4 x i32>*
%45 = load <4 x i32>, <4 x i32>* %44
%46 = add nsw <4 x i32> %42, %45
%47 = add nuw nsw i64 %17, 33
%48 = getelementptr inbounds i32, i32* %0, i64 %47
%49 = bitcast i32* %48 to <4 x i32>*
%50 = load <4 x i32>, <4 x i32>* %49
%51 = add nsw <4 x i32> %46, %50
%52 = add nsw i64 %17, -31
%53 = getelementptr inbounds i32, i32* %0, i64 %52
%54 = bitcast i32* %53 to <4 x i32>*
%55 = load <4 x i32>, <4 x i32>* %54
%56 = add nsw <4 x i32> %51, %55
%57 = add nsw i64 %34, -1024
%58 = getelementptr inbounds i32, i32* %0, i64 %57
%59 = bitcast i32* %58 to <4 x i32>*
%60 = load <4 x i32>, <4 x i32>* %59
%61 = add nsw <4 x i32> %56, %60
%62 = add nuw nsw i64 %34, 1024
%63 = getelementptr inbounds i32, i32* %0, i64 %62
%64 = bitcast i32* %63 to <4 x i32>*
%65 = load <4 x i32>, <4 x i32>* %64
%66 = add nsw <4 x i32> %61, %65
%67 = getelementptr inbounds i32, i32* %1, i64 %34
%68 = bitcast i32* %67 to <4 x i32>*
store <4 x i32> %66, <4 x i32>* %68
%69 = or i64 %16, 5
%70 = add nuw nsw i64 %69, %11
%71 = getelementptr inbounds i32, i32* %0, i64 %70
%72 = bitcast i32* %71 to <4 x i32>*
%73 = load <4 x i32>, <4 x i32>* %72
%74 = or i64 %17, 6
%75 = getelementptr inbounds i32, i32* %0, i64 %74
%76 = bitcast i32* %75 to <4 x i32>*
%77 = load <4 x i32>, <4 x i32>* %76
%78 = add nsw <4 x i32> %77, %73
%79 = or i64 %17, 4
%80 = getelementptr inbounds i32, i32* %0, i64 %79
%81 = bitcast i32* %80 to <4 x i32>*
%82 = load <4 x i32>, <4 x i32>* %81
%83 = add nsw <4 x i32> %78, %82
%84 = add nuw nsw i64 %17, 37
%85 = getelementptr inbounds i32, i32* %0, i64 %84
%86 = bitcast i32* %85 to <4 x i32>*
%87 = load <4 x i32>, <4 x i32>* %86
%88 = add nsw <4 x i32> %83, %87
%89 = add nsw i64 %17, -27
%90 = getelementptr inbounds i32, i32* %0, i64 %89
%91 = bitcast i32* %90 to <4 x i32>*
%92 = load <4 x i32>, <4 x i32>* %91
%93 = add nsw <4 x i32> %88, %92
%94 = add nsw i64 %70, -1024
%95 = getelementptr inbounds i32, i32* %0, i64 %94
%96 = bitcast i32* %95 to <4 x i32>*
%97 = load <4 x i32>, <4 x i32>* %96
%98 = add nsw <4 x i32> %93, %97
%99 = add nuw nsw i64 %70, 1024
%100 = getelementptr inbounds i32, i32* %0, i64 %99
%101 = bitcast i32* %100 to <4 x i32>*
%102 = load <4 x i32>, <4 x i32>* %101
%103 = add nsw <4 x i32> %98, %102
%104 = getelementptr inbounds i32, i32* %1, i64 %70
%105 = bitcast i32* %104 to <4 x i32>*
store <4 x i32> %103, <4 x i32>* %105
%106 = or i64 %16, 9
%107 = add nuw nsw i64 %106, %11
%108 = getelementptr inbounds i32, i32* %0, i64 %107
%109 = bitcast i32* %108 to <4 x i32>*
%110 = load <4 x i32>, <4 x i32>* %109
%111 = or i64 %17, 10
%112 = getelementptr inbounds i32, i32* %0, i64 %111
%113 = bitcast i32* %112 to <4 x i32>*
%114 = load <4 x i32>, <4 x i32>* %113
%115 = add nsw <4 x i32> %114, %110
%116 = or i64 %17, 8
%117 = getelementptr inbounds i32, i32* %0, i64 %116
%118 = bitcast i32* %117 to <4 x i32>*
%119 = load <4 x i32>, <4 x i32>* %118
%120 = add nsw <4 x i32> %115, %119
%121 = add nuw nsw i64 %17, 41
%122 = getelementptr inbounds i32, i32* %0, i64 %121
%123 = bitcast i32* %122 to <4 x i32>*
%124 = load <4 x i32>, <4 x i32>* %123
%125 = add nsw <4 x i32> %120, %124
%126 = add nsw i64 %17, -23
%127 = getelementptr inbounds i32, i32* %0, i64 %126
%128 = bitcast i32* %127 to <4 x i32>*
%129 = load <4 x i32>, <4 x i32>* %128
%130 = add nsw <4 x i32> %125, %129
%131 = add nsw i64 %107, -1024
%132 = getelementptr inbounds i32, i32* %0, i64 %131
%133 = bitcast i32* %132 to <4 x i32>*
%134 = load <4 x i32>, <4 x i32>* %133
%135 = add nsw <4 x i32> %130, %134
%136 = add nuw nsw i64 %107, 1024
%137 = getelementptr inbounds i32, i32* %0, i64 %136
%138 = bitcast i32* %137 to <4 x i32>*
%139 = load <4 x i32>, <4 x i32>* %138
%140 = add nsw <4 x i32> %135, %139
%141 = getelementptr inbounds i32, i32* %1, i64 %107
%142 = bitcast i32* %141 to <4 x i32>*
store <4 x i32> %140, <4 x i32>* %142
%143 = or i64 %16, 13
%144 = add nuw nsw i64 %143, %11
%145 = getelementptr inbounds i32, i32* %0, i64 %144
%146 = bitcast i32* %145 to <4 x i32>*
%147 = load <4 x i32>, <4 x i32>* %146
%148 = or i64 %17, 14
%149 = getelementptr inbounds i32, i32* %0, i64 %148
%150 = bitcast i32* %149 to <4 x i32>*
%151 = load <4 x i32>, <4 x i32>* %150
%152 = add nsw <4 x i32> %151, %147
%153 = or i64 %17, 12
%154 = getelementptr inbounds i32, i32* %0, i64 %153
%155 = bitcast i32* %154 to <4 x i32>*
%156 = load <4 x i32>, <4 x i32>* %155
%157 = add nsw <4 x i32> %152, %156
%158 = add nuw nsw i64 %17, 45
%159 = getelementptr inbounds i32, i32* %0, i64 %158
%160 = bitcast i32* %159 to <4 x i32>*
%161 = load <4 x i32>, <4 x i32>* %160
%162 = add nsw <4 x i32> %157, %161
%163 = add nsw i64 %17, -19
%164 = getelementptr inbounds i32, i32* %0, i64 %163
%165 = bitcast i32* %164 to <4 x i32>*
%166 = load <4 x i32>, <4 x i32>* %165
%167 = add nsw <4 x i32> %162, %166
%168 = add nsw i64 %144, -1024
%169 = getelementptr inbounds i32, i32* %0, i64 %168
%170 = bitcast i32* %169 to <4 x i32>*
%171 = load <4 x i32>, <4 x i32>* %170
%172 = add nsw <4 x i32> %167, %171
%173 = add nuw nsw i64 %144, 1024
%174 = getelementptr inbounds i32, i32* %0, i64 %173
%175 = bitcast i32* %174 to <4 x i32>*
%176 = load <4 x i32>, <4 x i32>* %175
%177 = add nsw <4 x i32> %172, %176
%178 = getelementptr inbounds i32, i32* %1, i64 %144
%179 = bitcast i32* %178 to <4 x i32>*
store <4 x i32> %177, <4 x i32>* %179
%180 = or i64 %16, 17
%181 = add nuw nsw i64 %180, %11
%182 = getelementptr inbounds i32, i32* %0, i64 %181
%183 = bitcast i32* %182 to <4 x i32>*
%184 = load <4 x i32>, <4 x i32>* %183
%185 = or i64 %17, 18
%186 = getelementptr inbounds i32, i32* %0, i64 %185
%187 = bitcast i32* %186 to <4 x i32>*
%188 = load <4 x i32>, <4 x i32>* %187
%189 = add nsw <4 x i32> %188, %184
%190 = or i64 %17, 16
%191 = getelementptr inbounds i32, i32* %0, i64 %190
%192 = bitcast i32* %191 to <4 x i32>*
%193 = load <4 x i32>, <4 x i32>* %192
%194 = add nsw <4 x i32> %189, %193
%195 = add nuw nsw i64 %17, 49
%196 = getelementptr inbounds i32, i32* %0, i64 %195
%197 = bitcast i32* %196 to <4 x i32>*
%198 = load <4 x i32>, <4 x i32>* %197
%199 = add nsw <4 x i32> %194, %198
%200 = add nsw i64 %17, -15
%201 = getelementptr inbounds i32, i32* %0, i64 %200
%202 = bitcast i32* %201 to <4 x i32>*
%203 = load <4 x i32>, <4 x i32>* %202
%204 = add nsw <4 x i32> %199, %203
%205 = add nsw i64 %181, -1024
%206 = getelementptr inbounds i32, i32* %0, i64 %205
%207 = bitcast i32* %206 to <4 x i32>*
%208 = load <4 x i32>, <4 x i32>* %207
%209 = add nsw <4 x i32> %204, %208
%210 = add nuw nsw i64 %181, 1024
%211 = getelementptr inbounds i32, i32* %0, i64 %210
%212 = bitcast i32* %211 to <4 x i32>*
%213 = load <4 x i32>, <4 x i32>* %212
%214 = add nsw <4 x i32> %209, %213
%215 = getelementptr inbounds i32, i32* %1, i64 %181
%216 = bitcast i32* %215 to <4 x i32>*
store <4 x i32> %214, <4 x i32>* %216
%217 = or i64 %16, 21
%218 = add nuw nsw i64 %217, %11
%219 = getelementptr inbounds i32, i32* %0, i64 %218
%220 = bitcast i32* %219 to <4 x i32>*
%221 = load <4 x i32>, <4 x i32>* %220
%222 = or i64 %17, 22
%223 = getelementptr inbounds i32, i32* %0, i64 %222
%224 = bitcast i32* %223 to <4 x i32>*
%225 = load <4 x i32>, <4 x i32>* %224
%226 = add nsw <4 x i32> %225, %221
%227 = or i64 %17, 20
%228 = getelementptr inbounds i32, i32* %0, i64 %227
%229 = bitcast i32* %228 to <4 x i32>*
%230 = load <4 x i32>, <4 x i32>* %229
%231 = add nsw <4 x i32> %226, %230
%232 = add nuw nsw i64 %17, 53
%233 = getelementptr inbounds i32, i32* %0, i64 %232
%234 = bitcast i32* %233 to <4 x i32>*
%235 = load <4 x i32>, <4 x i32>* %234
%236 = add nsw <4 x i32> %231, %235
%237 = add nsw i64 %17, -11
%238 = getelementptr inbounds i32, i32* %0, i64 %237
%239 = bitcast i32* %238 to <4 x i32>*
%240 = load <4 x i32>, <4 x i32>* %239
%241 = add nsw <4 x i32> %236, %240
%242 = add nsw i64 %218, -1024
%243 = getelementptr inbounds i32, i32* %0, i64 %242
%244 = bitcast i32* %243 to <4 x i32>*
%245 = load <4 x i32>, <4 x i32>* %244
%246 = add nsw <4 x i32> %241, %245
%247 = add nuw nsw i64 %218, 1024
%248 = getelementptr inbounds i32, i32* %0, i64 %247
%249 = bitcast i32* %248 to <4 x i32>*
%250 = load <4 x i32>, <4 x i32>* %249
%251 = add nsw <4 x i32> %246, %250
%252 = getelementptr inbounds i32, i32* %1, i64 %218
%253 = bitcast i32* %252 to <4 x i32>*
store <4 x i32> %251, <4 x i32>* %253
%254 = or i64 %16, 25
%255 = add nuw nsw i64 %254, %11
%256 = getelementptr inbounds i32, i32* %0, i64 %255
%257 = bitcast i32* %256 to <4 x i32>*
%258 = load <4 x i32>, <4 x i32>* %257
%259 = or i64 %17, 26
%260 = getelementptr inbounds i32, i32* %0, i64 %259
%261 = bitcast i32* %260 to <4 x i32>*
%262 = load <4 x i32>, <4 x i32>* %261
%263 = add nsw <4 x i32> %262, %258
%264 = or i64 %17, 24
%265 = getelementptr inbounds i32, i32* %0, i64 %264
%266 = bitcast i32* %265 to <4 x i32>*
%267 = load <4 x i32>, <4 x i32>* %266
%268 = add nsw <4 x i32> %263, %267
%269 = add nuw nsw i64 %17, 57
%270 = getelementptr inbounds i32, i32* %0, i64 %269
%271 = bitcast i32* %270 to <4 x i32>*
%272 = load <4 x i32>, <4 x i32>* %271
%273 = add nsw <4 x i32> %268, %272
%274 = add nsw i64 %17, -7
%275 = getelementptr inbounds i32, i32* %0, i64 %274
%276 = bitcast i32* %275 to <4 x i32>*
%277 = load <4 x i32>, <4 x i32>* %276
%278 = add nsw <4 x i32> %273, %277
%279 = add nsw i64 %255, -1024
%280 = getelementptr inbounds i32, i32* %0, i64 %279
%281 = bitcast i32* %280 to <4 x i32>*
%282 = load <4 x i32>, <4 x i32>* %281
%283 = add nsw <4 x i32> %278, %282
%284 = add nuw nsw i64 %255, 1024
%285 = getelementptr inbounds i32, i32* %0, i64 %284
%286 = bitcast i32* %285 to <4 x i32>*
%287 = load <4 x i32>, <4 x i32>* %286
%288 = add nsw <4 x i32> %283, %287
%289 = getelementptr inbounds i32, i32* %1, i64 %255
%290 = bitcast i32* %289 to <4 x i32>*
store <4 x i32> %288, <4 x i32>* %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 i32, i32* %0, i64 %296
%298 = load i32, i32* %297
%299 = add nuw nsw i64 %294, 1
%300 = add nuw nsw i64 %17, %299
%301 = getelementptr inbounds i32, i32* %0, i64 %300
%302 = load i32, i32* %301
%303 = add nsw i32 %302, %298
%304 = add nuw nsw i64 %18, %294
%305 = getelementptr inbounds i32, i32* %0, i64 %304
%306 = load i32, i32* %305
%307 = add nsw i32 %303, %306
%308 = add nuw nsw i64 %19, %294
%309 = getelementptr inbounds i32, i32* %0, i64 %308
%310 = load i32, i32* %309
%311 = add nsw i32 %307, %310
%312 = add nuw nsw i64 %20, %294
%313 = getelementptr inbounds i32, i32* %0, i64 %312
%314 = load i32, i32* %313
%315 = add nsw i32 %311, %314
%316 = add nsw i64 %296, -1024
%317 = getelementptr inbounds i32, i32* %0, i64 %316
%318 = load i32, i32* %317
%319 = add nsw i32 %315, %318
%320 = add nuw nsw i64 %296, 1024
%321 = getelementptr inbounds i32, i32* %0, i64 %320
%322 = load i32, i32* %321
%323 = add nsw i32 %319, %322
%324 = getelementptr inbounds i32, i32* %1, i64 %296
store i32 %323, i32* %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
}