user: 请从给定的汇编指令推导出C源代码：

```asm
<strtod>:
  endbr64
  push   %r15
  push   %r14
  push   %r13
  push   %r12
  push   %rbp
  push   %rbx
  sub    $0x18,%rsp
  mov    %rdi,%r14
  mov    %rsi,%r15
  movzbl (%rdi),%eax
  cmp    $0x20,%al
  je     L344
  cmp    $0x9,%al
  jne    L13
L344:
  mov    %r14,%rbx
L175:
  add    $0x1,%rbx
  movzbl (%rbx),%eax
  cmp    $0x20,%al
  je     L175
  cmp    $0x9,%al
  je     L175
L354:
  cmp    $0x2d,%al
  je     L204
  movl   $0x0,0x4(%rsp)
  cmp    $0x2b,%al
  je     L197
L29:
  mov    $0xffffffff,%r13d
  mov    $0x0,%ebp
  jmp    L110
L13:
  mov    %rdi,%rbx
  jmp    L354
L204:
  add    $0x1,%rbx
  movl   $0x1,0x4(%rsp)
  jmp    L29
L197:
  add    $0x1,%rbx
  jmp    L29
L424:
  mov    %ebp,%r13d
L94:
  add    $0x1,%rbx
  add    $0x1,%ebp
L110:
  movzbl (%rbx),%r12d
  movsbl %r12b,%edi
  call   <isdigit@plt>
  test   %rax,%rax
  jne    L94
  cmp    $0x2e,%r12b
  jne    L290
  test   %r13d,%r13d
  js     L424
L290:
  movslq %ebp,%rdx
  mov    %rbx,%rax
  sub    %rdx,%rax
  test   %r13d,%r13d
  js     L432
  sub    $0x1,%ebp
L234:
  cmp    $0x12,%ebp
  jle    L346
  sub    $0x12,%r13d
  mov    $0x12,%ebp
L201:
  mov    %ebp,%ecx
  mov    $0x0,%esi
  jmp    L104
L432:
  mov    %ebp,%r13d
  jmp    L234
L346:
  test   %ebp,%ebp
  je     L511
  sub    %ebp,%r13d
  cmp    $0x9,%ebp
  jg     L201
  mov    $0x0,%esi
  jmp    L89
L11:
  movzbl 0x1(%rax),%edx
  lea    0x2(%rax),%rax
L299:
  lea    (%rsi,%rsi,4),%esi
  movsbl %dl,%edx
  lea    -0x30(%rdx,%rsi,2),%esi
  sub    $0x1,%ecx
  cmp    $0x9,%ecx
  jle    L182
L104:
  movzbl (%rax),%edx
  cmp    $0x2e,%dl
  je     L11
  add    $0x1,%rax
  jmp    L299
L182:
  lea    -0xa(%rbp),%edx
  neg    %edx
  cmp    $0x9,%ebp
  mov    $0x0,%ecx
  cmovle %ecx,%edx
  lea    -0x1(%rbp,%rdx,1),%ebp
L89:
  test   %ebp,%ebp
  jle    L341
  mov    $0x0,%ecx
  jmp    L268
L328:
  movzbl 0x1(%rax),%edx
  lea    0x2(%rax),%rax
L136:
  lea    (%rcx,%rcx,4),%ecx
  movsbl %dl,%edx
  lea    -0x30(%rdx,%rcx,2),%ecx
  sub    $0x1,%ebp
  je     L296
L268:
  movzbl (%rax),%edx
  cmp    $0x2e,%dl
  je     L328
  add    $0x1,%rax
  jmp    L136
L341:
  mov    $0x0,%ecx
L296:
  pxor   %xmm0,%xmm0
  cvtsi2sd %esi,%xmm0
  mulsd  D13(%rip),%xmm0
  pxor   %xmm1,%xmm1
  cvtsi2sd %ecx,%xmm1
  addsd  %xmm1,%xmm0
  movsd  %xmm0,0x8(%rsp)
  movzbl (%rbx),%eax
  mov    %eax,%edx
  and    $0xffffffdf,%edx
  cmp    $0x45,%dl
  je     L464
  sub    $0x44,%eax
  cmp    $0x2f,%al
  ja     L156
  mov    $0x0,%ebp
  movabs $0x810500008105,%rdx
  bt     %rax,%rdx
  jb     L464
L93:
  add    %ebp,%r13d
  jmp    L507
L464:
  movzbl 0x1(%rbx),%eax
  cmp    $0x2d,%al
  je     L400
  cmp    $0x2b,%al
  je     L181
  add    $0x1,%rbx
  mov    $0x0,%r12d
L487:
  mov    $0x0,%ebp
  jmp    L269
L400:
  add    $0x2,%rbx
  mov    $0x1,%r12d
  jmp    L487
L181:
  add    $0x2,%rbx
  mov    $0x0,%r12d
  jmp    L487
L263:
  lea    0x0(%rbp,%rbp,4),%edx
  add    $0x1,%rbx
  movsbl -0x1(%rbx),%eax
  lea    -0x30(%rax,%rdx,2),%ebp
L269:
  movsbl (%rbx),%edi
  call   <isdigit@plt>
  test   %rax,%rax
  jne    L263
  test   %r12d,%r12d
  je     L93
  sub    %ebp,%r13d
L507:
  test   %r13d,%r13d
  js     L366
  mov    $0x133,%eax
  cmp    %eax,%r13d
  cmovle %r13d,%eax
  mov    $0x0,%ecx
  movsd  D45(%rip),%xmm0
  test   %r13d,%r13d
  je     L231
L430:
  lea    D24(%rip),%rdx
  movsd  D45(%rip),%xmm0
  jmp    L453
L156:
  mov    $0x0,%ebp
  jmp    L93
L366:
  mov    %r13d,%eax
  neg    %eax
  mov    $0x133,%edx
  cmp    %edx,%eax
  cmovg  %edx,%eax
  mov    $0x1,%ecx
  jmp    L430
L406:
  add    $0x8,%rdx
  sar    %eax
  je     L448
L453:
  test   $0x1,%al
  je     L406
  mulsd  (%rdx),%xmm0
  jmp    L406
L448:
  test   %ecx,%ecx
  je     L231
  movsd  0x8(%rsp),%xmm1
  divsd  %xmm0,%xmm1
L492:
  test   %r15,%r15
  je     L173
  mov    %rbx,(%r15)
L173:
  cmpl   $0x0,0x4(%rsp)
  je     L102
  xorpd  D44(%rip),%xmm1
L102:
  movapd %xmm1,%xmm0
  add    $0x18,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
L231:
  movsd  0x8(%rsp),%xmm1
  mulsd  %xmm0,%xmm1
  jmp    L492
L511:
  mov    %r14,%rbx
  pxor   %xmm1,%xmm1
  jmp    L492
```

