ylfeng/ReF-Decompile-dataset huggingface dataset:
user: Converte this assembly snippet into its equivalent C code:

```asm
<strlcpy>:
  endbr64
  push   %rbp
  mov    %rdi,%r8
  mov    %rsi,%rdi
  push   %rbx
  mov    %rdx,%rbx
  sub    $0x8,%rsp
  test   %rdx,%rdx
  je     L119
  mov    %r8,%rax
  sub    $0x1,%rbx
  mov    %r8,%rcx
  xor    %rsi,%rax
  test   $0x7,%al
  jne    L73
  test   $0x7,%sil
  je     L36
  test   %rbx,%rbx
  jne    L55
  jmp    L167
  nopl   (%rax)
L75:
  add    $0x1,%rdi
  sub    $0x1,%rbx
  add    $0x1,%rcx
  test   $0x7,%dil
  je     L36
  test   %rbx,%rbx
  je     L61
L55:
  movzbl (%rdi),%eax
  mov    %al,(%rcx)
  test   %al,%al
  jne    L75
L52:
  cmpb   $0x0,(%rdi)
  je     L39
  cmp    $0x7,%rbx
  jbe    L39
  mov    D0(%rip),%r11
  mov    $0xffffffffffffffff,%r10
  nopl   0x0(%rax)
L110:
  mov    (%r11),%rsi
  mov    %r10,%rax
  xor    %edx,%edx
  mov    (%rdi),%r9
  div    %rsi
  shr    %rsi
  mov    %r9,%rdx
  mov    %r9,%rbp
  add    $0x1,%rsi
  not    %rbp
  imul   %rax,%rsi
  sub    %rax,%rdx
  and    %rbp,%rdx
  test   %rsi,%rdx
  jne    L39
  sub    $0x8,%rbx
  mov    %r9,(%rcx)
  add    $0x8,%rdi
  add    $0x8,%rcx
  cmp    $0x7,%rbx
  ja     L110
  nopw   0x0(%rax,%rax,1)
L73:
  test   %rbx,%rbx
  je     L61
L39:
  add    %rdi,%rbx
  jmp    L112
  nopw   0x0(%rax,%rax,1)
L88:
  add    $0x1,%rdi
  add    $0x1,%rcx
  cmp    %rbx,%rdi
  je     L61
L112:
  movzbl (%rdi),%eax
  mov    %al,(%rcx)
  test   %al,%al
  jne    L88
L61:
  mov    %rcx,%rbx
  sub    %r8,%rbx
L167:
  movb   $0x0,(%rcx)
L119:
  call   <strlen@plt>
  add    $0x8,%rsp
  add    %rbx,%rax
  pop    %rbx
  pop    %rbp
  ret
  cs nopw 0x0(%rax,%rax,1)
L36:
  test   %rbx,%rbx
  jne    L52
  jmp    L61
```

assistant: ```c
size_t strlcpy(char *d, const char *s, size_t n) {
  char *d0 = d;
  size_t *wd;
  const size_t *ws;
  if (!n--)
    goto finish;
  if (((uintptr_t)s & (sizeof(size_t) - 1)) == ((uintptr_t)d & (sizeof(size_t) - 1))) {
    for (; ((uintptr_t)s & (sizeof(size_t) - 1)) && n && (*d = *s); n--, s++, d++)
      ;
    if (n && *s) {
      wd = (void *)d;
      ws = (const void *)s;
      for (; n >= sizeof(size_t) && !((*ws) - ((size_t)-1 / UCHAR_MAX) & ~(*ws) & (((size_t)-1 / UCHAR_MAX) * (UCHAR_MAX / 2 + 1))); n -= sizeof(size_t), ws++, wd++)
        *wd = *ws;
      d = (void *)wd;
      s = (const void *)ws;
    }
  }
  for (; n && (*d = *s); n--, s++, d++)
    ;
  *d = 0;
finish:
  return d - d0 + strlen(s);
}
```
user: Demonstrate the C code that generates the assembly output below:

