user: 提供的汇编代码用C语言表示会是什么样子：

```asm
<Interpolate>:
  endbr64
  push   %r15
  push   %r14
  push   %r13
  push   %r12
  push   %rbp
  push   %rbx
  sub    $0x28,%rsp
  mov    %rdi,%r12
  mov    %esi,%ebp
  mov    %rcx,%r14
  mov    0x80(%rsp),%r15d
  cmp    $0x1,%r15d
  je     L216
  cmpl   $0x1,0x88(%rsp)
  jne    L3
L216:
  cmp    $0x1,%ebp
  je     L202
  cmp    $0x1,%edx
  je     L202
L3:
  lea    D19(%rip),%rdi
  call   <DymosimError@plt>
L92:
  add    $0x28,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
L202:
  cmp    $0x1,%r15d
  cmovle 0x88(%rsp),%r15d
  cmp    $0x1,%ebp
  jle    L265
  cmp    %ebp,%r15d
  jne    L158
L166:
  mov    %r12,%rax
  lea    -0x1(%rbp),%edx
  lea    0x8(%r12,%rdx,8),%rsi
  mov    $0x1,%ebx
  mov    $0x0,%ecx
  movsd  D26(%rip),%xmm4
  movsd  D25(%rip),%xmm3
  movsd  D11(%rip),%xmm5
  jmp    L175
L265:
  cmp    %edx,%r15d
  jne    L158
  mov    %edx,%ebp
  mov    $0x1,%ebx
  mov    $0x0,%ecx
  test   %edx,%edx
  jg     L166
L165:
  imul   %r9d,%r8d
  mov    %r8d,%r13d
  cmp    %ecx,%r8d
  jne    L182
  mov    0x70(%rsp),%eax
  imul   0x68(%rsp),%eax
  cmp    %ebx,%eax
  jne    L90
  cmp    $0x1,%ebp
  jle    L180
  mov    0x78(%rsp),%rax
  movsd  (%rax),%xmm0
  movsd  (%r14),%xmm1
  comisd %xmm0,%xmm1
  jae    L122
  cvttsd2si (%r12),%esi
  movslq %esi,%rax
  lea    0x0(,%rax,8),%rcx
  comisd -0x8(%r14,%rax,8),%xmm0
  jb     L193
  add    %r14,%rcx
  sub    $0x1,%ebp
  lea    0x8(%r12),%rdi
  push   $0x1
  sub    $0x1,%r15d
  push   %r15
  mov    0x88(%rsp),%rax
  add    $0x8,%rax
  push   %rax
  push   $0x1
  mov    %ebx,%eax
  cltd
  idiv   %esi
  push   %rax
  lea    -0x1(%rsi),%eax
  imul   %ebx,%eax
  cltd
  idiv   %esi
  cltq
  mov    0x88(%rsp),%rbx
  lea    (%rbx,%rax,8),%rax
  push   %rax
  mov    $0x1,%r9d
  sub    %esi,%r8d
  mov    $0x1,%edx
  mov    %ebp,%esi
  call   <Interpolate>
  add    $0x30,%rsp
  jmp    L92
L158:
  lea    D52(%rip),%rdi
  call   <DymosimError@plt>
  jmp    L92
L56:
  ucomisd %xmm1,%xmm0
  jp     L149
  jne    L149
  cvttsd2si %xmm0,%edx
  add    %edx,%ecx
  imul   %edx,%ebx
  add    $0x8,%rax
  cmp    %rsi,%rax
  je     L165
L175:
  movsd  (%rax),%xmm0
  movapd %xmm0,%xmm1
  movapd %xmm0,%xmm2
  andpd  %xmm3,%xmm2
  ucomisd %xmm2,%xmm4
  jbe    L56
  cvttsd2si %xmm0,%rdx
  pxor   %xmm2,%xmm2
  cvtsi2sd %rdx,%xmm2
  movapd %xmm2,%xmm1
  cmpnlesd %xmm0,%xmm1
  andpd  %xmm5,%xmm1
  subsd  %xmm1,%xmm2
  movapd %xmm3,%xmm1
  andnpd %xmm0,%xmm1
  orpd   %xmm2,%xmm1
  jmp    L56
L149:
  lea    D60(%rip),%rdi
  call   <DymosimError@plt>
  jmp    L92
L182:
  lea    D44(%rip),%rdi
  call   <DymosimError@plt>
  jmp    L92
L90:
  lea    D35(%rip),%rdi
  call   <DymosimError@plt>
  jmp    L92
L180:
  mov    $0x1,%r9d
  mov    %ebx,%r8d
  mov    0x60(%rsp),%rcx
  mov    $0x1,%edx
  mov    %r13d,%esi
  mov    %r14,%rdi
  mov    0x78(%rsp),%rax
  movsd  (%rax),%xmm0
  call   <Interpolate1@plt>
  jmp    L92
L122:
  cvttsd2si (%r12),%ecx
  movslq %ecx,%rax
  lea    (%r14,%rax,8),%r10
  lea    -0x1(%rbp),%esi
  lea    0x8(%r12),%rdi
  push   $0x1
  sub    $0x1,%r15d
  push   %r15
  mov    0x88(%rsp),%rax
  add    $0x8,%rax
  push   %rax
  push   $0x1
  mov    %ebx,%eax
  cltd
  idiv   %ecx
  push   %rax
  push   0x88(%rsp)
  mov    $0x1,%r9d
  sub    %ecx,%r8d
  mov    %r10,%rcx
  mov    $0x1,%edx
  call   <Interpolate>
  add    $0x30,%rsp
  jmp    L92
L193:
  mov    %r14,%rdi
  call   <SearchGrid@plt>
  lea    -0x1(%r15),%edx
  mov    0x78(%rsp),%rdi
  lea    0x8(%rdi),%r15
  cvttsd2si (%r12),%ecx
  mov    %eax,0x14(%rsp)
  mov    %eax,%edi
  imul   %ebx,%edi
  lea    -0x1(%rbp),%r11d
  lea    0x8(%r12),%rbp
  movslq %ecx,%rax
  lea    (%r14,%rax,8),%rsi
  push   $0x1
  mov    %edx,0x10(%rsp)
  push   %rdx
  push   %r15
  push   $0x1
  mov    %ebx,%eax
  cltd
  idiv   %ecx
  push   %rax
  mov    %edi,0x34(%rsp)
  mov    %edi,%eax
  cltd
  idiv   %ecx
  cltq
  mov    0x88(%rsp),%r10
  lea    (%r10,%rax,8),%rax
  push   %rax
  mov    $0x1,%r9d
  mov    %r13d,%r8d
  sub    %ecx,%r8d
  mov    %rsi,%rcx
  mov    $0x1,%edx
  mov    %r11d,0x40(%rsp)
  mov    %r11d,%esi
  mov    %rbp,%rdi
  call   <Interpolate>
  movsd  %xmm0,0x48(%rsp)
  cvttsd2si (%r12),%ecx
  add    $0x30,%rsp
  movslq %ecx,%rax
  lea    (%r14,%rax,8),%rsi
  push   $0x1
  mov    0x10(%rsp),%edx
  push   %rdx
  push   %r15
  push   $0x1
  mov    %ebx,%eax
  cltd
  idiv   %ecx
  push   %rax
  mov    0x34(%rsp),%edx
  lea    (%rdx,%rbx,1),%eax
  cltd
  idiv   %ecx
  cltq
  mov    0x88(%rsp),%rbx
  lea    (%rbx,%rax,8),%rax
  push   %rax
  mov    $0x1,%r9d
  mov    %r13d,%r8d
  sub    %ecx,%r8d
  mov    %rsi,%rcx
  mov    $0x1,%edx
  mov    0x40(%rsp),%esi
  mov    %rbp,%rdi
  call   <Interpolate>
  movslq 0x44(%rsp),%rax
  movsd  (%r14,%rax,8),%xmm2
  mov    0xa8(%rsp),%rbx
  movsd  (%rbx),%xmm1
  subsd  %xmm2,%xmm1
  movsd  0x48(%rsp),%xmm6
  subsd  %xmm6,%xmm0
  mulsd  %xmm1,%xmm0
  movsd  0x8(%r14,%rax,8),%xmm1
  subsd  %xmm2,%xmm1
  divsd  %xmm1,%xmm0
  addsd  %xmm6,%xmm0
  add    $0x30,%rsp
  jmp    L92
```

