int _countNeighbors(unsigned short *im, const int dimx, const int dimy,
                    const int dimz, const int i, const int j, const int k,
                    unsigned short lbl) {
  int a, b, c;
  int ct = 0;
  c = k - 1;
  b = j;
  a = i;
  if ((c >= 0) && (c < dimz) && (b >= 0) && (b < dimy) && (a >= 0) &&
      (a < dimx))
    ct += (im[((b) * (dimx) + (a) + (c) * (dimx) * (dimy))] == lbl) ? 1 : 0;
  c = k + 1;
  b = j;
  a = i;
  if ((c >= 0) && (c < dimz) && (b >= 0) && (b < dimy) && (a >= 0) &&
      (a < dimx))
    ct += (im[((b) * (dimx) + (a) + (c) * (dimx) * (dimy))] == lbl) ? 1 : 0;
  c = k;
  b = j - 1;
  a = i;
  if ((c >= 0) && (c < dimz) && (b >= 0) && (b < dimy) && (a >= 0) &&
      (a < dimx))
    ct += (im[((b) * (dimx) + (a) + (c) * (dimx) * (dimy))] == lbl) ? 1 : 0;
  c = k;
  b = j + 1;
  a = i;
  if ((c >= 0) && (c < dimz) && (b >= 0) && (b < dimy) && (a >= 0) &&
      (a < dimx))
    ct += (im[((b) * (dimx) + (a) + (c) * (dimx) * (dimy))] == lbl) ? 1 : 0;
  c = k;
  b = j;
  a = i - 1;
  if ((c >= 0) && (c < dimz) && (b >= 0) && (b < dimy) && (a >= 0) &&
      (a < dimx))
    ct += (im[((b) * (dimx) + (a) + (c) * (dimx) * (dimy))] == lbl) ? 1 : 0;
  c = k;
  b = j;
  a = i + 1;
  if ((c >= 0) && (c < dimz) && (b >= 0) && (b < dimy) && (a >= 0) &&
      (a < dimx))
    ct += (im[((b) * (dimx) + (a) + (c) * (dimx) * (dimy))] == lbl) ? 1 : 0;
  c = k - 1;
  b = j - 1;
  a = i;
  if ((c >= 0) && (c < dimz) && (b >= 0) && (b < dimy) && (a >= 0) &&
      (a < dimx))
    ct += (im[((b) * (dimx) + (a) + (c) * (dimx) * (dimy))] == lbl) ? 1 : 0;
  c = k - 1;
  b = j + 1;
  a = i;
  if ((c >= 0) && (c < dimz) && (b >= 0) && (b < dimy) && (a >= 0) &&
      (a < dimx))
    ct += (im[((b) * (dimx) + (a) + (c) * (dimx) * (dimy))] == lbl) ? 1 : 0;
  c = k - 1;
  b = j;
  a = i - 1;
  if ((c >= 0) && (c < dimz) && (b >= 0) && (b < dimy) && (a >= 0) &&
      (a < dimx))
    ct += (im[((b) * (dimx) + (a) + (c) * (dimx) * (dimy))] == lbl) ? 1 : 0;
  c = k - 1;
  b = j;
  a = i + 1;
  if ((c >= 0) && (c < dimz) && (b >= 0) && (b < dimy) && (a >= 0) &&
      (a < dimx))
    ct += (im[((b) * (dimx) + (a) + (c) * (dimx) * (dimy))] == lbl) ? 1 : 0;
  c = k + 1;
  b = j - 1;
  a = i;
  if ((c >= 0) && (c < dimz) && (b >= 0) && (b < dimy) && (a >= 0) &&
      (a < dimx))
    ct += (im[((b) * (dimx) + (a) + (c) * (dimx) * (dimy))] == lbl) ? 1 : 0;
  c = k + 1;
  b = j + 1;
  a = i;
  if ((c >= 0) && (c < dimz) && (b >= 0) && (b < dimy) && (a >= 0) &&
      (a < dimx))
    ct += (im[((b) * (dimx) + (a) + (c) * (dimx) * (dimy))] == lbl) ? 1 : 0;
  c = k + 1;
  b = j;
  a = i - 1;
  if ((c >= 0) && (c < dimz) && (b >= 0) && (b < dimy) && (a >= 0) &&
      (a < dimx))
    ct += (im[((b) * (dimx) + (a) + (c) * (dimx) * (dimy))] == lbl) ? 1 : 0;
  c = k + 1;
  b = j;
  a = i + 1;
  if ((c >= 0) && (c < dimz) && (b >= 0) && (b < dimy) && (a >= 0) &&
      (a < dimx))
    ct += (im[((b) * (dimx) + (a) + (c) * (dimx) * (dimy))] == lbl) ? 1 : 0;
  c = k;
  b = j - 1;
  a = i - 1;
  if ((c >= 0) && (c < dimz) && (b >= 0) && (b < dimy) && (a >= 0) &&
      (a < dimx))
    ct += (im[((b) * (dimx) + (a) + (c) * (dimx) * (dimy))] == lbl) ? 1 : 0;
  c = k;
  b = j - 1;
  a = i + 1;
  if ((c >= 0) && (c < dimz) && (b >= 0) && (b < dimy) && (a >= 0) &&
      (a < dimx))
    ct += (im[((b) * (dimx) + (a) + (c) * (dimx) * (dimy))] == lbl) ? 1 : 0;
  c = k;
  b = j + 1;
  a = i - 1;
  if ((c >= 0) && (c < dimz) && (b >= 0) && (b < dimy) && (a >= 0) &&
      (a < dimx))
    ct += (im[((b) * (dimx) + (a) + (c) * (dimx) * (dimy))] == lbl) ? 1 : 0;
  c = k;
  b = j + 1;
  a = i + 1;
  if ((c >= 0) && (c < dimz) && (b >= 0) && (b < dimy) && (a >= 0) &&
      (a < dimx))
    ct += (im[((b) * (dimx) + (a) + (c) * (dimx) * (dimy))] == lbl) ? 1 : 0;
  c = k - 1;
  b = j - 1;
  a = i - 1;
  if ((c >= 0) && (c < dimz) && (b >= 0) && (b < dimy) && (a >= 0) &&
      (a < dimx))
    ct += (im[((b) * (dimx) + (a) + (c) * (dimx) * (dimy))] == lbl) ? 1 : 0;
  c = k - 1;
  b = j - 1;
  a = i + 1;
  if ((c >= 0) && (c < dimz) && (b >= 0) && (b < dimy) && (a >= 0) &&
      (a < dimx))
    ct += (im[((b) * (dimx) + (a) + (c) * (dimx) * (dimy))] == lbl) ? 1 : 0;
  c = k - 1;
  b = j + 1;
  a = i - 1;
  if ((c >= 0) && (c < dimz) && (b >= 0) && (b < dimy) && (a >= 0) &&
      (a < dimx))
    ct += (im[((b) * (dimx) + (a) + (c) * (dimx) * (dimy))] == lbl) ? 1 : 0;
  c = k - 1;
  b = j + 1;
  a = i + 1;
  if ((c >= 0) && (c < dimz) && (b >= 0) && (b < dimy) && (a >= 0) &&
      (a < dimx))
    ct += (im[((b) * (dimx) + (a) + (c) * (dimx) * (dimy))] == lbl) ? 1 : 0;
  c = k + 1;
  b = j - 1;
  a = i - 1;
  if ((c >= 0) && (c < dimz) && (b >= 0) && (b < dimy) && (a >= 0) &&
      (a < dimx))
    ct += (im[((b) * (dimx) + (a) + (c) * (dimx) * (dimy))] == lbl) ? 1 : 0;
  c = k + 1;
  b = j - 1;
  a = i + 1;
  if ((c >= 0) && (c < dimz) && (b >= 0) && (b < dimy) && (a >= 0) &&
      (a < dimx))
    ct += (im[((b) * (dimx) + (a) + (c) * (dimx) * (dimy))] == lbl) ? 1 : 0;
  c = k + 1;
  b = j + 1;
  a = i - 1;
  if ((c >= 0) && (c < dimz) && (b >= 0) && (b < dimy) && (a >= 0) &&
      (a < dimx))
    ct += (im[((b) * (dimx) + (a) + (c) * (dimx) * (dimy))] == lbl) ? 1 : 0;
  c = k + 1;
  b = j + 1;
  a = i + 1;
  if ((c >= 0) && (c < dimz) && (b >= 0) && (b < dimy) && (a >= 0) &&
      (a < dimx))
    ct += (im[((b) * (dimx) + (a) + (c) * (dimx) * (dimy))] == lbl) ? 1 : 0;
  return ct;
}


