#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 exclude(int **, int ***, int, int, int);
int /*<<< orphan*/ memset(int *, int /*<<< orphan*/, int);
int /*<<< orphan*/ printf(char *, int, int, ...);
int groupDetermine(int sudoku[9][9], int aux[10][9][9]) {
  int sudokuType;
  int blocki, blockj;
  int i, j, k;
  int counter[10];
  int numlist[10];
  for (blocki = 0; blocki < 9; blocki += 3) {
    for (blockj = 0; blockj < 9; blockj += 3) {
      memset(counter, 0, 10 * sizeof(int));
      memset(numlist, 0, 10 * sizeof(int));
      for (i = blocki; i < blocki + 3; i++) {
        for (j = blockj; j < blockj + 3; j++) {
          if (0 != sudoku[i][j]) {
            numlist[sudoku[i][j]] = 1;
          }
          for (k = 1; k < 10; k++) {
            if (0 == aux[k][i][j]) {
              counter[k]++;
            }
          }
        }
      }
      for (k = 1; k < 10; k++) {
        if (0 == numlist[k] && 0 == counter[k]) {
          printf("Error! Block (%d, %d) has lost number %d.\n", blocki, blockj,
                 k);
          return 2;
        }
      }
      for (k = 1; k < 10; k++) {
        if (1 == counter[k]) {
          for (i = blocki; i < blocki + 3; i++) {
            for (j = blockj; j < blockj + 3; j++) {
              if (0 == aux[k][i][j]) {
                printf("Block determined, %d at (%d, %d)\n", k, i, j);
                sudoku[i][j] = k;
                sudokuType = exclude(sudoku, aux, i, j, k);
                return 0;
              }
            }
          }
        }
      }
    }
  }
  for (i = 0; i < 9; i++) {
    memset(counter, 0, 10 * sizeof(int));
    memset(numlist, 0, 10 * sizeof(int));
    for (j = 0; j < 9; j++) {
      for (k = 1; k < 10; k++) {
        if (0 != sudoku[i][j]) {
          numlist[sudoku[i][j]] = 1;
        }
        if (0 == aux[k][i][j]) {
          counter[k]++;
        }
      }
    }
    for (k = 1; k < 10; k++) {
      if (0 == numlist[k] && 0 == counter[k]) {
        printf("Error! Row %d has lost number %d.\n", i, k);
        return 2;
      }
    }
    for (k = 1; k < 10; k++) {
      if (1 == counter[k]) {
        for (j = 0; j < 9; j++) {
          if (0 == aux[k][i][j]) {
            printf("Row determined, %d at (%d, %d)\n", k, i, j);
            sudoku[i][j] = k;
            sudokuType = exclude(sudoku, aux, i, j, k);
            return 0;
          }
        }
      }
    }
  }
  for (j = 0; j < 9; j++) {
    memset(counter, 0, 10 * sizeof(int));
    memset(numlist, 0, 10 * sizeof(int));
    for (i = 0; i < 9; i++) {
      for (k = 1; k < 10; k++) {
        if (0 != sudoku[i][j]) {
          numlist[sudoku[i][j]] = 1;
        }
        if (0 == aux[k][i][j]) {
          counter[k]++;
        }
      }
    }
    for (k = 1; k < 10; k++) {
      if (0 == numlist[k] && 0 == counter[k]) {
        printf("Error! Column %d has lost number %d.\n", j, k);
        return 2;
      }
    }
    for (k = 1; k < 10; k++) {
      if (1 == counter[k]) {
        for (i = 0; i < 9; i++) {
          if (0 == aux[k][i][j]) {
            printf("Column determined, %d at (%d, %d)\n", k, i, j);
            sudoku[i][j] = k;
            sudokuType = exclude(sudoku, aux, i, j, k);
            return 0;
          }
        }
      }
    }
  }
  return 1;
}