```asm
<strlcpy>:
  endbr64
  push   %rbp
  mov    %rdi,%r8
  mov    %rsi,%rdi
  push   %rbx
  mov    %rdx,%rbx
  sub    $0x8,%rsp
  test   %rdx,%rdx
  je     L15
  mov    %r8,%rax
  sub    $0x1,%rbx
  mov    %r8,%rcx
  xor    %rsi,%rax
  test   $0x7,%al
  jne    L7
  test   $0x7,%sil
  je     L160
  test   %rbx,%rbx
  jne    L153
  jmp    L164
  nopl   (%rax)
L131:
  add    $0x1,%rdi
  sub    $0x1,%rbx
  add    $0x1,%rcx
  test   $0x7,%dil
  je     L160
  test   %rbx,%rbx
  je     L51
L153:
  movzbl (%rdi),%eax
  mov    %al,(%rcx)
  test   %al,%al
  jne    L131
L24:
  cmpb   $0x0,(%rdi)
  je     L88
  cmp    $0x7,%rbx
  jbe    L88
  mov    D1(%rip),%r11
  mov    $0xffffffffffffffff,%r10
  nopl   0x0(%rax)
L154:
  mov    (%r11),%rsi
  mov    %r10,%rax
  xor    %edx,%edx
  mov    (%rdi),%r9
  div    %rsi
  shr    %rsi
  mov    %r9,%rdx
  mov    %r9,%rbp
  add    $0x1,%rsi
  not    %rbp
  imul   %rax,%rsi
  sub    %rax,%rdx
  and    %rbp,%rdx
  test   %rsi,%rdx
  jne    L88
  sub    $0x8,%rbx
  mov    %r9,(%rcx)
  add    $0x8,%rdi
  add    $0x8,%rcx
  cmp    $0x7,%rbx
  ja     L154
  nopw   0x0(%rax,%rax,1)
L7:
  test   %rbx,%rbx
  je     L51
L88:
  add    %rdi,%rbx
  jmp    L117
  nopw   0x0(%rax,%rax,1)
L132:
  add    $0x1,%rdi
  add    $0x1,%rcx
  cmp    %rbx,%rdi
  je     L51
L117:
  movzbl (%rdi),%eax
  mov    %al,(%rcx)
  test   %al,%al
  jne    L132
L51:
  mov    %rcx,%rbx
  sub    %r8,%rbx
L164:
  movb   $0x0,(%rcx)
L15:
  call   <strlen@plt>
  add    $0x8,%rsp
  add    %rbx,%rax
  pop    %rbx
  pop    %rbp
  ret
  cs nopw 0x0(%rax,%rax,1)
L160:
  test   %rbx,%rbx
  jne    L24
  jmp    L51
```

assistant: ```c
size_t strlcpy(char *d, const char *s, size_t n) {
  char *d0 = d;
  size_t *wd;
  const size_t *ws;
  if (!n--)
    goto finish;
  if (((uintptr_t)s & (sizeof(size_t) - 1)) == ((uintptr_t)d & (sizeof(size_t) - 1))) {
    for (; ((uintptr_t)s & (sizeof(size_t) - 1)) && n && (*d = *s); n--, s++, d++)
      ;
    if (n && *s) {
      wd = (void *)d;
      ws = (const void *)s;
      for (; n >= sizeof(size_t) && !((*ws) - ((size_t)-1 / UCHAR_MAX) & ~(*ws) & (((size_t)-1 / UCHAR_MAX) * (UCHAR_MAX / 2 + 1))); n -= sizeof(size_t), ws++, wd++)
        *wd = *ws;
      d = (void *)wd;
      s = (const void *)ws;
    }
  }
  for (; n && (*d = *s); n--, s++, d++)
    ;
  *d = 0;
finish:
  return d - d0 + strlen(s);
}
```
user: Translate the below assembly code into C programming language:

```asm
<__ether_line_w>:
  endbr64
  push   %rbp
  mov    %rsp,%rbp
  sub    $0x20,%rsp
  mov    %rdi,-0x18(%rbp)
  mov    %rsi,-0x20(%rbp)
  mov    -0x18(%rbp),%rax
  lea    D8(%rip),%rdx
  mov    %rdx,%rsi
  mov    %rax,%rdi
  call   <strpbrk@plt>
  mov    %rax,-0x8(%rbp)
  cmpq   $0x0,-0x8(%rbp)
  je     L6
  mov    -0x8(%rbp),%rax
  movb   $0x0,(%rax)
L6:
  mov    -0x20(%rbp),%rdx
  mov    -0x18(%rbp),%rax
  mov    %rdx,%rsi
  mov    %rax,%rdi
  call   <__ether_line@plt>
  leave
  ret
```

