void init_flag(char *problem, int imax, int jmax, int kmax, int ***Flag, int wl,
               int wr, int wf, int wh, int wt, int wb) {
  int i, j, k;
  if (strcmp(problem, "drop.pgm") == 0 ||
      strcmp(problem, "breaking_dam.pgm") == 0) {
    for (i = 0; i <= imax + 1; i++) {
      for (k = 0; k <= kmax + 1; k++) {
        for (j = 0; j <= jmax + 1; j++) {
          setcelltype(&Flag[i][j][k], 0);
        }
      }
    }
  } else {
    int **Pic = read_pgm(problem);
    for (k = 1; k < kmax + 1; k++) {
      for (int j = 1; j < jmax + 1; j++) {
        for (int i = 1; i < imax + 1; i++) {
          Flag[i][jmax + 1 - j][k] = createflag(Pic, i, j, k, imax, jmax, kmax);
        }
      }
    }
  }
  for (k = 0; k < kmax + 2; k++) {
    Flag[0][0][k] = getwallbit(wf);
    Flag[0][jmax + 1][k] = getwallbit(wh);
    Flag[imax + 1][0][k] = getwallbit(wf);
    Flag[imax + 1][jmax + 1][k] = getwallbit(wh);
  }
  for (j = 0; j < jmax + 2; j++) {
    Flag[0][j][0] = getwallbit(wb);
    Flag[0][j][kmax + 1] = getwallbit(wt);
    Flag[imax + 1][j][0] = getwallbit(wb);
    Flag[imax + 1][j][kmax + 1] = getwallbit(wt);
  }
  for (i = 0; i < imax + 2; i++) {
    Flag[i][0][0] = getwallbit(wf);
    Flag[i][jmax + 1][0] = getwallbit(wh);
    Flag[i][0][kmax + 1] = getwallbit(wf);
    Flag[i][jmax + 1][kmax + 1] = getwallbit(wh);
  }
  for (i = 1; i <= imax; i++) {
    for (j = 1; j <= jmax; j++) {
      if ((Flag[i][j][1] & pow2(2, 12)) == (Flag[i][j][1] & pow2(2, 13))) {
        Flag[i][j][0] = getwallbit(0) + (Flag[i][j][1] & (pow2(2, 12) * 15));
      } else {
        Flag[i][j][0] = (getwallbit(wb) - 3) + (Flag[i][j][1] & 3);
      }
      if ((Flag[i][j][kmax] & pow2(2, 12)) ==
          (Flag[i][j][kmax] & pow2(2, 13))) {
        Flag[i][j][kmax + 1] =
            getwallbit(0) + (Flag[i][j][kmax] & (pow2(2, 12) * 15));
      } else {
        Flag[i][j][kmax + 1] = (getwallbit(wt) - 12) + (Flag[i][j][kmax] & 12);
      }
    }
  }
  for (j = 1; j <= jmax; j++) {
    for (k = 1; k <= kmax; k++) {
      if ((Flag[1][j][k] & pow2(2, 12)) == (Flag[1][j][k] & pow2(2, 13))) {
        Flag[0][j][k] = getwallbit(0) + (Flag[1][j][k] & (pow2(2, 12) * 15));
      } else {
        Flag[0][j][k] = (getwallbit(wl) - 3 * pow2(2, 10)) +
                        (Flag[1][j][k] & (3 * pow2(2, 10)));
      }
      if ((Flag[imax][j][k] & pow2(2, 12)) ==
          (Flag[imax][j][k] & pow2(2, 13))) {
        Flag[imax + 1][j][k] =
            getwallbit(0) + (Flag[imax][j][k] & (pow2(2, 12) * 15));
      } else {
        Flag[imax + 1][j][k] = (getwallbit(wr) - 3 * pow2(2, 8)) +
                               (Flag[imax][j][k] & (3 * pow2(2, 8)));
      }
    }
  }
  for (i = 1; i <= imax; i++) {
    for (k = 1; k <= kmax; k++) {
      if ((Flag[i][1][k] & pow2(2, 12)) == (Flag[i][1][k] & pow2(2, 13))) {
        Flag[i][0][k] = getwallbit(0) + (Flag[i][1][k] & (pow2(2, 12) * 15));
      } else {
        Flag[i][0][k] = (getwallbit(wf) - 64 * 3) + (Flag[i][1][k] & (64 * 3));
      }
      if ((Flag[i][jmax][k] & pow2(2, 12)) ==
          (Flag[i][jmax][k] & pow2(2, 13))) {
        Flag[i][jmax + 1][k] =
            getwallbit(0) + (Flag[i][jmax][k] & (pow2(2, 12) * 15));
      } else {
        Flag[i][jmax + 1][k] =
            (getwallbit(wh) - 16 * 3) + (Flag[i][jmax][k] & (16 * 3));
      }
    }
  }
  if (strcmp(problem, "drop.pgm") == 0) {
    init_sphere(problem, imax, jmax, kmax, Flag, wl, wr, wf, wh, wt, wb);
  } else if (strcmp(problem, "breaking_dam.pgm") == 0) {
    init_breaking_dam(problem, imax, jmax, kmax, Flag, wl, wr, wf, wh, wt, wb);
  }
  printf("init_cells\n");
  for (i = 1; i < imax + 1; i++) {
    for (k = 1; k < kmax + 1; k++) {
      for (j = 1; j < jmax + 1; j++) {
        init_cell(Flag, i, j, k);
      }
    }
  }
}


