void singleplayer(void) {
  int difficultyLevel;
  char *difficultyLevelOptions[] = {"1. Easy", "2. Normal", "3. Hard"};
  menuSelection(&difficultyLevel, "DIFFICULTY LEVEL", difficultyLevelOptions,
                3);
  int startingPlayer = drawing();
  char player[2][78] = {"   |   YOU start the game!                            "
                        "                      |",
                        "   |   COMPUTER starts the game!                      "
                        "                      |"};
  printTitle("INSTRUCTIONS");
  printf("   |   Let's flip a coin:                                            "
         "       |\n"
         "%s\n",
         player[startingPlayer - 1]);
  printGameboard("123456789");
  int field;
  char board[9] = "         ";
  for (int i = 0; 1; i++) {
    int human = (startingPlayer + i) % 2;
    if (human) {
      askForMenuNumber(&field, 9);
      if (board[field - 1] != ' ') {
        i--;
        continue;
      }
    } else {
      waitingForMove();
      aiGenerateMove(difficultyLevel, &field, board);
      printf("   |   Type number: %d                                           "
             "            |\n",
             field);
    }
    if (difficultyLevel == 3 && startingPlayer == 1)
      board[field - 1] = i % 2 ? 'X' : 'O';
    else
      board[field - 1] = i % 2 ? 'O' : 'X';
    printTitle("GAMEBOARD");
    checkForEndOfGame(&i, &field, board, singleplayer);
    if (human)
      printf("   |   COMPUTER is making a move!                                "
             "           |\n");
    else
      printf("   |   YOUR turn now, make a move!                               "
             "           |\n");
    printGameboard(board);
  }
}


