ylfeng/ReF-Decompile-dataset huggingface dataset:
user: Demonstrate the C code that generates the assembly output below:

```asm
<matchcharclass>:
  endbr64
  push   %r14
  push   %r13
  mov    %edi,%r13d
  push   %r12
  mov    %edi,%r12d
  push   %rbp
  movsbl %dil,%ebp
  push   %rbx
  mov    %rsi,%rbx
  jmp    L103
  nopl   0x0(%rax,%rax,1)
L74:
  cmp    %r13b,%al
  je     L88
L11:
  add    $0x1,%rbx
  test   %al,%al
  je     L7
L103:
  mov    %rbx,%rsi
  mov    %ebp,%edi
  call   <matchrange@plt>
  test   %rax,%rax
  jne    L86
  movzbl (%rbx),%eax
  cmp    $0x5c,%al
  jne    L74
  lea    0x1(%rbx),%r14
  mov    %ebp,%edi
  mov    %r14,%rsi
  call   <matchmetachar@plt>
  test   %rax,%rax
  jne    L86
  movzbl 0x1(%rbx),%eax
  cmp    %r13b,%al
  je     L57
  mov    %r14,%rbx
  add    $0x1,%rbx
  test   %al,%al
  jne    L103
L7:
  pop    %rbx
  xor    %eax,%eax
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  ret
  nopl   (%rax)
L88:
  cmp    $0x2d,%r12b
  je     L30
L86:
  mov    $0x1,%eax
L15:
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  ret
  nopl   0x0(%rax)
L57:
  mov    %ebp,%edi
  call   <ismetachar@plt>
  test   %eax,%eax
  je     L86
  movzbl 0x1(%rbx),%eax
  mov    %r14,%rbx
  jmp    L11
L30:
  cmpb   $0x0,-0x1(%rbx)
  je     L86
  xor    %eax,%eax
  cmpb   $0x0,0x1(%rbx)
  sete   %al
  jmp    L15
```

assistant: ```c
int matchcharclass(char c, const char *str) {
  do {
    if (matchrange(c, str)) {
      return 1;
    } else if (str[0] == '\\') {
      str += 1;
      if (matchmetachar(c, str)) {
        return 1;
      } else if ((c == str[0]) && !ismetachar(c)) {
        return 1;
      }
    } else if (c == str[0]) {
      if (c == '-') {
        return ((str[-1] == '\0') || (str[1] == '\0'));
      } else {
        return 1;
      }
    }
  } while (*str++ != '\0');
  return 0;
}
```
user: 请将这段汇编代码片段转换成等效的C代码：

```asm
<matchcharclass>:
  endbr64
  push   %r14
  push   %r13
  mov    %edi,%r13d
  push   %r12
  mov    %edi,%r12d
  push   %rbp
  movsbl %dil,%ebp
  push   %rbx
  mov    %rsi,%rbx
  jmp    L114
  nopl   0x0(%rax,%rax,1)
L59:
  cmp    %r13b,%al
  je     L25
L6:
  add    $0x1,%rbx
  test   %al,%al
  je     L16
L114:
  mov    %rbx,%rsi
  mov    %ebp,%edi
  call   <matchrange@plt>
  test   %rax,%rax
  jne    L33
  movzbl (%rbx),%eax
  cmp    $0x5c,%al
  jne    L59
  lea    0x1(%rbx),%r14
  mov    %ebp,%edi
  mov    %r14,%rsi
  call   <matchmetachar@plt>
  test   %rax,%rax
  jne    L33
  movzbl 0x1(%rbx),%eax
  cmp    %r13b,%al
  je     L115
  mov    %r14,%rbx
  add    $0x1,%rbx
  test   %al,%al
  jne    L114
L16:
  pop    %rbx
  xor    %eax,%eax
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  ret
  nopl   (%rax)
L25:
  cmp    $0x2d,%r12b
  je     L103
L33:
  mov    $0x1,%eax
L23:
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  ret
  nopl   0x0(%rax)
L115:
  mov    %ebp,%edi
  call   <ismetachar@plt>
  test   %eax,%eax
  je     L33
  movzbl 0x1(%rbx),%eax
  mov    %r14,%rbx
  jmp    L6
L103:
  cmpb   $0x0,-0x1(%rbx)
  je     L33
  xor    %eax,%eax
  cmpb   $0x0,0x1(%rbx)
  sete   %al
  jmp    L23
```