tool_calls: name: extract_symbolic_data
arguments: data_tag: D13
type_guessed: f32[2]
name: extract_symbolic_data
arguments: data_tag: D45
type_guessed: f64
name: extract_symbolic_data
arguments: data_tag: D24
type_guessed: f64
name: extract_symbolic_data
arguments: data_tag: D44
type_guessed: f32[4]

tool: {"D13": [0.0,25.725290298461914]}

tool: D45: 1

tool: D24: 10

tool: {"D44": [0.0,-0.0,0.0,0.0]}

assistant: ```c
double strtod(const char *string, char **endPtr) {
  int sign = 0, expSign = 0, i;
  double fraction, dblExp;
  register const char *p;
  register char c;
  int exp = 0;
  int fracExp = 0;
  int mantSize;
  int decPt;
  const char *pExp;
  static int maxExponent = 307;
  static double powersOf10[] = {
      1e1, 1e2, 1e4, 1e8, 1e16, 1e32,
  };
  p = string;
  while (*p == ' ' || *p == '\t')
    ++p;
  if (*p == '-') {
    sign = 1;
    ++p;
  } else if (*p == '+')
    ++p;
  decPt = -1;
  for (mantSize = 0;; ++mantSize) {
    c = *p;
    if (!isdigit(c)) {
      if (c != '.' || decPt >= 0)
        break;
      decPt = mantSize;
    }
    ++p;
  }
  pExp = p;
  p -= mantSize;
  if (decPt < 0)
    decPt = mantSize;
  else
    --mantSize;
  if (mantSize > 2 * 9)
    mantSize = 2 * 9;
  fracExp = decPt - mantSize;
  if (mantSize == 0) {
    fraction = 0.0;
    p = string;
    goto done;
  } else {
    int frac1, frac2;
    for (frac1 = 0; mantSize > 9; --mantSize) {
      c = *p++;
      if (c == '.')
        c = *p++;
      frac1 = frac1 * 10 + (c - '0');
    }
    for (frac2 = 0; mantSize > 0; --mantSize) {
      c = *p++;
      if (c == '.')
        c = *p++;
      frac2 = frac2 * 10 + (c - '0');
    }
    fraction = (double)1000000000 * frac1 + frac2;
  }
  p = pExp;
  if (*p == 'E' || *p == 'e' || *p == 'S' || *p == 's' || *p == 'F' || *p == 'f' || *p == 'D' || *p == 'd' || *p == 'L' || *p == 'l') {
    ++p;
    if (*p == '-') {
      expSign = 1;
      ++p;
    } else if (*p == '+')
      ++p;
    while (isdigit(*p))
      exp = exp * 10 + (*p++ - '0');
  }
  if (expSign)
    exp = fracExp - exp;
  else
    exp = fracExp + exp;
  if (exp < 0) {
    expSign = 1;
    exp = -exp;
  } else
    expSign = 0;
  if (exp > maxExponent)
    exp = maxExponent;
  dblExp = 1.0;
  for (i = 0; exp; exp >>= 1, ++i)
    if (exp & 01)
      dblExp *= powersOf10[i];
  if (expSign)
    fraction /= dblExp;
  else
    fraction *= dblExp;
done:
  if (endPtr)
    *endPtr = (char *)p;
  return sign ? -fraction : fraction;
}
```