#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 */
scalar_t__ abs(int);
scalar_t__ malloc(int);
int **queensAttacktheKing(int **queens, int queensSize, int *queensColSize,
                          int *king, int kingSize, int *returnSize,
                          int **returnColumnSizes) {
  int **target = (int **)malloc(sizeof(int *) * 8);
  int found[8] = {0};
  for (int i = 0; i < queensSize; i++) {
    if (queens[i][0] == king[0]) {
      int *tmp = (int *)malloc(sizeof(int) * 2);
      tmp[0] = queens[i][0];
      tmp[1] = queens[i][1];
      if (queens[i][1] > king[1]) {
        if (found[0]) {
          if (target[0][1] > queens[i][1])
            target[0] = tmp;
        } else {
          found[0] = 1;
          target[0] = tmp;
        }
      } else {
        if (found[1]) {
          if (target[1][1] < queens[i][1])
            target[1] = tmp;
        } else {
          found[1] = 1;
          target[1] = tmp;
        }
      }
    } else if (queens[i][1] == king[1]) {
      int *tmp = (int *)malloc(sizeof(int) * 2);
      tmp[0] = queens[i][0];
      tmp[1] = queens[i][1];
      if (queens[i][0] > king[0]) {
        if (found[2]) {
          if (target[2][0] > queens[i][0])
            target[2] = tmp;
        } else {
          found[2] = 1;
          target[2] = tmp;
        }
      } else {
        if (found[3]) {
          if (target[3][0] < queens[i][0])
            target[3] = tmp;
        } else {
          found[3] = 1;
          target[3] = tmp;
        }
      }
    } else if (abs(queens[i][0] - queens[i][1]) == abs(king[0] - king[1])) {
      int *tmp = (int *)malloc(sizeof(int) * 2);
      tmp[0] = queens[i][0];
      tmp[1] = queens[i][1];
      if (queens[i][0] > king[0]) {
        int index;
        if (queens[i][1] < king[1])
          index = 4;
        else
          index = 5;
        if (found[index]) {
          if (target[index][0] > queens[i][0])
            target[index] = tmp;
        } else {
          found[index] = 1;
          target[index] = tmp;
        }
      } else {
        int index;
        if (queens[i][1] < king[1])
          index = 6;
        else
          index = 7;
        if (found[index]) {
          if (target[index][0] < queens[i][0])
            target[index] = tmp;
        } else {
          found[index] = 1;
          target[index] = tmp;
        }
      }
    }
  }
  int cnt = 0;
  for (int i = 0; i < 8; i++) {
    if (found[i])
      target[cnt++] = target[i];
  }
  returnSize = (int *)malloc(sizeof(int));
  *returnSize = cnt;
  returnColumnSizes = (int **)malloc(sizeof(int *));
  *returnColumnSizes = (int *)malloc(sizeof(int));
  **returnColumnSizes = 2;
  return target;
}


