#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 */
typedef int /*<<< orphan*/ nums;

/* Variables and functions */
int /*<<< orphan*/ bzero(char *, int);
int avail(char **board, int row, int col) {
  static char nums[10];
  int i, j;
  bzero(nums, sizeof(nums));
  for (i = 0; i < 9; i++) {
    if (board[row][i] == '.')
      continue;
    if (nums[board[row][i] - '1'])
      return (0);
    nums[board[row][i] - '1'] = board[row][i];
  }
  bzero(nums, sizeof(nums));
  for (i = 0; i < 9; i++) {
    if (board[i][col] == '.')
      continue;
    if (nums[board[i][col] - '1'])
      return (0);
    nums[board[i][col] - '1'] = board[i][col];
  }
  bzero(nums, sizeof(nums));
  row /= 3;
  col /= 3;
  for (i = row * 3; i < row * 3 + 3; i++) {
    for (j = col * 3; j < col * 3 + 3; j++) {
      if (board[i][j] == '.')
        continue;
      if (nums[board[i][j] - '1'])
        return (0);
      nums[board[i][j] - '1'] = board[i][j];
    }
  }
  return (1);
}


x86 assembly (clang, -O0):
<avail>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %edx,-0x18(%rbp)
lea    0x2f00(%rip),%rdi
mov    $0xa,%esi
call   1030 <bzero@plt>
movl   $0x0,-0x1c(%rbp)
cmpl   $0x9,-0x1c(%rbp)
jge    11e2 <avail+0xd2>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2e,%eax
jne    1166 <avail+0x56>
jmp    11d4 <avail+0xc4>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
sub    $0x31,%eax
movslq %eax,%rcx
lea    0x2ea2(%rip),%rax
cmpb   $0x0,(%rax,%rcx,1)
je     119d <avail+0x8d>
movl   $0x0,-0x4(%rbp)
jmp    13b9 <avail+0x2a9>
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
sub    $0x31,%eax
movslq %eax,%rcx
lea    0x2e58(%rip),%rax
mov    %dl,(%rax,%rcx,1)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    113a <avail+0x2a>
lea    0x2e40(%rip),%rdi
mov    $0xa,%esi
call   1030 <bzero@plt>
movl   $0x0,-0x1c(%rbp)
cmpl   $0x9,-0x1c(%rbp)
jge    12a2 <avail+0x192>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x18(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2e,%eax
jne    1226 <avail+0x116>
jmp    1294 <avail+0x184>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x18(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
sub    $0x31,%eax
movslq %eax,%rcx
lea    0x2de2(%rip),%rax
cmpb   $0x0,(%rax,%rcx,1)
je     125d <avail+0x14d>
movl   $0x0,-0x4(%rbp)
jmp    13b9 <avail+0x2a9>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x18(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
sub    $0x31,%eax
movslq %eax,%rcx
lea    0x2d98(%rip),%rax
mov    %dl,(%rax,%rcx,1)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    11fa <avail+0xea>
lea    0x2d80(%rip),%rdi
mov    $0xa,%esi
call   1030 <bzero@plt>
mov    -0x14(%rbp),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,-0x14(%rbp)
mov    -0x18(%rbp),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,-0x18(%rbp)
imul   $0x3,-0x14(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
imul   $0x3,-0x14(%rbp),%ecx
add    $0x3,%ecx
cmp    %ecx,%eax
jge    13b2 <avail+0x2a2>
imul   $0x3,-0x18(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
imul   $0x3,-0x18(%rbp),%ecx
add    $0x3,%ecx
cmp    %ecx,%eax
jge    139f <avail+0x28f>
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    1323 <avail+0x213>
jmp    1391 <avail+0x281>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
sub    $0x31,%eax
movslq %eax,%rcx
lea    0x2ce5(%rip),%rax
cmpb   $0x0,(%rax,%rcx,1)
je     135a <avail+0x24a>
movl   $0x0,-0x4(%rbp)
jmp    13b9 <avail+0x2a9>
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x20(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
sub    $0x31,%eax
movslq %eax,%rcx
lea    0x2c9b(%rip),%rax
mov    %dl,(%rax,%rcx,1)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    12ef <avail+0x1df>
jmp    13a4 <avail+0x294>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    12d6 <avail+0x1c6>
movl   $0x1,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<avail>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
mov    %edx,%r15d
mov    %esi,%ebx
mov    %rdi,%r12
lea    0x2f02(%rip),%rbp
mov    %rbp,%rdi
mov    $0xa,%esi
call   1030 <bzero@plt>
movslq %ebx,%rbx
mov    (%r12,%rbx,8),%rax
movsbq (%rax),%rcx
cmp    $0x2e,%rcx
je     115a <avail+0x4a>
xor    %eax,%eax
cmpb   $0x0,-0x31(%rcx,%rbp,1)
jne    1440 <avail+0x330>
mov    %cl,-0x31(%rcx,%rbp,1)
mov    (%r12,%rbx,8),%rax
movsbq 0x1(%rax),%rcx
cmp    $0x2e,%rcx
je     117a <avail+0x6a>
xor    %eax,%eax
cmpb   $0x0,-0x31(%rcx,%rbp,1)
jne    1440 <avail+0x330>
mov    %cl,-0x31(%rcx,%rbp,1)
mov    (%r12,%rbx,8),%rax
movsbq 0x2(%rax),%rcx
cmp    $0x2e,%rcx
je     119a <avail+0x8a>
xor    %eax,%eax
cmpb   $0x0,-0x31(%rcx,%rbp,1)
jne    1440 <avail+0x330>
mov    %cl,-0x31(%rcx,%rbp,1)
mov    (%r12,%rbx,8),%rax
movsbq 0x3(%rax),%rcx
cmp    $0x2e,%rcx
je     11ba <avail+0xaa>
xor    %eax,%eax
cmpb   $0x0,-0x31(%rcx,%rbp,1)
jne    1440 <avail+0x330>
mov    %cl,-0x31(%rcx,%rbp,1)
mov    (%r12,%rbx,8),%rax
movsbq 0x4(%rax),%rcx
cmp    $0x2e,%rcx
je     11da <avail+0xca>
xor    %eax,%eax
cmpb   $0x0,-0x31(%rcx,%rbp,1)
jne    1440 <avail+0x330>
mov    %cl,-0x31(%rcx,%rbp,1)
mov    (%r12,%rbx,8),%rax
movsbq 0x5(%rax),%rcx
cmp    $0x2e,%rcx
je     11fa <avail+0xea>
xor    %eax,%eax
cmpb   $0x0,-0x31(%rcx,%rbp,1)
jne    1440 <avail+0x330>
mov    %cl,-0x31(%rcx,%rbp,1)
mov    (%r12,%rbx,8),%rax
movsbq 0x6(%rax),%rcx
cmp    $0x2e,%rcx
je     121a <avail+0x10a>
xor    %eax,%eax
cmpb   $0x0,-0x31(%rcx,%rbp,1)
jne    1440 <avail+0x330>
mov    %cl,-0x31(%rcx,%rbp,1)
mov    (%r12,%rbx,8),%rax
movsbq 0x7(%rax),%rcx
cmp    $0x2e,%rcx
je     123a <avail+0x12a>
xor    %eax,%eax
cmpb   $0x0,-0x31(%rcx,%rbp,1)
jne    1440 <avail+0x330>
mov    %cl,-0x31(%rcx,%rbp,1)
mov    (%r12,%rbx,8),%rax
movsbq 0x8(%rax),%rcx
cmp    $0x2e,%rcx
je     1256 <avail+0x146>
xor    %eax,%eax
cmpb   $0x0,-0x31(%rcx,%rbp,1)
jne    1440 <avail+0x330>
mov    %cl,-0x31(%rcx,%rbp,1)
lea    0x2dcc(%rip),%r14
mov    %r14,%rdi
mov    $0xa,%esi
call   1030 <bzero@plt>
movslq %r15d,%rbp
mov    (%r12),%rax
movsbq (%rax,%rbp,1),%rcx
cmp    $0x2e,%rcx
je     128f <avail+0x17f>
xor    %eax,%eax
cmpb   $0x0,-0x31(%rcx,%r14,1)
jne    1440 <avail+0x330>
mov    %cl,-0x31(%rcx,%r14,1)
mov    0x8(%r12),%rax
movsbq (%rax,%rbp,1),%rcx
cmp    $0x2e,%rcx
je     12b2 <avail+0x1a2>
xor    %eax,%eax
cmpb   $0x0,-0x31(%rcx,%r14,1)
jne    1440 <avail+0x330>
mov    %cl,-0x31(%rcx,%r14,1)
mov    0x10(%r12),%rax
movsbq (%rax,%rbp,1),%rcx
cmp    $0x2e,%rcx
je     12d5 <avail+0x1c5>
xor    %eax,%eax
cmpb   $0x0,-0x31(%rcx,%r14,1)
jne    1440 <avail+0x330>
mov    %cl,-0x31(%rcx,%r14,1)
mov    0x18(%r12),%rax
movsbq (%rax,%rbp,1),%rcx
cmp    $0x2e,%rcx
je     12f8 <avail+0x1e8>
xor    %eax,%eax
cmpb   $0x0,-0x31(%rcx,%r14,1)
jne    1440 <avail+0x330>
mov    %cl,-0x31(%rcx,%r14,1)
mov    0x20(%r12),%rax
movsbq (%rax,%rbp,1),%rcx
cmp    $0x2e,%rcx
je     131b <avail+0x20b>
xor    %eax,%eax
cmpb   $0x0,-0x31(%rcx,%r14,1)
jne    1440 <avail+0x330>
mov    %cl,-0x31(%rcx,%r14,1)
mov    0x28(%r12),%rax
movsbq (%rax,%rbp,1),%rcx
cmp    $0x2e,%rcx
je     133e <avail+0x22e>
xor    %eax,%eax
cmpb   $0x0,-0x31(%rcx,%r14,1)
jne    1440 <avail+0x330>
mov    %cl,-0x31(%rcx,%r14,1)
mov    0x30(%r12),%rax
movsbq (%rax,%rbp,1),%rcx
cmp    $0x2e,%rcx
je     1361 <avail+0x251>
xor    %eax,%eax
cmpb   $0x0,-0x31(%rcx,%r14,1)
jne    1440 <avail+0x330>
mov    %cl,-0x31(%rcx,%r14,1)
mov    0x38(%r12),%rax
movsbq (%rax,%rbp,1),%rcx
cmp    $0x2e,%rcx
je     1384 <avail+0x274>
xor    %eax,%eax
cmpb   $0x0,-0x31(%rcx,%r14,1)
jne    1440 <avail+0x330>
mov    %cl,-0x31(%rcx,%r14,1)
mov    0x40(%r12),%rax
movsbq (%rax,%rbp,1),%rcx
cmp    $0x2e,%rcx
je     13a7 <avail+0x297>
xor    %eax,%eax
cmpb   $0x0,-0x31(%rcx,%r14,1)
jne    1440 <avail+0x330>
mov    %cl,-0x31(%rcx,%r14,1)
mov    %r14,%rdi
mov    $0xa,%esi
call   1030 <bzero@plt>
imul   $0x55555556,%rbx,%rax
mov    %rax,%rcx
shr    $0x3f,%rcx
shr    $0x20,%rax
add    %ecx,%eax
lea    (%rax,%rax,2),%edx
imul   $0x55555556,%rbp,%rsi
mov    %rsi,%rcx
shr    $0x3f,%rcx
shr    $0x20,%rsi
add    %ecx,%esi
lea    (%rsi,%rsi,2),%ecx
movslq %ecx,%rcx
movslq %edx,%rdx
lea    (%rsi,%rsi,2),%esi
add    $0x2,%esi
movslq %esi,%rsi
lea    (%rax,%rax,2),%eax
add    $0x2,%eax
movslq %eax,%rdi
add    $0xffffffffffffffff,%rcx
jmp    1411 <avail+0x301>
lea    0x1(%rdx),%rbp
mov    $0x1,%eax
cmp    %rdi,%rdx
mov    %rbp,%rdx
jge    1440 <avail+0x330>
mov    %rcx,%rax
jmp    141f <avail+0x30f>
add    $0x1,%rax
cmp    %rsi,%rax
jge    1400 <avail+0x2f0>
mov    (%r12,%rdx,8),%rbp
movsbq 0x1(%rbp,%rax,1),%rbp
cmp    $0x2e,%rbp
je     1416 <avail+0x306>
cmpb   $0x0,-0x31(%rbp,%r14,1)
jne    143e <avail+0x32e>
mov    %bpl,-0x31(%rbp,%r14,1)
jmp    1416 <avail+0x306>
xor    %eax,%eax
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret

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

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