assistant: ```c
int matchcharclass(char c, const char *str) {
  do {
    if (matchrange(c, str)) {
      return 1;
    } else if (str[0] == '\\') {
      str += 1;
      if (matchmetachar(c, str)) {
        return 1;
      } else if ((c == str[0]) && !ismetachar(c)) {
        return 1;
      }
    } else if (c == str[0]) {
      if (c == '-') {
        return ((str[-1] == '\0') || (str[1] == '\0'));
      } else {
        return 1;
      }
    }
  } while (*str++ != '\0');
  return 0;
}
```
user: Demonstrate the C code that generates the assembly output below:

```asm
<test>:
  endbr64
  push   %rbp
  mov    %rsp,%rbp
  sub    $0x20,%rsp
  mov    %edi,-0x14(%rbp)
  movl   $0x0,-0x8(%rbp)
  jmp    L3
L18:
  movl   $0x0,-0x4(%rbp)
  jmp    L16
L25:
  mov    $0x1,%edi
  call   <hash@plt>
  mov    -0x8(%rbp),%eax
  mov    %eax,%edi
  call   <hash@plt>
  mov    -0x4(%rbp),%eax
  mov    %eax,%edi
  call   <hash@plt>
  addl   $0x1,-0x4(%rbp)
L16:
  mov    -0x14(%rbp),%eax
  cmp    -0x4(%rbp),%eax
  jg     L25
  addl   $0x1,-0x8(%rbp)
L3:
  mov    -0x14(%rbp),%eax
  cmp    -0x8(%rbp),%eax
  jg     L18
  nop
  nop
  leave
  ret
```

assistant: ```c
void test(int M) {
  int c2, c4;
  int i, j;
  for (c2 = 0; c2 <= M - 1; c2++) {
    for (c4 = 0; c4 <= M - 1; c4++) {
      {
        hash(1);
        hash(c2);
        hash(c4);
      };
    }
  }
}
```
user: What would the C source look like for the assembly code provided here:

```asm
<test>:
  endbr64
  push   %r12
  push   %rbp
  push   %rbx
  mov    %edi,%r12d
  mov    $0x0,%ebp
  test   %edi,%edi
  jle    L8
L20:
  mov    $0x0,%ebx
L9:
  mov    $0x1,%edi
  call   <hash@plt>
  mov    %ebp,%edi
  call   <hash@plt>
  mov    %ebx,%edi
  call   <hash@plt>
  mov    %ebx,%eax
  add    $0x1,%ebx
  cmp    %ebx,%r12d
  jne    L9
  lea    0x1(%rbp),%edx
  cmp    %eax,%ebp
  je     L8
  mov    %edx,%ebp
  jmp    L20
L8:
  pop    %rbx
  pop    %rbp
  pop    %r12
  ret
```

assistant: ```c
void test(int M) {
  int c2, c4;
  int i, j;
  for (c2 = 0; c2 <= M - 1; c2++) {
    for (c4 = 0; c4 <= M - 1; c4++) {
      {
        hash(1);
        hash(c2);
        hash(c4);
      };
    }
  }
}
```
user: Please show me the C implementation that matches the assembly code listed below:

```asm
<test>:
  endbr64
  test   %edi,%edi
  jle    L38
  push   %r12
  mov    %edi,%r12d
  push   %rbp
  xor    %ebp,%ebp
  push   %rbx
  nopl   0x0(%rax)
L17:
  xor    %ebx,%ebx
  nopw   0x0(%rax,%rax,1)
L34:
  mov    $0x1,%edi
  call   <hash@plt>
  mov    %ebp,%edi
  call   <hash@plt>
  mov    %ebx,%edi
  call   <hash@plt>
  mov    %ebx,%eax
  add    $0x1,%ebx
  cmp    %ebx,%r12d
  jne    L34
  lea    0x1(%rbp),%edx
  cmp    %eax,%ebp
  je     L6
  mov    %edx,%ebp
  jmp    L17
  nopl   (%rax)
L6:
  pop    %rbx
  pop    %rbp
  pop    %r12
  ret
L38:
  ret
```

