#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ exibe_tabuleiro(char **, int);
int /*<<< orphan*/ finaliza(int *, int);
int /*<<< orphan*/ getchar();
int /*<<< orphan*/ printf(char *, ...);
int /*<<< orphan*/ scanf(char *, int *);
int /*<<< orphan*/ system(char *);
void PLAY_engine(char matriz[10][10], int limite) {
  int i, j, final = 0, n_player = 0, id_player, pontos[2] = {0, 0}, linha[2],
            coluna[2], valida[10][10];
  int po_item = 0, p_jog[2][2], jogadas = 0, valida_pos[2] = {0, 0};
  char exibicao[10][10], saida[2], historico[2] = {'#', '#'};
  for (i = 0; i < limite; i++) {
    for (j = 0; j < limite; j++) {
      exibicao[i][j] = 178;
      valida[i][j] = 0;
    }
  }
  while (final < ((limite * limite) / 2)) {
    system("clear");
    exibe_tabuleiro(exibicao, limite);
    if (n_player % 2 == 0)
      id_player = 0;
    else
      id_player = 1;
    printf("\nVez: Jogador %d               Pontos: |Jogador 1%c %d|     "
           "|Jogador 2%c %d|\n ",
           id_player + 1, 26, pontos[0], 26, pontos[1]);
    if (po_item == 0) {
      printf("\nDigite o n%cmero da linha do primeiro item: ", 163);
      scanf("%d", &linha[0]);
      printf("Digite o n%cmero da coluna do primeiro item: ", 163);
      scanf("%d", &coluna[0]);
      linha[0]--;
      coluna[0]--;
      if (linha[0] < limite && linha[0] >= 0 && coluna[0] < limite &&
          coluna[0] >= 0) {
        exibicao[linha[0]][coluna[0]] = matriz[linha[0]][coluna[0]];
        saida[0] = matriz[linha[0]][coluna[0]];
        p_jog[0][0] = linha[0];
        p_jog[0][1] = coluna[0];
        valida_pos[0] = 1;
      } else {
        valida_pos[0] = 0;
      }
      po_item++;
    } else if (po_item == 1) {
      printf("\nDigite o n%cmero da linha do segundo item: ", 163);
      scanf("%d", &linha[1]);
      printf("Digite o n%cmero da coluna do segundo item: ", 163);
      scanf("%d", &coluna[1]);
      linha[1]--;
      coluna[1]--;
      if (linha[1] < limite && linha[1] >= 0 && coluna[1] < limite &&
          coluna[1] >= 0) {
        exibicao[linha[1]][coluna[1]] = matriz[linha[1]][coluna[1]];
        saida[1] = matriz[linha[1]][coluna[1]];
        p_jog[1][0] = linha[1];
        p_jog[1][1] = coluna[1];
        valida_pos[1] = 1;
      } else {
        valida_pos[1] = 0;
      }
      po_item++;
    } else {
      po_item = 0;
      if (valida_pos[0] == 0 || valida_pos[1] == 0) {
        printf("\nJogada inv%clida! As posi%c%ces n%co existem no tabuleiro.",
               160, 135, 228, 198);
        if (valida[p_jog[0][0]][p_jog[0][1]] == 0 &&
            (p_jog[0][0] < limite || p_jog[0][0] >= 0 || p_jog[0][1] < limite ||
             p_jog[0][1] >= 0))
          exibicao[p_jog[0][0]][p_jog[0][1]] = 178;
        if (valida[p_jog[1][0]][p_jog[1][1]] == 0 &&
            (p_jog[1][0] < limite || p_jog[1][0] >= 0 || p_jog[1][1] < limite ||
             p_jog[1][1] >= 0))
          exibicao[p_jog[1][0]][p_jog[1][1]] = 178;
        getchar();
      } else if (saida[0] == saida[1]) {
        if ((p_jog[0][0] == p_jog[1][0] && p_jog[0][1] == p_jog[1][1]) ||
            valida[p_jog[0][0]][p_jog[0][1]] == 1 ||
            valida[p_jog[1][0]][p_jog[1][1]] == 1) {
          printf("\nJogada inv%clida! As posi%c%ces s%co iguais, ou j%c foram "
                 "jogadas.",
                 160, 135, 228, 198, 160);
          if (valida[p_jog[0][0]][p_jog[0][1]] == 0)
            exibicao[p_jog[0][0]][p_jog[0][1]] = 178;
          if (valida[p_jog[1][0]][p_jog[1][1]] == 0)
            exibicao[p_jog[1][0]][p_jog[1][1]] = 178;
        } else {
          if (saida[0] == '@') {
            printf("\nVoc%c ganhou o b%cnus de 4 pontos!", 136, 147);
            pontos[id_player] += 4;
            if (historico[id_player] != '#') {
              historico[id_player] = '#';
              n_player++;
            }
            historico[id_player] = saida[0];
            jogadas++;
          } else if (saida[0] == '$') {
            printf("\nVoc%c ganhou o b%cnus de 7 pontos!", 136, 147);
            pontos[id_player] += 7;
            if (historico[id_player] != '#') {
              historico[id_player] = '#';
              n_player++;
            }
            historico[id_player] = saida[0];
            jogadas++;
          } else {
            printf("\nVoc%c ganhou 2 pontos!", 136);
            pontos[id_player] += 2;
            n_player++;
            jogadas++;
          }
          valida[p_jog[0][0]][p_jog[0][1]] = 1;
          valida[p_jog[1][0]][p_jog[1][1]] = 1;
          final++;
        }
        getchar();
      } else {
        if ((p_jog[0][0] == p_jog[1][0] && p_jog[0][1] == p_jog[1][1]) ||
            valida[p_jog[0][0]][p_jog[0][1]] == 1 ||
            valida[p_jog[1][0]][p_jog[1][1]] == 1) {
          printf("\nJogada inv%clida! As posi%c%ces s%co iguais, ou j%c foram "
                 "jogadas.",
                 160, 135, 228, 198, 160);
        } else {
          printf("\nVoc%c perdeu", 136);
          jogadas++;
          if (saida[0] == '@') {
            pontos[id_player] -= 4;
            printf(" 4 pontos");
          }
          if (saida[0] == '$') {
            pontos[id_player] -= 7;
            printf(" 7 pontos");
          }
          printf("!");
          n_player++;
        }
        if (valida[p_jog[0][0]][p_jog[0][1]] == 0)
          exibicao[p_jog[0][0]][p_jog[0][1]] = 178;
        if (valida[p_jog[1][0]][p_jog[1][1]] == 0)
          exibicao[p_jog[1][0]][p_jog[1][1]] = 178;
        getchar();
      }
    }
  }
  finaliza(pontos, jogadas);
}


