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 - 1) * 32 * 32)] +
                  g1[((x + 1) + (y)*32 + (z - 1) * 32 * 32)] +
                  g1[((x - 1) + (y)*32 + (z - 1) * 32 * 32)] +
                  g1[((x) + (y + 1) * 32 + (z - 1) * 32 * 32)] +
                  g1[((x + 1) + (y + 1) * 32 + (z - 1) * 32 * 32)] +
                  g1[((x - 1) + (y + 1) * 32 + (z - 1) * 32 * 32)] +
                  g1[((x) + (y - 1) * 32 + (z - 1) * 32 * 32)] +
                  g1[((x + 1) + (y - 1) * 32 + (z - 1) * 32 * 32)] +
                  g1[((x - 1) + (y - 1) * 32 + (z - 1) * 32 * 32)] +
                  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 + 1) + (y + 1) * 32 + (z)*32 * 32)] +
                  g1[((x - 1) + (y + 1) * 32 + (z)*32 * 32)] +
                  g1[((x) + (y - 1) * 32 + (z)*32 * 32)] +
                  g1[((x + 1) + (y - 1) * 32 + (z)*32 * 32)] +
                  g1[((x - 1) + (y - 1) * 32 + (z)*32 * 32)] +
                  g1[((x) + (y)*32 + (z + 1) * 32 * 32)] +
                  g1[((x + 1) + (y)*32 + (z + 1) * 32 * 32)] +
                  g1[((x - 1) + (y)*32 + (z + 1) * 32 * 32)] +
                  g1[((x) + (y + 1) * 32 + (z + 1) * 32 * 32)] +
                  g1[((x + 1) + (y + 1) * 32 + (z + 1) * 32 * 32)] +
                  g1[((x - 1) + (y + 1) * 32 + (z + 1) * 32 * 32)] +
                  g1[((x) + (y - 1) * 32 + (z + 1) * 32 * 32)] +
                  g1[((x + 1) + (y - 1) * 32 + (z + 1) * 32 * 32)] +
                  g1[((x - 1) + (y - 1) * 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    15f6 <kernel+0x4f6>
mov    -0x20(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
mov    $0x20,%ecx
sub    -0x20(%rbp),%ecx
cmp    %ecx,%eax
jge    15e3 <kernel+0x4e3>
mov    -0x20(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x20,%ecx
sub    -0x20(%rbp),%ecx
cmp    %ecx,%eax
jge    15d0 <kernel+0x4d0>
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
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
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
sub    $0x1,%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
add    $0x1,%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
add    $0x1,%ecx
mov    -0x18(%rbp),%edx
add    $0x1,%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
sub    $0x1,%ecx
mov    -0x18(%rbp),%edx
add    $0x1,%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
sub    $0x1,%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
add    $0x1,%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%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
sub    $0x1,%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%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
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
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
add    $0x1,%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
sub    $0x1,%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
add    $0x1,%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
sub    $0x1,%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
add    $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
add    $0x1,%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
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
add    $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
add    $0x1,%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
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
mov    -0x18(%rbp),%edx
add    $0x1,%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
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x18(%rbp),%edx
add    $0x1,%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
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
add    $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
add    $0x1,%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%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
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%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    15d5 <kernel+0x4d5>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1132 <kernel+0x32>
jmp    15e8 <kernel+0x4e8>
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    0x2108(%rdi),%r8
lea    0x1084(%rsi),%rbp
lea    0x1080(%rsi),%rcx
lea    0x2100(%rdi),%rax
mov    $0x1,%edx
xor    %r13d,%r13d
xchg   %ax,%ax
mov    %rdx,-0x28(%rsp)
mov    %r13,-0x30(%rsp)
shl    $0xa,%r13
lea    0x421(%r13),%r14
lea    0x43f(%r13),%r12
lea    0x860(%r13),%r15
mov    %rax,-0x20(%rsp)
mov    %rcx,-0x18(%rsp)
mov    %rbp,-0x10(%rsp)
mov    %r8,-0x8(%rsp)
xor    %r9d,%r9d
mov    $0x1,%r10d
mov    %r9,%rbx
shl    $0x5,%rbx
lea    (%r15,%rbx,1),%rdx
lea    (%rdi,%rdx,4),%r11
lea    (%r14,%rbx,1),%rdx
lea    (%rsi,%rdx,4),%rdx
cmp    %r11,%rdx
jae    11a9 <kernel+0xa9>
lea    (%rbx,%r13,1),%rdx
lea    (%rdi,%rdx,4),%r11
add    %r12,%rbx
lea    (%rsi,%rbx,4),%rdx
mov    $0x1,%ebx
cmp    %rdx,%r11
jb     1300 <kernel+0x200>
xor    %r11d,%r11d
nopl   0x0(%rax)
movups -0x2084(%r8,%r11,4),%xmm0
ff ff
movups -0x2080(%r8,%r11,4),%xmm1
ff ff
addps  %xmm0,%xmm1
movups -0x2108(%r8,%r11,4),%xmm0
ff ff
movups -0x2104(%r8,%r11,4),%xmm2
ff ff
movups -0x2100(%r8,%r11,4),%xmm3
ff ff
movups -0x2088(%r8,%r11,4),%xmm4
ff ff
addps  %xmm1,%xmm4
movups -0x2004(%r8,%r11,4),%xmm1
ff ff
addps  %xmm4,%xmm1
movups -0x2000(%r8,%r11,4),%xmm4
ff ff
addps  %xmm1,%xmm4
movups -0x2008(%r8,%r11,4),%xmm1
ff ff
addps  %xmm4,%xmm1
addps  %xmm2,%xmm1
addps  %xmm3,%xmm1
addps  %xmm0,%xmm1
movups -0x1084(%r8,%r11,4),%xmm0
ff ff
addps  %xmm1,%xmm0
movups -0x1080(%r8,%r11,4),%xmm1
ff ff
addps  %xmm0,%xmm1
movups -0x1088(%r8,%r11,4),%xmm0
ff ff
addps  %xmm1,%xmm0
movups -0x1004(%r8,%r11,4),%xmm1
ff ff
addps  %xmm0,%xmm1
movups -0x1000(%r8,%r11,4),%xmm0
ff ff
addps  %xmm1,%xmm0
movups -0x1008(%r8,%r11,4),%xmm1
ff ff
addps  %xmm0,%xmm1
movups -0x1104(%r8,%r11,4),%xmm0
ff ff
addps  %xmm1,%xmm0
movups -0x1100(%r8,%r11,4),%xmm1
ff ff
addps  %xmm0,%xmm1
movups -0x1108(%r8,%r11,4),%xmm0
ff ff
addps  %xmm1,%xmm0
movups -0x84(%r8,%r11,4),%xmm1
ff ff
addps  %xmm0,%xmm1
movups -0x80(%r8,%r11,4),%xmm0
addps  %xmm1,%xmm0
movups -0x88(%r8,%r11,4),%xmm1
ff ff
addps  %xmm0,%xmm1
movups -0x4(%r8,%r11,4),%xmm0
addps  %xmm1,%xmm0
movups (%r8,%r11,4),%xmm1
addps  %xmm0,%xmm1
movups -0x8(%r8,%r11,4),%xmm0
addps  %xmm1,%xmm0
movups -0x104(%r8,%r11,4),%xmm1
ff ff
addps  %xmm0,%xmm1
movups -0x100(%r8,%r11,4),%xmm0
ff ff
addps  %xmm1,%xmm0
movups -0x108(%r8,%r11,4),%xmm1
ff ff
addps  %xmm0,%xmm1
movups %xmm1,0x0(%rbp,%r11,4)
add    $0x4,%r11
cmp    $0x1c,%r11
jne    11b0 <kernel+0xb0>
mov    $0x1d,%ebx
nopl   (%rax)
movss  -0x2080(%rax,%rbx,4),%xmm0
ff ff
addss  -0x207c(%rax,%rbx,4),%xmm0
ff ff
addss  -0x2084(%rax,%rbx,4),%xmm0
ff ff
addss  -0x2000(%rax,%rbx,4),%xmm0
ff ff
addss  -0x1ffc(%rax,%rbx,4),%xmm0
ff ff
addss  -0x2004(%rax,%rbx,4),%xmm0
ff ff
addss  -0x2100(%rax,%rbx,4),%xmm0
ff ff
addss  -0x20fc(%rax,%rbx,4),%xmm0
ff ff
addss  -0x2104(%rax,%rbx,4),%xmm0
ff ff
addss  -0x1080(%rax,%rbx,4),%xmm0
ff ff
addss  -0x107c(%rax,%rbx,4),%xmm0
ff ff
addss  -0x1084(%rax,%rbx,4),%xmm0
ff ff
addss  -0x1000(%rax,%rbx,4),%xmm0
ff ff
addss  -0xffc(%rax,%rbx,4),%xmm0
ff ff
addss  -0x1004(%rax,%rbx,4),%xmm0
ff ff
addss  -0x1100(%rax,%rbx,4),%xmm0
ff ff
addss  -0x10fc(%rax,%rbx,4),%xmm0
ff ff
addss  -0x1104(%rax,%rbx,4),%xmm0
ff ff
addss  -0x80(%rax,%rbx,4),%xmm0
addss  -0x7c(%rax,%rbx,4),%xmm0
addss  -0x84(%rax,%rbx,4),%xmm0
ff ff
addss  (%rax,%rbx,4),%xmm0
addss  0x4(%rax,%rbx,4),%xmm0
addss  -0x4(%rax,%rbx,4),%xmm0
addss  -0x100(%rax,%rbx,4),%xmm0
ff ff
addss  -0xfc(%rax,%rbx,4),%xmm0
ff ff
addss  -0x104(%rax,%rbx,4),%xmm0
ff ff
movss  %xmm0,(%rcx,%rbx,4)
lea    0x1(%rbx),%rdx
mov    %rdx,%rbx
cmp    $0x1f,%rdx
jne    1300 <kernel+0x200>
add    $0x1,%r10
add    $0x1,%r9
sub    $0xffffffffffffff80,%r8
sub    $0xffffffffffffff80,%rbp
sub    $0xffffffffffffff80,%rcx
sub    $0xffffffffffffff80,%rax
cmp    $0x1f,%r10
jne    1170 <kernel+0x70>
mov    -0x28(%rsp),%rdx
add    $0x1,%rdx
mov    -0x30(%rsp),%r13
add    $0x1,%r13
mov    -0x8(%rsp),%r8
add    $0x1000,%r8
mov    -0x10(%rsp),%rbp
add    $0x1000,%rbp
mov    -0x18(%rsp),%rcx
add    $0x1000,%rcx
mov    -0x20(%rsp),%rax
add    $0x1000,%rax
cmp    $0x1f,%rdx
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 = %455, %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 %458
16: ; preds = %11
%17 = load i32, i32* %8
store i32 %17, i32* %6
br label %18
18: ; preds = %451, %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 %454
23: ; preds = %18
%24 = load i32, i32* %8
store i32 %24, i32* %5
br label %25
25: ; preds = %447, %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 %450
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 = sub nsw i32 %36, 1
%38 = mul nsw i32 %37, 32
%39 = mul nsw i32 %38, 32
%40 = add nsw i32 %35, %39
%41 = sext i32 %40 to i64
%42 = getelementptr inbounds float, float* %31, i64 %41
%43 = load float, float* %42
%44 = load float*, float** %3
%45 = load i32, i32* %5
%46 = add nsw i32 %45, 1
%47 = load i32, i32* %6
%48 = mul nsw i32 %47, 32
%49 = add nsw i32 %46, %48
%50 = load i32, i32* %7
%51 = sub nsw i32 %50, 1
%52 = mul nsw i32 %51, 32
%53 = mul nsw i32 %52, 32
%54 = add nsw i32 %49, %53
%55 = sext i32 %54 to i64
%56 = getelementptr inbounds float, float* %44, i64 %55
%57 = load float, float* %56
%58 = fadd float %43, %57
%59 = load float*, float** %3
%60 = load i32, i32* %5
%61 = sub nsw i32 %60, 1
%62 = load i32, i32* %6
%63 = mul nsw i32 %62, 32
%64 = add nsw i32 %61, %63
%65 = load i32, i32* %7
%66 = sub nsw i32 %65, 1
%67 = mul nsw i32 %66, 32
%68 = mul nsw i32 %67, 32
%69 = add nsw i32 %64, %68
%70 = sext i32 %69 to i64
%71 = getelementptr inbounds float, float* %59, i64 %70
%72 = load float, float* %71
%73 = fadd float %58, %72
%74 = load float*, float** %3
%75 = load i32, i32* %5
%76 = load i32, i32* %6
%77 = add nsw i32 %76, 1
%78 = mul nsw i32 %77, 32
%79 = add nsw i32 %75, %78
%80 = load i32, i32* %7
%81 = sub nsw i32 %80, 1
%82 = mul nsw i32 %81, 32
%83 = mul nsw i32 %82, 32
%84 = add nsw i32 %79, %83
%85 = sext i32 %84 to i64
%86 = getelementptr inbounds float, float* %74, i64 %85
%87 = load float, float* %86
%88 = fadd float %73, %87
%89 = load float*, float** %3
%90 = load i32, i32* %5
%91 = add nsw i32 %90, 1
%92 = load i32, i32* %6
%93 = add nsw i32 %92, 1
%94 = mul nsw i32 %93, 32
%95 = add nsw i32 %91, %94
%96 = load i32, i32* %7
%97 = sub nsw i32 %96, 1
%98 = mul nsw i32 %97, 32
%99 = mul nsw i32 %98, 32
%100 = add nsw i32 %95, %99
%101 = sext i32 %100 to i64
%102 = getelementptr inbounds float, float* %89, i64 %101
%103 = load float, float* %102
%104 = fadd float %88, %103
%105 = load float*, float** %3
%106 = load i32, i32* %5
%107 = sub nsw i32 %106, 1
%108 = load i32, i32* %6
%109 = add nsw i32 %108, 1
%110 = mul nsw i32 %109, 32
%111 = add nsw i32 %107, %110
%112 = load i32, i32* %7
%113 = sub nsw i32 %112, 1
%114 = mul nsw i32 %113, 32
%115 = mul nsw i32 %114, 32
%116 = add nsw i32 %111, %115
%117 = sext i32 %116 to i64
%118 = getelementptr inbounds float, float* %105, i64 %117
%119 = load float, float* %118
%120 = fadd float %104, %119
%121 = load float*, float** %3
%122 = load i32, i32* %5
%123 = load i32, i32* %6
%124 = sub nsw i32 %123, 1
%125 = mul nsw i32 %124, 32
%126 = add nsw i32 %122, %125
%127 = load i32, i32* %7
%128 = sub nsw i32 %127, 1
%129 = mul nsw i32 %128, 32
%130 = mul nsw i32 %129, 32
%131 = add nsw i32 %126, %130
%132 = sext i32 %131 to i64
%133 = getelementptr inbounds float, float* %121, i64 %132
%134 = load float, float* %133
%135 = fadd float %120, %134
%136 = load float*, float** %3
%137 = load i32, i32* %5
%138 = add nsw i32 %137, 1
%139 = load i32, i32* %6
%140 = sub nsw i32 %139, 1
%141 = mul nsw i32 %140, 32
%142 = add nsw i32 %138, %141
%143 = load i32, i32* %7
%144 = sub nsw i32 %143, 1
%145 = mul nsw i32 %144, 32
%146 = mul nsw i32 %145, 32
%147 = add nsw i32 %142, %146
%148 = sext i32 %147 to i64
%149 = getelementptr inbounds float, float* %136, i64 %148
%150 = load float, float* %149
%151 = fadd float %135, %150
%152 = load float*, float** %3
%153 = load i32, i32* %5
%154 = sub nsw i32 %153, 1
%155 = load i32, i32* %6
%156 = sub nsw i32 %155, 1
%157 = mul nsw i32 %156, 32
%158 = add nsw i32 %154, %157
%159 = load i32, i32* %7
%160 = sub nsw i32 %159, 1
%161 = mul nsw i32 %160, 32
%162 = mul nsw i32 %161, 32
%163 = add nsw i32 %158, %162
%164 = sext i32 %163 to i64
%165 = getelementptr inbounds float, float* %152, i64 %164
%166 = load float, float* %165
%167 = fadd float %151, %166
%168 = load float*, float** %3
%169 = load i32, i32* %5
%170 = load i32, i32* %6
%171 = mul nsw i32 %170, 32
%172 = add nsw i32 %169, %171
%173 = load i32, i32* %7
%174 = mul nsw i32 %173, 32
%175 = mul nsw i32 %174, 32
%176 = add nsw i32 %172, %175
%177 = sext i32 %176 to i64
%178 = getelementptr inbounds float, float* %168, i64 %177
%179 = load float, float* %178
%180 = fadd float %167, %179
%181 = load float*, float** %3
%182 = load i32, i32* %5
%183 = add nsw i32 %182, 1
%184 = load i32, i32* %6
%185 = mul nsw i32 %184, 32
%186 = add nsw i32 %183, %185
%187 = load i32, i32* %7
%188 = mul nsw i32 %187, 32
%189 = mul nsw i32 %188, 32
%190 = add nsw i32 %186, %189
%191 = sext i32 %190 to i64
%192 = getelementptr inbounds float, float* %181, i64 %191
%193 = load float, float* %192
%194 = fadd float %180, %193
%195 = load float*, float** %3
%196 = load i32, i32* %5
%197 = sub nsw i32 %196, 1
%198 = load i32, i32* %6
%199 = mul nsw i32 %198, 32
%200 = add nsw i32 %197, %199
%201 = load i32, i32* %7
%202 = mul nsw i32 %201, 32
%203 = mul nsw i32 %202, 32
%204 = add nsw i32 %200, %203
%205 = sext i32 %204 to i64
%206 = getelementptr inbounds float, float* %195, i64 %205
%207 = load float, float* %206
%208 = fadd float %194, %207
%209 = load float*, float** %3
%210 = load i32, i32* %5
%211 = load i32, i32* %6
%212 = add nsw i32 %211, 1
%213 = mul nsw i32 %212, 32
%214 = add nsw i32 %210, %213
%215 = load i32, i32* %7
%216 = mul nsw i32 %215, 32
%217 = mul nsw i32 %216, 32
%218 = add nsw i32 %214, %217
%219 = sext i32 %218 to i64
%220 = getelementptr inbounds float, float* %209, i64 %219
%221 = load float, float* %220
%222 = fadd float %208, %221
%223 = load float*, float** %3
%224 = load i32, i32* %5
%225 = add nsw i32 %224, 1
%226 = load i32, i32* %6
%227 = add nsw i32 %226, 1
%228 = mul nsw i32 %227, 32
%229 = add nsw i32 %225, %228
%230 = load i32, i32* %7
%231 = mul nsw i32 %230, 32
%232 = mul nsw i32 %231, 32
%233 = add nsw i32 %229, %232
%234 = sext i32 %233 to i64
%235 = getelementptr inbounds float, float* %223, i64 %234
%236 = load float, float* %235
%237 = fadd float %222, %236
%238 = load float*, float** %3
%239 = load i32, i32* %5
%240 = sub nsw i32 %239, 1
%241 = load i32, i32* %6
%242 = add nsw i32 %241, 1
%243 = mul nsw i32 %242, 32
%244 = add nsw i32 %240, %243
%245 = load i32, i32* %7
%246 = mul nsw i32 %245, 32
%247 = mul nsw i32 %246, 32
%248 = add nsw i32 %244, %247
%249 = sext i32 %248 to i64
%250 = getelementptr inbounds float, float* %238, i64 %249
%251 = load float, float* %250
%252 = fadd float %237, %251
%253 = load float*, float** %3
%254 = load i32, i32* %5
%255 = load i32, i32* %6
%256 = sub nsw i32 %255, 1
%257 = mul nsw i32 %256, 32
%258 = add nsw i32 %254, %257
%259 = load i32, i32* %7
%260 = mul nsw i32 %259, 32
%261 = mul nsw i32 %260, 32
%262 = add nsw i32 %258, %261
%263 = sext i32 %262 to i64
%264 = getelementptr inbounds float, float* %253, i64 %263
%265 = load float, float* %264
%266 = fadd float %252, %265
%267 = load float*, float** %3
%268 = load i32, i32* %5
%269 = add nsw i32 %268, 1
%270 = load i32, i32* %6
%271 = sub nsw i32 %270, 1
%272 = mul nsw i32 %271, 32
%273 = add nsw i32 %269, %272
%274 = load i32, i32* %7
%275 = mul nsw i32 %274, 32
%276 = mul nsw i32 %275, 32
%277 = add nsw i32 %273, %276
%278 = sext i32 %277 to i64
%279 = getelementptr inbounds float, float* %267, i64 %278
%280 = load float, float* %279
%281 = fadd float %266, %280
%282 = load float*, float** %3
%283 = load i32, i32* %5
%284 = sub nsw i32 %283, 1
%285 = load i32, i32* %6
%286 = sub nsw i32 %285, 1
%287 = mul nsw i32 %286, 32
%288 = add nsw i32 %284, %287
%289 = load i32, i32* %7
%290 = mul nsw i32 %289, 32
%291 = mul nsw i32 %290, 32
%292 = add nsw i32 %288, %291
%293 = sext i32 %292 to i64
%294 = getelementptr inbounds float, float* %282, i64 %293
%295 = load float, float* %294
%296 = fadd float %281, %295
%297 = load float*, float** %3
%298 = load i32, i32* %5
%299 = load i32, i32* %6
%300 = mul nsw i32 %299, 32
%301 = add nsw i32 %298, %300
%302 = load i32, i32* %7
%303 = add nsw i32 %302, 1
%304 = mul nsw i32 %303, 32
%305 = mul nsw i32 %304, 32
%306 = add nsw i32 %301, %305
%307 = sext i32 %306 to i64
%308 = getelementptr inbounds float, float* %297, i64 %307
%309 = load float, float* %308
%310 = fadd float %296, %309
%311 = load float*, float** %3
%312 = load i32, i32* %5
%313 = add nsw i32 %312, 1
%314 = load i32, i32* %6
%315 = mul nsw i32 %314, 32
%316 = add nsw i32 %313, %315
%317 = load i32, i32* %7
%318 = add nsw i32 %317, 1
%319 = mul nsw i32 %318, 32
%320 = mul nsw i32 %319, 32
%321 = add nsw i32 %316, %320
%322 = sext i32 %321 to i64
%323 = getelementptr inbounds float, float* %311, i64 %322
%324 = load float, float* %323
%325 = fadd float %310, %324
%326 = load float*, float** %3
%327 = load i32, i32* %5
%328 = sub nsw i32 %327, 1
%329 = load i32, i32* %6
%330 = mul nsw i32 %329, 32
%331 = add nsw i32 %328, %330
%332 = load i32, i32* %7
%333 = add nsw i32 %332, 1
%334 = mul nsw i32 %333, 32
%335 = mul nsw i32 %334, 32
%336 = add nsw i32 %331, %335
%337 = sext i32 %336 to i64
%338 = getelementptr inbounds float, float* %326, i64 %337
%339 = load float, float* %338
%340 = fadd float %325, %339
%341 = load float*, float** %3
%342 = load i32, i32* %5
%343 = load i32, i32* %6
%344 = add nsw i32 %343, 1
%345 = mul nsw i32 %344, 32
%346 = add nsw i32 %342, %345
%347 = load i32, i32* %7
%348 = add nsw i32 %347, 1
%349 = mul nsw i32 %348, 32
%350 = mul nsw i32 %349, 32
%351 = add nsw i32 %346, %350
%352 = sext i32 %351 to i64
%353 = getelementptr inbounds float, float* %341, i64 %352
%354 = load float, float* %353
%355 = fadd float %340, %354
%356 = load float*, float** %3
%357 = load i32, i32* %5
%358 = add nsw i32 %357, 1
%359 = load i32, i32* %6
%360 = add nsw i32 %359, 1
%361 = mul nsw i32 %360, 32
%362 = add nsw i32 %358, %361
%363 = load i32, i32* %7
%364 = add nsw i32 %363, 1
%365 = mul nsw i32 %364, 32
%366 = mul nsw i32 %365, 32
%367 = add nsw i32 %362, %366
%368 = sext i32 %367 to i64
%369 = getelementptr inbounds float, float* %356, i64 %368
%370 = load float, float* %369
%371 = fadd float %355, %370
%372 = load float*, float** %3
%373 = load i32, i32* %5
%374 = sub nsw i32 %373, 1
%375 = load i32, i32* %6
%376 = add nsw i32 %375, 1
%377 = mul nsw i32 %376, 32
%378 = add nsw i32 %374, %377
%379 = load i32, i32* %7
%380 = add nsw i32 %379, 1
%381 = mul nsw i32 %380, 32
%382 = mul nsw i32 %381, 32
%383 = add nsw i32 %378, %382
%384 = sext i32 %383 to i64
%385 = getelementptr inbounds float, float* %372, i64 %384
%386 = load float, float* %385
%387 = fadd float %371, %386
%388 = load float*, float** %3
%389 = load i32, i32* %5
%390 = load i32, i32* %6
%391 = sub nsw i32 %390, 1
%392 = mul nsw i32 %391, 32
%393 = add nsw i32 %389, %392
%394 = load i32, i32* %7
%395 = add nsw i32 %394, 1
%396 = mul nsw i32 %395, 32
%397 = mul nsw i32 %396, 32
%398 = add nsw i32 %393, %397
%399 = sext i32 %398 to i64
%400 = getelementptr inbounds float, float* %388, i64 %399
%401 = load float, float* %400
%402 = fadd float %387, %401
%403 = load float*, float** %3
%404 = load i32, i32* %5
%405 = add nsw i32 %404, 1
%406 = load i32, i32* %6
%407 = sub nsw i32 %406, 1
%408 = mul nsw i32 %407, 32
%409 = add nsw i32 %405, %408
%410 = load i32, i32* %7
%411 = add nsw i32 %410, 1
%412 = mul nsw i32 %411, 32
%413 = mul nsw i32 %412, 32
%414 = add nsw i32 %409, %413
%415 = sext i32 %414 to i64
%416 = getelementptr inbounds float, float* %403, i64 %415
%417 = load float, float* %416
%418 = fadd float %402, %417
%419 = load float*, float** %3
%420 = load i32, i32* %5
%421 = sub nsw i32 %420, 1
%422 = load i32, i32* %6
%423 = sub nsw i32 %422, 1
%424 = mul nsw i32 %423, 32
%425 = add nsw i32 %421, %424
%426 = load i32, i32* %7
%427 = add nsw i32 %426, 1
%428 = mul nsw i32 %427, 32
%429 = mul nsw i32 %428, 32
%430 = add nsw i32 %425, %429
%431 = sext i32 %430 to i64
%432 = getelementptr inbounds float, float* %419, i64 %431
%433 = load float, float* %432
%434 = fadd float %418, %433
store float %434, float* %9
%435 = load float, float* %9
%436 = load float*, float** %4
%437 = load i32, i32* %5
%438 = load i32, i32* %6
%439 = mul nsw i32 %438, 32
%440 = add nsw i32 %437, %439
%441 = load i32, i32* %7
%442 = mul nsw i32 %441, 32
%443 = mul nsw i32 %442, 32
%444 = add nsw i32 %440, %443
%445 = sext i32 %444 to i64
%446 = getelementptr inbounds float, float* %436, i64 %445
store float %435, float* %446
br label %447
447: ; preds = %30
%448 = load i32, i32* %5
%449 = add nsw i32 %448, 1
store i32 %449, i32* %5
br label %25
450: ; preds = %25
br label %451
451: ; preds = %450
%452 = load i32, i32* %6
%453 = add nsw i32 %452, 1
store i32 %453, i32* %6
br label %18
454: ; preds = %18
br label %455
455: ; preds = %454
%456 = load i32, i32* %7
%457 = add nsw i32 %456, 1
store i32 %457, i32* %7
br label %11
458: ; preds = %11
ret void
}

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