assistant: ```c
void test(int M) {
  int c2, c4;
  int i, j;
  for (c2 = 0; c2 <= M - 1; c2++) {
    for (c4 = 0; c4 <= M - 1; c4++) {
      {
        hash(1);
        hash(c2);
        hash(c4);
      };
    }
  }
}
```
user: 请将这段汇编代码片段转换成等效的C代码：

```asm
<test>:
  endbr64
  test   %edi,%edi
  jle    L37
  push   %r12
  mov    %edi,%r12d
  push   %rbp
  xor    %ebp,%ebp
  push   %rbx
  nopl   0x0(%rax)
L32:
  xor    %ebx,%ebx
  nopw   0x0(%rax,%rax,1)
L31:
  mov    $0x1,%edi
  call   <hash@plt>
  mov    %ebp,%edi
  call   <hash@plt>
  mov    %ebx,%edi
  call   <hash@plt>
  mov    %ebx,%eax
  add    $0x1,%ebx
  cmp    %ebx,%r12d
  jne    L31
  lea    0x1(%rbp),%edx
  cmp    %eax,%ebp
  je     L2
  mov    %edx,%ebp
  jmp    L32
  nopl   (%rax)
L2:
  pop    %rbx
  pop    %rbp
  pop    %r12
  ret
L37:
  ret
```

assistant: ```c
void test(int M) {
  int c2, c4;
  int i, j;
  for (c2 = 0; c2 <= M - 1; c2++) {
    for (c4 = 0; c4 <= M - 1; c4++) {
      {
        hash(1);
        hash(c2);
        hash(c4);
      };
    }
  }
}
```
user: 请从给定的汇编指令推导出C源代码:

```asm
<ldvals>:
  endbr64
  push   %r15
  push   %r14
  push   %r13
  push   %r12
  push   %rbp
  push   %rbx
  sub    $0x238,%rsp
  mov    %rdi,%rbp
  mov    %rsi,0x8(%rsp)
  mov    %edx,%ebx
  mov    %rcx,%r12
  mov    %r8d,%r15d
  mov    %r9d,0x4(%rsp)
  mov    %fs:0x28,%rax
  mov    %rax,0x228(%rsp)
  xor    %eax,%eax
  lea    0x20(%rsp),%r13
L143:
  mov    %rbp,%rdx
  mov    $0x200,%esi
  mov    %r13,%rdi
  call   <fgetstr@plt>
  test   %rax,%rax
  je     L51
  cmpb   $0x23,0x20(%rsp)
  je     L143
  mov    %r13,%rdi
  call   <empty@plt>
  mov    %eax,%r14d
  test   %eax,%eax
  jne    L143
  lea    0x18(%rsp),%rsi
  lea    0x20(%rsp),%rdi
  call   <getval@plt>
  mov    %rax,%rdi
  mov    0x8(%rsp),%rsi
  call   <strcmp@plt>
  test   %rax,%rax
  jne    L50
  lea    -0x1(%r15),%ebp
  test   %r15d,%r15d
  jle    L165
  mov    %r12,%r15
  mov    %r12,%r14
  mov    %r12,0x8(%rsp)
  lea    0x18(%rsp),%r13
  jmp    L161
L51:
  mov    $0x0,%r14d
L50:
  mov    0x228(%rsp),%rax
  sub    %fs:0x28,%rax
  jne    L22
  mov    %r14d,%eax
  add    $0x238,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
L120:
  cmp    $0x4,%ebx
  jne    L44
  movq   $0x0,(%r15)
  lea    0x8(%r15),%r15
  jmp    L44
L54:
  mov    0x4(%rsp),%edx
  mov    $0x0,%esi
  mov    %rax,%rdi
  call   <strtoul@plt>
  mov    %al,(%r12)
  lea    0x1(%r12),%r12
L44:
  sub    $0x1,%ebp
  cmp    $0xffffffff,%ebp
  je     L177
L161:
  mov    %r13,%rsi
  mov    0x18(%rsp),%rdi
  call   <getval@plt>
  test   %rax,%rax
  je     L21
  cmp    $0x3,%ebx
  je     L19
  jg     L120
  cmp    $0x1,%ebx
  je     L54
  cmp    $0x2,%ebx
  jne    L44
  mov    0x4(%rsp),%edx
  mov    $0x0,%esi
  mov    %rax,%rdi
  call   <strtoul@plt>
  mov    0x8(%rsp),%rcx
  mov    %eax,(%rcx)
  lea    0x4(%rcx),%rax
  mov    %rax,0x8(%rsp)
  jmp    L44
L19:
  mov    0x4(%rsp),%edx
  mov    $0x0,%esi
  mov    %rax,%rdi
  call   <strtoul@plt>
  mov    %rax,(%r14)
  lea    0x8(%r14),%r14
  jmp    L44
L177:
  mov    $0x1,%r14d
  jmp    L50
L165:
  mov    $0x1,%r14d
  jmp    L50
L21:
  mov    $0x1,%r14d
  jmp    L50
L22:
  call   <__stack_chk_fail@plt>
```

