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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ initArray(int *, int, int /*<<< orphan*/);
int /*<<< orphan*/ printf(char *, int, int);
int sudokuValide(int sudoku[9][9]) {
  int i, j, rCol, rLin;
  int seen[9];
  initArray(seen, 9, 0);
  for (i = 0; i < 9; i++) {
    for (j = 0; j < 9; j++) {
      if (sudoku[i][j] > 0) {
        seen[sudoku[i][j] - 1]++;
        if (seen[sudoku[i][j] - 1] > 1) {
          printf("Invalid on line on (%d,%d)\n", i, j);
          return 0;
        }
      }
    }
    initArray(seen, 9, 0);
  }
  for (i = 0; i < 9; i++) {
    for (j = 0; j < 9; j++) {
      if (sudoku[j][i] > 0) {
        seen[sudoku[j][i] - 1]++;
        if (seen[sudoku[j][i] - 1] > 1) {
          printf("Invalid on column on (%d,%d)\n", j, i);
          return 0;
        }
      }
    }
    initArray(seen, 9, 0);
  }
  for (rCol = 0; rCol < 9; rCol += 3) {
    for (rLin = 0; rLin < 9; rLin += 3) {
      for (i = 0; i < (9 / 3); i++) {
        for (j = 0; j < (9 / 3); j++) {
          if (sudoku[rLin + i][rCol + j] > 0) {
            seen[sudoku[rLin + i][rCol + j] - 1]++;
            if (seen[sudoku[rLin + i][rCol + j] - 1] > 1) {
              printf("Invalid on region on (%d,%d)\n", rLin + i, rCol + j);
              return 0;
            }
          }
        }
      }
      initArray(seen, 9, 0);
    }
  }
  return 1;
}