tool_calls: name: disassemble_data
arguments: data_label: D8
datatype: string

tool: D8: #


assistant: ```c
const char *__ether_line_w(char *line, struct ether_addr *addr) {
  char *end = strpbrk(line, "#\n");
  if (end)
    *end = '\0';
  return __ether_line(line, addr);
}
```
user: 请将这段汇编代码片段转换成等效的C代码:

```asm
<__ether_line_w>:
  endbr64
  push   %rbp
  push   %rbx
  sub    $0x8,%rsp
  mov    %rdi,%rbx
  mov    %rsi,%rbp
  lea    D3(%rip),%rsi
  call   <strpbrk@plt>
  test   %rax,%rax
  je     L7
  movb   $0x0,(%rax)
L7:
  mov    %rbp,%rsi
  mov    %rbx,%rdi
  call   <__ether_line@plt>
  add    $0x8,%rsp
  pop    %rbx
  pop    %rbp
  ret
```

tool_calls: name: parse_data
arguments: label: D3
type: string

tool: D3: #


assistant: ```c
const char *__ether_line_w(char *line, struct ether_addr *addr) {
  char *end = strpbrk(line, "#\n");
  if (end)
    *end = '\0';
  return __ether_line(line, addr);
}
```
user: 请将这段汇编代码片段转换成等效的C代码：

```asm
<__ether_line_w>:
  endbr64
  push   %r12
  mov    %rsi,%r12
  lea    D6(%rip),%rsi
  push   %rbp
  mov    %rdi,%rbp
  sub    $0x8,%rsp
  call   <strpbrk@plt>
  test   %rax,%rax
  je     L2
  movb   $0x0,(%rax)
L2:
  add    $0x8,%rsp
  mov    %r12,%rsi
  mov    %rbp,%rdi
  pop    %rbp
  pop    %r12
  jmp    1060 <__ether_line@plt>
```

tool_calls: name: disassemble_data
arguments: label: D6
datatype: string

tool: D6: #


assistant: ```c
const char *__ether_line_w(char *line, struct ether_addr *addr) {
  char *end = strpbrk(line, "#\n");
  if (end)
    *end = '\0';
  return __ether_line(line, addr);
}
```
user: 请将以下的汇编代码转换成C语言代码:

```asm
<__ether_line_w>:
  endbr64
  push   %r12
  mov    %rsi,%r12
  lea    D4(%rip),%rsi
  push   %rbp
  mov    %rdi,%rbp
  sub    $0x8,%rsp
  call   <strpbrk@plt>
  test   %rax,%rax
  je     L1
  movb   $0x0,(%rax)
L1:
  add    $0x8,%rsp
  mov    %r12,%rsi
  mov    %rbp,%rdi
  pop    %rbp
  pop    %r12
  jmp    1060 <__ether_line@plt>
```

tool_calls: name: unpack_data
arguments: tag: D4
type_guessed: string

tool: D4: #


assistant: ```c
const char *__ether_line_w(char *line, struct ether_addr *addr) {
  char *end = strpbrk(line, "#\n");
  if (end)
    *end = '\0';
  return __ether_line(line, addr);
}
```
user: 提供的汇编代码用C语言表示会是什么样子：

```asm
<main>:
  endbr64
  push   %rbp
  mov    %rsp,%rbp
  sub    $0x20,%rsp
  mov    %fs:0x28,%rax
  mov    %rax,-0x8(%rbp)
  xor    %eax,%eax
  movl   $0xbb8,-0x1c(%rbp)
  lea    -0x1c(%rbp),%rax
  mov    %rax,-0x18(%rbp)
  lea    -0x18(%rbp),%rax
  mov    %rax,-0x10(%rbp)
  mov    -0x1c(%rbp),%eax
  mov    %eax,%esi
  lea    D8(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  mov    -0x18(%rbp),%rax
  mov    (%rax),%eax
  mov    %eax,%esi
  lea    D23(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  mov    -0x10(%rbp),%rax
  mov    (%rax),%rax
  mov    (%rax),%eax
  mov    %eax,%esi
  lea    D25(%rip),%rax
  mov    %rax,%rdi
  call   <printf@plt>
  mov    $0x0,%eax
  mov    -0x8(%rbp),%rdx
  sub    %fs:0x28,%rdx
  je     L5
  call   <__stack_chk_fail@plt>
L5:
  leave
  ret
```