x86 assembly (clang, -O0):
<PLAY_engine>:
push   %rbp
mov    %rsp,%rbp
sub    $0x270,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
movl   $0x0,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
lea    -0x28(%rbp),%rdi
xor    %esi,%esi
mov    $0x8,%edx
call   1070 <memset@plt>
movl   $0x0,-0x1d4(%rbp)
movl   $0x0,-0x1f4(%rbp)
lea    -0x1fc(%rbp),%rdi
xor    %esi,%esi
mov    $0x8,%edx
call   1070 <memset@plt>
mov    0xe32(%rip),%ax
mov    %ax,-0x264(%rbp)
movl   $0x0,-0x10(%rbp)
mov    -0x10(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1253 <PLAY_engine+0xe3>
movl   $0x0,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1240 <PLAY_engine+0xd0>
movslq -0x10(%rbp),%rcx
lea    -0x260(%rbp),%rax
imul   $0xa,%rcx,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
movb   $0xb2,(%rax,%rcx,1)
movslq -0x10(%rbp),%rcx
lea    -0x1d0(%rbp),%rax
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    11ef <PLAY_engine+0x7f>
jmp    1245 <PLAY_engine+0xd5>
mov    -0x10(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x10(%rbp)
jmp    11dc <PLAY_engine+0x6c>
jmp    1258 <PLAY_engine+0xe8>
mov    -0x18(%rbp),%eax
mov    %eax,-0x268(%rbp)
mov    -0xc(%rbp),%eax
imul   -0xc(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x268(%rbp),%eax
cmp    %ecx,%eax
jge    1b2d <PLAY_engine+0x9bd>
lea    0xd7b(%rip),%rdi
call   1040 <system@plt>
lea    -0x260(%rbp),%rdi
mov    -0xc(%rbp),%esi
call   1030 <exibe_tabuleiro@plt>
mov    -0x1c(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    12bb <PLAY_engine+0x14b>
movl   $0x0,-0x20(%rbp)
jmp    12c2 <PLAY_engine+0x152>
movl   $0x1,-0x20(%rbp)
mov    -0x20(%rbp),%esi
add    $0x1,%esi
mov    -0x28(%rbp),%ecx
mov    -0x24(%rbp),%r9d
lea    0xd32(%rip),%rdi
mov    $0x1a,%r8d
mov    %r8d,%edx
mov    $0x0,%al
call   1050 <printf@plt>
cmpl   $0x0,-0x1d4(%rbp)
jne    1401 <PLAY_engine+0x291>
lea    0xd5d(%rip),%rdi
mov    $0xa3,%esi
mov    $0x0,%al
call   1050 <printf@plt>
lea    -0x30(%rbp),%rsi
lea    0xd74(%rip),%rdi
call   1090 <scanf@plt>
lea    0xd6b(%rip),%rdi
mov    $0xa3,%esi
mov    $0x0,%al
call   1050 <printf@plt>
lea    -0x38(%rbp),%rsi
lea    0xd51(%rip),%rdi
call   1090 <scanf@plt>
mov    -0x30(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x30(%rbp)
mov    -0x38(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x38(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    13e3 <PLAY_engine+0x273>
cmpl   $0x0,-0x30(%rbp)
jl     13e3 <PLAY_engine+0x273>
mov    -0x38(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    13e3 <PLAY_engine+0x273>
cmpl   $0x0,-0x38(%rbp)
jl     13e3 <PLAY_engine+0x273>
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
imul   $0xa,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
movslq -0x30(%rbp),%rcx
lea    -0x260(%rbp),%rax
imul   $0xa,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
imul   $0xa,%rcx,%rcx
add    %rcx,%rax
movslq -0x38(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x262(%rbp)
mov    -0x30(%rbp),%eax
mov    %eax,-0x1f0(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0x1ec(%rbp)
movl   $0x1,-0x1fc(%rbp)
jmp    13ed <PLAY_engine+0x27d>
movl   $0x0,-0x1fc(%rbp)
mov    -0x1d4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1d4(%rbp)
jmp    1b28 <PLAY_engine+0x9b8>
cmpl   $0x1,-0x1d4(%rbp)
jne    1524 <PLAY_engine+0x3b4>
lea    0xca1(%rip),%rdi
mov    $0xa3,%esi
mov    $0x0,%al
call   1050 <printf@plt>
lea    -0x30(%rbp),%rsi
add    $0x4,%rsi
lea    0xc55(%rip),%rdi
call   1090 <scanf@plt>
lea    0xca7(%rip),%rdi
mov    $0xa3,%esi
mov    $0x0,%al
call   1050 <printf@plt>
lea    -0x38(%rbp),%rsi
add    $0x4,%rsi
lea    0xc2e(%rip),%rdi
call   1090 <scanf@plt>
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1506 <PLAY_engine+0x396>
cmpl   $0x0,-0x2c(%rbp)
jl     1506 <PLAY_engine+0x396>
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1506 <PLAY_engine+0x396>
cmpl   $0x0,-0x34(%rbp)
jl     1506 <PLAY_engine+0x396>
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa,%rcx,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
movslq -0x2c(%rbp),%rcx
lea    -0x260(%rbp),%rax
imul   $0xa,%rcx,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
imul   $0xa,%rcx,%rcx
add    %rcx,%rax
movslq -0x34(%rbp),%rcx
mov    (%rax,%rcx,1),%al
mov    %al,-0x261(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x1e8(%rbp)
mov    -0x34(%rbp),%eax
mov    %eax,-0x1e4(%rbp)
movl   $0x1,-0x1f8(%rbp)
jmp    1510 <PLAY_engine+0x3a0>
movl   $0x0,-0x1f8(%rbp)
mov    -0x1d4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1d4(%rbp)
jmp    1b23 <PLAY_engine+0x9b3>
movl   $0x0,-0x1d4(%rbp)
cmpl   $0x0,-0x1fc(%rbp)
je     1548 <PLAY_engine+0x3d8>
cmpl   $0x0,-0x1f8(%rbp)
jne    1673 <PLAY_engine+0x503>
lea    0xbc1(%rip),%rdi
mov    $0xa0,%esi
mov    $0x87,%edx
mov    $0xe4,%ecx
mov    $0xc6,%r8d
mov    $0x0,%al
call   1050 <printf@plt>
movslq -0x1f0(%rbp),%rcx
lea    -0x1d0(%rbp),%rax
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x1ec(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    15e9 <PLAY_engine+0x479>
mov    -0x1f0(%rbp),%eax
cmp    -0xc(%rbp),%eax
jl     15c9 <PLAY_engine+0x459>
cmpl   $0x0,-0x1f0(%rbp)
jge    15c9 <PLAY_engine+0x459>
mov    -0x1ec(%rbp),%eax
cmp    -0xc(%rbp),%eax
jl     15c9 <PLAY_engine+0x459>
cmpl   $0x0,-0x1ec(%rbp)
jl     15e9 <PLAY_engine+0x479>
movslq -0x1f0(%rbp),%rcx
lea    -0x260(%rbp),%rax
imul   $0xa,%rcx,%rcx
add    %rcx,%rax
movslq -0x1ec(%rbp),%rcx
movb   $0xb2,(%rax,%rcx,1)
movslq -0x1e8(%rbp),%rcx
lea    -0x1d0(%rbp),%rax
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x1e4(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    1667 <PLAY_engine+0x4f7>
mov    -0x1e8(%rbp),%eax
cmp    -0xc(%rbp),%eax
jl     1647 <PLAY_engine+0x4d7>
cmpl   $0x0,-0x1e8(%rbp)
jge    1647 <PLAY_engine+0x4d7>
mov    -0x1e4(%rbp),%eax
cmp    -0xc(%rbp),%eax
jl     1647 <PLAY_engine+0x4d7>
cmpl   $0x0,-0x1e4(%rbp)
jl     1667 <PLAY_engine+0x4f7>
movslq -0x1e8(%rbp),%rcx
lea    -0x260(%rbp),%rax
imul   $0xa,%rcx,%rcx
add    %rcx,%rax
movslq -0x1e4(%rbp),%rcx
movb   $0xb2,(%rax,%rcx,1)
mov    $0x0,%al
call   1080 <getchar@plt>
jmp    1b1e <PLAY_engine+0x9ae>
movsbl -0x262(%rbp),%eax
movsbl -0x261(%rbp),%ecx
cmp    %ecx,%eax
jne    1957 <PLAY_engine+0x7e7>
mov    -0x1f0(%rbp),%eax
cmp    -0x1e8(%rbp),%eax
jne    16ad <PLAY_engine+0x53d>
mov    -0x1ec(%rbp),%eax
cmp    -0x1e4(%rbp),%eax
je     16f9 <PLAY_engine+0x589>
movslq -0x1f0(%rbp),%rcx
lea    -0x1d0(%rbp),%rax
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x1ec(%rbp),%rcx
cmpl   $0x1,(%rax,%rcx,4)
je     16f9 <PLAY_engine+0x589>
movslq -0x1e8(%rbp),%rcx
lea    -0x1d0(%rbp),%rax
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x1e4(%rbp),%rcx
cmpl   $0x1,(%rax,%rcx,4)
jne    17b1 <PLAY_engine+0x641>
lea    0xa4c(%rip),%rdi
mov    $0xa0,%r9d
mov    $0x87,%edx
mov    $0xe4,%ecx
mov    $0xc6,%r8d
mov    %r9d,%esi
mov    $0x0,%al
call   1050 <printf@plt>
movslq -0x1f0(%rbp),%rcx
lea    -0x1d0(%rbp),%rax
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x1ec(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    1766 <PLAY_engine+0x5f6>
movslq -0x1f0(%rbp),%rcx
lea    -0x260(%rbp),%rax
imul   $0xa,%rcx,%rcx
add    %rcx,%rax
movslq -0x1ec(%rbp),%rcx
movb   $0xb2,(%rax,%rcx,1)
movslq -0x1e8(%rbp),%rcx
lea    -0x1d0(%rbp),%rax
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x1e4(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    17ac <PLAY_engine+0x63c>
movslq -0x1e8(%rbp),%rcx
lea    -0x260(%rbp),%rax
imul   $0xa,%rcx,%rcx
add    %rcx,%rax
movslq -0x1e4(%rbp),%rcx
movb   $0xb2,(%rax,%rcx,1)
jmp    194b <PLAY_engine+0x7db>
movsbl -0x262(%rbp),%eax
cmp    $0x40,%eax
jne    1837 <PLAY_engine+0x6c7>
lea    0x9c8(%rip),%rdi
mov    $0x88,%esi
mov    $0x93,%edx
mov    $0x0,%al
call   1050 <printf@plt>
movslq -0x20(%rbp),%rax
mov    -0x28(%rbp,%rax,4),%ecx
add    $0x4,%ecx
mov    %ecx,-0x28(%rbp,%rax,4)
movslq -0x20(%rbp),%rax
movsbl -0x264(%rbp,%rax,1),%eax
ff
cmp    $0x23,%eax
je     1812 <PLAY_engine+0x6a2>
movslq -0x20(%rbp),%rax
movb   $0x23,-0x264(%rbp,%rax,1)
23
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x262(%rbp),%cl
movslq -0x20(%rbp),%rax
mov    %cl,-0x264(%rbp,%rax,1)
mov    -0x1f4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1f4(%rbp)
jmp    18fc <PLAY_engine+0x78c>
movsbl -0x262(%rbp),%eax
cmp    $0x24,%eax
jne    18bd <PLAY_engine+0x74d>
lea    0x966(%rip),%rdi
mov    $0x88,%esi
mov    $0x93,%edx
mov    $0x0,%al
call   1050 <printf@plt>
movslq -0x20(%rbp),%rax
mov    -0x28(%rbp,%rax,4),%ecx
add    $0x7,%ecx
mov    %ecx,-0x28(%rbp,%rax,4)
movslq -0x20(%rbp),%rax
movsbl -0x264(%rbp,%rax,1),%eax
ff
cmp    $0x23,%eax
je     1898 <PLAY_engine+0x728>
movslq -0x20(%rbp),%rax
movb   $0x23,-0x264(%rbp,%rax,1)
23
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x262(%rbp),%cl
movslq -0x20(%rbp),%rax
mov    %cl,-0x264(%rbp,%rax,1)
mov    -0x1f4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1f4(%rbp)
jmp    18f7 <PLAY_engine+0x787>
lea    0x914(%rip),%rdi
mov    $0x88,%esi
mov    $0x0,%al
call   1050 <printf@plt>
movslq -0x20(%rbp),%rax
mov    -0x28(%rbp,%rax,4),%ecx
add    $0x2,%ecx
mov    %ecx,-0x28(%rbp,%rax,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1f4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1f4(%rbp)
jmp    18fc <PLAY_engine+0x78c>
movslq -0x1f0(%rbp),%rcx
lea    -0x1d0(%rbp),%rax
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x1ec(%rbp),%rcx
movl   $0x1,(%rax,%rcx,4)
movslq -0x1e8(%rbp),%rcx
lea    -0x1d0(%rbp),%rax
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x1e4(%rbp),%rcx
movl   $0x1,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
mov    $0x0,%al
call   1080 <getchar@plt>
jmp    1b19 <PLAY_engine+0x9a9>
mov    -0x1f0(%rbp),%eax
cmp    -0x1e8(%rbp),%eax
jne    197b <PLAY_engine+0x80b>
mov    -0x1ec(%rbp),%eax
cmp    -0x1e4(%rbp),%eax
je     19c7 <PLAY_engine+0x857>
movslq -0x1f0(%rbp),%rcx
lea    -0x1d0(%rbp),%rax
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x1ec(%rbp),%rcx
cmpl   $0x1,(%rax,%rcx,4)
je     19c7 <PLAY_engine+0x857>
movslq -0x1e8(%rbp),%rcx
lea    -0x1d0(%rbp),%rax
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x1e4(%rbp),%rcx
cmpl   $0x1,(%rax,%rcx,4)
jne    19f3 <PLAY_engine+0x883>
lea    0x77e(%rip),%rdi
mov    $0xa0,%r9d
mov    $0x87,%edx
mov    $0xe4,%ecx
mov    $0xc6,%r8d
mov    %r9d,%esi
mov    $0x0,%al
call   1050 <printf@plt>
jmp    1a86 <PLAY_engine+0x916>
lea    0x7f6(%rip),%rdi
mov    $0x88,%esi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x1f4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1f4(%rbp)
movsbl -0x262(%rbp),%eax
cmp    $0x40,%eax
jne    1a42 <PLAY_engine+0x8d2>
movslq -0x20(%rbp),%rax
mov    -0x28(%rbp,%rax,4),%ecx
sub    $0x4,%ecx
mov    %ecx,-0x28(%rbp,%rax,4)
lea    0x7c3(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
movsbl -0x262(%rbp),%eax
cmp    $0x24,%eax
jne    1a6f <PLAY_engine+0x8ff>
movslq -0x20(%rbp),%rax
mov    -0x28(%rbp,%rax,4),%ecx
sub    $0x7,%ecx
mov    %ecx,-0x28(%rbp,%rax,4)
lea    0x7a0(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
lea    0x778(%rip),%rdi
mov    $0x0,%al
call   1050 <printf@plt>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
movslq -0x1f0(%rbp),%rcx
lea    -0x1d0(%rbp),%rax
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x1ec(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    1acc <PLAY_engine+0x95c>
movslq -0x1f0(%rbp),%rcx
lea    -0x260(%rbp),%rax
imul   $0xa,%rcx,%rcx
add    %rcx,%rax
movslq -0x1ec(%rbp),%rcx
movb   $0xb2,(%rax,%rcx,1)
movslq -0x1e8(%rbp),%rcx
lea    -0x1d0(%rbp),%rax
imul   $0x28,%rcx,%rcx
add    %rcx,%rax
movslq -0x1e4(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    1b12 <PLAY_engine+0x9a2>
movslq -0x1e8(%rbp),%rcx
lea    -0x260(%rbp),%rax
imul   $0xa,%rcx,%rcx
add    %rcx,%rax
movslq -0x1e4(%rbp),%rcx
movb   $0xb2,(%rax,%rcx,1)
mov    $0x0,%al
call   1080 <getchar@plt>
jmp    1b1e <PLAY_engine+0x9ae>
jmp    1b23 <PLAY_engine+0x9b3>
jmp    1b28 <PLAY_engine+0x9b8>
jmp    1258 <PLAY_engine+0xe8>
lea    -0x28(%rbp),%rdi
mov    -0x1f4(%rbp),%esi
call   1060 <finaliza@plt>
add    $0x270,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<PLAY_engine>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x268,%rsp
mov    %rdi,0x58(%rsp)
movq   $0x0,0x28(%rsp)
movw   $0x2323,0x6(%rsp)
mov    %esi,0xc(%rsp)
test   %esi,%esi
jle    1320 <PLAY_engine+0x1a0>
mov    0xc(%rsp),%r13d
lea    0x0(,%r13,4),%r15
lea    -0x1(%r13),%rax
mov    %r13d,%ecx
and    $0x3,%ecx
mov    %rcx,0x48(%rsp)
cmp    $0x3,%rax
jae    11db <PLAY_engine+0x5b>
xor    %ebp,%ebp
jmp    12b5 <PLAY_engine+0x135>
mov    %r13d,%r12d
and    $0xfffffffc,%r12d
xor    %r14d,%r14d
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
lea    (%rsp,%r14,1),%rdi
add    $0x60,%rdi
lea    (%rsp,%r14,4),%rbx
add    $0xd0,%rbx
mov    $0xb2,%esi
mov    %r13,%rdx
call   1080 <memset@plt>
mov    %rbx,%rdi
xor    %esi,%esi
mov    %r15,%rdx
call   1080 <memset@plt>
lea    (%rsp,%r14,1),%rdi
add    $0x6a,%rdi
lea    (%rsp,%r14,4),%rbx
add    $0xf8,%rbx
mov    $0xb2,%esi
mov    %r13,%rdx
call   1080 <memset@plt>
mov    %rbx,%rdi
xor    %esi,%esi
mov    %r15,%rdx
call   1080 <memset@plt>
lea    (%rsp,%r14,1),%rdi
add    $0x74,%rdi
lea    (%rsp,%r14,4),%rbx
add    $0x120,%rbx
mov    $0xb2,%esi
mov    %r13,%rdx
call   1080 <memset@plt>
mov    %rbx,%rdi
xor    %esi,%esi
mov    %r15,%rdx
call   1080 <memset@plt>
lea    (%rsp,%r14,1),%rdi
add    $0x7e,%rdi
lea    (%rsp,%r14,4),%rbx
add    $0x148,%rbx
mov    $0xb2,%esi
mov    %r13,%rdx
call   1080 <memset@plt>
mov    %rbx,%rdi
xor    %esi,%esi
mov    %r15,%rdx
call   1080 <memset@plt>
add    $0x4,%rbp
add    $0x28,%r14
cmp    %rbp,%r12
jne    11f0 <PLAY_engine+0x70>
mov    0x48(%rsp),%rcx
test   %rcx,%rcx
je     1320 <PLAY_engine+0x1a0>
lea    0x0(,%rbp,4),%rax
add    %rbp,%rax
lea    (%rsp,%rax,8),%rdx
add    $0xd0,%rdx
mov    %rdx,0x20(%rsp)
lea    (%rsp,%rax,2),%r12
add    $0x60,%r12
add    %rcx,%rcx
lea    (%rcx,%rcx,4),%rbp
xor    %r14d,%r14d
nopl   0x0(%rax)
lea    (%r12,%r14,1),%rdi
mov    0x20(%rsp),%rax
lea    (%rax,%r14,4),%rbx
mov    $0xb2,%esi
mov    %r13,%rdx
call   1080 <memset@plt>
mov    %rbx,%rdi
xor    %esi,%esi
mov    %r15,%rdx
call   1080 <memset@plt>
add    $0xa,%r14
cmp    %r14,%rbp
jne    12f0 <PLAY_engine+0x170>
mov    0xc(%rsp),%r14d
mov    %r14d,%eax
imul   %r14d,%eax
xor    %esi,%esi
cmp    $0x2,%eax
jb     19a0 <PLAY_engine+0x820>
shr    %eax
mov    %eax,0x54(%rsp)
mov    $0x0,%ebx
mov    $0x0,%r13d
movl   $0x0,0x10(%rsp)
xor    %r12d,%r12d
movl   $0x0,0x34(%rsp)
xor    %ebp,%ebp
xor    %eax,%eax
mov    %rax,0x20(%rsp)
movl   $0x0,0x48(%rsp)
nopl   0x0(%rax)
lea    0xc89(%rip),%rdi
call   1050 <system@plt>
lea    0x60(%rsp),%rdi
mov    %r14d,%esi
call   1040 <exibe_tabuleiro@plt>
mov    0x20(%rsp),%r15
and    $0x1,%r15d
lea    0x1(%r15),%esi
lea    0xc69(%rip),%rdi
mov    $0x1a,%edx
mov    %r13d,%ecx
mov    $0x1a,%r8d
mov    %ebx,%r9d
xor    %eax,%eax
call   1060 <printf@plt>
cmp    $0x1,%ebp
je     1490 <PLAY_engine+0x310>
test   %ebp,%ebp
jne    1560 <PLAY_engine+0x3e0>
xor    %r12d,%r12d
lea    0xc85(%rip),%rdi
mov    $0xa3,%esi
xor    %eax,%eax
call   1060 <printf@plt>
lea    0xca0(%rip),%rbx
mov    %rbx,%rdi
lea    0x40(%rsp),%rsi
call   10a0 <scanf@plt>
lea    0xc8f(%rip),%rdi
mov    $0xa3,%esi
xor    %eax,%eax
call   1060 <printf@plt>
mov    %rbx,%rdi
lea    0x38(%rsp),%rsi
call   10a0 <scanf@plt>
mov    0x40(%rsp),%esi
lea    -0x1(%rsi),%eax
mov    %eax,0x40(%rsp)
mov    0x38(%rsp),%edx
lea    -0x1(%rdx),%ecx
mov    %ecx,0x38(%rsp)
mov    $0x1,%ebp
cmp    %r14d,%esi
jg     1940 <PLAY_engine+0x7c0>
test   %esi,%esi
jle    1940 <PLAY_engine+0x7c0>
cmp    %r14d,%edx
jg     1940 <PLAY_engine+0x7c0>
test   %edx,%edx
jle    1940 <PLAY_engine+0x7c0>
mov    %eax,%edx
mov    %ecx,%esi
add    %rdx,%rdx
lea    (%rdx,%rdx,4),%rdx
mov    0x58(%rsp),%rdi
add    %rdx,%rdi
movzbl (%rsi,%rdi,1),%ebx
lea    0x60(%rsp,%rdx,1),%rdx
mov    %bl,0x4(%rsp)
mov    %bl,(%rsi,%rdx,1)
mov    $0x1,%ebp
mov    %ecx,0x18(%rsp)
mov    %eax,0x1c(%rsp)
mov    $0x1,%r12d
jmp    1940 <PLAY_engine+0x7c0>
nopl   0x0(%rax,%rax,1)
movl   $0x0,0x10(%rsp)
lea    0xc15(%rip),%rdi
mov    $0xa3,%esi
xor    %eax,%eax
call   1060 <printf@plt>
lea    0xbd1(%rip),%rbx
mov    %rbx,%rdi
lea    0x44(%rsp),%rsi
call   10a0 <scanf@plt>
lea    0xc1b(%rip),%rdi
mov    $0xa3,%esi
xor    %eax,%eax
call   1060 <printf@plt>
mov    %rbx,%rdi
lea    0x3c(%rsp),%rsi
call   10a0 <scanf@plt>
mov    0x44(%rsp),%esi
lea    -0x1(%rsi),%eax
mov    %eax,0x44(%rsp)
mov    0x3c(%rsp),%edx
lea    -0x1(%rdx),%ecx
mov    %ecx,0x3c(%rsp)
mov    $0x2,%ebp
cmp    %r14d,%esi
jg     1940 <PLAY_engine+0x7c0>
test   %esi,%esi
jle    1940 <PLAY_engine+0x7c0>
cmp    %r14d,%edx
jg     1940 <PLAY_engine+0x7c0>
test   %edx,%edx
jle    1940 <PLAY_engine+0x7c0>
mov    %eax,%edx
mov    %ecx,%esi
add    %rdx,%rdx
lea    (%rdx,%rdx,4),%rdx
mov    0x58(%rsp),%rdi
add    %rdx,%rdi
movzbl (%rsi,%rdi,1),%ebx
lea    0x60(%rsp,%rdx,1),%rdx
mov    %bl,0x5(%rsp)
mov    %bl,(%rsi,%rdx,1)
movl   $0x1,0x10(%rsp)
mov    %ecx,0x8(%rsp)
mov    %eax,0x14(%rsp)
jmp    1940 <PLAY_engine+0x7c0>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movslq 0x1c(%rsp),%rbp
movslq 0x18(%rsp),%rbx
test   %r12d,%r12d
je     1676 <PLAY_engine+0x4f6>
cmpl   $0x0,0x10(%rsp)
je     1676 <PLAY_engine+0x4f6>
mov    0x1c(%rsp),%eax
mov    0x14(%rsp),%esi
xor    %esi,%eax
mov    0x18(%rsp),%ecx
mov    0x8(%rsp),%edx
xor    %edx,%ecx
or     %eax,%ecx
sete   %al
movzbl 0x4(%rsp),%ecx
cmp    0x5(%rsp),%cl
jne    172f <PLAY_engine+0x5af>
test   %al,%al
jne    15ec <PLAY_engine+0x46c>
lea    0x0(,%rbp,4),%rax
add    %rbp,%rax
lea    (%rsp,%rax,8),%r14
add    $0xd0,%r14
cmpl   $0x1,(%r14,%rbx,4)
je     15ec <PLAY_engine+0x46c>
movslq 0x14(%rsp),%rax
movslq 0x8(%rsp),%r12
lea    (%rax,%rax,4),%rax
lea    (%rsp,%rax,8),%r13
add    $0xd0,%r13
cmpl   $0x1,0x0(%r13,%r12,4)
jne    1821 <PLAY_engine+0x6a1>
lea    0xb57(%rip),%rdi
mov    $0xa0,%esi
mov    $0x87,%edx
mov    $0xe4,%ecx
mov    $0xc6,%r8d
mov    $0xa0,%r9d
xor    %eax,%eax
call   1060 <printf@plt>
lea    0x0(,%rbp,4),%rax
add    %rbp,%rax
lea    (%rsp,%rax,8),%rcx
add    $0xd0,%rcx
cmpl   $0x0,(%rcx,%rbx,4)
jne    163d <PLAY_engine+0x4bd>
lea    (%rsp,%rax,2),%rax
add    $0x60,%rax
movb   $0xb2,(%rbx,%rax,1)
movslq 0x14(%rsp),%rcx
movslq 0x8(%rsp),%rax
lea    (%rcx,%rcx,4),%rcx
lea    (%rsp,%rcx,8),%rdx
add    $0xd0,%rdx
cmpl   $0x0,(%rdx,%rax,4)
mov    0xc(%rsp),%r14d
jne    191f <PLAY_engine+0x79f>
lea    (%rsp,%rcx,2),%rcx
add    $0x60,%rcx
movb   $0xb2,(%rax,%rcx,1)
jmp    191f <PLAY_engine+0x79f>
lea    0xa91(%rip),%rdi
mov    $0xa0,%esi
mov    $0x87,%edx
mov    $0xe4,%ecx
mov    $0xc6,%r8d
xor    %eax,%eax
call   1060 <printf@plt>
lea    0x0(,%rbp,4),%rax
add    %rbp,%rax
lea    (%rsp,%rax,8),%rcx
add    $0xd0,%rcx
cmpl   $0x0,(%rcx,%rbx,4)
jne    16dd <PLAY_engine+0x55d>
cmp    %r14d,0x1c(%rsp)
jl     16d1 <PLAY_engine+0x551>
cmpl   $0x0,0x1c(%rsp)
jns    16d1 <PLAY_engine+0x551>
cmp    %r14d,0x18(%rsp)
jl     16d1 <PLAY_engine+0x551>
cmpl   $0x0,0x18(%rsp)
js     16dd <PLAY_engine+0x55d>
lea    (%rsp,%rax,2),%rax
add    $0x60,%rax
movb   $0xb2,(%rbx,%rax,1)
mov    0x14(%rsp),%esi
movslq %esi,%rcx
movslq 0x8(%rsp),%rax
lea    (%rcx,%rcx,4),%rcx
lea    (%rsp,%rcx,8),%rdx
add    $0xd0,%rdx
cmpl   $0x0,(%rdx,%rax,4)
jne    1721 <PLAY_engine+0x5a1>
cmp    %r14d,%esi
jl     1715 <PLAY_engine+0x595>
test   %esi,%esi
jns    1715 <PLAY_engine+0x595>
cmp    %r14d,0x8(%rsp)
jl     1715 <PLAY_engine+0x595>
cmpl   $0x0,0x8(%rsp)
js     1721 <PLAY_engine+0x5a1>
lea    (%rsp,%rcx,2),%rcx
add    $0x60,%rcx
movb   $0xb2,(%rax,%rcx,1)
xor    %ebp,%ebp
xor    %eax,%eax
call   1090 <getchar@plt>
jmp    1940 <PLAY_engine+0x7c0>
movslq %esi,%r13
movslq %edx,%r12
test   %al,%al
jne    1778 <PLAY_engine+0x5f8>
lea    0x0(,%rbp,4),%rax
add    %rbp,%rax
lea    (%rsp,%rax,8),%rax
add    $0xd0,%rax
mov    (%rax,%rbx,4),%r14d
cmp    $0x1,%r14d
je     1778 <PLAY_engine+0x5f8>
lea    0x0(,%r13,4),%rax
add    %r13,%rax
lea    (%rsp,%rax,8),%rax
add    $0xd0,%rax
cmpl   $0x1,(%rax,%r12,4)
jne    1861 <PLAY_engine+0x6e1>
lea    0x9cb(%rip),%rdi
mov    $0xa0,%esi
mov    $0x87,%edx
mov    $0xe4,%ecx
mov    $0xc6,%r8d
mov    $0xa0,%r9d
xor    %eax,%eax
call   1060 <printf@plt>
lea    0x0(,%rbp,4),%rax
add    %rbp,%rax
lea    (%rsp,%rax,8),%rax
add    $0xd0,%rax
mov    (%rax,%rbx,4),%r14d
test   %r14d,%r14d
jne    17d6 <PLAY_engine+0x656>
lea    0x0(,%rbp,4),%rax
add    %rbp,%rax
lea    (%rsp,%rax,2),%rax
add    $0x60,%rax
movb   $0xb2,(%rbx,%rax,1)
lea    0x0(,%r13,4),%rax
add    %r13,%rax
lea    (%rsp,%rax,8),%rcx
add    $0xd0,%rcx
cmpl   $0x0,(%rcx,%r12,4)
mov    0xc(%rsp),%r14d
jne    1805 <PLAY_engine+0x685>
lea    (%rsp,%rax,2),%rax
add    $0x60,%rax
movb   $0xb2,(%r12,%rax,1)
xor    %ebp,%ebp
xor    %eax,%eax
call   1090 <getchar@plt>
mov    $0x1,%r12d
movl   $0x1,0x10(%rsp)
jmp    1940 <PLAY_engine+0x7c0>
cmp    $0x24,%cl
je     189a <PLAY_engine+0x71a>
cmp    $0x40,%cl
jne    18c9 <PLAY_engine+0x749>
lea    0x958(%rip),%rdi
mov    $0x88,%esi
mov    $0x93,%edx
xor    %eax,%eax
call   1060 <printf@plt>
addl   $0x4,0x28(%rsp,%r15,4)
cmpb   $0x23,0x6(%rsp,%r15,1)
setne  %al
movb   $0x40,0x6(%rsp,%r15,1)
jmp    18e6 <PLAY_engine+0x766>
lea    0x986(%rip),%rdi
mov    $0x88,%esi
xor    %eax,%eax
call   1060 <printf@plt>
movzbl 0x4(%rsp),%eax
cmp    $0x40,%al
je     1958 <PLAY_engine+0x7d8>
cmp    $0x24,%al
jne    1972 <PLAY_engine+0x7f2>
mov    $0xfffffff9,%eax
lea    0x971(%rip),%rdi
jmp    1964 <PLAY_engine+0x7e4>
lea    0x911(%rip),%rdi
mov    $0x88,%esi
mov    $0x93,%edx
xor    %eax,%eax
call   1060 <printf@plt>
addl   $0x7,0x28(%rsp,%r15,4)
cmpb   $0x23,0x6(%rsp,%r15,1)
setne  %al
movb   $0x24,0x6(%rsp,%r15,1)
jmp    18e6 <PLAY_engine+0x766>
lea    0x906(%rip),%rdi
mov    $0x88,%esi
xor    %eax,%eax
call   1060 <printf@plt>
mov    %r15d,%eax
addl   $0x2,0x28(%rsp,%rax,4)
mov    $0x1,%al
lea    (%r14,%rbx,4),%rcx
lea    0x0(,%r12,4),%rdx
add    %r13,%rdx
movzbl %al,%eax
mov    0x20(%rsp),%rsi
add    %eax,%esi
mov    %rsi,0x20(%rsp)
addl   $0x1,0x34(%rsp)
movl   $0x1,(%rcx)
movl   $0x1,(%rdx)
addl   $0x1,0x48(%rsp)
mov    0xc(%rsp),%r14d
xor    %ebp,%ebp
xor    %eax,%eax
call   1090 <getchar@plt>
mov    $0x1,%r12d
movl   $0x1,0x10(%rsp)
movzbl 0x4(%rsp),%eax
mov    %al,0x5(%rsp)
nop
mov    0x48(%rsp),%eax
cmp    0x54(%rsp),%eax
jge    199c <PLAY_engine+0x81c>
mov    0x28(%rsp),%r13d
mov    0x2c(%rsp),%ebx
jmp    1370 <PLAY_engine+0x1f0>
mov    $0xfffffffc,%eax
lea    0x898(%rip),%rdi
mov    %r15d,%ecx
add    %eax,0x28(%rsp,%rcx,4)
xor    %eax,%eax
call   1060 <printf@plt>
addl   $0x1,0x34(%rsp)
mov    $0x21,%edi
call   1030 <putchar@plt>
mov    0x20(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x20(%rsp)
test   %r14d,%r14d
jne    17d6 <PLAY_engine+0x656>
jmp    17bf <PLAY_engine+0x63f>
mov    0x34(%rsp),%esi
lea    0x28(%rsp),%rdi
call   1070 <finaliza@plt>
add    $0x268,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@__const.PLAY_engine.historico = [2 x i8] c"##"
@.str = [6 x i8] c"clear\00"
@.str.1 = [79 x i8] c"\0AVez: Jogador %d Pontos: |Jogador 1%c %d| |Jogador 2%c %d|\0A \00"
@.str.2 = [46 x i8] c"\0ADigite o n%cmero da linha do primeiro item: \00"
@.str.3 = [3 x i8] c"%d\00"
@.str.4 = [46 x i8] c"Digite o n%cmero da coluna do primeiro item: \00"
@.str.5 = [45 x i8] c"\0ADigite o n%cmero da linha do segundo item: \00"
@.str.6 = [45 x i8] c"Digite o n%cmero da coluna do segundo item: \00"
@.str.7 = [60 x i8] c"\0AJogada inv%clida! As posi%c%ces n%co existem no tabuleiro.\00"
@.str.8 = [68 x i8] c"\0AJogada inv%clida! As posi%c%ces s%co iguais, ou j%c foram jogadas.\00"
@.str.9 = [36 x i8] c"\0AVoc%c ganhou o b%cnus de 4 pontos!\00"
@.str.10 = [36 x i8] c"\0AVoc%c ganhou o b%cnus de 7 pontos!\00"
@.str.11 = [24 x i8] c"\0AVoc%c ganhou 2 pontos!\00"
@.str.12 = [14 x i8] c"\0AVoc%c perdeu\00"
@.str.13 = [10 x i8] c" 4 pontos\00"
@.str.14 = [10 x i8] c" 7 pontos\00"
@.str.15 = [2 x i8] c"!\00"
define void @PLAY_engine([10 x i8]* %0, i32 %1) {
%3 = alloca [10 x i8]*
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca [2 x i32]
%11 = alloca [2 x i32]
%12 = alloca [2 x i32]
%13 = alloca [10 x [10 x i32]]
%14 = alloca i32
%15 = alloca [2 x [2 x i32]]
%16 = alloca i32
%17 = alloca [2 x i32]
%18 = alloca [10 x [10 x i8]]
%19 = alloca [2 x i8]
%20 = alloca [2 x i8]
store [10 x i8]* %0, [10 x i8]** %3
store i32 %1, i32* %4
store i32 0, i32* %7
store i32 0, i32* %8
%21 = bitcast [2 x i32]* %10 to i8*
store i32 0, i32* %14
store i32 0, i32* %16
%22 = bitcast [2 x i32]* %17 to i8*
%23 = bitcast [2 x i8]* %20 to i8*
store i32 0, i32* %5
br label %24
24: ; preds = %50, %2
%25 = load i32, i32* %5
%26 = load i32, i32* %4
%27 = icmp slt i32 %25, %26
br i1 %27, label %28, label %53
28: ; preds = %24
store i32 0, i32* %6
br label %29
29: ; preds = %46, %28
%30 = load i32, i32* %6
%31 = load i32, i32* %4
%32 = icmp slt i32 %30, %31
br i1 %32, label %33, label %49
33: ; preds = %29
%34 = load i32, i32* %5
%35 = sext i32 %34 to i64
%36 = getelementptr inbounds [10 x [10 x i8]], [10 x [10 x i8]]* %18, i64 0, i64 %35
%37 = load i32, i32* %6
%38 = sext i32 %37 to i64
%39 = getelementptr inbounds [10 x i8], [10 x i8]* %36, i64 0, i64 %38
store i8 -78, i8* %39
%40 = load i32, i32* %5
%41 = sext i32 %40 to i64
%42 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %13, i64 0, i64 %41
%43 = load i32, i32* %6
%44 = sext i32 %43 to i64
%45 = getelementptr inbounds [10 x i32], [10 x i32]* %42, i64 0, i64 %44
store i32 0, i32* %45
br label %46
46: ; preds = %33
%47 = load i32, i32* %6
%48 = add nsw i32 %47, 1
store i32 %48, i32* %6
br label %29
49: ; preds = %29
br label %50
50: ; preds = %49
%51 = load i32, i32* %5
%52 = add nsw i32 %51, 1
store i32 %52, i32* %5
br label %24
53: ; preds = %24
br label %54
54: ; preds = %665, %53
%55 = load i32, i32* %7
%56 = load i32, i32* %4
%57 = load i32, i32* %4
%58 = mul nsw i32 %56, %57
%59 = sdiv i32 %58, 2
%60 = icmp slt i32 %55, %59
br i1 %60, label %61, label %666
61: ; preds = %54
%62 = call i32 @system(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0))
%63 = getelementptr inbounds [10 x [10 x i8]], [10 x [10 x i8]]* %18, i64 0, i64 0
%64 = bitcast [10 x i8]* %63 to i8**
%65 = load i32, i32* %4
%66 = call i32 @exibe_tabuleiro(i8** %64, i32 %65)
%67 = load i32, i32* %8
%68 = srem i32 %67, 2
%69 = icmp eq i32 %68, 0
br i1 %69, label %70, label %71
70: ; preds = %61
store i32 0, i32* %9
br label %72
71: ; preds = %61
store i32 1, i32* %9
br label %72
72: ; preds = %71, %70
%73 = load i32, i32* %9
%74 = add nsw i32 %73, 1
%75 = getelementptr inbounds [2 x i32], [2 x i32]* %10, i64 0, i64 0
%76 = load i32, i32* %75
%77 = getelementptr inbounds [2 x i32], [2 x i32]* %10, i64 0, i64 1
%78 = load i32, i32* %77
%79 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([79 x i8], [79 x i8]* @.str.1, i64 0, i64 0), i32 %74, i32 26, i32 %76, i32 26, i32 %78)
%80 = load i32, i32* %14
%81 = icmp eq i32 %80, 0
br i1 %81, label %82, label %156
82: ; preds = %72
%83 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.2, i64 0, i64 0), i32 163)
%84 = getelementptr inbounds [2 x i32], [2 x i32]* %11, i64 0, i64 0
%85 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), i32* %84)
%86 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.4, i64 0, i64 0), i32 163)
%87 = getelementptr inbounds [2 x i32], [2 x i32]* %12, i64 0, i64 0
%88 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), i32* %87)
%89 = getelementptr inbounds [2 x i32], [2 x i32]* %11, i64 0, i64 0
%90 = load i32, i32* %89
%91 = add nsw i32 %90, -1
store i32 %91, i32* %89
%92 = getelementptr inbounds [2 x i32], [2 x i32]* %12, i64 0, i64 0
%93 = load i32, i32* %92
%94 = add nsw i32 %93, -1
store i32 %94, i32* %92
%95 = getelementptr inbounds [2 x i32], [2 x i32]* %11, i64 0, i64 0
%96 = load i32, i32* %95
%97 = load i32, i32* %4
%98 = icmp slt i32 %96, %97
br i1 %98, label %99, label %151
99: ; preds = %82
%100 = getelementptr inbounds [2 x i32], [2 x i32]* %11, i64 0, i64 0
%101 = load i32, i32* %100
%102 = icmp sge i32 %101, 0
br i1 %102, label %103, label %151
103: ; preds = %99
%104 = getelementptr inbounds [2 x i32], [2 x i32]* %12, i64 0, i64 0
%105 = load i32, i32* %104
%106 = load i32, i32* %4
%107 = icmp slt i32 %105, %106
br i1 %107, label %108, label %151
108: ; preds = %103
%109 = getelementptr inbounds [2 x i32], [2 x i32]* %12, i64 0, i64 0
%110 = load i32, i32* %109
%111 = icmp sge i32 %110, 0
br i1 %111, label %112, label %151
112: ; preds = %108
%113 = load [10 x i8]*, [10 x i8]** %3
%114 = getelementptr inbounds [2 x i32], [2 x i32]* %11, i64 0, i64 0
%115 = load i32, i32* %114
%116 = sext i32 %115 to i64
%117 = getelementptr inbounds [10 x i8], [10 x i8]* %113, i64 %116
%118 = getelementptr inbounds [2 x i32], [2 x i32]* %12, i64 0, i64 0
%119 = load i32, i32* %118
%120 = sext i32 %119 to i64
%121 = getelementptr inbounds [10 x i8], [10 x i8]* %117, i64 0, i64 %120
%122 = load i8, i8* %121
%123 = getelementptr inbounds [2 x i32], [2 x i32]* %11, i64 0, i64 0
%124 = load i32, i32* %123
%125 = sext i32 %124 to i64
%126 = getelementptr inbounds [10 x [10 x i8]], [10 x [10 x i8]]* %18, i64 0, i64 %125
%127 = getelementptr inbounds [2 x i32], [2 x i32]* %12, i64 0, i64 0
%128 = load i32, i32* %127
%129 = sext i32 %128 to i64
%130 = getelementptr inbounds [10 x i8], [10 x i8]* %126, i64 0, i64 %129
store i8 %122, i8* %130
%131 = load [10 x i8]*, [10 x i8]** %3
%132 = getelementptr inbounds [2 x i32], [2 x i32]* %11, i64 0, i64 0
%133 = load i32, i32* %132
%134 = sext i32 %133 to i64
%135 = getelementptr inbounds [10 x i8], [10 x i8]* %131, i64 %134
%136 = getelementptr inbounds [2 x i32], [2 x i32]* %12, i64 0, i64 0
%137 = load i32, i32* %136
%138 = sext i32 %137 to i64
%139 = getelementptr inbounds [10 x i8], [10 x i8]* %135, i64 0, i64 %138
%140 = load i8, i8* %139
%141 = getelementptr inbounds [2 x i8], [2 x i8]* %19, i64 0, i64 0
store i8 %140, i8* %141
%142 = getelementptr inbounds [2 x i32], [2 x i32]* %11, i64 0, i64 0
%143 = load i32, i32* %142
%144 = getelementptr inbounds [2 x [2 x i32]], [2 x [2 x i32]]* %15, i64 0, i64 0
%145 = getelementptr inbounds [2 x i32], [2 x i32]* %144, i64 0, i64 0
store i32 %143, i32* %145
%146 = getelementptr inbounds [2 x i32], [2 x i32]* %12, i64 0, i64 0
%147 = load i32, i32* %146
%148 = getelementptr inbounds [2 x [2 x i32]], [2 x [2 x i32]]* %15, i64 0, i64 0
%149 = getelementptr inbounds [2 x i32], [2 x i32]* %148, i64 0, i64 1
store i32 %147, i32* %149
%150 = getelementptr inbounds [2 x i32], [2 x i32]* %17, i64 0, i64 0
store i32 1, i32* %150
br label %153
151: ; preds = %108, %103, %99, %82
%152 = getelementptr inbounds [2 x i32], [2 x i32]* %17, i64 0, i64 0
store i32 0, i32* %152
br label %153
153: ; preds = %151, %112
%154 = load i32, i32* %14
%155 = add nsw i32 %154, 1
store i32 %155, i32* %14
br label %665
156: ; preds = %72
%157 = load i32, i32* %14
%158 = icmp eq i32 %157, 1
br i1 %158, label %159, label %233
159: ; preds = %156
%160 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([45 x i8], [45 x i8]* @.str.5, i64 0, i64 0), i32 163)
%161 = getelementptr inbounds [2 x i32], [2 x i32]* %11, i64 0, i64 1
%162 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), i32* %161)
%163 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([45 x i8], [45 x i8]* @.str.6, i64 0, i64 0), i32 163)
%164 = getelementptr inbounds [2 x i32], [2 x i32]* %12, i64 0, i64 1
%165 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), i32* %164)
%166 = getelementptr inbounds [2 x i32], [2 x i32]* %11, i64 0, i64 1
%167 = load i32, i32* %166
%168 = add nsw i32 %167, -1
store i32 %168, i32* %166
%169 = getelementptr inbounds [2 x i32], [2 x i32]* %12, i64 0, i64 1
%170 = load i32, i32* %169
%171 = add nsw i32 %170, -1
store i32 %171, i32* %169
%172 = getelementptr inbounds [2 x i32], [2 x i32]* %11, i64 0, i64 1
%173 = load i32, i32* %172
%174 = load i32, i32* %4
%175 = icmp slt i32 %173, %174
br i1 %175, label %176, label %228
176: ; preds = %159
%177 = getelementptr inbounds [2 x i32], [2 x i32]* %11, i64 0, i64 1
%178 = load i32, i32* %177
%179 = icmp sge i32 %178, 0
br i1 %179, label %180, label %228
180: ; preds = %176
%181 = getelementptr inbounds [2 x i32], [2 x i32]* %12, i64 0, i64 1
%182 = load i32, i32* %181
%183 = load i32, i32* %4
%184 = icmp slt i32 %182, %183
br i1 %184, label %185, label %228
185: ; preds = %180
%186 = getelementptr inbounds [2 x i32], [2 x i32]* %12, i64 0, i64 1
%187 = load i32, i32* %186
%188 = icmp sge i32 %187, 0
br i1 %188, label %189, label %228
189: ; preds = %185
%190 = load [10 x i8]*, [10 x i8]** %3
%191 = getelementptr inbounds [2 x i32], [2 x i32]* %11, i64 0, i64 1
%192 = load i32, i32* %191
%193 = sext i32 %192 to i64
%194 = getelementptr inbounds [10 x i8], [10 x i8]* %190, i64 %193
%195 = getelementptr inbounds [2 x i32], [2 x i32]* %12, i64 0, i64 1
%196 = load i32, i32* %195
%197 = sext i32 %196 to i64
%198 = getelementptr inbounds [10 x i8], [10 x i8]* %194, i64 0, i64 %197
%199 = load i8, i8* %198
%200 = getelementptr inbounds [2 x i32], [2 x i32]* %11, i64 0, i64 1
%201 = load i32, i32* %200
%202 = sext i32 %201 to i64
%203 = getelementptr inbounds [10 x [10 x i8]], [10 x [10 x i8]]* %18, i64 0, i64 %202
%204 = getelementptr inbounds [2 x i32], [2 x i32]* %12, i64 0, i64 1
%205 = load i32, i32* %204
%206 = sext i32 %205 to i64
%207 = getelementptr inbounds [10 x i8], [10 x i8]* %203, i64 0, i64 %206
store i8 %199, i8* %207
%208 = load [10 x i8]*, [10 x i8]** %3
%209 = getelementptr inbounds [2 x i32], [2 x i32]* %11, i64 0, i64 1
%210 = load i32, i32* %209
%211 = sext i32 %210 to i64
%212 = getelementptr inbounds [10 x i8], [10 x i8]* %208, i64 %211
%213 = getelementptr inbounds [2 x i32], [2 x i32]* %12, i64 0, i64 1
%214 = load i32, i32* %213
%215 = sext i32 %214 to i64
%216 = getelementptr inbounds [10 x i8], [10 x i8]* %212, i64 0, i64 %215
%217 = load i8, i8* %216
%218 = getelementptr inbounds [2 x i8], [2 x i8]* %19, i64 0, i64 1
store i8 %217, i8* %218
%219 = getelementptr inbounds [2 x i32], [2 x i32]* %11, i64 0, i64 1
%220 = load i32, i32* %219
%221 = getelementptr inbounds [2 x [2 x i32]], [2 x [2 x i32]]* %15, i64 0, i64 1
%222 = getelementptr inbounds [2 x i32], [2 x i32]* %221, i64 0, i64 0
store i32 %220, i32* %222
%223 = getelementptr inbounds [2 x i32], [2 x i32]* %12, i64 0, i64 1
%224 = load i32, i32* %223
%225 = getelementptr inbounds [2 x [2 x i32]], [2 x [2 x i32]]* %15, i64 0, i64 1
%226 = getelementptr inbounds [2 x i32], [2 x i32]* %225, i64 0, i64 1
store i32 %224, i32* %226
%227 = getelementptr inbounds [2 x i32], [2 x i32]* %17, i64 0, i64 1
store i32 1, i32* %227
br label %230
228: ; preds = %185, %180, %176, %159
%229 = getelementptr inbounds [2 x i32], [2 x i32]* %17, i64 0, i64 1
store i32 0, i32* %229
br label %230
230: ; preds = %228, %189
%231 = load i32, i32* %14
%232 = add nsw i32 %231, 1
store i32 %232, i32* %14
br label %664
233: ; preds = %156
store i32 0, i32* %14
%234 = getelementptr inbounds [2 x i32], [2 x i32]* %17, i64 0, i64 0
%235 = load i32, i32* %234
%236 = icmp eq i32 %235, 0
br i1 %236, label %241, label %237
237: ; preds = %233
%238 = getelementptr inbounds [2 x i32], [2 x i32]* %17, i64 0, i64 1
%239 = load i32, i32* %238
%240 = icmp eq i32 %239, 0
br i1 %240, label %241, label %336
241: ; preds = %237, %233
%242 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([60 x i8], [60 x i8]* @.str.7, i64 0, i64 0), i32 160, i32 135, i32 228, i32 198)
%243 = getelementptr inbounds [2 x [2 x i32]], [2 x [2 x i32]]* %15, i64 0, i64 0
%244 = getelementptr inbounds [2 x i32], [2 x i32]* %243, i64 0, i64 0
%245 = load i32, i32* %244
%246 = sext i32 %245 to i64
%247 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %13, i64 0, i64 %246
%248 = getelementptr inbounds [2 x [2 x i32]], [2 x [2 x i32]]* %15, i64 0, i64 0
%249 = getelementptr inbounds [2 x i32], [2 x i32]* %248, i64 0, i64 1
%250 = load i32, i32* %249
%251 = sext i32 %250 to i64
%252 = getelementptr inbounds [10 x i32], [10 x i32]* %247, i64 0, i64 %251
%253 = load i32, i32* %252
%254 = icmp eq i32 %253, 0
br i1 %254, label %255, label %288
255: ; preds = %241
%256 = getelementptr inbounds [2 x [2 x i32]], [2 x [2 x i32]]* %15, i64 0, i64 0
%257 = getelementptr inbounds [2 x i32], [2 x i32]* %256, i64 0, i64 0
%258 = load i32, i32* %257
%259 = load i32, i32* %4
%260 = icmp slt i32 %258, %259
br i1 %260, label %277, label %261
261: ; preds = %255
%262 = getelementptr inbounds [2 x [2 x i32]], [2 x [2 x i32]]* %15, i64 0, i64 0
%263 = getelementptr inbounds [2 x i32], [2 x i32]* %262, i64 0, i64 0
%264 = load i32, i32* %263
%265 = icmp sge i32 %264, 0
br i1 %265, label %277, label %266
266: ; preds = %261
%267 = getelementptr inbounds [2 x [2 x i32]], [2 x [2 x i32]]* %15, i64 0, i64 0
%268 = getelementptr inbounds [2 x i32], [2 x i32]* %267, i64 0, i64 1
%269 = load i32, i32* %268
%270 = load i32, i32* %4
%271 = icmp slt i32 %269, %270
br i1 %271, label %277, label %272
272: ; preds = %266
%273 = getelementptr inbounds [2 x [2 x i32]], [2 x [2 x i32]]* %15, i64 0, i64 0
%274 = getelementptr inbounds [2 x i32], [2 x i32]* %273, i64 0, i64 1
%275 = load i32, i32* %274
%276 = icmp sge i32 %275, 0
br i1 %276, label %277, label %288
277: ; preds = %272, %266, %261, %255
%278 = getelementptr inbounds [2 x [2 x i32]], [2 x [2 x i32]]* %15, i64 0, i64 0
%279 = getelementptr inbounds [2 x i32], [2 x i32]* %278, i64 0, i64 0
%280 = load i32, i32* %279
%281 = sext i32 %280 to i64
%282 = getelementptr inbounds [10 x [10 x i8]], [10 x [10 x i8]]* %18, i64 0, i64 %281
%283 = getelementptr inbounds [2 x [2 x i32]], [2 x [2 x i32]]* %15, i64 0, i64 0
%284 = getelementptr inbounds [2 x i32], [2 x i32]* %283, i64 0, i64 1
%285 = load i32, i32* %284
%286 = sext i32 %285 to i64
%287 = getelementptr inbounds [10 x i8], [10 x i8]* %282, i64 0, i64 %286
store i8 -78, i8* %287
br label %288
288: ; preds = %277, %272, %241
%289 = getelementptr inbounds [2 x [2 x i32]], [2 x [2 x i32]]* %15, i64 0, i64 1
%290 = getelementptr inbounds [2 x i32], [2 x i32]* %289, i64 0, i64 0
%291 = load i32, i32* %290
%292 = sext i32 %291 to i64
%293 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %13, i64 0, i64 %292
%294 = getelementptr inbounds [2 x [2 x i32]], [2 x [2 x i32]]* %15, i64 0, i64 1
%295 = getelementptr inbounds [2 x i32], [2 x i32]* %294, i64 0, i64 1
%296 = load i32, i32* %295
%297 = sext i32 %296 to i64
%298 = getelementptr inbounds [10 x i32], [10 x i32]* %293, i64 0, i64 %297
%299 = load i32, i32* %298
%300 = icmp eq i32 %299, 0
br i1 %300, label %301, label %334
301: ; preds = %288
%302 = getelementptr inbounds [2 x [2 x i32]], [2 x [2 x i32]]* %15, i64 0, i64 1
%303 = getelementptr inbounds [2 x i32], [2 x i32]* %302, i64 0, i64 0
%304 = load i32, i32* %303
%305 = load i32, i32* %4
%306 = icmp slt i32 %304, %305
br i1 %306, label %323, label %307
307: ; preds = %301
%308 = getelementptr inbounds [2 x [2 x i32]], [2 x [2 x i32]]* %15, i64 0, i64 1
%309 = getelementptr inbounds [2 x i32], [2 x i32]* %308, i64 0, i64 0
%310 = load i32, i32* %309
%311 = icmp sge i32 %310, 0
br i1 %311, label %323, label %312
312: ; preds = %307
%313 = getelementptr inbounds [2 x [2 x i32]], [2 x [2 x i32]]* %15, i64 0, i64 1
%314 = getelementptr inbounds [2 x i32], [2 x i32]* %313, i64 0, i64 1
%315 = load i32, i32* %314
%316 = load i32, i32* %4
%317 = icmp slt i32 %315, %316
br i1 %317, label %323, label %318
318: ; preds = %312
%319 = getelementptr inbounds [2 x [2 x i32]], [2 x [2 x i32]]* %15, i64 0, i64 1
%320 = getelementptr inbounds [2 x i32], [2 x i32]* %319, i64 0, i64 1
%321 = load i32, i32* %320
%322 = icmp sge i32 %321, 0
br i1 %322, label %323, label %334
323: ; preds = %318, %312, %307, %301
%324 = getelementptr inbounds [2 x [2 x i32]], [2 x [2 x i32]]* %15, i64 0, i64 1
%325 = getelementptr inbounds [2 x i32], [2 x i32]* %324, i64 0, i64 0
%326 = load i32, i32* %325
%327 = sext i32 %326 to i64
%328 = getelementptr inbounds [10 x [10 x i8]], [10 x [10 x i8]]* %18, i64 0, i64 %327
%329 = getelementptr inbounds [2 x [2 x i32]], [2 x [2 x i32]]* %15, i64 0, i64 1
%330 = getelementptr inbounds [2 x i32], [2 x i32]* %329, i64 0, i64 1
%331 = load i32, i32* %330
%332 = sext i32 %331 to i64
%333 = getelementptr inbounds [10 x i8], [10 x i8]* %328, i64 0, i64 %332
store i8 -78, i8* %333
br label %334
334: ; preds = %323, %318, %288
%335 = call i32 (...) @getchar()
br label %663
336: ; preds = %237
%337 = getelementptr inbounds [2 x i8], [2 x i8]* %19, i64 0, i64 0
%338 = load i8, i8* %337
%339 = sext i8 %338 to i32
%340 = getelementptr inbounds [2 x i8], [2 x i8]* %19, i64 0, i64 1
%341 = load i8, i8* %340
%342 = sext i8 %341 to i32
%343 = icmp eq i32 %339, %342
br i1 %343, label %344, label %537
344: ; preds = %336
%345 = getelementptr inbounds [2 x [2 x i32]], [2 x [2 x i32]]* %15, i64 0, i64 0
%346 = getelementptr inbounds [2 x i32], [2 x i32]* %345, i64 0, i64 0
%347 = load i32, i32* %346
%348 = getelementptr inbounds [2 x [2 x i32]], [2 x [2 x i32]]* %15, i64 0, i64 1
%349 = getelementptr inbounds [2 x i32], [2 x i32]* %348, i64 0, i64 0
%350 = load i32, i32* %349
%351 = icmp eq i32 %347, %350
br i1 %351, label %352, label %360
352: ; preds = %344
%353 = getelementptr inbounds [2 x [2 x i32]], [2 x [2 x i32]]* %15, i64 0, i64 0
%354 = getelementptr inbounds [2 x i32], [2 x i32]* %353, i64 0, i64 1
%355 = load i32, i32* %354
%356 = getelementptr inbounds [2 x [2 x i32]], [2 x [2 x i32]]* %15, i64 0, i64 1
%357 = getelementptr inbounds [2 x i32], [2 x i32]* %356, i64 0, i64 1
%358 = load i32, i32* %357
%359 = icmp eq i32 %355, %358
br i1 %359, label %386, label %360
360: ; preds = %352, %344
%361 = getelementptr inbounds [2 x [2 x i32]], [2 x [2 x i32]]* %15, i64 0, i64 0
%362 = getelementptr inbounds [2 x i32], [2 x i32]* %361, i64 0, i64 0
%363 = load i32, i32* %362
%364 = sext i32 %363 to i64
%365 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %13, i64 0, i64 %364
%366 = getelementptr inbounds [2 x [2 x i32]], [2 x [2 x i32]]* %15, i64 0, i64 0
%367 = getelementptr inbounds [2 x i32], [2 x i32]* %366, i64 0, i64 1
%368 = load i32, i32* %367
%369 = sext i32 %368 to i64
%370 = getelementptr inbounds [10 x i32], [10 x i32]* %365, i64 0, i64 %369
%371 = load i32, i32* %370
%372 = icmp eq i32 %371, 1
br i1 %372, label %386, label %373
373: ; preds = %360
%374 = getelementptr inbounds [2 x [2 x i32]], [2 x [2 x i32]]* %15, i64 0, i64 1
%375 = getelementptr inbounds [2 x i32], [2 x i32]* %374, i64 0, i64 0
%376 = load i32, i32* %375
%377 = sext i32 %376 to i64
%378 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %13, i64 0, i64 %377
%379 = getelementptr inbounds [2 x [2 x i32]], [2 x [2 x i32]]* %15, i64 0, i64 1
%380 = getelementptr inbounds [2 x i32], [2 x i32]* %379, i64 0, i64 1
%381 = load i32, i32* %380
%382 = sext i32 %381 to i64
%383 = getelementptr inbounds [10 x i32], [10 x i32]* %378, i64 0, i64 %382
%384 = load i32, i32* %383
%385 = icmp eq i32 %384, 1
br i1 %385, label %386, label %436
386: ; preds = %373, %360, %352
%387 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([68 x i8], [68 x i8]* @.str.8, i64 0, i64 0), i32 160, i32 135, i32 228, i32 198, i32 160)
%388 = getelementptr inbounds [2 x [2 x i32]], [2 x [2 x i32]]* %15, i64 0, i64 0
%389 = getelementptr inbounds [2 x i32], [2 x i32]* %388, i64 0, i64 0
%390 = load i32, i32* %389
%391 = sext i32 %390 to i64
%392 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %13, i64 0, i64 %391
%393 = getelementptr inbounds [2 x [2 x i32]], [2 x [2 x i32]]* %15, i64 0, i64 0
%394 = getelementptr inbounds [2 x i32], [2 x i32]* %393, i64 0, i64 1
%395 = load i32, i32* %394
%396 = sext i32 %395 to i64
%397 = getelementptr inbounds [10 x i32], [10 x i32]* %392, i64 0, i64 %396
%398 = load i32, i32* %397
%399 = icmp eq i32 %398, 0
br i1 %399, label %400, label %411
400: ; preds = %386
%401 = getelementptr inbounds [2 x [2 x i32]], [2 x [2 x i32]]* %15, i64 0, i64 0
%402 = getelementptr inbounds [2 x i32], [2 x i32]* %401, i64 0, i64 0
%403 = load i32, i32* %402
%404 = sext i32 %403 to i64
%405 = getelementptr inbounds [10 x [10 x i8]], [10 x [10 x i8]]* %18, i64 0, i64 %404
%406 = getelementptr inbounds [2 x [2 x i32]], [2 x [2 x i32]]* %15, i64 0, i64 0
%407 = getelementptr inbounds [2 x i32], [2 x i32]* %406, i64 0, i64 1
%408 = load i32, i32* %407
%409 = sext i32 %408 to i64
%410 = getelementptr inbounds [10 x i8], [10 x i8]* %405, i64 0, i64 %409
store i8 -78, i8* %410
br label %411
411: ; preds = %400, %386
%412 = getelementptr inbounds [2 x [2 x i32]], [2 x [2 x i32]]* %15, i64 0, i64 1
%413 = getelementptr inbounds [2 x i32], [2 x i32]* %412, i64 0, i64 0
%414 = load i32, i32* %413
%415 = sext i32 %414 to i64
%416 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %13, i64 0, i64 %415
%417 = getelementptr inbounds [2 x [2 x i32]], [2 x [2 x i32]]* %15, i64 0, i64 1
%418 = getelementptr inbounds [2 x i32], [2 x i32]* %417, i64 0, i64 1
%419 = load i32, i32* %418
%420 = sext i32 %419 to i64
%421 = getelementptr inbounds [10 x i32], [10 x i32]* %416, i64 0, i64 %420
%422 = load i32, i32* %421
%423 = icmp eq i32 %422, 0
br i1 %423, label %424, label %435
424: ; preds = %411
%425 = getelementptr inbounds [2 x [2 x i32]], [2 x [2 x i32]]* %15, i64 0, i64 1
%426 = getelementptr inbounds [2 x i32], [2 x i32]* %425, i64 0, i64 0
%427 = load i32, i32* %426
%428 = sext i32 %427 to i64
%429 = getelementptr inbounds [10 x [10 x i8]], [10 x [10 x i8]]* %18, i64 0, i64 %428
%430 = getelementptr inbounds [2 x [2 x i32]], [2 x [2 x i32]]* %15, i64 0, i64 1
%431 = getelementptr inbounds [2 x i32], [2 x i32]* %430, i64 0, i64 1
%432 = load i32, i32* %431
%433 = sext i32 %432 to i64
%434 = getelementptr inbounds [10 x i8], [10 x i8]* %429, i64 0, i64 %433
store i8 -78, i8* %434
br label %435
435: ; preds = %424, %411
br label %535
436: ; preds = %373
%437 = getelementptr inbounds [2 x i8], [2 x i8]* %19, i64 0, i64 0
%438 = load i8, i8* %437
%439 = sext i8 %438 to i32
%440 = icmp eq i32 %439, 64
br i1 %440, label %441, label %468
441: ; preds = %436
%442 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.9, i64 0, i64 0), i32 136, i32 147)
%443 = load i32, i32* %9
%444 = sext i32 %443 to i64
%445 = getelementptr inbounds [2 x i32], [2 x i32]* %10, i64 0, i64 %444
%446 = load i32, i32* %445
%447 = add nsw i32 %446, 4
store i32 %447, i32* %445
%448 = load i32, i32* %9
%449 = sext i32 %448 to i64
%450 = getelementptr inbounds [2 x i8], [2 x i8]* %20, i64 0, i64 %449
%451 = load i8, i8* %450
%452 = sext i8 %451 to i32
%453 = icmp ne i32 %452, 35
br i1 %453, label %454, label %460
454: ; preds = %441
%455 = load i32, i32* %9
%456 = sext i32 %455 to i64
%457 = getelementptr inbounds [2 x i8], [2 x i8]* %20, i64 0, i64 %456
store i8 35, i8* %457
%458 = load i32, i32* %8
%459 = add nsw i32 %458, 1
store i32 %459, i32* %8
br label %460
460: ; preds = %454, %441
%461 = getelementptr inbounds [2 x i8], [2 x i8]* %19, i64 0, i64 0
%462 = load i8, i8* %461
%463 = load i32, i32* %9
%464 = sext i32 %463 to i64
%465 = getelementptr inbounds [2 x i8], [2 x i8]* %20, i64 0, i64 %464
store i8 %462, i8* %465
%466 = load i32, i32* %16
%467 = add nsw i32 %466, 1
store i32 %467, i32* %16
br label %512
468: ; preds = %436
%469 = getelementptr inbounds [2 x i8], [2 x i8]* %19, i64 0, i64 0
%470 = load i8, i8* %469
%471 = sext i8 %470 to i32
%472 = icmp eq i32 %471, 36
br i1 %472, label %473, label %500
473: ; preds = %468
%474 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([36 x i8], [36 x i8]* @.str.10, i64 0, i64 0), i32 136, i32 147)
%475 = load i32, i32* %9
%476 = sext i32 %475 to i64
%477 = getelementptr inbounds [2 x i32], [2 x i32]* %10, i64 0, i64 %476
%478 = load i32, i32* %477
%479 = add nsw i32 %478, 7
store i32 %479, i32* %477
%480 = load i32, i32* %9
%481 = sext i32 %480 to i64
%482 = getelementptr inbounds [2 x i8], [2 x i8]* %20, i64 0, i64 %481
%483 = load i8, i8* %482
%484 = sext i8 %483 to i32
%485 = icmp ne i32 %484, 35
br i1 %485, label %486, label %492
486: ; preds = %473
%487 = load i32, i32* %9
%488 = sext i32 %487 to i64
%489 = getelementptr inbounds [2 x i8], [2 x i8]* %20, i64 0, i64 %488
store i8 35, i8* %489
%490 = load i32, i32* %8
%491 = add nsw i32 %490, 1
store i32 %491, i32* %8
br label %492
492: ; preds = %486, %473
%493 = getelementptr inbounds [2 x i8], [2 x i8]* %19, i64 0, i64 0
%494 = load i8, i8* %493
%495 = load i32, i32* %9
%496 = sext i32 %495 to i64
%497 = getelementptr inbounds [2 x i8], [2 x i8]* %20, i64 0, i64 %496
store i8 %494, i8* %497
%498 = load i32, i32* %16
%499 = add nsw i32 %498, 1
store i32 %499, i32* %16
br label %511
500: ; preds = %468
%501 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([24 x i8], [24 x i8]* @.str.11, i64 0, i64 0), i32 136)
%502 = load i32, i32* %9
%503 = sext i32 %502 to i64
%504 = getelementptr inbounds [2 x i32], [2 x i32]* %10, i64 0, i64 %503
%505 = load i32, i32* %504
%506 = add nsw i32 %505, 2
store i32 %506, i32* %504
%507 = load i32, i32* %8
%508 = add nsw i32 %507, 1
store i32 %508, i32* %8
%509 = load i32, i32* %16
%510 = add nsw i32 %509, 1
store i32 %510, i32* %16
br label %511
511: ; preds = %500, %492
br label %512
512: ; preds = %511, %460
%513 = getelementptr inbounds [2 x [2 x i32]], [2 x [2 x i32]]* %15, i64 0, i64 0
%514 = getelementptr inbounds [2 x i32], [2 x i32]* %513, i64 0, i64 0
%515 = load i32, i32* %514
%516 = sext i32 %515 to i64
%517 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %13, i64 0, i64 %516
%518 = getelementptr inbounds [2 x [2 x i32]], [2 x [2 x i32]]* %15, i64 0, i64 0
%519 = getelementptr inbounds [2 x i32], [2 x i32]* %518, i64 0, i64 1
%520 = load i32, i32* %519
%521 = sext i32 %520 to i64
%522 = getelementptr inbounds [10 x i32], [10 x i32]* %517, i64 0, i64 %521
store i32 1, i32* %522
%523 = getelementptr inbounds [2 x [2 x i32]], [2 x [2 x i32]]* %15, i64 0, i64 1
%524 = getelementptr inbounds [2 x i32], [2 x i32]* %523, i64 0, i64 0
%525 = load i32, i32* %524
%526 = sext i32 %525 to i64
%527 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %13, i64 0, i64 %526
%528 = getelementptr inbounds [2 x [2 x i32]], [2 x [2 x i32]]* %15, i64 0, i64 1
%529 = getelementptr inbounds [2 x i32], [2 x i32]* %528, i64 0, i64 1
%530 = load i32, i32* %529
%531 = sext i32 %530 to i64
%532 = getelementptr inbounds [10 x i32], [10 x i32]* %527, i64 0, i64 %531
store i32 1, i32* %532
%533 = load i32, i32* %7
%534 = add nsw i32 %533, 1
store i32 %534, i32* %7
br label %535
535: ; preds = %512, %435
%536 = call i32 (...) @getchar()
br label %662
537: ; preds = %336
%538 = getelementptr inbounds [2 x [2 x i32]], [2 x [2 x i32]]* %15, i64 0, i64 0
%539 = getelementptr inbounds [2 x i32], [2 x i32]* %538, i64 0, i64 0
%540 = load i32, i32* %539
%541 = getelementptr inbounds [2 x [2 x i32]], [2 x [2 x i32]]* %15, i64 0, i64 1
%542 = getelementptr inbounds [2 x i32], [2 x i32]* %541, i64 0, i64 0
%543 = load i32, i32* %542
%544 = icmp eq i32 %540, %543
br i1 %544, label %545, label %553
545: ; preds = %537
%546 = getelementptr inbounds [2 x [2 x i32]], [2 x [2 x i32]]* %15, i64 0, i64 0
%547 = getelementptr inbounds [2 x i32], [2 x i32]* %546, i64 0, i64 1
%548 = load i32, i32* %547
%549 = getelementptr inbounds [2 x [2 x i32]], [2 x [2 x i32]]* %15, i64 0, i64 1
%550 = getelementptr inbounds [2 x i32], [2 x i32]* %549, i64 0, i64 1
%551 = load i32, i32* %550
%552 = icmp eq i32 %548, %551
br i1 %552, label %579, label %553
553: ; preds = %545, %537
%554 = getelementptr inbounds [2 x [2 x i32]], [2 x [2 x i32]]* %15, i64 0, i64 0
%555 = getelementptr inbounds [2 x i32], [2 x i32]* %554, i64 0, i64 0
%556 = load i32, i32* %555
%557 = sext i32 %556 to i64
%558 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %13, i64 0, i64 %557
%559 = getelementptr inbounds [2 x [2 x i32]], [2 x [2 x i32]]* %15, i64 0, i64 0
%560 = getelementptr inbounds [2 x i32], [2 x i32]* %559, i64 0, i64 1
%561 = load i32, i32* %560
%562 = sext i32 %561 to i64
%563 = getelementptr inbounds [10 x i32], [10 x i32]* %558, i64 0, i64 %562
%564 = load i32, i32* %563
%565 = icmp eq i32 %564, 1
br i1 %565, label %579, label %566
566: ; preds = %553
%567 = getelementptr inbounds [2 x [2 x i32]], [2 x [2 x i32]]* %15, i64 0, i64 1
%568 = getelementptr inbounds [2 x i32], [2 x i32]* %567, i64 0, i64 0
%569 = load i32, i32* %568
%570 = sext i32 %569 to i64
%571 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %13, i64 0, i64 %570
%572 = getelementptr inbounds [2 x [2 x i32]], [2 x [2 x i32]]* %15, i64 0, i64 1
%573 = getelementptr inbounds [2 x i32], [2 x i32]* %572, i64 0, i64 1
%574 = load i32, i32* %573
%575 = sext i32 %574 to i64
%576 = getelementptr inbounds [10 x i32], [10 x i32]* %571, i64 0, i64 %575
%577 = load i32, i32* %576
%578 = icmp eq i32 %577, 1
br i1 %578, label %579, label %581
579: ; preds = %566, %553, %545
%580 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([68 x i8], [68 x i8]* @.str.8, i64 0, i64 0), i32 160, i32 135, i32 228, i32 198, i32 160)
br label %612
581: ; preds = %566
%582 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([14 x i8], [14 x i8]* @.str.12, i64 0, i64 0), i32 136)
%583 = load i32, i32* %16
%584 = add nsw i32 %583, 1
store i32 %584, i32* %16
%585 = getelementptr inbounds [2 x i8], [2 x i8]* %19, i64 0, i64 0
%586 = load i8, i8* %585
%587 = sext i8 %586 to i32
%588 = icmp eq i32 %587, 64
br i1 %588, label %589, label %596
589: ; preds = %581
%590 = load i32, i32* %9
%591 = sext i32 %590 to i64
%592 = getelementptr inbounds [2 x i32], [2 x i32]* %10, i64 0, i64 %591
%593 = load i32, i32* %592
%594 = sub nsw i32 %593, 4
store i32 %594, i32* %592
%595 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.13, i64 0, i64 0))
br label %596
596: ; preds = %589, %581
%597 = getelementptr inbounds [2 x i8], [2 x i8]* %19, i64 0, i64 0
%598 = load i8, i8* %597
%599 = sext i8 %598 to i32
%600 = icmp eq i32 %599, 36
br i1 %600, label %601, label %608
601: ; preds = %596
%602 = load i32, i32* %9
%603 = sext i32 %602 to i64
%604 = getelementptr inbounds [2 x i32], [2 x i32]* %10, i64 0, i64 %603
%605 = load i32, i32* %604
%606 = sub nsw i32 %605, 7
store i32 %606, i32* %604
%607 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([10 x i8], [10 x i8]* @.str.14, i64 0, i64 0))
br label %608
608: ; preds = %601, %596
%609 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([2 x i8], [2 x i8]* @.str.15, i64 0, i64 0))
%610 = load i32, i32* %8
%611 = add nsw i32 %610, 1
store i32 %611, i32* %8
br label %612
612: ; preds = %608, %579
%613 = getelementptr inbounds [2 x [2 x i32]], [2 x [2 x i32]]* %15, i64 0, i64 0
%614 = getelementptr inbounds [2 x i32], [2 x i32]* %613, i64 0, i64 0
%615 = load i32, i32* %614
%616 = sext i32 %615 to i64
%617 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %13, i64 0, i64 %616
%618 = getelementptr inbounds [2 x [2 x i32]], [2 x [2 x i32]]* %15, i64 0, i64 0
%619 = getelementptr inbounds [2 x i32], [2 x i32]* %618, i64 0, i64 1
%620 = load i32, i32* %619
%621 = sext i32 %620 to i64
%622 = getelementptr inbounds [10 x i32], [10 x i32]* %617, i64 0, i64 %621
%623 = load i32, i32* %622
%624 = icmp eq i32 %623, 0
br i1 %624, label %625, label %636
625: ; preds = %612
%626 = getelementptr inbounds [2 x [2 x i32]], [2 x [2 x i32]]* %15, i64 0, i64 0
%627 = getelementptr inbounds [2 x i32], [2 x i32]* %626, i64 0, i64 0
%628 = load i32, i32* %627
%629 = sext i32 %628 to i64
%630 = getelementptr inbounds [10 x [10 x i8]], [10 x [10 x i8]]* %18, i64 0, i64 %629
%631 = getelementptr inbounds [2 x [2 x i32]], [2 x [2 x i32]]* %15, i64 0, i64 0
%632 = getelementptr inbounds [2 x i32], [2 x i32]* %631, i64 0, i64 1
%633 = load i32, i32* %632
%634 = sext i32 %633 to i64
%635 = getelementptr inbounds [10 x i8], [10 x i8]* %630, i64 0, i64 %634
store i8 -78, i8* %635
br label %636
636: ; preds = %625, %612
%637 = getelementptr inbounds [2 x [2 x i32]], [2 x [2 x i32]]* %15, i64 0, i64 1
%638 = getelementptr inbounds [2 x i32], [2 x i32]* %637, i64 0, i64 0
%639 = load i32, i32* %638
%640 = sext i32 %639 to i64
%641 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %13, i64 0, i64 %640
%642 = getelementptr inbounds [2 x [2 x i32]], [2 x [2 x i32]]* %15, i64 0, i64 1
%643 = getelementptr inbounds [2 x i32], [2 x i32]* %642, i64 0, i64 1
%644 = load i32, i32* %643
%645 = sext i32 %644 to i64
%646 = getelementptr inbounds [10 x i32], [10 x i32]* %641, i64 0, i64 %645
%647 = load i32, i32* %646
%648 = icmp eq i32 %647, 0
br i1 %648, label %649, label %660
649: ; preds = %636
%650 = getelementptr inbounds [2 x [2 x i32]], [2 x [2 x i32]]* %15, i64 0, i64 1
%651 = getelementptr inbounds [2 x i32], [2 x i32]* %650, i64 0, i64 0
%652 = load i32, i32* %651
%653 = sext i32 %652 to i64
%654 = getelementptr inbounds [10 x [10 x i8]], [10 x [10 x i8]]* %18, i64 0, i64 %653
%655 = getelementptr inbounds [2 x [2 x i32]], [2 x [2 x i32]]* %15, i64 0, i64 1
%656 = getelementptr inbounds [2 x i32], [2 x i32]* %655, i64 0, i64 1
%657 = load i32, i32* %656
%658 = sext i32 %657 to i64
%659 = getelementptr inbounds [10 x i8], [10 x i8]* %654, i64 0, i64 %658
store i8 -78, i8* %659
br label %660
660: ; preds = %649, %636
%661 = call i32 (...) @getchar()
br label %662
662: ; preds = %660, %535
br label %663
663: ; preds = %662, %334
br label %664
664: ; preds = %663, %230
br label %665
665: ; preds = %664, %153
br label %54
666: ; preds = %54
%667 = getelementptr inbounds [2 x i32], [2 x i32]* %10, i64 0, i64 0
%668 = load i32, i32* %16
%669 = call i32 @finaliza(i32* %667, i32 %668)
ret void
}

