user: 下面的汇编指令对应的C源代码是什么：

```asm
<main>:
  endbr64
  push   %r15
  xor    %edi,%edi
  push   %r14
  push   %r13
  push   %r12
  lea    D43(%rip),%r12
  push   %rbp
  push   %rbx
  lea    D265(%rip),%rbx
  sub    $0x368,%rsp
  mov    %fs:0x28,%rax
  mov    %rax,0x358(%rsp)
  xor    %eax,%eax
  lea    0x18(%rsp),%rbp
  call   <time@plt>
  mov    %eax,%edi
  call   <srand@plt>
  pxor   %xmm0,%xmm0
  lea    D285(%rip),%rdi
  movq   $0x0,0x50(%rsp)
  movaps %xmm0,0x30(%rsp)
  movaps %xmm0,0x40(%rsp)
  movaps %xmm0,0x1c0(%rsp)
  movaps %xmm0,0x1d0(%rsp)
  movups %xmm0,0x58(%rsp)
  movups %xmm0,0x68(%rsp)
  movups %xmm0,0x1e8(%rsp)
  movups %xmm0,0x1f8(%rsp)
  movaps %xmm0,0x80(%rsp)
  movaps %xmm0,0x90(%rsp)
  movaps %xmm0,0x210(%rsp)
  movaps %xmm0,0x220(%rsp)
  movups %xmm0,0xa8(%rsp)
  movups %xmm0,0xb8(%rsp)
  movups %xmm0,0x238(%rsp)
  movups %xmm0,0x248(%rsp)
  movaps %xmm0,0xd0(%rsp)
  movaps %xmm0,0xe0(%rsp)
  movaps %xmm0,0x260(%rsp)
  movaps %xmm0,0x270(%rsp)
  movups %xmm0,0xf8(%rsp)
  movups %xmm0,0x108(%rsp)
  movq   $0x0,0x1e0(%rsp)
  movq   $0x0,0x78(%rsp)
  movq   $0x0,0x208(%rsp)
  movq   $0x0,0xa0(%rsp)
  movq   $0x0,0x230(%rsp)
  movq   $0x0,0xc8(%rsp)
  movq   $0x0,0x258(%rsp)
  movq   $0x0,0xf0(%rsp)
  movq   $0x0,0x280(%rsp)
  movq   $0x0,0x118(%rsp)
  movq   $0x0,0x2a8(%rsp)
  movq   $0x0,0x140(%rsp)
  movq   $0x0,0x2d0(%rsp)
  movq   $0x0,0x168(%rsp)
  movq   $0x0,0x2f8(%rsp)
  movq   $0x0,0x190(%rsp)
  movq   $0x0,0x320(%rsp)
  movq   $0x0,0x1b8(%rsp)
  movq   $0x0,0x348(%rsp)
  movups %xmm0,0x288(%rsp)
  movups %xmm0,0x298(%rsp)
  movaps %xmm0,0x120(%rsp)
  movaps %xmm0,0x130(%rsp)
  movaps %xmm0,0x2b0(%rsp)
  movaps %xmm0,0x2c0(%rsp)
  movups %xmm0,0x148(%rsp)
  movups %xmm0,0x158(%rsp)
  movups %xmm0,0x2d8(%rsp)
  movups %xmm0,0x2e8(%rsp)
  movaps %xmm0,0x170(%rsp)
  movaps %xmm0,0x180(%rsp)
  movaps %xmm0,0x300(%rsp)
  movaps %xmm0,0x310(%rsp)
  movups %xmm0,0x198(%rsp)
  movups %xmm0,0x1a8(%rsp)
  movups %xmm0,0x328(%rsp)
  movups %xmm0,0x338(%rsp)
  call   <puts@plt>
  mov    %rbp,%rsi
  mov    %rbx,%rdi
  call   <scanf@plt>
  cmpl   $0x1,0x18(%rsp)
  jbe    L345
L71:
  mov    %r12,%rdi
  call   <puts@plt>
  mov    %rbp,%rsi
  mov    %rbx,%rdi
  call   <scanf@plt>
  cmpl   $0x1,0x18(%rsp)
  ja     L71
L345:
  lea    D181(%rip),%rdi
  lea    0x1c(%rsp),%rbp
  call   <puts@plt>
  mov    %rbp,%rsi
  mov    %rbx,%rdi
  lea    D187(%rip),%r12
  call   <scanf@plt>
  mov    0x1c(%rsp),%esi
  test   %esi,%esi
  jg     L130
L67:
  mov    %r12,%rdi
  call   <puts@plt>
  mov    %rbp,%rsi
  mov    %rbx,%rdi
  call   <scanf@plt>
  mov    0x1c(%rsp),%esi
  test   %esi,%esi
  jle    L67
L130:
  cmp    $0x63,%esi
  jle    L268
  lea    D48(%rip),%r12
L61:
  mov    %r12,%rdi
  call   <puts@plt>
  mov    %rbp,%rsi
  mov    %rbx,%rdi
  call   <scanf@plt>
  mov    0x1c(%rsp),%esi
  cmp    $0x63,%esi
  jg     L61
L268:
  lea    -0x4b(%rsi),%eax
  cmp    $0x18,%eax
  ja     L324
  mov    $0x64,%edx
  lea    D52(%rip),%rdi
  xor    %eax,%eax
  sub    %esi,%edx
  mov    %edx,0x20(%rsp)
  call   <printf@plt>
L21:
  lea    D105(%rip),%rdi
  call   <puts@plt>
  lea    0x24(%rsp),%rsi
  mov    %rbx,%rdi
  call   <scanf@plt>
  cmpl   $0x1,0x24(%rsp)
  je     L343
L195:
  lea    D101(%rip),%rdi
  mov    $0x1,%r12d
  call   <puts@plt>
  lea    D40(%rip),%rdi
  call   <puts@plt>
  jmp    L168
  nopw   0x0(%rax,%rax,1)
L150:
  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    0x30(%rsp,%rax,4),%esi
  test   %esi,%esi
  je     L140
L168:
  cmp    0x1c(%rsp),%r12d
  jle    L150
  mov    0x24(%rsp),%eax
  movl   $0x1,0xc(%rsp)
  lea    D254(%rip),%r15
  test   %eax,%eax
  jle    L42
L69:
  mov    0x20(%rsp),%edx
  test   %edx,%edx
  jle    L142
  lea    D217(%rip),%rdi
  lea    0x28(%rsp),%rbp
  call   <puts@plt>
  mov    %rbp,%rsi
  mov    %rbx,%rdi
  lea    D102(%rip),%r12
  call   <scanf@plt>
  cmpl   $0x9,0x28(%rsp)
  jbe    L238
  cs nopw 0x0(%rax,%rax,1)
L337:
  mov    %r12,%rdi
  call   <puts@plt>
  mov    %rbp,%rsi
  mov    %rbx,%rdi
  call   <scanf@plt>
  cmpl   $0x9,0x28(%rsp)
  ja     L337
L238:
  lea    D268(%rip),%rdi
  lea    0x2c(%rsp),%r12
  call   <puts@plt>
  mov    %r12,%rsi
  mov    %rbx,%rdi
  lea    D201(%rip),%r13
  call   <scanf@plt>
  movslq 0x2c(%rsp),%rax
  cmp    $0x9,%eax
  jbe    L449
  nopw   0x0(%rax,%rax,1)
L436:
  mov    %r13,%rdi
  call   <puts@plt>
  mov    %r12,%rsi
  mov    %rbx,%rdi
  call   <scanf@plt>
  movslq 0x2c(%rsp),%rax
  cmp    $0x9,%eax
  ja     L436
L449:
  movslq 0x28(%rsp),%rdx
  lea    (%rdx,%rdx,4),%rcx
  lea    (%rax,%rcx,2),%rcx
  cmpl   $0x1,0x1c0(%rsp,%rcx,4)
  jne    L36
  lea    D83(%rip),%r14
  lea    D201(%rip),%r13
  cs nopw 0x0(%rax,%rax,1)
L1:
  lea    D20(%rip),%rdi
  call   <puts@plt>
  lea    D217(%rip),%rdi
  jmp    L132
  nopl   (%rax)
L215:
  mov    %r14,%rdi
L132:
  call   <puts@plt>
  mov    %rbp,%rsi
  mov    %rbx,%rdi
  call   <scanf@plt>
  cmpl   $0x9,0x28(%rsp)
  ja     L215
  lea    D268(%rip),%rdi
  jmp    L200
  nopl   0x0(%rax,%rax,1)
L64:
  mov    %r13,%rdi
L200:
  call   <puts@plt>
  mov    %r12,%rsi
  mov    %rbx,%rdi
  call   <scanf@plt>
  movslq 0x2c(%rsp),%rax
  cmp    $0x9,%eax
  ja     L64
  movslq 0x28(%rsp),%rdx
  lea    (%rdx,%rdx,4),%rcx
  lea    (%rax,%rcx,2),%rcx
  cmpl   $0x1,0x1c0(%rsp,%rcx,4)
  je     L1
L36:
  lea    (%rdx,%rdx,4),%rcx
  lea    (%rax,%rcx,2),%rsi
  mov    $0x3,%ecx
  cmpl   $0x1,0x30(%rsp,%rsi,4)
  jne    L66
  subl   $0x1,0x24(%rsp)
  mov    $0x2,%ecx
L66:
  lea    (%rdx,%rdx,4),%rdx
  mov    0xc(%rsp),%esi
  lea    D22(%rip),%rdi
  lea    (%rax,%rdx,2),%rax
  lea    0x58(%rsp),%rbp
  mov    %ecx,0x30(%rsp,%rax,4)
  lea    D131(%rip),%r12
  lea    D223(%rip),%r14
  movl   $0x1,0x1c0(%rsp,%rax,4)
  xor    %eax,%eax
  call   <printf@plt>
  lea    0x1e8(%rsp),%rax
  mov    %rax,(%rsp)
  nopw   0x0(%rax,%rax,1)
L365:
  lea    -0x28(%rbp),%r13
  jmp    L197
  cs nopw 0x0(%rax,%rax,1)
L211:
  mov    %r12,%rdi
  xor    %eax,%eax
  call   <printf@plt>
L49:
  add    $0x4,%r13
  cmp    %r13,%rbp
  je     L103
L197:
  mov    0x18(%rsp),%ecx
  mov    0x0(%r13),%eax
  test   %ecx,%ecx
  je     L55
  cmp    $0x1,%eax
  je     L5
L55:
  cmp    $0x2,%eax
  je     L362
  cmp    $0x3,%eax
  jne    L211
  mov    %r15,%rdi
  xor    %eax,%eax
  add    $0x4,%r13
  call   <printf@plt>
  cmp    %r13,%rbp
  jne    L197
L103:
  mov    $0xa,%edi
  add    $0x28,%rbp
  call   <putchar@plt>
  cmp    (%rsp),%rbp
  jne    L365
  mov    0x20(%rsp),%eax
  movslq 0x2c(%rsp),%rdx
  lea    -0x1(%rax),%esi
  movslq 0x28(%rsp),%rax
  mov    %esi,0x20(%rsp)
  lea    (%rax,%rax,4),%rax
  lea    (%rdx,%rax,2),%rax
  cmpl   $0x2,0x30(%rsp,%rax,4)
  je     L98
  lea    D21(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  mov    0x24(%rsp),%eax
  addl   $0x1,0xc(%rsp)
  test   %eax,%eax
  jg     L69
L42:
  test   %eax,%eax
  jne    L142
  lea    D10(%rip),%rdi
  call   <puts@plt>
L411:
  xor    %eax,%eax
  call   <getch@plt>
  mov    0x358(%rsp),%rax
  sub    %fs:0x28,%rax
  jne    L321
  add    $0x368,%rsp
  xor    %eax,%eax
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
  cs nopw 0x0(%rax,%rax,1)
L362:
  mov    %r14,%rdi
  xor    %eax,%eax
  call   <printf@plt>
  jmp    L49
  nop
L5:
  lea    D170(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  jmp    L49
L142:
  mov    0x20(%rsp),%eax
  test   %eax,%eax
  jne    L411
  lea    D132(%rip),%rdi
  call   <puts@plt>
  jmp    L411
  nopl   0x0(%rax)
L98:
  mov    %esi,%edx
  mov    0x24(%rsp),%esi
  lea    D197(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  mov    0x24(%rsp),%eax
  addl   $0x1,0xc(%rsp)
  test   %eax,%eax
  jg     L69
  jmp    L42
L140:
  movl   $0x1,0x30(%rsp,%rax,4)
  add    $0x1,%r12d
  jmp    L168
L324:
  lea    D295(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  lea    0x20(%rsp),%rsi
  mov    %rbx,%rdi
  call   <scanf@plt>
  jmp    L21
L343:
  lea    D114(%rip),%rdi
  call   <puts@plt>
  jmp    L195
L321:
  call   <__stack_chk_fail@plt>
```

