user: What is the c source code of the assembly code below:

```asm
<strtod>:
  endbr64
  push   %r15
  push   %r14
  mov    %rsi,%r14
  push   %r13
  mov    %rdi,%r13
  push   %r12
  push   %rbp
  push   %rbx
  mov    %rdi,%rbx
  sub    $0x18,%rsp
  movzbl (%rdi),%eax
  cmp    $0x20,%al
  jne    L321
  nopw   0x0(%rax,%rax,1)
L386:
  movzbl 0x1(%rbx),%eax
  add    $0x1,%rbx
  cmp    $0x20,%al
  je     L386
L321:
  cmp    $0x9,%al
  je     L386
  cmp    $0x2d,%al
  je     L66
  cmp    $0x2b,%al
  movl   $0x0,0xc(%rsp)
  sete   %al
  movzbl %al,%eax
  add    %rax,%rbx
L169:
  mov    $0xffffffff,%r12d
  xor    %ebp,%ebp
  jmp    L51
  nopl   (%rax)
L235:
  mov    %ebp,%r12d
L145:
  add    $0x1,%rbx
  add    $0x1,%ebp
L51:
  movsbl (%rbx),%edi
  mov    %edi,%r15d
  call   <isdigit@plt>
  test   %rax,%rax
  jne    L145
  cmp    $0x2e,%r15b
  jne    L389
  test   %r12d,%r12d
  js     L235
L389:
  movslq %ebp,%rdx
  mov    %rbx,%rax
  sub    %rdx,%rax
  cmp    $0xffffffff,%r12d
  je     L94
  sub    $0x1,%ebp
L187:
  cmp    $0x12,%ebp
  jle    L69
  sub    $0x12,%r12d
  mov    $0x12,%ebp
L275:
  mov    %ebp,%esi
  xor    %ecx,%ecx
  jmp    L338
  nopl   0x0(%rax,%rax,1)
L361:
  lea    (%rcx,%rcx,4),%ecx
  sub    $0x1,%esi
  add    $0x1,%rax
  lea    -0x30(%rdx,%rcx,2),%ecx
  cmp    $0x9,%esi
  je     L89
L338:
  movsbl (%rax),%edx
  cmp    $0x2e,%dl
  jne    L361
  movsbl 0x1(%rax),%edx
  lea    (%rcx,%rcx,4),%ecx
  sub    $0x1,%esi
  add    $0x2,%rax
  lea    -0x30(%rdx,%rcx,2),%ecx
  cmp    $0x9,%esi
  jne    L338
L89:
  lea    -0xa(%rbp),%edx
  xor    %esi,%esi
  neg    %edx
  cmp    $0x9,%ebp
  cmovle %esi,%edx
  lea    -0x1(%rbp,%rdx,1),%ebp
L39:
  xor    %esi,%esi
  jmp    L421
  nop
L227:
  lea    (%rsi,%rsi,4),%esi
  add    $0x1,%rax
  lea    -0x30(%rdx,%rsi,2),%esi
  sub    $0x1,%ebp
  je     L108
L421:
  movsbl (%rax),%edx
  cmp    $0x2e,%dl
  jne    L227
  movsbl 0x1(%rax),%edx
  lea    (%rsi,%rsi,4),%esi
  add    $0x2,%rax
  lea    -0x30(%rdx,%rsi,2),%esi
  sub    $0x1,%ebp
  jne    L421
L108:
  pxor   %xmm0,%xmm0
  pxor   %xmm1,%xmm1
  cvtsi2sd %ecx,%xmm0
  mulsd  D16(%rip),%xmm0
  cvtsi2sd %esi,%xmm1
  addsd  %xmm1,%xmm0
  movsd  %xmm0,(%rsp)
L28:
  movzbl (%rbx),%eax
  mov    %eax,%edx
  and    $0xffffffdf,%edx
  cmp    $0x45,%dl
  je     L341
  sub    $0x44,%eax
  cmp    $0x2f,%al
  ja     L3
  movabs $0x810500008105,%rdx
  bt     %rax,%rdx
  jb     L341
L3:
  test   %r12d,%r12d
  js     L115
L189:
  mov    $0x133,%eax
  cmp    %eax,%r12d
  cmovle %r12d,%eax
  test   %r12d,%r12d
  je     L154
  xor    %ecx,%ecx
L276:
  movsd  D23(%rip),%xmm0
  lea    D22(%rip),%rdx
  nopl   0x0(%rax)
L355:
  test   $0x1,%al
  je     L403
  mulsd  (%rdx),%xmm0
L403:
  add    $0x8,%rdx
  sar    %eax
  jne    L355
  test   %ecx,%ecx
  jne    L137
  mulsd  (%rsp),%xmm0
  movsd  %xmm0,(%rsp)
L154:
  test   %r14,%r14
  je     L299
  mov    %rbx,(%r14)
L299:
  mov    0xc(%rsp),%eax
  test   %eax,%eax
  je     L297
  movsd  (%rsp),%xmm2
  xorpd  D6(%rip),%xmm2
  movsd  %xmm2,(%rsp)
L297:
  movsd  (%rsp),%xmm0
  add    $0x18,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
L341:
  movsbl 0x1(%rbx),%edi
  cmp    $0x2d,%dil
  je     L441
  cmp    $0x2b,%dil
  je     L188
  add    $0x1,%rbx
  xor    %ebp,%ebp
L436:
  xor    %r13d,%r13d
  jmp    L402
  nopl   0x0(%rax,%rax,1)
L204:
  movsbl (%rbx),%eax
  lea    0x0(%r13,%r13,4),%edx
  movsbl 0x1(%rbx),%edi
  add    $0x1,%rbx
  lea    -0x30(%rax,%rdx,2),%r13d
L402:
  call   <isdigit@plt>
  test   %rax,%rax
  jne    L204
  lea    (%r12,%r13,1),%eax
  sub    %r13d,%r12d
  test   %ebp,%ebp
  cmove  %eax,%r12d
  test   %r12d,%r12d
  jns    L189
L115:
  mov    %r12d,%eax
  mov    $0x133,%edx
  mov    $0x1,%ecx
  neg    %eax
  cmp    %edx,%eax
  cmovg  %edx,%eax
  jmp    L276
  cs nopw 0x0(%rax,%rax,1)
L69:
  test   %ebp,%ebp
  je     L229
  sub    %ebp,%r12d
  cmp    $0x9,%ebp
  jg     L275
  test   %ebp,%ebp
  jg     L448
  pxor   %xmm6,%xmm6
  movsd  %xmm6,(%rsp)
  jmp    L28
  nopw   0x0(%rax,%rax,1)
L441:
  movsbl 0x2(%rbx),%edi
  mov    $0x1,%ebp
  add    $0x2,%rbx
  jmp    L436
  nopw   0x0(%rax,%rax,1)
L137:
  movsd  (%rsp),%xmm3
  divsd  %xmm0,%xmm3
  movsd  %xmm3,(%rsp)
  jmp    L154
  nopl   0x0(%rax,%rax,1)
L94:
  mov    %ebp,%r12d
  jmp    L187
L66:
  movl   $0x1,0xc(%rsp)
  add    $0x1,%rbx
  jmp    L169
L229:
  pxor   %xmm5,%xmm5
  mov    %r13,%rbx
  movsd  %xmm5,(%rsp)
  jmp    L154
L188:
  movsbl 0x2(%rbx),%edi
  xor    %ebp,%ebp
  add    $0x2,%rbx
  jmp    L436
L448:
  xor    %ecx,%ecx
  jmp    L39
```

tool_calls: name: retrieve_data
arguments: tag: D16
type: f32[2]
name: retrieve_data
arguments: tag: D23
type: f64
name: retrieve_data
arguments: tag: D22
type: f64
name: retrieve_data
arguments: tag: D6
type: f32[4]

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

tool: D23: 1

tool: D22: 10

tool: {"D6": [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;
}
```