tool_calls: name: read_data
arguments: data_tag: D8
data_type: string
name: read_data
arguments: data_tag: D23
data_type: string
name: read_data
arguments: data_tag: D25
data_type: string

tool: D8: value of  var = %d


tool: D23: value of at *ptr = %d


tool: D25: value of  at **pptr= %d


assistant: ```c
int main() {
  int var;
  int *ptr;
  int **pptr;
  var = 3000;
  ptr = &var;
  pptr = &ptr;
  printf("value of  var = %d\n", var);
  printf("value of at *ptr = %d\n", *ptr);
  printf("value of  at **pptr= %d\n", **pptr);
}
```
user: What is the c source code of the assembly code below:

```asm
<main>:
  endbr64
  sub    $0x8,%rsp
  mov    $0xbb8,%esi
  lea    D15(%rip),%rdi
  call   <printf@plt>
  mov    $0xbb8,%esi
  lea    D13(%rip),%rdi
  call   <printf@plt>
  mov    $0xbb8,%esi
  lea    D24(%rip),%rdi
  call   <printf@plt>
  mov    $0x0,%eax
  add    $0x8,%rsp
  ret
```

tool_calls: name: parse_data
arguments: data_tag: D15
type: string
name: parse_data
arguments: data_tag: D13
type: string
name: parse_data
arguments: data_tag: D24
type: string

tool: D15: value of  var = %d


tool: D13: value of at *ptr = %d


tool: D24: value of  at **pptr= %d


assistant: ```c
int main() {
  int var;
  int *ptr;
  int **pptr;
  var = 3000;
  ptr = &var;
  pptr = &ptr;
  printf("value of  var = %d\n", var);
  printf("value of at *ptr = %d\n", *ptr);
  printf("value of  at **pptr= %d\n", **pptr);
}
```
user: 请将这段汇编代码片段转换成等效的C代码:

```asm
<main>:
  endbr64
  sub    $0x8,%rsp
  mov    $0xbb8,%esi
  lea    D20(%rip),%rdi
  call   <printf@plt>
  mov    $0xbb8,%esi
  lea    D21(%rip),%rdi
  call   <printf@plt>
  mov    $0xbb8,%esi
  lea    D3(%rip),%rdi
  call   <printf@plt>
  xor    %eax,%eax
  add    $0x8,%rsp
  ret
```

tool_calls: name: extract_symbolic_data
arguments: data_tag: D20
type_guessed: string
name: extract_symbolic_data
arguments: data_tag: D21
type_guessed: string
name: extract_symbolic_data
arguments: data_tag: D3
type_guessed: string

tool: D20: value of  var = %d


tool: D21: value of at *ptr = %d


tool: D3: value of  at **pptr= %d


assistant: ```c
int main() {
  int var;
  int *ptr;
  int **pptr;
  var = 3000;
  ptr = &var;
  pptr = &ptr;
  printf("value of  var = %d\n", var);
  printf("value of at *ptr = %d\n", *ptr);
  printf("value of  at **pptr= %d\n", **pptr);
}
```
user: Converte this assembly snippet into its equivalent C code:

```asm
<main>:
  endbr64
  sub    $0x8,%rsp
  mov    $0xbb8,%esi
  lea    D6(%rip),%rdi
  call   <printf@plt>
  mov    $0xbb8,%esi
  lea    D9(%rip),%rdi
  call   <printf@plt>
  mov    $0xbb8,%esi
  lea    D7(%rip),%rdi
  call   <printf@plt>
  xor    %eax,%eax
  add    $0x8,%rsp
  ret
```

tool_calls: name: read_data
arguments: tag: D6
datatype: string
name: read_data
arguments: tag: D9
datatype: string
name: read_data
arguments: tag: D7
datatype: string

tool: D6: value of  var = %d


tool: D9: value of at *ptr = %d


tool: D7: value of  at **pptr= %d


assistant: ```c
int main() {
  int var;
  int *ptr;
  int **pptr;
  var = 3000;
  ptr = &var;
  pptr = &ptr;
  printf("value of  var = %d\n", var);
  printf("value of at *ptr = %d\n", *ptr);
  printf("value of  at **pptr= %d\n", **pptr);
}
```
user: 下面的汇编指令对应的C源代码是什么:

```asm
<defineColors>:
  endbr64
  push   %rbp
  mov    %rsp,%rbp
  mov    D29(%rip),%rax
  mov    (%rax),%eax
  mov    %eax,%edx
  mov    $0x7,%esi
  mov    $0x0,%edi
  call   <init_pair@plt>
  mov    D2(%rip),%rax
  mov    (%rax),%eax
  mov    %eax,%edx
  mov    $0x0,%esi
  mov    $0x1,%edi
  call   <init_pair@plt>
  mov    D55(%rip),%rax
  mov    (%rax),%eax
  mov    %eax,%edx
  mov    $0x0,%esi
  mov    $0x2,%edi
  call   <init_pair@plt>
  mov    D31(%rip),%rax
  mov    (%rax),%eax
  mov    %eax,%edx
  mov    $0x0,%esi
  mov    $0x3,%edi
  call   <init_pair@plt>
  mov    D24(%rip),%rax
  mov    (%rax),%eax
  mov    %eax,%edx
  mov    $0x0,%esi
  mov    $0x4,%edi
  call   <init_pair@plt>
  mov    D76(%rip),%rax
  mov    (%rax),%eax
  mov    %eax,%edx
  mov    $0x0,%esi
  mov    $0x5,%edi
  call   <init_pair@plt>
  mov    D6(%rip),%rax
  mov    (%rax),%eax
  mov    %eax,%edx
  mov    $0x0,%esi
  mov    $0x6,%edi
  call   <init_pair@plt>
  mov    D23(%rip),%rax
  mov    (%rax),%eax
  mov    %eax,%edx
  mov    $0x0,%esi
  mov    $0x7,%edi
  call   <init_pair@plt>
  nop
  pop    %rbp
  ret
```

assistant: ```c
void defineColors() {
  init_pair(0, 7, COLOR_BLACK);
  init_pair(1, 0, COLOR_RED);
  init_pair(2, 0, COLOR_GREEN);
  init_pair(3, 0, COLOR_YELLOW);
  init_pair(4, 0, COLOR_BLUE);
  init_pair(5, 0, COLOR_MAGENTA);
  init_pair(6, 0, COLOR_CYAN);
  init_pair(7, 0, COLOR_WHITE);
}
```
user: What would the C source look like for the assembly code provided here:

```asm
<defineColors>:
  endbr64
  sub    $0x8,%rsp
  mov    D50(%rip),%rax
  mov    (%rax),%edx
  mov    $0x7,%esi
  mov    $0x0,%edi
  call   <init_pair@plt>
  mov    D70(%rip),%rax
  mov    (%rax),%edx
  mov    $0x0,%esi
  mov    $0x1,%edi
  call   <init_pair@plt>
  mov    D27(%rip),%rax
  mov    (%rax),%edx
  mov    $0x0,%esi
  mov    $0x2,%edi
  call   <init_pair@plt>
  mov    D43(%rip),%rax
  mov    (%rax),%edx
  mov    $0x0,%esi
  mov    $0x3,%edi
  call   <init_pair@plt>
  mov    D16(%rip),%rax
  mov    (%rax),%edx
  mov    $0x0,%esi
  mov    $0x4,%edi
  call   <init_pair@plt>
  mov    D14(%rip),%rax
  mov    (%rax),%edx
  mov    $0x0,%esi
  mov    $0x5,%edi
  call   <init_pair@plt>
  mov    D76(%rip),%rax
  mov    (%rax),%edx
  mov    $0x0,%esi
  mov    $0x6,%edi
  call   <init_pair@plt>
  mov    D12(%rip),%rax
  mov    (%rax),%edx
  mov    $0x0,%esi
  mov    $0x7,%edi
  call   <init_pair@plt>
  add    $0x8,%rsp
  ret
```

assistant: ```c
void defineColors() {
  init_pair(0, 7, COLOR_BLACK);
  init_pair(1, 0, COLOR_RED);
  init_pair(2, 0, COLOR_GREEN);
  init_pair(3, 0, COLOR_YELLOW);
  init_pair(4, 0, COLOR_BLUE);
  init_pair(5, 0, COLOR_MAGENTA);
  init_pair(6, 0, COLOR_CYAN);
  init_pair(7, 0, COLOR_WHITE);
}
```
user: 下面的汇编指令对应的C源代码是什么：

