int perform_convolution(image, out_image, detect_type, threshold, rows, cols,
                        bits_per_pixel, high)
short **image, **out_image;
int detect_type, high, threshold;
long rows, cols, bits_per_pixel;
{
  char response[80];
  int a, b, i, is_present, j, sum;
  short mask_0[3][3], mask_1[3][3], mask_2[3][3], mask_3[3][3], mask_4[3][3],
      mask_5[3][3], mask_6[3][3], mask_7[3][3], max, min, new_hi, new_low;
  setup_masks(detect_type, mask_0, mask_1, mask_2, mask_3, mask_4, mask_5,
              mask_6, mask_7);
  new_hi = 250;
  new_low = 16;
  if (bits_per_pixel == 4) {
    new_hi = 10;
    new_low = 3;
  }
  min = 0;
  max = 255;
  if (bits_per_pixel == 4)
    max = 16;
  for (i = 0; i < rows; i++)
    for (j = 0; j < cols; j++)
      out_image[i][j] = 0;
  printf("\n ");
  for (i = 1; i < rows - 1; i++) {
    if ((i % 10) == 0) {
      printf("%4d", i);
    }
    for (j = 1; j < cols - 1; j++) {
      sum = 0;
      for (a = -1; a < 2; a++) {
        for (b = -1; b < 2; b++) {
          sum = sum + image[i + a][j + b] * mask_0[a + 1][b + 1];
        }
      }
      if (sum > max)
        sum = max;
      if (sum < 0)
        sum = 0;
      if (sum > out_image[i][j])
        out_image[i][j] = sum;
      sum = 0;
      for (a = -1; a < 2; a++) {
        for (b = -1; b < 2; b++) {
          sum = sum + image[i + a][j + b] * mask_1[a + 1][b + 1];
        }
      }
      if (sum > max)
        sum = max;
      if (sum < 0)
        sum = 0;
      if (sum > out_image[i][j])
        out_image[i][j] = sum;
      sum = 0;
      for (a = -1; a < 2; a++) {
        for (b = -1; b < 2; b++) {
          sum = sum + image[i + a][j + b] * mask_2[a + 1][b + 1];
        }
      }
      if (sum > max)
        sum = max;
      if (sum < 0)
        sum = 0;
      if (sum > out_image[i][j])
        out_image[i][j] = sum;
      sum = 0;
      for (a = -1; a < 2; a++) {
        for (b = -1; b < 2; b++) {
          sum = sum + image[i + a][j + b] * mask_3[a + 1][b + 1];
        }
      }
      if (sum > max)
        sum = max;
      if (sum < 0)
        sum = 0;
      if (sum > out_image[i][j])
        out_image[i][j] = sum;
      sum = 0;
      for (a = -1; a < 2; a++) {
        for (b = -1; b < 2; b++) {
          sum = sum + image[i + a][j + b] * mask_4[a + 1][b + 1];
        }
      }
      if (sum > max)
        sum = max;
      if (sum < 0)
        sum = 0;
      if (sum > out_image[i][j])
        out_image[i][j] = sum;
      sum = 0;
      for (a = -1; a < 2; a++) {
        for (b = -1; b < 2; b++) {
          sum = sum + image[i + a][j + b] * mask_5[a + 1][b + 1];
        }
      }
      if (sum > max)
        sum = max;
      if (sum < 0)
        sum = 0;
      if (sum > out_image[i][j])
        out_image[i][j] = sum;
      sum = 0;
      for (a = -1; a < 2; a++) {
        for (b = -1; b < 2; b++) {
          sum = sum + image[i + a][j + b] * mask_6[a + 1][b + 1];
        }
      }
      if (sum > max)
        sum = max;
      if (sum < 0)
        sum = 0;
      if (sum > out_image[i][j])
        out_image[i][j] = sum;
      sum = 0;
      for (a = -1; a < 2; a++) {
        for (b = -1; b < 2; b++) {
          sum = sum + image[i + a][j + b] * mask_7[a + 1][b + 1];
        }
      }
      if (sum > max)
        sum = max;
      if (sum < 0)
        sum = 0;
      if (sum > out_image[i][j])
        out_image[i][j] = sum;
    }
  }
  if (threshold == 1) {
    for (i = 0; i < rows; i++) {
      for (j = 0; j < cols; j++) {
        if (out_image[i][j] > high) {
          out_image[i][j] = new_hi;
        } else {
          out_image[i][j] = new_low;
        }
      }
    }
  }
  return (1);
}


