int dilate_not_join(the_image, out_image, value, threshold, rows, cols)
short **the_image, **out_image, threshold, value;
long cols, rows;
{
  int a, b, count, i, j, k;
  for (i = 0; i < rows; i++)
    for (j = 0; j < cols; j++)
      out_image[i][j] = the_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] == value && the_image[i][j] == 0) {
        count = 0;
        for (a = -1; a <= 1; a++) {
          for (b = -1; b <= 1; b++) {
            if (the_image[i + a][j + b] == value)
              count++;
          }
        }
        if (count > threshold) {
          if (can_dilate(the_image, i, j, value)) {
            out_image[i][j] = value;
          }
        }
      }
    }
  }
  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] == value && the_image[i][j] == 0) {
        count = 0;
        for (a = -1; a <= 1; a++) {
          for (b = -1; b <= 1; b++) {
            if (the_image[i + a][j + b] == value)
              count++;
          }
        }
        if (count > threshold) {
          if (can_dilate(the_image, i, j, value)) {
            out_image[i][j] = value;
          }
        }
      }
    }
  }
  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] == value && the_image[i][j] == 0) {
        count = 0;
        for (a = -1; a <= 1; a++) {
          for (b = -1; b <= 1; b++) {
            if (the_image[i + a][j + b] == value)
              count++;
          }
        }
        if (count > threshold) {
          if (can_dilate(the_image, i, j, value)) {
            out_image[i][j] = value;
          }
        }
      }
    }
  }
  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] == value && the_image[i][j] == 0) {
        count = 0;
        for (a = -1; a <= 1; a++) {
          for (b = -1; b <= 1; b++) {
            if (the_image[i + a][j + b] == value)
              count++;
          }
        }
        if (count > threshold) {
          if (can_dilate(the_image, i, j, value)) {
            out_image[i][j] = value;
          }
        }
      }
    }
  }
  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):
