int main() {
  system("clear");
  system("reset");
  int n = 10;
  int s_max = n;
  int s_top = 0;
  int sols = 0;
  char **istack = (char **)malloc(n * n * sizeof(char *));
  for (int i = 0; i < n * n; i++) {
    istack[i] = (char *)malloc((n * n) * sizeof(char));
  }
  char **solutions = (char **)malloc(n * sizeof(char *));
  for (int i = 0; i < n; i++) {
    solutions[i] = (char *)malloc((n * n) * sizeof(char));
  }
#pragma omp parallel for
  for (int o = 0; o < n * n; o++) {
    for (int i = 0; i < n * n; i++) {
      if (i < o) {
        istack[o][i] = '*';
      } else {
        istack[o][i] = '_';
      }
    }
  }
#pragma omp parallel shared(n, s_top, s_max, sols, solutions)
  {
#pragma omp for
    for (int init = 0; init < n * n; init++) {
#pragma omp task
      {
        int tid = omp_get_thread_num();
        int top = 0;
        int max = n * n;
        int index = 0;
        int c = 0;
        int matches = 0;
        char match_found = 'f';
        char successful_move = 'f';
        char *board = (char *)malloc((n * n) * sizeof(char));
        new_board(n, init, board, istack);
        char **stack = (char **)malloc(n * n * sizeof(char *));
        for (int i = 0; i < n * n; i++) {
          stack[i] = (char *)malloc((n * n) * sizeof(char));
        }
        while (top >= 0) {
          if (remaining_moves(n, board) > 0) {
            index = 0;
            successful_move = 'f';
            while (index < n * n && successful_move == 'f') {
              if (board[index] == '_') {
                validate_stack_size(n, top, &max, stack);
                backtrack(n, index, board, &top, stack);
                place_piece(n, index, board);
                successful_move = 't';
              } else {
                index += 1;
              }
            }
          } else {
#pragma omp critical
            {
              if (validate_board(n, board) == 1) {
                if (s_top == 0) {
                  for (int i = 0; i < n * n; i++) {
                    solutions[s_top][i] = board[i];
                  }
                  s_top += 1;
                  sols += 1;
                } else {
                  match_found = 'f';
                  for (int s = 0; s < s_top; s++) {
                    if (match_found == 'f') {
                      matches = 0;
                      for (int c = 0; c < n * n; c++) {
                        if (solutions[s][c] == board[c]) {
                          matches += 1;
                        }
                      }
                      if (matches == n * n) {
                        match_found = 't';
                      }
                    }
                  }
                  if (match_found == 'f') {
                    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));
                      }
                    }
                    for (int i = 0; i < n * n; i++) {
                      solutions[s_top][i] = board[i];
                    }
                    s_top += 1;
                    sols += validate_board(n, board);
                  }
                }
              }
            }
            top -= 1;
            if (top >= 0) {
              new_board(n, top, board, stack);
            }
          }
        }
        free(stack);
        free(board);
      }
    }
  }
  printf("Solutions: %d\n\n", sols);
  free(istack);
  free(solutions);
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0xa0,%rsp
movl   $0x0,-0x4(%rbp)
lea    0xe17(%rip),%rdi
mov    $0x0,%al
call   1060 <system@plt>
lea    0xe0f(%rip),%rdi
mov    $0x0,%al
call   1060 <system@plt>
movl   $0xa,-0x8(%rbp)
mov    -0x8(%rbp),%eax
mov    %eax,-0xc(%rbp)
movl   $0x0,-0x10(%rbp)
movl   $0x0,-0x14(%rbp)
mov    -0x8(%rbp),%eax
imul   -0x8(%rbp),%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   10b0 <malloc@plt>
mov    %rax,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    -0x8(%rbp),%ecx
imul   -0x8(%rbp),%ecx
cmp    %ecx,%eax
jge    1279 <main+0xa9>
mov    -0x8(%rbp),%eax
imul   -0x8(%rbp),%eax
movslq %eax,%rdi
shl    $0x0,%rdi
call   10b0 <malloc@plt>
mov    %rax,%rdx
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1237 <main+0x67>
movslq -0x8(%rbp),%rdi
shl    $0x3,%rdi
call   10b0 <malloc@plt>
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    12cd <main+0xfd>
mov    -0x8(%rbp),%eax
imul   -0x8(%rbp),%eax
movslq %eax,%rdi
shl    $0x0,%rdi
call   10b0 <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    1291 <main+0xc1>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    -0x8(%rbp),%ecx
imul   -0x8(%rbp),%ecx
cmp    %ecx,%eax
jge    135e <main+0x18e>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x8(%rbp),%ecx
imul   -0x8(%rbp),%ecx
cmp    %ecx,%eax
jge    134b <main+0x17b>
mov    -0x3c(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    1324 <main+0x154>
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movb   $0x2a,(%rax,%rcx,1)
jmp    1338 <main+0x168>
mov    -0x20(%rbp),%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movb   $0x5f,(%rax,%rcx,1)
jmp    133d <main+0x16d>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    12ed <main+0x11d>
jmp    1350 <main+0x180>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    12d4 <main+0x104>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
mov    -0x8(%rbp),%ecx
imul   -0x8(%rbp),%ecx
cmp    %ecx,%eax
jge    17d7 <main+0x607>
mov    $0x0,%al
call   1040 <omp_get_thread_num@plt>
mov    %eax,-0x44(%rbp)
movl   $0x0,-0x48(%rbp)
mov    -0x8(%rbp),%eax
imul   -0x8(%rbp),%eax
mov    %eax,-0x4c(%rbp)
movl   $0x0,-0x50(%rbp)
movl   $0x0,-0x54(%rbp)
movl   $0x0,-0x58(%rbp)
movb   $0x66,-0x59(%rbp)
movb   $0x66,-0x5a(%rbp)
mov    -0x8(%rbp),%eax
imul   -0x8(%rbp),%eax
movslq %eax,%rdi
shl    $0x0,%rdi
call   10b0 <malloc@plt>
mov    %rax,-0x68(%rbp)
mov    -0x8(%rbp),%edi
mov    -0x40(%rbp),%esi
mov    -0x68(%rbp),%rdx
mov    -0x20(%rbp),%rcx
mov    $0x0,%al
call   10d0 <new_board@plt>
mov    -0x8(%rbp),%eax
imul   -0x8(%rbp),%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   10b0 <malloc@plt>
mov    %rax,-0x70(%rbp)
movl   $0x0,-0x74(%rbp)
mov    -0x74(%rbp),%eax
mov    -0x8(%rbp),%ecx
imul   -0x8(%rbp),%ecx
cmp    %ecx,%eax
jge    143b <main+0x26b>
mov    -0x8(%rbp),%eax
imul   -0x8(%rbp),%eax
movslq %eax,%rdi
shl    $0x0,%rdi
call   10b0 <malloc@plt>
mov    %rax,%rdx
mov    -0x70(%rbp),%rax
movslq -0x74(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    13f9 <main+0x229>
jmp    1440 <main+0x270>
cmpl   $0x0,-0x48(%rbp)
jl     17b7 <main+0x5e7>
mov    -0x8(%rbp),%edi
mov    -0x68(%rbp),%rsi
mov    $0x0,%al
call   1050 <remaining_moves@plt>
cmp    $0x0,%eax
jle    1519 <main+0x349>
movl   $0x0,-0x50(%rbp)
movb   $0x66,-0x5a(%rbp)
mov    -0x50(%rbp),%ecx
mov    -0x8(%rbp),%edx
imul   -0x8(%rbp),%edx
xor    %eax,%eax
cmp    %edx,%ecx
mov    %al,-0x89(%rbp)
jge    1496 <main+0x2c6>
movsbl -0x5a(%rbp),%eax
cmp    $0x66,%eax
sete   %al
mov    %al,-0x89(%rbp)
mov    -0x89(%rbp),%al
test   $0x1,%al
jne    14a9 <main+0x2d9>
jmp    1514 <main+0x344>
mov    -0x68(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x5f,%eax
jne    1506 <main+0x336>
mov    -0x8(%rbp),%edi
mov    -0x48(%rbp),%esi
mov    -0x70(%rbp),%rcx
lea    -0x4c(%rbp),%rdx
mov    $0x0,%al
call   10c0 <validate_stack_size@plt>
mov    -0x8(%rbp),%edi
mov    -0x50(%rbp),%esi
mov    -0x68(%rbp),%rdx
mov    -0x70(%rbp),%r8
lea    -0x48(%rbp),%rcx
mov    $0x0,%al
call   10a0 <backtrack@plt>
mov    -0x8(%rbp),%edi
mov    -0x50(%rbp),%esi
mov    -0x68(%rbp),%rdx
mov    $0x0,%al
call   1090 <place_piece@plt>
movb   $0x74,-0x5a(%rbp)
jmp    150f <main+0x33f>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    146c <main+0x29c>
jmp    17b2 <main+0x5e2>
mov    -0x8(%rbp),%edi
mov    -0x68(%rbp),%rsi
mov    $0x0,%al
call   1080 <validate_board@plt>
cmp    $0x1,%eax
jne    1785 <main+0x5b5>
cmpl   $0x0,-0x10(%rbp)
jne    1596 <main+0x3c6>
movl   $0x0,-0x78(%rbp)
mov    -0x78(%rbp),%eax
mov    -0x8(%rbp),%ecx
imul   -0x8(%rbp),%ecx
cmp    %ecx,%eax
jge    157f <main+0x3af>
mov    -0x68(%rbp),%rax
movslq -0x78(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x30(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x78(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    1541 <main+0x371>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1780 <main+0x5b0>
movb   $0x66,-0x59(%rbp)
movl   $0x0,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    164c <main+0x47c>
movsbl -0x59(%rbp),%eax
cmp    $0x66,%eax
jne    1639 <main+0x469>
movl   $0x0,-0x58(%rbp)
movl   $0x0,-0x80(%rbp)
mov    -0x80(%rbp),%eax
mov    -0x8(%rbp),%ecx
imul   -0x8(%rbp),%ecx
cmp    %ecx,%eax
jge    161e <main+0x44e>
mov    -0x30(%rbp),%rax
movslq -0x7c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x80(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    -0x68(%rbp),%rcx
movslq -0x80(%rbp),%rdx
movsbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jne    160b <main+0x43b>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1610 <main+0x440>
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
jmp    15c8 <main+0x3f8>
mov    -0x58(%rbp),%eax
mov    -0x8(%rbp),%ecx
imul   -0x8(%rbp),%ecx
cmp    %ecx,%eax
jne    1634 <main+0x464>
movb   $0x74,-0x59(%rbp)
jmp    1639 <main+0x469>
jmp    163e <main+0x46e>
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    15a1 <main+0x3d1>
movsbl -0x59(%rbp),%eax
cmp    $0x66,%eax
jne    177b <main+0x5ab>
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jl     1707 <main+0x537>
cvtsi2sdl -0xc(%rbp),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
mov    -0xc(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cvtsi2sd %eax,%xmm0
call   10f0 <floor@plt>
movaps %xmm0,%xmm1
movsd  -0x98(%rbp),%xmm0
ff
addsd  %xmm1,%xmm0
cvttsd2si %xmm0,%eax
mov    %eax,-0xc(%rbp)
mov    -0x30(%rbp),%rdi
movslq -0xc(%rbp),%rsi
shl    $0x3,%rsi
call   10e0 <realloc@plt>
mov    %rax,-0x30(%rbp)
mov    -0x10(%rbp),%eax
mov    %eax,-0x84(%rbp)
mov    -0x84(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1702 <main+0x532>
mov    -0x8(%rbp),%eax
imul   -0x8(%rbp),%eax
movslq %eax,%rdi
shl    $0x0,%rdi
call   10b0 <malloc@plt>
mov    %rax,%rdx
mov    -0x30(%rbp),%rax
movslq -0x84(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    16ba <main+0x4ea>
jmp    1707 <main+0x537>
movl   $0x0,-0x88(%rbp)
mov    -0x88(%rbp),%eax
mov    -0x8(%rbp),%ecx
imul   -0x8(%rbp),%ecx
cmp    %ecx,%eax
jge    175e <main+0x58e>
mov    -0x68(%rbp),%rax
movslq -0x88(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x30(%rbp),%rax
movslq -0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x88(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    1711 <main+0x541>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%edi
mov    -0x68(%rbp),%rsi
mov    $0x0,%al
call   1080 <validate_board@plt>
add    -0x14(%rbp),%eax
mov    %eax,-0x14(%rbp)
jmp    1780 <main+0x5b0>
jmp    1785 <main+0x5b5>
mov    -0x48(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x48(%rbp)
cmpl   $0x0,-0x48(%rbp)
jl     17ad <main+0x5dd>
mov    -0x8(%rbp),%edi
mov    -0x48(%rbp),%esi
mov    -0x68(%rbp),%rdx
mov    -0x70(%rbp),%rcx
mov    $0x0,%al
call   10d0 <new_board@plt>
jmp    17b2 <main+0x5e2>
jmp    1440 <main+0x270>
mov    -0x70(%rbp),%rdi
call   1030 <free@plt>
mov    -0x68(%rbp),%rdi
call   1030 <free@plt>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1365 <main+0x195>
mov    -0x14(%rbp),%esi
lea    0x82b(%rip),%rdi
mov    $0x0,%al
call   1070 <printf@plt>
mov    -0x20(%rbp),%rdi
call   1030 <free@plt>
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
mov    -0x4(%rbp),%eax
add    $0xa0,%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    0xe3b(%rip),%rdi
xor    %ebx,%ebx
xor    %eax,%eax
call   1060 <system@plt>
lea    0xe31(%rip),%rdi
xor    %eax,%eax
call   1060 <system@plt>
mov    $0x320,%edi
call   10b0 <malloc@plt>
mov    %rax,%r14
nopl   0x0(%rax)
mov    $0x64,%edi
call   10b0 <malloc@plt>
mov    %rax,(%r14,%rbx,8)
add    $0x1,%rbx
cmp    $0x64,%rbx
jne    1200 <main+0x40>
mov    $0x50,%edi
call   10b0 <malloc@plt>
mov    %rax,%rbx
mov    $0x64,%edi
call   10b0 <malloc@plt>
mov    %rax,(%rbx)
mov    $0x64,%edi
call   10b0 <malloc@plt>
mov    %rax,0x8(%rbx)
mov    $0x64,%edi
call   10b0 <malloc@plt>
mov    %rax,0x10(%rbx)
mov    $0x64,%edi
call   10b0 <malloc@plt>
mov    %rax,0x18(%rbx)
mov    $0x64,%edi
call   10b0 <malloc@plt>
mov    %rax,0x20(%rbx)
mov    $0x64,%edi
call   10b0 <malloc@plt>
mov    %rax,0x28(%rbx)
mov    $0x64,%edi
call   10b0 <malloc@plt>
mov    %rax,0x30(%rbx)
mov    $0x64,%edi
call   10b0 <malloc@plt>
mov    %rax,0x38(%rbx)
mov    $0x64,%edi
call   10b0 <malloc@plt>
mov    %rax,0x40(%rbx)
mov    $0x64,%edi
call   10b0 <malloc@plt>
mov    %rax,0x48(%rbx)
xor    %eax,%eax
mov    $0x2a,%ecx
nopw   0x0(%rax,%rax,1)
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmp    %rax,%rdx
mov    (%r14,%rax,8),%rsi
mov    $0x5f,%edi
cmovb  %ecx,%edi
mov    %dil,(%rsi,%rdx,1)
lea    0x1(%rdx),%rsi
cmp    %rax,%rsi
mov    (%r14,%rax,8),%rsi
mov    $0x5f,%edi
cmovb  %ecx,%edi
mov    %dil,0x1(%rsi,%rdx,1)
lea    0x2(%rdx),%rsi
cmp    %rax,%rsi
mov    (%r14,%rax,8),%rsi
mov    $0x5f,%edi
cmovb  %ecx,%edi
mov    %dil,0x2(%rsi,%rdx,1)
lea    0x3(%rdx),%rsi
cmp    %rax,%rsi
mov    $0x5f,%esi
cmovb  %ecx,%esi
mov    (%r14,%rax,8),%rdi
mov    %sil,0x3(%rdi,%rdx,1)
add    $0x4,%rdx
cmp    $0x64,%rdx
jne    12d0 <main+0x110>
add    $0x1,%rax
cmp    $0x64,%rax
jne    12c0 <main+0x100>
movl   $0xa,0x8(%rsp)
movl   $0x0,(%rsp)
movl   $0x0,0xc(%rsp)
xor    %ebp,%ebp
jmp    1380 <main+0x1c0>
nopw   0x0(%rax,%rax,1)
mov    %r12,%rdi
call   1030 <free@plt>
mov    %r15,%rdi
call   1030 <free@plt>
mov    0x14(%rsp),%ebp
add    $0x1,%ebp
cmp    $0x64,%ebp
je     1714 <main+0x554>
xor    %eax,%eax
call   1040 <omp_get_thread_num@plt>
movl   $0x0,0x4(%rsp)
movl   $0x64,0x10(%rsp)
mov    $0x64,%edi
call   10b0 <malloc@plt>
mov    %rax,%r15
mov    $0xa,%edi
mov    %ebp,0x14(%rsp)
mov    %ebp,%esi
mov    %rax,%rdx
mov    %r14,%rcx
xor    %eax,%eax
call   10d0 <new_board@plt>
mov    $0x320,%edi
call   10b0 <malloc@plt>
mov    %rax,%r12
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
mov    $0x64,%edi
call   10b0 <malloc@plt>
mov    %rax,(%r12,%rbp,8)
add    $0x1,%rbp
cmp    $0x64,%rbp
jne    13d0 <main+0x210>
cmpl   $0x0,0x4(%rsp)
lea    0x10(%rsp),%rbp
jns    144d <main+0x28d>
jmp    1360 <main+0x1a0>
nopl   0x0(%rax)
mov    0x4(%rsp),%esi
mov    $0xa,%edi
mov    %rbp,%rdx
mov    %r12,%rcx
xor    %eax,%eax
call   10c0 <validate_stack_size@plt>
mov    $0xa,%edi
mov    %r13d,%esi
mov    %r15,%rdx
lea    0x4(%rsp),%rcx
mov    %r12,%r8
xor    %eax,%eax
call   10a0 <backtrack@plt>
mov    $0xa,%edi
mov    %r13d,%esi
mov    %r15,%rdx
xor    %eax,%eax
call   1090 <place_piece@plt>
cmpl   $0x0,0x4(%rsp)
js     1360 <main+0x1a0>
mov    $0xa,%edi
mov    %r15,%rsi
xor    %eax,%eax
call   1050 <remaining_moves@plt>
test   %eax,%eax
jle    1490 <main+0x2d0>
xor    %r13d,%r13d
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movzbl (%r15,%r13,1),%eax
cmp    $0x5f,%al
je     1400 <main+0x240>
je     1442 <main+0x282>
lea    0x1(%r13),%rax
cmp    $0x62,%r13d
mov    %rax,%r13
jbe    1470 <main+0x2b0>
jmp    1442 <main+0x282>
nopw   0x0(%rax,%rax,1)
mov    $0xa,%edi
mov    %r15,%rsi
xor    %eax,%eax
call   1080 <validate_board@plt>
cmp    $0x1,%eax
jne    16ea <main+0x52a>
mov    (%rsp),%eax
test   %eax,%eax
movdqa 0xb4b(%rip),%xmm4
mov    $0x74,%edi
je     15bd <main+0x3fd>
jle    15ad <main+0x3ed>
mov    %eax,%eax
mov    $0x66,%dl
xor    %ecx,%ecx
jmp    14fe <main+0x33e>
xchg   %ax,%ax
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%edx
cmp    $0x64,%edx
mov    $0x66,%edx
cmove  %edi,%edx
add    $0x1,%rcx
cmp    %rax,%rcx
je     15a1 <main+0x3e1>
cmp    $0x66,%dl
jne    14f1 <main+0x331>
mov    (%rbx,%rcx,8),%rdx
pxor   %xmm1,%xmm1
mov    $0xc,%esi
movd   -0xc(%rdx,%rsi,1),%xmm2
movd   -0xc(%r15,%rsi,1),%xmm0
pcmpeqb %xmm2,%xmm0
punpcklbw %xmm0,%xmm0
punpcklwd %xmm0,%xmm0
pand   %xmm4,%xmm0
paddd  %xmm1,%xmm0
cmp    $0x6c,%rsi
je     14d0 <main+0x310>
movd   -0x8(%rdx,%rsi,1),%xmm1
movd   -0x8(%r15,%rsi,1),%xmm2
pcmpeqb %xmm1,%xmm2
punpcklbw %xmm2,%xmm2
punpcklwd %xmm2,%xmm2
pand   %xmm4,%xmm2
paddd  %xmm2,%xmm0
movd   -0x4(%rdx,%rsi,1),%xmm1
movd   -0x4(%r15,%rsi,1),%xmm2
pcmpeqb %xmm1,%xmm2
punpcklbw %xmm2,%xmm2
punpcklwd %xmm2,%xmm2
pand   %xmm4,%xmm2
movd   (%rdx,%rsi,1),%xmm3
movd   (%r15,%rsi,1),%xmm1
pcmpeqb %xmm3,%xmm1
punpcklbw %xmm1,%xmm1
punpcklwd %xmm1,%xmm1
pand   %xmm4,%xmm1
paddd  %xmm2,%xmm1
paddd  %xmm0,%xmm1
add    $0x10,%rsi
jmp    1510 <main+0x350>
cmp    $0x66,%dl
mov    (%rsp),%eax
jne    16ea <main+0x52a>
mov    0x8(%rsp),%ecx
cmp    %ecx,%eax
jge    161a <main+0x45a>
mov    %ecx,%r13d
jmp    167b <main+0x4bb>
xor    %eax,%eax
nop
movzbl (%r15,%rax,1),%ecx
mov    (%rbx),%rdx
mov    %cl,(%rdx,%rax,1)
movzbl 0x1(%r15,%rax,1),%ecx
mov    (%rbx),%rdx
mov    %cl,0x1(%rdx,%rax,1)
movzbl 0x2(%r15,%rax,1),%ecx
mov    (%rbx),%rdx
mov    %cl,0x2(%rdx,%rax,1)
movzbl 0x3(%r15,%rax,1),%ecx
mov    (%rbx),%rdx
mov    %cl,0x3(%rdx,%rax,1)
movzbl 0x4(%r15,%rax,1),%ecx
mov    (%rbx),%rdx
mov    %cl,0x4(%rdx,%rax,1)
add    $0x5,%rax
cmp    $0x64,%rax
jne    15c0 <main+0x400>
addl   $0x1,0xc(%rsp)
movl   $0x1,(%rsp)
jmp    16ea <main+0x52a>
mov    %ecx,%r13d
shr    $0x1f,%r13d
add    %ecx,%r13d
sar    %r13d
add    %ecx,%r13d
movslq %r13d,%rbp
lea    0x0(,%rbp,8),%rsi
mov    %rbx,%rdi
call   10e0 <realloc@plt>
mov    %rax,%rbx
mov    (%rsp),%eax
cmp    %ebp,%eax
jge    1676 <main+0x4b6>
mov    %r13d,0x8(%rsp)
movslq %eax,%r13
nop
mov    $0x64,%edi
call   10b0 <malloc@plt>
mov    %rax,(%rbx,%r13,8)
add    $0x1,%r13
cmp    %r13,%rbp
jne    1650 <main+0x490>
lea    0x10(%rsp),%rbp
mov    (%rsp),%eax
mov    0x8(%rsp),%r13d
jmp    167b <main+0x4bb>
lea    0x10(%rsp),%rbp
cltq
xor    %ecx,%ecx
nop
movzbl (%r15,%rcx,1),%edx
mov    (%rbx,%rax,8),%rsi
mov    %dl,(%rsi,%rcx,1)
movzbl 0x1(%r15,%rcx,1),%edx
mov    (%rbx,%rax,8),%rsi
mov    %dl,0x1(%rsi,%rcx,1)
movzbl 0x2(%r15,%rcx,1),%edx
mov    (%rbx,%rax,8),%rsi
mov    %dl,0x2(%rsi,%rcx,1)
movzbl 0x3(%r15,%rcx,1),%edx
mov    (%rbx,%rax,8),%rsi
mov    %dl,0x3(%rsi,%rcx,1)
movzbl 0x4(%r15,%rcx,1),%edx
mov    (%rbx,%rax,8),%rsi
mov    %dl,0x4(%rsi,%rcx,1)
add    $0x5,%rcx
cmp    $0x64,%rcx
jne    1680 <main+0x4c0>
addl   $0x1,(%rsp)
mov    $0xa,%edi
mov    %r15,%rsi
xor    %eax,%eax
call   1080 <validate_board@plt>
add    %eax,0xc(%rsp)
mov    %r13d,0x8(%rsp)
mov    0x4(%rsp),%eax
lea    -0x1(%rax),%esi
mov    %esi,0x4(%rsp)
test   %eax,%eax
jle    1360 <main+0x1a0>
mov    $0xa,%edi
mov    %r15,%rdx
mov    %r12,%rcx
xor    %eax,%eax
call   10d0 <new_board@plt>
jmp    1442 <main+0x282>
lea    0x901(%rip),%rdi
mov    0xc(%rsp),%esi
xor    %eax,%eax
call   1070 <printf@plt>
mov    %r14,%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 = [6 x i8] c"clear\00"
@.str.1 = [6 x i8] c"reset\00"
@.str.2 = [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 i8**
%7 = alloca i32
%8 = alloca i8**
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i8
%20 = alloca i8
%21 = alloca i8*
%22 = alloca i8**
%23 = alloca i32
%24 = alloca i32
%25 = alloca i32
%26 = alloca i32
%27 = alloca i32
%28 = alloca i32
store i32 0, i32* %1
%29 = call i32 (i8*, ...) bitcast (i32 (...)* @system to i32 (i8*, ...)*)(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0))
%30 = call i32 (i8*, ...) bitcast (i32 (...)* @system to i32 (i8*, ...)*)(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str.1, i64 0, i64 0))
store i32 10, i32* %2
%31 = load i32, i32* %2
store i32 %31, i32* %3
store i32 0, i32* %4
store i32 0, i32* %5
%32 = load i32, i32* %2
%33 = load i32, i32* %2
%34 = mul nsw i32 %32, %33
%35 = sext i32 %34 to i64
%36 = mul i64 %35, 8
%37 = call i8* @malloc(i64 %36)
%38 = bitcast i8* %37 to i8**
store i8** %38, i8*** %6
store i32 0, i32* %7
br label %39
39: ; preds = %56, %0
%40 = load i32, i32* %7
%41 = load i32, i32* %2
%42 = load i32, i32* %2
%43 = mul nsw i32 %41, %42
%44 = icmp slt i32 %40, %43
br i1 %44, label %45, label %59
45: ; preds = %39
%46 = load i32, i32* %2
%47 = load i32, i32* %2
%48 = mul nsw i32 %46, %47
%49 = sext i32 %48 to i64
%50 = mul i64 %49, 1
%51 = call i8* @malloc(i64 %50)
%52 = load i8**, i8*** %6
%53 = load i32, i32* %7
%54 = sext i32 %53 to i64
%55 = getelementptr inbounds i8*, i8** %52, i64 %54
store i8* %51, i8** %55
br label %56
56: ; preds = %45
%57 = load i32, i32* %7
%58 = add nsw i32 %57, 1
store i32 %58, i32* %7
br label %39
59: ; preds = %39
%60 = load i32, i32* %2
%61 = sext i32 %60 to i64
%62 = mul i64 %61, 8
%63 = call i8* @malloc(i64 %62)
%64 = bitcast i8* %63 to i8**
store i8** %64, i8*** %8
store i32 0, i32* %9
br label %65
65: ; preds = %80, %59
%66 = load i32, i32* %9
%67 = load i32, i32* %2
%68 = icmp slt i32 %66, %67
br i1 %68, label %69, label %83
69: ; preds = %65
%70 = load i32, i32* %2
%71 = load i32, i32* %2
%72 = mul nsw i32 %70, %71
%73 = sext i32 %72 to i64
%74 = mul i64 %73, 1
%75 = call i8* @malloc(i64 %74)
%76 = load i8**, i8*** %8
%77 = load i32, i32* %9
%78 = sext i32 %77 to i64
%79 = getelementptr inbounds i8*, i8** %76, i64 %78
store i8* %75, i8** %79
br label %80
80: ; preds = %69
%81 = load i32, i32* %9
%82 = add nsw i32 %81, 1
store i32 %82, i32* %9
br label %65
83: ; preds = %65
store i32 0, i32* %10
br label %84
84: ; preds = %124, %83
%85 = load i32, i32* %10
%86 = load i32, i32* %2
%87 = load i32, i32* %2
%88 = mul nsw i32 %86, %87
%89 = icmp slt i32 %85, %88
br i1 %89, label %90, label %127
90: ; preds = %84
store i32 0, i32* %11
br label %91
91: ; preds = %120, %90
%92 = load i32, i32* %11
%93 = load i32, i32* %2
%94 = load i32, i32* %2
%95 = mul nsw i32 %93, %94
%96 = icmp slt i32 %92, %95
br i1 %96, label %97, label %123
97: ; preds = %91
%98 = load i32, i32* %11
%99 = load i32, i32* %10
%100 = icmp slt i32 %98, %99
br i1 %100, label %101, label %110
101: ; preds = %97
%102 = load i8**, i8*** %6
%103 = load i32, i32* %10
%104 = sext i32 %103 to i64
%105 = getelementptr inbounds i8*, i8** %102, i64 %104
%106 = load i8*, i8** %105
%107 = load i32, i32* %11
%108 = sext i32 %107 to i64
%109 = getelementptr inbounds i8, i8* %106, i64 %108
store i8 42, i8* %109
br label %119
110: ; preds = %97
%111 = load i8**, i8*** %6
%112 = load i32, i32* %10
%113 = sext i32 %112 to i64
%114 = getelementptr inbounds i8*, i8** %111, i64 %113
%115 = load i8*, i8** %114
%116 = load i32, i32* %11
%117 = sext i32 %116 to i64
%118 = getelementptr inbounds i8, i8* %115, i64 %117
store i8 95, i8* %118
br label %119
119: ; preds = %110, %101
br label %120
120: ; preds = %119
%121 = load i32, i32* %11
%122 = add nsw i32 %121, 1
store i32 %122, i32* %11
br label %91
123: ; preds = %91
br label %124
124: ; preds = %123
%125 = load i32, i32* %10
%126 = add nsw i32 %125, 1
store i32 %126, i32* %10
br label %84
127: ; preds = %84
store i32 0, i32* %12
br label %128
128: ; preds = %411, %127
%129 = load i32, i32* %12
%130 = load i32, i32* %2
%131 = load i32, i32* %2
%132 = mul nsw i32 %130, %131
%133 = icmp slt i32 %129, %132
br i1 %133, label %134, label %414
134: ; preds = %128
%135 = call i32 (...) @omp_get_thread_num()
store i32 %135, i32* %13
store i32 0, i32* %14
%136 = load i32, i32* %2
%137 = load i32, i32* %2
%138 = mul nsw i32 %136, %137
store i32 %138, i32* %15
store i32 0, i32* %16
store i32 0, i32* %17
store i32 0, i32* %18
store i8 102, i8* %19
store i8 102, i8* %20
%139 = load i32, i32* %2
%140 = load i32, i32* %2
%141 = mul nsw i32 %139, %140
%142 = sext i32 %141 to i64
%143 = mul i64 %142, 1
%144 = call i8* @malloc(i64 %143)
store i8* %144, i8** %21
%145 = load i32, i32* %2
%146 = load i32, i32* %12
%147 = load i8*, i8** %21
%148 = load i8**, i8*** %6
%149 = call i32 (i32, i32, i8*, i8**, ...) bitcast (i32 (...)* @new_board to i32 (i32, i32, i8*, i8**, ...)*)(i32 %145, i32 %146, i8* %147, i8** %148)
%150 = load i32, i32* %2
%151 = load i32, i32* %2
%152 = mul nsw i32 %150, %151
%153 = sext i32 %152 to i64
%154 = mul i64 %153, 8
%155 = call i8* @malloc(i64 %154)
%156 = bitcast i8* %155 to i8**
store i8** %156, i8*** %22
store i32 0, i32* %23
br label %157
157: ; preds = %174, %134
%158 = load i32, i32* %23
%159 = load i32, i32* %2
%160 = load i32, i32* %2
%161 = mul nsw i32 %159, %160
%162 = icmp slt i32 %158, %161
br i1 %162, label %163, label %177
163: ; preds = %157
%164 = load i32, i32* %2
%165 = load i32, i32* %2
%166 = mul nsw i32 %164, %165
%167 = sext i32 %166 to i64
%168 = mul i64 %167, 1
%169 = call i8* @malloc(i64 %168)
%170 = load i8**, i8*** %22
%171 = load i32, i32* %23
%172 = sext i32 %171 to i64
%173 = getelementptr inbounds i8*, i8** %170, i64 %172
store i8* %169, i8** %173
br label %174
174: ; preds = %163
%175 = load i32, i32* %23
%176 = add nsw i32 %175, 1
store i32 %176, i32* %23
br label %157
177: ; preds = %157
br label %178
178: ; preds = %406, %177
%179 = load i32, i32* %14
%180 = icmp sge i32 %179, 0
br i1 %180, label %181, label %407
181: ; preds = %178
%182 = load i32, i32* %2
%183 = load i8*, i8** %21
%184 = call i32 (i32, i8*, ...) bitcast (i32 (...)* @remaining_moves to i32 (i32, i8*, ...)*)(i32 %182, i8* %183)
%185 = icmp sgt i32 %184, 0
br i1 %185, label %186, label %226
186: ; preds = %181
store i32 0, i32* %16
store i8 102, i8* %20
br label %187
187: ; preds = %224, %186
%188 = load i32, i32* %16
%189 = load i32, i32* %2
%190 = load i32, i32* %2
%191 = mul nsw i32 %189, %190
%192 = icmp slt i32 %188, %191
br i1 %192, label %193, label %197
193: ; preds = %187
%194 = load i8, i8* %20
%195 = sext i8 %194 to i32
%196 = icmp eq i32 %195, 102
br label %197
197: ; preds = %193, %187
%198 = phi i1 [ false, %187 ], [ %196, %193 ]
br i1 %198, label %199, label %225
199: ; preds = %197
%200 = load i8*, i8** %21
%201 = load i32, i32* %16
%202 = sext i32 %201 to i64
%203 = getelementptr inbounds i8, i8* %200, i64 %202
%204 = load i8, i8* %203
%205 = sext i8 %204 to i32
%206 = icmp eq i32 %205, 95
br i1 %206, label %207, label %221
207: ; preds = %199
%208 = load i32, i32* %2
%209 = load i32, i32* %14
%210 = load i8**, i8*** %22
%211 = call i32 (i32, i32, i32*, i8**, ...) bitcast (i32 (...)* @validate_stack_size to i32 (i32, i32, i32*, i8**, ...)*)(i32 %208, i32 %209, i32* %15, i8** %210)
%212 = load i32, i32* %2
%213 = load i32, i32* %16
%214 = load i8*, i8** %21
%215 = load i8**, i8*** %22
%216 = call i32 (i32, i32, i8*, i32*, i8**, ...) bitcast (i32 (...)* @backtrack to i32 (i32, i32, i8*, i32*, i8**, ...)*)(i32 %212, i32 %213, i8* %214, i32* %14, i8** %215)
%217 = load i32, i32* %2
%218 = load i32, i32* %16
%219 = load i8*, i8** %21
%220 = call i32 (i32, i32, i8*, ...) bitcast (i32 (...)* @place_piece to i32 (i32, i32, i8*, ...)*)(i32 %217, i32 %218, i8* %219)
store i8 116, i8* %20
br label %224
221: ; preds = %199
%222 = load i32, i32* %16
%223 = add nsw i32 %222, 1
store i32 %223, i32* %16
br label %224
224: ; preds = %221, %207
br label %187
225: ; preds = %197
br label %406
226: ; preds = %181
%227 = load i32, i32* %2
%228 = load i8*, i8** %21
%229 = call i32 (i32, i8*, ...) bitcast (i32 (...)* @validate_board to i32 (i32, i8*, ...)*)(i32 %227, i8* %228)
%230 = icmp eq i32 %229, 1
br i1 %230, label %231, label %394
231: ; preds = %226
%232 = load i32, i32* %4
%233 = icmp eq i32 %232, 0
br i1 %233, label %234, label %263
234: ; preds = %231
store i32 0, i32* %24
br label %235
235: ; preds = %255, %234
%236 = load i32, i32* %24
%237 = load i32, i32* %2
%238 = load i32, i32* %2
%239 = mul nsw i32 %237, %238
%240 = icmp slt i32 %236, %239
br i1 %240, label %241, label %258
241: ; preds = %235
%242 = load i8*, i8** %21
%243 = load i32, i32* %24
%244 = sext i32 %243 to i64
%245 = getelementptr inbounds i8, i8* %242, i64 %244
%246 = load i8, i8* %245
%247 = load i8**, i8*** %8
%248 = load i32, i32* %4
%249 = sext i32 %248 to i64
%250 = getelementptr inbounds i8*, i8** %247, i64 %249
%251 = load i8*, i8** %250
%252 = load i32, i32* %24
%253 = sext i32 %252 to i64
%254 = getelementptr inbounds i8, i8* %251, i64 %253
store i8 %246, i8* %254
br label %255
255: ; preds = %241
%256 = load i32, i32* %24
%257 = add nsw i32 %256, 1
store i32 %257, i32* %24
br label %235
258: ; preds = %235
%259 = load i32, i32* %4
%260 = add nsw i32 %259, 1
store i32 %260, i32* %4
%261 = load i32, i32* %5
%262 = add nsw i32 %261, 1
store i32 %262, i32* %5
br label %393
263: ; preds = %231
store i8 102, i8* %19
store i32 0, i32* %25
br label %264
264: ; preds = %313, %263
%265 = load i32, i32* %25
%266 = load i32, i32* %4
%267 = icmp slt i32 %265, %266
br i1 %267, label %268, label %316
268: ; preds = %264
%269 = load i8, i8* %19
%270 = sext i8 %269 to i32
%271 = icmp eq i32 %270, 102
br i1 %271, label %272, label %312
272: ; preds = %268
store i32 0, i32* %18
store i32 0, i32* %26
br label %273
273: ; preds = %301, %272
%274 = load i32, i32* %26
%275 = load i32, i32* %2
%276 = load i32, i32* %2
%277 = mul nsw i32 %275, %276
%278 = icmp slt i32 %274, %277
br i1 %278, label %279, label %304
279: ; preds = %273
%280 = load i8**, i8*** %8
%281 = load i32, i32* %25
%282 = sext i32 %281 to i64
%283 = getelementptr inbounds i8*, i8** %280, i64 %282
%284 = load i8*, i8** %283
%285 = load i32, i32* %26
%286 = sext i32 %285 to i64
%287 = getelementptr inbounds i8, i8* %284, i64 %286
%288 = load i8, i8* %287
%289 = sext i8 %288 to i32
%290 = load i8*, i8** %21
%291 = load i32, i32* %26
%292 = sext i32 %291 to i64
%293 = getelementptr inbounds i8, i8* %290, i64 %292
%294 = load i8, i8* %293
%295 = sext i8 %294 to i32
%296 = icmp eq i32 %289, %295
br i1 %296, label %297, label %300
297: ; preds = %279
%298 = load i32, i32* %18
%299 = add nsw i32 %298, 1
store i32 %299, i32* %18
br label %300
300: ; preds = %297, %279
br label %301
301: ; preds = %300
%302 = load i32, i32* %26
%303 = add nsw i32 %302, 1
store i32 %303, i32* %26
br label %273
304: ; preds = %273
%305 = load i32, i32* %18
%306 = load i32, i32* %2
%307 = load i32, i32* %2
%308 = mul nsw i32 %306, %307
%309 = icmp eq i32 %305, %308
br i1 %309, label %310, label %311
310: ; preds = %304
store i8 116, i8* %19
br label %311
311: ; preds = %310, %304
br label %312
312: ; preds = %311, %268
br label %313
313: ; preds = %312
%314 = load i32, i32* %25
%315 = add nsw i32 %314, 1
store i32 %315, i32* %25
br label %264
316: ; preds = %264
%317 = load i8, i8* %19
%318 = sext i8 %317 to i32
%319 = icmp eq i32 %318, 102
br i1 %319, label %320, label %392
320: ; preds = %316
%321 = load i32, i32* %4
%322 = load i32, i32* %3
%323 = icmp sge i32 %321, %322
br i1 %323, label %324, label %360
324: ; preds = %320
%325 = load i32, i32* %3
%326 = sitofp i32 %325 to double
%327 = load i32, i32* %3
%328 = sdiv i32 %327, 2
%329 = sitofp i32 %328 to double
%330 = call double @llvm.floor.f64(double %329)
%331 = fadd double %326, %330
%332 = fptosi double %331 to i32
store i32 %332, i32* %3
%333 = load i8**, i8*** %8
%334 = bitcast i8** %333 to i8*
%335 = load i32, i32* %3
%336 = sext i32 %335 to i64
%337 = mul i64 %336, 8
%338 = call i8* @realloc(i8* %334, i64 %337)
%339 = bitcast i8* %338 to i8**
store i8** %339, i8*** %8
%340 = load i32, i32* %4
store i32 %340, i32* %27
br label %341
341: ; preds = %356, %324
%342 = load i32, i32* %27
%343 = load i32, i32* %3
%344 = icmp slt i32 %342, %343
br i1 %344, label %345, label %359
345: ; preds = %341
%346 = load i32, i32* %2
%347 = load i32, i32* %2
%348 = mul nsw i32 %346, %347
%349 = sext i32 %348 to i64
%350 = mul i64 %349, 1
%351 = call i8* @malloc(i64 %350)
%352 = load i8**, i8*** %8
%353 = load i32, i32* %27
%354 = sext i32 %353 to i64
%355 = getelementptr inbounds i8*, i8** %352, i64 %354
store i8* %351, i8** %355
br label %356
356: ; preds = %345
%357 = load i32, i32* %27
%358 = add nsw i32 %357, 1
store i32 %358, i32* %27
br label %341
359: ; preds = %341
br label %360
360: ; preds = %359, %320
store i32 0, i32* %28
br label %361
361: ; preds = %381, %360
%362 = load i32, i32* %28
%363 = load i32, i32* %2
%364 = load i32, i32* %2
%365 = mul nsw i32 %363, %364
%366 = icmp slt i32 %362, %365
br i1 %366, label %367, label %384
367: ; preds = %361
%368 = load i8*, i8** %21
%369 = load i32, i32* %28
%370 = sext i32 %369 to i64
%371 = getelementptr inbounds i8, i8* %368, i64 %370
%372 = load i8, i8* %371
%373 = load i8**, i8*** %8
%374 = load i32, i32* %4
%375 = sext i32 %374 to i64
%376 = getelementptr inbounds i8*, i8** %373, i64 %375
%377 = load i8*, i8** %376
%378 = load i32, i32* %28
%379 = sext i32 %378 to i64
%380 = getelementptr inbounds i8, i8* %377, i64 %379
store i8 %372, i8* %380
br label %381
381: ; preds = %367
%382 = load i32, i32* %28
%383 = add nsw i32 %382, 1
store i32 %383, i32* %28
br label %361
384: ; preds = %361
%385 = load i32, i32* %4
%386 = add nsw i32 %385, 1
store i32 %386, i32* %4
%387 = load i32, i32* %2
%388 = load i8*, i8** %21
%389 = call i32 (i32, i8*, ...) bitcast (i32 (...)* @validate_board to i32 (i32, i8*, ...)*)(i32 %387, i8* %388)
%390 = load i32, i32* %5
%391 = add nsw i32 %390, %389
store i32 %391, i32* %5
br label %392
392: ; preds = %384, %316
br label %393
393: ; preds = %392, %258
br label %394
394: ; preds = %393, %226
%395 = load i32, i32* %14
%396 = sub nsw i32 %395, 1
store i32 %396, i32* %14
%397 = load i32, i32* %14
%398 = icmp sge i32 %397, 0
br i1 %398, label %399, label %405
399: ; preds = %394
%400 = load i32, i32* %2
%401 = load i32, i32* %14
%402 = load i8*, i8** %21
%403 = load i8**, i8*** %22
%404 = call i32 (i32, i32, i8*, i8**, ...) bitcast (i32 (...)* @new_board to i32 (i32, i32, i8*, i8**, ...)*)(i32 %400, i32 %401, i8* %402, i8** %403)
br label %405
405: ; preds = %399, %394
br label %406
406: ; preds = %405, %225
br label %178
407: ; preds = %178
%408 = load i8**, i8*** %22
%409 = bitcast i8** %408 to i8*
%410 = load i8*, i8** %21
br label %411
411: ; preds = %407
%412 = load i32, i32* %12
%413 = add nsw i32 %412, 1
store i32 %413, i32* %12
br label %128
414: ; preds = %128
%415 = load i32, i32* %5
%416 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([16 x i8], [16 x i8]* @.str.2, i64 0, i64 0), i32 %415)
%417 = load i8**, i8*** %6
%418 = bitcast i8** %417 to i8*
%419 = load i8**, i8*** %8
%420 = bitcast i8** %419 to i8*
%421 = load i32, i32* %1
ret i32 %421
}

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