```asm
<defineColors>:
  endbr64
  sub    $0x8,%rsp
  mov    D25(%rip),%rax
  mov    $0x7,%esi
  xor    %edi,%edi
  mov    (%rax),%edx
  call   <init_pair@plt>
  mov    D58(%rip),%rax
  xor    %esi,%esi
  mov    $0x1,%edi
  mov    (%rax),%edx
  call   <init_pair@plt>
  mov    D22(%rip),%rax
  xor    %esi,%esi
  mov    $0x2,%edi
  mov    (%rax),%edx
  call   <init_pair@plt>
  mov    D0(%rip),%rax
  xor    %esi,%esi
  mov    $0x3,%edi
  mov    (%rax),%edx
  call   <init_pair@plt>
  mov    D48(%rip),%rax
  xor    %esi,%esi
  mov    $0x4,%edi
  mov    (%rax),%edx
  call   <init_pair@plt>
  mov    D17(%rip),%rax
  xor    %esi,%esi
  mov    $0x5,%edi
  mov    (%rax),%edx
  call   <init_pair@plt>
  mov    D10(%rip),%rax
  xor    %esi,%esi
  mov    $0x6,%edi
  mov    (%rax),%edx
  call   <init_pair@plt>
  mov    D1(%rip),%rax
  xor    %esi,%esi
  mov    $0x7,%edi
  mov    (%rax),%edx
  add    $0x8,%rsp
  jmp    1050 <init_pair@plt>
```

assistant: ```c
void defineColors() {
  init_pair(0, 7, COLOR_BLACK);
  init_pair(1, 0, COLOR_RED);
  init_pair(2, 0, COLOR_GREEN);
  init_pair(3, 0, COLOR_YELLOW);
  init_pair(4, 0, COLOR_BLUE);
  init_pair(5, 0, COLOR_MAGENTA);
  init_pair(6, 0, COLOR_CYAN);
  init_pair(7, 0, COLOR_WHITE);
}
```
user: 请将这段汇编代码片段转换成等效的C代码:

```asm
<defineColors>:
  endbr64
  sub    $0x8,%rsp
  mov    D63(%rip),%rax
  mov    $0x7,%esi
  xor    %edi,%edi
  mov    (%rax),%edx
  call   <init_pair@plt>
  mov    D54(%rip),%rax
  xor    %esi,%esi
  mov    $0x1,%edi
  mov    (%rax),%edx
  call   <init_pair@plt>
  mov    D79(%rip),%rax
  xor    %esi,%esi
  mov    $0x2,%edi
  mov    (%rax),%edx
  call   <init_pair@plt>
  mov    D18(%rip),%rax
  xor    %esi,%esi
  mov    $0x3,%edi
  mov    (%rax),%edx
  call   <init_pair@plt>
  mov    D61(%rip),%rax
  xor    %esi,%esi
  mov    $0x4,%edi
  mov    (%rax),%edx
  call   <init_pair@plt>
  mov    D36(%rip),%rax
  xor    %esi,%esi
  mov    $0x5,%edi
  mov    (%rax),%edx
  call   <init_pair@plt>
  mov    D29(%rip),%rax
  xor    %esi,%esi
  mov    $0x6,%edi
  mov    (%rax),%edx
  call   <init_pair@plt>
  mov    D59(%rip),%rax
  xor    %esi,%esi
  mov    $0x7,%edi
  mov    (%rax),%edx
  add    $0x8,%rsp
  jmp    1050 <init_pair@plt>
```

assistant: ```c
void defineColors() {
  init_pair(0, 7, COLOR_BLACK);
  init_pair(1, 0, COLOR_RED);
  init_pair(2, 0, COLOR_GREEN);
  init_pair(3, 0, COLOR_YELLOW);
  init_pair(4, 0, COLOR_BLUE);
  init_pair(5, 0, COLOR_MAGENTA);
  init_pair(6, 0, COLOR_CYAN);
  init_pair(7, 0, COLOR_WHITE);
}
```
user: 请将以下的汇编代码转换成C语言代码：