<dilate_not_join>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %ecx,%eax
mov    %dx,%cx
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %cx,-0x12(%rbp)
mov    %ax,-0x14(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
movl   $0x0,-0x38(%rbp)
movslq -0x38(%rbp),%rax
cmp    -0x20(%rbp),%rax
jge    11b8 <dilate_not_join+0x98>
movl   $0x0,-0x3c(%rbp)
movslq -0x3c(%rbp),%rax
cmp    -0x28(%rbp),%rax
jge    11a5 <dilate_not_join+0x85>
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,2),%dx
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1161 <dilate_not_join+0x41>
jmp    11aa <dilate_not_join+0x8a>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    114c <dilate_not_join+0x2c>
lea    0xe41(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x38(%rbp)
movslq -0x38(%rbp),%rax
mov    -0x20(%rbp),%rcx
sub    $0x1,%rcx
cmp    %rcx,%rax
jge    135c <dilate_not_join+0x23c>
mov    -0x38(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    1207 <dilate_not_join+0xe7>
mov    -0x38(%rbp),%esi
lea    0xe02(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x3c(%rbp)
movslq -0x3c(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    $0x1,%rcx
cmp    %rcx,%rax
jge    1349 <dilate_not_join+0x229>
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movswl (%rax,%rcx,2),%eax
movswl -0x12(%rbp),%ecx
cmp    %ecx,%eax
jne    1336 <dilate_not_join+0x216>
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
cmp    $0x0,%eax
jne    1336 <dilate_not_join+0x216>
movl   $0x0,-0x34(%rbp)
movl   $0xffffffff,-0x2c(%rbp)
cmpl   $0x1,-0x2c(%rbp)
jg     12e7 <dilate_not_join+0x1c7>
movl   $0xffffffff,-0x30(%rbp)
cmpl   $0x1,-0x30(%rbp)
jg     12d4 <dilate_not_join+0x1b4>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x3c(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movswl (%rax,%rcx,2),%eax
movswl -0x12(%rbp),%ecx
cmp    %ecx,%eax
jne    12c1 <dilate_not_join+0x1a1>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    12c6 <dilate_not_join+0x1a6>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1284 <dilate_not_join+0x164>
jmp    12d9 <dilate_not_join+0x1b9>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1273 <dilate_not_join+0x153>
mov    -0x34(%rbp),%eax
movswl -0x14(%rbp),%ecx
cmp    %ecx,%eax
jle    1331 <dilate_not_join+0x211>
mov    -0x8(%rbp),%rdi
mov    -0x38(%rbp),%esi
mov    -0x3c(%rbp),%edx
movswl -0x12(%rbp),%ecx
mov    $0x0,%al
call   1040 <can_dilate@plt>
cmp    $0x0,%eax
je     132c <dilate_not_join+0x20c>
mov    -0x12(%rbp),%dx
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
jmp    1331 <dilate_not_join+0x211>
jmp    1336 <dilate_not_join+0x216>
jmp    133b <dilate_not_join+0x21b>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    120e <dilate_not_join+0xee>
jmp    134e <dilate_not_join+0x22e>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    11cd <dilate_not_join+0xad>
movl   $0x0,-0x38(%rbp)
movslq -0x38(%rbp),%rax
cmp    -0x20(%rbp),%rax
jge    13cf <dilate_not_join+0x2af>
movl   $0x0,-0x3c(%rbp)
movslq -0x3c(%rbp),%rax
cmp    -0x28(%rbp),%rax
jge    13bc <dilate_not_join+0x29c>
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,2),%dx
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1378 <dilate_not_join+0x258>
jmp    13c1 <dilate_not_join+0x2a1>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1363 <dilate_not_join+0x243>
lea    0xc2a(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x38(%rbp)
movslq -0x38(%rbp),%rax
mov    -0x20(%rbp),%rcx
sub    $0x1,%rcx
cmp    %rcx,%rax
jge    1573 <dilate_not_join+0x453>
mov    -0x38(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    141e <dilate_not_join+0x2fe>
mov    -0x38(%rbp),%esi
lea    0xbeb(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x3c(%rbp)
movslq -0x3c(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    $0x1,%rcx
cmp    %rcx,%rax
jge    1560 <dilate_not_join+0x440>
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x3c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movswl (%rax,%rcx,2),%eax
movswl -0x12(%rbp),%ecx
cmp    %ecx,%eax
jne    154d <dilate_not_join+0x42d>
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
cmp    $0x0,%eax
jne    154d <dilate_not_join+0x42d>
movl   $0x0,-0x34(%rbp)
movl   $0xffffffff,-0x2c(%rbp)
cmpl   $0x1,-0x2c(%rbp)
jg     14fe <dilate_not_join+0x3de>
movl   $0xffffffff,-0x30(%rbp)
cmpl   $0x1,-0x30(%rbp)
jg     14eb <dilate_not_join+0x3cb>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x3c(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movswl (%rax,%rcx,2),%eax
movswl -0x12(%rbp),%ecx
cmp    %ecx,%eax
jne    14d8 <dilate_not_join+0x3b8>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    14dd <dilate_not_join+0x3bd>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    149b <dilate_not_join+0x37b>
jmp    14f0 <dilate_not_join+0x3d0>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    148a <dilate_not_join+0x36a>
mov    -0x34(%rbp),%eax
movswl -0x14(%rbp),%ecx
cmp    %ecx,%eax
jle    1548 <dilate_not_join+0x428>
mov    -0x8(%rbp),%rdi
mov    -0x38(%rbp),%esi
mov    -0x3c(%rbp),%edx
movswl -0x12(%rbp),%ecx
mov    $0x0,%al
call   1040 <can_dilate@plt>
cmp    $0x0,%eax
je     1543 <dilate_not_join+0x423>
mov    -0x12(%rbp),%dx
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
jmp    1548 <dilate_not_join+0x428>
jmp    154d <dilate_not_join+0x42d>
jmp    1552 <dilate_not_join+0x432>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1425 <dilate_not_join+0x305>
jmp    1565 <dilate_not_join+0x445>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    13e4 <dilate_not_join+0x2c4>
movl   $0x0,-0x38(%rbp)
movslq -0x38(%rbp),%rax
cmp    -0x20(%rbp),%rax
jge    15e6 <dilate_not_join+0x4c6>
movl   $0x0,-0x3c(%rbp)
movslq -0x3c(%rbp),%rax
cmp    -0x28(%rbp),%rax
jge    15d3 <dilate_not_join+0x4b3>
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,2),%dx
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    158f <dilate_not_join+0x46f>
jmp    15d8 <dilate_not_join+0x4b8>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    157a <dilate_not_join+0x45a>
lea    0xa13(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x3c(%rbp)
movslq -0x3c(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    $0x1,%rcx
cmp    %rcx,%rax
jge    178a <dilate_not_join+0x66a>
mov    -0x3c(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    1635 <dilate_not_join+0x515>
mov    -0x3c(%rbp),%esi
lea    0x9d4(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x38(%rbp)
movslq -0x38(%rbp),%rax
mov    -0x20(%rbp),%rcx
sub    $0x1,%rcx
cmp    %rcx,%rax
jge    1777 <dilate_not_join+0x657>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
movswl -0x12(%rbp),%ecx
cmp    %ecx,%eax
jne    1764 <dilate_not_join+0x644>
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
cmp    $0x0,%eax
jne    1764 <dilate_not_join+0x644>
movl   $0x0,-0x34(%rbp)
movl   $0xffffffff,-0x2c(%rbp)
cmpl   $0x1,-0x2c(%rbp)
jg     1715 <dilate_not_join+0x5f5>
movl   $0xffffffff,-0x30(%rbp)
cmpl   $0x1,-0x30(%rbp)
jg     1702 <dilate_not_join+0x5e2>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x3c(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movswl (%rax,%rcx,2),%eax
movswl -0x12(%rbp),%ecx
cmp    %ecx,%eax
jne    16ef <dilate_not_join+0x5cf>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    16f4 <dilate_not_join+0x5d4>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    16b2 <dilate_not_join+0x592>
jmp    1707 <dilate_not_join+0x5e7>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    16a1 <dilate_not_join+0x581>
mov    -0x34(%rbp),%eax
movswl -0x14(%rbp),%ecx
cmp    %ecx,%eax
jle    175f <dilate_not_join+0x63f>
mov    -0x8(%rbp),%rdi
mov    -0x38(%rbp),%esi
mov    -0x3c(%rbp),%edx
movswl -0x12(%rbp),%ecx
mov    $0x0,%al
call   1040 <can_dilate@plt>
cmp    $0x0,%eax
je     175a <dilate_not_join+0x63a>
mov    -0x12(%rbp),%dx
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
jmp    175f <dilate_not_join+0x63f>
jmp    1764 <dilate_not_join+0x644>
jmp    1769 <dilate_not_join+0x649>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    163c <dilate_not_join+0x51c>
jmp    177c <dilate_not_join+0x65c>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    15fb <dilate_not_join+0x4db>
movl   $0x0,-0x38(%rbp)
movslq -0x38(%rbp),%rax
cmp    -0x20(%rbp),%rax
jge    17fd <dilate_not_join+0x6dd>
movl   $0x0,-0x3c(%rbp)
movslq -0x3c(%rbp),%rax
cmp    -0x28(%rbp),%rax
jge    17ea <dilate_not_join+0x6ca>
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,2),%dx
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    17a6 <dilate_not_join+0x686>
jmp    17ef <dilate_not_join+0x6cf>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1791 <dilate_not_join+0x671>
lea    0x7fc(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x3c(%rbp)
movslq -0x3c(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    $0x1,%rcx
cmp    %rcx,%rax
jge    19a1 <dilate_not_join+0x881>
mov    -0x3c(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    184c <dilate_not_join+0x72c>
mov    -0x3c(%rbp),%esi
lea    0x7bd(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x1,-0x38(%rbp)
movslq -0x38(%rbp),%rax
mov    -0x20(%rbp),%rcx
sub    $0x1,%rcx
cmp    %rcx,%rax
jge    198e <dilate_not_join+0x86e>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
movswl -0x12(%rbp),%ecx
cmp    %ecx,%eax
jne    197b <dilate_not_join+0x85b>
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movswl (%rax,%rcx,2),%eax
cmp    $0x0,%eax
jne    197b <dilate_not_join+0x85b>
movl   $0x0,-0x34(%rbp)
movl   $0xffffffff,-0x2c(%rbp)
cmpl   $0x1,-0x2c(%rbp)
jg     192c <dilate_not_join+0x80c>
movl   $0xffffffff,-0x30(%rbp)
cmpl   $0x1,-0x30(%rbp)
jg     1919 <dilate_not_join+0x7f9>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x3c(%rbp),%ecx
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movswl (%rax,%rcx,2),%eax
movswl -0x12(%rbp),%ecx
cmp    %ecx,%eax
jne    1906 <dilate_not_join+0x7e6>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    190b <dilate_not_join+0x7eb>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    18c9 <dilate_not_join+0x7a9>
jmp    191e <dilate_not_join+0x7fe>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    18b8 <dilate_not_join+0x798>
mov    -0x34(%rbp),%eax
movswl -0x14(%rbp),%ecx
cmp    %ecx,%eax
jle    1976 <dilate_not_join+0x856>
mov    -0x8(%rbp),%rdi
mov    -0x38(%rbp),%esi
mov    -0x3c(%rbp),%edx
movswl -0x12(%rbp),%ecx
mov    $0x0,%al
call   1040 <can_dilate@plt>
cmp    $0x0,%eax
je     1971 <dilate_not_join+0x851>
mov    -0x12(%rbp),%dx
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
jmp    1976 <dilate_not_join+0x856>
jmp    197b <dilate_not_join+0x85b>
jmp    1980 <dilate_not_join+0x860>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1853 <dilate_not_join+0x733>
jmp    1993 <dilate_not_join+0x873>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1812 <dilate_not_join+0x6f2>
movl   $0x0,-0x38(%rbp)
movslq -0x38(%rbp),%rax
cmp    -0x20(%rbp),%rax
jge    1a14 <dilate_not_join+0x8f4>
movl   $0x0,-0x3c(%rbp)
movslq -0x3c(%rbp),%rax
cmp    -0x28(%rbp),%rax
jge    1a01 <dilate_not_join+0x8e1>
mov    -0x10(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,2),%dx
mov    -0x8(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    19bd <dilate_not_join+0x89d>
jmp    1a06 <dilate_not_join+0x8e6>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    19a8 <dilate_not_join+0x888>
mov    $0x1,%eax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<dilate_not_join>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    %r9,%r12
mov    %r8,%r13
mov    %ecx,0x2c(%rsp)
mov    %edx,0x8(%rsp)
mov    %rsi,0x20(%rsp)
mov    %rdi,%r14
movabs $0x1ffffffffffffffc,%rax
ff ff 1f
test   %r8,%r8
mov    %r9,0x38(%rsp)
mov    %r8,0x30(%rsp)
jle    14a0 <dilate_not_join+0x370>
lea    -0x10(%r12),%rcx
mov    %rcx,0x48(%rsp)
mov    %rcx,%r8
shr    $0x4,%r8
add    $0x1,%r8
mov    %r12,%r10
and    $0xfffffffffffffff0,%r10
mov    %r8d,%r9d
and    $0x3,%r9d
mov    %r8,0x50(%rsp)
and    %rax,%r8
mov    %r12d,%r11d
and    $0x3,%r11d
mov    %r9,%r15
shl    $0x5,%r15
xor    %ebp,%ebp
jmp    11bd <dilate_not_join+0x8d>
xchg   %ax,%ax
add    $0x1,%rbp
cmp    %r13,%rbp
je     130c <dilate_not_join+0x1dc>
test   %r12,%r12
jle    11b0 <dilate_not_join+0x80>
mov    (%r14,%rbp,8),%rbx
mov    0x20(%rsp),%rax
mov    (%rax,%rbp,8),%rdx
cmp    $0x10,%r12
jb     11e7 <dilate_not_join+0xb7>
lea    (%rbx,%r12,2),%rax
cmp    %rax,%rdx
jae    1254 <dilate_not_join+0x124>
lea    (%rdx,%r12,2),%rax
cmp    %rax,%rbx
jae    1254 <dilate_not_join+0x124>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
add    %r12,%rcx
test   %r11,%r11
je     1212 <dilate_not_join+0xe2>
mov    %r11,%rsi
nopw   0x0(%rax,%rax,1)
movzwl (%rbx,%rax,2),%edi
mov    %di,(%rdx,%rax,2)
add    $0x1,%rax
add    $0xffffffffffffffff,%rsi
jne    1200 <dilate_not_join+0xd0>
cmp    $0x3,%rcx
jb     11b0 <dilate_not_join+0x80>
nopl   0x0(%rax,%rax,1)
movzwl (%rbx,%rax,2),%ecx
mov    %cx,(%rdx,%rax,2)
movzwl 0x2(%rbx,%rax,2),%ecx
mov    %cx,0x2(%rdx,%rax,2)
movzwl 0x4(%rbx,%rax,2),%ecx
mov    %cx,0x4(%rdx,%rax,2)
movzwl 0x6(%rbx,%rax,2),%ecx
mov    %cx,0x6(%rdx,%rax,2)
add    $0x4,%rax
cmp    %rax,%r12
jne    1220 <dilate_not_join+0xf0>
jmp    11b0 <dilate_not_join+0x80>
cmpq   $0x30,0x48(%rsp)
jae    1260 <dilate_not_join+0x130>
xor    %eax,%eax
jmp    12c8 <dilate_not_join+0x198>
mov    %r8,%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nop
movups (%rbx,%rax,2),%xmm0
movups 0x10(%rbx,%rax,2),%xmm1
movups %xmm0,(%rdx,%rax,2)
movups %xmm1,0x10(%rdx,%rax,2)
movups 0x20(%rbx,%rax,2),%xmm0
movups 0x30(%rbx,%rax,2),%xmm1
movups %xmm0,0x20(%rdx,%rax,2)
movups %xmm1,0x30(%rdx,%rax,2)
movups 0x40(%rbx,%rax,2),%xmm0
movups 0x50(%rbx,%rax,2),%xmm1
movups %xmm0,0x40(%rdx,%rax,2)
movups %xmm1,0x50(%rdx,%rax,2)
movups 0x60(%rbx,%rax,2),%xmm0
movups 0x70(%rbx,%rax,2),%xmm1
movups %xmm0,0x60(%rdx,%rax,2)
movups %xmm1,0x70(%rdx,%rax,2)
add    $0x40,%rax
add    $0xfffffffffffffffc,%rcx
jne    1270 <dilate_not_join+0x140>
test   %r9,%r9
je     12fb <dilate_not_join+0x1cb>
lea    (%rdx,%rax,2),%rcx
add    $0x10,%rcx
lea    (%rbx,%rax,2),%rax
add    $0x10,%rax
xor    %esi,%esi
nop
movups -0x10(%rax,%rsi,1),%xmm0
movups (%rax,%rsi,1),%xmm1
movups %xmm0,-0x10(%rcx,%rsi,1)
movups %xmm1,(%rcx,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%r15
jne    12e0 <dilate_not_join+0x1b0>
mov    %r10,%rax
cmp    %r12,%r10
je     11b0 <dilate_not_join+0x80>
jmp    11e9 <dilate_not_join+0xb9>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    -0x1(%r13),%r9
cmp    $0x3,%r13
setge  %al
mov    %r9,0x10(%rsp)
jl     14ca <dilate_not_join+0x39a>
mov    %eax,0x1c(%rsp)
mov    %r12,%rdx
mov    0x8(%rsp),%eax
movswl %ax,%r13d
movswl 0x2c(%rsp),%ecx
mov    %ecx,0xc(%rsp)
xor    %r12d,%r12d
test   $0xffff,%eax
sete   %r12b
mov    $0x2,%r15d
sub    %rdx,%r15
mov    $0x1,%ebp
jmp    136d <dilate_not_join+0x23d>
add    $0x1,%rbp
cmp    %r9,%rbp
je     14dc <dilate_not_join+0x3ac>
imul   $0xcccccccd,%ebp,%eax
ror    %eax
cmp    $0x19999999,%eax
jbe    1390 <dilate_not_join+0x260>
cmpq   $0x3,0x38(%rsp)
jl     1360 <dilate_not_join+0x230>
jmp    13ad <dilate_not_join+0x27d>
cs nopw 0x0(%rax,%rax,1)
lea    0x1c69(%rip),%rdi
mov    %ebp,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x10(%rsp),%r9
cmpq   $0x3,0x38(%rsp)
jl     1360 <dilate_not_join+0x230>
mov    $0x1,%ebx
jmp    13d2 <dilate_not_join+0x2a2>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    (%r15,%rbx,1),%rax
add    $0x1,%rax
add    $0x1,%rbx
cmp    $0x1,%rax
je     1360 <dilate_not_join+0x230>
mov    (%r14,%rbp,8),%rcx
movswl -0x2(%rcx,%rbx,2),%eax
cmp    %eax,%r13d
jne    13c0 <dilate_not_join+0x290>
cmpw   $0x0,(%rcx,%rbx,2)
jne    13c0 <dilate_not_join+0x290>
mov    -0x8(%r14,%rbp,8),%rdx
mov    0x8(%r14,%rbp,8),%r8
movswl -0x2(%rdx,%rbx,2),%esi
xor    %edi,%edi
cmp    %esi,%r13d
sete   %dil
movswl (%rdx,%rbx,2),%esi
xor    %eax,%eax
cmp    %esi,%r13d
sete   %al
add    %edi,%eax
movswl 0x2(%rdx,%rbx,2),%edx
xor    %esi,%esi
cmp    %edx,%r13d
sete   %sil
add    %eax,%esi
add    %r12d,%esi
movswl 0x2(%rcx,%rbx,2),%eax
xor    %ecx,%ecx
cmp    %eax,%r13d
sete   %cl
add    %esi,%ecx
movswl -0x2(%r8,%rbx,2),%eax
xor    %edx,%edx
cmp    %eax,%r13d
sete   %dl
add    %ecx,%edx
movswl (%r8,%rbx,2),%eax
xor    %ecx,%ecx
cmp    %eax,%r13d
sete   %cl
add    %edx,%ecx
movswl 0x2(%r8,%rbx,2),%eax
xor    %edx,%edx
cmp    %eax,%r13d
sete   %dl
lea    (%rdx,%rcx,1),%eax
add    $0x1,%eax
cmp    0xc(%rsp),%eax
jle    13c0 <dilate_not_join+0x290>
mov    %r14,%rdi
mov    %ebp,%esi
mov    %ebx,%edx
mov    %r13d,%ecx
xor    %eax,%eax
call   1050 <can_dilate@plt>
mov    0x10(%rsp),%r9
test   %eax,%eax
je     13c0 <dilate_not_join+0x290>
mov    0x20(%rsp),%rax
mov    (%rax,%rbp,8),%rax
mov    0x8(%rsp),%ecx
mov    %cx,(%rax,%rbx,2)
jmp    13c0 <dilate_not_join+0x290>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    -0x1(%r13),%rax
mov    %rax,0x10(%rsp)
mov    $0xa,%edi
call   1030 <putchar@plt>
movl   $0x0,0x1c(%rsp)
jmp    19dc <dilate_not_join+0x8ac>
movl   $0x0,0x1c(%rsp)
test   %r13,%r13
jg     14ef <dilate_not_join+0x3bf>
jmp    168c <dilate_not_join+0x55c>
mov    0x38(%rsp),%r12
mov    0x30(%rsp),%r13
test   %r13,%r13
jle    168c <dilate_not_join+0x55c>
mov    %r12,%r10
and    $0xfffffffffffffff0,%r10
mov    0x50(%rsp),%r8
mov    %r8d,%r9d
and    $0x3,%r9d
movabs $0x1ffffffffffffffc,%rax
ff ff 1f
and    %rax,%r8
mov    %r12d,%r11d
and    $0x3,%r11d
mov    %r9,%r15
shl    $0x5,%r15
xor    %ebp,%ebp
jmp    153d <dilate_not_join+0x40d>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%rbp
cmp    %r13,%rbp
je     168c <dilate_not_join+0x55c>
test   %r12,%r12
jle    1530 <dilate_not_join+0x400>
mov    0x20(%rsp),%rax
mov    (%rax,%rbp,8),%rbx
mov    (%r14,%rbp,8),%rdx
cmp    $0x10,%r12
jb     1567 <dilate_not_join+0x437>
lea    (%rbx,%r12,2),%rax
cmp    %rax,%rdx
jae    15d4 <dilate_not_join+0x4a4>
lea    (%rdx,%r12,2),%rax
cmp    %rax,%rbx
jae    15d4 <dilate_not_join+0x4a4>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
add    %r12,%rcx
test   %r11,%r11
je     1592 <dilate_not_join+0x462>
mov    %r11,%rsi
nopw   0x0(%rax,%rax,1)
movzwl (%rbx,%rax,2),%edi
mov    %di,(%rdx,%rax,2)
add    $0x1,%rax
add    $0xffffffffffffffff,%rsi
jne    1580 <dilate_not_join+0x450>
cmp    $0x3,%rcx
jb     1530 <dilate_not_join+0x400>
nopl   0x0(%rax,%rax,1)
movzwl (%rbx,%rax,2),%ecx
mov    %cx,(%rdx,%rax,2)
movzwl 0x2(%rbx,%rax,2),%ecx
mov    %cx,0x2(%rdx,%rax,2)
movzwl 0x4(%rbx,%rax,2),%ecx
mov    %cx,0x4(%rdx,%rax,2)
movzwl 0x6(%rbx,%rax,2),%ecx
mov    %cx,0x6(%rdx,%rax,2)
add    $0x4,%rax
cmp    %rax,%r12
jne    15a0 <dilate_not_join+0x470>
jmp    1530 <dilate_not_join+0x400>
cmpq   $0x30,0x48(%rsp)
jae    15e0 <dilate_not_join+0x4b0>
xor    %eax,%eax
jmp    1648 <dilate_not_join+0x518>
mov    %r8,%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nop
movups (%rbx,%rax,2),%xmm0
movups 0x10(%rbx,%rax,2),%xmm1
movups %xmm0,(%rdx,%rax,2)
movups %xmm1,0x10(%rdx,%rax,2)
movups 0x20(%rbx,%rax,2),%xmm0
movups 0x30(%rbx,%rax,2),%xmm1
movups %xmm0,0x20(%rdx,%rax,2)
movups %xmm1,0x30(%rdx,%rax,2)
movups 0x40(%rbx,%rax,2),%xmm0
movups 0x50(%rbx,%rax,2),%xmm1
movups %xmm0,0x40(%rdx,%rax,2)
movups %xmm1,0x50(%rdx,%rax,2)
movups 0x60(%rbx,%rax,2),%xmm0
movups 0x70(%rbx,%rax,2),%xmm1
movups %xmm0,0x60(%rdx,%rax,2)
movups %xmm1,0x70(%rdx,%rax,2)
add    $0x40,%rax
add    $0xfffffffffffffffc,%rcx
jne    15f0 <dilate_not_join+0x4c0>
test   %r9,%r9
je     167b <dilate_not_join+0x54b>
lea    (%rdx,%rax,2),%rcx
add    $0x10,%rcx
lea    (%rbx,%rax,2),%rax
add    $0x10,%rax
xor    %esi,%esi
nop
movups -0x10(%rax,%rsi,1),%xmm0
movups (%rax,%rsi,1),%xmm1
movups %xmm0,-0x10(%rcx,%rsi,1)
movups %xmm1,(%rcx,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%r15
jne    1660 <dilate_not_join+0x530>
mov    %r10,%rax
cmp    %r12,%r10
je     1530 <dilate_not_join+0x400>
jmp    1569 <dilate_not_join+0x439>
mov    $0xa,%edi
call   1030 <putchar@plt>
cmpb   $0x0,0x1c(%rsp)
mov    0x10(%rsp),%r9
je     181f <dilate_not_join+0x6ef>
mov    0x8(%rsp),%eax
movswl %ax,%ebp
movswl 0x2c(%rsp),%ecx
mov    %ecx,0xc(%rsp)
xor    %ecx,%ecx
test   $0xffff,%eax
sete   %cl
mov    %ecx,0x40(%rsp)
mov    $0x2,%r15d
sub    %r12,%r15
mov    $0x1,%ebx
jmp    16f2 <dilate_not_join+0x5c2>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rbx
cmp    %r9,%rbx
mov    0x38(%rsp),%r12
je     181f <dilate_not_join+0x6ef>
imul   $0xcccccccd,%ebx,%eax
ror    %eax
cmp    $0x19999999,%eax
jbe    1710 <dilate_not_join+0x5e0>
cmp    $0x3,%r12
jl     16e0 <dilate_not_join+0x5b0>
jmp    172b <dilate_not_join+0x5fb>
nopl   0x0(%rax)
lea    0x18e9(%rip),%rdi
mov    %ebx,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x10(%rsp),%r9
cmp    $0x3,%r12
jl     16e0 <dilate_not_join+0x5b0>
mov    $0x1,%r12d
jmp    174a <dilate_not_join+0x61a>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    (%r15,%r12,1),%rax
cmp    $0x1,%rax
je     16e0 <dilate_not_join+0x5b0>
mov    %r12,%r13
mov    (%r14,%rbx,8),%rcx
add    $0x1,%r12
movswl 0x2(%rcx,%r13,2),%eax
cmp    %eax,%ebp
jne    1740 <dilate_not_join+0x610>
cmpw   $0x0,(%rcx,%r13,2)
jne    1740 <dilate_not_join+0x610>
mov    -0x8(%r14,%rbx,8),%rdx
mov    0x8(%r14,%rbx,8),%r8
movswl -0x2(%rdx,%r13,2),%esi
xor    %edi,%edi
cmp    %esi,%ebp
sete   %dil
movswl (%rdx,%r13,2),%esi
xor    %eax,%eax
cmp    %esi,%ebp
sete   %al
add    %edi,%eax
movswl 0x2(%rdx,%r13,2),%edx
xor    %esi,%esi
cmp    %edx,%ebp
sete   %sil
add    %eax,%esi
movswl -0x2(%rcx,%r13,2),%eax
xor    %ecx,%ecx
cmp    %eax,%ebp
sete   %cl
add    %esi,%ecx
add    0x40(%rsp),%ecx
movswl -0x2(%r8,%r13,2),%eax
xor    %edx,%edx
cmp    %eax,%ebp
sete   %dl
add    %ecx,%edx
movswl (%r8,%r13,2),%eax
xor    %ecx,%ecx
cmp    %eax,%ebp
sete   %cl
add    %edx,%ecx
movswl 0x2(%r8,%r13,2),%eax
xor    %edx,%edx
cmp    %eax,%ebp
sete   %dl
lea    (%rdx,%rcx,1),%eax
add    $0x1,%eax
cmp    0xc(%rsp),%eax
jle    1740 <dilate_not_join+0x610>
mov    %r14,%rdi
mov    %ebx,%esi
mov    %r13d,%edx
mov    %ebp,%ecx
xor    %eax,%eax
call   1050 <can_dilate@plt>
mov    0x10(%rsp),%r9
test   %eax,%eax
je     1740 <dilate_not_join+0x610>
mov    0x20(%rsp),%rax
mov    (%rax,%rbx,8),%rax
mov    0x8(%rsp),%ecx
mov    %cx,(%rax,%r13,2)
jmp    1740 <dilate_not_join+0x610>
mov    0x30(%rsp),%r15
test   %r15,%r15
jle    19dc <dilate_not_join+0x8ac>
mov    %r12,%r9
and    $0xfffffffffffffff0,%r9
mov    0x50(%rsp),%r13
mov    %r13d,%r8d
and    $0x3,%r8d
movabs $0x1ffffffffffffffc,%rax
ff ff 1f
and    %rax,%r13
mov    %r12d,%r10d
and    $0x3,%r10d
mov    %r8,%r11
shl    $0x5,%r11
xor    %edi,%edi
jmp    186d <dilate_not_join+0x73d>
nop
add    $0x1,%rdi
cmp    %r15,%rdi
je     19dc <dilate_not_join+0x8ac>
test   %r12,%r12
jle    1860 <dilate_not_join+0x730>
mov    0x20(%rsp),%rax
mov    (%rax,%rdi,8),%rbp
mov    (%r14,%rdi,8),%rbx
cmp    $0x10,%r12
jb     18a2 <dilate_not_join+0x772>
lea    0x0(,%r12,2),%rax
add    %rbp,%rax
cmp    %rax,%rbx
jae    1915 <dilate_not_join+0x7e5>
lea    (%rbx,%r12,2),%rax
cmp    %rax,%rbp
jae    1915 <dilate_not_join+0x7e5>
xor    %eax,%eax
mov    %rax,%rcx
not    %rcx
add    %r12,%rcx
test   %r10,%r10
je     18d3 <dilate_not_join+0x7a3>
mov    %r10,%rdx
cs nopw 0x0(%rax,%rax,1)
nop
movzwl 0x0(%rbp,%rax,2),%esi
mov    %si,(%rbx,%rax,2)
add    $0x1,%rax
add    $0xffffffffffffffff,%rdx
jne    18c0 <dilate_not_join+0x790>
cmp    $0x3,%rcx
jb     1860 <dilate_not_join+0x730>
nopl   0x0(%rax)
movzwl 0x0(%rbp,%rax,2),%ecx
mov    %cx,(%rbx,%rax,2)
movzwl 0x2(%rbp,%rax,2),%ecx
mov    %cx,0x2(%rbx,%rax,2)
movzwl 0x4(%rbp,%rax,2),%ecx
mov    %cx,0x4(%rbx,%rax,2)
movzwl 0x6(%rbp,%rax,2),%ecx
mov    %cx,0x6(%rbx,%rax,2)
add    $0x4,%rax
cmp    %rax,%r12
jne    18e0 <dilate_not_join+0x7b0>
jmp    1860 <dilate_not_join+0x730>
cmpq   $0x30,0x48(%rsp)
jae    1921 <dilate_not_join+0x7f1>
xor    %eax,%eax
jmp    1989 <dilate_not_join+0x859>
mov    %r13,%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
movups 0x0(%rbp,%rax,2),%xmm0
movups 0x10(%rbp,%rax,2),%xmm1
movups %xmm0,(%rbx,%rax,2)
movups %xmm1,0x10(%rbx,%rax,2)
movups 0x20(%rbp,%rax,2),%xmm0
movups 0x30(%rbp,%rax,2),%xmm1
movups %xmm0,0x20(%rbx,%rax,2)
movups %xmm1,0x30(%rbx,%rax,2)
movups 0x40(%rbp,%rax,2),%xmm0
movups 0x50(%rbp,%rax,2),%xmm1
movups %xmm0,0x40(%rbx,%rax,2)
movups %xmm1,0x50(%rbx,%rax,2)
movups 0x60(%rbp,%rax,2),%xmm0
movups 0x70(%rbp,%rax,2),%xmm1
movups %xmm0,0x60(%rbx,%rax,2)
movups %xmm1,0x70(%rbx,%rax,2)
add    $0x40,%rax
add    $0xfffffffffffffffc,%rcx
jne    1930 <dilate_not_join+0x800>
test   %r8,%r8
je     19cb <dilate_not_join+0x89b>
lea    (%rbx,%rax,2),%rcx
add    $0x10,%rcx
lea    0x10(,%rax,2),%rax
add    %rbp,%rax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x10(%rax,%rdx,1),%xmm0
movups (%rax,%rdx,1),%xmm1
movups %xmm0,-0x10(%rcx,%rdx,1)
movups %xmm1,(%rcx,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%r11
jne    19b0 <dilate_not_join+0x880>
mov    %r9,%rax
cmp    %r12,%r9
je     1860 <dilate_not_join+0x730>
jmp    18a4 <dilate_not_join+0x774>
mov    $0xa,%edi
call   1030 <putchar@plt>
lea    -0x1(%r12),%rax
mov    %rax,0x40(%rsp)
cmp    $0x3,%r12
mov    0x10(%rsp),%rdi
mov    0x1c(%rsp),%r12d
jl     1b5d <dilate_not_join+0xa2d>
mov    0x8(%rsp),%ecx
movswl %cx,%ebp
movswl 0x2c(%rsp),%eax
mov    %eax,0xc(%rsp)
xor    %r15d,%r15d
test   $0xffff,%ecx
sete   %r15b
mov    $0x1,%ebx
jmp    1a3f <dilate_not_join+0x90f>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rbx
cmp    0x40(%rsp),%rbx
je     1b5d <dilate_not_join+0xa2d>
imul   $0xcccccccd,%ebx,%eax
ror    %eax
cmp    $0x19999999,%eax
jbe    1a60 <dilate_not_join+0x930>
test   %r12b,%r12b
je     1a30 <dilate_not_join+0x900>
jmp    1a7a <dilate_not_join+0x94a>
cs nopw 0x0(%rax,%rax,1)
nop
lea    0x1599(%rip),%rdi
mov    %ebx,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x10(%rsp),%rdi
test   %r12b,%r12b
je     1a30 <dilate_not_join+0x900>
mov    $0x1,%r13d
jmp    1a99 <dilate_not_join+0x969>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%r13
cmp    %r13,%rdi
je     1a30 <dilate_not_join+0x900>
mov    -0x8(%r14,%r13,8),%rcx
movswl (%rcx,%rbx,2),%eax
cmp    %eax,%ebp
jne    1a90 <dilate_not_join+0x960>
mov    (%r14,%r13,8),%rax
cmpw   $0x0,(%rax,%rbx,2)
jne    1a90 <dilate_not_join+0x960>
movswl -0x2(%rcx,%rbx,2),%edx
xor    %esi,%esi
cmp    %edx,%ebp
sete   %sil
movswl 0x2(%rcx,%rbx,2),%ecx
xor    %edx,%edx
cmp    %ecx,%ebp
sete   %dl
add    %esi,%edx
movswl -0x2(%rax,%rbx,2),%ecx
xor    %esi,%esi
cmp    %ecx,%ebp
sete   %sil
add    %edx,%esi
add    %r15d,%esi
movswl 0x2(%rax,%rbx,2),%eax
xor    %ecx,%ecx
cmp    %eax,%ebp
sete   %cl
add    %esi,%ecx
mov    0x8(%r14,%r13,8),%rax
movswl -0x2(%rax,%rbx,2),%edx
xor    %esi,%esi
cmp    %edx,%ebp
sete   %sil
add    %ecx,%esi
movswl (%rax,%rbx,2),%ecx
xor    %edx,%edx
cmp    %ecx,%ebp
sete   %dl
add    %esi,%edx
movswl 0x2(%rax,%rbx,2),%eax
xor    %ecx,%ecx
cmp    %eax,%ebp
sete   %cl
lea    (%rcx,%rdx,1),%eax
add    $0x1,%eax
cmp    0xc(%rsp),%eax
jle    1a90 <dilate_not_join+0x960>
mov    %r14,%rdi
mov    %r13d,%esi
mov    %ebx,%edx
mov    %ebp,%ecx
xor    %eax,%eax
call   1050 <can_dilate@plt>
mov    0x10(%rsp),%rdi
test   %eax,%eax
je     1a90 <dilate_not_join+0x960>
mov    0x20(%rsp),%rax
mov    (%rax,%r13,8),%rax
mov    0x8(%rsp),%ecx
mov    %cx,(%rax,%rbx,2)
jmp    1a90 <dilate_not_join+0x960>
cmpq   $0x0,0x30(%rsp)
mov    0x38(%rsp),%rbx
jle    1d2c <dilate_not_join+0xbfc>
lea    -0x10(%rbx),%r8
mov    %r8,%r10
shr    $0x4,%r10
add    $0x1,%r10
mov    %rbx,%r11
and    $0xfffffffffffffff0,%r11
mov    %r10d,%r9d
and    $0x3,%r9d
movabs $0x1ffffffffffffffc,%rax
ff ff 1f
and    %rax,%r10
mov    %ebx,%r15d
and    $0x3,%r15d
mov    %r9,%r12
shl    $0x5,%r12
xor    %r13d,%r13d
jmp    1bbf <dilate_not_join+0xa8f>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r13
cmp    0x30(%rsp),%r13
je     1d2c <dilate_not_join+0xbfc>
test   %rbx,%rbx
jle    1bb0 <dilate_not_join+0xa80>
mov    0x20(%rsp),%rax
mov    (%rax,%r13,8),%rax
mov    (%r14,%r13,8),%rbp
cmp    $0x10,%rbx
jb     1bf4 <dilate_not_join+0xac4>
lea    (%rax,%rbx,2),%rcx
cmp    %rcx,%rbp
jae    1c65 <dilate_not_join+0xb35>
lea    0x0(,%rbx,2),%rcx
add    %rbp,%rcx
cmp    %rcx,%rax
jae    1c65 <dilate_not_join+0xb35>
xor    %edx,%edx
mov    %rdx,%rcx
not    %rcx
add    %rbx,%rcx
test   %r15,%r15
je     1c23 <dilate_not_join+0xaf3>
mov    %r15,%rdi
nopw   0x0(%rax,%rax,1)
movzwl (%rax,%rdx,2),%esi
mov    %si,0x0(%rbp,%rdx,2)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rdi
jne    1c10 <dilate_not_join+0xae0>
cmp    $0x3,%rcx
jb     1bb0 <dilate_not_join+0xa80>
nopl   0x0(%rax)
movzwl (%rax,%rdx,2),%ecx
mov    %cx,0x0(%rbp,%rdx,2)
movzwl 0x2(%rax,%rdx,2),%ecx
mov    %cx,0x2(%rbp,%rdx,2)
movzwl 0x4(%rax,%rdx,2),%ecx
mov    %cx,0x4(%rbp,%rdx,2)
movzwl 0x6(%rax,%rdx,2),%ecx
mov    %cx,0x6(%rbp,%rdx,2)
add    $0x4,%rdx
cmp    %rdx,%rbx
jne    1c30 <dilate_not_join+0xb00>
jmp    1bb0 <dilate_not_join+0xa80>
cmp    $0x30,%r8
jae    1c6f <dilate_not_join+0xb3f>
xor    %edx,%edx
jmp    1cd9 <dilate_not_join+0xba9>
mov    %r10,%rcx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups (%rax,%rdx,2),%xmm0
movups 0x10(%rax,%rdx,2),%xmm1
movups %xmm0,0x0(%rbp,%rdx,2)
movups %xmm1,0x10(%rbp,%rdx,2)
movups 0x20(%rax,%rdx,2),%xmm0
movups 0x30(%rax,%rdx,2),%xmm1
movups %xmm0,0x20(%rbp,%rdx,2)
movups %xmm1,0x30(%rbp,%rdx,2)
movups 0x40(%rax,%rdx,2),%xmm0
movups 0x50(%rax,%rdx,2),%xmm1
movups %xmm0,0x40(%rbp,%rdx,2)
movups %xmm1,0x50(%rbp,%rdx,2)
movups 0x60(%rax,%rdx,2),%xmm0
movups 0x70(%rax,%rdx,2),%xmm1
movups %xmm0,0x60(%rbp,%rdx,2)
movups %xmm1,0x70(%rbp,%rdx,2)
add    $0x40,%rdx
add    $0xfffffffffffffffc,%rcx
jne    1c80 <dilate_not_join+0xb50>
test   %r9,%r9
je     1d1b <dilate_not_join+0xbeb>
lea    0x10(,%rdx,2),%rcx
add    %rbp,%rcx
lea    (%rax,%rdx,2),%rdx
add    $0x10,%rdx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x10(%rdx,%rdi,1),%xmm0
movups (%rdx,%rdi,1),%xmm1
movups %xmm0,-0x10(%rcx,%rdi,1)
movups %xmm1,(%rcx,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%r12
jne    1d00 <dilate_not_join+0xbd0>
mov    %r11,%rdx
cmp    %rbx,%r11
je     1bb0 <dilate_not_join+0xa80>
jmp    1bf6 <dilate_not_join+0xac6>
mov    $0xa,%edi
call   1030 <putchar@plt>
cmp    $0x3,%rbx
mov    0x10(%rsp),%r9
jl     1eac <dilate_not_join+0xd7c>
mov    0x8(%rsp),%ecx
movswl %cx,%r15d
movswl 0x2c(%rsp),%eax
mov    %eax,0xc(%rsp)
xor    %r12d,%r12d
test   $0xffff,%ecx
sete   %r12b
mov    $0x1,%ebx
jmp    1d7f <dilate_not_join+0xc4f>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rbx
cmp    0x40(%rsp),%rbx
je     1eac <dilate_not_join+0xd7c>
imul   $0xcccccccd,%ebx,%eax
ror    %eax
cmp    $0x19999999,%eax
jbe    1da0 <dilate_not_join+0xc70>
cmpb   $0x0,0x1c(%rsp)
je     1d70 <dilate_not_join+0xc40>
jmp    1dbc <dilate_not_join+0xc8c>
nopw   0x0(%rax,%rax,1)
lea    0x1259(%rip),%rdi
mov    %ebx,%esi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x10(%rsp),%r9
cmpb   $0x0,0x1c(%rsp)
je     1d70 <dilate_not_join+0xc40>
mov    $0x1,%ebp
jmp    1dd5 <dilate_not_join+0xca5>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
cmp    %rbp,%r9
je     1d70 <dilate_not_join+0xc40>
mov    %rbp,%r13
add    $0x1,%rbp
mov    0x8(%r14,%r13,8),%rax
movswl (%rax,%rbx,2),%ecx
cmp    %ecx,%r15d
jne    1dd0 <dilate_not_join+0xca0>
mov    (%r14,%r13,8),%rcx
cmpw   $0x0,(%rcx,%rbx,2)
jne    1dd0 <dilate_not_join+0xca0>
mov    -0x8(%r14,%r13,8),%rdx
movswl -0x2(%rdx,%rbx,2),%esi
xor    %edi,%edi
cmp    %esi,%r15d
sete   %dil
movswl (%rdx,%rbx,2),%r8d
xor    %esi,%esi
cmp    %r8d,%r15d
sete   %sil
add    %edi,%esi
movswl 0x2(%rdx,%rbx,2),%edx
xor    %edi,%edi
cmp    %edx,%r15d
sete   %dil
add    %esi,%edi
movswl -0x2(%rcx,%rbx,2),%edx
xor    %esi,%esi
cmp    %edx,%r15d
sete   %sil
add    %edi,%esi
add    %r12d,%esi
movswl 0x2(%rcx,%rbx,2),%ecx
xor    %edx,%edx
cmp    %ecx,%r15d
sete   %dl
add    %esi,%edx
movswl -0x2(%rax,%rbx,2),%ecx
xor    %esi,%esi
cmp    %ecx,%r15d
sete   %sil
add    %edx,%esi
movswl 0x2(%rax,%rbx,2),%eax
xor    %ecx,%ecx
cmp    %eax,%r15d
sete   %cl
lea    (%rcx,%rsi,1),%eax
add    $0x1,%eax
cmp    0xc(%rsp),%eax
jle    1dd0 <dilate_not_join+0xca0>
mov    %r14,%rdi
mov    %r13d,%esi
mov    %ebx,%edx
mov    %r15d,%ecx
xor    %eax,%eax
call   1050 <can_dilate@plt>
mov    0x10(%rsp),%r9
test   %eax,%eax
je     1dd0 <dilate_not_join+0xca0>
mov    0x20(%rsp),%rax
mov    (%rax,%r13,8),%rax
mov    0x8(%rsp),%ecx
mov    %cx,(%rax,%rbx,2)
jmp    1dd0 <dilate_not_join+0xca0>
cmpq   $0x0,0x30(%rsp)
mov    0x38(%rsp),%rbx
jle    207c <dilate_not_join+0xf4c>
lea    -0x10(%rbx),%r8
mov    %r8,%r10
shr    $0x4,%r10
add    $0x1,%r10
mov    %rbx,%r11
and    $0xfffffffffffffff0,%r11
mov    %r10d,%r9d
and    $0x3,%r9d
movabs $0x1ffffffffffffffc,%rax
ff ff 1f
and    %rax,%r10
mov    %ebx,%r15d
and    $0x3,%r15d
mov    %r9,%r12
shl    $0x5,%r12
xor    %r13d,%r13d
jmp    1f0f <dilate_not_join+0xddf>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r13
cmp    0x30(%rsp),%r13
je     207c <dilate_not_join+0xf4c>
test   %rbx,%rbx
jle    1f00 <dilate_not_join+0xdd0>
mov    0x20(%rsp),%rax
mov    (%rax,%r13,8),%rax
mov    (%r14,%r13,8),%rbp
cmp    $0x10,%rbx
jb     1f44 <dilate_not_join+0xe14>
lea    (%rax,%rbx,2),%rcx
cmp    %rcx,%rbp
jae    1fb5 <dilate_not_join+0xe85>
lea    0x0(,%rbx,2),%rcx
add    %rbp,%rcx
cmp    %rcx,%rax
jae    1fb5 <dilate_not_join+0xe85>
xor    %edx,%edx
mov    %rdx,%rcx
not    %rcx
add    %rbx,%rcx
test   %r15,%r15
je     1f73 <dilate_not_join+0xe43>
mov    %r15,%rdi
nopw   0x0(%rax,%rax,1)
movzwl (%rax,%rdx,2),%esi
mov    %si,0x0(%rbp,%rdx,2)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rdi
jne    1f60 <dilate_not_join+0xe30>
cmp    $0x3,%rcx
jb     1f00 <dilate_not_join+0xdd0>
nopl   0x0(%rax)
movzwl (%rax,%rdx,2),%ecx
mov    %cx,0x0(%rbp,%rdx,2)
movzwl 0x2(%rax,%rdx,2),%ecx
mov    %cx,0x2(%rbp,%rdx,2)
movzwl 0x4(%rax,%rdx,2),%ecx
mov    %cx,0x4(%rbp,%rdx,2)
movzwl 0x6(%rax,%rdx,2),%ecx
mov    %cx,0x6(%rbp,%rdx,2)
add    $0x4,%rdx
cmp    %rdx,%rbx
jne    1f80 <dilate_not_join+0xe50>
jmp    1f00 <dilate_not_join+0xdd0>
cmp    $0x30,%r8
jae    1fbf <dilate_not_join+0xe8f>
xor    %edx,%edx
jmp    2029 <dilate_not_join+0xef9>
mov    %r10,%rcx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups (%rax,%rdx,2),%xmm0
movups 0x10(%rax,%rdx,2),%xmm1
movups %xmm0,0x0(%rbp,%rdx,2)
movups %xmm1,0x10(%rbp,%rdx,2)
movups 0x20(%rax,%rdx,2),%xmm0
movups 0x30(%rax,%rdx,2),%xmm1
movups %xmm0,0x20(%rbp,%rdx,2)
movups %xmm1,0x30(%rbp,%rdx,2)
movups 0x40(%rax,%rdx,2),%xmm0
movups 0x50(%rax,%rdx,2),%xmm1
movups %xmm0,0x40(%rbp,%rdx,2)
movups %xmm1,0x50(%rbp,%rdx,2)
movups 0x60(%rax,%rdx,2),%xmm0
movups 0x70(%rax,%rdx,2),%xmm1
movups %xmm0,0x60(%rbp,%rdx,2)
movups %xmm1,0x70(%rbp,%rdx,2)
add    $0x40,%rdx
add    $0xfffffffffffffffc,%rcx
jne    1fd0 <dilate_not_join+0xea0>
test   %r9,%r9
je     206b <dilate_not_join+0xf3b>
lea    0x10(,%rdx,2),%rcx
add    %rbp,%rcx
lea    (%rax,%rdx,2),%rdx
add    $0x10,%rdx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x10(%rdx,%rdi,1),%xmm0
movups (%rdx,%rdi,1),%xmm1
movups %xmm0,-0x10(%rcx,%rdi,1)
movups %xmm1,(%rcx,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%r12
jne    2050 <dilate_not_join+0xf20>
mov    %r11,%rdx
cmp    %rbx,%r11
je     1f00 <dilate_not_join+0xdd0>
jmp    1f46 <dilate_not_join+0xe16>
mov    $0x1,%eax
add    $0x58,%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"
define i32 @dilate_not_join(i16** %0, i16** %1, i32 %2, i32 %3, i64 %4, i64 %5) {
%7 = alloca i16**
%8 = alloca i16**
%9 = alloca i16
%10 = alloca i16
%11 = alloca i64
%12 = alloca i64
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = trunc i32 %2 to i16
%20 = trunc i32 %3 to i16
store i16** %0, i16*** %7
store i16** %1, i16*** %8
store i16 %19, i16* %9
store i16 %20, i16* %10
store i64 %4, i64* %11
store i64 %5, i64* %12
store i32 0, i32* %16
br label %21
21: ; preds = %54, %6
%22 = load i32, i32* %16
%23 = sext i32 %22 to i64
%24 = load i64, i64* %11
%25 = icmp slt i64 %23, %24
br i1 %25, label %26, label %57
26: ; preds = %21
store i32 0, i32* %17
br label %27
27: ; preds = %50, %26
%28 = load i32, i32* %17
%29 = sext i32 %28 to i64
%30 = load i64, i64* %12
%31 = icmp slt i64 %29, %30
br i1 %31, label %32, label %53
32: ; preds = %27
%33 = load i16**, i16*** %7
%34 = load i32, i32* %16
%35 = sext i32 %34 to i64
%36 = getelementptr inbounds i16*, i16** %33, i64 %35
%37 = load i16*, i16** %36
%38 = load i32, i32* %17
%39 = sext i32 %38 to i64
%40 = getelementptr inbounds i16, i16* %37, i64 %39
%41 = load i16, i16* %40
%42 = load i16**, i16*** %8
%43 = load i32, i32* %16
%44 = sext i32 %43 to i64
%45 = getelementptr inbounds i16*, i16** %42, i64 %44
%46 = load i16*, i16** %45
%47 = load i32, i32* %17
%48 = sext i32 %47 to i64
%49 = getelementptr inbounds i16, i16* %46, i64 %48
store i16 %41, i16* %49
br label %50
50: ; preds = %32
%51 = load i32, i32* %17
%52 = add nsw i32 %51, 1
store i32 %52, i32* %17
br label %27
53: ; preds = %27
br label %54
54: ; preds = %53
%55 = load i32, i32* %16
%56 = add nsw i32 %55, 1
store i32 %56, i32* %16
br label %21
57: ; preds = %21
%58 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
store i32 1, i32* %16
br label %59
59: ; preds = %173, %57
%60 = load i32, i32* %16
%61 = sext i32 %60 to i64
%62 = load i64, i64* %11
%63 = sub nsw i64 %62, 1
%64 = icmp slt i64 %61, %63
br i1 %64, label %65, label %176
65: ; preds = %59
%66 = load i32, i32* %16
%67 = srem i32 %66, 10
%68 = icmp eq i32 %67, 0
br i1 %68, label %69, label %72
69: ; preds = %65
%70 = load i32, i32* %16
%71 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %70)
br label %72
72: ; preds = %69, %65
store i32 1, i32* %17
br label %73
73: ; preds = %169, %72
%74 = load i32, i32* %17
%75 = sext i32 %74 to i64
%76 = load i64, i64* %12
%77 = sub nsw i64 %76, 1
%78 = icmp slt i64 %75, %77
br i1 %78, label %79, label %172
79: ; preds = %73
%80 = load i16**, i16*** %7
%81 = load i32, i32* %16
%82 = sext i32 %81 to i64
%83 = getelementptr inbounds i16*, i16** %80, i64 %82
%84 = load i16*, i16** %83
%85 = load i32, i32* %17
%86 = sub nsw i32 %85, 1
%87 = sext i32 %86 to i64
%88 = getelementptr inbounds i16, i16* %84, i64 %87
%89 = load i16, i16* %88
%90 = sext i16 %89 to i32
%91 = load i16, i16* %9
%92 = sext i16 %91 to i32
%93 = icmp eq i32 %90, %92
br i1 %93, label %94, label %168
94: ; preds = %79
%95 = load i16**, i16*** %7
%96 = load i32, i32* %16
%97 = sext i32 %96 to i64
%98 = getelementptr inbounds i16*, i16** %95, i64 %97
%99 = load i16*, i16** %98
%100 = load i32, i32* %17
%101 = sext i32 %100 to i64
%102 = getelementptr inbounds i16, i16* %99, i64 %101
%103 = load i16, i16* %102
%104 = sext i16 %103 to i32
%105 = icmp eq i32 %104, 0
br i1 %105, label %106, label %168
106: ; preds = %94
store i32 0, i32* %15
store i32 -1, i32* %13
br label %107
107: ; preds = %140, %106
%108 = load i32, i32* %13
%109 = icmp sle i32 %108, 1
br i1 %109, label %110, label %143
110: ; preds = %107
store i32 -1, i32* %14
br label %111
111: ; preds = %136, %110
%112 = load i32, i32* %14
%113 = icmp sle i32 %112, 1
br i1 %113, label %114, label %139
114: ; preds = %111
%115 = load i16**, i16*** %7
%116 = load i32, i32* %16
%117 = load i32, i32* %13
%118 = add nsw i32 %116, %117
%119 = sext i32 %118 to i64
%120 = getelementptr inbounds i16*, i16** %115, i64 %119
%121 = load i16*, i16** %120
%122 = load i32, i32* %17
%123 = load i32, i32* %14
%124 = add nsw i32 %122, %123
%125 = sext i32 %124 to i64
%126 = getelementptr inbounds i16, i16* %121, i64 %125
%127 = load i16, i16* %126
%128 = sext i16 %127 to i32
%129 = load i16, i16* %9
%130 = sext i16 %129 to i32
%131 = icmp eq i32 %128, %130
br i1 %131, label %132, label %135
132: ; preds = %114
%133 = load i32, i32* %15
%134 = add nsw i32 %133, 1
store i32 %134, i32* %15
br label %135
135: ; preds = %132, %114
br label %136
136: ; preds = %135
%137 = load i32, i32* %14
%138 = add nsw i32 %137, 1
store i32 %138, i32* %14
br label %111
139: ; preds = %111
br label %140
140: ; preds = %139
%141 = load i32, i32* %13
%142 = add nsw i32 %141, 1
store i32 %142, i32* %13
br label %107
143: ; preds = %107
%144 = load i32, i32* %15
%145 = load i16, i16* %10
%146 = sext i16 %145 to i32
%147 = icmp sgt i32 %144, %146
br i1 %147, label %148, label %167
148: ; preds = %143
%149 = load i16**, i16*** %7
%150 = load i32, i32* %16
%151 = load i32, i32* %17
%152 = load i16, i16* %9
%153 = sext i16 %152 to i32
%154 = call i32 (i16**, i32, i32, i32, ...) bitcast (i32 (...)* @can_dilate to i32 (i16**, i32, i32, i32, ...)*)(i16** %149, i32 %150, i32 %151, i32 %153)
%155 = icmp ne i32 %154, 0
br i1 %155, label %156, label %166
156: ; preds = %148
%157 = load i16, i16* %9
%158 = load i16**, i16*** %8
%159 = load i32, i32* %16
%160 = sext i32 %159 to i64
%161 = getelementptr inbounds i16*, i16** %158, i64 %160
%162 = load i16*, i16** %161
%163 = load i32, i32* %17
%164 = sext i32 %163 to i64
%165 = getelementptr inbounds i16, i16* %162, i64 %164
store i16 %157, i16* %165
br label %166
166: ; preds = %156, %148
br label %167
167: ; preds = %166, %143
br label %168
168: ; preds = %167, %94, %79
br label %169
169: ; preds = %168
%170 = load i32, i32* %17
%171 = add nsw i32 %170, 1
store i32 %171, i32* %17
br label %73
172: ; preds = %73
br label %173
173: ; preds = %172
%174 = load i32, i32* %16
%175 = add nsw i32 %174, 1
store i32 %175, i32* %16
br label %59
176: ; preds = %59
store i32 0, i32* %16
br label %177
177: ; preds = %210, %176
%178 = load i32, i32* %16
%179 = sext i32 %178 to i64
%180 = load i64, i64* %11
%181 = icmp slt i64 %179, %180
br i1 %181, label %182, label %213
182: ; preds = %177
store i32 0, i32* %17
br label %183
183: ; preds = %206, %182
%184 = load i32, i32* %17
%185 = sext i32 %184 to i64
%186 = load i64, i64* %12
%187 = icmp slt i64 %185, %186
br i1 %187, label %188, label %209
188: ; preds = %183
%189 = load i16**, i16*** %8
%190 = load i32, i32* %16
%191 = sext i32 %190 to i64
%192 = getelementptr inbounds i16*, i16** %189, i64 %191
%193 = load i16*, i16** %192
%194 = load i32, i32* %17
%195 = sext i32 %194 to i64
%196 = getelementptr inbounds i16, i16* %193, i64 %195
%197 = load i16, i16* %196
%198 = load i16**, i16*** %7
%199 = load i32, i32* %16
%200 = sext i32 %199 to i64
%201 = getelementptr inbounds i16*, i16** %198, i64 %200
%202 = load i16*, i16** %201
%203 = load i32, i32* %17
%204 = sext i32 %203 to i64
%205 = getelementptr inbounds i16, i16* %202, i64 %204
store i16 %197, i16* %205
br label %206
206: ; preds = %188
%207 = load i32, i32* %17
%208 = add nsw i32 %207, 1
store i32 %208, i32* %17
br label %183
209: ; preds = %183
br label %210
210: ; preds = %209
%211 = load i32, i32* %16
%212 = add nsw i32 %211, 1
store i32 %212, i32* %16
br label %177
213: ; preds = %177
%214 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
store i32 1, i32* %16
br label %215
215: ; preds = %329, %213
%216 = load i32, i32* %16
%217 = sext i32 %216 to i64
%218 = load i64, i64* %11
%219 = sub nsw i64 %218, 1
%220 = icmp slt i64 %217, %219
br i1 %220, label %221, label %332
221: ; preds = %215
%222 = load i32, i32* %16
%223 = srem i32 %222, 10
%224 = icmp eq i32 %223, 0
br i1 %224, label %225, label %228
225: ; preds = %221
%226 = load i32, i32* %16
%227 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %226)
br label %228
228: ; preds = %225, %221
store i32 1, i32* %17
br label %229
229: ; preds = %325, %228
%230 = load i32, i32* %17
%231 = sext i32 %230 to i64
%232 = load i64, i64* %12
%233 = sub nsw i64 %232, 1
%234 = icmp slt i64 %231, %233
br i1 %234, label %235, label %328
235: ; preds = %229
%236 = load i16**, i16*** %7
%237 = load i32, i32* %16
%238 = sext i32 %237 to i64
%239 = getelementptr inbounds i16*, i16** %236, i64 %238
%240 = load i16*, i16** %239
%241 = load i32, i32* %17
%242 = add nsw i32 %241, 1
%243 = sext i32 %242 to i64
%244 = getelementptr inbounds i16, i16* %240, i64 %243
%245 = load i16, i16* %244
%246 = sext i16 %245 to i32
%247 = load i16, i16* %9
%248 = sext i16 %247 to i32
%249 = icmp eq i32 %246, %248
br i1 %249, label %250, label %324
250: ; preds = %235
%251 = load i16**, i16*** %7
%252 = load i32, i32* %16
%253 = sext i32 %252 to i64
%254 = getelementptr inbounds i16*, i16** %251, i64 %253
%255 = load i16*, i16** %254
%256 = load i32, i32* %17
%257 = sext i32 %256 to i64
%258 = getelementptr inbounds i16, i16* %255, i64 %257
%259 = load i16, i16* %258
%260 = sext i16 %259 to i32
%261 = icmp eq i32 %260, 0
br i1 %261, label %262, label %324
262: ; preds = %250
store i32 0, i32* %15
store i32 -1, i32* %13
br label %263
263: ; preds = %296, %262
%264 = load i32, i32* %13
%265 = icmp sle i32 %264, 1
br i1 %265, label %266, label %299
266: ; preds = %263
store i32 -1, i32* %14
br label %267
267: ; preds = %292, %266
%268 = load i32, i32* %14
%269 = icmp sle i32 %268, 1
br i1 %269, label %270, label %295
270: ; preds = %267
%271 = load i16**, i16*** %7
%272 = load i32, i32* %16
%273 = load i32, i32* %13
%274 = add nsw i32 %272, %273
%275 = sext i32 %274 to i64
%276 = getelementptr inbounds i16*, i16** %271, i64 %275
%277 = load i16*, i16** %276
%278 = load i32, i32* %17
%279 = load i32, i32* %14
%280 = add nsw i32 %278, %279
%281 = sext i32 %280 to i64
%282 = getelementptr inbounds i16, i16* %277, i64 %281
%283 = load i16, i16* %282
%284 = sext i16 %283 to i32
%285 = load i16, i16* %9
%286 = sext i16 %285 to i32
%287 = icmp eq i32 %284, %286
br i1 %287, label %288, label %291
288: ; preds = %270
%289 = load i32, i32* %15
%290 = add nsw i32 %289, 1
store i32 %290, i32* %15
br label %291
291: ; preds = %288, %270
br label %292
292: ; preds = %291
%293 = load i32, i32* %14
%294 = add nsw i32 %293, 1
store i32 %294, i32* %14
br label %267
295: ; preds = %267
br label %296
296: ; preds = %295
%297 = load i32, i32* %13
%298 = add nsw i32 %297, 1
store i32 %298, i32* %13
br label %263
299: ; preds = %263
%300 = load i32, i32* %15
%301 = load i16, i16* %10
%302 = sext i16 %301 to i32
%303 = icmp sgt i32 %300, %302
br i1 %303, label %304, label %323
304: ; preds = %299
%305 = load i16**, i16*** %7
%306 = load i32, i32* %16
%307 = load i32, i32* %17
%308 = load i16, i16* %9
%309 = sext i16 %308 to i32
%310 = call i32 (i16**, i32, i32, i32, ...) bitcast (i32 (...)* @can_dilate to i32 (i16**, i32, i32, i32, ...)*)(i16** %305, i32 %306, i32 %307, i32 %309)
%311 = icmp ne i32 %310, 0
br i1 %311, label %312, label %322
312: ; preds = %304
%313 = load i16, i16* %9
%314 = load i16**, i16*** %8
%315 = load i32, i32* %16
%316 = sext i32 %315 to i64
%317 = getelementptr inbounds i16*, i16** %314, i64 %316
%318 = load i16*, i16** %317
%319 = load i32, i32* %17
%320 = sext i32 %319 to i64
%321 = getelementptr inbounds i16, i16* %318, i64 %320
store i16 %313, i16* %321
br label %322
322: ; preds = %312, %304
br label %323
323: ; preds = %322, %299
br label %324
324: ; preds = %323, %250, %235
br label %325
325: ; preds = %324
%326 = load i32, i32* %17
%327 = add nsw i32 %326, 1
store i32 %327, i32* %17
br label %229
328: ; preds = %229
br label %329
329: ; preds = %328
%330 = load i32, i32* %16
%331 = add nsw i32 %330, 1
store i32 %331, i32* %16
br label %215
332: ; preds = %215
store i32 0, i32* %16
br label %333
333: ; preds = %366, %332
%334 = load i32, i32* %16
%335 = sext i32 %334 to i64
%336 = load i64, i64* %11
%337 = icmp slt i64 %335, %336
br i1 %337, label %338, label %369
338: ; preds = %333
store i32 0, i32* %17
br label %339
339: ; preds = %362, %338
%340 = load i32, i32* %17
%341 = sext i32 %340 to i64
%342 = load i64, i64* %12
%343 = icmp slt i64 %341, %342
br i1 %343, label %344, label %365
344: ; preds = %339
%345 = load i16**, i16*** %8
%346 = load i32, i32* %16
%347 = sext i32 %346 to i64
%348 = getelementptr inbounds i16*, i16** %345, i64 %347
%349 = load i16*, i16** %348
%350 = load i32, i32* %17
%351 = sext i32 %350 to i64
%352 = getelementptr inbounds i16, i16* %349, i64 %351
%353 = load i16, i16* %352
%354 = load i16**, i16*** %7
%355 = load i32, i32* %16
%356 = sext i32 %355 to i64
%357 = getelementptr inbounds i16*, i16** %354, i64 %356
%358 = load i16*, i16** %357
%359 = load i32, i32* %17
%360 = sext i32 %359 to i64
%361 = getelementptr inbounds i16, i16* %358, i64 %360
store i16 %353, i16* %361
br label %362
362: ; preds = %344
%363 = load i32, i32* %17
%364 = add nsw i32 %363, 1
store i32 %364, i32* %17
br label %339
365: ; preds = %339
br label %366
366: ; preds = %365
%367 = load i32, i32* %16
%368 = add nsw i32 %367, 1
store i32 %368, i32* %16
br label %333
369: ; preds = %333
%370 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
store i32 1, i32* %17
br label %371
371: ; preds = %485, %369
%372 = load i32, i32* %17
%373 = sext i32 %372 to i64
%374 = load i64, i64* %12
%375 = sub nsw i64 %374, 1
%376 = icmp slt i64 %373, %375
br i1 %376, label %377, label %488
377: ; preds = %371
%378 = load i32, i32* %17
%379 = srem i32 %378, 10
%380 = icmp eq i32 %379, 0
br i1 %380, label %381, label %384
381: ; preds = %377
%382 = load i32, i32* %17
%383 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %382)
br label %384
384: ; preds = %381, %377
store i32 1, i32* %16
br label %385
385: ; preds = %481, %384
%386 = load i32, i32* %16
%387 = sext i32 %386 to i64
%388 = load i64, i64* %11
%389 = sub nsw i64 %388, 1
%390 = icmp slt i64 %387, %389
br i1 %390, label %391, label %484
391: ; preds = %385
%392 = load i16**, i16*** %7
%393 = load i32, i32* %16
%394 = sub nsw i32 %393, 1
%395 = sext i32 %394 to i64
%396 = getelementptr inbounds i16*, i16** %392, i64 %395
%397 = load i16*, i16** %396
%398 = load i32, i32* %17
%399 = sext i32 %398 to i64
%400 = getelementptr inbounds i16, i16* %397, i64 %399
%401 = load i16, i16* %400
%402 = sext i16 %401 to i32
%403 = load i16, i16* %9
%404 = sext i16 %403 to i32
%405 = icmp eq i32 %402, %404
br i1 %405, label %406, label %480
406: ; preds = %391
%407 = load i16**, i16*** %7
%408 = load i32, i32* %16
%409 = sext i32 %408 to i64
%410 = getelementptr inbounds i16*, i16** %407, i64 %409
%411 = load i16*, i16** %410
%412 = load i32, i32* %17
%413 = sext i32 %412 to i64
%414 = getelementptr inbounds i16, i16* %411, i64 %413
%415 = load i16, i16* %414
%416 = sext i16 %415 to i32
%417 = icmp eq i32 %416, 0
br i1 %417, label %418, label %480
418: ; preds = %406
store i32 0, i32* %15
store i32 -1, i32* %13
br label %419
419: ; preds = %452, %418
%420 = load i32, i32* %13
%421 = icmp sle i32 %420, 1
br i1 %421, label %422, label %455
422: ; preds = %419
store i32 -1, i32* %14
br label %423
423: ; preds = %448, %422
%424 = load i32, i32* %14
%425 = icmp sle i32 %424, 1
br i1 %425, label %426, label %451
426: ; preds = %423
%427 = load i16**, i16*** %7
%428 = load i32, i32* %16
%429 = load i32, i32* %13
%430 = add nsw i32 %428, %429
%431 = sext i32 %430 to i64
%432 = getelementptr inbounds i16*, i16** %427, i64 %431
%433 = load i16*, i16** %432
%434 = load i32, i32* %17
%435 = load i32, i32* %14
%436 = add nsw i32 %434, %435
%437 = sext i32 %436 to i64
%438 = getelementptr inbounds i16, i16* %433, i64 %437
%439 = load i16, i16* %438
%440 = sext i16 %439 to i32
%441 = load i16, i16* %9
%442 = sext i16 %441 to i32
%443 = icmp eq i32 %440, %442
br i1 %443, label %444, label %447
444: ; preds = %426
%445 = load i32, i32* %15
%446 = add nsw i32 %445, 1
store i32 %446, i32* %15
br label %447
447: ; preds = %444, %426
br label %448
448: ; preds = %447
%449 = load i32, i32* %14
%450 = add nsw i32 %449, 1
store i32 %450, i32* %14
br label %423
451: ; preds = %423
br label %452
452: ; preds = %451
%453 = load i32, i32* %13
%454 = add nsw i32 %453, 1
store i32 %454, i32* %13
br label %419
455: ; preds = %419
%456 = load i32, i32* %15
%457 = load i16, i16* %10
%458 = sext i16 %457 to i32
%459 = icmp sgt i32 %456, %458
br i1 %459, label %460, label %479
460: ; preds = %455
%461 = load i16**, i16*** %7
%462 = load i32, i32* %16
%463 = load i32, i32* %17
%464 = load i16, i16* %9
%465 = sext i16 %464 to i32
%466 = call i32 (i16**, i32, i32, i32, ...) bitcast (i32 (...)* @can_dilate to i32 (i16**, i32, i32, i32, ...)*)(i16** %461, i32 %462, i32 %463, i32 %465)
%467 = icmp ne i32 %466, 0
br i1 %467, label %468, label %478
468: ; preds = %460
%469 = load i16, i16* %9
%470 = load i16**, i16*** %8
%471 = load i32, i32* %16
%472 = sext i32 %471 to i64
%473 = getelementptr inbounds i16*, i16** %470, i64 %472
%474 = load i16*, i16** %473
%475 = load i32, i32* %17
%476 = sext i32 %475 to i64
%477 = getelementptr inbounds i16, i16* %474, i64 %476
store i16 %469, i16* %477
br label %478
478: ; preds = %468, %460
br label %479
479: ; preds = %478, %455
br label %480
480: ; preds = %479, %406, %391
br label %481
481: ; preds = %480
%482 = load i32, i32* %16
%483 = add nsw i32 %482, 1
store i32 %483, i32* %16
br label %385
484: ; preds = %385
br label %485
485: ; preds = %484
%486 = load i32, i32* %17
%487 = add nsw i32 %486, 1
store i32 %487, i32* %17
br label %371
488: ; preds = %371
store i32 0, i32* %16
br label %489
489: ; preds = %522, %488
%490 = load i32, i32* %16
%491 = sext i32 %490 to i64
%492 = load i64, i64* %11
%493 = icmp slt i64 %491, %492
br i1 %493, label %494, label %525
494: ; preds = %489
store i32 0, i32* %17
br label %495
495: ; preds = %518, %494
%496 = load i32, i32* %17
%497 = sext i32 %496 to i64
%498 = load i64, i64* %12
%499 = icmp slt i64 %497, %498
br i1 %499, label %500, label %521
500: ; preds = %495
%501 = load i16**, i16*** %8
%502 = load i32, i32* %16
%503 = sext i32 %502 to i64
%504 = getelementptr inbounds i16*, i16** %501, i64 %503
%505 = load i16*, i16** %504
%506 = load i32, i32* %17
%507 = sext i32 %506 to i64
%508 = getelementptr inbounds i16, i16* %505, i64 %507
%509 = load i16, i16* %508
%510 = load i16**, i16*** %7
%511 = load i32, i32* %16
%512 = sext i32 %511 to i64
%513 = getelementptr inbounds i16*, i16** %510, i64 %512
%514 = load i16*, i16** %513
%515 = load i32, i32* %17
%516 = sext i32 %515 to i64
%517 = getelementptr inbounds i16, i16* %514, i64 %516
store i16 %509, i16* %517
br label %518
518: ; preds = %500
%519 = load i32, i32* %17
%520 = add nsw i32 %519, 1
store i32 %520, i32* %17
br label %495
521: ; preds = %495
br label %522
522: ; preds = %521
%523 = load i32, i32* %16
%524 = add nsw i32 %523, 1
store i32 %524, i32* %16
br label %489
525: ; preds = %489
%526 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str, i64 0, i64 0))
store i32 1, i32* %17
br label %527
527: ; preds = %641, %525
%528 = load i32, i32* %17
%529 = sext i32 %528 to i64
%530 = load i64, i64* %12
%531 = sub nsw i64 %530, 1
%532 = icmp slt i64 %529, %531
br i1 %532, label %533, label %644
533: ; preds = %527
%534 = load i32, i32* %17
%535 = srem i32 %534, 10
%536 = icmp eq i32 %535, 0
br i1 %536, label %537, label %540
537: ; preds = %533
%538 = load i32, i32* %17
%539 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.1, i64 0, i64 0), i32 %538)
br label %540
540: ; preds = %537, %533
store i32 1, i32* %16
br label %541
541: ; preds = %637, %540
%542 = load i32, i32* %16
%543 = sext i32 %542 to i64
%544 = load i64, i64* %11
%545 = sub nsw i64 %544, 1
%546 = icmp slt i64 %543, %545
br i1 %546, label %547, label %640
547: ; preds = %541
%548 = load i16**, i16*** %7
%549 = load i32, i32* %16
%550 = add nsw i32 %549, 1
%551 = sext i32 %550 to i64
%552 = getelementptr inbounds i16*, i16** %548, i64 %551
%553 = load i16*, i16** %552
%554 = load i32, i32* %17
%555 = sext i32 %554 to i64
%556 = getelementptr inbounds i16, i16* %553, i64 %555
%557 = load i16, i16* %556
%558 = sext i16 %557 to i32
%559 = load i16, i16* %9
%560 = sext i16 %559 to i32
%561 = icmp eq i32 %558, %560
br i1 %561, label %562, label %636
562: ; preds = %547
%563 = load i16**, i16*** %7
%564 = load i32, i32* %16
%565 = sext i32 %564 to i64
%566 = getelementptr inbounds i16*, i16** %563, i64 %565
%567 = load i16*, i16** %566
%568 = load i32, i32* %17
%569 = sext i32 %568 to i64
%570 = getelementptr inbounds i16, i16* %567, i64 %569
%571 = load i16, i16* %570
%572 = sext i16 %571 to i32
%573 = icmp eq i32 %572, 0
br i1 %573, label %574, label %636
574: ; preds = %562
store i32 0, i32* %15
store i32 -1, i32* %13
br label %575
575: ; preds = %608, %574
%576 = load i32, i32* %13
%577 = icmp sle i32 %576, 1
br i1 %577, label %578, label %611
578: ; preds = %575
store i32 -1, i32* %14
br label %579
579: ; preds = %604, %578
%580 = load i32, i32* %14
%581 = icmp sle i32 %580, 1
br i1 %581, label %582, label %607
582: ; preds = %579
%583 = load i16**, i16*** %7
%584 = load i32, i32* %16
%585 = load i32, i32* %13
%586 = add nsw i32 %584, %585
%587 = sext i32 %586 to i64
%588 = getelementptr inbounds i16*, i16** %583, i64 %587
%589 = load i16*, i16** %588
%590 = load i32, i32* %17
%591 = load i32, i32* %14
%592 = add nsw i32 %590, %591
%593 = sext i32 %592 to i64
%594 = getelementptr inbounds i16, i16* %589, i64 %593
%595 = load i16, i16* %594
%596 = sext i16 %595 to i32
%597 = load i16, i16* %9
%598 = sext i16 %597 to i32
%599 = icmp eq i32 %596, %598
br i1 %599, label %600, label %603
600: ; preds = %582
%601 = load i32, i32* %15
%602 = add nsw i32 %601, 1
store i32 %602, i32* %15
br label %603
603: ; preds = %600, %582
br label %604
604: ; preds = %603
%605 = load i32, i32* %14
%606 = add nsw i32 %605, 1
store i32 %606, i32* %14
br label %579
607: ; preds = %579
br label %608
608: ; preds = %607
%609 = load i32, i32* %13
%610 = add nsw i32 %609, 1
store i32 %610, i32* %13
br label %575
611: ; preds = %575
%612 = load i32, i32* %15
%613 = load i16, i16* %10
%614 = sext i16 %613 to i32
%615 = icmp sgt i32 %612, %614
br i1 %615, label %616, label %635
616: ; preds = %611
%617 = load i16**, i16*** %7
%618 = load i32, i32* %16
%619 = load i32, i32* %17
%620 = load i16, i16* %9
%621 = sext i16 %620 to i32
%622 = call i32 (i16**, i32, i32, i32, ...) bitcast (i32 (...)* @can_dilate to i32 (i16**, i32, i32, i32, ...)*)(i16** %617, i32 %618, i32 %619, i32 %621)
%623 = icmp ne i32 %622, 0
br i1 %623, label %624, label %634
624: ; preds = %616
%625 = load i16, i16* %9
%626 = load i16**, i16*** %8
%627 = load i32, i32* %16
%628 = sext i32 %627 to i64
%629 = getelementptr inbounds i16*, i16** %626, i64 %628
%630 = load i16*, i16** %629
%631 = load i32, i32* %17
%632 = sext i32 %631 to i64
%633 = getelementptr inbounds i16, i16* %630, i64 %632
store i16 %625, i16* %633
br label %634
634: ; preds = %624, %616
br label %635
635: ; preds = %634, %611
br label %636
636: ; preds = %635, %562, %547
br label %637
637: ; preds = %636
%638 = load i32, i32* %16
%639 = add nsw i32 %638, 1
store i32 %639, i32* %16
br label %541
640: ; preds = %541
br label %641
641: ; preds = %640
%642 = load i32, i32* %17
%643 = add nsw i32 %642, 1
store i32 %643, i32* %17
br label %527
644: ; preds = %527
store i32 0, i32* %16
br label %645
645: ; preds = %678, %644
%646 = load i32, i32* %16
%647 = sext i32 %646 to i64
%648 = load i64, i64* %11
%649 = icmp slt i64 %647, %648
br i1 %649, label %650, label %681
650: ; preds = %645
store i32 0, i32* %17
br label %651
651: ; preds = %674, %650
%652 = load i32, i32* %17
%653 = sext i32 %652 to i64
%654 = load i64, i64* %12
%655 = icmp slt i64 %653, %654
br i1 %655, label %656, label %677
656: ; preds = %651
%657 = load i16**, i16*** %8
%658 = load i32, i32* %16
%659 = sext i32 %658 to i64
%660 = getelementptr inbounds i16*, i16** %657, i64 %659
%661 = load i16*, i16** %660
%662 = load i32, i32* %17
%663 = sext i32 %662 to i64
%664 = getelementptr inbounds i16, i16* %661, i64 %663
%665 = load i16, i16* %664
%666 = load i16**, i16*** %7
%667 = load i32, i32* %16
%668 = sext i32 %667 to i64
%669 = getelementptr inbounds i16*, i16** %666, i64 %668
%670 = load i16*, i16** %669
%671 = load i32, i32* %17
%672 = sext i32 %671 to i64
%673 = getelementptr inbounds i16, i16* %670, i64 %672
store i16 %665, i16* %673
br label %674
674: ; preds = %656
%675 = load i32, i32* %17
%676 = add nsw i32 %675, 1
store i32 %676, i32* %17
br label %651
677: ; preds = %651
br label %678
678: ; preds = %677
%679 = load i32, i32* %16
%680 = add nsw i32 %679, 1
store i32 %680, i32* %16
br label %645
681: ; preds = %645
ret i32 1
}

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