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

```asm
<__dtostr>:
  endbr64
  push   %r15
  mov    %ecx,%r15d
  push   %r14
  mov    %esi,%r14d
  push   %r13
  mov    %r8d,%r13d
  push   %r12
  mov    %edx,%r12d
  push   %rbp
  mov    %rdi,%rbp
  push   %rbx
  sub    $0x18,%rsp
  movsd  %xmm0,0x8(%rsp)
  call   <isinf@plt>
  movsd  0x8(%rsp),%xmm0
  lea    D113(%rip),%rdx
  test   %eax,%eax
  jne    L216
  movsd  %xmm0,0x8(%rsp)
  mov    %eax,%ebx
  call   <isnan@plt>
  movsd  0x8(%rsp),%xmm0
  test   %rax,%rax
  jne    L582
  pxor   %xmm1,%xmm1
  movq   %xmm0,%rdx
  ucomisd %xmm1,%xmm0
  jp     L41
  je     L157
L41:
  comisd %xmm0,%xmm1
  mov    %rbp,%r9
  movapd %xmm0,%xmm2
  jbe    L24
  movb   $0x2d,0x0(%rbp)
  xorpd  D124(%rip),%xmm2
  sub    $0x1,%r14d
  lea    0x1(%rbp),%r9
L24:
  movsd  D35(%rip),%xmm1
  test   %r15d,%r15d
  je     L151
  movsd  D0(%rip),%xmm3
  nopl   0x0(%rax,%rax,1)
L128:
  mulsd  %xmm3,%xmm1
  add    $0x1,%ebx
  cmp    %ebx,%r15d
  jne    L128
L151:
  addsd  %xmm1,%xmm2
  movsd  D43(%rip),%xmm1
  comisd %xmm2,%xmm1
  jbe    L119
  movb   $0x30,(%r9)
  sub    $0x1,%r14d
  add    $0x1,%r9
L119:
  shr    $0x34,%rdx
  pxor   %xmm1,%xmm1
  and    $0x7ff,%edx
  sub    $0x3ff,%rdx
  cvtsi2sd %rdx,%xmm1
  mulsd  D6(%rip),%xmm1
  cvttsd2si %xmm1,%rbx
  add    $0x1,%rbx
  test   %rbx,%rbx
  jle    L269
  movsd  D73(%rip),%xmm4
  mov    %ebx,%eax
  movapd %xmm4,%xmm1
  cmp    $0xa,%ebx
  jbe    L169
  movsd  D125(%rip),%xmm3
  nopl   (%rax)
L76:
  mulsd  %xmm3,%xmm1
  sub    $0xa,%eax
  cmp    $0xa,%eax
  ja     L76
  cmp    $0x1,%eax
  je     L385
L594:
  mulsd  %xmm4,%xmm1
  cmp    $0x2,%eax
  je     L385
  mulsd  %xmm4,%xmm1
  cmp    $0x3,%eax
  je     L385
  mulsd  %xmm4,%xmm1
  cmp    $0x4,%eax
  je     L385
  mulsd  %xmm4,%xmm1
  cmp    $0x5,%eax
  je     L385
  mulsd  %xmm4,%xmm1
  cmp    $0x6,%eax
  je     L385
  mulsd  %xmm4,%xmm1
  cmp    $0x7,%eax
  je     L385
  mulsd  %xmm4,%xmm1
  lea    -0x7(%rax),%edx
  cmp    $0x8,%eax
  je     L385
  mulsd  %xmm4,%xmm1
  cmp    $0x2,%edx
  je     L385
  mulsd  %xmm4,%xmm1
L385:
  comisd D47(%rip),%xmm1
  jbe    L586
L1:
  movsd  D47(%rip),%xmm5
  mov    $0x1,%edx
  jmp    L617
  nopl   0x0(%rax)
L215:
  divsd  %xmm4,%xmm1
  comisd %xmm5,%xmm1
  jbe    L586
L617:
  movapd %xmm2,%xmm3
  divsd  %xmm1,%xmm3
  cvttsd2si %xmm3,%eax
  test   %edx,%edx
  je     L9
  mov    $0x1,%edx
  test   %al,%al
  je     L215
L9:
  lea    0x30(%rax),%edx
  add    $0x1,%r9
  mov    %dl,-0x1(%r9)
  test   %r14d,%r14d
  je     L95
  movsbl %al,%eax
  pxor   %xmm3,%xmm3
  sub    $0x1,%r14d
  xor    %edx,%edx
  cvtsi2sd %eax,%xmm3
  mulsd  %xmm1,%xmm3
  divsd  %xmm4,%xmm1
  subsd  %xmm3,%xmm2
  comisd %xmm5,%xmm1
  ja     L617
L586:
  cmp    %rbp,%r9
  je     L533
L563:
  test   %r15d,%r15d
  jne    L31
  mov    %r9,%rax
  sub    %rbp,%rax
  lea    0x1(%rax),%edx
  cmp    %r12d,%edx
  jb     L31
L515:
  movb   $0x0,(%r9)
  add    $0x18,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
  nopl   0x0(%rax)
L582:
  lea    D111(%rip),%rdx
L216:
  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)
L157:
  test   %r15d,%r15d
  jne    L445
  test   %r14d,%r14d
  je     L422
  mov    $0x1,%r15d
  test   %rdx,%rdx
  jns    L364
  movb   $0x2d,0x0(%rbp)
  jmp    L72
  xchg   %ax,%ax
L445:
  add    $0x2,%r15d
  cmp    %r15d,%r14d
  jae    L295
L422:
  mov    $0x8,%r15d
  test   %rdx,%rdx
  jns    L364
  movb   $0x2d,0x0(%rbp)
  mov    $0x1,%ebx
L364:
  lea    -0x1(%r15),%r12d
  lea    0x1(%rbx),%r13d
  mov    $0x1,%eax
  mov    %ebx,%edi
  sub    %ebx,%r12d
  mov    $0x30,%esi
  mov    %r12d,%edx
  add    $0x1,%rdx
  cmp    %r13d,%r15d
  cmovb  %rax,%rdx
  add    %rbp,%rdi
  call   <memset@plt>
  xor    %eax,%eax
  cmp    %r13d,%r15d
  cmovae %r12d,%eax
  lea    (%rax,%r13,1),%ecx
  mov    %rcx,%rax
  add    %rbp,%rcx
L312:
  xor    %edx,%edx
  cmpb   $0x30,0x0(%rbp)
  setne  %dl
  add    $0x1,%rdx
L156:
  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)
L31:
  test   %r14d,%r14d
  je     L322
  lea    0x1(%r9),%rdx
  movb   $0x2e,(%r9)
  sub    $0x1,%r14d
  mov    %rdx,%rax
  sub    %rbp,%rax
  test   %r13d,%r13d
  je     L112
  test   %r15d,%r15d
  cmovne %r15d,%r12d
  sub    %eax,%r12d
  lea    0x1(%r12),%r15d
L443:
  cmp    %r14d,%r15d
  ja     L322
  test   %r15d,%r15d
  je     L205
L609:
  lea    0x1(%r15),%eax
  movsd  D73(%rip),%xmm4
  add    %rax,%r9
  nopl   0x0(%rax)
L556:
  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  %xmm4,%xmm1
  subsd  %xmm0,%xmm2
  cmp    %r9,%rdx
  jne    L556
L565:
  mov    %r9,%rax
  sub    %rbp,%rax
  jmp    L515
  nopl   (%rax)
L95:
  divsd  %xmm1,%xmm0
  xor    %esi,%esi
  xor    %r8d,%r8d
  mov    %r15d,%ecx
  mov    %r12d,%edx
  mov    %rbp,%rdi
  mov    %r9,0x8(%rsp)
  call   <__dtostr>
  mov    0x8(%rsp),%r9
  test   %eax,%eax
  mov    %eax,%esi
  jne    L521
  nopl   0x0(%rax,%rax,1)
L322:
  xor    %eax,%eax
L561:
  add    $0x18,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
  nopl   0x0(%rax)
L269:
  movsd  D0(%rip),%xmm1
  jmp    L586
  nopl   (%rax)
L533:
  test   %r14d,%r14d
  je     L322
  movb   $0x30,(%r9)
  sub    $0x1,%r14d
  add    $0x1,%r9
  jmp    L563
  xchg   %ax,%ax
L112:
  test   %r15d,%r15d
  je     L439
  cmp    %r14d,%r15d
  jbe    L609
  xor    %eax,%eax
  jmp    L561
  cs nopw 0x0(%rax,%rax,1)
L295:
  mov    %rbp,%rcx
  xor    %eax,%eax
  test   %r15d,%r15d
  je     L312
  test   %rdx,%rdx
  jns    L364
  movb   $0x2d,0x0(%rbp)
  mov    $0x1,%ebx
  cmp    $0x1,%r15d
  jne    L364
L72:
  lea    0x1(%rbp),%rcx
  mov    $0x1,%eax
  mov    $0x2,%edx
  jmp    L156
  nopl   (%rax)
L521:
  movslq %eax,%rdi
  mov    %eax,%ecx
  add    %r9,%rdi
  not    %ecx
  movb   $0x65,(%rdi)
  lea    0x1(%rdi),%r9
  cmp    $0x3e7,%rbx
  jle    L342
  test   %ecx,%ecx
  je     L20
  mov    %rbx,%rax
  lea    0x2(%rdi),%r9
  movabs $0x20c49ba5e353f7cf,%rdx
  imul   %rdx
  mov    %rbx,%rax
  sar    $0x3f,%rax
  sar    $0x7,%rdx
  sub    %rax,%rdx
  lea    0x30(%rdx),%eax
  mov    %al,0x1(%rdi)
L20:
  mov    %rbx,%rax
  mov    $0xfffffffe,%ecx
  movabs $0x20c49ba5e353f7cf,%rdx
  imul   %rdx
  mov    %rbx,%rax
  sub    %esi,%ecx
  sar    $0x3f,%rax
  sar    $0x7,%rdx
  sub    %rax,%rdx
  imul   $0x3e8,%rdx,%rax
  sub    %rax,%rbx
L348:
  test   %ecx,%ecx
  je     L647
  mov    %rbx,%rdx
  add    $0x1,%r9
  movabs $0x28f5c28f5c28f5c3,%rsi
  shr    $0x2,%rdx
  mov    %rdx,%rax
  mul    %rsi
  shr    $0x2,%rdx
  lea    0x30(%rdx),%eax
  mov    %al,-0x1(%r9)
L647:
  movabs $0x28f5c28f5c28f5c3,%rsi
  mov    %rbx,%rdx
  sub    $0x1,%ecx
  shr    $0x2,%rdx
  mov    %rdx,%rax
  mul    %rsi
  mov    %rdx,%rax
  and    $0xfffffffffffffffc,%rdx
  shr    $0x2,%rax
  add    %rdx,%rax
  lea    (%rax,%rax,4),%rax
  shl    $0x2,%rax
  sub    %rax,%rbx
L520:
  test   %ecx,%ecx
  je     L174
  mov    %rbx,%rax
  add    $0x1,%r9
  movabs $0xcccccccccccccccd,%rdx
  mul    %rdx
  shr    $0x3,%rdx
  lea    0x30(%rdx),%eax
  mov    %al,-0x1(%r9)
L174:
  movabs $0xcccccccccccccccd,%rdx
  mov    %rbx,%rax
  sub    $0x1,%ecx
  mul    %rdx
  shr    $0x3,%rdx
  lea    (%rdx,%rdx,4),%rax
  add    %rax,%rax
  sub    %rax,%rbx
L458:
  test   %ecx,%ecx
  je     L565
  add    $0x30,%ebx
  add    $0x1,%r9
  mov    %bl,-0x1(%r9)
  cmp    $0x1,%ecx
  jne    L565
  jmp    L322
L439:
  lea    0x1(%r12),%r15d
  sub    %eax,%r15d
  jmp    L443
L169:
  cmp    $0x1,%ebx
  ja     L594
  jmp    L1
L342:
  cmp    $0x63,%rbx
  jg     L348
  cmp    $0x9,%rbx
  jle    L458
  jmp    L520
  nopl   0x0(%rax,%rax,1)
L205:
  mov    %rdx,%r9
  jmp    L515
```

tool_calls: name: extract_symbolic_data
arguments: data_tag: D113
type: string
name: extract_symbolic_data
arguments: data_tag: D124
type: f32[4]
name: extract_symbolic_data
arguments: data_tag: D35
type: f64
name: extract_symbolic_data
arguments: data_tag: D0
type: f64
name: extract_symbolic_data
arguments: data_tag: D43
type: f64
name: extract_symbolic_data
arguments: data_tag: D6
type: f64
name: extract_symbolic_data
arguments: data_tag: D73
type: f64
name: extract_symbolic_data
arguments: data_tag: D125
type: f64
name: extract_symbolic_data
arguments: data_tag: D47
type: f64[2]
name: extract_symbolic_data
arguments: data_tag: D111
type: string

tool: D113: inf

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

tool: D35: 0.5

tool: D0: 0.1

tool: D43: 1

tool: D6: 0.3010299956639812

tool: D73: 10

tool: D125: 10000000000

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

tool: D111: 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;
}
```