```asm
<calcQuarterbackRating>:
  endbr64
  sub    $0x28,%rsp
  movss  %xmm2,0x14(%rsp)
  movss  %xmm3,0x18(%rsp)
  movss  %xmm4,0x1c(%rsp)
  movss  %xmm1,0xc(%rsp)
  divss  %xmm1,%xmm0
  mulss  D51(%rip),%xmm0
  subss  D117(%rip),%xmm0
  divss  D1(%rip),%xmm0
  pxor   %xmm1,%xmm1
  call   <max@plt>
  mov    %eax,%edi
  movss  D12(%rip),%xmm0
  call   <min@plt>
  movss  %xmm0,0x10(%rsp)
  movss  0x14(%rsp),%xmm6
  divss  0xc(%rsp),%xmm6
  movaps %xmm6,%xmm0
  mulss  D51(%rip),%xmm0
  divss  D28(%rip),%xmm0
  pxor   %xmm1,%xmm1
  call   <max@plt>
  mov    %eax,%edi
  movss  D12(%rip),%xmm0
  call   <min@plt>
  movss  %xmm0,0x14(%rsp)
  movss  0x18(%rsp),%xmm7
  divss  0xc(%rsp),%xmm7
  movaps %xmm7,%xmm1
  mulss  D51(%rip),%xmm1
  movss  D59(%rip),%xmm0
  subss  %xmm1,%xmm0
  mulss  D133(%rip),%xmm0
  pxor   %xmm1,%xmm1
  call   <max@plt>
  mov    %eax,%edi
  movss  D12(%rip),%xmm0
  call   <min@plt>
  movaps %xmm0,%xmm1
  movss  0x10(%rsp),%xmm2
  addss  0x14(%rsp),%xmm2
  movaps %xmm2,%xmm0
  addss  %xmm1,%xmm0
  movss  %xmm0,0x10(%rsp)
  movss  0x1c(%rsp),%xmm4
  divss  0xc(%rsp),%xmm4
  movaps %xmm4,%xmm0
  subss  D142(%rip),%xmm0
  mulss  D133(%rip),%xmm0
  pxor   %xmm1,%xmm1
  call   <max@plt>
  mov    %eax,%edi
  movss  D12(%rip),%xmm0
  call   <min@plt>
  addss  0x10(%rsp),%xmm0
  divss  D41(%rip),%xmm0
  add    $0x28,%rsp
  ret
```

tool_calls: name: extract_symbolic_data
arguments: tag: D51
type_infered: byte[4]
name: extract_symbolic_data
arguments: tag: D117
type_infered: byte[4]
name: extract_symbolic_data
arguments: tag: D1
type_infered: byte[4]
name: extract_symbolic_data
arguments: tag: D12
type_infered: byte[4]
name: extract_symbolic_data
arguments: tag: D28
type_infered: byte[4]
name: extract_symbolic_data
arguments: tag: D59
type_infered: byte[4]
name: extract_symbolic_data
arguments: tag: D133
type_infered: byte[4]
name: extract_symbolic_data
arguments: tag: D142
type_infered: byte[4]
name: extract_symbolic_data
arguments: tag: D41
type_infered: byte[4]

tool: {"D51": [0x00,0x00,0xc8,0x42]}

tool: {"D117": [0x00,0x00,0xf0,0x41]}

tool: {"D1": [0x00,0x00,0xa0,0x41]}

tool: {"D12": [0x00,0x00,0x18,0x40]}

tool: {"D28": [0x00,0x00,0xa0,0x40]}

tool: {"D59": [0x00,0x00,0x18,0x41]}

tool: {"D133": [0x00,0x00,0x80,0x3e]}

tool: {"D142": [0x00,0x00,0x40,0x40]}

tool: {"D41": [0x8f,0xc2,0x75,0x3d]}

assistant: ```c
float calcQuarterbackRating(float Comp, float Att, float TDs, float Int, float Yards) {
  float a, b, c, d;
  a = (((Comp / Att) * 100.0F) - 30.0F) / 20.0F;
  b = ((TDs / Att) * 100.0F) / 5.0F;
  c = (9.5F - ((Int / Att) * 100.0F)) / 4.0F;
  d = ((Yards / Att) - 3.0F) / 4.0F;
  a = min(max(a, 0.0F), 2.375F);
  b = min(max(b, 0.0F), 2.375F);
  c = min(max(c, 0.0F), 2.375F);
  return (a + b + c + min(max(d, 0.0F), 2.375F)) / .06F;
}
```
user: What would the C source look like for the assembly code provided here?