x86 assembly (clang, -O0):
<init_flag>:
push   %rbp
mov    %rsp,%rbp
push   %r14
push   %rbx
sub    $0x100,%rsp
mov    0x30(%rbp),%eax
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %rdi,-0x18(%rbp)
mov    %esi,-0x1c(%rbp)
mov    %edx,-0x20(%rbp)
mov    %ecx,-0x24(%rbp)
mov    %r8,-0x30(%rbp)
mov    %r9d,-0x34(%rbp)
mov    -0x18(%rbp),%rdi
lea    0x1e23(%rip),%rsi
call   1090 <strcmp@plt>
cmp    $0x0,%eax
je     1204 <init_flag+0x64>
mov    -0x18(%rbp),%rdi
lea    0x1e13(%rip),%rsi
call   1090 <strcmp@plt>
cmp    $0x0,%eax
jne    12ad <init_flag+0x10d>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jg     12a8 <init_flag+0x108>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jg     1295 <init_flag+0xf5>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jg     1282 <init_flag+0xe2>
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
movslq -0x40(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdi
xor    %esi,%esi
mov    $0x0,%al
call   1060 <setcelltype@plt>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    123b <init_flag+0x9b>
jmp    1287 <init_flag+0xe7>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1223 <init_flag+0x83>
jmp    129a <init_flag+0xfa>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    120b <init_flag+0x6b>
jmp    1386 <init_flag+0x1e6>
mov    -0x18(%rbp),%rdi
mov    $0x0,%al
call   1070 <read_pgm@plt>
cltq
mov    %rax,-0x48(%rbp)
movl   $0x1,-0x40(%rbp)
mov    -0x40(%rbp),%eax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1381 <init_flag+0x1e1>
movl   $0x1,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    136e <init_flag+0x1ce>
movl   $0x1,-0x50(%rbp)
mov    -0x50(%rbp),%eax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    135b <init_flag+0x1bb>
mov    -0x48(%rbp),%rdi
mov    -0x50(%rbp),%esi
mov    -0x4c(%rbp),%edx
mov    -0x40(%rbp),%ecx
mov    -0x1c(%rbp),%r8d
mov    -0x20(%rbp),%r9d
mov    -0x24(%rbp),%eax
mov    %eax,(%rsp)
mov    $0x0,%al
call   1050 <createflag@plt>
mov    %eax,%edx
mov    -0x30(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
sub    -0x4c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    12f5 <init_flag+0x155>
jmp    1360 <init_flag+0x1c0>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    12dd <init_flag+0x13d>
jmp    1373 <init_flag+0x1d3>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    12c5 <init_flag+0x125>
jmp    1386 <init_flag+0x1e6>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
mov    -0x24(%rbp),%ecx
add    $0x2,%ecx
cmp    %ecx,%eax
jge    1448 <init_flag+0x2a8>
mov    0x18(%rbp),%edi
mov    $0x0,%al
call   1030 <getwallbit@plt>
mov    %eax,%edx
mov    -0x30(%rbp),%rax
mov    (%rax),%rax
mov    (%rax),%rax
movslq -0x40(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x20(%rbp),%edi
mov    $0x0,%al
call   1030 <getwallbit@plt>
mov    %eax,%edx
mov    -0x30(%rbp),%rax
mov    (%rax),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x18(%rbp),%edi
mov    $0x0,%al
call   1030 <getwallbit@plt>
mov    %eax,%edx
mov    -0x30(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    (%rax),%rax
movslq -0x40(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x20(%rbp),%edi
mov    $0x0,%al
call   1030 <getwallbit@plt>
mov    %eax,%edx
mov    -0x30(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    138d <init_flag+0x1ed>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x20(%rbp),%ecx
add    $0x2,%ecx
cmp    %ecx,%eax
jge    150a <init_flag+0x36a>
mov    0x30(%rbp),%edi
mov    $0x0,%al
call   1030 <getwallbit@plt>
mov    %eax,%ecx
mov    -0x30(%rbp),%rax
mov    (%rax),%rax
movslq -0x3c(%rbp),%rdx
mov    (%rax,%rdx,8),%rax
mov    %ecx,(%rax)
mov    0x28(%rbp),%edi
mov    $0x0,%al
call   1030 <getwallbit@plt>
mov    %eax,%edx
mov    -0x30(%rbp),%rax
mov    (%rax),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x30(%rbp),%edi
mov    $0x0,%al
call   1030 <getwallbit@plt>
mov    %eax,%ecx
mov    -0x30(%rbp),%rax
mov    -0x1c(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
mov    (%rax,%rdx,8),%rax
movslq -0x3c(%rbp),%rdx
mov    (%rax,%rdx,8),%rax
mov    %ecx,(%rax)
mov    0x28(%rbp),%edi
mov    $0x0,%al
call   1030 <getwallbit@plt>
mov    %eax,%edx
mov    -0x30(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    144f <init_flag+0x2af>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x1c(%rbp),%ecx
add    $0x2,%ecx
cmp    %ecx,%eax
jge    15cc <init_flag+0x42c>
mov    0x18(%rbp),%edi
mov    $0x0,%al
call   1030 <getwallbit@plt>
mov    %eax,%ecx
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rdx
mov    (%rax,%rdx,8),%rax
mov    (%rax),%rax
mov    %ecx,(%rax)
mov    0x20(%rbp),%edi
mov    $0x0,%al
call   1030 <getwallbit@plt>
mov    %eax,%ecx
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rdx
mov    (%rax,%rdx,8),%rax
mov    -0x20(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
mov    (%rax,%rdx,8),%rax
mov    %ecx,(%rax)
mov    0x18(%rbp),%edi
mov    $0x0,%al
call   1030 <getwallbit@plt>
mov    %eax,%edx
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    (%rax),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x20(%rbp),%edi
mov    $0x0,%al
call   1030 <getwallbit@plt>
mov    %eax,%edx
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1511 <init_flag+0x371>
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1864 <init_flag+0x6c4>
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jg     1851 <init_flag+0x6b1>
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x5c(%rbp)
mov    $0x2,%edi
mov    $0xc,%esi
mov    $0x0,%al
call   1040 <pow2@plt>
mov    %eax,%ecx
mov    -0x5c(%rbp),%eax
and    %ecx,%eax
mov    %eax,-0x54(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x58(%rbp)
mov    $0x2,%edi
mov    $0xd,%esi
mov    $0x0,%al
call   1040 <pow2@plt>
mov    -0x58(%rbp),%ecx
mov    %eax,%edx
mov    -0x54(%rbp),%eax
and    %edx,%ecx
cmp    %ecx,%eax
jne    16c5 <init_flag+0x525>
xor    %edi,%edi
mov    $0x0,%al
call   1030 <getwallbit@plt>
mov    %eax,-0x64(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x60(%rbp)
mov    $0x2,%edi
mov    $0xc,%esi
mov    $0x0,%al
call   1040 <pow2@plt>
mov    -0x64(%rbp),%ecx
mov    %eax,%edx
mov    -0x60(%rbp),%eax
imul   $0xf,%edx,%edx
and    %edx,%eax
add    %eax,%ecx
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rdx
mov    (%rax,%rdx,8),%rax
movslq -0x3c(%rbp),%rdx
mov    (%rax,%rdx,8),%rax
mov    %ecx,(%rax)
jmp    1706 <init_flag+0x566>
mov    0x30(%rbp),%edi
mov    $0x0,%al
call   1030 <getwallbit@plt>
mov    %eax,%ecx
sub    $0x3,%ecx
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rdx
mov    (%rax,%rdx,8),%rax
movslq -0x3c(%rbp),%rdx
mov    (%rax,%rdx,8),%rax
mov    0x4(%rax),%eax
and    $0x3,%eax
add    %eax,%ecx
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rdx
mov    (%rax,%rdx,8),%rax
movslq -0x3c(%rbp),%rdx
mov    (%rax,%rdx,8),%rax
mov    %ecx,(%rax)
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x70(%rbp)
mov    $0x2,%edi
mov    $0xc,%esi
mov    $0x0,%al
call   1040 <pow2@plt>
mov    %eax,%ecx
mov    -0x70(%rbp),%eax
and    %ecx,%eax
mov    %eax,-0x68(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x6c(%rbp)
mov    $0x2,%edi
mov    $0xd,%esi
mov    $0x0,%al
call   1040 <pow2@plt>
mov    -0x6c(%rbp),%ecx
mov    %eax,%edx
mov    -0x68(%rbp),%eax
and    %edx,%ecx
cmp    %ecx,%eax
jne    17ef <init_flag+0x64f>
xor    %edi,%edi
mov    $0x0,%al
call   1030 <getwallbit@plt>
mov    %eax,-0x78(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x74(%rbp)
mov    $0x2,%edi
mov    $0xc,%esi
mov    $0x0,%al
call   1040 <pow2@plt>
mov    -0x78(%rbp),%edx
mov    %eax,%ecx
mov    -0x74(%rbp),%eax
imul   $0xf,%ecx,%ecx
and    %ecx,%eax
add    %eax,%edx
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    183e <init_flag+0x69e>
mov    0x28(%rbp),%edi
mov    $0x0,%al
call   1030 <getwallbit@plt>
mov    %eax,%edx
sub    $0xc,%edx
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
and    $0xc,%eax
add    %eax,%edx
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1843 <init_flag+0x6a3>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    15e6 <init_flag+0x446>
jmp    1856 <init_flag+0x6b6>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    15d3 <init_flag+0x433>
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x20(%rbp),%eax
jg     1bc4 <init_flag+0xa24>
movl   $0x1,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     1bb1 <init_flag+0xa11>
mov    -0x30(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x84(%rbp)
mov    $0x2,%edi
mov    $0xc,%esi
mov    $0x0,%al
call   1040 <pow2@plt>
mov    %eax,%ecx
mov    -0x84(%rbp),%eax
and    %ecx,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x30(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x80(%rbp)
mov    $0x2,%edi
mov    $0xd,%esi
mov    $0x0,%al
call   1040 <pow2@plt>
mov    -0x80(%rbp),%ecx
mov    %eax,%edx
mov    -0x7c(%rbp),%eax
and    %edx,%ecx
cmp    %ecx,%eax
jne    196f <init_flag+0x7cf>
xor    %edi,%edi
mov    $0x0,%al
call   1030 <getwallbit@plt>
mov    %eax,-0x8c(%rbp)
mov    -0x30(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x88(%rbp)
mov    $0x2,%edi
mov    $0xc,%esi
mov    $0x0,%al
call   1040 <pow2@plt>
mov    -0x8c(%rbp),%edx
mov    %eax,%ecx
mov    -0x88(%rbp),%eax
imul   $0xf,%ecx,%ecx
and    %ecx,%eax
add    %eax,%edx
mov    -0x30(%rbp),%rax
mov    (%rax),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    19fc <init_flag+0x85c>
mov    -0x34(%rbp),%edi
mov    $0x0,%al
call   1030 <getwallbit@plt>
mov    %eax,-0x98(%rbp)
mov    $0x2,%edi
mov    $0xa,%esi
mov    $0x0,%al
call   1040 <pow2@plt>
mov    %eax,%ecx
mov    -0x98(%rbp),%eax
imul   $0x3,%ecx,%ecx
sub    %ecx,%eax
mov    %eax,-0x94(%rbp)
mov    -0x30(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x90(%rbp)
mov    $0x2,%edi
mov    $0xa,%esi
mov    $0x0,%al
call   1040 <pow2@plt>
mov    -0x94(%rbp),%edx
mov    %eax,%ecx
mov    -0x90(%rbp),%eax
imul   $0x3,%ecx,%ecx
and    %ecx,%eax
add    %eax,%edx
mov    -0x30(%rbp),%rax
mov    (%rax),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xa4(%rbp)
mov    $0x2,%edi
mov    $0xc,%esi
mov    $0x0,%al
call   1040 <pow2@plt>
mov    %eax,%ecx
mov    -0xa4(%rbp),%eax
and    %ecx,%eax
mov    %eax,-0x9c(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xa0(%rbp)
mov    $0x2,%edi
mov    $0xd,%esi
mov    $0x0,%al
call   1040 <pow2@plt>
mov    -0xa0(%rbp),%ecx
mov    %eax,%edx
mov    -0x9c(%rbp),%eax
and    %edx,%ecx
cmp    %ecx,%eax
jne    1b03 <init_flag+0x963>
xor    %edi,%edi
mov    $0x0,%al
call   1030 <getwallbit@plt>
mov    %eax,-0xac(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xa8(%rbp)
mov    $0x2,%edi
mov    $0xc,%esi
mov    $0x0,%al
call   1040 <pow2@plt>
mov    -0xac(%rbp),%edx
mov    %eax,%ecx
mov    -0xa8(%rbp),%eax
imul   $0xf,%ecx,%ecx
and    %ecx,%eax
add    %eax,%edx
mov    -0x30(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1b9e <init_flag+0x9fe>
mov    0x10(%rbp),%edi
mov    $0x0,%al
call   1030 <getwallbit@plt>
mov    %eax,-0xb8(%rbp)
mov    $0x2,%edi
mov    $0x8,%esi
mov    $0x0,%al
call   1040 <pow2@plt>
mov    %eax,%ecx
mov    -0xb8(%rbp),%eax
imul   $0x3,%ecx,%ecx
sub    %ecx,%eax
mov    %eax,-0xb4(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xb0(%rbp)
mov    $0x2,%edi
mov    $0x8,%esi
mov    $0x0,%al
call   1040 <pow2@plt>
mov    -0xb4(%rbp),%edx
mov    %eax,%ecx
mov    -0xb0(%rbp),%eax
imul   $0x3,%ecx,%ecx
and    %ecx,%eax
add    %eax,%edx
mov    -0x30(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1ba3 <init_flag+0xa03>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    187e <init_flag+0x6de>
jmp    1bb6 <init_flag+0xa16>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    186b <init_flag+0x6cb>
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1e9d <init_flag+0xcfd>
movl   $0x1,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     1e8a <init_flag+0xcea>
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x8(%rax),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xc4(%rbp)
mov    $0x2,%edi
mov    $0xc,%esi
mov    $0x0,%al
call   1040 <pow2@plt>
mov    %eax,%ecx
mov    -0xc4(%rbp),%eax
and    %ecx,%eax
mov    %eax,-0xbc(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x8(%rax),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xc0(%rbp)
mov    $0x2,%edi
mov    $0xd,%esi
mov    $0x0,%al
call   1040 <pow2@plt>
mov    -0xc0(%rbp),%ecx
mov    %eax,%edx
mov    -0xbc(%rbp),%eax
and    %edx,%ecx
cmp    %ecx,%eax
jne    1cdb <init_flag+0xb3b>
xor    %edi,%edi
mov    $0x0,%al
call   1030 <getwallbit@plt>
mov    %eax,-0xcc(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x8(%rax),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xc8(%rbp)
mov    $0x2,%edi
mov    $0xc,%esi
mov    $0x0,%al
call   1040 <pow2@plt>
mov    -0xcc(%rbp),%edx
mov    %eax,%ecx
mov    -0xc8(%rbp),%eax
imul   $0xf,%ecx,%ecx
and    %ecx,%eax
add    %eax,%edx
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    (%rax),%rax
movslq -0x40(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1d21 <init_flag+0xb81>
mov    0x18(%rbp),%edi
mov    $0x0,%al
call   1030 <getwallbit@plt>
mov    %eax,%edx
sub    $0xc0,%edx
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x8(%rax),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
and    $0xc0,%eax
add    %eax,%edx
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    (%rax),%rax
movslq -0x40(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xd8(%rbp)
mov    $0x2,%edi
mov    $0xc,%esi
mov    $0x0,%al
call   1040 <pow2@plt>
mov    %eax,%ecx
mov    -0xd8(%rbp),%eax
and    %ecx,%eax
mov    %eax,-0xd0(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xd4(%rbp)
mov    $0x2,%edi
mov    $0xd,%esi
mov    $0x0,%al
call   1040 <pow2@plt>
mov    -0xd4(%rbp),%ecx
mov    %eax,%edx
mov    -0xd0(%rbp),%eax
and    %edx,%ecx
cmp    %ecx,%eax
jne    1e28 <init_flag+0xc88>
xor    %edi,%edi
mov    $0x0,%al
call   1030 <getwallbit@plt>
mov    %eax,-0xe0(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xdc(%rbp)
mov    $0x2,%edi
mov    $0xc,%esi
mov    $0x0,%al
call   1040 <pow2@plt>
mov    -0xe0(%rbp),%edx
mov    %eax,%ecx
mov    -0xdc(%rbp),%eax
imul   $0xf,%ecx,%ecx
and    %ecx,%eax
add    %eax,%edx
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1e77 <init_flag+0xcd7>
mov    0x20(%rbp),%edi
mov    $0x0,%al
call   1030 <getwallbit@plt>
mov    %eax,%edx
sub    $0x30,%edx
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
and    $0x30,%eax
add    %eax,%edx
mov    -0x30(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1e7c <init_flag+0xcdc>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1bde <init_flag+0xa3e>
jmp    1e8f <init_flag+0xcef>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1bcb <init_flag+0xa2b>
mov    -0x18(%rbp),%rdi
lea    0x1158(%rip),%rsi
call   1090 <strcmp@plt>
cmp    $0x0,%eax
jne    1eff <init_flag+0xd5f>
mov    -0x18(%rbp),%rdi
mov    -0x1c(%rbp),%esi
mov    -0x20(%rbp),%edx
mov    -0x24(%rbp),%ecx
mov    -0x30(%rbp),%r8
mov    -0x34(%rbp),%r9d
mov    0x10(%rbp),%r14d
mov    0x18(%rbp),%ebx
mov    0x20(%rbp),%r11d
mov    0x28(%rbp),%r10d
mov    0x30(%rbp),%eax
mov    %r14d,(%rsp)
mov    %ebx,0x8(%rsp)
mov    %r11d,0x10(%rsp)
mov    %r10d,0x18(%rsp)
mov    %eax,0x20(%rsp)
mov    $0x0,%al
call   10a0 <init_sphere@plt>
jmp    1f61 <init_flag+0xdc1>
mov    -0x18(%rbp),%rdi
lea    0x10ff(%rip),%rsi
call   1090 <strcmp@plt>
cmp    $0x0,%eax
jne    1f5c <init_flag+0xdbc>
mov    -0x18(%rbp),%rdi
mov    -0x1c(%rbp),%esi
mov    -0x20(%rbp),%edx
mov    -0x24(%rbp),%ecx
mov    -0x30(%rbp),%r8
mov    -0x34(%rbp),%r9d
mov    0x10(%rbp),%r14d
mov    0x18(%rbp),%ebx
mov    0x20(%rbp),%r11d
mov    0x28(%rbp),%r10d
mov    0x30(%rbp),%eax
mov    %r14d,(%rsp)
mov    %ebx,0x8(%rsp)
mov    %r11d,0x10(%rsp)
mov    %r10d,0x18(%rsp)
mov    %eax,0x20(%rsp)
mov    $0x0,%al
call   10b0 <init_breaking_dam@plt>
jmp    1f61 <init_flag+0xdc1>
lea    0x10b2(%rip),%rdi
mov    $0x0,%al
call   1080 <printf@plt>
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1fff <init_flag+0xe5f>
movl   $0x1,-0x40(%rbp)
mov    -0x40(%rbp),%eax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1fec <init_flag+0xe4c>
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1fd9 <init_flag+0xe39>
mov    -0x30(%rbp),%rdi
mov    -0x38(%rbp),%esi
mov    -0x3c(%rbp),%edx
mov    -0x40(%rbp),%ecx
mov    $0x0,%al
call   10c0 <init_cell@plt>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1fa6 <init_flag+0xe06>
jmp    1fde <init_flag+0xe3e>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1f8e <init_flag+0xdee>
jmp    1ff1 <init_flag+0xe51>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1f76 <init_flag+0xdd6>
add    $0x100,%rsp
pop    %rbx
pop    %r14
pop    %rbp
ret

x86 assembly (clang, -O2):
<init_flag>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x58,%rsp
mov    %r9d,0x44(%rsp)
mov    %r8,0x28(%rsp)
mov    %ecx,%ebx
mov    %rdx,0x8(%rsp)
mov    %rsi,0x10(%rsp)
mov    %rdi,%rbp
lea    0xe32(%rip),%rsi
call   1090 <strcmp@plt>
test   %eax,%eax
mov    %rbx,0x18(%rsp)
mov    %rbp,0x50(%rsp)
je     130a <init_flag+0x16a>
lea    0xe1d(%rip),%rsi
mov    %rbp,%rdi
call   1090 <strcmp@plt>
test   %eax,%eax
je     130a <init_flag+0x16a>
mov    %rbp,%rdi
xor    %eax,%eax
call   1080 <read_pgm@plt>
test   %ebx,%ebx
jle    1315 <init_flag+0x175>
movslq %eax,%r8
mov    0x8(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x38(%rsp)
mov    0x10(%rsp),%rax
lea    0x1(%rax),%esi
mov    0x18(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x48(%rsp)
mov    $0x1,%ecx
mov    %rsi,0x30(%rsp)
mov    0x18(%rsp),%rbx
mov    0x8(%rsp),%r13
jmp    125f <init_flag+0xbf>
nopl   0x0(%rax)
add    $0x1,%rcx
cmp    0x48(%rsp),%rcx
je     1315 <init_flag+0x175>
cmpl   $0x0,0x8(%rsp)
mov    0x10(%rsp),%r10
jle    1250 <init_flag+0xb0>
mov    $0x1,%r12d
jmp    128b <init_flag+0xeb>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r12
cmp    0x38(%rsp),%r12
je     1250 <init_flag+0xb0>
test   %r10d,%r10d
jle    1280 <init_flag+0xe0>
mov    0x38(%rsp),%rax
sub    %r12d,%eax
cltq
mov    %rax,0x20(%rsp)
mov    $0x1,%r14d
cs nopw 0x0(%rax,%rax,1)
nop
sub    $0x8,%rsp
mov    %r8,%r15
mov    %r8,%rdi
mov    %r14d,%esi
mov    %r12d,%edx
mov    0x18(%rsp),%r8
mov    %rcx,%rbp
mov    %r13d,%r9d
xor    %eax,%eax
push   %rbx
call   1050 <createflag@plt>
mov    %rbp,%rcx
mov    0x38(%rsp),%rdi
mov    %r15,%r8
mov    0x20(%rsp),%r10
add    $0x10,%rsp
mov    (%rdi,%r14,8),%rsi
mov    0x20(%rsp),%rbp
mov    (%rsi,%rbp,8),%rsi
mov    %eax,(%rsi,%rcx,4)
mov    0x30(%rsp),%rsi
add    $0x1,%r14
cmp    %r14,%rsi
jne    12b0 <init_flag+0x110>
jmp    1280 <init_flag+0xe0>
cmpl   $0xffffffff,0x10(%rsp)
jge    1706 <init_flag+0x566>
mov    0x98(%rsp),%r14d
cmpl   $0xffffffff,0x18(%rsp)
mov    0x28(%rsp),%r13
jl     13c7 <init_flag+0x227>
mov    0x8(%rsp),%rax
add    $0x1,%eax
movslq %eax,%r15
mov    0x10(%rsp),%rax
add    $0x1,%eax
movslq %eax,%rbp
mov    0x18(%rsp),%rax
add    $0x2,%eax
mov    %rax,0x20(%rsp)
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r14d,%edi
xor    %eax,%eax
call   1030 <getwallbit@plt>
mov    0x0(%r13),%rcx
mov    (%rcx),%rcx
mov    %eax,(%rcx,%rbx,4)
mov    0xa0(%rsp),%r12d
mov    %r12d,%edi
xor    %eax,%eax
call   1030 <getwallbit@plt>
mov    0x0(%r13),%rcx
mov    (%rcx,%r15,8),%rcx
mov    %eax,(%rcx,%rbx,4)
mov    %r14d,%edi
xor    %eax,%eax
call   1030 <getwallbit@plt>
mov    0x0(%r13,%rbp,8),%rcx
mov    (%rcx),%rcx
mov    %eax,(%rcx,%rbx,4)
mov    %r12d,%edi
xor    %eax,%eax
call   1030 <getwallbit@plt>
mov    0x0(%r13,%rbp,8),%rcx
mov    (%rcx,%r15,8),%rcx
mov    %eax,(%rcx,%rbx,4)
add    $0x1,%rbx
cmp    %rbx,0x20(%rsp)
jne    1360 <init_flag+0x1c0>
mov    0xa8(%rsp),%r12d
cmpl   $0xffffffff,0x8(%rsp)
jl     1467 <init_flag+0x2c7>
mov    0x18(%rsp),%rax
add    $0x1,%eax
movslq %eax,%r15
mov    0x10(%rsp),%rax
add    $0x1,%eax
movslq %eax,%rbp
mov    0x8(%rsp),%rax
lea    0x2(%rax),%r14d
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
mov    0xb0(%rsp),%edi
xor    %eax,%eax
call   1030 <getwallbit@plt>
mov    0x0(%r13),%rcx
mov    (%rcx,%rbx,8),%rcx
mov    %eax,(%rcx)
mov    %r12d,%edi
xor    %eax,%eax
call   1030 <getwallbit@plt>
mov    0x0(%r13),%rcx
mov    (%rcx,%rbx,8),%rcx
mov    %eax,(%rcx,%r15,4)
mov    0xb0(%rsp),%edi
xor    %eax,%eax
call   1030 <getwallbit@plt>
mov    0x0(%r13,%rbp,8),%rcx
mov    (%rcx,%rbx,8),%rcx
mov    %eax,(%rcx)
mov    %r12d,%edi
xor    %eax,%eax
call   1030 <getwallbit@plt>
mov    0x0(%r13,%rbp,8),%rcx
mov    (%rcx,%rbx,8),%rcx
mov    %eax,(%rcx,%r15,4)
add    $0x1,%rbx
cmp    %rbx,%r14
jne    1400 <init_flag+0x260>
movb   $0x1,0x48(%rsp)
mov    0x10(%rsp),%rcx
cmp    $0xffffffff,%ecx
jl     1799 <init_flag+0x5f9>
mov    0x8(%rsp),%rax
lea    0x1(%rax),%edx
mov    %rdx,%rax
mov    %rdx,0x30(%rsp)
movslq %edx,%rbp
mov    0x18(%rsp),%rax
add    $0x1,%eax
movslq %eax,%r15
lea    0x2(%rcx),%eax
mov    %rax,0x20(%rsp)
xor    %ebx,%ebx
mov    0x98(%rsp),%r12d
mov    0xa0(%rsp),%r14d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r12d,%edi
xor    %eax,%eax
call   1030 <getwallbit@plt>
mov    0x0(%r13,%rbx,8),%rcx
mov    (%rcx),%rcx
mov    %eax,(%rcx)
mov    %r14d,%edi
xor    %eax,%eax
call   1030 <getwallbit@plt>
mov    0x0(%r13,%rbx,8),%rcx
mov    (%rcx,%rbp,8),%rcx
mov    %eax,(%rcx)
mov    %r12d,%edi
xor    %eax,%eax
call   1030 <getwallbit@plt>
mov    0x0(%r13,%rbx,8),%rcx
mov    (%rcx),%rcx
mov    %eax,(%rcx,%r15,4)
mov    %r14d,%edi
xor    %eax,%eax
call   1030 <getwallbit@plt>
mov    0x0(%r13,%rbx,8),%rcx
mov    (%rcx,%rbp,8),%rcx
mov    %eax,(%rcx,%r15,4)
add    $0x1,%rbx
cmp    %rbx,0x20(%rsp)
jne    14c0 <init_flag+0x320>
mov    %r15,0x20(%rsp)
cmpl   $0x0,0x10(%rsp)
setle  %al
jle    1799 <init_flag+0x5f9>
mov    %al,0x48(%rsp)
movslq 0x18(%rsp),%r13
mov    0x10(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x38(%rsp)
mov    0x30(%rsp),%rax
lea    -0x8(,%rax,8),%rax
ff
mov    %rax,0x30(%rsp)
mov    $0x1,%r12d
mov    0x28(%rsp),%r14
jmp    157f <init_flag+0x3df>
nopl   0x0(%rax)
add    $0x1,%r12
cmp    0x38(%rsp),%r12
je     1794 <init_flag+0x5f4>
cmpl   $0x0,0x8(%rsp)
jle    1570 <init_flag+0x3d0>
mov    0x28(%rsp),%rax
mov    (%rax,%r12,8),%rcx
xor    %r15d,%r15d
jmp    15d6 <init_flag+0x436>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0xa8(%rsp),%edi
xor    %eax,%eax
call   1030 <getwallbit@plt>
mov    (%r14,%r12,8),%rcx
mov    0x8(%rcx,%r15,1),%rdx
mov    (%rdx,%r13,4),%esi
and    $0xc,%esi
add    %esi,%eax
add    $0xfffffff4,%eax
mov    0x20(%rsp),%rsi
mov    %eax,(%rdx,%rsi,4)
add    $0x8,%r15
cmp    %r15,0x30(%rsp)
je     1570 <init_flag+0x3d0>
mov    0x8(%rcx,%r15,1),%rax
mov    0x4(%rax),%ebp
mov    $0x2,%edi
mov    $0xc,%esi
xor    %eax,%eax
call   1040 <pow2@plt>
mov    %eax,%ebx
and    %ebp,%ebx
mov    (%r14,%r12,8),%rax
mov    0x8(%rax,%r15,1),%rax
mov    0x4(%rax),%ebp
mov    $0x2,%edi
mov    $0xd,%esi
xor    %eax,%eax
call   1040 <pow2@plt>
and    %ebp,%eax
cmp    %eax,%ebx
jne    1660 <init_flag+0x4c0>
xor    %edi,%edi
xor    %eax,%eax
call   1030 <getwallbit@plt>
mov    %eax,%ebx
mov    (%r14,%r12,8),%rax
mov    0x8(%rax,%r15,1),%rax
mov    0x4(%rax),%ebp
mov    $0x2,%edi
mov    $0xc,%esi
xor    %eax,%eax
call   1040 <pow2@plt>
lea    (%rax,%rax,4),%eax
lea    (%rax,%rax,2),%eax
and    %ebp,%eax
add    %ebx,%eax
mov    (%r14,%r12,8),%rcx
mov    0x8(%rcx,%r15,1),%rcx
jmp    1682 <init_flag+0x4e2>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0xb0(%rsp),%edi
xor    %eax,%eax
call   1030 <getwallbit@plt>
mov    (%r14,%r12,8),%rcx
mov    0x8(%rcx,%r15,1),%rcx
mov    0x4(%rcx),%edx
and    $0x3,%edx
add    %edx,%eax
add    $0xfffffffd,%eax
mov    %eax,(%rcx)
mov    (%rcx,%r13,4),%ebp
mov    $0x2,%edi
mov    $0xc,%esi
xor    %eax,%eax
call   1040 <pow2@plt>
mov    %eax,%ebx
and    %ebp,%ebx
mov    (%r14,%r12,8),%rax
mov    0x8(%rax,%r15,1),%rax
mov    (%rax,%r13,4),%ebp
mov    $0x2,%edi
mov    $0xd,%esi
xor    %eax,%eax
call   1040 <pow2@plt>
and    %ebp,%eax
cmp    %eax,%ebx
jne    15a0 <init_flag+0x400>
xor    %edi,%edi
xor    %eax,%eax
call   1030 <getwallbit@plt>
mov    %eax,%ebx
mov    (%r14,%r12,8),%rax
mov    0x8(%rax,%r15,1),%rax
mov    (%rax,%r13,4),%ebp
mov    $0x2,%edi
mov    $0xc,%esi
xor    %eax,%eax
call   1040 <pow2@plt>
lea    (%rax,%rax,4),%eax
lea    (%rax,%rax,2),%eax
and    %ebp,%eax
add    %ebx,%eax
mov    (%r14,%r12,8),%rcx
mov    0x8(%rcx,%r15,1),%rdx
jmp    15c3 <init_flag+0x423>
mov    0x8(%rsp),%rax
lea    0x2(%rax),%r12d
mov    0x18(%rsp),%rax
lea    0x2(%rax),%r15d
mov    0x10(%rsp),%rax
add    $0x2,%eax
mov    %rax,0x20(%rsp)
xor    %r13d,%r13d
mov    0x28(%rsp),%r14
jmp    173f <init_flag+0x59f>
nop
add    $0x1,%r13
cmp    0x20(%rsp),%r13
je     1315 <init_flag+0x175>
cmpl   $0xffffffff,0x18(%rsp)
jl     1730 <init_flag+0x590>
xor    %ebx,%ebx
jmp    1759 <init_flag+0x5b9>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rbx
cmp    %r15,%rbx
je     1730 <init_flag+0x590>
cmpl   $0xffffffff,0x8(%rsp)
jl     1750 <init_flag+0x5b0>
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%r14,%r13,8),%rax
lea    0x0(,%rbx,4),%rdi
add    (%rax,%rbp,8),%rdi
xor    %esi,%esi
xor    %eax,%eax
call   1070 <setcelltype@plt>
add    $0x1,%rbp
cmp    %rbp,%r12
jne    1770 <init_flag+0x5d0>
jmp    1750 <init_flag+0x5b0>
mov    0x28(%rsp),%r13
cmpl   $0x0,0x8(%rsp)
jle    19cf <init_flag+0x82f>
mov    0x10(%rsp),%rax
movslq %eax,%r14
add    $0x1,%eax
cltq
mov    %rax,0x20(%rsp)
mov    0x18(%rsp),%rax
add    $0x1,%eax
mov    0x8(%rsp),%rcx
add    $0x1,%ecx
mov    %rcx,0x38(%rsp)
lea    -0x4(,%rax,4),%rax
ff
mov    %rax,0x30(%rsp)
mov    $0x1,%r12d
jmp    17ef <init_flag+0x64f>
add    $0x1,%r12
cmp    0x38(%rsp),%r12
je     19cf <init_flag+0x82f>
cmpl   $0x0,0x18(%rsp)
jle    17e0 <init_flag+0x640>
xor    %r15d,%r15d
jmp    1874 <init_flag+0x6d4>
nopl   0x0(%rax,%rax,1)
mov    0x90(%rsp),%edi
xor    %eax,%eax
call   1030 <getwallbit@plt>
mov    %eax,%ebp
mov    $0x2,%edi
mov    $0x8,%esi
xor    %eax,%eax
call   1040 <pow2@plt>
lea    (%rax,%rax,2),%eax
sub    %eax,%ebp
mov    0x0(%r13,%r14,8),%rax
mov    (%rax,%r12,8),%rax
mov    0x4(%rax,%r15,1),%r13d
mov    $0x2,%edi
mov    $0x8,%esi
xor    %eax,%eax
call   1040 <pow2@plt>
lea    (%rax,%rax,2),%ebx
and    %r13d,%ebx
mov    0x28(%rsp),%r13
add    %ebp,%ebx
mov    0x20(%rsp),%rax
mov    0x0(%r13,%rax,8),%rax
mov    (%rax,%r12,8),%rax
mov    %ebx,0x4(%rax,%r15,1)
add    $0x4,%r15
cmp    %r15,0x30(%rsp)
je     17e0 <init_flag+0x640>
mov    0x8(%r13),%rax
mov    (%rax,%r12,8),%rax
mov    0x4(%rax,%r15,1),%ebp
mov    $0x2,%edi
mov    $0xc,%esi
xor    %eax,%eax
call   1040 <pow2@plt>
mov    %eax,%ebx
and    %ebp,%ebx
mov    0x8(%r13),%rax
mov    (%rax,%r12,8),%rax
mov    0x4(%rax,%r15,1),%ebp
mov    $0x2,%edi
mov    $0xd,%esi
xor    %eax,%eax
call   1040 <pow2@plt>
and    %ebp,%eax
cmp    %eax,%ebx
jne    18f0 <init_flag+0x750>
xor    %edi,%edi
xor    %eax,%eax
call   1030 <getwallbit@plt>
mov    %eax,%ebx
mov    0x8(%r13),%rax
mov    (%rax,%r12,8),%rax
mov    0x4(%rax,%r15,1),%r13d
mov    $0x2,%edi
mov    $0xc,%esi
xor    %eax,%eax
call   1040 <pow2@plt>
lea    (%rax,%rax,4),%eax
lea    (%rax,%rax,2),%ebp
and    %r13d,%ebp
jmp    1937 <init_flag+0x797>
xchg   %ax,%ax
mov    0x44(%rsp),%edi
xor    %eax,%eax
call   1030 <getwallbit@plt>
mov    %eax,%ebp
mov    $0x2,%edi
mov    $0xa,%esi
xor    %eax,%eax
call   1040 <pow2@plt>
lea    (%rax,%rax,2),%eax
sub    %eax,%ebp
mov    0x8(%r13),%rax
mov    (%rax,%r12,8),%rax
mov    0x4(%rax,%r15,1),%r13d
mov    $0x2,%edi
mov    $0xa,%esi
xor    %eax,%eax
call   1040 <pow2@plt>
lea    (%rax,%rax,2),%ebx
and    %r13d,%ebx
mov    0x28(%rsp),%r13
add    %ebp,%ebx
mov    0x0(%r13),%rax
mov    (%rax,%r12,8),%rax
mov    %ebx,0x4(%rax,%r15,1)
mov    0x0(%r13,%r14,8),%rax
mov    (%rax,%r12,8),%rax
mov    0x4(%rax,%r15,1),%ebp
mov    $0x2,%edi
mov    $0xc,%esi
xor    %eax,%eax
call   1040 <pow2@plt>
mov    %eax,%ebx
and    %ebp,%ebx
mov    0x0(%r13,%r14,8),%rax
mov    (%rax,%r12,8),%rax
mov    0x4(%rax,%r15,1),%ebp
mov    $0x2,%edi
mov    $0xd,%esi
xor    %eax,%eax
call   1040 <pow2@plt>
and    %ebp,%eax
cmp    %eax,%ebx
jne    1800 <init_flag+0x660>
xor    %edi,%edi
xor    %eax,%eax
call   1030 <getwallbit@plt>
mov    %eax,%ebx
mov    0x0(%r13,%r14,8),%rax
mov    (%rax,%r12,8),%rax
mov    0x4(%rax,%r15,1),%r13d
mov    $0x2,%edi
mov    $0xc,%esi
xor    %eax,%eax
call   1040 <pow2@plt>
lea    (%rax,%rax,4),%eax
lea    (%rax,%rax,2),%ebp
and    %r13d,%ebp
jmp    184b <init_flag+0x6ab>
cmpb   $0x0,0x48(%rsp)
mov    0xa0(%rsp),%ebp
je     1a67 <init_flag+0x8c7>
lea    0x618(%rip),%rsi
mov    0x50(%rsp),%rbx
mov    %rbx,%rdi
call   1090 <strcmp@plt>
test   %eax,%eax
je     1c5a <init_flag+0xaba>
lea    0x605(%rip),%rsi
mov    %rbx,%rdi
call   1090 <strcmp@plt>
test   %eax,%eax
mov    0x28(%rsp),%r12
mov    0x18(%rsp),%r13
jne    1cac <init_flag+0xb0c>
sub    $0x8,%rsp
mov    %rbx,%rdi
mov    0x18(%rsp),%rsi
mov    0x10(%rsp),%rdx
mov    %r13d,%ecx
mov    %r12,%r8
mov    0x4c(%rsp),%r9d
xor    %eax,%eax
mov    0xb8(%rsp),%ebx
push   %rbx
mov    0xb8(%rsp),%ebx
push   %rbx
push   %rbp
mov    0xb8(%rsp),%ebp
push   %rbp
mov    0xb8(%rsp),%ebp
push   %rbp
call   10b0 <init_breaking_dam@plt>
jmp    1ca8 <init_flag+0xb08>
mov    0x8(%rsp),%rax
movslq %eax,%r13
add    $0x1,%eax
cltq
mov    %rax,0x20(%rsp)
mov    0x18(%rsp),%rax
add    $0x1,%eax
mov    0x10(%rsp),%rcx
add    $0x1,%ecx
mov    %rcx,0x38(%rsp)
lea    -0x4(,%rax,4),%rax
ff
mov    %rax,0x30(%rsp)
mov    $0x1,%r15d
mov    0x28(%rsp),%r12
jmp    1abf <init_flag+0x91f>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r15
cmp    0x38(%rsp),%r15
je     19e1 <init_flag+0x841>
cmpl   $0x0,0x18(%rsp)
jle    1ab0 <init_flag+0x910>
mov    0x28(%rsp),%rax
mov    (%rax,%r15,8),%rcx
xor    %r14d,%r14d
jmp    1b1e <init_flag+0x97e>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0xa0(%rsp),%ebp
mov    %ebp,%edi
xor    %eax,%eax
call   1030 <getwallbit@plt>
mov    (%r12,%r15,8),%rcx
mov    (%rcx,%r13,8),%rdx
mov    0x4(%rdx,%r14,1),%edx
and    $0x30,%edx
add    %edx,%eax
add    $0xffffffd0,%eax
mov    0x20(%rsp),%rdx
mov    (%rcx,%rdx,8),%rdx
mov    %eax,0x4(%rdx,%r14,1)
add    $0x4,%r14
cmp    %r14,0x30(%rsp)
je     1ab0 <init_flag+0x910>
mov    0x8(%rcx),%rax
mov    0x4(%rax,%r14,1),%ebp
mov    $0x2,%edi
mov    $0xc,%esi
xor    %eax,%eax
call   1040 <pow2@plt>
mov    %eax,%ebx
and    %ebp,%ebx
mov    (%r12,%r15,8),%rax
mov    0x8(%rax),%rax
mov    0x4(%rax,%r14,1),%ebp
mov    $0x2,%edi
mov    $0xd,%esi
xor    %eax,%eax
call   1040 <pow2@plt>
and    %ebp,%eax
cmp    %eax,%ebx
jne    1ba0 <init_flag+0xa00>
xor    %edi,%edi
xor    %eax,%eax
call   1030 <getwallbit@plt>
mov    %eax,%ebx
mov    (%r12,%r15,8),%rax
mov    0x8(%rax),%rax
mov    0x4(%rax,%r14,1),%ebp
mov    $0x2,%edi
mov    $0xc,%esi
xor    %eax,%eax
call   1040 <pow2@plt>
lea    (%rax,%rax,4),%eax
lea    (%rax,%rax,2),%eax
and    %ebp,%eax
add    %ebx,%eax
mov    (%r12,%r15,8),%rcx
jmp    1bc9 <init_flag+0xa29>
nopl   0x0(%rax)
mov    0x98(%rsp),%edi
xor    %eax,%eax
call   1030 <getwallbit@plt>
mov    (%r12,%r15,8),%rcx
mov    0x8(%rcx),%rdx
mov    0x4(%rdx,%r14,1),%edx
mov    $0xc0,%esi
and    %esi,%edx
add    %edx,%eax
add    $0xffffff40,%eax
mov    (%rcx),%rdx
mov    %eax,0x4(%rdx,%r14,1)
mov    (%rcx,%r13,8),%rax
mov    0x4(%rax,%r14,1),%ebp
mov    $0x2,%edi
mov    $0xc,%esi
xor    %eax,%eax
call   1040 <pow2@plt>
mov    %eax,%ebx
and    %ebp,%ebx
mov    (%r12,%r15,8),%rax
mov    (%rax,%r13,8),%rax
mov    0x4(%rax,%r14,1),%ebp
mov    $0x2,%edi
mov    $0xd,%esi
xor    %eax,%eax
call   1040 <pow2@plt>
and    %ebp,%eax
cmp    %eax,%ebx
jne    1ae0 <init_flag+0x940>
xor    %edi,%edi
xor    %eax,%eax
call   1030 <getwallbit@plt>
mov    %eax,%ebx
mov    (%r12,%r15,8),%rax
mov    (%rax,%r13,8),%rax
mov    0x4(%rax,%r14,1),%ebp
mov    $0x2,%edi
mov    $0xc,%esi
xor    %eax,%eax
call   1040 <pow2@plt>
lea    (%rax,%rax,4),%eax
lea    (%rax,%rax,2),%eax
and    %ebp,%eax
add    %ebx,%eax
mov    (%r12,%r15,8),%rcx
mov    0xa0(%rsp),%ebp
jmp    1b05 <init_flag+0x965>
sub    $0x8,%rsp
mov    %rbx,%rdi
mov    0x18(%rsp),%rsi
mov    0x10(%rsp),%rdx
mov    0x20(%rsp),%r13
mov    %r13d,%ecx
mov    0x30(%rsp),%r12
mov    %r12,%r8
mov    0x4c(%rsp),%r9d
xor    %eax,%eax
mov    0xb8(%rsp),%ebx
push   %rbx
mov    0xb8(%rsp),%ebx
push   %rbx
push   %rbp
mov    0xb8(%rsp),%ebp
push   %rbp
mov    0xb8(%rsp),%ebp
push   %rbp
call   10a0 <init_sphere@plt>
add    $0x30,%rsp
lea    0x367(%rip),%rdi
call   1060 <puts@plt>
cmpb   $0x0,0x48(%rsp)
je     1cce <init_flag+0xb2e>
add    $0x58,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0x8(%rsp),%r15
neg    %r15d
mov    $0x1,%r14d
jmp    1cee <init_flag+0xb4e>
xchg   %ax,%ax
lea    0x1(%r14),%eax
cmp    0x10(%rsp),%r14d
mov    %eax,%r14d
je     1cbf <init_flag+0xb1f>
test   %r13d,%r13d
jle    1ce0 <init_flag+0xb40>
mov    $0x1,%ebp
jmp    1d0a <init_flag+0xb6a>
nopw   0x0(%rax,%rax,1)
lea    0x1(%rbp),%eax
cmp    %r13d,%ebp
mov    %eax,%ebp
je     1ce0 <init_flag+0xb40>
cmpl   $0x0,0x8(%rsp)
jle    1d00 <init_flag+0xb60>
mov    $0x1,%ebx
cs nopw 0x0(%rax,%rax,1)
mov    %r12,%rdi
mov    %r14d,%esi
mov    %ebx,%edx
mov    %ebp,%ecx
xor    %eax,%eax
call   10c0 <init_cell@plt>
lea    (%r15,%rbx,1),%eax
add    $0x1,%eax
mov    %ebx,%ecx
add    $0x1,%ecx
mov    %ecx,%ebx
cmp    $0x1,%eax
jne    1d20 <init_flag+0xb80>
jmp    1d00 <init_flag+0xb60>

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

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