assistant: ```c
int ldvals(FILE *f, const char *tag, int type, void *pval, int reps, int base) {
  char *p, *pr, line[512];
  unsigned char *pc = (unsigned char *)pval;
  unsigned int *pi = (unsigned int *)pval;
  unsigned long *pl = (unsigned long *)pval;
  unsigned long *pq = (unsigned long *)pval;
  while ((p = fgetstr(line, sizeof(line), f)) != NULL)
    if (line[0] != '#' && !empty(line))
      break;
  if (p == NULL || strcmp(getval(line, &pr), tag) != 0)
    return (0);
  while (reps-- > 0) {
    if ((p = getval(pr, &pr)) == NULL)
      return (1);
    switch (type) {
    case 1:
      *pc++ = (unsigned char)strtoul(p, NULL, base);
      break;
    case 2:
      *pi++ = (unsigned int)strtoul(p, NULL, base);
      break;
    case 3:
      *pl++ = (unsigned long)strtoul(p, NULL, base);
      break;
    case 4:
      *pq++ = (unsigned long)0;
      break;
    }
  }
  return (1);
}
```
user: Please show me the C implementation that matches the assembly code listed below:

```asm
<ldvals>:
  endbr64
  push   %r15
  push   %r14
  mov    %r9d,%r14d
  push   %r13
  mov    %rdi,%r13
  push   %r12
  mov    %rcx,%r12
  push   %rbp
  mov    %rsi,%rbp
  push   %rbx
  mov    %edx,%ebx
  sub    $0x238,%rsp
  mov    %r8d,(%rsp)
  lea    0x20(%rsp),%r15
  mov    %fs:0x28,%rax
  mov    %rax,0x228(%rsp)
  xor    %eax,%eax
  jmp    L8
  nopl   0x0(%rax)
L15:
  cmpb   $0x23,0x20(%rsp)
  jne    L181
L8:
  mov    %r13,%rdx
  mov    $0x200,%esi
  mov    %r15,%rdi
  call   <fgetstr@plt>
  test   %rax,%rax
  jne    L15
L155:
  xor    %eax,%eax
L97:
  mov    0x228(%rsp),%rdx
  sub    %fs:0x28,%rdx
  jne    L19
  add    $0x238,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
  nop
L181:
  mov    %r15,%rdi
  call   <empty@plt>
  test   %eax,%eax
  jne    L8
  lea    0x18(%rsp),%r13
  mov    %r15,%rdi
  mov    %r13,%rsi
  call   <getval@plt>
  mov    %rbp,%rsi
  mov    %rax,%rdi
  call   <strcmp@plt>
  test   %rax,%rax
  jne    L155
  mov    (%rsp),%eax
  mov    %r12,0x8(%rsp)
  mov    %r12,%r15
  mov    %r12,(%rsp)
  lea    -0x1(%rax),%ebp
  test   %eax,%eax
  jg     L149
  jmp    L94
  nopl   0x0(%rax)
L39:
  cmp    $0x2,%ebx
  jne    L171
  mov    %r14d,%edx
  xor    %esi,%esi
  call   <strtoul@plt>
  mov    (%rsp),%rcx
  mov    %eax,(%rcx)
  lea    0x4(%rcx),%rax
  mov    %rax,(%rsp)
L171:
  sub    $0x1,%ebp
  jb     L94
L149:
  mov    0x18(%rsp),%rdi
  mov    %r13,%rsi
  call   <getval@plt>
  mov    %rax,%rdi
  test   %rax,%rax
  je     L94
  cmp    $0x3,%ebx
  je     L170
  jg     L4
  cmp    $0x1,%ebx
  jne    L39
  mov    %r14d,%edx
  xor    %esi,%esi
  add    $0x1,%r12
  call   <strtoul@plt>
  mov    %al,-0x1(%r12)
  sub    $0x1,%ebp
  jae    L149
  nopl   0x0(%rax,%rax,1)
L94:
  mov    $0x1,%eax
  jmp    L97
  nopw   0x0(%rax,%rax,1)
L4:
  cmp    $0x4,%ebx
  jne    L171
  movq   $0x0,(%r15)
  add    $0x8,%r15
  jmp    L171
  nopw   0x0(%rax,%rax,1)
L170:
  mov    %r14d,%edx
  xor    %esi,%esi
  call   <strtoul@plt>
  mov    0x8(%rsp),%rcx
  mov    %rax,(%rcx)
  lea    0x8(%rcx),%rax
  mov    %rax,0x8(%rsp)
  jmp    L171
L19:
  call   <__stack_chk_fail@plt>
```