x86 assembly (clang, -O0):
<groupDetermine>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
movl   $0x0,-0x20(%rbp)
cmpl   $0x9,-0x20(%rbp)
jge    141d <groupDetermine+0x2ed>
movl   $0x0,-0x24(%rbp)
cmpl   $0x9,-0x24(%rbp)
jge    140a <groupDetermine+0x2da>
lea    -0x60(%rbp),%rdi
xor    %esi,%esi
mov    $0x28,%edx
call   1050 <memset@plt>
lea    -0x90(%rbp),%rdi
xor    %esi,%esi
mov    $0x28,%edx
call   1050 <memset@plt>
mov    -0x20(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x20(%rbp),%ecx
add    $0x3,%ecx
cmp    %ecx,%eax
jge    127b <groupDetermine+0x14b>
mov    -0x24(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x24(%rbp),%ecx
add    $0x3,%ecx
cmp    %ecx,%eax
jge    1268 <groupDetermine+0x138>
mov    -0x10(%rbp),%rcx
movslq -0x28(%rbp),%rax
imul   $0x24,%rax,%rax
add    %rax,%rcx
movslq -0x2c(%rbp),%rdx
xor    %eax,%eax
cmp    (%rcx,%rdx,4),%eax
je     11f6 <groupDetermine+0xc6>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
imul   $0x24,%rcx,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
movslq (%rax,%rcx,4),%rax
movl   $0x1,-0x90(%rbp,%rax,4)
movl   $0x1,-0x30(%rbp)
cmpl   $0xa,-0x30(%rbp)
jge    1255 <groupDetermine+0x125>
mov    -0x18(%rbp),%rcx
movslq -0x30(%rbp),%rax
imul   $0x144,%rax,%rax
add    %rax,%rcx
movslq -0x28(%rbp),%rax
imul   $0x24,%rax,%rax
add    %rax,%rcx
movslq -0x2c(%rbp),%rdx
xor    %eax,%eax
cmp    (%rcx,%rdx,4),%eax
jne    1242 <groupDetermine+0x112>
movslq -0x30(%rbp),%rax
mov    -0x60(%rbp,%rax,4),%ecx
add    $0x1,%ecx
mov    %ecx,-0x60(%rbp,%rax,4)
jmp    1247 <groupDetermine+0x117>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11fd <groupDetermine+0xcd>
jmp    125a <groupDetermine+0x12a>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11a5 <groupDetermine+0x75>
jmp    126d <groupDetermine+0x13d>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    118e <groupDetermine+0x5e>
movl   $0x1,-0x30(%rbp)
cmpl   $0xa,-0x30(%rbp)
jge    12e5 <groupDetermine+0x1b5>
movslq -0x30(%rbp),%rcx
xor    %eax,%eax
cmp    -0x90(%rbp,%rcx,4),%eax
jne    12d2 <groupDetermine+0x1a2>
movslq -0x30(%rbp),%rcx
xor    %eax,%eax
cmp    -0x60(%rbp,%rcx,4),%eax
jne    12d2 <groupDetermine+0x1a2>
mov    -0x20(%rbp),%esi
mov    -0x24(%rbp),%edx
mov    -0x30(%rbp),%ecx
lea    0xd41(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x2,-0x4(%rbp)
jmp    18ca <groupDetermine+0x79a>
jmp    12d7 <groupDetermine+0x1a7>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1282 <groupDetermine+0x152>
movl   $0x1,-0x30(%rbp)
cmpl   $0xa,-0x30(%rbp)
jge    13f7 <groupDetermine+0x2c7>
movslq -0x30(%rbp),%rcx
mov    $0x1,%eax
cmp    -0x60(%rbp,%rcx,4),%eax
jne    13e4 <groupDetermine+0x2b4>
mov    -0x20(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x20(%rbp),%ecx
add    $0x3,%ecx
cmp    %ecx,%eax
jge    13df <groupDetermine+0x2af>
mov    -0x24(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x24(%rbp),%ecx
add    $0x3,%ecx
cmp    %ecx,%eax
jge    13cc <groupDetermine+0x29c>
mov    -0x18(%rbp),%rcx
movslq -0x30(%rbp),%rax
imul   $0x144,%rax,%rax
add    %rax,%rcx
movslq -0x28(%rbp),%rax
imul   $0x24,%rax,%rax
add    %rax,%rcx
movslq -0x2c(%rbp),%rdx
xor    %eax,%eax
cmp    (%rcx,%rdx,4),%eax
jne    13b9 <groupDetermine+0x289>
mov    -0x30(%rbp),%esi
mov    -0x28(%rbp),%edx
mov    -0x2c(%rbp),%ecx
lea    0xcb8(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x30(%rbp),%edx
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
imul   $0x24,%rcx,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x28(%rbp),%edx
mov    -0x2c(%rbp),%ecx
mov    -0x30(%rbp),%r8d
call   1040 <exclude@plt>
mov    %eax,-0x1c(%rbp)
movl   $0x0,-0x4(%rbp)
jmp    18ca <groupDetermine+0x79a>
jmp    13be <groupDetermine+0x28e>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1326 <groupDetermine+0x1f6>
jmp    13d1 <groupDetermine+0x2a1>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    130f <groupDetermine+0x1df>
jmp    13e4 <groupDetermine+0x2b4>
jmp    13e9 <groupDetermine+0x2b9>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    12ec <groupDetermine+0x1bc>
jmp    13fc <groupDetermine+0x2cc>
mov    -0x24(%rbp),%eax
add    $0x3,%eax
mov    %eax,-0x24(%rbp)
jmp    115b <groupDetermine+0x2b>
jmp    140f <groupDetermine+0x2df>
mov    -0x20(%rbp),%eax
add    $0x3,%eax
mov    %eax,-0x20(%rbp)
jmp    114a <groupDetermine+0x1a>
movl   $0x0,-0x28(%rbp)
cmpl   $0x9,-0x28(%rbp)
jge    1670 <groupDetermine+0x540>
lea    -0x60(%rbp),%rdi
xor    %esi,%esi
mov    $0x28,%edx
call   1050 <memset@plt>
lea    -0x90(%rbp),%rdi
xor    %esi,%esi
mov    $0x28,%edx
call   1050 <memset@plt>
movl   $0x0,-0x2c(%rbp)
cmpl   $0x9,-0x2c(%rbp)
jge    1514 <groupDetermine+0x3e4>
movl   $0x1,-0x30(%rbp)
cmpl   $0xa,-0x30(%rbp)
jge    1501 <groupDetermine+0x3d1>
mov    -0x10(%rbp),%rcx
movslq -0x28(%rbp),%rax
imul   $0x24,%rax,%rax
add    %rax,%rcx
movslq -0x2c(%rbp),%rdx
xor    %eax,%eax
cmp    (%rcx,%rdx,4),%eax
je     14b3 <groupDetermine+0x383>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
imul   $0x24,%rcx,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
movslq (%rax,%rcx,4),%rax
movl   $0x1,-0x90(%rbp,%rax,4)
mov    -0x18(%rbp),%rcx
movslq -0x30(%rbp),%rax
imul   $0x144,%rax,%rax
add    %rax,%rcx
movslq -0x28(%rbp),%rax
imul   $0x24,%rax,%rax
add    %rax,%rcx
movslq -0x2c(%rbp),%rdx
xor    %eax,%eax
cmp    (%rcx,%rdx,4),%eax
jne    14ee <groupDetermine+0x3be>
movslq -0x30(%rbp),%rax
mov    -0x60(%rbp,%rax,4),%ecx
add    $0x1,%ecx
mov    %ecx,-0x60(%rbp,%rax,4)
jmp    14f3 <groupDetermine+0x3c3>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1469 <groupDetermine+0x339>
jmp    1506 <groupDetermine+0x3d6>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1458 <groupDetermine+0x328>
movl   $0x1,-0x30(%rbp)
cmpl   $0xa,-0x30(%rbp)
jge    157b <groupDetermine+0x44b>
movslq -0x30(%rbp),%rcx
xor    %eax,%eax
cmp    -0x90(%rbp,%rcx,4),%eax
jne    1568 <groupDetermine+0x438>
movslq -0x30(%rbp),%rcx
xor    %eax,%eax
cmp    -0x60(%rbp,%rcx,4),%eax
jne    1568 <groupDetermine+0x438>
mov    -0x28(%rbp),%esi
mov    -0x30(%rbp),%edx
lea    0xaf8(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x2,-0x4(%rbp)
jmp    18ca <groupDetermine+0x79a>
jmp    156d <groupDetermine+0x43d>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    151b <groupDetermine+0x3eb>
movl   $0x1,-0x30(%rbp)
cmpl   $0xa,-0x30(%rbp)
jge    165d <groupDetermine+0x52d>
movslq -0x30(%rbp),%rcx
mov    $0x1,%eax
cmp    -0x60(%rbp,%rcx,4),%eax
jne    164a <groupDetermine+0x51a>
movl   $0x0,-0x2c(%rbp)
cmpl   $0x9,-0x2c(%rbp)
jge    1645 <groupDetermine+0x515>
mov    -0x18(%rbp),%rcx
movslq -0x30(%rbp),%rax
imul   $0x144,%rax,%rax
add    %rax,%rcx
movslq -0x28(%rbp),%rax
imul   $0x24,%rax,%rax
add    %rax,%rcx
movslq -0x2c(%rbp),%rdx
xor    %eax,%eax
cmp    (%rcx,%rdx,4),%eax
jne    1632 <groupDetermine+0x502>
mov    -0x30(%rbp),%esi
mov    -0x28(%rbp),%edx
mov    -0x2c(%rbp),%ecx
lea    0xa84(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x30(%rbp),%edx
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
imul   $0x24,%rcx,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x28(%rbp),%edx
mov    -0x2c(%rbp),%ecx
mov    -0x30(%rbp),%r8d
call   1040 <exclude@plt>
mov    %eax,-0x1c(%rbp)
movl   $0x0,-0x4(%rbp)
jmp    18ca <groupDetermine+0x79a>
jmp    1637 <groupDetermine+0x507>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    15a6 <groupDetermine+0x476>
jmp    164a <groupDetermine+0x51a>
jmp    164f <groupDetermine+0x51f>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1582 <groupDetermine+0x452>
jmp    1662 <groupDetermine+0x532>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1424 <groupDetermine+0x2f4>
movl   $0x0,-0x2c(%rbp)
cmpl   $0x9,-0x2c(%rbp)
jge    18c3 <groupDetermine+0x793>
lea    -0x60(%rbp),%rdi
xor    %esi,%esi
mov    $0x28,%edx
call   1050 <memset@plt>
lea    -0x90(%rbp),%rdi
xor    %esi,%esi
mov    $0x28,%edx
call   1050 <memset@plt>
movl   $0x0,-0x28(%rbp)
cmpl   $0x9,-0x28(%rbp)
jge    1767 <groupDetermine+0x637>
movl   $0x1,-0x30(%rbp)
cmpl   $0xa,-0x30(%rbp)
jge    1754 <groupDetermine+0x624>
mov    -0x10(%rbp),%rcx
movslq -0x28(%rbp),%rax
imul   $0x24,%rax,%rax
add    %rax,%rcx
movslq -0x2c(%rbp),%rdx
xor    %eax,%eax
cmp    (%rcx,%rdx,4),%eax
je     1706 <groupDetermine+0x5d6>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
imul   $0x24,%rcx,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
movslq (%rax,%rcx,4),%rax
movl   $0x1,-0x90(%rbp,%rax,4)
mov    -0x18(%rbp),%rcx
movslq -0x30(%rbp),%rax
imul   $0x144,%rax,%rax
add    %rax,%rcx
movslq -0x28(%rbp),%rax
imul   $0x24,%rax,%rax
add    %rax,%rcx
movslq -0x2c(%rbp),%rdx
xor    %eax,%eax
cmp    (%rcx,%rdx,4),%eax
jne    1741 <groupDetermine+0x611>
movslq -0x30(%rbp),%rax
mov    -0x60(%rbp,%rax,4),%ecx
add    $0x1,%ecx
mov    %ecx,-0x60(%rbp,%rax,4)
jmp    1746 <groupDetermine+0x616>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    16bc <groupDetermine+0x58c>
jmp    1759 <groupDetermine+0x629>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    16ab <groupDetermine+0x57b>
movl   $0x1,-0x30(%rbp)
cmpl   $0xa,-0x30(%rbp)
jge    17ce <groupDetermine+0x69e>
movslq -0x30(%rbp),%rcx
xor    %eax,%eax
cmp    -0x90(%rbp,%rcx,4),%eax
jne    17bb <groupDetermine+0x68b>
movslq -0x30(%rbp),%rcx
xor    %eax,%eax
cmp    -0x60(%rbp,%rcx,4),%eax
jne    17bb <groupDetermine+0x68b>
mov    -0x2c(%rbp),%esi
mov    -0x30(%rbp),%edx
lea    0x8e8(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
movl   $0x2,-0x4(%rbp)
jmp    18ca <groupDetermine+0x79a>
jmp    17c0 <groupDetermine+0x690>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    176e <groupDetermine+0x63e>
movl   $0x1,-0x30(%rbp)
cmpl   $0xa,-0x30(%rbp)
jge    18b0 <groupDetermine+0x780>
movslq -0x30(%rbp),%rcx
mov    $0x1,%eax
cmp    -0x60(%rbp,%rcx,4),%eax
jne    189d <groupDetermine+0x76d>
movl   $0x0,-0x28(%rbp)
cmpl   $0x9,-0x28(%rbp)
jge    1898 <groupDetermine+0x768>
mov    -0x18(%rbp),%rcx
movslq -0x30(%rbp),%rax
imul   $0x144,%rax,%rax
add    %rax,%rcx
movslq -0x28(%rbp),%rax
imul   $0x24,%rax,%rax
add    %rax,%rcx
movslq -0x2c(%rbp),%rdx
xor    %eax,%eax
cmp    (%rcx,%rdx,4),%eax
jne    1885 <groupDetermine+0x755>
mov    -0x30(%rbp),%esi
mov    -0x28(%rbp),%edx
mov    -0x2c(%rbp),%ecx
lea    0x877(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x30(%rbp),%edx
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
imul   $0x24,%rcx,%rcx
add    %rcx,%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%rdi
mov    -0x18(%rbp),%rsi
mov    -0x28(%rbp),%edx
mov    -0x2c(%rbp),%ecx
mov    -0x30(%rbp),%r8d
call   1040 <exclude@plt>
mov    %eax,-0x1c(%rbp)
movl   $0x0,-0x4(%rbp)
jmp    18ca <groupDetermine+0x79a>
jmp    188a <groupDetermine+0x75a>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    17f9 <groupDetermine+0x6c9>
jmp    189d <groupDetermine+0x76d>
jmp    18a2 <groupDetermine+0x772>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    17d5 <groupDetermine+0x6a5>
jmp    18b5 <groupDetermine+0x785>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1677 <groupDetermine+0x547>
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<groupDetermine>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xb8,%rsp
lea    0xb64(%rsi),%rbp
mov    %rsi,0x70(%rsp)
add    $0x194,%rsi
movl   $0x1,0x64(%rsp)
mov    $0x2,%edx
mov    $0x3,%r15d
xor    %eax,%eax
mov    %rax,0x28(%rsp)
mov    %rsp,%rbx
lea    0x30(%rsp),%r14
mov    %rdi,0x68(%rsp)
mov    %edx,0x60(%rsp)
mov    $0x1,%edx
mov    %rsi,0x90(%rsp)
mov    %rbp,0x98(%rsp)
mov    %rbp,%r12
mov    %rdi,0x88(%rsp)
mov    %rdi,%rbp
xor    %eax,%eax
mov    %rsi,0xb0(%rsp)
mov    %rdx,0x78(%rsp)
mov    %rax,0x80(%rsp)
mov    %rbx,%rdi
xor    %esi,%esi
mov    $0x28,%edx
call   1050 <memset@plt>
mov    %r14,%rdi
xor    %esi,%esi
mov    $0x28,%edx
call   1050 <memset@plt>
mov    0x4(%rsp),%r8d
mov    0x8(%rsp),%r9d
mov    0xc(%rsp),%r10d
mov    0x10(%rsp),%r11d
mov    %rbp,%rsi
mov    0x14(%rsp),%r13d
mov    0x18(%rsp),%ebp
mov    0x1c(%rsp),%ebx
mov    0x20(%rsp),%eax
mov    0x24(%rsp),%ecx
mov    %r12,0xa8(%rsp)
mov    %r12,%rdx
mov    %rsi,0xa0(%rsp)
mov    0x28(%rsp),%r12
jmp    1235 <groupDetermine+0x105>
nopl   (%rax)
add    $0x1,%r12
add    $0x24,%rsi
add    $0x24,%rdx
cmp    %r15,%r12
je     1380 <groupDetermine+0x250>
xor    %edi,%edi
jmp    125b <groupDetermine+0x12b>
nopl   0x0(%rax)
add    $0x1,%eax
mov    %eax,0x20(%rsp)
cmpl   $0x0,(%rdx,%rdi,4)
je     1367 <groupDetermine+0x237>
add    $0x1,%rdi
cmp    $0x3,%rdi
je     1220 <groupDetermine+0xf0>
movslq (%rsi,%rdi,4),%r14
test   %r14,%r14
je     126d <groupDetermine+0x13d>
movl   $0x1,0x30(%rsp,%r14,4)
cmpl   $0x0,-0xa20(%rdx,%rdi,4)
je     12d0 <groupDetermine+0x1a0>
cmpl   $0x0,-0x8dc(%rdx,%rdi,4)
je     12e3 <groupDetermine+0x1b3>
cmpl   $0x0,-0x798(%rdx,%rdi,4)
je     12f6 <groupDetermine+0x1c6>
cmpl   $0x0,-0x654(%rdx,%rdi,4)
je     1309 <groupDetermine+0x1d9>
cmpl   $0x0,-0x510(%rdx,%rdi,4)
je     131c <groupDetermine+0x1ec>
cmpl   $0x0,-0x3cc(%rdx,%rdi,4)
je     1333 <groupDetermine+0x203>
cmpl   $0x0,-0x288(%rdx,%rdi,4)
je     1348 <groupDetermine+0x218>
cmpl   $0x0,-0x144(%rdx,%rdi,4)
jne    135d <groupDetermine+0x22d>
jmp    1240 <groupDetermine+0x110>
xchg   %ax,%ax
add    $0x1,%r8d
mov    %r8d,0x4(%rsp)
cmpl   $0x0,-0x8dc(%rdx,%rdi,4)
jne    1281 <groupDetermine+0x151>
add    $0x1,%r9d
mov    %r9d,0x8(%rsp)
cmpl   $0x0,-0x798(%rdx,%rdi,4)
jne    128b <groupDetermine+0x15b>
add    $0x1,%r10d
mov    %r10d,0xc(%rsp)
cmpl   $0x0,-0x654(%rdx,%rdi,4)
jne    1295 <groupDetermine+0x165>
add    $0x1,%r11d
mov    %r11d,0x10(%rsp)
cmpl   $0x0,-0x510(%rdx,%rdi,4)
jne    129f <groupDetermine+0x16f>
add    $0x1,%r13d
mov    %r13d,0x14(%rsp)
cmpl   $0x0,-0x3cc(%rdx,%rdi,4)
jne    12ad <groupDetermine+0x17d>
add    $0x1,%ebp
mov    %ebp,0x18(%rsp)
cmpl   $0x0,-0x288(%rdx,%rdi,4)
jne    12bb <groupDetermine+0x18b>
add    $0x1,%ebx
mov    %ebx,0x1c(%rsp)
cmpl   $0x0,-0x144(%rdx,%rdi,4)
je     1240 <groupDetermine+0x110>
cmpl   $0x0,(%rdx,%rdi,4)
jne    1251 <groupDetermine+0x121>
add    $0x1,%ecx
mov    %ecx,0x24(%rsp)
jmp    1251 <groupDetermine+0x121>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x34(%rsp),%eax
or     0x4(%rsp),%eax
je     1b36 <groupDetermine+0xa06>
mov    0x38(%rsp),%eax
or     0x8(%rsp),%eax
je     1b3d <groupDetermine+0xa0d>
mov    0x3c(%rsp),%eax
or     0xc(%rsp),%eax
je     1b44 <groupDetermine+0xa14>
mov    0x40(%rsp),%eax
or     0x10(%rsp),%eax
je     1b4b <groupDetermine+0xa1b>
mov    0x44(%rsp),%eax
or     0x14(%rsp),%eax
je     1b52 <groupDetermine+0xa22>
mov    0x48(%rsp),%eax
or     0x18(%rsp),%eax
je     1b59 <groupDetermine+0xa29>
mov    0x4c(%rsp),%eax
or     0x1c(%rsp),%eax
je     1b60 <groupDetermine+0xa30>
mov    0x50(%rsp),%eax
or     0x20(%rsp),%eax
je     1b67 <groupDetermine+0xa37>
mov    0x54(%rsp),%eax
or     0x24(%rsp),%eax
je     1b6e <groupDetermine+0xa3e>
mov    0x80(%rsp),%rcx
lea    0x2(%rcx),%r12
mov    $0x1,%r13d
mov    0xb0(%rsp),%rsi
mov    %rsi,%rax
jmp    1430 <groupDetermine+0x300>
nopl   (%rax)
add    $0x1,%r13
add    $0x144,%rax
cmp    $0xa,%r13
je     1491 <groupDetermine+0x361>
cmpl   $0x1,(%rsp,%r13,4)
jne    1420 <groupDetermine+0x2f0>
cmpl   $0x0,-0x50(%rax)
je     1aa2 <groupDetermine+0x972>
cmpl   $0x0,-0x4c(%rax)
je     1aae <groupDetermine+0x97e>
cmpl   $0x0,-0x48(%rax)
je     1ab7 <groupDetermine+0x987>
cmpl   $0x0,-0x2c(%rax)
je     1ac0 <groupDetermine+0x990>
cmpl   $0x0,-0x28(%rax)
je     1ac9 <groupDetermine+0x999>
cmpl   $0x0,-0x24(%rax)
je     1ace <groupDetermine+0x99e>
cmpl   $0x0,-0x8(%rax)
je     1ad4 <groupDetermine+0x9a4>
cmpl   $0x0,-0x4(%rax)
je     1add <groupDetermine+0x9ad>
cmpl   $0x0,(%rax)
jne    1420 <groupDetermine+0x2f0>
jmp    1ae8 <groupDetermine+0x9b8>
mov    %rcx,%rax
add    $0x3,%rax
mov    0x78(%rsp),%rdx
add    $0x3,%rdx
mov    0xa0(%rsp),%rbp
add    $0xc,%rbp
mov    0xa8(%rsp),%r12
add    $0xc,%r12
add    $0xc,%rsi
cmp    $0x6,%ecx
mov    %rsp,%rbx
lea    0x30(%rsp),%r14
jb     11a4 <groupDetermine+0x74>
mov    0x28(%rsp),%rcx
mov    %rcx,%rax
add    $0x3,%rax
add    $0x3,%r15
addl   $0x3,0x64(%rsp)
mov    0x60(%rsp),%edx
add    $0x3,%edx
mov    0x88(%rsp),%rdi
add    $0x6c,%rdi
mov    0x98(%rsp),%rbp
add    $0x6c,%rbp
mov    0x90(%rsp),%rsi
add    $0x6c,%rsi
cmp    $0x6,%ecx
mov    %rax,0x28(%rsp)
jb     117b <groupDetermine+0x4b>
mov    0x70(%rsp),%rax
lea    0xb64(%rax),%rbp
lea    0x164(%rax),%r15
xor    %r14d,%r14d
mov    %rsp,%rdi
lea    0x30(%rsp),%rbx
mov    0x68(%rsp),%r13
xor    %esi,%esi
mov    $0x28,%edx
call   1050 <memset@plt>
mov    %rbx,%rdi
xor    %esi,%esi
mov    $0x28,%edx
call   1050 <memset@plt>
mov    0x4(%rsp),%r8d
mov    0x8(%rsp),%r9d
mov    0xc(%rsp),%r10d
mov    0x10(%rsp),%r11d
mov    0x14(%rsp),%r12d
mov    0x18(%rsp),%ebx
mov    0x1c(%rsp),%eax
mov    0x20(%rsp),%ecx
mov    0x24(%rsp),%edx
xor    %esi,%esi
jmp    1595 <groupDetermine+0x465>
add    $0x1,%rsi
cmp    $0x9,%rsi
je     16b0 <groupDetermine+0x580>
movslq 0x0(%r13,%rsi,4),%rdi
test   %rdi,%rdi
je     15a7 <groupDetermine+0x477>
movl   $0x1,0x30(%rsp,%rdi,4)
cmpl   $0x0,-0xa20(%rbp,%rsi,4)
jne    15ba <groupDetermine+0x48a>
add    $0x1,%r8d
mov    %r8d,0x4(%rsp)
test   %edi,%edi
je     15c6 <groupDetermine+0x496>
movl   $0x1,0x30(%rsp,%rdi,4)
cmpl   $0x0,-0x8dc(%rbp,%rsi,4)
jne    15d9 <groupDetermine+0x4a9>
add    $0x1,%r9d
mov    %r9d,0x8(%rsp)
test   %edi,%edi
je     15e5 <groupDetermine+0x4b5>
movl   $0x1,0x30(%rsp,%rdi,4)
cmpl   $0x0,-0x798(%rbp,%rsi,4)
jne    15f8 <groupDetermine+0x4c8>
add    $0x1,%r10d
mov    %r10d,0xc(%rsp)
test   %edi,%edi
je     1604 <groupDetermine+0x4d4>
movl   $0x1,0x30(%rsp,%rdi,4)
cmpl   $0x0,-0x654(%rbp,%rsi,4)
jne    1617 <groupDetermine+0x4e7>
add    $0x1,%r11d
mov    %r11d,0x10(%rsp)
test   %edi,%edi
je     1623 <groupDetermine+0x4f3>
movl   $0x1,0x30(%rsp,%rdi,4)
cmpl   $0x0,-0x510(%rbp,%rsi,4)
jne    1636 <groupDetermine+0x506>
add    $0x1,%r12d
mov    %r12d,0x14(%rsp)
test   %edi,%edi
je     1642 <groupDetermine+0x512>
movl   $0x1,0x30(%rsp,%rdi,4)
cmpl   $0x0,-0x3cc(%rbp,%rsi,4)
jne    1653 <groupDetermine+0x523>
add    $0x1,%ebx
mov    %ebx,0x18(%rsp)
test   %edi,%edi
je     165f <groupDetermine+0x52f>
movl   $0x1,0x30(%rsp,%rdi,4)
cmpl   $0x0,-0x288(%rbp,%rsi,4)
jne    1670 <groupDetermine+0x540>
add    $0x1,%eax
mov    %eax,0x1c(%rsp)
test   %edi,%edi
je     167c <groupDetermine+0x54c>
movl   $0x1,0x30(%rsp,%rdi,4)
cmpl   $0x0,-0x144(%rbp,%rsi,4)
jne    168d <groupDetermine+0x55d>
add    $0x1,%ecx
mov    %ecx,0x20(%rsp)
test   %edi,%edi
je     1699 <groupDetermine+0x569>
movl   $0x1,0x30(%rsp,%rdi,4)
cmpl   $0x0,0x0(%rbp,%rsi,4)
jne    1587 <groupDetermine+0x457>
add    $0x1,%edx
mov    %edx,0x24(%rsp)
jmp    1587 <groupDetermine+0x457>
mov    0x34(%rsp),%eax
or     0x4(%rsp),%eax
je     1c27 <groupDetermine+0xaf7>
mov    0x38(%rsp),%eax
or     0x8(%rsp),%eax
je     1c2e <groupDetermine+0xafe>
mov    0x3c(%rsp),%eax
or     0xc(%rsp),%eax
je     1c35 <groupDetermine+0xb05>
mov    0x40(%rsp),%eax
or     0x10(%rsp),%eax
je     1c3c <groupDetermine+0xb0c>
mov    0x44(%rsp),%eax
or     0x14(%rsp),%eax
je     1c43 <groupDetermine+0xb13>
mov    0x48(%rsp),%eax
or     0x18(%rsp),%eax
je     1c4a <groupDetermine+0xb1a>
mov    0x4c(%rsp),%eax
or     0x1c(%rsp),%eax
je     1c51 <groupDetermine+0xb21>
mov    0x50(%rsp),%eax
or     0x20(%rsp),%eax
je     1c58 <groupDetermine+0xb28>
mov    0x54(%rsp),%eax
or     0x24(%rsp),%eax
je     1c5f <groupDetermine+0xb2f>
mov    $0x1,%r12d
mov    %r15,%rcx
mov    %r15,%rax
jmp    174c <groupDetermine+0x61c>
add    $0x1,%r12
add    $0x144,%rax
cmp    $0xa,%r12
je     17b0 <groupDetermine+0x680>
cmpl   $0x1,(%rsp,%r12,4)
jne    173c <groupDetermine+0x60c>
xor    %r15d,%r15d
cmpl   $0x0,-0x20(%rax)
je     1ba9 <groupDetermine+0xa79>
cmpl   $0x0,-0x1c(%rax)
je     1bad <groupDetermine+0xa7d>
cmpl   $0x0,-0x18(%rax)
je     1bb4 <groupDetermine+0xa84>
cmpl   $0x0,-0x14(%rax)
je     1bbb <groupDetermine+0xa8b>
cmpl   $0x0,-0x10(%rax)
je     1bc2 <groupDetermine+0xa92>
cmpl   $0x0,-0xc(%rax)
je     1bc9 <groupDetermine+0xa99>
cmpl   $0x0,-0x8(%rax)
je     1bd0 <groupDetermine+0xaa0>
cmpl   $0x0,-0x4(%rax)
je     1bd7 <groupDetermine+0xaa7>
cmpl   $0x0,(%rax)
jne    173c <groupDetermine+0x60c>
jmp    1bde <groupDetermine+0xaae>
add    $0x1,%r14
add    $0x24,%r13
add    $0x24,%rbp
mov    %rcx,%r15
add    $0x24,%r15
cmp    $0x9,%r14
mov    %rsp,%rdi
lea    0x30(%rsp),%rbx
jne    153f <groupDetermine+0x40f>
mov    0x70(%rsp),%rax
lea    0xb64(%rax),%rbp
add    $0x144,%rax
mov    %rax,0x28(%rsp)
xor    %r14d,%r14d
mov    0x68(%rsp),%r13
mov    %rsp,%rdi
xor    %esi,%esi
mov    $0x28,%edx
call   1050 <memset@plt>
lea    0x30(%rsp),%rdi
xor    %esi,%esi
mov    $0x28,%edx
call   1050 <memset@plt>
mov    0x4(%rsp),%r8d
mov    0x8(%rsp),%r9d
mov    0xc(%rsp),%r10d
mov    0x10(%rsp),%r11d
mov    0x14(%rsp),%r12d
mov    0x18(%rsp),%ebx
mov    0x1c(%rsp),%eax
mov    0x20(%rsp),%ecx
mov    0x24(%rsp),%edx
xor    %esi,%esi
jmp    1852 <groupDetermine+0x722>
add    $0x24,%rsi
cmp    $0x144,%rsi
je     196d <groupDetermine+0x83d>
movslq 0x0(%r13,%rsi,1),%rdi
test   %rdi,%rdi
je     1864 <groupDetermine+0x734>
movl   $0x1,0x30(%rsp,%rdi,4)
cmpl   $0x0,-0xa20(%rbp,%rsi,1)
jne    1877 <groupDetermine+0x747>
add    $0x1,%r8d
mov    %r8d,0x4(%rsp)
test   %edi,%edi
je     1883 <groupDetermine+0x753>
movl   $0x1,0x30(%rsp,%rdi,4)
cmpl   $0x0,-0x8dc(%rbp,%rsi,1)
jne    1896 <groupDetermine+0x766>
add    $0x1,%r9d
mov    %r9d,0x8(%rsp)
test   %edi,%edi
je     18a2 <groupDetermine+0x772>
movl   $0x1,0x30(%rsp,%rdi,4)
cmpl   $0x0,-0x798(%rbp,%rsi,1)
jne    18b5 <groupDetermine+0x785>
add    $0x1,%r10d
mov    %r10d,0xc(%rsp)
test   %edi,%edi
je     18c1 <groupDetermine+0x791>
movl   $0x1,0x30(%rsp,%rdi,4)
cmpl   $0x0,-0x654(%rbp,%rsi,1)
jne    18d4 <groupDetermine+0x7a4>
add    $0x1,%r11d
mov    %r11d,0x10(%rsp)
test   %edi,%edi
je     18e0 <groupDetermine+0x7b0>
movl   $0x1,0x30(%rsp,%rdi,4)
cmpl   $0x0,-0x510(%rbp,%rsi,1)
jne    18f3 <groupDetermine+0x7c3>
add    $0x1,%r12d
mov    %r12d,0x14(%rsp)
test   %edi,%edi
je     18ff <groupDetermine+0x7cf>
movl   $0x1,0x30(%rsp,%rdi,4)
cmpl   $0x0,-0x3cc(%rbp,%rsi,1)
jne    1910 <groupDetermine+0x7e0>
add    $0x1,%ebx
mov    %ebx,0x18(%rsp)
test   %edi,%edi
je     191c <groupDetermine+0x7ec>
movl   $0x1,0x30(%rsp,%rdi,4)
cmpl   $0x0,-0x288(%rbp,%rsi,1)
jne    192d <groupDetermine+0x7fd>
add    $0x1,%eax
mov    %eax,0x1c(%rsp)
test   %edi,%edi
je     1939 <groupDetermine+0x809>
movl   $0x1,0x30(%rsp,%rdi,4)
cmpl   $0x0,-0x144(%rbp,%rsi,1)
jne    194a <groupDetermine+0x81a>
add    $0x1,%ecx
mov    %ecx,0x20(%rsp)
test   %edi,%edi
je     1956 <groupDetermine+0x826>
movl   $0x1,0x30(%rsp,%rdi,4)
cmpl   $0x0,0x0(%rbp,%rsi,1)
jne    1841 <groupDetermine+0x711>
add    $0x1,%edx
mov    %edx,0x24(%rsp)
jmp    1841 <groupDetermine+0x711>
mov    0x34(%rsp),%eax
or     0x4(%rsp),%eax
je     1cef <groupDetermine+0xbbf>
mov    0x38(%rsp),%eax
or     0x8(%rsp),%eax
je     1d00 <groupDetermine+0xbd0>
mov    0x3c(%rsp),%eax
or     0xc(%rsp),%eax
je     1d11 <groupDetermine+0xbe1>
mov    0x40(%rsp),%eax
or     0x10(%rsp),%eax
je     1d22 <groupDetermine+0xbf2>
mov    0x44(%rsp),%eax
or     0x14(%rsp),%eax
je     1d33 <groupDetermine+0xc03>
mov    0x48(%rsp),%eax
or     0x18(%rsp),%eax
je     1d44 <groupDetermine+0xc14>
mov    0x4c(%rsp),%eax
or     0x1c(%rsp),%eax
je     1d55 <groupDetermine+0xc25>
mov    0x50(%rsp),%eax
or     0x20(%rsp),%eax
je     1d66 <groupDetermine+0xc36>
mov    0x54(%rsp),%eax
or     0x24(%rsp),%eax
je     1d77 <groupDetermine+0xc47>
mov    $0x1,%r12d
mov    0x28(%rsp),%rax
jmp    1a08 <groupDetermine+0x8d8>
add    $0x1,%r12
add    $0x144,%rax
cmp    $0xa,%r12
je     1a7b <groupDetermine+0x94b>
cmpl   $0x1,(%rsp,%r12,4)
jne    19f8 <groupDetermine+0x8c8>
xor    %r15d,%r15d
cmpl   $0x0,(%rax)
je     1c7a <groupDetermine+0xb4a>
cmpl   $0x0,0x24(%rax)
je     1c7e <groupDetermine+0xb4e>
cmpl   $0x0,0x48(%rax)
je     1c85 <groupDetermine+0xb55>
cmpl   $0x0,0x6c(%rax)
je     1c8c <groupDetermine+0xb5c>
cmpl   $0x0,0x90(%rax)
je     1c93 <groupDetermine+0xb63>
cmpl   $0x0,0xb4(%rax)
je     1c9a <groupDetermine+0xb6a>
cmpl   $0x0,0xd8(%rax)
je     1ca1 <groupDetermine+0xb71>
cmpl   $0x0,0xfc(%rax)
je     1ca8 <groupDetermine+0xb78>
cmpl   $0x0,0x120(%rax)
jne    19f8 <groupDetermine+0x8c8>
jmp    1caf <groupDetermine+0xb7f>
add    $0x1,%r14
add    $0x4,%r13
add    $0x4,%rbp
addq   $0x4,0x28(%rsp)
mov    $0x1,%r15d
cmp    $0x9,%r14
jne    17f4 <groupDetermine+0x6c4>
jmp    1b94 <groupDetermine+0xa64>
mov    0x28(%rsp),%rax
mov    %eax,%ebx
mov    %rcx,%r12
jmp    1aec <groupDetermine+0x9bc>
mov    0x28(%rsp),%rax
mov    %eax,%ebx
jmp    1ae1 <groupDetermine+0x9b1>
mov    0x28(%rsp),%rax
mov    %eax,%ebx
jmp    1aec <groupDetermine+0x9bc>
mov    %rcx,%r12
mov    0x64(%rsp),%ebx
jmp    1aec <groupDetermine+0x9bc>
mov    0x78(%rsp),%r12
mov    0x64(%rsp),%ebx
jmp    1aec <groupDetermine+0x9bc>
mov    0x60(%rsp),%ebx
mov    %rcx,%r12
jmp    1aec <groupDetermine+0x9bc>
mov    0x60(%rsp),%ebx
mov    0x78(%rsp),%r12
jmp    1aec <groupDetermine+0x9bc>
mov    0x60(%rsp),%ebx
mov    %ebx,%ebp
mov    %r12d,%r14d
lea    0x533(%rip),%rdi
xor    %r15d,%r15d
mov    %r13d,%esi
mov    %ebx,%edx
mov    %r12d,%ecx
xor    %eax,%eax
call   1030 <printf@plt>
lea    0x0(,%rbp,8),%rax
add    %rbp,%rax
mov    0x68(%rsp),%rdi
lea    (%rdi,%rax,4),%rax
mov    %r13d,(%rax,%r14,4)
mov    0x70(%rsp),%rsi
mov    %ebx,%edx
mov    %r12d,%ecx
mov    %r13d,%r8d
call   1040 <exclude@plt>
jmp    1b94 <groupDetermine+0xa64>
mov    $0x1,%ecx
jmp    1b73 <groupDetermine+0xa43>
mov    $0x2,%ecx
jmp    1b73 <groupDetermine+0xa43>
mov    $0x3,%ecx
jmp    1b73 <groupDetermine+0xa43>
mov    $0x4,%ecx
jmp    1b73 <groupDetermine+0xa43>
mov    $0x5,%ecx
jmp    1b73 <groupDetermine+0xa43>
mov    $0x6,%ecx
jmp    1b73 <groupDetermine+0xa43>
mov    $0x7,%ecx
jmp    1b73 <groupDetermine+0xa43>
mov    $0x8,%ecx
jmp    1b73 <groupDetermine+0xa43>
mov    $0x9,%ecx
lea    0x486(%rip),%rdi
mov    0x28(%rsp),%rsi
mov    0x80(%rsp),%rdx
xor    %eax,%eax
call   1030 <printf@plt>
mov    $0x2,%r15d
mov    %r15d,%eax
add    $0xb8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %ebp,%ebp
jmp    1be3 <groupDetermine+0xab3>
mov    $0x1,%ebp
jmp    1be3 <groupDetermine+0xab3>
mov    $0x2,%ebp
jmp    1be3 <groupDetermine+0xab3>
mov    $0x3,%ebp
jmp    1be3 <groupDetermine+0xab3>
mov    $0x4,%ebp
jmp    1be3 <groupDetermine+0xab3>
mov    $0x5,%ebp
jmp    1be3 <groupDetermine+0xab3>
mov    $0x6,%ebp
jmp    1be3 <groupDetermine+0xab3>
mov    $0x7,%ebp
jmp    1be3 <groupDetermine+0xab3>
mov    $0x8,%ebp
mov    %r14d,%ebx
mov    %ebp,%r13d
lea    0x480(%rip),%rdi
mov    %r12d,%esi
mov    %r14d,%edx
mov    %ebp,%ecx
xor    %eax,%eax
call   1030 <printf@plt>
lea    (%rbx,%rbx,8),%rax
mov    0x68(%rsp),%rdi
lea    (%rdi,%rax,4),%rax
mov    %r12d,(%rax,%r13,4)
mov    0x70(%rsp),%rsi
mov    %r14d,%edx
mov    %ebp,%ecx
mov    %r12d,%r8d
call   1040 <exclude@plt>
jmp    1b94 <groupDetermine+0xa64>
mov    $0x1,%edx
jmp    1c64 <groupDetermine+0xb34>
mov    $0x2,%edx
jmp    1c64 <groupDetermine+0xb34>
mov    $0x3,%edx
jmp    1c64 <groupDetermine+0xb34>
mov    $0x4,%edx
jmp    1c64 <groupDetermine+0xb34>
mov    $0x5,%edx
jmp    1c64 <groupDetermine+0xb34>
mov    $0x6,%edx
jmp    1c64 <groupDetermine+0xb34>
mov    $0x7,%edx
jmp    1c64 <groupDetermine+0xb34>
mov    $0x8,%edx
jmp    1c64 <groupDetermine+0xb34>
mov    $0x9,%edx
lea    0x3e2(%rip),%rdi
mov    %r14d,%esi
xor    %eax,%eax
call   1030 <printf@plt>
jmp    1b8e <groupDetermine+0xa5e>
xor    %ebp,%ebp
jmp    1cb4 <groupDetermine+0xb84>
mov    $0x1,%ebp
jmp    1cb4 <groupDetermine+0xb84>
mov    $0x2,%ebp
jmp    1cb4 <groupDetermine+0xb84>
mov    $0x3,%ebp
jmp    1cb4 <groupDetermine+0xb84>
mov    $0x4,%ebp
jmp    1cb4 <groupDetermine+0xb84>
mov    $0x5,%ebp
jmp    1cb4 <groupDetermine+0xb84>
mov    $0x6,%ebp
jmp    1cb4 <groupDetermine+0xb84>
mov    $0x7,%ebp
jmp    1cb4 <groupDetermine+0xb84>
mov    $0x8,%ebp
mov    %ebp,%ebx
mov    %r14d,%r13d
lea    0x3f6(%rip),%rdi
mov    %r12d,%esi
mov    %ebp,%edx
mov    %r14d,%ecx
xor    %eax,%eax
call   1030 <printf@plt>
lea    (%rbx,%rbx,8),%rax
mov    0x68(%rsp),%rdi
lea    (%rdi,%rax,4),%rax
mov    %r12d,(%rax,%r13,4)
mov    0x70(%rsp),%rsi
mov    %ebp,%edx
mov    %r14d,%ecx
jmp    1c1a <groupDetermine+0xaea>
mov    $0x1,%edx
lea    0x395(%rip),%rdi
jmp    1c6b <groupDetermine+0xb3b>
mov    $0x2,%edx
lea    0x384(%rip),%rdi
jmp    1c6b <groupDetermine+0xb3b>
mov    $0x3,%edx
lea    0x373(%rip),%rdi
jmp    1c6b <groupDetermine+0xb3b>
mov    $0x4,%edx
lea    0x362(%rip),%rdi
jmp    1c6b <groupDetermine+0xb3b>
mov    $0x5,%edx
lea    0x351(%rip),%rdi
jmp    1c6b <groupDetermine+0xb3b>
mov    $0x6,%edx
lea    0x340(%rip),%rdi
jmp    1c6b <groupDetermine+0xb3b>
mov    $0x7,%edx
lea    0x32f(%rip),%rdi
jmp    1c6b <groupDetermine+0xb3b>
mov    $0x8,%edx
lea    0x31e(%rip),%rdi
jmp    1c6b <groupDetermine+0xb3b>
mov    $0x9,%edx
lea    0x30d(%rip),%rdi
jmp    1c6b <groupDetermine+0xb3b>

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

LLVM IR (-O2):
@.str = [43 x i8] c"Error! Block (%d, %d) has lost number %d.\0A\00"
@.str.1 = [34 x i8] c"Block determined, %d at (%d, %d)\0A\00"
@.str.2 = [35 x i8] c"Error! Row %d has lost number %d.\0A\00"
@.str.3 = [32 x i8] c"Row determined, %d at (%d, %d)\0A\00"
@.str.4 = [38 x i8] c"Error! Column %d has lost number %d.\0A\00"
@.str.5 = [35 x i8] c"Column determined, %d at (%d, %d)\0A\00"
define i32 @groupDetermine([9 x i32]* %0, [9 x [9 x i32]]* %1) {
%3 = alloca [10 x i32]
%4 = alloca [10 x i32]
%5 = bitcast [10 x i32]* %3 to i8*
%6 = bitcast [10 x i32]* %4 to i8*
%7 = getelementptr inbounds [10 x i32], [10 x i32]* %3, i64 0, i64 0
%8 = getelementptr inbounds [10 x i32], [10 x i32]* %4, i64 0, i64 0
%9 = getelementptr inbounds [10 x i32], [10 x i32]* %3, i64 0, i64 1
%10 = getelementptr inbounds [10 x i32], [10 x i32]* %3, i64 0, i64 2
%11 = getelementptr inbounds [10 x i32], [10 x i32]* %3, i64 0, i64 3
%12 = getelementptr inbounds [10 x i32], [10 x i32]* %3, i64 0, i64 4
%13 = getelementptr inbounds [10 x i32], [10 x i32]* %3, i64 0, i64 5
%14 = getelementptr inbounds [10 x i32], [10 x i32]* %3, i64 0, i64 6
%15 = getelementptr inbounds [10 x i32], [10 x i32]* %3, i64 0, i64 7
%16 = getelementptr inbounds [10 x i32], [10 x i32]* %3, i64 0, i64 8
%17 = getelementptr inbounds [10 x i32], [10 x i32]* %3, i64 0, i64 9
%18 = getelementptr inbounds [10 x i32], [10 x i32]* %4, i64 0, i64 1
%19 = getelementptr inbounds [10 x i32], [10 x i32]* %3, i64 0, i64 1
%20 = getelementptr inbounds [10 x i32], [10 x i32]* %4, i64 0, i64 2
%21 = getelementptr inbounds [10 x i32], [10 x i32]* %3, i64 0, i64 2
%22 = getelementptr inbounds [10 x i32], [10 x i32]* %4, i64 0, i64 3
%23 = getelementptr inbounds [10 x i32], [10 x i32]* %3, i64 0, i64 3
%24 = getelementptr inbounds [10 x i32], [10 x i32]* %4, i64 0, i64 4
%25 = getelementptr inbounds [10 x i32], [10 x i32]* %3, i64 0, i64 4
%26 = getelementptr inbounds [10 x i32], [10 x i32]* %4, i64 0, i64 5
%27 = getelementptr inbounds [10 x i32], [10 x i32]* %3, i64 0, i64 5
%28 = getelementptr inbounds [10 x i32], [10 x i32]* %4, i64 0, i64 6
%29 = getelementptr inbounds [10 x i32], [10 x i32]* %3, i64 0, i64 6
%30 = getelementptr inbounds [10 x i32], [10 x i32]* %4, i64 0, i64 7
%31 = getelementptr inbounds [10 x i32], [10 x i32]* %3, i64 0, i64 7
%32 = getelementptr inbounds [10 x i32], [10 x i32]* %4, i64 0, i64 8
%33 = getelementptr inbounds [10 x i32], [10 x i32]* %3, i64 0, i64 8
%34 = getelementptr inbounds [10 x i32], [10 x i32]* %4, i64 0, i64 9
%35 = getelementptr inbounds [10 x i32], [10 x i32]* %3, i64 0, i64 9
br label %36
36: ; preds = %2, %332
%37 = phi i64 [ 3, %2 ], [ %335, %332 ]
%38 = phi i32 [ 2, %2 ], [ %337, %332 ]
%39 = phi i32 [ 1, %2 ], [ %336, %332 ]
%40 = phi i64 [ 0, %2 ], [ %333, %332 ]
%41 = trunc i64 %40 to i32
%42 = add nuw nsw i64 %40, 1
%43 = add nuw nsw i64 %40, 2
br label %72
44: ; preds = %332
%45 = getelementptr inbounds [10 x i32], [10 x i32]* %4, i64 0, i64 1
%46 = getelementptr inbounds [10 x i32], [10 x i32]* %4, i64 0, i64 2
%47 = getelementptr inbounds [10 x i32], [10 x i32]* %4, i64 0, i64 3
%48 = getelementptr inbounds [10 x i32], [10 x i32]* %4, i64 0, i64 4
%49 = getelementptr inbounds [10 x i32], [10 x i32]* %4, i64 0, i64 5
%50 = getelementptr inbounds [10 x i32], [10 x i32]* %4, i64 0, i64 6
%51 = getelementptr inbounds [10 x i32], [10 x i32]* %4, i64 0, i64 7
%52 = getelementptr inbounds [10 x i32], [10 x i32]* %4, i64 0, i64 8
%53 = getelementptr inbounds [10 x i32], [10 x i32]* %4, i64 0, i64 9
%54 = getelementptr inbounds [10 x i32], [10 x i32]* %3, i64 0, i64 1
%55 = getelementptr inbounds [10 x i32], [10 x i32]* %3, i64 0, i64 2
%56 = getelementptr inbounds [10 x i32], [10 x i32]* %3, i64 0, i64 3
%57 = getelementptr inbounds [10 x i32], [10 x i32]* %3, i64 0, i64 4
%58 = getelementptr inbounds [10 x i32], [10 x i32]* %3, i64 0, i64 5
%59 = getelementptr inbounds [10 x i32], [10 x i32]* %3, i64 0, i64 6
%60 = getelementptr inbounds [10 x i32], [10 x i32]* %3, i64 0, i64 7
%61 = getelementptr inbounds [10 x i32], [10 x i32]* %3, i64 0, i64 8
%62 = getelementptr inbounds [10 x i32], [10 x i32]* %3, i64 0, i64 9
%63 = getelementptr inbounds [10 x i32], [10 x i32]* %3, i64 0, i64 1
%64 = getelementptr inbounds [10 x i32], [10 x i32]* %3, i64 0, i64 2
%65 = getelementptr inbounds [10 x i32], [10 x i32]* %3, i64 0, i64 3
%66 = getelementptr inbounds [10 x i32], [10 x i32]* %3, i64 0, i64 4
%67 = getelementptr inbounds [10 x i32], [10 x i32]* %3, i64 0, i64 5
%68 = getelementptr inbounds [10 x i32], [10 x i32]* %3, i64 0, i64 6
%69 = getelementptr inbounds [10 x i32], [10 x i32]* %3, i64 0, i64 7
%70 = getelementptr inbounds [10 x i32], [10 x i32]* %3, i64 0, i64 8
%71 = getelementptr inbounds [10 x i32], [10 x i32]* %3, i64 0, i64 9
br label %357
72: ; preds = %36, %327
%73 = phi i64 [ 3, %36 ], [ %330, %327 ]
%74 = phi i64 [ 1, %36 ], [ %331, %327 ]
%75 = phi i64 [ 0, %36 ], [ %328, %327 ]
%76 = trunc i64 %75 to i32
%77 = call i32 @memset(i32* %7, i32 0, i32 40)
%78 = call i32 @memset(i32* %8, i32 0, i32 40)
%79 = load i32, i32* %9
%80 = load i32, i32* %10
%81 = load i32, i32* %11
%82 = load i32, i32* %12
%83 = load i32, i32* %13
%84 = load i32, i32* %14
%85 = load i32, i32* %15
%86 = load i32, i32* %16
%87 = load i32, i32* %17
br label %88
88: ; preds = %72, %200
%89 = phi i32 [ %87, %72 ], [ %196, %200 ]
%90 = phi i32 [ %86, %72 ], [ %188, %200 ]
%91 = phi i32 [ %85, %72 ], [ %180, %200 ]
%92 = phi i32 [ %84, %72 ], [ %172, %200 ]
%93 = phi i32 [ %83, %72 ], [ %164, %200 ]
%94 = phi i32 [ %82, %72 ], [ %156, %200 ]
%95 = phi i32 [ %81, %72 ], [ %148, %200 ]
%96 = phi i32 [ %80, %72 ], [ %140, %200 ]
%97 = phi i32 [ %79, %72 ], [ %132, %200 ]
%98 = phi i64 [ %40, %72 ], [ %201, %200 ]
br label %99
99: ; preds = %88, %195
%100 = phi i32 [ %89, %88 ], [ %196, %195 ]
%101 = phi i32 [ %90, %88 ], [ %188, %195 ]
%102 = phi i32 [ %91, %88 ], [ %180, %195 ]
%103 = phi i32 [ %92, %88 ], [ %172, %195 ]
%104 = phi i32 [ %93, %88 ], [ %164, %195 ]
%105 = phi i32 [ %94, %88 ], [ %156, %195 ]
%106 = phi i32 [ %95, %88 ], [ %148, %195 ]
%107 = phi i32 [ %96, %88 ], [ %140, %195 ]
%108 = phi i32 [ %97, %88 ], [ %132, %195 ]
%109 = phi i32 [ %89, %88 ], [ %197, %195 ]
%110 = phi i32 [ %90, %88 ], [ %189, %195 ]
%111 = phi i32 [ %91, %88 ], [ %181, %195 ]
%112 = phi i32 [ %92, %88 ], [ %173, %195 ]
%113 = phi i32 [ %93, %88 ], [ %165, %195 ]
%114 = phi i32 [ %94, %88 ], [ %157, %195 ]
%115 = phi i32 [ %95, %88 ], [ %149, %195 ]
%116 = phi i32 [ %96, %88 ], [ %141, %195 ]
%117 = phi i32 [ %97, %88 ], [ %133, %195 ]
%118 = phi i64 [ %75, %88 ], [ %198, %195 ]
%119 = getelementptr inbounds [9 x i32], [9 x i32]* %0, i64 %98, i64 %118
%120 = load i32, i32* %119
%121 = icmp eq i32 %120, 0
br i1 %121, label %125, label %122
122: ; preds = %99
%123 = sext i32 %120 to i64
%124 = getelementptr inbounds [10 x i32], [10 x i32]* %4, i64 0, i64 %123
store i32 1, i32* %124
br label %125
125: ; preds = %122, %99
%126 = getelementptr inbounds [9 x [9 x i32]], [9 x [9 x i32]]* %1, i64 1, i64 %98, i64 %118
%127 = load i32, i32* %126
%128 = icmp eq i32 %127, 0
br i1 %128, label %129, label %131
129: ; preds = %125
%130 = add nsw i32 %117, 1
store i32 %130, i32* %9
br label %131
131: ; preds = %125, %129
%132 = phi i32 [ %108, %125 ], [ %130, %129 ]
%133 = phi i32 [ %117, %125 ], [ %130, %129 ]
%134 = getelementptr inbounds [9 x [9 x i32]], [9 x [9 x i32]]* %1, i64 2, i64 %98, i64 %118
%135 = load i32, i32* %134
%136 = icmp eq i32 %135, 0
br i1 %136, label %137, label %139
137: ; preds = %131
%138 = add nsw i32 %116, 1
store i32 %138, i32* %10
br label %139
139: ; preds = %137, %131
%140 = phi i32 [ %138, %137 ], [ %107, %131 ]
%141 = phi i32 [ %138, %137 ], [ %116, %131 ]
%142 = getelementptr inbounds [9 x [9 x i32]], [9 x [9 x i32]]* %1, i64 3, i64 %98, i64 %118
%143 = load i32, i32* %142
%144 = icmp eq i32 %143, 0
br i1 %144, label %145, label %147
145: ; preds = %139
%146 = add nsw i32 %115, 1
store i32 %146, i32* %11
br label %147
147: ; preds = %145, %139
%148 = phi i32 [ %146, %145 ], [ %106, %139 ]
%149 = phi i32 [ %146, %145 ], [ %115, %139 ]
%150 = getelementptr inbounds [9 x [9 x i32]], [9 x [9 x i32]]* %1, i64 4, i64 %98, i64 %118
%151 = load i32, i32* %150
%152 = icmp eq i32 %151, 0
br i1 %152, label %153, label %155
153: ; preds = %147
%154 = add nsw i32 %114, 1
store i32 %154, i32* %12
br label %155
155: ; preds = %153, %147
%156 = phi i32 [ %154, %153 ], [ %105, %147 ]
%157 = phi i32 [ %154, %153 ], [ %114, %147 ]
%158 = getelementptr inbounds [9 x [9 x i32]], [9 x [9 x i32]]* %1, i64 5, i64 %98, i64 %118
%159 = load i32, i32* %158
%160 = icmp eq i32 %159, 0
br i1 %160, label %161, label %163
161: ; preds = %155
%162 = add nsw i32 %113, 1
store i32 %162, i32* %13
br label %163
163: ; preds = %161, %155
%164 = phi i32 [ %162, %161 ], [ %104, %155 ]
%165 = phi i32 [ %162, %161 ], [ %113, %155 ]
%166 = getelementptr inbounds [9 x [9 x i32]], [9 x [9 x i32]]* %1, i64 6, i64 %98, i64 %118
%167 = load i32, i32* %166
%168 = icmp eq i32 %167, 0
br i1 %168, label %169, label %171
169: ; preds = %163
%170 = add nsw i32 %112, 1
store i32 %170, i32* %14
br label %171
171: ; preds = %169, %163
%172 = phi i32 [ %170, %169 ], [ %103, %163 ]
%173 = phi i32 [ %170, %169 ], [ %112, %163 ]
%174 = getelementptr inbounds [9 x [9 x i32]], [9 x [9 x i32]]* %1, i64 7, i64 %98, i64 %118
%175 = load i32, i32* %174
%176 = icmp eq i32 %175, 0
br i1 %176, label %177, label %179
177: ; preds = %171
%178 = add nsw i32 %111, 1
store i32 %178, i32* %15
br label %179
179: ; preds = %177, %171
%180 = phi i32 [ %178, %177 ], [ %102, %171 ]
%181 = phi i32 [ %178, %177 ], [ %111, %171 ]
%182 = getelementptr inbounds [9 x [9 x i32]], [9 x [9 x i32]]* %1, i64 8, i64 %98, i64 %118
%183 = load i32, i32* %182
%184 = icmp eq i32 %183, 0
br i1 %184, label %185, label %187
185: ; preds = %179
%186 = add nsw i32 %110, 1
store i32 %186, i32* %16
br label %187
187: ; preds = %185, %179
%188 = phi i32 [ %186, %185 ], [ %101, %179 ]
%189 = phi i32 [ %186, %185 ], [ %110, %179 ]
%190 = getelementptr inbounds [9 x [9 x i32]], [9 x [9 x i32]]* %1, i64 9, i64 %98, i64 %118
%191 = load i32, i32* %190
%192 = icmp eq i32 %191, 0
br i1 %192, label %193, label %195
193: ; preds = %187
%194 = add nsw i32 %109, 1
store i32 %194, i32* %17
br label %195
195: ; preds = %193, %187
%196 = phi i32 [ %194, %193 ], [ %100, %187 ]
%197 = phi i32 [ %194, %193 ], [ %109, %187 ]
%198 = add nuw nsw i64 %118, 1
%199 = icmp eq i64 %198, %73
br i1 %199, label %200, label %99
200: ; preds = %195
%201 = add nuw nsw i64 %98, 1
%202 = icmp eq i64 %201, %37
br i1 %202, label %203, label %88
203: ; preds = %200
%204 = load i32, i32* %18
%205 = icmp eq i32 %204, 0
%206 = load i32, i32* %19
%207 = icmp eq i32 %206, 0
%208 = select i1 %205, i1 %207, i1 false
br i1 %208, label %209, label %214
209: ; preds = %256, %250, %244, %238, %232, %226, %220, %214, %203
%210 = phi i32 [ 1, %203 ], [ 2, %214 ], [ 3, %220 ], [ 4, %226 ], [ 5, %232 ], [ 6, %238 ], [ 7, %244 ], [ 8, %250 ], [ 9, %256 ]
%211 = trunc i64 %40 to i32
%212 = trunc i64 %75 to i32
%213 = call i32 (i8*, i32, i32, ...) @printf(i8* getelementptr inbounds ([43 x i8], [43 x i8]* @.str, i64 0, i64 0), i32 %211, i32 %212, i32 %210)
br label %813
214: ; preds = %203
%215 = load i32, i32* %20
%216 = icmp eq i32 %215, 0
%217 = load i32, i32* %21
%218 = icmp eq i32 %217, 0
%219 = select i1 %216, i1 %218, i1 false
br i1 %219, label %209, label %220
220: ; preds = %214
%221 = load i32, i32* %22
%222 = icmp eq i32 %221, 0
%223 = load i32, i32* %23
%224 = icmp eq i32 %223, 0
%225 = select i1 %222, i1 %224, i1 false
br i1 %225, label %209, label %226
226: ; preds = %220
%227 = load i32, i32* %24
%228 = icmp eq i32 %227, 0
%229 = load i32, i32* %25
%230 = icmp eq i32 %229, 0
%231 = select i1 %228, i1 %230, i1 false
br i1 %231, label %209, label %232
232: ; preds = %226
%233 = load i32, i32* %26
%234 = icmp eq i32 %233, 0
%235 = load i32, i32* %27
%236 = icmp eq i32 %235, 0
%237 = select i1 %234, i1 %236, i1 false
br i1 %237, label %209, label %238
238: ; preds = %232
%239 = load i32, i32* %28
%240 = icmp eq i32 %239, 0
%241 = load i32, i32* %29
%242 = icmp eq i32 %241, 0
%243 = select i1 %240, i1 %242, i1 false
br i1 %243, label %209, label %244
244: ; preds = %238
%245 = load i32, i32* %30
%246 = icmp eq i32 %245, 0
%247 = load i32, i32* %31
%248 = icmp eq i32 %247, 0
%249 = select i1 %246, i1 %248, i1 false
br i1 %249, label %209, label %250
250: ; preds = %244
%251 = load i32, i32* %32
%252 = icmp eq i32 %251, 0
%253 = load i32, i32* %33
%254 = icmp eq i32 %253, 0
%255 = select i1 %252, i1 %254, i1 false
br i1 %255, label %209, label %256
256: ; preds = %250
%257 = load i32, i32* %34
%258 = icmp eq i32 %257, 0
%259 = load i32, i32* %35
%260 = icmp eq i32 %259, 0
%261 = select i1 %258, i1 %260, i1 false
br i1 %261, label %209, label %262
262: ; preds = %256
%263 = add nuw nsw i64 %75, 1
%264 = add nuw nsw i64 %75, 2
br label %265
265: ; preds = %262, %324
%266 = phi i64 [ 1, %262 ], [ %325, %324 ]
%267 = getelementptr inbounds [10 x i32], [10 x i32]* %3, i64 0, i64 %266
%268 = load i32, i32* %267
%269 = icmp eq i32 %268, 1
br i1 %269, label %270, label %324
270: ; preds = %265
%271 = getelementptr inbounds [9 x [9 x i32]], [9 x [9 x i32]]* %1, i64 %266, i64 %40, i64 %75
%272 = load i32, i32* %271
%273 = icmp eq i32 %272, 0
br i1 %273, label %278, label %292
274: ; preds = %296
%275 = trunc i64 %40 to i32
br label %280
276: ; preds = %292
%277 = trunc i64 %40 to i32
br label %280
278: ; preds = %270
%279 = trunc i64 %40 to i32
br label %280
280: ; preds = %300, %304, %308, %312, %316, %320, %278, %276, %274
%281 = phi i32 [ %275, %274 ], [ %277, %276 ], [ %279, %278 ], [ %38, %320 ], [ %38, %316 ], [ %38, %312 ], [ %39, %308 ], [ %39, %304 ], [ %39, %300 ]
%282 = phi i64 [ %264, %274 ], [ %74, %276 ], [ %75, %278 ], [ %264, %320 ], [ %74, %316 ], [ %75, %312 ], [ %264, %308 ], [ %74, %304 ], [ %75, %300 ]
%283 = trunc i64 %266 to i32
%284 = trunc i64 %282 to i32
%285 = zext i32 %281 to i64
%286 = and i64 %282, 4294967295
%287 = call i32 (i8*, i32, i32, ...) @printf(i8* getelementptr inbounds ([34 x i8], [34 x i8]* @.str.1, i64 0, i64 0), i32 %283, i32 %281, i32 %284)
%288 = getelementptr inbounds [9 x i32], [9 x i32]* %0, i64 %285, i64 %286
store i32 %283, i32* %288
%289 = bitcast [9 x i32]* %0 to i32**
%290 = bitcast [9 x [9 x i32]]* %1 to i32***
%291 = call i32 @exclude(i32** %289, i32*** %290, i32 %281, i32 %284, i32 %283)
br label %813
292: ; preds = %270
%293 = getelementptr inbounds [9 x [9 x i32]], [9 x [9 x i32]]* %1, i64 %266, i64 %40, i64 %263
%294 = load i32, i32* %293
%295 = icmp eq i32 %294, 0
br i1 %295, label %276, label %296
296: ; preds = %292
%297 = getelementptr inbounds [9 x [9 x i32]], [9 x [9 x i32]]* %1, i64 %266, i64 %40, i64 %264
%298 = load i32, i32* %297
%299 = icmp eq i32 %298, 0
br i1 %299, label %274, label %300
300: ; preds = %296
%301 = getelementptr inbounds [9 x [9 x i32]], [9 x [9 x i32]]* %1, i64 %266, i64 %42, i64 %75
%302 = load i32, i32* %301
%303 = icmp eq i32 %302, 0
br i1 %303, label %280, label %304
304: ; preds = %300
%305 = getelementptr inbounds [9 x [9 x i32]], [9 x [9 x i32]]* %1, i64 %266, i64 %42, i64 %263
%306 = load i32, i32* %305
%307 = icmp eq i32 %306, 0
br i1 %307, label %280, label %308
308: ; preds = %304
%309 = getelementptr inbounds [9 x [9 x i32]], [9 x [9 x i32]]* %1, i64 %266, i64 %42, i64 %264
%310 = load i32, i32* %309
%311 = icmp eq i32 %310, 0
br i1 %311, label %280, label %312
312: ; preds = %308
%313 = getelementptr inbounds [9 x [9 x i32]], [9 x [9 x i32]]* %1, i64 %266, i64 %43, i64 %75
%314 = load i32, i32* %313
%315 = icmp eq i32 %314, 0
br i1 %315, label %280, label %316
316: ; preds = %312
%317 = getelementptr inbounds [9 x [9 x i32]], [9 x [9 x i32]]* %1, i64 %266, i64 %43, i64 %263
%318 = load i32, i32* %317
%319 = icmp eq i32 %318, 0
br i1 %319, label %280, label %320
320: ; preds = %316
%321 = getelementptr inbounds [9 x [9 x i32]], [9 x [9 x i32]]* %1, i64 %266, i64 %43, i64 %264
%322 = load i32, i32* %321
%323 = icmp eq i32 %322, 0
br i1 %323, label %280, label %324
324: ; preds = %320, %265
%325 = add nuw nsw i64 %266, 1
%326 = icmp eq i64 %325, 10
br i1 %326, label %327, label %265
327: ; preds = %324
%328 = add nuw nsw i64 %75, 3
%329 = icmp ult i32 %76, 6
%330 = add nuw nsw i64 %73, 3
%331 = add nuw nsw i64 %74, 3
br i1 %329, label %72, label %332
332: ; preds = %327
%333 = add nuw nsw i64 %40, 3
%334 = icmp ult i32 %41, 6
%335 = add nuw nsw i64 %37, 3
%336 = add nuw nsw i32 %39, 3
%337 = add nuw nsw i32 %38, 3
br i1 %334, label %36, label %44
338: ; preds = %582
%339 = getelementptr inbounds [10 x i32], [10 x i32]* %3, i64 0, i64 1
%340 = getelementptr inbounds [10 x i32], [10 x i32]* %3, i64 0, i64 2
%341 = getelementptr inbounds [10 x i32], [10 x i32]* %3, i64 0, i64 3
%342 = getelementptr inbounds [10 x i32], [10 x i32]* %3, i64 0, i64 4
%343 = getelementptr inbounds [10 x i32], [10 x i32]* %3, i64 0, i64 5
%344 = getelementptr inbounds [10 x i32], [10 x i32]* %3, i64 0, i64 6
%345 = getelementptr inbounds [10 x i32], [10 x i32]* %3, i64 0, i64 7
%346 = getelementptr inbounds [10 x i32], [10 x i32]* %3, i64 0, i64 8
%347 = getelementptr inbounds [10 x i32], [10 x i32]* %3, i64 0, i64 9
%348 = getelementptr inbounds [10 x i32], [10 x i32]* %3, i64 0, i64 1
%349 = getelementptr inbounds [10 x i32], [10 x i32]* %3, i64 0, i64 2
%350 = getelementptr inbounds [10 x i32], [10 x i32]* %3, i64 0, i64 3
%351 = getelementptr inbounds [10 x i32], [10 x i32]* %3, i64 0, i64 4
%352 = getelementptr inbounds [10 x i32], [10 x i32]* %3, i64 0, i64 5
%353 = getelementptr inbounds [10 x i32], [10 x i32]* %3, i64 0, i64 6
%354 = getelementptr inbounds [10 x i32], [10 x i32]* %3, i64 0, i64 7
%355 = getelementptr inbounds [10 x i32], [10 x i32]* %3, i64 0, i64 8
%356 = getelementptr inbounds [10 x i32], [10 x i32]* %3, i64 0, i64 9
br label %585
357: ; preds = %44, %582
%358 = phi i64 [ 0, %44 ], [ %583, %582 ]
%359 = call i32 @memset(i32* %7, i32 0, i32 40)
%360 = call i32 @memset(i32* %8, i32 0, i32 40)
%361 = load i32, i32* %54
%362 = load i32, i32* %55
%363 = load i32, i32* %56
%364 = load i32, i32* %57
%365 = load i32, i32* %58
%366 = load i32, i32* %59
%367 = load i32, i32* %60
%368 = load i32, i32* %61
%369 = load i32, i32* %62
br label %370
370: ; preds = %357, %465
%371 = phi i32 [ %369, %357 ], [ %466, %465 ]
%372 = phi i32 [ %368, %357 ], [ %457, %465 ]
%373 = phi i32 [ %367, %357 ], [ %448, %465 ]
%374 = phi i32 [ %366, %357 ], [ %439, %465 ]
%375 = phi i32 [ %365, %357 ], [ %430, %465 ]
%376 = phi i32 [ %364, %357 ], [ %421, %465 ]
%377 = phi i32 [ %363, %357 ], [ %412, %465 ]
%378 = phi i32 [ %362, %357 ], [ %403, %465 ]
%379 = phi i32 [ %361, %357 ], [ %394, %465 ]
%380 = phi i64 [ 0, %357 ], [ %467, %465 ]
%381 = getelementptr inbounds [9 x i32], [9 x i32]* %0, i64 %358, i64 %380
%382 = load i32, i32* %381
%383 = icmp eq i32 %382, 0
%384 = sext i32 %382 to i64
%385 = getelementptr inbounds [10 x i32], [10 x i32]* %4, i64 0, i64 %384
br i1 %383, label %387, label %386
386: ; preds = %370
store i32 1, i32* %385
br label %387
387: ; preds = %386, %370
%388 = getelementptr inbounds [9 x [9 x i32]], [9 x [9 x i32]]* %1, i64 1, i64 %358, i64 %380
%389 = load i32, i32* %388
%390 = icmp eq i32 %389, 0
br i1 %390, label %391, label %393
391: ; preds = %387
%392 = add nsw i32 %379, 1
store i32 %392, i32* %54
br label %393
393: ; preds = %387, %391
%394 = phi i32 [ %379, %387 ], [ %392, %391 ]
br i1 %383, label %396, label %395
395: ; preds = %393
store i32 1, i32* %385
br label %396
396: ; preds = %395, %393
%397 = getelementptr inbounds [9 x [9 x i32]], [9 x [9 x i32]]* %1, i64 2, i64 %358, i64 %380
%398 = load i32, i32* %397
%399 = icmp eq i32 %398, 0
br i1 %399, label %400, label %402
400: ; preds = %396
%401 = add nsw i32 %378, 1
store i32 %401, i32* %55
br label %402
402: ; preds = %400, %396
%403 = phi i32 [ %401, %400 ], [ %378, %396 ]
br i1 %383, label %405, label %404
404: ; preds = %402
store i32 1, i32* %385
br label %405
405: ; preds = %404, %402
%406 = getelementptr inbounds [9 x [9 x i32]], [9 x [9 x i32]]* %1, i64 3, i64 %358, i64 %380
%407 = load i32, i32* %406
%408 = icmp eq i32 %407, 0
br i1 %408, label %409, label %411
409: ; preds = %405
%410 = add nsw i32 %377, 1
store i32 %410, i32* %56
br label %411
411: ; preds = %409, %405
%412 = phi i32 [ %410, %409 ], [ %377, %405 ]
br i1 %383, label %414, label %413
413: ; preds = %411
store i32 1, i32* %385
br label %414
414: ; preds = %413, %411
%415 = getelementptr inbounds [9 x [9 x i32]], [9 x [9 x i32]]* %1, i64 4, i64 %358, i64 %380
%416 = load i32, i32* %415
%417 = icmp eq i32 %416, 0
br i1 %417, label %418, label %420
418: ; preds = %414
%419 = add nsw i32 %376, 1
store i32 %419, i32* %57
br label %420
420: ; preds = %418, %414
%421 = phi i32 [ %419, %418 ], [ %376, %414 ]
br i1 %383, label %423, label %422
422: ; preds = %420
store i32 1, i32* %385
br label %423
423: ; preds = %422, %420
%424 = getelementptr inbounds [9 x [9 x i32]], [9 x [9 x i32]]* %1, i64 5, i64 %358, i64 %380
%425 = load i32, i32* %424
%426 = icmp eq i32 %425, 0
br i1 %426, label %427, label %429
427: ; preds = %423
%428 = add nsw i32 %375, 1
store i32 %428, i32* %58
br label %429
429: ; preds = %427, %423
%430 = phi i32 [ %428, %427 ], [ %375, %423 ]
br i1 %383, label %432, label %431
431: ; preds = %429
store i32 1, i32* %385
br label %432
432: ; preds = %431, %429
%433 = getelementptr inbounds [9 x [9 x i32]], [9 x [9 x i32]]* %1, i64 6, i64 %358, i64 %380
%434 = load i32, i32* %433
%435 = icmp eq i32 %434, 0
br i1 %435, label %436, label %438
436: ; preds = %432
%437 = add nsw i32 %374, 1
store i32 %437, i32* %59
br label %438
438: ; preds = %436, %432
%439 = phi i32 [ %437, %436 ], [ %374, %432 ]
br i1 %383, label %441, label %440
440: ; preds = %438
store i32 1, i32* %385
br label %441
441: ; preds = %440, %438
%442 = getelementptr inbounds [9 x [9 x i32]], [9 x [9 x i32]]* %1, i64 7, i64 %358, i64 %380
%443 = load i32, i32* %442
%444 = icmp eq i32 %443, 0
br i1 %444, label %445, label %447
445: ; preds = %441
%446 = add nsw i32 %373, 1
store i32 %446, i32* %60
br label %447
447: ; preds = %445, %441
%448 = phi i32 [ %446, %445 ], [ %373, %441 ]
br i1 %383, label %450, label %449
449: ; preds = %447
store i32 1, i32* %385
br label %450
450: ; preds = %449, %447
%451 = getelementptr inbounds [9 x [9 x i32]], [9 x [9 x i32]]* %1, i64 8, i64 %358, i64 %380
%452 = load i32, i32* %451
%453 = icmp eq i32 %452, 0
br i1 %453, label %454, label %456
454: ; preds = %450
%455 = add nsw i32 %372, 1
store i32 %455, i32* %61
br label %456
456: ; preds = %454, %450
%457 = phi i32 [ %455, %454 ], [ %372, %450 ]
br i1 %383, label %459, label %458
458: ; preds = %456
store i32 1, i32* %385
br label %459
459: ; preds = %458, %456
%460 = getelementptr inbounds [9 x [9 x i32]], [9 x [9 x i32]]* %1, i64 9, i64 %358, i64 %380
%461 = load i32, i32* %460
%462 = icmp eq i32 %461, 0
br i1 %462, label %463, label %465
463: ; preds = %459
%464 = add nsw i32 %371, 1
store i32 %464, i32* %62
br label %465
465: ; preds = %463, %459
%466 = phi i32 [ %464, %463 ], [ %371, %459 ]
%467 = add nuw nsw i64 %380, 1
%468 = icmp eq i64 %467, 9
br i1 %468, label %469, label %370
469: ; preds = %465
%470 = load i32, i32* %45
%471 = icmp eq i32 %470, 0
%472 = load i32, i32* %63
%473 = icmp eq i32 %472, 0
%474 = select i1 %471, i1 %473, i1 false
br i1 %474, label %475, label %479
475: ; preds = %521, %515, %509, %503, %497, %491, %485, %479, %469
%476 = phi i32 [ 1, %469 ], [ 2, %479 ], [ 3, %485 ], [ 4, %491 ], [ 5, %497 ], [ 6, %503 ], [ 7, %509 ], [ 8, %515 ], [ 9, %521 ]
%477 = trunc i64 %358 to i32
%478 = call i32 (i8*, i32, i32, ...) @printf(i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str.2, i64 0, i64 0), i32 %477, i32 %476)
br label %813
479: ; preds = %469
%480 = load i32, i32* %46
%481 = icmp eq i32 %480, 0
%482 = load i32, i32* %64
%483 = icmp eq i32 %482, 0
%484 = select i1 %481, i1 %483, i1 false
br i1 %484, label %475, label %485
485: ; preds = %479
%486 = load i32, i32* %47
%487 = icmp eq i32 %486, 0
%488 = load i32, i32* %65
%489 = icmp eq i32 %488, 0
%490 = select i1 %487, i1 %489, i1 false
br i1 %490, label %475, label %491
491: ; preds = %485
%492 = load i32, i32* %48
%493 = icmp eq i32 %492, 0
%494 = load i32, i32* %66
%495 = icmp eq i32 %494, 0
%496 = select i1 %493, i1 %495, i1 false
br i1 %496, label %475, label %497
497: ; preds = %491
%498 = load i32, i32* %49
%499 = icmp eq i32 %498, 0
%500 = load i32, i32* %67
%501 = icmp eq i32 %500, 0
%502 = select i1 %499, i1 %501, i1 false
br i1 %502, label %475, label %503
503: ; preds = %497
%504 = load i32, i32* %50
%505 = icmp eq i32 %504, 0
%506 = load i32, i32* %68
%507 = icmp eq i32 %506, 0
%508 = select i1 %505, i1 %507, i1 false
br i1 %508, label %475, label %509
509: ; preds = %503
%510 = load i32, i32* %51
%511 = icmp eq i32 %510, 0
%512 = load i32, i32* %69
%513 = icmp eq i32 %512, 0
%514 = select i1 %511, i1 %513, i1 false
br i1 %514, label %475, label %515
515: ; preds = %509
%516 = load i32, i32* %52
%517 = icmp eq i32 %516, 0
%518 = load i32, i32* %70
%519 = icmp eq i32 %518, 0
%520 = select i1 %517, i1 %519, i1 false
br i1 %520, label %475, label %521
521: ; preds = %515
%522 = load i32, i32* %53
%523 = icmp eq i32 %522, 0
%524 = load i32, i32* %71
%525 = icmp eq i32 %524, 0
%526 = select i1 %523, i1 %525, i1 false
br i1 %526, label %475, label %527
527: ; preds = %521, %579
%528 = phi i64 [ %580, %579 ], [ 1, %521 ]
%529 = getelementptr inbounds [10 x i32], [10 x i32]* %3, i64 0, i64 %528
%530 = load i32, i32* %529
%531 = icmp eq i32 %530, 1
br i1 %531, label %532, label %579
532: ; preds = %527
%533 = getelementptr inbounds [9 x [9 x i32]], [9 x [9 x i32]]* %1, i64 %528, i64 %358, i64 0
%534 = load i32, i32* %533
%535 = icmp eq i32 %534, 0
br i1 %535, label %536, label %547
536: ; preds = %575, %571, %567, %563, %559, %555, %551, %547, %532
%537 = phi i32 [ 0, %532 ], [ 1, %547 ], [ 2, %551 ], [ 3, %555 ], [ 4, %559 ], [ 5, %563 ], [ 6, %567 ], [ 7, %571 ], [ 8, %575 ]
%538 = trunc i64 %358 to i32
%539 = trunc i64 %528 to i32
%540 = and i64 %358, 4294967295
%541 = zext i32 %537 to i64
%542 = call i32 (i8*, i32, i32, ...) @printf(i8* getelementptr inbounds ([32 x i8], [32 x i8]* @.str.3, i64 0, i64 0), i32 %539, i32 %538, i32 %537)
%543 = getelementptr inbounds [9 x i32], [9 x i32]* %0, i64 %540, i64 %541
store i32 %539, i32* %543
%544 = bitcast [9 x i32]* %0 to i32**
%545 = bitcast [9 x [9 x i32]]* %1 to i32***
%546 = call i32 @exclude(i32** %544, i32*** %545, i32 %538, i32 %537, i32 %539)
br label %813
547: ; preds = %532
%548 = getelementptr inbounds [9 x [9 x i32]], [9 x [9 x i32]]* %1, i64 %528, i64 %358, i64 1
%549 = load i32, i32* %548
%550 = icmp eq i32 %549, 0
br i1 %550, label %536, label %551
551: ; preds = %547
%552 = getelementptr inbounds [9 x [9 x i32]], [9 x [9 x i32]]* %1, i64 %528, i64 %358, i64 2
%553 = load i32, i32* %552
%554 = icmp eq i32 %553, 0
br i1 %554, label %536, label %555
555: ; preds = %551
%556 = getelementptr inbounds [9 x [9 x i32]], [9 x [9 x i32]]* %1, i64 %528, i64 %358, i64 3
%557 = load i32, i32* %556
%558 = icmp eq i32 %557, 0
br i1 %558, label %536, label %559
559: ; preds = %555
%560 = getelementptr inbounds [9 x [9 x i32]], [9 x [9 x i32]]* %1, i64 %528, i64 %358, i64 4
%561 = load i32, i32* %560
%562 = icmp eq i32 %561, 0
br i1 %562, label %536, label %563
563: ; preds = %559
%564 = getelementptr inbounds [9 x [9 x i32]], [9 x [9 x i32]]* %1, i64 %528, i64 %358, i64 5
%565 = load i32, i32* %564
%566 = icmp eq i32 %565, 0
br i1 %566, label %536, label %567
567: ; preds = %563
%568 = getelementptr inbounds [9 x [9 x i32]], [9 x [9 x i32]]* %1, i64 %528, i64 %358, i64 6
%569 = load i32, i32* %568
%570 = icmp eq i32 %569, 0
br i1 %570, label %536, label %571
571: ; preds = %567
%572 = getelementptr inbounds [9 x [9 x i32]], [9 x [9 x i32]]* %1, i64 %528, i64 %358, i64 7
%573 = load i32, i32* %572
%574 = icmp eq i32 %573, 0
br i1 %574, label %536, label %575
575: ; preds = %571
%576 = getelementptr inbounds [9 x [9 x i32]], [9 x [9 x i32]]* %1, i64 %528, i64 %358, i64 8
%577 = load i32, i32* %576
%578 = icmp eq i32 %577, 0
br i1 %578, label %536, label %579
579: ; preds = %575, %527
%580 = add nuw nsw i64 %528, 1
%581 = icmp eq i64 %580, 10
br i1 %581, label %582, label %527
582: ; preds = %579
%583 = add nuw nsw i64 %358, 1
%584 = icmp eq i64 %583, 9
br i1 %584, label %338, label %357
585: ; preds = %338, %810
%586 = phi i64 [ 0, %338 ], [ %811, %810 ]
%587 = call i32 @memset(i32* %7, i32 0, i32 40)
%588 = call i32 @memset(i32* %8, i32 0, i32 40)
%589 = load i32, i32* %339
%590 = load i32, i32* %340
%591 = load i32, i32* %341
%592 = load i32, i32* %342
%593 = load i32, i32* %343
%594 = load i32, i32* %344
%595 = load i32, i32* %345
%596 = load i32, i32* %346
%597 = load i32, i32* %347
br label %598
598: ; preds = %585, %693
%599 = phi i32 [ %597, %585 ], [ %694, %693 ]
%600 = phi i32 [ %596, %585 ], [ %685, %693 ]
%601 = phi i32 [ %595, %585 ], [ %676, %693 ]
%602 = phi i32 [ %594, %585 ], [ %667, %693 ]
%603 = phi i32 [ %593, %585 ], [ %658, %693 ]
%604 = phi i32 [ %592, %585 ], [ %649, %693 ]
%605 = phi i32 [ %591, %585 ], [ %640, %693 ]
%606 = phi i32 [ %590, %585 ], [ %631, %693 ]
%607 = phi i32 [ %589, %585 ], [ %622, %693 ]
%608 = phi i64 [ 0, %585 ], [ %695, %693 ]
%609 = getelementptr inbounds [9 x i32], [9 x i32]* %0, i64 %608, i64 %586
%610 = load i32, i32* %609
%611 = icmp eq i32 %610, 0
%612 = sext i32 %610 to i64
%613 = getelementptr inbounds [10 x i32], [10 x i32]* %4, i64 0, i64 %612
br i1 %611, label %615, label %614
614: ; preds = %598
store i32 1, i32* %613
br label %615
615: ; preds = %614, %598
%616 = getelementptr inbounds [9 x [9 x i32]], [9 x [9 x i32]]* %1, i64 1, i64 %608, i64 %586
%617 = load i32, i32* %616
%618 = icmp eq i32 %617, 0
br i1 %618, label %619, label %621
619: ; preds = %615
%620 = add nsw i32 %607, 1
store i32 %620, i32* %339
br label %621
621: ; preds = %615, %619
%622 = phi i32 [ %607, %615 ], [ %620, %619 ]
br i1 %611, label %624, label %623
623: ; preds = %621
store i32 1, i32* %613
br label %624
624: ; preds = %623, %621
%625 = getelementptr inbounds [9 x [9 x i32]], [9 x [9 x i32]]* %1, i64 2, i64 %608, i64 %586
%626 = load i32, i32* %625
%627 = icmp eq i32 %626, 0
br i1 %627, label %628, label %630
628: ; preds = %624
%629 = add nsw i32 %606, 1
store i32 %629, i32* %340
br label %630
630: ; preds = %628, %624
%631 = phi i32 [ %629, %628 ], [ %606, %624 ]
br i1 %611, label %633, label %632
632: ; preds = %630
store i32 1, i32* %613
br label %633
633: ; preds = %632, %630
%634 = getelementptr inbounds [9 x [9 x i32]], [9 x [9 x i32]]* %1, i64 3, i64 %608, i64 %586
%635 = load i32, i32* %634
%636 = icmp eq i32 %635, 0
br i1 %636, label %637, label %639
637: ; preds = %633
%638 = add nsw i32 %605, 1
store i32 %638, i32* %341
br label %639
639: ; preds = %637, %633
%640 = phi i32 [ %638, %637 ], [ %605, %633 ]
br i1 %611, label %642, label %641
641: ; preds = %639
store i32 1, i32* %613
br label %642
642: ; preds = %641, %639
%643 = getelementptr inbounds [9 x [9 x i32]], [9 x [9 x i32]]* %1, i64 4, i64 %608, i64 %586
%644 = load i32, i32* %643
%645 = icmp eq i32 %644, 0
br i1 %645, label %646, label %648
646: ; preds = %642
%647 = add nsw i32 %604, 1
store i32 %647, i32* %342
br label %648
648: ; preds = %646, %642
%649 = phi i32 [ %647, %646 ], [ %604, %642 ]
br i1 %611, label %651, label %650
650: ; preds = %648
store i32 1, i32* %613
br label %651
651: ; preds = %650, %648
%652 = getelementptr inbounds [9 x [9 x i32]], [9 x [9 x i32]]* %1, i64 5, i64 %608, i64 %586
%653 = load i32, i32* %652
%654 = icmp eq i32 %653, 0
br i1 %654, label %655, label %657
655: ; preds = %651
%656 = add nsw i32 %603, 1
store i32 %656, i32* %343
br label %657
657: ; preds = %655, %651
%658 = phi i32 [ %656, %655 ], [ %603, %651 ]
br i1 %611, label %660, label %659
659: ; preds = %657
store i32 1, i32* %613
br label %660
660: ; preds = %659, %657
%661 = getelementptr inbounds [9 x [9 x i32]], [9 x [9 x i32]]* %1, i64 6, i64 %608, i64 %586
%662 = load i32, i32* %661
%663 = icmp eq i32 %662, 0
br i1 %663, label %664, label %666
664: ; preds = %660
%665 = add nsw i32 %602, 1
store i32 %665, i32* %344
br label %666
666: ; preds = %664, %660
%667 = phi i32 [ %665, %664 ], [ %602, %660 ]
br i1 %611, label %669, label %668
668: ; preds = %666
store i32 1, i32* %613
br label %669
669: ; preds = %668, %666
%670 = getelementptr inbounds [9 x [9 x i32]], [9 x [9 x i32]]* %1, i64 7, i64 %608, i64 %586
%671 = load i32, i32* %670
%672 = icmp eq i32 %671, 0
br i1 %672, label %673, label %675
673: ; preds = %669
%674 = add nsw i32 %601, 1
store i32 %674, i32* %345
br label %675
675: ; preds = %673, %669
%676 = phi i32 [ %674, %673 ], [ %601, %669 ]
br i1 %611, label %678, label %677
677: ; preds = %675
store i32 1, i32* %613
br label %678
678: ; preds = %677, %675
%679 = getelementptr inbounds [9 x [9 x i32]], [9 x [9 x i32]]* %1, i64 8, i64 %608, i64 %586
%680 = load i32, i32* %679
%681 = icmp eq i32 %680, 0
br i1 %681, label %682, label %684
682: ; preds = %678
%683 = add nsw i32 %600, 1
store i32 %683, i32* %346
br label %684
684: ; preds = %682, %678
%685 = phi i32 [ %683, %682 ], [ %600, %678 ]
br i1 %611, label %687, label %686
686: ; preds = %684
store i32 1, i32* %613
br label %687
687: ; preds = %686, %684
%688 = getelementptr inbounds [9 x [9 x i32]], [9 x [9 x i32]]* %1, i64 9, i64 %608, i64 %586
%689 = load i32, i32* %688
%690 = icmp eq i32 %689, 0
br i1 %690, label %691, label %693
691: ; preds = %687
%692 = add nsw i32 %599, 1
store i32 %692, i32* %347
br label %693
693: ; preds = %691, %687
%694 = phi i32 [ %692, %691 ], [ %599, %687 ]
%695 = add nuw nsw i64 %608, 1
%696 = icmp eq i64 %695, 9
br i1 %696, label %697, label %598
697: ; preds = %693
%698 = load i32, i32* %45
%699 = icmp eq i32 %698, 0
%700 = load i32, i32* %348
%701 = icmp eq i32 %700, 0
%702 = select i1 %699, i1 %701, i1 false
br i1 %702, label %703, label %707
703: ; preds = %749, %743, %737, %731, %725, %719, %713, %707, %697
%704 = phi i32 [ 1, %697 ], [ 2, %707 ], [ 3, %713 ], [ 4, %719 ], [ 5, %725 ], [ 6, %731 ], [ 7, %737 ], [ 8, %743 ], [ 9, %749 ]
%705 = trunc i64 %586 to i32
%706 = call i32 (i8*, i32, i32, ...) @printf(i8* getelementptr inbounds ([38 x i8], [38 x i8]* @.str.4, i64 0, i64 0), i32 %705, i32 %704)
br label %813
707: ; preds = %697
%708 = load i32, i32* %46
%709 = icmp eq i32 %708, 0
%710 = load i32, i32* %349
%711 = icmp eq i32 %710, 0
%712 = select i1 %709, i1 %711, i1 false
br i1 %712, label %703, label %713
713: ; preds = %707
%714 = load i32, i32* %47
%715 = icmp eq i32 %714, 0
%716 = load i32, i32* %350
%717 = icmp eq i32 %716, 0
%718 = select i1 %715, i1 %717, i1 false
br i1 %718, label %703, label %719
719: ; preds = %713
%720 = load i32, i32* %48
%721 = icmp eq i32 %720, 0
%722 = load i32, i32* %351
%723 = icmp eq i32 %722, 0
%724 = select i1 %721, i1 %723, i1 false
br i1 %724, label %703, label %725
725: ; preds = %719
%726 = load i32, i32* %49
%727 = icmp eq i32 %726, 0
%728 = load i32, i32* %352
%729 = icmp eq i32 %728, 0
%730 = select i1 %727, i1 %729, i1 false
br i1 %730, label %703, label %731
731: ; preds = %725
%732 = load i32, i32* %50
%733 = icmp eq i32 %732, 0
%734 = load i32, i32* %353
%735 = icmp eq i32 %734, 0
%736 = select i1 %733, i1 %735, i1 false
br i1 %736, label %703, label %737
737: ; preds = %731
%738 = load i32, i32* %51
%739 = icmp eq i32 %738, 0
%740 = load i32, i32* %354
%741 = icmp eq i32 %740, 0
%742 = select i1 %739, i1 %741, i1 false
br i1 %742, label %703, label %743
743: ; preds = %737
%744 = load i32, i32* %52
%745 = icmp eq i32 %744, 0
%746 = load i32, i32* %355
%747 = icmp eq i32 %746, 0
%748 = select i1 %745, i1 %747, i1 false
br i1 %748, label %703, label %749
749: ; preds = %743
%750 = load i32, i32* %53
%751 = icmp eq i32 %750, 0
%752 = load i32, i32* %356
%753 = icmp eq i32 %752, 0
%754 = select i1 %751, i1 %753, i1 false
br i1 %754, label %703, label %755
755: ; preds = %749, %807
%756 = phi i64 [ %808, %807 ], [ 1, %749 ]
%757 = getelementptr inbounds [10 x i32], [10 x i32]* %3, i64 0, i64 %756
%758 = load i32, i32* %757
%759 = icmp eq i32 %758, 1
br i1 %759, label %760, label %807
760: ; preds = %755
%761 = getelementptr inbounds [9 x [9 x i32]], [9 x [9 x i32]]* %1, i64 %756, i64 0, i64 %586
%762 = load i32, i32* %761
%763 = icmp eq i32 %762, 0
br i1 %763, label %764, label %775
764: ; preds = %803, %799, %795, %791, %787, %783, %779, %775, %760
%765 = phi i32 [ 0, %760 ], [ 1, %775 ], [ 2, %779 ], [ 3, %783 ], [ 4, %787 ], [ 5, %791 ], [ 6, %795 ], [ 7, %799 ], [ 8, %803 ]
%766 = trunc i64 %586 to i32
%767 = trunc i64 %756 to i32
%768 = zext i32 %765 to i64
%769 = and i64 %586, 4294967295
%770 = call i32 (i8*, i32, i32, ...) @printf(i8* getelementptr inbounds ([35 x i8], [35 x i8]* @.str.5, i64 0, i64 0), i32 %767, i32 %765, i32 %766)
%771 = getelementptr inbounds [9 x i32], [9 x i32]* %0, i64 %768, i64 %769
store i32 %767, i32* %771
%772 = bitcast [9 x i32]* %0 to i32**
%773 = bitcast [9 x [9 x i32]]* %1 to i32***
%774 = call i32 @exclude(i32** %772, i32*** %773, i32 %765, i32 %766, i32 %767)
br label %813
775: ; preds = %760
%776 = getelementptr inbounds [9 x [9 x i32]], [9 x [9 x i32]]* %1, i64 %756, i64 1, i64 %586
%777 = load i32, i32* %776
%778 = icmp eq i32 %777, 0
br i1 %778, label %764, label %779
779: ; preds = %775
%780 = getelementptr inbounds [9 x [9 x i32]], [9 x [9 x i32]]* %1, i64 %756, i64 2, i64 %586
%781 = load i32, i32* %780
%782 = icmp eq i32 %781, 0
br i1 %782, label %764, label %783
783: ; preds = %779
%784 = getelementptr inbounds [9 x [9 x i32]], [9 x [9 x i32]]* %1, i64 %756, i64 3, i64 %586
%785 = load i32, i32* %784
%786 = icmp eq i32 %785, 0
br i1 %786, label %764, label %787
787: ; preds = %783
%788 = getelementptr inbounds [9 x [9 x i32]], [9 x [9 x i32]]* %1, i64 %756, i64 4, i64 %586
%789 = load i32, i32* %788
%790 = icmp eq i32 %789, 0
br i1 %790, label %764, label %791
791: ; preds = %787
%792 = getelementptr inbounds [9 x [9 x i32]], [9 x [9 x i32]]* %1, i64 %756, i64 5, i64 %586
%793 = load i32, i32* %792
%794 = icmp eq i32 %793, 0
br i1 %794, label %764, label %795
795: ; preds = %791
%796 = getelementptr inbounds [9 x [9 x i32]], [9 x [9 x i32]]* %1, i64 %756, i64 6, i64 %586
%797 = load i32, i32* %796
%798 = icmp eq i32 %797, 0
br i1 %798, label %764, label %799
799: ; preds = %795
%800 = getelementptr inbounds [9 x [9 x i32]], [9 x [9 x i32]]* %1, i64 %756, i64 7, i64 %586
%801 = load i32, i32* %800
%802 = icmp eq i32 %801, 0
br i1 %802, label %764, label %803
803: ; preds = %799
%804 = getelementptr inbounds [9 x [9 x i32]], [9 x [9 x i32]]* %1, i64 %756, i64 8, i64 %586
%805 = load i32, i32* %804
%806 = icmp eq i32 %805, 0
br i1 %806, label %764, label %807
807: ; preds = %803, %755
%808 = add nuw nsw i64 %756, 1
%809 = icmp eq i64 %808, 10
br i1 %809, label %810, label %755
810: ; preds = %807
%811 = add nuw nsw i64 %586, 1
%812 = icmp eq i64 %811, 9
br i1 %812, label %813, label %585
813: ; preds = %810, %764, %703, %536, %475, %280, %209
%814 = phi i32 [ 2, %209 ], [ 0, %280 ], [ 2, %475 ], [ 0, %536 ], [ 2, %703 ], [ 0, %764 ], [ 1, %810 ]
ret i32 %814
}