#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*/ initarr(int *);
int isValidSudoku(char **board, int boardRowSize, int boardColSize) {
  static int arr[9];
  int i, j, k, l;
  for (i = 0; i < 9; i++) {
    initarr(arr);
    for (j = 0; j < 9; j++)
      if (board[i][j] == '.')
        continue;
      else if (--arr[board[i][j] - '0'] < 0)
        return (0);
  }
  for (i = 0; i < 9; i++) {
    initarr(arr);
    for (j = 0; j < 9; j++)
      if (board[j][i] == '.')
        continue;
      else if (--arr[board[j][i] - '0'] < 0)
        return (0);
  }
  for (i = 0; i < 3; i++) {
    for (j = 0; j < 3; j++) {
      initarr(arr);
      for (k = 3 * i; k < 3 * i + 3; k++) {
        for (l = 3 * j; l < 3 * j + 3; l++)
          if (board[k][l] == '.')
            continue;
          else if (--arr[board[k][l] - '0'] < 0)
            return (0);
      }
    }
  }
  return (1);
}


x86 assembly (clang, -O0):
<isValidSudoku>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %edx,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
cmpl   $0x9,-0x1c(%rbp)
jge    11e3 <isValidSudoku+0xd3>
lea    0x2f06(%rip),%rdi
call   1030 <initarr@plt>
movl   $0x0,-0x20(%rbp)
cmpl   $0x9,-0x20(%rbp)
jge    11d0 <isValidSudoku+0xc0>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2e,%eax
jne    1172 <isValidSudoku+0x62>
jmp    11c2 <isValidSudoku+0xb2>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
sub    $0x30,%eax
movslq %eax,%rdx
lea    0x2ead(%rip),%rax
mov    (%rax,%rdx,4),%eax
add    $0xffffffff,%eax
lea    0x2ea0(%rip),%rcx
mov    %eax,(%rcx,%rdx,4)
cmp    $0x0,%eax
jge    11b8 <isValidSudoku+0xa8>
movl   $0x0,-0x4(%rbp)
jmp    13c4 <isValidSudoku+0x2b4>
jmp    11bd <isValidSudoku+0xad>
jmp    11c2 <isValidSudoku+0xb2>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1146 <isValidSudoku+0x36>
jmp    11d5 <isValidSudoku+0xc5>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1129 <isValidSudoku+0x19>
movl   $0x0,-0x1c(%rbp)
cmpl   $0x9,-0x1c(%rbp)
jge    12a4 <isValidSudoku+0x194>
lea    0x2e45(%rip),%rdi
call   1030 <initarr@plt>
movl   $0x0,-0x20(%rbp)
cmpl   $0x9,-0x20(%rbp)
jge    1291 <isValidSudoku+0x181>
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2e,%eax
jne    1233 <isValidSudoku+0x123>
jmp    1283 <isValidSudoku+0x173>
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
sub    $0x30,%eax
movslq %eax,%rdx
lea    0x2dec(%rip),%rax
mov    (%rax,%rdx,4),%eax
add    $0xffffffff,%eax
lea    0x2ddf(%rip),%rcx
mov    %eax,(%rcx,%rdx,4)
cmp    $0x0,%eax
jge    1279 <isValidSudoku+0x169>
movl   $0x0,-0x4(%rbp)
jmp    13c4 <isValidSudoku+0x2b4>
jmp    127e <isValidSudoku+0x16e>
jmp    1283 <isValidSudoku+0x173>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1207 <isValidSudoku+0xf7>
jmp    1296 <isValidSudoku+0x186>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    11ea <isValidSudoku+0xda>
movl   $0x0,-0x1c(%rbp)
cmpl   $0x3,-0x1c(%rbp)
jge    13bd <isValidSudoku+0x2ad>
movl   $0x0,-0x20(%rbp)
cmpl   $0x3,-0x20(%rbp)
jge    13aa <isValidSudoku+0x29a>
lea    0x2d73(%rip),%rdi
call   1030 <initarr@plt>
imul   $0x3,-0x1c(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
imul   $0x3,-0x1c(%rbp),%ecx
add    $0x3,%ecx
cmp    %ecx,%eax
jge    1397 <isValidSudoku+0x287>
imul   $0x3,-0x20(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
imul   $0x3,-0x20(%rbp),%ecx
add    $0x3,%ecx
cmp    %ecx,%eax
jge    1384 <isValidSudoku+0x274>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2e,%eax
jne    1326 <isValidSudoku+0x216>
jmp    1376 <isValidSudoku+0x266>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x28(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
sub    $0x30,%eax
movslq %eax,%rdx
lea    0x2cf9(%rip),%rax
mov    (%rax,%rdx,4),%eax
add    $0xffffffff,%eax
lea    0x2cec(%rip),%rcx
mov    %eax,(%rcx,%rdx,4)
cmp    $0x0,%eax
jge    136c <isValidSudoku+0x25c>
movl   $0x0,-0x4(%rbp)
jmp    13c4 <isValidSudoku+0x2b4>
jmp    1371 <isValidSudoku+0x261>
jmp    1376 <isValidSudoku+0x266>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    12f2 <isValidSudoku+0x1e2>
jmp    1389 <isValidSudoku+0x279>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    12d9 <isValidSudoku+0x1c9>
jmp    139c <isValidSudoku+0x28c>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    12bc <isValidSudoku+0x1ac>
jmp    13af <isValidSudoku+0x29f>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    12ab <isValidSudoku+0x19b>
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<isValidSudoku>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
mov    %rdi,%r14
xor    %ebp,%ebp
lea    0x2f1c(%rip),%rbx
jmp    113e <isValidSudoku+0x2e>
cs nopw 0x0(%rax,%rax,1)
add    $0x1,%rbp
cmp    $0x9,%rbp
je     1290 <isValidSudoku+0x180>
mov    %rbx,%rdi
call   1030 <initarr@plt>
mov    (%r14,%rbp,8),%rax
movsbq (%rax),%rcx
cmp    $0x2e,%rcx
je     116d <isValidSudoku+0x5d>
mov    -0xc0(%rbx,%rcx,4),%edx
lea    -0x1(%rdx),%esi
mov    %esi,-0xc0(%rbx,%rcx,4)
test   %edx,%edx
jle    1285 <isValidSudoku+0x175>
movsbq 0x1(%rax),%rcx
cmp    $0x2e,%rcx
je     1191 <isValidSudoku+0x81>
mov    -0xc0(%rbx,%rcx,4),%edx
lea    -0x1(%rdx),%esi
mov    %esi,-0xc0(%rbx,%rcx,4)
test   %edx,%edx
jle    1285 <isValidSudoku+0x175>
movsbq 0x2(%rax),%rcx
cmp    $0x2e,%rcx
je     11b5 <isValidSudoku+0xa5>
mov    -0xc0(%rbx,%rcx,4),%edx
lea    -0x1(%rdx),%esi
mov    %esi,-0xc0(%rbx,%rcx,4)
test   %edx,%edx
jle    1285 <isValidSudoku+0x175>
movsbq 0x3(%rax),%rcx
cmp    $0x2e,%rcx
je     11d9 <isValidSudoku+0xc9>
mov    -0xc0(%rbx,%rcx,4),%edx
lea    -0x1(%rdx),%esi
mov    %esi,-0xc0(%rbx,%rcx,4)
test   %edx,%edx
jle    1285 <isValidSudoku+0x175>
movsbq 0x4(%rax),%rcx
cmp    $0x2e,%rcx
je     11fd <isValidSudoku+0xed>
mov    -0xc0(%rbx,%rcx,4),%edx
lea    -0x1(%rdx),%esi
mov    %esi,-0xc0(%rbx,%rcx,4)
test   %edx,%edx
jle    1285 <isValidSudoku+0x175>
movsbq 0x5(%rax),%rcx
cmp    $0x2e,%rcx
je     121d <isValidSudoku+0x10d>
mov    -0xc0(%rbx,%rcx,4),%edx
lea    -0x1(%rdx),%esi
mov    %esi,-0xc0(%rbx,%rcx,4)
test   %edx,%edx
jle    1285 <isValidSudoku+0x175>
movsbq 0x6(%rax),%rcx
cmp    $0x2e,%rcx
je     123d <isValidSudoku+0x12d>
mov    -0xc0(%rbx,%rcx,4),%edx
lea    -0x1(%rdx),%esi
mov    %esi,-0xc0(%rbx,%rcx,4)
test   %edx,%edx
jle    1285 <isValidSudoku+0x175>
movsbq 0x7(%rax),%rcx
cmp    $0x2e,%rcx
je     125d <isValidSudoku+0x14d>
mov    -0xc0(%rbx,%rcx,4),%edx
lea    -0x1(%rdx),%esi
mov    %esi,-0xc0(%rbx,%rcx,4)
test   %edx,%edx
jle    1285 <isValidSudoku+0x175>
movsbq 0x8(%rax),%rax
cmp    $0x2e,%rax
je     1130 <isValidSudoku+0x20>
mov    -0xc0(%rbx,%rax,4),%ecx
lea    -0x1(%rcx),%edx
mov    %edx,-0xc0(%rbx,%rax,4)
test   %ecx,%ecx
jg     1130 <isValidSudoku+0x20>
xor    %eax,%eax
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %ebp,%ebp
jmp    12ae <isValidSudoku+0x19e>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rbp
cmp    $0x9,%rbp
je     141e <isValidSudoku+0x30e>
mov    %rbx,%rdi
call   1030 <initarr@plt>
mov    (%r14),%rax
movsbq (%rax,%rbp,1),%rax
cmp    $0x2e,%rax
je     12d9 <isValidSudoku+0x1c9>
mov    -0xc0(%rbx,%rax,4),%ecx
lea    -0x1(%rcx),%edx
mov    %edx,-0xc0(%rbx,%rax,4)
test   %ecx,%ecx
jle    1285 <isValidSudoku+0x175>
mov    0x8(%r14),%rax
movsbq (%rax,%rbp,1),%rax
cmp    $0x2e,%rax
je     12fd <isValidSudoku+0x1ed>
mov    -0xc0(%rbx,%rax,4),%ecx
lea    -0x1(%rcx),%edx
mov    %edx,-0xc0(%rbx,%rax,4)
test   %ecx,%ecx
jle    1285 <isValidSudoku+0x175>
mov    0x10(%r14),%rax
movsbq (%rax,%rbp,1),%rax
cmp    $0x2e,%rax
je     1325 <isValidSudoku+0x215>
mov    -0xc0(%rbx,%rax,4),%ecx
lea    -0x1(%rcx),%edx
mov    %edx,-0xc0(%rbx,%rax,4)
test   %ecx,%ecx
jle    1285 <isValidSudoku+0x175>
mov    0x18(%r14),%rax
movsbq (%rax,%rbp,1),%rax
cmp    $0x2e,%rax
je     134d <isValidSudoku+0x23d>
mov    -0xc0(%rbx,%rax,4),%ecx
lea    -0x1(%rcx),%edx
mov    %edx,-0xc0(%rbx,%rax,4)
test   %ecx,%ecx
jle    1285 <isValidSudoku+0x175>
mov    0x20(%r14),%rax
movsbq (%rax,%rbp,1),%rax
cmp    $0x2e,%rax
je     1375 <isValidSudoku+0x265>
mov    -0xc0(%rbx,%rax,4),%ecx
lea    -0x1(%rcx),%edx
mov    %edx,-0xc0(%rbx,%rax,4)
test   %ecx,%ecx
jle    1285 <isValidSudoku+0x175>
mov    0x28(%r14),%rax
movsbq (%rax,%rbp,1),%rax
cmp    $0x2e,%rax
je     139d <isValidSudoku+0x28d>
mov    -0xc0(%rbx,%rax,4),%ecx
lea    -0x1(%rcx),%edx
mov    %edx,-0xc0(%rbx,%rax,4)
test   %ecx,%ecx
jle    1285 <isValidSudoku+0x175>
mov    0x30(%r14),%rax
movsbq (%rax,%rbp,1),%rax
cmp    $0x2e,%rax
je     13c5 <isValidSudoku+0x2b5>
mov    -0xc0(%rbx,%rax,4),%ecx
lea    -0x1(%rcx),%edx
mov    %edx,-0xc0(%rbx,%rax,4)
test   %ecx,%ecx
jle    1285 <isValidSudoku+0x175>
mov    0x38(%r14),%rax
movsbq (%rax,%rbp,1),%rax
cmp    $0x2e,%rax
je     13ed <isValidSudoku+0x2dd>
mov    -0xc0(%rbx,%rax,4),%ecx
lea    -0x1(%rcx),%edx
mov    %edx,-0xc0(%rbx,%rax,4)
test   %ecx,%ecx
jle    1285 <isValidSudoku+0x175>
mov    0x40(%r14),%rax
movsbq (%rax,%rbp,1),%rax
cmp    $0x2e,%rax
je     12a0 <isValidSudoku+0x190>
mov    -0xc0(%rbx,%rax,4),%ecx
lea    -0x1(%rcx),%edx
mov    %edx,-0xc0(%rbx,%rax,4)
test   %ecx,%ecx
jg     12a0 <isValidSudoku+0x190>
jmp    1285 <isValidSudoku+0x175>
xor    %r15d,%r15d
xor    %r12d,%r12d
mov    $0x2,%ebp
jmp    1438 <isValidSudoku+0x328>
add    $0x3,%rbp
cmp    $0xb,%ebp
je     15a1 <isValidSudoku+0x491>
mov    %rbx,%rdi
call   1030 <initarr@plt>
mov    (%r14,%r15,8),%rax
movsbq -0x2(%rax,%rbp,1),%rcx
cmp    $0x2e,%rcx
je     1469 <isValidSudoku+0x359>
mov    -0xc0(%rbx,%rcx,4),%edx
lea    -0x1(%rdx),%esi
mov    %esi,-0xc0(%rbx,%rcx,4)
test   %edx,%edx
jle    1285 <isValidSudoku+0x175>
movsbq -0x1(%rax,%rbp,1),%rcx
cmp    $0x2e,%rcx
je     148e <isValidSudoku+0x37e>
mov    -0xc0(%rbx,%rcx,4),%edx
lea    -0x1(%rdx),%esi
mov    %esi,-0xc0(%rbx,%rcx,4)
test   %edx,%edx
jle    1285 <isValidSudoku+0x175>
movsbq (%rax,%rbp,1),%rax
cmp    $0x2e,%rax
je     14b2 <isValidSudoku+0x3a2>
mov    -0xc0(%rbx,%rax,4),%ecx
lea    -0x1(%rcx),%edx
mov    %edx,-0xc0(%rbx,%rax,4)
test   %ecx,%ecx
jle    1285 <isValidSudoku+0x175>
mov    0x8(%r14,%r15,8),%rax
movsbq -0x2(%rax,%rbp,1),%rcx
cmp    $0x2e,%rcx
je     14dc <isValidSudoku+0x3cc>
mov    -0xc0(%rbx,%rcx,4),%edx
lea    -0x1(%rdx),%esi
mov    %esi,-0xc0(%rbx,%rcx,4)
test   %edx,%edx
jle    1285 <isValidSudoku+0x175>
movsbq -0x1(%rax,%rbp,1),%rcx
cmp    $0x2e,%rcx
je     1501 <isValidSudoku+0x3f1>
mov    -0xc0(%rbx,%rcx,4),%edx
lea    -0x1(%rdx),%esi
mov    %esi,-0xc0(%rbx,%rcx,4)
test   %edx,%edx
jle    1285 <isValidSudoku+0x175>
movsbq (%rax,%rbp,1),%rax
cmp    $0x2e,%rax
je     1525 <isValidSudoku+0x415>
mov    -0xc0(%rbx,%rax,4),%ecx
lea    -0x1(%rcx),%edx
mov    %edx,-0xc0(%rbx,%rax,4)
test   %ecx,%ecx
jle    1285 <isValidSudoku+0x175>
mov    0x10(%r14,%r15,8),%rax
movsbq -0x2(%rax,%rbp,1),%rcx
cmp    $0x2e,%rcx
je     154f <isValidSudoku+0x43f>
mov    -0xc0(%rbx,%rcx,4),%edx
lea    -0x1(%rdx),%esi
mov    %esi,-0xc0(%rbx,%rcx,4)
test   %edx,%edx
jle    1285 <isValidSudoku+0x175>
movsbq -0x1(%rax,%rbp,1),%rcx
cmp    $0x2e,%rcx
je     1574 <isValidSudoku+0x464>
mov    -0xc0(%rbx,%rcx,4),%edx
lea    -0x1(%rdx),%esi
mov    %esi,-0xc0(%rbx,%rcx,4)
test   %edx,%edx
jle    1285 <isValidSudoku+0x175>
movsbq (%rax,%rbp,1),%rax
cmp    $0x2e,%rax
je     142b <isValidSudoku+0x31b>
mov    -0xc0(%rbx,%rax,4),%ecx
lea    -0x1(%rcx),%edx
mov    %edx,-0xc0(%rbx,%rax,4)
test   %ecx,%ecx
jg     142b <isValidSudoku+0x31b>
jmp    1285 <isValidSudoku+0x175>
add    $0x1,%r12d
add    $0x3,%r15
mov    $0x1,%eax
cmp    $0x3,%r12d
jne    1424 <isValidSudoku+0x314>
jmp    1287 <isValidSudoku+0x177>

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

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