int main() {
  printf("\033[H\033[J");
  int n = 10;
  int max = n * n;
  int top = 0;
  int s_max = n;
  int s_top = 0;
  int index = 0;
  int sols = 0;
  char successful_move = 'f';
  char **stack = (char **)malloc(n * n * sizeof(char *));
  for (int i = 0; i < n * n; i++) {
    stack[i] = (char *)malloc((n * n) * sizeof(char));
  }
  char *board = (char *)malloc((n * n) * sizeof(char));
  for (int i = 0; i < n * n; i++) {
    board[i] = '_';
  }
  char **solutions = (char **)malloc(n * sizeof(char *));
  for (int i = 0; i < n; i++) {
    solutions[i] = (char *)malloc((n * n) * sizeof(char));
  }
  while (top > -1) {
    if (remaining_moves(n, board) == 0) {
      if (validate_board(n, board, s_top, solutions) == 1) {
        sols += 1;
        if (s_top >= s_max) {
          s_max = s_max + floor(s_max / 2);
          solutions = realloc(solutions, (s_max) * sizeof(char *));
          for (int i = s_top; i < (s_max); i++) {
            solutions[i] = malloc((n * n) * sizeof(char));
          }
        }
        new_solution(n, board, s_top, solutions);
        s_top += 1;
      }
      new_board(n, &top, board, stack);
    }
    index = 0;
    successful_move = 'f';
    while (index < n * n && successful_move == 'f') {
      if (board[index] == '_') {
        backtrack(n, index, board, &top, &max, stack);
        place_piece(n, index, board);
        successful_move = 't';
      } else {
        index += 1;
      }
    }
  }
  printf("Solutions: %d\n\n", sols);
  free(stack);
  free(solutions);
  free(board);
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
movl   $0x0,-0x4(%rbp)
lea    0xe3a(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movl   $0xa,-0x8(%rbp)
mov    -0x8(%rbp),%eax
imul   -0x8(%rbp),%eax
mov    %eax,-0xc(%rbp)
movl   $0x0,-0x10(%rbp)
mov    -0x8(%rbp),%eax
mov    %eax,-0x14(%rbp)
movl   $0x0,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
movb   $0x66,-0x21(%rbp)
mov    -0x8(%rbp),%eax
imul   -0x8(%rbp),%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    -0x8(%rbp),%ecx
imul   -0x8(%rbp),%ecx
cmp    %ecx,%eax
jge    1264 <main+0xb4>
mov    -0x8(%rbp),%eax
imul   -0x8(%rbp),%eax
movslq %eax,%rdi
shl    $0x0,%rdi
call   10a0 <malloc@plt>
mov    %rax,%rdx
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1222 <main+0x72>
mov    -0x8(%rbp),%eax
imul   -0x8(%rbp),%eax
movslq %eax,%rdi
shl    $0x0,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0x40(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
mov    -0x8(%rbp),%ecx
imul   -0x8(%rbp),%ecx
cmp    %ecx,%eax
jge    12ae <main+0xfe>
mov    -0x40(%rbp),%rax
movslq -0x44(%rbp),%rcx
movb   $0x5f,(%rax,%rcx,1)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1282 <main+0xd2>
movslq -0x8(%rbp),%rdi
shl    $0x3,%rdi
call   10a0 <malloc@plt>
mov    %rax,-0x50(%rbp)
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1302 <main+0x152>
mov    -0x8(%rbp),%eax
imul   -0x8(%rbp),%eax
movslq %eax,%rdi
shl    $0x0,%rdi
call   10a0 <malloc@plt>
mov    %rax,%rdx
mov    -0x50(%rbp),%rax
movslq -0x54(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    12c6 <main+0x116>
jmp    1307 <main+0x157>
cmpl   $0xffffffff,-0x10(%rbp)
jle    14ba <main+0x30a>
mov    -0x8(%rbp),%edi
mov    -0x40(%rbp),%rsi
mov    $0x0,%al
call   1040 <remaining_moves@plt>
cmp    $0x0,%eax
jne    141c <main+0x26c>
mov    -0x8(%rbp),%edi
mov    -0x40(%rbp),%rsi
mov    -0x18(%rbp),%edx
mov    -0x50(%rbp),%rcx
mov    $0x0,%al
call   1060 <validate_board@plt>
cmp    $0x1,%eax
jne    1406 <main+0x256>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jl     13e8 <main+0x238>
cvtsi2sdl -0x14(%rbp),%xmm0
movsd  %xmm0,-0x60(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cvtsi2sd %eax,%xmm0
call   10d0 <floor@plt>
movaps %xmm0,%xmm1
movsd  -0x60(%rbp),%xmm0
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0x14(%rbp)
mov    -0x50(%rbp),%rdi
movslq -0x14(%rbp),%rsi
shl    $0x3,%rsi
call   10c0 <realloc@plt>
mov    %rax,-0x50(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    13e3 <main+0x233>
mov    -0x8(%rbp),%eax
imul   -0x8(%rbp),%eax
movslq %eax,%rdi
shl    $0x0,%rdi
call   10a0 <malloc@plt>
mov    %rax,%rdx
mov    -0x50(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    13a7 <main+0x1f7>
jmp    13e8 <main+0x238>
mov    -0x8(%rbp),%edi
mov    -0x40(%rbp),%rsi
mov    -0x18(%rbp),%edx
mov    -0x50(%rbp),%rcx
mov    $0x0,%al
call   1090 <new_solution@plt>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
mov    -0x8(%rbp),%edi
mov    -0x40(%rbp),%rdx
mov    -0x30(%rbp),%rcx
lea    -0x10(%rbp),%rsi
mov    $0x0,%al
call   10b0 <new_board@plt>
movl   $0x0,-0x1c(%rbp)
movb   $0x66,-0x21(%rbp)
mov    -0x1c(%rbp),%ecx
mov    -0x8(%rbp),%edx
imul   -0x8(%rbp),%edx
xor    %eax,%eax
cmp    %edx,%ecx
mov    %al,-0x61(%rbp)
jge    144b <main+0x29b>
movsbl -0x21(%rbp),%eax
cmp    $0x66,%eax
sete   %al
mov    %al,-0x61(%rbp)
mov    -0x61(%rbp),%al
test   $0x1,%al
jne    145b <main+0x2ab>
jmp    14b5 <main+0x305>
mov    -0x40(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x5f,%eax
jne    14a7 <main+0x2f7>
mov    -0x8(%rbp),%edi
mov    -0x1c(%rbp),%esi
mov    -0x40(%rbp),%rdx
mov    -0x30(%rbp),%r9
lea    -0x10(%rbp),%rcx
lea    -0xc(%rbp),%r8
mov    $0x0,%al
call   1080 <backtrack@plt>
mov    -0x8(%rbp),%edi
mov    -0x1c(%rbp),%esi
mov    -0x40(%rbp),%rdx
mov    $0x0,%al
call   1070 <place_piece@plt>
movb   $0x74,-0x21(%rbp)
jmp    14b0 <main+0x300>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1427 <main+0x277>
jmp    1307 <main+0x157>
mov    -0x20(%rbp),%esi
lea    0xb43(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
mov    -0x4(%rbp),%eax
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
lea    0xe5b(%rip),%rdi
xor    %ebx,%ebx
xor    %eax,%eax
call   1050 <printf@plt>
movl   $0x64,0xc(%rsp)
movl   $0x0,(%rsp)
mov    $0x320,%edi
call   10a0 <malloc@plt>
mov    %rax,%r14
nopw   0x0(%rax,%rax,1)
mov    $0x64,%edi
call   10a0 <malloc@plt>
mov    %rax,(%r14,%rbx,8)
add    $0x1,%rbx
cmp    $0x64,%rbx
jne    11e0 <main+0x40>
mov    $0x64,%edi
call   10a0 <malloc@plt>
mov    %rax,%rbx
movaps 0xdf4(%rip),%xmm0
movups %xmm0,(%rax)
movups %xmm0,0x10(%rax)
movups %xmm0,0x20(%rax)
movups %xmm0,0x30(%rax)
movups %xmm0,0x40(%rax)
movups %xmm0,0x50(%rax)
movl   $0x5f5f5f5f,0x60(%rax)
mov    $0x50,%edi
call   10a0 <malloc@plt>
mov    %rax,%r15
mov    $0x64,%edi
call   10a0 <malloc@plt>
mov    %rax,(%r15)
mov    $0x64,%edi
call   10a0 <malloc@plt>
mov    %rax,0x8(%r15)
mov    $0x64,%edi
call   10a0 <malloc@plt>
mov    %rax,0x10(%r15)
mov    $0x64,%edi
call   10a0 <malloc@plt>
mov    %rax,0x18(%r15)
mov    $0x64,%edi
call   10a0 <malloc@plt>
mov    %rax,0x20(%r15)
mov    $0x64,%edi
call   10a0 <malloc@plt>
mov    %rax,0x28(%r15)
mov    $0x64,%edi
call   10a0 <malloc@plt>
mov    %rax,0x30(%r15)
mov    $0x64,%edi
call   10a0 <malloc@plt>
mov    %rax,0x38(%r15)
mov    $0x64,%edi
call   10a0 <malloc@plt>
mov    %rax,0x40(%r15)
mov    $0x64,%edi
call   10a0 <malloc@plt>
mov    %rax,0x48(%r15)
movl   $0xa,0x8(%rsp)
xor    %r13d,%r13d
xor    %ebp,%ebp
mov    %r14,0x10(%rsp)
jmp    1319 <main+0x179>
cs nopw 0x0(%rax,%rax,1)
mov    $0xa,%edi
mov    %r12d,%esi
mov    %rbx,%rdx
mov    %rsp,%rcx
lea    0xc(%rsp),%r8
mov    %r14,%r9
xor    %eax,%eax
call   1080 <backtrack@plt>
mov    $0xa,%edi
mov    %r12d,%esi
mov    %rbx,%rdx
xor    %eax,%eax
call   1070 <place_piece@plt>
cmpl   $0x0,(%rsp)
js     1416 <main+0x276>
mov    $0xa,%edi
mov    %rbx,%rsi
xor    %eax,%eax
call   1040 <remaining_moves@plt>
test   %eax,%eax
jne    13e6 <main+0x246>
mov    $0xa,%edi
mov    %rbx,%rsi
mov    %r13d,%edx
mov    %r15,%rcx
xor    %eax,%eax
call   1060 <validate_board@plt>
cmp    $0x1,%eax
jne    13d1 <main+0x231>
mov    0x8(%rsp),%eax
cmp    %eax,%r13d
jge    135c <main+0x1bc>
mov    %eax,%r12d
jmp    13b0 <main+0x210>
mov    %ebp,0x4(%rsp)
mov    %eax,%r12d
shr    $0x1f,%r12d
add    %eax,%r12d
sar    %r12d
add    %eax,%r12d
movslq %r12d,%rbp
lea    0x0(,%rbp,8),%rsi
mov    %r15,%rdi
call   10c0 <realloc@plt>
mov    %rax,%r15
cmp    %ebp,%r13d
jge    13ac <main+0x20c>
movslq %r13d,%r14
xchg   %ax,%ax
mov    $0x64,%edi
call   10a0 <malloc@plt>
mov    %rax,(%r15,%r14,8)
add    $0x1,%r14
cmp    %r14,%rbp
jne    1390 <main+0x1f0>
mov    0x10(%rsp),%r14
mov    0x4(%rsp),%ebp
add    $0x1,%ebp
mov    $0xa,%edi
mov    %rbx,%rsi
mov    %r13d,%edx
mov    %r15,%rcx
xor    %eax,%eax
call   1090 <new_solution@plt>
add    $0x1,%r13d
mov    %r12d,0x8(%rsp)
mov    $0xa,%edi
mov    %rsp,%rsi
mov    %rbx,%rdx
mov    %r14,%rcx
xor    %eax,%eax
call   10b0 <new_board@plt>
xor    %r12d,%r12d
nopl   0x0(%rax)
movzbl (%rbx,%r12,1),%eax
cmp    $0x5f,%al
je     12e0 <main+0x140>
je     130f <main+0x16f>
lea    0x1(%r12),%rax
cmp    $0x62,%r12d
mov    %rax,%r12
jbe    13f0 <main+0x250>
jmp    130f <main+0x16f>
lea    0xbfa(%rip),%rdi
mov    %ebp,%esi
xor    %eax,%eax
call   1050 <printf@plt>
mov    %r14,%rdi
call   1030 <free@plt>
mov    %r15,%rdi
call   1030 <free@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
xor    %eax,%eax
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@.str = [7 x i8] c"\1B[H\1B[J\00"
@.str.1 = [16 x i8] c"Solutions: %d\0A\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i32
%3 = tail call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([7 x i8], [7 x i8]* @.str, i64 0, i64 0))
%4 = bitcast i32* %1 to i8*
store i32 100, i32* %1
%5 = bitcast i32* %2 to i8*
store i32 0, i32* %2
%6 = tail call dereferenceable_or_null(800) i8* @malloc(i64 800)
%7 = bitcast i8* %6 to i8**
br label %8
8: ; preds = %0, %8
%9 = phi i64 [ 0, %0 ], [ %12, %8 ]
%10 = tail call dereferenceable_or_null(100) i8* @malloc(i64 100)
%11 = getelementptr inbounds i8*, i8** %7, i64 %9
store i8* %10, i8** %11
%12 = add nuw nsw i64 %9, 1
%13 = icmp eq i64 %12, 100
br i1 %13, label %14, label %8
14: ; preds = %8
%15 = tail call dereferenceable_or_null(100) i8* @malloc(i64 100)
%16 = tail call dereferenceable_or_null(80) i8* @malloc(i64 80)
%17 = bitcast i8* %16 to i8**
%18 = tail call dereferenceable_or_null(100) i8* @malloc(i64 100)
store i8* %18, i8** %17
%19 = tail call dereferenceable_or_null(100) i8* @malloc(i64 100)
%20 = getelementptr inbounds i8*, i8** %17, i64 1
store i8* %19, i8** %20
%21 = tail call dereferenceable_or_null(100) i8* @malloc(i64 100)
%22 = getelementptr inbounds i8*, i8** %17, i64 2
store i8* %21, i8** %22
%23 = tail call dereferenceable_or_null(100) i8* @malloc(i64 100)
%24 = getelementptr inbounds i8*, i8** %17, i64 3
store i8* %23, i8** %24
%25 = tail call dereferenceable_or_null(100) i8* @malloc(i64 100)
%26 = getelementptr inbounds i8*, i8** %17, i64 4
store i8* %25, i8** %26
%27 = tail call dereferenceable_or_null(100) i8* @malloc(i64 100)
%28 = getelementptr inbounds i8*, i8** %17, i64 5
store i8* %27, i8** %28
%29 = tail call dereferenceable_or_null(100) i8* @malloc(i64 100)
%30 = getelementptr inbounds i8*, i8** %17, i64 6
store i8* %29, i8** %30
%31 = tail call dereferenceable_or_null(100) i8* @malloc(i64 100)
%32 = getelementptr inbounds i8*, i8** %17, i64 7
store i8* %31, i8** %32
%33 = tail call dereferenceable_or_null(100) i8* @malloc(i64 100)
%34 = getelementptr inbounds i8*, i8** %17, i64 8
store i8* %33, i8** %34
%35 = tail call dereferenceable_or_null(100) i8* @malloc(i64 100)
%36 = getelementptr inbounds i8*, i8** %17, i64 9
store i8* %35, i8** %36
br label %40
37: ; preds = %95, %92
%38 = load i32, i32* %2
%39 = icmp sgt i32 %38, -1
br i1 %39, label %40, label %99
40: ; preds = %14, %37
%41 = phi i8** [ %85, %37 ], [ %17, %14 ]
%42 = phi i32 [ %84, %37 ], [ 10, %14 ]
%43 = phi i32 [ %83, %37 ], [ 0, %14 ]
%44 = phi i32 [ %82, %37 ], [ 0, %14 ]
%45 = call i32 (i32, i8*, ...) bitcast (i32 (...)* @remaining_moves to i32 (i32, i8*, ...)*)(i32 10, i8* %15)
%46 = icmp eq i32 %45, 0
br i1 %46, label %47, label %81
47: ; preds = %40
%48 = call i32 (i32, i8*, i32, i8**, ...) bitcast (i32 (...)* @validate_board to i32 (i32, i8*, i32, i8**, ...)*)(i32 10, i8* %15, i32 %43, i8** %41)
%49 = icmp eq i32 %48, 1
br i1 %49, label %50, label %75
50: ; preds = %47
%51 = add nsw i32 %44, 1
%52 = icmp slt i32 %43, %42
br i1 %52, label %70, label %53
53: ; preds = %50
%54 = sdiv i32 %42, 2
%55 = add i32 %42, %54
%56 = bitcast i8** %41 to i8*
%57 = sext i32 %55 to i64
%58 = shl nsw i64 %57, 3
%59 = call i8* @realloc(i8* %56, i64 %58)
%60 = bitcast i8* %59 to i8**
%61 = icmp slt i32 %43, %55
br i1 %61, label %62, label %70
62: ; preds = %53
%63 = sext i32 %43 to i64
br label %64
64: ; preds = %62, %64
%65 = phi i64 [ %63, %62 ], [ %68, %64 ]
%66 = call dereferenceable_or_null(100) i8* @malloc(i64 100)
%67 = getelementptr inbounds i8*, i8** %60, i64 %65
store i8* %66, i8** %67
%68 = add nsw i64 %65, 1
%69 = icmp eq i64 %68, %57
br i1 %69, label %70, label %64
70: ; preds = %64, %53, %50
%71 = phi i32 [ %42, %50 ], [ %55, %53 ], [ %55, %64 ]
%72 = phi i8** [ %41, %50 ], [ %60, %53 ], [ %60, %64 ]
%73 = call i32 (i32, i8*, i32, i8**, ...) bitcast (i32 (...)* @new_solution to i32 (i32, i8*, i32, i8**, ...)*)(i32 10, i8* %15, i32 %43, i8** %72)
%74 = add nsw i32 %43, 1
br label %75
75: ; preds = %70, %47
%76 = phi i32 [ %51, %70 ], [ %44, %47 ]
%77 = phi i32 [ %74, %70 ], [ %43, %47 ]
%78 = phi i32 [ %71, %70 ], [ %42, %47 ]
%79 = phi i8** [ %72, %70 ], [ %41, %47 ]
%80 = call i32 (i32, i32*, i8*, i8**, ...) bitcast (i32 (...)* @new_board to i32 (i32, i32*, i8*, i8**, ...)*)(i32 10, i32* %2, i8* %15, i8** %7)
br label %81
81: ; preds = %75, %40
%82 = phi i32 [ %76, %75 ], [ %44, %40 ]
%83 = phi i32 [ %77, %75 ], [ %43, %40 ]
%84 = phi i32 [ %78, %75 ], [ %42, %40 ]
%85 = phi i8** [ %79, %75 ], [ %41, %40 ]
br label %86
86: ; preds = %81, %95
%87 = phi i32 [ 0, %81 ], [ %96, %95 ]
%88 = zext i32 %87 to i64
%89 = getelementptr inbounds i8, i8* %15, i64 %88
%90 = load i8, i8* %89
%91 = icmp eq i8 %90, 95
br i1 %91, label %92, label %95
92: ; preds = %86
%93 = call i32 (i32, i32, i8*, i32*, i32*, i8**, ...) bitcast (i32 (...)* @backtrack to i32 (i32, i32, i8*, i32*, i32*, i8**, ...)*)(i32 10, i32 %87, i8* %15, i32* %2, i32* %1, i8** %7)
%94 = call i32 (i32, i32, i8*, ...) bitcast (i32 (...)* @place_piece to i32 (i32, i32, i8*, ...)*)(i32 10, i32 %87, i8* %15)
br label %37
95: ; preds = %86
%96 = add nuw nsw i32 %87, 1
%97 = icmp ugt i32 %87, 98
%98 = or i1 %91, %97
br i1 %98, label %37, label %86
99: ; preds = %37
%100 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([16 x i8], [16 x i8]* @.str.1, i64 0, i64 0), i32 %82)
%101 = bitcast i8** %85 to i8*
ret i32 0
}