user: 下面的汇编指令对应的C源代码是什么:

```asm
<my_double2str>:
  endbr64
  push   %r15
  push   %r14
  push   %r13
  push   %r12
  push   %rbp
  push   %rbx
  sub    $0x38,%rsp
  mov    %rdi,(%rsp)
  movsd  %xmm0,0x18(%rsp)
  mov    %fs:0x28,%rax
  mov    %rax,0x28(%rsp)
  xor    %eax,%eax
  cmp    $0x7,%rsi
  jbe    L665
  shr    %rsi
  pxor   %xmm3,%xmm3
  lea    -0xa(%rsi),%rax
  cmp    $0x13,%rax
  ja     L199
  xor    %ebx,%ebx
  comisd %xmm0,%xmm3
  jbe    L117
  xorpd  D206(%rip),%xmm0
  mov    $0x2d,%ebx
  movsd  %xmm0,0x18(%rsp)
L117:
  movsd  D187(%rip),%xmm1
  xor    %r12d,%r12d
  cmp    $0xa,%rsi
  jne    L332
L316:
  movsd  %xmm3,0x10(%rsp)
  movsd  %xmm1,0x8(%rsp)
  call   <isnan@plt>
  movsd  0x8(%rsp),%xmm1
  movsd  0x10(%rsp),%xmm3
  test   %rax,%rax
  jne    L473
  movsd  0x18(%rsp),%xmm0
  comisd %xmm3,%xmm0
  jbe    L270
  xor    %r15d,%r15d
  comisd D146(%rip),%xmm0
  movsd  D176(%rip),%xmm2
  jae    L440
  jmp    L12
  nopl   0x0(%rax,%rax,1)
L328:
  test   %al,%al
  je     L78
L440:
  mulsd  %xmm2,%xmm0
  add    $0x20,%r15d
  cmp    $0x15e,%r15d
  setle  %al
  comisd D146(%rip),%xmm0
  jae    L328
L78:
  movsd  %xmm0,0x18(%rsp)
L203:
  comisd D94(%rip),%xmm0
  movsd  D121(%rip),%xmm3
  jb     L701
  test   %al,%al
  jne    L637
  jmp    L701
  xchg   %ax,%ax
L129:
  test   %al,%al
  je     L442
L637:
  mulsd  %xmm3,%xmm0
  add    $0x8,%r15d
  cmp    $0x15e,%r15d
  setle  %al
  comisd D94(%rip),%xmm0
  jae    L129
L442:
  movsd  %xmm0,0x18(%rsp)
L701:
  comisd D155(%rip),%xmm0
  jb     L602
  test   %al,%al
  je     L602
  movsd  D171(%rip),%xmm2
  jmp    L322
  xchg   %ax,%ax
L200:
  comisd D155(%rip),%xmm0
  jb     L402
L322:
  mulsd  %xmm2,%xmm0
  add    $0x1,%r15d
  cmp    $0x15e,%r15d
  jle    L200
L402:
  movsd  %xmm0,0x18(%rsp)
L602:
  comisd %xmm0,%xmm3
  movsd  D94(%rip),%xmm2
  jbe    L718
  nop
L704:
  mulsd  %xmm2,%xmm0
  sub    $0x8,%r15d
  comisd %xmm0,%xmm3
  ja     L704
  movsd  %xmm0,0x18(%rsp)
L718:
  movsd  D71(%rip),%xmm2
  movsd  D155(%rip),%xmm3
  comisd %xmm0,%xmm2
  jbe    L163
  nopw   0x0(%rax,%rax,1)
L339:
  mulsd  %xmm3,%xmm0
  sub    $0x1,%r15d
  comisd %xmm0,%xmm2
  ja     L339
  movsd  %xmm0,0x18(%rsp)
L163:
  cmp    $0x15e,%r15d
  jg     L356
  addsd  0x18(%rsp),%xmm1
  comisd D155(%rip),%xmm1
  movsd  %xmm1,0x18(%rsp)
  jb     L80
  add    $0x1,%r15d
  cmp    $0xfffffffc,%r15d
  setl   %al
  jmp    L510
  nopl   0x0(%rax,%rax,1)
L199:
  xor    %ebx,%ebx
  comisd %xmm0,%xmm3
  jbe    L461
  xorpd  D206(%rip),%xmm0
  mov    $0x2d,%ebx
  movsd  %xmm0,0x18(%rsp)
L461:
  mov    $0x13,%r12d
L537:
  movsd  D187(%rip),%xmm1
  movsd  D171(%rip),%xmm2
  mov    %r12d,%eax
  nopl   0x0(%rax)
L271:
  mulsd  %xmm2,%xmm1
  sub    $0x1,%eax
  jne    L271
  jmp    L316
  cs nopw 0x0(%rax,%rax,1)
L270:
  addsd  %xmm0,%xmm1
  comisd D155(%rip),%xmm1
  movsd  %xmm1,0x18(%rsp)
  jae    L630
  movl   $0x0,0x24(%rsp)
  mov    (%rsp),%rcx
  test   %bl,%bl
  je     L486
  movb   $0x2d,(%rcx)
  lea    0x1(%rcx),%rdx
  xor    %eax,%eax
  xor    %r15d,%r15d
  movb   $0x1,0x10(%rsp)
  lea    0x2(%rcx),%r13
L396:
  add    $0x1,%eax
  lea    0x24(%rsp),%rbp
  lea    0x18(%rsp),%rbx
  cltq
  add    %rdx,%rax
  mov    %rax,%r14
  jmp    L439
  nopl   0x0(%rax,%rax,1)
L364:
  add    $0x1,%r13
L439:
  mov    %rbp,%rsi
  mov    %rbx,%rdi
  call   <getdigit@plt>
  mov    %al,-0x1(%r13)
  cmp    %r13,%r14
  jne    L364
  test   %r12d,%r12d
  jg     L571
L715:
  cmpb   $0x2,0x10(%rsp)
  je     L333
L452:
  movb   $0x0,(%r14)
  xor    %eax,%eax
  jmp    L420
  nopl   0x0(%rax)
L473:
  mov    (%rsp),%rdi
  lea    D106(%rip),%rsi
  call   <strcpy@plt>
  xor    %eax,%eax
L420:
  mov    0x28(%rsp),%rdx
  sub    %fs:0x28,%rdx
  jne    L82
  add    $0x38,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
  nopl   (%rax)
L630:
  xor    %eax,%eax
  mov    $0x1,%r15d
L510:
  mulsd  D171(%rip),%xmm1
  movsd  %xmm1,0x18(%rsp)
  cmp    %r12d,%r15d
  jg     L654
L502:
  test   %al,%al
  jne    L654
  mov    %r12d,%eax
  movl   $0x0,0x24(%rsp)
  mov    (%rsp),%rdx
  sub    %r15d,%eax
  mov    %eax,0x8(%rsp)
  test   %bl,%bl
  jne    L134
L318:
  lea    0x1(%rdx),%r13
  mov    %r13,%r14
  test   %r15d,%r15d
  jns    L194
  mov    0x8(%rsp),%ecx
  movb   $0x30,(%rdx)
  lea    0x1(%r15),%eax
  test   %ecx,%ecx
  jle    L615
  movb   $0x2e,0x1(%rdx)
  lea    0x2(%rdx),%r14
  test   %eax,%eax
  je     L500
L546:
  mov    0x8(%rsp),%eax
  mov    %r15d,%ebx
  mov    %r14,%r13
  not    %ebx
  add    %r14,%rbx
  lea    (%rax,%r14,1),%ebp
  nopl   0x0(%rax,%rax,1)
L309:
  mov    %ebp,%eax
  xor    %edi,%edi
  sub    %r13d,%eax
  test   %eax,%eax
  setg   %dil
  add    $0x1,%r13
  call   <assert@plt>
  movb   $0x30,-0x1(%r13)
  cmp    %r13,%rbx
  jne    L309
  mov    %r15d,%eax
  movb   $0x1,0x10(%rsp)
  not    %eax
  add    %rax,%r14
  mov    0x8(%rsp),%eax
  lea    0x1(%r15,%rax,1),%eax
  test   %eax,%eax
  jle    L312
  lea    0x24(%rsp),%rbp
  lea    0x18(%rsp),%rbx
L173:
  mov    %r14,%r13
  nopw   0x0(%rax,%rax,1)
L468:
  mov    %rbp,%rsi
  mov    %rbx,%rdi
  add    $0x1,%r13
  call   <getdigit@plt>
  mov    %al,-0x1(%r13)
  mov    $0x1,%eax
  sub    %r13d,%eax
  add    %r14d,%eax
  add    %r12d,%eax
  test   %eax,%eax
  jg     L468
  xor    %eax,%eax
  test   %r12d,%r12d
  cmovns %r12d,%eax
  add    $0x1,%eax
  cltq
  add    %rax,%r14
L312:
  mov    0x8(%rsp),%eax
  test   %eax,%eax
  jg     L352
  jmp    L715
  nopl   0x0(%rax,%rax,1)
L165:
  movb   $0x0,-0x1(%r14)
  sub    $0x1,%r14
L352:
  cmpb   $0x30,-0x1(%r14)
  je     L165
  xor    %edi,%edi
  cmp    %r14,(%rsp)
  setb   %dil
  call   <assert@plt>
  cmpb   $0x2e,-0x1(%r14)
  jne    L715
  movb   $0x0,-0x1(%r14)
  sub    $0x1,%r14
  cmpb   $0x2,0x10(%rsp)
  jne    L452
L333:
  movb   $0x65,(%r14)
  lea    0x2(%r14),%rsi
  mov    $0x2b,%eax
  test   %r15d,%r15d
  jns    L137
  neg    %r15d
  mov    $0x2d,%eax
L137:
  mov    %al,0x1(%r14)
  cmp    $0x63,%r15d
  jle    L624
  mov    %r15d,%eax
  lea    0x3(%r14),%rsi
  imul   $0x51eb851f,%rax,%rax
  shr    $0x25,%rax
  lea    0x30(%rax),%edi
  imul   $0x64,%eax,%eax
  mov    %dil,0x2(%r14)
  sub    %eax,%r15d
L624:
  mov    $0xcccccccd,%ecx
  mov    %r15d,%eax
  lea    0x2(%rsi),%r14
  mov    %r15d,%edx
  imul   %rcx,%rax
  shr    $0x23,%rax
  lea    0x30(%rax),%ecx
  lea    (%rax,%rax,4),%eax
  add    %eax,%eax
  mov    %cl,(%rsi)
  sub    %eax,%edx
  add    $0x30,%edx
  mov    %dl,0x1(%rsi)
  jmp    L452
  nopw   0x0(%rax,%rax,1)
L80:
  cmp    $0xfffffffc,%r15d
  setl   %al
  cmp    %r12d,%r15d
  jle    L502
L654:
  movl   $0x0,0x24(%rsp)
  mov    (%rsp),%rcx
  test   %bl,%bl
  je     L345
  movb   $0x2d,(%rcx)
  lea    0x1(%rcx),%rdx
  xor    %eax,%eax
  lea    0x2(%rcx),%r13
  movb   $0x2,0x10(%rsp)
  jmp    L396
L615:
  test   %eax,%eax
  jne    L546
  movb   $0x1,0x10(%rsp)
  jmp    L715
  nopl   0x0(%rax)
L356:
  cmp    $0x2d,%bl
  je     L62
  mov    (%rsp),%rdi
  lea    D182(%rip),%rsi
  call   <strcpy@plt>
  xor    %eax,%eax
  jmp    L420
  nopl   0x0(%rax)
L345:
  movb   $0x2,0x10(%rsp)
  mov    %rcx,%rdx
  xor    %eax,%eax
  lea    0x1(%rcx),%r13
  jmp    L396
L12:
  mov    $0x1,%eax
  jmp    L203
L62:
  mov    (%rsp),%rdi
  lea    D54(%rip),%rsi
  call   <strcpy@plt>
  xor    %eax,%eax
  jmp    L420
L486:
  movb   $0x1,0x10(%rsp)
  mov    %rcx,%rdx
  xor    %eax,%eax
  xor    %r15d,%r15d
  lea    0x1(%rcx),%r13
  jmp    L396
L134:
  mov    %rdx,%rax
  lea    0x1(%rdx),%rdx
  movb   $0x2d,(%rax)
  jmp    L318
L571:
  mov    %r14,%rax
  lea    0x1(%r14),%r14
  movb   $0x2e,(%rax)
L405:
  mov    %r12d,0x8(%rsp)
  sub    $0x1,%r12d
  jmp    L173
L332:
  mov    %esi,%r12d
  sub    $0xb,%r12d
  je     L316
  jmp    L537
  nopl   0x0(%rax,%rax,1)
L665:
  mov    $0xffffffff,%eax
  jmp    L420
L82:
  call   <__stack_chk_fail@plt>
L500:
  movb   $0x1,0x10(%rsp)
  mov    0x8(%rsp),%r12d
  or     $0xffffffff,%r15d
  lea    0x24(%rsp),%rbp
  lea    0x18(%rsp),%rbx
  jmp    L405
L194:
  movb   $0x1,0x10(%rsp)
  mov    0x8(%rsp),%r12d
  mov    %r15d,%eax
  jmp    L396
```