assistant: ```c
int ldvals(FILE *f, const char *tag, int type, void *pval, int reps, int base) {
  char *p, *pr, line[512];
  unsigned char *pc = (unsigned char *)pval;
  unsigned int *pi = (unsigned int *)pval;
  unsigned long *pl = (unsigned long *)pval;
  unsigned long *pq = (unsigned long *)pval;
  while ((p = fgetstr(line, sizeof(line), f)) != NULL)
    if (line[0] != '#' && !empty(line))
      break;
  if (p == NULL || strcmp(getval(line, &pr), tag) != 0)
    return (0);
  while (reps-- > 0) {
    if ((p = getval(pr, &pr)) == NULL)
      return (1);
    switch (type) {
    case 1:
      *pc++ = (unsigned char)strtoul(p, NULL, base);
      break;
    case 2:
      *pi++ = (unsigned int)strtoul(p, NULL, base);
      break;
    case 3:
      *pl++ = (unsigned long)strtoul(p, NULL, base);
      break;
    case 4:
      *pq++ = (unsigned long)0;
      break;
    }
  }
  return (1);
}
```
user: What is the c source code of the assembly code below?

```asm
<ldvals>:
  endbr64
  push   %r15
  push   %r14
  mov    %r9d,%r14d
  push   %r13
  mov    %rdi,%r13
  push   %r12
  mov    %rcx,%r12
  push   %rbp
  mov    %rsi,%rbp
  push   %rbx
  mov    %edx,%ebx
  sub    $0x238,%rsp
  mov    %r8d,(%rsp)
  lea    0x20(%rsp),%r15
  mov    %fs:0x28,%rax
  mov    %rax,0x228(%rsp)
  xor    %eax,%eax
  jmp    L22
  nopl   0x0(%rax)
L30:
  cmpb   $0x23,0x20(%rsp)
  jne    L29
L22:
  mov    %r13,%rdx
  mov    $0x200,%esi
  mov    %r15,%rdi
  call   <fgetstr@plt>
  test   %rax,%rax
  jne    L30
L162:
  xor    %eax,%eax
L26:
  mov    0x228(%rsp),%rdx
  sub    %fs:0x28,%rdx
  jne    L72
  add    $0x238,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
  nop
L29:
  mov    %r15,%rdi
  call   <empty@plt>
  test   %eax,%eax
  jne    L22
  lea    0x18(%rsp),%r13
  mov    %r15,%rdi
  mov    %r13,%rsi
  call   <getval@plt>
  mov    %rbp,%rsi
  mov    %rax,%rdi
  call   <strcmp@plt>
  test   %rax,%rax
  jne    L162
  mov    (%rsp),%eax
  mov    %r12,0x8(%rsp)
  mov    %r12,%r15
  mov    %r12,(%rsp)
  lea    -0x1(%rax),%ebp
  test   %eax,%eax
  jg     L83
  jmp    L147
  nopl   0x0(%rax)
L111:
  cmp    $0x2,%ebx
  jne    L149
  mov    %r14d,%edx
  xor    %esi,%esi
  call   <strtoul@plt>
  mov    (%rsp),%rcx
  mov    %eax,(%rcx)
  lea    0x4(%rcx),%rax
  mov    %rax,(%rsp)
L149:
  sub    $0x1,%ebp
  jb     L147
L83:
  mov    0x18(%rsp),%rdi
  mov    %r13,%rsi
  call   <getval@plt>
  mov    %rax,%rdi
  test   %rax,%rax
  je     L147
  cmp    $0x3,%ebx
  je     L93
  jg     L180
  cmp    $0x1,%ebx
  jne    L111
  mov    %r14d,%edx
  xor    %esi,%esi
  add    $0x1,%r12
  call   <strtoul@plt>
  mov    %al,-0x1(%r12)
  sub    $0x1,%ebp
  jae    L83
  nopl   0x0(%rax,%rax,1)
L147:
  mov    $0x1,%eax
  jmp    L26
  nopw   0x0(%rax,%rax,1)
L180:
  cmp    $0x4,%ebx
  jne    L149
  movq   $0x0,(%r15)
  add    $0x8,%r15
  jmp    L149
  nopw   0x0(%rax,%rax,1)
L93:
  mov    %r14d,%edx
  xor    %esi,%esi
  call   <strtoul@plt>
  mov    0x8(%rsp),%rcx
  mov    %rax,(%rcx)
  lea    0x8(%rcx),%rax
  mov    %rax,0x8(%rsp)
  jmp    L149
L72:
  call   <__stack_chk_fail@plt>
```

