int thinning(the_image, out_image, value, threshold, once_only, rows, cols)
int once_only;
short **the_image, **out_image, threshold, value;
long cols, rows;
{
  int a, b, big_count, count, i, j, k, not_finished;
  for (i = 0; i < rows; i++)
    for (j = 0; j < cols; j++)
      out_image[i][j] = the_image[i][j];
  not_finished = 1;
  while (not_finished) {
    if (once_only == 1)
      not_finished = 0;
    big_count = 0;
    printf("\n");
    for (i = 1; i < rows - 1; i++) {
      if ((i % 10) == 0)
        printf("%3d", i);
      for (j = 1; j < cols - 1; j++) {
        if (the_image[i][j - 1] == 0 && the_image[i][j] == value) {
          count = 0;
          for (a = -1; a <= 1; a++) {
            for (b = -1; b <= 1; b++) {
              if (the_image[i + a][j + b] == 0)
                count++;
            }
          }
          if (count > threshold) {
            if (can_thin(the_image, i, j, value)) {
              out_image[i][j] = 0;
              big_count++;
            }
          }
        }
      }
    }
    for (i = 0; i < rows; i++)
      for (j = 0; j < cols; j++)
        the_image[i][j] = out_image[i][j];
    printf("\n");
    for (i = 1; i < rows - 1; i++) {
      if ((i % 10) == 0)
        printf("%3d", i);
      for (j = 1; j < cols - 1; j++) {
        if (the_image[i][j + 1] == 0 && the_image[i][j] == value) {
          count = 0;
          for (a = -1; a <= 1; a++) {
            for (b = -1; b <= 1; b++) {
              if (the_image[i + a][j + b] == 0)
                count++;
            }
          }
          if (count > threshold) {
            if (can_thin(the_image, i, j, value)) {
              out_image[i][j] = 0;
              big_count++;
            }
          }
        }
      }
    }
    for (i = 0; i < rows; i++)
      for (j = 0; j < cols; j++)
        the_image[i][j] = out_image[i][j];
    printf("\n");
    for (j = 1; j < cols - 1; j++) {
      if ((j % 10) == 0)
        printf("%3d", j);
      for (i = 1; i < rows - 1; i++) {
        if (the_image[i - 1][j] == 0 && the_image[i][j] == value) {
          count = 0;
          for (a = -1; a <= 1; a++) {
            for (b = -1; b <= 1; b++) {
              if (the_image[i + a][j + b] == 0)
                count++;
            }
          }
          if (count > threshold) {
            if (can_thin(the_image, i, j, value)) {
              out_image[i][j] = 0;
              big_count++;
            }
          }
        }
      }
    }
    for (i = 0; i < rows; i++)
      for (j = 0; j < cols; j++)
        the_image[i][j] = out_image[i][j];
    printf("\n");
    for (j = 1; j < cols - 1; j++) {
      if ((j % 10) == 0)
        printf("%3d", j);
      for (i = 1; i < rows - 1; i++) {
        if (the_image[i + 1][j] == 0 && the_image[i][j] == value) {
          count = 0;
          for (a = -1; a <= 1; a++) {
            for (b = -1; b <= 1; b++) {
              if (the_image[i + a][j + b] == 0)
                count++;
            }
          }
          if (count > threshold) {
            if (can_thin(the_image, i, j, value)) {
              out_image[i][j] = 0;
              big_count++;
            }
          }
        }
      }
    }
    for (i = 0; i < rows; i++)
      for (j = 0; j < cols; j++)
        the_image[i][j] = out_image[i][j];
    printf("\n\nThinned %d pixels", big_count);
    if (big_count == 0)
      not_finished = 0;
    else {
      for (i = 0; i < rows; i++)
        for (j = 0; j < cols; j++)
          the_image[i][j] = out_image[i][j];
    }
  }
  return (1);
}