tool_calls: name: unpack_data
arguments: label: D206
type_guessed: f32[4]
name: unpack_data
arguments: label: D187
type_guessed: f64
name: unpack_data
arguments: label: D146
type_guessed: f64[2]
name: unpack_data
arguments: label: D176
type_guessed: byte[8]
name: unpack_data
arguments: label: D94
type_guessed: f64[2]
name: unpack_data
arguments: label: D121
type_guessed: byte[8]
name: unpack_data
arguments: label: D155
type_guessed: f64[2]
name: unpack_data
arguments: label: D171
type_guessed: f64
name: unpack_data
arguments: label: D71
type_guessed: f64
name: unpack_data
arguments: label: D106
type_guessed: string
name: unpack_data
arguments: label: D182
type_guessed: string
name: unpack_data
arguments: label: D54
type_guessed: string

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

tool: D187: 0.5

tool: {"D146": [1e32,1e-32]}

tool: {"D176": [0x33,0xa7,0xa8,0xd5,0x23,0xf6,0x49,0x39]}

tool: {"D94": [100000000.0,1e-8]}

tool: {"D121": [0x3a,0x8c,0x30,0xe2,0x8e,0x79,0x45,0x3e]}

tool: {"D155": [10.0,1.0]}

tool: D171: 0.1

