user: Demonstrate the C code that generates the assembly output below:

```asm
<main>:
  endbr64
  push   %r15
  xor    %edi,%edi
  push   %r14
  push   %r13
  push   %r12
  push   %rbp
  push   %rbx
  sub    $0x378,%rsp
  mov    %fs:0x28,%rax
  mov    %rax,0x368(%rsp)
  xor    %eax,%eax
  call   <time@plt>
  mov    %eax,%edi
  call   <srand@plt>
  lea    0x40(%rsp),%rdx
  lea    0x68(%rsp),%rax
  mov    %rdx,0x18(%rsp)
  lea    0x1d0(%rsp),%rcx
  mov    %rax,0x8(%rsp)
  nopw   0x0(%rax,%rax,1)
L432:
  xor    %eax,%eax
  nopw   0x0(%rax,%rax,1)
L212:
  movl   $0x0,(%rdx,%rax,1)
  movl   $0x0,(%rcx,%rax,1)
  add    $0x28,%rax
  cmp    $0x190,%rax
  jne    L212
  add    $0x4,%rdx
  add    $0x4,%rcx
  cmp    0x8(%rsp),%rdx
  jne    L432
  lea    D195(%rip),%rdi
  lea    0x28(%rsp),%rbp
  lea    D75(%rip),%rbx
  lea    D115(%rip),%r12
  call   <puts@plt>
  mov    %rbp,%rsi
  mov    %rbx,%rdi
  call   <scanf@plt>
  cmpl   $0x1,0x28(%rsp)
  jbe    L26
L189:
  mov    %r12,%rdi
  call   <puts@plt>
  mov    %rbp,%rsi
  mov    %rbx,%rdi
  call   <scanf@plt>
  cmpl   $0x1,0x28(%rsp)
  ja     L189
L26:
  lea    D17(%rip),%rdi
  lea    0x2c(%rsp),%rbp
  call   <puts@plt>
  mov    %rbp,%rsi
  mov    %rbx,%rdi
  lea    D220(%rip),%r12
  call   <scanf@plt>
  mov    0x2c(%rsp),%esi
  test   %esi,%esi
  jg     L284
L24:
  mov    %r12,%rdi
  call   <puts@plt>
  mov    %rbp,%rsi
  mov    %rbx,%rdi
  call   <scanf@plt>
  mov    0x2c(%rsp),%esi
  test   %esi,%esi
  jle    L24
L284:
  cmp    $0x63,%esi
  jle    L121
  lea    D250(%rip),%r12
L369:
  mov    %r12,%rdi
  call   <puts@plt>
  mov    %rbp,%rsi
  mov    %rbx,%rdi
  call   <scanf@plt>
  mov    0x2c(%rsp),%esi
  cmp    $0x63,%esi
  jg     L369
L121:
  lea    -0x4b(%rsi),%eax
  cmp    $0x18,%eax
  ja     L163
  mov    $0x64,%edx
  lea    D176(%rip),%rdi
  xor    %eax,%eax
  sub    %esi,%edx
  mov    %edx,0x30(%rsp)
  call   <printf@plt>
L463:
  lea    D296(%rip),%rdi
  call   <puts@plt>
  lea    0x34(%rsp),%rsi
  mov    %rbx,%rdi
  call   <scanf@plt>
  cmpl   $0x1,0x34(%rsp)
  je     L458
L17:
  lea    D43(%rip),%rdi
  mov    $0x1,%r12d
  call   <puts@plt>
  lea    D219(%rip),%rdi
  call   <puts@plt>
  jmp    L252
  nopl   0x0(%rax,%rax,1)
L405:
  xor    %eax,%eax
  call   <rand@plt>
  movslq %eax,%rbp
  cltd
  imul   $0x66666667,%rbp,%rbp
  sar    $0x22,%rbp
  sub    %edx,%ebp
  lea    0x0(%rbp,%rbp,4),%edx
  add    %edx,%edx
  sub    %edx,%eax
  movslq %eax,%rbp
  xor    %eax,%eax
  call   <rand@plt>
  movslq %eax,%rdx
  mov    %eax,%ecx
  imul   $0x66666667,%rdx,%rdx
  sar    $0x1f,%ecx
  sar    $0x22,%rdx
  sub    %ecx,%edx
  lea    (%rdx,%rdx,4),%ecx
  add    %ecx,%ecx
  sub    %ecx,%eax
  movslq %eax,%rdx
  lea    0x0(%rbp,%rbp,4),%rax
  lea    (%rdx,%rax,2),%rax
  mov    0x40(%rsp,%rax,4),%esi
  test   %esi,%esi
  je     L406
L252:
  cmp    0x2c(%rsp),%r12d
  jle    L405
  mov    0x34(%rsp),%eax
  movl   $0x1,0x14(%rsp)
  lea    D223(%rip),%r15
  test   %eax,%eax
  jle    L185
L330:
  mov    0x30(%rsp),%edx
  test   %edx,%edx
  jle    L402
  lea    D38(%rip),%rdi
  lea    0x38(%rsp),%rbp
  call   <puts@plt>
  mov    %rbp,%rsi
  mov    %rbx,%rdi
  lea    D142(%rip),%r12
  call   <scanf@plt>
  cmpl   $0x9,0x38(%rsp)
  jbe    L428
  cs nopw 0x0(%rax,%rax,1)
L178:
  mov    %r12,%rdi
  call   <puts@plt>
  mov    %rbp,%rsi
  mov    %rbx,%rdi
  call   <scanf@plt>
  cmpl   $0x9,0x38(%rsp)
  ja     L178
L428:
  lea    D244(%rip),%rdi
  lea    0x3c(%rsp),%r12
  call   <puts@plt>
  mov    %r12,%rsi
  mov    %rbx,%rdi
  lea    D247(%rip),%r13
  call   <scanf@plt>
  movslq 0x3c(%rsp),%rax
  cmp    $0x9,%eax
  jbe    L283
  nopw   0x0(%rax,%rax,1)
L333:
  mov    %r13,%rdi
  call   <puts@plt>
  mov    %r12,%rsi
  mov    %rbx,%rdi
  call   <scanf@plt>
  movslq 0x3c(%rsp),%rax
  cmp    $0x9,%eax
  ja     L333
L283:
  movslq 0x38(%rsp),%rdx
  lea    (%rdx,%rdx,4),%rcx
  lea    (%rax,%rcx,2),%rcx
  cmpl   $0x1,0x1d0(%rsp,%rcx,4)
  jne    L199
  lea    D210(%rip),%r14
  lea    D247(%rip),%r13
  cs nopw 0x0(%rax,%rax,1)
L28:
  lea    D11(%rip),%rdi
  call   <puts@plt>
  lea    D38(%rip),%rdi
  jmp    L335
  nopl   (%rax)
L150:
  mov    %r14,%rdi
L335:
  call   <puts@plt>
  mov    %rbp,%rsi
  mov    %rbx,%rdi
  call   <scanf@plt>
  cmpl   $0x9,0x38(%rsp)
  ja     L150
  lea    D244(%rip),%rdi
  jmp    L172
  nopl   0x0(%rax,%rax,1)
L395:
  mov    %r13,%rdi
L172:
  call   <puts@plt>
  mov    %r12,%rsi
  mov    %rbx,%rdi
  call   <scanf@plt>
  movslq 0x3c(%rsp),%rax
  cmp    $0x9,%eax
  ja     L395
  movslq 0x38(%rsp),%rdx
  lea    (%rdx,%rdx,4),%rcx
  lea    (%rax,%rcx,2),%rcx
  cmpl   $0x1,0x1d0(%rsp,%rcx,4)
  je     L28
L199:
  lea    (%rdx,%rdx,4),%rcx
  lea    (%rax,%rcx,2),%rcx
  cmpl   $0x1,0x40(%rsp,%rcx,4)
  je     L292
  movl   $0x3,0x40(%rsp,%rcx,4)
L87:
  lea    (%rdx,%rdx,4),%rdx
  mov    0x14(%rsp),%esi
  lea    D203(%rip),%rdi
  lea    (%rax,%rdx,2),%rax
  lea    D116(%rip),%r12
  movl   $0x1,0x1d0(%rsp,%rax,4)
  xor    %eax,%eax
  lea    D3(%rip),%r14
  call   <printf@plt>
  mov    0x18(%rsp),%rax
  mov    0x8(%rsp),%rbp
  add    $0x1b8,%rax
  mov    %rax,(%rsp)
  cs nopw 0x0(%rax,%rax,1)
L119:
  lea    -0x28(%rbp),%r13
  jmp    L198
  cs nopw 0x0(%rax,%rax,1)
L457:
  mov    %r12,%rdi
  xor    %eax,%eax
  call   <printf@plt>
L43:
  add    $0x4,%r13
  cmp    %rbp,%r13
  je     L319
L198:
  mov    0x28(%rsp),%ecx
  mov    0x0(%r13),%eax
  test   %ecx,%ecx
  je     L55
  cmp    $0x1,%eax
  je     L3
L55:
  cmp    $0x2,%eax
  je     L215
  cmp    $0x3,%eax
  jne    L457
  mov    %r15,%rdi
  xor    %eax,%eax
  add    $0x4,%r13
  call   <printf@plt>
  cmp    %rbp,%r13
  jne    L198
L319:
  mov    $0xa,%edi
  lea    0x28(%r13),%rbp
  call   <putchar@plt>
  cmp    (%rsp),%rbp
  jne    L119
  mov    0x30(%rsp),%eax
  movslq 0x3c(%rsp),%rdx
  lea    -0x1(%rax),%esi
  movslq 0x38(%rsp),%rax
  mov    %esi,0x30(%rsp)
  lea    (%rax,%rax,4),%rax
  lea    (%rdx,%rax,2),%rax
  cmpl   $0x2,0x40(%rsp,%rax,4)
  je     L19
  lea    D146(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
L152:
  mov    0x34(%rsp),%eax
  addl   $0x1,0x14(%rsp)
  test   %eax,%eax
  jg     L330
L185:
  test   %eax,%eax
  jne    L402
  lea    D242(%rip),%rdi
  call   <puts@plt>
L216:
  xor    %eax,%eax
  call   <getch@plt>
  mov    0x368(%rsp),%rax
  sub    %fs:0x28,%rax
  jne    L7
  add    $0x378,%rsp
  xor    %eax,%eax
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
  cs nopw 0x0(%rax,%rax,1)
L215:
  mov    %r14,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  jmp    L43
  nop
L3:
  lea    D182(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  jmp    L43
L402:
  mov    0x30(%rsp),%eax
  test   %eax,%eax
  jne    L216
  lea    D28(%rip),%rdi
  call   <puts@plt>
  jmp    L216
  nopl   0x0(%rax)
L19:
  mov    %esi,%edx
  mov    0x34(%rsp),%esi
  lea    D64(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  jmp    L152
L292:
  subl   $0x1,0x34(%rsp)
  movl   $0x2,0x40(%rsp,%rcx,4)
  jmp    L87
L406:
  movl   $0x1,0x40(%rsp,%rax,4)
  add    $0x1,%r12d
  jmp    L252
L163:
  lea    D204(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  lea    0x30(%rsp),%rsi
  mov    %rbx,%rdi
  call   <scanf@plt>
  jmp    L463
L458:
  lea    D243(%rip),%rdi
  call   <puts@plt>
  jmp    L17
L7:
  call   <__stack_chk_fail@plt>
```