x86 assembly (clang, -O0):
<singleplayer>:
push   %rbp
mov    %rsp,%rbp
sub    $0xe0,%rsp
mov    0x2c4e(%rip),%rax
mov    %rax,-0x20(%rbp)
mov    0x2c4b(%rip),%rax
mov    %rax,-0x18(%rbp)
mov    0x2c48(%rip),%rax
mov    %rax,-0x10(%rbp)
lea    -0x20(%rbp),%rdx
lea    -0x4(%rbp),%rdi
lea    0xe3f(%rip),%rsi
mov    $0x3,%ecx
mov    $0x0,%al
call   10b0 <menuSelection@plt>
mov    $0x0,%al
call   1080 <drawing@plt>
mov    %eax,-0x24(%rbp)
lea    -0xc0(%rbp),%rdi
lea    0xf91(%rip),%rsi
mov    $0x9c,%edx
call   1070 <memcpy@plt>
lea    0xe1b(%rip),%rdi
mov    $0x0,%al
call   1040 <printTitle@plt>
mov    -0x24(%rbp),%eax
sub    $0x1,%eax
cltq
lea    -0xc0(%rbp),%rsi
imul   $0x4e,%rax,%rax
add    %rax,%rsi
lea    0xe04(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    0xe48(%rip),%rdi
mov    $0x0,%al
call   1050 <printGameboard@plt>
mov    0xfdc(%rip),%rax
mov    %rax,-0xcd(%rbp)
mov    0xfd7(%rip),%al
mov    %al,-0xc5(%rbp)
movl   $0x0,-0xd4(%rbp)
mov    $0x1,%al
test   $0x1,%al
jne    127c <singleplayer+0xdc>
jmp    1419 <singleplayer+0x279>
mov    -0x24(%rbp),%eax
add    -0xd4(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %edx,-0xd8(%rbp)
cmpl   $0x0,-0xd8(%rbp)
je     12e8 <singleplayer+0x148>
lea    -0xc4(%rbp),%rdi
mov    $0x9,%esi
mov    $0x0,%al
call   1090 <askForMenuNumber@plt>
mov    -0xc4(%rbp),%eax
sub    $0x1,%eax
cltq
movsbl -0xcd(%rbp,%rax,1),%eax
ff
cmp    $0x20,%eax
je     12e3 <singleplayer+0x143>
mov    -0xd4(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xd4(%rbp)
jmp    1405 <singleplayer+0x265>
jmp    131b <singleplayer+0x17b>
mov    $0x0,%al
call   10c0 <waitingForMove@plt>
mov    -0x4(%rbp),%edi
lea    -0xcd(%rbp),%rdx
lea    -0xc4(%rbp),%rsi
mov    $0x0,%al
call   10a0 <aiGenerateMove@plt>
mov    -0xc4(%rbp),%esi
lea    0xd80(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
cmpl   $0x3,-0x4(%rbp)
jne    1366 <singleplayer+0x1c6>
cmpl   $0x1,-0x24(%rbp)
jne    1366 <singleplayer+0x1c6>
mov    -0xd4(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    $0x4f,%eax
mov    $0x58,%ecx
cmp    $0x0,%edx
cmovne %ecx,%eax
mov    %al,%cl
mov    -0xc4(%rbp),%eax
sub    $0x1,%eax
cltq
mov    %cl,-0xcd(%rbp,%rax,1)
jmp    1398 <singleplayer+0x1f8>
mov    -0xd4(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    $0x58,%eax
mov    $0x4f,%ecx
cmp    $0x0,%edx
cmovne %ecx,%eax
mov    %al,%cl
mov    -0xc4(%rbp),%eax
sub    $0x1,%eax
cltq
mov    %cl,-0xcd(%rbp,%rax,1)
lea    0xd45(%rip),%rdi
mov    $0x0,%al
call   1040 <printTitle@plt>
lea    -0xcd(%rbp),%rdx
lea    -0xd4(%rbp),%rdi
lea    -0xc4(%rbp),%rsi
mov    0x2c1e(%rip),%rcx
mov    $0x0,%al
call   1030 <checkForEndOfGame@plt>
cmpl   $0x0,-0xd8(%rbp)
je     13e9 <singleplayer+0x249>
lea    0xd11(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
jmp    13f7 <singleplayer+0x257>
lea    0xd4d(%rip),%rdi
mov    $0x0,%al
call   1060 <printf@plt>
lea    -0xcd(%rbp),%rdi
mov    $0x0,%al
call   1050 <printGameboard@plt>
mov    -0xd4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd4(%rbp)
jmp    126d <singleplayer+0xcd>
add    $0xe0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<singleplayer>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xe8,%rsp
mov    0x2c48(%rip),%rax
mov    %rax,0x30(%rsp)
movaps 0x2c2c(%rip),%xmm0
movaps %xmm0,0x20(%rsp)
lea    0xe3a(%rip),%rsi
lea    0xc(%rsp),%rdi
lea    0x20(%rsp),%rdx
mov    $0x3,%ecx
xor    %eax,%eax
call   10c0 <menuSelection@plt>
xor    %eax,%eax
call   1090 <drawing@plt>
mov    %eax,%r14d
lea    0xf89(%rip),%rsi
lea    0x40(%rsp),%rdi
mov    $0x9c,%edx
call   1080 <memcpy@plt>
lea    0xe0e(%rip),%rdi
xor    %eax,%eax
call   1040 <printTitle@plt>
lea    -0x1(%r14),%eax
cltq
imul   $0x4e,%rax,%rax
lea    (%rsp,%rax,1),%rsi
add    $0x40,%rsi
lea    0xdfb(%rip),%rdi
xor    %eax,%eax
call   1070 <printf@plt>
lea    0xe3f(%rip),%rdi
xor    %eax,%eax
call   1060 <printGameboard@plt>
movabs $0x2020202020202020,%rax
20 20 20
mov    %rax,0x10(%rsp)
movb   $0x20,0x18(%rsp)
lea    0x8(%rsp),%r15
lea    0x10(%rsp),%rbx
mov    %r14d,%ebp
xor    $0x1,%ebp
lea    0x4(%rsp),%r12
xor    %eax,%eax
jmp    128e <singleplayer+0xde>
nop
mov    0x4(%rsp),%eax
add    $0xffffffff,%eax
mov    %eax,0x4(%rsp)
add    $0x1,%eax
mov    %eax,0x4(%rsp)
add    %r14d,%eax
test   $0x1,%al
jne    12d0 <singleplayer+0x120>
xor    %eax,%eax
call   10d0 <waitingForMove@plt>
mov    0xc(%rsp),%edi
mov    %r15,%rsi
mov    %rbx,%rdx
xor    %eax,%eax
call   10b0 <aiGenerateMove@plt>
mov    0x8(%rsp),%esi
lea    0xdd8(%rip),%rdi
xor    %eax,%eax
call   1070 <printf@plt>
lea    0xe24(%rip),%r13
jmp    12f2 <singleplayer+0x142>
nopl   0x0(%rax)
mov    %r15,%rdi
mov    $0x9,%esi
xor    %eax,%eax
call   10a0 <askForMenuNumber@plt>
movslq 0x8(%rsp),%rax
cmpb   $0x20,-0x1(%rax,%rbx,1)
lea    0xe4c(%rip),%r13
jne    1280 <singleplayer+0xd0>
mov    0xc(%rsp),%eax
xor    $0x3,%eax
xor    %ecx,%ecx
xor    %edx,%edx
testb  $0x1,0x4(%rsp)
sete   %cl
lea    0x4f(%rcx,%rcx,8),%ecx
movslq 0x8(%rsp),%rsi
setne  %dl
lea    (%rdx,%rdx,8),%edx
add    $0x4f,%edx
or     %ebp,%eax
cmovne %ecx,%edx
mov    %dl,-0x1(%rsi,%rbx,1)
lea    0xdbd(%rip),%rdi
xor    %eax,%eax
call   1040 <printTitle@plt>
mov    %r12,%rdi
mov    %r15,%rsi
mov    %rbx,%rdx
mov    0x2ca2(%rip),%rcx
xor    %eax,%eax
call   1030 <checkForEndOfGame@plt>
mov    %r13,%rdi
call   1050 <puts@plt>
mov    %rbx,%rdi
xor    %eax,%eax
call   1060 <printGameboard@plt>
mov    0x4(%rsp),%eax
add    $0x1,%eax
jmp    128e <singleplayer+0xde>

LLVM IR (-O0):
@.str = [8 x i8] c"1. Easy\00"
@.str.1 = [10 x i8] c"2. Normal\00"
@.str.2 = [8 x i8] c"3. Hard\00"
@__const.singleplayer.difficultyLevelOptions = [3 x i8*] [i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.1, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.2, i32 0, i32 0)]
@.str.3 = [17 x i8] c"DIFFICULTY LEVEL\00"
@__const.singleplayer.player = [2 x [78 x i8]] [[78 x i8] c" | YOU start the game! |\00", [78 x i8] c" | COMPUTER starts the game! |\00"]
@.str.4 = [13 x i8] c"INSTRUCTIONS\00"
@.str.5 = [82 x i8] c" | Let's flip a coin: |\0A%s\0A\00"
@.str.6 = [10 x i8] c"123456789\00"
@__const.singleplayer.board = [9 x i8] c" "
@.str.7 = [80 x i8] c" | Type number: %d |\0A\00"
@.str.8 = [10 x i8] c"GAMEBOARD\00"
@.str.9 = [79 x i8] c" | COMPUTER is making a move! |\0A\00"
@.str.10 = [79 x i8] c" | YOUR turn now, make a move! |\0A\00"
define void @singleplayer() {
%1 = alloca i32
%2 = alloca [3 x i8*]
%3 = alloca i32
%4 = alloca [2 x [78 x i8]]
%5 = alloca i32
%6 = alloca [9 x i8]
%7 = alloca i32
%8 = alloca i32
%9 = bitcast [3 x i8*]* %2 to i8*
%10 = getelementptr inbounds [3 x i8*], [3 x i8*]* %2, i64 0, i64 0
%11 = call i32 (i32*, i8*, i8**, i32, ...) bitcast (i32 (...)* @menuSelection to i32 (i32*, i8*, i8**, i32, ...)*)(i32* %1, i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.3, i64 0, i64 0), i8** %10, i32 3)
%12 = call i32 (...) @drawing()
store i32 %12, i32* %3
%13 = bitcast [2 x [78 x i8]]* %4 to i8*
%14 = call i32 (i8*, ...) bitcast (i32 (...)* @printTitle to i32 (i8*, ...)*)(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.4, i64 0, i64 0))
%15 = load i32, i32* %3
%16 = sub nsw i32 %15, 1
%17 = sext i32 %16 to i64
%18 = getelementptr inbounds [2 x [78 x i8]], [2 x [78 x i8]]* %4, i64 0, i64 %17
%19 = getelementptr inbounds [78 x i8], [78 x i8]* %18, i64 0, i64 0
%20 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([82 x i8], [82 x i8]* @.str.5, i64 0, i64 0), i8* %19)
%21 = call i32 (i8*, ...) bitcast (i32 (...)* @printGameboard to i32 (i8*, ...)*)(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.6, i64 0, i64 0))
%22 = bitcast [9 x i8]* %6 to i8*
store i32 0, i32* %7
br label %23
23: ; preds = %92, %0
br i1 true, label %24, label %95
24: ; preds = %23
%25 = load i32, i32* %3
%26 = load i32, i32* %7
%27 = add nsw i32 %25, %26
%28 = srem i32 %27, 2
store i32 %28, i32* %8
%29 = load i32, i32* %8
%30 = icmp ne i32 %29, 0
br i1 %30, label %31, label %44
31: ; preds = %24
%32 = call i32 (i32*, i32, ...) bitcast (i32 (...)* @askForMenuNumber to i32 (i32*, i32, ...)*)(i32* %5, i32 9)
%33 = load i32, i32* %5
%34 = sub nsw i32 %33, 1
%35 = sext i32 %34 to i64
%36 = getelementptr inbounds [9 x i8], [9 x i8]* %6, i64 0, i64 %35
%37 = load i8, i8* %36
%38 = sext i8 %37 to i32
%39 = icmp ne i32 %38, 32
br i1 %39, label %40, label %43
40: ; preds = %31
%41 = load i32, i32* %7
%42 = add nsw i32 %41, -1
store i32 %42, i32* %7
br label %92
43: ; preds = %31
br label %51
44: ; preds = %24
%45 = call i32 (...) @waitingForMove()
%46 = load i32, i32* %1
%47 = getelementptr inbounds [9 x i8], [9 x i8]* %6, i64 0, i64 0
%48 = call i32 (i32, i32*, i8*, ...) bitcast (i32 (...)* @aiGenerateMove to i32 (i32, i32*, i8*, ...)*)(i32 %46, i32* %5, i8* %47)
%49 = load i32, i32* %5
%50 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([80 x i8], [80 x i8]* @.str.7, i64 0, i64 0), i32 %49)
br label %51
51: ; preds = %44, %43
%52 = load i32, i32* %1
%53 = icmp eq i32 %52, 3
br i1 %53, label %54, label %68
54: ; preds = %51
%55 = load i32, i32* %3
%56 = icmp eq i32 %55, 1
br i1 %56, label %57, label %68
57: ; preds = %54
%58 = load i32, i32* %7
%59 = srem i32 %58, 2
%60 = icmp ne i32 %59, 0
%61 = zext i1 %60 to i64
%62 = select i1 %60, i32 88, i32 79
%63 = trunc i32 %62 to i8
%64 = load i32, i32* %5
%65 = sub nsw i32 %64, 1
%66 = sext i32 %65 to i64
%67 = getelementptr inbounds [9 x i8], [9 x i8]* %6, i64 0, i64 %66
store i8 %63, i8* %67
br label %79
68: ; preds = %54, %51
%69 = load i32, i32* %7
%70 = srem i32 %69, 2
%71 = icmp ne i32 %70, 0
%72 = zext i1 %71 to i64
%73 = select i1 %71, i32 79, i32 88
%74 = trunc i32 %73 to i8
%75 = load i32, i32* %5
%76 = sub nsw i32 %75, 1
%77 = sext i32 %76 to i64
%78 = getelementptr inbounds [9 x i8], [9 x i8]* %6, i64 0, i64 %77
store i8 %74, i8* %78
br label %79
79: ; preds = %68, %57
%80 = call i32 (i8*, ...) bitcast (i32 (...)* @printTitle to i32 (i8*, ...)*)(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.8, i64 0, i64 0))
%81 = getelementptr inbounds [9 x i8], [9 x i8]* %6, i64 0, i64 0
%82 = call i32 (i32*, i32*, i8*, void ()*, ...) bitcast (i32 (...)* @checkForEndOfGame to i32 (i32*, i32*, i8*, void ()*, ...)*)(i32* %7, i32* %5, i8* %81, void ()* @singleplayer)
%83 = load i32, i32* %8
%84 = icmp ne i32 %83, 0
br i1 %84, label %85, label %87
85: ; preds = %79
%86 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([79 x i8], [79 x i8]* @.str.9, i64 0, i64 0))
br label %89
87: ; preds = %79
%88 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([79 x i8], [79 x i8]* @.str.10, i64 0, i64 0))
br label %89
89: ; preds = %87, %85
%90 = getelementptr inbounds [9 x i8], [9 x i8]* %6, i64 0, i64 0
%91 = call i32 (i8*, ...) bitcast (i32 (...)* @printGameboard to i32 (i8*, ...)*)(i8* %90)
br label %92
92: ; preds = %89, %40
%93 = load i32, i32* %7
%94 = add nsw i32 %93, 1
store i32 %94, i32* %7
br label %23
95: ; preds = %23
ret void
}