x86 assembly (clang, -O0):
<sudokuValide>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x10(%rbp)
lea    -0x50(%rbp),%rdi
mov    $0x9,%esi
xor    %edx,%edx
call   1040 <initArray@plt>
movl   $0x0,-0x14(%rbp)
cmpl   $0x9,-0x14(%rbp)
jge    121b <sudokuValide+0xfb>
movl   $0x0,-0x18(%rbp)
cmpl   $0x9,-0x18(%rbp)
jge    11fd <sudokuValide+0xdd>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
imul   $0x24,%rcx,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jle    11ea <sudokuValide+0xca>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
imul   $0x24,%rcx,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
sub    $0x1,%eax
cltq
mov    -0x50(%rbp,%rax,4),%ecx
add    $0x1,%ecx
mov    %ecx,-0x50(%rbp,%rax,4)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
imul   $0x24,%rcx,%rcx
add    %rcx,%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
sub    $0x1,%eax
cltq
cmpl   $0x1,-0x50(%rbp,%rax,4)
jle    11e5 <sudokuValide+0xc5>
mov    -0x14(%rbp),%esi
mov    -0x18(%rbp),%edx
lea    0xe2c(%rip),%rdi
call   1030 <printf@plt>
movl   $0x0,-0x4(%rbp)
jmp    144c <sudokuValide+0x32c>
jmp    11ea <sudokuValide+0xca>
jmp    11ef <sudokuValide+0xcf>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1154 <sudokuValide+0x34>
lea    -0x50(%rbp),%rdi
mov    $0x9,%esi
xor    %edx,%edx
call   1040 <initArray@plt>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1143 <sudokuValide+0x23>
movl   $0x0,-0x14(%rbp)
cmpl   $0x9,-0x14(%rbp)
jge    12fa <sudokuValide+0x1da>
movl   $0x0,-0x18(%rbp)
cmpl   $0x9,-0x18(%rbp)
jge    12dc <sudokuValide+0x1bc>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
imul   $0x24,%rcx,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jle    12c9 <sudokuValide+0x1a9>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
imul   $0x24,%rcx,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
sub    $0x1,%eax
cltq
mov    -0x50(%rbp,%rax,4),%ecx
add    $0x1,%ecx
mov    %ecx,-0x50(%rbp,%rax,4)
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
imul   $0x24,%rcx,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
sub    $0x1,%eax
cltq
cmpl   $0x1,-0x50(%rbp,%rax,4)
jle    12c4 <sudokuValide+0x1a4>
mov    -0x18(%rbp),%esi
mov    -0x14(%rbp),%edx
lea    0xd69(%rip),%rdi
call   1030 <printf@plt>
movl   $0x0,-0x4(%rbp)
jmp    144c <sudokuValide+0x32c>
jmp    12c9 <sudokuValide+0x1a9>
jmp    12ce <sudokuValide+0x1ae>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1233 <sudokuValide+0x113>
lea    -0x50(%rbp),%rdi
mov    $0x9,%esi
xor    %edx,%edx
call   1040 <initArray@plt>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1222 <sudokuValide+0x102>
movl   $0x0,-0x1c(%rbp)
cmpl   $0x9,-0x1c(%rbp)
jge    1445 <sudokuValide+0x325>
movl   $0x0,-0x20(%rbp)
cmpl   $0x9,-0x20(%rbp)
jge    1432 <sudokuValide+0x312>
movl   $0x0,-0x14(%rbp)
cmpl   $0x3,-0x14(%rbp)
jge    1414 <sudokuValide+0x2f4>
movl   $0x0,-0x18(%rbp)
cmpl   $0x3,-0x18(%rbp)
jge    1401 <sudokuValide+0x2e1>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
imul   $0x24,%rcx,%rcx
add    %rcx,%rax
mov    -0x1c(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
jle    13ee <sudokuValide+0x2ce>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
imul   $0x24,%rcx,%rcx
add    %rcx,%rax
mov    -0x1c(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
sub    $0x1,%eax
cltq
mov    -0x50(%rbp,%rax,4),%ecx
add    $0x1,%ecx
mov    %ecx,-0x50(%rbp,%rax,4)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
imul   $0x24,%rcx,%rcx
add    %rcx,%rax
mov    -0x1c(%rbp),%ecx
add    -0x18(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
sub    $0x1,%eax
cltq
cmpl   $0x1,-0x50(%rbp,%rax,4)
jle    13e9 <sudokuValide+0x2c9>
mov    -0x20(%rbp),%esi
add    -0x14(%rbp),%esi
mov    -0x1c(%rbp),%edx
add    -0x18(%rbp),%edx
lea    0xc62(%rip),%rdi
call   1030 <printf@plt>
movl   $0x0,-0x4(%rbp)
jmp    144c <sudokuValide+0x32c>
jmp    13ee <sudokuValide+0x2ce>
jmp    13f3 <sudokuValide+0x2d3>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1334 <sudokuValide+0x214>
jmp    1406 <sudokuValide+0x2e6>
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1323 <sudokuValide+0x203>
lea    -0x50(%rbp),%rdi
mov    $0x9,%esi
xor    %edx,%edx
call   1040 <initArray@plt>
mov    -0x20(%rbp),%eax
add    $0x3,%eax
mov    %eax,-0x20(%rbp)
jmp    1312 <sudokuValide+0x1f2>
jmp    1437 <sudokuValide+0x317>
mov    -0x1c(%rbp),%eax
add    $0x3,%eax
mov    %eax,-0x1c(%rbp)
jmp    1301 <sudokuValide+0x1e1>
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<sudokuValide>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    %rdi,%r15
mov    %rsp,%r14
xor    %ebx,%ebx
mov    %r14,%rdi
mov    $0x9,%esi
xor    %edx,%edx
call   1040 <initArray@plt>
lea    0x20(%r15),%rbp
jmp    1171 <sudokuValide+0x51>
nopl   0x0(%rax,%rax,1)
mov    %r14,%rdi
mov    $0x9,%esi
xor    %edx,%edx
call   1040 <initArray@plt>
add    $0x1,%rbx
add    $0x24,%rbp
cmp    $0x9,%rbx
je     1272 <sudokuValide+0x152>
mov    -0x20(%rbp),%eax
test   %eax,%eax
jle    118c <sudokuValide+0x6c>
add    $0xffffffff,%eax
mov    (%rsp,%rax,4),%ecx
lea    0x1(%rcx),%edx
mov    %edx,(%rsp,%rax,4)
test   %ecx,%ecx
jg     13be <sudokuValide+0x29e>
mov    -0x1c(%rbp),%eax
test   %eax,%eax
jle    11a7 <sudokuValide+0x87>
add    $0xffffffff,%eax
mov    (%rsp,%rax,4),%ecx
lea    0x1(%rcx),%edx
mov    %edx,(%rsp,%rax,4)
test   %ecx,%ecx
jg     13c2 <sudokuValide+0x2a2>
mov    -0x18(%rbp),%eax
test   %eax,%eax
jle    11c2 <sudokuValide+0xa2>
add    $0xffffffff,%eax
mov    (%rsp,%rax,4),%ecx
lea    0x1(%rcx),%edx
mov    %edx,(%rsp,%rax,4)
test   %ecx,%ecx
jg     13c9 <sudokuValide+0x2a9>
mov    -0x14(%rbp),%eax
test   %eax,%eax
jle    11dd <sudokuValide+0xbd>
add    $0xffffffff,%eax
mov    (%rsp,%rax,4),%ecx
lea    0x1(%rcx),%edx
mov    %edx,(%rsp,%rax,4)
test   %ecx,%ecx
jg     13d0 <sudokuValide+0x2b0>
mov    -0x10(%rbp),%eax
test   %eax,%eax
jle    11f8 <sudokuValide+0xd8>
add    $0xffffffff,%eax
mov    (%rsp,%rax,4),%ecx
lea    0x1(%rcx),%edx
mov    %edx,(%rsp,%rax,4)
test   %ecx,%ecx
jg     13d7 <sudokuValide+0x2b7>
mov    -0xc(%rbp),%eax
test   %eax,%eax
jle    1213 <sudokuValide+0xf3>
add    $0xffffffff,%eax
mov    (%rsp,%rax,4),%ecx
lea    0x1(%rcx),%edx
mov    %edx,(%rsp,%rax,4)
test   %ecx,%ecx
jg     13de <sudokuValide+0x2be>
mov    -0x8(%rbp),%eax
test   %eax,%eax
jle    122e <sudokuValide+0x10e>
add    $0xffffffff,%eax
mov    (%rsp,%rax,4),%ecx
lea    0x1(%rcx),%edx
mov    %edx,(%rsp,%rax,4)
test   %ecx,%ecx
jg     13e5 <sudokuValide+0x2c5>
mov    -0x4(%rbp),%eax
test   %eax,%eax
jle    1249 <sudokuValide+0x129>
add    $0xffffffff,%eax
mov    (%rsp,%rax,4),%ecx
lea    0x1(%rcx),%edx
mov    %edx,(%rsp,%rax,4)
test   %ecx,%ecx
jg     13ec <sudokuValide+0x2cc>
mov    0x0(%rbp),%eax
test   %eax,%eax
jle    1150 <sudokuValide+0x30>
add    $0xffffffff,%eax
mov    (%rsp,%rax,4),%ecx
lea    0x1(%rcx),%edx
mov    %edx,(%rsp,%rax,4)
test   %ecx,%ecx
jle    1150 <sudokuValide+0x30>
mov    $0x8,%edx
jmp    13f1 <sudokuValide+0x2d1>
xor    %ebx,%ebx
mov    %rsp,%r14
jmp    129d <sudokuValide+0x17d>
nopl   0x0(%rax)
mov    %r14,%rdi
mov    $0x9,%esi
xor    %edx,%edx
call   1040 <initArray@plt>
add    $0x1,%rbx
cmp    $0x9,%rbx
je     1410 <sudokuValide+0x2f0>
mov    (%r15,%rbx,4),%eax
test   %eax,%eax
jle    12b9 <sudokuValide+0x199>
add    $0xffffffff,%eax
mov    (%rsp,%rax,4),%ecx
lea    0x1(%rcx),%edx
mov    %edx,(%rsp,%rax,4)
test   %ecx,%ecx
jg     1583 <sudokuValide+0x463>
mov    0x24(%r15,%rbx,4),%eax
test   %eax,%eax
jle    12d6 <sudokuValide+0x1b6>
add    $0xffffffff,%eax
mov    (%rsp,%rax,4),%ecx
lea    0x1(%rcx),%edx
mov    %edx,(%rsp,%rax,4)
test   %ecx,%ecx
jg     1587 <sudokuValide+0x467>
mov    0x48(%r15,%rbx,4),%eax
test   %eax,%eax
jle    12f3 <sudokuValide+0x1d3>
add    $0xffffffff,%eax
mov    (%rsp,%rax,4),%ecx
lea    0x1(%rcx),%edx
mov    %edx,(%rsp,%rax,4)
test   %ecx,%ecx
jg     158e <sudokuValide+0x46e>
mov    0x6c(%r15,%rbx,4),%eax
test   %eax,%eax
jle    1310 <sudokuValide+0x1f0>
add    $0xffffffff,%eax
mov    (%rsp,%rax,4),%ecx
lea    0x1(%rcx),%edx
mov    %edx,(%rsp,%rax,4)
test   %ecx,%ecx
jg     1595 <sudokuValide+0x475>
mov    0x90(%r15,%rbx,4),%eax
test   %eax,%eax
jle    1330 <sudokuValide+0x210>
add    $0xffffffff,%eax
mov    (%rsp,%rax,4),%ecx
lea    0x1(%rcx),%edx
mov    %edx,(%rsp,%rax,4)
test   %ecx,%ecx
jg     159c <sudokuValide+0x47c>
mov    0xb4(%r15,%rbx,4),%eax
test   %eax,%eax
jle    1350 <sudokuValide+0x230>
add    $0xffffffff,%eax
mov    (%rsp,%rax,4),%ecx
lea    0x1(%rcx),%edx
mov    %edx,(%rsp,%rax,4)
test   %ecx,%ecx
jg     15a3 <sudokuValide+0x483>
mov    0xd8(%r15,%rbx,4),%eax
test   %eax,%eax
jle    1370 <sudokuValide+0x250>
add    $0xffffffff,%eax
mov    (%rsp,%rax,4),%ecx
lea    0x1(%rcx),%edx
mov    %edx,(%rsp,%rax,4)
test   %ecx,%ecx
jg     15aa <sudokuValide+0x48a>
mov    0xfc(%r15,%rbx,4),%eax
test   %eax,%eax
jle    1390 <sudokuValide+0x270>
add    $0xffffffff,%eax
mov    (%rsp,%rax,4),%ecx
lea    0x1(%rcx),%edx
mov    %edx,(%rsp,%rax,4)
test   %ecx,%ecx
jg     15b1 <sudokuValide+0x491>
mov    0x120(%r15,%rbx,4),%eax
test   %eax,%eax
jle    1280 <sudokuValide+0x160>
add    $0xffffffff,%eax
mov    (%rsp,%rax,4),%ecx
lea    0x1(%rcx),%edx
mov    %edx,(%rsp,%rax,4)
test   %ecx,%ecx
jle    1280 <sudokuValide+0x160>
mov    $0x8,%esi
jmp    15b6 <sudokuValide+0x496>
xor    %edx,%edx
jmp    13f1 <sudokuValide+0x2d1>
mov    $0x1,%edx
jmp    13f1 <sudokuValide+0x2d1>
mov    $0x2,%edx
jmp    13f1 <sudokuValide+0x2d1>
mov    $0x3,%edx
jmp    13f1 <sudokuValide+0x2d1>
mov    $0x4,%edx
jmp    13f1 <sudokuValide+0x2d1>
mov    $0x5,%edx
jmp    13f1 <sudokuValide+0x2d1>
mov    $0x6,%edx
jmp    13f1 <sudokuValide+0x2d1>
mov    $0x7,%edx
lea    0xc08(%rip),%rdi
mov    %ebx,%esi
call   1030 <printf@plt>
xor    %eax,%eax
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
add    $0x50,%r15
xor    %r14d,%r14d
mov    %rsp,%rbx
lea    0x1(%r14),%rax
mov    %rax,0x30(%rsp)
lea    0x2(%r14),%r13
mov    %r15,%r12
xor    %ebp,%ebp
jmp    1452 <sudokuValide+0x332>
mov    %rbx,%rdi
mov    $0x9,%esi
xor    %edx,%edx
call   1040 <initArray@plt>
lea    0x3(%rbp),%rax
add    $0x6c,%r12
cmp    $0x6,%rbp
mov    %rax,%rbp
jae    1564 <sudokuValide+0x444>
mov    -0x50(%r12),%eax
test   %eax,%eax
jle    146f <sudokuValide+0x34f>
add    $0xffffffff,%eax
mov    (%rsp,%rax,4),%ecx
lea    0x1(%rcx),%edx
mov    %edx,(%rsp,%rax,4)
test   %ecx,%ecx
jg     15c4 <sudokuValide+0x4a4>
mov    -0x4c(%r12),%eax
test   %eax,%eax
jle    148c <sudokuValide+0x36c>
add    $0xffffffff,%eax
mov    (%rsp,%rax,4),%ecx
lea    0x1(%rcx),%edx
mov    %edx,(%rsp,%rax,4)
test   %ecx,%ecx
jg     15c9 <sudokuValide+0x4a9>
mov    -0x48(%r12),%eax
test   %eax,%eax
jle    14a9 <sudokuValide+0x389>
add    $0xffffffff,%eax
mov    (%rsp,%rax,4),%ecx
lea    0x1(%rcx),%edx
mov    %edx,(%rsp,%rax,4)
test   %ecx,%ecx
jg     15d3 <sudokuValide+0x4b3>
lea    0x1(%rbp),%rsi
mov    -0x2c(%r12),%eax
test   %eax,%eax
jle    14ca <sudokuValide+0x3aa>
add    $0xffffffff,%eax
mov    (%rsp,%rax,4),%ecx
lea    0x1(%rcx),%edx
mov    %edx,(%rsp,%rax,4)
test   %ecx,%ecx
jg     15d9 <sudokuValide+0x4b9>
mov    -0x28(%r12),%eax
test   %eax,%eax
jle    14e7 <sudokuValide+0x3c7>
add    $0xffffffff,%eax
mov    (%rsp,%rax,4),%ecx
lea    0x1(%rcx),%edx
mov    %edx,(%rsp,%rax,4)
test   %ecx,%ecx
jg     15cc <sudokuValide+0x4ac>
mov    -0x24(%r12),%eax
test   %eax,%eax
jle    1504 <sudokuValide+0x3e4>
add    $0xffffffff,%eax
mov    (%rsp,%rax,4),%ecx
lea    0x1(%rcx),%edx
mov    %edx,(%rsp,%rax,4)
test   %ecx,%ecx
jg     15d6 <sudokuValide+0x4b6>
lea    0x2(%rbp),%rsi
mov    -0x8(%r12),%eax
test   %eax,%eax
jle    1525 <sudokuValide+0x405>
add    $0xffffffff,%eax
mov    (%rsp,%rax,4),%ecx
lea    0x1(%rcx),%edx
mov    %edx,(%rsp,%rax,4)
test   %ecx,%ecx
jg     15d9 <sudokuValide+0x4b9>
mov    -0x4(%r12),%eax
test   %eax,%eax
jle    1542 <sudokuValide+0x422>
add    $0xffffffff,%eax
mov    (%rsp,%rax,4),%ecx
lea    0x1(%rcx),%edx
mov    %edx,(%rsp,%rax,4)
test   %ecx,%ecx
jg     15cc <sudokuValide+0x4ac>
mov    (%r12),%eax
test   %eax,%eax
jle    142e <sudokuValide+0x30e>
add    $0xffffffff,%eax
mov    (%rsp,%rax,4),%ecx
lea    0x1(%rcx),%edx
mov    %edx,(%rsp,%rax,4)
test   %ecx,%ecx
jle    142e <sudokuValide+0x30e>
jmp    15d6 <sudokuValide+0x4b6>
lea    0x3(%r14),%rcx
add    $0xc,%r15
mov    $0x1,%eax
cmp    $0x6,%r14
mov    %rcx,%r14
jb     141a <sudokuValide+0x2fa>
jmp    1401 <sudokuValide+0x2e1>
xor    %esi,%esi
jmp    15b6 <sudokuValide+0x496>
mov    $0x1,%esi
jmp    15b6 <sudokuValide+0x496>
mov    $0x2,%esi
jmp    15b6 <sudokuValide+0x496>
mov    $0x3,%esi
jmp    15b6 <sudokuValide+0x496>
mov    $0x4,%esi
jmp    15b6 <sudokuValide+0x496>
mov    $0x5,%esi
jmp    15b6 <sudokuValide+0x496>
mov    $0x6,%esi
jmp    15b6 <sudokuValide+0x496>
mov    $0x7,%esi
lea    0xa5f(%rip),%rdi
mov    %ebx,%edx
jmp    13fa <sudokuValide+0x2da>
mov    %rbp,%rsi
jmp    15d9 <sudokuValide+0x4b9>
mov    %rbp,%rsi
mov    0x30(%rsp),%r14
jmp    15d9 <sudokuValide+0x4b9>
mov    %rbp,%rsi
mov    %r13,%r14
lea    0xa5a(%rip),%rdi
mov    %r14d,%edx
jmp    13fa <sudokuValide+0x2da>

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

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