#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*/ copytab(int **, int **);
int /*<<< orphan*/ fillblank(int, int, int, int, int **);
scalar_t__ tabcmp(int **, int **);
int swipe(int dirx, int diry, int tab[4][4], int in) {
  int sx, sy, x, y, cont;
  int clone[4][4];
  if (in) {
    copytab(tab, clone);
    swipe(dirx, diry, clone, 0);
    if (tabcmp(tab, clone))
      return 0;
  }
  if (diry == 0) {
    sx = 0;
    for (sy = 0; sy < 4; sy++) {
      if (dirx > 0) {
        for (cont = 0; cont < 4 - 1; cont++) {
          fillblank(dirx, diry, sy, sx, tab);
        }
        for (x = 4 - 1; x >= 1; x--) {
          if (tab[x][sy] == tab[x - 1][sy]) {
            tab[x][sy] = tab[x][sy] * 2;
            tab[x - 1][sy] = 0;
            fillblank(dirx, diry, sy, sx, tab);
          }
        }
      } else if (dirx < 0) {
        for (cont = 0; cont < 4 - 1; cont++) {
          fillblank(dirx, diry, sy, sx, tab);
        }
        for (x = 0; x < 4 - 1; x++) {
          if (tab[x][sy] == tab[x + 1][sy]) {
            tab[x][sy] = tab[x][sy] * 2;
            tab[x + 1][sy] = 0;
            fillblank(dirx, diry, sy, sx, tab);
          }
        }
      }
    }
  } else if (dirx == 0) {
    sy = 0;
    for (sx = 0; sx < 4; sx++) {
      if (diry > 0) {
        for (cont = 0; cont < 4 - 1; cont++) {
          fillblank(dirx, diry, sy, sx, tab);
        }
        for (y = 4 - 1; y >= 1; y--) {
          if (tab[sx][y] == tab[sx][y - 1]) {
            tab[sx][y] = tab[sx][y] * 2;
            tab[sx][y - 1] = 0;
            fillblank(dirx, diry, sy, sx, tab);
          }
        }
      } else if (diry < 0) {
        for (cont = 0; cont < 4 - 1; cont++) {
          fillblank(dirx, diry, sy, sx, tab);
        }
        for (y = 0; y < 4 - 1; y++) {
          if (tab[sx][y] == tab[sx][y + 1]) {
            tab[sx][y] = tab[sx][y] * 2;
            tab[sx][y + 1] = 0;
            fillblank(dirx, diry, sy, sx, tab);
          }
        }
      }
    }
  }
  return 1;
}


