user: What is the c source code of the assembly code below?

```asm
<main>:
  endbr64
  push   %rbp
  mov    %rsp,%rbp
  sub    $0x360,%rsp
  mov    %fs:0x28,%rax
  mov    %rax,-0x8(%rbp)
  xor    %eax,%eax
  mov    $0x0,%edi
  call   <time@plt>
  mov    %eax,%edi
  call   <srand@plt>
  movl   $0x1,-0x338(%rbp)
  movl   $0x0,-0x33c(%rbp)
  jmp    L498
L245:
  movl   $0x0,-0x340(%rbp)
  jmp    L56
L7:
  mov    -0x33c(%rbp),%eax
  movslq %eax,%rcx
  mov    -0x340(%rbp),%eax
  movslq %eax,%rdx
  mov    %rdx,%rax
  shl    $0x2,%rax
  add    %rdx,%rax
  add    %rax,%rax
  add    %rcx,%rax
  movl   $0x0,-0x330(%rbp,%rax,4)
  mov    -0x33c(%rbp),%eax
  movslq %eax,%rcx
  mov    -0x340(%rbp),%eax
  movslq %eax,%rdx
  mov    %rdx,%rax
  shl    $0x2,%rax
  add    %rdx,%rax
  add    %rax,%rax
  add    %rcx,%rax
  movl   $0x0,-0x1a0(%rbp,%rax,4)
  addl   $0x1,-0x340(%rbp)
L56:
  cmpl   $0x9,-0x340(%rbp)
  jle    L7
  addl   $0x1,-0x33c(%rbp)
L498:
  cmpl   $0x9,-0x33c(%rbp)
  jle    L245
  lea    D336(%rip),%rax
  mov    %rax,%rdi
  call   <puts@plt>
  lea    -0x358(%rbp),%rax
  mov    %rax,%rsi
  lea    D96(%rip),%rax
  mov    %rax,%rdi
  call   <scanf@plt>
  jmp    L328
L366:
  lea    D116(%rip),%rax
  mov    %rax,%rdi
  call   <puts@plt>
  lea    -0x358(%rbp),%rax
  mov    %rax,%rsi
  lea    D96(%rip),%rax
  mov    %rax,%rdi
  call   <scanf@plt>
L328:
  mov    -0x358(%rbp),%eax
  cmp    $0x1,%eax
  je     L373
  mov    -0x358(%rbp),%eax
  test   %eax,%eax
  jne    L366
L373:
  lea    D21(%rip),%rax
  mov    %rax,%rdi
  call   <puts@plt>
  lea    -0x354(%rbp),%rax
  mov    %rax,%rsi
  lea    D96(%rip),%rax
  mov    %rax,%rdi
  call   <scanf@plt>
  movl   $0x1,-0x334(%rbp)
  jmp    L429
L128:
  lea    D396(%rip),%rax
  mov    %rax,%rdi
  call   <puts@plt>
  lea    -0x354(%rbp),%rax
  mov    %rax,%rsi
  lea    D96(%rip),%rax
  mov    %rax,%rdi
  call   <scanf@plt>
L429:
  mov    -0x354(%rbp),%eax
  test   %eax,%eax
  jle    L128
  jmp    L448
L64:
  lea    D32(%rip),%rax
  mov    %rax,%rdi
  call   <puts@plt>
  lea    -0x354(%rbp),%rax
  mov    %rax,%rsi
  lea    D96(%rip),%rax
  mov    %rax,%rdi
  call   <scanf@plt>
L448:
  mov    -0x354(%rbp),%eax
  cmp    $0x63,%eax
  jg     L64
  mov    -0x354(%rbp),%eax
  cmp    $0x63,%eax
  jg     L493
  mov    -0x354(%rbp),%eax
  cmp    $0x4a,%eax
  jle    L493
  mov    -0x354(%rbp),%edx
  mov    $0x64,%eax
  sub    %edx,%eax
  mov    %eax,-0x350(%rbp)
  mov    -0x350(%rbp),%edx
  mov    -0x354(%rbp),%eax
  mov    %eax,%esi
  lea    D185(%rip),%rax
  mov    %rax,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  jmp    L499
L493:
  mov    -0x354(%rbp),%eax
  mov    %eax,%esi
  lea    D334(%rip),%rax
  mov    %rax,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  lea    -0x350(%rbp),%rax
  mov    %rax,%rsi
  lea    D96(%rip),%rax
  mov    %rax,%rdi
  call   <scanf@plt>
L499:
  lea    D79(%rip),%rax
  mov    %rax,%rdi
  call   <puts@plt>
  lea    -0x34c(%rbp),%rax
  mov    %rax,%rsi
  lea    D96(%rip),%rax
  mov    %rax,%rdi
  call   <scanf@plt>
  mov    -0x34c(%rbp),%eax
  cmp    $0x1,%eax
  jne    L400
  lea    D352(%rip),%rax
  mov    %rax,%rdi
  call   <puts@plt>
L400:
  lea    D400(%rip),%rax
  mov    %rax,%rdi
  call   <puts@plt>
  lea    D398(%rip),%rax
  mov    %rax,%rdi
  call   <puts@plt>
  jmp    L490
L330:
  mov    $0x0,%eax
  call   <rand@plt>
  mov    %eax,%edx
  movslq %edx,%rax
  imul   $0x66666667,%rax,%rax
  shr    $0x20,%rax
  sar    $0x2,%eax
  mov    %edx,%ecx
  sar    $0x1f,%ecx
  sub    %ecx,%eax
  mov    %eax,-0x340(%rbp)
  mov    -0x340(%rbp),%ecx
  mov    %ecx,%eax
  shl    $0x2,%eax
  add    %ecx,%eax
  add    %eax,%eax
  sub    %eax,%edx
  mov    %edx,-0x340(%rbp)
  mov    $0x0,%eax
  call   <rand@plt>
  mov    %eax,%edx
  movslq %edx,%rax
  imul   $0x66666667,%rax,%rax
  shr    $0x20,%rax
  sar    $0x2,%eax
  mov    %edx,%ecx
  sar    $0x1f,%ecx
  sub    %ecx,%eax
  mov    %eax,-0x33c(%rbp)
  mov    -0x33c(%rbp),%ecx
  mov    %ecx,%eax
  shl    $0x2,%eax
  add    %ecx,%eax
  add    %eax,%eax
  sub    %eax,%edx
  mov    %edx,-0x33c(%rbp)
  mov    -0x33c(%rbp),%eax
  movslq %eax,%rcx
  mov    -0x340(%rbp),%eax
  movslq %eax,%rdx
  mov    %rdx,%rax
  shl    $0x2,%rax
  add    %rdx,%rax
  add    %rax,%rax
  add    %rcx,%rax
  mov    -0x330(%rbp,%rax,4),%eax
  test   %eax,%eax
  jne    L490
  mov    -0x33c(%rbp),%eax
  movslq %eax,%rcx
  mov    -0x340(%rbp),%eax
  movslq %eax,%rdx
  mov    %rdx,%rax
  shl    $0x2,%rax
  add    %rdx,%rax
  add    %rax,%rax
  add    %rcx,%rax
  movl   $0x1,-0x330(%rbp,%rax,4)
  addl   $0x1,-0x334(%rbp)
L490:
  mov    -0x354(%rbp),%eax
  cmp    %eax,-0x334(%rbp)
  jle    L330
  jmp    L112
L315:
  lea    D372(%rip),%rax
  mov    %rax,%rdi
  call   <puts@plt>
  lea    -0x348(%rbp),%rax
  mov    %rax,%rsi
  lea    D96(%rip),%rax
  mov    %rax,%rdi
  call   <scanf@plt>
  jmp    L90
L130:
  lea    D341(%rip),%rax
  mov    %rax,%rdi
  call   <puts@plt>
  lea    -0x348(%rbp),%rax
  mov    %rax,%rsi
  lea    D96(%rip),%rax
  mov    %rax,%rdi
  call   <scanf@plt>
L90:
  mov    -0x348(%rbp),%eax
  test   %eax,%eax
  js     L130
  mov    -0x348(%rbp),%eax
  cmp    $0x9,%eax
  jg     L130
  lea    D153(%rip),%rax
  mov    %rax,%rdi
  call   <puts@plt>
  lea    -0x344(%rbp),%rax
  mov    %rax,%rsi
  lea    D96(%rip),%rax
  mov    %rax,%rdi
  call   <scanf@plt>
  jmp    L331
L202:
  lea    D438(%rip),%rax
  mov    %rax,%rdi
  call   <puts@plt>
  lea    -0x344(%rbp),%rax
  mov    %rax,%rsi
  lea    D96(%rip),%rax
  mov    %rax,%rdi
  call   <scanf@plt>
L331:
  mov    -0x344(%rbp),%eax
  test   %eax,%eax
  js     L202
  mov    -0x344(%rbp),%eax
  cmp    $0x9,%eax
  jg     L202
  jmp    L513
L194:
  lea    D295(%rip),%rax
  mov    %rax,%rdi
  call   <puts@plt>
  lea    D372(%rip),%rax
  mov    %rax,%rdi
  call   <puts@plt>
  lea    -0x348(%rbp),%rax
  mov    %rax,%rsi
  lea    D96(%rip),%rax
  mov    %rax,%rdi
  call   <scanf@plt>
  jmp    L495
L166:
  lea    D375(%rip),%rax
  mov    %rax,%rdi
  call   <puts@plt>
  lea    -0x348(%rbp),%rax
  mov    %rax,%rsi
  lea    D96(%rip),%rax
  mov    %rax,%rdi
  call   <scanf@plt>
L495:
  mov    -0x348(%rbp),%eax
  test   %eax,%eax
  js     L166
  mov    -0x348(%rbp),%eax
  cmp    $0x9,%eax
  jg     L166
  lea    D153(%rip),%rax
  mov    %rax,%rdi
  call   <puts@plt>
  lea    -0x344(%rbp),%rax
  mov    %rax,%rsi
  lea    D96(%rip),%rax
  mov    %rax,%rdi
  call   <scanf@plt>
  jmp    L230
L309:
  lea    D438(%rip),%rax
  mov    %rax,%rdi
  call   <puts@plt>
  lea    -0x344(%rbp),%rax
  mov    %rax,%rsi
  lea    D96(%rip),%rax
  mov    %rax,%rdi
  call   <scanf@plt>
L230:
  mov    -0x344(%rbp),%eax
  test   %eax,%eax
  js     L309
  mov    -0x344(%rbp),%eax
  cmp    $0x9,%eax
  jg     L309
L513:
  mov    -0x348(%rbp),%eax
  mov    -0x344(%rbp),%edx
  movslq %edx,%rcx
  movslq %eax,%rdx
  mov    %rdx,%rax
  shl    $0x2,%rax
  add    %rdx,%rax
  add    %rax,%rax
  add    %rcx,%rax
  mov    -0x1a0(%rbp,%rax,4),%eax
  cmp    $0x1,%eax
  je     L194
  mov    -0x348(%rbp),%eax
  mov    -0x344(%rbp),%edx
  movslq %edx,%rcx
  movslq %eax,%rdx
  mov    %rdx,%rax
  shl    $0x2,%rax
  add    %rdx,%rax
  add    %rax,%rax
  add    %rcx,%rax
  mov    -0x330(%rbp,%rax,4),%eax
  cmp    $0x1,%eax
  jne    L280
  mov    -0x348(%rbp),%eax
  mov    -0x344(%rbp),%edx
  movslq %edx,%rcx
  movslq %eax,%rdx
  mov    %rdx,%rax
  shl    $0x2,%rax
  add    %rdx,%rax
  add    %rax,%rax
  add    %rcx,%rax
  movl   $0x2,-0x330(%rbp,%rax,4)
  mov    -0x34c(%rbp),%eax
  sub    $0x1,%eax
  mov    %eax,-0x34c(%rbp)
  jmp    L251
L280:
  mov    -0x348(%rbp),%eax
  mov    -0x344(%rbp),%edx
  movslq %edx,%rcx
  movslq %eax,%rdx
  mov    %rdx,%rax
  shl    $0x2,%rax
  add    %rdx,%rax
  add    %rax,%rax
  add    %rcx,%rax
  movl   $0x3,-0x330(%rbp,%rax,4)
L251:
  mov    -0x348(%rbp),%eax
  mov    -0x344(%rbp),%edx
  movslq %edx,%rcx
  movslq %eax,%rdx
  mov    %rdx,%rax
  shl    $0x2,%rax
  add    %rdx,%rax
  add    %rax,%rax
  add    %rcx,%rax
  movl   $0x1,-0x1a0(%rbp,%rax,4)
  mov    -0x338(%rbp),%eax
  mov    %eax,%esi
  lea    D14(%rip),%rax
  mov    %rax,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  movl   $0x0,-0x340(%rbp)
  jmp    L281
L175:
  movl   $0x0,-0x33c(%rbp)
  jmp    L464
L458:
  mov    -0x358(%rbp),%eax
  test   %eax,%eax
  je     L295
  mov    -0x33c(%rbp),%eax
  movslq %eax,%rcx
  mov    -0x340(%rbp),%eax
  movslq %eax,%rdx
  mov    %rdx,%rax
  shl    $0x2,%rax
  add    %rdx,%rax
  add    %rax,%rax
  add    %rcx,%rax
  mov    -0x330(%rbp,%rax,4),%eax
  cmp    $0x1,%eax
  jne    L295
  lea    D253(%rip),%rax
  mov    %rax,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  jmp    L257
L295:
  mov    -0x33c(%rbp),%eax
  movslq %eax,%rcx
  mov    -0x340(%rbp),%eax
  movslq %eax,%rdx
  mov    %rdx,%rax
  shl    $0x2,%rax
  add    %rdx,%rax
  add    %rax,%rax
  add    %rcx,%rax
  mov    -0x330(%rbp,%rax,4),%eax
  cmp    $0x2,%eax
  jne    L407
  lea    D189(%rip),%rax
  mov    %rax,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  jmp    L257
L407:
  mov    -0x33c(%rbp),%eax
  movslq %eax,%rcx
  mov    -0x340(%rbp),%eax
  movslq %eax,%rdx
  mov    %rdx,%rax
  shl    $0x2,%rax
  add    %rdx,%rax
  add    %rax,%rax
  add    %rcx,%rax
  mov    -0x330(%rbp,%rax,4),%eax
  cmp    $0x3,%eax
  jne    L53
  lea    D177(%rip),%rax
  mov    %rax,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  jmp    L257
L53:
  lea    D167(%rip),%rax
  mov    %rax,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
L257:
  addl   $0x1,-0x33c(%rbp)
L464:
  cmpl   $0x9,-0x33c(%rbp)
  jle    L458
  mov    $0xa,%edi
  call   <putchar@plt>
  addl   $0x1,-0x340(%rbp)
L281:
  cmpl   $0x9,-0x340(%rbp)
  jle    L175
  mov    -0x350(%rbp),%eax
  sub    $0x1,%eax
  mov    %eax,-0x350(%rbp)
  mov    -0x348(%rbp),%eax
  mov    -0x344(%rbp),%edx
  movslq %edx,%rcx
  movslq %eax,%rdx
  mov    %rdx,%rax
  shl    $0x2,%rax
  add    %rdx,%rax
  add    %rax,%rax
  add    %rcx,%rax
  mov    -0x330(%rbp,%rax,4),%eax
  cmp    $0x2,%eax
  jne    L234
  mov    -0x350(%rbp),%edx
  mov    -0x34c(%rbp),%eax
  mov    %eax,%esi
  lea    D232(%rip),%rax
  mov    %rax,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  jmp    L475
L234:
  mov    -0x350(%rbp),%eax
  mov    %eax,%esi
  lea    D44(%rip),%rax
  mov    %rax,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
L475:
  addl   $0x1,-0x338(%rbp)
L112:
  mov    -0x34c(%rbp),%eax
  test   %eax,%eax
  jle    L368
  mov    -0x350(%rbp),%eax
  test   %eax,%eax
  jg     L315
L368:
  mov    -0x34c(%rbp),%eax
  test   %eax,%eax
  jne    L345
  lea    D19(%rip),%rax
  mov    %rax,%rdi
  call   <puts@plt>
  jmp    L333
L345:
  mov    -0x350(%rbp),%eax
  test   %eax,%eax
  jne    L333
  lea    D329(%rip),%rax
  mov    %rax,%rdi
  call   <puts@plt>
L333:
  mov    $0x0,%eax
  call   <getch@plt>
  mov    $0x0,%eax
  mov    -0x8(%rbp),%rdx
  sub    %fs:0x28,%rdx
  je     L182
  call   <__stack_chk_fail@plt>
L182:
  leave
  ret
```

