#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 aux(char **, char **, char **, char **, int, int /*<<< orphan*/,
        int /*<<< orphan*/);
void solveSudoku(char **board, int boardRowSize, int boardColSize) {
  char rows[9][9];
  char cols[9][9];
  char blks[9][9];
  int row, col, blk, nUnfilled;
  nUnfilled = 0;
  for (row = 0; row < 9; ++row) {
    for (col = 0; col < 9; ++col) {
      rows[row][col] = cols[row][col] = blks[row][col] = 0;
    }
  }
  for (row = 0; row < 9; ++row) {
    for (col = 0; col < 9; ++col) {
      blk = (row / 3) * 3 + col / 3;
      if (board[row][col] == '.') {
        nUnfilled++;
      } else {
        int i;
        i = board[row][col] - '1';
        rows[row][i] = cols[col][i] = blks[blk][i] = 1;
      }
    }
  }
  int ret;
  ret = aux(board, rows, cols, blks, nUnfilled, 0, 0);
}


x86 assembly (clang, -O0):
<solveSudoku>:
push   %rbp
mov    %rsp,%rbp
sub    $0x160,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
movl   $0x0,-0x140(%rbp)
movl   $0x0,-0x134(%rbp)
cmpl   $0x9,-0x134(%rbp)
jge    11e7 <solveSudoku+0xd7>
movl   $0x0,-0x138(%rbp)
cmpl   $0x9,-0x138(%rbp)
jge    11ce <solveSudoku+0xbe>
movslq -0x134(%rbp),%rcx
lea    -0x130(%rbp),%rax
imul   $0x9,%rcx,%rcx
add    %rcx,%rax
movslq -0x138(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
movslq -0x134(%rbp),%rcx
lea    -0xd0(%rbp),%rax
imul   $0x9,%rcx,%rcx
add    %rcx,%rax
movslq -0x138(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
movslq -0x134(%rbp),%rcx
lea    -0x70(%rbp),%rax
imul   $0x9,%rcx,%rcx
add    %rcx,%rax
movslq -0x138(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x138(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x138(%rbp)
jmp    1150 <solveSudoku+0x40>
jmp    11d3 <solveSudoku+0xc3>
mov    -0x134(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x134(%rbp)
jmp    1139 <solveSudoku+0x29>
movl   $0x0,-0x134(%rbp)
cmpl   $0x9,-0x134(%rbp)
jge    1333 <solveSudoku+0x223>
movl   $0x0,-0x138(%rbp)
cmpl   $0x9,-0x138(%rbp)
jge    131a <solveSudoku+0x20a>
mov    -0x134(%rbp),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
imul   $0x3,%eax,%eax
mov    %eax,-0x14c(%rbp)
mov    -0x138(%rbp),%eax
mov    $0x3,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x14c(%rbp),%eax
add    %ecx,%eax
mov    %eax,-0x13c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x134(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x138(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x2e,%eax
jne    1281 <solveSudoku+0x171>
mov    -0x140(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x140(%rbp)
jmp    1301 <solveSudoku+0x1f1>
mov    -0x8(%rbp),%rax
movslq -0x134(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x138(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
sub    $0x31,%eax
mov    %eax,-0x144(%rbp)
movslq -0x13c(%rbp),%rcx
lea    -0x130(%rbp),%rax
imul   $0x9,%rcx,%rcx
add    %rcx,%rax
movslq -0x144(%rbp),%rcx
movb   $0x1,(%rax,%rcx,1)
movslq -0x138(%rbp),%rcx
lea    -0xd0(%rbp),%rax
imul   $0x9,%rcx,%rcx
add    %rcx,%rax
movslq -0x144(%rbp),%rcx
movb   $0x1,(%rax,%rcx,1)
movslq -0x134(%rbp),%rcx
lea    -0x70(%rbp),%rax
imul   $0x9,%rcx,%rcx
add    %rcx,%rax
movslq -0x144(%rbp),%rcx
movb   $0x1,(%rax,%rcx,1)
jmp    1306 <solveSudoku+0x1f6>
mov    -0x138(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x138(%rbp)
jmp    1208 <solveSudoku+0xf8>
jmp    131f <solveSudoku+0x20f>
mov    -0x134(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x134(%rbp)
jmp    11f1 <solveSudoku+0xe1>
mov    -0x8(%rbp),%rdi
lea    -0x70(%rbp),%rsi
lea    -0xd0(%rbp),%rdx
lea    -0x130(%rbp),%rcx
mov    -0x140(%rbp),%r8d
xor    %r9d,%r9d
movl   $0x0,(%rsp)
call   1030 <aux@plt>
mov    %eax,-0x148(%rbp)
add    $0x160,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<solveSudoku>:
push   %rbx
sub    $0x130,%rsp
xorps  %xmm0,%xmm0
movaps %xmm0,0x50(%rsp)
movaps %xmm0,0x40(%rsp)
movaps %xmm0,0x30(%rsp)
movaps %xmm0,0x20(%rsp)
movaps %xmm0,0x10(%rsp)
movb   $0x0,0x60(%rsp)
movaps %xmm0,0x70(%rsp)
movaps %xmm0,0x80(%rsp)
movaps %xmm0,0x90(%rsp)
movaps %xmm0,0xa0(%rsp)
movaps %xmm0,0xb0(%rsp)
movb   $0x0,0xc0(%rsp)
movaps %xmm0,0xd0(%rsp)
movaps %xmm0,0xe0(%rsp)
movaps %xmm0,0xf0(%rsp)
movaps %xmm0,0x100(%rsp)
movaps %xmm0,0x110(%rsp)
movb   $0x0,0x120(%rsp)
xor    %eax,%eax
lea    0x9f(%rsp),%r10
mov    $0xaaaaaaab,%r9d
xor    %esi,%esi
xor    %r8d,%r8d
jmp    11c6 <solveSudoku+0xb6>
nopl   (%rax)
add    $0x1,%r8d
add    $0x1,%rsi
add    $0x9,%rax
cmp    $0x51,%rax
je     13dd <solveSudoku+0x2cd>
mov    %esi,%ecx
imul   %r9,%rcx
shr    $0x21,%rcx
lea    (%rcx,%rcx,2),%r11d
mov    (%rdi,%rsi,8),%rcx
movsbq (%rcx),%rdx
cmp    $0x2e,%rdx
jne    11f0 <solveSudoku+0xe0>
add    $0x1,%r8d
jmp    120f <solveSudoku+0xff>
nopl   0x0(%rax,%rax,1)
movslq %r11d,%rbx
lea    (%rbx,%rbx,8),%rbx
add    %rsp,%rbx
add    $0x10,%rbx
movb   $0x1,-0x31(%rdx,%rbx,1)
movb   $0x1,0x3f(%rsp,%rdx,1)
add    %r10,%rdx
movb   $0x1,(%rax,%rdx,1)
movsbq 0x1(%rcx),%rdx
cmp    $0x2e,%rdx
jne    1220 <solveSudoku+0x110>
add    $0x1,%r8d
jmp    123f <solveSudoku+0x12f>
movslq %r11d,%rbx
lea    (%rbx,%rbx,8),%rbx
add    %rsp,%rbx
add    $0x10,%rbx
movb   $0x1,-0x31(%rdx,%rbx,1)
movb   $0x1,0x48(%rsp,%rdx,1)
add    %r10,%rdx
movb   $0x1,(%rax,%rdx,1)
movsbq 0x2(%rcx),%rdx
cmp    $0x2e,%rdx
jne    1250 <solveSudoku+0x140>
add    $0x1,%r8d
jmp    126f <solveSudoku+0x15f>
movslq %r11d,%rbx
lea    (%rbx,%rbx,8),%rbx
add    %rsp,%rbx
add    $0x10,%rbx
movb   $0x1,-0x31(%rdx,%rbx,1)
movb   $0x1,0x51(%rsp,%rdx,1)
add    %r10,%rdx
movb   $0x1,(%rax,%rdx,1)
movsbq 0x3(%rcx),%rdx
cmp    $0x2e,%rdx
jne    1280 <solveSudoku+0x170>
add    $0x1,%r8d
jmp    12a3 <solveSudoku+0x193>
lea    0x1(%r11),%ebx
movslq %ebx,%rbx
lea    (%rbx,%rbx,8),%rbx
add    %rsp,%rbx
add    $0x10,%rbx
movb   $0x1,-0x31(%rdx,%rbx,1)
movb   $0x1,0x5a(%rsp,%rdx,1)
add    %r10,%rdx
movb   $0x1,(%rax,%rdx,1)
movsbq 0x4(%rcx),%rdx
cmp    $0x2e,%rdx
jne    12c0 <solveSudoku+0x1b0>
add    $0x1,%r8d
jmp    12e3 <solveSudoku+0x1d3>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    0x1(%r11),%ebx
movslq %ebx,%rbx
lea    (%rbx,%rbx,8),%rbx
add    %rsp,%rbx
add    $0x10,%rbx
movb   $0x1,-0x31(%rdx,%rbx,1)
movb   $0x1,0x63(%rsp,%rdx,1)
add    %r10,%rdx
movb   $0x1,(%rax,%rdx,1)
movsbq 0x5(%rcx),%rdx
cmp    $0x2e,%rdx
jne    1300 <solveSudoku+0x1f0>
add    $0x1,%r8d
jmp    1323 <solveSudoku+0x213>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    0x1(%r11),%ebx
movslq %ebx,%rbx
lea    (%rbx,%rbx,8),%rbx
add    %rsp,%rbx
add    $0x10,%rbx
movb   $0x1,-0x31(%rdx,%rbx,1)
movb   $0x1,0x6c(%rsp,%rdx,1)
add    %r10,%rdx
movb   $0x1,(%rax,%rdx,1)
movsbq 0x6(%rcx),%rdx
cmp    $0x2e,%rdx
jne    1340 <solveSudoku+0x230>
add    $0x1,%r8d
jmp    1363 <solveSudoku+0x253>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    0x2(%r11),%ebx
movslq %ebx,%rbx
lea    (%rbx,%rbx,8),%rbx
add    %rsp,%rbx
add    $0x10,%rbx
movb   $0x1,-0x31(%rdx,%rbx,1)
movb   $0x1,0x75(%rsp,%rdx,1)
add    %r10,%rdx
movb   $0x1,(%rax,%rdx,1)
movsbq 0x7(%rcx),%rdx
cmp    $0x2e,%rdx
jne    1380 <solveSudoku+0x270>
add    $0x1,%r8d
jmp    13a3 <solveSudoku+0x293>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    0x2(%r11),%ebx
movslq %ebx,%rbx
lea    (%rbx,%rbx,8),%rbx
add    %rsp,%rbx
add    $0x10,%rbx
movb   $0x1,-0x31(%rdx,%rbx,1)
movb   $0x1,0x7e(%rsp,%rdx,1)
add    %r10,%rdx
movb   $0x1,(%rax,%rdx,1)
movsbq 0x8(%rcx),%rcx
cmp    $0x2e,%rcx
je     11b0 <solveSudoku+0xa0>
add    $0x2,%r11d
movslq %r11d,%rdx
lea    (%rdx,%rdx,8),%rdx
add    %rsp,%rdx
add    $0x10,%rdx
movb   $0x1,-0x31(%rcx,%rdx,1)
movb   $0x1,0x87(%rsp,%rcx,1)
01
add    %r10,%rcx
movb   $0x1,(%rax,%rcx,1)
jmp    11b4 <solveSudoku+0xa4>
movl   $0x0,(%rsp)
lea    0xd0(%rsp),%rsi
lea    0x70(%rsp),%rdx
lea    0x10(%rsp),%rcx
xor    %r9d,%r9d
call   1030 <aux@plt>
add    $0x130,%rsp
pop    %rbx
ret

LLVM IR (-O0):
define void @solveSudoku(i8** %0, i32 %1, i32 %2) {
%4 = alloca i8**
%5 = alloca i32
%6 = alloca i32
%7 = alloca [9 x [9 x i8]]
%8 = alloca [9 x [9 x i8]]
%9 = alloca [9 x [9 x i8]]
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
store i8** %0, i8*** %4
store i32 %1, i32* %5
store i32 %2, i32* %6
store i32 0, i32* %13
store i32 0, i32* %10
br label %16
16: ; preds = %46, %3
%17 = load i32, i32* %10
%18 = icmp slt i32 %17, 9
br i1 %18, label %19, label %49
19: ; preds = %16
store i32 0, i32* %11
br label %20
20: ; preds = %42, %19
%21 = load i32, i32* %11
%22 = icmp slt i32 %21, 9
br i1 %22, label %23, label %45
23: ; preds = %20
%24 = load i32, i32* %10
%25 = sext i32 %24 to i64
%26 = getelementptr inbounds [9 x [9 x i8]], [9 x [9 x i8]]* %9, i64 0, i64 %25
%27 = load i32, i32* %11
%28 = sext i32 %27 to i64
%29 = getelementptr inbounds [9 x i8], [9 x i8]* %26, i64 0, i64 %28
store i8 0, i8* %29
%30 = load i32, i32* %10
%31 = sext i32 %30 to i64
%32 = getelementptr inbounds [9 x [9 x i8]], [9 x [9 x i8]]* %8, i64 0, i64 %31
%33 = load i32, i32* %11
%34 = sext i32 %33 to i64
%35 = getelementptr inbounds [9 x i8], [9 x i8]* %32, i64 0, i64 %34
store i8 0, i8* %35
%36 = load i32, i32* %10
%37 = sext i32 %36 to i64
%38 = getelementptr inbounds [9 x [9 x i8]], [9 x [9 x i8]]* %7, i64 0, i64 %37
%39 = load i32, i32* %11
%40 = sext i32 %39 to i64
%41 = getelementptr inbounds [9 x i8], [9 x i8]* %38, i64 0, i64 %40
store i8 0, i8* %41
br label %42
42: ; preds = %23
%43 = load i32, i32* %11
%44 = add nsw i32 %43, 1
store i32 %44, i32* %11
br label %20
45: ; preds = %20
br label %46
46: ; preds = %45
%47 = load i32, i32* %10
%48 = add nsw i32 %47, 1
store i32 %48, i32* %10
br label %16
49: ; preds = %16
store i32 0, i32* %10
br label %50
50: ; preds = %113, %49
%51 = load i32, i32* %10
%52 = icmp slt i32 %51, 9
br i1 %52, label %53, label %116
53: ; preds = %50
store i32 0, i32* %11
br label %54
54: ; preds = %109, %53
%55 = load i32, i32* %11
%56 = icmp slt i32 %55, 9
br i1 %56, label %57, label %112
57: ; preds = %54
%58 = load i32, i32* %10
%59 = sdiv i32 %58, 3
%60 = mul nsw i32 %59, 3
%61 = load i32, i32* %11
%62 = sdiv i32 %61, 3
%63 = add nsw i32 %60, %62
store i32 %63, i32* %12
%64 = load i8**, i8*** %4
%65 = load i32, i32* %10
%66 = sext i32 %65 to i64
%67 = getelementptr inbounds i8*, i8** %64, i64 %66
%68 = load i8*, i8** %67
%69 = load i32, i32* %11
%70 = sext i32 %69 to i64
%71 = getelementptr inbounds i8, i8* %68, i64 %70
%72 = load i8, i8* %71
%73 = sext i8 %72 to i32
%74 = icmp eq i32 %73, 46
br i1 %74, label %75, label %78
75: ; preds = %57
%76 = load i32, i32* %13
%77 = add nsw i32 %76, 1
store i32 %77, i32* %13
br label %108
78: ; preds = %57
%79 = load i8**, i8*** %4
%80 = load i32, i32* %10
%81 = sext i32 %80 to i64
%82 = getelementptr inbounds i8*, i8** %79, i64 %81
%83 = load i8*, i8** %82
%84 = load i32, i32* %11
%85 = sext i32 %84 to i64
%86 = getelementptr inbounds i8, i8* %83, i64 %85
%87 = load i8, i8* %86
%88 = sext i8 %87 to i32
%89 = sub nsw i32 %88, 49
store i32 %89, i32* %14
%90 = load i32, i32* %12
%91 = sext i32 %90 to i64
%92 = getelementptr inbounds [9 x [9 x i8]], [9 x [9 x i8]]* %9, i64 0, i64 %91
%93 = load i32, i32* %14
%94 = sext i32 %93 to i64
%95 = getelementptr inbounds [9 x i8], [9 x i8]* %92, i64 0, i64 %94
store i8 1, i8* %95
%96 = load i32, i32* %11
%97 = sext i32 %96 to i64
%98 = getelementptr inbounds [9 x [9 x i8]], [9 x [9 x i8]]* %8, i64 0, i64 %97
%99 = load i32, i32* %14
%100 = sext i32 %99 to i64
%101 = getelementptr inbounds [9 x i8], [9 x i8]* %98, i64 0, i64 %100
store i8 1, i8* %101
%102 = load i32, i32* %10
%103 = sext i32 %102 to i64
%104 = getelementptr inbounds [9 x [9 x i8]], [9 x [9 x i8]]* %7, i64 0, i64 %103
%105 = load i32, i32* %14
%106 = sext i32 %105 to i64
%107 = getelementptr inbounds [9 x i8], [9 x i8]* %104, i64 0, i64 %106
store i8 1, i8* %107
br label %108
108: ; preds = %78, %75
br label %109
109: ; preds = %108
%110 = load i32, i32* %11
%111 = add nsw i32 %110, 1
store i32 %111, i32* %11
br label %54
112: ; preds = %54
br label %113
113: ; preds = %112
%114 = load i32, i32* %10
%115 = add nsw i32 %114, 1
store i32 %115, i32* %10
br label %50
116: ; preds = %50
%117 = load i8**, i8*** %4
%118 = getelementptr inbounds [9 x [9 x i8]], [9 x [9 x i8]]* %7, i64 0, i64 0
%119 = bitcast [9 x i8]* %118 to i8**
%120 = getelementptr inbounds [9 x [9 x i8]], [9 x [9 x i8]]* %8, i64 0, i64 0
%121 = bitcast [9 x i8]* %120 to i8**
%122 = getelementptr inbounds [9 x [9 x i8]], [9 x [9 x i8]]* %9, i64 0, i64 0
%123 = bitcast [9 x i8]* %122 to i8**
%124 = load i32, i32* %13
%125 = call i32 @aux(i8** %117, i8** %119, i8** %121, i8** %123, i32 %124, i32 0, i32 0)
store i32 %125, i32* %15
ret void
}

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