user: What would the C source look like for the assembly code provided here?

```asm
<main>:
  endbr64
  push   %r15
  push   %r14
  push   %r13
  push   %r12
  push   %rbp
  push   %rbx
  sub    $0x378,%rsp
  mov    %fs:0x28,%rax
  mov    %rax,0x368(%rsp)
  xor    %eax,%eax
  mov    $0x0,%edi
  call   <time@plt>
  mov    %eax,%edi
  call   <srand@plt>
  lea    0x40(%rsp),%rdx
  mov    %rdx,0x18(%rsp)
  lea    0x1d0(%rsp),%rcx
  lea    0x68(%rsp),%rax
  mov    %rax,0x8(%rsp)
L415:
  mov    $0x0,%eax
L147:
  movl   $0x0,(%rdx,%rax,1)
  movl   $0x0,(%rcx,%rax,1)
  add    $0x28,%rax
  cmp    $0x190,%rax
  jne    L147
  add    $0x4,%rdx
  add    $0x4,%rcx
  cmp    0x8(%rsp),%rdx
  jne    L415
  lea    D144(%rip),%rdi
  call   <puts@plt>
  lea    0x28(%rsp),%rsi
  lea    D252(%rip),%rdi
  call   <scanf@plt>
  cmpl   $0x1,0x28(%rsp)
  jbe    L40
  lea    D241(%rip),%r12
  lea    0x28(%rsp),%rbp
  lea    D252(%rip),%rbx
L481:
  mov    %r12,%rdi
  call   <puts@plt>
  mov    %rbp,%rsi
  mov    %rbx,%rdi
  call   <scanf@plt>
  cmpl   $0x1,0x28(%rsp)
  ja     L481
L40:
  lea    D391(%rip),%rdi
  call   <puts@plt>
  lea    0x2c(%rsp),%rsi
  lea    D252(%rip),%rdi
  call   <scanf@plt>
  cmpl   $0x0,0x2c(%rsp)
  jg     L83
  lea    D114(%rip),%r12
  lea    0x2c(%rsp),%rbp
  lea    D252(%rip),%rbx
L278:
  mov    %r12,%rdi
  call   <puts@plt>
  mov    %rbp,%rsi
  mov    %rbx,%rdi
  call   <scanf@plt>
  cmpl   $0x0,0x2c(%rsp)
  jle    L278
L83:
  mov    0x2c(%rsp),%esi
  cmp    $0x63,%esi
  jle    L17
  lea    D281(%rip),%r12
  lea    0x2c(%rsp),%rbp
  lea    D252(%rip),%rbx
L137:
  mov    %r12,%rdi
  call   <puts@plt>
  mov    %rbp,%rsi
  mov    %rbx,%rdi
  call   <scanf@plt>
  mov    0x2c(%rsp),%esi
  cmp    $0x63,%esi
  jg     L137
L17:
  lea    -0x4b(%rsi),%eax
  cmp    $0x18,%eax
  ja     L45
  mov    $0x64,%edx
  sub    %esi,%edx
  mov    %edx,0x30(%rsp)
  lea    D169(%rip),%rdi
  mov    $0x0,%eax
  call   <printf@plt>
L355:
  lea    D139(%rip),%rdi
  call   <puts@plt>
  lea    0x34(%rsp),%rsi
  lea    D252(%rip),%rdi
  call   <scanf@plt>
  cmpl   $0x1,0x34(%rsp)
  je     L430
L252:
  lea    D42(%rip),%rdi
  call   <puts@plt>
  lea    D67(%rip),%rdi
  call   <puts@plt>
  mov    $0x1,%ebp
L359:
  cmp    0x2c(%rsp),%ebp
  jg     L292
  mov    $0x0,%eax
  call   <rand@plt>
  movslq %eax,%rbx
  imul   $0x66666667,%rbx,%rbx
  sar    $0x22,%rbx
  cltd
  sub    %edx,%ebx
  lea    (%rbx,%rbx,4),%edx
  add    %edx,%edx
  sub    %edx,%eax
  mov    %eax,%ebx
  mov    $0x0,%eax
  call   <rand@plt>
  movslq %eax,%rdx
  imul   $0x66666667,%rdx,%rdx
  sar    $0x22,%rdx
  mov    %eax,%ecx
  sar    $0x1f,%ecx
  sub    %ecx,%edx
  lea    (%rdx,%rdx,4),%ecx
  add    %ecx,%ecx
  sub    %ecx,%eax
  movslq %eax,%rcx
  movslq %ebx,%rax
  lea    (%rax,%rax,4),%rax
  lea    (%rcx,%rax,2),%rax
  cmpl   $0x0,0x40(%rsp,%rax,4)
  jne    L359
  movslq %ebx,%rbx
  lea    (%rbx,%rbx,4),%rax
  lea    (%rcx,%rax,2),%rax
  movl   $0x1,0x40(%rsp,%rax,4)
  add    $0x1,%ebp
  jmp    L359
L45:
  lea    D245(%rip),%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  lea    0x30(%rsp),%rsi
  lea    D252(%rip),%rdi
  call   <scanf@plt>
  jmp    L355
L430:
  lea    D135(%rip),%rdi
  call   <puts@plt>
  jmp    L252
L292:
  mov    0x34(%rsp),%eax
  movl   $0x1,0x14(%rsp)
  lea    D34(%rip),%r13
  test   %eax,%eax
  jg     L78
L132:
  test   %eax,%eax
  je     L413
  cmpl   $0x0,0x30(%rsp)
  je     L395
L182:
  mov    $0x0,%eax
  call   <getch@plt>
  mov    0x368(%rsp),%rax
  sub    %fs:0x28,%rax
  jne    L5
  mov    $0x0,%eax
  add    $0x378,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
L215:
  mov    0x38(%rsp),%edx
  mov    0x3c(%rsp),%ecx
  movslq %ecx,%rsi
  movslq %edx,%rax
  lea    (%rax,%rax,4),%rax
  lea    (%rsi,%rax,2),%rax
  cmpl   $0x1,0x1d0(%rsp,%rax,4)
  jne    L14
L100:
  mov    %r15,%rdi
  call   <puts@plt>
  lea    D163(%rip),%rdi
  call   <puts@plt>
  lea    0x38(%rsp),%rsi
  mov    %rbx,%rdi
  call   <scanf@plt>
  cmpl   $0x9,0x38(%rsp)
  jbe    L193
  lea    0x38(%rsp),%rbp
L195:
  mov    %r14,%rdi
  call   <puts@plt>
  mov    %rbp,%rsi
  mov    %rbx,%rdi
  call   <scanf@plt>
  cmpl   $0x9,0x38(%rsp)
  ja     L195
L193:
  lea    D187(%rip),%rdi
  call   <puts@plt>
  lea    0x3c(%rsp),%rsi
  mov    %rbx,%rdi
  call   <scanf@plt>
  cmpl   $0x9,0x3c(%rsp)
  jbe    L215
  lea    D249(%rip),%r12
  lea    0x3c(%rsp),%rbp
L322:
  mov    %r12,%rdi
  call   <puts@plt>
  mov    %rbp,%rsi
  mov    %rbx,%rdi
  call   <scanf@plt>
  cmpl   $0x9,0x3c(%rsp)
  ja     L322
  jmp    L215
L14:
  movslq %ecx,%rax
  movslq %edx,%rsi
  lea    (%rsi,%rsi,4),%rsi
  lea    (%rax,%rsi,2),%rax
  cmpl   $0x1,0x40(%rsp,%rax,4)
  je     L95
  movslq %ecx,%rax
  movslq %edx,%rsi
  lea    (%rsi,%rsi,4),%rsi
  lea    (%rax,%rsi,2),%rax
  movl   $0x3,0x40(%rsp,%rax,4)
L418:
  movslq %ecx,%rcx
  movslq %edx,%rdx
  lea    (%rdx,%rdx,4),%rax
  lea    (%rcx,%rax,2),%rax
  movl   $0x1,0x1d0(%rsp,%rax,4)
  mov    0x14(%rsp),%esi
  lea    D296(%rip),%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  mov    0x18(%rsp),%rax
  add    $0x1b8,%rax
  mov    %rax,(%rsp)
  mov    0x8(%rsp),%rbp
  lea    D273(%rip),%r12
  lea    D179(%rip),%r15
  jmp    L39
L95:
  movslq %ecx,%rax
  movslq %edx,%rsi
  lea    (%rsi,%rsi,4),%rsi
  lea    (%rax,%rsi,2),%rax
  movl   $0x2,0x40(%rsp,%rax,4)
  subl   $0x1,0x34(%rsp)
  jmp    L418
L393:
  mov    (%rbx),%eax
  cmp    $0x2,%eax
  je     L382
  cmp    $0x3,%eax
  je     L146
  mov    %r12,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
L60:
  add    $0x4,%rbx
  cmp    %rbx,%rbp
  je     L72
L113:
  cmpl   $0x0,0x28(%rsp)
  je     L393
  cmpl   $0x1,(%rbx)
  jne    L393
  mov    %r14,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  jmp    L60
L382:
  mov    %r15,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  jmp    L60
L146:
  mov    %r13,%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  jmp    L60
L72:
  mov    $0xa,%edi
  call   <putchar@plt>
  add    $0x28,%rbp
  cmp    %rbp,(%rsp)
  je     L34
L39:
  lea    -0x28(%rbp),%rbx
  lea    D97(%rip),%r14
  jmp    L113
L34:
  mov    0x30(%rsp),%eax
  lea    -0x1(%rax),%esi
  mov    %esi,0x30(%rsp)
  movslq 0x3c(%rsp),%rdx
  movslq 0x38(%rsp),%rax
  lea    (%rax,%rax,4),%rax
  lea    (%rdx,%rax,2),%rax
  cmpl   $0x2,0x40(%rsp,%rax,4)
  je     L421
  lea    D226(%rip),%rdi
  mov    $0x0,%eax
  call   <printf@plt>
L16:
  addl   $0x1,0x14(%rsp)
  mov    0x34(%rsp),%eax
  test   %eax,%eax
  jle    L132
L78:
  cmpl   $0x0,0x30(%rsp)
  jle    L132
  lea    D163(%rip),%rdi
  call   <puts@plt>
  lea    0x38(%rsp),%rsi
  lea    D252(%rip),%rdi
  call   <scanf@plt>
  cmpl   $0x9,0x38(%rsp)
  jbe    L208
  lea    D84(%rip),%r12
  lea    0x38(%rsp),%rbp
  lea    D252(%rip),%rbx
L243:
  mov    %r12,%rdi
  call   <puts@plt>
  mov    %rbp,%rsi
  mov    %rbx,%rdi
  call   <scanf@plt>
  cmpl   $0x9,0x38(%rsp)
  ja     L243
L208:
  lea    D187(%rip),%rdi
  call   <puts@plt>
  lea    0x3c(%rsp),%rsi
  lea    D252(%rip),%rdi
  call   <scanf@plt>
  cmpl   $0x9,0x3c(%rsp)
  jbe    L363
  lea    D249(%rip),%r12
  lea    0x3c(%rsp),%rbp
  lea    D252(%rip),%rbx
L6:
  mov    %r12,%rdi
  call   <puts@plt>
  mov    %rbp,%rsi
  mov    %rbx,%rdi
  call   <scanf@plt>
  cmpl   $0x9,0x3c(%rsp)
  ja     L6
L363:
  mov    0x38(%rsp),%edx
  mov    0x3c(%rsp),%ecx
  movslq %ecx,%rsi
  movslq %edx,%rax
  lea    (%rax,%rax,4),%rax
  lea    (%rsi,%rax,2),%rax
  cmpl   $0x1,0x1d0(%rsp,%rax,4)
  jne    L14
  lea    D356(%rip),%r15
  lea    D252(%rip),%rbx
  lea    D9(%rip),%r14
  jmp    L100
L421:
  mov    %esi,%edx
  mov    0x34(%rsp),%esi
  lea    D375(%rip),%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  jmp    L16
L413:
  lea    D178(%rip),%rdi
  call   <puts@plt>
  jmp    L182
L395:
  lea    D213(%rip),%rdi
  call   <puts@plt>
  jmp    L182
L5:
  call   <__stack_chk_fail@plt>
```