```asm
<calcQuarterbackRating>:
  endbr64
  divss  %xmm1,%xmm0
  sub    $0x28,%rsp
  movss  %xmm1,0xc(%rsp)
  pxor   %xmm1,%xmm1
  movss  %xmm4,0x18(%rsp)
  movss  %xmm3,0x1c(%rsp)
  movss  %xmm2,0x14(%rsp)
  mulss  D49(%rip),%xmm0
  subss  D115(%rip),%xmm0
  divss  D52(%rip),%xmm0
  call   <max@plt>
  movss  D113(%rip),%xmm0
  mov    %eax,%edi
  call   <min@plt>
  movss  0x14(%rsp),%xmm2
  pxor   %xmm1,%xmm1
  divss  0xc(%rsp),%xmm2
  movss  %xmm0,0x10(%rsp)
  movss  D49(%rip),%xmm0
  mulss  %xmm2,%xmm0
  divss  D146(%rip),%xmm0
  call   <max@plt>
  movss  D113(%rip),%xmm0
  mov    %eax,%edi
  call   <min@plt>
  movss  0x1c(%rsp),%xmm3
  pxor   %xmm1,%xmm1
  divss  0xc(%rsp),%xmm3
  mulss  D49(%rip),%xmm3
  movss  %xmm0,0x14(%rsp)
  movss  D80(%rip),%xmm0
  subss  %xmm3,%xmm0
  mulss  D22(%rip),%xmm0
  call   <max@plt>
  movss  D113(%rip),%xmm0
  mov    %eax,%edi
  call   <min@plt>
  movss  0x10(%rsp),%xmm5
  addss  0x14(%rsp),%xmm5
  movaps %xmm0,%xmm1
  movss  0x18(%rsp),%xmm4
  divss  0xc(%rsp),%xmm4
  movaps %xmm5,%xmm0
  addss  %xmm1,%xmm0
  pxor   %xmm1,%xmm1
  movss  %xmm0,0x10(%rsp)
  movaps %xmm4,%xmm0
  subss  D12(%rip),%xmm0
  mulss  D22(%rip),%xmm0
  call   <max@plt>
  movss  D113(%rip),%xmm0
  mov    %eax,%edi
  call   <min@plt>
  addss  0x10(%rsp),%xmm0
  divss  D14(%rip),%xmm0
  add    $0x28,%rsp
  ret
```

tool_calls: name: read_data
arguments: tag: D49
type: byte[4]
name: read_data
arguments: tag: D115
type: byte[4]
name: read_data
arguments: tag: D52
type: byte[4]
name: read_data
arguments: tag: D113
type: byte[4]
name: read_data
arguments: tag: D146
type: byte[4]
name: read_data
arguments: tag: D80
type: byte[4]
name: read_data
arguments: tag: D22
type: byte[4]
name: read_data
arguments: tag: D12
type: byte[4]
name: read_data
arguments: tag: D14
type: byte[4]

tool: {"D49": [0x00,0x00,0xc8,0x42]}

tool: {"D115": [0x00,0x00,0xf0,0x41]}

tool: {"D52": [0x00,0x00,0xa0,0x41]}

tool: {"D113": [0x00,0x00,0x18,0x40]}

tool: {"D146": [0x00,0x00,0xa0,0x40]}

tool: {"D80": [0x00,0x00,0x18,0x41]}

tool: {"D22": [0x00,0x00,0x80,0x3e]}

tool: {"D12": [0x00,0x00,0x40,0x40]}

tool: {"D14": [0x8f,0xc2,0x75,0x3d]}

assistant: ```c
float calcQuarterbackRating(float Comp, float Att, float TDs, float Int, float Yards) {
  float a, b, c, d;
  a = (((Comp / Att) * 100.0F) - 30.0F) / 20.0F;
  b = ((TDs / Att) * 100.0F) / 5.0F;
  c = (9.5F - ((Int / Att) * 100.0F)) / 4.0F;
  d = ((Yards / Att) - 3.0F) / 4.0F;
  a = min(max(a, 0.0F), 2.375F);
  b = min(max(b, 0.0F), 2.375F);
  c = min(max(c, 0.0F), 2.375F);
  return (a + b + c + min(max(d, 0.0F), 2.375F)) / .06F;
}
```