#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ errhandler(int, char *, char *);
int getbit(int);
int getcelltype(int);
int min(int, int);
int pow2(int, int);
int **read_pgm(char *);
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(217,
                     "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/"
                     "outputs/2022-01-22/02-19-57/repos/EvaBr/CFD-Lab/refs/"
                     "heads/master/Backup/FinalProjectPresentation/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(221,
                     "/scratch/repos/new/home/jordi_armengol_estape/c-scraper/"
                     "outputs/2022-01-22/02-19-57/repos/EvaBr/CFD-Lab/refs/"
                     "heads/master/Backup/FinalProjectPresentation/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
call   1050 <read_pgm@plt>
mov    %rax,-0x68(%rbp)
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1655 <init_flag+0x4f5>
movl   $0x1,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    1642 <init_flag+0x4e2>
movl   $0x1,-0x70(%rbp)
mov    -0x70(%rbp),%eax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    162f <init_flag+0x4cf>
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
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
call   1060 <min@plt>
mov    %eax,-0x98(%rbp)
mov    $0x2,%edi
mov    $0xa,%esi
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
call   1060 <min@plt>
mov    %eax,-0x90(%rbp)
mov    $0x2,%edi
mov    $0x8,%esi
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
call   1060 <min@plt>
mov    %eax,-0x88(%rbp)
mov    $0x2,%edi
mov    $0x6,%esi
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
call   1060 <min@plt>
mov    %eax,-0x80(%rbp)
mov    $0x2,%edi
mov    $0x4,%esi
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
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
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    1596 <init_flag+0x436>
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
call   1060 <min@plt>
cmp    $0x0,%eax
je     157e <init_flag+0x41e>
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    1596 <init_flag+0x436>
mov    $0xd9,%edi
lea    0x1a92(%rip),%rsi
lea    0x1b2c(%rip),%rdx
call   1040 <errhandler@plt>
mov    -0x34(%rbp),%edi
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    15fb <init_flag+0x49b>
cmpl   $0x5,-0x38(%rbp)
je     15e3 <init_flag+0x483>
cmpl   $0x6,-0x38(%rbp)
je     15e3 <init_flag+0x483>
cmpl   $0x9,-0x38(%rbp)
je     15e3 <init_flag+0x483>
cmpl   $0xa,-0x38(%rbp)
jne    15fb <init_flag+0x49b>
mov    $0xdd,%edi
lea    0x1a2d(%rip),%rsi
lea    0x1ac7(%rip),%rdx
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    11fd <init_flag+0x9d>
jmp    1634 <init_flag+0x4d4>
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    11e5 <init_flag+0x85>
jmp    1647 <init_flag+0x4e7>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11cd <init_flag+0x6d>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x14(%rbp),%ecx
add    $0x2,%ecx
cmp    %ecx,%eax
jge    170f <init_flag+0x5af>
mov    0x18(%rbp),%edi
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
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
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
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    165c <init_flag+0x4fc>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x10(%rbp),%ecx
add    $0x2,%ecx
cmp    %ecx,%eax
jge    17c9 <init_flag+0x669>
mov    0x30(%rbp),%edi
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
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
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
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    1716 <init_flag+0x5b6>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0xc(%rbp),%ecx
add    $0x2,%ecx
cmp    %ecx,%eax
jge    1883 <init_flag+0x723>
mov    0x18(%rbp),%edi
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
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
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
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    17d0 <init_flag+0x670>
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     1b43 <init_flag+0x9e3>
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     1b30 <init_flag+0x9d0>
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
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
call   1030 <pow2@plt>
mov    -0xa4(%rbp),%ecx
mov    %eax,%edx
mov    -0xa0(%rbp),%eax
and    %edx,%ecx
cmp    %ecx,%eax
jne    1992 <init_flag+0x832>
xor    %edi,%edi
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
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    19d1 <init_flag+0x871>
mov    0x30(%rbp),%edi
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
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
call   1030 <pow2@plt>
mov    -0xb8(%rbp),%ecx
mov    %eax,%edx
mov    -0xb4(%rbp),%eax
and    %edx,%ecx
cmp    %ecx,%eax
jne    1ad0 <init_flag+0x970>
xor    %edi,%edi
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
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    1b1d <init_flag+0x9bd>
mov    0x28(%rbp),%edi
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    1b22 <init_flag+0x9c2>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    189d <init_flag+0x73d>
jmp    1b35 <init_flag+0x9d5>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    188a <init_flag+0x72a>
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     1e93 <init_flag+0xd33>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1e80 <init_flag+0xd20>
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
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
call   1030 <pow2@plt>
mov    -0xcc(%rbp),%ecx
mov    %eax,%edx
mov    -0xc8(%rbp),%eax
and    %edx,%ecx
cmp    %ecx,%eax
jne    1c52 <init_flag+0xaf2>
xor    %edi,%edi
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
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    1cd9 <init_flag+0xb79>
mov    -0x24(%rbp),%edi
call   1070 <getbit@plt>
mov    %eax,-0xe4(%rbp)
mov    $0x2,%edi
mov    $0xa,%esi
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
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
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
call   1030 <pow2@plt>
mov    -0xec(%rbp),%ecx
mov    %eax,%edx
mov    -0xe8(%rbp),%eax
and    %edx,%ecx
cmp    %ecx,%eax
jne    1dd8 <init_flag+0xc78>
xor    %edi,%edi
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
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    1e6d <init_flag+0xd0d>
mov    0x10(%rbp),%edi
call   1070 <getbit@plt>
mov    %eax,-0x104(%rbp)
mov    $0x2,%edi
mov    $0x8,%esi
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
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    1e72 <init_flag+0xd12>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1b5d <init_flag+0x9fd>
jmp    1e85 <init_flag+0xd25>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1b4a <init_flag+0x9ea>
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     2158 <init_flag+0xff8>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     2145 <init_flag+0xfe5>
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
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
call   1030 <pow2@plt>
mov    -0x10c(%rbp),%ecx
mov    %eax,%edx
mov    -0x108(%rbp),%eax
and    %edx,%ecx
cmp    %ecx,%eax
jne    1fa2 <init_flag+0xe42>
xor    %edi,%edi
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
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    1fe6 <init_flag+0xe86>
mov    0x18(%rbp),%edi
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
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
call   1030 <pow2@plt>
mov    -0x120(%rbp),%ecx
mov    %eax,%edx
mov    -0x11c(%rbp),%eax
and    %edx,%ecx
cmp    %ecx,%eax
jne    20e5 <init_flag+0xf85>
xor    %edi,%edi
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
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    2132 <init_flag+0xfd2>
mov    0x20(%rbp),%edi
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    2137 <init_flag+0xfd7>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1ead <init_flag+0xd4d>
jmp    214a <init_flag+0xfea>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1e9a <init_flag+0xd3a>
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,0x10(%rsp)
mov    %ecx,%r14d
mov    %edx,%ebp
mov    %esi,%ebx
call   1050 <read_pgm@plt>
test   %r14d,%r14d
mov    %r14,0x48(%rsp)
mov    %rbx,0x18(%rsp)
mov    %rbp,0x20(%rsp)
jle    14f6 <init_flag+0x396>
mov    %rax,%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)
nopl   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     14ff <init_flag+0x39f>
test   %ebp,%ebp
jle    14e0 <init_flag+0x380>
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    12f6 <init_flag+0x196>
nopl   0x0(%rax,%rax,1)
mov    0x10(%rsp),%rax
mov    (%rax,%r15,8),%rax
mov    0x38(%rsp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x28(%rsp),%rcx
mov    %r14d,(%rax,%rcx,4)
cmp    %rbx,0x50(%rsp)
je     1260 <init_flag+0x100>
mov    %rbx,%r15
mov    (%r12,%rbx,8),%rax
movslq (%rax,%r13,4),%rbp
mov    $0x2,%edi
mov    $0xc,%esi
call   1030 <pow2@plt>
mov    %eax,%ebx
lea    0xce7(%rip),%rax
imul   (%rax,%rbp,4),%ebx
mov    0x8(%r12,%r15,8),%rax
mov    (%rax,%r13,4),%edi
add    $0x1,%edi
mov    $0x3,%esi
call   1060 <min@plt>
mov    %eax,%r14d
mov    $0x2,%edi
mov    $0xa,%esi
call   1030 <pow2@plt>
mov    %eax,%ebp
imul   %r14d,%ebp
add    %ebx,%ebp
mov    -0x8(%r12,%r15,8),%rax
mov    (%rax,%r13,4),%edi
add    $0x1,%edi
mov    $0x3,%esi
call   1060 <min@plt>
mov    %eax,%r14d
mov    $0x2,%edi
mov    $0x8,%esi
call   1030 <pow2@plt>
mov    %eax,%ebx
imul   %r14d,%ebx
add    %ebp,%ebx
mov    (%r12,%r15,8),%rax
mov    -0x4(%rax,%r13,4),%edi
add    $0x1,%edi
mov    $0x3,%esi
call   1060 <min@plt>
mov    %eax,%r14d
mov    $0x2,%edi
mov    $0x6,%esi
call   1030 <pow2@plt>
mov    %eax,%ebp
imul   %r14d,%ebp
add    %ebx,%ebp
mov    (%r12,%r15,8),%rax
mov    0x4(%rax,%r13,4),%edi
add    $0x1,%edi
mov    $0x3,%esi
call   1060 <min@plt>
mov    %eax,%r14d
mov    $0x2,%edi
mov    $0x4,%esi
call   1030 <pow2@plt>
mov    %eax,%ebx
imul   %r14d,%ebx
add    %ebp,%ebx
mov    (%r12,%r15,8),%rax
mov    0x8(%rsp),%rcx
mov    (%rax,%rcx,4),%edi
add    $0x1,%edi
mov    $0x3,%esi
call   1060 <min@plt>
lea    (%rbx,%rax,4),%ebx
mov    (%r12,%r15,8),%rax
mov    0x30(%rsp),%rcx
mov    (%rax,%rcx,4),%edi
add    $0x1,%edi
mov    $0x3,%esi
call   1060 <min@plt>
mov    %eax,%r14d
add    %ebx,%r14d
mov    (%r12,%r15,8),%rax
cmpl   $0x2,(%rax,%r13,4)
jl     1476 <init_flag+0x316>
mov    -0x4(%rax,%r13,4),%edi
add    0x4(%rax,%r13,4),%edi
mov    -0x8(%r12,%r15,8),%rax
mov    0x8(%r12,%r15,8),%rcx
mov    (%rcx,%r13,4),%esi
add    (%rax,%r13,4),%esi
call   1060 <min@plt>
test   %eax,%eax
je     145e <init_flag+0x2fe>
mov    (%r12,%r15,8),%rax
mov    0x8(%rsp),%rcx
mov    (%rax,%rcx,4),%ecx
mov    0x30(%rsp),%rdx
add    (%rax,%rdx,4),%ecx
jne    1476 <init_flag+0x316>
mov    $0xd9,%edi
lea    0xbb2(%rip),%rsi
lea    0xc4c(%rip),%rdx
call   1040 <errhandler@plt>
lea    0x1(%r15),%rbx
mov    %r14d,%edi
call   1080 <getcelltype@plt>
mov    %r14d,%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    $0xdd,%edi
lea    0xb55(%rip),%rsi
lea    0xbef(%rip),%rdx
call   1040 <errhandler@plt>
jmp    12d0 <init_flag+0x170>
nopl   0x0(%rax,%rax,1)
mov    0x28(%rsp),%rcx
add    $0x1,%rcx
mov    %rcx,%rax
mov    %rcx,0x28(%rsp)
jmp    11f7 <init_flag+0x97>
lea    0x1(%r14),%eax
mov    %rax,0x40(%rsp)
mov    0xd8(%rsp),%edx
cmp    $0xffffffff,%r14d
mov    0x10(%rsp),%rbp
jl     15a4 <init_flag+0x444>
mov    0x20(%rsp),%rax
add    $0x1,%eax
movslq %eax,%r15
mov    0x18(%rsp),%rax
add    $0x1,%eax
movslq %eax,%r12
mov    0x48(%rsp),%rax
add    $0x2,%eax
mov    %rax,0x8(%rsp)
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
mov    %edx,%r14d
mov    %edx,%edi
call   1070 <getbit@plt>
mov    0x0(%rbp),%rcx
mov    (%rcx),%rcx
mov    %eax,(%rcx,%rbx,4)
mov    0xe0(%rsp),%r13d
mov    %r13d,%edi
call   1070 <getbit@plt>
mov    0x0(%rbp),%rcx
mov    (%rcx,%r15,8),%rcx
mov    %eax,(%rcx,%rbx,4)
mov    %r14d,%edi
call   1070 <getbit@plt>
mov    0x0(%rbp,%r12,8),%rcx
mov    (%rcx),%rcx
mov    %eax,(%rcx,%rbx,4)
mov    %r13d,%edi
call   1070 <getbit@plt>
mov    %r14d,%edx
mov    0x0(%rbp,%r12,8),%rcx
mov    (%rcx,%r15,8),%rcx
mov    %eax,(%rcx,%rbx,4)
add    $0x1,%rbx
cmp    %rbx,0x8(%rsp)
jne    1540 <init_flag+0x3e0>
mov    0xf0(%rsp),%r13d
cmpl   $0xffffffff,0x20(%rsp)
jl     1641 <init_flag+0x4e1>
movslq 0x40(%rsp),%r15
mov    0x18(%rsp),%rax
add    $0x1,%eax
movslq %eax,%r12
mov    0x20(%rsp),%rax
add    $0x2,%eax
mov    %rax,0x8(%rsp)
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
mov    %r13d,%edi
call   1070 <getbit@plt>
mov    0x0(%rbp),%rcx
mov    (%rcx,%rbx,8),%rcx
mov    %eax,(%rcx)
mov    0xe8(%rsp),%r14d
mov    %r14d,%edi
call   1070 <getbit@plt>
mov    0x0(%rbp),%rcx
mov    (%rcx,%rbx,8),%rcx
mov    %eax,(%rcx,%r15,4)
mov    %r13d,%edi
call   1070 <getbit@plt>
mov    0x0(%rbp,%r12,8),%rcx
mov    (%rcx,%rbx,8),%rcx
mov    %eax,(%rcx)
mov    %r14d,%edi
call   1070 <getbit@plt>
mov    0x0(%rbp,%r12,8),%rcx
mov    (%rcx,%rbx,8),%rcx
mov    %eax,(%rcx,%r15,4)
add    $0x1,%rbx
cmp    %rbx,0x8(%rsp)
jne    15e0 <init_flag+0x480>
mov    0x18(%rsp),%rax
cmp    $0xffffffff,%eax
jl     18ac <init_flag+0x74c>
movb   $0x1,0x50(%rsp)
mov    0x20(%rsp),%rcx
lea    0x1(%rcx),%edx
mov    %rdx,%rcx
mov    %rdx,0x30(%rsp)
movslq %edx,%rbp
movslq 0x40(%rsp),%r12
add    $0x2,%eax
mov    %rax,0x8(%rsp)
xor    %ebx,%ebx
mov    0x10(%rsp),%r14
mov    0xe0(%rsp),%r13d
mov    0xd8(%rsp),%r15d
nopl   0x0(%rax,%rax,1)
mov    %r15d,%edi
call   1070 <getbit@plt>
mov    (%r14,%rbx,8),%rcx
mov    (%rcx),%rcx
mov    %eax,(%rcx)
mov    %r13d,%edi
call   1070 <getbit@plt>
mov    (%r14,%rbx,8),%rcx
mov    (%rcx,%rbp,8),%rcx
mov    %eax,(%rcx)
mov    %r15d,%edi
call   1070 <getbit@plt>
mov    (%r14,%rbx,8),%rcx
mov    (%rcx),%rcx
mov    %eax,(%rcx,%r12,4)
mov    %r13d,%edi
call   1070 <getbit@plt>
mov    (%r14,%rbx,8),%rcx
mov    (%rcx,%rbp,8),%rcx
mov    %eax,(%rcx,%r12,4)
add    $0x1,%rbx
cmp    %rbx,0x8(%rsp)
jne    1690 <init_flag+0x530>
mov    %r12,0x8(%rsp)
cmpl   $0x0,0x18(%rsp)
setle  %al
jle    18c0 <init_flag+0x760>
mov    %al,0x28(%rsp)
movslq 0x48(%rsp),%r14
mov    0x18(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x38(%rsp)
mov    0x30(%rsp),%rax
lea    -0x8(,%rax,8),%rax
ff
mov    %rax,0x30(%rsp)
mov    $0x1,%r12d
jmp    173f <init_flag+0x5df>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r12
cmp    0x38(%rsp),%r12
je     18b3 <init_flag+0x753>
cmpl   $0x0,0x20(%rsp)
jle    1730 <init_flag+0x5d0>
mov    0x10(%rsp),%rax
mov    (%rax,%r12,8),%rcx
xor    %r13d,%r13d
jmp    1794 <init_flag+0x634>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0xe8(%rsp),%edi
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     1730 <init_flag+0x5d0>
mov    0x8(%rcx,%r13,1),%rax
mov    0x4(%rax),%r15d
mov    $0x2,%edi
mov    $0xc,%esi
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
call   1030 <pow2@plt>
and    %ebp,%eax
cmp    %eax,%ebx
jne    1810 <init_flag+0x6b0>
xor    %edi,%edi
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
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    1830 <init_flag+0x6d0>
mov    0xf0(%rsp),%edi
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
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
call   1030 <pow2@plt>
and    %ebp,%eax
cmp    %eax,%ebx
jne    1760 <init_flag+0x600>
xor    %edi,%edi
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
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    1781 <init_flag+0x621>
movb   $0x1,0x50(%rsp)
jmp    18bb <init_flag+0x75b>
mov    0x28(%rsp),%al
mov    %al,0x50(%rsp)
mov    0x10(%rsp),%r14
mov    0x40(%rsp),%eax
mov    %rax,0x38(%rsp)
cmpl   $0x0,0x20(%rsp)
jle    1add <init_flag+0x97d>
mov    0x18(%rsp),%rax
movslq %eax,%r15
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,%r12d
jmp    191f <init_flag+0x7bf>
nopl   0x0(%rax)
add    $0x1,%r12
cmp    0x28(%rsp),%r12
je     1add <init_flag+0x97d>
cmpl   $0x0,0x48(%rsp)
jle    1910 <init_flag+0x7b0>
xor    %r13d,%r13d
jmp    199c <init_flag+0x83c>
nopl   0x0(%rax,%rax,1)
mov    0xd0(%rsp),%edi
call   1070 <getbit@plt>
mov    %eax,%ebp
mov    $0x2,%edi
mov    $0x8,%esi
call   1030 <pow2@plt>
lea    (%rax,%rax,2),%eax
sub    %eax,%ebp
mov    (%r14,%r15,8),%rax
mov    (%rax,%r12,8),%rax
mov    0x4(%rax,%r13,4),%r14d
mov    $0x2,%edi
mov    $0x8,%esi
call   1030 <pow2@plt>
lea    (%rax,%rax,2),%ebx
and    %r14d,%ebx
mov    0x10(%rsp),%r14
add    %ebp,%ebx
mov    0x8(%rsp),%rax
mov    (%r14,%rax,8),%rax
mov    (%rax,%r12,8),%rax
mov    %ebx,0x4(%rax,%r13,4)
add    $0x1,%r13
cmp    %r13,0x30(%rsp)
je     1910 <init_flag+0x7b0>
mov    0x8(%r14),%rax
mov    (%rax,%r12,8),%rax
mov    0x4(%rax,%r13,4),%ebp
mov    $0x2,%edi
mov    $0xc,%esi
call   1030 <pow2@plt>
mov    %eax,%ebx
and    %ebp,%ebx
mov    0x8(%r14),%rax
mov    (%rax,%r12,8),%rax
mov    0x4(%rax,%r13,4),%ebp
mov    $0x2,%edi
mov    $0xd,%esi
call   1030 <pow2@plt>
and    %ebp,%eax
cmp    %eax,%ebx
jne    1a10 <init_flag+0x8b0>
xor    %edi,%edi
call   1070 <getbit@plt>
mov    %eax,%ebx
mov    0x8(%r14),%rax
mov    (%rax,%r12,8),%rax
mov    0x4(%rax,%r13,4),%r14d
mov    $0x2,%edi
mov    $0xc,%esi
call   1030 <pow2@plt>
lea    (%rax,%rax,4),%eax
lea    (%rax,%rax,2),%ebp
and    %r14d,%ebp
jmp    1a51 <init_flag+0x8f1>
xchg   %ax,%ax
mov    0x64(%rsp),%edi
call   1070 <getbit@plt>
mov    %eax,%ebp
mov    $0x2,%edi
mov    $0xa,%esi
call   1030 <pow2@plt>
lea    (%rax,%rax,2),%eax
sub    %eax,%ebp
mov    0x8(%r14),%rax
mov    (%rax,%r12,8),%rax
mov    0x4(%rax,%r13,4),%r14d
mov    $0x2,%edi
mov    $0xa,%esi
call   1030 <pow2@plt>
lea    (%rax,%rax,2),%ebx
and    %r14d,%ebx
mov    0x10(%rsp),%r14
add    %ebp,%ebx
mov    (%r14),%rax
mov    (%rax,%r12,8),%rax
mov    %ebx,0x4(%rax,%r13,4)
mov    (%r14,%r15,8),%rax
mov    (%rax,%r12,8),%rax
mov    0x4(%rax,%r13,4),%ebp
mov    $0x2,%edi
mov    $0xc,%esi
call   1030 <pow2@plt>
mov    %eax,%ebx
and    %ebp,%ebx
mov    (%r14,%r15,8),%rax
mov    (%rax,%r12,8),%rax
mov    0x4(%rax,%r13,4),%ebp
mov    $0x2,%edi
mov    $0xd,%esi
call   1030 <pow2@plt>
and    %ebp,%eax
cmp    %eax,%ebx
jne    1930 <init_flag+0x7d0>
xor    %edi,%edi
call   1070 <getbit@plt>
mov    %eax,%ebx
mov    (%r14,%r15,8),%rax
mov    (%rax,%r12,8),%rax
mov    0x4(%rax,%r13,4),%r14d
mov    $0x2,%edi
mov    $0xc,%esi
call   1030 <pow2@plt>
lea    (%rax,%rax,4),%eax
lea    (%rax,%rax,2),%ebp
and    %r14d,%ebp
jmp    1974 <init_flag+0x814>
cmpb   $0x0,0x50(%rsp)
je     1af6 <init_flag+0x996>
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    1b3b <init_flag+0x9db>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r13
cmp    0x18(%rsp),%r13
je     1ae4 <init_flag+0x984>
cmpl   $0x0,0x48(%rsp)
jle    1b30 <init_flag+0x9d0>
mov    0x10(%rsp),%rax
mov    (%rax,%r13,8),%rcx
xor    %ebp,%ebp
jmp    1b88 <init_flag+0xa28>
nop
mov    0xe0(%rsp),%edi
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     1b30 <init_flag+0x9d0>
mov    0x8(%rcx),%rax
mov    0x4(%rax,%rbp,4),%r12d
mov    $0x2,%edi
mov    $0xc,%esi
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
call   1030 <pow2@plt>
and    %r12d,%eax
cmp    %eax,%ebx
jne    1c00 <init_flag+0xaa0>
xor    %edi,%edi
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
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    1c26 <init_flag+0xac6>
xchg   %ax,%ax
mov    0xd8(%rsp),%edi
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
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
call   1030 <pow2@plt>
and    %r12d,%eax
cmp    %eax,%ebx
jne    1b50 <init_flag+0x9f0>
xor    %edi,%edi
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
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    1b70 <init_flag+0xa10>

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