assistant: ```c
int ldvals(FILE *f, const char *tag, int type, void *pval, int reps, int base) {
  char *p, *pr, line[512];
  unsigned char *pc = (unsigned char *)pval;
  unsigned int *pi = (unsigned int *)pval;
  unsigned long *pl = (unsigned long *)pval;
  unsigned long *pq = (unsigned long *)pval;
  while ((p = fgetstr(line, sizeof(line), f)) != NULL)
    if (line[0] != '#' && !empty(line))
      break;
  if (p == NULL || strcmp(getval(line, &pr), tag) != 0)
    return (0);
  while (reps-- > 0) {
    if ((p = getval(pr, &pr)) == NULL)
      return (1);
    switch (type) {
    case 1:
      *pc++ = (unsigned char)strtoul(p, NULL, base);
      break;
    case 2:
      *pi++ = (unsigned int)strtoul(p, NULL, base);
      break;
    case 3:
      *pl++ = (unsigned long)strtoul(p, NULL, base);
      break;
    case 4:
      *pq++ = (unsigned long)0;
      break;
    }
  }
  return (1);
}
```
user: Translate the below assembly code into C programming language:

```asm
<cfrac>:
  endbr64
  movapd %xmm0,%xmm11
  movsd  D67(%rip),%xmm4
  addsd  %xmm4,%xmm1
  subsd  %xmm0,%xmm1
  divsd  %xmm1,%xmm4
  movapd %xmm4,%xmm14
  movsd  D68(%rip),%xmm3
  mov    $0x1,%eax
  movsd  D89(%rip),%xmm8
  movq   D82(%rip),%xmm7
  movsd  D64(%rip),%xmm6
  movapd %xmm7,%xmm13
  movapd %xmm6,%xmm12
  movapd %xmm6,%xmm5
  movapd %xmm6,%xmm10
  movapd %xmm7,%xmm9
  jmp    L6
L54:
  divsd  %xmm3,%xmm2
  movapd %xmm2,%xmm3
  addsd  %xmm1,%xmm3
  movapd %xmm3,%xmm0
  andpd  %xmm13,%xmm0
  comisd %xmm0,%xmm12
  ja     L20
  movsd  D64(%rip),%xmm0
L32:
  movsd  D67(%rip),%xmm15
  movapd %xmm15,%xmm4
  divsd  %xmm0,%xmm4
  movapd %xmm3,%xmm2
  mulsd  %xmm4,%xmm2
  mulsd  %xmm2,%xmm14
  subsd  %xmm15,%xmm2
  andpd  %xmm9,%xmm2
  movsd  D31(%rip),%xmm15
  comisd %xmm2,%xmm15
  ja     L20
  add    $0x1,%eax
  cmp    $0x400,%eax
  je     L20
L6:
  pxor   %xmm15,%xmm15
  cvtsi2sd %eax,%xmm15
  movapd %xmm11,%xmm2
  subsd  %xmm15,%xmm2
  mulsd  %xmm15,%xmm2
  mulsd  %xmm2,%xmm4
  movapd %xmm4,%xmm0
  addsd  %xmm8,%xmm1
  addsd  %xmm1,%xmm0
  movapd %xmm0,%xmm4
  andpd  %xmm7,%xmm4
  comisd %xmm4,%xmm6
  ja     L54
  divsd  %xmm3,%xmm2
  movapd %xmm2,%xmm3
  addsd  %xmm1,%xmm3
  movapd %xmm3,%xmm2
  andpd  D82(%rip),%xmm2
  cmpnltsd %xmm5,%xmm2
  andpd  %xmm2,%xmm3
  andnpd %xmm10,%xmm2
  orpd   %xmm2,%xmm3
  jmp    L32
L20:
  movapd %xmm14,%xmm0
  ret
```