LLVM IR (-O2):
@.str = [8 x i8] c"1. Easy\00"
@.str.1 = [10 x i8] c"2. Normal\00"
@.str.2 = [8 x i8] c"3. Hard\00"
@__const.singleplayer.difficultyLevelOptions = [3 x i8*] [i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str, i32 0, i32 0), i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.1, i32 0, i32 0), i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str.2, i32 0, i32 0)]
@.str.3 = [17 x i8] c"DIFFICULTY LEVEL\00"
@__const.singleplayer.player = [2 x [78 x i8]] [[78 x i8] c" | YOU start the game! |\00", [78 x i8] c" | COMPUTER starts the game! |\00"]
@.str.4 = [13 x i8] c"INSTRUCTIONS\00"
@.str.5 = [82 x i8] c" | Let's flip a coin: |\0A%s\0A\00"
@.str.6 = [10 x i8] c"123456789\00"
@.str.7 = [80 x i8] c" | Type number: %d |\0A\00"
@.str.8 = [10 x i8] c"GAMEBOARD\00"
@str = [78 x i8] c" | YOUR turn now, make a move! |\00"
@str.11 = [78 x i8] c" | COMPUTER is making a move! |\00"
define void @singleplayer() {
%1 = alloca i32
%2 = alloca [3 x i8*]
%3 = alloca [2 x [78 x i8]]
%4 = alloca i32
%5 = alloca [9 x i8]
%6 = alloca i32
%7 = bitcast i32* %1 to i8*
%8 = bitcast [3 x i8*]* %2 to i8*
%9 = getelementptr inbounds [3 x i8*], [3 x i8*]* %2, i64 0, i64 0
%10 = call i32 (i32*, i8*, i8**, i32, ...) bitcast (i32 (...)* @menuSelection to i32 (i32*, i8*, i8**, i32, ...)*)(i32* %1, i8* getelementptr inbounds ([17 x i8], [17 x i8]* @.str.3, i64 0, i64 0), i8** %9, i32 3)
%11 = call i32 (...) @drawing()
%12 = getelementptr inbounds [2 x [78 x i8]], [2 x [78 x i8]]* %3, i64 0, i64 0, i64 0
%13 = call i32 (i8*, ...) bitcast (i32 (...)* @printTitle to i32 (i8*, ...)*)(i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.str.4, i64 0, i64 0))
%14 = add nsw i32 %11, -1
%15 = sext i32 %14 to i64
%16 = getelementptr inbounds [2 x [78 x i8]], [2 x [78 x i8]]* %3, i64 0, i64 %15, i64 0
%17 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([82 x i8], [82 x i8]* @.str.5, i64 0, i64 0), i8* %16)
%18 = call i32 (i8*, ...) bitcast (i32 (...)* @printGameboard to i32 (i8*, ...)*)(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.6, i64 0, i64 0))
%19 = bitcast i32* %4 to i8*
%20 = getelementptr inbounds [9 x i8], [9 x i8]* %5, i64 0, i64 0
%21 = bitcast i32* %6 to i8*
%22 = icmp eq i32 %11, 1
br label %23
23: ; preds = %65, %0
%24 = phi i32 [ 0, %0 ], [ %67, %65 ]
store i32 %24, i32* %6
%25 = add nsw i32 %24, %11
%26 = and i32 %25, 1
%27 = icmp eq i32 %26, 0
br i1 %27, label %39, label %28
28: ; preds = %23
%29 = call i32 (i32*, i32, ...) bitcast (i32 (...)* @askForMenuNumber to i32 (i32*, i32, ...)*)(i32* %4, i32 9)
%30 = load i32, i32* %4
%31 = add nsw i32 %30, -1
%32 = sext i32 %31 to i64
%33 = getelementptr inbounds [9 x i8], [9 x i8]* %5, i64 0, i64 %32
%34 = load i8, i8* %33
%35 = icmp eq i8 %34, 32
br i1 %35, label %45, label %36
36: ; preds = %28
%37 = load i32, i32* %6
%38 = add nsw i32 %37, -1
store i32 %38, i32* %6
br label %65
39: ; preds = %23
%40 = call i32 (...) @waitingForMove()
%41 = load i32, i32* %1
%42 = call i32 (i32, i32*, i8*, ...) bitcast (i32 (...)* @aiGenerateMove to i32 (i32, i32*, i8*, ...)*)(i32 %41, i32* %4, i8* %20)
%43 = load i32, i32* %4
%44 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([80 x i8], [80 x i8]* @.str.7, i64 0, i64 0), i32 %43)
br label %45
45: ; preds = %28, %39
%46 = phi i8* [ getelementptr inbounds ([78 x i8], [78 x i8]* @str.11, i64 0, i64 0), %28 ], [ getelementptr inbounds ([78 x i8], [78 x i8]* @str, i64 0, i64 0), %39 ]
%47 = load i32, i32* %1
%48 = icmp eq i32 %47, 3
%49 = select i1 %48, i1 %22, i1 false
%50 = load i32, i32* %6
%51 = and i32 %50, 1
%52 = icmp eq i32 %51, 0
%53 = select i1 %52, i8 88, i8 79
%54 = load i32, i32* %4
%55 = select i1 %52, i8 79, i8 88
%56 = select i1 %49, i8 %55, i8 %53
%57 = add nsw i32 %54, -1
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds [9 x i8], [9 x i8]* %5, i64 0, i64 %58
store i8 %56, i8* %59
%60 = call i32 (i8*, ...) bitcast (i32 (...)* @printTitle to i32 (i8*, ...)*)(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.8, i64 0, i64 0))
%61 = call i32 (i32*, i32*, i8*, void ()*, ...) bitcast (i32 (...)* @checkForEndOfGame to i32 (i32*, i32*, i8*, void ()*, ...)*)(i32* %6, i32* %4, i8* %20, void ()* @singleplayer)
%62 = call i32 @puts(i8* dereferenceable(1) %46)
%63 = call i32 (i8*, ...) bitcast (i32 (...)* @printGameboard to i32 (i8*, ...)*)(i8* %20)
%64 = load i32, i32* %6
br label %65
65: ; preds = %45, %36
%66 = phi i32 [ %64, %45 ], [ %38, %36 ]
%67 = add nsw i32 %66, 1
br label %23
}