void pencil_convolution(float inputs[8][16][32 + 4][32 + 4],
                        float filters[16][16][4 + 1][4 + 1],
                        float rconv[8][16][32][32], float bias[16]) {
#pragma scop
  for (int n = 0; n < 8; n++) {
    for (int f = 0; f < 16; f++) {
      for (int y = 0; y < 32; y++) {
        for (int x = 0; x < 32; x++) {
          rconv[n][f][y][x] = bias[f];
        }
      }
    }
  }
  for (int n = 0; n < 8; n++) {
    for (int f = 0; f < 16; f++) {
      for (int y = 0; y < 32; y++) {
        for (int x = 0; x < 32; x++) {
          for (int fz = 0; fz < 16; fz++) {
            for (int fy = 0; fy < 4 + 1; fy++) {
              for (int fx = 0; fx < 4 + 1; fx++) {
                rconv[n][f][y][x] +=
                    filters[f][fz][fy][fx] * inputs[n][fz][y + fy][x + fx];
              }
            }
          }
        }
      }
    }
  }
#pragma endscop
}


x86 assembly (clang, -O0):
<pencil_convolution>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
cmpl   $0x8,-0x24(%rbp)
jge    11da <pencil_convolution+0xda>
movl   $0x0,-0x28(%rbp)
cmpl   $0x10,-0x28(%rbp)
jge    11c7 <pencil_convolution+0xc7>
movl   $0x0,-0x2c(%rbp)
cmpl   $0x20,-0x2c(%rbp)
jge    11b4 <pencil_convolution+0xb4>
movl   $0x0,-0x30(%rbp)
cmpl   $0x20,-0x30(%rbp)
jge    11a1 <pencil_convolution+0xa1>
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
shl    $0x10,%rcx
add    %rcx,%rax
movslq -0x28(%rbp),%rcx
shl    $0xc,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
shl    $0x7,%rcx
add    %rcx,%rax
movslq -0x30(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    114e <pencil_convolution+0x4e>
jmp    11a6 <pencil_convolution+0xa6>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    113d <pencil_convolution+0x3d>
jmp    11b9 <pencil_convolution+0xb9>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    112c <pencil_convolution+0x2c>
jmp    11cc <pencil_convolution+0xcc>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    111b <pencil_convolution+0x1b>
movl   $0x0,-0x34(%rbp)
cmpl   $0x8,-0x34(%rbp)
jge    137e <pencil_convolution+0x27e>
movl   $0x0,-0x38(%rbp)
cmpl   $0x10,-0x38(%rbp)
jge    136b <pencil_convolution+0x26b>
movl   $0x0,-0x3c(%rbp)
cmpl   $0x20,-0x3c(%rbp)
jge    1358 <pencil_convolution+0x258>
movl   $0x0,-0x40(%rbp)
cmpl   $0x20,-0x40(%rbp)
jge    1345 <pencil_convolution+0x245>
movl   $0x0,-0x44(%rbp)
cmpl   $0x10,-0x44(%rbp)
jge    1332 <pencil_convolution+0x232>
movl   $0x0,-0x48(%rbp)
cmpl   $0x5,-0x48(%rbp)
jge    131f <pencil_convolution+0x21f>
movl   $0x0,-0x4c(%rbp)
cmpl   $0x5,-0x4c(%rbp)
jge    130c <pencil_convolution+0x20c>
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
imul   $0x640,%rcx,%rcx
add    %rcx,%rax
movslq -0x44(%rbp),%rcx
imul   $0x64,%rcx,%rcx
add    %rcx,%rax
movslq -0x48(%rbp),%rcx
imul   $0x14,%rcx,%rcx
add    %rcx,%rax
movslq -0x4c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
imul   $0x14400,%rcx,%rcx
add    %rcx,%rax
movslq -0x44(%rbp),%rcx
imul   $0x1440,%rcx,%rcx
add    %rcx,%rax
mov    -0x3c(%rbp),%ecx
add    -0x48(%rbp),%ecx
movslq %ecx,%rcx
imul   $0x90,%rcx,%rcx
add    %rcx,%rax
mov    -0x40(%rbp),%ecx
add    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
shl    $0x10,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
shl    $0xc,%rcx
add    %rcx,%rax
movslq -0x3c(%rbp),%rcx
shl    $0x7,%rcx
add    %rcx,%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1247 <pencil_convolution+0x147>
jmp    1311 <pencil_convolution+0x211>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1236 <pencil_convolution+0x136>
jmp    1324 <pencil_convolution+0x224>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1225 <pencil_convolution+0x125>
jmp    1337 <pencil_convolution+0x237>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1214 <pencil_convolution+0x114>
jmp    134a <pencil_convolution+0x24a>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1203 <pencil_convolution+0x103>
jmp    135d <pencil_convolution+0x25d>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    11f2 <pencil_convolution+0xf2>
jmp    1370 <pencil_convolution+0x270>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11e1 <pencil_convolution+0xe1>
pop    %rbp
ret

x86 assembly (clang, -O2):
<pencil_convolution>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %rsi,%r14
mov    %rdi,-0x8(%rsp)
lea    0xc(%rdx),%r8
xor    %ebx,%ebx
jmp    1135 <pencil_convolution+0x35>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rbx
add    $0x1000,%r8
cmp    $0x10,%rbx
je     1217 <pencil_convolution+0x117>
lea    (%rcx,%rbx,4),%r9
lea    (%rcx,%rbx,4),%r10
add    $0x4,%r10
mov    %r8,%rax
xor    %r11d,%r11d
jmp    11ae <pencil_convolution+0xae>
nopl   0x0(%rax)
movss  (%rcx,%rbx,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movups %xmm0,0x0(%rbp,%rdi,1)
movups %xmm0,0x10(%rbp,%rdi,1)
movss  (%rcx,%rbx,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movups %xmm0,0x20(%rbp,%rdi,1)
movups %xmm0,0x30(%rbp,%rdi,1)
movss  (%rcx,%rbx,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movups %xmm0,0x40(%rbp,%rdi,1)
movups %xmm0,0x50(%rbp,%rdi,1)
movss  (%rcx,%rbx,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movups %xmm0,0x60(%rbp,%rdi,1)
movups %xmm0,0x70(%rbp,%rdi,1)
add    $0x1,%r11
sub    $0xffffffffffffff80,%rax
cmp    $0x20,%r11
je     1120 <pencil_convolution+0x20>
mov    %rbx,%rdi
shl    $0xc,%rdi
add    %rdx,%rdi
mov    %r11,%rbp
shl    $0x7,%rbp
lea    (%rdi,%rbp,1),%rsi
cmp    %r10,%rsi
jae    1150 <pencil_convolution+0x50>
lea    (%rdi,%rbp,1),%rsi
add    $0x80,%rsi
cmp    %rsi,%r9
jae    1150 <pencil_convolution+0x50>
xor    %edi,%edi
xchg   %ax,%ax
movss  (%rcx,%rbx,4),%xmm0
movss  %xmm0,-0xc(%rax,%rdi,4)
movss  (%rcx,%rbx,4),%xmm0
movss  %xmm0,-0x8(%rax,%rdi,4)
movss  (%rcx,%rbx,4),%xmm0
movss  %xmm0,-0x4(%rax,%rdi,4)
movss  (%rcx,%rbx,4),%xmm0
movss  %xmm0,(%rax,%rdi,4)
add    $0x4,%rdi
cmp    $0x20,%rdi
jne    11e0 <pencil_convolution+0xe0>
jmp    119c <pencil_convolution+0x9c>
lea    0x1000c(%rdx),%r8
xor    %ebx,%ebx
jmp    1245 <pencil_convolution+0x145>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rbx
add    $0x1000,%r8
cmp    $0x10,%rbx
je     135a <pencil_convolution+0x25a>
lea    (%rcx,%rbx,4),%r9
lea    (%rcx,%rbx,4),%r10
add    $0x4,%r10
mov    %r8,%rax
xor    %r11d,%r11d
jmp    12d6 <pencil_convolution+0x1d6>
nopl   0x0(%rax)
movss  (%rcx,%rbx,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movups %xmm0,0x10000(%rbp,%rdi,1)
movups %xmm0,0x10010(%rbp,%rdi,1)
movss  (%rcx,%rbx,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movups %xmm0,0x10020(%rbp,%rdi,1)
movups %xmm0,0x10030(%rbp,%rdi,1)
movss  (%rcx,%rbx,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movups %xmm0,0x10040(%rbp,%rdi,1)
movups %xmm0,0x10050(%rbp,%rdi,1)
movss  (%rcx,%rbx,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movups %xmm0,0x10060(%rbp,%rdi,1)
movups %xmm0,0x10070(%rbp,%rdi,1)
add    $0x1,%r11
sub    $0xffffffffffffff80,%rax
cmp    $0x20,%r11
je     1230 <pencil_convolution+0x130>
mov    %rbx,%rdi
shl    $0xc,%rdi
add    %rdx,%rdi
mov    %r11,%rbp
shl    $0x7,%rbp
lea    (%rdi,%rbp,1),%rsi
add    $0x10000,%rsi
cmp    %r10,%rsi
jae    1260 <pencil_convolution+0x160>
lea    (%rdi,%rbp,1),%rsi
add    $0x10080,%rsi
cmp    %rsi,%r9
jae    1260 <pencil_convolution+0x160>
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  (%rcx,%rbx,4),%xmm0
movss  %xmm0,-0xc(%rax,%rdi,4)
movss  (%rcx,%rbx,4),%xmm0
movss  %xmm0,-0x8(%rax,%rdi,4)
movss  (%rcx,%rbx,4),%xmm0
movss  %xmm0,-0x4(%rax,%rdi,4)
movss  (%rcx,%rbx,4),%xmm0
movss  %xmm0,(%rax,%rdi,4)
add    $0x4,%rdi
cmp    $0x20,%rdi
jne    1320 <pencil_convolution+0x220>
jmp    12c4 <pencil_convolution+0x1c4>
lea    0x2000c(%rdx),%r8
xor    %ebx,%ebx
jmp    1385 <pencil_convolution+0x285>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rbx
add    $0x1000,%r8
cmp    $0x10,%rbx
je     149a <pencil_convolution+0x39a>
lea    (%rcx,%rbx,4),%r9
lea    (%rcx,%rbx,4),%r10
add    $0x4,%r10
mov    %r8,%rax
xor    %r11d,%r11d
jmp    1416 <pencil_convolution+0x316>
nopl   0x0(%rax)
movss  (%rcx,%rbx,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movups %xmm0,0x20000(%rbp,%rdi,1)
movups %xmm0,0x20010(%rbp,%rdi,1)
movss  (%rcx,%rbx,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movups %xmm0,0x20020(%rbp,%rdi,1)
movups %xmm0,0x20030(%rbp,%rdi,1)
movss  (%rcx,%rbx,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movups %xmm0,0x20040(%rbp,%rdi,1)
movups %xmm0,0x20050(%rbp,%rdi,1)
movss  (%rcx,%rbx,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movups %xmm0,0x20060(%rbp,%rdi,1)
movups %xmm0,0x20070(%rbp,%rdi,1)
add    $0x1,%r11
sub    $0xffffffffffffff80,%rax
cmp    $0x20,%r11
je     1370 <pencil_convolution+0x270>
mov    %rbx,%rdi
shl    $0xc,%rdi
add    %rdx,%rdi
mov    %r11,%rbp
shl    $0x7,%rbp
lea    (%rdi,%rbp,1),%rsi
add    $0x20000,%rsi
cmp    %r10,%rsi
jae    13a0 <pencil_convolution+0x2a0>
lea    (%rdi,%rbp,1),%rsi
add    $0x20080,%rsi
cmp    %rsi,%r9
jae    13a0 <pencil_convolution+0x2a0>
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  (%rcx,%rbx,4),%xmm0
movss  %xmm0,-0xc(%rax,%rdi,4)
movss  (%rcx,%rbx,4),%xmm0
movss  %xmm0,-0x8(%rax,%rdi,4)
movss  (%rcx,%rbx,4),%xmm0
movss  %xmm0,-0x4(%rax,%rdi,4)
movss  (%rcx,%rbx,4),%xmm0
movss  %xmm0,(%rax,%rdi,4)
add    $0x4,%rdi
cmp    $0x20,%rdi
jne    1460 <pencil_convolution+0x360>
jmp    1404 <pencil_convolution+0x304>
lea    0x3000c(%rdx),%r8
xor    %ebx,%ebx
jmp    14c5 <pencil_convolution+0x3c5>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rbx
add    $0x1000,%r8
cmp    $0x10,%rbx
je     15da <pencil_convolution+0x4da>
lea    (%rcx,%rbx,4),%r9
lea    (%rcx,%rbx,4),%r10
add    $0x4,%r10
mov    %r8,%rax
xor    %r11d,%r11d
jmp    1556 <pencil_convolution+0x456>
nopl   0x0(%rax)
movss  (%rcx,%rbx,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movups %xmm0,0x30000(%rbp,%rdi,1)
movups %xmm0,0x30010(%rbp,%rdi,1)
movss  (%rcx,%rbx,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movups %xmm0,0x30020(%rbp,%rdi,1)
movups %xmm0,0x30030(%rbp,%rdi,1)
movss  (%rcx,%rbx,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movups %xmm0,0x30040(%rbp,%rdi,1)
movups %xmm0,0x30050(%rbp,%rdi,1)
movss  (%rcx,%rbx,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movups %xmm0,0x30060(%rbp,%rdi,1)
movups %xmm0,0x30070(%rbp,%rdi,1)
add    $0x1,%r11
sub    $0xffffffffffffff80,%rax
cmp    $0x20,%r11
je     14b0 <pencil_convolution+0x3b0>
mov    %rbx,%rdi
shl    $0xc,%rdi
add    %rdx,%rdi
mov    %r11,%rbp
shl    $0x7,%rbp
lea    (%rdi,%rbp,1),%rsi
add    $0x30000,%rsi
cmp    %r10,%rsi
jae    14e0 <pencil_convolution+0x3e0>
lea    (%rdi,%rbp,1),%rsi
add    $0x30080,%rsi
cmp    %rsi,%r9
jae    14e0 <pencil_convolution+0x3e0>
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  (%rcx,%rbx,4),%xmm0
movss  %xmm0,-0xc(%rax,%rdi,4)
movss  (%rcx,%rbx,4),%xmm0
movss  %xmm0,-0x8(%rax,%rdi,4)
movss  (%rcx,%rbx,4),%xmm0
movss  %xmm0,-0x4(%rax,%rdi,4)
movss  (%rcx,%rbx,4),%xmm0
movss  %xmm0,(%rax,%rdi,4)
add    $0x4,%rdi
cmp    $0x20,%rdi
jne    15a0 <pencil_convolution+0x4a0>
jmp    1544 <pencil_convolution+0x444>
lea    0x4000c(%rdx),%r8
xor    %ebx,%ebx
jmp    1605 <pencil_convolution+0x505>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rbx
add    $0x1000,%r8
cmp    $0x10,%rbx
je     171a <pencil_convolution+0x61a>
lea    (%rcx,%rbx,4),%r9
lea    (%rcx,%rbx,4),%r10
add    $0x4,%r10
mov    %r8,%rax
xor    %r11d,%r11d
jmp    1696 <pencil_convolution+0x596>
nopl   0x0(%rax)
movss  (%rcx,%rbx,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movups %xmm0,0x40000(%rbp,%rdi,1)
movups %xmm0,0x40010(%rbp,%rdi,1)
movss  (%rcx,%rbx,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movups %xmm0,0x40020(%rbp,%rdi,1)
movups %xmm0,0x40030(%rbp,%rdi,1)
movss  (%rcx,%rbx,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movups %xmm0,0x40040(%rbp,%rdi,1)
movups %xmm0,0x40050(%rbp,%rdi,1)
movss  (%rcx,%rbx,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movups %xmm0,0x40060(%rbp,%rdi,1)
movups %xmm0,0x40070(%rbp,%rdi,1)
add    $0x1,%r11
sub    $0xffffffffffffff80,%rax
cmp    $0x20,%r11
je     15f0 <pencil_convolution+0x4f0>
mov    %rbx,%rdi
shl    $0xc,%rdi
add    %rdx,%rdi
mov    %r11,%rbp
shl    $0x7,%rbp
lea    (%rdi,%rbp,1),%rsi
add    $0x40000,%rsi
cmp    %r10,%rsi
jae    1620 <pencil_convolution+0x520>
lea    (%rdi,%rbp,1),%rsi
add    $0x40080,%rsi
cmp    %rsi,%r9
jae    1620 <pencil_convolution+0x520>
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  (%rcx,%rbx,4),%xmm0
movss  %xmm0,-0xc(%rax,%rdi,4)
movss  (%rcx,%rbx,4),%xmm0
movss  %xmm0,-0x8(%rax,%rdi,4)
movss  (%rcx,%rbx,4),%xmm0
movss  %xmm0,-0x4(%rax,%rdi,4)
movss  (%rcx,%rbx,4),%xmm0
movss  %xmm0,(%rax,%rdi,4)
add    $0x4,%rdi
cmp    $0x20,%rdi
jne    16e0 <pencil_convolution+0x5e0>
jmp    1684 <pencil_convolution+0x584>
lea    0x5000c(%rdx),%r8
xor    %ebx,%ebx
jmp    1745 <pencil_convolution+0x645>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rbx
add    $0x1000,%r8
cmp    $0x10,%rbx
je     185a <pencil_convolution+0x75a>
lea    (%rcx,%rbx,4),%r9
lea    (%rcx,%rbx,4),%r10
add    $0x4,%r10
mov    %r8,%rax
xor    %r11d,%r11d
jmp    17d6 <pencil_convolution+0x6d6>
nopl   0x0(%rax)
movss  (%rcx,%rbx,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movups %xmm0,0x50000(%rbp,%rdi,1)
movups %xmm0,0x50010(%rbp,%rdi,1)
movss  (%rcx,%rbx,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movups %xmm0,0x50020(%rbp,%rdi,1)
movups %xmm0,0x50030(%rbp,%rdi,1)
movss  (%rcx,%rbx,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movups %xmm0,0x50040(%rbp,%rdi,1)
movups %xmm0,0x50050(%rbp,%rdi,1)
movss  (%rcx,%rbx,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movups %xmm0,0x50060(%rbp,%rdi,1)
movups %xmm0,0x50070(%rbp,%rdi,1)
add    $0x1,%r11
sub    $0xffffffffffffff80,%rax
cmp    $0x20,%r11
je     1730 <pencil_convolution+0x630>
mov    %rbx,%rdi
shl    $0xc,%rdi
add    %rdx,%rdi
mov    %r11,%rbp
shl    $0x7,%rbp
lea    (%rdi,%rbp,1),%rsi
add    $0x50000,%rsi
cmp    %r10,%rsi
jae    1760 <pencil_convolution+0x660>
lea    (%rdi,%rbp,1),%rsi
add    $0x50080,%rsi
cmp    %rsi,%r9
jae    1760 <pencil_convolution+0x660>
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  (%rcx,%rbx,4),%xmm0
movss  %xmm0,-0xc(%rax,%rdi,4)
movss  (%rcx,%rbx,4),%xmm0
movss  %xmm0,-0x8(%rax,%rdi,4)
movss  (%rcx,%rbx,4),%xmm0
movss  %xmm0,-0x4(%rax,%rdi,4)
movss  (%rcx,%rbx,4),%xmm0
movss  %xmm0,(%rax,%rdi,4)
add    $0x4,%rdi
cmp    $0x20,%rdi
jne    1820 <pencil_convolution+0x720>
jmp    17c4 <pencil_convolution+0x6c4>
lea    0x6000c(%rdx),%r8
xor    %ebx,%ebx
jmp    1885 <pencil_convolution+0x785>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rbx
add    $0x1000,%r8
cmp    $0x10,%rbx
je     199a <pencil_convolution+0x89a>
lea    (%rcx,%rbx,4),%r9
lea    (%rcx,%rbx,4),%r10
add    $0x4,%r10
mov    %r8,%rax
xor    %r11d,%r11d
jmp    1916 <pencil_convolution+0x816>
nopl   0x0(%rax)
movss  (%rcx,%rbx,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movups %xmm0,0x60000(%rbp,%rdi,1)
movups %xmm0,0x60010(%rbp,%rdi,1)
movss  (%rcx,%rbx,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movups %xmm0,0x60020(%rbp,%rdi,1)
movups %xmm0,0x60030(%rbp,%rdi,1)
movss  (%rcx,%rbx,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movups %xmm0,0x60040(%rbp,%rdi,1)
movups %xmm0,0x60050(%rbp,%rdi,1)
movss  (%rcx,%rbx,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movups %xmm0,0x60060(%rbp,%rdi,1)
movups %xmm0,0x60070(%rbp,%rdi,1)
add    $0x1,%r11
sub    $0xffffffffffffff80,%rax
cmp    $0x20,%r11
je     1870 <pencil_convolution+0x770>
mov    %rbx,%rdi
shl    $0xc,%rdi
add    %rdx,%rdi
mov    %r11,%rbp
shl    $0x7,%rbp
lea    (%rdi,%rbp,1),%rsi
add    $0x60000,%rsi
cmp    %r10,%rsi
jae    18a0 <pencil_convolution+0x7a0>
lea    (%rdi,%rbp,1),%rsi
add    $0x60080,%rsi
cmp    %rsi,%r9
jae    18a0 <pencil_convolution+0x7a0>
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  (%rcx,%rbx,4),%xmm0
movss  %xmm0,-0xc(%rax,%rdi,4)
movss  (%rcx,%rbx,4),%xmm0
movss  %xmm0,-0x8(%rax,%rdi,4)
movss  (%rcx,%rbx,4),%xmm0
movss  %xmm0,-0x4(%rax,%rdi,4)
movss  (%rcx,%rbx,4),%xmm0
movss  %xmm0,(%rax,%rdi,4)
add    $0x4,%rdi
cmp    $0x20,%rdi
jne    1960 <pencil_convolution+0x860>
jmp    1904 <pencil_convolution+0x804>
lea    0x7000c(%rdx),%r8
xor    %ebx,%ebx
jmp    19c5 <pencil_convolution+0x8c5>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rbx
add    $0x1000,%r8
cmp    $0x10,%rbx
je     1ada <pencil_convolution+0x9da>
lea    (%rcx,%rbx,4),%r9
lea    (%rcx,%rbx,4),%r10
add    $0x4,%r10
mov    %r8,%rax
xor    %r11d,%r11d
jmp    1a56 <pencil_convolution+0x956>
nopl   0x0(%rax)
movss  (%rcx,%rbx,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movups %xmm0,0x70000(%rbp,%rdi,1)
movups %xmm0,0x70010(%rbp,%rdi,1)
movss  (%rcx,%rbx,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movups %xmm0,0x70020(%rbp,%rdi,1)
movups %xmm0,0x70030(%rbp,%rdi,1)
movss  (%rcx,%rbx,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movups %xmm0,0x70040(%rbp,%rdi,1)
movups %xmm0,0x70050(%rbp,%rdi,1)
movss  (%rcx,%rbx,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movups %xmm0,0x70060(%rbp,%rdi,1)
movups %xmm0,0x70070(%rbp,%rdi,1)
add    $0x1,%r11
sub    $0xffffffffffffff80,%rax
cmp    $0x20,%r11
je     19b0 <pencil_convolution+0x8b0>
mov    %rbx,%rdi
shl    $0xc,%rdi
add    %rdx,%rdi
mov    %r11,%rbp
shl    $0x7,%rbp
lea    (%rdi,%rbp,1),%rsi
add    $0x70000,%rsi
cmp    %r10,%rsi
jae    19e0 <pencil_convolution+0x8e0>
lea    (%rdi,%rbp,1),%rsi
add    $0x70080,%rsi
cmp    %rsi,%r9
jae    19e0 <pencil_convolution+0x8e0>
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  (%rcx,%rbx,4),%xmm0
movss  %xmm0,-0xc(%rax,%rdi,4)
movss  (%rcx,%rbx,4),%xmm0
movss  %xmm0,-0x8(%rax,%rdi,4)
movss  (%rcx,%rbx,4),%xmm0
movss  %xmm0,-0x4(%rax,%rdi,4)
movss  (%rcx,%rbx,4),%xmm0
movss  %xmm0,(%rax,%rdi,4)
add    $0x4,%rdi
cmp    $0x20,%rdi
jne    1aa0 <pencil_convolution+0x9a0>
jmp    1a44 <pencil_convolution+0x944>
addq   $0x10,-0x8(%rsp)
xor    %r8d,%r8d
mov    %r14,%rsi
cs nopw 0x0(%rax,%rax,1)
mov    %rsi,%r10
xor    %r11d,%r11d
cs nopw 0x0(%rax,%rax,1)
mov    -0x8(%rsp),%rdi
xor    %r14d,%r14d
nopl   0x0(%rax,%rax,1)
mov    %rdi,%r9
xor    %r15d,%r15d
cs nopw 0x0(%rax,%rax,1)
mov    %r8,%rax
shl    $0x10,%rax
add    %rdx,%rax
mov    %r11,%rcx
shl    $0xc,%rcx
add    %rax,%rcx
mov    %r14,%rax
shl    $0x7,%rax
add    %rcx,%rax
lea    (%rax,%r15,4),%rcx
movss  (%rax,%r15,4),%xmm0
add    $0x1,%r15
mov    %r10,%rbx
mov    %r9,%r12
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    $0x10,%ebp
mov    %r12,%r13
nopl   0x0(%rax,%rax,1)
movss  -0x10(%rbx,%rbp,1),%xmm1
mulss  -0x10(%r13),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,(%rcx)
movss  -0xc(%rbx,%rbp,1),%xmm0
mulss  -0xc(%r13),%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rcx)
movss  -0x8(%rbx,%rbp,1),%xmm1
mulss  -0x8(%r13),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,(%rcx)
movss  -0x4(%rbx,%rbp,1),%xmm2
mulss  -0x4(%r13),%xmm2
addss  %xmm1,%xmm2
movss  %xmm2,(%rcx)
movss  (%rbx,%rbp,1),%xmm0
mulss  0x0(%r13),%xmm0
addss  %xmm2,%xmm0
movss  %xmm0,(%rcx)
add    $0x90,%r13
add    $0x14,%rbp
cmp    $0x74,%rbp
jne    1b70 <pencil_convolution+0xa70>
add    $0x1,%rax
add    $0x1440,%r12
add    $0x64,%rbx
cmp    $0x10,%rax
jne    1b60 <pencil_convolution+0xa60>
add    $0x4,%r9
cmp    $0x20,%r15
jne    1b20 <pencil_convolution+0xa20>
add    $0x1,%r14
add    $0x90,%rdi
cmp    $0x20,%r14
jne    1b10 <pencil_convolution+0xa10>
add    $0x1,%r11
add    $0x640,%r10
cmp    $0x10,%r11
jne    1b00 <pencil_convolution+0xa00>
add    $0x1,%r8
addq   $0x14400,-0x8(%rsp)
cmp    $0x8,%r8
jne    1af0 <pencil_convolution+0x9f0>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @pencil_convolution([16 x [36 x [36 x float]]]* nocapture %0, [16 x [5 x [5 x float]]]* nocapture %1, [16 x [32 x [32 x float]]]* nocapture %2, float* nocapture %3) {
br label %5
5: ; preds = %4, %560
%6 = phi i64 [ 0, %4 ], [ %561, %560 ]
%7 = getelementptr float, float* %3, i64 %6
%8 = add nuw i64 %6, 1
%9 = getelementptr float, float* %3, i64 %8
%10 = getelementptr inbounds float, float* %3, i64 %6
br label %515
11: ; preds = %560, %80
%12 = phi i64 [ %81, %80 ], [ 0, %560 ]
%13 = getelementptr float, float* %3, i64 %12
%14 = add nuw i64 %12, 1
%15 = getelementptr float, float* %3, i64 %14
%16 = getelementptr inbounds float, float* %3, i64 %12
br label %17
17: ; preds = %11, %77
%18 = phi i64 [ 0, %11 ], [ %78, %77 ]
%19 = add nuw i64 %18, 1
%20 = getelementptr [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 1, i64 %12, i64 %19, i64 0
%21 = getelementptr [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 1, i64 %12, i64 %18, i64 0
%22 = icmp ult float* %21, %15
%23 = icmp ult float* %13, %20
%24 = and i1 %22, %23
br i1 %24, label %62, label %25
25: ; preds = %17
%26 = load float, float* %16
%27 = insertelement <4 x float> poison, float %26, i64 0
%28 = shufflevector <4 x float> %27, <4 x float> poison, <4 x i32> zeroinitializer
%29 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 1, i64 %12, i64 %18, i64 0
%30 = bitcast float* %29 to <4 x float>*
store <4 x float> %28, <4 x float>* %30
%31 = insertelement <4 x float> poison, float %26, i64 0
%32 = shufflevector <4 x float> %31, <4 x float> poison, <4 x i32> zeroinitializer
%33 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 1, i64 %12, i64 %18, i64 4
%34 = bitcast float* %33 to <4 x float>*
store <4 x float> %32, <4 x float>* %34
%35 = load float, float* %16
%36 = insertelement <4 x float> poison, float %35, i64 0
%37 = shufflevector <4 x float> %36, <4 x float> poison, <4 x i32> zeroinitializer
%38 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 1, i64 %12, i64 %18, i64 8
%39 = bitcast float* %38 to <4 x float>*
store <4 x float> %37, <4 x float>* %39
%40 = insertelement <4 x float> poison, float %35, i64 0
%41 = shufflevector <4 x float> %40, <4 x float> poison, <4 x i32> zeroinitializer
%42 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 1, i64 %12, i64 %18, i64 12
%43 = bitcast float* %42 to <4 x float>*
store <4 x float> %41, <4 x float>* %43
%44 = load float, float* %16
%45 = insertelement <4 x float> poison, float %44, i64 0
%46 = shufflevector <4 x float> %45, <4 x float> poison, <4 x i32> zeroinitializer
%47 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 1, i64 %12, i64 %18, i64 16
%48 = bitcast float* %47 to <4 x float>*
store <4 x float> %46, <4 x float>* %48
%49 = insertelement <4 x float> poison, float %44, i64 0
%50 = shufflevector <4 x float> %49, <4 x float> poison, <4 x i32> zeroinitializer
%51 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 1, i64 %12, i64 %18, i64 20
%52 = bitcast float* %51 to <4 x float>*
store <4 x float> %50, <4 x float>* %52
%53 = load float, float* %16
%54 = insertelement <4 x float> poison, float %53, i64 0
%55 = shufflevector <4 x float> %54, <4 x float> poison, <4 x i32> zeroinitializer
%56 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 1, i64 %12, i64 %18, i64 24
%57 = bitcast float* %56 to <4 x float>*
store <4 x float> %55, <4 x float>* %57
%58 = insertelement <4 x float> poison, float %53, i64 0
%59 = shufflevector <4 x float> %58, <4 x float> poison, <4 x i32> zeroinitializer
%60 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 1, i64 %12, i64 %18, i64 28
%61 = bitcast float* %60 to <4 x float>*
store <4 x float> %59, <4 x float>* %61
br label %77
62: ; preds = %17, %62
%63 = phi i64 [ %75, %62 ], [ 0, %17 ]
%64 = load float, float* %16
%65 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 1, i64 %12, i64 %18, i64 %63
store float %64, float* %65
%66 = or i64 %63, 1
%67 = load float, float* %16
%68 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 1, i64 %12, i64 %18, i64 %66
store float %67, float* %68
%69 = or i64 %63, 2
%70 = load float, float* %16
%71 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 1, i64 %12, i64 %18, i64 %69
store float %70, float* %71
%72 = or i64 %63, 3
%73 = load float, float* %16
%74 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 1, i64 %12, i64 %18, i64 %72
store float %73, float* %74
%75 = add nuw nsw i64 %63, 4
%76 = icmp eq i64 %75, 32
br i1 %76, label %77, label %62
77: ; preds = %62, %25
%78 = add nuw nsw i64 %18, 1
%79 = icmp eq i64 %78, 32
br i1 %79, label %80, label %17
80: ; preds = %77
%81 = add nuw nsw i64 %12, 1
%82 = icmp eq i64 %81, 16
br i1 %82, label %83, label %11
83: ; preds = %80, %152
%84 = phi i64 [ %153, %152 ], [ 0, %80 ]
%85 = getelementptr float, float* %3, i64 %84
%86 = add nuw i64 %84, 1
%87 = getelementptr float, float* %3, i64 %86
%88 = getelementptr inbounds float, float* %3, i64 %84
br label %89
89: ; preds = %83, %149
%90 = phi i64 [ 0, %83 ], [ %150, %149 ]
%91 = add nuw i64 %90, 1
%92 = getelementptr [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 2, i64 %84, i64 %91, i64 0
%93 = getelementptr [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 2, i64 %84, i64 %90, i64 0
%94 = icmp ult float* %93, %87
%95 = icmp ult float* %85, %92
%96 = and i1 %94, %95
br i1 %96, label %134, label %97
97: ; preds = %89
%98 = load float, float* %88
%99 = insertelement <4 x float> poison, float %98, i64 0
%100 = shufflevector <4 x float> %99, <4 x float> poison, <4 x i32> zeroinitializer
%101 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 2, i64 %84, i64 %90, i64 0
%102 = bitcast float* %101 to <4 x float>*
store <4 x float> %100, <4 x float>* %102
%103 = insertelement <4 x float> poison, float %98, i64 0
%104 = shufflevector <4 x float> %103, <4 x float> poison, <4 x i32> zeroinitializer
%105 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 2, i64 %84, i64 %90, i64 4
%106 = bitcast float* %105 to <4 x float>*
store <4 x float> %104, <4 x float>* %106
%107 = load float, float* %88
%108 = insertelement <4 x float> poison, float %107, i64 0
%109 = shufflevector <4 x float> %108, <4 x float> poison, <4 x i32> zeroinitializer
%110 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 2, i64 %84, i64 %90, i64 8
%111 = bitcast float* %110 to <4 x float>*
store <4 x float> %109, <4 x float>* %111
%112 = insertelement <4 x float> poison, float %107, i64 0
%113 = shufflevector <4 x float> %112, <4 x float> poison, <4 x i32> zeroinitializer
%114 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 2, i64 %84, i64 %90, i64 12
%115 = bitcast float* %114 to <4 x float>*
store <4 x float> %113, <4 x float>* %115
%116 = load float, float* %88
%117 = insertelement <4 x float> poison, float %116, i64 0
%118 = shufflevector <4 x float> %117, <4 x float> poison, <4 x i32> zeroinitializer
%119 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 2, i64 %84, i64 %90, i64 16
%120 = bitcast float* %119 to <4 x float>*
store <4 x float> %118, <4 x float>* %120
%121 = insertelement <4 x float> poison, float %116, i64 0
%122 = shufflevector <4 x float> %121, <4 x float> poison, <4 x i32> zeroinitializer
%123 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 2, i64 %84, i64 %90, i64 20
%124 = bitcast float* %123 to <4 x float>*
store <4 x float> %122, <4 x float>* %124
%125 = load float, float* %88
%126 = insertelement <4 x float> poison, float %125, i64 0
%127 = shufflevector <4 x float> %126, <4 x float> poison, <4 x i32> zeroinitializer
%128 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 2, i64 %84, i64 %90, i64 24
%129 = bitcast float* %128 to <4 x float>*
store <4 x float> %127, <4 x float>* %129
%130 = insertelement <4 x float> poison, float %125, i64 0
%131 = shufflevector <4 x float> %130, <4 x float> poison, <4 x i32> zeroinitializer
%132 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 2, i64 %84, i64 %90, i64 28
%133 = bitcast float* %132 to <4 x float>*
store <4 x float> %131, <4 x float>* %133
br label %149
134: ; preds = %89, %134
%135 = phi i64 [ %147, %134 ], [ 0, %89 ]
%136 = load float, float* %88
%137 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 2, i64 %84, i64 %90, i64 %135
store float %136, float* %137
%138 = or i64 %135, 1
%139 = load float, float* %88
%140 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 2, i64 %84, i64 %90, i64 %138
store float %139, float* %140
%141 = or i64 %135, 2
%142 = load float, float* %88
%143 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 2, i64 %84, i64 %90, i64 %141
store float %142, float* %143
%144 = or i64 %135, 3
%145 = load float, float* %88
%146 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 2, i64 %84, i64 %90, i64 %144
store float %145, float* %146
%147 = add nuw nsw i64 %135, 4
%148 = icmp eq i64 %147, 32
br i1 %148, label %149, label %134
149: ; preds = %134, %97
%150 = add nuw nsw i64 %90, 1
%151 = icmp eq i64 %150, 32
br i1 %151, label %152, label %89
152: ; preds = %149
%153 = add nuw nsw i64 %84, 1
%154 = icmp eq i64 %153, 16
br i1 %154, label %155, label %83
155: ; preds = %152, %224
%156 = phi i64 [ %225, %224 ], [ 0, %152 ]
%157 = getelementptr float, float* %3, i64 %156
%158 = add nuw i64 %156, 1
%159 = getelementptr float, float* %3, i64 %158
%160 = getelementptr inbounds float, float* %3, i64 %156
br label %161
161: ; preds = %155, %221
%162 = phi i64 [ 0, %155 ], [ %222, %221 ]
%163 = add nuw i64 %162, 1
%164 = getelementptr [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 3, i64 %156, i64 %163, i64 0
%165 = getelementptr [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 3, i64 %156, i64 %162, i64 0
%166 = icmp ult float* %165, %159
%167 = icmp ult float* %157, %164
%168 = and i1 %166, %167
br i1 %168, label %206, label %169
169: ; preds = %161
%170 = load float, float* %160
%171 = insertelement <4 x float> poison, float %170, i64 0
%172 = shufflevector <4 x float> %171, <4 x float> poison, <4 x i32> zeroinitializer
%173 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 3, i64 %156, i64 %162, i64 0
%174 = bitcast float* %173 to <4 x float>*
store <4 x float> %172, <4 x float>* %174
%175 = insertelement <4 x float> poison, float %170, i64 0
%176 = shufflevector <4 x float> %175, <4 x float> poison, <4 x i32> zeroinitializer
%177 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 3, i64 %156, i64 %162, i64 4
%178 = bitcast float* %177 to <4 x float>*
store <4 x float> %176, <4 x float>* %178
%179 = load float, float* %160
%180 = insertelement <4 x float> poison, float %179, i64 0
%181 = shufflevector <4 x float> %180, <4 x float> poison, <4 x i32> zeroinitializer
%182 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 3, i64 %156, i64 %162, i64 8
%183 = bitcast float* %182 to <4 x float>*
store <4 x float> %181, <4 x float>* %183
%184 = insertelement <4 x float> poison, float %179, i64 0
%185 = shufflevector <4 x float> %184, <4 x float> poison, <4 x i32> zeroinitializer
%186 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 3, i64 %156, i64 %162, i64 12
%187 = bitcast float* %186 to <4 x float>*
store <4 x float> %185, <4 x float>* %187
%188 = load float, float* %160
%189 = insertelement <4 x float> poison, float %188, i64 0
%190 = shufflevector <4 x float> %189, <4 x float> poison, <4 x i32> zeroinitializer
%191 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 3, i64 %156, i64 %162, i64 16
%192 = bitcast float* %191 to <4 x float>*
store <4 x float> %190, <4 x float>* %192
%193 = insertelement <4 x float> poison, float %188, i64 0
%194 = shufflevector <4 x float> %193, <4 x float> poison, <4 x i32> zeroinitializer
%195 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 3, i64 %156, i64 %162, i64 20
%196 = bitcast float* %195 to <4 x float>*
store <4 x float> %194, <4 x float>* %196
%197 = load float, float* %160
%198 = insertelement <4 x float> poison, float %197, i64 0
%199 = shufflevector <4 x float> %198, <4 x float> poison, <4 x i32> zeroinitializer
%200 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 3, i64 %156, i64 %162, i64 24
%201 = bitcast float* %200 to <4 x float>*
store <4 x float> %199, <4 x float>* %201
%202 = insertelement <4 x float> poison, float %197, i64 0
%203 = shufflevector <4 x float> %202, <4 x float> poison, <4 x i32> zeroinitializer
%204 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 3, i64 %156, i64 %162, i64 28
%205 = bitcast float* %204 to <4 x float>*
store <4 x float> %203, <4 x float>* %205
br label %221
206: ; preds = %161, %206
%207 = phi i64 [ %219, %206 ], [ 0, %161 ]
%208 = load float, float* %160
%209 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 3, i64 %156, i64 %162, i64 %207
store float %208, float* %209
%210 = or i64 %207, 1
%211 = load float, float* %160
%212 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 3, i64 %156, i64 %162, i64 %210
store float %211, float* %212
%213 = or i64 %207, 2
%214 = load float, float* %160
%215 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 3, i64 %156, i64 %162, i64 %213
store float %214, float* %215
%216 = or i64 %207, 3
%217 = load float, float* %160
%218 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 3, i64 %156, i64 %162, i64 %216
store float %217, float* %218
%219 = add nuw nsw i64 %207, 4
%220 = icmp eq i64 %219, 32
br i1 %220, label %221, label %206
221: ; preds = %206, %169
%222 = add nuw nsw i64 %162, 1
%223 = icmp eq i64 %222, 32
br i1 %223, label %224, label %161
224: ; preds = %221
%225 = add nuw nsw i64 %156, 1
%226 = icmp eq i64 %225, 16
br i1 %226, label %227, label %155
227: ; preds = %224, %296
%228 = phi i64 [ %297, %296 ], [ 0, %224 ]
%229 = getelementptr float, float* %3, i64 %228
%230 = add nuw i64 %228, 1
%231 = getelementptr float, float* %3, i64 %230
%232 = getelementptr inbounds float, float* %3, i64 %228
br label %233
233: ; preds = %227, %293
%234 = phi i64 [ 0, %227 ], [ %294, %293 ]
%235 = add nuw i64 %234, 1
%236 = getelementptr [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 4, i64 %228, i64 %235, i64 0
%237 = getelementptr [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 4, i64 %228, i64 %234, i64 0
%238 = icmp ult float* %237, %231
%239 = icmp ult float* %229, %236
%240 = and i1 %238, %239
br i1 %240, label %278, label %241
241: ; preds = %233
%242 = load float, float* %232
%243 = insertelement <4 x float> poison, float %242, i64 0
%244 = shufflevector <4 x float> %243, <4 x float> poison, <4 x i32> zeroinitializer
%245 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 4, i64 %228, i64 %234, i64 0
%246 = bitcast float* %245 to <4 x float>*
store <4 x float> %244, <4 x float>* %246
%247 = insertelement <4 x float> poison, float %242, i64 0
%248 = shufflevector <4 x float> %247, <4 x float> poison, <4 x i32> zeroinitializer
%249 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 4, i64 %228, i64 %234, i64 4
%250 = bitcast float* %249 to <4 x float>*
store <4 x float> %248, <4 x float>* %250
%251 = load float, float* %232
%252 = insertelement <4 x float> poison, float %251, i64 0
%253 = shufflevector <4 x float> %252, <4 x float> poison, <4 x i32> zeroinitializer
%254 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 4, i64 %228, i64 %234, i64 8
%255 = bitcast float* %254 to <4 x float>*
store <4 x float> %253, <4 x float>* %255
%256 = insertelement <4 x float> poison, float %251, i64 0
%257 = shufflevector <4 x float> %256, <4 x float> poison, <4 x i32> zeroinitializer
%258 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 4, i64 %228, i64 %234, i64 12
%259 = bitcast float* %258 to <4 x float>*
store <4 x float> %257, <4 x float>* %259
%260 = load float, float* %232
%261 = insertelement <4 x float> poison, float %260, i64 0
%262 = shufflevector <4 x float> %261, <4 x float> poison, <4 x i32> zeroinitializer
%263 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 4, i64 %228, i64 %234, i64 16
%264 = bitcast float* %263 to <4 x float>*
store <4 x float> %262, <4 x float>* %264
%265 = insertelement <4 x float> poison, float %260, i64 0
%266 = shufflevector <4 x float> %265, <4 x float> poison, <4 x i32> zeroinitializer
%267 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 4, i64 %228, i64 %234, i64 20
%268 = bitcast float* %267 to <4 x float>*
store <4 x float> %266, <4 x float>* %268
%269 = load float, float* %232
%270 = insertelement <4 x float> poison, float %269, i64 0
%271 = shufflevector <4 x float> %270, <4 x float> poison, <4 x i32> zeroinitializer
%272 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 4, i64 %228, i64 %234, i64 24
%273 = bitcast float* %272 to <4 x float>*
store <4 x float> %271, <4 x float>* %273
%274 = insertelement <4 x float> poison, float %269, i64 0
%275 = shufflevector <4 x float> %274, <4 x float> poison, <4 x i32> zeroinitializer
%276 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 4, i64 %228, i64 %234, i64 28
%277 = bitcast float* %276 to <4 x float>*
store <4 x float> %275, <4 x float>* %277
br label %293
278: ; preds = %233, %278
%279 = phi i64 [ %291, %278 ], [ 0, %233 ]
%280 = load float, float* %232
%281 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 4, i64 %228, i64 %234, i64 %279
store float %280, float* %281
%282 = or i64 %279, 1
%283 = load float, float* %232
%284 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 4, i64 %228, i64 %234, i64 %282
store float %283, float* %284
%285 = or i64 %279, 2
%286 = load float, float* %232
%287 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 4, i64 %228, i64 %234, i64 %285
store float %286, float* %287
%288 = or i64 %279, 3
%289 = load float, float* %232
%290 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 4, i64 %228, i64 %234, i64 %288
store float %289, float* %290
%291 = add nuw nsw i64 %279, 4
%292 = icmp eq i64 %291, 32
br i1 %292, label %293, label %278
293: ; preds = %278, %241
%294 = add nuw nsw i64 %234, 1
%295 = icmp eq i64 %294, 32
br i1 %295, label %296, label %233
296: ; preds = %293
%297 = add nuw nsw i64 %228, 1
%298 = icmp eq i64 %297, 16
br i1 %298, label %299, label %227
299: ; preds = %296, %368
%300 = phi i64 [ %369, %368 ], [ 0, %296 ]
%301 = getelementptr float, float* %3, i64 %300
%302 = add nuw i64 %300, 1
%303 = getelementptr float, float* %3, i64 %302
%304 = getelementptr inbounds float, float* %3, i64 %300
br label %305
305: ; preds = %299, %365
%306 = phi i64 [ 0, %299 ], [ %366, %365 ]
%307 = add nuw i64 %306, 1
%308 = getelementptr [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 5, i64 %300, i64 %307, i64 0
%309 = getelementptr [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 5, i64 %300, i64 %306, i64 0
%310 = icmp ult float* %309, %303
%311 = icmp ult float* %301, %308
%312 = and i1 %310, %311
br i1 %312, label %350, label %313
313: ; preds = %305
%314 = load float, float* %304
%315 = insertelement <4 x float> poison, float %314, i64 0
%316 = shufflevector <4 x float> %315, <4 x float> poison, <4 x i32> zeroinitializer
%317 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 5, i64 %300, i64 %306, i64 0
%318 = bitcast float* %317 to <4 x float>*
store <4 x float> %316, <4 x float>* %318
%319 = insertelement <4 x float> poison, float %314, i64 0
%320 = shufflevector <4 x float> %319, <4 x float> poison, <4 x i32> zeroinitializer
%321 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 5, i64 %300, i64 %306, i64 4
%322 = bitcast float* %321 to <4 x float>*
store <4 x float> %320, <4 x float>* %322
%323 = load float, float* %304
%324 = insertelement <4 x float> poison, float %323, i64 0
%325 = shufflevector <4 x float> %324, <4 x float> poison, <4 x i32> zeroinitializer
%326 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 5, i64 %300, i64 %306, i64 8
%327 = bitcast float* %326 to <4 x float>*
store <4 x float> %325, <4 x float>* %327
%328 = insertelement <4 x float> poison, float %323, i64 0
%329 = shufflevector <4 x float> %328, <4 x float> poison, <4 x i32> zeroinitializer
%330 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 5, i64 %300, i64 %306, i64 12
%331 = bitcast float* %330 to <4 x float>*
store <4 x float> %329, <4 x float>* %331
%332 = load float, float* %304
%333 = insertelement <4 x float> poison, float %332, i64 0
%334 = shufflevector <4 x float> %333, <4 x float> poison, <4 x i32> zeroinitializer
%335 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 5, i64 %300, i64 %306, i64 16
%336 = bitcast float* %335 to <4 x float>*
store <4 x float> %334, <4 x float>* %336
%337 = insertelement <4 x float> poison, float %332, i64 0
%338 = shufflevector <4 x float> %337, <4 x float> poison, <4 x i32> zeroinitializer
%339 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 5, i64 %300, i64 %306, i64 20
%340 = bitcast float* %339 to <4 x float>*
store <4 x float> %338, <4 x float>* %340
%341 = load float, float* %304
%342 = insertelement <4 x float> poison, float %341, i64 0
%343 = shufflevector <4 x float> %342, <4 x float> poison, <4 x i32> zeroinitializer
%344 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 5, i64 %300, i64 %306, i64 24
%345 = bitcast float* %344 to <4 x float>*
store <4 x float> %343, <4 x float>* %345
%346 = insertelement <4 x float> poison, float %341, i64 0
%347 = shufflevector <4 x float> %346, <4 x float> poison, <4 x i32> zeroinitializer
%348 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 5, i64 %300, i64 %306, i64 28
%349 = bitcast float* %348 to <4 x float>*
store <4 x float> %347, <4 x float>* %349
br label %365
350: ; preds = %305, %350
%351 = phi i64 [ %363, %350 ], [ 0, %305 ]
%352 = load float, float* %304
%353 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 5, i64 %300, i64 %306, i64 %351
store float %352, float* %353
%354 = or i64 %351, 1
%355 = load float, float* %304
%356 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 5, i64 %300, i64 %306, i64 %354
store float %355, float* %356
%357 = or i64 %351, 2
%358 = load float, float* %304
%359 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 5, i64 %300, i64 %306, i64 %357
store float %358, float* %359
%360 = or i64 %351, 3
%361 = load float, float* %304
%362 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 5, i64 %300, i64 %306, i64 %360
store float %361, float* %362
%363 = add nuw nsw i64 %351, 4
%364 = icmp eq i64 %363, 32
br i1 %364, label %365, label %350
365: ; preds = %350, %313
%366 = add nuw nsw i64 %306, 1
%367 = icmp eq i64 %366, 32
br i1 %367, label %368, label %305
368: ; preds = %365
%369 = add nuw nsw i64 %300, 1
%370 = icmp eq i64 %369, 16
br i1 %370, label %371, label %299
371: ; preds = %368, %440
%372 = phi i64 [ %441, %440 ], [ 0, %368 ]
%373 = getelementptr float, float* %3, i64 %372
%374 = add nuw i64 %372, 1
%375 = getelementptr float, float* %3, i64 %374
%376 = getelementptr inbounds float, float* %3, i64 %372
br label %377
377: ; preds = %371, %437
%378 = phi i64 [ 0, %371 ], [ %438, %437 ]
%379 = add nuw i64 %378, 1
%380 = getelementptr [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 6, i64 %372, i64 %379, i64 0
%381 = getelementptr [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 6, i64 %372, i64 %378, i64 0
%382 = icmp ult float* %381, %375
%383 = icmp ult float* %373, %380
%384 = and i1 %382, %383
br i1 %384, label %422, label %385
385: ; preds = %377
%386 = load float, float* %376
%387 = insertelement <4 x float> poison, float %386, i64 0
%388 = shufflevector <4 x float> %387, <4 x float> poison, <4 x i32> zeroinitializer
%389 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 6, i64 %372, i64 %378, i64 0
%390 = bitcast float* %389 to <4 x float>*
store <4 x float> %388, <4 x float>* %390
%391 = insertelement <4 x float> poison, float %386, i64 0
%392 = shufflevector <4 x float> %391, <4 x float> poison, <4 x i32> zeroinitializer
%393 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 6, i64 %372, i64 %378, i64 4
%394 = bitcast float* %393 to <4 x float>*
store <4 x float> %392, <4 x float>* %394
%395 = load float, float* %376
%396 = insertelement <4 x float> poison, float %395, i64 0
%397 = shufflevector <4 x float> %396, <4 x float> poison, <4 x i32> zeroinitializer
%398 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 6, i64 %372, i64 %378, i64 8
%399 = bitcast float* %398 to <4 x float>*
store <4 x float> %397, <4 x float>* %399
%400 = insertelement <4 x float> poison, float %395, i64 0
%401 = shufflevector <4 x float> %400, <4 x float> poison, <4 x i32> zeroinitializer
%402 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 6, i64 %372, i64 %378, i64 12
%403 = bitcast float* %402 to <4 x float>*
store <4 x float> %401, <4 x float>* %403
%404 = load float, float* %376
%405 = insertelement <4 x float> poison, float %404, i64 0
%406 = shufflevector <4 x float> %405, <4 x float> poison, <4 x i32> zeroinitializer
%407 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 6, i64 %372, i64 %378, i64 16
%408 = bitcast float* %407 to <4 x float>*
store <4 x float> %406, <4 x float>* %408
%409 = insertelement <4 x float> poison, float %404, i64 0
%410 = shufflevector <4 x float> %409, <4 x float> poison, <4 x i32> zeroinitializer
%411 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 6, i64 %372, i64 %378, i64 20
%412 = bitcast float* %411 to <4 x float>*
store <4 x float> %410, <4 x float>* %412
%413 = load float, float* %376
%414 = insertelement <4 x float> poison, float %413, i64 0
%415 = shufflevector <4 x float> %414, <4 x float> poison, <4 x i32> zeroinitializer
%416 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 6, i64 %372, i64 %378, i64 24
%417 = bitcast float* %416 to <4 x float>*
store <4 x float> %415, <4 x float>* %417
%418 = insertelement <4 x float> poison, float %413, i64 0
%419 = shufflevector <4 x float> %418, <4 x float> poison, <4 x i32> zeroinitializer
%420 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 6, i64 %372, i64 %378, i64 28
%421 = bitcast float* %420 to <4 x float>*
store <4 x float> %419, <4 x float>* %421
br label %437
422: ; preds = %377, %422
%423 = phi i64 [ %435, %422 ], [ 0, %377 ]
%424 = load float, float* %376
%425 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 6, i64 %372, i64 %378, i64 %423
store float %424, float* %425
%426 = or i64 %423, 1
%427 = load float, float* %376
%428 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 6, i64 %372, i64 %378, i64 %426
store float %427, float* %428
%429 = or i64 %423, 2
%430 = load float, float* %376
%431 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 6, i64 %372, i64 %378, i64 %429
store float %430, float* %431
%432 = or i64 %423, 3
%433 = load float, float* %376
%434 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 6, i64 %372, i64 %378, i64 %432
store float %433, float* %434
%435 = add nuw nsw i64 %423, 4
%436 = icmp eq i64 %435, 32
br i1 %436, label %437, label %422
437: ; preds = %422, %385
%438 = add nuw nsw i64 %378, 1
%439 = icmp eq i64 %438, 32
br i1 %439, label %440, label %377
440: ; preds = %437
%441 = add nuw nsw i64 %372, 1
%442 = icmp eq i64 %441, 16
br i1 %442, label %443, label %371
443: ; preds = %440, %512
%444 = phi i64 [ %513, %512 ], [ 0, %440 ]
%445 = getelementptr float, float* %3, i64 %444
%446 = add nuw i64 %444, 1
%447 = getelementptr float, float* %3, i64 %446
%448 = getelementptr inbounds float, float* %3, i64 %444
br label %449
449: ; preds = %443, %509
%450 = phi i64 [ 0, %443 ], [ %510, %509 ]
%451 = add nuw i64 %450, 1
%452 = getelementptr [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 7, i64 %444, i64 %451, i64 0
%453 = getelementptr [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 7, i64 %444, i64 %450, i64 0
%454 = icmp ult float* %453, %447
%455 = icmp ult float* %445, %452
%456 = and i1 %454, %455
br i1 %456, label %494, label %457
457: ; preds = %449
%458 = load float, float* %448
%459 = insertelement <4 x float> poison, float %458, i64 0
%460 = shufflevector <4 x float> %459, <4 x float> poison, <4 x i32> zeroinitializer
%461 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 7, i64 %444, i64 %450, i64 0
%462 = bitcast float* %461 to <4 x float>*
store <4 x float> %460, <4 x float>* %462
%463 = insertelement <4 x float> poison, float %458, i64 0
%464 = shufflevector <4 x float> %463, <4 x float> poison, <4 x i32> zeroinitializer
%465 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 7, i64 %444, i64 %450, i64 4
%466 = bitcast float* %465 to <4 x float>*
store <4 x float> %464, <4 x float>* %466
%467 = load float, float* %448
%468 = insertelement <4 x float> poison, float %467, i64 0
%469 = shufflevector <4 x float> %468, <4 x float> poison, <4 x i32> zeroinitializer
%470 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 7, i64 %444, i64 %450, i64 8
%471 = bitcast float* %470 to <4 x float>*
store <4 x float> %469, <4 x float>* %471
%472 = insertelement <4 x float> poison, float %467, i64 0
%473 = shufflevector <4 x float> %472, <4 x float> poison, <4 x i32> zeroinitializer
%474 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 7, i64 %444, i64 %450, i64 12
%475 = bitcast float* %474 to <4 x float>*
store <4 x float> %473, <4 x float>* %475
%476 = load float, float* %448
%477 = insertelement <4 x float> poison, float %476, i64 0
%478 = shufflevector <4 x float> %477, <4 x float> poison, <4 x i32> zeroinitializer
%479 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 7, i64 %444, i64 %450, i64 16
%480 = bitcast float* %479 to <4 x float>*
store <4 x float> %478, <4 x float>* %480
%481 = insertelement <4 x float> poison, float %476, i64 0
%482 = shufflevector <4 x float> %481, <4 x float> poison, <4 x i32> zeroinitializer
%483 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 7, i64 %444, i64 %450, i64 20
%484 = bitcast float* %483 to <4 x float>*
store <4 x float> %482, <4 x float>* %484
%485 = load float, float* %448
%486 = insertelement <4 x float> poison, float %485, i64 0
%487 = shufflevector <4 x float> %486, <4 x float> poison, <4 x i32> zeroinitializer
%488 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 7, i64 %444, i64 %450, i64 24
%489 = bitcast float* %488 to <4 x float>*
store <4 x float> %487, <4 x float>* %489
%490 = insertelement <4 x float> poison, float %485, i64 0
%491 = shufflevector <4 x float> %490, <4 x float> poison, <4 x i32> zeroinitializer
%492 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 7, i64 %444, i64 %450, i64 28
%493 = bitcast float* %492 to <4 x float>*
store <4 x float> %491, <4 x float>* %493
br label %509
494: ; preds = %449, %494
%495 = phi i64 [ %507, %494 ], [ 0, %449 ]
%496 = load float, float* %448
%497 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 7, i64 %444, i64 %450, i64 %495
store float %496, float* %497
%498 = or i64 %495, 1
%499 = load float, float* %448
%500 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 7, i64 %444, i64 %450, i64 %498
store float %499, float* %500
%501 = or i64 %495, 2
%502 = load float, float* %448
%503 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 7, i64 %444, i64 %450, i64 %501
store float %502, float* %503
%504 = or i64 %495, 3
%505 = load float, float* %448
%506 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 7, i64 %444, i64 %450, i64 %504
store float %505, float* %506
%507 = add nuw nsw i64 %495, 4
%508 = icmp eq i64 %507, 32
br i1 %508, label %509, label %494
509: ; preds = %494, %457
%510 = add nuw nsw i64 %450, 1
%511 = icmp eq i64 %510, 32
br i1 %511, label %512, label %449
512: ; preds = %509
%513 = add nuw nsw i64 %444, 1
%514 = icmp eq i64 %513, 16
br i1 %514, label %581, label %443
515: ; preds = %563, %5
%516 = phi i64 [ 0, %5 ], [ %564, %563 ]
%517 = add nuw i64 %516, 1
%518 = getelementptr [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 0, i64 %6, i64 %517, i64 0
%519 = getelementptr [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 0, i64 %6, i64 %516, i64 0
%520 = icmp ult float* %519, %9
%521 = icmp ult float* %7, %518
%522 = and i1 %520, %521
br i1 %522, label %566, label %523
523: ; preds = %515
%524 = load float, float* %10
%525 = insertelement <4 x float> poison, float %524, i64 0
%526 = shufflevector <4 x float> %525, <4 x float> poison, <4 x i32> zeroinitializer
%527 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 0, i64 %6, i64 %516, i64 0
%528 = bitcast float* %527 to <4 x float>*
store <4 x float> %526, <4 x float>* %528
%529 = insertelement <4 x float> poison, float %524, i64 0
%530 = shufflevector <4 x float> %529, <4 x float> poison, <4 x i32> zeroinitializer
%531 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 0, i64 %6, i64 %516, i64 4
%532 = bitcast float* %531 to <4 x float>*
store <4 x float> %530, <4 x float>* %532
%533 = load float, float* %10
%534 = insertelement <4 x float> poison, float %533, i64 0
%535 = shufflevector <4 x float> %534, <4 x float> poison, <4 x i32> zeroinitializer
%536 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 0, i64 %6, i64 %516, i64 8
%537 = bitcast float* %536 to <4 x float>*
store <4 x float> %535, <4 x float>* %537
%538 = insertelement <4 x float> poison, float %533, i64 0
%539 = shufflevector <4 x float> %538, <4 x float> poison, <4 x i32> zeroinitializer
%540 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 0, i64 %6, i64 %516, i64 12
%541 = bitcast float* %540 to <4 x float>*
store <4 x float> %539, <4 x float>* %541
%542 = load float, float* %10
%543 = insertelement <4 x float> poison, float %542, i64 0
%544 = shufflevector <4 x float> %543, <4 x float> poison, <4 x i32> zeroinitializer
%545 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 0, i64 %6, i64 %516, i64 16
%546 = bitcast float* %545 to <4 x float>*
store <4 x float> %544, <4 x float>* %546
%547 = insertelement <4 x float> poison, float %542, i64 0
%548 = shufflevector <4 x float> %547, <4 x float> poison, <4 x i32> zeroinitializer
%549 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 0, i64 %6, i64 %516, i64 20
%550 = bitcast float* %549 to <4 x float>*
store <4 x float> %548, <4 x float>* %550
%551 = load float, float* %10
%552 = insertelement <4 x float> poison, float %551, i64 0
%553 = shufflevector <4 x float> %552, <4 x float> poison, <4 x i32> zeroinitializer
%554 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 0, i64 %6, i64 %516, i64 24
%555 = bitcast float* %554 to <4 x float>*
store <4 x float> %553, <4 x float>* %555
%556 = insertelement <4 x float> poison, float %551, i64 0
%557 = shufflevector <4 x float> %556, <4 x float> poison, <4 x i32> zeroinitializer
%558 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 0, i64 %6, i64 %516, i64 28
%559 = bitcast float* %558 to <4 x float>*
store <4 x float> %557, <4 x float>* %559
br label %563
560: ; preds = %563
%561 = add nuw nsw i64 %6, 1
%562 = icmp eq i64 %561, 16
br i1 %562, label %11, label %5
563: ; preds = %566, %523
%564 = add nuw nsw i64 %516, 1
%565 = icmp eq i64 %564, 32
br i1 %565, label %560, label %515
566: ; preds = %515, %566
%567 = phi i64 [ %579, %566 ], [ 0, %515 ]
%568 = load float, float* %10
%569 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 0, i64 %6, i64 %516, i64 %567
store float %568, float* %569
%570 = or i64 %567, 1
%571 = load float, float* %10
%572 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 0, i64 %6, i64 %516, i64 %570
store float %571, float* %572
%573 = or i64 %567, 2
%574 = load float, float* %10
%575 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 0, i64 %6, i64 %516, i64 %573
store float %574, float* %575
%576 = or i64 %567, 3
%577 = load float, float* %10
%578 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 0, i64 %6, i64 %516, i64 %576
store float %577, float* %578
%579 = add nuw nsw i64 %567, 4
%580 = icmp eq i64 %579, 32
br i1 %580, label %563, label %566
581: ; preds = %512, %586
%582 = phi i64 [ %587, %586 ], [ 0, %512 ]
br label %584
583: ; preds = %586
ret void
584: ; preds = %581, %591
%585 = phi i64 [ 0, %581 ], [ %592, %591 ]
br label %589
586: ; preds = %591
%587 = add nuw nsw i64 %582, 1
%588 = icmp eq i64 %587, 8
br i1 %588, label %583, label %581
589: ; preds = %584, %602
%590 = phi i64 [ 0, %584 ], [ %603, %602 ]
br label %594
591: ; preds = %602
%592 = add nuw nsw i64 %585, 1
%593 = icmp eq i64 %592, 16
br i1 %593, label %586, label %584
594: ; preds = %589, %608
%595 = phi i64 [ 0, %589 ], [ %598, %608 ]
%596 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 %582, i64 %585, i64 %590, i64 %595
%597 = load float, float* %596
%598 = add nuw nsw i64 %595, 1
%599 = add nuw nsw i64 %595, 2
%600 = add nuw nsw i64 %595, 3
%601 = add nuw nsw i64 %595, 4
br label %605
602: ; preds = %608
%603 = add nuw nsw i64 %590, 1
%604 = icmp eq i64 %603, 32
br i1 %604, label %591, label %589
605: ; preds = %594, %641
%606 = phi float [ %597, %594 ], [ %638, %641 ]
%607 = phi i64 [ 0, %594 ], [ %642, %641 ]
br label %610
608: ; preds = %641
%609 = icmp eq i64 %598, 32
br i1 %609, label %602, label %594
610: ; preds = %605, %610
%611 = phi float [ %606, %605 ], [ %638, %610 ]
%612 = phi i64 [ 0, %605 ], [ %639, %610 ]
%613 = add nuw nsw i64 %612, %590
%614 = getelementptr inbounds [16 x [5 x [5 x float]]], [16 x [5 x [5 x float]]]* %1, i64 %585, i64 %607, i64 %612, i64 0
%615 = load float, float* %614
%616 = getelementptr inbounds [16 x [36 x [36 x float]]], [16 x [36 x [36 x float]]]* %0, i64 %582, i64 %607, i64 %613, i64 %595
%617 = load float, float* %616
%618 = tail call float @llvm.fmuladd.f32(float %615, float %617, float %611)
store float %618, float* %596
%619 = getelementptr inbounds [16 x [5 x [5 x float]]], [16 x [5 x [5 x float]]]* %1, i64 %585, i64 %607, i64 %612, i64 1
%620 = load float, float* %619
%621 = getelementptr inbounds [16 x [36 x [36 x float]]], [16 x [36 x [36 x float]]]* %0, i64 %582, i64 %607, i64 %613, i64 %598
%622 = load float, float* %621
%623 = tail call float @llvm.fmuladd.f32(float %620, float %622, float %618)
store float %623, float* %596
%624 = getelementptr inbounds [16 x [5 x [5 x float]]], [16 x [5 x [5 x float]]]* %1, i64 %585, i64 %607, i64 %612, i64 2
%625 = load float, float* %624
%626 = getelementptr inbounds [16 x [36 x [36 x float]]], [16 x [36 x [36 x float]]]* %0, i64 %582, i64 %607, i64 %613, i64 %599
%627 = load float, float* %626
%628 = tail call float @llvm.fmuladd.f32(float %625, float %627, float %623)
store float %628, float* %596
%629 = getelementptr inbounds [16 x [5 x [5 x float]]], [16 x [5 x [5 x float]]]* %1, i64 %585, i64 %607, i64 %612, i64 3
%630 = load float, float* %629
%631 = getelementptr inbounds [16 x [36 x [36 x float]]], [16 x [36 x [36 x float]]]* %0, i64 %582, i64 %607, i64 %613, i64 %600
%632 = load float, float* %631
%633 = tail call float @llvm.fmuladd.f32(float %630, float %632, float %628)
store float %633, float* %596
%634 = getelementptr inbounds [16 x [5 x [5 x float]]], [16 x [5 x [5 x float]]]* %1, i64 %585, i64 %607, i64 %612, i64 4
%635 = load float, float* %634
%636 = getelementptr inbounds [16 x [36 x [36 x float]]], [16 x [36 x [36 x float]]]* %0, i64 %582, i64 %607, i64 %613, i64 %601
%637 = load float, float* %636
%638 = tail call float @llvm.fmuladd.f32(float %635, float %637, float %633)
store float %638, float* %596
%639 = add nuw nsw i64 %612, 1
%640 = icmp eq i64 %639, 5
br i1 %640, label %641, label %610
641: ; preds = %610
%642 = add nuw nsw i64 %607, 1
%643 = icmp eq i64 %642, 16
br i1 %643, label %608, label %605
}