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;
  int temp, temp2;
  int tarr[] = {1, 2, 0, 3, 4, 7, 8};
  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++) {
        temp = tarr[Pic[i][j + k * (jmax + 2)]] * pow2(2, 12) +
               min(Pic[i + 1][j + k * (jmax + 2)] + 1, 3) * pow2(2, 10) +
               min(Pic[i - 1][j + k * (jmax + 2)] + 1, 3) * pow2(2, 8) +
               min(Pic[i][j + k * (jmax + 2) - 1] + 1, 3) * pow2(2, 6) +
               min(Pic[i][j + k * (jmax + 2) + 1] + 1, 3) * pow2(2, 4) +
               min(Pic[i][j + (k - 1) * (jmax + 2)] + 1, 3) * 4 +
               min(Pic[i][j + (k + 1) * (jmax + 2)] + 1, 3);
        if (Pic[i][j + k * (jmax + 2)] > 1 &&
            (min(Pic[i][j + k * (jmax + 2) + 1] +
                     Pic[i][j + k * (jmax + 2) - 1],
                 Pic[i - 1][j + k * (jmax + 2)] +
                     Pic[i + 1][j + k * (jmax + 2)]) == 0 ||
             !(Pic[i][j + (k - 1) * (jmax + 2)] +
               Pic[i][j + (k + 1) * (jmax + 2)]))) {
          errhandler(246,
                     "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/"
                     "outputs/2022-01-22/02-19-57/repos/EvaBr/CFD-Lab/refs/"
                     "heads/master/Backup/FinalProjectBackup/init.c",
                     "Invalid geometry! Forbidden boundary cell found.\n");
        }
        temp2 = getcelltype(temp) % 16;
        if ((((temp >> 12) & 15) == 8) &&
            (temp2 == 5 || temp2 == 6 || temp2 == 9 || temp2 == 10)) {
          errhandler(250,
                     "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/"
                     "outputs/2022-01-22/02-19-57/repos/EvaBr/CFD-Lab/refs/"
                     "heads/master/Backup/FinalProjectBackup/init.c",
                     "Invalid geometry! Forbidden boundary cell found.\n");
        }
        Flag[i][jmax + 1 - j][k] = temp;
      }
    }
  }
  for (k = 0; k < kmax + 2; k++) {
    Flag[0][0][k] = getbit(wf);
    Flag[0][jmax + 1][k] = getbit(wh);
    Flag[imax + 1][0][k] = getbit(wf);
    Flag[imax + 1][jmax + 1][k] = getbit(wh);
  }
  for (j = 0; j < jmax + 2; j++) {
    Flag[0][j][0] = getbit(wb);
    Flag[0][j][kmax + 1] = getbit(wt);
    Flag[imax + 1][j][0] = getbit(wb);
    Flag[imax + 1][j][kmax + 1] = getbit(wt);
  }
  for (i = 0; i < imax + 2; i++) {
    Flag[i][0][0] = getbit(wf);
    Flag[i][jmax + 1][0] = getbit(wh);
    Flag[i][0][kmax + 1] = getbit(wf);
    Flag[i][jmax + 1][kmax + 1] = getbit(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] = getbit(0) + (Flag[i][j][1] & (pow2(2, 12) * 15));
      } else {
        Flag[i][j][0] = (getbit(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] =
            getbit(0) + (Flag[i][j][kmax] & (pow2(2, 12) * 15));
      } else {
        Flag[i][j][kmax + 1] = (getbit(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] = getbit(0) + (Flag[1][j][k] & (pow2(2, 12) * 15));
      } else {
        Flag[0][j][k] = (getbit(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] =
            getbit(0) + (Flag[imax][j][k] & (pow2(2, 12) * 15));
      } else {
        Flag[imax + 1][j][k] = (getbit(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] = getbit(0) + (Flag[i][1][k] & (pow2(2, 12) * 15));
      } else {
        Flag[i][0][k] = (getbit(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] =
            getbit(0) + (Flag[i][jmax][k] & (pow2(2, 12) * 15));
      } else {
        Flag[i][jmax + 1][k] =
            (getbit(wh) - 16 * 3) + (Flag[i][jmax][k] & (16 * 3));
      }
    }
  }
}


x86 assembly (clang, -O0):
<init_flag>:
push   %rbp
mov    %rsp,%rbp
sub    $0x130,%rsp
mov    0x30(%rbp),%eax
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9d,-0x24(%rbp)
mov    0x1e6a(%rip),%rax
mov    %rax,-0x60(%rbp)
mov    0x1e67(%rip),%rax
mov    %rax,-0x58(%rbp)
mov    0x1e64(%rip),%rax
mov    %rax,-0x50(%rbp)
mov    0x1e62(%rip),%eax
mov    %eax,-0x48(%rbp)
mov    -0x8(%rbp),%rdi
mov    $0x0,%al
call   1050 <read_pgm@plt>
cltq
mov    %rax,-0x68(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1677 <init_flag+0x517>
movl   $0x1,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1664 <init_flag+0x504>
movl   $0x1,-0x70(%rbp)
mov    -0x70(%rbp),%eax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1651 <init_flag+0x4f1>
mov    -0x68(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x6c(%rbp),%ecx
mov    -0x30(%rbp),%edx
mov    -0x10(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movslq (%rax,%rcx,4),%rax
mov    -0x60(%rbp,%rax,4),%eax
mov    %eax,-0x9c(%rbp)
mov    $0x2,%edi
mov    $0xc,%esi
mov    $0x0,%al
call   1030 <pow2@plt>
mov    %eax,%ecx
mov    -0x9c(%rbp),%eax
imul   %ecx,%eax
mov    %eax,-0x94(%rbp)
mov    -0x68(%rbp),%rax
mov    -0x70(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x6c(%rbp),%ecx
mov    -0x30(%rbp),%edx
mov    -0x10(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edi
add    $0x1,%edi
mov    $0x3,%esi
mov    $0x0,%al
call   1060 <min@plt>
mov    %eax,-0x98(%rbp)
mov    $0x2,%edi
mov    $0xa,%esi
mov    $0x0,%al
call   1030 <pow2@plt>
mov    -0x98(%rbp),%ecx
mov    %eax,%edx
mov    -0x94(%rbp),%eax
imul   %edx,%ecx
add    %ecx,%eax
mov    %eax,-0x8c(%rbp)
mov    -0x68(%rbp),%rax
mov    -0x70(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x6c(%rbp),%ecx
mov    -0x30(%rbp),%edx
mov    -0x10(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edi
add    $0x1,%edi
mov    $0x3,%esi
mov    $0x0,%al
call   1060 <min@plt>
mov    %eax,-0x90(%rbp)
mov    $0x2,%edi
mov    $0x8,%esi
mov    $0x0,%al
call   1030 <pow2@plt>
mov    -0x90(%rbp),%ecx
mov    %eax,%edx
mov    -0x8c(%rbp),%eax
imul   %edx,%ecx
add    %ecx,%eax
mov    %eax,-0x84(%rbp)
mov    -0x68(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x6c(%rbp),%ecx
mov    -0x30(%rbp),%edx
mov    -0x10(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
add    %edx,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edi
add    $0x1,%edi
mov    $0x3,%esi
mov    $0x0,%al
call   1060 <min@plt>
mov    %eax,-0x88(%rbp)
mov    $0x2,%edi
mov    $0x6,%esi
mov    $0x0,%al
call   1030 <pow2@plt>
mov    -0x88(%rbp),%ecx
mov    %eax,%edx
mov    -0x84(%rbp),%eax
imul   %edx,%ecx
add    %ecx,%eax
mov    %eax,-0x7c(%rbp)
mov    -0x68(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x6c(%rbp),%ecx
mov    -0x30(%rbp),%edx
mov    -0x10(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
add    %edx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edi
add    $0x1,%edi
mov    $0x3,%esi
mov    $0x0,%al
call   1060 <min@plt>
mov    %eax,-0x80(%rbp)
mov    $0x2,%edi
mov    $0x4,%esi
mov    $0x0,%al
call   1030 <pow2@plt>
mov    -0x80(%rbp),%ecx
mov    %eax,%edx
mov    -0x7c(%rbp),%eax
imul   %edx,%ecx
add    %ecx,%eax
mov    %eax,-0x78(%rbp)
mov    -0x68(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x6c(%rbp),%ecx
mov    -0x30(%rbp),%edx
sub    $0x1,%edx
mov    -0x10(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edi
add    $0x1,%edi
mov    $0x3,%esi
mov    $0x0,%al
call   1060 <min@plt>
mov    %eax,%ecx
mov    -0x78(%rbp),%eax
shl    $0x2,%ecx
add    %ecx,%eax
mov    %eax,-0x74(%rbp)
mov    -0x68(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x6c(%rbp),%ecx
mov    -0x30(%rbp),%edx
add    $0x1,%edx
mov    -0x10(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edi
add    $0x1,%edi
mov    $0x3,%esi
mov    $0x0,%al
call   1060 <min@plt>
mov    %eax,%ecx
mov    -0x74(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x34(%rbp)
mov    -0x68(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x6c(%rbp),%ecx
mov    -0x30(%rbp),%edx
mov    -0x10(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
cmpl   $0x1,(%rax,%rcx,4)
jle    15b4 <init_flag+0x454>
mov    -0x68(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x6c(%rbp),%ecx
mov    -0x30(%rbp),%edx
mov    -0x10(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
add    %edx,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edi
mov    -0x68(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x6c(%rbp),%ecx
mov    -0x30(%rbp),%edx
mov    -0x10(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
add    %edx,%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
add    (%rax,%rcx,4),%edi
mov    -0x68(%rbp),%rax
mov    -0x70(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x6c(%rbp),%ecx
mov    -0x30(%rbp),%edx
mov    -0x10(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%esi
mov    -0x68(%rbp),%rax
mov    -0x70(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x6c(%rbp),%ecx
mov    -0x30(%rbp),%edx
mov    -0x10(%rbp),%r8d
add    $0x2,%r8d
imul   %r8d,%edx
add    %edx,%ecx
movslq %ecx,%rcx
add    (%rax,%rcx,4),%esi
mov    $0x0,%al
call   1060 <min@plt>
cmp    $0x0,%eax
je     159a <init_flag+0x43a>
mov    -0x68(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x6c(%rbp),%ecx
mov    -0x30(%rbp),%edx
sub    $0x1,%edx
mov    -0x10(%rbp),%esi
add    $0x2,%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x68(%rbp),%rcx
movslq -0x70(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
mov    -0x6c(%rbp),%edx
mov    -0x30(%rbp),%esi
add    $0x1,%esi
mov    -0x10(%rbp),%edi
add    $0x2,%edi
imul   %edi,%esi
add    %esi,%edx
movslq %edx,%rdx
add    (%rcx,%rdx,4),%eax
cmp    $0x0,%eax
jne    15b4 <init_flag+0x454>
mov    $0xf6,%edi
lea    0x1a76(%rip),%rsi
lea    0x1b0a(%rip),%rdx
mov    $0x0,%al
call   1040 <errhandler@plt>
mov    -0x34(%rbp),%edi
mov    $0x0,%al
call   1080 <getcelltype@plt>
mov    $0x10,%ecx
cltd
idiv   %ecx
mov    %edx,-0x38(%rbp)
mov    -0x34(%rbp),%eax
sar    $0xc,%eax
and    $0xf,%eax
cmp    $0x8,%eax
jne    161d <init_flag+0x4bd>
cmpl   $0x5,-0x38(%rbp)
je     1603 <init_flag+0x4a3>
cmpl   $0x6,-0x38(%rbp)
je     1603 <init_flag+0x4a3>
cmpl   $0x9,-0x38(%rbp)
je     1603 <init_flag+0x4a3>
cmpl   $0xa,-0x38(%rbp)
jne    161d <init_flag+0x4bd>
mov    $0xfa,%edi
lea    0x1a0d(%rip),%rsi
lea    0x1aa1(%rip),%rdx
mov    $0x0,%al
call   1040 <errhandler@plt>
mov    -0x34(%rbp),%edx
mov    -0x20(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
sub    -0x6c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    1201 <init_flag+0xa1>
jmp    1656 <init_flag+0x4f6>
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    11e9 <init_flag+0x89>
jmp    1669 <init_flag+0x509>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11d1 <init_flag+0x71>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x14(%rbp),%ecx
add    $0x2,%ecx
cmp    %ecx,%eax
jge    1739 <init_flag+0x5d9>
mov    0x18(%rbp),%edi
mov    $0x0,%al
call   1070 <getbit@plt>
mov    %eax,%edx
mov    -0x20(%rbp),%rax
mov    (%rax),%rax
mov    (%rax),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x20(%rbp),%edi
mov    $0x0,%al
call   1070 <getbit@plt>
mov    %eax,%edx
mov    -0x20(%rbp),%rax
mov    (%rax),%rax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x18(%rbp),%edi
mov    $0x0,%al
call   1070 <getbit@plt>
mov    %eax,%edx
mov    -0x20(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    (%rax),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x20(%rbp),%edi
mov    $0x0,%al
call   1070 <getbit@plt>
mov    %eax,%edx
mov    -0x20(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    167e <init_flag+0x51e>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x10(%rbp),%ecx
add    $0x2,%ecx
cmp    %ecx,%eax
jge    17fb <init_flag+0x69b>
mov    0x30(%rbp),%edi
mov    $0x0,%al
call   1070 <getbit@plt>
mov    %eax,%ecx
mov    -0x20(%rbp),%rax
mov    (%rax),%rax
movslq -0x2c(%rbp),%rdx
mov    (%rax,%rdx,8),%rax
mov    %ecx,(%rax)
mov    0x28(%rbp),%edi
mov    $0x0,%al
call   1070 <getbit@plt>
mov    %eax,%edx
mov    -0x20(%rbp),%rax
mov    (%rax),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x30(%rbp),%edi
mov    $0x0,%al
call   1070 <getbit@plt>
mov    %eax,%ecx
mov    -0x20(%rbp),%rax
mov    -0xc(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
mov    (%rax,%rdx,8),%rax
movslq -0x2c(%rbp),%rdx
mov    (%rax,%rdx,8),%rax
mov    %ecx,(%rax)
mov    0x28(%rbp),%edi
mov    $0x0,%al
call   1070 <getbit@plt>
mov    %eax,%edx
mov    -0x20(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1740 <init_flag+0x5e0>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0xc(%rbp),%ecx
add    $0x2,%ecx
cmp    %ecx,%eax
jge    18bd <init_flag+0x75d>
mov    0x18(%rbp),%edi
mov    $0x0,%al
call   1070 <getbit@plt>
mov    %eax,%ecx
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rdx
mov    (%rax,%rdx,8),%rax
mov    (%rax),%rax
mov    %ecx,(%rax)
mov    0x20(%rbp),%edi
mov    $0x0,%al
call   1070 <getbit@plt>
mov    %eax,%ecx
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rdx
mov    (%rax,%rdx,8),%rax
mov    -0x10(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
mov    (%rax,%rdx,8),%rax
mov    %ecx,(%rax)
mov    0x18(%rbp),%edi
mov    $0x0,%al
call   1070 <getbit@plt>
mov    %eax,%edx
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    (%rax),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    0x20(%rbp),%edi
mov    $0x0,%al
call   1070 <getbit@plt>
mov    %eax,%edx
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1802 <init_flag+0x6a2>
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1b91 <init_flag+0xa31>
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     1b7e <init_flag+0xa1e>
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x4(%rax),%eax
mov    %eax,-0xa8(%rbp)
mov    $0x2,%edi
mov    $0xc,%esi
mov    $0x0,%al
call   1030 <pow2@plt>
mov    %eax,%ecx
mov    -0xa8(%rbp),%eax
and    %ecx,%eax
mov    %eax,-0xa0(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x4(%rax),%eax
mov    %eax,-0xa4(%rbp)
mov    $0x2,%edi
mov    $0xd,%esi
mov    $0x0,%al
call   1030 <pow2@plt>
mov    -0xa4(%rbp),%ecx
mov    %eax,%edx
mov    -0xa0(%rbp),%eax
and    %edx,%ecx
cmp    %ecx,%eax
jne    19d4 <init_flag+0x874>
xor    %edi,%edi
mov    $0x0,%al
call   1070 <getbit@plt>
mov    %eax,-0xb0(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x4(%rax),%eax
mov    %eax,-0xac(%rbp)
mov    $0x2,%edi
mov    $0xc,%esi
mov    $0x0,%al
call   1030 <pow2@plt>
mov    -0xb0(%rbp),%ecx
mov    %eax,%edx
mov    -0xac(%rbp),%eax
imul   $0xf,%edx,%edx
and    %edx,%eax
add    %eax,%ecx
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rdx
mov    (%rax,%rdx,8),%rax
movslq -0x2c(%rbp),%rdx
mov    (%rax,%rdx,8),%rax
mov    %ecx,(%rax)
jmp    1a15 <init_flag+0x8b5>
mov    0x30(%rbp),%edi
mov    $0x0,%al
call   1070 <getbit@plt>
mov    %eax,%ecx
sub    $0x3,%ecx
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rdx
mov    (%rax,%rdx,8),%rax
movslq -0x2c(%rbp),%rdx
mov    (%rax,%rdx,8),%rax
mov    0x4(%rax),%eax
and    $0x3,%eax
add    %eax,%ecx
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rdx
mov    (%rax,%rdx,8),%rax
movslq -0x2c(%rbp),%rdx
mov    (%rax,%rdx,8),%rax
mov    %ecx,(%rax)
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xbc(%rbp)
mov    $0x2,%edi
mov    $0xc,%esi
mov    $0x0,%al
call   1030 <pow2@plt>
mov    %eax,%ecx
mov    -0xbc(%rbp),%eax
and    %ecx,%eax
mov    %eax,-0xb4(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xb8(%rbp)
mov    $0x2,%edi
mov    $0xd,%esi
mov    $0x0,%al
call   1030 <pow2@plt>
mov    -0xb8(%rbp),%ecx
mov    %eax,%edx
mov    -0xb4(%rbp),%eax
and    %edx,%ecx
cmp    %ecx,%eax
jne    1b1c <init_flag+0x9bc>
xor    %edi,%edi
mov    $0x0,%al
call   1070 <getbit@plt>
mov    %eax,-0xc4(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xc0(%rbp)
mov    $0x2,%edi
mov    $0xc,%esi
mov    $0x0,%al
call   1030 <pow2@plt>
mov    -0xc4(%rbp),%edx
mov    %eax,%ecx
mov    -0xc0(%rbp),%eax
imul   $0xf,%ecx,%ecx
and    %ecx,%eax
add    %eax,%edx
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1b6b <init_flag+0xa0b>
mov    0x28(%rbp),%edi
mov    $0x0,%al
call   1070 <getbit@plt>
mov    %eax,%edx
sub    $0xc,%edx
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
and    $0xc,%eax
add    %eax,%edx
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1b70 <init_flag+0xa10>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    18d7 <init_flag+0x777>
jmp    1b83 <init_flag+0xa23>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    18c4 <init_flag+0x764>
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     1efd <init_flag+0xd9d>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1eea <init_flag+0xd8a>
mov    -0x20(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xd0(%rbp)
mov    $0x2,%edi
mov    $0xc,%esi
mov    $0x0,%al
call   1030 <pow2@plt>
mov    %eax,%ecx
mov    -0xd0(%rbp),%eax
and    %ecx,%eax
mov    %eax,-0xc8(%rbp)
mov    -0x20(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xcc(%rbp)
mov    $0x2,%edi
mov    $0xd,%esi
mov    $0x0,%al
call   1030 <pow2@plt>
mov    -0xcc(%rbp),%ecx
mov    %eax,%edx
mov    -0xc8(%rbp),%eax
and    %edx,%ecx
cmp    %ecx,%eax
jne    1ca8 <init_flag+0xb48>
xor    %edi,%edi
mov    $0x0,%al
call   1070 <getbit@plt>
mov    %eax,-0xd8(%rbp)
mov    -0x20(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xd4(%rbp)
mov    $0x2,%edi
mov    $0xc,%esi
mov    $0x0,%al
call   1030 <pow2@plt>
mov    -0xd8(%rbp),%edx
mov    %eax,%ecx
mov    -0xd4(%rbp),%eax
imul   $0xf,%ecx,%ecx
and    %ecx,%eax
add    %eax,%edx
mov    -0x20(%rbp),%rax
mov    (%rax),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1d35 <init_flag+0xbd5>
mov    -0x24(%rbp),%edi
mov    $0x0,%al
call   1070 <getbit@plt>
mov    %eax,-0xe4(%rbp)
mov    $0x2,%edi
mov    $0xa,%esi
mov    $0x0,%al
call   1030 <pow2@plt>
mov    %eax,%ecx
mov    -0xe4(%rbp),%eax
imul   $0x3,%ecx,%ecx
sub    %ecx,%eax
mov    %eax,-0xe0(%rbp)
mov    -0x20(%rbp),%rax
mov    0x8(%rax),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xdc(%rbp)
mov    $0x2,%edi
mov    $0xa,%esi
mov    $0x0,%al
call   1030 <pow2@plt>
mov    -0xe0(%rbp),%edx
mov    %eax,%ecx
mov    -0xdc(%rbp),%eax
imul   $0x3,%ecx,%ecx
and    %ecx,%eax
add    %eax,%edx
mov    -0x20(%rbp),%rax
mov    (%rax),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xf0(%rbp)
mov    $0x2,%edi
mov    $0xc,%esi
mov    $0x0,%al
call   1030 <pow2@plt>
mov    %eax,%ecx
mov    -0xf0(%rbp),%eax
and    %ecx,%eax
mov    %eax,-0xe8(%rbp)
mov    -0x20(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xec(%rbp)
mov    $0x2,%edi
mov    $0xd,%esi
mov    $0x0,%al
call   1030 <pow2@plt>
mov    -0xec(%rbp),%ecx
mov    %eax,%edx
mov    -0xe8(%rbp),%eax
and    %edx,%ecx
cmp    %ecx,%eax
jne    1e3c <init_flag+0xcdc>
xor    %edi,%edi
mov    $0x0,%al
call   1070 <getbit@plt>
mov    %eax,-0xf8(%rbp)
mov    -0x20(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xf4(%rbp)
mov    $0x2,%edi
mov    $0xc,%esi
mov    $0x0,%al
call   1030 <pow2@plt>
mov    -0xf8(%rbp),%edx
mov    %eax,%ecx
mov    -0xf4(%rbp),%eax
imul   $0xf,%ecx,%ecx
and    %ecx,%eax
add    %eax,%edx
mov    -0x20(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1ed7 <init_flag+0xd77>
mov    0x10(%rbp),%edi
mov    $0x0,%al
call   1070 <getbit@plt>
mov    %eax,-0x104(%rbp)
mov    $0x2,%edi
mov    $0x8,%esi
mov    $0x0,%al
call   1030 <pow2@plt>
mov    %eax,%ecx
mov    -0x104(%rbp),%eax
imul   $0x3,%ecx,%ecx
sub    %ecx,%eax
mov    %eax,-0x100(%rbp)
mov    -0x20(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xfc(%rbp)
mov    $0x2,%edi
mov    $0x8,%esi
mov    $0x0,%al
call   1030 <pow2@plt>
mov    -0x100(%rbp),%edx
mov    %eax,%ecx
mov    -0xfc(%rbp),%eax
imul   $0x3,%ecx,%ecx
and    %ecx,%eax
add    %eax,%edx
mov    -0x20(%rbp),%rax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1edc <init_flag+0xd7c>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1bab <init_flag+0xa4b>
jmp    1eef <init_flag+0xd8f>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1b98 <init_flag+0xa38>
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     21d6 <init_flag+0x1076>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     21c3 <init_flag+0x1063>
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x8(%rax),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x110(%rbp)
mov    $0x2,%edi
mov    $0xc,%esi
mov    $0x0,%al
call   1030 <pow2@plt>
mov    %eax,%ecx
mov    -0x110(%rbp),%eax
and    %ecx,%eax
mov    %eax,-0x108(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x8(%rax),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x10c(%rbp)
mov    $0x2,%edi
mov    $0xd,%esi
mov    $0x0,%al
call   1030 <pow2@plt>
mov    -0x10c(%rbp),%ecx
mov    %eax,%edx
mov    -0x108(%rbp),%eax
and    %edx,%ecx
cmp    %ecx,%eax
jne    2014 <init_flag+0xeb4>
xor    %edi,%edi
mov    $0x0,%al
call   1070 <getbit@plt>
mov    %eax,-0x118(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x8(%rax),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x114(%rbp)
mov    $0x2,%edi
mov    $0xc,%esi
mov    $0x0,%al
call   1030 <pow2@plt>
mov    -0x118(%rbp),%edx
mov    %eax,%ecx
mov    -0x114(%rbp),%eax
imul   $0xf,%ecx,%ecx
and    %ecx,%eax
add    %eax,%edx
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    (%rax),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    205a <init_flag+0xefa>
mov    0x18(%rbp),%edi
mov    $0x0,%al
call   1070 <getbit@plt>
mov    %eax,%edx
sub    $0xc0,%edx
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x8(%rax),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
and    $0xc0,%eax
add    %eax,%edx
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    (%rax),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x124(%rbp)
mov    $0x2,%edi
mov    $0xc,%esi
mov    $0x0,%al
call   1030 <pow2@plt>
mov    %eax,%ecx
mov    -0x124(%rbp),%eax
and    %ecx,%eax
mov    %eax,-0x11c(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x120(%rbp)
mov    $0x2,%edi
mov    $0xd,%esi
mov    $0x0,%al
call   1030 <pow2@plt>
mov    -0x120(%rbp),%ecx
mov    %eax,%edx
mov    -0x11c(%rbp),%eax
and    %edx,%ecx
cmp    %ecx,%eax
jne    2161 <init_flag+0x1001>
xor    %edi,%edi
mov    $0x0,%al
call   1070 <getbit@plt>
mov    %eax,-0x12c(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x128(%rbp)
mov    $0x2,%edi
mov    $0xc,%esi
mov    $0x0,%al
call   1030 <pow2@plt>
mov    -0x12c(%rbp),%edx
mov    %eax,%ecx
mov    -0x128(%rbp),%eax
imul   $0xf,%ecx,%ecx
and    %ecx,%eax
add    %eax,%edx
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    21b0 <init_flag+0x1050>
mov    0x20(%rbp),%edi
mov    $0x0,%al
call   1070 <getbit@plt>
mov    %eax,%edx
sub    $0x30,%edx
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
and    $0x30,%eax
add    %eax,%edx
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    21b5 <init_flag+0x1055>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1f17 <init_flag+0xdb7>
jmp    21c8 <init_flag+0x1068>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1f04 <init_flag+0xda4>
add    $0x130,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<init_flag>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x98,%rsp
mov    %r9d,0x64(%rsp)
mov    %r8,%r12
mov    %ecx,%r14d
mov    %edx,%ebp
mov    %esi,%ebx
xor    %eax,%eax
call   1050 <read_pgm@plt>
test   %r14d,%r14d
mov    %r12,0x10(%rsp)
mov    %r14,0x48(%rsp)
mov    %rbx,0x18(%rsp)
mov    %rbp,0x20(%rsp)
jle    1523 <init_flag+0x3c3>
movslq %eax,%r12
lea    0x1(%rbp),%eax
mov    %rax,0x68(%rsp)
lea    0x2(%rbp),%eax
lea    0x1(%rbx),%ecx
mov    %rcx,0x50(%rsp)
cltq
mov    %rax,0x70(%rsp)
lea    0x1(%r14),%eax
mov    %rax,0x40(%rsp)
mov    $0x1,%eax
mov    %rax,0x28(%rsp)
jmp    1202 <init_flag+0xa2>
cs nopw 0x0(%rax,%rax,1)
mov    0x78(%rsp),%rcx
mov    %rcx,%rax
mov    %rcx,0x28(%rsp)
mov    0x48(%rsp),%r14
mov    0x20(%rsp),%rbp
cmp    0x40(%rsp),%rcx
je     151c <init_flag+0x3bc>
test   %ebp,%ebp
jle    1500 <init_flag+0x3a0>
mov    0x28(%rsp),%rcx
mov    %rcx,%rdx
mov    0x70(%rsp),%rax
imul   %rax,%rdx
mov    %rdx,0x90(%rsp)
lea    -0x1(%rcx),%rdx
imul   %rax,%rdx
mov    %rdx,0x88(%rsp)
add    $0x1,%rcx
mov    %rcx,0x78(%rsp)
imul   %rax,%rcx
mov    %rcx,0x80(%rsp)
mov    $0x1,%eax
mov    %rax,0x58(%rsp)
jmp    127e <init_flag+0x11e>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x58(%rsp),%rax
add    $0x1,%rax
mov    %rax,0x58(%rsp)
cmp    0x68(%rsp),%rax
mov    0x18(%rsp),%rbx
je     11e0 <init_flag+0x80>
test   %ebx,%ebx
jle    1260 <init_flag+0x100>
mov    0x90(%rsp),%rax
mov    0x58(%rsp),%rcx
lea    (%rcx,%rax,1),%r13
mov    0x88(%rsp),%rax
add    %rcx,%rax
mov    %rax,0x8(%rsp)
mov    0x80(%rsp),%rax
add    %rcx,%rax
mov    %rax,0x30(%rsp)
mov    0x68(%rsp),%rax
sub    %ecx,%eax
cltq
mov    %rax,0x38(%rsp)
mov    $0x1,%ebx
jmp    12f5 <init_flag+0x195>
nopl   0x0(%rax,%rax,1)
mov    0x10(%rsp),%rax
mov    (%rax,%r14,8),%rax
mov    0x38(%rsp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x28(%rsp),%rcx
mov    %ebp,(%rax,%rcx,4)
cmp    %rbx,0x50(%rsp)
je     1260 <init_flag+0x100>
mov    %rbx,%r14
mov    (%r12,%rbx,8),%rax
movslq (%rax,%r13,4),%rbp
mov    $0x2,%edi
mov    $0xc,%esi
xor    %eax,%eax
call   1030 <pow2@plt>
mov    %eax,%ebx
lea    0xce6(%rip),%rax
imul   (%rax,%rbp,4),%ebx
mov    0x8(%r12,%r14,8),%rax
mov    (%rax,%r13,4),%edi
add    $0x1,%edi
mov    $0x3,%esi
xor    %eax,%eax
call   1060 <min@plt>
mov    %eax,%ebp
mov    $0x2,%edi
mov    $0xa,%esi
xor    %eax,%eax
call   1030 <pow2@plt>
mov    %eax,%r15d
imul   %ebp,%r15d
add    %ebx,%r15d
mov    -0x8(%r12,%r14,8),%rax
mov    (%rax,%r13,4),%edi
add    $0x1,%edi
mov    $0x3,%esi
xor    %eax,%eax
call   1060 <min@plt>
mov    %eax,%ebx
mov    $0x2,%edi
mov    $0x8,%esi
xor    %eax,%eax
call   1030 <pow2@plt>
mov    %eax,%ebp
imul   %ebx,%ebp
add    %r15d,%ebp
mov    (%r12,%r14,8),%rax
mov    -0x4(%rax,%r13,4),%edi
add    $0x1,%edi
mov    $0x3,%esi
xor    %eax,%eax
call   1060 <min@plt>
mov    %eax,%r15d
mov    $0x2,%edi
mov    $0x6,%esi
xor    %eax,%eax
call   1030 <pow2@plt>
mov    %eax,%ebx
imul   %r15d,%ebx
add    %ebp,%ebx
mov    (%r12,%r14,8),%rax
mov    0x4(%rax,%r13,4),%edi
add    $0x1,%edi
mov    $0x3,%esi
xor    %eax,%eax
call   1060 <min@plt>
mov    %eax,%r15d
mov    $0x2,%edi
mov    $0x4,%esi
xor    %eax,%eax
call   1030 <pow2@plt>
mov    %eax,%ebp
imul   %r15d,%ebp
add    %ebx,%ebp
mov    (%r12,%r14,8),%rax
mov    0x8(%rsp),%rcx
mov    (%rax,%rcx,4),%edi
add    $0x1,%edi
mov    $0x3,%esi
xor    %eax,%eax
call   1060 <min@plt>
lea    0x0(%rbp,%rax,4),%ebx
mov    (%r12,%r14,8),%rax
mov    0x30(%rsp),%rcx
mov    (%rax,%rcx,4),%edi
add    $0x1,%edi
mov    $0x3,%esi
xor    %eax,%eax
call   1060 <min@plt>
mov    %eax,%ebp
add    %ebx,%ebp
mov    (%r12,%r14,8),%rax
cmpl   $0x2,(%rax,%r13,4)
jl     148e <init_flag+0x32e>
mov    -0x4(%rax,%r13,4),%edi
add    0x4(%rax,%r13,4),%edi
mov    -0x8(%r12,%r14,8),%rax
mov    0x8(%r12,%r14,8),%rcx
mov    (%rcx,%r13,4),%esi
add    (%rax,%r13,4),%esi
xor    %eax,%eax
call   1060 <min@plt>
test   %eax,%eax
je     1474 <init_flag+0x314>
mov    (%r12,%r14,8),%rax
mov    0x8(%rsp),%rcx
mov    (%rax,%rcx,4),%ecx
mov    0x30(%rsp),%rdx
add    (%rax,%rdx,4),%ecx
jne    148e <init_flag+0x32e>
mov    $0xf6,%edi
lea    0xb9c(%rip),%rsi
lea    0xc30(%rip),%rdx
xor    %eax,%eax
call   1040 <errhandler@plt>
lea    0x1(%r14),%rbx
mov    %ebp,%edi
xor    %eax,%eax
call   1080 <getcelltype@plt>
mov    %ebp,%ecx
and    $0xf000,%ecx
cmp    $0x8000,%ecx
jne    12d0 <init_flag+0x170>
lea    0xf(%rax),%ecx
test   %eax,%eax
cmovns %eax,%ecx
and    $0xfffffff0,%ecx
sub    %ecx,%eax
cmp    $0xa,%eax
ja     12d0 <init_flag+0x170>
mov    $0x660,%ecx
bt     %eax,%ecx
jae    12d0 <init_flag+0x170>
mov    $0xfa,%edi
lea    0xb3d(%rip),%rsi
lea    0xbd1(%rip),%rdx
xor    %eax,%eax
call   1040 <errhandler@plt>
jmp    12d0 <init_flag+0x170>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x28(%rsp),%rcx
add    $0x1,%rcx
mov    %rcx,%rax
mov    %rcx,0x28(%rsp)
cmp    0x40(%rsp),%rcx
jne    1202 <init_flag+0xa2>
mov    0x10(%rsp),%r12
jmp    152c <init_flag+0x3cc>
lea    0x1(%r14),%eax
mov    %rax,0x40(%rsp)
mov    0xd8(%rsp),%edx
cmp    $0xffffffff,%r14d
jl     15da <init_flag+0x47a>
mov    0x20(%rsp),%rax
add    $0x1,%eax
movslq %eax,%r15
mov    0x18(%rsp),%rax
add    $0x1,%eax
movslq %eax,%rbp
mov    0x48(%rsp),%rax
add    $0x2,%eax
mov    %rax,0x8(%rsp)
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %edx,%r14d
mov    %edx,%edi
xor    %eax,%eax
call   1070 <getbit@plt>
mov    (%r12),%rcx
mov    (%rcx),%rcx
mov    %eax,(%rcx,%rbx,4)
mov    0xe0(%rsp),%r13d
mov    %r13d,%edi
xor    %eax,%eax
call   1070 <getbit@plt>
mov    (%r12),%rcx
mov    (%rcx,%r15,8),%rcx
mov    %eax,(%rcx,%rbx,4)
mov    %r14d,%edi
xor    %eax,%eax
call   1070 <getbit@plt>
mov    (%r12,%rbp,8),%rcx
mov    (%rcx),%rcx
mov    %eax,(%rcx,%rbx,4)
mov    %r13d,%edi
xor    %eax,%eax
call   1070 <getbit@plt>
mov    %r14d,%edx
mov    (%r12,%rbp,8),%rcx
mov    (%rcx,%r15,8),%rcx
mov    %eax,(%rcx,%rbx,4)
add    $0x1,%rbx
cmp    %rbx,0x8(%rsp)
jne    1570 <init_flag+0x410>
mov    0xf0(%rsp),%r13d
cmpl   $0xffffffff,0x20(%rsp)
jl     1677 <init_flag+0x517>
movslq 0x40(%rsp),%r15
mov    0x18(%rsp),%rax
add    $0x1,%eax
movslq %eax,%rbp
mov    0x20(%rsp),%rax
add    $0x2,%eax
mov    %rax,0x8(%rsp)
xor    %ebx,%ebx
nopl   0x0(%rax)
mov    %r13d,%edi
xor    %eax,%eax
call   1070 <getbit@plt>
mov    (%r12),%rcx
mov    (%rcx,%rbx,8),%rcx
mov    %eax,(%rcx)
mov    0xe8(%rsp),%r14d
mov    %r14d,%edi
xor    %eax,%eax
call   1070 <getbit@plt>
mov    (%r12),%rcx
mov    (%rcx,%rbx,8),%rcx
mov    %eax,(%rcx,%r15,4)
mov    %r13d,%edi
xor    %eax,%eax
call   1070 <getbit@plt>
mov    (%r12,%rbp,8),%rcx
mov    (%rcx,%rbx,8),%rcx
mov    %eax,(%rcx)
mov    %r14d,%edi
xor    %eax,%eax
call   1070 <getbit@plt>
mov    (%r12,%rbp,8),%rcx
mov    (%rcx,%rbx,8),%rcx
mov    %eax,(%rcx,%r15,4)
add    $0x1,%rbx
cmp    %rbx,0x8(%rsp)
jne    1610 <init_flag+0x4b0>
mov    0x18(%rsp),%rax
cmp    $0xffffffff,%eax
jl     1916 <init_flag+0x7b6>
movb   $0x1,0x50(%rsp)
mov    0x20(%rsp),%rcx
lea    0x1(%rcx),%edx
mov    %rdx,%rcx
mov    %rdx,0x28(%rsp)
movslq %edx,%rcx
mov    %rcx,0x8(%rsp)
movslq 0x40(%rsp),%r14
mov    %r12,%rbp
add    $0x2,%eax
mov    %rax,0x30(%rsp)
xor    %ebx,%ebx
mov    0xe0(%rsp),%r13d
mov    0xd8(%rsp),%r15d
mov    0x8(%rsp),%r12
nopl   0x0(%rax)
mov    %r15d,%edi
xor    %eax,%eax
call   1070 <getbit@plt>
mov    0x0(%rbp,%rbx,8),%rcx
mov    (%rcx),%rcx
mov    %eax,(%rcx)
mov    %r13d,%edi
xor    %eax,%eax
call   1070 <getbit@plt>
mov    0x0(%rbp,%rbx,8),%rcx
mov    (%rcx,%r12,8),%rcx
mov    %eax,(%rcx)
mov    %r15d,%edi
xor    %eax,%eax
call   1070 <getbit@plt>
mov    0x0(%rbp,%rbx,8),%rcx
mov    (%rcx),%rcx
mov    %eax,(%rcx,%r14,4)
mov    %r13d,%edi
xor    %eax,%eax
call   1070 <getbit@plt>
mov    0x0(%rbp,%rbx,8),%rcx
mov    (%rcx,%r12,8),%rcx
mov    %eax,(%rcx,%r14,4)
add    $0x1,%rbx
cmp    %rbx,0x30(%rsp)
jne    16d0 <init_flag+0x570>
mov    %r14,0x8(%rsp)
cmpl   $0x0,0x18(%rsp)
setle  %al
mov    %rbp,%r12
jle    1922 <init_flag+0x7c2>
mov    %al,0x50(%rsp)
movslq 0x48(%rsp),%r14
mov    0x18(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x38(%rsp)
mov    0x28(%rsp),%rax
lea    -0x8(,%rax,8),%rax
ff
mov    %rax,0x30(%rsp)
mov    $0x1,%r12d
jmp    178f <init_flag+0x62f>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r12
cmp    0x38(%rsp),%r12
je     191d <init_flag+0x7bd>
cmpl   $0x0,0x20(%rsp)
jle    1780 <init_flag+0x620>
mov    0x10(%rsp),%rax
mov    (%rax,%r12,8),%rcx
xor    %r13d,%r13d
jmp    17e6 <init_flag+0x686>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0xe8(%rsp),%edi
xor    %eax,%eax
call   1070 <getbit@plt>
mov    (%r15,%r12,8),%rcx
mov    0x8(%rcx,%r13,1),%rdx
mov    (%rdx,%r14,4),%esi
and    $0xc,%esi
add    %esi,%eax
add    $0xfffffff4,%eax
mov    0x8(%rsp),%rsi
mov    %eax,(%rdx,%rsi,4)
add    $0x8,%r13
cmp    %r13,0x30(%rsp)
je     1780 <init_flag+0x620>
mov    0x8(%rcx,%r13,1),%rax
mov    0x4(%rax),%r15d
mov    $0x2,%edi
mov    $0xc,%esi
xor    %eax,%eax
call   1030 <pow2@plt>
mov    %eax,%ebx
and    %r15d,%ebx
mov    0x10(%rsp),%r15
mov    (%r15,%r12,8),%rax
mov    0x8(%rax,%r13,1),%rax
mov    0x4(%rax),%ebp
mov    $0x2,%edi
mov    $0xd,%esi
xor    %eax,%eax
call   1030 <pow2@plt>
and    %ebp,%eax
cmp    %eax,%ebx
jne    1870 <init_flag+0x710>
xor    %edi,%edi
xor    %eax,%eax
call   1070 <getbit@plt>
mov    %eax,%ebx
mov    (%r15,%r12,8),%rax
mov    0x8(%rax,%r13,1),%rax
mov    0x4(%rax),%ebp
mov    $0x2,%edi
mov    $0xc,%esi
xor    %eax,%eax
call   1030 <pow2@plt>
lea    (%rax,%rax,4),%eax
lea    (%rax,%rax,2),%eax
and    %ebp,%eax
add    %ebx,%eax
mov    (%r15,%r12,8),%rcx
mov    0x8(%rcx,%r13,1),%rcx
jmp    1892 <init_flag+0x732>
nopw   0x0(%rax,%rax,1)
mov    0xf0(%rsp),%edi
xor    %eax,%eax
call   1070 <getbit@plt>
mov    (%r15,%r12,8),%rcx
mov    0x8(%rcx,%r13,1),%rcx
mov    0x4(%rcx),%edx
and    $0x3,%edx
add    %edx,%eax
add    $0xfffffffd,%eax
mov    %eax,(%rcx)
mov    (%rcx,%r14,4),%ebp
mov    $0x2,%edi
mov    $0xc,%esi
xor    %eax,%eax
call   1030 <pow2@plt>
mov    %eax,%ebx
and    %ebp,%ebx
mov    (%r15,%r12,8),%rax
mov    0x8(%rax,%r13,1),%rax
mov    (%rax,%r14,4),%ebp
mov    $0x2,%edi
mov    $0xd,%esi
xor    %eax,%eax
call   1030 <pow2@plt>
and    %ebp,%eax
cmp    %eax,%ebx
jne    17b0 <init_flag+0x650>
xor    %edi,%edi
xor    %eax,%eax
call   1070 <getbit@plt>
mov    %eax,%ebx
mov    (%r15,%r12,8),%rax
mov    0x8(%rax,%r13,1),%rax
mov    (%rax,%r14,4),%ebp
mov    $0x2,%edi
mov    $0xc,%esi
xor    %eax,%eax
call   1030 <pow2@plt>
lea    (%rax,%rax,4),%eax
lea    (%rax,%rax,2),%eax
and    %ebp,%eax
add    %ebx,%eax
mov    (%r15,%r12,8),%rcx
mov    0x8(%rcx,%r13,1),%rdx
jmp    17d3 <init_flag+0x673>
movb   $0x1,0x50(%rsp)
jmp    1922 <init_flag+0x7c2>
mov    0x10(%rsp),%r12
mov    0x40(%rsp),%eax
mov    %rax,0x38(%rsp)
cmpl   $0x0,0x20(%rsp)
jle    1b5d <init_flag+0x9fd>
mov    0x18(%rsp),%rax
movslq %eax,%r14
add    $0x1,%eax
cltq
mov    %rax,0x8(%rsp)
mov    0x20(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x28(%rsp)
mov    0x38(%rsp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,0x30(%rsp)
mov    $0x1,%r15d
jmp    197f <init_flag+0x81f>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r15
cmp    0x28(%rsp),%r15
je     1b5d <init_flag+0x9fd>
cmpl   $0x0,0x48(%rsp)
jle    1970 <init_flag+0x810>
xor    %r13d,%r13d
jmp    1a02 <init_flag+0x8a2>
nopl   0x0(%rax,%rax,1)
mov    0xd0(%rsp),%edi
xor    %eax,%eax
call   1070 <getbit@plt>
mov    %eax,%ebp
mov    $0x2,%edi
mov    $0x8,%esi
xor    %eax,%eax
call   1030 <pow2@plt>
lea    (%rax,%rax,2),%eax
sub    %eax,%ebp
mov    (%r12,%r14,8),%rax
mov    (%rax,%r15,8),%rax
mov    0x4(%rax,%r13,4),%r12d
mov    $0x2,%edi
mov    $0x8,%esi
xor    %eax,%eax
call   1030 <pow2@plt>
lea    (%rax,%rax,2),%ebx
and    %r12d,%ebx
mov    0x10(%rsp),%r12
add    %ebp,%ebx
mov    0x8(%rsp),%rax
mov    (%r12,%rax,8),%rax
mov    (%rax,%r15,8),%rax
mov    %ebx,0x4(%rax,%r13,4)
add    $0x1,%r13
cmp    %r13,0x30(%rsp)
je     1970 <init_flag+0x810>
mov    0x8(%r12),%rax
mov    (%rax,%r15,8),%rax
mov    0x4(%rax,%r13,4),%ebp
mov    $0x2,%edi
mov    $0xc,%esi
xor    %eax,%eax
call   1030 <pow2@plt>
mov    %eax,%ebx
and    %ebp,%ebx
mov    0x8(%r12),%rax
mov    (%rax,%r15,8),%rax
mov    0x4(%rax,%r13,4),%ebp
mov    $0x2,%edi
mov    $0xd,%esi
xor    %eax,%eax
call   1030 <pow2@plt>
and    %ebp,%eax
cmp    %eax,%ebx
jne    1a80 <init_flag+0x920>
xor    %edi,%edi
xor    %eax,%eax
call   1070 <getbit@plt>
mov    %eax,%ebx
mov    0x8(%r12),%rax
mov    (%rax,%r15,8),%rax
mov    0x4(%rax,%r13,4),%r12d
mov    $0x2,%edi
mov    $0xc,%esi
xor    %eax,%eax
call   1030 <pow2@plt>
lea    (%rax,%rax,4),%eax
lea    (%rax,%rax,2),%ebp
and    %r12d,%ebp
jmp    1ac8 <init_flag+0x968>
nop
mov    0x64(%rsp),%edi
xor    %eax,%eax
call   1070 <getbit@plt>
mov    %eax,%ebp
mov    $0x2,%edi
mov    $0xa,%esi
xor    %eax,%eax
call   1030 <pow2@plt>
lea    (%rax,%rax,2),%eax
sub    %eax,%ebp
mov    0x8(%r12),%rax
mov    (%rax,%r15,8),%rax
mov    0x4(%rax,%r13,4),%r12d
mov    $0x2,%edi
mov    $0xa,%esi
xor    %eax,%eax
call   1030 <pow2@plt>
lea    (%rax,%rax,2),%ebx
and    %r12d,%ebx
mov    0x10(%rsp),%r12
add    %ebp,%ebx
mov    (%r12),%rax
mov    (%rax,%r15,8),%rax
mov    %ebx,0x4(%rax,%r13,4)
mov    (%r12,%r14,8),%rax
mov    (%rax,%r15,8),%rax
mov    0x4(%rax,%r13,4),%ebp
mov    $0x2,%edi
mov    $0xc,%esi
xor    %eax,%eax
call   1030 <pow2@plt>
mov    %eax,%ebx
and    %ebp,%ebx
mov    (%r12,%r14,8),%rax
mov    (%rax,%r15,8),%rax
mov    0x4(%rax,%r13,4),%ebp
mov    $0x2,%edi
mov    $0xd,%esi
xor    %eax,%eax
call   1030 <pow2@plt>
and    %ebp,%eax
cmp    %eax,%ebx
jne    1990 <init_flag+0x830>
xor    %edi,%edi
xor    %eax,%eax
call   1070 <getbit@plt>
mov    %eax,%ebx
mov    (%r12,%r14,8),%rax
mov    (%rax,%r15,8),%rax
mov    0x4(%rax,%r13,4),%r12d
mov    $0x2,%edi
mov    $0xc,%esi
xor    %eax,%eax
call   1030 <pow2@plt>
lea    (%rax,%rax,4),%eax
lea    (%rax,%rax,2),%ebp
and    %r12d,%ebp
jmp    19da <init_flag+0x87a>
cmpb   $0x0,0x50(%rsp)
je     1b76 <init_flag+0xa16>
add    $0x98,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0x20(%rsp),%rax
movslq %eax,%r15
add    $0x1,%eax
cltq
mov    %rax,0x8(%rsp)
mov    0x18(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x18(%rsp)
addq   $0xffffffffffffffff,0x38(%rsp)
mov    $0x1,%r13d
mov    0x10(%rsp),%r14
jmp    1bbb <init_flag+0xa5b>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r13
cmp    0x18(%rsp),%r13
je     1b64 <init_flag+0xa04>
cmpl   $0x0,0x48(%rsp)
jle    1bb0 <init_flag+0xa50>
mov    0x10(%rsp),%rax
mov    (%rax,%r13,8),%rcx
xor    %ebp,%ebp
jmp    1c0a <init_flag+0xaaa>
nop
mov    0xe0(%rsp),%edi
xor    %eax,%eax
call   1070 <getbit@plt>
mov    (%r14,%r13,8),%rcx
mov    (%rcx,%r15,8),%rdx
mov    0x4(%rdx,%rbp,4),%edx
and    $0x30,%edx
add    %edx,%eax
add    $0xffffffd0,%eax
mov    0x8(%rsp),%rdx
mov    (%rcx,%rdx,8),%rdx
mov    %eax,0x4(%rdx,%rbp,4)
add    $0x1,%rbp
cmp    %rbp,0x38(%rsp)
je     1bb0 <init_flag+0xa50>
mov    0x8(%rcx),%rax
mov    0x4(%rax,%rbp,4),%r12d
mov    $0x2,%edi
mov    $0xc,%esi
xor    %eax,%eax
call   1030 <pow2@plt>
mov    %eax,%ebx
and    %r12d,%ebx
mov    (%r14,%r13,8),%rax
mov    0x8(%rax),%rax
mov    0x4(%rax,%rbp,4),%r12d
mov    $0x2,%edi
mov    $0xd,%esi
xor    %eax,%eax
call   1030 <pow2@plt>
and    %r12d,%eax
cmp    %eax,%ebx
jne    1c90 <init_flag+0xb30>
xor    %edi,%edi
xor    %eax,%eax
call   1070 <getbit@plt>
mov    %eax,%r12d
mov    (%r14,%r13,8),%rax
mov    0x8(%rax),%rax
mov    0x4(%rax,%rbp,4),%ebx
mov    $0x2,%edi
mov    $0xc,%esi
xor    %eax,%eax
call   1030 <pow2@plt>
lea    (%rax,%rax,4),%eax
lea    (%rax,%rax,2),%eax
and    %ebx,%eax
add    %r12d,%eax
mov    (%r14,%r13,8),%rcx
jmp    1cb8 <init_flag+0xb58>
nopl   0x0(%rax,%rax,1)
mov    0xd8(%rsp),%edi
xor    %eax,%eax
call   1070 <getbit@plt>
mov    (%r14,%r13,8),%rcx
mov    0x8(%rcx),%rdx
mov    0x4(%rdx,%rbp,4),%edx
mov    $0xc0,%esi
and    %esi,%edx
add    %edx,%eax
add    $0xffffff40,%eax
mov    (%rcx),%rdx
mov    %eax,0x4(%rdx,%rbp,4)
mov    (%rcx,%r15,8),%rax
mov    0x4(%rax,%rbp,4),%r12d
mov    $0x2,%edi
mov    $0xc,%esi
xor    %eax,%eax
call   1030 <pow2@plt>
mov    %eax,%ebx
and    %r12d,%ebx
mov    (%r14,%r13,8),%rax
mov    (%rax,%r15,8),%rax
mov    0x4(%rax,%rbp,4),%r12d
mov    $0x2,%edi
mov    $0xd,%esi
xor    %eax,%eax
call   1030 <pow2@plt>
and    %r12d,%eax
cmp    %eax,%ebx
jne    1bd0 <init_flag+0xa70>
xor    %edi,%edi
xor    %eax,%eax
call   1070 <getbit@plt>
mov    %eax,%r12d
mov    (%r14,%r13,8),%rax
mov    (%rax,%r15,8),%rax
mov    0x4(%rax,%rbp,4),%ebx
mov    $0x2,%edi
mov    $0xc,%esi
xor    %eax,%eax
call   1030 <pow2@plt>
lea    (%rax,%rax,4),%eax
lea    (%rax,%rax,2),%eax
and    %ebx,%eax
add    %r12d,%eax
mov    (%r14,%r13,8),%rcx
jmp    1bf2 <init_flag+0xa92>

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

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