tool_calls: name: parse_data
arguments: tag: D67
type: byte[8]
name: parse_data
arguments: tag: D68
type: byte[8]
name: parse_data
arguments: tag: D89
type: byte[8]
name: parse_data
arguments: tag: D82
type: qword[2]
name: parse_data
arguments: tag: D64
type: byte[8]
name: parse_data
arguments: tag: D31
type: byte[8]

tool: {"D67": [0x00,0x00,0x00,0x00,0x00,0x00,0xf0,0x3f]}

tool: {"D68": [0x00,0x00,0x00,0x00,0x00,0x00,0xb0,0x49]}

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

tool: {"D82": [0x7fffffffffffffff,0x0000000000000000]}

tool: {"D64": [0x00,0x00,0x00,0x00,0x00,0x00,0x30,0x36]}

tool: {"D31": [0x00,0x00,0x00,0x00,0x00,0x00,0xb0,0x3c]}

assistant: ```c
double cfrac(double n, double x) {
  int i;
  double a, b, c, d, e, f;
  b = x + 1 - n;
  c = 1 / (2.2204460492503131e-16 * 2.2204460492503131e-16 * 2.2204460492503131e-16);
  f = d = 1 / b;
  for (i = 1; i < 1024; i++) {
    a = i * (n - i);
    d = a * d + (b += 2);
    if (fabs(d) < (2.2204460492503131e-16 * 2.2204460492503131e-16 * 2.2204460492503131e-16))
      d = (2.2204460492503131e-16 * 2.2204460492503131e-16 * 2.2204460492503131e-16);
    c = b + a / c;
    if (fabs(c) < (2.2204460492503131e-16 * 2.2204460492503131e-16 * 2.2204460492503131e-16))
      c = (2.2204460492503131e-16 * 2.2204460492503131e-16 * 2.2204460492503131e-16);
    d = 1 / d;
    f *= e = d * c;
    if (fabs(e - 1) < 2.2204460492503131e-16)
      break;
  }
  return f;
}
```
user: Please show me the C implementation that matches the assembly code listed below:

