int main(void) {
  int i, j;
  char **board = malloc(9 * sizeof(char *));
  int *col_sizes = malloc(9 * sizeof(int));
  board[0] = malloc(10);
  board[0][0] = '5';
  board[0][1] = '3';
  board[0][2] = '.';
  board[0][3] = '.';
  board[0][4] = '7';
  board[0][5] = '.';
  board[0][6] = '.';
  board[0][7] = '.';
  board[0][8] = '.';
  board[0][9] = '\0';
  col_sizes[0] = 9;
  board[1] = malloc(10);
  board[1][0] = '6';
  board[1][1] = '.';
  board[1][2] = '.';
  board[1][3] = '1';
  board[1][4] = '9';
  board[1][5] = '5';
  board[1][6] = '.';
  board[1][7] = '.';
  board[1][8] = '.';
  board[1][9] = '\0';
  col_sizes[1] = 9;
  board[2] = malloc(10);
  board[2][0] = '.';
  board[2][1] = '9';
  board[2][2] = '8';
  board[2][3] = '.';
  board[2][4] = '.';
  board[2][5] = '.';
  board[2][6] = '.';
  board[2][7] = '6';
  board[2][8] = '.';
  board[2][9] = '\0';
  col_sizes[2] = 9;
  board[3] = malloc(10);
  board[3][0] = '8';
  board[3][1] = '.';
  board[3][2] = '.';
  board[3][3] = '.';
  board[3][4] = '6';
  board[3][5] = '.';
  board[3][6] = '.';
  board[3][7] = '.';
  board[3][8] = '3';
  board[3][9] = '\0';
  col_sizes[3] = 9;
  board[4] = malloc(10);
  board[4][0] = '4';
  board[4][1] = '.';
  board[4][2] = '.';
  board[4][3] = '8';
  board[4][4] = '.';
  board[4][5] = '3';
  board[4][6] = '.';
  board[4][7] = '.';
  board[4][8] = '1';
  board[4][9] = '\0';
  col_sizes[4] = 9;
  board[5] = malloc(10);
  board[5][0] = '7';
  board[5][1] = '.';
  board[5][2] = '.';
  board[5][3] = '.';
  board[5][4] = '2';
  board[5][5] = '.';
  board[5][6] = '.';
  board[5][7] = '.';
  board[5][8] = '6';
  board[5][9] = '\0';
  col_sizes[5] = 9;
  board[6] = malloc(10);
  board[6][0] = '.';
  board[6][1] = '6';
  board[6][2] = '.';
  board[6][3] = '.';
  board[6][4] = '.';
  board[6][5] = '.';
  board[6][6] = '2';
  board[6][7] = '8';
  board[6][8] = '.';
  board[6][9] = '\0';
  col_sizes[6] = 9;
  board[7] = malloc(10);
  board[7][0] = '.';
  board[7][1] = '.';
  board[7][2] = '.';
  board[7][3] = '4';
  board[7][4] = '1';
  board[7][5] = '9';
  board[7][6] = '.';
  board[7][7] = '.';
  board[7][8] = '5';
  board[7][9] = '\0';
  col_sizes[7] = 9;
  board[8] = malloc(10);
  board[8][0] = '.';
  board[8][1] = '.';
  board[8][2] = '.';
  board[8][3] = '.';
  board[8][4] = '8';
  board[8][5] = '.';
  board[8][6] = '.';
  board[8][7] = '7';
  board[8][8] = '9';
  board[8][9] = '\0';
  col_sizes[8] = 9;
  for (i = 0; i < 9; i++) {
    for (j = 0; j < 9; j++) {
      printf("%c ", board[i][j]);
    }
    printf("\n");
  }
  printf("\n");
  solveSudoku(board, 9, col_sizes);
  for (i = 0; i < 9; i++) {
    for (j = 0; j < 9; j++) {
      printf("%c ", board[i][j]);
    }
    printf("\n");
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
movl   $0x0,-0x4(%rbp)
mov    $0x48,%edi
call   1050 <malloc@plt>
mov    %rax,-0x18(%rbp)
mov    $0x24,%edi
call   1050 <malloc@plt>
mov    %rax,-0x20(%rbp)
mov    $0xa,%edi
call   1050 <malloc@plt>
mov    %rax,%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
movb   $0x35,(%rax)
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
movb   $0x33,0x1(%rax)
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
movb   $0x2e,0x2(%rax)
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
movb   $0x2e,0x3(%rax)
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
movb   $0x37,0x4(%rax)
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
movb   $0x2e,0x5(%rax)
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
movb   $0x2e,0x6(%rax)
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
movb   $0x2e,0x7(%rax)
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
movb   $0x2e,0x8(%rax)
mov    -0x18(%rbp),%rax
mov    (%rax),%rax
movb   $0x0,0x9(%rax)
mov    -0x20(%rbp),%rax
movl   $0x9,(%rax)
mov    $0xa,%edi
call   1050 <malloc@plt>
mov    %rax,%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,0x8(%rax)
mov    -0x18(%rbp),%rax
mov    0x8(%rax),%rax
movb   $0x36,(%rax)
mov    -0x18(%rbp),%rax
mov    0x8(%rax),%rax
movb   $0x2e,0x1(%rax)
mov    -0x18(%rbp),%rax
mov    0x8(%rax),%rax
movb   $0x2e,0x2(%rax)
mov    -0x18(%rbp),%rax
mov    0x8(%rax),%rax
movb   $0x31,0x3(%rax)
mov    -0x18(%rbp),%rax
mov    0x8(%rax),%rax
movb   $0x39,0x4(%rax)
mov    -0x18(%rbp),%rax
mov    0x8(%rax),%rax
movb   $0x35,0x5(%rax)
mov    -0x18(%rbp),%rax
mov    0x8(%rax),%rax
movb   $0x2e,0x6(%rax)
mov    -0x18(%rbp),%rax
mov    0x8(%rax),%rax
movb   $0x2e,0x7(%rax)
mov    -0x18(%rbp),%rax
mov    0x8(%rax),%rax
movb   $0x2e,0x8(%rax)
mov    -0x18(%rbp),%rax
mov    0x8(%rax),%rax
movb   $0x0,0x9(%rax)
mov    -0x20(%rbp),%rax
movl   $0x9,0x4(%rax)
mov    $0xa,%edi
call   1050 <malloc@plt>
mov    %rax,%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,0x10(%rax)
mov    -0x18(%rbp),%rax
mov    0x10(%rax),%rax
movb   $0x2e,(%rax)
mov    -0x18(%rbp),%rax
mov    0x10(%rax),%rax
movb   $0x39,0x1(%rax)
mov    -0x18(%rbp),%rax
mov    0x10(%rax),%rax
movb   $0x38,0x2(%rax)
mov    -0x18(%rbp),%rax
mov    0x10(%rax),%rax
movb   $0x2e,0x3(%rax)
mov    -0x18(%rbp),%rax
mov    0x10(%rax),%rax
movb   $0x2e,0x4(%rax)
mov    -0x18(%rbp),%rax
mov    0x10(%rax),%rax
movb   $0x2e,0x5(%rax)
mov    -0x18(%rbp),%rax
mov    0x10(%rax),%rax
movb   $0x2e,0x6(%rax)
mov    -0x18(%rbp),%rax
mov    0x10(%rax),%rax
movb   $0x36,0x7(%rax)
mov    -0x18(%rbp),%rax
mov    0x10(%rax),%rax
movb   $0x2e,0x8(%rax)
mov    -0x18(%rbp),%rax
mov    0x10(%rax),%rax
movb   $0x0,0x9(%rax)
mov    -0x20(%rbp),%rax
movl   $0x9,0x8(%rax)
mov    $0xa,%edi
call   1050 <malloc@plt>
mov    %rax,%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,0x18(%rax)
mov    -0x18(%rbp),%rax
mov    0x18(%rax),%rax
movb   $0x38,(%rax)
mov    -0x18(%rbp),%rax
mov    0x18(%rax),%rax
movb   $0x2e,0x1(%rax)
mov    -0x18(%rbp),%rax
mov    0x18(%rax),%rax
movb   $0x2e,0x2(%rax)
mov    -0x18(%rbp),%rax
mov    0x18(%rax),%rax
movb   $0x2e,0x3(%rax)
mov    -0x18(%rbp),%rax
mov    0x18(%rax),%rax
movb   $0x36,0x4(%rax)
mov    -0x18(%rbp),%rax
mov    0x18(%rax),%rax
movb   $0x2e,0x5(%rax)
mov    -0x18(%rbp),%rax
mov    0x18(%rax),%rax
movb   $0x2e,0x6(%rax)
mov    -0x18(%rbp),%rax
mov    0x18(%rax),%rax
movb   $0x2e,0x7(%rax)
mov    -0x18(%rbp),%rax
mov    0x18(%rax),%rax
movb   $0x33,0x8(%rax)
mov    -0x18(%rbp),%rax
mov    0x18(%rax),%rax
movb   $0x0,0x9(%rax)
mov    -0x20(%rbp),%rax
movl   $0x9,0xc(%rax)
mov    $0xa,%edi
call   1050 <malloc@plt>
mov    %rax,%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,0x20(%rax)
mov    -0x18(%rbp),%rax
mov    0x20(%rax),%rax
movb   $0x34,(%rax)
mov    -0x18(%rbp),%rax
mov    0x20(%rax),%rax
movb   $0x2e,0x1(%rax)
mov    -0x18(%rbp),%rax
mov    0x20(%rax),%rax
movb   $0x2e,0x2(%rax)
mov    -0x18(%rbp),%rax
mov    0x20(%rax),%rax
movb   $0x38,0x3(%rax)
mov    -0x18(%rbp),%rax
mov    0x20(%rax),%rax
movb   $0x2e,0x4(%rax)
mov    -0x18(%rbp),%rax
mov    0x20(%rax),%rax
movb   $0x33,0x5(%rax)
mov    -0x18(%rbp),%rax
mov    0x20(%rax),%rax
movb   $0x2e,0x6(%rax)
mov    -0x18(%rbp),%rax
mov    0x20(%rax),%rax
movb   $0x2e,0x7(%rax)
mov    -0x18(%rbp),%rax
mov    0x20(%rax),%rax
movb   $0x31,0x8(%rax)
mov    -0x18(%rbp),%rax
mov    0x20(%rax),%rax
movb   $0x0,0x9(%rax)
mov    -0x20(%rbp),%rax
movl   $0x9,0x10(%rax)
mov    $0xa,%edi
call   1050 <malloc@plt>
mov    %rax,%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,0x28(%rax)
mov    -0x18(%rbp),%rax
mov    0x28(%rax),%rax
movb   $0x37,(%rax)
mov    -0x18(%rbp),%rax
mov    0x28(%rax),%rax
movb   $0x2e,0x1(%rax)
mov    -0x18(%rbp),%rax
mov    0x28(%rax),%rax
movb   $0x2e,0x2(%rax)
mov    -0x18(%rbp),%rax
mov    0x28(%rax),%rax
movb   $0x2e,0x3(%rax)
mov    -0x18(%rbp),%rax
mov    0x28(%rax),%rax
movb   $0x32,0x4(%rax)
mov    -0x18(%rbp),%rax
mov    0x28(%rax),%rax
movb   $0x2e,0x5(%rax)
mov    -0x18(%rbp),%rax
mov    0x28(%rax),%rax
movb   $0x2e,0x6(%rax)
mov    -0x18(%rbp),%rax
mov    0x28(%rax),%rax
movb   $0x2e,0x7(%rax)
mov    -0x18(%rbp),%rax
mov    0x28(%rax),%rax
movb   $0x36,0x8(%rax)
mov    -0x18(%rbp),%rax
mov    0x28(%rax),%rax
movb   $0x0,0x9(%rax)
mov    -0x20(%rbp),%rax
movl   $0x9,0x14(%rax)
mov    $0xa,%edi
call   1050 <malloc@plt>
mov    %rax,%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,0x30(%rax)
mov    -0x18(%rbp),%rax
mov    0x30(%rax),%rax
movb   $0x2e,(%rax)
mov    -0x18(%rbp),%rax
mov    0x30(%rax),%rax
movb   $0x36,0x1(%rax)
mov    -0x18(%rbp),%rax
mov    0x30(%rax),%rax
movb   $0x2e,0x2(%rax)
mov    -0x18(%rbp),%rax
mov    0x30(%rax),%rax
movb   $0x2e,0x3(%rax)
mov    -0x18(%rbp),%rax
mov    0x30(%rax),%rax
movb   $0x2e,0x4(%rax)
mov    -0x18(%rbp),%rax
mov    0x30(%rax),%rax
movb   $0x2e,0x5(%rax)
mov    -0x18(%rbp),%rax
mov    0x30(%rax),%rax
movb   $0x32,0x6(%rax)
mov    -0x18(%rbp),%rax
mov    0x30(%rax),%rax
movb   $0x38,0x7(%rax)
mov    -0x18(%rbp),%rax
mov    0x30(%rax),%rax
movb   $0x2e,0x8(%rax)
mov    -0x18(%rbp),%rax
mov    0x30(%rax),%rax
movb   $0x0,0x9(%rax)
mov    -0x20(%rbp),%rax
movl   $0x9,0x18(%rax)
mov    $0xa,%edi
call   1050 <malloc@plt>
mov    %rax,%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,0x38(%rax)
mov    -0x18(%rbp),%rax
mov    0x38(%rax),%rax
movb   $0x2e,(%rax)
mov    -0x18(%rbp),%rax
mov    0x38(%rax),%rax
movb   $0x2e,0x1(%rax)
mov    -0x18(%rbp),%rax
mov    0x38(%rax),%rax
movb   $0x2e,0x2(%rax)
mov    -0x18(%rbp),%rax
mov    0x38(%rax),%rax
movb   $0x34,0x3(%rax)
mov    -0x18(%rbp),%rax
mov    0x38(%rax),%rax
movb   $0x31,0x4(%rax)
mov    -0x18(%rbp),%rax
mov    0x38(%rax),%rax
movb   $0x39,0x5(%rax)
mov    -0x18(%rbp),%rax
mov    0x38(%rax),%rax
movb   $0x2e,0x6(%rax)
mov    -0x18(%rbp),%rax
mov    0x38(%rax),%rax
movb   $0x2e,0x7(%rax)
mov    -0x18(%rbp),%rax
mov    0x38(%rax),%rax
movb   $0x35,0x8(%rax)
mov    -0x18(%rbp),%rax
mov    0x38(%rax),%rax
movb   $0x0,0x9(%rax)
mov    -0x20(%rbp),%rax
movl   $0x9,0x1c(%rax)
mov    $0xa,%edi
call   1050 <malloc@plt>
mov    %rax,%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,0x40(%rax)
mov    -0x18(%rbp),%rax
mov    0x40(%rax),%rax
movb   $0x2e,(%rax)
mov    -0x18(%rbp),%rax
mov    0x40(%rax),%rax
movb   $0x2e,0x1(%rax)
mov    -0x18(%rbp),%rax
mov    0x40(%rax),%rax
movb   $0x2e,0x2(%rax)
mov    -0x18(%rbp),%rax
mov    0x40(%rax),%rax
movb   $0x2e,0x3(%rax)
mov    -0x18(%rbp),%rax
mov    0x40(%rax),%rax
movb   $0x38,0x4(%rax)
mov    -0x18(%rbp),%rax
mov    0x40(%rax),%rax
movb   $0x2e,0x5(%rax)
mov    -0x18(%rbp),%rax
mov    0x40(%rax),%rax
movb   $0x2e,0x6(%rax)
mov    -0x18(%rbp),%rax
mov    0x40(%rax),%rax
movb   $0x37,0x7(%rax)
mov    -0x18(%rbp),%rax
mov    0x40(%rax),%rax
movb   $0x39,0x8(%rax)
mov    -0x18(%rbp),%rax
mov    0x40(%rax),%rax
movb   $0x0,0x9(%rax)
mov    -0x20(%rbp),%rax
movl   $0x9,0x20(%rax)
movl   $0x0,-0x8(%rbp)
cmpl   $0x9,-0x8(%rbp)
jge    170c <main+0x5dc>
movl   $0x0,-0xc(%rbp)
cmpl   $0x9,-0xc(%rbp)
jge    16f0 <main+0x5c0>
mov    -0x18(%rbp),%rax
movslq -0x8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xc(%rbp),%rcx
movsbl (%rax,%rcx,1),%esi
lea    0x925(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    16b6 <main+0x586>
lea    0x90d(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    16a5 <main+0x575>
lea    0x8f1(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x18(%rbp),%rdi
mov    -0x20(%rbp),%rdx
mov    $0x9,%esi
mov    $0x0,%al
call   1040 <solveSudoku@plt>
movl   $0x0,-0x8(%rbp)
cmpl   $0x9,-0x8(%rbp)
jge    179c <main+0x66c>
movl   $0x0,-0xc(%rbp)
cmpl   $0x9,-0xc(%rbp)
jge    1780 <main+0x650>
mov    -0x18(%rbp),%rax
movslq -0x8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xc(%rbp),%rcx
movsbl (%rax,%rcx,1),%esi
lea    0x895(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
jmp    1746 <main+0x616>
lea    0x87d(%rip),%rdi
mov    $0x0,%al
call   1030 <printf@plt>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    1735 <main+0x605>
xor    %eax,%eax
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    $0x48,%edi
call   1060 <malloc@plt>
mov    %rax,%r15
mov    $0x24,%edi
call   1060 <malloc@plt>
mov    %rax,%r14
mov    $0xa,%edi
call   1060 <malloc@plt>
mov    %rax,(%r15)
movl   $0x2e2e3335,(%rax)
movb   $0x37,0x4(%rax)
movl   $0x2e2e2e2e,0x5(%rax)
movb   $0x0,0x9(%rax)
mov    $0xa,%edi
call   1060 <malloc@plt>
mov    %rax,0x8(%r15)
movabs $0x2e2e3539312e2e36,%rcx
35 2e 2e
mov    %rcx,(%rax)
movw   $0x2e,0x8(%rax)
mov    $0xa,%edi
call   1060 <malloc@plt>
mov    %rax,0x10(%r15)
movw   $0x392e,(%rax)
movb   $0x38,0x2(%rax)
movl   $0x2e2e2e2e,0x3(%rax)
movw   $0x2e36,0x7(%rax)
movb   $0x0,0x9(%rax)
mov    $0xa,%edi
call   1060 <malloc@plt>
mov    %rax,0x18(%r15)
movabs $0x2e2e2e362e2e2e38,%rcx
2e 2e 2e
mov    %rcx,(%rax)
movw   $0x33,0x8(%rax)
movaps 0xe0a(%rip),%xmm0
movups %xmm0,(%r14)
mov    $0xa,%edi
call   1060 <malloc@plt>
mov    %rax,0x20(%r15)
movabs $0x2e2e332e382e2e34,%rcx
33 2e 2e
mov    %rcx,(%rax)
movw   $0x31,0x8(%rax)
mov    $0xa,%edi
call   1060 <malloc@plt>
mov    %rax,0x28(%r15)
movabs $0x2e2e2e322e2e2e37,%rcx
2e 2e 2e
mov    %rcx,(%rax)
movw   $0x36,0x8(%rax)
mov    $0xa,%edi
call   1060 <malloc@plt>
mov    %rax,0x30(%r15)
movw   $0x362e,(%rax)
movabs $0x2e38322e2e2e2e,%rcx
mov    %rcx,0x2(%rax)
mov    $0xa,%edi
call   1060 <malloc@plt>
mov    %rax,0x38(%r15)
movabs $0x2e2e3931342e2e2e,%rcx
39 2e 2e
mov    %rcx,(%rax)
movw   $0x35,0x8(%rax)
movaps 0xd7b(%rip),%xmm0
movups %xmm0,0x10(%r14)
mov    $0xa,%edi
call   1060 <malloc@plt>
mov    %rax,0x40(%r15)
movabs $0x372e2e382e2e2e2e,%rcx
2e 2e 37
mov    %rcx,(%rax)
movw   $0x39,0x8(%rax)
movl   $0x9,0x20(%r14)
lea    0xd56(%rip),%r12
xor    %r13d,%r13d
nopl   (%rax)
mov    (%r15,%r13,8),%rbx
movsbl (%rbx),%esi
mov    %r12,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movsbl 0x1(%rbx),%esi
mov    %r12,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movsbl 0x2(%rbx),%esi
mov    %r12,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movsbl 0x3(%rbx),%esi
mov    %r12,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movsbl 0x4(%rbx),%esi
mov    %r12,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movsbl 0x5(%rbx),%esi
mov    %r12,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movsbl 0x6(%rbx),%esi
mov    %r12,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movsbl 0x7(%rbx),%esi
mov    %r12,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
movsbl 0x8(%rbx),%esi
mov    %r12,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
add    $0x1,%r13
cmp    $0x9,%r13
jne    12c0 <main+0x180>
mov    $0xa,%edi
call   1030 <putchar@plt>
mov    %r15,%rdi
mov    $0x9,%esi
mov    %r14,%rdx
xor    %eax,%eax
call   1050 <solveSudoku@plt>
lea    0xc94(%rip),%r14
xor    %ebx,%ebx
xchg   %ax,%ax
mov    (%r15,%rbx,8),%rax
movsbl (%rax),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    (%r15,%rbx,8),%rax
movsbl 0x1(%rax),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    (%r15,%rbx,8),%rax
movsbl 0x2(%rax),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    (%r15,%rbx,8),%rax
movsbl 0x3(%rax),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    (%r15,%rbx,8),%rax
movsbl 0x4(%rax),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    (%r15,%rbx,8),%rax
movsbl 0x5(%rax),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    (%r15,%rbx,8),%rax
movsbl 0x6(%rax),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    (%r15,%rbx,8),%rax
movsbl 0x7(%rax),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    (%r15,%rbx,8),%rax
movsbl 0x8(%rax),%esi
mov    %r14,%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    $0xa,%edi
call   1030 <putchar@plt>
add    $0x1,%rbx
cmp    $0x9,%rbx
jne    1380 <main+0x240>
xor    %eax,%eax
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
@.str = [4 x i8] c"%c \00"
@.str.1 = [2 x i8] c"\0A\00"
define i32 @main() {
%1 = alloca i32
%2 = alloca i32
%3 = alloca i32
%4 = alloca i8**
%5 = alloca i32*
store i32 0, i32* %1
%6 = call i8* @malloc(i64 72)
%7 = bitcast i8* %6 to i8**
store i8** %7, i8*** %4
%8 = call i8* @malloc(i64 36)
%9 = bitcast i8* %8 to i32*
store i32* %9, i32** %5
%10 = call i8* @malloc(i64 10)
%11 = load i8**, i8*** %4
%12 = getelementptr inbounds i8*, i8** %11, i64 0
store i8* %10, i8** %12
%13 = load i8**, i8*** %4
%14 = getelementptr inbounds i8*, i8** %13, i64 0
%15 = load i8*, i8** %14
%16 = getelementptr inbounds i8, i8* %15, i64 0
store i8 53, i8* %16
%17 = load i8**, i8*** %4
%18 = getelementptr inbounds i8*, i8** %17, i64 0
%19 = load i8*, i8** %18
%20 = getelementptr inbounds i8, i8* %19, i64 1
store i8 51, i8* %20
%21 = load i8**, i8*** %4
%22 = getelementptr inbounds i8*, i8** %21, i64 0
%23 = load i8*, i8** %22
%24 = getelementptr inbounds i8, i8* %23, i64 2
store i8 46, i8* %24
%25 = load i8**, i8*** %4
%26 = getelementptr inbounds i8*, i8** %25, i64 0
%27 = load i8*, i8** %26
%28 = getelementptr inbounds i8, i8* %27, i64 3
store i8 46, i8* %28
%29 = load i8**, i8*** %4
%30 = getelementptr inbounds i8*, i8** %29, i64 0
%31 = load i8*, i8** %30
%32 = getelementptr inbounds i8, i8* %31, i64 4
store i8 55, i8* %32
%33 = load i8**, i8*** %4
%34 = getelementptr inbounds i8*, i8** %33, i64 0
%35 = load i8*, i8** %34
%36 = getelementptr inbounds i8, i8* %35, i64 5
store i8 46, i8* %36
%37 = load i8**, i8*** %4
%38 = getelementptr inbounds i8*, i8** %37, i64 0
%39 = load i8*, i8** %38
%40 = getelementptr inbounds i8, i8* %39, i64 6
store i8 46, i8* %40
%41 = load i8**, i8*** %4
%42 = getelementptr inbounds i8*, i8** %41, i64 0
%43 = load i8*, i8** %42
%44 = getelementptr inbounds i8, i8* %43, i64 7
store i8 46, i8* %44
%45 = load i8**, i8*** %4
%46 = getelementptr inbounds i8*, i8** %45, i64 0
%47 = load i8*, i8** %46
%48 = getelementptr inbounds i8, i8* %47, i64 8
store i8 46, i8* %48
%49 = load i8**, i8*** %4
%50 = getelementptr inbounds i8*, i8** %49, i64 0
%51 = load i8*, i8** %50
%52 = getelementptr inbounds i8, i8* %51, i64 9
store i8 0, i8* %52
%53 = load i32*, i32** %5
%54 = getelementptr inbounds i32, i32* %53, i64 0
store i32 9, i32* %54
%55 = call i8* @malloc(i64 10)
%56 = load i8**, i8*** %4
%57 = getelementptr inbounds i8*, i8** %56, i64 1
store i8* %55, i8** %57
%58 = load i8**, i8*** %4
%59 = getelementptr inbounds i8*, i8** %58, i64 1
%60 = load i8*, i8** %59
%61 = getelementptr inbounds i8, i8* %60, i64 0
store i8 54, i8* %61
%62 = load i8**, i8*** %4
%63 = getelementptr inbounds i8*, i8** %62, i64 1
%64 = load i8*, i8** %63
%65 = getelementptr inbounds i8, i8* %64, i64 1
store i8 46, i8* %65
%66 = load i8**, i8*** %4
%67 = getelementptr inbounds i8*, i8** %66, i64 1
%68 = load i8*, i8** %67
%69 = getelementptr inbounds i8, i8* %68, i64 2
store i8 46, i8* %69
%70 = load i8**, i8*** %4
%71 = getelementptr inbounds i8*, i8** %70, i64 1
%72 = load i8*, i8** %71
%73 = getelementptr inbounds i8, i8* %72, i64 3
store i8 49, i8* %73
%74 = load i8**, i8*** %4
%75 = getelementptr inbounds i8*, i8** %74, i64 1
%76 = load i8*, i8** %75
%77 = getelementptr inbounds i8, i8* %76, i64 4
store i8 57, i8* %77
%78 = load i8**, i8*** %4
%79 = getelementptr inbounds i8*, i8** %78, i64 1
%80 = load i8*, i8** %79
%81 = getelementptr inbounds i8, i8* %80, i64 5
store i8 53, i8* %81
%82 = load i8**, i8*** %4
%83 = getelementptr inbounds i8*, i8** %82, i64 1
%84 = load i8*, i8** %83
%85 = getelementptr inbounds i8, i8* %84, i64 6
store i8 46, i8* %85
%86 = load i8**, i8*** %4
%87 = getelementptr inbounds i8*, i8** %86, i64 1
%88 = load i8*, i8** %87
%89 = getelementptr inbounds i8, i8* %88, i64 7
store i8 46, i8* %89
%90 = load i8**, i8*** %4
%91 = getelementptr inbounds i8*, i8** %90, i64 1
%92 = load i8*, i8** %91
%93 = getelementptr inbounds i8, i8* %92, i64 8
store i8 46, i8* %93
%94 = load i8**, i8*** %4
%95 = getelementptr inbounds i8*, i8** %94, i64 1
%96 = load i8*, i8** %95
%97 = getelementptr inbounds i8, i8* %96, i64 9
store i8 0, i8* %97
%98 = load i32*, i32** %5
%99 = getelementptr inbounds i32, i32* %98, i64 1
store i32 9, i32* %99
%100 = call i8* @malloc(i64 10)
%101 = load i8**, i8*** %4
%102 = getelementptr inbounds i8*, i8** %101, i64 2
store i8* %100, i8** %102
%103 = load i8**, i8*** %4
%104 = getelementptr inbounds i8*, i8** %103, i64 2
%105 = load i8*, i8** %104
%106 = getelementptr inbounds i8, i8* %105, i64 0
store i8 46, i8* %106
%107 = load i8**, i8*** %4
%108 = getelementptr inbounds i8*, i8** %107, i64 2
%109 = load i8*, i8** %108
%110 = getelementptr inbounds i8, i8* %109, i64 1
store i8 57, i8* %110
%111 = load i8**, i8*** %4
%112 = getelementptr inbounds i8*, i8** %111, i64 2
%113 = load i8*, i8** %112
%114 = getelementptr inbounds i8, i8* %113, i64 2
store i8 56, i8* %114
%115 = load i8**, i8*** %4
%116 = getelementptr inbounds i8*, i8** %115, i64 2
%117 = load i8*, i8** %116
%118 = getelementptr inbounds i8, i8* %117, i64 3
store i8 46, i8* %118
%119 = load i8**, i8*** %4
%120 = getelementptr inbounds i8*, i8** %119, i64 2
%121 = load i8*, i8** %120
%122 = getelementptr inbounds i8, i8* %121, i64 4
store i8 46, i8* %122
%123 = load i8**, i8*** %4
%124 = getelementptr inbounds i8*, i8** %123, i64 2
%125 = load i8*, i8** %124
%126 = getelementptr inbounds i8, i8* %125, i64 5
store i8 46, i8* %126
%127 = load i8**, i8*** %4
%128 = getelementptr inbounds i8*, i8** %127, i64 2
%129 = load i8*, i8** %128
%130 = getelementptr inbounds i8, i8* %129, i64 6
store i8 46, i8* %130
%131 = load i8**, i8*** %4
%132 = getelementptr inbounds i8*, i8** %131, i64 2
%133 = load i8*, i8** %132
%134 = getelementptr inbounds i8, i8* %133, i64 7
store i8 54, i8* %134
%135 = load i8**, i8*** %4
%136 = getelementptr inbounds i8*, i8** %135, i64 2
%137 = load i8*, i8** %136
%138 = getelementptr inbounds i8, i8* %137, i64 8
store i8 46, i8* %138
%139 = load i8**, i8*** %4
%140 = getelementptr inbounds i8*, i8** %139, i64 2
%141 = load i8*, i8** %140
%142 = getelementptr inbounds i8, i8* %141, i64 9
store i8 0, i8* %142
%143 = load i32*, i32** %5
%144 = getelementptr inbounds i32, i32* %143, i64 2
store i32 9, i32* %144
%145 = call i8* @malloc(i64 10)
%146 = load i8**, i8*** %4
%147 = getelementptr inbounds i8*, i8** %146, i64 3
store i8* %145, i8** %147
%148 = load i8**, i8*** %4
%149 = getelementptr inbounds i8*, i8** %148, i64 3
%150 = load i8*, i8** %149
%151 = getelementptr inbounds i8, i8* %150, i64 0
store i8 56, i8* %151
%152 = load i8**, i8*** %4
%153 = getelementptr inbounds i8*, i8** %152, i64 3
%154 = load i8*, i8** %153
%155 = getelementptr inbounds i8, i8* %154, i64 1
store i8 46, i8* %155
%156 = load i8**, i8*** %4
%157 = getelementptr inbounds i8*, i8** %156, i64 3
%158 = load i8*, i8** %157
%159 = getelementptr inbounds i8, i8* %158, i64 2
store i8 46, i8* %159
%160 = load i8**, i8*** %4
%161 = getelementptr inbounds i8*, i8** %160, i64 3
%162 = load i8*, i8** %161
%163 = getelementptr inbounds i8, i8* %162, i64 3
store i8 46, i8* %163
%164 = load i8**, i8*** %4
%165 = getelementptr inbounds i8*, i8** %164, i64 3
%166 = load i8*, i8** %165
%167 = getelementptr inbounds i8, i8* %166, i64 4
store i8 54, i8* %167
%168 = load i8**, i8*** %4
%169 = getelementptr inbounds i8*, i8** %168, i64 3
%170 = load i8*, i8** %169
%171 = getelementptr inbounds i8, i8* %170, i64 5
store i8 46, i8* %171
%172 = load i8**, i8*** %4
%173 = getelementptr inbounds i8*, i8** %172, i64 3
%174 = load i8*, i8** %173
%175 = getelementptr inbounds i8, i8* %174, i64 6
store i8 46, i8* %175
%176 = load i8**, i8*** %4
%177 = getelementptr inbounds i8*, i8** %176, i64 3
%178 = load i8*, i8** %177
%179 = getelementptr inbounds i8, i8* %178, i64 7
store i8 46, i8* %179
%180 = load i8**, i8*** %4
%181 = getelementptr inbounds i8*, i8** %180, i64 3
%182 = load i8*, i8** %181
%183 = getelementptr inbounds i8, i8* %182, i64 8
store i8 51, i8* %183
%184 = load i8**, i8*** %4
%185 = getelementptr inbounds i8*, i8** %184, i64 3
%186 = load i8*, i8** %185
%187 = getelementptr inbounds i8, i8* %186, i64 9
store i8 0, i8* %187
%188 = load i32*, i32** %5
%189 = getelementptr inbounds i32, i32* %188, i64 3
store i32 9, i32* %189
%190 = call i8* @malloc(i64 10)
%191 = load i8**, i8*** %4
%192 = getelementptr inbounds i8*, i8** %191, i64 4
store i8* %190, i8** %192
%193 = load i8**, i8*** %4
%194 = getelementptr inbounds i8*, i8** %193, i64 4
%195 = load i8*, i8** %194
%196 = getelementptr inbounds i8, i8* %195, i64 0
store i8 52, i8* %196
%197 = load i8**, i8*** %4
%198 = getelementptr inbounds i8*, i8** %197, i64 4
%199 = load i8*, i8** %198
%200 = getelementptr inbounds i8, i8* %199, i64 1
store i8 46, i8* %200
%201 = load i8**, i8*** %4
%202 = getelementptr inbounds i8*, i8** %201, i64 4
%203 = load i8*, i8** %202
%204 = getelementptr inbounds i8, i8* %203, i64 2
store i8 46, i8* %204
%205 = load i8**, i8*** %4
%206 = getelementptr inbounds i8*, i8** %205, i64 4
%207 = load i8*, i8** %206
%208 = getelementptr inbounds i8, i8* %207, i64 3
store i8 56, i8* %208
%209 = load i8**, i8*** %4
%210 = getelementptr inbounds i8*, i8** %209, i64 4
%211 = load i8*, i8** %210
%212 = getelementptr inbounds i8, i8* %211, i64 4
store i8 46, i8* %212
%213 = load i8**, i8*** %4
%214 = getelementptr inbounds i8*, i8** %213, i64 4
%215 = load i8*, i8** %214
%216 = getelementptr inbounds i8, i8* %215, i64 5
store i8 51, i8* %216
%217 = load i8**, i8*** %4
%218 = getelementptr inbounds i8*, i8** %217, i64 4
%219 = load i8*, i8** %218
%220 = getelementptr inbounds i8, i8* %219, i64 6
store i8 46, i8* %220
%221 = load i8**, i8*** %4
%222 = getelementptr inbounds i8*, i8** %221, i64 4
%223 = load i8*, i8** %222
%224 = getelementptr inbounds i8, i8* %223, i64 7
store i8 46, i8* %224
%225 = load i8**, i8*** %4
%226 = getelementptr inbounds i8*, i8** %225, i64 4
%227 = load i8*, i8** %226
%228 = getelementptr inbounds i8, i8* %227, i64 8
store i8 49, i8* %228
%229 = load i8**, i8*** %4
%230 = getelementptr inbounds i8*, i8** %229, i64 4
%231 = load i8*, i8** %230
%232 = getelementptr inbounds i8, i8* %231, i64 9
store i8 0, i8* %232
%233 = load i32*, i32** %5
%234 = getelementptr inbounds i32, i32* %233, i64 4
store i32 9, i32* %234
%235 = call i8* @malloc(i64 10)
%236 = load i8**, i8*** %4
%237 = getelementptr inbounds i8*, i8** %236, i64 5
store i8* %235, i8** %237
%238 = load i8**, i8*** %4
%239 = getelementptr inbounds i8*, i8** %238, i64 5
%240 = load i8*, i8** %239
%241 = getelementptr inbounds i8, i8* %240, i64 0
store i8 55, i8* %241
%242 = load i8**, i8*** %4
%243 = getelementptr inbounds i8*, i8** %242, i64 5
%244 = load i8*, i8** %243
%245 = getelementptr inbounds i8, i8* %244, i64 1
store i8 46, i8* %245
%246 = load i8**, i8*** %4
%247 = getelementptr inbounds i8*, i8** %246, i64 5
%248 = load i8*, i8** %247
%249 = getelementptr inbounds i8, i8* %248, i64 2
store i8 46, i8* %249
%250 = load i8**, i8*** %4
%251 = getelementptr inbounds i8*, i8** %250, i64 5
%252 = load i8*, i8** %251
%253 = getelementptr inbounds i8, i8* %252, i64 3
store i8 46, i8* %253
%254 = load i8**, i8*** %4
%255 = getelementptr inbounds i8*, i8** %254, i64 5
%256 = load i8*, i8** %255
%257 = getelementptr inbounds i8, i8* %256, i64 4
store i8 50, i8* %257
%258 = load i8**, i8*** %4
%259 = getelementptr inbounds i8*, i8** %258, i64 5
%260 = load i8*, i8** %259
%261 = getelementptr inbounds i8, i8* %260, i64 5
store i8 46, i8* %261
%262 = load i8**, i8*** %4
%263 = getelementptr inbounds i8*, i8** %262, i64 5
%264 = load i8*, i8** %263
%265 = getelementptr inbounds i8, i8* %264, i64 6
store i8 46, i8* %265
%266 = load i8**, i8*** %4
%267 = getelementptr inbounds i8*, i8** %266, i64 5
%268 = load i8*, i8** %267
%269 = getelementptr inbounds i8, i8* %268, i64 7
store i8 46, i8* %269
%270 = load i8**, i8*** %4
%271 = getelementptr inbounds i8*, i8** %270, i64 5
%272 = load i8*, i8** %271
%273 = getelementptr inbounds i8, i8* %272, i64 8
store i8 54, i8* %273
%274 = load i8**, i8*** %4
%275 = getelementptr inbounds i8*, i8** %274, i64 5
%276 = load i8*, i8** %275
%277 = getelementptr inbounds i8, i8* %276, i64 9
store i8 0, i8* %277
%278 = load i32*, i32** %5
%279 = getelementptr inbounds i32, i32* %278, i64 5
store i32 9, i32* %279
%280 = call i8* @malloc(i64 10)
%281 = load i8**, i8*** %4
%282 = getelementptr inbounds i8*, i8** %281, i64 6
store i8* %280, i8** %282
%283 = load i8**, i8*** %4
%284 = getelementptr inbounds i8*, i8** %283, i64 6
%285 = load i8*, i8** %284
%286 = getelementptr inbounds i8, i8* %285, i64 0
store i8 46, i8* %286
%287 = load i8**, i8*** %4
%288 = getelementptr inbounds i8*, i8** %287, i64 6
%289 = load i8*, i8** %288
%290 = getelementptr inbounds i8, i8* %289, i64 1
store i8 54, i8* %290
%291 = load i8**, i8*** %4
%292 = getelementptr inbounds i8*, i8** %291, i64 6
%293 = load i8*, i8** %292
%294 = getelementptr inbounds i8, i8* %293, i64 2
store i8 46, i8* %294
%295 = load i8**, i8*** %4
%296 = getelementptr inbounds i8*, i8** %295, i64 6
%297 = load i8*, i8** %296
%298 = getelementptr inbounds i8, i8* %297, i64 3
store i8 46, i8* %298
%299 = load i8**, i8*** %4
%300 = getelementptr inbounds i8*, i8** %299, i64 6
%301 = load i8*, i8** %300
%302 = getelementptr inbounds i8, i8* %301, i64 4
store i8 46, i8* %302
%303 = load i8**, i8*** %4
%304 = getelementptr inbounds i8*, i8** %303, i64 6
%305 = load i8*, i8** %304
%306 = getelementptr inbounds i8, i8* %305, i64 5
store i8 46, i8* %306
%307 = load i8**, i8*** %4
%308 = getelementptr inbounds i8*, i8** %307, i64 6
%309 = load i8*, i8** %308
%310 = getelementptr inbounds i8, i8* %309, i64 6
store i8 50, i8* %310
%311 = load i8**, i8*** %4
%312 = getelementptr inbounds i8*, i8** %311, i64 6
%313 = load i8*, i8** %312
%314 = getelementptr inbounds i8, i8* %313, i64 7
store i8 56, i8* %314
%315 = load i8**, i8*** %4
%316 = getelementptr inbounds i8*, i8** %315, i64 6
%317 = load i8*, i8** %316
%318 = getelementptr inbounds i8, i8* %317, i64 8
store i8 46, i8* %318
%319 = load i8**, i8*** %4
%320 = getelementptr inbounds i8*, i8** %319, i64 6
%321 = load i8*, i8** %320
%322 = getelementptr inbounds i8, i8* %321, i64 9
store i8 0, i8* %322
%323 = load i32*, i32** %5
%324 = getelementptr inbounds i32, i32* %323, i64 6
store i32 9, i32* %324
%325 = call i8* @malloc(i64 10)
%326 = load i8**, i8*** %4
%327 = getelementptr inbounds i8*, i8** %326, i64 7
store i8* %325, i8** %327
%328 = load i8**, i8*** %4
%329 = getelementptr inbounds i8*, i8** %328, i64 7
%330 = load i8*, i8** %329
%331 = getelementptr inbounds i8, i8* %330, i64 0
store i8 46, i8* %331
%332 = load i8**, i8*** %4
%333 = getelementptr inbounds i8*, i8** %332, i64 7
%334 = load i8*, i8** %333
%335 = getelementptr inbounds i8, i8* %334, i64 1
store i8 46, i8* %335
%336 = load i8**, i8*** %4
%337 = getelementptr inbounds i8*, i8** %336, i64 7
%338 = load i8*, i8** %337
%339 = getelementptr inbounds i8, i8* %338, i64 2
store i8 46, i8* %339
%340 = load i8**, i8*** %4
%341 = getelementptr inbounds i8*, i8** %340, i64 7
%342 = load i8*, i8** %341
%343 = getelementptr inbounds i8, i8* %342, i64 3
store i8 52, i8* %343
%344 = load i8**, i8*** %4
%345 = getelementptr inbounds i8*, i8** %344, i64 7
%346 = load i8*, i8** %345
%347 = getelementptr inbounds i8, i8* %346, i64 4
store i8 49, i8* %347
%348 = load i8**, i8*** %4
%349 = getelementptr inbounds i8*, i8** %348, i64 7
%350 = load i8*, i8** %349
%351 = getelementptr inbounds i8, i8* %350, i64 5
store i8 57, i8* %351
%352 = load i8**, i8*** %4
%353 = getelementptr inbounds i8*, i8** %352, i64 7
%354 = load i8*, i8** %353
%355 = getelementptr inbounds i8, i8* %354, i64 6
store i8 46, i8* %355
%356 = load i8**, i8*** %4
%357 = getelementptr inbounds i8*, i8** %356, i64 7
%358 = load i8*, i8** %357
%359 = getelementptr inbounds i8, i8* %358, i64 7
store i8 46, i8* %359
%360 = load i8**, i8*** %4
%361 = getelementptr inbounds i8*, i8** %360, i64 7
%362 = load i8*, i8** %361
%363 = getelementptr inbounds i8, i8* %362, i64 8
store i8 53, i8* %363
%364 = load i8**, i8*** %4
%365 = getelementptr inbounds i8*, i8** %364, i64 7
%366 = load i8*, i8** %365
%367 = getelementptr inbounds i8, i8* %366, i64 9
store i8 0, i8* %367
%368 = load i32*, i32** %5
%369 = getelementptr inbounds i32, i32* %368, i64 7
store i32 9, i32* %369
%370 = call i8* @malloc(i64 10)
%371 = load i8**, i8*** %4
%372 = getelementptr inbounds i8*, i8** %371, i64 8
store i8* %370, i8** %372
%373 = load i8**, i8*** %4
%374 = getelementptr inbounds i8*, i8** %373, i64 8
%375 = load i8*, i8** %374
%376 = getelementptr inbounds i8, i8* %375, i64 0
store i8 46, i8* %376
%377 = load i8**, i8*** %4
%378 = getelementptr inbounds i8*, i8** %377, i64 8
%379 = load i8*, i8** %378
%380 = getelementptr inbounds i8, i8* %379, i64 1
store i8 46, i8* %380
%381 = load i8**, i8*** %4
%382 = getelementptr inbounds i8*, i8** %381, i64 8
%383 = load i8*, i8** %382
%384 = getelementptr inbounds i8, i8* %383, i64 2
store i8 46, i8* %384
%385 = load i8**, i8*** %4
%386 = getelementptr inbounds i8*, i8** %385, i64 8
%387 = load i8*, i8** %386
%388 = getelementptr inbounds i8, i8* %387, i64 3
store i8 46, i8* %388
%389 = load i8**, i8*** %4
%390 = getelementptr inbounds i8*, i8** %389, i64 8
%391 = load i8*, i8** %390
%392 = getelementptr inbounds i8, i8* %391, i64 4
store i8 56, i8* %392
%393 = load i8**, i8*** %4
%394 = getelementptr inbounds i8*, i8** %393, i64 8
%395 = load i8*, i8** %394
%396 = getelementptr inbounds i8, i8* %395, i64 5
store i8 46, i8* %396
%397 = load i8**, i8*** %4
%398 = getelementptr inbounds i8*, i8** %397, i64 8
%399 = load i8*, i8** %398
%400 = getelementptr inbounds i8, i8* %399, i64 6
store i8 46, i8* %400
%401 = load i8**, i8*** %4
%402 = getelementptr inbounds i8*, i8** %401, i64 8
%403 = load i8*, i8** %402
%404 = getelementptr inbounds i8, i8* %403, i64 7
store i8 55, i8* %404
%405 = load i8**, i8*** %4
%406 = getelementptr inbounds i8*, i8** %405, i64 8
%407 = load i8*, i8** %406
%408 = getelementptr inbounds i8, i8* %407, i64 8
store i8 57, i8* %408
%409 = load i8**, i8*** %4
%410 = getelementptr inbounds i8*, i8** %409, i64 8
%411 = load i8*, i8** %410
%412 = getelementptr inbounds i8, i8* %411, i64 9
store i8 0, i8* %412
%413 = load i32*, i32** %5
%414 = getelementptr inbounds i32, i32* %413, i64 8
store i32 9, i32* %414
store i32 0, i32* %2
br label %415
415: ; preds = %439, %0
%416 = load i32, i32* %2
%417 = icmp slt i32 %416, 9
br i1 %417, label %418, label %442
418: ; preds = %415
store i32 0, i32* %3
br label %419
419: ; preds = %434, %418
%420 = load i32, i32* %3
%421 = icmp slt i32 %420, 9
br i1 %421, label %422, label %437
422: ; preds = %419
%423 = load i8**, i8*** %4
%424 = load i32, i32* %2
%425 = sext i32 %424 to i64
%426 = getelementptr inbounds i8*, i8** %423, i64 %425
%427 = load i8*, i8** %426
%428 = load i32, i32* %3
%429 = sext i32 %428 to i64
%430 = getelementptr inbounds i8, i8* %427, i64 %429
%431 = load i8, i8* %430
%432 = sext i8 %431 to i32
%433 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i32 %432)
br label %434
434: ; preds = %422
%435 = load i32, i32* %3
%436 = add nsw i32 %435, 1
store i32 %436, i32* %3
br label %419
437: ; preds = %419
%438 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
br label %439
439: ; preds = %437
%440 = load i32, i32* %2
%441 = add nsw i32 %440, 1
store i32 %441, i32* %2
br label %415
442: ; preds = %415
%443 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
%444 = load i8**, i8*** %4
%445 = load i32*, i32** %5
%446 = call i32 (i8**, i32, i32*, ...) bitcast (i32 (...)* @solveSudoku to i32 (i8**, i32, i32*, ...)*)(i8** %444, i32 9, i32* %445)
store i32 0, i32* %2
br label %447
447: ; preds = %471, %442
%448 = load i32, i32* %2
%449 = icmp slt i32 %448, 9
br i1 %449, label %450, label %474
450: ; preds = %447
store i32 0, i32* %3
br label %451
451: ; preds = %466, %450
%452 = load i32, i32* %3
%453 = icmp slt i32 %452, 9
br i1 %453, label %454, label %469
454: ; preds = %451
%455 = load i8**, i8*** %4
%456 = load i32, i32* %2
%457 = sext i32 %456 to i64
%458 = getelementptr inbounds i8*, i8** %455, i64 %457
%459 = load i8*, i8** %458
%460 = load i32, i32* %3
%461 = sext i32 %460 to i64
%462 = getelementptr inbounds i8, i8* %459, i64 %461
%463 = load i8, i8* %462
%464 = sext i8 %463 to i32
%465 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i32 %464)
br label %466
466: ; preds = %454
%467 = load i32, i32* %3
%468 = add nsw i32 %467, 1
store i32 %468, i32* %3
br label %451
469: ; preds = %451
%470 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.1, i64 0, i64 0))
br label %471
471: ; preds = %469
%472 = load i32, i32* %2
%473 = add nsw i32 %472, 1
store i32 %473, i32* %2
br label %447
474: ; preds = %447
ret i32 0
}

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