#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*/ free(char *);
int /*<<< orphan*/ free_imatrix(int **, int /*<<< orphan*/, int,
                                int /*<<< orphan*/, int);
int **imatrix(int /*<<< orphan*/, int, int /*<<< orphan*/, int);
char *malloc(scalar_t__);
int **read_pgm(char *);
int /*<<< orphan*/ strcat(char *, char *);
scalar_t__ strcmp(char const *, char *);
int /*<<< orphan*/ strcpy(char *, char const *);
scalar_t__ strlen(char const *);
void init_flag(const char *problem, int imax, int jmax, int ***flag) {
  char *problemPBMFile = 0;
  int **obstacleFlag = 0;
  int i, j;
  *flag = imatrix(0, imax + 1, 0, jmax + 1);
  for (i = 0; i <= imax + 1; i++) {
    (*flag)[i][0] = 0x00;
    (*flag)[i][jmax + 1] = 0x00;
  }
  for (j = 0; j <= jmax + 1; j++) {
    (*flag)[0][j] = 0x00;
    (*flag)[imax + 1][j] = 0x00;
  }
  problemPBMFile = malloc(strlen(problem) + 5);
  strcpy(problemPBMFile, problem);
  strcat(problemPBMFile, ".pbm");
  obstacleFlag = read_pgm(problemPBMFile);
  for (i = 1; i <= imax; i++) {
    for (j = 1; j <= jmax; j++) {
      if (obstacleFlag[i][j] == 1) {
        (*flag)[i][j] = 0x10;
      } else {
        (*flag)[i][j] = 0x00;
      }
    }
  }
  for (i = 1; i <= imax; i++) {
    for (j = 1; j <= jmax; j++) {
      if (obstacleFlag[i - 1][j] == 1) {
        (*flag)[i][j] |= 0x04;
      }
      if (obstacleFlag[i + 1][j] == 1) {
        (*flag)[i][j] |= 0x08;
      }
      if (obstacleFlag[i][j + 1] == 1) {
        (*flag)[i][j] |= 0x01;
      }
      if (obstacleFlag[i][j - 1] == 1) {
        (*flag)[i][j] |= 0x02;
      }
    }
  }
  if (strcmp(problem, "plane_shear_flow") == 0) {
    for (j = 1; j <= jmax; j++) {
      (*flag)[0][j] = 0x20;
    }
  }
  free_imatrix(obstacleFlag, 0, imax + 1, 0, jmax + 1);
  free(problemPBMFile);
}


