int countNeighbors(unsigned char *im, const int dimx, const int dimy,
                   const int dimz, const int i, const int j, const int k) {
  int a, b, c;
  int ct = 0;
  c = k - 1;
  b = j;
  a = i;
  ct += (im[((b) * (dimx) + (a) + (c) * (dimx) * (dimy))] != 0) ? 1 : 0;
  c = k + 1;
  b = j;
  a = i;
  ct += (im[((b) * (dimx) + (a) + (c) * (dimx) * (dimy))] != 0) ? 1 : 0;
  c = k;
  b = j - 1;
  a = i;
  ct += (im[((b) * (dimx) + (a) + (c) * (dimx) * (dimy))] != 0) ? 1 : 0;
  c = k;
  b = j + 1;
  a = i;
  ct += (im[((b) * (dimx) + (a) + (c) * (dimx) * (dimy))] != 0) ? 1 : 0;
  c = k;
  b = j;
  a = i - 1;
  ct += (im[((b) * (dimx) + (a) + (c) * (dimx) * (dimy))] != 0) ? 1 : 0;
  c = k;
  b = j;
  a = i + 1;
  ct += (im[((b) * (dimx) + (a) + (c) * (dimx) * (dimy))] != 0) ? 1 : 0;
  c = k - 1;
  b = j - 1;
  a = i;
  ct += (im[((b) * (dimx) + (a) + (c) * (dimx) * (dimy))] != 0) ? 1 : 0;
  c = k - 1;
  b = j + 1;
  a = i;
  ct += (im[((b) * (dimx) + (a) + (c) * (dimx) * (dimy))] != 0) ? 1 : 0;
  c = k - 1;
  b = j;
  a = i - 1;
  ct += (im[((b) * (dimx) + (a) + (c) * (dimx) * (dimy))] != 0) ? 1 : 0;
  c = k - 1;
  b = j;
  a = i + 1;
  ct += (im[((b) * (dimx) + (a) + (c) * (dimx) * (dimy))] != 0) ? 1 : 0;
  c = k + 1;
  b = j - 1;
  a = i;
  ct += (im[((b) * (dimx) + (a) + (c) * (dimx) * (dimy))] != 0) ? 1 : 0;
  c = k + 1;
  b = j + 1;
  a = i;
  ct += (im[((b) * (dimx) + (a) + (c) * (dimx) * (dimy))] != 0) ? 1 : 0;
  c = k + 1;
  b = j;
  a = i - 1;
  ct += (im[((b) * (dimx) + (a) + (c) * (dimx) * (dimy))] != 0) ? 1 : 0;
  c = k + 1;
  b = j;
  a = i + 1;
  ct += (im[((b) * (dimx) + (a) + (c) * (dimx) * (dimy))] != 0) ? 1 : 0;
  c = k;
  b = j - 1;
  a = i - 1;
  ct += (im[((b) * (dimx) + (a) + (c) * (dimx) * (dimy))] != 0) ? 1 : 0;
  c = k;
  b = j - 1;
  a = i + 1;
  ct += (im[((b) * (dimx) + (a) + (c) * (dimx) * (dimy))] != 0) ? 1 : 0;
  c = k;
  b = j + 1;
  a = i - 1;
  ct += (im[((b) * (dimx) + (a) + (c) * (dimx) * (dimy))] != 0) ? 1 : 0;
  c = k;
  b = j + 1;
  a = i + 1;
  ct += (im[((b) * (dimx) + (a) + (c) * (dimx) * (dimy))] != 0) ? 1 : 0;
  c = k - 1;
  b = j - 1;
  a = i - 1;
  ct += (im[((b) * (dimx) + (a) + (c) * (dimx) * (dimy))] != 0) ? 1 : 0;
  c = k - 1;
  b = j - 1;
  a = i + 1;
  ct += (im[((b) * (dimx) + (a) + (c) * (dimx) * (dimy))] != 0) ? 1 : 0;
  c = k - 1;
  b = j + 1;
  a = i - 1;
  ct += (im[((b) * (dimx) + (a) + (c) * (dimx) * (dimy))] != 0) ? 1 : 0;
  c = k - 1;
  b = j + 1;
  a = i + 1;
  ct += (im[((b) * (dimx) + (a) + (c) * (dimx) * (dimy))] != 0) ? 1 : 0;
  c = k + 1;
  b = j - 1;
  a = i - 1;
  ct += (im[((b) * (dimx) + (a) + (c) * (dimx) * (dimy))] != 0) ? 1 : 0;
  c = k + 1;
  b = j - 1;
  a = i + 1;
  ct += (im[((b) * (dimx) + (a) + (c) * (dimx) * (dimy))] != 0) ? 1 : 0;
  c = k + 1;
  b = j + 1;
  a = i - 1;
  ct += (im[((b) * (dimx) + (a) + (c) * (dimx) * (dimy))] != 0) ? 1 : 0;
  c = k + 1;
  b = j + 1;
  a = i + 1;
  ct += (im[((b) * (dimx) + (a) + (c) * (dimx) * (dimy))] != 0) ? 1 : 0;
  return ct;
}


