user: 这段汇编代码用C语言表示是什么样的?

```asm
<my_double2str>:
  endbr64
  push   %r15
  push   %r14
  push   %r13
  push   %r12
  push   %rbp
  push   %rbx
  sub    $0x48,%rsp
  mov    %rdi,0x10(%rsp)
  movsd  %xmm0,0x28(%rsp)
  mov    %fs:0x28,%rax
  mov    %rax,0x38(%rsp)
  xor    %eax,%eax
  cmp    $0x7,%rsi
  jbe    L535
  shr    %rsi
  pxor   %xmm3,%xmm3
  lea    -0xa(%rsi),%rax
  cmp    $0x13,%rax
  ja     L658
  xor    %ebx,%ebx
  comisd %xmm0,%xmm3
  jbe    L806
  xorpd  D51(%rip),%xmm0
  mov    $0x2d,%ebx
  movsd  %xmm0,0x28(%rsp)
L806:
  movl   $0x0,0xc(%rsp)
  movsd  D98(%rip),%xmm1
  cmp    $0xa,%rsi
  jne    L129
L323:
  movsd  %xmm3,0x20(%rsp)
  movsd  %xmm1,0x18(%rsp)
  call   <isnan@plt>
  movsd  0x18(%rsp),%xmm1
  movsd  0x20(%rsp),%xmm3
  test   %rax,%rax
  jne    L421
  movsd  0x28(%rsp),%xmm0
  comisd %xmm3,%xmm0
  jbe    L452
  movsd  D17(%rip),%xmm2
  comisd %xmm2,%xmm0
  jb     L8
  movsd  D85(%rip),%xmm3
  mulsd  %xmm3,%xmm0
  comisd %xmm2,%xmm0
  jb     L616
  mulsd  %xmm3,%xmm0
  comisd %xmm2,%xmm0
  jb     L85
  mulsd  %xmm3,%xmm0
  comisd %xmm2,%xmm0
  jb     L317
  mulsd  %xmm3,%xmm0
  comisd %xmm2,%xmm0
  jb     L367
  mulsd  %xmm3,%xmm0
  comisd %xmm2,%xmm0
  jb     L107
  mulsd  %xmm3,%xmm0
  comisd %xmm2,%xmm0
  jb     L4
  mulsd  %xmm3,%xmm0
  comisd %xmm2,%xmm0
  jb     L826
  mulsd  %xmm3,%xmm0
  comisd %xmm2,%xmm0
  jb     L87
  mulsd  %xmm3,%xmm0
  comisd %xmm2,%xmm0
  jb     L340
  mulsd  %xmm3,%xmm0
  comisd %xmm2,%xmm0
  jb     L523
  mulsd  %xmm3,%xmm0
  xor    %eax,%eax
  mov    $0x160,%r15d
L849:
  movsd  %xmm0,0x28(%rsp)
L654:
  comisd D47(%rip),%xmm0
  movsd  D172(%rip),%xmm3
  jb     L31
  test   %al,%al
  jne    L232
  jmp    L31
  nopw   0x0(%rax,%rax,1)
L353:
  test   %al,%al
  je     L429
L232:
  mulsd  %xmm3,%xmm0
  add    $0x8,%r15d
  cmp    $0x15e,%r15d
  setle  %al
  comisd D47(%rip),%xmm0
  jae    L353
L429:
  movsd  %xmm0,0x28(%rsp)
L31:
  comisd D108(%rip),%xmm0
  jb     L14
  test   %al,%al
  je     L14
  movsd  D84(%rip),%xmm2
  jmp    L100
  xchg   %ax,%ax
L595:
  comisd D108(%rip),%xmm0
  jb     L581
L100:
  mulsd  %xmm2,%xmm0
  add    $0x1,%r15d
  cmp    $0x15e,%r15d
  jle    L595
L581:
  movsd  %xmm0,0x28(%rsp)
L14:
  comisd %xmm0,%xmm3
  movsd  D47(%rip),%xmm2
  jbe    L420
  nopl   0x0(%rax,%rax,1)
L800:
  mulsd  %xmm2,%xmm0
  sub    $0x8,%r15d
  comisd %xmm0,%xmm3
  ja     L800
  movsd  D164(%rip),%xmm2
  comisd %xmm0,%xmm2
  jbe    L349
L649:
  movsd  D108(%rip),%xmm3
  nopl   0x0(%rax)
L591:
  mulsd  %xmm3,%xmm0
  sub    $0x1,%r15d
  comisd %xmm0,%xmm2
  ja     L591
  movsd  %xmm0,0x28(%rsp)
L661:
  cmp    $0x15e,%r15d
  jg     L434
L349:
  addsd  %xmm1,%xmm0
  comisd D108(%rip),%xmm0
  movsd  %xmm0,0x28(%rsp)
  jae    L327
  mov    0xc(%rsp),%edx
  cmp    $0xfffffffc,%r15d
  setl   %al
  cmp    %edx,%r15d
  jg     L601
L364:
  test   %al,%al
  jne    L601
  sub    %r15d,%edx
  movl   $0x0,0x34(%rsp)
  mov    0x10(%rsp),%r13
  mov    %edx,0x18(%rsp)
  test   %bl,%bl
  jne    L700
L1:
  lea    0x1(%r13),%r14
  mov    %r14,%r12
  test   %r15d,%r15d
  jns    L738
  mov    0x18(%rsp),%ecx
  movb   $0x30,0x0(%r13)
  lea    0x1(%r15),%eax
  test   %ecx,%ecx
  jle    L618
  movb   $0x2e,0x1(%r13)
  lea    0x2(%r13),%r12
  test   %eax,%eax
  je     L304
L723:
  mov    0x18(%rsp),%eax
  mov    %r15d,%ebx
  mov    %r12,%r13
  not    %ebx
  add    %r12,%rbx
  lea    (%rax,%r12,1),%ebp
  nopw   0x0(%rax,%rax,1)
L840:
  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    %rbx,%r13
  jne    L840
  mov    %r15d,%eax
  movb   $0x1,0x20(%rsp)
  not    %eax
  add    %rax,%r12
  mov    0x18(%rsp),%eax
  lea    0x1(%r15,%rax,1),%eax
  test   %eax,%eax
  jle    L477
  lea    0x34(%rsp),%rbx
  lea    0x28(%rsp),%rbp
L850:
  mov    %r12,%r14
  mov    $0x1,%r13d
  nopl   (%rax)
L536:
  mov    %rbx,%rsi
  mov    %rbp,%rdi
  add    $0x1,%r14
  call   <getdigit@plt>
  mov    %al,-0x1(%r14)
  mov    %r13d,%eax
  sub    %r14d,%eax
  add    %r12d,%eax
  add    0xc(%rsp),%eax
  test   %eax,%eax
  jg     L536
  mov    0xc(%rsp),%ecx
  xor    %eax,%eax
  test   %ecx,%ecx
  cmovns %ecx,%eax
  add    $0x1,%eax
  cltq
  add    %rax,%r12
L477:
  mov    0x18(%rsp),%edx
  test   %edx,%edx
  jg     L270
  jmp    L185
  nopl   0x0(%rax)
L21:
  movb   $0x0,-0x1(%r12)
  sub    $0x1,%r12
L270:
  cmpb   $0x30,-0x1(%r12)
  je     L21
  xor    %edi,%edi
  cmp    %r12,0x10(%rsp)
  setb   %dil
  call   <assert@plt>
  cmpb   $0x2e,-0x1(%r12)
  jne    L185
  movb   $0x0,-0x1(%r12)
  sub    $0x1,%r12
L185:
  cmpb   $0x2,0x20(%rsp)
  je     L675
L704:
  movb   $0x0,(%r12)
  xor    %eax,%eax
  jmp    L508
  nopl   0x0(%rax,%rax,1)
L658:
  xor    %ebx,%ebx
  comisd %xmm0,%xmm3
  jbe    L664
  xorpd  D51(%rip),%xmm0
  mov    $0x2d,%ebx
  movsd  %xmm0,0x28(%rsp)
L664:
  movl   $0x13,0xc(%rsp)
L634:
  mov    0xc(%rsp),%eax
  movsd  D98(%rip),%xmm1
  movsd  D84(%rip),%xmm2
  nop
L527:
  mulsd  %xmm2,%xmm1
  sub    $0x1,%eax
  jne    L527
  jmp    L323
  xchg   %ax,%ax
L452:
  addsd  %xmm1,%xmm0
  comisd D108(%rip),%xmm0
  movsd  %xmm0,0x28(%rsp)
  jae    L502
  movl   $0x0,0x34(%rsp)
  test   %bl,%bl
  je     L586
  mov    0x10(%rsp),%rdx
  movb   $0x1,0x20(%rsp)
  xor    %eax,%eax
  xor    %r15d,%r15d
  movb   $0x2d,(%rdx)
  lea    0x1(%rdx),%r13
  lea    0x2(%rdx),%r14
L688:
  add    $0x1,%eax
  lea    0x34(%rsp),%rbx
  lea    0x28(%rsp),%rbp
  cltq
  add    %rax,%r13
  jmp    L214
  cs nopw 0x0(%rax,%rax,1)
L102:
  add    $0x1,%r14
L214:
  mov    %rbx,%rsi
  mov    %rbp,%rdi
  call   <getdigit@plt>
  mov    %al,-0x1(%r14)
  cmp    %r13,%r14
  jne    L102
  mov    0xc(%rsp),%eax
  test   %eax,%eax
  jg     L645
L83:
  mov    %r13,%r12
  jmp    L185
  nopl   0x0(%rax)
L421:
  mov    0x10(%rsp),%rdi
  lea    D133(%rip),%rsi
  call   <strcpy@plt>
  xor    %eax,%eax
L508:
  mov    0x38(%rsp),%rdx
  sub    %fs:0x28,%rdx
  jne    L338
  add    $0x48,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
  cs nopw 0x0(%rax,%rax,1)
L502:
  xor    %eax,%eax
  mov    $0x1,%r15d
L392:
  mulsd  D84(%rip),%xmm0
  mov    0xc(%rsp),%edx
  movsd  %xmm0,0x28(%rsp)
  cmp    %edx,%r15d
  jle    L364
L601:
  movl   $0x0,0x34(%rsp)
  test   %bl,%bl
  je     L244
  mov    0x10(%rsp),%rcx
  movb   $0x2,0x20(%rsp)
  xor    %eax,%eax
  movb   $0x2d,(%rcx)
  lea    0x1(%rcx),%r13
  lea    0x2(%rcx),%r14
  jmp    L688
L618:
  test   %eax,%eax
  jne    L723
  movb   $0x1,0x20(%rsp)
  mov    %r14,%r13
  jmp    L83
  nopl   0x0(%rax)
L675:
  movb   $0x65,(%r12)
  lea    0x2(%r12),%rsi
  mov    $0x2b,%eax
  test   %r15d,%r15d
  jns    L155
  neg    %r15d
  mov    $0x2d,%eax
L155:
  mov    %al,0x1(%r12)
  cmp    $0x63,%r15d
  jle    L354
  mov    %r15d,%eax
  lea    0x3(%r12),%rsi
  imul   $0x51eb851f,%rax,%rax
  shr    $0x25,%rax
  lea    0x30(%rax),%edi
  imul   $0x64,%eax,%eax
  mov    %dil,0x2(%r12)
  sub    %eax,%r15d
L354:
  mov    $0xcccccccd,%ecx
  mov    %r15d,%eax
  lea    0x2(%rsi),%r12
  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    L704
  xchg   %ax,%ax
L434:
  cmp    $0x2d,%bl
  je     L222
  mov    0x10(%rsp),%rdi
  lea    D130(%rip),%rsi
  call   <strcpy@plt>
  xor    %eax,%eax
  jmp    L508
  nopl   0x0(%rax)
L244:
  mov    0x10(%rsp),%rdx
  movb   $0x2,0x20(%rsp)
  xor    %eax,%eax
  mov    %rdx,%r13
  lea    0x1(%rdx),%r14
  jmp    L688
L327:
  add    $0x1,%r15d
  cmp    $0xfffffffc,%r15d
  setl   %al
  jmp    L392
L8:
  mov    $0x1,%eax
  xor    %r15d,%r15d
  jmp    L654
L616:
  mov    $0x1,%eax
  mov    $0x20,%r15d
  jmp    L849
L586:
  mov    0x10(%rsp),%rcx
  movb   $0x1,0x20(%rsp)
  xor    %eax,%eax
  xor    %r15d,%r15d
  mov    %rcx,%r13
  lea    0x1(%rcx),%r14
  jmp    L688
L222:
  mov    0x10(%rsp),%rdi
  lea    D185(%rip),%rsi
  call   <strcpy@plt>
  xor    %eax,%eax
  jmp    L508
L420:
  movsd  D164(%rip),%xmm2
  comisd %xmm0,%xmm2
  ja     L649
  jmp    L661
L700:
  mov    %r13,%rax
  lea    0x1(%r13),%r13
  movb   $0x2d,(%rax)
  jmp    L1
L107:
  mov    $0x1,%eax
  mov    $0xa0,%r15d
  jmp    L849
L85:
  mov    $0x1,%eax
  mov    $0x40,%r15d
  jmp    L849
L645:
  movb   $0x2e,(%r14)
  lea    0x1(%r14),%r12
L589:
  mov    0xc(%rsp),%eax
  mov    %eax,0x18(%rsp)
  sub    $0x1,%eax
  mov    %eax,0xc(%rsp)
  jmp    L850
L317:
  mov    $0x1,%eax
  mov    $0x60,%r15d
  jmp    L849
L367:
  mov    $0x1,%eax
  mov    $0x80,%r15d
  jmp    L849
L129:
  mov    %esi,%eax
  sub    $0xb,%eax
  mov    %eax,0xc(%rsp)
  je     L323
  jmp    L634
  cs nopw 0x0(%rax,%rax,1)
L4:
  mov    $0x1,%eax
  mov    $0xc0,%r15d
  jmp    L849
L826:
  mov    $0x1,%eax
  mov    $0xe0,%r15d
  jmp    L849
L87:
  mov    $0x1,%eax
  mov    $0x100,%r15d
  jmp    L849
L340:
  mov    $0x1,%eax
  mov    $0x120,%r15d
  jmp    L849
L523:
  mov    $0x1,%eax
  mov    $0x140,%r15d
  jmp    L849
L535:
  mov    $0xffffffff,%eax
  jmp    L508
L338:
  call   <__stack_chk_fail@plt>
L304:
  mov    0x18(%rsp),%eax
  movb   $0x1,0x20(%rsp)
  or     $0xffffffff,%r15d
  lea    0x34(%rsp),%rbx
  lea    0x28(%rsp),%rbp
  mov    %eax,0xc(%rsp)
  jmp    L589
L738:
  mov    0x18(%rsp),%ecx
  movb   $0x1,0x20(%rsp)
  mov    %r15d,%eax
  mov    %ecx,0xc(%rsp)
  jmp    L688
```

tool_calls: name: unpack_data
arguments: data_label: D51
data_type: f32[4]
name: unpack_data
arguments: data_label: D98
data_type: f64
name: unpack_data
arguments: data_label: D17
data_type: f64
name: unpack_data
arguments: data_label: D85
data_type: byte[8]
name: unpack_data
arguments: data_label: D47
data_type: f64[2]
name: unpack_data
arguments: data_label: D172
data_type: byte[8]
name: unpack_data
arguments: data_label: D108
data_type: f64[2]
name: unpack_data
arguments: data_label: D84
data_type: f64
name: unpack_data
arguments: data_label: D164
data_type: f64
name: unpack_data
arguments: data_label: D133
data_type: string
name: unpack_data
arguments: data_label: D130
data_type: string
name: unpack_data
arguments: data_label: D185
data_type: string

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

tool: D98: 0.5

tool: D17: 1e+32

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

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

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

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

tool: D84: 0.1

tool: D164: 1

tool: D133: NaN

tool: D130: Inf

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