tool_calls: name: unpack_data
arguments: data_label: D144
type: string
name: unpack_data
arguments: data_label: D252
type: string
name: unpack_data
arguments: data_label: D241
type: string
name: unpack_data
arguments: data_label: D391
type: string
name: unpack_data
arguments: data_label: D114
type: string
name: unpack_data
arguments: data_label: D281
type: string
name: unpack_data
arguments: data_label: D169
type: string
name: unpack_data
arguments: data_label: D139
type: string
name: unpack_data
arguments: data_label: D42
type: string
name: unpack_data
arguments: data_label: D67
type: string
name: unpack_data
arguments: data_label: D245
type: string
name: unpack_data
arguments: data_label: D135
type: string
name: unpack_data
arguments: data_label: D34
type: string
name: unpack_data
arguments: data_label: D163
type: string
name: unpack_data
arguments: data_label: D187
type: string
name: unpack_data
arguments: data_label: D249
type: string
name: unpack_data
arguments: data_label: D296
type: string
name: unpack_data
arguments: data_label: D273
type: string
name: unpack_data
arguments: data_label: D179
type: string
name: unpack_data
arguments: data_label: D97
type: string
name: unpack_data
arguments: data_label: D226
type: string
name: unpack_data
arguments: data_label: D84
type: string
name: unpack_data
arguments: data_label: D356
type: string
name: unpack_data
arguments: data_label: D9
type: string
name: unpack_data
arguments: data_label: D375
type: string
name: unpack_data
arguments: data_label: D178
type: string
name: unpack_data
arguments: data_label: D213
type: string

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

tool: D252: %d

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

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

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

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

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


tool: D139: Quantas vidas voce deseja ter?

tool: D42: 


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


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


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

tool: D34: [O]	

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

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

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

tool: D296: 

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


tool: 

tool: D179: [X]	

tool: D97: [B]	

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



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

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

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


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



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

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