x86 assembly (clang, -O0):
<swipe>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %edi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
cmpl   $0x0,-0x1c(%rbp)
je     11a5 <swipe+0x65>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1040 <copytab@plt>
mov    -0x8(%rbp),%edi
mov    -0xc(%rbp),%esi
lea    -0x70(%rbp),%rdx
xor    %ecx,%ecx
call   1050 <swipe@plt>
mov    -0x18(%rbp),%rdi
lea    -0x70(%rbp),%rsi
call   1030 <tabcmp@plt>
cmp    $0x0,%rax
je     11a0 <swipe+0x60>
movl   $0x0,-0x4(%rbp)
jmp    1633 <swipe+0x4f3>
jmp    11a5 <swipe+0x65>
cmpl   $0x0,-0xc(%rbp)
jne    13e6 <swipe+0x2a6>
movl   $0x0,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
cmpl   $0x4,-0x24(%rbp)
jge    13e1 <swipe+0x2a1>
cmpl   $0x0,-0x8(%rbp)
jle    12c8 <swipe+0x188>
movl   $0x0,-0x30(%rbp)
cmpl   $0x3,-0x30(%rbp)
jge    1205 <swipe+0xc5>
mov    -0x8(%rbp),%edi
mov    -0xc(%rbp),%esi
mov    -0x24(%rbp),%edx
mov    -0x20(%rbp),%ecx
mov    -0x18(%rbp),%r8
call   1060 <fillblank@plt>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11d8 <swipe+0x98>
movl   $0x3,-0x28(%rbp)
cmpl   $0x1,-0x28(%rbp)
jl     12c3 <swipe+0x183>
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x18(%rbp),%rcx
mov    -0x28(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
shl    $0x4,%rdx
add    %rdx,%rcx
movslq -0x24(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jne    12b0 <swipe+0x170>
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
shl    $0x1,%edx
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x8(%rbp),%edi
mov    -0xc(%rbp),%esi
mov    -0x24(%rbp),%edx
mov    -0x20(%rbp),%ecx
mov    -0x18(%rbp),%r8
call   1060 <fillblank@plt>
jmp    12b5 <swipe+0x175>
mov    -0x28(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x28(%rbp)
jmp    120c <swipe+0xcc>
jmp    13ce <swipe+0x28e>
cmpl   $0x0,-0x8(%rbp)
jge    13c9 <swipe+0x289>
movl   $0x0,-0x30(%rbp)
cmpl   $0x3,-0x30(%rbp)
jge    1306 <swipe+0x1c6>
mov    -0x8(%rbp),%edi
mov    -0xc(%rbp),%esi
mov    -0x24(%rbp),%edx
mov    -0x20(%rbp),%ecx
mov    -0x18(%rbp),%r8
call   1060 <fillblank@plt>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    12d9 <swipe+0x199>
movl   $0x0,-0x28(%rbp)
cmpl   $0x3,-0x28(%rbp)
jge    13c4 <swipe+0x284>
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x18(%rbp),%rcx
mov    -0x28(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
shl    $0x4,%rdx
add    %rdx,%rcx
movslq -0x24(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jne    13b1 <swipe+0x271>
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
shl    $0x1,%edx
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x24(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x8(%rbp),%edi
mov    -0xc(%rbp),%esi
mov    -0x24(%rbp),%edx
mov    -0x20(%rbp),%ecx
mov    -0x18(%rbp),%r8
call   1060 <fillblank@plt>
jmp    13b6 <swipe+0x276>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    130d <swipe+0x1cd>
jmp    13c9 <swipe+0x289>
jmp    13ce <swipe+0x28e>
jmp    13d3 <swipe+0x293>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11bd <swipe+0x7d>
jmp    162c <swipe+0x4ec>
cmpl   $0x0,-0x8(%rbp)
jne    1627 <swipe+0x4e7>
movl   $0x0,-0x24(%rbp)
movl   $0x0,-0x20(%rbp)
cmpl   $0x4,-0x20(%rbp)
jge    1622 <swipe+0x4e2>
cmpl   $0x0,-0xc(%rbp)
jle    1509 <swipe+0x3c9>
movl   $0x0,-0x30(%rbp)
cmpl   $0x3,-0x30(%rbp)
jge    1446 <swipe+0x306>
mov    -0x8(%rbp),%edi
mov    -0xc(%rbp),%esi
mov    -0x24(%rbp),%edx
mov    -0x20(%rbp),%ecx
mov    -0x18(%rbp),%r8
call   1060 <fillblank@plt>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1419 <swipe+0x2d9>
movl   $0x3,-0x2c(%rbp)
cmpl   $0x1,-0x2c(%rbp)
jl     1504 <swipe+0x3c4>
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x18(%rbp),%rcx
movslq -0x20(%rbp),%rdx
shl    $0x4,%rdx
add    %rdx,%rcx
mov    -0x2c(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jne    14f1 <swipe+0x3b1>
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
shl    $0x1,%edx
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x8(%rbp),%edi
mov    -0xc(%rbp),%esi
mov    -0x24(%rbp),%edx
mov    -0x20(%rbp),%ecx
mov    -0x18(%rbp),%r8
call   1060 <fillblank@plt>
jmp    14f6 <swipe+0x3b6>
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
jmp    144d <swipe+0x30d>
jmp    160f <swipe+0x4cf>
cmpl   $0x0,-0xc(%rbp)
jge    160a <swipe+0x4ca>
movl   $0x0,-0x30(%rbp)
cmpl   $0x3,-0x30(%rbp)
jge    1547 <swipe+0x407>
mov    -0x8(%rbp),%edi
mov    -0xc(%rbp),%esi
mov    -0x24(%rbp),%edx
mov    -0x20(%rbp),%ecx
mov    -0x18(%rbp),%r8
call   1060 <fillblank@plt>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    151a <swipe+0x3da>
movl   $0x0,-0x2c(%rbp)
cmpl   $0x3,-0x2c(%rbp)
jge    1605 <swipe+0x4c5>
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x18(%rbp),%rcx
movslq -0x20(%rbp),%rdx
shl    $0x4,%rdx
add    %rdx,%rcx
mov    -0x2c(%rbp),%edx
add    $0x1,%edx
movslq %edx,%rdx
cmp    (%rcx,%rdx,4),%eax
jne    15f2 <swipe+0x4b2>
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
shl    $0x1,%edx
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x8(%rbp),%edi
mov    -0xc(%rbp),%esi
mov    -0x24(%rbp),%edx
mov    -0x20(%rbp),%ecx
mov    -0x18(%rbp),%r8
call   1060 <fillblank@plt>
jmp    15f7 <swipe+0x4b7>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    154e <swipe+0x40e>
jmp    160a <swipe+0x4ca>
jmp    160f <swipe+0x4cf>
jmp    1614 <swipe+0x4d4>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    13fe <swipe+0x2be>
jmp    1627 <swipe+0x4e7>
jmp    162c <swipe+0x4ec>
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<swipe>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %rdx,%r13
mov    %esi,%r14d
mov    %edi,%r12d
test   %ecx,%ecx
je     1190 <swipe+0x50>
mov    %rsp,%rbp
mov    %r13,%rdi
mov    %rbp,%rsi
call   1040 <copytab@plt>
xor    %r15d,%r15d
mov    %r12d,%edi
mov    %r14d,%esi
mov    %rbp,%rdx
xor    %ecx,%ecx
call   1050 <swipe@plt>
mov    %r13,%rdi
mov    %rbp,%rsi
call   1030 <tabcmp@plt>
test   %rax,%rax
jne    14a7 <swipe+0x367>
test   %r14d,%r14d
je     12f3 <swipe+0x1b3>
mov    $0x1,%r15d
test   %r12d,%r12d
jne    14a7 <swipe+0x367>
lea    0x8(%r13),%rbx
xor    %ebp,%ebp
jmp    11dd <swipe+0x9d>
add    %eax,%eax
mov    %eax,(%rdx)
movl   $0x0,(%rcx)
xor    %edi,%edi
mov    %r14d,%esi
xor    %edx,%edx
mov    %ebp,%ecx
mov    %r13,%r8
call   1060 <fillblank@plt>
add    $0x1,%rbp
add    $0x10,%rbx
cmp    $0x4,%rbp
je     14a7 <swipe+0x367>
xor    %edi,%edi
mov    %r14d,%esi
xor    %edx,%edx
mov    %ebp,%ecx
mov    %r13,%r8
call   1060 <fillblank@plt>
xor    %edi,%edi
mov    %r14d,%esi
xor    %edx,%edx
mov    %ebp,%ecx
mov    %r13,%r8
call   1060 <fillblank@plt>
xor    %edi,%edi
mov    %r14d,%esi
xor    %edx,%edx
mov    %ebp,%ecx
mov    %r13,%r8
call   1060 <fillblank@plt>
test   %r14d,%r14d
jle    1290 <swipe+0x150>
mov    (%rbx),%ecx
mov    0x4(%rbx),%eax
cmp    %ecx,%eax
jne    123c <swipe+0xfc>
add    %eax,%eax
mov    %eax,0x4(%rbx)
movl   $0x0,(%rbx)
xor    %edi,%edi
mov    %r14d,%esi
xor    %edx,%edx
mov    %ebp,%ecx
mov    %r13,%r8
call   1060 <fillblank@plt>
mov    (%rbx),%ecx
mov    -0x4(%rbx),%eax
cmp    %eax,%ecx
jne    1262 <swipe+0x122>
add    %ecx,%ecx
mov    %ecx,(%rbx)
movl   $0x0,-0x4(%rbx)
xor    %edi,%edi
mov    %r14d,%esi
xor    %edx,%edx
mov    %ebp,%ecx
mov    %r13,%r8
call   1060 <fillblank@plt>
mov    -0x4(%rbx),%eax
cmp    -0x8(%rbx),%eax
jne    11cb <swipe+0x8b>
mov    %rbp,%rcx
shl    $0x4,%rcx
lea    (%rcx,%r13,1),%rdx
add    $0x4,%rdx
add    %r13,%rcx
jmp    11b0 <swipe+0x70>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    -0x8(%rbx),%eax
mov    -0x4(%rbx),%ecx
cmp    %ecx,%eax
jne    12ba <swipe+0x17a>
add    %eax,%eax
mov    %eax,-0x8(%rbx)
movl   $0x0,-0x4(%rbx)
xor    %edi,%edi
mov    %r14d,%esi
xor    %edx,%edx
mov    %ebp,%ecx
mov    %r13,%r8
call   1060 <fillblank@plt>
mov    -0x4(%rbx),%ecx
mov    (%rbx),%eax
cmp    %eax,%ecx
jne    12de <swipe+0x19e>
add    %ecx,%ecx
mov    %ecx,-0x4(%rbx)
movl   $0x0,(%rbx)
xor    %edi,%edi
mov    %r14d,%esi
xor    %edx,%edx
mov    %ebp,%ecx
mov    %r13,%r8
call   1060 <fillblank@plt>
mov    (%rbx),%eax
cmp    0x4(%rbx),%eax
jne    11cb <swipe+0x8b>
lea    0x4(%rbx),%rcx
mov    %rbx,%rdx
jmp    11b0 <swipe+0x70>
lea    0x20(%r13),%r14
xor    %ebp,%ebp
jmp    1318 <swipe+0x1d8>
nopl   0x0(%rax,%rax,1)
js     13f4 <swipe+0x2b4>
add    $0x1,%rbp
add    $0x4,%r14
cmp    $0x4,%rbp
je     14a1 <swipe+0x361>
test   %r12d,%r12d
jle    1300 <swipe+0x1c0>
mov    %r12d,%edi
xor    %esi,%esi
mov    %ebp,%edx
xor    %ecx,%ecx
mov    %r13,%r8
call   1060 <fillblank@plt>
mov    %r12d,%edi
xor    %esi,%esi
mov    %ebp,%edx
xor    %ecx,%ecx
mov    %r13,%r8
call   1060 <fillblank@plt>
mov    %r12d,%edi
xor    %esi,%esi
mov    %ebp,%edx
xor    %ecx,%ecx
mov    %r13,%r8
call   1060 <fillblank@plt>
mov    0x20(%r13,%rbp,4),%ecx
mov    0x30(%r13,%rbp,4),%eax
cmp    %ecx,%eax
jne    1384 <swipe+0x244>
add    %eax,%eax
mov    %eax,0x30(%r13,%rbp,4)
movl   $0x0,0x20(%r13,%rbp,4)
mov    %r12d,%edi
xor    %esi,%esi
mov    %ebp,%edx
xor    %ecx,%ecx
mov    %r13,%r8
call   1060 <fillblank@plt>
mov    0x20(%r13,%rbp,4),%ecx
mov    0x10(%r13,%rbp,4),%eax
cmp    %eax,%ecx
jne    13b3 <swipe+0x273>
add    %ecx,%ecx
mov    %ecx,0x20(%r13,%rbp,4)
movl   $0x0,0x10(%r13,%rbp,4)
mov    %r12d,%edi
xor    %esi,%esi
mov    %ebp,%edx
xor    %ecx,%ecx
mov    %r13,%r8
call   1060 <fillblank@plt>
mov    0x10(%r13,%rbp,4),%eax
cmp    0x0(%r13,%rbp,4),%eax
jne    1306 <swipe+0x1c6>
lea    0x10(,%rbp,4),%rdx
add    %r13,%rdx
lea    0x0(,%rbp,4),%rcx
add    %r13,%rcx
add    %eax,%eax
mov    %eax,(%rdx)
movl   $0x0,(%rcx)
mov    %r12d,%edi
xor    %esi,%esi
mov    %ebp,%edx
xor    %ecx,%ecx
mov    %r13,%r8
call   1060 <fillblank@plt>
jmp    1306 <swipe+0x1c6>
mov    %r12d,%edi
xor    %esi,%esi
mov    %ebp,%edx
xor    %ecx,%ecx
mov    %r13,%r8
call   1060 <fillblank@plt>
mov    %r12d,%edi
xor    %esi,%esi
mov    %ebp,%edx
xor    %ecx,%ecx
mov    %r13,%r8
call   1060 <fillblank@plt>
mov    %r12d,%edi
xor    %esi,%esi
mov    %ebp,%edx
xor    %ecx,%ecx
mov    %r13,%r8
call   1060 <fillblank@plt>
mov    0x0(%r13,%rbp,4),%eax
mov    0x10(%r13,%rbp,4),%ecx
cmp    %ecx,%eax
jne    145b <swipe+0x31b>
add    %eax,%eax
mov    %eax,0x0(%r13,%rbp,4)
movl   $0x0,0x10(%r13,%rbp,4)
mov    %r12d,%edi
xor    %esi,%esi
mov    %ebp,%edx
xor    %ecx,%ecx
mov    %r13,%r8
call   1060 <fillblank@plt>
mov    0x10(%r13,%rbp,4),%ecx
mov    0x20(%r13,%rbp,4),%eax
cmp    %eax,%ecx
jne    148a <swipe+0x34a>
add    %ecx,%ecx
mov    %ecx,0x10(%r13,%rbp,4)
movl   $0x0,0x20(%r13,%rbp,4)
mov    %r12d,%edi
xor    %esi,%esi
mov    %ebp,%edx
xor    %ecx,%ecx
mov    %r13,%r8
call   1060 <fillblank@plt>
mov    0x20(%r13,%rbp,4),%eax
cmp    0x30(%r13,%rbp,4),%eax
jne    1306 <swipe+0x1c6>
lea    0x10(%r14),%rcx
mov    %r14,%rdx
jmp    13d4 <swipe+0x294>
mov    $0x1,%r15d
mov    %r15d,%eax
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define i32 @swipe(i32 %0, i32 %1, [4 x i32]* %2, i32 %3) {
%5 = alloca [4 x [4 x i32]]
%6 = bitcast [4 x [4 x i32]]* %5 to i8*
%7 = icmp eq i32 %3, 0
br i1 %7, label %16, label %8
8: ; preds = %4
%9 = bitcast [4 x i32]* %2 to i32**
%10 = getelementptr inbounds [4 x [4 x i32]], [4 x [4 x i32]]* %5, i64 0, i64 0
%11 = bitcast [4 x [4 x i32]]* %5 to i32**
%12 = call i32 @copytab(i32** %9, i32** %11)
%13 = call i32 @swipe(i32 %0, i32 %1, [4 x i32]* %10, i32 0)
%14 = call i64 @tabcmp(i32** %9, i32** %11)
%15 = icmp eq i64 %14, 0
br i1 %15, label %16, label %159
16: ; preds = %8, %4
%17 = icmp eq i32 %1, 0
br i1 %17, label %18, label %91
18: ; preds = %16
%19 = icmp sgt i32 %0, 0
%20 = icmp slt i32 %0, 0
%21 = bitcast [4 x i32]* %2 to i32**
br label %22
22: ; preds = %18, %88
%23 = phi i64 [ 0, %18 ], [ %89, %88 ]
br i1 %19, label %24, label %52
24: ; preds = %22
%25 = trunc i64 %23 to i32
%26 = call i32 @fillblank(i32 %0, i32 0, i32 %25, i32 0, i32** %21)
%27 = call i32 @fillblank(i32 %0, i32 0, i32 %25, i32 0, i32** %21)
%28 = call i32 @fillblank(i32 %0, i32 0, i32 %25, i32 0, i32** %21)
%29 = getelementptr inbounds [4 x i32], [4 x i32]* %2, i64 3, i64 %23
%30 = load i32, i32* %29
%31 = getelementptr inbounds [4 x i32], [4 x i32]* %2, i64 2, i64 %23
%32 = load i32, i32* %31
%33 = icmp eq i32 %30, %32
br i1 %33, label %34, label %38
34: ; preds = %24
%35 = shl nsw i32 %30, 1
store i32 %35, i32* %29
store i32 0, i32* %31
%36 = call i32 @fillblank(i32 %0, i32 0, i32 %25, i32 0, i32** %21)
%37 = load i32, i32* %31
br label %38
38: ; preds = %24, %34
%39 = phi i32 [ %32, %24 ], [ %37, %34 ]
%40 = getelementptr inbounds [4 x i32], [4 x i32]* %2, i64 1, i64 %23
%41 = load i32, i32* %40
%42 = icmp eq i32 %39, %41
br i1 %42, label %43, label %47
43: ; preds = %38
%44 = shl nsw i32 %39, 1
store i32 %44, i32* %31
store i32 0, i32* %40
%45 = call i32 @fillblank(i32 %0, i32 0, i32 %25, i32 0, i32** %21)
%46 = load i32, i32* %40
br label %47
47: ; preds = %43, %38
%48 = phi i32 [ %46, %43 ], [ %41, %38 ]
%49 = getelementptr inbounds [4 x i32], [4 x i32]* %2, i64 0, i64 %23
%50 = load i32, i32* %49
%51 = icmp eq i32 %48, %50
br i1 %51, label %81, label %88
52: ; preds = %22
br i1 %20, label %53, label %88
53: ; preds = %52
%54 = trunc i64 %23 to i32
%55 = call i32 @fillblank(i32 %0, i32 0, i32 %54, i32 0, i32** %21)
%56 = call i32 @fillblank(i32 %0, i32 0, i32 %54, i32 0, i32** %21)
%57 = call i32 @fillblank(i32 %0, i32 0, i32 %54, i32 0, i32** %21)
%58 = getelementptr inbounds [4 x i32], [4 x i32]* %2, i64 0, i64 %23
%59 = load i32, i32* %58
%60 = getelementptr inbounds [4 x i32], [4 x i32]* %2, i64 1, i64 %23
%61 = load i32, i32* %60
%62 = icmp eq i32 %59, %61
br i1 %62, label %63, label %67
63: ; preds = %53
%64 = shl nsw i32 %59, 1
store i32 %64, i32* %58
store i32 0, i32* %60
%65 = call i32 @fillblank(i32 %0, i32 0, i32 %54, i32 0, i32** %21)
%66 = load i32, i32* %60
br label %67
67: ; preds = %53, %63
%68 = phi i32 [ %61, %53 ], [ %66, %63 ]
%69 = getelementptr inbounds [4 x i32], [4 x i32]* %2, i64 2, i64 %23
%70 = load i32, i32* %69
%71 = icmp eq i32 %68, %70
br i1 %71, label %72, label %76
72: ; preds = %67
%73 = shl nsw i32 %68, 1
store i32 %73, i32* %60
store i32 0, i32* %69
%74 = call i32 @fillblank(i32 %0, i32 0, i32 %54, i32 0, i32** %21)
%75 = load i32, i32* %69
br label %76
76: ; preds = %72, %67
%77 = phi i32 [ %75, %72 ], [ %70, %67 ]
%78 = getelementptr inbounds [4 x i32], [4 x i32]* %2, i64 3, i64 %23
%79 = load i32, i32* %78
%80 = icmp eq i32 %77, %79
br i1 %80, label %81, label %88
81: ; preds = %76, %47
%82 = phi i32 [ %48, %47 ], [ %77, %76 ]
%83 = phi i32* [ %40, %47 ], [ %69, %76 ]
%84 = phi i32* [ %49, %47 ], [ %78, %76 ]
%85 = phi i32 [ %25, %47 ], [ %54, %76 ]
%86 = shl nsw i32 %82, 1
store i32 %86, i32* %83
store i32 0, i32* %84
%87 = call i32 @fillblank(i32 %0, i32 0, i32 %85, i32 0, i32** %21)
br label %88
88: ; preds = %81, %76, %47, %52
%89 = add nuw nsw i64 %23, 1
%90 = icmp eq i64 %89, 4
br i1 %90, label %159, label %22
91: ; preds = %16
%92 = icmp eq i32 %0, 0
br i1 %92, label %93, label %159
93: ; preds = %91
%94 = icmp sgt i32 %1, 0
%95 = bitcast [4 x i32]* %2 to i32**
br label %96
96: ; preds = %93, %156
%97 = phi i64 [ 0, %93 ], [ %157, %156 ]
%98 = trunc i64 %97 to i32
%99 = call i32 @fillblank(i32 0, i32 %1, i32 0, i32 %98, i32** %95)
%100 = call i32 @fillblank(i32 0, i32 %1, i32 0, i32 %98, i32** %95)
%101 = call i32 @fillblank(i32 0, i32 %1, i32 0, i32 %98, i32** %95)
br i1 %94, label %108, label %102
102: ; preds = %96
%103 = getelementptr inbounds [4 x i32], [4 x i32]* %2, i64 %97, i64 0
%104 = load i32, i32* %103
%105 = getelementptr inbounds [4 x i32], [4 x i32]* %2, i64 %97, i64 1
%106 = load i32, i32* %105
%107 = icmp eq i32 %104, %106
br i1 %107, label %132, label %136
108: ; preds = %96
%109 = getelementptr inbounds [4 x i32], [4 x i32]* %2, i64 %97, i64 3
%110 = load i32, i32* %109
%111 = getelementptr inbounds [4 x i32], [4 x i32]* %2, i64 %97, i64 2
%112 = load i32, i32* %111
%113 = icmp eq i32 %110, %112
br i1 %113, label %114, label %118
114: ; preds = %108
%115 = shl nsw i32 %110, 1
store i32 %115, i32* %109
store i32 0, i32* %111
%116 = call i32 @fillblank(i32 0, i32 %1, i32 0, i32 %98, i32** %95)
%117 = load i32, i32* %111
br label %118
118: ; preds = %108, %114
%119 = phi i32 [ %112, %108 ], [ %117, %114 ]
%120 = getelementptr inbounds [4 x i32], [4 x i32]* %2, i64 %97, i64 1
%121 = load i32, i32* %120
%122 = icmp eq i32 %119, %121
br i1 %122, label %123, label %127
123: ; preds = %118
%124 = shl nsw i32 %119, 1
store i32 %124, i32* %111
store i32 0, i32* %120
%125 = call i32 @fillblank(i32 0, i32 %1, i32 0, i32 %98, i32** %95)
%126 = load i32, i32* %120
br label %127
127: ; preds = %123, %118
%128 = phi i32 [ %126, %123 ], [ %121, %118 ]
%129 = getelementptr inbounds [4 x i32], [4 x i32]* %2, i64 %97, i64 0
%130 = load i32, i32* %129
%131 = icmp eq i32 %128, %130
br i1 %131, label %150, label %156
132: ; preds = %102
%133 = shl nsw i32 %104, 1
store i32 %133, i32* %103
store i32 0, i32* %105
%134 = call i32 @fillblank(i32 0, i32 %1, i32 0, i32 %98, i32** %95)
%135 = load i32, i32* %105
br label %136
136: ; preds = %102, %132
%137 = phi i32 [ %106, %102 ], [ %135, %132 ]
%138 = getelementptr inbounds [4 x i32], [4 x i32]* %2, i64 %97, i64 2
%139 = load i32, i32* %138
%140 = icmp eq i32 %137, %139
br i1 %140, label %141, label %145
141: ; preds = %136
%142 = shl nsw i32 %137, 1
store i32 %142, i32* %105
store i32 0, i32* %138
%143 = call i32 @fillblank(i32 0, i32 %1, i32 0, i32 %98, i32** %95)
%144 = load i32, i32* %138
br label %145
145: ; preds = %141, %136
%146 = phi i32 [ %144, %141 ], [ %139, %136 ]
%147 = getelementptr inbounds [4 x i32], [4 x i32]* %2, i64 %97, i64 3
%148 = load i32, i32* %147
%149 = icmp eq i32 %146, %148
br i1 %149, label %150, label %156
150: ; preds = %145, %127
%151 = phi i32 [ %128, %127 ], [ %146, %145 ]
%152 = phi i32* [ %120, %127 ], [ %138, %145 ]
%153 = phi i32* [ %129, %127 ], [ %147, %145 ]
%154 = shl nsw i32 %151, 1
store i32 %154, i32* %152
store i32 0, i32* %153
%155 = call i32 @fillblank(i32 0, i32 %1, i32 0, i32 %98, i32** %95)
br label %156
156: ; preds = %150, %145, %127
%157 = add nuw nsw i64 %97, 1
%158 = icmp eq i64 %157, 4
br i1 %158, label %159, label %96
159: ; preds = %156, %88, %91, %8
%160 = phi i32 [ 0, %8 ], [ 1, %91 ], [ 1, %88 ], [ 1, %156 ]
ret i32 %160
}