tool: D71: 1

tool: D106: NaN

tool: D182: Inf

tool: D54: -Inf

assistant: ```c
int my_double2str(char *buf, size_t bufsize, double realvalue) {
  int precision = -1;
  char *bufpt;
  char prefix;
  char xtype = 0;
  int idx, exp, e2;
  double rounder;
  char flag_exp;
  char flag_rtz;
  char flag_dp;
  char flag_alternateform = 0;
  char flag_altform2 = 0;
  int nsd;
  if (bufsize < 8)
    return -1;
  if (precision < 0)
    precision = 20;
  if (precision > bufsize / 2 - 10)
    precision = bufsize / 2 - 10;
  if (realvalue < 0.0) {
    realvalue = -realvalue;
    prefix = '-';
  } else {
    prefix = 0;
  }
  if (xtype == 0 && precision > 0)
    precision--;
  for (idx = precision, rounder = 0.5; idx > 0; idx--, rounder *= 0.1) {
  }
  if (xtype == 1)
    realvalue += rounder;
  exp = 0;
  if (isnan(realvalue)) {
    strcpy(buf, "NaN");
    return 0;
  }
  if (realvalue > 0.0) {
    while (realvalue >= 1e32 && exp <= 350) {
      realvalue *= 1e-32;
      exp += 32;
    }
    while (realvalue >= 1e8 && exp <= 350) {
      realvalue *= 1e-8;
      exp += 8;
    }
    while (realvalue >= 10.0 && exp <= 350) {
      realvalue *= 0.1;
      exp++;
    }
    while (realvalue < 1e-8) {
      realvalue *= 1e8;
      exp -= 8;
    }
    while (realvalue < 1.0) {
      realvalue *= 10.0;
      exp--;
    }
    if (exp > 350) {
      if (prefix == '-') {
        strcpy(buf, "-Inf");
      } else {
        strcpy(buf, "Inf");
      }
      return 0;
    }
  }
  bufpt = buf;
  flag_exp = xtype == 2;
  if (xtype != 1) {
    realvalue += rounder;
    if (realvalue >= 10.0) {
      realvalue *= 0.1;
      exp++;
    }
  }
  if (xtype == 0) {
    flag_rtz = !flag_alternateform;
    if (exp < -4 || exp > precision) {
      xtype = 2;
    } else {
      precision = precision - exp;
      xtype = 1;
    }
  } else {
    flag_rtz = 0;
  }
  if (xtype == 2) {
    e2 = 0;
  } else {
    e2 = exp;
  }
  nsd = 0;
  flag_dp = (precision > 0 ? 1 : 0) | flag_alternateform | flag_altform2;
  if (prefix) {
    *(bufpt++) = prefix;
  }
  if (e2 < 0) {
    *(bufpt++) = '0';
  } else {
    for (; e2 >= 0; e2--) {
      *(bufpt++) = getdigit(&realvalue, &nsd);
    }
  }
  if (flag_dp) {
    *(bufpt++) = '.';
  }
  for (e2++; e2 < 0; precision--, e2++) {
    assert(precision > 0);
    *(bufpt++) = '0';
  }
  while ((precision--) > 0) {
    *(bufpt++) = getdigit(&realvalue, &nsd);
  }
  if (flag_rtz && flag_dp) {
    while (bufpt[-1] == '0')
      *(--bufpt) = 0;
    assert(bufpt > buf);
    if (bufpt[-1] == '.') {
      if (flag_altform2) {
        *(bufpt++) = '0';
      } else {
        *(--bufpt) = 0;
      }
    }
  }
  if (flag_exp || xtype == 2) {
    *(bufpt++) = 'e';
    if (exp < 0) {
      *(bufpt++) = '-';
      exp = -exp;
    } else {
      *(bufpt++) = '+';
    }
    if (exp >= 100) {
      *(bufpt++) = (char)((exp / 100) + '0');
      exp %= 100;
    }
    *(bufpt++) = (char)(exp / 10 + '0');
    *(bufpt++) = (char)(exp % 10 + '0');
  }
  *bufpt = 0;
  return 0;
}
```