x86 assembly (clang, -O0):
<_countNeighbors>:
push   %rbp
mov    %rsp,%rbp
mov    0x18(%rbp),%ax
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8d,-0x18(%rbp)
mov    %r9d,-0x1c(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    0x10(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x20(%rbp)
cmpl   $0x0,-0x28(%rbp)
jl     11b6 <_countNeighbors+0xb6>
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11b6 <_countNeighbors+0xb6>
cmpl   $0x0,-0x24(%rbp)
jl     11b6 <_countNeighbors+0xb6>
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    11b6 <_countNeighbors+0xb6>
cmpl   $0x0,-0x20(%rbp)
jl     11b6 <_countNeighbors+0xb6>
mov    -0x20(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    11b6 <_countNeighbors+0xb6>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x20(%rbp),%ecx
mov    -0x28(%rbp),%edx
imul   -0xc(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movzwl (%rax,%rcx,2),%edx
movzwl 0x18(%rbp),%esi
xor    %eax,%eax
mov    $0x1,%ecx
cmp    %esi,%edx
cmove  %ecx,%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x20(%rbp)
cmpl   $0x0,-0x28(%rbp)
jl     1245 <_countNeighbors+0x145>
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1245 <_countNeighbors+0x145>
cmpl   $0x0,-0x24(%rbp)
jl     1245 <_countNeighbors+0x145>
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1245 <_countNeighbors+0x145>
cmpl   $0x0,-0x20(%rbp)
jl     1245 <_countNeighbors+0x145>
mov    -0x20(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1245 <_countNeighbors+0x145>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x20(%rbp),%ecx
mov    -0x28(%rbp),%edx
imul   -0xc(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movzwl (%rax,%rcx,2),%edx
movzwl 0x18(%rbp),%esi
xor    %eax,%eax
mov    $0x1,%ecx
cmp    %esi,%edx
cmove  %ecx,%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    0x10(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x20(%rbp)
cmpl   $0x0,-0x28(%rbp)
jl     12d4 <_countNeighbors+0x1d4>
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    12d4 <_countNeighbors+0x1d4>
cmpl   $0x0,-0x24(%rbp)
jl     12d4 <_countNeighbors+0x1d4>
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    12d4 <_countNeighbors+0x1d4>
cmpl   $0x0,-0x20(%rbp)
jl     12d4 <_countNeighbors+0x1d4>
mov    -0x20(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    12d4 <_countNeighbors+0x1d4>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x20(%rbp),%ecx
mov    -0x28(%rbp),%edx
imul   -0xc(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movzwl (%rax,%rcx,2),%edx
movzwl 0x18(%rbp),%esi
xor    %eax,%eax
mov    $0x1,%ecx
cmp    %esi,%edx
cmove  %ecx,%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    0x10(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x20(%rbp)
cmpl   $0x0,-0x28(%rbp)
jl     1363 <_countNeighbors+0x263>
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1363 <_countNeighbors+0x263>
cmpl   $0x0,-0x24(%rbp)
jl     1363 <_countNeighbors+0x263>
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1363 <_countNeighbors+0x263>
cmpl   $0x0,-0x20(%rbp)
jl     1363 <_countNeighbors+0x263>
mov    -0x20(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1363 <_countNeighbors+0x263>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x20(%rbp),%ecx
mov    -0x28(%rbp),%edx
imul   -0xc(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movzwl (%rax,%rcx,2),%edx
movzwl 0x18(%rbp),%esi
xor    %eax,%eax
mov    $0x1,%ecx
cmp    %esi,%edx
cmove  %ecx,%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    0x10(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x18(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x20(%rbp)
cmpl   $0x0,-0x28(%rbp)
jl     13f2 <_countNeighbors+0x2f2>
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    13f2 <_countNeighbors+0x2f2>
cmpl   $0x0,-0x24(%rbp)
jl     13f2 <_countNeighbors+0x2f2>
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    13f2 <_countNeighbors+0x2f2>
cmpl   $0x0,-0x20(%rbp)
jl     13f2 <_countNeighbors+0x2f2>
mov    -0x20(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    13f2 <_countNeighbors+0x2f2>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x20(%rbp),%ecx
mov    -0x28(%rbp),%edx
imul   -0xc(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movzwl (%rax,%rcx,2),%edx
movzwl 0x18(%rbp),%esi
xor    %eax,%eax
mov    $0x1,%ecx
cmp    %esi,%edx
cmove  %ecx,%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    0x10(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
cmpl   $0x0,-0x28(%rbp)
jl     1481 <_countNeighbors+0x381>
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1481 <_countNeighbors+0x381>
cmpl   $0x0,-0x24(%rbp)
jl     1481 <_countNeighbors+0x381>
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1481 <_countNeighbors+0x381>
cmpl   $0x0,-0x20(%rbp)
jl     1481 <_countNeighbors+0x381>
mov    -0x20(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1481 <_countNeighbors+0x381>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x20(%rbp),%ecx
mov    -0x28(%rbp),%edx
imul   -0xc(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movzwl (%rax,%rcx,2),%edx
movzwl 0x18(%rbp),%esi
xor    %eax,%eax
mov    $0x1,%ecx
cmp    %esi,%edx
cmove  %ecx,%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    0x10(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x20(%rbp)
cmpl   $0x0,-0x28(%rbp)
jl     1513 <_countNeighbors+0x413>
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1513 <_countNeighbors+0x413>
cmpl   $0x0,-0x24(%rbp)
jl     1513 <_countNeighbors+0x413>
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1513 <_countNeighbors+0x413>
cmpl   $0x0,-0x20(%rbp)
jl     1513 <_countNeighbors+0x413>
mov    -0x20(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1513 <_countNeighbors+0x413>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x20(%rbp),%ecx
mov    -0x28(%rbp),%edx
imul   -0xc(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movzwl (%rax,%rcx,2),%edx
movzwl 0x18(%rbp),%esi
xor    %eax,%eax
mov    $0x1,%ecx
cmp    %esi,%edx
cmove  %ecx,%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    0x10(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x20(%rbp)
cmpl   $0x0,-0x28(%rbp)
jl     15a5 <_countNeighbors+0x4a5>
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    15a5 <_countNeighbors+0x4a5>
cmpl   $0x0,-0x24(%rbp)
jl     15a5 <_countNeighbors+0x4a5>
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    15a5 <_countNeighbors+0x4a5>
cmpl   $0x0,-0x20(%rbp)
jl     15a5 <_countNeighbors+0x4a5>
mov    -0x20(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    15a5 <_countNeighbors+0x4a5>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x20(%rbp),%ecx
mov    -0x28(%rbp),%edx
imul   -0xc(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movzwl (%rax,%rcx,2),%edx
movzwl 0x18(%rbp),%esi
xor    %eax,%eax
mov    $0x1,%ecx
cmp    %esi,%edx
cmove  %ecx,%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    0x10(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x18(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x20(%rbp)
cmpl   $0x0,-0x28(%rbp)
jl     1637 <_countNeighbors+0x537>
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1637 <_countNeighbors+0x537>
cmpl   $0x0,-0x24(%rbp)
jl     1637 <_countNeighbors+0x537>
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1637 <_countNeighbors+0x537>
cmpl   $0x0,-0x20(%rbp)
jl     1637 <_countNeighbors+0x537>
mov    -0x20(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1637 <_countNeighbors+0x537>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x20(%rbp),%ecx
mov    -0x28(%rbp),%edx
imul   -0xc(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movzwl (%rax,%rcx,2),%edx
movzwl 0x18(%rbp),%esi
xor    %eax,%eax
mov    $0x1,%ecx
cmp    %esi,%edx
cmove  %ecx,%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    0x10(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
cmpl   $0x0,-0x28(%rbp)
jl     16c9 <_countNeighbors+0x5c9>
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    16c9 <_countNeighbors+0x5c9>
cmpl   $0x0,-0x24(%rbp)
jl     16c9 <_countNeighbors+0x5c9>
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    16c9 <_countNeighbors+0x5c9>
cmpl   $0x0,-0x20(%rbp)
jl     16c9 <_countNeighbors+0x5c9>
mov    -0x20(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    16c9 <_countNeighbors+0x5c9>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x20(%rbp),%ecx
mov    -0x28(%rbp),%edx
imul   -0xc(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movzwl (%rax,%rcx,2),%edx
movzwl 0x18(%rbp),%esi
xor    %eax,%eax
mov    $0x1,%ecx
cmp    %esi,%edx
cmove  %ecx,%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x20(%rbp)
cmpl   $0x0,-0x28(%rbp)
jl     175b <_countNeighbors+0x65b>
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    175b <_countNeighbors+0x65b>
cmpl   $0x0,-0x24(%rbp)
jl     175b <_countNeighbors+0x65b>
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    175b <_countNeighbors+0x65b>
cmpl   $0x0,-0x20(%rbp)
jl     175b <_countNeighbors+0x65b>
mov    -0x20(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    175b <_countNeighbors+0x65b>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x20(%rbp),%ecx
mov    -0x28(%rbp),%edx
imul   -0xc(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movzwl (%rax,%rcx,2),%edx
movzwl 0x18(%rbp),%esi
xor    %eax,%eax
mov    $0x1,%ecx
cmp    %esi,%edx
cmove  %ecx,%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x20(%rbp)
cmpl   $0x0,-0x28(%rbp)
jl     17ed <_countNeighbors+0x6ed>
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    17ed <_countNeighbors+0x6ed>
cmpl   $0x0,-0x24(%rbp)
jl     17ed <_countNeighbors+0x6ed>
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    17ed <_countNeighbors+0x6ed>
cmpl   $0x0,-0x20(%rbp)
jl     17ed <_countNeighbors+0x6ed>
mov    -0x20(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    17ed <_countNeighbors+0x6ed>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x20(%rbp),%ecx
mov    -0x28(%rbp),%edx
imul   -0xc(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movzwl (%rax,%rcx,2),%edx
movzwl 0x18(%rbp),%esi
xor    %eax,%eax
mov    $0x1,%ecx
cmp    %esi,%edx
cmove  %ecx,%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x18(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x20(%rbp)
cmpl   $0x0,-0x28(%rbp)
jl     187f <_countNeighbors+0x77f>
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    187f <_countNeighbors+0x77f>
cmpl   $0x0,-0x24(%rbp)
jl     187f <_countNeighbors+0x77f>
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    187f <_countNeighbors+0x77f>
cmpl   $0x0,-0x20(%rbp)
jl     187f <_countNeighbors+0x77f>
mov    -0x20(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    187f <_countNeighbors+0x77f>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x20(%rbp),%ecx
mov    -0x28(%rbp),%edx
imul   -0xc(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movzwl (%rax,%rcx,2),%edx
movzwl 0x18(%rbp),%esi
xor    %eax,%eax
mov    $0x1,%ecx
cmp    %esi,%edx
cmove  %ecx,%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
cmpl   $0x0,-0x28(%rbp)
jl     1911 <_countNeighbors+0x811>
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1911 <_countNeighbors+0x811>
cmpl   $0x0,-0x24(%rbp)
jl     1911 <_countNeighbors+0x811>
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1911 <_countNeighbors+0x811>
cmpl   $0x0,-0x20(%rbp)
jl     1911 <_countNeighbors+0x811>
mov    -0x20(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1911 <_countNeighbors+0x811>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x20(%rbp),%ecx
mov    -0x28(%rbp),%edx
imul   -0xc(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movzwl (%rax,%rcx,2),%edx
movzwl 0x18(%rbp),%esi
xor    %eax,%eax
mov    $0x1,%ecx
cmp    %esi,%edx
cmove  %ecx,%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    0x10(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x18(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x20(%rbp)
cmpl   $0x0,-0x28(%rbp)
jl     19a3 <_countNeighbors+0x8a3>
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    19a3 <_countNeighbors+0x8a3>
cmpl   $0x0,-0x24(%rbp)
jl     19a3 <_countNeighbors+0x8a3>
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    19a3 <_countNeighbors+0x8a3>
cmpl   $0x0,-0x20(%rbp)
jl     19a3 <_countNeighbors+0x8a3>
mov    -0x20(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    19a3 <_countNeighbors+0x8a3>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x20(%rbp),%ecx
mov    -0x28(%rbp),%edx
imul   -0xc(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movzwl (%rax,%rcx,2),%edx
movzwl 0x18(%rbp),%esi
xor    %eax,%eax
mov    $0x1,%ecx
cmp    %esi,%edx
cmove  %ecx,%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    0x10(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
cmpl   $0x0,-0x28(%rbp)
jl     1a35 <_countNeighbors+0x935>
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1a35 <_countNeighbors+0x935>
cmpl   $0x0,-0x24(%rbp)
jl     1a35 <_countNeighbors+0x935>
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1a35 <_countNeighbors+0x935>
cmpl   $0x0,-0x20(%rbp)
jl     1a35 <_countNeighbors+0x935>
mov    -0x20(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1a35 <_countNeighbors+0x935>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x20(%rbp),%ecx
mov    -0x28(%rbp),%edx
imul   -0xc(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movzwl (%rax,%rcx,2),%edx
movzwl 0x18(%rbp),%esi
xor    %eax,%eax
mov    $0x1,%ecx
cmp    %esi,%edx
cmove  %ecx,%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    0x10(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x18(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x20(%rbp)
cmpl   $0x0,-0x28(%rbp)
jl     1ac7 <_countNeighbors+0x9c7>
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1ac7 <_countNeighbors+0x9c7>
cmpl   $0x0,-0x24(%rbp)
jl     1ac7 <_countNeighbors+0x9c7>
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1ac7 <_countNeighbors+0x9c7>
cmpl   $0x0,-0x20(%rbp)
jl     1ac7 <_countNeighbors+0x9c7>
mov    -0x20(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1ac7 <_countNeighbors+0x9c7>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x20(%rbp),%ecx
mov    -0x28(%rbp),%edx
imul   -0xc(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movzwl (%rax,%rcx,2),%edx
movzwl 0x18(%rbp),%esi
xor    %eax,%eax
mov    $0x1,%ecx
cmp    %esi,%edx
cmove  %ecx,%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    0x10(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
cmpl   $0x0,-0x28(%rbp)
jl     1b59 <_countNeighbors+0xa59>
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1b59 <_countNeighbors+0xa59>
cmpl   $0x0,-0x24(%rbp)
jl     1b59 <_countNeighbors+0xa59>
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1b59 <_countNeighbors+0xa59>
cmpl   $0x0,-0x20(%rbp)
jl     1b59 <_countNeighbors+0xa59>
mov    -0x20(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1b59 <_countNeighbors+0xa59>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x20(%rbp),%ecx
mov    -0x28(%rbp),%edx
imul   -0xc(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movzwl (%rax,%rcx,2),%edx
movzwl 0x18(%rbp),%esi
xor    %eax,%eax
mov    $0x1,%ecx
cmp    %esi,%edx
cmove  %ecx,%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    0x10(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x18(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x20(%rbp)
cmpl   $0x0,-0x28(%rbp)
jl     1bee <_countNeighbors+0xaee>
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1bee <_countNeighbors+0xaee>
cmpl   $0x0,-0x24(%rbp)
jl     1bee <_countNeighbors+0xaee>
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1bee <_countNeighbors+0xaee>
cmpl   $0x0,-0x20(%rbp)
jl     1bee <_countNeighbors+0xaee>
mov    -0x20(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1bee <_countNeighbors+0xaee>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x20(%rbp),%ecx
mov    -0x28(%rbp),%edx
imul   -0xc(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movzwl (%rax,%rcx,2),%edx
movzwl 0x18(%rbp),%esi
xor    %eax,%eax
mov    $0x1,%ecx
cmp    %esi,%edx
cmove  %ecx,%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    0x10(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
cmpl   $0x0,-0x28(%rbp)
jl     1c83 <_countNeighbors+0xb83>
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1c83 <_countNeighbors+0xb83>
cmpl   $0x0,-0x24(%rbp)
jl     1c83 <_countNeighbors+0xb83>
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1c83 <_countNeighbors+0xb83>
cmpl   $0x0,-0x20(%rbp)
jl     1c83 <_countNeighbors+0xb83>
mov    -0x20(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1c83 <_countNeighbors+0xb83>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x20(%rbp),%ecx
mov    -0x28(%rbp),%edx
imul   -0xc(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movzwl (%rax,%rcx,2),%edx
movzwl 0x18(%rbp),%esi
xor    %eax,%eax
mov    $0x1,%ecx
cmp    %esi,%edx
cmove  %ecx,%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    0x10(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x18(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x20(%rbp)
cmpl   $0x0,-0x28(%rbp)
jl     1d18 <_countNeighbors+0xc18>
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1d18 <_countNeighbors+0xc18>
cmpl   $0x0,-0x24(%rbp)
jl     1d18 <_countNeighbors+0xc18>
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1d18 <_countNeighbors+0xc18>
cmpl   $0x0,-0x20(%rbp)
jl     1d18 <_countNeighbors+0xc18>
mov    -0x20(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1d18 <_countNeighbors+0xc18>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x20(%rbp),%ecx
mov    -0x28(%rbp),%edx
imul   -0xc(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movzwl (%rax,%rcx,2),%edx
movzwl 0x18(%rbp),%esi
xor    %eax,%eax
mov    $0x1,%ecx
cmp    %esi,%edx
cmove  %ecx,%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    0x10(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
cmpl   $0x0,-0x28(%rbp)
jl     1dad <_countNeighbors+0xcad>
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1dad <_countNeighbors+0xcad>
cmpl   $0x0,-0x24(%rbp)
jl     1dad <_countNeighbors+0xcad>
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1dad <_countNeighbors+0xcad>
cmpl   $0x0,-0x20(%rbp)
jl     1dad <_countNeighbors+0xcad>
mov    -0x20(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1dad <_countNeighbors+0xcad>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x20(%rbp),%ecx
mov    -0x28(%rbp),%edx
imul   -0xc(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movzwl (%rax,%rcx,2),%edx
movzwl 0x18(%rbp),%esi
xor    %eax,%eax
mov    $0x1,%ecx
cmp    %esi,%edx
cmove  %ecx,%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x18(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x20(%rbp)
cmpl   $0x0,-0x28(%rbp)
jl     1e42 <_countNeighbors+0xd42>
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1e42 <_countNeighbors+0xd42>
cmpl   $0x0,-0x24(%rbp)
jl     1e42 <_countNeighbors+0xd42>
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1e42 <_countNeighbors+0xd42>
cmpl   $0x0,-0x20(%rbp)
jl     1e42 <_countNeighbors+0xd42>
mov    -0x20(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1e42 <_countNeighbors+0xd42>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x20(%rbp),%ecx
mov    -0x28(%rbp),%edx
imul   -0xc(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movzwl (%rax,%rcx,2),%edx
movzwl 0x18(%rbp),%esi
xor    %eax,%eax
mov    $0x1,%ecx
cmp    %esi,%edx
cmove  %ecx,%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x1c(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
cmpl   $0x0,-0x28(%rbp)
jl     1ed7 <_countNeighbors+0xdd7>
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1ed7 <_countNeighbors+0xdd7>
cmpl   $0x0,-0x24(%rbp)
jl     1ed7 <_countNeighbors+0xdd7>
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1ed7 <_countNeighbors+0xdd7>
cmpl   $0x0,-0x20(%rbp)
jl     1ed7 <_countNeighbors+0xdd7>
mov    -0x20(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1ed7 <_countNeighbors+0xdd7>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x20(%rbp),%ecx
mov    -0x28(%rbp),%edx
imul   -0xc(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movzwl (%rax,%rcx,2),%edx
movzwl 0x18(%rbp),%esi
xor    %eax,%eax
mov    $0x1,%ecx
cmp    %esi,%edx
cmove  %ecx,%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x18(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x20(%rbp)
cmpl   $0x0,-0x28(%rbp)
jl     1f6c <_countNeighbors+0xe6c>
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1f6c <_countNeighbors+0xe6c>
cmpl   $0x0,-0x24(%rbp)
jl     1f6c <_countNeighbors+0xe6c>
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1f6c <_countNeighbors+0xe6c>
cmpl   $0x0,-0x20(%rbp)
jl     1f6c <_countNeighbors+0xe6c>
mov    -0x20(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1f6c <_countNeighbors+0xe6c>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x20(%rbp),%ecx
mov    -0x28(%rbp),%edx
imul   -0xc(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movzwl (%rax,%rcx,2),%edx
movzwl 0x18(%rbp),%esi
xor    %eax,%eax
mov    $0x1,%ecx
cmp    %esi,%edx
cmove  %ecx,%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
cmpl   $0x0,-0x28(%rbp)
jl     2001 <_countNeighbors+0xf01>
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    2001 <_countNeighbors+0xf01>
cmpl   $0x0,-0x24(%rbp)
jl     2001 <_countNeighbors+0xf01>
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    2001 <_countNeighbors+0xf01>
cmpl   $0x0,-0x20(%rbp)
jl     2001 <_countNeighbors+0xf01>
mov    -0x20(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    2001 <_countNeighbors+0xf01>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x20(%rbp),%ecx
mov    -0x28(%rbp),%edx
imul   -0xc(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movzwl (%rax,%rcx,2),%edx
movzwl 0x18(%rbp),%esi
xor    %eax,%eax
mov    $0x1,%ecx
cmp    %esi,%edx
cmove  %ecx,%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<_countNeighbors>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
movzwl 0x40(%rsp),%r10d
mov    0x38(%rsp),%r12d
lea    -0x1(%r12),%eax
mov    %eax,-0x8(%rsp)
test   %r12d,%r12d
jle    1162 <_countNeighbors+0x62>
xor    %eax,%eax
test   %r9d,%r9d
js     115b <_countNeighbors+0x5b>
cmp    %ecx,%r12d
jg     115b <_countNeighbors+0x5b>
cmp    %esi,%r8d
jge    115b <_countNeighbors+0x5b>
test   %r8d,%r8d
js     115b <_countNeighbors+0x5b>
cmp    %edx,%r9d
jge    115b <_countNeighbors+0x5b>
mov    -0x8(%rsp),%eax
imul   %edx,%eax
add    %r9d,%eax
imul   %esi,%eax
add    %r8d,%eax
movslq %eax,%rbp
xor    %eax,%eax
cmp    %r10w,(%rdi,%rbp,2)
sete   %al
lea    0x1(%r12),%r11d
jmp    1173 <_countNeighbors+0x73>
lea    0x1(%r12),%r11d
xor    %eax,%eax
cmp    $0xffffffff,%r12d
jl     12c9 <_countNeighbors+0x1c9>
test   %r9d,%r9d
js     11aa <_countNeighbors+0xaa>
cmp    %ecx,%r11d
jge    11aa <_countNeighbors+0xaa>
cmp    %esi,%r8d
jge    11aa <_countNeighbors+0xaa>
test   %r8d,%r8d
js     11aa <_countNeighbors+0xaa>
cmp    %edx,%r9d
jge    11aa <_countNeighbors+0xaa>
mov    %r11d,%ebp
imul   %edx,%ebp
add    %r9d,%ebp
imul   %esi,%ebp
add    %r8d,%ebp
movslq %ebp,%rbp
xor    %ebx,%ebx
cmp    %r10w,(%rdi,%rbp,2)
sete   %bl
add    %ebx,%eax
lea    -0x1(%r9),%ebx
mov    %ebx,-0xc(%rsp)
test   %r12d,%r12d
js     12ad <_countNeighbors+0x1ad>
test   %r9d,%r9d
jle    11f3 <_countNeighbors+0xf3>
cmp    %ecx,%r12d
jge    11f3 <_countNeighbors+0xf3>
cmp    %esi,%r8d
jge    11f3 <_countNeighbors+0xf3>
test   %r8d,%r8d
js     11f3 <_countNeighbors+0xf3>
cmp    %edx,%r9d
jg     11f3 <_countNeighbors+0xf3>
mov    %r12d,%ebp
imul   %edx,%ebp
add    -0xc(%rsp),%ebp
imul   %esi,%ebp
add    %r8d,%ebp
movslq %ebp,%rbp
xor    %ebx,%ebx
cmp    %r10w,(%rdi,%rbp,2)
sete   %bl
add    %ebx,%eax
lea    0x1(%r9),%r13d
cmp    $0xffffffff,%r9d
jl     122f <_countNeighbors+0x12f>
cmp    %ecx,%r12d
jge    122f <_countNeighbors+0x12f>
cmp    %esi,%r8d
jge    122f <_countNeighbors+0x12f>
test   %r8d,%r8d
js     122f <_countNeighbors+0x12f>
cmp    %edx,%r13d
jge    122f <_countNeighbors+0x12f>
mov    %r12d,%ebp
imul   %edx,%ebp
add    %r13d,%ebp
imul   %esi,%ebp
add    %r8d,%ebp
movslq %ebp,%rbp
xor    %ebx,%ebx
cmp    %r10w,(%rdi,%rbp,2)
sete   %bl
add    %ebx,%eax
lea    -0x1(%r8),%ebx
mov    %ebx,-0x10(%rsp)
test   %r9d,%r9d
js     12b9 <_countNeighbors+0x1b9>
cmp    %ecx,%r12d
jge    12b9 <_countNeighbors+0x1b9>
cmp    %esi,%r8d
jg     126f <_countNeighbors+0x16f>
test   %r8d,%r8d
jle    126f <_countNeighbors+0x16f>
cmp    %edx,%r9d
jge    126f <_countNeighbors+0x16f>
mov    %r12d,%ebp
imul   %edx,%ebp
add    %r9d,%ebp
imul   %esi,%ebp
add    -0x10(%rsp),%ebp
movslq %ebp,%rbp
xor    %ebx,%ebx
cmp    %r10w,(%rdi,%rbp,2)
sete   %bl
add    %ebx,%eax
lea    0x1(%r8),%r15d
mov    $0x1,%bl
mov    %ebx,-0x4(%rsp)
cmp    $0xffffffff,%r8d
jl     12fb <_countNeighbors+0x1fb>
cmp    %edx,%r9d
jge    12fb <_countNeighbors+0x1fb>
cmp    %esi,%r15d
jge    12fb <_countNeighbors+0x1fb>
mov    %r12d,%ebx
imul   %edx,%ebx
add    %r9d,%ebx
imul   %esi,%ebx
add    %r15d,%ebx
movslq %ebx,%rbx
xor    %ebp,%ebp
mov    %r10d,%r14d
cmp    %r10w,(%rdi,%rbx,2)
sete   %bpl
add    %ebp,%eax
jmp    12fe <_countNeighbors+0x1fe>
mov    %r10d,%r14d
mov    $0x1,%bpl
mov    %ebp,-0x4(%rsp)
jmp    12de <_countNeighbors+0x1de>
mov    %r10d,%r14d
lea    0x1(%r8),%r15d
mov    $0x1,%bpl
mov    %ebp,-0x4(%rsp)
jmp    12fe <_countNeighbors+0x1fe>
mov    %r10d,%r14d
lea    -0x1(%r9),%eax
mov    %eax,-0xc(%rsp)
movl   $0x0,-0x4(%rsp)
xor    %eax,%eax
lea    0x1(%r9),%r13d
lea    -0x1(%r8),%ebp
mov    %ebp,-0x10(%rsp)
lea    0x1(%r8),%r15d
xor    %r10d,%r10d
test   %r12d,%r12d
jg     130a <_countNeighbors+0x20a>
jmp    13e8 <_countNeighbors+0x2e8>
mov    %r10d,%r14d
mov    $0x1,%r10b
test   %r12d,%r12d
jle    13e8 <_countNeighbors+0x2e8>
test   %r9d,%r9d
jle    1344 <_countNeighbors+0x244>
cmp    %ecx,%r12d
jg     1344 <_countNeighbors+0x244>
cmp    %esi,%r8d
jge    1344 <_countNeighbors+0x244>
test   %r8d,%r8d
js     1344 <_countNeighbors+0x244>
cmp    %edx,%r9d
jg     1344 <_countNeighbors+0x244>
mov    -0x8(%rsp),%ebx
imul   %edx,%ebx
add    -0xc(%rsp),%ebx
imul   %esi,%ebx
add    %r8d,%ebx
movslq %ebx,%rbx
xor    %ebp,%ebp
cmp    %r14w,(%rdi,%rbx,2)
sete   %bpl
add    %ebp,%eax
cmp    $0xffffffff,%r9d
jl     137e <_countNeighbors+0x27e>
cmp    %ecx,%r12d
jg     137e <_countNeighbors+0x27e>
cmp    %esi,%r8d
jge    137e <_countNeighbors+0x27e>
test   %r8d,%r8d
js     137e <_countNeighbors+0x27e>
cmp    %edx,%r13d
jge    137e <_countNeighbors+0x27e>
mov    -0x8(%rsp),%ebx
imul   %edx,%ebx
add    %r13d,%ebx
imul   %esi,%ebx
add    %r8d,%ebx
movslq %ebx,%rbx
xor    %ebp,%ebp
cmp    %r14w,(%rdi,%rbx,2)
sete   %bpl
add    %ebp,%eax
test   %r9d,%r9d
js     13e8 <_countNeighbors+0x2e8>
cmp    %ecx,%r12d
jg     13e8 <_countNeighbors+0x2e8>
cmp    %esi,%r8d
jg     13b8 <_countNeighbors+0x2b8>
test   %r8d,%r8d
jle    13b8 <_countNeighbors+0x2b8>
cmp    %edx,%r9d
jge    13b8 <_countNeighbors+0x2b8>
mov    -0x8(%rsp),%ebx
imul   %edx,%ebx
add    %r9d,%ebx
imul   %esi,%ebx
add    -0x10(%rsp),%ebx
movslq %ebx,%rbx
xor    %ebp,%ebp
cmp    %r14w,(%rdi,%rbx,2)
sete   %bpl
add    %ebp,%eax
cmp    $0xffffffff,%r8d
jl     13e8 <_countNeighbors+0x2e8>
cmp    %edx,%r9d
jge    13e8 <_countNeighbors+0x2e8>
cmp    %esi,%r15d
jge    13e8 <_countNeighbors+0x2e8>
mov    -0x8(%rsp),%ebx
imul   %edx,%ebx
add    %r9d,%ebx
imul   %esi,%ebx
add    %r15d,%ebx
movslq %ebx,%rbx
xor    %ebp,%ebp
cmp    %r14w,(%rdi,%rbx,2)
sete   %bpl
add    %ebp,%eax
cmpb   $0x0,-0x4(%rsp)
je     14cd <_countNeighbors+0x3cd>
test   %r9d,%r9d
jle    142c <_countNeighbors+0x32c>
cmp    %ecx,%r11d
jge    142c <_countNeighbors+0x32c>
cmp    %esi,%r8d
jge    142c <_countNeighbors+0x32c>
test   %r8d,%r8d
js     142c <_countNeighbors+0x32c>
cmp    %edx,%r9d
jg     142c <_countNeighbors+0x32c>
mov    %r11d,%ebx
imul   %edx,%ebx
add    -0xc(%rsp),%ebx
imul   %esi,%ebx
add    %r8d,%ebx
movslq %ebx,%rbx
xor    %ebp,%ebp
cmp    %r14w,(%rdi,%rbx,2)
sete   %bpl
add    %ebp,%eax
cmp    $0xffffffff,%r9d
jl     1465 <_countNeighbors+0x365>
cmp    %ecx,%r11d
jge    1465 <_countNeighbors+0x365>
cmp    %esi,%r8d
jge    1465 <_countNeighbors+0x365>
test   %r8d,%r8d
js     1465 <_countNeighbors+0x365>
cmp    %edx,%r13d
jge    1465 <_countNeighbors+0x365>
mov    %r11d,%ebx
imul   %edx,%ebx
add    %r13d,%ebx
imul   %esi,%ebx
add    %r8d,%ebx
movslq %ebx,%rbx
xor    %ebp,%ebp
cmp    %r14w,(%rdi,%rbx,2)
sete   %bpl
add    %ebp,%eax
test   %r9d,%r9d
js     14cd <_countNeighbors+0x3cd>
cmp    %ecx,%r11d
jge    14cd <_countNeighbors+0x3cd>
cmp    %esi,%r8d
jg     149e <_countNeighbors+0x39e>
test   %r8d,%r8d
jle    149e <_countNeighbors+0x39e>
cmp    %edx,%r9d
jge    149e <_countNeighbors+0x39e>
mov    %r11d,%ebx
imul   %edx,%ebx
add    %r9d,%ebx
imul   %esi,%ebx
add    -0x10(%rsp),%ebx
movslq %ebx,%rbx
xor    %ebp,%ebp
cmp    %r14w,(%rdi,%rbx,2)
sete   %bpl
add    %ebp,%eax
cmp    $0xffffffff,%r8d
jl     14cd <_countNeighbors+0x3cd>
cmp    %edx,%r9d
jge    14cd <_countNeighbors+0x3cd>
cmp    %esi,%r15d
jge    14cd <_countNeighbors+0x3cd>
mov    %r11d,%ebx
imul   %edx,%ebx
add    %r9d,%ebx
imul   %esi,%ebx
add    %r15d,%ebx
movslq %ebx,%rbx
xor    %ebp,%ebp
cmp    %r14w,(%rdi,%rbx,2)
sete   %bpl
add    %ebp,%eax
test   %r10b,%r10b
je     15a9 <_countNeighbors+0x4a9>
test   %r9d,%r9d
jle    1540 <_countNeighbors+0x440>
cmp    %ecx,%r12d
jge    1540 <_countNeighbors+0x440>
cmp    %esi,%r8d
jg     1510 <_countNeighbors+0x410>
test   %r8d,%r8d
jle    1510 <_countNeighbors+0x410>
cmp    %edx,%r9d
jg     1510 <_countNeighbors+0x410>
mov    %r12d,%ebx
imul   %edx,%ebx
add    -0xc(%rsp),%ebx
imul   %esi,%ebx
add    -0x10(%rsp),%ebx
movslq %ebx,%rbx
xor    %ebp,%ebp
cmp    %r14w,(%rdi,%rbx,2)
sete   %bpl
add    %ebp,%eax
cmp    $0xffffffff,%r8d
jl     1540 <_countNeighbors+0x440>
cmp    %edx,%r9d
jg     1540 <_countNeighbors+0x440>
cmp    %esi,%r15d
jge    1540 <_countNeighbors+0x440>
mov    %r12d,%ebx
imul   %edx,%ebx
add    -0xc(%rsp),%ebx
imul   %esi,%ebx
add    %r15d,%ebx
movslq %ebx,%rbx
xor    %ebp,%ebp
cmp    %r14w,(%rdi,%rbx,2)
sete   %bpl
add    %ebp,%eax
cmp    $0xffffffff,%r9d
jl     15a9 <_countNeighbors+0x4a9>
cmp    %ecx,%r12d
jge    15a9 <_countNeighbors+0x4a9>
cmp    %esi,%r8d
jg     157a <_countNeighbors+0x47a>
test   %r8d,%r8d
jle    157a <_countNeighbors+0x47a>
cmp    %edx,%r13d
jge    157a <_countNeighbors+0x47a>
mov    %r12d,%ebx
imul   %edx,%ebx
add    %r13d,%ebx
imul   %esi,%ebx
add    -0x10(%rsp),%ebx
movslq %ebx,%rbx
xor    %ebp,%ebp
cmp    %r14w,(%rdi,%rbx,2)
sete   %bpl
add    %ebp,%eax
cmp    $0xffffffff,%r8d
jl     15a9 <_countNeighbors+0x4a9>
cmp    %edx,%r13d
jge    15a9 <_countNeighbors+0x4a9>
cmp    %esi,%r15d
jge    15a9 <_countNeighbors+0x4a9>
mov    %r12d,%ebx
imul   %edx,%ebx
add    %r13d,%ebx
imul   %esi,%ebx
add    %r15d,%ebx
movslq %ebx,%rbx
xor    %ebp,%ebp
cmp    %r14w,(%rdi,%rbx,2)
sete   %bpl
add    %ebp,%eax
test   %r12d,%r12d
jle    1689 <_countNeighbors+0x589>
test   %r9d,%r9d
jle    161e <_countNeighbors+0x51e>
cmp    %ecx,%r12d
jg     161e <_countNeighbors+0x51e>
cmp    %esi,%r8d
jg     15ed <_countNeighbors+0x4ed>
test   %r8d,%r8d
jle    15ed <_countNeighbors+0x4ed>
cmp    %edx,%r9d
jg     15ed <_countNeighbors+0x4ed>
mov    -0x8(%rsp),%ebx
imul   %edx,%ebx
add    -0xc(%rsp),%ebx
imul   %esi,%ebx
add    -0x10(%rsp),%ebx
movslq %ebx,%rbx
xor    %ebp,%ebp
cmp    %r14w,(%rdi,%rbx,2)
sete   %bpl
add    %ebp,%eax
cmp    $0xffffffff,%r8d
jl     161e <_countNeighbors+0x51e>
cmp    %edx,%r9d
jg     161e <_countNeighbors+0x51e>
cmp    %esi,%r15d
jge    161e <_countNeighbors+0x51e>
mov    -0x8(%rsp),%ebx
imul   %edx,%ebx
add    -0xc(%rsp),%ebx
imul   %esi,%ebx
add    %r15d,%ebx
movslq %ebx,%rbx
xor    %ebp,%ebp
cmp    %r14w,(%rdi,%rbx,2)
sete   %bpl
add    %ebp,%eax
cmp    $0xffffffff,%r9d
jl     1689 <_countNeighbors+0x589>
cmp    %ecx,%r12d
jg     1689 <_countNeighbors+0x589>
cmp    %esi,%r8d
jg     1659 <_countNeighbors+0x559>
test   %r8d,%r8d
jle    1659 <_countNeighbors+0x559>
cmp    %edx,%r13d
jge    1659 <_countNeighbors+0x559>
mov    -0x8(%rsp),%ebx
imul   %edx,%ebx
add    %r13d,%ebx
imul   %esi,%ebx
add    -0x10(%rsp),%ebx
movslq %ebx,%rbx
xor    %ebp,%ebp
cmp    %r14w,(%rdi,%rbx,2)
sete   %bpl
add    %ebp,%eax
cmp    $0xffffffff,%r8d
jl     1689 <_countNeighbors+0x589>
cmp    %edx,%r13d
jge    1689 <_countNeighbors+0x589>
cmp    %esi,%r15d
jge    1689 <_countNeighbors+0x589>
mov    -0x8(%rsp),%ebp
imul   %edx,%ebp
add    %r13d,%ebp
imul   %esi,%ebp
add    %r15d,%ebp
movslq %ebp,%rbx
xor    %ebp,%ebp
cmp    %r14w,(%rdi,%rbx,2)
sete   %bpl
add    %ebp,%eax
cmpb   $0x0,-0x4(%rsp)
je     1763 <_countNeighbors+0x663>
test   %r9d,%r9d
jle    16fc <_countNeighbors+0x5fc>
cmp    %ecx,%r11d
jge    16fc <_countNeighbors+0x5fc>
cmp    %esi,%r8d
jg     16cd <_countNeighbors+0x5cd>
test   %r8d,%r8d
jle    16cd <_countNeighbors+0x5cd>
cmp    %edx,%r9d
jg     16cd <_countNeighbors+0x5cd>
mov    %r11d,%ebp
imul   %edx,%ebp
add    -0xc(%rsp),%ebp
imul   %esi,%ebp
add    -0x10(%rsp),%ebp
movslq %ebp,%rbp
xor    %ebx,%ebx
cmp    %r14w,(%rdi,%rbp,2)
sete   %bl
add    %ebx,%eax
cmp    $0xffffffff,%r8d
jl     16fc <_countNeighbors+0x5fc>
cmp    %edx,%r9d
jg     16fc <_countNeighbors+0x5fc>
cmp    %esi,%r15d
jge    16fc <_countNeighbors+0x5fc>
mov    %r11d,%ebp
imul   %edx,%ebp
add    -0xc(%rsp),%ebp
imul   %esi,%ebp
add    %r15d,%ebp
movslq %ebp,%rbp
xor    %ebx,%ebx
cmp    %r14w,(%rdi,%rbp,2)
sete   %bl
add    %ebx,%eax
cmp    $0xffffffff,%r9d
jl     1763 <_countNeighbors+0x663>
cmp    %ecx,%r11d
jge    1763 <_countNeighbors+0x663>
cmp    %esi,%r8d
jg     1736 <_countNeighbors+0x636>
test   %r8d,%r8d
jle    1736 <_countNeighbors+0x636>
cmp    %edx,%r13d
jge    1736 <_countNeighbors+0x636>
mov    %r11d,%ecx
imul   %edx,%ecx
add    %r13d,%ecx
imul   %esi,%ecx
add    -0x10(%rsp),%ecx
movslq %ecx,%rcx
xor    %ebp,%ebp
cmp    %r14w,(%rdi,%rcx,2)
sete   %bpl
add    %ebp,%eax
cmp    $0xffffffff,%r8d
jl     1763 <_countNeighbors+0x663>
cmp    %edx,%r13d
jge    1763 <_countNeighbors+0x663>
cmp    %esi,%r15d
jge    1763 <_countNeighbors+0x663>
imul   %edx,%r11d
add    %r13d,%r11d
imul   %esi,%r11d
add    %r15d,%r11d
movslq %r11d,%rcx
xor    %edx,%edx
cmp    %r14w,(%rdi,%rcx,2)
sete   %dl
add    %edx,%eax
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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