tool_calls: name: retrieve_data
arguments: data_tag: D19
data_type: string
name: retrieve_data
arguments: data_tag: D26
data_type: byte[8]
name: retrieve_data
arguments: data_tag: D25
data_type: byte[8]
name: retrieve_data
arguments: data_tag: D11
data_type: byte[8]
name: retrieve_data
arguments: data_tag: D52
data_type: string
name: retrieve_data
arguments: data_tag: D60
data_type: string
name: retrieve_data
arguments: data_tag: D44
data_type: string
name: retrieve_data
arguments: data_tag: D35
data_type: string

tool: D19: Arguments to Interpolate must be vectors.

tool: {"D26": [0x00,0x00,0x00,0x00,0x00,0x00,0x30,0x43]}

tool: {"D25": [0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x7f]}

tool: {"D11": [0x00,0x00,0x00,0x00,0x00,0x00,0xf0,0x3f]}

tool: D52: The size of the argument vector is not the same as
  the dimension vector of a table.

tool: D60: The dimension vector of a table must only contain integers.

tool: D44: The size of the grid vector is not consistent with
  information in the dimension vector of a table.

tool: D35: The size of the table value vector is not
  consistent with information in the dimension vector.

assistant: ```c
double Interpolate(const double dim[], int Mdim, int Ndim, const double xval[], int Mxval, int Nxval, const double yval[], int Myval, int Nyval, const double x[], int Mx, int Nx) {
  int below;
  double ybelow, yabove;
  int i, dimsum, dimprod;
  int Kx, Kdim, Kxval, Kyval;
  if ((Mx != 1 && Nx != 1) || (Mdim != 1 && Ndim != 1)) {
    return DymosimError("Arguments to Interpolate must be vectors.");
  }
  Kx = Mx > 1 ? Mx : Nx;
  Kdim = Mdim > 1 ? Mdim : Ndim;
  Kxval = Mxval * Nxval;
  Kyval = Myval * Nyval;
  if (Kx != Kdim) {
    return DymosimError("The size of the argument vector is not the same as\n"
                        "  the dimension vector of a table.");
  }
  dimsum = 0;
  dimprod = 1;
  for (i = 0; i < Kdim; i++) {
    if (dim[i] != floor(dim[i])) {
      return DymosimError("The dimension vector of a table must only contain "
                          "integers.");
    }
    dimsum = dimsum + (int)dim[i];
    dimprod = dimprod * (int)dim[i];
  }
  if (Kxval != dimsum) {
    return DymosimError("The size of the grid vector is not consistent with\n"
                        "  information in the dimension vector of a table.");
  }
  if (Kyval != dimprod) {
    return DymosimError("The size of the table value vector is not\n"
                        "  consistent with information in the dimension vector.");
  }
  if (Kdim <= 1)
    return Interpolate1(x[0], xval, Kxval, 1, yval, Kyval, 1);
  else if (x[0] <= xval[0]) {
    below = 0;
    return Interpolate(&dim[1], Kdim - 1, 1, &xval[(int)dim[0]], Kxval - (int)dim[0], 1, &yval[below * dimprod / (int)dim[0]], Kyval / (int)dim[0], 1, &x[1], Kx - 1, 1);
  } else if (x[0] >= xval[(int)dim[0] - 1]) {
    below = (int)dim[0] - 1;
    return Interpolate(&dim[1], Kdim - 1, 1, &xval[(int)dim[0]], Kxval - (int)dim[0], 1, &yval[below * dimprod / (int)dim[0]], Kyval / (int)dim[0], 1, &x[1], Kx - 1, 1);
  } else {
    below = SearchGrid(x[0], xval, (int)dim[0]);
    ybelow = Interpolate(&dim[1], Kdim - 1, 1, &xval[(int)dim[0]], Kxval - (int)dim[0], 1, &yval[below * dimprod / (int)dim[0]], Kyval / (int)dim[0], 1, &x[1], Kx - 1, 1);
    yabove = Interpolate(&dim[1], Kdim - 1, 1, &xval[(int)dim[0]], Kxval - (int)dim[0], 1, &yval[(below + 1) * dimprod / (int)dim[0]], Kyval / (int)dim[0], 1, &x[1], Kx - 1, 1);
    return (ybelow + (yabove - ybelow) * (x[0] - xval[below]) / (xval[below + 1] - xval[below]));
  }
}
```