tool_calls: name: read_data
arguments: tag: D336
datatype: string
name: read_data
arguments: tag: D96
datatype: string
name: read_data
arguments: tag: D116
datatype: string
name: read_data
arguments: tag: D21
datatype: string
name: read_data
arguments: tag: D396
datatype: string
name: read_data
arguments: tag: D32
datatype: string
name: read_data
arguments: tag: D185
datatype: string
name: read_data
arguments: tag: D334
datatype: string
name: read_data
arguments: tag: D79
datatype: string
name: read_data
arguments: tag: D352
datatype: string
name: read_data
arguments: tag: D400
datatype: string
name: read_data
arguments: tag: D398
datatype: string
name: read_data
arguments: tag: D372
datatype: string
name: read_data
arguments: tag: D341
datatype: string
name: read_data
arguments: tag: D153
datatype: string
name: read_data
arguments: tag: D438
datatype: string
name: read_data
arguments: tag: D295
datatype: string
name: read_data
arguments: tag: D375
datatype: string
name: read_data
arguments: tag: D14
datatype: string
name: read_data
arguments: tag: D253
datatype: string
name: read_data
arguments: tag: D189
datatype: string
name: read_data
arguments: tag: D177
datatype: string
name: read_data
arguments: tag: D167
datatype: string
name: read_data
arguments: tag: D232
datatype: string
name: read_data
arguments: tag: D44
datatype: string
name: read_data
arguments: tag: D19
datatype: string
name: read_data
arguments: tag: D329
datatype: string