x86 assembly (clang, -O0):
<queensAttacktheKing>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
mov    %r9,-0x30(%rbp)
mov    $0x40,%edi
call   1050 <malloc@plt>
mov    %rax,-0x38(%rbp)
lea    -0x60(%rbp),%rdi
xor    %esi,%esi
mov    $0x20,%edx
call   1040 <memset@plt>
movl   $0x0,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    15ca <queensAttacktheKing+0x49a>
mov    -0x8(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    (%rax),%eax
mov    -0x20(%rbp),%rcx
cmp    (%rcx),%eax
jne    129d <queensAttacktheKing+0x16d>
mov    $0x8,%edi
call   1050 <malloc@plt>
mov    %rax,-0x70(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    (%rax),%ecx
mov    -0x70(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x8(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x4(%rax),%ecx
mov    -0x70(%rbp),%rax
mov    %ecx,0x4(%rax)
mov    -0x8(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x4(%rax),%eax
mov    -0x20(%rbp),%rcx
cmp    0x4(%rcx),%eax
jle    1245 <queensAttacktheKing+0x115>
cmpl   $0x0,-0x60(%rbp)
je     122e <queensAttacktheKing+0xfe>
mov    -0x38(%rbp),%rax
mov    (%rax),%rax
mov    0x4(%rax),%eax
mov    -0x8(%rbp),%rcx
movslq -0x64(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
cmp    0x4(%rcx),%eax
jle    1229 <queensAttacktheKing+0xf9>
mov    -0x70(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    %rcx,(%rax)
jmp    1240 <queensAttacktheKing+0x110>
movl   $0x1,-0x60(%rbp)
mov    -0x70(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    %rcx,(%rax)
jmp    1298 <queensAttacktheKing+0x168>
cmpl   $0x0,-0x5c(%rbp)
je     1280 <queensAttacktheKing+0x150>
mov    -0x38(%rbp),%rax
mov    0x8(%rax),%rax
mov    0x4(%rax),%eax
mov    -0x8(%rbp),%rcx
movslq -0x64(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
cmp    0x4(%rcx),%eax
jge    127b <queensAttacktheKing+0x14b>
mov    -0x70(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    %rcx,0x8(%rax)
jmp    1293 <queensAttacktheKing+0x163>
movl   $0x1,-0x5c(%rbp)
mov    -0x70(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    %rcx,0x8(%rax)
jmp    1298 <queensAttacktheKing+0x168>
jmp    15b7 <queensAttacktheKing+0x487>
mov    -0x8(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x4(%rax),%eax
mov    -0x20(%rbp),%rcx
cmp    0x4(%rcx),%eax
jne    13b2 <queensAttacktheKing+0x282>
mov    $0x8,%edi
call   1050 <malloc@plt>
mov    %rax,-0x78(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    (%rax),%ecx
mov    -0x78(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x8(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x4(%rax),%ecx
mov    -0x78(%rbp),%rax
mov    %ecx,0x4(%rax)
mov    -0x8(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    (%rax),%eax
mov    -0x20(%rbp),%rcx
cmp    (%rcx),%eax
jle    135c <queensAttacktheKing+0x22c>
cmpl   $0x0,-0x58(%rbp)
je     1344 <queensAttacktheKing+0x214>
mov    -0x38(%rbp),%rax
mov    0x10(%rax),%rax
mov    (%rax),%eax
mov    -0x8(%rbp),%rcx
movslq -0x64(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
cmp    (%rcx),%eax
jle    133f <queensAttacktheKing+0x20f>
mov    -0x78(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    %rcx,0x10(%rax)
jmp    1357 <queensAttacktheKing+0x227>
movl   $0x1,-0x58(%rbp)
mov    -0x78(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    %rcx,0x10(%rax)
jmp    13ad <queensAttacktheKing+0x27d>
cmpl   $0x0,-0x54(%rbp)
je     1395 <queensAttacktheKing+0x265>
mov    -0x38(%rbp),%rax
mov    0x18(%rax),%rax
mov    (%rax),%eax
mov    -0x8(%rbp),%rcx
movslq -0x64(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
cmp    (%rcx),%eax
jge    1390 <queensAttacktheKing+0x260>
mov    -0x78(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    %rcx,0x18(%rax)
jmp    13a8 <queensAttacktheKing+0x278>
movl   $0x1,-0x54(%rbp)
mov    -0x78(%rbp),%rcx
mov    -0x38(%rbp),%rax
mov    %rcx,0x18(%rax)
jmp    13ad <queensAttacktheKing+0x27d>
jmp    15b2 <queensAttacktheKing+0x482>
mov    -0x8(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    (%rax),%edi
mov    -0x8(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
sub    0x4(%rax),%edi
call   1030 <abs@plt>
mov    %rax,-0x98(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%edi
mov    -0x20(%rbp),%rax
sub    0x4(%rax),%edi
call   1030 <abs@plt>
mov    %rax,%rcx
mov    -0x98(%rbp),%rax
cmp    %rcx,%rax
jne    15ad <queensAttacktheKing+0x47d>
mov    $0x8,%edi
call   1050 <malloc@plt>
mov    %rax,-0x80(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    (%rax),%ecx
mov    -0x80(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x8(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x4(%rax),%ecx
mov    -0x80(%rbp),%rax
mov    %ecx,0x4(%rax)
mov    -0x8(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    (%rax),%eax
mov    -0x20(%rbp),%rcx
cmp    (%rcx),%eax
jle    14fd <queensAttacktheKing+0x3cd>
mov    -0x8(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x4(%rax),%eax
mov    -0x20(%rbp),%rcx
cmp    0x4(%rcx),%eax
jge    147d <queensAttacktheKing+0x34d>
movl   $0x4,-0x84(%rbp)
jmp    1487 <queensAttacktheKing+0x357>
movl   $0x5,-0x84(%rbp)
movslq -0x84(%rbp),%rax
cmpl   $0x0,-0x60(%rbp,%rax,4)
je     14d6 <queensAttacktheKing+0x3a6>
mov    -0x38(%rbp),%rax
movslq -0x84(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    (%rax),%eax
mov    -0x8(%rbp),%rcx
movslq -0x64(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
cmp    (%rcx),%eax
jle    14d1 <queensAttacktheKing+0x3a1>
mov    -0x80(%rbp),%rdx
mov    -0x38(%rbp),%rax
movslq -0x84(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
jmp    14f8 <queensAttacktheKing+0x3c8>
movslq -0x84(%rbp),%rax
movl   $0x1,-0x60(%rbp,%rax,4)
mov    -0x80(%rbp),%rdx
mov    -0x38(%rbp),%rax
movslq -0x84(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
jmp    15a8 <queensAttacktheKing+0x478>
mov    -0x8(%rbp),%rax
movslq -0x64(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x4(%rax),%eax
mov    -0x20(%rbp),%rcx
cmp    0x4(%rcx),%eax
jge    1528 <queensAttacktheKing+0x3f8>
movl   $0x6,-0x88(%rbp)
jmp    1532 <queensAttacktheKing+0x402>
movl   $0x7,-0x88(%rbp)
movslq -0x88(%rbp),%rax
cmpl   $0x0,-0x60(%rbp,%rax,4)
je     1581 <queensAttacktheKing+0x451>
mov    -0x38(%rbp),%rax
movslq -0x88(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    (%rax),%eax
mov    -0x8(%rbp),%rcx
movslq -0x64(%rbp),%rdx
mov    (%rcx,%rdx,8),%rcx
cmp    (%rcx),%eax
jge    157c <queensAttacktheKing+0x44c>
mov    -0x80(%rbp),%rdx
mov    -0x38(%rbp),%rax
movslq -0x88(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
jmp    15a3 <queensAttacktheKing+0x473>
movslq -0x88(%rbp),%rax
movl   $0x1,-0x60(%rbp,%rax,4)
mov    -0x80(%rbp),%rdx
mov    -0x38(%rbp),%rax
movslq -0x88(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
jmp    15a8 <queensAttacktheKing+0x478>
jmp    15ad <queensAttacktheKing+0x47d>
jmp    15b2 <queensAttacktheKing+0x482>
jmp    15b7 <queensAttacktheKing+0x487>
jmp    15bc <queensAttacktheKing+0x48c>
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    117b <queensAttacktheKing+0x4b>
movl   $0x0,-0x8c(%rbp)
movl   $0x0,-0x90(%rbp)
cmpl   $0x8,-0x90(%rbp)
jge    1641 <queensAttacktheKing+0x511>
movslq -0x90(%rbp),%rax
cmpl   $0x0,-0x60(%rbp,%rax,4)
je     1628 <queensAttacktheKing+0x4f8>
mov    -0x38(%rbp),%rax
movslq -0x90(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x38(%rbp),%rax
mov    -0x8c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x8c(%rbp)
movslq %ecx,%rcx
mov    %rdx,(%rax,%rcx,8)
jmp    162d <queensAttacktheKing+0x4fd>
mov    -0x90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x90(%rbp)
jmp    15de <queensAttacktheKing+0x4ae>
mov    $0x4,%edi
call   1050 <malloc@plt>
mov    %rax,-0x30(%rbp)
mov    -0x8c(%rbp),%ecx
mov    -0x30(%rbp),%rax
mov    %ecx,(%rax)
mov    $0x8,%edi
call   1050 <malloc@plt>
mov    %rax,0x10(%rbp)
mov    $0x4,%edi
call   1050 <malloc@plt>
mov    %rax,%rcx
mov    0x10(%rbp),%rax
mov    %rcx,(%rax)
mov    0x10(%rbp),%rax
mov    (%rax),%rax
movl   $0x2,(%rax)
mov    -0x38(%rbp),%rax
add    $0xa0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<queensAttacktheKing>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %rcx,%rbx
mov    %esi,%ebp
mov    %rdi,%r15
mov    $0x40,%edi
call   1040 <malloc@plt>
mov    %rax,%r14
xorps  %xmm0,%xmm0
movaps %xmm0,0x30(%rsp)
movaps %xmm0,0x20(%rsp)
test   %ebp,%ebp
jle    144d <queensAttacktheKing+0x32d>
mov    %ebp,%ebp
xor    %r12d,%r12d
xor    %r13d,%r13d
movl   $0x0,0x14(%rsp)
movl   $0x0,0xc(%rsp)
movl   $0x0,0x10(%rsp)
mov    %rbp,0x18(%rsp)
jmp    119d <queensAttacktheKing+0x7d>
movl   $0x1,0x20(%rsp,%rdx,4)
mov    %rax,(%r14,%rdx,8)
mov    0x18(%rsp),%rbp
add    $0x1,%r12
cmp    %r12,%rbp
je     1357 <queensAttacktheKing+0x237>
mov    (%r15,%r12,8),%rax
mov    (%rax),%edi
cmp    (%rbx),%edi
jne    11e0 <queensAttacktheKing+0xc0>
mov    $0x8,%edi
call   1040 <malloc@plt>
mov    (%r15,%r12,8),%rcx
mov    (%rcx),%edx
mov    %edx,(%rax)
mov    0x4(%rcx),%edx
mov    %edx,0x4(%rax)
mov    0x4(%rcx),%ecx
cmp    0x4(%rbx),%ecx
jle    1230 <queensAttacktheKing+0x110>
test   %r13d,%r13d
je     12e6 <queensAttacktheKing+0x1c6>
mov    (%r14),%rdx
cmp    %ecx,0x4(%rdx)
jle    1190 <queensAttacktheKing+0x70>
mov    %rax,(%r14)
jmp    1190 <queensAttacktheKing+0x70>
nopl   (%rax)
mov    0x4(%rax),%eax
cmp    0x4(%rbx),%eax
jne    1260 <queensAttacktheKing+0x140>
mov    $0x8,%edi
call   1040 <malloc@plt>
mov    (%r15,%r12,8),%rcx
mov    (%rcx),%edx
mov    %edx,(%rax)
mov    0x4(%rcx),%edx
mov    %edx,0x4(%rax)
mov    (%rcx),%ecx
cmp    (%rbx),%ecx
jle    12ca <queensAttacktheKing+0x1aa>
cmpl   $0x0,0xc(%rsp)
je     1335 <queensAttacktheKing+0x215>
mov    0x10(%r14),%rdx
cmp    %ecx,(%rdx)
jle    1190 <queensAttacktheKing+0x70>
mov    %rax,0x10(%r14)
jmp    1190 <queensAttacktheKing+0x70>
nopw   0x0(%rax,%rax,1)
cmpl   $0x0,0x14(%rsp)
je     12f4 <queensAttacktheKing+0x1d4>
mov    0x8(%r14),%rdx
cmp    %ecx,0x4(%rdx)
jge    1190 <queensAttacktheKing+0x70>
mov    %rax,0x8(%r14)
jmp    1190 <queensAttacktheKing+0x70>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
sub    %eax,%edi
call   1030 <abs@plt>
mov    %rax,%rbp
mov    (%rbx),%edi
sub    0x4(%rbx),%edi
call   1030 <abs@plt>
cmp    %rax,%rbp
jne    118b <queensAttacktheKing+0x6b>
mov    $0x8,%edi
call   1040 <malloc@plt>
mov    (%r15,%r12,8),%rdx
mov    (%rdx),%ecx
mov    %ecx,(%rax)
mov    0x4(%rdx),%ecx
mov    %ecx,0x4(%rax)
mov    (%rdx),%ecx
mov    0x4(%rdx),%esi
mov    0x4(%rbx),%edi
cmp    (%rbx),%ecx
jle    1305 <queensAttacktheKing+0x1e5>
xor    %edx,%edx
cmp    %edi,%esi
setl   %dl
xor    $0x5,%rdx
cmpl   $0x0,0x20(%rsp,%rdx,4)
je     117f <queensAttacktheKing+0x5f>
mov    (%r14,%rdx,8),%rsi
cmp    %ecx,(%rsi)
mov    0x18(%rsp),%rbp
jle    1190 <queensAttacktheKing+0x70>
jmp    132c <queensAttacktheKing+0x20c>
cmpl   $0x0,0x10(%rsp)
je     1346 <queensAttacktheKing+0x226>
mov    0x18(%r14),%rdx
cmp    %ecx,(%rdx)
jge    1190 <queensAttacktheKing+0x70>
mov    %rax,0x18(%r14)
jmp    1190 <queensAttacktheKing+0x70>
mov    %rax,(%r14)
mov    $0x1,%r13d
jmp    1190 <queensAttacktheKing+0x70>
mov    %rax,0x8(%r14)
movl   $0x1,0x14(%rsp)
jmp    1190 <queensAttacktheKing+0x70>
xor    %edx,%edx
cmp    %edi,%esi
setl   %dl
xor    $0x7,%rdx
cmpl   $0x0,0x20(%rsp,%rdx,4)
je     117f <queensAttacktheKing+0x5f>
mov    (%r14,%rdx,8),%rsi
cmp    %ecx,(%rsi)
mov    0x18(%rsp),%rbp
jge    1190 <queensAttacktheKing+0x70>
mov    %rax,(%r14,%rdx,8)
jmp    1190 <queensAttacktheKing+0x70>
mov    %rax,0x10(%r14)
movl   $0x1,0xc(%rsp)
jmp    1190 <queensAttacktheKing+0x70>
mov    %rax,0x18(%r14)
movl   $0x1,0x10(%rsp)
jmp    1190 <queensAttacktheKing+0x70>
mov    0x10(%rsp),%eax
mov    %eax,0x2c(%rsp)
mov    0xc(%rsp),%eax
mov    %eax,0x28(%rsp)
mov    0x14(%rsp),%ecx
mov    %ecx,0x24(%rsp)
mov    %r13d,0x20(%rsp)
xor    %ebx,%ebx
test   %r13d,%r13d
setne  %al
test   %ecx,%ecx
je     145f <queensAttacktheKing+0x33f>
xor    %eax,%eax
test   %r13d,%r13d
setne  %al
mov    0x8(%r14),%rcx
lea    0x1(%rax),%ebx
mov    %rcx,(%r14,%rax,8)
cmpl   $0x0,0xc(%rsp)
je     13ab <queensAttacktheKing+0x28b>
mov    0x10(%r14),%rax
mov    %ebx,%ecx
add    $0x1,%ebx
mov    %rax,(%r14,%rcx,8)
cmpl   $0x0,0x10(%rsp)
je     13bf <queensAttacktheKing+0x29f>
mov    0x18(%r14),%rax
mov    %ebx,%ecx
add    $0x1,%ebx
mov    %rax,(%r14,%rcx,8)
cmpl   $0x0,0x30(%rsp)
je     13d3 <queensAttacktheKing+0x2b3>
mov    0x20(%r14),%rax
mov    %ebx,%ecx
add    $0x1,%ebx
mov    %rax,(%r14,%rcx,8)
cmpl   $0x0,0x34(%rsp)
je     13e7 <queensAttacktheKing+0x2c7>
mov    0x28(%r14),%rax
mov    %ebx,%ecx
add    $0x1,%ebx
mov    %rax,(%r14,%rcx,8)
cmpl   $0x0,0x38(%rsp)
je     13fb <queensAttacktheKing+0x2db>
mov    0x30(%r14),%rax
mov    %ebx,%ecx
add    $0x1,%ebx
mov    %rax,(%r14,%rcx,8)
cmpl   $0x0,0x3c(%rsp)
je     140f <queensAttacktheKing+0x2ef>
mov    0x38(%r14),%rax
mov    %ebx,%ecx
add    $0x1,%ebx
mov    %rax,(%r14,%rcx,8)
mov    $0x4,%edi
call   1040 <malloc@plt>
mov    %ebx,(%rax)
mov    $0x8,%edi
call   1040 <malloc@plt>
mov    %rax,%rbx
mov    $0x4,%edi
call   1040 <malloc@plt>
mov    %rax,(%rbx)
movl   $0x2,(%rax)
mov    %r14,%rax
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %ebx,%ebx
cmpl   $0x0,0x30(%rsp)
jne    13c6 <queensAttacktheKing+0x2a6>
jmp    13d3 <queensAttacktheKing+0x2b3>
mov    %al,%bl
cmpl   $0x0,0xc(%rsp)
jne    139e <queensAttacktheKing+0x27e>
jmp    13ab <queensAttacktheKing+0x28b>

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

LLVM IR (-O2):
define i32** @queensAttacktheKing(i32** nocapture %0, i32 %1, i32* nocapture readnone %2, i32* nocapture %3, i32 %4, i32* nocapture readnone %5, i32** nocapture readnone %6) {
%8 = alloca [8 x i32]
%9 = tail call i64 @malloc(i32 64)
%10 = inttoptr i64 %9 to i32**
%11 = bitcast [8 x i32]* %8 to i8*
%12 = icmp sgt i32 %1, 0
br i1 %12, label %13, label %178
13: ; preds = %7
%14 = getelementptr inbounds i32, i32* %3, i64 1
%15 = getelementptr inbounds [8 x i32], [8 x i32]* %8, i64 0, i64 3
%16 = getelementptr inbounds i32*, i32** %10, i64 3
%17 = getelementptr inbounds [8 x i32], [8 x i32]* %8, i64 0, i64 2
%18 = getelementptr inbounds i32*, i32** %10, i64 2
%19 = getelementptr inbounds [8 x i32], [8 x i32]* %8, i64 0, i64 1
%20 = getelementptr inbounds i32*, i32** %10, i64 1
%21 = getelementptr inbounds [8 x i32], [8 x i32]* %8, i64 0, i64 0
%22 = zext i32 %1 to i64
br label %27
23: ; preds = %147
store i32 %151, i32* %15
store i32 %150, i32* %17
store i32 %149, i32* %19
store i32 %148, i32* %21
%24 = icmp ne i32 %148, 0
%25 = zext i1 %24 to i32
%26 = icmp eq i32 %149, 0
br i1 %26, label %160, label %154
27: ; preds = %13, %147
%28 = phi i64 [ 0, %13 ], [ %152, %147 ]
%29 = phi i32 [ 0, %13 ], [ %148, %147 ]
%30 = phi i32 [ 0, %13 ], [ %149, %147 ]
%31 = phi i32 [ 0, %13 ], [ %150, %147 ]
%32 = phi i32 [ 0, %13 ], [ %151, %147 ]
%33 = getelementptr inbounds i32*, i32** %0, i64 %28
%34 = load i32*, i32** %33
%35 = load i32, i32* %34
%36 = load i32, i32* %3
%37 = icmp eq i32 %35, %36
br i1 %37, label %38, label %67
38: ; preds = %27
%39 = tail call i64 @malloc(i32 8)
%40 = inttoptr i64 %39 to i32*
%41 = load i32*, i32** %33
%42 = load i32, i32* %41
store i32 %42, i32* %40
%43 = getelementptr inbounds i32, i32* %41, i64 1
%44 = load i32, i32* %43
%45 = getelementptr inbounds i32, i32* %40, i64 1
store i32 %44, i32* %45
%46 = load i32, i32* %43
%47 = load i32, i32* %14
%48 = icmp sgt i32 %46, %47
br i1 %48, label %49, label %58
49: ; preds = %38
%50 = icmp eq i32 %29, 0
br i1 %50, label %57, label %51
51: ; preds = %49
%52 = load i32*, i32** %10
%53 = getelementptr inbounds i32, i32* %52, i64 1
%54 = load i32, i32* %53
%55 = icmp sgt i32 %54, %46
br i1 %55, label %56, label %147
56: ; preds = %51
store i32* %40, i32** %10
br label %147
57: ; preds = %49
store i32* %40, i32** %10
br label %147
58: ; preds = %38
%59 = icmp eq i32 %30, 0
br i1 %59, label %66, label %60
60: ; preds = %58
%61 = load i32*, i32** %20
%62 = getelementptr inbounds i32, i32* %61, i64 1
%63 = load i32, i32* %62
%64 = icmp slt i32 %63, %46
br i1 %64, label %65, label %147
65: ; preds = %60
store i32* %40, i32** %20
br label %147
66: ; preds = %58
store i32* %40, i32** %20
br label %147
67: ; preds = %27
%68 = getelementptr inbounds i32, i32* %34, i64 1
%69 = load i32, i32* %68
%70 = load i32, i32* %14
%71 = icmp eq i32 %69, %70
br i1 %71, label %72, label %99
72: ; preds = %67
%73 = tail call i64 @malloc(i32 8)
%74 = inttoptr i64 %73 to i32*
%75 = load i32*, i32** %33
%76 = load i32, i32* %75
store i32 %76, i32* %74
%77 = getelementptr inbounds i32, i32* %75, i64 1
%78 = load i32, i32* %77
%79 = getelementptr inbounds i32, i32* %74, i64 1
store i32 %78, i32* %79
%80 = load i32, i32* %75
%81 = load i32, i32* %3
%82 = icmp sgt i32 %80, %81
br i1 %82, label %83, label %91
83: ; preds = %72
%84 = icmp eq i32 %31, 0
br i1 %84, label %90, label %85
85: ; preds = %83
%86 = load i32*, i32** %18
%87 = load i32, i32* %86
%88 = icmp sgt i32 %87, %80
br i1 %88, label %89, label %147
89: ; preds = %85
store i32* %74, i32** %18
br label %147
90: ; preds = %83
store i32* %74, i32** %18
br label %147
91: ; preds = %72
%92 = icmp eq i32 %32, 0
br i1 %92, label %98, label %93
93: ; preds = %91
%94 = load i32*, i32** %16
%95 = load i32, i32* %94
%96 = icmp slt i32 %95, %80
br i1 %96, label %97, label %147
97: ; preds = %93
store i32* %74, i32** %16
br label %147
98: ; preds = %91
store i32* %74, i32** %16
br label %147
99: ; preds = %67
%100 = sub nsw i32 %35, %69
%101 = tail call i64 @abs(i32 %100)
%102 = load i32, i32* %3
%103 = load i32, i32* %14
%104 = sub nsw i32 %102, %103
%105 = tail call i64 @abs(i32 %104)
%106 = icmp eq i64 %101, %105
br i1 %106, label %107, label %147
107: ; preds = %99
%108 = tail call i64 @malloc(i32 8)
%109 = inttoptr i64 %108 to i32*
%110 = load i32*, i32** %33
%111 = load i32, i32* %110
store i32 %111, i32* %109
%112 = getelementptr inbounds i32, i32* %110, i64 1
%113 = load i32, i32* %112
%114 = getelementptr inbounds i32, i32* %109, i64 1
store i32 %113, i32* %114
%115 = load i32, i32* %110
%116 = load i32, i32* %3
%117 = icmp sgt i32 %115, %116
%118 = load i32, i32* %112
%119 = load i32, i32* %14
%120 = icmp slt i32 %118, %119
br i1 %117, label %121, label %134
121: ; preds = %107
%122 = select i1 %120, i64 4, i64 5
%123 = getelementptr inbounds [8 x i32], [8 x i32]* %8, i64 0, i64 %122
%124 = load i32, i32* %123
%125 = icmp eq i32 %124, 0
br i1 %125, label %132, label %126
126: ; preds = %121
%127 = getelementptr inbounds i32*, i32** %10, i64 %122
%128 = load i32*, i32** %127
%129 = load i32, i32* %128
%130 = icmp sgt i32 %129, %115
br i1 %130, label %131, label %147
131: ; preds = %126
store i32* %109, i32** %127
br label %147
132: ; preds = %121
store i32 1, i32* %123
%133 = getelementptr inbounds i32*, i32** %10, i64 %122
store i32* %109, i32** %133
br label %147
134: ; preds = %107
%135 = select i1 %120, i64 6, i64 7
%136 = getelementptr inbounds [8 x i32], [8 x i32]* %8, i64 0, i64 %135
%137 = load i32, i32* %136
%138 = icmp eq i32 %137, 0
br i1 %138, label %145, label %139
139: ; preds = %134
%140 = getelementptr inbounds i32*, i32** %10, i64 %135
%141 = load i32*, i32** %140
%142 = load i32, i32* %141
%143 = icmp slt i32 %142, %115
br i1 %143, label %144, label %147
144: ; preds = %139
store i32* %109, i32** %140
br label %147
145: ; preds = %134
store i32 1, i32* %136
%146 = getelementptr inbounds i32*, i32** %10, i64 %135
store i32* %109, i32** %146
br label %147
147: ; preds = %126, %131, %132, %139, %144, %145, %85, %89, %90, %93, %97, %98, %51, %56, %57, %60, %65, %66, %99
%148 = phi i32 [ %29, %126 ], [ %29, %131 ], [ %29, %132 ], [ %29, %139 ], [ %29, %144 ], [ %29, %145 ], [ %29, %85 ], [ %29, %89 ], [ %29, %90 ], [ %29, %93 ], [ %29, %97 ], [ %29, %98 ], [ %29, %51 ], [ %29, %56 ], [ 1, %57 ], [ %29, %60 ], [ %29, %65 ], [ %29, %66 ], [ %29, %99 ]
%149 = phi i32 [ %30, %126 ], [ %30, %131 ], [ %30, %132 ], [ %30, %139 ], [ %30, %144 ], [ %30, %145 ], [ %30, %85 ], [ %30, %89 ], [ %30, %90 ], [ %30, %93 ], [ %30, %97 ], [ %30, %98 ], [ %30, %51 ], [ %30, %56 ], [ %30, %57 ], [ %30, %60 ], [ %30, %65 ], [ 1, %66 ], [ %30, %99 ]
%150 = phi i32 [ %31, %126 ], [ %31, %131 ], [ %31, %132 ], [ %31, %139 ], [ %31, %144 ], [ %31, %145 ], [ %31, %85 ], [ %31, %89 ], [ 1, %90 ], [ %31, %93 ], [ %31, %97 ], [ %31, %98 ], [ %31, %51 ], [ %31, %56 ], [ %31, %57 ], [ %31, %60 ], [ %31, %65 ], [ %31, %66 ], [ %31, %99 ]
%151 = phi i32 [ %32, %126 ], [ %32, %131 ], [ %32, %132 ], [ %32, %139 ], [ %32, %144 ], [ %32, %145 ], [ %32, %85 ], [ %32, %89 ], [ %32, %90 ], [ %32, %93 ], [ %32, %97 ], [ 1, %98 ], [ %32, %51 ], [ %32, %56 ], [ %32, %57 ], [ %32, %60 ], [ %32, %65 ], [ %32, %66 ], [ %32, %99 ]
%152 = add nuw nsw i64 %28, 1
%153 = icmp eq i64 %152, %22
br i1 %153, label %23, label %27
154: ; preds = %23
%155 = getelementptr inbounds i32*, i32** %10, i64 1
%156 = load i32*, i32** %155
%157 = select i1 %24, i32 2, i32 1
%158 = zext i1 %24 to i64
%159 = getelementptr inbounds i32*, i32** %10, i64 %158
store i32* %156, i32** %159
br label %160
160: ; preds = %154, %23
%161 = phi i32 [ %157, %154 ], [ %25, %23 ]
%162 = icmp eq i32 %150, 0
br i1 %162, label %169, label %163
163: ; preds = %160
%164 = getelementptr inbounds i32*, i32** %10, i64 2
%165 = load i32*, i32** %164
%166 = add nuw nsw i32 %161, 1
%167 = zext i32 %161 to i64
%168 = getelementptr inbounds i32*, i32** %10, i64 %167
store i32* %165, i32** %168
br label %169
169: ; preds = %163, %160
%170 = phi i32 [ %166, %163 ], [ %161, %160 ]
%171 = icmp eq i32 %151, 0
br i1 %171, label %178, label %172
172: ; preds = %169
%173 = getelementptr inbounds i32*, i32** %10, i64 3
%174 = load i32*, i32** %173
%175 = add nuw nsw i32 %170, 1
%176 = zext i32 %170 to i64
%177 = getelementptr inbounds i32*, i32** %10, i64 %176
store i32* %174, i32** %177
br label %178
178: ; preds = %7, %172, %169
%179 = phi i32 [ %175, %172 ], [ %170, %169 ], [ 0, %7 ]
%180 = getelementptr inbounds [8 x i32], [8 x i32]* %8, i64 0, i64 4
%181 = load i32, i32* %180
%182 = icmp eq i32 %181, 0
br i1 %182, label %189, label %183
183: ; preds = %178
%184 = getelementptr inbounds i32*, i32** %10, i64 4
%185 = load i32*, i32** %184
%186 = add nuw nsw i32 %179, 1
%187 = zext i32 %179 to i64
%188 = getelementptr inbounds i32*, i32** %10, i64 %187
store i32* %185, i32** %188
br label %189
189: ; preds = %183, %178
%190 = phi i32 [ %186, %183 ], [ %179, %178 ]
%191 = getelementptr inbounds [8 x i32], [8 x i32]* %8, i64 0, i64 5
%192 = load i32, i32* %191
%193 = icmp eq i32 %192, 0
br i1 %193, label %200, label %194
194: ; preds = %189
%195 = getelementptr inbounds i32*, i32** %10, i64 5
%196 = load i32*, i32** %195
%197 = add nuw nsw i32 %190, 1
%198 = zext i32 %190 to i64
%199 = getelementptr inbounds i32*, i32** %10, i64 %198
store i32* %196, i32** %199
br label %200
200: ; preds = %194, %189
%201 = phi i32 [ %197, %194 ], [ %190, %189 ]
%202 = getelementptr inbounds [8 x i32], [8 x i32]* %8, i64 0, i64 6
%203 = load i32, i32* %202
%204 = icmp eq i32 %203, 0
br i1 %204, label %211, label %205
205: ; preds = %200
%206 = getelementptr inbounds i32*, i32** %10, i64 6
%207 = load i32*, i32** %206
%208 = add nuw nsw i32 %201, 1
%209 = zext i32 %201 to i64
%210 = getelementptr inbounds i32*, i32** %10, i64 %209
store i32* %207, i32** %210
br label %211
211: ; preds = %205, %200
%212 = phi i32 [ %208, %205 ], [ %201, %200 ]
%213 = getelementptr inbounds [8 x i32], [8 x i32]* %8, i64 0, i64 7
%214 = load i32, i32* %213
%215 = icmp eq i32 %214, 0
br i1 %215, label %222, label %216
216: ; preds = %211
%217 = getelementptr inbounds i32*, i32** %10, i64 7
%218 = load i32*, i32** %217
%219 = add nuw nsw i32 %212, 1
%220 = zext i32 %212 to i64
%221 = getelementptr inbounds i32*, i32** %10, i64 %220
store i32* %218, i32** %221
br label %222
222: ; preds = %216, %211
%223 = phi i32 [ %219, %216 ], [ %212, %211 ]
%224 = tail call i64 @malloc(i32 4)
%225 = inttoptr i64 %224 to i32*
store i32 %223, i32* %225
%226 = tail call i64 @malloc(i32 8)
%227 = inttoptr i64 %226 to i32**
%228 = tail call i64 @malloc(i32 4)
%229 = inttoptr i64 %228 to i32*
store i32* %229, i32** %227
store i32 2, i32* %229
ret i32** %10
}