LLVM IR (-O2):
@.str = [6 x i8] c"clear\00"
@.str.1 = [79 x i8] c"\0AVez: Jogador %d Pontos: |Jogador 1%c %d| |Jogador 2%c %d|\0A \00"
@.str.2 = [46 x i8] c"\0ADigite o n%cmero da linha do primeiro item: \00"
@.str.3 = [3 x i8] c"%d\00"
@.str.4 = [46 x i8] c"Digite o n%cmero da coluna do primeiro item: \00"
@.str.5 = [45 x i8] c"\0ADigite o n%cmero da linha do segundo item: \00"
@.str.6 = [45 x i8] c"Digite o n%cmero da coluna do segundo item: \00"
@.str.7 = [60 x i8] c"\0AJogada inv%clida! As posi%c%ces n%co existem no tabuleiro.\00"
@.str.8 = [68 x i8] c"\0AJogada inv%clida! As posi%c%ces s%co iguais, ou j%c foram jogadas.\00"
@.str.9 = [36 x i8] c"\0AVoc%c ganhou o b%cnus de 4 pontos!\00"
@.str.10 = [36 x i8] c"\0AVoc%c ganhou o b%cnus de 7 pontos!\00"
@.str.11 = [24 x i8] c"\0AVoc%c ganhou 2 pontos!\00"
@.str.12 = [14 x i8] c"\0AVoc%c perdeu\00"
@.str.13 = [10 x i8] c" 4 pontos\00"
@.str.14 = [10 x i8] c" 7 pontos\00"
define void @PLAY_engine([10 x i8]* nocapture %0, i32 %1) {
%3 = alloca i64
%4 = bitcast i64* %3 to [2 x i32]*
%5 = alloca [2 x i32]
%6 = alloca [2 x i32]
%7 = alloca [10 x [10 x i32]]
%8 = alloca [10 x [10 x i8]]
%9 = alloca i16
%10 = bitcast i16* %9 to [2 x i8]*
%11 = bitcast i64* %3 to i8*
store i64 0, i64* %3
%12 = bitcast [2 x i32]* %5 to i8*
%13 = bitcast [2 x i32]* %6 to i8*
%14 = bitcast [10 x [10 x i32]]* %7 to i8*
%15 = getelementptr inbounds [10 x [10 x i8]], [10 x [10 x i8]]* %8, i64 0, i64 0, i64 0
%16 = bitcast i16* %9 to i8*
store i16 8995, i16* %9
%17 = icmp sgt i32 %1, 0
br i1 %17, label %18, label %38
18: ; preds = %2
%19 = zext i32 %1 to i64
%20 = shl nuw nsw i64 %19, 2
%21 = add nsw i64 %19, -1
%22 = and i64 %19, 3
%23 = icmp ult i64 %21, 3
br i1 %23, label %26, label %24
24: ; preds = %18
%25 = and i64 %19, 4294967292
br label %50
26: ; preds = %50, %18
%27 = phi i64 [ 0, %18 ], [ %68, %50 ]
%28 = icmp eq i64 %22, 0
br i1 %28, label %38, label %29
29: ; preds = %26, %29
%30 = phi i64 [ %35, %29 ], [ %27, %26 ]
%31 = phi i64 [ %36, %29 ], [ 0, %26 ]
%32 = getelementptr [10 x [10 x i8]], [10 x [10 x i8]]* %8, i64 0, i64 %30, i64 0
%33 = getelementptr [10 x [10 x i32]], [10 x [10 x i32]]* %7, i64 0, i64 %30, i64 0
%34 = bitcast i32* %33 to i8*
%35 = add nuw nsw i64 %30, 1
%36 = add i64 %31, 1
%37 = icmp eq i64 %36, %22
br i1 %37, label %38, label %29
38: ; preds = %26, %29, %2
%39 = mul nsw i32 %1, %1
%40 = lshr i32 %39, 1
%41 = icmp ult i32 %39, 2
br i1 %41, label %307, label %42
42: ; preds = %38
%43 = bitcast [10 x [10 x i8]]* %8 to i8**
%44 = bitcast i64* %3 to i32*
%45 = getelementptr inbounds [2 x i32], [2 x i32]* %4, i64 0, i64 1
%46 = getelementptr inbounds [2 x i32], [2 x i32]* %5, i64 0, i64 1
%47 = getelementptr inbounds [2 x i32], [2 x i32]* %6, i64 0, i64 1
%48 = getelementptr inbounds [2 x i32], [2 x i32]* %5, i64 0, i64 0
%49 = getelementptr inbounds [2 x i32], [2 x i32]* %6, i64 0, i64 0
br label %71
50: ; preds = %50, %24
%51 = phi i64 [ 0, %24 ], [ %68, %50 ]
%52 = phi i64 [ 0, %24 ], [ %69, %50 ]
%53 = getelementptr [10 x [10 x i8]], [10 x [10 x i8]]* %8, i64 0, i64 %51, i64 0
%54 = getelementptr [10 x [10 x i32]], [10 x [10 x i32]]* %7, i64 0, i64 %51, i64 0
%55 = bitcast i32* %54 to i8*
%56 = or i64 %51, 1
%57 = getelementptr [10 x [10 x i8]], [10 x [10 x i8]]* %8, i64 0, i64 %56, i64 0
%58 = getelementptr [10 x [10 x i32]], [10 x [10 x i32]]* %7, i64 0, i64 %56, i64 0
%59 = bitcast i32* %58 to i8*
%60 = or i64 %51, 2
%61 = getelementptr [10 x [10 x i8]], [10 x [10 x i8]]* %8, i64 0, i64 %60, i64 0
%62 = getelementptr [10 x [10 x i32]], [10 x [10 x i32]]* %7, i64 0, i64 %60, i64 0
%63 = bitcast i32* %62 to i8*
%64 = or i64 %51, 3
%65 = getelementptr [10 x [10 x i8]], [10 x [10 x i8]]* %8, i64 0, i64 %64, i64 0
%66 = getelementptr [10 x [10 x i32]], [10 x [10 x i32]]* %7, i64 0, i64 %64, i64 0
%67 = bitcast i32* %66 to i8*
%68 = add nuw nsw i64 %51, 4
%69 = add i64 %52, 4
%70 = icmp eq i64 %69, %25
br i1 %70, label %26, label %50
71: ; preds = %304, %42
%72 = phi i32 [ 0, %42 ], [ %306, %304 ]
%73 = phi i32 [ 0, %42 ], [ %305, %304 ]
%74 = phi i8 [ undef, %42 ], [ %302, %304 ]
%75 = phi i8 [ undef, %42 ], [ %301, %304 ]
%76 = phi i32 [ 0, %42 ], [ %300, %304 ]
%77 = phi i32 [ 0, %42 ], [ %299, %304 ]
%78 = phi i32 [ 0, %42 ], [ %298, %304 ]
%79 = phi i32 [ undef, %42 ], [ %297, %304 ]
%80 = phi i32 [ undef, %42 ], [ %296, %304 ]
%81 = phi i32 [ undef, %42 ], [ %295, %304 ]
%82 = phi i32 [ undef, %42 ], [ %294, %304 ]
%83 = phi i32 [ 0, %42 ], [ %293, %304 ]
%84 = phi i32 [ 0, %42 ], [ %292, %304 ]
%85 = phi i32 [ 0, %42 ], [ %291, %304 ]
%86 = call i32 @system(i8* getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0))
%87 = call i32 @exibe_tabuleiro(i8** %43, i32 %1)
%88 = and i32 %84, 1
%89 = add nuw nsw i32 %88, 1
%90 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([79 x i8], [79 x i8]* @.str.1, i64 0, i64 0), i32 %89, i32 26, i32 %73, i32 26, i32 %72)
switch i32 %83, label %135 [
i32 0, label %91
i32 1, label %113
]
91: ; preds = %71
%92 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([46 x i8], [46 x i8]* @.str.2, i64 0, i64 0), i32 163)
%93 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), i32* %48)
%94 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([46 x i8], [46 x i8]* @.str.4, i64 0, i64 0), i32 163)
%95 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), i32* %49)
%96 = load i32, i32* %48
%97 = add nsw i32 %96, -1
store i32 %97, i32* %48
%98 = load i32, i32* %49
%99 = add nsw i32 %98, -1
store i32 %99, i32* %49
%100 = icmp sle i32 %96, %1
%101 = icmp sgt i32 %96, 0
%102 = and i1 %100, %101
br i1 %102, label %103, label %290
103: ; preds = %91
%104 = icmp sle i32 %98, %1
%105 = icmp sgt i32 %98, 0
%106 = and i1 %104, %105
br i1 %106, label %107, label %290
107: ; preds = %103
%108 = zext i32 %97 to i64
%109 = zext i32 %99 to i64
%110 = getelementptr inbounds [10 x i8], [10 x i8]* %0, i64 %108, i64 %109
%111 = load i8, i8* %110
%112 = getelementptr inbounds [10 x [10 x i8]], [10 x [10 x i8]]* %8, i64 0, i64 %108, i64 %109
store i8 %111, i8* %112
br label %290
113: ; preds = %71
%114 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([45 x i8], [45 x i8]* @.str.5, i64 0, i64 0), i32 163)
%115 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), i32* %46)
%116 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([45 x i8], [45 x i8]* @.str.6, i64 0, i64 0), i32 163)
%117 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.3, i64 0, i64 0), i32* %47)
%118 = load i32, i32* %46
%119 = add nsw i32 %118, -1
store i32 %119, i32* %46
%120 = load i32, i32* %47
%121 = add nsw i32 %120, -1
store i32 %121, i32* %47
%122 = icmp sle i32 %118, %1
%123 = icmp sgt i32 %118, 0
%124 = and i1 %122, %123
br i1 %124, label %125, label %290
125: ; preds = %113
%126 = icmp sle i32 %120, %1
%127 = icmp sgt i32 %120, 0
%128 = and i1 %126, %127
br i1 %128, label %129, label %290
129: ; preds = %125
%130 = zext i32 %119 to i64
%131 = zext i32 %121 to i64
%132 = getelementptr inbounds [10 x i8], [10 x i8]* %0, i64 %130, i64 %131
%133 = load i8, i8* %132
%134 = getelementptr inbounds [10 x [10 x i8]], [10 x [10 x i8]]* %8, i64 0, i64 %130, i64 %131
store i8 %133, i8* %134
br label %290
135: ; preds = %71
%136 = icmp eq i32 %77, 0
%137 = icmp eq i32 %76, 0
%138 = select i1 %136, i1 true, i1 %137
br i1 %138, label %139, label %174
139: ; preds = %135
%140 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([60 x i8], [60 x i8]* @.str.7, i64 0, i64 0), i32 160, i32 135, i32 228, i32 198)
%141 = sext i32 %79 to i64
%142 = sext i32 %80 to i64
%143 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %7, i64 0, i64 %141, i64 %142
%144 = load i32, i32* %143
%145 = icmp eq i32 %144, 0
br i1 %145, label %146, label %156
146: ; preds = %139
%147 = icmp slt i32 %79, %1
%148 = icmp sgt i32 %79, -1
%149 = or i1 %147, %148
br i1 %149, label %154, label %150
150: ; preds = %146
%151 = icmp slt i32 %80, %1
%152 = icmp sgt i32 %80, -1
%153 = or i1 %151, %152
br i1 %153, label %154, label %156
154: ; preds = %150, %146
%155 = getelementptr inbounds [10 x [10 x i8]], [10 x [10 x i8]]* %8, i64 0, i64 %141, i64 %142
store i8 -78, i8* %155
br label %156
156: ; preds = %150, %154, %139
%157 = sext i32 %81 to i64
%158 = sext i32 %82 to i64
%159 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %7, i64 0, i64 %157, i64 %158
%160 = load i32, i32* %159
%161 = icmp eq i32 %160, 0
br i1 %161, label %162, label %172
162: ; preds = %156
%163 = icmp slt i32 %81, %1
%164 = icmp sgt i32 %81, -1
%165 = or i1 %163, %164
br i1 %165, label %170, label %166
166: ; preds = %162
%167 = icmp slt i32 %82, %1
%168 = icmp sgt i32 %82, -1
%169 = or i1 %167, %168
br i1 %169, label %170, label %172
170: ; preds = %166, %162
%171 = getelementptr inbounds [10 x [10 x i8]], [10 x [10 x i8]]* %8, i64 0, i64 %157, i64 %158
store i8 -78, i8* %171
br label %172
172: ; preds = %166, %170, %156
%173 = call i32 (...) @getchar()
br label %290
174: ; preds = %135
%175 = icmp eq i8 %74, %75
%176 = icmp eq i32 %79, %81
%177 = icmp eq i32 %80, %82
%178 = select i1 %176, i1 %177, i1 false
%179 = sext i32 %79 to i64
%180 = sext i32 %80 to i64
br i1 %175, label %181, label %243
181: ; preds = %174
br i1 %178, label %192, label %182
182: ; preds = %181
%183 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %7, i64 0, i64 %179, i64 %180
%184 = load i32, i32* %183
%185 = icmp eq i32 %184, 1
br i1 %185, label %192, label %186
186: ; preds = %182
%187 = sext i32 %81 to i64
%188 = sext i32 %82 to i64
%189 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %7, i64 0, i64 %187, i64 %188
%190 = load i32, i32* %189
%191 = icmp eq i32 %190, 1
br i1 %191, label %192, label %207
192: ; preds = %181, %186, %182
%193 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([68 x i8], [68 x i8]* @.str.8, i64 0, i64 0), i32 160, i32 135, i32 228, i32 198, i32 160)
%194 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %7, i64 0, i64 %179, i64 %180
%195 = load i32, i32* %194
%196 = icmp eq i32 %195, 0
br i1 %196, label %197, label %199
197: ; preds = %192
%198 = getelementptr inbounds [10 x [10 x i8]], [10 x [10 x i8]]* %8, i64 0, i64 %179, i64 %180
store i8 -78, i8* %198
br label %199
199: ; preds = %197, %192
%200 = sext i32 %81 to i64
%201 = sext i32 %82 to i64
%202 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %7, i64 0, i64 %200, i64 %201
%203 = load i32, i32* %202
%204 = icmp eq i32 %203, 0
br i1 %204, label %205, label %238
205: ; preds = %199
%206 = getelementptr inbounds [10 x [10 x i8]], [10 x [10 x i8]]* %8, i64 0, i64 %200, i64 %201
store i8 -78, i8* %206
br label %238
207: ; preds = %186
switch i8 %74, label %226 [
i8 64, label %208
i8 36, label %217
]
208: ; preds = %207
%209 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([36 x i8], [36 x i8]* @.str.9, i64 0, i64 0), i32 136, i32 147)
%210 = zext i32 %88 to i64
%211 = getelementptr inbounds [2 x i32], [2 x i32]* %4, i64 0, i64 %210
%212 = load i32, i32* %211
%213 = add nsw i32 %212, 4
store i32 %213, i32* %211
%214 = getelementptr inbounds [2 x i8], [2 x i8]* %10, i64 0, i64 %210
%215 = load i8, i8* %214
%216 = icmp ne i8 %215, 35
store i8 64, i8* %214
br label %232
217: ; preds = %207
%218 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([36 x i8], [36 x i8]* @.str.10, i64 0, i64 0), i32 136, i32 147)
%219 = zext i32 %88 to i64
%220 = getelementptr inbounds [2 x i32], [2 x i32]* %4, i64 0, i64 %219
%221 = load i32, i32* %220
%222 = add nsw i32 %221, 7
store i32 %222, i32* %220
%223 = getelementptr inbounds [2 x i8], [2 x i8]* %10, i64 0, i64 %219
%224 = load i8, i8* %223
%225 = icmp ne i8 %224, 35
store i8 36, i8* %223
br label %232
226: ; preds = %207
%227 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([24 x i8], [24 x i8]* @.str.11, i64 0, i64 0), i32 136)
%228 = zext i32 %88 to i64
%229 = getelementptr inbounds [2 x i32], [2 x i32]* %4, i64 0, i64 %228
%230 = load i32, i32* %229
%231 = add nsw i32 %230, 2
store i32 %231, i32* %229
br label %232
232: ; preds = %217, %226, %208
%233 = phi i1 [ %216, %208 ], [ %225, %217 ], [ true, %226 ]
%234 = zext i1 %233 to i32
%235 = add nsw i32 %84, %234
%236 = add nsw i32 %78, 1
store i32 1, i32* %183
store i32 1, i32* %189
%237 = add nsw i32 %85, 1
br label %238
238: ; preds = %199, %205, %232
%239 = phi i32 [ %85, %205 ], [ %85, %199 ], [ %237, %232 ]
%240 = phi i32 [ %84, %205 ], [ %84, %199 ], [ %235, %232 ]
%241 = phi i32 [ %78, %205 ], [ %78, %199 ], [ %236, %232 ]
%242 = call i32 (...) @getchar()
br label %290
243: ; preds = %174
br i1 %178, label %254, label %244
244: ; preds = %243
%245 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %7, i64 0, i64 %179, i64 %180
%246 = load i32, i32* %245
%247 = icmp eq i32 %246, 1
br i1 %247, label %254, label %248
248: ; preds = %244
%249 = sext i32 %81 to i64
%250 = sext i32 %82 to i64
%251 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %7, i64 0, i64 %249, i64 %250
%252 = load i32, i32* %251
%253 = icmp eq i32 %252, 1
br i1 %253, label %254, label %258
254: ; preds = %243, %248, %244
%255 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([68 x i8], [68 x i8]* @.str.8, i64 0, i64 0), i32 160, i32 135, i32 228, i32 198, i32 160)
%256 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %7, i64 0, i64 %179, i64 %180
%257 = load i32, i32* %256
br label %273
258: ; preds = %248
%259 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([14 x i8], [14 x i8]* @.str.12, i64 0, i64 0), i32 136)
%260 = add nsw i32 %78, 1
switch i8 %74, label %270 [
i8 64, label %262
i8 36, label %261
]
261: ; preds = %258
br label %262
262: ; preds = %258, %261
%263 = phi i32 [ -7, %261 ], [ -4, %258 ]
%264 = phi i8* [ getelementptr inbounds ([10 x i8], [10 x i8]* @.str.14, i64 0, i64 0), %261 ], [ getelementptr inbounds ([10 x i8], [10 x i8]* @.str.13, i64 0, i64 0), %258 ]
%265 = zext i32 %88 to i64
%266 = getelementptr inbounds [2 x i32], [2 x i32]* %4, i64 0, i64 %265
%267 = load i32, i32* %266
%268 = add nsw i32 %267, %263
store i32 %268, i32* %266
%269 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) %264)
br label %270
270: ; preds = %262, %258
%271 = call i32 @putchar(i32 33)
%272 = add nsw i32 %84, 1
br label %273
273: ; preds = %270, %254
%274 = phi i32 [ %246, %270 ], [ %257, %254 ]
%275 = phi i32 [ %272, %270 ], [ %84, %254 ]
%276 = phi i32 [ %260, %270 ], [ %78, %254 ]
%277 = icmp eq i32 %274, 0
br i1 %277, label %278, label %280
278: ; preds = %273
%279 = getelementptr inbounds [10 x [10 x i8]], [10 x [10 x i8]]* %8, i64 0, i64 %179, i64 %180
store i8 -78, i8* %279
br label %280
280: ; preds = %278, %273
%281 = sext i32 %81 to i64
%282 = sext i32 %82 to i64
%283 = getelementptr inbounds [10 x [10 x i32]], [10 x [10 x i32]]* %7, i64 0, i64 %281, i64 %282
%284 = load i32, i32* %283
%285 = icmp eq i32 %284, 0
br i1 %285, label %286, label %288
286: ; preds = %280
%287 = getelementptr inbounds [10 x [10 x i8]], [10 x [10 x i8]]* %8, i64 0, i64 %281, i64 %282
store i8 -78, i8* %287
br label %288
288: ; preds = %286, %280
%289 = call i32 (...) @getchar()
br label %290
290: ; preds = %129, %125, %113, %107, %103, %91, %238, %288, %172
%291 = phi i32 [ %85, %172 ], [ %239, %238 ], [ %85, %288 ], [ %85, %91 ], [ %85, %103 ], [ %85, %107 ], [ %85, %113 ], [ %85, %125 ], [ %85, %129 ]
%292 = phi i32 [ %84, %172 ], [ %240, %238 ], [ %275, %288 ], [ %84, %91 ], [ %84, %103 ], [ %84, %107 ], [ %84, %113 ], [ %84, %125 ], [ %84, %129 ]
%293 = phi i32 [ 0, %172 ], [ 0, %238 ], [ 0, %288 ], [ 1, %91 ], [ 1, %103 ], [ 1, %107 ], [ 2, %113 ], [ 2, %125 ], [ 2, %129 ]
%294 = phi i32 [ %82, %172 ], [ %82, %238 ], [ %82, %288 ], [ %82, %91 ], [ %82, %103 ], [ %82, %107 ], [ %82, %113 ], [ %82, %125 ], [ %121, %129 ]
%295 = phi i32 [ %81, %172 ], [ %81, %238 ], [ %81, %288 ], [ %81, %91 ], [ %81, %103 ], [ %81, %107 ], [ %81, %113 ], [ %81, %125 ], [ %119, %129 ]
%296 = phi i32 [ %80, %172 ], [ %80, %238 ], [ %80, %288 ], [ %80, %91 ], [ %80, %103 ], [ %99, %107 ], [ %80, %113 ], [ %80, %125 ], [ %80, %129 ]
%297 = phi i32 [ %79, %172 ], [ %79, %238 ], [ %79, %288 ], [ %79, %91 ], [ %79, %103 ], [ %97, %107 ], [ %79, %113 ], [ %79, %125 ], [ %79, %129 ]
%298 = phi i32 [ %78, %172 ], [ %241, %238 ], [ %276, %288 ], [ %78, %91 ], [ %78, %103 ], [ %78, %107 ], [ %78, %113 ], [ %78, %125 ], [ %78, %129 ]
%299 = phi i32 [ %77, %172 ], [ 1, %238 ], [ 1, %288 ], [ 0, %91 ], [ 0, %103 ], [ 1, %107 ], [ %77, %113 ], [ %77, %125 ], [ %77, %129 ]
%300 = phi i32 [ %76, %172 ], [ 1, %238 ], [ 1, %288 ], [ %76, %91 ], [ %76, %103 ], [ %76, %107 ], [ 0, %113 ], [ 0, %125 ], [ 1, %129 ]
%301 = phi i8 [ %75, %172 ], [ %74, %238 ], [ %75, %288 ], [ %75, %91 ], [ %75, %103 ], [ %75, %107 ], [ %75, %113 ], [ %75, %125 ], [ %133, %129 ]
%302 = phi i8 [ %74, %172 ], [ %74, %238 ], [ %74, %288 ], [ %74, %91 ], [ %74, %103 ], [ %111, %107 ], [ %74, %113 ], [ %74, %125 ], [ %74, %129 ]
%303 = icmp slt i32 %291, %40
br i1 %303, label %304, label %307
304: ; preds = %290
%305 = load i32, i32* %44
%306 = load i32, i32* %45
br label %71
307: ; preds = %290, %38
%308 = phi i32 [ 0, %38 ], [ %298, %290 ]
%309 = bitcast i64* %3 to i32*
%310 = call i32 @finaliza(i32* %309, i32 %308)
ret void
}