tool_calls: name: disassemble_data
arguments: data_label: D195
type_infered: string
name: disassemble_data
arguments: data_label: D75
type_infered: string
name: disassemble_data
arguments: data_label: D115
type_infered: string
name: disassemble_data
arguments: data_label: D17
type_infered: string
name: disassemble_data
arguments: data_label: D220
type_infered: string
name: disassemble_data
arguments: data_label: D250
type_infered: string
name: disassemble_data
arguments: data_label: D176
type_infered: string
name: disassemble_data
arguments: data_label: D296
type_infered: string
name: disassemble_data
arguments: data_label: D43
type_infered: string
name: disassemble_data
arguments: data_label: D219
type_infered: string
name: disassemble_data
arguments: data_label: D223
type_infered: string
name: disassemble_data
arguments: data_label: D38
type_infered: string
name: disassemble_data
arguments: data_label: D142
type_infered: string
name: disassemble_data
arguments: data_label: D244
type_infered: string
name: disassemble_data
arguments: data_label: D247
type_infered: string
name: disassemble_data
arguments: data_label: D210
type_infered: string
name: disassemble_data
arguments: data_label: D11
type_infered: string
name: disassemble_data
arguments: data_label: D203
type_infered: string
name: disassemble_data
arguments: data_label: D116
type_infered: string
name: disassemble_data
arguments: data_label: D3
type_infered: string
name: disassemble_data
arguments: data_label: D146
type_infered: string
name: disassemble_data
arguments: data_label: D242
type_infered: string
name: disassemble_data
arguments: data_label: D182
type_infered: string
name: disassemble_data
arguments: data_label: D28
type_infered: string
name: disassemble_data
arguments: data_label: D64
type_infered: string
name: disassemble_data
arguments: data_label: D204
type_infered: string
name: disassemble_data
arguments: data_label: D243
type_infered: string

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

tool: D75: %d

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

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

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

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

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


tool: D296: Quantas vidas voce deseja ter?

tool: D43: 


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


tool: D223: [O]	

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

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

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

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

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


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

tool: D203: 

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


tool: 

tool: D3: [X]	

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



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

tool: D182: [B]	

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

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



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


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

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;
}
```