x86 assembly (clang, -O0):
<perform_convolution>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1b0,%rsp
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
mov    -0x14(%rbp),%edi
lea    -0xb0(%rbp),%rsi
lea    -0xd0(%rbp),%rdx
lea    -0xf0(%rbp),%rcx
lea    -0x110(%rbp),%r8
lea    -0x130(%rbp),%r9
lea    -0x150(%rbp),%r11
lea    -0x170(%rbp),%r10
lea    -0x190(%rbp),%rax
mov    %r11,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
mov    $0x0,%al
call   1040 <setup_masks@plt>
movw   $0xfa,-0x196(%rbp)
movw   $0x10,-0x198(%rbp)
cmpq   $0x4,0x10(%rbp)
jne    11c7 <perform_convolution+0xa7>
movw   $0xa,-0x196(%rbp)
movw   $0x3,-0x198(%rbp)
movw   $0x0,-0x194(%rbp)
movw   $0xff,-0x192(%rbp)
cmpq   $0x4,0x10(%rbp)
jne    11ed <perform_convolution+0xcd>
movw   $0x10,-0x192(%rbp)
movl   $0x0,-0x8c(%rbp)
movslq -0x8c(%rbp),%rax
cmp    -0x20(%rbp),%rax
jge    126c <perform_convolution+0x14c>
movl   $0x0,-0x94(%rbp)
movslq -0x94(%rbp),%rax
cmp    -0x28(%rbp),%rax
jge    1253 <perform_convolution+0x133>
mov    -0x10(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x94(%rbp),%rcx
movw   $0x0,(%rax,%rcx,2)
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    1212 <perform_convolution+0xf2>
jmp    1258 <perform_convolution+0x138>
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    11f7 <perform_convolution+0xd7>
lea    0xd8d(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x8c(%rbp)
movslq -0x8c(%rbp),%rax
mov    -0x20(%rbp),%rcx
sub    $0x1,%rcx
cmp    %rcx,%rax
jge    1d8b <perform_convolution+0xc6b>
mov    -0x8c(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    12c7 <perform_convolution+0x1a7>
mov    -0x8c(%rbp),%esi
lea    0xd43(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x94(%rbp)
movslq -0x94(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    $0x1,%rcx
cmp    %rcx,%rax
jge    1d72 <perform_convolution+0xc52>
movl   $0x0,-0x98(%rbp)
movl   $0xffffffff,-0x84(%rbp)
ff ff ff
cmpl   $0x2,-0x84(%rbp)
jge    13b3 <perform_convolution+0x293>
movl   $0xffffffff,-0x88(%rbp)
ff ff ff
cmpl   $0x2,-0x88(%rbp)
jge    139a <perform_convolution+0x27a>
mov    -0x98(%rbp),%eax
mov    -0x8(%rbp),%rcx
mov    -0x8c(%rbp),%edx
add    -0x84(%rbp),%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,8),%rcx
mov    -0x94(%rbp),%edx
add    -0x88(%rbp),%edx
movslq %edx,%rdx
movswl (%rcx,%rdx,2),%ecx
mov    -0x84(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rsi
lea    -0xb0(%rbp),%rdx
imul   $0x6,%rsi,%rsi
add    %rsi,%rdx
mov    -0x88(%rbp),%esi
add    $0x1,%esi
movslq %esi,%rsi
movswl (%rdx,%rsi,2),%edx
imul   %edx,%ecx
add    %ecx,%eax
mov    %eax,-0x98(%rbp)
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    1314 <perform_convolution+0x1f4>
jmp    139f <perform_convolution+0x27f>
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    12fd <perform_convolution+0x1dd>
mov    -0x98(%rbp),%eax
movswl -0x192(%rbp),%ecx
cmp    %ecx,%eax
jle    13d5 <perform_convolution+0x2b5>
movswl -0x192(%rbp),%eax
mov    %eax,-0x98(%rbp)
cmpl   $0x0,-0x98(%rbp)
jge    13ec <perform_convolution+0x2cc>
movl   $0x0,-0x98(%rbp)
mov    -0x98(%rbp),%eax
mov    -0x10(%rbp),%rcx
movslq -0x8c(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
movslq -0x94(%rbp),%rdx
movswl (%rcx,%rdx,2),%ecx
cmp    %ecx,%eax
jle    1437 <perform_convolution+0x317>
mov    -0x98(%rbp),%eax
mov    %ax,%dx
mov    -0x10(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x94(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
movl   $0x0,-0x98(%rbp)
movl   $0xffffffff,-0x84(%rbp)
ff ff ff
cmpl   $0x2,-0x84(%rbp)
jge    1501 <perform_convolution+0x3e1>
movl   $0xffffffff,-0x88(%rbp)
ff ff ff
cmpl   $0x2,-0x88(%rbp)
jge    14e8 <perform_convolution+0x3c8>
mov    -0x98(%rbp),%eax
mov    -0x8(%rbp),%rcx
mov    -0x8c(%rbp),%edx
add    -0x84(%rbp),%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,8),%rcx
mov    -0x94(%rbp),%edx
add    -0x88(%rbp),%edx
movslq %edx,%rdx
movswl (%rcx,%rdx,2),%ecx
mov    -0x84(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rsi
lea    -0xd0(%rbp),%rdx
imul   $0x6,%rsi,%rsi
add    %rsi,%rdx
mov    -0x88(%rbp),%esi
add    $0x1,%esi
movslq %esi,%rsi
movswl (%rdx,%rsi,2),%edx
imul   %edx,%ecx
add    %ecx,%eax
mov    %eax,-0x98(%rbp)
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    1462 <perform_convolution+0x342>
jmp    14ed <perform_convolution+0x3cd>
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    144b <perform_convolution+0x32b>
mov    -0x98(%rbp),%eax
movswl -0x192(%rbp),%ecx
cmp    %ecx,%eax
jle    1523 <perform_convolution+0x403>
movswl -0x192(%rbp),%eax
mov    %eax,-0x98(%rbp)
cmpl   $0x0,-0x98(%rbp)
jge    153a <perform_convolution+0x41a>
movl   $0x0,-0x98(%rbp)
mov    -0x98(%rbp),%eax
mov    -0x10(%rbp),%rcx
movslq -0x8c(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
movslq -0x94(%rbp),%rdx
movswl (%rcx,%rdx,2),%ecx
cmp    %ecx,%eax
jle    1585 <perform_convolution+0x465>
mov    -0x98(%rbp),%eax
mov    %ax,%dx
mov    -0x10(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x94(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
movl   $0x0,-0x98(%rbp)
movl   $0xffffffff,-0x84(%rbp)
ff ff ff
cmpl   $0x2,-0x84(%rbp)
jge    164f <perform_convolution+0x52f>
movl   $0xffffffff,-0x88(%rbp)
ff ff ff
cmpl   $0x2,-0x88(%rbp)
jge    1636 <perform_convolution+0x516>
mov    -0x98(%rbp),%eax
mov    -0x8(%rbp),%rcx
mov    -0x8c(%rbp),%edx
add    -0x84(%rbp),%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,8),%rcx
mov    -0x94(%rbp),%edx
add    -0x88(%rbp),%edx
movslq %edx,%rdx
movswl (%rcx,%rdx,2),%ecx
mov    -0x84(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rsi
lea    -0xf0(%rbp),%rdx
imul   $0x6,%rsi,%rsi
add    %rsi,%rdx
mov    -0x88(%rbp),%esi
add    $0x1,%esi
movslq %esi,%rsi
movswl (%rdx,%rsi,2),%edx
imul   %edx,%ecx
add    %ecx,%eax
mov    %eax,-0x98(%rbp)
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    15b0 <perform_convolution+0x490>
jmp    163b <perform_convolution+0x51b>
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    1599 <perform_convolution+0x479>
mov    -0x98(%rbp),%eax
movswl -0x192(%rbp),%ecx
cmp    %ecx,%eax
jle    1671 <perform_convolution+0x551>
movswl -0x192(%rbp),%eax
mov    %eax,-0x98(%rbp)
cmpl   $0x0,-0x98(%rbp)
jge    1688 <perform_convolution+0x568>
movl   $0x0,-0x98(%rbp)
mov    -0x98(%rbp),%eax
mov    -0x10(%rbp),%rcx
movslq -0x8c(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
movslq -0x94(%rbp),%rdx
movswl (%rcx,%rdx,2),%ecx
cmp    %ecx,%eax
jle    16d3 <perform_convolution+0x5b3>
mov    -0x98(%rbp),%eax
mov    %ax,%dx
mov    -0x10(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x94(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
movl   $0x0,-0x98(%rbp)
movl   $0xffffffff,-0x84(%rbp)
ff ff ff
cmpl   $0x2,-0x84(%rbp)
jge    179d <perform_convolution+0x67d>
movl   $0xffffffff,-0x88(%rbp)
ff ff ff
cmpl   $0x2,-0x88(%rbp)
jge    1784 <perform_convolution+0x664>
mov    -0x98(%rbp),%eax
mov    -0x8(%rbp),%rcx
mov    -0x8c(%rbp),%edx
add    -0x84(%rbp),%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,8),%rcx
mov    -0x94(%rbp),%edx
add    -0x88(%rbp),%edx
movslq %edx,%rdx
movswl (%rcx,%rdx,2),%ecx
mov    -0x84(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rsi
lea    -0x110(%rbp),%rdx
imul   $0x6,%rsi,%rsi
add    %rsi,%rdx
mov    -0x88(%rbp),%esi
add    $0x1,%esi
movslq %esi,%rsi
movswl (%rdx,%rsi,2),%edx
imul   %edx,%ecx
add    %ecx,%eax
mov    %eax,-0x98(%rbp)
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    16fe <perform_convolution+0x5de>
jmp    1789 <perform_convolution+0x669>
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    16e7 <perform_convolution+0x5c7>
mov    -0x98(%rbp),%eax
movswl -0x192(%rbp),%ecx
cmp    %ecx,%eax
jle    17bf <perform_convolution+0x69f>
movswl -0x192(%rbp),%eax
mov    %eax,-0x98(%rbp)
cmpl   $0x0,-0x98(%rbp)
jge    17d6 <perform_convolution+0x6b6>
movl   $0x0,-0x98(%rbp)
mov    -0x98(%rbp),%eax
mov    -0x10(%rbp),%rcx
movslq -0x8c(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
movslq -0x94(%rbp),%rdx
movswl (%rcx,%rdx,2),%ecx
cmp    %ecx,%eax
jle    1821 <perform_convolution+0x701>
mov    -0x98(%rbp),%eax
mov    %ax,%dx
mov    -0x10(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x94(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
movl   $0x0,-0x98(%rbp)
movl   $0xffffffff,-0x84(%rbp)
ff ff ff
cmpl   $0x2,-0x84(%rbp)
jge    18eb <perform_convolution+0x7cb>
movl   $0xffffffff,-0x88(%rbp)
ff ff ff
cmpl   $0x2,-0x88(%rbp)
jge    18d2 <perform_convolution+0x7b2>
mov    -0x98(%rbp),%eax
mov    -0x8(%rbp),%rcx
mov    -0x8c(%rbp),%edx
add    -0x84(%rbp),%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,8),%rcx
mov    -0x94(%rbp),%edx
add    -0x88(%rbp),%edx
movslq %edx,%rdx
movswl (%rcx,%rdx,2),%ecx
mov    -0x84(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rsi
lea    -0x130(%rbp),%rdx
imul   $0x6,%rsi,%rsi
add    %rsi,%rdx
mov    -0x88(%rbp),%esi
add    $0x1,%esi
movslq %esi,%rsi
movswl (%rdx,%rsi,2),%edx
imul   %edx,%ecx
add    %ecx,%eax
mov    %eax,-0x98(%rbp)
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    184c <perform_convolution+0x72c>
jmp    18d7 <perform_convolution+0x7b7>
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    1835 <perform_convolution+0x715>
mov    -0x98(%rbp),%eax
movswl -0x192(%rbp),%ecx
cmp    %ecx,%eax
jle    190d <perform_convolution+0x7ed>
movswl -0x192(%rbp),%eax
mov    %eax,-0x98(%rbp)
cmpl   $0x0,-0x98(%rbp)
jge    1924 <perform_convolution+0x804>
movl   $0x0,-0x98(%rbp)
mov    -0x98(%rbp),%eax
mov    -0x10(%rbp),%rcx
movslq -0x8c(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
movslq -0x94(%rbp),%rdx
movswl (%rcx,%rdx,2),%ecx
cmp    %ecx,%eax
jle    196f <perform_convolution+0x84f>
mov    -0x98(%rbp),%eax
mov    %ax,%dx
mov    -0x10(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x94(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
movl   $0x0,-0x98(%rbp)
movl   $0xffffffff,-0x84(%rbp)
ff ff ff
cmpl   $0x2,-0x84(%rbp)
jge    1a39 <perform_convolution+0x919>
movl   $0xffffffff,-0x88(%rbp)
ff ff ff
cmpl   $0x2,-0x88(%rbp)
jge    1a20 <perform_convolution+0x900>
mov    -0x98(%rbp),%eax
mov    -0x8(%rbp),%rcx
mov    -0x8c(%rbp),%edx
add    -0x84(%rbp),%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,8),%rcx
mov    -0x94(%rbp),%edx
add    -0x88(%rbp),%edx
movslq %edx,%rdx
movswl (%rcx,%rdx,2),%ecx
mov    -0x84(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rsi
lea    -0x150(%rbp),%rdx
imul   $0x6,%rsi,%rsi
add    %rsi,%rdx
mov    -0x88(%rbp),%esi
add    $0x1,%esi
movslq %esi,%rsi
movswl (%rdx,%rsi,2),%edx
imul   %edx,%ecx
add    %ecx,%eax
mov    %eax,-0x98(%rbp)
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    199a <perform_convolution+0x87a>
jmp    1a25 <perform_convolution+0x905>
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    1983 <perform_convolution+0x863>
mov    -0x98(%rbp),%eax
movswl -0x192(%rbp),%ecx
cmp    %ecx,%eax
jle    1a5b <perform_convolution+0x93b>
movswl -0x192(%rbp),%eax
mov    %eax,-0x98(%rbp)
cmpl   $0x0,-0x98(%rbp)
jge    1a72 <perform_convolution+0x952>
movl   $0x0,-0x98(%rbp)
mov    -0x98(%rbp),%eax
mov    -0x10(%rbp),%rcx
movslq -0x8c(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
movslq -0x94(%rbp),%rdx
movswl (%rcx,%rdx,2),%ecx
cmp    %ecx,%eax
jle    1abd <perform_convolution+0x99d>
mov    -0x98(%rbp),%eax
mov    %ax,%dx
mov    -0x10(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x94(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
movl   $0x0,-0x98(%rbp)
movl   $0xffffffff,-0x84(%rbp)
ff ff ff
cmpl   $0x2,-0x84(%rbp)
jge    1b87 <perform_convolution+0xa67>
movl   $0xffffffff,-0x88(%rbp)
ff ff ff
cmpl   $0x2,-0x88(%rbp)
jge    1b6e <perform_convolution+0xa4e>
mov    -0x98(%rbp),%eax
mov    -0x8(%rbp),%rcx
mov    -0x8c(%rbp),%edx
add    -0x84(%rbp),%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,8),%rcx
mov    -0x94(%rbp),%edx
add    -0x88(%rbp),%edx
movslq %edx,%rdx
movswl (%rcx,%rdx,2),%ecx
mov    -0x84(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rsi
lea    -0x170(%rbp),%rdx
imul   $0x6,%rsi,%rsi
add    %rsi,%rdx
mov    -0x88(%rbp),%esi
add    $0x1,%esi
movslq %esi,%rsi
movswl (%rdx,%rsi,2),%edx
imul   %edx,%ecx
add    %ecx,%eax
mov    %eax,-0x98(%rbp)
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    1ae8 <perform_convolution+0x9c8>
jmp    1b73 <perform_convolution+0xa53>
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    1ad1 <perform_convolution+0x9b1>
mov    -0x98(%rbp),%eax
movswl -0x192(%rbp),%ecx
cmp    %ecx,%eax
jle    1ba9 <perform_convolution+0xa89>
movswl -0x192(%rbp),%eax
mov    %eax,-0x98(%rbp)
cmpl   $0x0,-0x98(%rbp)
jge    1bc0 <perform_convolution+0xaa0>
movl   $0x0,-0x98(%rbp)
mov    -0x98(%rbp),%eax
mov    -0x10(%rbp),%rcx
movslq -0x8c(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
movslq -0x94(%rbp),%rdx
movswl (%rcx,%rdx,2),%ecx
cmp    %ecx,%eax
jle    1c0b <perform_convolution+0xaeb>
mov    -0x98(%rbp),%eax
mov    %ax,%dx
mov    -0x10(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x94(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
movl   $0x0,-0x98(%rbp)
movl   $0xffffffff,-0x84(%rbp)
ff ff ff
cmpl   $0x2,-0x84(%rbp)
jge    1cd5 <perform_convolution+0xbb5>
movl   $0xffffffff,-0x88(%rbp)
ff ff ff
cmpl   $0x2,-0x88(%rbp)
jge    1cbc <perform_convolution+0xb9c>
mov    -0x98(%rbp),%eax
mov    -0x8(%rbp),%rcx
mov    -0x8c(%rbp),%edx
add    -0x84(%rbp),%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,8),%rcx
mov    -0x94(%rbp),%edx
add    -0x88(%rbp),%edx
movslq %edx,%rdx
movswl (%rcx,%rdx,2),%ecx
mov    -0x84(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rsi
lea    -0x190(%rbp),%rdx
imul   $0x6,%rsi,%rsi
add    %rsi,%rdx
mov    -0x88(%rbp),%esi
add    $0x1,%esi
movslq %esi,%rsi
movswl (%rdx,%rsi,2),%edx
imul   %edx,%ecx
add    %ecx,%eax
mov    %eax,-0x98(%rbp)
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    1c36 <perform_convolution+0xb16>
jmp    1cc1 <perform_convolution+0xba1>
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    1c1f <perform_convolution+0xaff>
mov    -0x98(%rbp),%eax
movswl -0x192(%rbp),%ecx
cmp    %ecx,%eax
jle    1cf7 <perform_convolution+0xbd7>
movswl -0x192(%rbp),%eax
mov    %eax,-0x98(%rbp)
cmpl   $0x0,-0x98(%rbp)
jge    1d0e <perform_convolution+0xbee>
movl   $0x0,-0x98(%rbp)
mov    -0x98(%rbp),%eax
mov    -0x10(%rbp),%rcx
movslq -0x8c(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
movslq -0x94(%rbp),%rdx
movswl (%rcx,%rdx,2),%ecx
cmp    %ecx,%eax
jle    1d59 <perform_convolution+0xc39>
mov    -0x98(%rbp),%eax
mov    %ax,%dx
mov    -0x10(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x94(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
jmp    1d5e <perform_convolution+0xc3e>
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    12d1 <perform_convolution+0x1b1>
jmp    1d77 <perform_convolution+0xc57>
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    1284 <perform_convolution+0x164>
cmpl   $0x1,-0x18(%rbp)
jne    1e6c <perform_convolution+0xd4c>
movl   $0x0,-0x8c(%rbp)
movslq -0x8c(%rbp),%rax
cmp    -0x20(%rbp),%rax
jge    1e67 <perform_convolution+0xd47>
movl   $0x0,-0x94(%rbp)
movslq -0x94(%rbp),%rax
cmp    -0x28(%rbp),%rax
jge    1e4e <perform_convolution+0xd2e>
mov    -0x10(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x94(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
cmp    0x18(%rbp),%eax
jle    1e14 <perform_convolution+0xcf4>
mov    -0x196(%rbp),%dx
mov    -0x10(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x94(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
jmp    1e35 <perform_convolution+0xd15>
mov    -0x198(%rbp),%dx
mov    -0x10(%rbp),%rax
movslq -0x8c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x94(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
jmp    1e3a <perform_convolution+0xd1a>
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    1dba <perform_convolution+0xc9a>
jmp    1e53 <perform_convolution+0xd33>
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    1d9f <perform_convolution+0xc7f>
jmp    1e6c <perform_convolution+0xd4c>
mov    $0x1,%eax
add    $0x1b0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<perform_convolution>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x178,%rsp
mov    %r9,%rbp
mov    %r8,%rbx
mov    %ecx,0x14c(%rsp)
mov    %edx,%eax
mov    %rsi,0x38(%rsp)
mov    %rdi,0x150(%rsp)
mov    0x1b0(%rsp),%r14
sub    $0x8,%rsp
lea    0x48(%rsp),%r15
lea    0x68(%rsp),%r11
lea    0x88(%rsp),%r10
lea    0x128(%rsp),%rsi
lea    0x108(%rsp),%rdx
lea    0xe8(%rsp),%rcx
lea    0xc8(%rsp),%r8
lea    0xa8(%rsp),%r9
mov    %eax,%edi
xor    %eax,%eax
push   %r15
push   %r11
push   %r10
call   1050 <setup_masks@plt>
add    $0x20,%rsp
cmp    $0x4,%r14
mov    $0x10,%eax
mov    $0xff,%r13d
cmove  %eax,%r13d
mov    $0xa,%ecx
mov    $0xfa,%edx
cmove  %ecx,%edx
mov    $0x3,%ecx
cmovne %eax,%ecx
test   %rbx,%rbx
jle    1d7e <perform_convolution+0xc4e>
mov    %rbp,%r12
add    %rbp,%r12
lea    -0x1(%rbx),%rax
mov    %ebx,%r14d
and    $0x3,%r14d
mov    %rax,0x160(%rsp)
cmp    $0x3,%rax
mov    %rbx,0x140(%rsp)
mov    %edx,0x30(%rsp)
mov    %ecx,0x2c(%rsp)
mov    %r13d,0x34(%rsp)
jae    1da3 <perform_convolution+0xc73>
xor    %ebx,%ebx
test   %r14,%r14
je     125e <perform_convolution+0x12e>
mov    0x38(%rsp),%rax
lea    (%rax,%rbx,8),%r15
xor    %ebx,%ebx
jmp    1249 <perform_convolution+0x119>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%rbx
cmp    %rbx,%r14
je     125e <perform_convolution+0x12e>
test   %rbp,%rbp
jle    1240 <perform_convolution+0x110>
mov    (%r15,%rbx,8),%rdi
xor    %esi,%esi
mov    %r12,%rdx
call   1040 <memset@plt>
jmp    1240 <perform_convolution+0x110>
lea    0xd9b(%rip),%rdi
xor    %eax,%eax
call   1030 <printf@plt>
cmpq   $0x3,0x140(%rsp)
jl     1afc <perform_convolution+0x9cc>
lea    -0x2(%rbp),%rax
mov    %rax,0x168(%rsp)
mov    $0x1,%ebx
mov    %rbp,0x170(%rsp)
jmp    12b6 <perform_convolution+0x186>
cs nopw 0x0(%rax,%rax,1)
mov    0x158(%rsp),%rbx
cmp    0x160(%rsp),%rbx
je     1afc <perform_convolution+0x9cc>
imul   $0xcccccccd,%ebx,%eax
ror    %eax
cmp    $0x19999999,%eax
jbe    1ad0 <perform_convolution+0x9a0>
cmp    $0x2,%rbp
jle    1aea <perform_convolution+0x9ba>
mov    0x38(%rsp),%rax
mov    (%rax,%rbx,8),%rax
mov    %rax,0x8(%rsp)
mov    0x150(%rsp),%rax
mov    -0x8(%rax,%rbx,8),%rcx
mov    %rcx,0x20(%rsp)
mov    (%rax,%rbx,8),%rcx
mov    %rcx,0x18(%rsp)
mov    0x8(%rax,%rbx,8),%rax
mov    %rax,0x10(%rsp)
add    $0x1,%rbx
mov    %rbx,0x158(%rsp)
xor    %edi,%edi
jmp    1332 <perform_convolution+0x202>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rdi
cmp    %rdi,0x168(%rsp)
je     12a0 <perform_convolution+0x170>
mov    0x20(%rsp),%rdx
movswl (%rdx,%rdi,2),%r9d
movswl 0x120(%rsp),%eax
imul   %r9d,%eax
movswl 0x2(%rdx,%rdi,2),%r10d
movswl 0x122(%rsp),%ecx
imul   %r10d,%ecx
add    %eax,%ecx
movswl 0x4(%rdx,%rdi,2),%r11d
movswl 0x124(%rsp),%edx
imul   %r11d,%edx
add    %ecx,%edx
mov    0x18(%rsp),%rax
movswl (%rax,%rdi,2),%ecx
movswl 0x126(%rsp),%esi
imul   %ecx,%esi
add    %edx,%esi
movswl 0x2(%rax,%rdi,2),%edx
movswl 0x128(%rsp),%ebp
imul   %edx,%ebp
add    %esi,%ebp
movswl 0x4(%rax,%rdi,2),%esi
movswl 0x12a(%rsp),%ebx
imul   %esi,%ebx
add    %ebp,%ebx
mov    0x10(%rsp),%rax
movswl (%rax,%rdi,2),%r14d
movswl 0x12c(%rsp),%ebp
imul   %r14d,%ebp
add    %ebx,%ebp
movswl 0x2(%rax,%rdi,2),%r12d
movswl 0x12e(%rsp),%ebx
imul   %r12d,%ebx
add    %ebp,%ebx
movswl 0x4(%rax,%rdi,2),%r15d
movswl 0x130(%rsp),%ebp
imul   %r15d,%ebp
add    %ebx,%ebp
mov    %r13d,%eax
cmp    %r13d,%ebp
jg     13f5 <perform_convolution+0x2c5>
mov    %ebp,%r13d
test   %r13d,%r13d
jns    13fd <perform_convolution+0x2cd>
xor    %r13d,%r13d
mov    0x8(%rsp),%rax
movswl 0x2(%rax,%rdi,2),%r8d
cmp    %r8d,%r13d
jle    145b <perform_convolution+0x32b>
mov    0x8(%rsp),%rax
mov    %r13w,0x2(%rax,%rdi,2)
mov    0x20(%rsp),%rax
movswl (%rax,%rdi,2),%r9d
movswl 0x2(%rax,%rdi,2),%r10d
movswl 0x4(%rax,%rdi,2),%r11d
mov    0x18(%rsp),%rax
movswl (%rax,%rdi,2),%ecx
movswl 0x2(%rax,%rdi,2),%edx
movswl 0x4(%rax,%rdi,2),%esi
mov    0x10(%rsp),%rax
movswl (%rax,%rdi,2),%r14d
movswl 0x2(%rax,%rdi,2),%r12d
movswl 0x4(%rax,%rdi,2),%r15d
movswl %r13w,%r8d
movswl 0x100(%rsp),%ebx
imul   %r9d,%ebx
movswl 0x102(%rsp),%ebp
imul   %r10d,%ebp
add    %ebx,%ebp
movswl 0x104(%rsp),%ebx
imul   %r11d,%ebx
add    %ebp,%ebx
movswl 0x106(%rsp),%ebp
imul   %ecx,%ebp
add    %ebx,%ebp
movswl 0x108(%rsp),%ebx
imul   %edx,%ebx
add    %ebp,%ebx
movswl 0x10a(%rsp),%ebp
imul   %esi,%ebp
add    %ebx,%ebp
movswl 0x10c(%rsp),%ebx
imul   %r14d,%ebx
add    %ebp,%ebx
movswl 0x10e(%rsp),%eax
imul   %r12d,%eax
add    %ebx,%eax
movswl 0x110(%rsp),%ebp
imul   %r15d,%ebp
add    %eax,%ebp
mov    0x34(%rsp),%r13d
mov    %r13d,%ebx
cmp    %r13d,%ebp
jle    1a10 <perform_convolution+0x8e0>
test   %ebx,%ebx
js     1a1a <perform_convolution+0x8ea>
cmp    %r8d,%ebx
jle    153f <perform_convolution+0x40f>
mov    0x8(%rsp),%rax
mov    %bx,0x2(%rax,%rdi,2)
mov    0x20(%rsp),%rax
movswl (%rax,%rdi,2),%r9d
movswl 0x2(%rax,%rdi,2),%r10d
movswl 0x4(%rax,%rdi,2),%r11d
mov    0x18(%rsp),%rax
movswl (%rax,%rdi,2),%ecx
movswl 0x2(%rax,%rdi,2),%edx
movswl 0x4(%rax,%rdi,2),%esi
mov    0x10(%rsp),%rax
movswl (%rax,%rdi,2),%r14d
movswl 0x2(%rax,%rdi,2),%r12d
movswl 0x4(%rax,%rdi,2),%r15d
movswl %bx,%r8d
movswl 0xe0(%rsp),%eax
imul   %r9d,%eax
movswl 0xe2(%rsp),%ebx
imul   %r10d,%ebx
add    %eax,%ebx
movswl 0xe4(%rsp),%eax
imul   %r11d,%eax
add    %ebx,%eax
movswl 0xe6(%rsp),%ebx
imul   %ecx,%ebx
add    %eax,%ebx
movswl 0xe8(%rsp),%eax
imul   %edx,%eax
add    %ebx,%eax
movswl 0xea(%rsp),%ebx
imul   %esi,%ebx
add    %eax,%ebx
movswl 0xec(%rsp),%eax
imul   %r14d,%eax
add    %ebx,%eax
movswl 0xee(%rsp),%ebp
imul   %r12d,%ebp
add    %eax,%ebp
movswl 0xf0(%rsp),%ebx
imul   %r15d,%ebx
add    %ebp,%ebx
mov    %r13d,%ebp
cmp    %r13d,%ebx
jle    1a30 <perform_convolution+0x900>
test   %ebp,%ebp
js     1a3a <perform_convolution+0x90a>
cmp    %r8d,%ebp
jle    161e <perform_convolution+0x4ee>
mov    0x8(%rsp),%rax
mov    %bp,0x2(%rax,%rdi,2)
mov    0x20(%rsp),%rax
movswl (%rax,%rdi,2),%r9d
movswl 0x2(%rax,%rdi,2),%r10d
movswl 0x4(%rax,%rdi,2),%r11d
mov    0x18(%rsp),%rax
movswl (%rax,%rdi,2),%ecx
movswl 0x2(%rax,%rdi,2),%edx
movswl 0x4(%rax,%rdi,2),%esi
mov    0x10(%rsp),%rax
movswl (%rax,%rdi,2),%r14d
movswl 0x2(%rax,%rdi,2),%r12d
movswl 0x4(%rax,%rdi,2),%r15d
movswl %bp,%r8d
movswl 0xc0(%rsp),%eax
imul   %r9d,%eax
movswl 0xc2(%rsp),%ebx
imul   %r10d,%ebx
add    %eax,%ebx
movswl 0xc4(%rsp),%eax
imul   %r11d,%eax
add    %ebx,%eax
movswl 0xc6(%rsp),%ebx
imul   %ecx,%ebx
add    %eax,%ebx
movswl 0xc8(%rsp),%eax
imul   %edx,%eax
add    %ebx,%eax
movswl 0xca(%rsp),%ebx
imul   %esi,%ebx
add    %eax,%ebx
movswl 0xcc(%rsp),%eax
imul   %r14d,%eax
add    %ebx,%eax
movswl 0xce(%rsp),%ebp
imul   %r12d,%ebp
add    %eax,%ebp
movswl 0xd0(%rsp),%ebx
imul   %r15d,%ebx
add    %ebp,%ebx
mov    %r13d,%ebp
cmp    %r13d,%ebx
jle    1a50 <perform_convolution+0x920>
test   %ebp,%ebp
js     1a5a <perform_convolution+0x92a>
cmp    %r8d,%ebp
jle    16fd <perform_convolution+0x5cd>
mov    0x8(%rsp),%rax
mov    %bp,0x2(%rax,%rdi,2)
mov    0x20(%rsp),%rax
movswl (%rax,%rdi,2),%r9d
movswl 0x2(%rax,%rdi,2),%r10d
movswl 0x4(%rax,%rdi,2),%r11d
mov    0x18(%rsp),%rax
movswl (%rax,%rdi,2),%ecx
movswl 0x2(%rax,%rdi,2),%edx
movswl 0x4(%rax,%rdi,2),%esi
mov    0x10(%rsp),%rax
movswl (%rax,%rdi,2),%r14d
movswl 0x2(%rax,%rdi,2),%r12d
movswl 0x4(%rax,%rdi,2),%r15d
movswl %bp,%r8d
movswl 0xa0(%rsp),%eax
imul   %r9d,%eax
movswl 0xa2(%rsp),%ebx
imul   %r10d,%ebx
add    %eax,%ebx
movswl 0xa4(%rsp),%eax
imul   %r11d,%eax
add    %ebx,%eax
movswl 0xa6(%rsp),%ebx
imul   %ecx,%ebx
add    %eax,%ebx
movswl 0xa8(%rsp),%eax
imul   %edx,%eax
add    %ebx,%eax
movswl 0xaa(%rsp),%ebx
imul   %esi,%ebx
add    %eax,%ebx
movswl 0xac(%rsp),%eax
imul   %r14d,%eax
add    %ebx,%eax
movswl 0xae(%rsp),%ebp
imul   %r12d,%ebp
add    %eax,%ebp
movswl 0xb0(%rsp),%ebx
imul   %r15d,%ebx
add    %ebp,%ebx
mov    %r13d,%ebp
cmp    %r13d,%ebx
jle    1a70 <perform_convolution+0x940>
test   %ebp,%ebp
js     1a7a <perform_convolution+0x94a>
cmp    %r8d,%ebp
jle    17dc <perform_convolution+0x6ac>
mov    0x8(%rsp),%rax
mov    %bp,0x2(%rax,%rdi,2)
mov    0x20(%rsp),%rax
movswl (%rax,%rdi,2),%r9d
movswl 0x2(%rax,%rdi,2),%r10d
movswl 0x4(%rax,%rdi,2),%r11d
mov    0x18(%rsp),%rax
movswl (%rax,%rdi,2),%ecx
movswl 0x2(%rax,%rdi,2),%edx
movswl 0x4(%rax,%rdi,2),%esi
mov    0x10(%rsp),%rax
movswl (%rax,%rdi,2),%r14d
movswl 0x2(%rax,%rdi,2),%r12d
movswl 0x4(%rax,%rdi,2),%r15d
movswl %bp,%r8d
movswl 0x80(%rsp),%eax
imul   %r9d,%eax
movswl 0x82(%rsp),%ebx
imul   %r10d,%ebx
add    %eax,%ebx
movswl 0x84(%rsp),%eax
imul   %r11d,%eax
add    %ebx,%eax
movswl 0x86(%rsp),%ebx
imul   %ecx,%ebx
add    %eax,%ebx
movswl 0x88(%rsp),%eax
imul   %edx,%eax
add    %ebx,%eax
movswl 0x8a(%rsp),%ebx
imul   %esi,%ebx
add    %eax,%ebx
movswl 0x8c(%rsp),%eax
imul   %r14d,%eax
add    %ebx,%eax
movswl 0x8e(%rsp),%ebp
imul   %r12d,%ebp
add    %eax,%ebp
movswl 0x90(%rsp),%ebx
imul   %r15d,%ebx
add    %ebp,%ebx
mov    %r13d,%ebp
cmp    %r13d,%ebx
jle    1a90 <perform_convolution+0x960>
test   %ebp,%ebp
js     1a9a <perform_convolution+0x96a>
cmp    %r8d,%ebp
jle    18bb <perform_convolution+0x78b>
mov    0x8(%rsp),%rax
mov    %bp,0x2(%rax,%rdi,2)
mov    0x20(%rsp),%rax
movswl (%rax,%rdi,2),%r9d
movswl 0x2(%rax,%rdi,2),%r10d
movswl 0x4(%rax,%rdi,2),%r11d
mov    0x18(%rsp),%rax
movswl (%rax,%rdi,2),%ecx
movswl 0x2(%rax,%rdi,2),%edx
movswl 0x4(%rax,%rdi,2),%esi
mov    0x10(%rsp),%rax
movswl (%rax,%rdi,2),%r14d
movswl 0x2(%rax,%rdi,2),%r12d
movswl 0x4(%rax,%rdi,2),%r15d
movswl %bp,%r8d
movswl 0x60(%rsp),%eax
imul   %r9d,%eax
movswl 0x62(%rsp),%ebx
imul   %r10d,%ebx
add    %eax,%ebx
movswl 0x64(%rsp),%eax
imul   %r11d,%eax
add    %ebx,%eax
movswl 0x66(%rsp),%ebx
imul   %ecx,%ebx
add    %eax,%ebx
movswl 0x68(%rsp),%eax
imul   %edx,%eax
add    %ebx,%eax
movswl 0x6a(%rsp),%ebx
imul   %esi,%ebx
add    %eax,%ebx
movswl 0x6c(%rsp),%eax
imul   %r14d,%eax
add    %ebx,%eax
movswl 0x6e(%rsp),%ebp
imul   %r12d,%ebp
add    %eax,%ebp
movswl 0x70(%rsp),%ebx
imul   %r15d,%ebx
add    %ebp,%ebx
mov    %r13d,%ebp
cmp    %r13d,%ebx
jle    1ab0 <perform_convolution+0x980>
test   %ebp,%ebp
js     1aba <perform_convolution+0x98a>
cmp    %r8d,%ebp
jle    197f <perform_convolution+0x84f>
mov    0x8(%rsp),%rax
mov    %bp,0x2(%rax,%rdi,2)
mov    0x20(%rsp),%rax
movswl (%rax,%rdi,2),%r9d
movswl 0x2(%rax,%rdi,2),%r10d
movswl 0x4(%rax,%rdi,2),%r11d
mov    0x10(%rsp),%rax
movswl (%rax,%rdi,2),%r14d
movswl 0x2(%rax,%rdi,2),%r12d
movswl 0x4(%rax,%rdi,2),%r15d
mov    0x18(%rsp),%rax
movswl (%rax,%rdi,2),%ecx
movswl 0x2(%rax,%rdi,2),%edx
movswl 0x4(%rax,%rdi,2),%esi
movswl %bp,%r8d
movswl 0x40(%rsp),%eax
imul   %r9d,%eax
movswl 0x42(%rsp),%ebp
imul   %r10d,%ebp
add    %eax,%ebp
movswl 0x44(%rsp),%eax
imul   %r11d,%eax
add    %ebp,%eax
movswl 0x46(%rsp),%ebp
imul   %ecx,%ebp
add    %eax,%ebp
movswl 0x48(%rsp),%eax
imul   %edx,%eax
add    %ebp,%eax
movswl 0x4a(%rsp),%ecx
imul   %esi,%ecx
add    %eax,%ecx
movswl 0x4c(%rsp),%eax
imul   %r14d,%eax
add    %ecx,%eax
movswl 0x4e(%rsp),%edx
imul   %r12d,%edx
add    %eax,%edx
movswl 0x50(%rsp),%ecx
imul   %r15d,%ecx
add    %edx,%ecx
mov    %r13d,%eax
cmp    %r13d,%ecx
jg     19e7 <perform_convolution+0x8b7>
mov    %ecx,%eax
test   %eax,%eax
mov    0x170(%rsp),%rbp
jns    19f5 <perform_convolution+0x8c5>
xor    %eax,%eax
cmp    %r8d,%eax
jle    1320 <perform_convolution+0x1f0>
mov    0x8(%rsp),%rcx
mov    %ax,0x2(%rcx,%rdi,2)
jmp    1320 <perform_convolution+0x1f0>
nopl   (%rax)
mov    %ebp,%ebx
test   %ebx,%ebx
jns    14ed <perform_convolution+0x3bd>
xor    %ebx,%ebx
cmp    %r8d,%ebx
jg     14f2 <perform_convolution+0x3c2>
jmp    153f <perform_convolution+0x40f>
nopw   0x0(%rax,%rax,1)
mov    %ebx,%ebp
test   %ebp,%ebp
jns    15cc <perform_convolution+0x49c>
xor    %ebp,%ebp
cmp    %r8d,%ebp
jg     15d1 <perform_convolution+0x4a1>
jmp    161e <perform_convolution+0x4ee>
nopw   0x0(%rax,%rax,1)
mov    %ebx,%ebp
test   %ebp,%ebp
jns    16ab <perform_convolution+0x57b>
xor    %ebp,%ebp
cmp    %r8d,%ebp
jg     16b0 <perform_convolution+0x580>
jmp    16fd <perform_convolution+0x5cd>
nopw   0x0(%rax,%rax,1)
mov    %ebx,%ebp
test   %ebp,%ebp
jns    178a <perform_convolution+0x65a>
xor    %ebp,%ebp
cmp    %r8d,%ebp
jg     178f <perform_convolution+0x65f>
jmp    17dc <perform_convolution+0x6ac>
nopw   0x0(%rax,%rax,1)
mov    %ebx,%ebp
test   %ebp,%ebp
jns    1869 <perform_convolution+0x739>
xor    %ebp,%ebp
cmp    %r8d,%ebp
jg     186e <perform_convolution+0x73e>
jmp    18bb <perform_convolution+0x78b>
nopw   0x0(%rax,%rax,1)
mov    %ebx,%ebp
test   %ebp,%ebp
jns    192d <perform_convolution+0x7fd>
xor    %ebp,%ebp
cmp    %r8d,%ebp
jg     1932 <perform_convolution+0x802>
jmp    197f <perform_convolution+0x84f>
nopw   0x0(%rax,%rax,1)
lea    0x52c(%rip),%rdi
mov    %ebx,%esi
xor    %eax,%eax
call   1030 <printf@plt>
cmp    $0x2,%rbp
jg     12d3 <perform_convolution+0x1a3>
add    $0x1,%rbx
cmp    0x160(%rsp),%rbx
jne    12b6 <perform_convolution+0x186>
cmpl   $0x1,0x14c(%rsp)
01
jne    1d8c <perform_convolution+0xc5c>
cmpq   $0x0,0x140(%rsp)
jle    1d8c <perform_convolution+0xc5c>
mov    0x1b8(%rsp),%r14d
lea    -0x10(%rbp),%r9
mov    %r9,%r10
shr    $0x4,%r10
add    $0x1,%r10
mov    %rbp,%r11
and    $0xfffffffffffffff0,%r11
movd   %r14d,%xmm0
pshufd $0x0,%xmm0,%xmm0
movd   0x30(%rsp),%xmm1
pshuflw $0x0,%xmm1,%xmm1
pshufd $0x0,%xmm1,%xmm8
movd   0x2c(%rsp),%xmm2
pshuflw $0x0,%xmm2,%xmm2
pshufd $0x0,%xmm2,%xmm2
mov    %r10,%r8
and    $0xfffffffffffffffe,%r8
xor    %edx,%edx
jmp    1b82 <perform_convolution+0xa52>
nopl   (%rax)
add    $0x1,%rdx
cmp    0x140(%rsp),%rdx
je     1d8c <perform_convolution+0xc5c>
test   %rbp,%rbp
jle    1b70 <perform_convolution+0xa40>
mov    0x38(%rsp),%rcx
mov    (%rcx,%rdx,8),%rbx
cmp    $0x10,%rbp
jae    1bb0 <perform_convolution+0xa80>
xor    %ecx,%ecx
mov    0x30(%rsp),%esi
mov    0x2c(%rsp),%eax
jmp    1d60 <perform_convolution+0xc30>
cs nopw 0x0(%rax,%rax,1)
nop
cmp    $0x10,%r9
jae    1bbd <perform_convolution+0xa8d>
xor    %edi,%edi
jmp    1cc8 <perform_convolution+0xb98>
mov    %r8,%rcx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movdqu (%rbx,%rdi,2),%xmm6
movdqu 0x10(%rbx,%rdi,2),%xmm7
movdqu 0x20(%rbx,%rdi,2),%xmm4
movdqu 0x30(%rbx,%rdi,2),%xmm3
punpcklwd %xmm6,%xmm5
psrad  $0x10,%xmm5
punpckhwd %xmm6,%xmm6
psrad  $0x10,%xmm6
punpcklwd %xmm7,%xmm1
psrad  $0x10,%xmm1
punpckhwd %xmm7,%xmm7
psrad  $0x10,%xmm7
pcmpgtd %xmm0,%xmm6
pcmpgtd %xmm0,%xmm5
packssdw %xmm6,%xmm5
pcmpgtd %xmm0,%xmm7
pcmpgtd %xmm0,%xmm1
packssdw %xmm7,%xmm1
movdqa %xmm8,%xmm6
pand   %xmm5,%xmm6
pandn  %xmm2,%xmm5
por    %xmm6,%xmm5
movdqa %xmm8,%xmm6
pand   %xmm1,%xmm6
pandn  %xmm2,%xmm1
por    %xmm6,%xmm1
movdqu %xmm5,(%rbx,%rdi,2)
movdqu %xmm1,0x10(%rbx,%rdi,2)
punpcklwd %xmm4,%xmm5
psrad  $0x10,%xmm5
punpckhwd %xmm4,%xmm1
psrad  $0x10,%xmm1
punpcklwd %xmm3,%xmm4
psrad  $0x10,%xmm4
punpckhwd %xmm3,%xmm3
psrad  $0x10,%xmm3
pcmpgtd %xmm0,%xmm1
pcmpgtd %xmm0,%xmm5
packssdw %xmm1,%xmm5
pcmpgtd %xmm0,%xmm3
pcmpgtd %xmm0,%xmm4
packssdw %xmm3,%xmm4
movdqa %xmm8,%xmm1
pand   %xmm5,%xmm1
pandn  %xmm2,%xmm5
por    %xmm1,%xmm5
movdqa %xmm8,%xmm1
pand   %xmm4,%xmm1
pandn  %xmm2,%xmm4
por    %xmm1,%xmm4
movdqu %xmm5,0x20(%rbx,%rdi,2)
movdqu %xmm4,0x30(%rbx,%rdi,2)
add    $0x20,%rdi
add    $0xfffffffffffffffe,%rcx
jne    1bd0 <perform_convolution+0xaa0>
test   $0x1,%r10b
je     1d42 <perform_convolution+0xc12>
movdqu (%rbx,%rdi,2),%xmm1
movdqu 0x10(%rbx,%rdi,2),%xmm4
punpcklwd %xmm1,%xmm3
psrad  $0x10,%xmm3
punpckhwd %xmm1,%xmm1
psrad  $0x10,%xmm1
punpcklwd %xmm4,%xmm5
psrad  $0x10,%xmm5
punpckhwd %xmm4,%xmm4
psrad  $0x10,%xmm4
pcmpgtd %xmm0,%xmm1
pcmpgtd %xmm0,%xmm3
packssdw %xmm1,%xmm3
pcmpgtd %xmm0,%xmm4
pcmpgtd %xmm0,%xmm5
packssdw %xmm4,%xmm5
movdqa %xmm8,%xmm1
pand   %xmm3,%xmm1
pandn  %xmm2,%xmm3
por    %xmm1,%xmm3
movdqa %xmm8,%xmm1
pand   %xmm5,%xmm1
pandn  %xmm2,%xmm5
por    %xmm1,%xmm5
movdqu %xmm3,(%rbx,%rdi,2)
movdqu %xmm5,0x10(%rbx,%rdi,2)
mov    %r11,%rcx
cmp    %rbp,%r11
mov    0x30(%rsp),%esi
mov    0x2c(%rsp),%eax
je     1b70 <perform_convolution+0xa40>
cs nopw 0x0(%rax,%rax,1)
movswl (%rbx,%rcx,2),%edi
cmp    %r14d,%edi
mov    %eax,%edi
cmovg  %esi,%edi
mov    %di,(%rbx,%rcx,2)
add    $0x1,%rcx
cmp    %rcx,%rbp
jne    1d60 <perform_convolution+0xc30>
jmp    1b70 <perform_convolution+0xa40>
lea    0x27b(%rip),%rdi
xor    %eax,%eax
call   1030 <printf@plt>
mov    $0x1,%eax
add    $0x178,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %rbx,%r15
and    $0xfffffffffffffffc,%r15
xor    %ebx,%ebx
jmp    1dbd <perform_convolution+0xc8d>
xchg   %ax,%ax
add    $0x4,%rbx
cmp    %rbx,%r15
je     1221 <perform_convolution+0xf1>
test   %rbp,%rbp
jle    1db0 <perform_convolution+0xc80>
mov    0x38(%rsp),%r13
mov    0x0(%r13,%rbx,8),%rdi
xor    %esi,%esi
mov    %r12,%rdx
call   1040 <memset@plt>
mov    0x8(%r13,%rbx,8),%rdi
xor    %esi,%esi
mov    %r12,%rdx
call   1040 <memset@plt>
mov    0x10(%r13,%rbx,8),%rdi
xor    %esi,%esi
mov    %r12,%rdx
call   1040 <memset@plt>
mov    0x18(%r13,%rbx,8),%rdi
mov    0x34(%rsp),%r13d
xor    %esi,%esi
mov    %r12,%rdx
call   1040 <memset@plt>
jmp    1db0 <perform_convolution+0xc80>

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

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