```asm
<cfrac>:
  endbr64
  movsd  D51(%rip),%xmm5
  movsd  D35(%rip),%xmm7
  movapd %xmm0,%xmm6
  mov    $0x1,%eax
  movq   D23(%rip),%xmm3
  movsd  D0(%rip),%xmm9
  addsd  %xmm5,%xmm1
  movapd %xmm5,%xmm10
  movsd  D59(%rip),%xmm4
  movsd  D4(%rip),%xmm8
  movapd %xmm9,%xmm2
  subsd  %xmm0,%xmm1
  divsd  %xmm1,%xmm10
  movapd %xmm10,%xmm12
  jmp    L18
  nopl   (%rax)
L36:
  movapd %xmm5,%xmm10
  cmpnltsd %xmm4,%xmm0
  divsd  %xmm11,%xmm10
  andpd  %xmm0,%xmm2
  andnpd %xmm4,%xmm0
  orpd   %xmm0,%xmm2
L5:
  movapd %xmm2,%xmm0
  mulsd  %xmm10,%xmm0
  mulsd  %xmm0,%xmm12
  subsd  %xmm5,%xmm0
  andpd  %xmm3,%xmm0
  comisd %xmm0,%xmm8
  ja     L45
  add    $0x1,%eax
  cmp    $0x400,%eax
  je     L45
L18:
  pxor   %xmm11,%xmm11
  movapd %xmm6,%xmm0
  addsd  %xmm7,%xmm1
  cvtsi2sd %eax,%xmm11
  subsd  %xmm11,%xmm0
  mulsd  %xmm11,%xmm0
  mulsd  %xmm0,%xmm10
  divsd  %xmm2,%xmm0
  movapd %xmm10,%xmm11
  addsd  %xmm1,%xmm11
  movapd %xmm11,%xmm10
  andpd  %xmm3,%xmm10
  comisd %xmm10,%xmm4
  movapd %xmm0,%xmm2
  addsd  %xmm1,%xmm2
  movapd %xmm2,%xmm0
  andpd  %xmm3,%xmm0
  jbe    L36
  comisd %xmm0,%xmm4
  ja     L45
  movapd %xmm9,%xmm10
  jmp    L5
  cs nopw 0x0(%rax,%rax,1)
L45:
  movapd %xmm12,%xmm0
  ret
```

tool_calls: name: parse_data
arguments: data_tag: D51
type_infered: byte[8]
name: parse_data
arguments: data_tag: D35
type_infered: byte[8]
name: parse_data
arguments: data_tag: D23
type_infered: qword
name: parse_data
arguments: data_tag: D0
type_infered: byte[8]
name: parse_data
arguments: data_tag: D59
type_infered: byte[8]
name: parse_data
arguments: data_tag: D4
type_infered: byte[8]

tool: {"D51": [0x00,0x00,0x00,0x00,0x00,0x00,0xf0,0x3f]}

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

tool: D23: 9223372036854775807

tool: {"D0": [0x00,0x00,0x00,0x00,0x00,0x00,0xb0,0x49]}

tool: {"D59": [0x00,0x00,0x00,0x00,0x00,0x00,0x30,0x36]}

tool: {"D4": [0x00,0x00,0x00,0x00,0x00,0x00,0xb0,0x3c]}

assistant: ```c
double cfrac(double n, double x) {
  int i;
  double a, b, c, d, e, f;
  b = x + 1 - n;
  c = 1 / (2.2204460492503131e-16 * 2.2204460492503131e-16 * 2.2204460492503131e-16);
  f = d = 1 / b;
  for (i = 1; i < 1024; i++) {
    a = i * (n - i);
    d = a * d + (b += 2);
    if (fabs(d) < (2.2204460492503131e-16 * 2.2204460492503131e-16 * 2.2204460492503131e-16))
      d = (2.2204460492503131e-16 * 2.2204460492503131e-16 * 2.2204460492503131e-16);
    c = b + a / c;
    if (fabs(c) < (2.2204460492503131e-16 * 2.2204460492503131e-16 * 2.2204460492503131e-16))
      c = (2.2204460492503131e-16 * 2.2204460492503131e-16 * 2.2204460492503131e-16);
    d = 1 / d;
    f *= e = d * c;
    if (fabs(e - 1) < 2.2204460492503131e-16)
      break;
  }
  return f;
}
```