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

```asm
<__dtostr>:
  endbr64
  push   %r15
  push   %r14
  mov    %esi,%r14d
  push   %r13
  mov    %ecx,%r13d
  push   %r12
  mov    %edx,%r12d
  push   %rbp
  mov    %rdi,%rbp
  push   %rbx
  sub    $0x18,%rsp
  movsd  %xmm0,(%rsp)
  mov    %r8d,0xc(%rsp)
  call   <isinf@plt>
  movsd  (%rsp),%xmm0
  lea    D32(%rip),%rdx
  test   %eax,%eax
  jne    L184
  movsd  %xmm0,(%rsp)
  mov    %eax,%ebx
  call   <isnan@plt>
  movsd  (%rsp),%xmm0
  test   %rax,%rax
  jne    L334
  pxor   %xmm1,%xmm1
  movq   %xmm0,%rdx
  ucomisd %xmm1,%xmm0
  jp     L513
  je     L404
L513:
  comisd %xmm0,%xmm1
  mov    %rbp,%r15
  movapd %xmm0,%xmm2
  jbe    L30
  movb   $0x2d,0x0(%rbp)
  xorpd  D81(%rip),%xmm2
  sub    $0x1,%r14d
  lea    0x1(%rbp),%r15
L30:
  movsd  D56(%rip),%xmm1
  test   %r13d,%r13d
  je     L144
  movsd  D123(%rip),%xmm3
  cs nopw 0x0(%rax,%rax,1)
L384:
  mulsd  %xmm3,%xmm1
  add    $0x1,%ebx
  cmp    %ebx,%r13d
  jne    L384
L144:
  addsd  %xmm1,%xmm2
  movsd  D87(%rip),%xmm1
  comisd %xmm2,%xmm1
  jbe    L222
  movb   $0x30,(%r15)
  sub    $0x1,%r14d
  add    $0x1,%r15
L222:
  shr    $0x34,%rdx
  pxor   %xmm1,%xmm1
  and    $0x7ff,%edx
  sub    $0x3ff,%rdx
  cvtsi2sd %rdx,%xmm1
  mulsd  D80(%rip),%xmm1
  cvttsd2si %xmm1,%rbx
  add    $0x1,%rbx
  test   %rbx,%rbx
  jle    L303
  movsd  D93(%rip),%xmm3
  mov    %ebx,%eax
  movapd %xmm3,%xmm1
  cmp    $0xa,%ebx
  jbe    L507
  movsd  D110(%rip),%xmm4
  nopl   (%rax)
L279:
  mulsd  %xmm4,%xmm1
  sub    $0xa,%eax
  cmp    $0xa,%eax
  ja     L279
  cmp    $0x1,%eax
  je     L260
  nopl   0x0(%rax)
L224:
  mulsd  %xmm3,%xmm1
  sub    $0x1,%eax
  cmp    $0x1,%eax
  jne    L224
L260:
  comisd D28(%rip),%xmm1
  jbe    L238
L443:
  movsd  D28(%rip),%xmm5
  mov    $0x1,%edx
  jmp    L354
  nopl   (%rax)
L138:
  divsd  %xmm3,%xmm1
  comisd %xmm5,%xmm1
  jbe    L238
L354:
  movapd %xmm2,%xmm4
  divsd  %xmm1,%xmm4
  cvttsd2si %xmm4,%eax
  test   %edx,%edx
  je     L347
  mov    $0x1,%edx
  test   %al,%al
  je     L138
L347:
  lea    0x30(%rax),%edx
  add    $0x1,%r15
  mov    %dl,-0x1(%r15)
  test   %r14d,%r14d
  je     L551
  movsbl %al,%eax
  pxor   %xmm4,%xmm4
  sub    $0x1,%r14d
  xor    %edx,%edx
  cvtsi2sd %eax,%xmm4
  mulsd  %xmm1,%xmm4
  divsd  %xmm3,%xmm1
  subsd  %xmm4,%xmm2
  comisd %xmm5,%xmm1
  ja     L354
L238:
  cmp    %rbp,%r15
  je     L288
L115:
  test   %r13d,%r13d
  jne    L239
  mov    %r15,%rax
  sub    %rbp,%rax
  lea    0x1(%rax),%edx
  cmp    %r12d,%edx
  jb     L239
L413:
  movb   $0x0,(%r15)
  add    $0x18,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
  nopl   0x0(%rax)
L334:
  lea    D128(%rip),%rdx
L184:
  add    $0x18,%rsp
  mov    %r14d,%esi
  mov    %rbp,%rdi
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  jmp    1090 <copystring@plt>
  nopl   0x0(%rax,%rax,1)
L404:
  test   %r13d,%r13d
  jne    L411
  test   %r14d,%r14d
  je     L505
  mov    $0x1,%r13d
  test   %rdx,%rdx
  jns    L414
  movb   $0x2d,0x0(%rbp)
  jmp    L192
  xchg   %ax,%ax
L411:
  add    $0x2,%r13d
  cmp    %r13d,%r14d
  jae    L44
L505:
  mov    $0x8,%r13d
  test   %rdx,%rdx
  jns    L414
  movb   $0x2d,0x0(%rbp)
  mov    $0x1,%ebx
L414:
  lea    -0x1(%r13),%r12d
  lea    0x1(%rbx),%r14d
  mov    $0x1,%eax
  mov    %ebx,%edi
  sub    %ebx,%r12d
  mov    $0x30,%esi
  mov    %r12d,%edx
  add    $0x1,%rdx
  cmp    %r13d,%r14d
  cmova  %rax,%rdx
  add    %rbp,%rdi
  call   <memset@plt>
  xor    %eax,%eax
  cmp    %r13d,%r14d
  cmovbe %r12d,%eax
  lea    (%rax,%r14,1),%ecx
  mov    %rcx,%rax
  add    %rbp,%rcx
L195:
  xor    %edx,%edx
  cmpb   $0x30,0x0(%rbp)
  setne  %dl
  add    $0x1,%rdx
L419:
  movb   $0x2e,0x0(%rbp,%rdx,1)
  movb   $0x0,(%rcx)
  add    $0x18,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
  nopl   (%rax)
L239:
  test   %r14d,%r14d
  je     L319
  lea    0x1(%r15),%rdx
  mov    0xc(%rsp),%ecx
  movb   $0x2e,(%r15)
  sub    $0x1,%r14d
  mov    %rdx,%rax
  sub    %rbp,%rax
  test   %ecx,%ecx
  je     L252
  test   %r13d,%r13d
  cmovne %r13d,%r12d
  sub    %eax,%r12d
  lea    0x1(%r12),%r13d
L147:
  cmp    %r14d,%r13d
  ja     L319
  test   %r13d,%r13d
  je     L25
L361:
  lea    0x1(%r13),%eax
  movsd  D93(%rip),%xmm3
  add    %rax,%r15
  nop
L277:
  movapd %xmm2,%xmm0
  add    $0x1,%rdx
  divsd  %xmm1,%xmm0
  cvttsd2si %xmm0,%eax
  pxor   %xmm0,%xmm0
  lea    0x30(%rax),%ecx
  movsbl %al,%eax
  cvtsi2sd %eax,%xmm0
  mov    %cl,-0x1(%rdx)
  mulsd  %xmm1,%xmm0
  divsd  %xmm3,%xmm1
  subsd  %xmm0,%xmm2
  cmp    %rdx,%r15
  jne    L277
L177:
  mov    %r15,%rax
  sub    %rbp,%rax
  jmp    L413
  nopl   (%rax)
L551:
  divsd  %xmm1,%xmm0
  xor    %esi,%esi
  xor    %r8d,%r8d
  mov    %r13d,%ecx
  mov    %r12d,%edx
  mov    %rbp,%rdi
  call   <__dtostr>
  mov    %eax,%esi
  test   %eax,%eax
  jne    L278
  nopl   0x0(%rax)
L319:
  xor    %eax,%eax
L420:
  add    $0x18,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
  nopl   0x0(%rax)
L303:
  movsd  D123(%rip),%xmm1
  jmp    L238
  nopl   (%rax)
L288:
  test   %r14d,%r14d
  je     L319
  movb   $0x30,(%r15)
  sub    $0x1,%r14d
  add    $0x1,%r15
  jmp    L115
  cs nopw 0x0(%rax,%rax,1)
L252:
  test   %r13d,%r13d
  je     L316
  cmp    %r14d,%r13d
  jbe    L361
  xor    %eax,%eax
  jmp    L420
  cs nopw 0x0(%rax,%rax,1)
L44:
  mov    %rbp,%rcx
  xor    %eax,%eax
  test   %r13d,%r13d
  je     L195
  test   %rdx,%rdx
  jns    L414
  movb   $0x2d,0x0(%rbp)
  mov    $0x1,%ebx
  cmp    $0x1,%r13d
  jne    L414
L192:
  lea    0x1(%rbp),%rcx
  mov    $0x1,%eax
  mov    $0x2,%edx
  jmp    L419
  nopl   (%rax)
L278:
  cltq
  not    %esi
  mov    $0x4,%r8d
  mov    $0x3e8,%edi
  add    %r15,%rax
  movb   $0x65,(%rax)
  lea    0x1(%rax),%r15
  mov    $0x1,%eax
L50:
  movslq %edi,%rcx
  cmp    %rbx,%rcx
  jle    L310
  mov    %eax,%edx
  mov    $0x1,%eax
  xor    $0x1,%edx
  test   %dl,%dl
  je     L22
L310:
  test   %esi,%esi
  je     L158
  mov    %rbx,%rax
  add    $0x1,%r15
  cqto
  idiv   %rcx
  add    $0x30,%eax
  mov    %al,-0x1(%r15)
L158:
  mov    %rbx,%rax
  sub    $0x1,%esi
  cqto
  idiv   %rcx
  xor    %eax,%eax
  mov    %rdx,%rbx
L22:
  imul   $0x66666667,%rcx,%rcx
  sar    $0x1f,%edi
  mov    %edi,%edx
  sar    $0x22,%rcx
  mov    %ecx,%edi
  sub    %edx,%edi
  sub    $0x1,%r8d
  jne    L50
  test   %esi,%esi
  jne    L177
  jmp    L319
L316:
  lea    0x1(%r12),%ecx
  sub    %eax,%ecx
  mov    %ecx,%r13d
  jmp    L147
L507:
  cmp    $0x1,%ebx
  ja     L224
  jmp    L443
L25:
  mov    %rdx,%r15
  jmp    L413
```