tool: D336: ===========================================
	Habilitar Trapaca?
	|- Digite 1 para ATIVAR
	|- Digite 0 para CONTINUAR
===========================================

tool: D96: %d

tool: D116: 
[ATENCAO]	Opcao invalida!
	|- Digite 1 para ATIVAR
	|- Digite 0 para CONTINUAR

tool: D21: Vamos jogar campo minado em um campo 10x10?
Digite quantas bombas terao [De 1 (Facil) ate 99 (Impossivel)]:

tool: D396: Tem que ter pelo menos uma bomba, se nao nao e um Campo Minado!
Digite um valor de bombas valido (ate 99)

tool: D32: O campo tem 100 quadrados, voce nao quer ganhar?
Digite um numero menor que 99 e maior que 1 para as bombas

tool: D185: Voce escolheu %d bombas e acaba de entrar no MODO DIFICIL!
Voce tera %d rodadas para completar o jogo.
(Sem choro!)


tool: D334: Voce escolheu %d bombas e entrou no MODO FACIL do jogo!
Digite quantas rodadas voce deseja para completar o jogo.


tool: D79: Quantas vidas voce deseja ter?

tool: D352: Desculpa ai Senhor Perfeito!
Boa sorte com sua unica vida.

tool: D400: 


tool: D398: Voce esta preparado?!
 Vamos JOGAR!


