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

```asm
<main>:
  endbr64
  push   %r15
  push   %r14
  lea    D54(%rip),%r14
  push   %r13
  lea    D15(%rip),%r13
  push   %r12
  push   %rbp
  push   %rbx
  sub    $0x38,%rsp
  mov    %fs:0x28,%rax
  mov    %rax,0x28(%rsp)
  xor    %eax,%eax
  lea    0x20(%rsp),%rax
  movl   $0x0,0x10(%rsp)
  lea    0x24(%rsp),%r15
  mov    %rax,0x18(%rsp)
  nopw   0x0(%rax,%rax,1)
L183:
  mov    %r13,%rdi
  xor    %r12d,%r12d
  xor    %ebp,%ebp
  call   <puts@plt>
  xor    %edi,%edi
  movl   $0x1,0x20(%rsp)
  movl   $0x0,0x24(%rsp)
  call   <time@plt>
  mov    %eax,%edi
  call   <srand@plt>
  xor    %eax,%eax
  call   <rand@plt>
  movl   $0x0,0xc(%rsp)
  cltd
  shr    $0x18,%edx
  lea    (%rax,%rdx,1),%ebx
  movzbl %bl,%ebx
  sub    %edx,%ebx
  mov    %ebx,%eax
  mov    %r12d,%ebx
  mov    %eax,%r12d
L159:
  mov    %r15,%rsi
  mov    %r14,%rdi
  call   <scanf@plt>
  mov    0x24(%rsp),%eax
  cmp    %r12d,%eax
  je     L166
  jle    L4
  sub    %r12d,%eax
  mov    %eax,%edx
  cmp    %ebx,%eax
  jl     L123
  test   %ebx,%ebx
  jne    L176
L123:
  lea    D77(%rip),%rdi
  mov    %edx,0x14(%rsp)
  add    $0x1,%ebp
  call   <puts@plt>
  mov    0x14(%rsp),%ebx
  jmp    L159
  nopw   0x0(%rax,%rax,1)
L166:
  mov    %ebp,%esi
  lea    D87(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  mov    0x10(%rsp),%eax
  test   %eax,%eax
  je     L109
  cmp    %eax,%ebp
  jl     L9
L140:
  mov    0x10(%rsp),%esi
  lea    D95(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  lea    D13(%rip),%rdi
  call   <puts@plt>
  mov    0x18(%rsp),%rsi
  mov    %r14,%rdi
  call   <scanf@plt>
  mov    0x20(%rsp),%eax
  cmp    $0x1,%eax
  je     L183
  test   %eax,%eax
  jne    L184
L75:
  mov    0x28(%rsp),%rax
  sub    %fs:0x28,%rax
  jne    L31
  add    $0x38,%rsp
  mov    $0x1,%eax
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
  nopl   0x0(%rax)
L4:
  jge    L159
  mov    %r12d,%edx
  sub    %eax,%edx
  mov    0xc(%rsp),%eax
  test   %eax,%eax
  je     L157
  cmp    %eax,%edx
  jge    L66
L157:
  lea    D103(%rip),%rdi
  mov    %edx,0xc(%rsp)
  add    $0x1,%ebp
  call   <puts@plt>
  jmp    L159
  nopw   0x0(%rax,%rax,1)
L109:
  mov    %ebp,0x10(%rsp)
  jmp    L140
  nopl   0x0(%rax)
L9:
  lea    D94(%rip),%rdi
  call   <puts@plt>
  mov    %ebp,0x10(%rsp)
  jmp    L140
  nopl   (%rax)
L176:
  lea    (%r12,%rbx,1),%esi
  lea    D14(%rip),%rdi
  xor    %eax,%eax
  call   <printf@plt>
  mov    %ebx,%edx
  jmp    L123
L66:
  mov    %r12d,%esi
  lea    D30(%rip),%rdi
  sub    %eax,%esi
  xor    %eax,%eax
  call   <printf@plt>
  mov    0xc(%rsp),%edx
  jmp    L157
L184:
  lea    D42(%rip),%rdi
  call   <puts@plt>
  jmp    L75
L31:
  call   <__stack_chk_fail@plt>
```