tool_calls: name: read_data
arguments: label: D43
data_type: string
name: read_data
arguments: label: D265
data_type: string
name: read_data
arguments: label: D285
data_type: string
name: read_data
arguments: label: D181
data_type: string
name: read_data
arguments: label: D187
data_type: string
name: read_data
arguments: label: D48
data_type: string
name: read_data
arguments: label: D52
data_type: string
name: read_data
arguments: label: D105
data_type: string
name: read_data
arguments: label: D101
data_type: string
name: read_data
arguments: label: D40
data_type: string
name: read_data
arguments: label: D254
data_type: string
name: read_data
arguments: label: D217
data_type: string
name: read_data
arguments: label: D102
data_type: string
name: read_data
arguments: label: D268
data_type: string
name: read_data
arguments: label: D201
data_type: string
name: read_data
arguments: label: D83
data_type: string
name: read_data
arguments: label: D20
data_type: string
name: read_data
arguments: label: D22
data_type: string
name: read_data
arguments: label: D131
data_type: string
name: read_data
arguments: label: D223
data_type: string
name: read_data
arguments: label: D21
data_type: string
name: read_data
arguments: label: D10
data_type: string
name: read_data
arguments: label: D170
data_type: string
name: read_data
arguments: label: D132
data_type: string
name: read_data
arguments: label: D197
data_type: string
name: read_data
arguments: label: D295
data_type: string
name: read_data
arguments: label: D114
data_type: string

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

tool: D265: %d

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

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

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

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

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


tool: D105: Quantas vidas voce deseja ter?

tool: D101: 


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


tool: D254: [O]	

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

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

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

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

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


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

tool: D22: 

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


tool: 

tool: D223: [X]	

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



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

tool: D170: [B]	

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

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



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


tool: D114: 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;
}
```