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    $0x28,%rsp
  mov    %fs:0x28,%rax
  mov    %rax,0x18(%rsp)
  xor    %eax,%eax
  mov    $0x1,%ebp
  mov    $0x0,%ebx
  mov    $0x0,%r15d
  movl   $0x0,0x8(%rsp)
  mov    $0x0,%r13d
  mov    $0x0,%r12d
  lea    D34(%rip),%r14
  jmp    L136
L14:
  lea    D57(%rip),%rdi
  call   <puts@plt>
  movl   $0x1,0x10(%rsp)
  movl   $0x0,0x14(%rsp)
  mov    $0x0,%edi
  call   <time@plt>
  mov    %eax,%edi
  call   <srand@plt>
  mov    $0x0,%eax
  call   <rand@plt>
  cltd
  shr    $0x18,%edx
  lea    (%rax,%rdx,1),%ebx
  movzbl %bl,%ebx
  sub    %edx,%ebx
  mov    $0x2,%ebp
  movl   $0x0,0x8(%rsp)
  mov    $0x0,%r13d
  mov    $0x0,%r12d
L136:
  cmp    $0x1,%ebp
  je     L14
  cmp    $0x2,%ebp
  jne    L136
  lea    0x14(%rsp),%rsi
  mov    %r14,%rdi
  call   <scanf@plt>
  mov    0x14(%rsp),%eax
  cmp    %ebx,%eax
  je     L170
  jle    L47
  sub    %ebx,%eax
  mov    %eax,0xc(%rsp)
  test   %r13d,%r13d
  je     L55
  cmp    %r13d,%eax
  jge    L70
L55:
  lea    D59(%rip),%rdi
  call   <puts@plt>
  add    $0x1,%r12d
  mov    0xc(%rsp),%r13d
  jmp    L136
L170:
  mov    %r12d,%esi
  lea    D52(%rip),%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  test   %r15d,%r15d
  je     L138
  cmp    %r15d,%r12d
  jge    L123
  lea    D1(%rip),%rdi
  call   <puts@plt>
  mov    %r12d,%r15d
  jmp    L123
L138:
  mov    %r12d,%r15d
L123:
  mov    %r15d,%esi
  lea    D68(%rip),%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  lea    D50(%rip),%rdi
  call   <puts@plt>
  lea    0x10(%rsp),%rsi
  mov    %r14,%rdi
  call   <scanf@plt>
  mov    0x10(%rsp),%ebp
  cmp    $0x1,%ebp
  je     L136
  test   %ebp,%ebp
  jne    L206
L17:
  mov    0x18(%rsp),%rax
  sub    %fs:0x28,%rax
  jne    L19
  mov    $0x1,%eax
  add    $0x28,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
L206:
  lea    D30(%rip),%rdi
  call   <puts@plt>
  jmp    L17
L70:
  lea    0x0(%r13,%rbx,1),%esi
  lea    D8(%rip),%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  mov    %r13d,0xc(%rsp)
  jmp    L55
L47:
  jge    L136
  mov    %ebx,%ecx
  sub    %eax,%ecx
  mov    %ecx,0xc(%rsp)
  mov    0x8(%rsp),%esi
  test   %esi,%esi
  je     L32
  cmp    %esi,%ecx
  jge    L94
L32:
  lea    D58(%rip),%rdi
  call   <puts@plt>
  add    $0x1,%r12d
  mov    0xc(%rsp),%eax
  mov    %eax,0x8(%rsp)
  jmp    L136
L94:
  mov    %ebx,%esi
  sub    0x8(%rsp),%esi
  lea    D92(%rip),%rdi
  mov    $0x0,%eax
  call   <printf@plt>
  mov    0x8(%rsp),%eax
  mov    %eax,0xc(%rsp)
  jmp    L32
L19:
  call   <__stack_chk_fail@plt>
```

tool_calls: name: unpack_data
arguments: data_label: D34
type_guessed: string
name: unpack_data
arguments: data_label: D57
type_guessed: string
name: unpack_data
arguments: data_label: D59
type_guessed: string
name: unpack_data
arguments: data_label: D52
type_guessed: string
name: unpack_data
arguments: data_label: D1
type_guessed: string
name: unpack_data
arguments: data_label: D68
type_guessed: string
name: unpack_data
arguments: data_label: D50
type_guessed: string
name: unpack_data
arguments: data_label: D30
type_guessed: string
name: unpack_data
arguments: data_label: D8
type_guessed: string
name: unpack_data
arguments: data_label: D58
type_guessed: string
name: unpack_data
arguments: data_label: D92
type_guessed: string

tool: D34: %d

tool: D57: GUESS A VALUE BETWEEN 0 AND 255

tool: D59: TOO HIGH. GUESS AGAIN.

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


tool: D1: < < NEW HIGH SCORE > >

tool: D68: HIGH SCORE :: %d


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

tool: D30: INVALID RESPONSE.

tool: D8: ANSWER IS NOT HIGHER THAN %d


tool: D58: TOO LOW. GUESS AGAIN.

tool: D92: ANSWER IS NOT LOWER THAN %d


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