#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
float Max(float, float);
void pencil_vgg(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], float rRelu[8][16][32][32],
                float rrconv[8][16][32 - 4][32 - 4],
                float rrRelu[8][16][32 - 4][32 - 4],
                float rPool[8][16][32 - 2 * 4][32 - 2 * 4]) {
#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];
              }
            }
          }
        }
      }
    }
  }
  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++) {
          rRelu[n][f][y][x] = Max(rconv[n][f][y][x], 0);
        }
      }
    }
  }
  for (int n = 0; n < 8; n++) {
    for (int f = 0; f < 16; f++) {
      for (int y = 0; y < 32 - 4; y++) {
        for (int x = 0; x < 32 - 4; x++) {
          rrconv[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 - 4; y++) {
        for (int x = 0; x < 32 - 4; x++) {
          for (int fz = 0; fz < 16; fz++) {
            for (int fy = 0; fy < 4 + 1; fy++) {
              for (int fx = 0; fx < 4 + 1; fx++) {
                rrconv[n][f][y][x] +=
                    filters[f][fz][fy][fx] * rRelu[n][fz][y + fy][x + fx];
              }
            }
          }
        }
      }
    }
  }
  for (int n = 0; n < 8; n++) {
    for (int f = 0; f < 16; f++) {
      for (int y = 0; y < 32 - 4; y++) {
        for (int x = 0; x < 32 - 4; x++) {
          rrRelu[n][f][y][x] = Max(rrconv[n][f][y][x], 0);
        }
      }
    }
  }
  for (int n = 0; n < 8; n++) {
    for (int f = 0; f < 16; f++) {
      for (int y = 0; y < 32 - 2 * 4; y++) {
        for (int x = 0; x < 32 - 2 * 4; x++) {
          rPool[n][f][y][x] = 0;
          for (int fy = 0; fy < 4 + 1; fy++) {
            for (int fx = 0; fx < 4 + 1; fx++) {
              rPool[n][f][y][x] =
                  Max(rrRelu[n][f][fy + y][fx + x], rPool[n][f][y][x]);
            }
          }
        }
      }
    }
  }
#pragma endscop
}


x86 assembly (clang, -O0):
<pencil_vgg>:
push   %rbp
mov    %rsp,%rbp
sub    $0xc0,%rsp
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
cmpl   $0x8,-0x34(%rbp)
jge    1201 <pencil_vgg+0xf1>
movl   $0x0,-0x38(%rbp)
cmpl   $0x10,-0x38(%rbp)
jge    11ee <pencil_vgg+0xde>
movl   $0x0,-0x3c(%rbp)
cmpl   $0x20,-0x3c(%rbp)
jge    11db <pencil_vgg+0xcb>
movl   $0x0,-0x40(%rbp)
cmpl   $0x20,-0x40(%rbp)
jge    11c8 <pencil_vgg+0xb8>
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
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  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1175 <pencil_vgg+0x65>
jmp    11cd <pencil_vgg+0xbd>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1164 <pencil_vgg+0x54>
jmp    11e0 <pencil_vgg+0xd0>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1153 <pencil_vgg+0x43>
jmp    11f3 <pencil_vgg+0xe3>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1142 <pencil_vgg+0x32>
movl   $0x0,-0x44(%rbp)
cmpl   $0x8,-0x44(%rbp)
jge    13a5 <pencil_vgg+0x295>
movl   $0x0,-0x48(%rbp)
cmpl   $0x10,-0x48(%rbp)
jge    1392 <pencil_vgg+0x282>
movl   $0x0,-0x4c(%rbp)
cmpl   $0x20,-0x4c(%rbp)
jge    137f <pencil_vgg+0x26f>
movl   $0x0,-0x50(%rbp)
cmpl   $0x20,-0x50(%rbp)
jge    136c <pencil_vgg+0x25c>
movl   $0x0,-0x54(%rbp)
cmpl   $0x10,-0x54(%rbp)
jge    1359 <pencil_vgg+0x249>
movl   $0x0,-0x58(%rbp)
cmpl   $0x5,-0x58(%rbp)
jge    1346 <pencil_vgg+0x236>
movl   $0x0,-0x5c(%rbp)
cmpl   $0x5,-0x5c(%rbp)
jge    1333 <pencil_vgg+0x223>
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
imul   $0x640,%rcx,%rcx
add    %rcx,%rax
movslq -0x54(%rbp),%rcx
imul   $0x64,%rcx,%rcx
add    %rcx,%rax
movslq -0x58(%rbp),%rcx
imul   $0x14,%rcx,%rcx
add    %rcx,%rax
movslq -0x5c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x44(%rbp),%rcx
imul   $0x14400,%rcx,%rcx
add    %rcx,%rax
movslq -0x54(%rbp),%rcx
imul   $0x1440,%rcx,%rcx
add    %rcx,%rax
mov    -0x4c(%rbp),%ecx
add    -0x58(%rbp),%ecx
movslq %ecx,%rcx
imul   $0x90,%rcx,%rcx
add    %rcx,%rax
mov    -0x50(%rbp),%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
shl    $0x10,%rcx
add    %rcx,%rax
movslq -0x48(%rbp),%rcx
shl    $0xc,%rcx
add    %rcx,%rax
movslq -0x4c(%rbp),%rcx
shl    $0x7,%rcx
add    %rcx,%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    126e <pencil_vgg+0x15e>
jmp    1338 <pencil_vgg+0x228>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    125d <pencil_vgg+0x14d>
jmp    134b <pencil_vgg+0x23b>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    124c <pencil_vgg+0x13c>
jmp    135e <pencil_vgg+0x24e>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    123b <pencil_vgg+0x12b>
jmp    1371 <pencil_vgg+0x261>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    122a <pencil_vgg+0x11a>
jmp    1384 <pencil_vgg+0x274>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1219 <pencil_vgg+0x109>
jmp    1397 <pencil_vgg+0x287>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1208 <pencil_vgg+0xf8>
movl   $0x0,-0x60(%rbp)
cmpl   $0x8,-0x60(%rbp)
jge    1494 <pencil_vgg+0x384>
movl   $0x0,-0x64(%rbp)
cmpl   $0x10,-0x64(%rbp)
jge    1481 <pencil_vgg+0x371>
movl   $0x0,-0x68(%rbp)
cmpl   $0x20,-0x68(%rbp)
jge    146e <pencil_vgg+0x35e>
movl   $0x0,-0x6c(%rbp)
cmpl   $0x20,-0x6c(%rbp)
jge    145b <pencil_vgg+0x34b>
mov    -0x18(%rbp),%rax
movslq -0x60(%rbp),%rcx
shl    $0x10,%rcx
add    %rcx,%rax
movslq -0x64(%rbp),%rcx
shl    $0xc,%rcx
add    %rcx,%rax
movslq -0x68(%rbp),%rcx
shl    $0x7,%rcx
add    %rcx,%rax
movslq -0x6c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
xorps  %xmm1,%xmm1
call   1030 <Max@plt>
mov    -0x28(%rbp),%rax
movslq -0x60(%rbp),%rcx
shl    $0x10,%rcx
add    %rcx,%rax
movslq -0x64(%rbp),%rcx
shl    $0xc,%rcx
add    %rcx,%rax
movslq -0x68(%rbp),%rcx
shl    $0x7,%rcx
add    %rcx,%rax
movslq -0x6c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    13df <pencil_vgg+0x2cf>
jmp    1460 <pencil_vgg+0x350>
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    13ce <pencil_vgg+0x2be>
jmp    1473 <pencil_vgg+0x363>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    13bd <pencil_vgg+0x2ad>
jmp    1486 <pencil_vgg+0x376>
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    13ac <pencil_vgg+0x29c>
movl   $0x0,-0x70(%rbp)
cmpl   $0x8,-0x70(%rbp)
jge    1560 <pencil_vgg+0x450>
movl   $0x0,-0x74(%rbp)
cmpl   $0x10,-0x74(%rbp)
jge    154d <pencil_vgg+0x43d>
movl   $0x0,-0x78(%rbp)
cmpl   $0x1c,-0x78(%rbp)
jge    153a <pencil_vgg+0x42a>
movl   $0x0,-0x7c(%rbp)
cmpl   $0x1c,-0x7c(%rbp)
jge    1527 <pencil_vgg+0x417>
mov    -0x20(%rbp),%rax
movslq -0x74(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x70(%rbp),%rcx
imul   $0xc400,%rcx,%rcx
add    %rcx,%rax
movslq -0x74(%rbp),%rcx
imul   $0xc40,%rcx,%rcx
add    %rcx,%rax
movslq -0x78(%rbp),%rcx
imul   $0x70,%rcx,%rcx
add    %rcx,%rax
movslq -0x7c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    14ce <pencil_vgg+0x3be>
jmp    152c <pencil_vgg+0x41c>
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    14bd <pencil_vgg+0x3ad>
jmp    153f <pencil_vgg+0x42f>
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    14ac <pencil_vgg+0x39c>
jmp    1552 <pencil_vgg+0x442>
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    149b <pencil_vgg+0x38b>
movl   $0x0,-0x80(%rbp)
cmpl   $0x8,-0x80(%rbp)
jge    176d <pencil_vgg+0x65d>
movl   $0x0,-0x84(%rbp)
cmpl   $0x10,-0x84(%rbp)
jge    175a <pencil_vgg+0x64a>
movl   $0x0,-0x88(%rbp)
cmpl   $0x1c,-0x88(%rbp)
jge    1741 <pencil_vgg+0x631>
movl   $0x0,-0x8c(%rbp)
cmpl   $0x1c,-0x8c(%rbp)
jge    1728 <pencil_vgg+0x618>
movl   $0x0,-0x90(%rbp)
cmpl   $0x10,-0x90(%rbp)
jge    170f <pencil_vgg+0x5ff>
movl   $0x0,-0x94(%rbp)
cmpl   $0x5,-0x94(%rbp)
jge    16f6 <pencil_vgg+0x5e6>
movl   $0x0,-0x98(%rbp)
cmpl   $0x5,-0x98(%rbp)
jge    16dd <pencil_vgg+0x5cd>
mov    -0x10(%rbp),%rax
movslq -0x84(%rbp),%rcx
imul   $0x640,%rcx,%rcx
add    %rcx,%rax
movslq -0x90(%rbp),%rcx
imul   $0x64,%rcx,%rcx
add    %rcx,%rax
movslq -0x94(%rbp),%rcx
imul   $0x14,%rcx,%rcx
add    %rcx,%rax
movslq -0x98(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x28(%rbp),%rax
movslq -0x80(%rbp),%rcx
shl    $0x10,%rcx
add    %rcx,%rax
movslq -0x90(%rbp),%rcx
shl    $0xc,%rcx
add    %rcx,%rax
mov    -0x88(%rbp),%ecx
add    -0x94(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x7,%rcx
add    %rcx,%rax
mov    -0x8c(%rbp),%ecx
add    -0x98(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x30(%rbp),%rax
movslq -0x80(%rbp),%rcx
imul   $0xc400,%rcx,%rcx
add    %rcx,%rax
movslq -0x84(%rbp),%rcx
imul   $0xc40,%rcx,%rcx
add    %rcx,%rax
movslq -0x88(%rbp),%rcx
imul   $0x70,%rcx,%rcx
add    %rcx,%rax
movslq -0x8c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x98(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x98(%rbp)
jmp    15ee <pencil_vgg+0x4de>
jmp    16e2 <pencil_vgg+0x5d2>
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    15d7 <pencil_vgg+0x4c7>
jmp    16fb <pencil_vgg+0x5eb>
mov    -0x90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x90(%rbp)
jmp    15c0 <pencil_vgg+0x4b0>
jmp    1714 <pencil_vgg+0x604>
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    15a9 <pencil_vgg+0x499>
jmp    172d <pencil_vgg+0x61d>
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    1592 <pencil_vgg+0x482>
jmp    1746 <pencil_vgg+0x636>
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    157b <pencil_vgg+0x46b>
jmp    175f <pencil_vgg+0x64f>
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
jmp    1567 <pencil_vgg+0x457>
movl   $0x0,-0x9c(%rbp)
cmpl   $0x8,-0x9c(%rbp)
jge    18b0 <pencil_vgg+0x7a0>
movl   $0x0,-0xa0(%rbp)
cmpl   $0x10,-0xa0(%rbp)
jge    1897 <pencil_vgg+0x787>
movl   $0x0,-0xa4(%rbp)
cmpl   $0x1c,-0xa4(%rbp)
jge    187e <pencil_vgg+0x76e>
movl   $0x0,-0xa8(%rbp)
cmpl   $0x1c,-0xa8(%rbp)
jge    1865 <pencil_vgg+0x755>
mov    -0x30(%rbp),%rax
movslq -0x9c(%rbp),%rcx
imul   $0xc400,%rcx,%rcx
add    %rcx,%rax
movslq -0xa0(%rbp),%rcx
imul   $0xc40,%rcx,%rcx
add    %rcx,%rax
movslq -0xa4(%rbp),%rcx
imul   $0x70,%rcx,%rcx
add    %rcx,%rax
movslq -0xa8(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
xorps  %xmm1,%xmm1
call   1030 <Max@plt>
mov    0x10(%rbp),%rax
movslq -0x9c(%rbp),%rcx
imul   $0xc400,%rcx,%rcx
add    %rcx,%rax
movslq -0xa0(%rbp),%rcx
imul   $0xc40,%rcx,%rcx
add    %rcx,%rax
movslq -0xa4(%rbp),%rcx
imul   $0x70,%rcx,%rcx
add    %rcx,%rax
movslq -0xa8(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0xa8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa8(%rbp)
jmp    17bc <pencil_vgg+0x6ac>
jmp    186a <pencil_vgg+0x75a>
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
jmp    17a5 <pencil_vgg+0x695>
jmp    1883 <pencil_vgg+0x773>
mov    -0xa0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa0(%rbp)
jmp    178e <pencil_vgg+0x67e>
jmp    189c <pencil_vgg+0x78c>
mov    -0x9c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x9c(%rbp)
jmp    1777 <pencil_vgg+0x667>
movl   $0x0,-0xac(%rbp)
cmpl   $0x8,-0xac(%rbp)
jge    1ae3 <pencil_vgg+0x9d3>
movl   $0x0,-0xb0(%rbp)
cmpl   $0x10,-0xb0(%rbp)
jge    1aca <pencil_vgg+0x9ba>
movl   $0x0,-0xb4(%rbp)
cmpl   $0x18,-0xb4(%rbp)
jge    1ab1 <pencil_vgg+0x9a1>
movl   $0x0,-0xb8(%rbp)
cmpl   $0x18,-0xb8(%rbp)
jge    1a98 <pencil_vgg+0x988>
mov    0x18(%rbp),%rax
movslq -0xac(%rbp),%rcx
imul   $0x9000,%rcx,%rcx
add    %rcx,%rax
movslq -0xb0(%rbp),%rcx
imul   $0x900,%rcx,%rcx
add    %rcx,%rax
movslq -0xb4(%rbp),%rcx
imul   $0x60,%rcx,%rcx
add    %rcx,%rax
movslq -0xb8(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movl   $0x0,-0xbc(%rbp)
cmpl   $0x5,-0xbc(%rbp)
jge    1a7f <pencil_vgg+0x96f>
movl   $0x0,-0xc0(%rbp)
cmpl   $0x5,-0xc0(%rbp)
jge    1a66 <pencil_vgg+0x956>
mov    0x10(%rbp),%rax
movslq -0xac(%rbp),%rcx
imul   $0xc400,%rcx,%rcx
add    %rcx,%rax
movslq -0xb0(%rbp),%rcx
imul   $0xc40,%rcx,%rcx
add    %rcx,%rax
mov    -0xbc(%rbp),%ecx
add    -0xb4(%rbp),%ecx
movslq %ecx,%rcx
imul   $0x70,%rcx,%rcx
add    %rcx,%rax
mov    -0xc0(%rbp),%ecx
add    -0xb8(%rbp),%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x18(%rbp),%rax
movslq -0xac(%rbp),%rcx
imul   $0x9000,%rcx,%rcx
add    %rcx,%rax
movslq -0xb0(%rbp),%rcx
imul   $0x900,%rcx,%rcx
add    %rcx,%rax
movslq -0xb4(%rbp),%rcx
imul   $0x60,%rcx,%rcx
add    %rcx,%rax
movslq -0xb8(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
call   1030 <Max@plt>
mov    0x18(%rbp),%rax
movslq -0xac(%rbp),%rcx
imul   $0x9000,%rcx,%rcx
add    %rcx,%rax
movslq -0xb0(%rbp),%rcx
imul   $0x900,%rcx,%rcx
add    %rcx,%rax
movslq -0xb4(%rbp),%rcx
imul   $0x60,%rcx,%rcx
add    %rcx,%rax
movslq -0xb8(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0xc0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc0(%rbp)
jmp    1970 <pencil_vgg+0x860>
jmp    1a6b <pencil_vgg+0x95b>
mov    -0xbc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xbc(%rbp)
jmp    1959 <pencil_vgg+0x849>
jmp    1a84 <pencil_vgg+0x974>
mov    -0xb8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb8(%rbp)
jmp    18ff <pencil_vgg+0x7ef>
jmp    1a9d <pencil_vgg+0x98d>
mov    -0xb4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
jmp    18e8 <pencil_vgg+0x7d8>
jmp    1ab6 <pencil_vgg+0x9a6>
mov    -0xb0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb0(%rbp)
jmp    18d1 <pencil_vgg+0x7c1>
jmp    1acf <pencil_vgg+0x9bf>
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    18ba <pencil_vgg+0x7aa>
add    $0xc0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<pencil_vgg>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %r9,%r13
mov    %rdx,%r14
mov    %rsi,0x10(%rsp)
mov    %rdi,0x8(%rsp)
lea    0xc(%rdx),%r10
xor    %esi,%esi
jmp    1155 <pencil_vgg+0x45>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rsi
add    $0x1000,%r10
cmp    $0x10,%rsi
je     1237 <pencil_vgg+0x127>
lea    (%rcx,%rsi,4),%r9
lea    (%rcx,%rsi,4),%r11
add    $0x4,%r11
mov    %r10,%rax
xor    %ebp,%ebp
jmp    11cd <pencil_vgg+0xbd>
nopl   0x0(%rax,%rax,1)
movss  (%rcx,%rsi,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movups %xmm0,(%rbx,%rdi,1)
movups %xmm0,0x10(%rbx,%rdi,1)
movss  (%rcx,%rsi,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movups %xmm0,0x20(%rbx,%rdi,1)
movups %xmm0,0x30(%rbx,%rdi,1)
movss  (%rcx,%rsi,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movups %xmm0,0x40(%rbx,%rdi,1)
movups %xmm0,0x50(%rbx,%rdi,1)
movss  (%rcx,%rsi,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movups %xmm0,0x60(%rbx,%rdi,1)
movups %xmm0,0x70(%rbx,%rdi,1)
add    $0x1,%rbp
sub    $0xffffffffffffff80,%rax
cmp    $0x20,%rbp
je     1140 <pencil_vgg+0x30>
mov    %rsi,%rdi
shl    $0xc,%rdi
add    %r14,%rdi
mov    %rbp,%rbx
shl    $0x7,%rbx
lea    (%rdi,%rbx,1),%rdx
cmp    %r11,%rdx
jae    1170 <pencil_vgg+0x60>
lea    (%rbx,%rdi,1),%rdx
add    $0x80,%rdx
cmp    %rdx,%r9
jae    1170 <pencil_vgg+0x60>
xor    %edi,%edi
nopl   (%rax)
movss  (%rcx,%rsi,4),%xmm0
movss  %xmm0,-0xc(%rax,%rdi,4)
movss  (%rcx,%rsi,4),%xmm0
movss  %xmm0,-0x8(%rax,%rdi,4)
movss  (%rcx,%rsi,4),%xmm0
movss  %xmm0,-0x4(%rax,%rdi,4)
movss  (%rcx,%rsi,4),%xmm0
movss  %xmm0,(%rax,%rdi,4)
add    $0x4,%rdi
cmp    $0x20,%rdi
jne    1200 <pencil_vgg+0xf0>
jmp    11bb <pencil_vgg+0xab>
lea    0x1000c(%r14),%r10
xor    %esi,%esi
jmp    1265 <pencil_vgg+0x155>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rsi
add    $0x1000,%r10
cmp    $0x10,%rsi
je     137a <pencil_vgg+0x26a>
lea    (%rcx,%rsi,4),%r9
lea    (%rcx,%rsi,4),%r11
add    $0x4,%r11
mov    %r10,%rax
xor    %ebp,%ebp
jmp    12f6 <pencil_vgg+0x1e6>
nopl   0x0(%rax,%rax,1)
movss  (%rcx,%rsi,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movups %xmm0,0x10000(%rbx,%rdi,1)
movups %xmm0,0x10010(%rbx,%rdi,1)
movss  (%rcx,%rsi,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movups %xmm0,0x10020(%rbx,%rdi,1)
movups %xmm0,0x10030(%rbx,%rdi,1)
movss  (%rcx,%rsi,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movups %xmm0,0x10040(%rbx,%rdi,1)
movups %xmm0,0x10050(%rbx,%rdi,1)
movss  (%rcx,%rsi,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movups %xmm0,0x10060(%rbx,%rdi,1)
movups %xmm0,0x10070(%rbx,%rdi,1)
add    $0x1,%rbp
sub    $0xffffffffffffff80,%rax
cmp    $0x20,%rbp
je     1250 <pencil_vgg+0x140>
mov    %rsi,%rdi
shl    $0xc,%rdi
add    %r14,%rdi
mov    %rbp,%rbx
shl    $0x7,%rbx
lea    (%rbx,%rdi,1),%rdx
add    $0x10000,%rdx
cmp    %r11,%rdx
jae    1280 <pencil_vgg+0x170>
lea    (%rbx,%rdi,1),%rdx
add    $0x10080,%rdx
cmp    %rdx,%r9
jae    1280 <pencil_vgg+0x170>
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  (%rcx,%rsi,4),%xmm0
movss  %xmm0,-0xc(%rax,%rdi,4)
movss  (%rcx,%rsi,4),%xmm0
movss  %xmm0,-0x8(%rax,%rdi,4)
movss  (%rcx,%rsi,4),%xmm0
movss  %xmm0,-0x4(%rax,%rdi,4)
movss  (%rcx,%rsi,4),%xmm0
movss  %xmm0,(%rax,%rdi,4)
add    $0x4,%rdi
cmp    $0x20,%rdi
jne    1340 <pencil_vgg+0x230>
jmp    12e4 <pencil_vgg+0x1d4>
lea    0x2000c(%r14),%r10
xor    %esi,%esi
jmp    13a5 <pencil_vgg+0x295>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rsi
add    $0x1000,%r10
cmp    $0x10,%rsi
je     14ba <pencil_vgg+0x3aa>
lea    (%rcx,%rsi,4),%r9
lea    (%rcx,%rsi,4),%r11
add    $0x4,%r11
mov    %r10,%rax
xor    %ebp,%ebp
jmp    1436 <pencil_vgg+0x326>
nopl   0x0(%rax,%rax,1)
movss  (%rcx,%rsi,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movups %xmm0,0x20000(%rbx,%rdi,1)
movups %xmm0,0x20010(%rbx,%rdi,1)
movss  (%rcx,%rsi,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movups %xmm0,0x20020(%rbx,%rdi,1)
movups %xmm0,0x20030(%rbx,%rdi,1)
movss  (%rcx,%rsi,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movups %xmm0,0x20040(%rbx,%rdi,1)
movups %xmm0,0x20050(%rbx,%rdi,1)
movss  (%rcx,%rsi,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movups %xmm0,0x20060(%rbx,%rdi,1)
movups %xmm0,0x20070(%rbx,%rdi,1)
add    $0x1,%rbp
sub    $0xffffffffffffff80,%rax
cmp    $0x20,%rbp
je     1390 <pencil_vgg+0x280>
mov    %rsi,%rdi
shl    $0xc,%rdi
add    %r14,%rdi
mov    %rbp,%rbx
shl    $0x7,%rbx
lea    (%rbx,%rdi,1),%rdx
add    $0x20000,%rdx
cmp    %r11,%rdx
jae    13c0 <pencil_vgg+0x2b0>
lea    (%rbx,%rdi,1),%rdx
add    $0x20080,%rdx
cmp    %rdx,%r9
jae    13c0 <pencil_vgg+0x2b0>
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  (%rcx,%rsi,4),%xmm0
movss  %xmm0,-0xc(%rax,%rdi,4)
movss  (%rcx,%rsi,4),%xmm0
movss  %xmm0,-0x8(%rax,%rdi,4)
movss  (%rcx,%rsi,4),%xmm0
movss  %xmm0,-0x4(%rax,%rdi,4)
movss  (%rcx,%rsi,4),%xmm0
movss  %xmm0,(%rax,%rdi,4)
add    $0x4,%rdi
cmp    $0x20,%rdi
jne    1480 <pencil_vgg+0x370>
jmp    1424 <pencil_vgg+0x314>
lea    0x3000c(%r14),%r10
xor    %esi,%esi
jmp    14e5 <pencil_vgg+0x3d5>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rsi
add    $0x1000,%r10
cmp    $0x10,%rsi
je     15fa <pencil_vgg+0x4ea>
lea    (%rcx,%rsi,4),%r9
lea    (%rcx,%rsi,4),%r11
add    $0x4,%r11
mov    %r10,%rax
xor    %ebp,%ebp
jmp    1576 <pencil_vgg+0x466>
nopl   0x0(%rax,%rax,1)
movss  (%rcx,%rsi,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movups %xmm0,0x30000(%rbx,%rdi,1)
movups %xmm0,0x30010(%rbx,%rdi,1)
movss  (%rcx,%rsi,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movups %xmm0,0x30020(%rbx,%rdi,1)
movups %xmm0,0x30030(%rbx,%rdi,1)
movss  (%rcx,%rsi,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movups %xmm0,0x30040(%rbx,%rdi,1)
movups %xmm0,0x30050(%rbx,%rdi,1)
movss  (%rcx,%rsi,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movups %xmm0,0x30060(%rbx,%rdi,1)
movups %xmm0,0x30070(%rbx,%rdi,1)
add    $0x1,%rbp
sub    $0xffffffffffffff80,%rax
cmp    $0x20,%rbp
je     14d0 <pencil_vgg+0x3c0>
mov    %rsi,%rdi
shl    $0xc,%rdi
add    %r14,%rdi
mov    %rbp,%rbx
shl    $0x7,%rbx
lea    (%rbx,%rdi,1),%rdx
add    $0x30000,%rdx
cmp    %r11,%rdx
jae    1500 <pencil_vgg+0x3f0>
lea    (%rbx,%rdi,1),%rdx
add    $0x30080,%rdx
cmp    %rdx,%r9
jae    1500 <pencil_vgg+0x3f0>
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  (%rcx,%rsi,4),%xmm0
movss  %xmm0,-0xc(%rax,%rdi,4)
movss  (%rcx,%rsi,4),%xmm0
movss  %xmm0,-0x8(%rax,%rdi,4)
movss  (%rcx,%rsi,4),%xmm0
movss  %xmm0,-0x4(%rax,%rdi,4)
movss  (%rcx,%rsi,4),%xmm0
movss  %xmm0,(%rax,%rdi,4)
add    $0x4,%rdi
cmp    $0x20,%rdi
jne    15c0 <pencil_vgg+0x4b0>
jmp    1564 <pencil_vgg+0x454>
lea    0x4000c(%r14),%r10
xor    %esi,%esi
jmp    1625 <pencil_vgg+0x515>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rsi
add    $0x1000,%r10
cmp    $0x10,%rsi
je     173a <pencil_vgg+0x62a>
lea    (%rcx,%rsi,4),%r9
lea    (%rcx,%rsi,4),%r11
add    $0x4,%r11
mov    %r10,%rax
xor    %ebp,%ebp
jmp    16b6 <pencil_vgg+0x5a6>
nopl   0x0(%rax,%rax,1)
movss  (%rcx,%rsi,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movups %xmm0,0x40000(%rbx,%rdi,1)
movups %xmm0,0x40010(%rbx,%rdi,1)
movss  (%rcx,%rsi,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movups %xmm0,0x40020(%rbx,%rdi,1)
movups %xmm0,0x40030(%rbx,%rdi,1)
movss  (%rcx,%rsi,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movups %xmm0,0x40040(%rbx,%rdi,1)
movups %xmm0,0x40050(%rbx,%rdi,1)
movss  (%rcx,%rsi,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movups %xmm0,0x40060(%rbx,%rdi,1)
movups %xmm0,0x40070(%rbx,%rdi,1)
add    $0x1,%rbp
sub    $0xffffffffffffff80,%rax
cmp    $0x20,%rbp
je     1610 <pencil_vgg+0x500>
mov    %rsi,%rdi
shl    $0xc,%rdi
add    %r14,%rdi
mov    %rbp,%rbx
shl    $0x7,%rbx
lea    (%rbx,%rdi,1),%rdx
add    $0x40000,%rdx
cmp    %r11,%rdx
jae    1640 <pencil_vgg+0x530>
lea    (%rbx,%rdi,1),%rdx
add    $0x40080,%rdx
cmp    %rdx,%r9
jae    1640 <pencil_vgg+0x530>
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  (%rcx,%rsi,4),%xmm0
movss  %xmm0,-0xc(%rax,%rdi,4)
movss  (%rcx,%rsi,4),%xmm0
movss  %xmm0,-0x8(%rax,%rdi,4)
movss  (%rcx,%rsi,4),%xmm0
movss  %xmm0,-0x4(%rax,%rdi,4)
movss  (%rcx,%rsi,4),%xmm0
movss  %xmm0,(%rax,%rdi,4)
add    $0x4,%rdi
cmp    $0x20,%rdi
jne    1700 <pencil_vgg+0x5f0>
jmp    16a4 <pencil_vgg+0x594>
lea    0x5000c(%r14),%r10
xor    %esi,%esi
jmp    1765 <pencil_vgg+0x655>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rsi
add    $0x1000,%r10
cmp    $0x10,%rsi
je     187a <pencil_vgg+0x76a>
lea    (%rcx,%rsi,4),%r9
lea    (%rcx,%rsi,4),%r11
add    $0x4,%r11
mov    %r10,%rax
xor    %ebp,%ebp
jmp    17f6 <pencil_vgg+0x6e6>
nopl   0x0(%rax,%rax,1)
movss  (%rcx,%rsi,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movups %xmm0,0x50000(%rbx,%rdi,1)
movups %xmm0,0x50010(%rbx,%rdi,1)
movss  (%rcx,%rsi,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movups %xmm0,0x50020(%rbx,%rdi,1)
movups %xmm0,0x50030(%rbx,%rdi,1)
movss  (%rcx,%rsi,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movups %xmm0,0x50040(%rbx,%rdi,1)
movups %xmm0,0x50050(%rbx,%rdi,1)
movss  (%rcx,%rsi,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movups %xmm0,0x50060(%rbx,%rdi,1)
movups %xmm0,0x50070(%rbx,%rdi,1)
add    $0x1,%rbp
sub    $0xffffffffffffff80,%rax
cmp    $0x20,%rbp
je     1750 <pencil_vgg+0x640>
mov    %rsi,%rdi
shl    $0xc,%rdi
add    %r14,%rdi
mov    %rbp,%rbx
shl    $0x7,%rbx
lea    (%rbx,%rdi,1),%rdx
add    $0x50000,%rdx
cmp    %r11,%rdx
jae    1780 <pencil_vgg+0x670>
lea    (%rbx,%rdi,1),%rdx
add    $0x50080,%rdx
cmp    %rdx,%r9
jae    1780 <pencil_vgg+0x670>
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  (%rcx,%rsi,4),%xmm0
movss  %xmm0,-0xc(%rax,%rdi,4)
movss  (%rcx,%rsi,4),%xmm0
movss  %xmm0,-0x8(%rax,%rdi,4)
movss  (%rcx,%rsi,4),%xmm0
movss  %xmm0,-0x4(%rax,%rdi,4)
movss  (%rcx,%rsi,4),%xmm0
movss  %xmm0,(%rax,%rdi,4)
add    $0x4,%rdi
cmp    $0x20,%rdi
jne    1840 <pencil_vgg+0x730>
jmp    17e4 <pencil_vgg+0x6d4>
lea    0x6000c(%r14),%r10
xor    %esi,%esi
jmp    18a5 <pencil_vgg+0x795>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rsi
add    $0x1000,%r10
cmp    $0x10,%rsi
je     19ba <pencil_vgg+0x8aa>
lea    (%rcx,%rsi,4),%r9
lea    (%rcx,%rsi,4),%r11
add    $0x4,%r11
mov    %r10,%rax
xor    %ebp,%ebp
jmp    1936 <pencil_vgg+0x826>
nopl   0x0(%rax,%rax,1)
movss  (%rcx,%rsi,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movups %xmm0,0x60000(%rbx,%rdi,1)
movups %xmm0,0x60010(%rbx,%rdi,1)
movss  (%rcx,%rsi,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movups %xmm0,0x60020(%rbx,%rdi,1)
movups %xmm0,0x60030(%rbx,%rdi,1)
movss  (%rcx,%rsi,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movups %xmm0,0x60040(%rbx,%rdi,1)
movups %xmm0,0x60050(%rbx,%rdi,1)
movss  (%rcx,%rsi,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movups %xmm0,0x60060(%rbx,%rdi,1)
movups %xmm0,0x60070(%rbx,%rdi,1)
add    $0x1,%rbp
sub    $0xffffffffffffff80,%rax
cmp    $0x20,%rbp
je     1890 <pencil_vgg+0x780>
mov    %rsi,%rdi
shl    $0xc,%rdi
add    %r14,%rdi
mov    %rbp,%rbx
shl    $0x7,%rbx
lea    (%rbx,%rdi,1),%rdx
add    $0x60000,%rdx
cmp    %r11,%rdx
jae    18c0 <pencil_vgg+0x7b0>
lea    (%rbx,%rdi,1),%rdx
add    $0x60080,%rdx
cmp    %rdx,%r9
jae    18c0 <pencil_vgg+0x7b0>
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  (%rcx,%rsi,4),%xmm0
movss  %xmm0,-0xc(%rax,%rdi,4)
movss  (%rcx,%rsi,4),%xmm0
movss  %xmm0,-0x8(%rax,%rdi,4)
movss  (%rcx,%rsi,4),%xmm0
movss  %xmm0,-0x4(%rax,%rdi,4)
movss  (%rcx,%rsi,4),%xmm0
movss  %xmm0,(%rax,%rdi,4)
add    $0x4,%rdi
cmp    $0x20,%rdi
jne    1980 <pencil_vgg+0x870>
jmp    1924 <pencil_vgg+0x814>
lea    0x7000c(%r14),%r10
xor    %esi,%esi
jmp    19e5 <pencil_vgg+0x8d5>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%rsi
add    $0x1000,%r10
cmp    $0x10,%rsi
je     1afa <pencil_vgg+0x9ea>
lea    (%rcx,%rsi,4),%r9
lea    (%rcx,%rsi,4),%r11
add    $0x4,%r11
mov    %r10,%rax
xor    %ebp,%ebp
jmp    1a76 <pencil_vgg+0x966>
nopl   0x0(%rax,%rax,1)
movss  (%rcx,%rsi,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movups %xmm0,0x70000(%rbx,%rdi,1)
movups %xmm0,0x70010(%rbx,%rdi,1)
movss  (%rcx,%rsi,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movups %xmm0,0x70020(%rbx,%rdi,1)
movups %xmm0,0x70030(%rbx,%rdi,1)
movss  (%rcx,%rsi,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movups %xmm0,0x70040(%rbx,%rdi,1)
movups %xmm0,0x70050(%rbx,%rdi,1)
movss  (%rcx,%rsi,4),%xmm0
shufps $0x0,%xmm0,%xmm0
movups %xmm0,0x70060(%rbx,%rdi,1)
movups %xmm0,0x70070(%rbx,%rdi,1)
add    $0x1,%rbp
sub    $0xffffffffffffff80,%rax
cmp    $0x20,%rbp
je     19d0 <pencil_vgg+0x8c0>
mov    %rsi,%rdi
shl    $0xc,%rdi
add    %r14,%rdi
mov    %rbp,%rbx
shl    $0x7,%rbx
lea    (%rbx,%rdi,1),%rdx
add    $0x70000,%rdx
cmp    %r11,%rdx
jae    1a00 <pencil_vgg+0x8f0>
lea    (%rbx,%rdi,1),%rdx
add    $0x70080,%rdx
cmp    %rdx,%r9
jae    1a00 <pencil_vgg+0x8f0>
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  (%rcx,%rsi,4),%xmm0
movss  %xmm0,-0xc(%rax,%rdi,4)
movss  (%rcx,%rsi,4),%xmm0
movss  %xmm0,-0x8(%rax,%rdi,4)
movss  (%rcx,%rsi,4),%xmm0
movss  %xmm0,-0x4(%rax,%rdi,4)
movss  (%rcx,%rsi,4),%xmm0
movss  %xmm0,(%rax,%rdi,4)
add    $0x4,%rdi
cmp    $0x20,%rdi
jne    1ac0 <pencil_vgg+0x9b0>
jmp    1a64 <pencil_vgg+0x954>
mov    %rcx,0x30(%rsp)
mov    %r8,0x28(%rsp)
addq   $0x10,0x8(%rsp)
xor    %r9d,%r9d
nopl   (%rax)
mov    0x10(%rsp),%r10
xor    %r11d,%r11d
nopl   0x0(%rax,%rax,1)
mov    0x8(%rsp),%rdi
xor    %r15d,%r15d
nopl   0x0(%rax,%rax,1)
mov    %rdi,%r8
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r9,%rax
shl    $0x10,%rax
add    %r14,%rax
mov    %r11,%rcx
shl    $0xc,%rcx
add    %rax,%rcx
mov    %r15,%rdx
shl    $0x7,%rdx
add    %rcx,%rdx
lea    (%rdx,%rbx,4),%rax
movss  (%rdx,%rbx,4),%xmm0
add    $0x1,%rbx
mov    %r10,%rcx
mov    %r8,%rdx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    $0x10,%r12d
mov    %rdx,%rsi
nopl   0x0(%rax)
movss  -0x10(%rcx,%r12,1),%xmm1
mulss  -0x10(%rsi),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,(%rax)
movss  -0xc(%rcx,%r12,1),%xmm0
mulss  -0xc(%rsi),%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax)
movss  -0x8(%rcx,%r12,1),%xmm1
mulss  -0x8(%rsi),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,(%rax)
movss  -0x4(%rcx,%r12,1),%xmm2
mulss  -0x4(%rsi),%xmm2
addss  %xmm1,%xmm2
movss  %xmm2,(%rax)
movss  (%rcx,%r12,1),%xmm0
mulss  (%rsi),%xmm0
addss  %xmm2,%xmm0
movss  %xmm0,(%rax)
add    $0x90,%rsi
add    $0x14,%r12
cmp    $0x74,%r12
jne    1b90 <pencil_vgg+0xa80>
add    $0x1,%rbp
add    $0x1440,%rdx
add    $0x64,%rcx
cmp    $0x10,%rbp
jne    1b80 <pencil_vgg+0xa70>
add    $0x4,%r8
cmp    $0x20,%rbx
jne    1b40 <pencil_vgg+0xa30>
add    $0x1,%r15
add    $0x90,%rdi
cmp    $0x20,%r15
jne    1b30 <pencil_vgg+0xa20>
add    $0x1,%r11
add    $0x640,%r10
cmp    $0x10,%r11
jne    1b20 <pencil_vgg+0xa10>
add    $0x1,%r9
addq   $0x14400,0x8(%rsp)
cmp    $0x8,%r9
jne    1b10 <pencil_vgg+0xa00>
xor    %eax,%eax
mov    0x28(%rsp),%rcx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %rax,0x40(%rsp)
mov    %rcx,0x38(%rsp)
mov    %rcx,%rbp
mov    %r14,%r15
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %rax,0x18(%rsp)
mov    %rbp,0x8(%rsp)
mov    %r15,0x20(%rsp)
xor    %r12d,%r12d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  (%r15,%rbx,4),%xmm0
xorps  %xmm1,%xmm1
call   1030 <Max@plt>
movss  %xmm0,0x0(%rbp,%rbx,4)
add    $0x1,%rbx
cmp    $0x20,%rbx
jne    1cd0 <pencil_vgg+0xbc0>
add    $0x1,%r12
sub    $0xffffffffffffff80,%r15
sub    $0xffffffffffffff80,%rbp
cmp    $0x20,%r12
jne    1cc0 <pencil_vgg+0xbb0>
mov    0x18(%rsp),%rax
add    $0x1,%rax
mov    0x20(%rsp),%r15
add    $0x1000,%r15
mov    0x8(%rsp),%rbp
add    $0x1000,%rbp
cmp    $0x10,%rax
jne    1ca0 <pencil_vgg+0xb90>
mov    0x40(%rsp),%rax
add    $0x1,%rax
add    $0x10000,%r14
mov    0x38(%rsp),%rcx
add    $0x10000,%rcx
cmp    $0x8,%rax
jne    1c80 <pencil_vgg+0xb70>
xor    %eax,%eax
mov    %r13,%rcx
mov    0x28(%rsp),%r12
mov    0x30(%rsp),%rbx
mov    %rcx,%rdx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nop
lea    (%rbx,%rsi,4),%rdi
mov    $0x6c,%ebp
nopl   0x0(%rax)
movss  (%rdi),%xmm0
movss  %xmm0,-0x6c(%rdx,%rbp,1)
movss  (%rdi),%xmm0
movss  %xmm0,-0x68(%rdx,%rbp,1)
movss  (%rdi),%xmm0
movss  %xmm0,-0x64(%rdx,%rbp,1)
movss  (%rdi),%xmm0
movss  %xmm0,-0x60(%rdx,%rbp,1)
movss  (%rdi),%xmm0
movss  %xmm0,-0x5c(%rdx,%rbp,1)
movss  (%rdi),%xmm0
movss  %xmm0,-0x58(%rdx,%rbp,1)
movss  (%rdi),%xmm0
movss  %xmm0,-0x54(%rdx,%rbp,1)
movss  (%rdi),%xmm0
movss  %xmm0,-0x50(%rdx,%rbp,1)
movss  (%rdi),%xmm0
movss  %xmm0,-0x4c(%rdx,%rbp,1)
movss  (%rdi),%xmm0
movss  %xmm0,-0x48(%rdx,%rbp,1)
movss  (%rdi),%xmm0
movss  %xmm0,-0x44(%rdx,%rbp,1)
movss  (%rdi),%xmm0
movss  %xmm0,-0x40(%rdx,%rbp,1)
movss  (%rdi),%xmm0
movss  %xmm0,-0x3c(%rdx,%rbp,1)
movss  (%rdi),%xmm0
movss  %xmm0,-0x38(%rdx,%rbp,1)
movss  (%rdi),%xmm0
movss  %xmm0,-0x34(%rdx,%rbp,1)
movss  (%rdi),%xmm0
movss  %xmm0,-0x30(%rdx,%rbp,1)
movss  (%rdi),%xmm0
movss  %xmm0,-0x2c(%rdx,%rbp,1)
movss  (%rdi),%xmm0
movss  %xmm0,-0x28(%rdx,%rbp,1)
movss  (%rdi),%xmm0
movss  %xmm0,-0x24(%rdx,%rbp,1)
movss  (%rdi),%xmm0
movss  %xmm0,-0x20(%rdx,%rbp,1)
movss  (%rdi),%xmm0
movss  %xmm0,-0x1c(%rdx,%rbp,1)
movss  (%rdi),%xmm0
movss  %xmm0,-0x18(%rdx,%rbp,1)
movss  (%rdi),%xmm0
movss  %xmm0,-0x14(%rdx,%rbp,1)
movss  (%rdi),%xmm0
movss  %xmm0,-0x10(%rdx,%rbp,1)
movss  (%rdi),%xmm0
movss  %xmm0,-0xc(%rdx,%rbp,1)
movss  (%rdi),%xmm0
movss  %xmm0,-0x8(%rdx,%rbp,1)
movss  (%rdi),%xmm0
movss  %xmm0,-0x4(%rdx,%rbp,1)
movss  (%rdi),%xmm0
movss  %xmm0,(%rdx,%rbp,1)
add    $0x70,%rbp
cmp    $0xcac,%rbp
jne    1d80 <pencil_vgg+0xc70>
add    $0x1,%rsi
add    $0xc40,%rdx
cmp    $0x10,%rsi
jne    1d70 <pencil_vgg+0xc60>
add    $0x1,%rax
add    $0xc400,%rcx
cmp    $0x8,%rax
jne    1d60 <pencil_vgg+0xc50>
add    $0x10,%r12
xor    %r9d,%r9d
nopl   0x0(%rax)
mov    0x10(%rsp),%r11
xor    %r10d,%r10d
nopl   0x0(%rax,%rax,1)
mov    %r12,%r8
xor    %r14d,%r14d
cs nopw 0x0(%rax,%rax,1)
mov    %r8,%rbx
xor    %r15d,%r15d
cs nopw 0x0(%rax,%rax,1)
imul   $0xc400,%r9,%rax
add    %r13,%rax
imul   $0xc40,%r10,%rcx
add    %rax,%rcx
imul   $0x70,%r14,%rax
add    %rcx,%rax
lea    (%rax,%r15,4),%rbp
movss  (%rax,%r15,4),%xmm0
add    $0x1,%r15
mov    %r11,%rcx
mov    %rbx,%rdx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    $0x10,%edi
mov    %rdx,%rsi
nopl   0x0(%rax,%rax,1)
movss  -0x10(%rcx,%rdi,1),%xmm1
mulss  -0x10(%rsi),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,0x0(%rbp)
movss  -0xc(%rcx,%rdi,1),%xmm0
mulss  -0xc(%rsi),%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,0x0(%rbp)
movss  -0x8(%rcx,%rdi,1),%xmm1
mulss  -0x8(%rsi),%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,0x0(%rbp)
movss  -0x4(%rcx,%rdi,1),%xmm2
mulss  -0x4(%rsi),%xmm2
addss  %xmm1,%xmm2
movss  %xmm2,0x0(%rbp)
movss  (%rcx,%rdi,1),%xmm0
mulss  (%rsi),%xmm0
addss  %xmm2,%xmm0
movss  %xmm0,0x0(%rbp)
sub    $0xffffffffffffff80,%rsi
add    $0x14,%rdi
cmp    $0x74,%rdi
jne    1f60 <pencil_vgg+0xe50>
add    $0x1,%rax
add    $0x1000,%rdx
add    $0x64,%rcx
cmp    $0x10,%rax
jne    1f50 <pencil_vgg+0xe40>
add    $0x4,%rbx
cmp    $0x1c,%r15
jne    1f10 <pencil_vgg+0xe00>
add    $0x1,%r14
sub    $0xffffffffffffff80,%r8
cmp    $0x1c,%r14
jne    1f00 <pencil_vgg+0xdf0>
add    $0x1,%r10
add    $0x640,%r11
cmp    $0x10,%r10
jne    1ef0 <pencil_vgg+0xde0>
add    $0x1,%r9
add    $0x10000,%r12
cmp    $0x8,%r9
jne    1ee0 <pencil_vgg+0xdd0>
xor    %ecx,%ecx
mov    0x80(%rsp),%r12
nopl   (%rax)
mov    %rcx,0x18(%rsp)
mov    %r12,0x10(%rsp)
mov    %r13,%rbx
xor    %ebp,%ebp
nop
mov    %r12,0x8(%rsp)
mov    %rbx,0x20(%rsp)
xor    %r15d,%r15d
nopl   (%rax)
xor    %r14d,%r14d
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  (%rbx,%r14,4),%xmm0
xorps  %xmm1,%xmm1
call   1030 <Max@plt>
movss  %xmm0,(%r12,%r14,4)
add    $0x1,%r14
cmp    $0x1c,%r14
jne    2070 <pencil_vgg+0xf60>
add    $0x1,%r15
add    $0x70,%rbx
add    $0x70,%r12
cmp    $0x1c,%r15
jne    2060 <pencil_vgg+0xf50>
add    $0x1,%rbp
mov    0x20(%rsp),%rbx
add    $0xc40,%rbx
mov    0x8(%rsp),%r12
add    $0xc40,%r12
cmp    $0x10,%rbp
jne    2050 <pencil_vgg+0xf40>
mov    0x18(%rsp),%rcx
add    $0x1,%rcx
add    $0xc400,%r13
mov    0x10(%rsp),%r12
add    $0xc400,%r12
cmp    $0x8,%rcx
jne    2040 <pencil_vgg+0xf30>
mov    0x80(%rsp),%r12
add    $0x10,%r12
xor    %ecx,%ecx
mov    %rcx,0x8(%rsp)
nopl   0x0(%rax,%rax,1)
mov    %r12,0x10(%rsp)
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
mov    %r12,0x18(%rsp)
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
mov    %r12,0x20(%rsp)
xor    %r15d,%r15d
nopl   0x0(%rax,%rax,1)
mov    0x8(%rsp),%rax
lea    (%rax,%rax,8),%rax
shl    $0xc,%rax
add    0x88(%rsp),%rax
lea    0x0(,%rbp,8),%rcx
add    %rbp,%rcx
shl    $0x8,%rcx
add    %rax,%rcx
lea    (%rbx,%rbx,2),%rax
shl    $0x5,%rax
add    %rcx,%rax
lea    (%rax,%r15,4),%r14
movl   $0x0,(%rax,%r15,4)
add    $0x1,%r15
xorps  %xmm1,%xmm1
xor    %r13d,%r13d
nopl   0x0(%rax,%rax,1)
movss  -0x10(%r12,%r13,1),%xmm0
call   1030 <Max@plt>
movaps %xmm0,%xmm1
movss  %xmm0,(%r14)
movss  -0xc(%r12,%r13,1),%xmm0
call   1030 <Max@plt>
movaps %xmm0,%xmm1
movss  %xmm0,(%r14)
movss  -0x8(%r12,%r13,1),%xmm0
call   1030 <Max@plt>
movaps %xmm0,%xmm1
movss  %xmm0,(%r14)
movss  -0x4(%r12,%r13,1),%xmm0
call   1030 <Max@plt>
movaps %xmm0,%xmm1
movss  %xmm0,(%r14)
movss  (%r12,%r13,1),%xmm0
call   1030 <Max@plt>
movaps %xmm0,%xmm1
movss  %xmm0,(%r14)
add    $0x70,%r13
cmp    $0x230,%r13
jne    2180 <pencil_vgg+0x1070>
add    $0x4,%r12
cmp    $0x18,%r15
jne    2130 <pencil_vgg+0x1020>
add    $0x1,%rbx
mov    0x20(%rsp),%r12
add    $0x70,%r12
cmp    $0x18,%rbx
jne    2120 <pencil_vgg+0x1010>
add    $0x1,%rbp
mov    0x18(%rsp),%r12
add    $0xc40,%r12
cmp    $0x10,%rbp
jne    2110 <pencil_vgg+0x1000>
mov    0x8(%rsp),%rdx
add    $0x1,%rdx
mov    0x10(%rsp),%r12
add    $0xc400,%r12
mov    %rdx,%rcx
mov    %rdx,0x8(%rsp)
cmp    $0x8,%rdx
jne    2100 <pencil_vgg+0xff0>
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @pencil_vgg([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, [16 x [32 x [32 x float]]]* nocapture %4, [16 x [28 x [28 x float]]]* nocapture %5, [16 x [28 x [28 x float]]]* nocapture %6, [16 x [24 x [24 x float]]]* nocapture %7) {
br label %9
9: ; preds = %8, %564
%10 = phi i64 [ 0, %8 ], [ %565, %564 ]
%11 = getelementptr float, float* %3, i64 %10
%12 = add nuw i64 %10, 1
%13 = getelementptr float, float* %3, i64 %12
%14 = getelementptr inbounds float, float* %3, i64 %10
br label %519
15: ; preds = %564, %84
%16 = phi i64 [ %85, %84 ], [ 0, %564 ]
%17 = getelementptr float, float* %3, i64 %16
%18 = add nuw i64 %16, 1
%19 = getelementptr float, float* %3, i64 %18
%20 = getelementptr inbounds float, float* %3, i64 %16
br label %21
21: ; preds = %15, %81
%22 = phi i64 [ 0, %15 ], [ %82, %81 ]
%23 = add nuw i64 %22, 1
%24 = getelementptr [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 1, i64 %16, i64 %23, i64 0
%25 = getelementptr [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 1, i64 %16, i64 %22, i64 0
%26 = icmp ult float* %25, %19
%27 = icmp ult float* %17, %24
%28 = and i1 %26, %27
br i1 %28, label %66, label %29
29: ; preds = %21
%30 = load float, float* %20
%31 = insertelement <4 x float> poison, float %30, 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 %16, i64 %22, i64 0
%34 = bitcast float* %33 to <4 x float>*
store <4 x float> %32, <4 x float>* %34
%35 = insertelement <4 x float> poison, float %30, i64 0
%36 = shufflevector <4 x float> %35, <4 x float> poison, <4 x i32> zeroinitializer
%37 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 1, i64 %16, i64 %22, i64 4
%38 = bitcast float* %37 to <4 x float>*
store <4 x float> %36, <4 x float>* %38
%39 = load float, float* %20
%40 = insertelement <4 x float> poison, float %39, 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 %16, i64 %22, i64 8
%43 = bitcast float* %42 to <4 x float>*
store <4 x float> %41, <4 x float>* %43
%44 = insertelement <4 x float> poison, float %39, i64 0
%45 = shufflevector <4 x float> %44, <4 x float> poison, <4 x i32> zeroinitializer
%46 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 1, i64 %16, i64 %22, i64 12
%47 = bitcast float* %46 to <4 x float>*
store <4 x float> %45, <4 x float>* %47
%48 = load float, float* %20
%49 = insertelement <4 x float> poison, float %48, 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 %16, i64 %22, i64 16
%52 = bitcast float* %51 to <4 x float>*
store <4 x float> %50, <4 x float>* %52
%53 = insertelement <4 x float> poison, float %48, i64 0
%54 = shufflevector <4 x float> %53, <4 x float> poison, <4 x i32> zeroinitializer
%55 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 1, i64 %16, i64 %22, i64 20
%56 = bitcast float* %55 to <4 x float>*
store <4 x float> %54, <4 x float>* %56
%57 = load float, float* %20
%58 = insertelement <4 x float> poison, float %57, 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 %16, i64 %22, i64 24
%61 = bitcast float* %60 to <4 x float>*
store <4 x float> %59, <4 x float>* %61
%62 = insertelement <4 x float> poison, float %57, i64 0
%63 = shufflevector <4 x float> %62, <4 x float> poison, <4 x i32> zeroinitializer
%64 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 1, i64 %16, i64 %22, i64 28
%65 = bitcast float* %64 to <4 x float>*
store <4 x float> %63, <4 x float>* %65
br label %81
66: ; preds = %21, %66
%67 = phi i64 [ %79, %66 ], [ 0, %21 ]
%68 = load float, float* %20
%69 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 1, i64 %16, i64 %22, i64 %67
store float %68, float* %69
%70 = or i64 %67, 1
%71 = load float, float* %20
%72 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 1, i64 %16, i64 %22, i64 %70
store float %71, float* %72
%73 = or i64 %67, 2
%74 = load float, float* %20
%75 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 1, i64 %16, i64 %22, i64 %73
store float %74, float* %75
%76 = or i64 %67, 3
%77 = load float, float* %20
%78 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 1, i64 %16, i64 %22, i64 %76
store float %77, float* %78
%79 = add nuw nsw i64 %67, 4
%80 = icmp eq i64 %79, 32
br i1 %80, label %81, label %66
81: ; preds = %66, %29
%82 = add nuw nsw i64 %22, 1
%83 = icmp eq i64 %82, 32
br i1 %83, label %84, label %21
84: ; preds = %81
%85 = add nuw nsw i64 %16, 1
%86 = icmp eq i64 %85, 16
br i1 %86, label %87, label %15
87: ; preds = %84, %156
%88 = phi i64 [ %157, %156 ], [ 0, %84 ]
%89 = getelementptr float, float* %3, i64 %88
%90 = add nuw i64 %88, 1
%91 = getelementptr float, float* %3, i64 %90
%92 = getelementptr inbounds float, float* %3, i64 %88
br label %93
93: ; preds = %87, %153
%94 = phi i64 [ 0, %87 ], [ %154, %153 ]
%95 = add nuw i64 %94, 1
%96 = getelementptr [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 2, i64 %88, i64 %95, i64 0
%97 = getelementptr [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 2, i64 %88, i64 %94, i64 0
%98 = icmp ult float* %97, %91
%99 = icmp ult float* %89, %96
%100 = and i1 %98, %99
br i1 %100, label %138, label %101
101: ; preds = %93
%102 = load float, float* %92
%103 = insertelement <4 x float> poison, float %102, 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 %88, i64 %94, i64 0
%106 = bitcast float* %105 to <4 x float>*
store <4 x float> %104, <4 x float>* %106
%107 = insertelement <4 x float> poison, float %102, i64 0
%108 = shufflevector <4 x float> %107, <4 x float> poison, <4 x i32> zeroinitializer
%109 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 2, i64 %88, i64 %94, i64 4
%110 = bitcast float* %109 to <4 x float>*
store <4 x float> %108, <4 x float>* %110
%111 = load float, float* %92
%112 = insertelement <4 x float> poison, float %111, 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 %88, i64 %94, i64 8
%115 = bitcast float* %114 to <4 x float>*
store <4 x float> %113, <4 x float>* %115
%116 = insertelement <4 x float> poison, float %111, i64 0
%117 = shufflevector <4 x float> %116, <4 x float> poison, <4 x i32> zeroinitializer
%118 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 2, i64 %88, i64 %94, i64 12
%119 = bitcast float* %118 to <4 x float>*
store <4 x float> %117, <4 x float>* %119
%120 = load float, float* %92
%121 = insertelement <4 x float> poison, float %120, 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 %88, i64 %94, i64 16
%124 = bitcast float* %123 to <4 x float>*
store <4 x float> %122, <4 x float>* %124
%125 = insertelement <4 x float> poison, float %120, i64 0
%126 = shufflevector <4 x float> %125, <4 x float> poison, <4 x i32> zeroinitializer
%127 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 2, i64 %88, i64 %94, i64 20
%128 = bitcast float* %127 to <4 x float>*
store <4 x float> %126, <4 x float>* %128
%129 = load float, float* %92
%130 = insertelement <4 x float> poison, float %129, 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 %88, i64 %94, i64 24
%133 = bitcast float* %132 to <4 x float>*
store <4 x float> %131, <4 x float>* %133
%134 = insertelement <4 x float> poison, float %129, i64 0
%135 = shufflevector <4 x float> %134, <4 x float> poison, <4 x i32> zeroinitializer
%136 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 2, i64 %88, i64 %94, i64 28
%137 = bitcast float* %136 to <4 x float>*
store <4 x float> %135, <4 x float>* %137
br label %153
138: ; preds = %93, %138
%139 = phi i64 [ %151, %138 ], [ 0, %93 ]
%140 = load float, float* %92
%141 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 2, i64 %88, i64 %94, i64 %139
store float %140, float* %141
%142 = or i64 %139, 1
%143 = load float, float* %92
%144 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 2, i64 %88, i64 %94, i64 %142
store float %143, float* %144
%145 = or i64 %139, 2
%146 = load float, float* %92
%147 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 2, i64 %88, i64 %94, i64 %145
store float %146, float* %147
%148 = or i64 %139, 3
%149 = load float, float* %92
%150 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 2, i64 %88, i64 %94, i64 %148
store float %149, float* %150
%151 = add nuw nsw i64 %139, 4
%152 = icmp eq i64 %151, 32
br i1 %152, label %153, label %138
153: ; preds = %138, %101
%154 = add nuw nsw i64 %94, 1
%155 = icmp eq i64 %154, 32
br i1 %155, label %156, label %93
156: ; preds = %153
%157 = add nuw nsw i64 %88, 1
%158 = icmp eq i64 %157, 16
br i1 %158, label %159, label %87
159: ; preds = %156, %228
%160 = phi i64 [ %229, %228 ], [ 0, %156 ]
%161 = getelementptr float, float* %3, i64 %160
%162 = add nuw i64 %160, 1
%163 = getelementptr float, float* %3, i64 %162
%164 = getelementptr inbounds float, float* %3, i64 %160
br label %165
165: ; preds = %159, %225
%166 = phi i64 [ 0, %159 ], [ %226, %225 ]
%167 = add nuw i64 %166, 1
%168 = getelementptr [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 3, i64 %160, i64 %167, i64 0
%169 = getelementptr [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 3, i64 %160, i64 %166, i64 0
%170 = icmp ult float* %169, %163
%171 = icmp ult float* %161, %168
%172 = and i1 %170, %171
br i1 %172, label %210, label %173
173: ; preds = %165
%174 = load float, float* %164
%175 = insertelement <4 x float> poison, float %174, 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 %160, i64 %166, i64 0
%178 = bitcast float* %177 to <4 x float>*
store <4 x float> %176, <4 x float>* %178
%179 = insertelement <4 x float> poison, float %174, i64 0
%180 = shufflevector <4 x float> %179, <4 x float> poison, <4 x i32> zeroinitializer
%181 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 3, i64 %160, i64 %166, i64 4
%182 = bitcast float* %181 to <4 x float>*
store <4 x float> %180, <4 x float>* %182
%183 = load float, float* %164
%184 = insertelement <4 x float> poison, float %183, 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 %160, i64 %166, i64 8
%187 = bitcast float* %186 to <4 x float>*
store <4 x float> %185, <4 x float>* %187
%188 = insertelement <4 x float> poison, float %183, i64 0
%189 = shufflevector <4 x float> %188, <4 x float> poison, <4 x i32> zeroinitializer
%190 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 3, i64 %160, i64 %166, i64 12
%191 = bitcast float* %190 to <4 x float>*
store <4 x float> %189, <4 x float>* %191
%192 = load float, float* %164
%193 = insertelement <4 x float> poison, float %192, 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 %160, i64 %166, i64 16
%196 = bitcast float* %195 to <4 x float>*
store <4 x float> %194, <4 x float>* %196
%197 = insertelement <4 x float> poison, float %192, i64 0
%198 = shufflevector <4 x float> %197, <4 x float> poison, <4 x i32> zeroinitializer
%199 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 3, i64 %160, i64 %166, i64 20
%200 = bitcast float* %199 to <4 x float>*
store <4 x float> %198, <4 x float>* %200
%201 = load float, float* %164
%202 = insertelement <4 x float> poison, float %201, 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 %160, i64 %166, i64 24
%205 = bitcast float* %204 to <4 x float>*
store <4 x float> %203, <4 x float>* %205
%206 = insertelement <4 x float> poison, float %201, i64 0
%207 = shufflevector <4 x float> %206, <4 x float> poison, <4 x i32> zeroinitializer
%208 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 3, i64 %160, i64 %166, i64 28
%209 = bitcast float* %208 to <4 x float>*
store <4 x float> %207, <4 x float>* %209
br label %225
210: ; preds = %165, %210
%211 = phi i64 [ %223, %210 ], [ 0, %165 ]
%212 = load float, float* %164
%213 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 3, i64 %160, i64 %166, i64 %211
store float %212, float* %213
%214 = or i64 %211, 1
%215 = load float, float* %164
%216 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 3, i64 %160, i64 %166, i64 %214
store float %215, float* %216
%217 = or i64 %211, 2
%218 = load float, float* %164
%219 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 3, i64 %160, i64 %166, i64 %217
store float %218, float* %219
%220 = or i64 %211, 3
%221 = load float, float* %164
%222 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 3, i64 %160, i64 %166, i64 %220
store float %221, float* %222
%223 = add nuw nsw i64 %211, 4
%224 = icmp eq i64 %223, 32
br i1 %224, label %225, label %210
225: ; preds = %210, %173
%226 = add nuw nsw i64 %166, 1
%227 = icmp eq i64 %226, 32
br i1 %227, label %228, label %165
228: ; preds = %225
%229 = add nuw nsw i64 %160, 1
%230 = icmp eq i64 %229, 16
br i1 %230, label %231, label %159
231: ; preds = %228, %300
%232 = phi i64 [ %301, %300 ], [ 0, %228 ]
%233 = getelementptr float, float* %3, i64 %232
%234 = add nuw i64 %232, 1
%235 = getelementptr float, float* %3, i64 %234
%236 = getelementptr inbounds float, float* %3, i64 %232
br label %237
237: ; preds = %231, %297
%238 = phi i64 [ 0, %231 ], [ %298, %297 ]
%239 = add nuw i64 %238, 1
%240 = getelementptr [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 4, i64 %232, i64 %239, i64 0
%241 = getelementptr [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 4, i64 %232, i64 %238, i64 0
%242 = icmp ult float* %241, %235
%243 = icmp ult float* %233, %240
%244 = and i1 %242, %243
br i1 %244, label %282, label %245
245: ; preds = %237
%246 = load float, float* %236
%247 = insertelement <4 x float> poison, float %246, 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 %232, i64 %238, i64 0
%250 = bitcast float* %249 to <4 x float>*
store <4 x float> %248, <4 x float>* %250
%251 = insertelement <4 x float> poison, float %246, i64 0
%252 = shufflevector <4 x float> %251, <4 x float> poison, <4 x i32> zeroinitializer
%253 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 4, i64 %232, i64 %238, i64 4
%254 = bitcast float* %253 to <4 x float>*
store <4 x float> %252, <4 x float>* %254
%255 = load float, float* %236
%256 = insertelement <4 x float> poison, float %255, 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 %232, i64 %238, i64 8
%259 = bitcast float* %258 to <4 x float>*
store <4 x float> %257, <4 x float>* %259
%260 = insertelement <4 x float> poison, float %255, i64 0
%261 = shufflevector <4 x float> %260, <4 x float> poison, <4 x i32> zeroinitializer
%262 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 4, i64 %232, i64 %238, i64 12
%263 = bitcast float* %262 to <4 x float>*
store <4 x float> %261, <4 x float>* %263
%264 = load float, float* %236
%265 = insertelement <4 x float> poison, float %264, 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 %232, i64 %238, i64 16
%268 = bitcast float* %267 to <4 x float>*
store <4 x float> %266, <4 x float>* %268
%269 = insertelement <4 x float> poison, float %264, i64 0
%270 = shufflevector <4 x float> %269, <4 x float> poison, <4 x i32> zeroinitializer
%271 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 4, i64 %232, i64 %238, i64 20
%272 = bitcast float* %271 to <4 x float>*
store <4 x float> %270, <4 x float>* %272
%273 = load float, float* %236
%274 = insertelement <4 x float> poison, float %273, 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 %232, i64 %238, i64 24
%277 = bitcast float* %276 to <4 x float>*
store <4 x float> %275, <4 x float>* %277
%278 = insertelement <4 x float> poison, float %273, i64 0
%279 = shufflevector <4 x float> %278, <4 x float> poison, <4 x i32> zeroinitializer
%280 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 4, i64 %232, i64 %238, i64 28
%281 = bitcast float* %280 to <4 x float>*
store <4 x float> %279, <4 x float>* %281
br label %297
282: ; preds = %237, %282
%283 = phi i64 [ %295, %282 ], [ 0, %237 ]
%284 = load float, float* %236
%285 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 4, i64 %232, i64 %238, i64 %283
store float %284, float* %285
%286 = or i64 %283, 1
%287 = load float, float* %236
%288 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 4, i64 %232, i64 %238, i64 %286
store float %287, float* %288
%289 = or i64 %283, 2
%290 = load float, float* %236
%291 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 4, i64 %232, i64 %238, i64 %289
store float %290, float* %291
%292 = or i64 %283, 3
%293 = load float, float* %236
%294 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 4, i64 %232, i64 %238, i64 %292
store float %293, float* %294
%295 = add nuw nsw i64 %283, 4
%296 = icmp eq i64 %295, 32
br i1 %296, label %297, label %282
297: ; preds = %282, %245
%298 = add nuw nsw i64 %238, 1
%299 = icmp eq i64 %298, 32
br i1 %299, label %300, label %237
300: ; preds = %297
%301 = add nuw nsw i64 %232, 1
%302 = icmp eq i64 %301, 16
br i1 %302, label %303, label %231
303: ; preds = %300, %372
%304 = phi i64 [ %373, %372 ], [ 0, %300 ]
%305 = getelementptr float, float* %3, i64 %304
%306 = add nuw i64 %304, 1
%307 = getelementptr float, float* %3, i64 %306
%308 = getelementptr inbounds float, float* %3, i64 %304
br label %309
309: ; preds = %303, %369
%310 = phi i64 [ 0, %303 ], [ %370, %369 ]
%311 = add nuw i64 %310, 1
%312 = getelementptr [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 5, i64 %304, i64 %311, i64 0
%313 = getelementptr [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 5, i64 %304, i64 %310, i64 0
%314 = icmp ult float* %313, %307
%315 = icmp ult float* %305, %312
%316 = and i1 %314, %315
br i1 %316, label %354, label %317
317: ; preds = %309
%318 = load float, float* %308
%319 = insertelement <4 x float> poison, float %318, 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 %304, i64 %310, i64 0
%322 = bitcast float* %321 to <4 x float>*
store <4 x float> %320, <4 x float>* %322
%323 = insertelement <4 x float> poison, float %318, i64 0
%324 = shufflevector <4 x float> %323, <4 x float> poison, <4 x i32> zeroinitializer
%325 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 5, i64 %304, i64 %310, i64 4
%326 = bitcast float* %325 to <4 x float>*
store <4 x float> %324, <4 x float>* %326
%327 = load float, float* %308
%328 = insertelement <4 x float> poison, float %327, 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 %304, i64 %310, i64 8
%331 = bitcast float* %330 to <4 x float>*
store <4 x float> %329, <4 x float>* %331
%332 = insertelement <4 x float> poison, float %327, i64 0
%333 = shufflevector <4 x float> %332, <4 x float> poison, <4 x i32> zeroinitializer
%334 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 5, i64 %304, i64 %310, i64 12
%335 = bitcast float* %334 to <4 x float>*
store <4 x float> %333, <4 x float>* %335
%336 = load float, float* %308
%337 = insertelement <4 x float> poison, float %336, 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 %304, i64 %310, i64 16
%340 = bitcast float* %339 to <4 x float>*
store <4 x float> %338, <4 x float>* %340
%341 = insertelement <4 x float> poison, float %336, i64 0
%342 = shufflevector <4 x float> %341, <4 x float> poison, <4 x i32> zeroinitializer
%343 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 5, i64 %304, i64 %310, i64 20
%344 = bitcast float* %343 to <4 x float>*
store <4 x float> %342, <4 x float>* %344
%345 = load float, float* %308
%346 = insertelement <4 x float> poison, float %345, 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 %304, i64 %310, i64 24
%349 = bitcast float* %348 to <4 x float>*
store <4 x float> %347, <4 x float>* %349
%350 = insertelement <4 x float> poison, float %345, i64 0
%351 = shufflevector <4 x float> %350, <4 x float> poison, <4 x i32> zeroinitializer
%352 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 5, i64 %304, i64 %310, i64 28
%353 = bitcast float* %352 to <4 x float>*
store <4 x float> %351, <4 x float>* %353
br label %369
354: ; preds = %309, %354
%355 = phi i64 [ %367, %354 ], [ 0, %309 ]
%356 = load float, float* %308
%357 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 5, i64 %304, i64 %310, i64 %355
store float %356, float* %357
%358 = or i64 %355, 1
%359 = load float, float* %308
%360 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 5, i64 %304, i64 %310, i64 %358
store float %359, float* %360
%361 = or i64 %355, 2
%362 = load float, float* %308
%363 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 5, i64 %304, i64 %310, i64 %361
store float %362, float* %363
%364 = or i64 %355, 3
%365 = load float, float* %308
%366 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 5, i64 %304, i64 %310, i64 %364
store float %365, float* %366
%367 = add nuw nsw i64 %355, 4
%368 = icmp eq i64 %367, 32
br i1 %368, label %369, label %354
369: ; preds = %354, %317
%370 = add nuw nsw i64 %310, 1
%371 = icmp eq i64 %370, 32
br i1 %371, label %372, label %309
372: ; preds = %369
%373 = add nuw nsw i64 %304, 1
%374 = icmp eq i64 %373, 16
br i1 %374, label %375, label %303
375: ; preds = %372, %444
%376 = phi i64 [ %445, %444 ], [ 0, %372 ]
%377 = getelementptr float, float* %3, i64 %376
%378 = add nuw i64 %376, 1
%379 = getelementptr float, float* %3, i64 %378
%380 = getelementptr inbounds float, float* %3, i64 %376
br label %381
381: ; preds = %375, %441
%382 = phi i64 [ 0, %375 ], [ %442, %441 ]
%383 = add nuw i64 %382, 1
%384 = getelementptr [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 6, i64 %376, i64 %383, i64 0
%385 = getelementptr [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 6, i64 %376, i64 %382, i64 0
%386 = icmp ult float* %385, %379
%387 = icmp ult float* %377, %384
%388 = and i1 %386, %387
br i1 %388, label %426, label %389
389: ; preds = %381
%390 = load float, float* %380
%391 = insertelement <4 x float> poison, float %390, 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 %376, i64 %382, i64 0
%394 = bitcast float* %393 to <4 x float>*
store <4 x float> %392, <4 x float>* %394
%395 = insertelement <4 x float> poison, float %390, i64 0
%396 = shufflevector <4 x float> %395, <4 x float> poison, <4 x i32> zeroinitializer
%397 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 6, i64 %376, i64 %382, i64 4
%398 = bitcast float* %397 to <4 x float>*
store <4 x float> %396, <4 x float>* %398
%399 = load float, float* %380
%400 = insertelement <4 x float> poison, float %399, 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 %376, i64 %382, i64 8
%403 = bitcast float* %402 to <4 x float>*
store <4 x float> %401, <4 x float>* %403
%404 = insertelement <4 x float> poison, float %399, i64 0
%405 = shufflevector <4 x float> %404, <4 x float> poison, <4 x i32> zeroinitializer
%406 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 6, i64 %376, i64 %382, i64 12
%407 = bitcast float* %406 to <4 x float>*
store <4 x float> %405, <4 x float>* %407
%408 = load float, float* %380
%409 = insertelement <4 x float> poison, float %408, 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 %376, i64 %382, i64 16
%412 = bitcast float* %411 to <4 x float>*
store <4 x float> %410, <4 x float>* %412
%413 = insertelement <4 x float> poison, float %408, i64 0
%414 = shufflevector <4 x float> %413, <4 x float> poison, <4 x i32> zeroinitializer
%415 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 6, i64 %376, i64 %382, i64 20
%416 = bitcast float* %415 to <4 x float>*
store <4 x float> %414, <4 x float>* %416
%417 = load float, float* %380
%418 = insertelement <4 x float> poison, float %417, 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 %376, i64 %382, i64 24
%421 = bitcast float* %420 to <4 x float>*
store <4 x float> %419, <4 x float>* %421
%422 = insertelement <4 x float> poison, float %417, i64 0
%423 = shufflevector <4 x float> %422, <4 x float> poison, <4 x i32> zeroinitializer
%424 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 6, i64 %376, i64 %382, i64 28
%425 = bitcast float* %424 to <4 x float>*
store <4 x float> %423, <4 x float>* %425
br label %441
426: ; preds = %381, %426
%427 = phi i64 [ %439, %426 ], [ 0, %381 ]
%428 = load float, float* %380
%429 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 6, i64 %376, i64 %382, i64 %427
store float %428, float* %429
%430 = or i64 %427, 1
%431 = load float, float* %380
%432 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 6, i64 %376, i64 %382, i64 %430
store float %431, float* %432
%433 = or i64 %427, 2
%434 = load float, float* %380
%435 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 6, i64 %376, i64 %382, i64 %433
store float %434, float* %435
%436 = or i64 %427, 3
%437 = load float, float* %380
%438 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 6, i64 %376, i64 %382, i64 %436
store float %437, float* %438
%439 = add nuw nsw i64 %427, 4
%440 = icmp eq i64 %439, 32
br i1 %440, label %441, label %426
441: ; preds = %426, %389
%442 = add nuw nsw i64 %382, 1
%443 = icmp eq i64 %442, 32
br i1 %443, label %444, label %381
444: ; preds = %441
%445 = add nuw nsw i64 %376, 1
%446 = icmp eq i64 %445, 16
br i1 %446, label %447, label %375
447: ; preds = %444, %516
%448 = phi i64 [ %517, %516 ], [ 0, %444 ]
%449 = getelementptr float, float* %3, i64 %448
%450 = add nuw i64 %448, 1
%451 = getelementptr float, float* %3, i64 %450
%452 = getelementptr inbounds float, float* %3, i64 %448
br label %453
453: ; preds = %447, %513
%454 = phi i64 [ 0, %447 ], [ %514, %513 ]
%455 = add nuw i64 %454, 1
%456 = getelementptr [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 7, i64 %448, i64 %455, i64 0
%457 = getelementptr [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 7, i64 %448, i64 %454, i64 0
%458 = icmp ult float* %457, %451
%459 = icmp ult float* %449, %456
%460 = and i1 %458, %459
br i1 %460, label %498, label %461
461: ; preds = %453
%462 = load float, float* %452
%463 = insertelement <4 x float> poison, float %462, 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 %448, i64 %454, i64 0
%466 = bitcast float* %465 to <4 x float>*
store <4 x float> %464, <4 x float>* %466
%467 = insertelement <4 x float> poison, float %462, i64 0
%468 = shufflevector <4 x float> %467, <4 x float> poison, <4 x i32> zeroinitializer
%469 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 7, i64 %448, i64 %454, i64 4
%470 = bitcast float* %469 to <4 x float>*
store <4 x float> %468, <4 x float>* %470
%471 = load float, float* %452
%472 = insertelement <4 x float> poison, float %471, 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 %448, i64 %454, i64 8
%475 = bitcast float* %474 to <4 x float>*
store <4 x float> %473, <4 x float>* %475
%476 = insertelement <4 x float> poison, float %471, i64 0
%477 = shufflevector <4 x float> %476, <4 x float> poison, <4 x i32> zeroinitializer
%478 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 7, i64 %448, i64 %454, i64 12
%479 = bitcast float* %478 to <4 x float>*
store <4 x float> %477, <4 x float>* %479
%480 = load float, float* %452
%481 = insertelement <4 x float> poison, float %480, 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 %448, i64 %454, i64 16
%484 = bitcast float* %483 to <4 x float>*
store <4 x float> %482, <4 x float>* %484
%485 = insertelement <4 x float> poison, float %480, i64 0
%486 = shufflevector <4 x float> %485, <4 x float> poison, <4 x i32> zeroinitializer
%487 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 7, i64 %448, i64 %454, i64 20
%488 = bitcast float* %487 to <4 x float>*
store <4 x float> %486, <4 x float>* %488
%489 = load float, float* %452
%490 = insertelement <4 x float> poison, float %489, 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 %448, i64 %454, i64 24
%493 = bitcast float* %492 to <4 x float>*
store <4 x float> %491, <4 x float>* %493
%494 = insertelement <4 x float> poison, float %489, i64 0
%495 = shufflevector <4 x float> %494, <4 x float> poison, <4 x i32> zeroinitializer
%496 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 7, i64 %448, i64 %454, i64 28
%497 = bitcast float* %496 to <4 x float>*
store <4 x float> %495, <4 x float>* %497
br label %513
498: ; preds = %453, %498
%499 = phi i64 [ %511, %498 ], [ 0, %453 ]
%500 = load float, float* %452
%501 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 7, i64 %448, i64 %454, i64 %499
store float %500, float* %501
%502 = or i64 %499, 1
%503 = load float, float* %452
%504 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 7, i64 %448, i64 %454, i64 %502
store float %503, float* %504
%505 = or i64 %499, 2
%506 = load float, float* %452
%507 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 7, i64 %448, i64 %454, i64 %505
store float %506, float* %507
%508 = or i64 %499, 3
%509 = load float, float* %452
%510 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 7, i64 %448, i64 %454, i64 %508
store float %509, float* %510
%511 = add nuw nsw i64 %499, 4
%512 = icmp eq i64 %511, 32
br i1 %512, label %513, label %498
513: ; preds = %498, %461
%514 = add nuw nsw i64 %454, 1
%515 = icmp eq i64 %514, 32
br i1 %515, label %516, label %453
516: ; preds = %513
%517 = add nuw nsw i64 %448, 1
%518 = icmp eq i64 %517, 16
br i1 %518, label %585, label %447
519: ; preds = %567, %9
%520 = phi i64 [ 0, %9 ], [ %568, %567 ]
%521 = add nuw i64 %520, 1
%522 = getelementptr [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 0, i64 %10, i64 %521, i64 0
%523 = getelementptr [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 0, i64 %10, i64 %520, i64 0
%524 = icmp ult float* %523, %13
%525 = icmp ult float* %11, %522
%526 = and i1 %524, %525
br i1 %526, label %570, label %527
527: ; preds = %519
%528 = load float, float* %14
%529 = insertelement <4 x float> poison, float %528, 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 %10, i64 %520, i64 0
%532 = bitcast float* %531 to <4 x float>*
store <4 x float> %530, <4 x float>* %532
%533 = insertelement <4 x float> poison, float %528, i64 0
%534 = shufflevector <4 x float> %533, <4 x float> poison, <4 x i32> zeroinitializer
%535 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 0, i64 %10, i64 %520, i64 4
%536 = bitcast float* %535 to <4 x float>*
store <4 x float> %534, <4 x float>* %536
%537 = load float, float* %14
%538 = insertelement <4 x float> poison, float %537, 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 %10, i64 %520, i64 8
%541 = bitcast float* %540 to <4 x float>*
store <4 x float> %539, <4 x float>* %541
%542 = insertelement <4 x float> poison, float %537, i64 0
%543 = shufflevector <4 x float> %542, <4 x float> poison, <4 x i32> zeroinitializer
%544 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 0, i64 %10, i64 %520, i64 12
%545 = bitcast float* %544 to <4 x float>*
store <4 x float> %543, <4 x float>* %545
%546 = load float, float* %14
%547 = insertelement <4 x float> poison, float %546, 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 %10, i64 %520, i64 16
%550 = bitcast float* %549 to <4 x float>*
store <4 x float> %548, <4 x float>* %550
%551 = insertelement <4 x float> poison, float %546, i64 0
%552 = shufflevector <4 x float> %551, <4 x float> poison, <4 x i32> zeroinitializer
%553 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 0, i64 %10, i64 %520, i64 20
%554 = bitcast float* %553 to <4 x float>*
store <4 x float> %552, <4 x float>* %554
%555 = load float, float* %14
%556 = insertelement <4 x float> poison, float %555, 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 %10, i64 %520, i64 24
%559 = bitcast float* %558 to <4 x float>*
store <4 x float> %557, <4 x float>* %559
%560 = insertelement <4 x float> poison, float %555, i64 0
%561 = shufflevector <4 x float> %560, <4 x float> poison, <4 x i32> zeroinitializer
%562 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 0, i64 %10, i64 %520, i64 28
%563 = bitcast float* %562 to <4 x float>*
store <4 x float> %561, <4 x float>* %563
br label %567
564: ; preds = %567
%565 = add nuw nsw i64 %10, 1
%566 = icmp eq i64 %565, 16
br i1 %566, label %15, label %9
567: ; preds = %570, %527
%568 = add nuw nsw i64 %520, 1
%569 = icmp eq i64 %568, 32
br i1 %569, label %564, label %519
570: ; preds = %519, %570
%571 = phi i64 [ %583, %570 ], [ 0, %519 ]
%572 = load float, float* %14
%573 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 0, i64 %10, i64 %520, i64 %571
store float %572, float* %573
%574 = or i64 %571, 1
%575 = load float, float* %14
%576 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 0, i64 %10, i64 %520, i64 %574
store float %575, float* %576
%577 = or i64 %571, 2
%578 = load float, float* %14
%579 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 0, i64 %10, i64 %520, i64 %577
store float %578, float* %579
%580 = or i64 %571, 3
%581 = load float, float* %14
%582 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 0, i64 %10, i64 %520, i64 %580
store float %581, float* %582
%583 = add nuw nsw i64 %571, 4
%584 = icmp eq i64 %583, 32
br i1 %584, label %567, label %570
585: ; preds = %516, %589
%586 = phi i64 [ %590, %589 ], [ 0, %516 ]
br label %587
587: ; preds = %585, %594
%588 = phi i64 [ 0, %585 ], [ %595, %594 ]
br label %592
589: ; preds = %594
%590 = add nuw nsw i64 %586, 1
%591 = icmp eq i64 %590, 8
br i1 %591, label %647, label %585
592: ; preds = %587, %605
%593 = phi i64 [ 0, %587 ], [ %606, %605 ]
br label %597
594: ; preds = %605
%595 = add nuw nsw i64 %588, 1
%596 = icmp eq i64 %595, 16
br i1 %596, label %589, label %587
597: ; preds = %592, %611
%598 = phi i64 [ 0, %592 ], [ %601, %611 ]
%599 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 %586, i64 %588, i64 %593, i64 %598
%600 = load float, float* %599
%601 = add nuw nsw i64 %598, 1
%602 = add nuw nsw i64 %598, 2
%603 = add nuw nsw i64 %598, 3
%604 = add nuw nsw i64 %598, 4
br label %608
605: ; preds = %611
%606 = add nuw nsw i64 %593, 1
%607 = icmp eq i64 %606, 32
br i1 %607, label %594, label %592
608: ; preds = %597, %644
%609 = phi float [ %600, %597 ], [ %641, %644 ]
%610 = phi i64 [ 0, %597 ], [ %645, %644 ]
br label %613
611: ; preds = %644
%612 = icmp eq i64 %601, 32
br i1 %612, label %605, label %597
613: ; preds = %608, %613
%614 = phi float [ %609, %608 ], [ %641, %613 ]
%615 = phi i64 [ 0, %608 ], [ %642, %613 ]
%616 = add nuw nsw i64 %615, %593
%617 = getelementptr inbounds [16 x [5 x [5 x float]]], [16 x [5 x [5 x float]]]* %1, i64 %588, i64 %610, i64 %615, i64 0
%618 = load float, float* %617
%619 = getelementptr inbounds [16 x [36 x [36 x float]]], [16 x [36 x [36 x float]]]* %0, i64 %586, i64 %610, i64 %616, i64 %598
%620 = load float, float* %619
%621 = tail call float @llvm.fmuladd.f32(float %618, float %620, float %614)
store float %621, float* %599
%622 = getelementptr inbounds [16 x [5 x [5 x float]]], [16 x [5 x [5 x float]]]* %1, i64 %588, i64 %610, i64 %615, i64 1
%623 = load float, float* %622
%624 = getelementptr inbounds [16 x [36 x [36 x float]]], [16 x [36 x [36 x float]]]* %0, i64 %586, i64 %610, i64 %616, i64 %601
%625 = load float, float* %624
%626 = tail call float @llvm.fmuladd.f32(float %623, float %625, float %621)
store float %626, float* %599
%627 = getelementptr inbounds [16 x [5 x [5 x float]]], [16 x [5 x [5 x float]]]* %1, i64 %588, i64 %610, i64 %615, i64 2
%628 = load float, float* %627
%629 = getelementptr inbounds [16 x [36 x [36 x float]]], [16 x [36 x [36 x float]]]* %0, i64 %586, i64 %610, i64 %616, i64 %602
%630 = load float, float* %629
%631 = tail call float @llvm.fmuladd.f32(float %628, float %630, float %626)
store float %631, float* %599
%632 = getelementptr inbounds [16 x [5 x [5 x float]]], [16 x [5 x [5 x float]]]* %1, i64 %588, i64 %610, i64 %615, i64 3
%633 = load float, float* %632
%634 = getelementptr inbounds [16 x [36 x [36 x float]]], [16 x [36 x [36 x float]]]* %0, i64 %586, i64 %610, i64 %616, i64 %603
%635 = load float, float* %634
%636 = tail call float @llvm.fmuladd.f32(float %633, float %635, float %631)
store float %636, float* %599
%637 = getelementptr inbounds [16 x [5 x [5 x float]]], [16 x [5 x [5 x float]]]* %1, i64 %588, i64 %610, i64 %615, i64 4
%638 = load float, float* %637
%639 = getelementptr inbounds [16 x [36 x [36 x float]]], [16 x [36 x [36 x float]]]* %0, i64 %586, i64 %610, i64 %616, i64 %604
%640 = load float, float* %639
%641 = tail call float @llvm.fmuladd.f32(float %638, float %640, float %636)
store float %641, float* %599
%642 = add nuw nsw i64 %615, 1
%643 = icmp eq i64 %642, 5
br i1 %643, label %644, label %613
644: ; preds = %613
%645 = add nuw nsw i64 %610, 1
%646 = icmp eq i64 %645, 16
br i1 %646, label %611, label %608
647: ; preds = %589, %651
%648 = phi i64 [ %652, %651 ], [ 0, %589 ]
br label %649
649: ; preds = %647, %656
%650 = phi i64 [ 0, %647 ], [ %657, %656 ]
br label %654
651: ; preds = %656
%652 = add nuw nsw i64 %648, 1
%653 = icmp eq i64 %652, 8
br i1 %653, label %670, label %647
654: ; preds = %649, %659
%655 = phi i64 [ 0, %649 ], [ %660, %659 ]
br label %662
656: ; preds = %659
%657 = add nuw nsw i64 %650, 1
%658 = icmp eq i64 %657, 16
br i1 %658, label %651, label %649
659: ; preds = %662
%660 = add nuw nsw i64 %655, 1
%661 = icmp eq i64 %660, 32
br i1 %661, label %656, label %654
662: ; preds = %654, %662
%663 = phi i64 [ 0, %654 ], [ %668, %662 ]
%664 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %2, i64 %648, i64 %650, i64 %655, i64 %663
%665 = load float, float* %664
%666 = tail call float @Max(float %665, float 0.000000e+00)
%667 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %4, i64 %648, i64 %650, i64 %655, i64 %663
store float %666, float* %667
%668 = add nuw nsw i64 %663, 1
%669 = icmp eq i64 %668, 32
br i1 %669, label %659, label %662
670: ; preds = %651, %675
%671 = phi i64 [ %676, %675 ], [ 0, %651 ]
br label %672
672: ; preds = %670, %738
%673 = phi i64 [ 0, %670 ], [ %739, %738 ]
%674 = getelementptr inbounds float, float* %3, i64 %673
br label %678
675: ; preds = %738
%676 = add nuw nsw i64 %671, 1
%677 = icmp eq i64 %676, 8
br i1 %677, label %741, label %670
678: ; preds = %672, %678
%679 = phi i64 [ 0, %672 ], [ %736, %678 ]
%680 = load float, float* %674
%681 = getelementptr inbounds [16 x [28 x [28 x float]]], [16 x [28 x [28 x float]]]* %5, i64 %671, i64 %673, i64 %679, i64 0
store float %680, float* %681
%682 = load float, float* %674
%683 = getelementptr inbounds [16 x [28 x [28 x float]]], [16 x [28 x [28 x float]]]* %5, i64 %671, i64 %673, i64 %679, i64 1
store float %682, float* %683
%684 = load float, float* %674
%685 = getelementptr inbounds [16 x [28 x [28 x float]]], [16 x [28 x [28 x float]]]* %5, i64 %671, i64 %673, i64 %679, i64 2
store float %684, float* %685
%686 = load float, float* %674
%687 = getelementptr inbounds [16 x [28 x [28 x float]]], [16 x [28 x [28 x float]]]* %5, i64 %671, i64 %673, i64 %679, i64 3
store float %686, float* %687
%688 = load float, float* %674
%689 = getelementptr inbounds [16 x [28 x [28 x float]]], [16 x [28 x [28 x float]]]* %5, i64 %671, i64 %673, i64 %679, i64 4
store float %688, float* %689
%690 = load float, float* %674
%691 = getelementptr inbounds [16 x [28 x [28 x float]]], [16 x [28 x [28 x float]]]* %5, i64 %671, i64 %673, i64 %679, i64 5
store float %690, float* %691
%692 = load float, float* %674
%693 = getelementptr inbounds [16 x [28 x [28 x float]]], [16 x [28 x [28 x float]]]* %5, i64 %671, i64 %673, i64 %679, i64 6
store float %692, float* %693
%694 = load float, float* %674
%695 = getelementptr inbounds [16 x [28 x [28 x float]]], [16 x [28 x [28 x float]]]* %5, i64 %671, i64 %673, i64 %679, i64 7
store float %694, float* %695
%696 = load float, float* %674
%697 = getelementptr inbounds [16 x [28 x [28 x float]]], [16 x [28 x [28 x float]]]* %5, i64 %671, i64 %673, i64 %679, i64 8
store float %696, float* %697
%698 = load float, float* %674
%699 = getelementptr inbounds [16 x [28 x [28 x float]]], [16 x [28 x [28 x float]]]* %5, i64 %671, i64 %673, i64 %679, i64 9
store float %698, float* %699
%700 = load float, float* %674
%701 = getelementptr inbounds [16 x [28 x [28 x float]]], [16 x [28 x [28 x float]]]* %5, i64 %671, i64 %673, i64 %679, i64 10
store float %700, float* %701
%702 = load float, float* %674
%703 = getelementptr inbounds [16 x [28 x [28 x float]]], [16 x [28 x [28 x float]]]* %5, i64 %671, i64 %673, i64 %679, i64 11
store float %702, float* %703
%704 = load float, float* %674
%705 = getelementptr inbounds [16 x [28 x [28 x float]]], [16 x [28 x [28 x float]]]* %5, i64 %671, i64 %673, i64 %679, i64 12
store float %704, float* %705
%706 = load float, float* %674
%707 = getelementptr inbounds [16 x [28 x [28 x float]]], [16 x [28 x [28 x float]]]* %5, i64 %671, i64 %673, i64 %679, i64 13
store float %706, float* %707
%708 = load float, float* %674
%709 = getelementptr inbounds [16 x [28 x [28 x float]]], [16 x [28 x [28 x float]]]* %5, i64 %671, i64 %673, i64 %679, i64 14
store float %708, float* %709
%710 = load float, float* %674
%711 = getelementptr inbounds [16 x [28 x [28 x float]]], [16 x [28 x [28 x float]]]* %5, i64 %671, i64 %673, i64 %679, i64 15
store float %710, float* %711
%712 = load float, float* %674
%713 = getelementptr inbounds [16 x [28 x [28 x float]]], [16 x [28 x [28 x float]]]* %5, i64 %671, i64 %673, i64 %679, i64 16
store float %712, float* %713
%714 = load float, float* %674
%715 = getelementptr inbounds [16 x [28 x [28 x float]]], [16 x [28 x [28 x float]]]* %5, i64 %671, i64 %673, i64 %679, i64 17
store float %714, float* %715
%716 = load float, float* %674
%717 = getelementptr inbounds [16 x [28 x [28 x float]]], [16 x [28 x [28 x float]]]* %5, i64 %671, i64 %673, i64 %679, i64 18
store float %716, float* %717
%718 = load float, float* %674
%719 = getelementptr inbounds [16 x [28 x [28 x float]]], [16 x [28 x [28 x float]]]* %5, i64 %671, i64 %673, i64 %679, i64 19
store float %718, float* %719
%720 = load float, float* %674
%721 = getelementptr inbounds [16 x [28 x [28 x float]]], [16 x [28 x [28 x float]]]* %5, i64 %671, i64 %673, i64 %679, i64 20
store float %720, float* %721
%722 = load float, float* %674
%723 = getelementptr inbounds [16 x [28 x [28 x float]]], [16 x [28 x [28 x float]]]* %5, i64 %671, i64 %673, i64 %679, i64 21
store float %722, float* %723
%724 = load float, float* %674
%725 = getelementptr inbounds [16 x [28 x [28 x float]]], [16 x [28 x [28 x float]]]* %5, i64 %671, i64 %673, i64 %679, i64 22
store float %724, float* %725
%726 = load float, float* %674
%727 = getelementptr inbounds [16 x [28 x [28 x float]]], [16 x [28 x [28 x float]]]* %5, i64 %671, i64 %673, i64 %679, i64 23
store float %726, float* %727
%728 = load float, float* %674
%729 = getelementptr inbounds [16 x [28 x [28 x float]]], [16 x [28 x [28 x float]]]* %5, i64 %671, i64 %673, i64 %679, i64 24
store float %728, float* %729
%730 = load float, float* %674
%731 = getelementptr inbounds [16 x [28 x [28 x float]]], [16 x [28 x [28 x float]]]* %5, i64 %671, i64 %673, i64 %679, i64 25
store float %730, float* %731
%732 = load float, float* %674
%733 = getelementptr inbounds [16 x [28 x [28 x float]]], [16 x [28 x [28 x float]]]* %5, i64 %671, i64 %673, i64 %679, i64 26
store float %732, float* %733
%734 = load float, float* %674
%735 = getelementptr inbounds [16 x [28 x [28 x float]]], [16 x [28 x [28 x float]]]* %5, i64 %671, i64 %673, i64 %679, i64 27
store float %734, float* %735
%736 = add nuw nsw i64 %679, 1
%737 = icmp eq i64 %736, 28
br i1 %737, label %738, label %678
738: ; preds = %678
%739 = add nuw nsw i64 %673, 1
%740 = icmp eq i64 %739, 16
br i1 %740, label %675, label %672
741: ; preds = %675, %745
%742 = phi i64 [ %746, %745 ], [ 0, %675 ]
br label %743
743: ; preds = %741, %750
%744 = phi i64 [ 0, %741 ], [ %751, %750 ]
br label %748
745: ; preds = %750
%746 = add nuw nsw i64 %742, 1
%747 = icmp eq i64 %746, 8
br i1 %747, label %803, label %741
748: ; preds = %743, %761
%749 = phi i64 [ 0, %743 ], [ %762, %761 ]
br label %753
750: ; preds = %761
%751 = add nuw nsw i64 %744, 1
%752 = icmp eq i64 %751, 16
br i1 %752, label %745, label %743
753: ; preds = %748, %767
%754 = phi i64 [ 0, %748 ], [ %757, %767 ]
%755 = getelementptr inbounds [16 x [28 x [28 x float]]], [16 x [28 x [28 x float]]]* %5, i64 %742, i64 %744, i64 %749, i64 %754
%756 = load float, float* %755
%757 = add nuw nsw i64 %754, 1
%758 = add nuw nsw i64 %754, 2
%759 = add nuw nsw i64 %754, 3
%760 = add nuw nsw i64 %754, 4
br label %764
761: ; preds = %767
%762 = add nuw nsw i64 %749, 1
%763 = icmp eq i64 %762, 28
br i1 %763, label %750, label %748
764: ; preds = %753, %800
%765 = phi float [ %756, %753 ], [ %797, %800 ]
%766 = phi i64 [ 0, %753 ], [ %801, %800 ]
br label %769
767: ; preds = %800
%768 = icmp eq i64 %757, 28
br i1 %768, label %761, label %753
769: ; preds = %764, %769
%770 = phi float [ %765, %764 ], [ %797, %769 ]
%771 = phi i64 [ 0, %764 ], [ %798, %769 ]
%772 = add nuw nsw i64 %771, %749
%773 = getelementptr inbounds [16 x [5 x [5 x float]]], [16 x [5 x [5 x float]]]* %1, i64 %744, i64 %766, i64 %771, i64 0
%774 = load float, float* %773
%775 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %4, i64 %742, i64 %766, i64 %772, i64 %754
%776 = load float, float* %775
%777 = tail call float @llvm.fmuladd.f32(float %774, float %776, float %770)
store float %777, float* %755
%778 = getelementptr inbounds [16 x [5 x [5 x float]]], [16 x [5 x [5 x float]]]* %1, i64 %744, i64 %766, i64 %771, i64 1
%779 = load float, float* %778
%780 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %4, i64 %742, i64 %766, i64 %772, i64 %757
%781 = load float, float* %780
%782 = tail call float @llvm.fmuladd.f32(float %779, float %781, float %777)
store float %782, float* %755
%783 = getelementptr inbounds [16 x [5 x [5 x float]]], [16 x [5 x [5 x float]]]* %1, i64 %744, i64 %766, i64 %771, i64 2
%784 = load float, float* %783
%785 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %4, i64 %742, i64 %766, i64 %772, i64 %758
%786 = load float, float* %785
%787 = tail call float @llvm.fmuladd.f32(float %784, float %786, float %782)
store float %787, float* %755
%788 = getelementptr inbounds [16 x [5 x [5 x float]]], [16 x [5 x [5 x float]]]* %1, i64 %744, i64 %766, i64 %771, i64 3
%789 = load float, float* %788
%790 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %4, i64 %742, i64 %766, i64 %772, i64 %759
%791 = load float, float* %790
%792 = tail call float @llvm.fmuladd.f32(float %789, float %791, float %787)
store float %792, float* %755
%793 = getelementptr inbounds [16 x [5 x [5 x float]]], [16 x [5 x [5 x float]]]* %1, i64 %744, i64 %766, i64 %771, i64 4
%794 = load float, float* %793
%795 = getelementptr inbounds [16 x [32 x [32 x float]]], [16 x [32 x [32 x float]]]* %4, i64 %742, i64 %766, i64 %772, i64 %760
%796 = load float, float* %795
%797 = tail call float @llvm.fmuladd.f32(float %794, float %796, float %792)
store float %797, float* %755
%798 = add nuw nsw i64 %771, 1
%799 = icmp eq i64 %798, 5
br i1 %799, label %800, label %769
800: ; preds = %769
%801 = add nuw nsw i64 %766, 1
%802 = icmp eq i64 %801, 16
br i1 %802, label %767, label %764
803: ; preds = %745, %807
%804 = phi i64 [ %808, %807 ], [ 0, %745 ]
br label %805
805: ; preds = %803, %812
%806 = phi i64 [ 0, %803 ], [ %813, %812 ]
br label %810
807: ; preds = %812
%808 = add nuw nsw i64 %804, 1
%809 = icmp eq i64 %808, 8
br i1 %809, label %826, label %803
810: ; preds = %805, %815
%811 = phi i64 [ 0, %805 ], [ %816, %815 ]
br label %818
812: ; preds = %815
%813 = add nuw nsw i64 %806, 1
%814 = icmp eq i64 %813, 16
br i1 %814, label %807, label %805
815: ; preds = %818
%816 = add nuw nsw i64 %811, 1
%817 = icmp eq i64 %816, 28
br i1 %817, label %812, label %810
818: ; preds = %810, %818
%819 = phi i64 [ 0, %810 ], [ %824, %818 ]
%820 = getelementptr inbounds [16 x [28 x [28 x float]]], [16 x [28 x [28 x float]]]* %5, i64 %804, i64 %806, i64 %811, i64 %819
%821 = load float, float* %820
%822 = tail call float @Max(float %821, float 0.000000e+00)
%823 = getelementptr inbounds [16 x [28 x [28 x float]]], [16 x [28 x [28 x float]]]* %6, i64 %804, i64 %806, i64 %811, i64 %819
store float %822, float* %823
%824 = add nuw nsw i64 %819, 1
%825 = icmp eq i64 %824, 28
br i1 %825, label %815, label %818
826: ; preds = %807, %831
%827 = phi i64 [ %832, %831 ], [ 0, %807 ]
br label %829
828: ; preds = %831
ret void
829: ; preds = %826, %836
%830 = phi i64 [ 0, %826 ], [ %837, %836 ]
br label %834
831: ; preds = %836
%832 = add nuw nsw i64 %827, 1
%833 = icmp eq i64 %832, 8
br i1 %833, label %828, label %826
834: ; preds = %829, %839
%835 = phi i64 [ 0, %829 ], [ %840, %839 ]
br label %842
836: ; preds = %839
%837 = add nuw nsw i64 %830, 1
%838 = icmp eq i64 %837, 16
br i1 %838, label %831, label %829
839: ; preds = %870
%840 = add nuw nsw i64 %835, 1
%841 = icmp eq i64 %840, 24
br i1 %841, label %836, label %834
842: ; preds = %834, %870
%843 = phi i64 [ 0, %834 ], [ %845, %870 ]
%844 = getelementptr inbounds [16 x [24 x [24 x float]]], [16 x [24 x [24 x float]]]* %7, i64 %827, i64 %830, i64 %835, i64 %843
store float 0.000000e+00, float* %844
%845 = add nuw nsw i64 %843, 1
%846 = add nuw nsw i64 %843, 2
%847 = add nuw nsw i64 %843, 3
%848 = add nuw nsw i64 %843, 4
br label %849
849: ; preds = %842, %849
%850 = phi float [ 0.000000e+00, %842 ], [ %867, %849 ]
%851 = phi i64 [ 0, %842 ], [ %868, %849 ]
%852 = add nuw nsw i64 %851, %835
%853 = getelementptr inbounds [16 x [28 x [28 x float]]], [16 x [28 x [28 x float]]]* %6, i64 %827, i64 %830, i64 %852, i64 %843
%854 = load float, float* %853
%855 = tail call float @Max(float %854, float %850)
store float %855, float* %844
%856 = getelementptr inbounds [16 x [28 x [28 x float]]], [16 x [28 x [28 x float]]]* %6, i64 %827, i64 %830, i64 %852, i64 %845
%857 = load float, float* %856
%858 = tail call float @Max(float %857, float %855)
store float %858, float* %844
%859 = getelementptr inbounds [16 x [28 x [28 x float]]], [16 x [28 x [28 x float]]]* %6, i64 %827, i64 %830, i64 %852, i64 %846
%860 = load float, float* %859
%861 = tail call float @Max(float %860, float %858)
store float %861, float* %844
%862 = getelementptr inbounds [16 x [28 x [28 x float]]], [16 x [28 x [28 x float]]]* %6, i64 %827, i64 %830, i64 %852, i64 %847
%863 = load float, float* %862
%864 = tail call float @Max(float %863, float %861)
store float %864, float* %844
%865 = getelementptr inbounds [16 x [28 x [28 x float]]], [16 x [28 x [28 x float]]]* %6, i64 %827, i64 %830, i64 %852, i64 %848
%866 = load float, float* %865
%867 = tail call float @Max(float %866, float %864)
store float %867, float* %844
%868 = add nuw nsw i64 %851, 1
%869 = icmp eq i64 %868, 5
br i1 %869, label %870, label %849
870: ; preds = %849
%871 = icmp eq i64 %845, 24
br i1 %871, label %839, label %842
}