tool_calls: name: retrieve_data
arguments: data_label: D54
type_guessed: string
name: retrieve_data
arguments: data_label: D15
type_guessed: string
name: retrieve_data
arguments: data_label: D77
type_guessed: string
name: retrieve_data
arguments: data_label: D87
type_guessed: string
name: retrieve_data
arguments: data_label: D95
type_guessed: string
name: retrieve_data
arguments: data_label: D13
type_guessed: string
name: retrieve_data
arguments: data_label: D103
type_guessed: string
name: retrieve_data
arguments: data_label: D94
type_guessed: string
name: retrieve_data
arguments: data_label: D14
type_guessed: string
name: retrieve_data
arguments: data_label: D30
type_guessed: string
name: retrieve_data
arguments: data_label: D42
type_guessed: string

tool: D54: %d

tool: D15: GUESS A VALUE BETWEEN 0 AND 255

tool: D77: TOO HIGH. GUESS AGAIN.

tool: D87: CORRECT. IT TOOK YOU %d ATTEMPTS


tool: D95: HIGH SCORE :: %d


tool: D13: PLAY AGAIN? (0 = N/1 = Y)

tool: D103: TOO LOW. GUESS AGAIN.

tool: D94: < < NEW HIGH SCORE > >

tool: D14: ANSWER IS NOT HIGHER THAN %d


tool: D30: ANSWER IS NOT LOWER THAN %d


tool: D42: INVALID RESPONSE.

assistant: ```c
int main(int argc, char **argv) {
  int guess_count = 0, upper_threshold = 0, lower_threshold = 0, high_score = 0, answer = 0;
  int location = 1, active = 1;
  while (active != 0) {
    switch (location) {
    case 1:
      printf("GUESS A VALUE BETWEEN 0 AND 255\n");
      int play_again = 1;
      int guess = 0;
      guess_count = 0;
      upper_threshold = 0;
      lower_threshold = 0;
      srand(time(NULL));
      answer = rand() % 256;
      location = 2;
      break;
    case 2:
      scanf("%d", &guess);
      if (guess == answer) {
        printf("CORRECT. IT TOOK YOU %d ATTEMPTS\n", guess_count);
        if (high_score == 0) {
          high_score = guess_count;
        } else if (high_score > guess_count) {
          printf("< < NEW HIGH SCORE > >\n");
          high_score = guess_count;
        }
        printf("HIGH SCORE :: %d\n", high_score);
        printf("PLAY AGAIN? (0 = N/1 = Y)\n");
        scanf("%d", &play_again);
        if (play_again == 1) {
          location = 1;
          break;
        } else if (play_again == 0) {
          active = 0;
          return 1;
        } else {
          printf("INVALID RESPONSE.\n");
          active = 0;
          return 1;
        }
      } else {
        if (guess > answer) {
          if ((guess - answer) >= upper_threshold) {
            if (upper_threshold != 0) {
              printf("ANSWER IS NOT HIGHER THAN %d\n", (answer + upper_threshold));
            } else {
              upper_threshold = (guess - answer);
            }
          } else {
            upper_threshold = (guess - answer);
          }
          printf("TOO HIGH. GUESS AGAIN.\n");
          guess_count++;
        } else if (guess < answer) {
          if ((answer - guess) >= lower_threshold) {
            if (lower_threshold != 0) {
              printf("ANSWER IS NOT LOWER THAN %d\n", (answer - lower_threshold));
            } else {
              lower_threshold = (answer - guess);
            }
          } else {
            lower_threshold = (answer - guess);
          }
          printf("TOO LOW. GUESS AGAIN.\n");
          guess_count++;
        }
      }
    default:
      break;
    }
  }
}
```