tool_calls: name: retrieve_data
arguments: tag: D32
type: string
name: retrieve_data
arguments: tag: D81
type: f32[4]
name: retrieve_data
arguments: tag: D56
type: f64
name: retrieve_data
arguments: tag: D123
type: f64
name: retrieve_data
arguments: tag: D87
type: f64
name: retrieve_data
arguments: tag: D80
type: f64
name: retrieve_data
arguments: tag: D93
type: f64
name: retrieve_data
arguments: tag: D110
type: f64
name: retrieve_data
arguments: tag: D28
type: f64[2]
name: retrieve_data
arguments: tag: D128
type: string

tool: D32: inf

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

tool: D56: 0.5

tool: D123: 0.1

tool: D87: 1

tool: D80: 0.3010299956639812

tool: D93: 10

tool: D110: 10000000000

tool: {"D28": [0.9,-0.0]}

tool: D128: nan

assistant: ```c
int __dtostr(double d, char *buf, unsigned int maxlen, unsigned int prec, unsigned int prec2, int g) {
  union {
    unsigned long long l;
    double d;
  } u = {.d = d};
  signed long e = ((u.l >> 52) & ((1 << 11) - 1)) - 1023;
  signed long e10;
  unsigned int i;
  double backup = d;
  double tmp;
  char *oldbuf = buf;
  if ((i = isinf(d)))
    return copystring(buf, maxlen, i > 0 ? "inf" : "-inf");
  if (isnan(d))
    return copystring(buf, maxlen, "nan");
  e10 = 1 + (long)(e * 0.30102999566398119802);
  if (d == 0.0) {
    prec2 = prec2 == 0 ? 1 : prec2 + 2;
    prec2 = prec2 > maxlen ? 8 : prec2;
    i = 0;
    if (prec2 && (long long)u.l < 0) {
      buf[0] = '-';
      ++i;
    }
    for (; i < prec2; ++i)
      buf[i] = '0';
    buf[buf[0] == '0' ? 1 : 2] = '.';
    buf[i] = 0;
    return i;
  }
  if (d < 0.0) {
    d = -d;
    *buf = '-';
    --maxlen;
    ++buf;
  }
  tmp = 0.5;
  for (i = 0; i < prec2; i++) {
    tmp *= 0.1;
  }
  d += tmp;
  if (d < 1.0) {
    *buf = '0';
    --maxlen;
    ++buf;
  }
  if (e10 > 0) {
    int first = 1;
    tmp = 10.0;
    i = e10;
    while (i > 10) {
      tmp = tmp * 1e10;
      i -= 10;
    }
    while (i > 1) {
      tmp = tmp * 10;
      --i;
    }
    while (tmp > 0.9) {
      char digit;
      double fraction = d / tmp;
      digit = (int)(fraction);
      if (!first || digit) {
        first = 0;
        *buf = digit + '0';
        ++buf;
        if (!maxlen) {
          int len = __dtostr(backup / tmp, oldbuf, maxlen, prec, prec2, 0);
          int initial = 1;
          if (len == 0)
            return 0;
          maxlen -= len;
          buf += len;
          if (maxlen > 0) {
            *buf = 'e';
            ++buf;
          }
          --maxlen;
          for (len = 1000; len > 0; len /= 10) {
            if (e10 >= len || !initial) {
              if (maxlen > 0) {
                *buf = (e10 / len) + '0';
                ++buf;
              }
              --maxlen;
              initial = 0;
              e10 = e10 % len;
            }
          }
          if (maxlen > 0)
            goto fini;
          return 0;
        }
        d -= digit * tmp;
        --maxlen;
      }
      tmp /= 10.0;
    }
  } else {
    tmp = 0.1;
  }
  if (buf == oldbuf) {
    if (!maxlen)
      return 0;
    --maxlen;
    *buf = '0';
    ++buf;
  }
  if (prec2 || prec > (unsigned int)(buf - oldbuf) + 1) {
    if (!maxlen)
      return 0;
    --maxlen;
    *buf = '.';
    ++buf;
    if (g) {
      if (prec2)
        prec = prec2;
      prec -= buf - oldbuf - 1;
    } else {
      prec -= buf - oldbuf - 1;
      if (prec2)
        prec = prec2;
    }
    if (prec > maxlen)
      return 0;
    while (prec > 0) {
      char digit;
      double fraction = d / tmp;
      digit = (int)(fraction);
      *buf = digit + '0';
      ++buf;
      d -= digit * tmp;
      tmp /= 10.0;
      --prec;
    }
  }
fini:
  *buf = 0;
  return buf - oldbuf;
}
```