x86 assembly (clang, -O0):
<init_flag>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
movq   $0x0,-0x20(%rbp)
movq   $0x0,-0x28(%rbp)
mov    -0xc(%rbp),%esi
add    $0x1,%esi
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
xor    %edx,%edx
mov    %edx,%edi
call   1050 <imatrix@plt>
mov    %rax,%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,(%rax)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jg     122f <init_flag+0x9f>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movl   $0x0,(%rax)
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11dc <init_flag+0x4c>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x10(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jg     1289 <init_flag+0xf9>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    (%rax),%rax
movslq -0x30(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    -0xc(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1236 <init_flag+0xa6>
mov    -0x8(%rbp),%rdi
call   1070 <strlen@plt>
mov    %rax,%rdi
add    $0x5,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rdi
mov    -0x8(%rbp),%rsi
call   1040 <strcpy@plt>
mov    -0x20(%rbp),%rdi
lea    0xd46(%rip),%rsi
call   10b0 <strcat@plt>
mov    -0x20(%rbp),%rdi
call   1060 <read_pgm@plt>
mov    %rax,-0x28(%rbp)
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     136b <init_flag+0x1db>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     1358 <init_flag+0x1c8>
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
cmpl   $0x1,(%rax,%rcx,4)
jne    132b <init_flag+0x19b>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movl   $0x10,(%rax,%rcx,4)
jmp    1345 <init_flag+0x1b5>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
jmp    134a <init_flag+0x1ba>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    12e6 <init_flag+0x156>
jmp    135d <init_flag+0x1cd>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    12d3 <init_flag+0x143>
movl   $0x1,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     14a3 <init_flag+0x313>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     1490 <init_flag+0x300>
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
cmpl   $0x1,(%rax,%rcx,4)
jne    13cc <init_flag+0x23c>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
or     $0x4,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
cmpl   $0x1,(%rax,%rcx,4)
jne    1407 <init_flag+0x277>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
or     $0x8,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
cmpl   $0x1,(%rax,%rcx,4)
jne    1442 <init_flag+0x2b2>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
or     $0x1,%edx
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
cmpl   $0x1,(%rax,%rcx,4)
jne    147d <init_flag+0x2ed>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
or     $0x2,%edx
mov    %edx,(%rax,%rcx,4)
jmp    1482 <init_flag+0x2f2>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1385 <init_flag+0x1f5>
jmp    1495 <init_flag+0x305>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1372 <init_flag+0x1e2>
mov    -0x8(%rbp),%rdi
lea    0xb57(%rip),%rsi
call   1080 <strcmp@plt>
cmp    $0x0,%rax
jne    14f8 <init_flag+0x368>
movl   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x10(%rbp),%eax
jg     14f3 <init_flag+0x363>
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
mov    (%rax),%rax
movslq -0x30(%rbp),%rcx
movl   $0x20,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    14c4 <init_flag+0x334>
jmp    14f8 <init_flag+0x368>
mov    -0x28(%rbp),%rdi
mov    -0xc(%rbp),%edx
add    $0x1,%edx
mov    -0x10(%rbp),%r8d
add    $0x1,%r8d
xor    %ecx,%ecx
mov    %ecx,%esi
call   1090 <free_imatrix@plt>
mov    -0x20(%rbp),%rdi
call   1030 <free@plt>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<init_flag>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %rcx,%r15
mov    %edx,%r14d
mov    %esi,%ebp
mov    %rdi,%r12
lea    0x1(%rbp),%esi
lea    0x1(%r14),%ecx
xor    %edi,%edi
mov    %esi,0xc(%rsp)
xor    %edx,%edx
mov    %ecx,0x8(%rsp)
call   1050 <imatrix@plt>
mov    %rbp,%rbx
mov    %rax,(%r15)
cmp    $0xffffffff,%ebx
jl     127c <init_flag+0xec>
movslq 0x8(%rsp),%rcx
lea    0x2(%rbx),%esi
lea    -0x1(%rsi),%rdi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0x3,%rdi
jae    11eb <init_flag+0x5b>
xor    %edi,%edi
jmp    1248 <init_flag+0xb8>
and    $0xfffffffc,%esi
xor    %edi,%edi
mov    (%rax,%rdi,8),%rbp
movl   $0x0,0x0(%rbp)
movl   $0x0,0x0(%rbp,%rcx,4)
mov    0x8(%rax,%rdi,8),%rbp
movl   $0x0,0x0(%rbp)
movl   $0x0,0x0(%rbp,%rcx,4)
mov    0x10(%rax,%rdi,8),%rbp
movl   $0x0,0x0(%rbp)
movl   $0x0,0x0(%rbp,%rcx,4)
mov    0x18(%rax,%rdi,8),%rbp
movl   $0x0,0x0(%rbp)
movl   $0x0,0x0(%rbp,%rcx,4)
add    $0x4,%rdi
cmp    %rdi,%rsi
jne    11f0 <init_flag+0x60>
test   %rdx,%rdx
je     127c <init_flag+0xec>
lea    (%rax,%rdi,8),%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%rsi,%rdi,8),%rbp
movl   $0x0,0x0(%rbp)
movl   $0x0,0x0(%rbp,%rcx,4)
add    $0x1,%rdi
cmp    %rdi,%rdx
jne    1260 <init_flag+0xd0>
mov    %rbx,0x18(%rsp)
cmp    $0xffffffff,%r14d
jl     1439 <init_flag+0x2a9>
mov    (%rax),%rcx
movslq 0xc(%rsp),%rdx
mov    (%rax,%rdx,8),%rax
xor    %esi,%esi
mov    0x8(%rsp),%edi
test   %edi,%edi
mov    $0x0,%edx
cmovg  %edi,%edx
lea    0x1(%rdx),%r9d
cmp    $0x7,%edx
jb     13a4 <init_flag+0x214>
lea    (%rax,%r9,4),%rdx
cmp    %rdx,%rcx
jae    12cd <init_flag+0x13d>
lea    (%rcx,%r9,4),%rdx
cmp    %rdx,%rax
jae    12cd <init_flag+0x13d>
xor    %esi,%esi
jmp    13a4 <init_flag+0x214>
mov    %r9d,%esi
and    $0xfffffff8,%esi
lea    -0x8(%rsi),%rdx
mov    %rdx,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%r8d
and    $0x3,%r8d
cmp    $0x18,%rdx
jae    12f3 <init_flag+0x163>
xor    %ebp,%ebp
jmp    1358 <init_flag+0x1c8>
and    $0xfffffffffffffffc,%rdi
xor    %ebp,%ebp
xorps  %xmm0,%xmm0
nopl   0x0(%rax)
movups %xmm0,(%rcx,%rbp,4)
movups %xmm0,0x10(%rcx,%rbp,4)
movups %xmm0,(%rax,%rbp,4)
movups %xmm0,0x10(%rax,%rbp,4)
movups %xmm0,0x20(%rcx,%rbp,4)
movups %xmm0,0x30(%rcx,%rbp,4)
movups %xmm0,0x20(%rax,%rbp,4)
movups %xmm0,0x30(%rax,%rbp,4)
movups %xmm0,0x40(%rcx,%rbp,4)
movups %xmm0,0x50(%rcx,%rbp,4)
movups %xmm0,0x40(%rax,%rbp,4)
movups %xmm0,0x50(%rax,%rbp,4)
movups %xmm0,0x60(%rcx,%rbp,4)
movups %xmm0,0x70(%rcx,%rbp,4)
movups %xmm0,0x60(%rax,%rbp,4)
movups %xmm0,0x70(%rax,%rbp,4)
add    $0x20,%rbp
add    $0xfffffffffffffffc,%rdi
jne    1300 <init_flag+0x170>
test   %r8,%r8
je     139b <init_flag+0x20b>
lea    (%rax,%rbp,4),%rdi
add    $0x10,%rdi
lea    (%rcx,%rbp,4),%rdx
add    $0x10,%rdx
shl    $0x5,%r8
xor    %ebp,%ebp
xorps  %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
movups %xmm0,-0x10(%rdx,%rbp,1)
movups %xmm0,(%rdx,%rbp,1)
movups %xmm0,-0x10(%rdi,%rbp,1)
movups %xmm0,(%rdi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%r8
jne    1380 <init_flag+0x1f0>
cmp    %r9,%rsi
je     1439 <init_flag+0x2a9>
mov    %rsi,%rdi
not    %rdi
add    %r9,%rdi
mov    %r9,%rdx
and    $0x3,%rdx
je     13d8 <init_flag+0x248>
cs nopw 0x0(%rax,%rax,1)
movl   $0x0,(%rcx,%rsi,4)
movl   $0x0,(%rax,%rsi,4)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rdx
jne    13c0 <init_flag+0x230>
cmp    $0x3,%rdi
jb     1439 <init_flag+0x2a9>
add    $0xffffffffffffffff,%r9
add    $0xffffffffffffffff,%rsi
cs nopw 0x0(%rax,%rax,1)
movl   $0x0,0x4(%rcx,%rsi,4)
movl   $0x0,0x4(%rax,%rsi,4)
movl   $0x0,0x8(%rcx,%rsi,4)
movl   $0x0,0x8(%rax,%rsi,4)
movl   $0x0,0xc(%rcx,%rsi,4)
movl   $0x0,0xc(%rax,%rsi,4)
movl   $0x0,0x10(%rcx,%rsi,4)
movl   $0x0,0x10(%rax,%rsi,4)
add    $0x4,%rsi
cmp    %rsi,%r9
jne    13f0 <init_flag+0x260>
mov    %r12,%rdi
call   1070 <strlen@plt>
lea    0x5(%rax),%rdi
call   10a0 <malloc@plt>
mov    %rax,%rbx
mov    %rax,%rdi
mov    %r12,0x20(%rsp)
mov    %r12,%rsi
call   1040 <strcpy@plt>
lea    0xbac(%rip),%rsi
mov    %rbx,%rdi
call   10b0 <strcat@plt>
mov    %rbx,0x10(%rsp)
mov    %rbx,%rdi
call   1060 <read_pgm@plt>
mov    %rax,%r12
mov    0x8(%rsp),%ebx
mov    %ebx,%r13d
mov    0x18(%rsp),%r10
test   %r10d,%r10d
jle    1610 <init_flag+0x480>
mov    0xc(%rsp),%r8d
lea    -0x1(%r13),%r9
mov    %r9,%rdx
and    $0xfffffffffffffffe,%rdx
neg    %rdx
mov    $0x1,%esi
jmp    14b9 <init_flag+0x329>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rsi
cmp    %r8,%rsi
je     1535 <init_flag+0x3a5>
test   %r14d,%r14d
jle    14b0 <init_flag+0x320>
mov    (%r12,%rsi,8),%rbp
mov    $0x1,%edi
cmp    $0x2,%ebx
je     1513 <init_flag+0x383>
mov    (%r15),%rax
mov    (%rax,%rsi,8),%rax
mov    $0x1,%edi
nopl   0x0(%rax,%rax,1)
xor    %ecx,%ecx
cmpl   $0x1,0x0(%rbp,%rdi,4)
sete   %cl
shl    $0x4,%ecx
mov    %ecx,(%rax,%rdi,4)
xor    %ecx,%ecx
cmpl   $0x1,0x4(%rbp,%rdi,4)
sete   %cl
shl    $0x4,%ecx
mov    %ecx,0x4(%rax,%rdi,4)
lea    (%rdx,%rdi,1),%rcx
add    $0x2,%rcx
add    $0x2,%rdi
cmp    $0x1,%rcx
jne    14e0 <init_flag+0x350>
test   $0x1,%r9b
je     14b0 <init_flag+0x320>
xor    %eax,%eax
cmpl   $0x1,0x0(%rbp,%rdi,4)
sete   %al
mov    (%r15),%rcx
mov    (%rcx,%rsi,8),%rcx
shl    $0x4,%eax
mov    %eax,(%rcx,%rdi,4)
jmp    14b0 <init_flag+0x320>
test   %r10d,%r10d
jle    1610 <init_flag+0x480>
lea    -0x4(,%r13,4),%rcx
ff
mov    $0x1,%edx
jmp    155c <init_flag+0x3cc>
nopl   (%rax)
mov    %r9,%rdx
cmp    %r8,%r9
je     1610 <init_flag+0x480>
test   %r14d,%r14d
jle    1600 <init_flag+0x470>
mov    -0x8(%r12,%rdx,8),%rdi
mov    (%r12,%rdx,8),%rbp
lea    0x1(%rdx),%r9
mov    %r9d,%eax
mov    (%r12,%rax,8),%rax
xor    %esi,%esi
jmp    1589 <init_flag+0x3f9>
nopl   (%rax)
add    $0x4,%rsi
cmp    %rsi,%rcx
je     1550 <init_flag+0x3c0>
cmpl   $0x1,0x4(%rdi,%rsi,1)
je     15b0 <init_flag+0x420>
cmpl   $0x1,0x4(%rax,%rsi,1)
je     15c3 <init_flag+0x433>
cmpl   $0x1,0x8(%rbp,%rsi,1)
je     15d6 <init_flag+0x446>
cmpl   $0x1,0x0(%rbp,%rsi,1)
jne    1580 <init_flag+0x3f0>
jmp    15e9 <init_flag+0x459>
nopw   0x0(%rax,%rax,1)
mov    (%r15),%rbx
mov    (%rbx,%rdx,8),%rbx
orl    $0x4,0x4(%rbx,%rsi,1)
cmpl   $0x1,0x4(%rax,%rsi,1)
jne    1597 <init_flag+0x407>
mov    (%r15),%rbx
mov    (%rbx,%rdx,8),%rbx
orl    $0x8,0x4(%rbx,%rsi,1)
cmpl   $0x1,0x8(%rbp,%rsi,1)
jne    159e <init_flag+0x40e>
mov    (%r15),%rbx
mov    (%rbx,%rdx,8),%rbx
orl    $0x1,0x4(%rbx,%rsi,1)
cmpl   $0x1,0x0(%rbp,%rsi,1)
jne    1580 <init_flag+0x3f0>
mov    (%r15),%rbx
mov    (%rbx,%rdx,8),%rbx
orl    $0x2,0x4(%rbx,%rsi,1)
jmp    1580 <init_flag+0x3f0>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rdx
mov    %rdx,%r9
cmp    %r8,%r9
jne    155c <init_flag+0x3cc>
lea    0x9fe(%rip),%rsi
mov    0x20(%rsp),%rdi
call   1080 <strcmp@plt>
mov    0x8(%rsp),%r8d
test   %rax,%rax
jne    1710 <init_flag+0x580>
test   %r14d,%r14d
jle    1710 <init_flag+0x580>
mov    (%r15),%rax
mov    (%rax),%rax
lea    -0x1(%r13),%rdx
mov    $0x1,%ecx
cmp    $0x8,%rdx
jb     1700 <init_flag+0x570>
mov    %rdx,%rcx
and    $0xfffffffffffffff8,%rcx
lea    -0x8(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%ebp
and    $0x3,%ebp
cmp    $0x18,%rdi
jae    1676 <init_flag+0x4e6>
xor    %edi,%edi
jmp    16c2 <init_flag+0x532>
and    $0xfffffffffffffffc,%rsi
xor    %edi,%edi
movaps 0x97d(%rip),%xmm0
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups %xmm0,0x4(%rax,%rdi,4)
movups %xmm0,0x14(%rax,%rdi,4)
movups %xmm0,0x24(%rax,%rdi,4)
movups %xmm0,0x34(%rax,%rdi,4)
movups %xmm0,0x44(%rax,%rdi,4)
movups %xmm0,0x54(%rax,%rdi,4)
movups %xmm0,0x64(%rax,%rdi,4)
movups %xmm0,0x74(%rax,%rdi,4)
add    $0x20,%rdi
add    $0xfffffffffffffffc,%rsi
jne    1690 <init_flag+0x500>
test   %rbp,%rbp
je     16ef <init_flag+0x55f>
movaps 0x932(%rip),%xmm0
xchg   %ax,%ax
lea    0x0(,%rdi,4),%rsi
or     $0x4,%rsi
movups %xmm0,(%rax,%rsi,1)
movups %xmm0,0x10(%rax,%rsi,1)
add    $0x8,%rdi
add    $0xffffffffffffffff,%rbp
jne    16d0 <init_flag+0x540>
cmp    %rcx,%rdx
je     1710 <init_flag+0x580>
or     $0x1,%rcx
nopl   0x0(%rax,%rax,1)
movl   $0x20,(%rax,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%r13
jne    1700 <init_flag+0x570>
mov    %r12,%rdi
xor    %esi,%esi
mov    0xc(%rsp),%edx
xor    %ecx,%ecx
call   1090 <free_imatrix@plt>
mov    0x10(%rsp),%rdi
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>

LLVM IR (-O0):
@.str = [5 x i8] c".pbm\00"
@.str.1 = [17 x i8] c"plane_shear_flow\00"
define void @init_flag(i8* %0, i32 %1, i32 %2, i32*** %3) {
%5 = alloca i8*
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32***
%9 = alloca i8*
%10 = alloca i32**
%11 = alloca i32
%12 = alloca i32
store i8* %0, i8** %5
store i32 %1, i32* %6
store i32 %2, i32* %7
store i32*** %3, i32**** %8
store i8* null, i8** %9
store i32** null, i32*** %10
%13 = load i32, i32* %6
%14 = add nsw i32 %13, 1
%15 = load i32, i32* %7
%16 = add nsw i32 %15, 1
%17 = call i32** @imatrix(i32 0, i32 %14, i32 0, i32 %16)
%18 = load i32***, i32**** %8
store i32** %17, i32*** %18
store i32 0, i32* %11
br label %19
19: ; preds = %42, %4
%20 = load i32, i32* %11
%21 = load i32, i32* %6
%22 = add nsw i32 %21, 1
%23 = icmp sle i32 %20, %22
br i1 %23, label %24, label %45
24: ; preds = %19
%25 = load i32***, i32**** %8
%26 = load i32**, i32*** %25
%27 = load i32, i32* %11
%28 = sext i32 %27 to i64
%29 = getelementptr inbounds i32*, i32** %26, i64 %28
%30 = load i32*, i32** %29
%31 = getelementptr inbounds i32, i32* %30, i64 0
store i32 0, i32* %31
%32 = load i32***, i32**** %8
%33 = load i32**, i32*** %32
%34 = load i32, i32* %11
%35 = sext i32 %34 to i64
%36 = getelementptr inbounds i32*, i32** %33, i64 %35
%37 = load i32*, i32** %36
%38 = load i32, i32* %7
%39 = add nsw i32 %38, 1
%40 = sext i32 %39 to i64
%41 = getelementptr inbounds i32, i32* %37, i64 %40
store i32 0, i32* %41
br label %42
42: ; preds = %24
%43 = load i32, i32* %11
%44 = add nsw i32 %43, 1
store i32 %44, i32* %11
br label %19
45: ; preds = %19
store i32 0, i32* %12
br label %46
46: ; preds = %69, %45
%47 = load i32, i32* %12
%48 = load i32, i32* %7
%49 = add nsw i32 %48, 1
%50 = icmp sle i32 %47, %49
br i1 %50, label %51, label %72
51: ; preds = %46
%52 = load i32***, i32**** %8
%53 = load i32**, i32*** %52
%54 = getelementptr inbounds i32*, i32** %53, i64 0
%55 = load i32*, i32** %54
%56 = load i32, i32* %12
%57 = sext i32 %56 to i64
%58 = getelementptr inbounds i32, i32* %55, i64 %57
store i32 0, i32* %58
%59 = load i32***, i32**** %8
%60 = load i32**, i32*** %59
%61 = load i32, i32* %6
%62 = add nsw i32 %61, 1
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds i32*, i32** %60, i64 %63
%65 = load i32*, i32** %64
%66 = load i32, i32* %12
%67 = sext i32 %66 to i64
%68 = getelementptr inbounds i32, i32* %65, i64 %67
store i32 0, i32* %68
br label %69
69: ; preds = %51
%70 = load i32, i32* %12
%71 = add nsw i32 %70, 1
store i32 %71, i32* %12
br label %46
72: ; preds = %46
%73 = load i8*, i8** %5
%74 = call i64 @strlen(i8* %73)
%75 = add nsw i64 %74, 5
%76 = call i8* @malloc(i64 %75)
store i8* %76, i8** %9
%77 = load i8*, i8** %9
%78 = load i8*, i8** %5
%79 = call i32 @strcpy(i8* %77, i8* %78)
%80 = load i8*, i8** %9
%81 = call i32 @strcat(i8* %80, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0))
%82 = load i8*, i8** %9
%83 = call i32** @read_pgm(i8* %82)
store i32** %83, i32*** %10
store i32 1, i32* %11
br label %84
84: ; preds = %129, %72
%85 = load i32, i32* %11
%86 = load i32, i32* %6
%87 = icmp sle i32 %85, %86
br i1 %87, label %88, label %132
88: ; preds = %84
store i32 1, i32* %12
br label %89
89: ; preds = %125, %88
%90 = load i32, i32* %12
%91 = load i32, i32* %7
%92 = icmp sle i32 %90, %91
br i1 %92, label %93, label %128
93: ; preds = %89
%94 = load i32**, i32*** %10
%95 = load i32, i32* %11
%96 = sext i32 %95 to i64
%97 = getelementptr inbounds i32*, i32** %94, i64 %96
%98 = load i32*, i32** %97
%99 = load i32, i32* %12
%100 = sext i32 %99 to i64
%101 = getelementptr inbounds i32, i32* %98, i64 %100
%102 = load i32, i32* %101
%103 = icmp eq i32 %102, 1
br i1 %103, label %104, label %114
104: ; preds = %93
%105 = load i32***, i32**** %8
%106 = load i32**, i32*** %105
%107 = load i32, i32* %11
%108 = sext i32 %107 to i64
%109 = getelementptr inbounds i32*, i32** %106, i64 %108
%110 = load i32*, i32** %109
%111 = load i32, i32* %12
%112 = sext i32 %111 to i64
%113 = getelementptr inbounds i32, i32* %110, i64 %112
store i32 16, i32* %113
br label %124
114: ; preds = %93
%115 = load i32***, i32**** %8
%116 = load i32**, i32*** %115
%117 = load i32, i32* %11
%118 = sext i32 %117 to i64
%119 = getelementptr inbounds i32*, i32** %116, i64 %118
%120 = load i32*, i32** %119
%121 = load i32, i32* %12
%122 = sext i32 %121 to i64
%123 = getelementptr inbounds i32, i32* %120, i64 %122
store i32 0, i32* %123
br label %124
124: ; preds = %114, %104
br label %125
125: ; preds = %124
%126 = load i32, i32* %12
%127 = add nsw i32 %126, 1
store i32 %127, i32* %12
br label %89
128: ; preds = %89
br label %129
129: ; preds = %128
%130 = load i32, i32* %11
%131 = add nsw i32 %130, 1
store i32 %131, i32* %11
br label %84
132: ; preds = %84
store i32 1, i32* %11
br label %133
133: ; preds = %243, %132
%134 = load i32, i32* %11
%135 = load i32, i32* %6
%136 = icmp sle i32 %134, %135
br i1 %136, label %137, label %246
137: ; preds = %133
store i32 1, i32* %12
br label %138
138: ; preds = %239, %137
%139 = load i32, i32* %12
%140 = load i32, i32* %7
%141 = icmp sle i32 %139, %140
br i1 %141, label %142, label %242
142: ; preds = %138
%143 = load i32**, i32*** %10
%144 = load i32, i32* %11
%145 = sub nsw i32 %144, 1
%146 = sext i32 %145 to i64
%147 = getelementptr inbounds i32*, i32** %143, i64 %146
%148 = load i32*, i32** %147
%149 = load i32, i32* %12
%150 = sext i32 %149 to i64
%151 = getelementptr inbounds i32, i32* %148, i64 %150
%152 = load i32, i32* %151
%153 = icmp eq i32 %152, 1
br i1 %153, label %154, label %166
154: ; preds = %142
%155 = load i32***, i32**** %8
%156 = load i32**, i32*** %155
%157 = load i32, i32* %11
%158 = sext i32 %157 to i64
%159 = getelementptr inbounds i32*, i32** %156, i64 %158
%160 = load i32*, i32** %159
%161 = load i32, i32* %12
%162 = sext i32 %161 to i64
%163 = getelementptr inbounds i32, i32* %160, i64 %162
%164 = load i32, i32* %163
%165 = or i32 %164, 4
store i32 %165, i32* %163
br label %166
166: ; preds = %154, %142
%167 = load i32**, i32*** %10
%168 = load i32, i32* %11
%169 = add nsw i32 %168, 1
%170 = sext i32 %169 to i64
%171 = getelementptr inbounds i32*, i32** %167, i64 %170
%172 = load i32*, i32** %171
%173 = load i32, i32* %12
%174 = sext i32 %173 to i64
%175 = getelementptr inbounds i32, i32* %172, i64 %174
%176 = load i32, i32* %175
%177 = icmp eq i32 %176, 1
br i1 %177, label %178, label %190
178: ; preds = %166
%179 = load i32***, i32**** %8
%180 = load i32**, i32*** %179
%181 = load i32, i32* %11
%182 = sext i32 %181 to i64
%183 = getelementptr inbounds i32*, i32** %180, i64 %182
%184 = load i32*, i32** %183
%185 = load i32, i32* %12
%186 = sext i32 %185 to i64
%187 = getelementptr inbounds i32, i32* %184, i64 %186
%188 = load i32, i32* %187
%189 = or i32 %188, 8
store i32 %189, i32* %187
br label %190
190: ; preds = %178, %166
%191 = load i32**, i32*** %10
%192 = load i32, i32* %11
%193 = sext i32 %192 to i64
%194 = getelementptr inbounds i32*, i32** %191, i64 %193
%195 = load i32*, i32** %194
%196 = load i32, i32* %12
%197 = add nsw i32 %196, 1
%198 = sext i32 %197 to i64
%199 = getelementptr inbounds i32, i32* %195, i64 %198
%200 = load i32, i32* %199
%201 = icmp eq i32 %200, 1
br i1 %201, label %202, label %214
202: ; preds = %190
%203 = load i32***, i32**** %8
%204 = load i32**, i32*** %203
%205 = load i32, i32* %11
%206 = sext i32 %205 to i64
%207 = getelementptr inbounds i32*, i32** %204, i64 %206
%208 = load i32*, i32** %207
%209 = load i32, i32* %12
%210 = sext i32 %209 to i64
%211 = getelementptr inbounds i32, i32* %208, i64 %210
%212 = load i32, i32* %211
%213 = or i32 %212, 1
store i32 %213, i32* %211
br label %214
214: ; preds = %202, %190
%215 = load i32**, i32*** %10
%216 = load i32, i32* %11
%217 = sext i32 %216 to i64
%218 = getelementptr inbounds i32*, i32** %215, i64 %217
%219 = load i32*, i32** %218
%220 = load i32, i32* %12
%221 = sub nsw i32 %220, 1
%222 = sext i32 %221 to i64
%223 = getelementptr inbounds i32, i32* %219, i64 %222
%224 = load i32, i32* %223
%225 = icmp eq i32 %224, 1
br i1 %225, label %226, label %238
226: ; preds = %214
%227 = load i32***, i32**** %8
%228 = load i32**, i32*** %227
%229 = load i32, i32* %11
%230 = sext i32 %229 to i64
%231 = getelementptr inbounds i32*, i32** %228, i64 %230
%232 = load i32*, i32** %231
%233 = load i32, i32* %12
%234 = sext i32 %233 to i64
%235 = getelementptr inbounds i32, i32* %232, i64 %234
%236 = load i32, i32* %235
%237 = or i32 %236, 2
store i32 %237, i32* %235
br label %238
238: ; preds = %226, %214
br label %239
239: ; preds = %238
%240 = load i32, i32* %12
%241 = add nsw i32 %240, 1
store i32 %241, i32* %12
br label %138
242: ; preds = %138
br label %243
243: ; preds = %242
%244 = load i32, i32* %11
%245 = add nsw i32 %244, 1
store i32 %245, i32* %11
br label %133
246: ; preds = %133
%247 = load i8*, i8** %5
%248 = call i64 @strcmp(i8* %247, i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.1, i64 0, i64 0))
%249 = icmp eq i64 %248, 0
br i1 %249, label %250, label %267
250: ; preds = %246
store i32 1, i32* %12
br label %251
251: ; preds = %263, %250
%252 = load i32, i32* %12
%253 = load i32, i32* %7
%254 = icmp sle i32 %252, %253
br i1 %254, label %255, label %266
255: ; preds = %251
%256 = load i32***, i32**** %8
%257 = load i32**, i32*** %256
%258 = getelementptr inbounds i32*, i32** %257, i64 0
%259 = load i32*, i32** %258
%260 = load i32, i32* %12
%261 = sext i32 %260 to i64
%262 = getelementptr inbounds i32, i32* %259, i64 %261
store i32 32, i32* %262
br label %263
263: ; preds = %255
%264 = load i32, i32* %12
%265 = add nsw i32 %264, 1
store i32 %265, i32* %12
br label %251
266: ; preds = %251
br label %267
267: ; preds = %266, %246
%268 = load i32**, i32*** %10
%269 = load i32, i32* %6
%270 = add nsw i32 %269, 1
%271 = load i32, i32* %7
%272 = add nsw i32 %271, 1
%273 = call i32 @free_imatrix(i32** %268, i32 0, i32 %270, i32 0, i32 %272)
%274 = load i8*, i8** %9
%275 = call i32 @free(i8* %274)
ret void
}

LLVM IR (-O2):
@.str = [5 x i8] c".pbm\00"
@.str.1 = [17 x i8] c"plane_shear_flow\00"
define void @init_flag(i8* %0, i32 %1, i32 %2, i32*** nocapture %3) {
%5 = add nsw i32 %1, 1
%6 = add nsw i32 %2, 1
%7 = tail call i32** @imatrix(i32 0, i32 %5, i32 0, i32 %6)
store i32** %7, i32*** %3
%8 = icmp slt i32 %1, -1
br i1 %8, label %30, label %9
9: ; preds = %4
%10 = sext i32 %6 to i64
%11 = add i32 %1, 2
%12 = zext i32 %11 to i64
%13 = add nsw i64 %12, -1
%14 = and i64 %12, 3
%15 = icmp ult i64 %13, 3
br i1 %15, label %18, label %16
16: ; preds = %9
%17 = and i64 %12, 4294967292
br label %133
18: ; preds = %133, %9
%19 = phi i64 [ 0, %9 ], [ %151, %133 ]
%20 = icmp eq i64 %14, 0
br i1 %20, label %30, label %21
21: ; preds = %18, %21
%22 = phi i64 [ %27, %21 ], [ %19, %18 ]
%23 = phi i64 [ %28, %21 ], [ 0, %18 ]
%24 = getelementptr inbounds i32*, i32** %7, i64 %22
%25 = load i32*, i32** %24
store i32 0, i32* %25
%26 = getelementptr inbounds i32, i32* %25, i64 %10
store i32 0, i32* %26
%27 = add nuw nsw i64 %22, 1
%28 = add i64 %23, 1
%29 = icmp eq i64 %28, %14
br i1 %29, label %30, label %21
30: ; preds = %18, %21, %4
%31 = icmp slt i32 %2, -1
br i1 %31, label %169, label %32
32: ; preds = %30
%33 = load i32*, i32** %7
%34 = sext i32 %5 to i64
%35 = getelementptr inbounds i32*, i32** %7, i64 %34
%36 = load i32*, i32** %35
%37 = call i32 @llvm.smax.i32(i32 %6, i32 0)
%38 = add nuw i32 %37, 1
%39 = zext i32 %38 to i64
%40 = icmp ult i32 %37, 7
br i1 %40, label %116, label %41
41: ; preds = %32
%42 = getelementptr i32, i32* %33, i64 %39
%43 = getelementptr i32, i32* %36, i64 %39
%44 = icmp ult i32* %33, %43
%45 = icmp ult i32* %36, %42
%46 = and i1 %44, %45
br i1 %46, label %116, label %47
47: ; preds = %41
%48 = and i64 %39, 4294967288
%49 = add nsw i64 %48, -8
%50 = lshr exact i64 %49, 3
%51 = add nuw nsw i64 %50, 1
%52 = and i64 %51, 3
%53 = icmp ult i64 %49, 24
br i1 %53, label %97, label %54
54: ; preds = %47
%55 = and i64 %51, 4611686018427387900
br label %56
56: ; preds = %56, %54
%57 = phi i64 [ 0, %54 ], [ %94, %56 ]
%58 = phi i64 [ 0, %54 ], [ %95, %56 ]
%59 = getelementptr inbounds i32, i32* %33, i64 %57
%60 = bitcast i32* %59 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %60
%61 = getelementptr inbounds i32, i32* %59, i64 4
%62 = bitcast i32* %61 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %62
%63 = getelementptr inbounds i32, i32* %36, i64 %57
%64 = bitcast i32* %63 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %64
%65 = getelementptr inbounds i32, i32* %63, i64 4
%66 = bitcast i32* %65 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %66
%67 = or i64 %57, 8
%68 = getelementptr inbounds i32, i32* %33, i64 %67
%69 = bitcast i32* %68 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %69
%70 = getelementptr inbounds i32, i32* %68, i64 4
%71 = bitcast i32* %70 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %71
%72 = getelementptr inbounds i32, i32* %36, i64 %67
%73 = bitcast i32* %72 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %73
%74 = getelementptr inbounds i32, i32* %72, i64 4
%75 = bitcast i32* %74 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %75
%76 = or i64 %57, 16
%77 = getelementptr inbounds i32, i32* %33, i64 %76
%78 = bitcast i32* %77 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %78
%79 = getelementptr inbounds i32, i32* %77, i64 4
%80 = bitcast i32* %79 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %80
%81 = getelementptr inbounds i32, i32* %36, i64 %76
%82 = bitcast i32* %81 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %82
%83 = getelementptr inbounds i32, i32* %81, i64 4
%84 = bitcast i32* %83 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %84
%85 = or i64 %57, 24
%86 = getelementptr inbounds i32, i32* %33, i64 %85
%87 = bitcast i32* %86 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %87
%88 = getelementptr inbounds i32, i32* %86, i64 4
%89 = bitcast i32* %88 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %89
%90 = getelementptr inbounds i32, i32* %36, i64 %85
%91 = bitcast i32* %90 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %91
%92 = getelementptr inbounds i32, i32* %90, i64 4
%93 = bitcast i32* %92 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %93
%94 = add nuw i64 %57, 32
%95 = add i64 %58, 4
%96 = icmp eq i64 %95, %55
br i1 %96, label %97, label %56
97: ; preds = %56, %47
%98 = phi i64 [ 0, %47 ], [ %94, %56 ]
%99 = icmp eq i64 %52, 0
br i1 %99, label %114, label %100
100: ; preds = %97, %100
%101 = phi i64 [ %111, %100 ], [ %98, %97 ]
%102 = phi i64 [ %112, %100 ], [ 0, %97 ]
%103 = getelementptr inbounds i32, i32* %33, i64 %101
%104 = bitcast i32* %103 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %104
%105 = getelementptr inbounds i32, i32* %103, i64 4
%106 = bitcast i32* %105 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %106
%107 = getelementptr inbounds i32, i32* %36, i64 %101
%108 = bitcast i32* %107 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %108
%109 = getelementptr inbounds i32, i32* %107, i64 4
%110 = bitcast i32* %109 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %110
%111 = add nuw i64 %101, 8
%112 = add i64 %102, 1
%113 = icmp eq i64 %112, %52
br i1 %113, label %114, label %100
114: ; preds = %100, %97
%115 = icmp eq i64 %48, %39
br i1 %115, label %169, label %116
116: ; preds = %41, %32, %114
%117 = phi i64 [ 0, %41 ], [ 0, %32 ], [ %48, %114 ]
%118 = xor i64 %117, -1
%119 = add nsw i64 %118, %39
%120 = and i64 %39, 3
%121 = icmp eq i64 %120, 0
br i1 %121, label %130, label %122
122: ; preds = %116, %122
%123 = phi i64 [ %127, %122 ], [ %117, %116 ]
%124 = phi i64 [ %128, %122 ], [ 0, %116 ]
%125 = getelementptr inbounds i32, i32* %33, i64 %123
store i32 0, i32* %125
%126 = getelementptr inbounds i32, i32* %36, i64 %123
store i32 0, i32* %126
%127 = add nuw nsw i64 %123, 1
%128 = add i64 %124, 1
%129 = icmp eq i64 %128, %120
br i1 %129, label %130, label %122
130: ; preds = %122, %116
%131 = phi i64 [ %117, %116 ], [ %127, %122 ]
%132 = icmp ult i64 %119, 3
br i1 %132, label %169, label %154
133: ; preds = %133, %16
%134 = phi i64 [ 0, %16 ], [ %151, %133 ]
%135 = phi i64 [ 0, %16 ], [ %152, %133 ]
%136 = getelementptr inbounds i32*, i32** %7, i64 %134
%137 = load i32*, i32** %136
store i32 0, i32* %137
%138 = getelementptr inbounds i32, i32* %137, i64 %10
store i32 0, i32* %138
%139 = or i64 %134, 1
%140 = getelementptr inbounds i32*, i32** %7, i64 %139
%141 = load i32*, i32** %140
store i32 0, i32* %141
%142 = getelementptr inbounds i32, i32* %141, i64 %10
store i32 0, i32* %142
%143 = or i64 %134, 2
%144 = getelementptr inbounds i32*, i32** %7, i64 %143
%145 = load i32*, i32** %144
store i32 0, i32* %145
%146 = getelementptr inbounds i32, i32* %145, i64 %10
store i32 0, i32* %146
%147 = or i64 %134, 3
%148 = getelementptr inbounds i32*, i32** %7, i64 %147
%149 = load i32*, i32** %148
store i32 0, i32* %149
%150 = getelementptr inbounds i32, i32* %149, i64 %10
store i32 0, i32* %150
%151 = add nuw nsw i64 %134, 4
%152 = add i64 %135, 4
%153 = icmp eq i64 %152, %17
br i1 %153, label %18, label %133
154: ; preds = %130, %154
%155 = phi i64 [ %167, %154 ], [ %131, %130 ]
%156 = getelementptr inbounds i32, i32* %33, i64 %155
store i32 0, i32* %156
%157 = getelementptr inbounds i32, i32* %36, i64 %155
store i32 0, i32* %157
%158 = add nuw nsw i64 %155, 1
%159 = getelementptr inbounds i32, i32* %33, i64 %158
store i32 0, i32* %159
%160 = getelementptr inbounds i32, i32* %36, i64 %158
store i32 0, i32* %160
%161 = add nuw nsw i64 %155, 2
%162 = getelementptr inbounds i32, i32* %33, i64 %161
store i32 0, i32* %162
%163 = getelementptr inbounds i32, i32* %36, i64 %161
store i32 0, i32* %163
%164 = add nuw nsw i64 %155, 3
%165 = getelementptr inbounds i32, i32* %33, i64 %164
store i32 0, i32* %165
%166 = getelementptr inbounds i32, i32* %36, i64 %164
store i32 0, i32* %166
%167 = add nuw nsw i64 %155, 4
%168 = icmp eq i64 %167, %39
br i1 %168, label %169, label %154
169: ; preds = %130, %154, %114, %30
%170 = tail call i64 @strlen(i8* dereferenceable(1) %0)
%171 = add nsw i64 %170, 5
%172 = tail call i8* @malloc(i64 %171)
%173 = tail call i32 @strcpy(i8* %172, i8* %0)
%174 = tail call i32 @strcat(i8* %172, i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0))
%175 = tail call i32** @read_pgm(i8* %172)
%176 = icmp slt i32 %1, 1
br i1 %176, label %301, label %177
177: ; preds = %169
%178 = icmp slt i32 %2, 1
%179 = zext i32 %5 to i64
%180 = zext i32 %6 to i64
%181 = add nsw i64 %180, -1
%182 = and i64 %181, 1
%183 = icmp eq i32 %6, 2
%184 = and i64 %181, -2
%185 = icmp eq i64 %182, 0
br label %186
186: ; preds = %177, %231
%187 = phi i64 [ 1, %177 ], [ %232, %231 ]
br i1 %178, label %231, label %188
188: ; preds = %186
%189 = getelementptr inbounds i32*, i32** %175, i64 %187
%190 = load i32*, i32** %189
br i1 %183, label %220, label %191
191: ; preds = %188
%192 = load i32**, i32*** %3
%193 = getelementptr inbounds i32*, i32** %192, i64 %187
%194 = load i32*, i32** %193
%195 = load i32**, i32*** %3
%196 = getelementptr inbounds i32*, i32** %195, i64 %187
%197 = load i32*, i32** %196
br label %203
198: ; preds = %231
br i1 %176, label %301, label %199
199: ; preds = %198
%200 = icmp slt i32 %2, 1
%201 = zext i32 %5 to i64
%202 = zext i32 %6 to i64
br label %234
203: ; preds = %203, %191
%204 = phi i64 [ 1, %191 ], [ %217, %203 ]
%205 = phi i64 [ 0, %191 ], [ %218, %203 ]
%206 = getelementptr inbounds i32, i32* %190, i64 %204
%207 = load i32, i32* %206
%208 = icmp eq i32 %207, 1
%209 = getelementptr inbounds i32, i32* %194, i64 %204
%210 = select i1 %208, i32 16, i32 0
store i32 %210, i32* %209
%211 = add nuw nsw i64 %204, 1
%212 = getelementptr inbounds i32, i32* %190, i64 %211
%213 = load i32, i32* %212
%214 = icmp eq i32 %213, 1
%215 = getelementptr inbounds i32, i32* %197, i64 %211
%216 = select i1 %214, i32 16, i32 0
store i32 %216, i32* %215
%217 = add nuw nsw i64 %204, 2
%218 = add i64 %205, 2
%219 = icmp eq i64 %218, %184
br i1 %219, label %220, label %203
220: ; preds = %203, %188
%221 = phi i64 [ 1, %188 ], [ %217, %203 ]
br i1 %185, label %231, label %222
222: ; preds = %220
%223 = getelementptr inbounds i32, i32* %190, i64 %221
%224 = load i32, i32* %223
%225 = icmp eq i32 %224, 1
%226 = load i32**, i32*** %3
%227 = getelementptr inbounds i32*, i32** %226, i64 %187
%228 = load i32*, i32** %227
%229 = getelementptr inbounds i32, i32* %228, i64 %221
%230 = select i1 %225, i32 16, i32 0
store i32 %230, i32* %229
br label %231
231: ; preds = %222, %220, %186
%232 = add nuw nsw i64 %187, 1
%233 = icmp eq i64 %232, %179
br i1 %233, label %198, label %186
234: ; preds = %199, %298
%235 = phi i64 [ 1, %199 ], [ %299, %298 ]
br i1 %200, label %236, label %238
236: ; preds = %234
%237 = add nuw nsw i64 %235, 1
br label %298
238: ; preds = %234
%239 = add nsw i64 %235, -1
%240 = getelementptr inbounds i32*, i32** %175, i64 %239
%241 = load i32*, i32** %240
%242 = add nuw nsw i64 %235, 1
%243 = and i64 %242, 4294967295
%244 = getelementptr inbounds i32*, i32** %175, i64 %243
%245 = load i32*, i32** %244
%246 = getelementptr inbounds i32*, i32** %175, i64 %235
%247 = load i32*, i32** %246
br label %248
248: ; preds = %238, %296
%249 = phi i64 [ 1, %238 ], [ %272, %296 ]
%250 = getelementptr inbounds i32, i32* %241, i64 %249
%251 = load i32, i32* %250
%252 = icmp eq i32 %251, 1
br i1 %252, label %253, label %260
253: ; preds = %248
%254 = load i32**, i32*** %3
%255 = getelementptr inbounds i32*, i32** %254, i64 %235
%256 = load i32*, i32** %255
%257 = getelementptr inbounds i32, i32* %256, i64 %249
%258 = load i32, i32* %257
%259 = or i32 %258, 4
store i32 %259, i32* %257
br label %260
260: ; preds = %253, %248
%261 = getelementptr inbounds i32, i32* %245, i64 %249
%262 = load i32, i32* %261
%263 = icmp eq i32 %262, 1
br i1 %263, label %264, label %271
264: ; preds = %260
%265 = load i32**, i32*** %3
%266 = getelementptr inbounds i32*, i32** %265, i64 %235
%267 = load i32*, i32** %266
%268 = getelementptr inbounds i32, i32* %267, i64 %249
%269 = load i32, i32* %268
%270 = or i32 %269, 8
store i32 %270, i32* %268
br label %271
271: ; preds = %264, %260
%272 = add nuw nsw i64 %249, 1
%273 = and i64 %272, 4294967295
%274 = getelementptr inbounds i32, i32* %247, i64 %273
%275 = load i32, i32* %274
%276 = icmp eq i32 %275, 1
br i1 %276, label %277, label %284
277: ; preds = %271
%278 = load i32**, i32*** %3
%279 = getelementptr inbounds i32*, i32** %278, i64 %235
%280 = load i32*, i32** %279
%281 = getelementptr inbounds i32, i32* %280, i64 %249
%282 = load i32, i32* %281
%283 = or i32 %282, 1
store i32 %283, i32* %281
br label %284
284: ; preds = %277, %271
%285 = add nsw i64 %249, -1
%286 = getelementptr inbounds i32, i32* %247, i64 %285
%287 = load i32, i32* %286
%288 = icmp eq i32 %287, 1
br i1 %288, label %289, label %296
289: ; preds = %284
%290 = load i32**, i32*** %3
%291 = getelementptr inbounds i32*, i32** %290, i64 %235
%292 = load i32*, i32** %291
%293 = getelementptr inbounds i32, i32* %292, i64 %249
%294 = load i32, i32* %293
%295 = or i32 %294, 2
store i32 %295, i32* %293
br label %296
296: ; preds = %284, %289
%297 = icmp eq i64 %272, %202
br i1 %297, label %298, label %248
298: ; preds = %296, %236
%299 = phi i64 [ %237, %236 ], [ %242, %296 ]
%300 = icmp eq i64 %299, %201
br i1 %300, label %301, label %234
301: ; preds = %298, %169, %198
%302 = tail call i64 @strcmp(i8* %0, i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.1, i64 0, i64 0))
%303 = icmp ne i64 %302, 0
%304 = icmp slt i32 %2, 1
%305 = or i1 %303, %304
br i1 %305, label %371, label %306
306: ; preds = %301
%307 = load i32**, i32*** %3
%308 = load i32*, i32** %307
%309 = zext i32 %6 to i64
%310 = add nsw i64 %309, -1
%311 = icmp ult i64 %310, 8
br i1 %311, label %364, label %312
312: ; preds = %306
%313 = and i64 %310, -8
%314 = or i64 %313, 1
%315 = add nsw i64 %313, -8
%316 = lshr exact i64 %315, 3
%317 = add nuw nsw i64 %316, 1
%318 = and i64 %317, 3
%319 = icmp ult i64 %315, 24
br i1 %319, label %348, label %320
320: ; preds = %312
%321 = and i64 %317, 4611686018427387900
br label %322
322: ; preds = %322, %320
%323 = phi i64 [ 0, %320 ], [ %345, %322 ]
%324 = phi i64 [ 0, %320 ], [ %346, %322 ]
%325 = or i64 %323, 1
%326 = getelementptr inbounds i32, i32* %308, i64 %325
%327 = bitcast i32* %326 to <4 x i32>*
store <4 x i32> <i32 32, i32 32, i32 32, i32 32>, <4 x i32>* %327
%328 = getelementptr inbounds i32, i32* %326, i64 4
%329 = bitcast i32* %328 to <4 x i32>*
store <4 x i32> <i32 32, i32 32, i32 32, i32 32>, <4 x i32>* %329
%330 = or i64 %323, 9
%331 = getelementptr inbounds i32, i32* %308, i64 %330
%332 = bitcast i32* %331 to <4 x i32>*
store <4 x i32> <i32 32, i32 32, i32 32, i32 32>, <4 x i32>* %332
%333 = getelementptr inbounds i32, i32* %331, i64 4
%334 = bitcast i32* %333 to <4 x i32>*
store <4 x i32> <i32 32, i32 32, i32 32, i32 32>, <4 x i32>* %334
%335 = or i64 %323, 17
%336 = getelementptr inbounds i32, i32* %308, i64 %335
%337 = bitcast i32* %336 to <4 x i32>*
store <4 x i32> <i32 32, i32 32, i32 32, i32 32>, <4 x i32>* %337
%338 = getelementptr inbounds i32, i32* %336, i64 4
%339 = bitcast i32* %338 to <4 x i32>*
store <4 x i32> <i32 32, i32 32, i32 32, i32 32>, <4 x i32>* %339
%340 = or i64 %323, 25
%341 = getelementptr inbounds i32, i32* %308, i64 %340
%342 = bitcast i32* %341 to <4 x i32>*
store <4 x i32> <i32 32, i32 32, i32 32, i32 32>, <4 x i32>* %342
%343 = getelementptr inbounds i32, i32* %341, i64 4
%344 = bitcast i32* %343 to <4 x i32>*
store <4 x i32> <i32 32, i32 32, i32 32, i32 32>, <4 x i32>* %344
%345 = add nuw i64 %323, 32
%346 = add i64 %324, 4
%347 = icmp eq i64 %346, %321
br i1 %347, label %348, label %322
348: ; preds = %322, %312
%349 = phi i64 [ 0, %312 ], [ %345, %322 ]
%350 = icmp eq i64 %318, 0
br i1 %350, label %362, label %351
351: ; preds = %348, %351
%352 = phi i64 [ %359, %351 ], [ %349, %348 ]
%353 = phi i64 [ %360, %351 ], [ 0, %348 ]
%354 = or i64 %352, 1
%355 = getelementptr inbounds i32, i32* %308, i64 %354
%356 = bitcast i32* %355 to <4 x i32>*
store <4 x i32> <i32 32, i32 32, i32 32, i32 32>, <4 x i32>* %356
%357 = getelementptr inbounds i32, i32* %355, i64 4
%358 = bitcast i32* %357 to <4 x i32>*
store <4 x i32> <i32 32, i32 32, i32 32, i32 32>, <4 x i32>* %358
%359 = add nuw i64 %352, 8
%360 = add i64 %353, 1
%361 = icmp eq i64 %360, %318
br i1 %361, label %362, label %351
362: ; preds = %351, %348
%363 = icmp eq i64 %310, %313
br i1 %363, label %371, label %364
364: ; preds = %306, %362
%365 = phi i64 [ 1, %306 ], [ %314, %362 ]
br label %366
366: ; preds = %364, %366
%367 = phi i64 [ %369, %366 ], [ %365, %364 ]
%368 = getelementptr inbounds i32, i32* %308, i64 %367
store i32 32, i32* %368
%369 = add nuw nsw i64 %367, 1
%370 = icmp eq i64 %369, %309
br i1 %370, label %371, label %366
371: ; preds = %366, %362, %301
%372 = tail call i32 @free_imatrix(i32** %175, i32 0, i32 %5, i32 0, i32 %6)
%373 = tail call i32 @free(i8* %172)
ret void
}