x86 assembly (clang, -O0):
<countNeighbors>:
push   %rbp
mov    %rsp,%rbp
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)
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
movzbl (%rax,%rcx,1),%edx
xor    %eax,%eax
mov    $0x1,%ecx
cmp    $0x0,%edx
cmovne %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)
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
movzbl (%rax,%rcx,1),%edx
xor    %eax,%eax
mov    $0x1,%ecx
cmp    $0x0,%edx
cmovne %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)
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
movzbl (%rax,%rcx,1),%edx
xor    %eax,%eax
mov    $0x1,%ecx
cmp    $0x0,%edx
cmovne %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)
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
movzbl (%rax,%rcx,1),%edx
xor    %eax,%eax
mov    $0x1,%ecx
cmp    $0x0,%edx
cmovne %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)
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
movzbl (%rax,%rcx,1),%edx
xor    %eax,%eax
mov    $0x1,%ecx
cmp    $0x0,%edx
cmovne %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)
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
movzbl (%rax,%rcx,1),%edx
xor    %eax,%eax
mov    $0x1,%ecx
cmp    $0x0,%edx
cmovne %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)
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
movzbl (%rax,%rcx,1),%edx
xor    %eax,%eax
mov    $0x1,%ecx
cmp    $0x0,%edx
cmovne %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)
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
movzbl (%rax,%rcx,1),%edx
xor    %eax,%eax
mov    $0x1,%ecx
cmp    $0x0,%edx
cmovne %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)
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
movzbl (%rax,%rcx,1),%edx
xor    %eax,%eax
mov    $0x1,%ecx
cmp    $0x0,%edx
cmovne %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)
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
movzbl (%rax,%rcx,1),%edx
xor    %eax,%eax
mov    $0x1,%ecx
cmp    $0x0,%edx
cmovne %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)
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
movzbl (%rax,%rcx,1),%edx
xor    %eax,%eax
mov    $0x1,%ecx
cmp    $0x0,%edx
cmovne %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)
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
movzbl (%rax,%rcx,1),%edx
xor    %eax,%eax
mov    $0x1,%ecx
cmp    $0x0,%edx
cmovne %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)
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
movzbl (%rax,%rcx,1),%edx
xor    %eax,%eax
mov    $0x1,%ecx
cmp    $0x0,%edx
cmovne %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)
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
movzbl (%rax,%rcx,1),%edx
xor    %eax,%eax
mov    $0x1,%ecx
cmp    $0x0,%edx
cmovne %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)
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
movzbl (%rax,%rcx,1),%edx
xor    %eax,%eax
mov    $0x1,%ecx
cmp    $0x0,%edx
cmovne %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)
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
movzbl (%rax,%rcx,1),%edx
xor    %eax,%eax
mov    $0x1,%ecx
cmp    $0x0,%edx
cmovne %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)
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
movzbl (%rax,%rcx,1),%edx
xor    %eax,%eax
mov    $0x1,%ecx
cmp    $0x0,%edx
cmovne %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)
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
movzbl (%rax,%rcx,1),%edx
xor    %eax,%eax
mov    $0x1,%ecx
cmp    $0x0,%edx
cmovne %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)
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
movzbl (%rax,%rcx,1),%edx
xor    %eax,%eax
mov    $0x1,%ecx
cmp    $0x0,%edx
cmovne %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)
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
movzbl (%rax,%rcx,1),%edx
xor    %eax,%eax
mov    $0x1,%ecx
cmp    $0x0,%edx
cmovne %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)
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
movzbl (%rax,%rcx,1),%edx
xor    %eax,%eax
mov    $0x1,%ecx
cmp    $0x0,%edx
cmovne %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)
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
movzbl (%rax,%rcx,1),%edx
xor    %eax,%eax
mov    $0x1,%ecx
cmp    $0x0,%edx
cmovne %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)
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
movzbl (%rax,%rcx,1),%edx
xor    %eax,%eax
mov    $0x1,%ecx
cmp    $0x0,%edx
cmovne %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)
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
movzbl (%rax,%rcx,1),%edx
xor    %eax,%eax
mov    $0x1,%ecx
cmp    $0x0,%edx
cmovne %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)
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
movzbl (%rax,%rcx,1),%edx
xor    %eax,%eax
mov    $0x1,%ecx
cmp    $0x0,%edx
cmovne %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)
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
movzbl (%rax,%rcx,1),%edx
xor    %eax,%eax
mov    $0x1,%ecx
cmp    $0x0,%edx
cmovne %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
mov    0x38(%rsp),%r13d
lea    -0x1(%r13),%r12d
mov    %r9d,%r15d
imul   %esi,%r15d
lea    (%r15,%r8,1),%eax
imul   %esi,%edx
imul   %edx,%r12d
lea    (%r12,%rax,1),%ebx
movslq %ebx,%rbx
lea    0x1(%r13),%r10d
imul   %edx,%r10d
add    %r10d,%eax
movslq %eax,%rcx
xor    %eax,%eax
cmpb   $0x0,(%rdi,%rcx,1)
setne  %al
cmpb   $0x1,(%rdi,%rbx,1)
sbb    $0xffffffff,%eax
lea    -0x1(%r9),%r11d
imul   %esi,%r11d
lea    (%r11,%r8,1),%r14d
imul   %r13d,%edx
lea    (%r14,%rdx,1),%ecx
movslq %ecx,%rcx
cmpb   $0x1,(%rdi,%rcx,1)
sbb    $0xffffffff,%eax
add    $0x1,%r9d
imul   %esi,%r9d
lea    (%r9,%r8,1),%esi
lea    (%rsi,%rdx,1),%ecx
movslq %ecx,%rcx
cmpb   $0x1,(%rdi,%rcx,1)
sbb    $0xffffffff,%eax
lea    (%r15,%r8,1),%ebx
add    $0xffffffff,%ebx
lea    (%rdx,%rbx,1),%ecx
movslq %ecx,%rcx
cmpb   $0x1,(%rdi,%rcx,1)
sbb    $0xffffffff,%eax
lea    (%r15,%r8,1),%ecx
add    $0x1,%ecx
lea    (%rdx,%rcx,1),%ebp
movslq %ebp,%rbp
cmpb   $0x1,(%rdi,%rbp,1)
sbb    $0xffffffff,%eax
lea    (%r12,%r14,1),%ebp
movslq %ebp,%rbp
cmpb   $0x1,(%rdi,%rbp,1)
sbb    $0xffffffff,%eax
lea    (%r12,%rsi,1),%ebp
movslq %ebp,%rbp
cmpb   $0x1,(%rdi,%rbp,1)
sbb    $0xffffffff,%eax
lea    (%r12,%rbx,1),%ebp
movslq %ebp,%rbp
cmpb   $0x1,(%rdi,%rbp,1)
sbb    $0xffffffff,%eax
lea    (%r12,%rcx,1),%ebp
movslq %ebp,%rbp
cmpb   $0x1,(%rdi,%rbp,1)
sbb    $0xffffffff,%eax
add    %r10d,%r14d
movslq %r14d,%rbp
cmpb   $0x1,(%rdi,%rbp,1)
sbb    $0xffffffff,%eax
add    %r10d,%esi
movslq %esi,%rsi
cmpb   $0x1,(%rdi,%rsi,1)
sbb    $0xffffffff,%eax
add    %r10d,%ebx
movslq %ebx,%rsi
cmpb   $0x1,(%rdi,%rsi,1)
sbb    $0xffffffff,%eax
add    %r10d,%ecx
movslq %ecx,%rcx
cmpb   $0x1,(%rdi,%rcx,1)
sbb    $0xffffffff,%eax
lea    (%r11,%r8,1),%esi
add    $0xffffffff,%esi
lea    (%rsi,%rdx,1),%ecx
movslq %ecx,%rcx
cmpb   $0x1,(%rdi,%rcx,1)
sbb    $0xffffffff,%eax
lea    (%r11,%r8,1),%ebx
add    $0x1,%ebx
lea    (%rbx,%rdx,1),%ecx
movslq %ecx,%rcx
cmpb   $0x1,(%rdi,%rcx,1)
sbb    $0xffffffff,%eax
lea    (%r9,%r8,1),%ecx
add    $0xffffffff,%ecx
lea    (%rcx,%rdx,1),%ebp
movslq %ebp,%rbp
cmpb   $0x1,(%rdi,%rbp,1)
sbb    $0xffffffff,%eax
add    %r9d,%r8d
add    $0x1,%r8d
add    %r8d,%edx
movslq %edx,%rdx
cmpb   $0x1,(%rdi,%rdx,1)
sbb    $0xffffffff,%eax
lea    (%r12,%rsi,1),%edx
movslq %edx,%rdx
cmpb   $0x1,(%rdi,%rdx,1)
sbb    $0xffffffff,%eax
lea    (%r12,%rbx,1),%edx
movslq %edx,%rdx
cmpb   $0x1,(%rdi,%rdx,1)
sbb    $0xffffffff,%eax
lea    (%r12,%rcx,1),%edx
movslq %edx,%rdx
cmpb   $0x1,(%rdi,%rdx,1)
sbb    $0xffffffff,%eax
add    %r8d,%r12d
movslq %r12d,%rdx
cmpb   $0x1,(%rdi,%rdx,1)
sbb    $0xffffffff,%eax
add    %r10d,%esi
movslq %esi,%rdx
cmpb   $0x1,(%rdi,%rdx,1)
sbb    $0xffffffff,%eax
add    %r10d,%ebx
movslq %ebx,%rdx
cmpb   $0x1,(%rdi,%rdx,1)
sbb    $0xffffffff,%eax
add    %r10d,%ecx
movslq %ecx,%rcx
cmpb   $0x1,(%rdi,%rcx,1)
sbb    $0xffffffff,%eax
add    %r8d,%r10d
movslq %r10d,%rcx
cmpb   $0x1,(%rdi,%rcx,1)
sbb    $0xffffffff,%eax
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define i32 @countNeighbors(i8* %0, i32 %1, i32 %2, i32 %3, i32 %4, i32 %5, i32 %6) {
%8 = add nsw i32 %6, -1
%9 = mul nsw i32 %5, %1
%10 = add nsw i32 %9, %4
%11 = mul i32 %2, %1
%12 = mul i32 %11, %8
%13 = add nsw i32 %12, %10
%14 = sext i32 %13 to i64
%15 = getelementptr inbounds i8, i8* %0, i64 %14
%16 = load i8, i8* %15
%17 = icmp ne i8 %16, 0
%18 = zext i1 %17 to i32
%19 = add nsw i32 %6, 1
%20 = mul i32 %11, %19
%21 = add nsw i32 %20, %10
%22 = sext i32 %21 to i64
%23 = getelementptr inbounds i8, i8* %0, i64 %22
%24 = load i8, i8* %23
%25 = icmp ne i8 %24, 0
%26 = zext i1 %25 to i32
%27 = add nuw nsw i32 %26, %18
%28 = add nsw i32 %5, -1
%29 = mul nsw i32 %28, %1
%30 = add nsw i32 %29, %4
%31 = mul i32 %11, %6
%32 = add nsw i32 %30, %31
%33 = sext i32 %32 to i64
%34 = getelementptr inbounds i8, i8* %0, i64 %33
%35 = load i8, i8* %34
%36 = icmp ne i8 %35, 0
%37 = zext i1 %36 to i32
%38 = add nuw nsw i32 %27, %37
%39 = add nsw i32 %5, 1
%40 = mul nsw i32 %39, %1
%41 = add nsw i32 %40, %4
%42 = add nsw i32 %41, %31
%43 = sext i32 %42 to i64
%44 = getelementptr inbounds i8, i8* %0, i64 %43
%45 = load i8, i8* %44
%46 = icmp ne i8 %45, 0
%47 = zext i1 %46 to i32
%48 = add nuw nsw i32 %38, %47
%49 = add nsw i32 %4, -1
%50 = add nsw i32 %9, %49
%51 = add nsw i32 %31, %50
%52 = sext i32 %51 to i64
%53 = getelementptr inbounds i8, i8* %0, i64 %52
%54 = load i8, i8* %53
%55 = icmp ne i8 %54, 0
%56 = zext i1 %55 to i32
%57 = add nuw nsw i32 %48, %56
%58 = add nsw i32 %4, 1
%59 = add nsw i32 %9, %58
%60 = add nsw i32 %31, %59
%61 = sext i32 %60 to i64
%62 = getelementptr inbounds i8, i8* %0, i64 %61
%63 = load i8, i8* %62
%64 = icmp ne i8 %63, 0
%65 = zext i1 %64 to i32
%66 = add nuw nsw i32 %57, %65
%67 = add nsw i32 %12, %30
%68 = sext i32 %67 to i64
%69 = getelementptr inbounds i8, i8* %0, i64 %68
%70 = load i8, i8* %69
%71 = icmp ne i8 %70, 0
%72 = zext i1 %71 to i32
%73 = add nuw nsw i32 %66, %72
%74 = add nsw i32 %12, %41
%75 = sext i32 %74 to i64
%76 = getelementptr inbounds i8, i8* %0, i64 %75
%77 = load i8, i8* %76
%78 = icmp ne i8 %77, 0
%79 = zext i1 %78 to i32
%80 = add nuw nsw i32 %73, %79
%81 = add nsw i32 %12, %50
%82 = sext i32 %81 to i64
%83 = getelementptr inbounds i8, i8* %0, i64 %82
%84 = load i8, i8* %83
%85 = icmp ne i8 %84, 0
%86 = zext i1 %85 to i32
%87 = add nuw nsw i32 %80, %86
%88 = add nsw i32 %12, %59
%89 = sext i32 %88 to i64
%90 = getelementptr inbounds i8, i8* %0, i64 %89
%91 = load i8, i8* %90
%92 = icmp ne i8 %91, 0
%93 = zext i1 %92 to i32
%94 = add nuw nsw i32 %87, %93
%95 = add nsw i32 %20, %30
%96 = sext i32 %95 to i64
%97 = getelementptr inbounds i8, i8* %0, i64 %96
%98 = load i8, i8* %97
%99 = icmp ne i8 %98, 0
%100 = zext i1 %99 to i32
%101 = add nuw nsw i32 %94, %100
%102 = add nsw i32 %20, %41
%103 = sext i32 %102 to i64
%104 = getelementptr inbounds i8, i8* %0, i64 %103
%105 = load i8, i8* %104
%106 = icmp ne i8 %105, 0
%107 = zext i1 %106 to i32
%108 = add nuw nsw i32 %101, %107
%109 = add nsw i32 %20, %50
%110 = sext i32 %109 to i64
%111 = getelementptr inbounds i8, i8* %0, i64 %110
%112 = load i8, i8* %111
%113 = icmp ne i8 %112, 0
%114 = zext i1 %113 to i32
%115 = add nuw nsw i32 %108, %114
%116 = add nsw i32 %20, %59
%117 = sext i32 %116 to i64
%118 = getelementptr inbounds i8, i8* %0, i64 %117
%119 = load i8, i8* %118
%120 = icmp ne i8 %119, 0
%121 = zext i1 %120 to i32
%122 = add nuw nsw i32 %115, %121
%123 = add nsw i32 %29, %49
%124 = add nsw i32 %123, %31
%125 = sext i32 %124 to i64
%126 = getelementptr inbounds i8, i8* %0, i64 %125
%127 = load i8, i8* %126
%128 = icmp ne i8 %127, 0
%129 = zext i1 %128 to i32
%130 = add nuw nsw i32 %122, %129
%131 = add nsw i32 %29, %58
%132 = add nsw i32 %131, %31
%133 = sext i32 %132 to i64
%134 = getelementptr inbounds i8, i8* %0, i64 %133
%135 = load i8, i8* %134
%136 = icmp ne i8 %135, 0
%137 = zext i1 %136 to i32
%138 = add nuw nsw i32 %130, %137
%139 = add nsw i32 %40, %49
%140 = add nsw i32 %139, %31
%141 = sext i32 %140 to i64
%142 = getelementptr inbounds i8, i8* %0, i64 %141
%143 = load i8, i8* %142
%144 = icmp ne i8 %143, 0
%145 = zext i1 %144 to i32
%146 = add nuw nsw i32 %138, %145
%147 = add nsw i32 %40, %58
%148 = add nsw i32 %147, %31
%149 = sext i32 %148 to i64
%150 = getelementptr inbounds i8, i8* %0, i64 %149
%151 = load i8, i8* %150
%152 = icmp ne i8 %151, 0
%153 = zext i1 %152 to i32
%154 = add nuw nsw i32 %146, %153
%155 = add nsw i32 %12, %123
%156 = sext i32 %155 to i64
%157 = getelementptr inbounds i8, i8* %0, i64 %156
%158 = load i8, i8* %157
%159 = icmp ne i8 %158, 0
%160 = zext i1 %159 to i32
%161 = add nuw nsw i32 %154, %160
%162 = add nsw i32 %12, %131
%163 = sext i32 %162 to i64
%164 = getelementptr inbounds i8, i8* %0, i64 %163
%165 = load i8, i8* %164
%166 = icmp ne i8 %165, 0
%167 = zext i1 %166 to i32
%168 = add nuw nsw i32 %161, %167
%169 = add nsw i32 %12, %139
%170 = sext i32 %169 to i64
%171 = getelementptr inbounds i8, i8* %0, i64 %170
%172 = load i8, i8* %171
%173 = icmp ne i8 %172, 0
%174 = zext i1 %173 to i32
%175 = add nuw nsw i32 %168, %174
%176 = add nsw i32 %12, %147
%177 = sext i32 %176 to i64
%178 = getelementptr inbounds i8, i8* %0, i64 %177
%179 = load i8, i8* %178
%180 = icmp ne i8 %179, 0
%181 = zext i1 %180 to i32
%182 = add nuw nsw i32 %175, %181
%183 = add nsw i32 %20, %123
%184 = sext i32 %183 to i64
%185 = getelementptr inbounds i8, i8* %0, i64 %184
%186 = load i8, i8* %185
%187 = icmp ne i8 %186, 0
%188 = zext i1 %187 to i32
%189 = add nuw nsw i32 %182, %188
%190 = add nsw i32 %20, %131
%191 = sext i32 %190 to i64
%192 = getelementptr inbounds i8, i8* %0, i64 %191
%193 = load i8, i8* %192
%194 = icmp ne i8 %193, 0
%195 = zext i1 %194 to i32
%196 = add nuw nsw i32 %189, %195
%197 = add nsw i32 %20, %139
%198 = sext i32 %197 to i64
%199 = getelementptr inbounds i8, i8* %0, i64 %198
%200 = load i8, i8* %199
%201 = icmp ne i8 %200, 0
%202 = zext i1 %201 to i32
%203 = add nuw nsw i32 %196, %202
%204 = add nsw i32 %20, %147
%205 = sext i32 %204 to i64
%206 = getelementptr inbounds i8, i8* %0, i64 %205
%207 = load i8, i8* %206
%208 = icmp ne i8 %207, 0
%209 = zext i1 %208 to i32
%210 = add nuw nsw i32 %203, %209
ret i32 %210
}