x86 assembly (clang, -O0):
<thinning>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %ecx,%eax
mov    0x10(%rbp),%rcx
mov    %dx,%cx
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %cx,-0x12(%rbp)
mov    %ax,-0x14(%rbp)
mov    %r8d,-0x18(%rbp)
mov    %r9,-0x20(%rbp)
movl   $0x0,-0x34(%rbp)
movslq -0x34(%rbp),%rax
cmp    -0x20(%rbp),%rax
jge    11bc <thinning+0x9c>
movl   $0x0,-0x38(%rbp)
movslq -0x38(%rbp),%rax
cmp    0x10(%rbp),%rax
jge    11a9 <thinning+0x89>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,2),%dx
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1165 <thinning+0x45>
jmp    11ae <thinning+0x8e>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1150 <thinning+0x30>
movl   $0x1,-0x40(%rbp)
cmpl   $0x0,-0x40(%rbp)
je     1af5 <thinning+0x9d5>
cmpl   $0x1,-0x18(%rbp)
jne    11de <thinning+0xbe>
movl   $0x0,-0x40(%rbp)
movl   $0x0,-0x2c(%rbp)
lea    0xe14(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x1,-0x34(%rbp)
movslq -0x34(%rbp),%rax
mov    -0x20(%rbp),%rcx
sub    $0x1,%rcx
cmp    %rcx,%rax
jge    138d <thinning+0x26d>
mov    -0x34(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    1234 <thinning+0x114>
mov    -0x34(%rbp),%esi
lea    0xdd5(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x1,-0x38(%rbp)
movslq -0x38(%rbp),%rax
mov    0x10(%rbp),%rcx
sub    $0x1,%rcx
cmp    %rcx,%rax
jge    137a <thinning+0x25a>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movswl (%rax,%rcx,2),%eax
cmp    $0x0,%eax
jne    1367 <thinning+0x247>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
movswl -0x12(%rbp),%ecx
cmp    %ecx,%eax
jne    1367 <thinning+0x247>
movl   $0x0,-0x30(%rbp)
movl   $0xffffffff,-0x24(%rbp)
cmpl   $0x1,-0x24(%rbp)
jg     1311 <thinning+0x1f1>
movl   $0xffffffff,-0x28(%rbp)
cmpl   $0x1,-0x28(%rbp)
jg     12fe <thinning+0x1de>
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movswl (%rax,%rcx,2),%eax
cmp    $0x0,%eax
jne    12eb <thinning+0x1cb>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    12f0 <thinning+0x1d0>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    12b1 <thinning+0x191>
jmp    1303 <thinning+0x1e3>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    12a0 <thinning+0x180>
mov    -0x30(%rbp),%eax
movswl -0x14(%rbp),%ecx
cmp    %ecx,%eax
jle    1362 <thinning+0x242>
mov    -0x8(%rbp),%rdi
mov    -0x34(%rbp),%esi
mov    -0x38(%rbp),%edx
movswl -0x12(%rbp),%ecx
mov    $0x0,%al
call   1030 <can_thin@plt>
cmp    $0x0,%eax
je     135d <thinning+0x23d>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movw   $0x0,(%rax,%rcx,2)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1362 <thinning+0x242>
jmp    1367 <thinning+0x247>
jmp    136c <thinning+0x24c>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    123b <thinning+0x11b>
jmp    137f <thinning+0x25f>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11fa <thinning+0xda>
movl   $0x0,-0x34(%rbp)
movslq -0x34(%rbp),%rax
cmp    -0x20(%rbp),%rax
jge    1400 <thinning+0x2e0>
movl   $0x0,-0x38(%rbp)
movslq -0x38(%rbp),%rax
cmp    0x10(%rbp),%rax
jge    13ed <thinning+0x2cd>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,2),%dx
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    13a9 <thinning+0x289>
jmp    13f2 <thinning+0x2d2>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1394 <thinning+0x274>
lea    0xbf9(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x1,-0x34(%rbp)
movslq -0x34(%rbp),%rax
mov    -0x20(%rbp),%rcx
sub    $0x1,%rcx
cmp    %rcx,%rax
jge    15a8 <thinning+0x488>
mov    -0x34(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    144f <thinning+0x32f>
mov    -0x34(%rbp),%esi
lea    0xbba(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x1,-0x38(%rbp)
movslq -0x38(%rbp),%rax
mov    0x10(%rbp),%rcx
sub    $0x1,%rcx
cmp    %rcx,%rax
jge    1595 <thinning+0x475>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movswl (%rax,%rcx,2),%eax
cmp    $0x0,%eax
jne    1582 <thinning+0x462>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
movswl -0x12(%rbp),%ecx
cmp    %ecx,%eax
jne    1582 <thinning+0x462>
movl   $0x0,-0x30(%rbp)
movl   $0xffffffff,-0x24(%rbp)
cmpl   $0x1,-0x24(%rbp)
jg     152c <thinning+0x40c>
movl   $0xffffffff,-0x28(%rbp)
cmpl   $0x1,-0x28(%rbp)
jg     1519 <thinning+0x3f9>
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movswl (%rax,%rcx,2),%eax
cmp    $0x0,%eax
jne    1506 <thinning+0x3e6>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    150b <thinning+0x3eb>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    14cc <thinning+0x3ac>
jmp    151e <thinning+0x3fe>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    14bb <thinning+0x39b>
mov    -0x30(%rbp),%eax
movswl -0x14(%rbp),%ecx
cmp    %ecx,%eax
jle    157d <thinning+0x45d>
mov    -0x8(%rbp),%rdi
mov    -0x34(%rbp),%esi
mov    -0x38(%rbp),%edx
movswl -0x12(%rbp),%ecx
mov    $0x0,%al
call   1030 <can_thin@plt>
cmp    $0x0,%eax
je     1578 <thinning+0x458>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movw   $0x0,(%rax,%rcx,2)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    157d <thinning+0x45d>
jmp    1582 <thinning+0x462>
jmp    1587 <thinning+0x467>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1456 <thinning+0x336>
jmp    159a <thinning+0x47a>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1415 <thinning+0x2f5>
movl   $0x0,-0x34(%rbp)
movslq -0x34(%rbp),%rax
cmp    -0x20(%rbp),%rax
jge    161b <thinning+0x4fb>
movl   $0x0,-0x38(%rbp)
movslq -0x38(%rbp),%rax
cmp    0x10(%rbp),%rax
jge    1608 <thinning+0x4e8>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,2),%dx
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    15c4 <thinning+0x4a4>
jmp    160d <thinning+0x4ed>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    15af <thinning+0x48f>
lea    0x9de(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x1,-0x38(%rbp)
movslq -0x38(%rbp),%rax
mov    0x10(%rbp),%rcx
sub    $0x1,%rcx
cmp    %rcx,%rax
jge    17c3 <thinning+0x6a3>
mov    -0x38(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    166a <thinning+0x54a>
mov    -0x38(%rbp),%esi
lea    0x99f(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x1,-0x34(%rbp)
movslq -0x34(%rbp),%rax
mov    -0x20(%rbp),%rcx
sub    $0x1,%rcx
cmp    %rcx,%rax
jge    17b0 <thinning+0x690>
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
cmp    $0x0,%eax
jne    179d <thinning+0x67d>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
movswl -0x12(%rbp),%ecx
cmp    %ecx,%eax
jne    179d <thinning+0x67d>
movl   $0x0,-0x30(%rbp)
movl   $0xffffffff,-0x24(%rbp)
cmpl   $0x1,-0x24(%rbp)
jg     1747 <thinning+0x627>
movl   $0xffffffff,-0x28(%rbp)
cmpl   $0x1,-0x28(%rbp)
jg     1734 <thinning+0x614>
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movswl (%rax,%rcx,2),%eax
cmp    $0x0,%eax
jne    1721 <thinning+0x601>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1726 <thinning+0x606>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    16e7 <thinning+0x5c7>
jmp    1739 <thinning+0x619>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    16d6 <thinning+0x5b6>
mov    -0x30(%rbp),%eax
movswl -0x14(%rbp),%ecx
cmp    %ecx,%eax
jle    1798 <thinning+0x678>
mov    -0x8(%rbp),%rdi
mov    -0x34(%rbp),%esi
mov    -0x38(%rbp),%edx
movswl -0x12(%rbp),%ecx
mov    $0x0,%al
call   1030 <can_thin@plt>
cmp    $0x0,%eax
je     1793 <thinning+0x673>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movw   $0x0,(%rax,%rcx,2)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1798 <thinning+0x678>
jmp    179d <thinning+0x67d>
jmp    17a2 <thinning+0x682>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1671 <thinning+0x551>
jmp    17b5 <thinning+0x695>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1630 <thinning+0x510>
movl   $0x0,-0x34(%rbp)
movslq -0x34(%rbp),%rax
cmp    -0x20(%rbp),%rax
jge    1836 <thinning+0x716>
movl   $0x0,-0x38(%rbp)
movslq -0x38(%rbp),%rax
cmp    0x10(%rbp),%rax
jge    1823 <thinning+0x703>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,2),%dx
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    17df <thinning+0x6bf>
jmp    1828 <thinning+0x708>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    17ca <thinning+0x6aa>
lea    0x7c3(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x1,-0x38(%rbp)
movslq -0x38(%rbp),%rax
mov    0x10(%rbp),%rcx
sub    $0x1,%rcx
cmp    %rcx,%rax
jge    19de <thinning+0x8be>
mov    -0x38(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    1885 <thinning+0x765>
mov    -0x38(%rbp),%esi
lea    0x784(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0x1,-0x34(%rbp)
movslq -0x34(%rbp),%rax
mov    -0x20(%rbp),%rcx
sub    $0x1,%rcx
cmp    %rcx,%rax
jge    19cb <thinning+0x8ab>
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
cmp    $0x0,%eax
jne    19b8 <thinning+0x898>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
movswl -0x12(%rbp),%ecx
cmp    %ecx,%eax
jne    19b8 <thinning+0x898>
movl   $0x0,-0x30(%rbp)
movl   $0xffffffff,-0x24(%rbp)
cmpl   $0x1,-0x24(%rbp)
jg     1962 <thinning+0x842>
movl   $0xffffffff,-0x28(%rbp)
cmpl   $0x1,-0x28(%rbp)
jg     194f <thinning+0x82f>
mov    -0x8(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x38(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movswl (%rax,%rcx,2),%eax
cmp    $0x0,%eax
jne    193c <thinning+0x81c>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1941 <thinning+0x821>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1902 <thinning+0x7e2>
jmp    1954 <thinning+0x834>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    18f1 <thinning+0x7d1>
mov    -0x30(%rbp),%eax
movswl -0x14(%rbp),%ecx
cmp    %ecx,%eax
jle    19b3 <thinning+0x893>
mov    -0x8(%rbp),%rdi
mov    -0x34(%rbp),%esi
mov    -0x38(%rbp),%edx
movswl -0x12(%rbp),%ecx
mov    $0x0,%al
call   1030 <can_thin@plt>
cmp    $0x0,%eax
je     19ae <thinning+0x88e>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
movw   $0x0,(%rax,%rcx,2)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    19b3 <thinning+0x893>
jmp    19b8 <thinning+0x898>
jmp    19bd <thinning+0x89d>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    188c <thinning+0x76c>
jmp    19d0 <thinning+0x8b0>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    184b <thinning+0x72b>
movl   $0x0,-0x34(%rbp)
movslq -0x34(%rbp),%rax
cmp    -0x20(%rbp),%rax
jge    1a51 <thinning+0x931>
movl   $0x0,-0x38(%rbp)
movslq -0x38(%rbp),%rax
cmp    0x10(%rbp),%rax
jge    1a3e <thinning+0x91e>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,2),%dx
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    19fa <thinning+0x8da>
jmp    1a43 <thinning+0x923>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    19e5 <thinning+0x8c5>
mov    -0x2c(%rbp),%esi
lea    0x5ab(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
cmpl   $0x0,-0x2c(%rbp)
jne    1a78 <thinning+0x958>
movl   $0x0,-0x40(%rbp)
jmp    1af0 <thinning+0x9d0>
movl   $0x0,-0x34(%rbp)
movslq -0x34(%rbp),%rax
cmp    -0x20(%rbp),%rax
jge    1aeb <thinning+0x9cb>
movl   $0x0,-0x38(%rbp)
movslq -0x38(%rbp),%rax
cmp    0x10(%rbp),%rax
jge    1ad8 <thinning+0x9b8>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,2),%dx
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x38(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1a94 <thinning+0x974>
jmp    1add <thinning+0x9bd>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1a7f <thinning+0x95f>
jmp    1af0 <thinning+0x9d0>
jmp    11c3 <thinning+0xa3>
mov    $0x1,%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<thinning>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x88,%rsp
mov    %r8d,0x1c(%rsp)
mov    %ecx,0x10(%rsp)
mov    %edx,0xc(%rsp)
mov    %rsi,0x20(%rsp)
mov    %rdi,%r15
mov    0xc0(%rsp),%r13
movabs $0x1ffffffffffffffc,%rax
ff ff 1f
mov    %rax,0x30(%rsp)
mov    %r9,0x38(%rsp)
test   %r9,%r9
jle    132e <thinning+0x1fe>
lea    -0x10(%r13),%r9
mov    %r9,0x40(%rsp)
shr    $0x4,%r9
add    $0x1,%r9
mov    %r13,%r14
and    $0xfffffffffffffff0,%r14
mov    %r9d,%r8d
and    $0x3,%r8d
movabs $0x1ffffffffffffffc,%rax
ff ff 1f
and    %rax,%r9
mov    %r13d,%r12d
and    $0x3,%r12d
mov    %r8,%r10
shl    $0x5,%r10
xor    %eax,%eax
jmp    11cf <thinning+0x9f>
nopl   0x0(%rax)
add    $0x1,%rax
cmp    0x38(%rsp),%rax
je     132e <thinning+0x1fe>
test   %r13,%r13
jle    11c0 <thinning+0x90>
mov    (%r15,%rax,8),%rsi
mov    0x20(%rsp),%rcx
mov    (%rcx,%rax,8),%rdi
cmp    $0x10,%r13
jb     11f9 <thinning+0xc9>
lea    (%rsi,%r13,2),%rcx
cmp    %rcx,%rdi
jae    1264 <thinning+0x134>
lea    (%rdi,%r13,2),%rcx
cmp    %rcx,%rsi
jae    1264 <thinning+0x134>
xor    %ebx,%ebx
mov    %rbx,%rcx
not    %rcx
add    %r13,%rcx
test   %r12,%r12
je     1222 <thinning+0xf2>
mov    %r12,%rdx
nopl   0x0(%rax)
movzwl (%rsi,%rbx,2),%ebp
mov    %bp,(%rdi,%rbx,2)
add    $0x1,%rbx
add    $0xffffffffffffffff,%rdx
jne    1210 <thinning+0xe0>
cmp    $0x3,%rcx
jb     11c0 <thinning+0x90>
nopl   0x0(%rax,%rax,1)
movzwl (%rsi,%rbx,2),%ecx
mov    %cx,(%rdi,%rbx,2)
movzwl 0x2(%rsi,%rbx,2),%ecx
mov    %cx,0x2(%rdi,%rbx,2)
movzwl 0x4(%rsi,%rbx,2),%ecx
mov    %cx,0x4(%rdi,%rbx,2)
movzwl 0x6(%rsi,%rbx,2),%ecx
mov    %cx,0x6(%rdi,%rbx,2)
add    $0x4,%rbx
cmp    %rbx,%r13
jne    1230 <thinning+0x100>
jmp    11c0 <thinning+0x90>
cmpq   $0x30,0x40(%rsp)
jae    1270 <thinning+0x140>
xor    %ebx,%ebx
jmp    12da <thinning+0x1aa>
mov    %r9,%r11
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
movups (%rsi,%rbx,2),%xmm0
movups 0x10(%rsi,%rbx,2),%xmm1
movups %xmm0,(%rdi,%rbx,2)
movups %xmm1,0x10(%rdi,%rbx,2)
movups 0x20(%rsi,%rbx,2),%xmm0
movups 0x30(%rsi,%rbx,2),%xmm1
movups %xmm0,0x20(%rdi,%rbx,2)
movups %xmm1,0x30(%rdi,%rbx,2)
movups 0x40(%rsi,%rbx,2),%xmm0
movups 0x50(%rsi,%rbx,2),%xmm1
movups %xmm0,0x40(%rdi,%rbx,2)
movups %xmm1,0x50(%rdi,%rbx,2)
movdqu 0x60(%rsi,%rbx,2),%xmm0
movups 0x70(%rsi,%rbx,2),%xmm1
movdqu %xmm0,0x60(%rdi,%rbx,2)
movups %xmm1,0x70(%rdi,%rbx,2)
add    $0x40,%rbx
add    $0xfffffffffffffffc,%r11
jne    1280 <thinning+0x150>
test   %r8,%r8
je     131d <thinning+0x1ed>
lea    (%rdi,%rbx,2),%rcx
add    $0x10,%rcx
lea    (%rsi,%rbx,2),%rdx
add    $0x10,%rdx
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movdqu -0x10(%rdx,%rbx,1),%xmm0
movups (%rdx,%rbx,1),%xmm1
movdqu %xmm0,-0x10(%rcx,%rbx,1)
movups %xmm1,(%rcx,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%r10
jne    1300 <thinning+0x1d0>
mov    %r14,%rbx
cmp    %r13,%r14
je     11c0 <thinning+0x90>
jmp    11fb <thinning+0xcb>
xor    %eax,%eax
cmpl   $0x1,0x1c(%rsp)
setne  %al
mov    %eax,0x64(%rsp)
mov    0x38(%rsp),%r12
lea    -0x1(%r12),%rax
mov    %rax,0x78(%rsp)
lea    -0x1(%r13),%rax
mov    %rax,0x70(%rsp)
movswl 0xc(%rsp),%r8d
movswl 0x10(%rsp),%eax
mov    %eax,0x40(%rsp)
lea    -0x10(%r13),%rax
mov    %rax,0x50(%rsp)
mov    %rax,%rcx
shr    $0x4,%rcx
add    $0x1,%rcx
mov    %r13,%rax
and    $0xfffffffffffffff0,%rax
mov    %rax,0x48(%rsp)
mov    %ecx,%edx
and    $0x3,%edx
mov    %rcx,%rax
mov    %rcx,0x68(%rsp)
and    %rcx,0x30(%rsp)
mov    %r13d,%eax
and    $0x3,%eax
mov    $0x2,%ecx
mov    $0x2,%r14d
sub    %r13,%r14
mov    %rdx,0x80(%rsp)
mov    %rdx,%r9
shl    $0x5,%r9
sub    %r12,%rcx
mov    %rcx,0x28(%rsp)
mov    %r8d,0xc(%rsp)
mov    %rax,0x58(%rsp)
mov    %r9,0x10(%rsp)
jmp    13ec <thinning+0x2bc>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x64(%rsp),%ebx
test   %ebx,%ebx
je     21e5 <thinning+0x10b5>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    0xc(%rsp),%ecx
movl   $0x0,0x1c(%rsp)
cmp    $0x3,%r12
jl     1560 <thinning+0x430>
movl   $0x0,0x1c(%rsp)
mov    $0x1,%r12d
jmp    142f <thinning+0x2ff>
nopl   0x0(%rax)
add    $0x1,%r12
cmp    0x78(%rsp),%r12
je     1560 <thinning+0x430>
imul   $0xcccccccd,%r12d,%eax
ror    %eax
cmp    $0x19999999,%eax
jbe    1450 <thinning+0x320>
cmp    $0x3,%r13
jl     1420 <thinning+0x2f0>
jmp    146b <thinning+0x33b>
nopw   0x0(%rax,%rax,1)
lea    0x1bb9(%rip),%rdi
mov    %r12d,%esi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0xc(%rsp),%ecx
cmp    $0x3,%r13
jl     1420 <thinning+0x2f0>
mov    $0x1,%ebp
jmp    1492 <thinning+0x362>
mov    0xc(%rsp),%ecx
cs nopw 0x0(%rax,%rax,1)
lea    (%r14,%rbp,1),%rax
add    $0x1,%rax
add    $0x1,%rbp
cmp    $0x1,%rax
je     1420 <thinning+0x2f0>
mov    (%r15,%r12,8),%rax
cmpw   $0x0,-0x2(%rax,%rbp,2)
jne    1480 <thinning+0x350>
movswl (%rax,%rbp,2),%edi
cmp    %edi,%ecx
jne    1480 <thinning+0x350>
mov    -0x8(%r15,%r12,8),%rdx
mov    0x8(%r15,%r12,8),%rsi
movd   (%rdx,%rbp,2),%xmm0
movss  (%rsi,%rbp,2),%xmm1
movzwl -0x2(%rdx,%rbp,2),%edx
movd   %edx,%xmm2
punpcklwd %xmm2,%xmm0
pshuflw $0xe1,%xmm0,%xmm0
pinsrw $0x3,%edi,%xmm0
pinsrw $0x4,0x2(%rax,%rbp,2),%xmm0
pinsrw $0x5,-0x2(%rsi,%rbp,2),%xmm0
shufps $0xe4,%xmm0,%xmm1
shufps $0x24,%xmm1,%xmm0
pcmpeqw 0x1b11(%rip),%xmm0
packsswb %xmm0,%xmm0
pmovmskb %xmm0,%eax
mov    %eax,%edx
shr    %dl
and    $0x55,%dl
sub    %dl,%al
mov    %eax,%edx
and    $0x33,%dl
shr    $0x2,%al
and    $0x33,%al
add    %dl,%al
mov    %eax,%edx
shr    $0x4,%dl
add    %al,%dl
and    $0xf,%dl
add    $0x1,%dl
movzbl %dl,%eax
cmp    %eax,0x40(%rsp)
jge    1480 <thinning+0x350>
mov    %r15,%rdi
mov    %r12d,%esi
mov    %ebp,%edx
xor    %eax,%eax
call   1040 <can_thin@plt>
test   %eax,%eax
je     1472 <thinning+0x342>
mov    0x20(%rsp),%rax
mov    (%rax,%r12,8),%rax
movw   $0x0,(%rax,%rbp,2)
addl   $0x1,0x1c(%rsp)
jmp    1472 <thinning+0x342>
cs nopw 0x0(%rax,%rax,1)
mov    0x38(%rsp),%r12
test   %r12,%r12
mov    0x10(%rsp),%r8
jle    1700 <thinning+0x5d0>
xor    %eax,%eax
jmp    158d <thinning+0x45d>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rax
cmp    %r12,%rax
je     1700 <thinning+0x5d0>
test   %r13,%r13
jle    1580 <thinning+0x450>
mov    0x20(%rsp),%rcx
mov    (%rcx,%rax,8),%rcx
mov    (%r15,%rax,8),%rdx
cmp    $0x10,%r13
jb     15b7 <thinning+0x487>
lea    (%rcx,%r13,2),%rsi
cmp    %rsi,%rdx
jae    1624 <thinning+0x4f4>
lea    (%rdx,%r13,2),%rsi
cmp    %rsi,%rcx
jae    1624 <thinning+0x4f4>
xor    %esi,%esi
mov    %rsi,%rdi
not    %rdi
add    %r13,%rdi
mov    0x58(%rsp),%rbp
test   %rbp,%rbp
je     15e2 <thinning+0x4b2>
nopl   0x0(%rax)
movzwl (%rcx,%rsi,2),%ebx
mov    %bx,(%rdx,%rsi,2)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rbp
jne    15d0 <thinning+0x4a0>
cmp    $0x3,%rdi
jb     1580 <thinning+0x450>
nopl   0x0(%rax,%rax,1)
movzwl (%rcx,%rsi,2),%edi
mov    %di,(%rdx,%rsi,2)
movzwl 0x2(%rcx,%rsi,2),%edi
mov    %di,0x2(%rdx,%rsi,2)
movzwl 0x4(%rcx,%rsi,2),%edi
mov    %di,0x4(%rdx,%rsi,2)
movzwl 0x6(%rcx,%rsi,2),%edi
mov    %di,0x6(%rdx,%rsi,2)
add    $0x4,%rsi
cmp    %rsi,%r13
jne    15f0 <thinning+0x4c0>
jmp    1580 <thinning+0x450>
cmpq   $0x30,0x50(%rsp)
jae    1630 <thinning+0x500>
xor    %esi,%esi
jmp    169a <thinning+0x56a>
mov    0x30(%rsp),%rdi
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movups (%rcx,%rsi,2),%xmm0
movups 0x10(%rcx,%rsi,2),%xmm1
movups %xmm0,(%rdx,%rsi,2)
movups %xmm1,0x10(%rdx,%rsi,2)
movups 0x20(%rcx,%rsi,2),%xmm0
movups 0x30(%rcx,%rsi,2),%xmm1
movups %xmm0,0x20(%rdx,%rsi,2)
movups %xmm1,0x30(%rdx,%rsi,2)
movups 0x40(%rcx,%rsi,2),%xmm0
movups 0x50(%rcx,%rsi,2),%xmm1
movups %xmm0,0x40(%rdx,%rsi,2)
movups %xmm1,0x50(%rdx,%rsi,2)
movdqu 0x60(%rcx,%rsi,2),%xmm0
movups 0x70(%rcx,%rsi,2),%xmm1
movdqu %xmm0,0x60(%rdx,%rsi,2)
movups %xmm1,0x70(%rdx,%rsi,2)
add    $0x40,%rsi
add    $0xfffffffffffffffc,%rdi
jne    1640 <thinning+0x510>
cmpq   $0x0,0x80(%rsp)
je     16dd <thinning+0x5ad>
lea    (%rdx,%rsi,2),%rdi
add    $0x10,%rdi
lea    (%rcx,%rsi,2),%rsi
add    $0x10,%rsi
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movdqu -0x10(%rsi,%rbp,1),%xmm0
movups (%rsi,%rbp,1),%xmm1
movdqu %xmm0,-0x10(%rdi,%rbp,1)
movups %xmm1,(%rdi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%r8
jne    16c0 <thinning+0x590>
mov    0x48(%rsp),%rdi
mov    %rdi,%rsi
cmp    %r13,%rdi
je     1580 <thinning+0x450>
jmp    15b9 <thinning+0x489>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    $0xa,%edi
call   1030 <putchar@plt>
cmp    $0x3,%r12
jl     1870 <thinning+0x740>
mov    $0x1,%r12d
mov    0xc(%rsp),%ecx
mov    0x10(%rsp),%r8
jmp    173f <thinning+0x60f>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r12
cmp    0x78(%rsp),%r12
je     1875 <thinning+0x745>
imul   $0xcccccccd,%r12d,%eax
ror    %eax
cmp    $0x19999999,%eax
jbe    1760 <thinning+0x630>
cmp    $0x3,%r13
jl     1730 <thinning+0x600>
jmp    1780 <thinning+0x650>
nopw   0x0(%rax,%rax,1)
lea    0x18a9(%rip),%rdi
mov    %r12d,%esi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x10(%rsp),%r8
mov    0xc(%rsp),%ecx
cmp    $0x3,%r13
jl     1730 <thinning+0x600>
mov    $0x1,%ebp
jmp    179a <thinning+0x66a>
mov    0xc(%rsp),%ecx
mov    0x10(%rsp),%r8
lea    (%r14,%rbp,1),%rax
cmp    $0x1,%rax
je     1730 <thinning+0x600>
mov    %rbp,%rbx
mov    (%r15,%r12,8),%rax
add    $0x1,%rbp
cmpw   $0x0,0x2(%rax,%rbx,2)
jne    1790 <thinning+0x660>
movswl (%rax,%rbx,2),%edi
cmp    %edi,%ecx
jne    1790 <thinning+0x660>
mov    -0x8(%r15,%r12,8),%rdx
mov    0x8(%r15,%r12,8),%rsi
movd   (%rdx,%rbx,2),%xmm0
movss  (%rsi,%rbx,2),%xmm1
movzwl -0x2(%rdx,%rbx,2),%edx
movd   %edx,%xmm2
punpcklwd %xmm2,%xmm0
pshuflw $0xe1,%xmm0,%xmm0
pinsrw $0x3,-0x2(%rax,%rbx,2),%xmm0
pinsrw $0x4,%edi,%xmm0
pinsrw $0x5,-0x2(%rsi,%rbx,2),%xmm0
shufps $0xe4,%xmm0,%xmm1
shufps $0x24,%xmm1,%xmm0
pcmpeqw 0x1802(%rip),%xmm0
packsswb %xmm0,%xmm0
pmovmskb %xmm0,%eax
mov    %eax,%edx
shr    %dl
and    $0x55,%dl
sub    %dl,%al
mov    %eax,%edx
and    $0x33,%dl
shr    $0x2,%al
and    $0x33,%al
add    %dl,%al
mov    %eax,%edx
shr    $0x4,%dl
add    %al,%dl
and    $0xf,%dl
add    $0x1,%dl
movzbl %dl,%eax
cmp    %eax,0x40(%rsp)
jge    1790 <thinning+0x660>
mov    %r15,%rdi
mov    %r12d,%esi
mov    %ebx,%edx
xor    %eax,%eax
call   1040 <can_thin@plt>
test   %eax,%eax
je     1787 <thinning+0x657>
mov    0x20(%rsp),%rax
mov    (%rax,%r12,8),%rax
movw   $0x0,(%rax,%rbx,2)
addl   $0x1,0x1c(%rsp)
jmp    1787 <thinning+0x657>
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x10(%rsp),%r8
mov    0x38(%rsp),%r12
test   %r12,%r12
jle    1a10 <thinning+0x8e0>
xor    %eax,%eax
jmp    189d <thinning+0x76d>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rax
cmp    %r12,%rax
je     1a10 <thinning+0x8e0>
test   %r13,%r13
jle    1890 <thinning+0x760>
mov    0x20(%rsp),%rcx
mov    (%rcx,%rax,8),%rcx
mov    (%r15,%rax,8),%rdx
cmp    $0x10,%r13
jb     18c7 <thinning+0x797>
lea    (%rcx,%r13,2),%rsi
cmp    %rsi,%rdx
jae    1934 <thinning+0x804>
lea    (%rdx,%r13,2),%rsi
cmp    %rsi,%rcx
jae    1934 <thinning+0x804>
xor    %esi,%esi
mov    %rsi,%rdi
not    %rdi
add    %r13,%rdi
test   $0x3,%r13b
je     18f2 <thinning+0x7c2>
mov    0x58(%rsp),%rbp
nopl   (%rax)
movzwl (%rcx,%rsi,2),%ebx
mov    %bx,(%rdx,%rsi,2)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rbp
jne    18e0 <thinning+0x7b0>
cmp    $0x3,%rdi
jb     1890 <thinning+0x760>
nopl   0x0(%rax,%rax,1)
movzwl (%rcx,%rsi,2),%edi
mov    %di,(%rdx,%rsi,2)
movzwl 0x2(%rcx,%rsi,2),%edi
mov    %di,0x2(%rdx,%rsi,2)
movzwl 0x4(%rcx,%rsi,2),%edi
mov    %di,0x4(%rdx,%rsi,2)
movzwl 0x6(%rcx,%rsi,2),%edi
mov    %di,0x6(%rdx,%rsi,2)
add    $0x4,%rsi
cmp    %rsi,%r13
jne    1900 <thinning+0x7d0>
jmp    1890 <thinning+0x760>
cmpq   $0x30,0x50(%rsp)
jae    1940 <thinning+0x810>
xor    %esi,%esi
jmp    19aa <thinning+0x87a>
mov    0x30(%rsp),%rdi
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movups (%rcx,%rsi,2),%xmm0
movups 0x10(%rcx,%rsi,2),%xmm1
movups %xmm0,(%rdx,%rsi,2)
movups %xmm1,0x10(%rdx,%rsi,2)
movups 0x20(%rcx,%rsi,2),%xmm0
movups 0x30(%rcx,%rsi,2),%xmm1
movups %xmm0,0x20(%rdx,%rsi,2)
movups %xmm1,0x30(%rdx,%rsi,2)
movups 0x40(%rcx,%rsi,2),%xmm0
movups 0x50(%rcx,%rsi,2),%xmm1
movups %xmm0,0x40(%rdx,%rsi,2)
movups %xmm1,0x50(%rdx,%rsi,2)
movdqu 0x60(%rcx,%rsi,2),%xmm0
movups 0x70(%rcx,%rsi,2),%xmm1
movdqu %xmm0,0x60(%rdx,%rsi,2)
movups %xmm1,0x70(%rdx,%rsi,2)
add    $0x40,%rsi
add    $0xfffffffffffffffc,%rdi
jne    1950 <thinning+0x820>
testb  $0x3,0x68(%rsp)
je     19ed <thinning+0x8bd>
lea    (%rdx,%rsi,2),%rdi
add    $0x10,%rdi
lea    (%rcx,%rsi,2),%rsi
add    $0x10,%rsi
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movdqu -0x10(%rsi,%rbp,1),%xmm0
movups (%rsi,%rbp,1),%xmm1
movdqu %xmm0,-0x10(%rdi,%rbp,1)
movups %xmm1,(%rdi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%r8
jne    19d0 <thinning+0x8a0>
mov    0x48(%rsp),%rdi
mov    %rdi,%rsi
cmp    %r13,%rdi
je     1890 <thinning+0x760>
jmp    18c9 <thinning+0x799>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    $0xa,%edi
call   1030 <putchar@plt>
cmp    $0x3,%r13
jl     1b70 <thinning+0xa40>
mov    $0x1,%ebp
mov    0xc(%rsp),%ecx
mov    0x28(%rsp),%r8
mov    0x10(%rsp),%r9
jmp    1a4f <thinning+0x91f>
nopl   0x0(%rax)
add    $0x1,%rbp
cmp    0x70(%rsp),%rbp
je     1b75 <thinning+0xa45>
imul   $0xcccccccd,%ebp,%eax
ror    %eax
cmp    $0x19999999,%eax
jbe    1a70 <thinning+0x940>
cmp    $0x3,%r12
jl     1a40 <thinning+0x910>
jmp    1a94 <thinning+0x964>
cs nopw 0x0(%rax,%rax,1)
lea    0x1599(%rip),%rdi
mov    %ebp,%esi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x10(%rsp),%r9
mov    0x28(%rsp),%r8
mov    0xc(%rsp),%ecx
cmp    $0x3,%r12
jl     1a40 <thinning+0x910>
mov    $0x1,%ebx
jmp    1ac6 <thinning+0x996>
mov    0xc(%rsp),%ecx
mov    0x28(%rsp),%r8
mov    0x10(%rsp),%r9
nopl   0x0(%rax)
lea    (%r8,%rbx,1),%rax
add    $0x1,%rax
add    $0x1,%rbx
cmp    $0x1,%rax
je     1a40 <thinning+0x910>
mov    -0x8(%r15,%rbx,8),%rdx
cmpw   $0x0,(%rdx,%rbp,2)
jne    1ab0 <thinning+0x980>
mov    (%r15,%rbx,8),%rax
movswl (%rax,%rbp,2),%edi
cmp    %edi,%ecx
jne    1ab0 <thinning+0x980>
xor    %esi,%esi
cmpw   $0x0,-0x2(%rdx,%rbp,2)
sete   %sil
cmpw   $0x1,0x2(%rdx,%rbp,2)
adc    $0x0,%esi
cmpw   $0x1,-0x2(%rax,%rbp,2)
adc    $0x0,%esi
cmp    $0x1,%di
adc    $0x0,%esi
cmpw   $0x1,0x2(%rax,%rbp,2)
adc    $0x0,%esi
mov    0x8(%r15,%rbx,8),%rax
cmpw   $0x1,-0x2(%rax,%rbp,2)
adc    $0x0,%esi
cmpw   $0x1,(%rax,%rbp,2)
adc    $0x0,%esi
cmpw   $0x1,0x2(%rax,%rbp,2)
adc    $0x0,%esi
add    $0x1,%esi
cmp    0x40(%rsp),%esi
jle    1ab0 <thinning+0x980>
mov    %r15,%rdi
mov    %ebx,%esi
mov    %ebp,%edx
xor    %eax,%eax
call   1040 <can_thin@plt>
test   %eax,%eax
je     1a9b <thinning+0x96b>
mov    0x20(%rsp),%rax
mov    (%rax,%rbx,8),%rax
movw   $0x0,(%rax,%rbp,2)
addl   $0x1,0x1c(%rsp)
jmp    1a9b <thinning+0x96b>
nopw   0x0(%rax,%rax,1)
mov    0x10(%rsp),%r9
test   %r12,%r12
jle    1d10 <thinning+0xbe0>
xor    %eax,%eax
jmp    1b9d <thinning+0xa6d>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rax
cmp    %r12,%rax
je     1d10 <thinning+0xbe0>
test   %r13,%r13
jle    1b90 <thinning+0xa60>
mov    0x20(%rsp),%rcx
mov    (%rcx,%rax,8),%rcx
mov    (%r15,%rax,8),%rdx
cmp    $0x10,%r13
jb     1bc7 <thinning+0xa97>
lea    (%rcx,%r13,2),%rsi
cmp    %rsi,%rdx
jae    1c34 <thinning+0xb04>
lea    (%rdx,%r13,2),%rsi
cmp    %rsi,%rcx
jae    1c34 <thinning+0xb04>
xor    %esi,%esi
mov    %rsi,%rdi
not    %rdi
add    %r13,%rdi
test   $0x3,%r13b
je     1bf2 <thinning+0xac2>
mov    0x58(%rsp),%rbp
nopl   (%rax)
movzwl (%rcx,%rsi,2),%ebx
mov    %bx,(%rdx,%rsi,2)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rbp
jne    1be0 <thinning+0xab0>
cmp    $0x3,%rdi
jb     1b90 <thinning+0xa60>
nopl   0x0(%rax,%rax,1)
movzwl (%rcx,%rsi,2),%edi
mov    %di,(%rdx,%rsi,2)
movzwl 0x2(%rcx,%rsi,2),%edi
mov    %di,0x2(%rdx,%rsi,2)
movzwl 0x4(%rcx,%rsi,2),%edi
mov    %di,0x4(%rdx,%rsi,2)
movzwl 0x6(%rcx,%rsi,2),%edi
mov    %di,0x6(%rdx,%rsi,2)
add    $0x4,%rsi
cmp    %rsi,%r13
jne    1c00 <thinning+0xad0>
jmp    1b90 <thinning+0xa60>
cmpq   $0x30,0x50(%rsp)
jae    1c40 <thinning+0xb10>
xor    %esi,%esi
jmp    1caa <thinning+0xb7a>
mov    0x30(%rsp),%rdi
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movups (%rcx,%rsi,2),%xmm0
movups 0x10(%rcx,%rsi,2),%xmm1
movups %xmm0,(%rdx,%rsi,2)
movups %xmm1,0x10(%rdx,%rsi,2)
movups 0x20(%rcx,%rsi,2),%xmm0
movups 0x30(%rcx,%rsi,2),%xmm1
movups %xmm0,0x20(%rdx,%rsi,2)
movups %xmm1,0x30(%rdx,%rsi,2)
movups 0x40(%rcx,%rsi,2),%xmm0
movups 0x50(%rcx,%rsi,2),%xmm1
movups %xmm0,0x40(%rdx,%rsi,2)
movups %xmm1,0x50(%rdx,%rsi,2)
movdqu 0x60(%rcx,%rsi,2),%xmm0
movups 0x70(%rcx,%rsi,2),%xmm1
movdqu %xmm0,0x60(%rdx,%rsi,2)
movups %xmm1,0x70(%rdx,%rsi,2)
add    $0x40,%rsi
add    $0xfffffffffffffffc,%rdi
jne    1c50 <thinning+0xb20>
testb  $0x3,0x68(%rsp)
je     1ced <thinning+0xbbd>
lea    (%rdx,%rsi,2),%rdi
add    $0x10,%rdi
lea    (%rcx,%rsi,2),%rsi
add    $0x10,%rsi
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movdqu -0x10(%rsi,%rbp,1),%xmm0
movups (%rsi,%rbp,1),%xmm1
movdqu %xmm0,-0x10(%rdi,%rbp,1)
movups %xmm1,(%rdi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%r9
jne    1cd0 <thinning+0xba0>
mov    0x48(%rsp),%rdi
mov    %rdi,%rsi
cmp    %r13,%rdi
je     1b90 <thinning+0xa60>
jmp    1bc9 <thinning+0xa99>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    $0xa,%edi
call   1030 <putchar@plt>
cmp    $0x3,%r13
jl     1e90 <thinning+0xd60>
mov    $0x1,%r12d
mov    0xc(%rsp),%ecx
mov    0x28(%rsp),%r8
mov    0x10(%rsp),%r9
jmp    1d4f <thinning+0xc1f>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r12
cmp    0x70(%rsp),%r12
je     1e95 <thinning+0xd65>
imul   $0xcccccccd,%r12d,%eax
ror    %eax
cmp    $0x19999999,%eax
jbe    1d70 <thinning+0xc40>
cmpq   $0x3,0x38(%rsp)
jl     1d40 <thinning+0xc10>
jmp    1d97 <thinning+0xc67>
nopl   0x0(%rax)
lea    0x1299(%rip),%rdi
mov    %r12d,%esi
xor    %eax,%eax
call   1050 <printf@plt>
mov    0x10(%rsp),%r9
mov    0x28(%rsp),%r8
mov    0xc(%rsp),%ecx
cmpq   $0x3,0x38(%rsp)
jl     1d40 <thinning+0xc10>
mov    $0x1,%ebp
jmp    1dba <thinning+0xc8a>
mov    0xc(%rsp),%ecx
mov    0x28(%rsp),%r8
mov    0x10(%rsp),%r9
nopl   0x0(%rax)
lea    (%r8,%rbp,1),%rax
cmp    $0x1,%rax
je     1d40 <thinning+0xc10>
mov    %rbp,%rbx
add    $0x1,%rbp
mov    0x8(%r15,%rbx,8),%rax
cmpw   $0x0,(%rax,%r12,2)
jne    1db0 <thinning+0xc80>
mov    (%r15,%rbx,8),%rdi
movswl (%rdi,%r12,2),%edx
cmp    %edx,%ecx
jne    1db0 <thinning+0xc80>
mov    -0x8(%r15,%rbx,8),%rsi
movd   (%rsi,%r12,2),%xmm0
movzwl -0x2(%rsi,%r12,2),%esi
movd   %esi,%xmm1
punpcklwd %xmm1,%xmm0
pshuflw $0xe1,%xmm0,%xmm0
pinsrw $0x3,-0x2(%rdi,%r12,2),%xmm0
pinsrw $0x4,%edx,%xmm0
pinsrw $0x5,0x2(%rdi,%r12,2),%xmm0
05
pinsrw $0x6,-0x2(%rax,%r12,2),%xmm0
06
pinsrw $0x7,0x2(%rax,%r12,2),%xmm0
07
pcmpeqw 0x11da(%rip),%xmm0
packsswb %xmm0,%xmm0
pmovmskb %xmm0,%eax
mov    %eax,%edx
shr    %dl
and    $0x55,%dl
sub    %dl,%al
mov    %eax,%edx
and    $0x33,%dl
shr    $0x2,%al
and    $0x33,%al
add    %dl,%al
mov    %eax,%edx
shr    $0x4,%dl
add    %al,%dl
and    $0xf,%dl
add    $0x1,%dl
movzbl %dl,%eax
cmp    %eax,0x40(%rsp)
jge    1db0 <thinning+0xc80>
mov    %r15,%rdi
mov    %ebx,%esi
mov    %r12d,%edx
xor    %eax,%eax
call   1040 <can_thin@plt>
test   %eax,%eax
je     1d9e <thinning+0xc6e>
mov    0x20(%rsp),%rax
mov    (%rax,%rbx,8),%rax
movw   $0x0,(%rax,%r12,2)
addl   $0x1,0x1c(%rsp)
jmp    1d9e <thinning+0xc6e>
xchg   %ax,%ax
mov    0x10(%rsp),%r9
mov    0x38(%rsp),%r12
test   %r12,%r12
jle    2030 <thinning+0xf00>
xor    %eax,%eax
jmp    1ebd <thinning+0xd8d>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rax
cmp    %r12,%rax
je     2030 <thinning+0xf00>
test   %r13,%r13
jle    1eb0 <thinning+0xd80>
mov    0x20(%rsp),%rcx
mov    (%rcx,%rax,8),%rcx
mov    (%r15,%rax,8),%rdx
cmp    $0x10,%r13
jb     1ee7 <thinning+0xdb7>
lea    (%rcx,%r13,2),%rsi
cmp    %rsi,%rdx
jae    1f54 <thinning+0xe24>
lea    (%rdx,%r13,2),%rsi
cmp    %rsi,%rcx
jae    1f54 <thinning+0xe24>
xor    %esi,%esi
mov    %rsi,%rdi
not    %rdi
add    %r13,%rdi
test   $0x3,%r13b
je     1f12 <thinning+0xde2>
mov    0x58(%rsp),%rbp
nopl   (%rax)
movzwl (%rcx,%rsi,2),%ebx
mov    %bx,(%rdx,%rsi,2)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rbp
jne    1f00 <thinning+0xdd0>
cmp    $0x3,%rdi
jb     1eb0 <thinning+0xd80>
nopl   0x0(%rax,%rax,1)
movzwl (%rcx,%rsi,2),%edi
mov    %di,(%rdx,%rsi,2)
movzwl 0x2(%rcx,%rsi,2),%edi
mov    %di,0x2(%rdx,%rsi,2)
movzwl 0x4(%rcx,%rsi,2),%edi
mov    %di,0x4(%rdx,%rsi,2)
movzwl 0x6(%rcx,%rsi,2),%edi
mov    %di,0x6(%rdx,%rsi,2)
add    $0x4,%rsi
cmp    %rsi,%r13
jne    1f20 <thinning+0xdf0>
jmp    1eb0 <thinning+0xd80>
cmpq   $0x30,0x50(%rsp)
jae    1f60 <thinning+0xe30>
xor    %esi,%esi
jmp    1fcc <thinning+0xe9c>
mov    0x30(%rsp),%rdi
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movups (%rcx,%rsi,2),%xmm0
movups 0x10(%rcx,%rsi,2),%xmm1
movups %xmm0,(%rdx,%rsi,2)
movups %xmm1,0x10(%rdx,%rsi,2)
movups 0x20(%rcx,%rsi,2),%xmm0
movups 0x30(%rcx,%rsi,2),%xmm1
movups %xmm0,0x20(%rdx,%rsi,2)
movups %xmm1,0x30(%rdx,%rsi,2)
movups 0x40(%rcx,%rsi,2),%xmm0
movups 0x50(%rcx,%rsi,2),%xmm1
movups %xmm0,0x40(%rdx,%rsi,2)
movups %xmm1,0x50(%rdx,%rsi,2)
movdqu 0x60(%rcx,%rsi,2),%xmm0
movdqu 0x70(%rcx,%rsi,2),%xmm1
movdqu %xmm0,0x60(%rdx,%rsi,2)
movdqu %xmm1,0x70(%rdx,%rsi,2)
add    $0x40,%rsi
add    $0xfffffffffffffffc,%rdi
jne    1f70 <thinning+0xe40>
testb  $0x3,0x68(%rsp)
je     200f <thinning+0xedf>
lea    (%rdx,%rsi,2),%rdi
add    $0x10,%rdi
lea    (%rcx,%rsi,2),%rsi
add    $0x10,%rsi
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nop
movdqu -0x10(%rsi,%rbp,1),%xmm0
movdqu (%rsi,%rbp,1),%xmm1
movdqu %xmm0,-0x10(%rdi,%rbp,1)
movdqu %xmm1,(%rdi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%r9
jne    1ff0 <thinning+0xec0>
mov    0x48(%rsp),%rdi
mov    %rdi,%rsi
cmp    %r13,%rdi
je     1eb0 <thinning+0xd80>
jmp    1ee9 <thinning+0xdb9>
cs nopw 0x0(%rax,%rax,1)
nop
lea    0xfdd(%rip),%rdi
mov    0x1c(%rsp),%ebx
mov    %ebx,%esi
xor    %eax,%eax
call   1050 <printf@plt>
test   %ebx,%ebx
cmovne 0x64(%rsp),%ebx
je     13e4 <thinning+0x2b4>
test   %r12,%r12
mov    0x10(%rsp),%r9
jle    13e4 <thinning+0x2b4>
xor    %eax,%eax
jmp    207d <thinning+0xf4d>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%rax
cmp    %r12,%rax
je     13e0 <thinning+0x2b0>
test   %r13,%r13
jle    2070 <thinning+0xf40>
mov    0x20(%rsp),%rcx
mov    (%rcx,%rax,8),%rcx
mov    (%r15,%rax,8),%rdx
cmp    $0x10,%r13
jb     20a7 <thinning+0xf77>
lea    (%rcx,%r13,2),%rsi
cmp    %rsi,%rdx
jae    2114 <thinning+0xfe4>
lea    (%rdx,%r13,2),%rsi
cmp    %rsi,%rcx
jae    2114 <thinning+0xfe4>
xor    %esi,%esi
mov    %rsi,%rdi
not    %rdi
add    %r13,%rdi
test   $0x3,%r13b
je     20d2 <thinning+0xfa2>
mov    0x58(%rsp),%rbp
nopl   (%rax)
movzwl (%rcx,%rsi,2),%ebx
mov    %bx,(%rdx,%rsi,2)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rbp
jne    20c0 <thinning+0xf90>
cmp    $0x3,%rdi
jb     2070 <thinning+0xf40>
nopl   0x0(%rax,%rax,1)
movzwl (%rcx,%rsi,2),%edi
mov    %di,(%rdx,%rsi,2)
movzwl 0x2(%rcx,%rsi,2),%edi
mov    %di,0x2(%rdx,%rsi,2)
movzwl 0x4(%rcx,%rsi,2),%edi
mov    %di,0x4(%rdx,%rsi,2)
movzwl 0x6(%rcx,%rsi,2),%edi
mov    %di,0x6(%rdx,%rsi,2)
add    $0x4,%rsi
cmp    %rsi,%r13
jne    20e0 <thinning+0xfb0>
jmp    2070 <thinning+0xf40>
cmpq   $0x30,0x50(%rsp)
jae    2120 <thinning+0xff0>
xor    %esi,%esi
jmp    218c <thinning+0x105c>
mov    0x30(%rsp),%rdi
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movups (%rcx,%rsi,2),%xmm0
movups 0x10(%rcx,%rsi,2),%xmm1
movups %xmm0,(%rdx,%rsi,2)
movups %xmm1,0x10(%rdx,%rsi,2)
movups 0x20(%rcx,%rsi,2),%xmm0
movups 0x30(%rcx,%rsi,2),%xmm1
movups %xmm0,0x20(%rdx,%rsi,2)
movups %xmm1,0x30(%rdx,%rsi,2)
movups 0x40(%rcx,%rsi,2),%xmm0
movups 0x50(%rcx,%rsi,2),%xmm1
movups %xmm0,0x40(%rdx,%rsi,2)
movups %xmm1,0x50(%rdx,%rsi,2)
movdqu 0x60(%rcx,%rsi,2),%xmm0
movdqu 0x70(%rcx,%rsi,2),%xmm1
movdqu %xmm0,0x60(%rdx,%rsi,2)
movdqu %xmm1,0x70(%rdx,%rsi,2)
add    $0x40,%rsi
add    $0xfffffffffffffffc,%rdi
jne    2130 <thinning+0x1000>
testb  $0x3,0x68(%rsp)
je     21cf <thinning+0x109f>
lea    (%rdx,%rsi,2),%rdi
add    $0x10,%rdi
lea    (%rcx,%rsi,2),%rsi
add    $0x10,%rsi
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nop
movdqu -0x10(%rsi,%rbp,1),%xmm0
movdqu (%rsi,%rbp,1),%xmm1
movdqu %xmm0,-0x10(%rdi,%rbp,1)
movdqu %xmm1,(%rdi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%r9
jne    21b0 <thinning+0x1080>
mov    0x48(%rsp),%rdi
mov    %rdi,%rsi
cmp    %r13,%rdi
je     2070 <thinning+0xf40>
jmp    20a9 <thinning+0xf79>
mov    $0x1,%eax
add    $0x88,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@.str.1 = [4 x i8] c"%3d\00"
@.str.2 = [20 x i8] c"\0A\0AThinned %d pixels\00"
define i32 @thinning(i16** %0, i16** nocapture %1, i32 %2, i32 %3, i32 %4, i64 %5, i64 %6) {
%8 = icmp sgt i64 %5, 0
br i1 %8, label %9, label %121
9: ; preds = %7
%10 = icmp sgt i64 %6, 0
%11 = add i64 %6, -16
%12 = lshr i64 %11, 4
%13 = add nuw nsw i64 %12, 1
%14 = icmp ult i64 %6, 16
%15 = and i64 %6, -16
%16 = and i64 %13, 3
%17 = icmp ult i64 %11, 48
%18 = and i64 %13, 2305843009213693948
%19 = icmp eq i64 %16, 0
%20 = icmp eq i64 %15, %6
%21 = and i64 %6, 3
%22 = icmp eq i64 %21, 0
br label %23
23: ; preds = %9, %201
%24 = phi i64 [ 0, %9 ], [ %202, %201 ]
br i1 %10, label %25, label %201
25: ; preds = %23
%26 = getelementptr inbounds i16*, i16** %0, i64 %24
%27 = load i16*, i16** %26
%28 = getelementptr inbounds i16*, i16** %1, i64 %24
%29 = load i16*, i16** %28
br i1 %14, label %105, label %30
30: ; preds = %25
%31 = getelementptr i16, i16* %29, i64 %6
%32 = getelementptr i16, i16* %27, i64 %6
%33 = icmp ult i16* %29, %32
%34 = icmp ult i16* %27, %31
%35 = and i1 %33, %34
br i1 %35, label %105, label %36
36: ; preds = %30
br i1 %17, label %86, label %37
37: ; preds = %36, %37
%38 = phi i64 [ %83, %37 ], [ 0, %36 ]
%39 = phi i64 [ %84, %37 ], [ 0, %36 ]
%40 = getelementptr inbounds i16, i16* %27, i64 %38
%41 = bitcast i16* %40 to <8 x i16>*
%42 = load <8 x i16>, <8 x i16>* %41
%43 = getelementptr inbounds i16, i16* %40, i64 8
%44 = bitcast i16* %43 to <8 x i16>*
%45 = load <8 x i16>, <8 x i16>* %44
%46 = getelementptr inbounds i16, i16* %29, i64 %38
%47 = bitcast i16* %46 to <8 x i16>*
store <8 x i16> %42, <8 x i16>* %47
%48 = getelementptr inbounds i16, i16* %46, i64 8
%49 = bitcast i16* %48 to <8 x i16>*
store <8 x i16> %45, <8 x i16>* %49
%50 = or i64 %38, 16
%51 = getelementptr inbounds i16, i16* %27, i64 %50
%52 = bitcast i16* %51 to <8 x i16>*
%53 = load <8 x i16>, <8 x i16>* %52
%54 = getelementptr inbounds i16, i16* %51, i64 8
%55 = bitcast i16* %54 to <8 x i16>*
%56 = load <8 x i16>, <8 x i16>* %55
%57 = getelementptr inbounds i16, i16* %29, i64 %50
%58 = bitcast i16* %57 to <8 x i16>*
store <8 x i16> %53, <8 x i16>* %58
%59 = getelementptr inbounds i16, i16* %57, i64 8
%60 = bitcast i16* %59 to <8 x i16>*
store <8 x i16> %56, <8 x i16>* %60
%61 = or i64 %38, 32
%62 = getelementptr inbounds i16, i16* %27, i64 %61
%63 = bitcast i16* %62 to <8 x i16>*
%64 = load <8 x i16>, <8 x i16>* %63
%65 = getelementptr inbounds i16, i16* %62, i64 8
%66 = bitcast i16* %65 to <8 x i16>*
%67 = load <8 x i16>, <8 x i16>* %66
%68 = getelementptr inbounds i16, i16* %29, i64 %61
%69 = bitcast i16* %68 to <8 x i16>*
store <8 x i16> %64, <8 x i16>* %69
%70 = getelementptr inbounds i16, i16* %68, i64 8
%71 = bitcast i16* %70 to <8 x i16>*
store <8 x i16> %67, <8 x i16>* %71
%72 = or i64 %38, 48
%73 = getelementptr inbounds i16, i16* %27, i64 %72
%74 = bitcast i16* %73 to <8 x i16>*
%75 = load <8 x i16>, <8 x i16>* %74
%76 = getelementptr inbounds i16, i16* %73, i64 8
%77 = bitcast i16* %76 to <8 x i16>*
%78 = load <8 x i16>, <8 x i16>* %77
%79 = getelementptr inbounds i16, i16* %29, i64 %72
%80 = bitcast i16* %79 to <8 x i16>*
store <8 x i16> %75, <8 x i16>* %80
%81 = getelementptr inbounds i16, i16* %79, i64 8
%82 = bitcast i16* %81 to <8 x i16>*
store <8 x i16> %78, <8 x i16>* %82
%83 = add nuw i64 %38, 64
%84 = add i64 %39, 4
%85 = icmp eq i64 %84, %18
br i1 %85, label %86, label %37
86: ; preds = %37, %36
%87 = phi i64 [ 0, %36 ], [ %83, %37 ]
br i1 %19, label %104, label %88
88: ; preds = %86, %88
%89 = phi i64 [ %101, %88 ], [ %87, %86 ]
%90 = phi i64 [ %102, %88 ], [ 0, %86 ]
%91 = getelementptr inbounds i16, i16* %27, i64 %89
%92 = bitcast i16* %91 to <8 x i16>*
%93 = load <8 x i16>, <8 x i16>* %92
%94 = getelementptr inbounds i16, i16* %91, i64 8
%95 = bitcast i16* %94 to <8 x i16>*
%96 = load <8 x i16>, <8 x i16>* %95
%97 = getelementptr inbounds i16, i16* %29, i64 %89
%98 = bitcast i16* %97 to <8 x i16>*
store <8 x i16> %93, <8 x i16>* %98
%99 = getelementptr inbounds i16, i16* %97, i64 8
%100 = bitcast i16* %99 to <8 x i16>*
store <8 x i16> %96, <8 x i16>* %100
%101 = add nuw i64 %89, 16
%102 = add i64 %90, 1
%103 = icmp eq i64 %102, %16
br i1 %103, label %104, label %88
104: ; preds = %88, %86
br i1 %20, label %201, label %105
105: ; preds = %30, %25, %104
%106 = phi i64 [ 0, %30 ], [ 0, %25 ], [ %15, %104 ]
%107 = xor i64 %106, -1
%108 = add i64 %107, %6
br i1 %22, label %118, label %109
109: ; preds = %105, %109
%110 = phi i64 [ %115, %109 ], [ %106, %105 ]
%111 = phi i64 [ %116, %109 ], [ 0, %105 ]
%112 = getelementptr inbounds i16, i16* %27, i64 %110
%113 = load i16, i16* %112
%114 = getelementptr inbounds i16, i16* %29, i64 %110
store i16 %113, i16* %114
%115 = add nuw nsw i64 %110, 1
%116 = add i64 %111, 1
%117 = icmp eq i64 %116, %21
br i1 %117, label %118, label %109
118: ; preds = %109, %105
%119 = phi i64 [ %106, %105 ], [ %115, %109 ]
%120 = icmp ult i64 %108, 3
br i1 %120, label %201, label %182
121: ; preds = %201, %7
%122 = icmp ne i32 %4, 1
%123 = zext i1 %122 to i32
%124 = add i64 %5, -1
%125 = icmp sgt i64 %5, 2
%126 = add i64 %6, -1
%127 = icmp sgt i64 %6, 2
%128 = shl i32 %2, 16
%129 = ashr exact i32 %128, 16
%130 = shl i32 %3, 16
%131 = ashr exact i32 %130, 16
%132 = icmp sgt i64 %6, 0
%133 = icmp slt i64 %5, 1
%134 = add i64 %6, -16
%135 = lshr i64 %134, 4
%136 = add nuw nsw i64 %135, 1
%137 = icmp ult i64 %6, 16
%138 = and i64 %6, -16
%139 = and i64 %136, 3
%140 = icmp ult i64 %134, 48
%141 = and i64 %136, 2305843009213693948
%142 = icmp eq i64 %139, 0
%143 = icmp eq i64 %138, %6
%144 = and i64 %6, 3
%145 = icmp eq i64 %144, 0
%146 = icmp ult i64 %6, 16
%147 = and i64 %6, -16
%148 = and i64 %136, 3
%149 = icmp ult i64 %134, 48
%150 = and i64 %136, 2305843009213693948
%151 = icmp eq i64 %148, 0
%152 = icmp eq i64 %147, %6
%153 = and i64 %6, 3
%154 = icmp eq i64 %153, 0
%155 = icmp ult i64 %6, 16
%156 = and i64 %6, -16
%157 = and i64 %136, 3
%158 = icmp ult i64 %134, 48
%159 = and i64 %136, 2305843009213693948
%160 = icmp eq i64 %157, 0
%161 = icmp eq i64 %156, %6
%162 = and i64 %6, 3
%163 = icmp eq i64 %162, 0
%164 = icmp ult i64 %6, 16
%165 = and i64 %6, -16
%166 = and i64 %136, 3
%167 = icmp ult i64 %134, 48
%168 = and i64 %136, 2305843009213693948
%169 = icmp eq i64 %166, 0
%170 = icmp eq i64 %165, %6
%171 = and i64 %6, 3
%172 = icmp eq i64 %171, 0
%173 = icmp ult i64 %6, 16
%174 = and i64 %6, -16
%175 = and i64 %136, 3
%176 = icmp ult i64 %134, 48
%177 = and i64 %136, 2305843009213693948
%178 = icmp eq i64 %175, 0
%179 = icmp eq i64 %174, %6
%180 = and i64 %6, 3
%181 = icmp eq i64 %180, 0
br label %204
182: ; preds = %118, %182
%183 = phi i64 [ %199, %182 ], [ %119, %118 ]
%184 = getelementptr inbounds i16, i16* %27, i64 %183
%185 = load i16, i16* %184
%186 = getelementptr inbounds i16, i16* %29, i64 %183
store i16 %185, i16* %186
%187 = add nuw nsw i64 %183, 1
%188 = getelementptr inbounds i16, i16* %27, i64 %187
%189 = load i16, i16* %188
%190 = getelementptr inbounds i16, i16* %29, i64 %187
store i16 %189, i16* %190
%191 = add nuw nsw i64 %183, 2
%192 = getelementptr inbounds i16, i16* %27, i64 %191
%193 = load i16, i16* %192
%194 = getelementptr inbounds i16, i16* %29, i64 %191
store i16 %193, i16* %194
%195 = add nuw nsw i64 %183, 3
%196 = getelementptr inbounds i16, i16* %27, i64 %195
%197 = load i16, i16* %196
%198 = getelementptr inbounds i16, i16* %29, i64 %195
store i16 %197, i16* %198
%199 = add nuw nsw i64 %183, 4
%200 = icmp eq i64 %199, %6
br i1 %200, label %201, label %182
201: ; preds = %118, %182, %104, %23
%202 = add nuw nsw i64 %24, 1
%203 = icmp eq i64 %202, %5
br i1 %203, label %121, label %23
204: ; preds = %121, %1136
%205 = tail call i32 @putchar(i32 10)
br i1 %125, label %208, label %206
206: ; preds = %279, %204
%207 = phi i32 [ 0, %204 ], [ %280, %279 ]
br i1 %8, label %283, label %403
208: ; preds = %204, %279
%209 = phi i64 [ %281, %279 ], [ 1, %204 ]
%210 = phi i32 [ %280, %279 ], [ 0, %204 ]
%211 = trunc i64 %209 to i32
%212 = urem i32 %211, 10
%213 = icmp eq i32 %212, 0
br i1 %213, label %214, label %216
214: ; preds = %208
%215 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %211)
br label %216
216: ; preds = %214, %208
br i1 %127, label %217, label %279
217: ; preds = %216
%218 = getelementptr inbounds i16*, i16** %0, i64 %209
%219 = getelementptr inbounds i16*, i16** %1, i64 %209
%220 = add nsw i64 %209, -1
%221 = getelementptr inbounds i16*, i16** %0, i64 %220
%222 = add nuw nsw i64 %209, 1
%223 = getelementptr inbounds i16*, i16** %0, i64 %222
br label %224
224: ; preds = %217, %275
%225 = phi i64 [ 1, %217 ], [ %277, %275 ]
%226 = phi i32 [ %210, %217 ], [ %276, %275 ]
%227 = load i16*, i16** %218
%228 = add nsw i64 %225, -1
%229 = getelementptr inbounds i16, i16* %227, i64 %228
%230 = load i16, i16* %229
%231 = icmp eq i16 %230, 0
br i1 %231, label %232, label %275
232: ; preds = %224
%233 = getelementptr inbounds i16, i16* %227, i64 %225
%234 = load i16, i16* %233
%235 = sext i16 %234 to i32
%236 = icmp eq i32 %129, %235
br i1 %236, label %237, label %275
237: ; preds = %232
%238 = load i16*, i16** %221
%239 = getelementptr inbounds i16, i16* %238, i64 %228
%240 = load i16, i16* %239
%241 = getelementptr inbounds i16, i16* %238, i64 %225
%242 = add nuw nsw i64 %225, 1
%243 = bitcast i16* %241 to <2 x i16>*
%244 = load <2 x i16>, <2 x i16>* %243
%245 = getelementptr inbounds i16, i16* %227, i64 %242
%246 = load i16, i16* %245
%247 = load i16*, i16** %223
%248 = getelementptr inbounds i16, i16* %247, i64 %228
%249 = load i16, i16* %248
%250 = getelementptr inbounds i16, i16* %247, i64 %225
%251 = bitcast i16* %250 to <2 x i16>*
%252 = load <2 x i16>, <2 x i16>* %251
%253 = insertelement <8 x i16> poison, i16 %240, i64 0
%254 = shufflevector <2 x i16> %244, <2 x i16> poison, <8 x i32> <i32 0, i32 1, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
%255 = shufflevector <8 x i16> %253, <8 x i16> %254, <8 x i32> <i32 0, i32 8, i32 9, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
%256 = insertelement <8 x i16> %255, i16 %234, i64 3
%257 = insertelement <8 x i16> %256, i16 %246, i64 4
%258 = insertelement <8 x i16> %257, i16 %249, i64 5
%259 = shufflevector <2 x i16> %252, <2 x i16> poison, <8 x i32> <i32 0, i32 1, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
%260 = shufflevector <8 x i16> %258, <8 x i16> %259, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 8, i32 9>
%261 = icmp eq <8 x i16> %260, zeroinitializer
%262 = bitcast <8 x i1> %261 to i8
%263 = call i8 @llvm.ctpop.i8(i8 %262)
%264 = add nuw nsw i8 %263, 1
%265 = zext i8 %264 to i32
%266 = icmp slt i32 %131, %265
br i1 %266, label %267, label %275
267: ; preds = %237
%268 = trunc i64 %225 to i32
%269 = tail call i32 (i16**, i32, i32, i32, ...) bitcast (i32 (...)* @can_thin to i32 (i16**, i32, i32, i32, ...)*)(i16** %0, i32 %211, i32 %268, i32 %129)
%270 = icmp eq i32 %269, 0
br i1 %270, label %275, label %271
271: ; preds = %267
%272 = load i16*, i16** %219
%273 = getelementptr inbounds i16, i16* %272, i64 %225
store i16 0, i16* %273
%274 = add nsw i32 %226, 1
br label %275
275: ; preds = %224, %232, %267, %271, %237
%276 = phi i32 [ %274, %271 ], [ %226, %267 ], [ %226, %237 ], [ %226, %232 ], [ %226, %224 ]
%277 = add nuw nsw i64 %225, 1
%278 = icmp eq i64 %277, %126
br i1 %278, label %279, label %224
279: ; preds = %275, %216
%280 = phi i32 [ %210, %216 ], [ %276, %275 ]
%281 = add nuw nsw i64 %209, 1
%282 = icmp eq i64 %281, %124
br i1 %282, label %206, label %208
283: ; preds = %206, %400
%284 = phi i64 [ %401, %400 ], [ 0, %206 ]
br i1 %132, label %285, label %400
285: ; preds = %283
%286 = getelementptr inbounds i16*, i16** %1, i64 %284
%287 = load i16*, i16** %286
%288 = getelementptr inbounds i16*, i16** %0, i64 %284
%289 = load i16*, i16** %288
br i1 %137, label %365, label %290
290: ; preds = %285
%291 = getelementptr i16, i16* %289, i64 %6
%292 = getelementptr i16, i16* %287, i64 %6
%293 = icmp ult i16* %289, %292
%294 = icmp ult i16* %287, %291
%295 = and i1 %293, %294
br i1 %295, label %365, label %296
296: ; preds = %290
br i1 %140, label %346, label %297
297: ; preds = %296, %297
%298 = phi i64 [ %343, %297 ], [ 0, %296 ]
%299 = phi i64 [ %344, %297 ], [ 0, %296 ]
%300 = getelementptr inbounds i16, i16* %287, i64 %298
%301 = bitcast i16* %300 to <8 x i16>*
%302 = load <8 x i16>, <8 x i16>* %301
%303 = getelementptr inbounds i16, i16* %300, i64 8
%304 = bitcast i16* %303 to <8 x i16>*
%305 = load <8 x i16>, <8 x i16>* %304
%306 = getelementptr inbounds i16, i16* %289, i64 %298
%307 = bitcast i16* %306 to <8 x i16>*
store <8 x i16> %302, <8 x i16>* %307
%308 = getelementptr inbounds i16, i16* %306, i64 8
%309 = bitcast i16* %308 to <8 x i16>*
store <8 x i16> %305, <8 x i16>* %309
%310 = or i64 %298, 16
%311 = getelementptr inbounds i16, i16* %287, i64 %310
%312 = bitcast i16* %311 to <8 x i16>*
%313 = load <8 x i16>, <8 x i16>* %312
%314 = getelementptr inbounds i16, i16* %311, i64 8
%315 = bitcast i16* %314 to <8 x i16>*
%316 = load <8 x i16>, <8 x i16>* %315
%317 = getelementptr inbounds i16, i16* %289, i64 %310
%318 = bitcast i16* %317 to <8 x i16>*
store <8 x i16> %313, <8 x i16>* %318
%319 = getelementptr inbounds i16, i16* %317, i64 8
%320 = bitcast i16* %319 to <8 x i16>*
store <8 x i16> %316, <8 x i16>* %320
%321 = or i64 %298, 32
%322 = getelementptr inbounds i16, i16* %287, i64 %321
%323 = bitcast i16* %322 to <8 x i16>*
%324 = load <8 x i16>, <8 x i16>* %323
%325 = getelementptr inbounds i16, i16* %322, i64 8
%326 = bitcast i16* %325 to <8 x i16>*
%327 = load <8 x i16>, <8 x i16>* %326
%328 = getelementptr inbounds i16, i16* %289, i64 %321
%329 = bitcast i16* %328 to <8 x i16>*
store <8 x i16> %324, <8 x i16>* %329
%330 = getelementptr inbounds i16, i16* %328, i64 8
%331 = bitcast i16* %330 to <8 x i16>*
store <8 x i16> %327, <8 x i16>* %331
%332 = or i64 %298, 48
%333 = getelementptr inbounds i16, i16* %287, i64 %332
%334 = bitcast i16* %333 to <8 x i16>*
%335 = load <8 x i16>, <8 x i16>* %334
%336 = getelementptr inbounds i16, i16* %333, i64 8
%337 = bitcast i16* %336 to <8 x i16>*
%338 = load <8 x i16>, <8 x i16>* %337
%339 = getelementptr inbounds i16, i16* %289, i64 %332
%340 = bitcast i16* %339 to <8 x i16>*
store <8 x i16> %335, <8 x i16>* %340
%341 = getelementptr inbounds i16, i16* %339, i64 8
%342 = bitcast i16* %341 to <8 x i16>*
store <8 x i16> %338, <8 x i16>* %342
%343 = add nuw i64 %298, 64
%344 = add i64 %299, 4
%345 = icmp eq i64 %344, %141
br i1 %345, label %346, label %297
346: ; preds = %297, %296
%347 = phi i64 [ 0, %296 ], [ %343, %297 ]
br i1 %142, label %364, label %348
348: ; preds = %346, %348
%349 = phi i64 [ %361, %348 ], [ %347, %346 ]
%350 = phi i64 [ %362, %348 ], [ 0, %346 ]
%351 = getelementptr inbounds i16, i16* %287, i64 %349
%352 = bitcast i16* %351 to <8 x i16>*
%353 = load <8 x i16>, <8 x i16>* %352
%354 = getelementptr inbounds i16, i16* %351, i64 8
%355 = bitcast i16* %354 to <8 x i16>*
%356 = load <8 x i16>, <8 x i16>* %355
%357 = getelementptr inbounds i16, i16* %289, i64 %349
%358 = bitcast i16* %357 to <8 x i16>*
store <8 x i16> %353, <8 x i16>* %358
%359 = getelementptr inbounds i16, i16* %357, i64 8
%360 = bitcast i16* %359 to <8 x i16>*
store <8 x i16> %356, <8 x i16>* %360
%361 = add nuw i64 %349, 16
%362 = add i64 %350, 1
%363 = icmp eq i64 %362, %139
br i1 %363, label %364, label %348
364: ; preds = %348, %346
br i1 %143, label %400, label %365
365: ; preds = %290, %285, %364
%366 = phi i64 [ 0, %290 ], [ 0, %285 ], [ %138, %364 ]
%367 = xor i64 %366, -1
%368 = add i64 %367, %6
br i1 %145, label %378, label %369
369: ; preds = %365, %369
%370 = phi i64 [ %375, %369 ], [ %366, %365 ]
%371 = phi i64 [ %376, %369 ], [ 0, %365 ]
%372 = getelementptr inbounds i16, i16* %287, i64 %370
%373 = load i16, i16* %372
%374 = getelementptr inbounds i16, i16* %289, i64 %370
store i16 %373, i16* %374
%375 = add nuw nsw i64 %370, 1
%376 = add i64 %371, 1
%377 = icmp eq i64 %376, %144
br i1 %377, label %378, label %369
378: ; preds = %369, %365
%379 = phi i64 [ %366, %365 ], [ %375, %369 ]
%380 = icmp ult i64 %368, 3
br i1 %380, label %400, label %381
381: ; preds = %378, %381
%382 = phi i64 [ %398, %381 ], [ %379, %378 ]
%383 = getelementptr inbounds i16, i16* %287, i64 %382
%384 = load i16, i16* %383
%385 = getelementptr inbounds i16, i16* %289, i64 %382
store i16 %384, i16* %385
%386 = add nuw nsw i64 %382, 1
%387 = getelementptr inbounds i16, i16* %287, i64 %386
%388 = load i16, i16* %387
%389 = getelementptr inbounds i16, i16* %289, i64 %386
store i16 %388, i16* %389
%390 = add nuw nsw i64 %382, 2
%391 = getelementptr inbounds i16, i16* %287, i64 %390
%392 = load i16, i16* %391
%393 = getelementptr inbounds i16, i16* %289, i64 %390
store i16 %392, i16* %393
%394 = add nuw nsw i64 %382, 3
%395 = getelementptr inbounds i16, i16* %287, i64 %394
%396 = load i16, i16* %395
%397 = getelementptr inbounds i16, i16* %289, i64 %394
store i16 %396, i16* %397
%398 = add nuw nsw i64 %382, 4
%399 = icmp eq i64 %398, %6
br i1 %399, label %400, label %381
400: ; preds = %378, %381, %364, %283
%401 = add nuw nsw i64 %284, 1
%402 = icmp eq i64 %401, %5
br i1 %402, label %403, label %283
403: ; preds = %400, %206
%404 = tail call i32 @putchar(i32 10)
br i1 %125, label %407, label %405
405: ; preds = %477, %403
%406 = phi i32 [ %207, %403 ], [ %478, %477 ]
br i1 %8, label %481, label %601
407: ; preds = %403, %477
%408 = phi i64 [ %479, %477 ], [ 1, %403 ]
%409 = phi i32 [ %478, %477 ], [ %207, %403 ]
%410 = trunc i64 %408 to i32
%411 = urem i32 %410, 10
%412 = icmp eq i32 %411, 0
br i1 %412, label %413, label %415
413: ; preds = %407
%414 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %410)
br label %415
415: ; preds = %413, %407
br i1 %127, label %416, label %477
416: ; preds = %415
%417 = getelementptr inbounds i16*, i16** %0, i64 %408
%418 = getelementptr inbounds i16*, i16** %1, i64 %408
%419 = add nsw i64 %408, -1
%420 = getelementptr inbounds i16*, i16** %0, i64 %419
%421 = add nuw nsw i64 %408, 1
%422 = getelementptr inbounds i16*, i16** %0, i64 %421
br label %423
423: ; preds = %416, %474
%424 = phi i64 [ 1, %416 ], [ %427, %474 ]
%425 = phi i32 [ %409, %416 ], [ %475, %474 ]
%426 = load i16*, i16** %417
%427 = add nuw nsw i64 %424, 1
%428 = getelementptr inbounds i16, i16* %426, i64 %427
%429 = load i16, i16* %428
%430 = icmp eq i16 %429, 0
br i1 %430, label %431, label %474
431: ; preds = %423
%432 = getelementptr inbounds i16, i16* %426, i64 %424
%433 = load i16, i16* %432
%434 = sext i16 %433 to i32
%435 = icmp eq i32 %129, %434
br i1 %435, label %436, label %474
436: ; preds = %431
%437 = add nsw i64 %424, -1
%438 = load i16*, i16** %420
%439 = getelementptr inbounds i16, i16* %438, i64 %437
%440 = load i16, i16* %439
%441 = getelementptr inbounds i16, i16* %438, i64 %424
%442 = bitcast i16* %441 to <2 x i16>*
%443 = load <2 x i16>, <2 x i16>* %442
%444 = getelementptr inbounds i16, i16* %426, i64 %437
%445 = load i16, i16* %444
%446 = load i16*, i16** %422
%447 = getelementptr inbounds i16, i16* %446, i64 %437
%448 = load i16, i16* %447
%449 = getelementptr inbounds i16, i16* %446, i64 %424
%450 = bitcast i16* %449 to <2 x i16>*
%451 = load <2 x i16>, <2 x i16>* %450
%452 = insertelement <8 x i16> poison, i16 %440, i64 0
%453 = shufflevector <2 x i16> %443, <2 x i16> poison, <8 x i32> <i32 0, i32 1, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
%454 = shufflevector <8 x i16> %452, <8 x i16> %453, <8 x i32> <i32 0, i32 8, i32 9, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
%455 = insertelement <8 x i16> %454, i16 %445, i64 3
%456 = insertelement <8 x i16> %455, i16 %433, i64 4
%457 = insertelement <8 x i16> %456, i16 %448, i64 5
%458 = shufflevector <2 x i16> %451, <2 x i16> poison, <8 x i32> <i32 0, i32 1, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
%459 = shufflevector <8 x i16> %457, <8 x i16> %458, <8 x i32> <i32 0, i32 1, i32 2, i32 3, i32 4, i32 5, i32 8, i32 9>
%460 = icmp eq <8 x i16> %459, zeroinitializer
%461 = bitcast <8 x i1> %460 to i8
%462 = call i8 @llvm.ctpop.i8(i8 %461)
%463 = add nuw nsw i8 %462, 1
%464 = zext i8 %463 to i32
%465 = icmp slt i32 %131, %464
br i1 %465, label %466, label %474
466: ; preds = %436
%467 = trunc i64 %424 to i32
%468 = tail call i32 (i16**, i32, i32, i32, ...) bitcast (i32 (...)* @can_thin to i32 (i16**, i32, i32, i32, ...)*)(i16** %0, i32 %410, i32 %467, i32 %129)
%469 = icmp eq i32 %468, 0
br i1 %469, label %474, label %470
470: ; preds = %466
%471 = load i16*, i16** %418
%472 = getelementptr inbounds i16, i16* %471, i64 %424
store i16 0, i16* %472
%473 = add nsw i32 %425, 1
br label %474
474: ; preds = %423, %431, %466, %470, %436
%475 = phi i32 [ %473, %470 ], [ %425, %466 ], [ %425, %436 ], [ %425, %431 ], [ %425, %423 ]
%476 = icmp eq i64 %427, %126
br i1 %476, label %477, label %423
477: ; preds = %474, %415
%478 = phi i32 [ %409, %415 ], [ %475, %474 ]
%479 = add nuw nsw i64 %408, 1
%480 = icmp eq i64 %479, %124
br i1 %480, label %405, label %407
481: ; preds = %405, %598
%482 = phi i64 [ %599, %598 ], [ 0, %405 ]
br i1 %132, label %483, label %598
483: ; preds = %481
%484 = getelementptr inbounds i16*, i16** %1, i64 %482
%485 = load i16*, i16** %484
%486 = getelementptr inbounds i16*, i16** %0, i64 %482
%487 = load i16*, i16** %486
br i1 %146, label %563, label %488
488: ; preds = %483
%489 = getelementptr i16, i16* %487, i64 %6
%490 = getelementptr i16, i16* %485, i64 %6
%491 = icmp ult i16* %487, %490
%492 = icmp ult i16* %485, %489
%493 = and i1 %491, %492
br i1 %493, label %563, label %494
494: ; preds = %488
br i1 %149, label %544, label %495
495: ; preds = %494, %495
%496 = phi i64 [ %541, %495 ], [ 0, %494 ]
%497 = phi i64 [ %542, %495 ], [ 0, %494 ]
%498 = getelementptr inbounds i16, i16* %485, i64 %496
%499 = bitcast i16* %498 to <8 x i16>*
%500 = load <8 x i16>, <8 x i16>* %499
%501 = getelementptr inbounds i16, i16* %498, i64 8
%502 = bitcast i16* %501 to <8 x i16>*
%503 = load <8 x i16>, <8 x i16>* %502
%504 = getelementptr inbounds i16, i16* %487, i64 %496
%505 = bitcast i16* %504 to <8 x i16>*
store <8 x i16> %500, <8 x i16>* %505
%506 = getelementptr inbounds i16, i16* %504, i64 8
%507 = bitcast i16* %506 to <8 x i16>*
store <8 x i16> %503, <8 x i16>* %507
%508 = or i64 %496, 16
%509 = getelementptr inbounds i16, i16* %485, i64 %508
%510 = bitcast i16* %509 to <8 x i16>*
%511 = load <8 x i16>, <8 x i16>* %510
%512 = getelementptr inbounds i16, i16* %509, i64 8
%513 = bitcast i16* %512 to <8 x i16>*
%514 = load <8 x i16>, <8 x i16>* %513
%515 = getelementptr inbounds i16, i16* %487, i64 %508
%516 = bitcast i16* %515 to <8 x i16>*
store <8 x i16> %511, <8 x i16>* %516
%517 = getelementptr inbounds i16, i16* %515, i64 8
%518 = bitcast i16* %517 to <8 x i16>*
store <8 x i16> %514, <8 x i16>* %518
%519 = or i64 %496, 32
%520 = getelementptr inbounds i16, i16* %485, i64 %519
%521 = bitcast i16* %520 to <8 x i16>*
%522 = load <8 x i16>, <8 x i16>* %521
%523 = getelementptr inbounds i16, i16* %520, i64 8
%524 = bitcast i16* %523 to <8 x i16>*
%525 = load <8 x i16>, <8 x i16>* %524
%526 = getelementptr inbounds i16, i16* %487, i64 %519
%527 = bitcast i16* %526 to <8 x i16>*
store <8 x i16> %522, <8 x i16>* %527
%528 = getelementptr inbounds i16, i16* %526, i64 8
%529 = bitcast i16* %528 to <8 x i16>*
store <8 x i16> %525, <8 x i16>* %529
%530 = or i64 %496, 48
%531 = getelementptr inbounds i16, i16* %485, i64 %530
%532 = bitcast i16* %531 to <8 x i16>*
%533 = load <8 x i16>, <8 x i16>* %532
%534 = getelementptr inbounds i16, i16* %531, i64 8
%535 = bitcast i16* %534 to <8 x i16>*
%536 = load <8 x i16>, <8 x i16>* %535
%537 = getelementptr inbounds i16, i16* %487, i64 %530
%538 = bitcast i16* %537 to <8 x i16>*
store <8 x i16> %533, <8 x i16>* %538
%539 = getelementptr inbounds i16, i16* %537, i64 8
%540 = bitcast i16* %539 to <8 x i16>*
store <8 x i16> %536, <8 x i16>* %540
%541 = add nuw i64 %496, 64
%542 = add i64 %497, 4
%543 = icmp eq i64 %542, %150
br i1 %543, label %544, label %495
544: ; preds = %495, %494
%545 = phi i64 [ 0, %494 ], [ %541, %495 ]
br i1 %151, label %562, label %546
546: ; preds = %544, %546
%547 = phi i64 [ %559, %546 ], [ %545, %544 ]
%548 = phi i64 [ %560, %546 ], [ 0, %544 ]
%549 = getelementptr inbounds i16, i16* %485, i64 %547
%550 = bitcast i16* %549 to <8 x i16>*
%551 = load <8 x i16>, <8 x i16>* %550
%552 = getelementptr inbounds i16, i16* %549, i64 8
%553 = bitcast i16* %552 to <8 x i16>*
%554 = load <8 x i16>, <8 x i16>* %553
%555 = getelementptr inbounds i16, i16* %487, i64 %547
%556 = bitcast i16* %555 to <8 x i16>*
store <8 x i16> %551, <8 x i16>* %556
%557 = getelementptr inbounds i16, i16* %555, i64 8
%558 = bitcast i16* %557 to <8 x i16>*
store <8 x i16> %554, <8 x i16>* %558
%559 = add nuw i64 %547, 16
%560 = add i64 %548, 1
%561 = icmp eq i64 %560, %148
br i1 %561, label %562, label %546
562: ; preds = %546, %544
br i1 %152, label %598, label %563
563: ; preds = %488, %483, %562
%564 = phi i64 [ 0, %488 ], [ 0, %483 ], [ %147, %562 ]
%565 = xor i64 %564, -1
%566 = add i64 %565, %6
br i1 %154, label %576, label %567
567: ; preds = %563, %567
%568 = phi i64 [ %573, %567 ], [ %564, %563 ]
%569 = phi i64 [ %574, %567 ], [ 0, %563 ]
%570 = getelementptr inbounds i16, i16* %485, i64 %568
%571 = load i16, i16* %570
%572 = getelementptr inbounds i16, i16* %487, i64 %568
store i16 %571, i16* %572
%573 = add nuw nsw i64 %568, 1
%574 = add i64 %569, 1
%575 = icmp eq i64 %574, %153
br i1 %575, label %576, label %567
576: ; preds = %567, %563
%577 = phi i64 [ %564, %563 ], [ %573, %567 ]
%578 = icmp ult i64 %566, 3
br i1 %578, label %598, label %579
579: ; preds = %576, %579
%580 = phi i64 [ %596, %579 ], [ %577, %576 ]
%581 = getelementptr inbounds i16, i16* %485, i64 %580
%582 = load i16, i16* %581
%583 = getelementptr inbounds i16, i16* %487, i64 %580
store i16 %582, i16* %583
%584 = add nuw nsw i64 %580, 1
%585 = getelementptr inbounds i16, i16* %485, i64 %584
%586 = load i16, i16* %585
%587 = getelementptr inbounds i16, i16* %487, i64 %584
store i16 %586, i16* %587
%588 = add nuw nsw i64 %580, 2
%589 = getelementptr inbounds i16, i16* %485, i64 %588
%590 = load i16, i16* %589
%591 = getelementptr inbounds i16, i16* %487, i64 %588
store i16 %590, i16* %591
%592 = add nuw nsw i64 %580, 3
%593 = getelementptr inbounds i16, i16* %485, i64 %592
%594 = load i16, i16* %593
%595 = getelementptr inbounds i16, i16* %487, i64 %592
store i16 %594, i16* %595
%596 = add nuw nsw i64 %580, 4
%597 = icmp eq i64 %596, %6
br i1 %597, label %598, label %579
598: ; preds = %576, %579, %562, %481
%599 = add nuw nsw i64 %482, 1
%600 = icmp eq i64 %599, %5
br i1 %600, label %601, label %481
601: ; preds = %598, %405
%602 = tail call i32 @putchar(i32 10)
br i1 %127, label %605, label %603
603: ; preds = %688, %601
%604 = phi i32 [ %406, %601 ], [ %689, %688 ]
br i1 %8, label %692, label %812
605: ; preds = %601, %688
%606 = phi i64 [ %690, %688 ], [ 1, %601 ]
%607 = phi i32 [ %689, %688 ], [ %406, %601 ]
%608 = trunc i64 %606 to i32
%609 = urem i32 %608, 10
%610 = icmp eq i32 %609, 0
br i1 %610, label %611, label %613
611: ; preds = %605
%612 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %608)
br label %613
613: ; preds = %611, %605
br i1 %125, label %614, label %688
614: ; preds = %613
%615 = add nsw i64 %606, -1
%616 = add nuw nsw i64 %606, 1
br label %617
617: ; preds = %614, %684
%618 = phi i64 [ 1, %614 ], [ %686, %684 ]
%619 = phi i32 [ %607, %614 ], [ %685, %684 ]
%620 = add nsw i64 %618, -1
%621 = getelementptr inbounds i16*, i16** %0, i64 %620
%622 = load i16*, i16** %621
%623 = getelementptr inbounds i16, i16* %622, i64 %606
%624 = load i16, i16* %623
%625 = icmp eq i16 %624, 0
br i1 %625, label %626, label %684
626: ; preds = %617
%627 = getelementptr inbounds i16*, i16** %0, i64 %618
%628 = load i16*, i16** %627
%629 = getelementptr inbounds i16, i16* %628, i64 %606
%630 = load i16, i16* %629
%631 = sext i16 %630 to i32
%632 = icmp eq i32 %129, %631
br i1 %632, label %633, label %684
633: ; preds = %626
%634 = getelementptr inbounds i16, i16* %622, i64 %615
%635 = load i16, i16* %634
%636 = icmp eq i16 %635, 0
%637 = select i1 %636, i32 2, i32 1
%638 = getelementptr inbounds i16, i16* %622, i64 %616
%639 = load i16, i16* %638
%640 = icmp eq i16 %639, 0
%641 = zext i1 %640 to i32
%642 = add nuw nsw i32 %637, %641
%643 = getelementptr inbounds i16, i16* %628, i64 %615
%644 = load i16, i16* %643
%645 = icmp eq i16 %644, 0
%646 = zext i1 %645 to i32
%647 = add nuw nsw i32 %642, %646
%648 = icmp eq i16 %630, 0
%649 = zext i1 %648 to i32
%650 = add nuw nsw i32 %647, %649
%651 = getelementptr inbounds i16, i16* %628, i64 %616
%652 = load i16, i16* %651
%653 = icmp eq i16 %652, 0
%654 = zext i1 %653 to i32
%655 = add nuw nsw i32 %650, %654
%656 = add nuw nsw i64 %618, 1
%657 = getelementptr inbounds i16*, i16** %0, i64 %656
%658 = load i16*, i16** %657
%659 = getelementptr inbounds i16, i16* %658, i64 %615
%660 = load i16, i16* %659
%661 = icmp eq i16 %660, 0
%662 = zext i1 %661 to i32
%663 = add nuw nsw i32 %655, %662
%664 = getelementptr inbounds i16, i16* %658, i64 %606
%665 = load i16, i16* %664
%666 = icmp eq i16 %665, 0
%667 = zext i1 %666 to i32
%668 = add nuw nsw i32 %663, %667
%669 = getelementptr inbounds i16, i16* %658, i64 %616
%670 = load i16, i16* %669
%671 = icmp eq i16 %670, 0
%672 = zext i1 %671 to i32
%673 = add nuw nsw i32 %668, %672
%674 = icmp sgt i32 %673, %131
br i1 %674, label %675, label %684
675: ; preds = %633
%676 = trunc i64 %618 to i32
%677 = tail call i32 (i16**, i32, i32, i32, ...) bitcast (i32 (...)* @can_thin to i32 (i16**, i32, i32, i32, ...)*)(i16** %0, i32 %676, i32 %608, i32 %129)
%678 = icmp eq i32 %677, 0
br i1 %678, label %684, label %679
679: ; preds = %675
%680 = getelementptr inbounds i16*, i16** %1, i64 %618
%681 = load i16*, i16** %680
%682 = getelementptr inbounds i16, i16* %681, i64 %606
store i16 0, i16* %682
%683 = add nsw i32 %619, 1
br label %684
684: ; preds = %617, %626, %675, %679, %633
%685 = phi i32 [ %683, %679 ], [ %619, %675 ], [ %619, %633 ], [ %619, %626 ], [ %619, %617 ]
%686 = add nuw nsw i64 %618, 1
%687 = icmp eq i64 %686, %124
br i1 %687, label %688, label %617
688: ; preds = %684, %613
%689 = phi i32 [ %607, %613 ], [ %685, %684 ]
%690 = add nuw nsw i64 %606, 1
%691 = icmp eq i64 %690, %126
br i1 %691, label %603, label %605
692: ; preds = %603, %809
%693 = phi i64 [ %810, %809 ], [ 0, %603 ]
br i1 %132, label %694, label %809
694: ; preds = %692
%695 = getelementptr inbounds i16*, i16** %1, i64 %693
%696 = load i16*, i16** %695
%697 = getelementptr inbounds i16*, i16** %0, i64 %693
%698 = load i16*, i16** %697
br i1 %155, label %774, label %699
699: ; preds = %694
%700 = getelementptr i16, i16* %698, i64 %6
%701 = getelementptr i16, i16* %696, i64 %6
%702 = icmp ult i16* %698, %701
%703 = icmp ult i16* %696, %700
%704 = and i1 %702, %703
br i1 %704, label %774, label %705
705: ; preds = %699
br i1 %158, label %755, label %706
706: ; preds = %705, %706
%707 = phi i64 [ %752, %706 ], [ 0, %705 ]
%708 = phi i64 [ %753, %706 ], [ 0, %705 ]
%709 = getelementptr inbounds i16, i16* %696, i64 %707
%710 = bitcast i16* %709 to <8 x i16>*
%711 = load <8 x i16>, <8 x i16>* %710
%712 = getelementptr inbounds i16, i16* %709, i64 8
%713 = bitcast i16* %712 to <8 x i16>*
%714 = load <8 x i16>, <8 x i16>* %713
%715 = getelementptr inbounds i16, i16* %698, i64 %707
%716 = bitcast i16* %715 to <8 x i16>*
store <8 x i16> %711, <8 x i16>* %716
%717 = getelementptr inbounds i16, i16* %715, i64 8
%718 = bitcast i16* %717 to <8 x i16>*
store <8 x i16> %714, <8 x i16>* %718
%719 = or i64 %707, 16
%720 = getelementptr inbounds i16, i16* %696, i64 %719
%721 = bitcast i16* %720 to <8 x i16>*
%722 = load <8 x i16>, <8 x i16>* %721
%723 = getelementptr inbounds i16, i16* %720, i64 8
%724 = bitcast i16* %723 to <8 x i16>*
%725 = load <8 x i16>, <8 x i16>* %724
%726 = getelementptr inbounds i16, i16* %698, i64 %719
%727 = bitcast i16* %726 to <8 x i16>*
store <8 x i16> %722, <8 x i16>* %727
%728 = getelementptr inbounds i16, i16* %726, i64 8
%729 = bitcast i16* %728 to <8 x i16>*
store <8 x i16> %725, <8 x i16>* %729
%730 = or i64 %707, 32
%731 = getelementptr inbounds i16, i16* %696, i64 %730
%732 = bitcast i16* %731 to <8 x i16>*
%733 = load <8 x i16>, <8 x i16>* %732
%734 = getelementptr inbounds i16, i16* %731, i64 8
%735 = bitcast i16* %734 to <8 x i16>*
%736 = load <8 x i16>, <8 x i16>* %735
%737 = getelementptr inbounds i16, i16* %698, i64 %730
%738 = bitcast i16* %737 to <8 x i16>*
store <8 x i16> %733, <8 x i16>* %738
%739 = getelementptr inbounds i16, i16* %737, i64 8
%740 = bitcast i16* %739 to <8 x i16>*
store <8 x i16> %736, <8 x i16>* %740
%741 = or i64 %707, 48
%742 = getelementptr inbounds i16, i16* %696, i64 %741
%743 = bitcast i16* %742 to <8 x i16>*
%744 = load <8 x i16>, <8 x i16>* %743
%745 = getelementptr inbounds i16, i16* %742, i64 8
%746 = bitcast i16* %745 to <8 x i16>*
%747 = load <8 x i16>, <8 x i16>* %746
%748 = getelementptr inbounds i16, i16* %698, i64 %741
%749 = bitcast i16* %748 to <8 x i16>*
store <8 x i16> %744, <8 x i16>* %749
%750 = getelementptr inbounds i16, i16* %748, i64 8
%751 = bitcast i16* %750 to <8 x i16>*
store <8 x i16> %747, <8 x i16>* %751
%752 = add nuw i64 %707, 64
%753 = add i64 %708, 4
%754 = icmp eq i64 %753, %159
br i1 %754, label %755, label %706
755: ; preds = %706, %705
%756 = phi i64 [ 0, %705 ], [ %752, %706 ]
br i1 %160, label %773, label %757
757: ; preds = %755, %757
%758 = phi i64 [ %770, %757 ], [ %756, %755 ]
%759 = phi i64 [ %771, %757 ], [ 0, %755 ]
%760 = getelementptr inbounds i16, i16* %696, i64 %758
%761 = bitcast i16* %760 to <8 x i16>*
%762 = load <8 x i16>, <8 x i16>* %761
%763 = getelementptr inbounds i16, i16* %760, i64 8
%764 = bitcast i16* %763 to <8 x i16>*
%765 = load <8 x i16>, <8 x i16>* %764
%766 = getelementptr inbounds i16, i16* %698, i64 %758
%767 = bitcast i16* %766 to <8 x i16>*
store <8 x i16> %762, <8 x i16>* %767
%768 = getelementptr inbounds i16, i16* %766, i64 8
%769 = bitcast i16* %768 to <8 x i16>*
store <8 x i16> %765, <8 x i16>* %769
%770 = add nuw i64 %758, 16
%771 = add i64 %759, 1
%772 = icmp eq i64 %771, %157
br i1 %772, label %773, label %757
773: ; preds = %757, %755
br i1 %161, label %809, label %774
774: ; preds = %699, %694, %773
%775 = phi i64 [ 0, %699 ], [ 0, %694 ], [ %156, %773 ]
%776 = xor i64 %775, -1
%777 = add i64 %776, %6
br i1 %163, label %787, label %778
778: ; preds = %774, %778
%779 = phi i64 [ %784, %778 ], [ %775, %774 ]
%780 = phi i64 [ %785, %778 ], [ 0, %774 ]
%781 = getelementptr inbounds i16, i16* %696, i64 %779
%782 = load i16, i16* %781
%783 = getelementptr inbounds i16, i16* %698, i64 %779
store i16 %782, i16* %783
%784 = add nuw nsw i64 %779, 1
%785 = add i64 %780, 1
%786 = icmp eq i64 %785, %162
br i1 %786, label %787, label %778
787: ; preds = %778, %774
%788 = phi i64 [ %775, %774 ], [ %784, %778 ]
%789 = icmp ult i64 %777, 3
br i1 %789, label %809, label %790
790: ; preds = %787, %790
%791 = phi i64 [ %807, %790 ], [ %788, %787 ]
%792 = getelementptr inbounds i16, i16* %696, i64 %791
%793 = load i16, i16* %792
%794 = getelementptr inbounds i16, i16* %698, i64 %791
store i16 %793, i16* %794
%795 = add nuw nsw i64 %791, 1
%796 = getelementptr inbounds i16, i16* %696, i64 %795
%797 = load i16, i16* %796
%798 = getelementptr inbounds i16, i16* %698, i64 %795
store i16 %797, i16* %798
%799 = add nuw nsw i64 %791, 2
%800 = getelementptr inbounds i16, i16* %696, i64 %799
%801 = load i16, i16* %800
%802 = getelementptr inbounds i16, i16* %698, i64 %799
store i16 %801, i16* %802
%803 = add nuw nsw i64 %791, 3
%804 = getelementptr inbounds i16, i16* %696, i64 %803
%805 = load i16, i16* %804
%806 = getelementptr inbounds i16, i16* %698, i64 %803
store i16 %805, i16* %806
%807 = add nuw nsw i64 %791, 4
%808 = icmp eq i64 %807, %6
br i1 %808, label %809, label %790
809: ; preds = %787, %790, %773, %692
%810 = add nuw nsw i64 %693, 1
%811 = icmp eq i64 %810, %5
br i1 %811, label %812, label %692
812: ; preds = %809, %603
%813 = tail call i32 @putchar(i32 10)
br i1 %127, label %816, label %814
814: ; preds = %887, %812
%815 = phi i32 [ %604, %812 ], [ %888, %887 ]
br i1 %8, label %891, label %1011
816: ; preds = %812, %887
%817 = phi i64 [ %889, %887 ], [ 1, %812 ]
%818 = phi i32 [ %888, %887 ], [ %604, %812 ]
%819 = trunc i64 %817 to i32
%820 = urem i32 %819, 10
%821 = icmp eq i32 %820, 0
br i1 %821, label %822, label %824
822: ; preds = %816
%823 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %819)
br label %824
824: ; preds = %822, %816
br i1 %125, label %825, label %887
825: ; preds = %824
%826 = add nsw i64 %817, -1
%827 = add nuw nsw i64 %817, 1
br label %828
828: ; preds = %825, %884
%829 = phi i64 [ 1, %825 ], [ %831, %884 ]
%830 = phi i32 [ %818, %825 ], [ %885, %884 ]
%831 = add nuw nsw i64 %829, 1
%832 = getelementptr inbounds i16*, i16** %0, i64 %831
%833 = load i16*, i16** %832
%834 = getelementptr inbounds i16, i16* %833, i64 %817
%835 = load i16, i16* %834
%836 = icmp eq i16 %835, 0
br i1 %836, label %837, label %884
837: ; preds = %828
%838 = getelementptr inbounds i16*, i16** %0, i64 %829
%839 = load i16*, i16** %838
%840 = getelementptr inbounds i16, i16* %839, i64 %817
%841 = load i16, i16* %840
%842 = sext i16 %841 to i32
%843 = icmp eq i32 %129, %842
br i1 %843, label %844, label %884
844: ; preds = %837
%845 = add nsw i64 %829, -1
%846 = getelementptr inbounds i16*, i16** %0, i64 %845
%847 = load i16*, i16** %846
%848 = getelementptr inbounds i16, i16* %847, i64 %826
%849 = load i16, i16* %848
%850 = getelementptr inbounds i16, i16* %847, i64 %817
%851 = bitcast i16* %850 to <2 x i16>*
%852 = load <2 x i16>, <2 x i16>* %851
%853 = getelementptr inbounds i16, i16* %839, i64 %826
%854 = load i16, i16* %853
%855 = getelementptr inbounds i16, i16* %839, i64 %827
%856 = load i16, i16* %855
%857 = getelementptr inbounds i16, i16* %833, i64 %826
%858 = load i16, i16* %857
%859 = getelementptr inbounds i16, i16* %833, i64 %827
%860 = load i16, i16* %859
%861 = insertelement <8 x i16> poison, i16 %849, i64 0
%862 = shufflevector <2 x i16> %852, <2 x i16> poison, <8 x i32> <i32 0, i32 1, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
%863 = shufflevector <8 x i16> %861, <8 x i16> %862, <8 x i32> <i32 0, i32 8, i32 9, i32 undef, i32 undef, i32 undef, i32 undef, i32 undef>
%864 = insertelement <8 x i16> %863, i16 %854, i64 3
%865 = insertelement <8 x i16> %864, i16 %841, i64 4
%866 = insertelement <8 x i16> %865, i16 %856, i64 5
%867 = insertelement <8 x i16> %866, i16 %858, i64 6
%868 = insertelement <8 x i16> %867, i16 %860, i64 7
%869 = icmp eq <8 x i16> %868, zeroinitializer
%870 = bitcast <8 x i1> %869 to i8
%871 = call i8 @llvm.ctpop.i8(i8 %870)
%872 = add nuw nsw i8 %871, 1
%873 = zext i8 %872 to i32
%874 = icmp slt i32 %131, %873
br i1 %874, label %875, label %884
875: ; preds = %844
%876 = trunc i64 %829 to i32
%877 = tail call i32 (i16**, i32, i32, i32, ...) bitcast (i32 (...)* @can_thin to i32 (i16**, i32, i32, i32, ...)*)(i16** %0, i32 %876, i32 %819, i32 %129)
%878 = icmp eq i32 %877, 0
br i1 %878, label %884, label %879
879: ; preds = %875
%880 = getelementptr inbounds i16*, i16** %1, i64 %829
%881 = load i16*, i16** %880
%882 = getelementptr inbounds i16, i16* %881, i64 %817
store i16 0, i16* %882
%883 = add nsw i32 %830, 1
br label %884
884: ; preds = %828, %837, %875, %879, %844
%885 = phi i32 [ %883, %879 ], [ %830, %875 ], [ %830, %844 ], [ %830, %837 ], [ %830, %828 ]
%886 = icmp eq i64 %831, %124
br i1 %886, label %887, label %828
887: ; preds = %884, %824
%888 = phi i32 [ %818, %824 ], [ %885, %884 ]
%889 = add nuw nsw i64 %817, 1
%890 = icmp eq i64 %889, %126
br i1 %890, label %814, label %816
891: ; preds = %814, %1008
%892 = phi i64 [ %1009, %1008 ], [ 0, %814 ]
br i1 %132, label %893, label %1008
893: ; preds = %891
%894 = getelementptr inbounds i16*, i16** %1, i64 %892
%895 = load i16*, i16** %894
%896 = getelementptr inbounds i16*, i16** %0, i64 %892
%897 = load i16*, i16** %896
br i1 %164, label %973, label %898
898: ; preds = %893
%899 = getelementptr i16, i16* %897, i64 %6
%900 = getelementptr i16, i16* %895, i64 %6
%901 = icmp ult i16* %897, %900
%902 = icmp ult i16* %895, %899
%903 = and i1 %901, %902
br i1 %903, label %973, label %904
904: ; preds = %898
br i1 %167, label %954, label %905
905: ; preds = %904, %905
%906 = phi i64 [ %951, %905 ], [ 0, %904 ]
%907 = phi i64 [ %952, %905 ], [ 0, %904 ]
%908 = getelementptr inbounds i16, i16* %895, i64 %906
%909 = bitcast i16* %908 to <8 x i16>*
%910 = load <8 x i16>, <8 x i16>* %909
%911 = getelementptr inbounds i16, i16* %908, i64 8
%912 = bitcast i16* %911 to <8 x i16>*
%913 = load <8 x i16>, <8 x i16>* %912
%914 = getelementptr inbounds i16, i16* %897, i64 %906
%915 = bitcast i16* %914 to <8 x i16>*
store <8 x i16> %910, <8 x i16>* %915
%916 = getelementptr inbounds i16, i16* %914, i64 8
%917 = bitcast i16* %916 to <8 x i16>*
store <8 x i16> %913, <8 x i16>* %917
%918 = or i64 %906, 16
%919 = getelementptr inbounds i16, i16* %895, i64 %918
%920 = bitcast i16* %919 to <8 x i16>*
%921 = load <8 x i16>, <8 x i16>* %920
%922 = getelementptr inbounds i16, i16* %919, i64 8
%923 = bitcast i16* %922 to <8 x i16>*
%924 = load <8 x i16>, <8 x i16>* %923
%925 = getelementptr inbounds i16, i16* %897, i64 %918
%926 = bitcast i16* %925 to <8 x i16>*
store <8 x i16> %921, <8 x i16>* %926
%927 = getelementptr inbounds i16, i16* %925, i64 8
%928 = bitcast i16* %927 to <8 x i16>*
store <8 x i16> %924, <8 x i16>* %928
%929 = or i64 %906, 32
%930 = getelementptr inbounds i16, i16* %895, i64 %929
%931 = bitcast i16* %930 to <8 x i16>*
%932 = load <8 x i16>, <8 x i16>* %931
%933 = getelementptr inbounds i16, i16* %930, i64 8
%934 = bitcast i16* %933 to <8 x i16>*
%935 = load <8 x i16>, <8 x i16>* %934
%936 = getelementptr inbounds i16, i16* %897, i64 %929
%937 = bitcast i16* %936 to <8 x i16>*
store <8 x i16> %932, <8 x i16>* %937
%938 = getelementptr inbounds i16, i16* %936, i64 8
%939 = bitcast i16* %938 to <8 x i16>*
store <8 x i16> %935, <8 x i16>* %939
%940 = or i64 %906, 48
%941 = getelementptr inbounds i16, i16* %895, i64 %940
%942 = bitcast i16* %941 to <8 x i16>*
%943 = load <8 x i16>, <8 x i16>* %942
%944 = getelementptr inbounds i16, i16* %941, i64 8
%945 = bitcast i16* %944 to <8 x i16>*
%946 = load <8 x i16>, <8 x i16>* %945
%947 = getelementptr inbounds i16, i16* %897, i64 %940
%948 = bitcast i16* %947 to <8 x i16>*
store <8 x i16> %943, <8 x i16>* %948
%949 = getelementptr inbounds i16, i16* %947, i64 8
%950 = bitcast i16* %949 to <8 x i16>*
store <8 x i16> %946, <8 x i16>* %950
%951 = add nuw i64 %906, 64
%952 = add i64 %907, 4
%953 = icmp eq i64 %952, %168
br i1 %953, label %954, label %905
954: ; preds = %905, %904
%955 = phi i64 [ 0, %904 ], [ %951, %905 ]
br i1 %169, label %972, label %956
956: ; preds = %954, %956
%957 = phi i64 [ %969, %956 ], [ %955, %954 ]
%958 = phi i64 [ %970, %956 ], [ 0, %954 ]
%959 = getelementptr inbounds i16, i16* %895, i64 %957
%960 = bitcast i16* %959 to <8 x i16>*
%961 = load <8 x i16>, <8 x i16>* %960
%962 = getelementptr inbounds i16, i16* %959, i64 8
%963 = bitcast i16* %962 to <8 x i16>*
%964 = load <8 x i16>, <8 x i16>* %963
%965 = getelementptr inbounds i16, i16* %897, i64 %957
%966 = bitcast i16* %965 to <8 x i16>*
store <8 x i16> %961, <8 x i16>* %966
%967 = getelementptr inbounds i16, i16* %965, i64 8
%968 = bitcast i16* %967 to <8 x i16>*
store <8 x i16> %964, <8 x i16>* %968
%969 = add nuw i64 %957, 16
%970 = add i64 %958, 1
%971 = icmp eq i64 %970, %166
br i1 %971, label %972, label %956
972: ; preds = %956, %954
br i1 %170, label %1008, label %973
973: ; preds = %898, %893, %972
%974 = phi i64 [ 0, %898 ], [ 0, %893 ], [ %165, %972 ]
%975 = xor i64 %974, -1
%976 = add i64 %975, %6
br i1 %172, label %986, label %977
977: ; preds = %973, %977
%978 = phi i64 [ %983, %977 ], [ %974, %973 ]
%979 = phi i64 [ %984, %977 ], [ 0, %973 ]
%980 = getelementptr inbounds i16, i16* %895, i64 %978
%981 = load i16, i16* %980
%982 = getelementptr inbounds i16, i16* %897, i64 %978
store i16 %981, i16* %982
%983 = add nuw nsw i64 %978, 1
%984 = add i64 %979, 1
%985 = icmp eq i64 %984, %171
br i1 %985, label %986, label %977
986: ; preds = %977, %973
%987 = phi i64 [ %974, %973 ], [ %983, %977 ]
%988 = icmp ult i64 %976, 3
br i1 %988, label %1008, label %989
989: ; preds = %986, %989
%990 = phi i64 [ %1006, %989 ], [ %987, %986 ]
%991 = getelementptr inbounds i16, i16* %895, i64 %990
%992 = load i16, i16* %991
%993 = getelementptr inbounds i16, i16* %897, i64 %990
store i16 %992, i16* %993
%994 = add nuw nsw i64 %990, 1
%995 = getelementptr inbounds i16, i16* %895, i64 %994
%996 = load i16, i16* %995
%997 = getelementptr inbounds i16, i16* %897, i64 %994
store i16 %996, i16* %997
%998 = add nuw nsw i64 %990, 2
%999 = getelementptr inbounds i16, i16* %895, i64 %998
%1000 = load i16, i16* %999
%1001 = getelementptr inbounds i16, i16* %897, i64 %998
store i16 %1000, i16* %1001
%1002 = add nuw nsw i64 %990, 3
%1003 = getelementptr inbounds i16, i16* %895, i64 %1002
%1004 = load i16, i16* %1003
%1005 = getelementptr inbounds i16, i16* %897, i64 %1002
store i16 %1004, i16* %1005
%1006 = add nuw nsw i64 %990, 4
%1007 = icmp eq i64 %1006, %6
br i1 %1007, label %1008, label %989
1008: ; preds = %986, %989, %972, %891
%1009 = add nuw nsw i64 %892, 1
%1010 = icmp eq i64 %1009, %5
br i1 %1010, label %1011, label %891
1011: ; preds = %1008, %814
%1012 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([20 x i8], [20 x i8]* @.str.2, i64 0, i64 0), i32 %815)
%1013 = icmp eq i32 %815, 0
%1014 = or i1 %1013, %133
%1015 = select i1 %1013, i32 0, i32 %123
br i1 %1014, label %1136, label %1016
1016: ; preds = %1011, %1133
%1017 = phi i64 [ %1134, %1133 ], [ 0, %1011 ]
br i1 %132, label %1018, label %1133
1018: ; preds = %1016
%1019 = getelementptr inbounds i16*, i16** %1, i64 %1017
%1020 = load i16*, i16** %1019
%1021 = getelementptr inbounds i16*, i16** %0, i64 %1017
%1022 = load i16*, i16** %1021
br i1 %173, label %1098, label %1023
1023: ; preds = %1018
%1024 = getelementptr i16, i16* %1022, i64 %6
%1025 = getelementptr i16, i16* %1020, i64 %6
%1026 = icmp ult i16* %1022, %1025
%1027 = icmp ult i16* %1020, %1024
%1028 = and i1 %1026, %1027
br i1 %1028, label %1098, label %1029
1029: ; preds = %1023
br i1 %176, label %1079, label %1030
1030: ; preds = %1029, %1030
%1031 = phi i64 [ %1076, %1030 ], [ 0, %1029 ]
%1032 = phi i64 [ %1077, %1030 ], [ 0, %1029 ]
%1033 = getelementptr inbounds i16, i16* %1020, i64 %1031
%1034 = bitcast i16* %1033 to <8 x i16>*
%1035 = load <8 x i16>, <8 x i16>* %1034
%1036 = getelementptr inbounds i16, i16* %1033, i64 8
%1037 = bitcast i16* %1036 to <8 x i16>*
%1038 = load <8 x i16>, <8 x i16>* %1037
%1039 = getelementptr inbounds i16, i16* %1022, i64 %1031
%1040 = bitcast i16* %1039 to <8 x i16>*
store <8 x i16> %1035, <8 x i16>* %1040
%1041 = getelementptr inbounds i16, i16* %1039, i64 8
%1042 = bitcast i16* %1041 to <8 x i16>*
store <8 x i16> %1038, <8 x i16>* %1042
%1043 = or i64 %1031, 16
%1044 = getelementptr inbounds i16, i16* %1020, i64 %1043
%1045 = bitcast i16* %1044 to <8 x i16>*
%1046 = load <8 x i16>, <8 x i16>* %1045
%1047 = getelementptr inbounds i16, i16* %1044, i64 8
%1048 = bitcast i16* %1047 to <8 x i16>*
%1049 = load <8 x i16>, <8 x i16>* %1048
%1050 = getelementptr inbounds i16, i16* %1022, i64 %1043
%1051 = bitcast i16* %1050 to <8 x i16>*
store <8 x i16> %1046, <8 x i16>* %1051
%1052 = getelementptr inbounds i16, i16* %1050, i64 8
%1053 = bitcast i16* %1052 to <8 x i16>*
store <8 x i16> %1049, <8 x i16>* %1053
%1054 = or i64 %1031, 32
%1055 = getelementptr inbounds i16, i16* %1020, i64 %1054
%1056 = bitcast i16* %1055 to <8 x i16>*
%1057 = load <8 x i16>, <8 x i16>* %1056
%1058 = getelementptr inbounds i16, i16* %1055, i64 8
%1059 = bitcast i16* %1058 to <8 x i16>*
%1060 = load <8 x i16>, <8 x i16>* %1059
%1061 = getelementptr inbounds i16, i16* %1022, i64 %1054
%1062 = bitcast i16* %1061 to <8 x i16>*
store <8 x i16> %1057, <8 x i16>* %1062
%1063 = getelementptr inbounds i16, i16* %1061, i64 8
%1064 = bitcast i16* %1063 to <8 x i16>*
store <8 x i16> %1060, <8 x i16>* %1064
%1065 = or i64 %1031, 48
%1066 = getelementptr inbounds i16, i16* %1020, i64 %1065
%1067 = bitcast i16* %1066 to <8 x i16>*
%1068 = load <8 x i16>, <8 x i16>* %1067
%1069 = getelementptr inbounds i16, i16* %1066, i64 8
%1070 = bitcast i16* %1069 to <8 x i16>*
%1071 = load <8 x i16>, <8 x i16>* %1070
%1072 = getelementptr inbounds i16, i16* %1022, i64 %1065
%1073 = bitcast i16* %1072 to <8 x i16>*
store <8 x i16> %1068, <8 x i16>* %1073
%1074 = getelementptr inbounds i16, i16* %1072, i64 8
%1075 = bitcast i16* %1074 to <8 x i16>*
store <8 x i16> %1071, <8 x i16>* %1075
%1076 = add nuw i64 %1031, 64
%1077 = add i64 %1032, 4
%1078 = icmp eq i64 %1077, %177
br i1 %1078, label %1079, label %1030
1079: ; preds = %1030, %1029
%1080 = phi i64 [ 0, %1029 ], [ %1076, %1030 ]
br i1 %178, label %1097, label %1081
1081: ; preds = %1079, %1081
%1082 = phi i64 [ %1094, %1081 ], [ %1080, %1079 ]
%1083 = phi i64 [ %1095, %1081 ], [ 0, %1079 ]
%1084 = getelementptr inbounds i16, i16* %1020, i64 %1082
%1085 = bitcast i16* %1084 to <8 x i16>*
%1086 = load <8 x i16>, <8 x i16>* %1085
%1087 = getelementptr inbounds i16, i16* %1084, i64 8
%1088 = bitcast i16* %1087 to <8 x i16>*
%1089 = load <8 x i16>, <8 x i16>* %1088
%1090 = getelementptr inbounds i16, i16* %1022, i64 %1082
%1091 = bitcast i16* %1090 to <8 x i16>*
store <8 x i16> %1086, <8 x i16>* %1091
%1092 = getelementptr inbounds i16, i16* %1090, i64 8
%1093 = bitcast i16* %1092 to <8 x i16>*
store <8 x i16> %1089, <8 x i16>* %1093
%1094 = add nuw i64 %1082, 16
%1095 = add i64 %1083, 1
%1096 = icmp eq i64 %1095, %175
br i1 %1096, label %1097, label %1081
1097: ; preds = %1081, %1079
br i1 %179, label %1133, label %1098
1098: ; preds = %1023, %1018, %1097
%1099 = phi i64 [ 0, %1023 ], [ 0, %1018 ], [ %174, %1097 ]
%1100 = xor i64 %1099, -1
%1101 = add i64 %1100, %6
br i1 %181, label %1111, label %1102
1102: ; preds = %1098, %1102
%1103 = phi i64 [ %1108, %1102 ], [ %1099, %1098 ]
%1104 = phi i64 [ %1109, %1102 ], [ 0, %1098 ]
%1105 = getelementptr inbounds i16, i16* %1020, i64 %1103
%1106 = load i16, i16* %1105
%1107 = getelementptr inbounds i16, i16* %1022, i64 %1103
store i16 %1106, i16* %1107
%1108 = add nuw nsw i64 %1103, 1
%1109 = add i64 %1104, 1
%1110 = icmp eq i64 %1109, %180
br i1 %1110, label %1111, label %1102
1111: ; preds = %1102, %1098
%1112 = phi i64 [ %1099, %1098 ], [ %1108, %1102 ]
%1113 = icmp ult i64 %1101, 3
br i1 %1113, label %1133, label %1114
1114: ; preds = %1111, %1114
%1115 = phi i64 [ %1131, %1114 ], [ %1112, %1111 ]
%1116 = getelementptr inbounds i16, i16* %1020, i64 %1115
%1117 = load i16, i16* %1116
%1118 = getelementptr inbounds i16, i16* %1022, i64 %1115
store i16 %1117, i16* %1118
%1119 = add nuw nsw i64 %1115, 1
%1120 = getelementptr inbounds i16, i16* %1020, i64 %1119
%1121 = load i16, i16* %1120
%1122 = getelementptr inbounds i16, i16* %1022, i64 %1119
store i16 %1121, i16* %1122
%1123 = add nuw nsw i64 %1115, 2
%1124 = getelementptr inbounds i16, i16* %1020, i64 %1123
%1125 = load i16, i16* %1124
%1126 = getelementptr inbounds i16, i16* %1022, i64 %1123
store i16 %1125, i16* %1126
%1127 = add nuw nsw i64 %1115, 3
%1128 = getelementptr inbounds i16, i16* %1020, i64 %1127
%1129 = load i16, i16* %1128
%1130 = getelementptr inbounds i16, i16* %1022, i64 %1127
store i16 %1129, i16* %1130
%1131 = add nuw nsw i64 %1115, 4
%1132 = icmp eq i64 %1131, %6
br i1 %1132, label %1133, label %1114
1133: ; preds = %1111, %1114, %1097, %1016
%1134 = add nuw nsw i64 %1017, 1
%1135 = icmp eq i64 %1134, %5
br i1 %1135, label %1136, label %1016
1136: ; preds = %1133, %1011
%1137 = phi i32 [ %1015, %1011 ], [ %123, %1133 ]
%1138 = icmp eq i32 %1137, 0
br i1 %1138, label %1139, label %204
1139: ; preds = %1136
ret i32 1
}