tool: D372: Digite uma linha [De 0 a 9]

tool: D341: Digite um valor valido para a linha [De 0 a 9]

tool: D153: Digite uma coluna [De 0 a 9]

tool: D438: Digite um valor valido para a coluna [De 0 a 9]

tool: D295: 
[ATENCAO]	Voce ja fez essa jogada!

tool: D375: Digite um valor valido para a linha [De 0 a 9]


tool: D14: 

----- Rodada: %d -----


tool: D253: [B]	

tool: D189: [X]	

tool: D177: [O]	

tool: 

tool: D232: Voce acertou uma BOMBA! [-1 VIDA]
Voce ainda tem: %d vidas
Lhe restam %d jogadas



tool: D44: UFA, ali nao tinha bomba!
Continue assim por mais %d jogadas que voce ganha!



tool: D19: Que pena, suas vidas acabaram!
Tente novamente outra hora.[Tente diminuir a dificuldade tambem]

tool: D329: AE! Parabens! Voce ganhou!!! (Musica de vitoria)
Obrigado por jogar.	~~~~

assistant: ```c
int main() {
  int campominado[10][10];
  int jogadas[10][10];
  int codigo, bombas, i, j, rodadas, rodada, vidas, sorteiobombas, a, b;
  srand(time(NULL));
  rodadas = 1;
  for (j = 0; j < 10; j++) {
    for (i = 0; i < 10; i++) {
      campominado[i][j] = 0;
      jogadas[i][j] = 0;
    }
  }
  printf("===========================================\n\tHabilitar Trapaca?\n\t|- Digite 1 para ATIVAR\n\t|- Digite 0 para CONTINUAR\n===========================================\n");
  scanf("%d", &codigo);
  while ((codigo != 1) && (codigo != 0)) {
    printf("\n[ATENCAO]\tOpcao invalida!\n\t|- Digite 1 para ATIVAR\n\t|- Digite 0 para CONTINUAR\n");
    scanf("%d", &codigo);
  }
  printf("Vamos jogar campo minado em um campo 10x10?\nDigite quantas bombas terao [De 1 (Facil) ate 99 (Impossivel)]:\n");
  scanf("%d", &bombas);
  sorteiobombas = 1;
  while (bombas < 1) {
    printf("Tem que ter pelo menos uma bomba, se nao nao e um Campo Minado!\nDigite um valor de bombas valido (ate 99)\n");
    scanf("%d", &bombas);
  }
  while (bombas > 99) {
    printf("O campo tem 100 quadrados, voce nao quer ganhar?\nDigite um numero menor que 99 e maior que 1 para as bombas\n");
    scanf("%d", &bombas);
  }
  if ((bombas <= 99) && (bombas >= 75)) {
    rodada = 100 - bombas;
    printf("Voce escolheu %d bombas e acaba de entrar no MODO DIFICIL!\nVoce tera %d rodadas para completar o jogo.\n(Sem choro!)\n", bombas, rodada);
  } else {
    printf("Voce escolheu %d bombas e entrou no MODO FACIL do jogo!\nDigite quantas rodadas voce deseja para completar o jogo.\n", bombas);
    scanf("%d", &rodada);
  }
  printf("Quantas vidas voce deseja ter?\n");
  scanf("%d", &vidas);
  if (vidas == 1) {
    printf("Desculpa ai Senhor Perfeito!\nBoa sorte com sua unica vida.\n");
  }
  printf("\n\n");
  printf("Voce esta preparado?!\n Vamos JOGAR!\n\n");
  while (sorteiobombas <= bombas) {
    i = rand() % 10;
    j = rand() % 10;
    if (campominado[i][j] == 0) {
      campominado[i][j] = 1;
      sorteiobombas++;
    }
  }
  while (vidas > 0 && rodada > 0) {
    printf("Digite uma linha [De 0 a 9]\n");
    scanf("%d", &a);
    while ((a < 0) || (a > 9)) {
      printf("Digite um valor valido para a linha [De 0 a 9]\n");
      scanf("%d", &a);
    }
    printf("Digite uma coluna [De 0 a 9]\n");
    scanf("%d", &b);
    while ((b < 0) || (b > 9)) {
      printf("Digite um valor valido para a coluna [De 0 a 9]\n");
      scanf("%d", &b);
    }
    while (jogadas[a][b] == 1) {
      printf("\n[ATENCAO]\tVoce ja fez essa jogada!\n");
      printf("Digite uma linha [De 0 a 9]\n");
      scanf("%d", &a);
      while ((a < 0) || (a > 9)) {
        printf("Digite um valor valido para a linha [De 0 a 9]\n\n");
        scanf("%d", &a);
      }
      printf("Digite uma coluna [De 0 a 9]\n");
      scanf("%d", &b);
      while ((b < 0) || (b > 9)) {
        printf("Digite um valor valido para a coluna [De 0 a 9]\n");
        scanf("%d", &b);
      }
    }
    if (campominado[a][b] == 1) {
      campominado[a][b] = 2;
      vidas--;
    } else {
      campominado[a][b] = 3;
    }
    jogadas[a][b] = 1;
    printf("\n\n----- Rodada: %d -----\n", rodadas);
    for (i = 0; i < 10; i++) {
      for (j = 0; j < 10; j++) {
        if (codigo && campominado[i][j] == 1) {
          printf("[B]\t");
        } else if (campominado[i][j] == 2) {
          printf("[X]\t");
        } else if (campominado[i][j] == 3) {
          printf("[O]\t");
        } else {
          printf("[ ]\t");
        }
      }
      printf("\n");
    }
    rodada = rodada - 1;
    if (campominado[a][b] == 2) {
      printf("Voce acertou uma BOMBA! [-1 VIDA]\nVoce ainda tem: %d vidas\nLhe restam %d jogadas\n\n", vidas, rodada);
    } else {
      printf("UFA, ali nao tinha bomba!\nContinue assim por mais %d jogadas que voce ganha!\n\n", rodada);
    }
    rodadas++;
  }
  if (vidas == 0) {
    printf("Que pena, suas vidas acabaram!\nTente novamente outra hora.\[Tente diminuir a dificuldade tambem]\n");
  } else if (rodada == 0) {
    printf("AE! Parabens! Voce ganhou!!! (Musica de vitoria)\nObrigado por jogar.\t~~~~\n");
  }
  getch();
  return 0;
}
```