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

```asm
<mk_sec5and7>:
  endbr64
  push   %r15
  push   %r14
  push   %r13
  push   %r12
  push   %rbp
  push   %rbx
  sub    $0x48,%rsp
  mov    %rdi,%r15
  mov    %esi,%r12d
  mov    %rdx,0x10(%rsp)
  mov    %rcx,%rbx
  mov    %r9d,0x18(%rsp)
  mov    %fs:0x28,%rax
  mov    %rax,0x38(%rsp)
  xor    %eax,%eax
  test   %esi,%esi
  jne    L146
  movl   $0x0,0x30(%rsp)
  pxor   %xmm4,%xmm4
  movsd  %xmm4,0x8(%rsp)
  pxor   %xmm5,%xmm5
  movss  %xmm5,0x1c(%rsp)
L137:
  mov    0x30(%rsp),%ecx
  mov    %r12d,%eax
  and    $0x7,%eax
  imul   %ecx,%eax
  add    $0x7,%eax
  shr    $0x3,%eax
  mov    %r12d,%edx
  shr    $0x3,%edx
  imul   %ecx,%edx
  lea    0x5(%rax,%rdx,1),%ebp
  mov    %ebp,%edi
  call   <malloc@plt>
  mov    %rax,%r14
  mov    %rax,(%rbx)
  test   %rax,%rax
  je     L118
L63:
  mov    %r14,%rsi
  mov    %ebp,%edi
  call   <uint_char@plt>
  movb   $0x7,0x4(%r14)
  test   %r12d,%r12d
  jne    L90
L182:
  mov    0x30(%rsp),%eax
  test   %eax,%eax
  jne    L46
  pxor   %xmm6,%xmm6
  cvtss2sd 0x1c(%rsp),%xmm6
  movsd  %xmm6,0x8(%rsp)
  mov    %eax,0x80(%rsp)
  mov    %eax,0x18(%rsp)
L46:
  mov    $0x15,%edi
  call   <malloc@plt>
  mov    %rax,%rbx
  mov    0x10(%rsp),%rax
  mov    %rbx,(%rax)
  test   %rbx,%rbx
  je     L50
L19:
  mov    %rbx,%rsi
  mov    $0x15,%edi
  call   <uint_char@plt>
  movb   $0x5,0x4(%rbx)
  lea    0x5(%rbx),%rsi
  mov    %r12d,%edi
  call   <uint_char@plt>
  lea    0x9(%rbx),%rsi
  mov    $0x0,%edi
  call   <uint2_char@plt>
  lea    0xb(%rbx),%rdi
  movsd  0x8(%rsp),%xmm0
  call   <flt2ieee@plt>
  lea    0xf(%rbx),%rsi
  mov    0x80(%rsp),%edi
  call   <int2_char@plt>
  lea    0x11(%rbx),%rsi
  mov    0x18(%rsp),%edi
  neg    %edi
  call   <int2_char@plt>
  mov    0x30(%rsp),%eax
  mov    %al,0x13(%rbx)
  movb   $0x0,0x14(%rbx)
  mov    0x38(%rsp),%rax
  sub    %fs:0x28,%rax
  jne    L170
  mov    $0x0,%eax
  add    $0x48,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
L146:
  mov    %r8d,%ebp
  lea    0x2c(%rsp),%rcx
  lea    0x28(%rsp),%rdx
  call   <min_max_array_all_defined@plt>
  movss  0x28(%rsp),%xmm7
  movss  %xmm7,0x1c(%rsp)
  test   %ebp,%ebp
  jne    L178
  pxor   %xmm6,%xmm6
  cvtss2sd %xmm7,%xmm6
  movsd  %xmm6,0x8(%rsp)
  pxor   %xmm0,%xmm0
  cvtss2sd 0x2c(%rsp),%xmm0
  subsd  %xmm6,%xmm0
  ucomisd D30(%rip),%xmm0
  jp     L174
  jne    L174
  movl   $0x0,0x30(%rsp)
  mov    %ebp,0x18(%rsp)
L237:
  mov    %r15,%rax
  lea    -0x1(%r12),%edx
  lea    0x4(%r15,%rdx,4),%rdx
L48:
  pxor   %xmm0,%xmm0
  cvtss2sd (%rax),%xmm0
  subsd  0x8(%rsp),%xmm0
  cvtsd2ss %xmm0,%xmm0
  movss  %xmm0,(%rax)
  add    $0x4,%rax
  cmp    %rdx,%rax
  jne    L48
  movl   $0x0,0x80(%rsp)
  jmp    L137
L174:
  lea    0x34(%rsp),%r13
  mov    %r13,%rdi
  call   <frexp@plt>
  mov    0x34(%rsp),%eax
  mov    %eax,%ecx
  sub    0x88(%rsp),%ecx
  mov    %ecx,0x80(%rsp)
  mov    0x88(%rsp),%ecx
  mov    %ecx,0x30(%rsp)
  mov    %ecx,%edi
  sub    %eax,%edi
  movsd  D48(%rip),%xmm0
  call   <ldexp@plt>
  movapd %xmm0,%xmm1
  pxor   %xmm0,%xmm0
  cvtss2sd 0x2c(%rsp),%xmm0
  subsd  0x8(%rsp),%xmm0
  mulsd  %xmm1,%xmm0
  addsd  D20(%rip),%xmm0
  cvtsd2ss %xmm0,%xmm0
  call   <floor@plt>
  mov    %r13,%rdi
  call   <frexp@plt>
  mov    %ebp,0x18(%rsp)
  mov    0x30(%rsp),%eax
  cmp    %eax,0x34(%rsp)
  je     L8
  addl   $0x1,0x80(%rsp)
  jmp    L8
L178:
  cmpl   $0x0,0x18(%rsp)
  jne    L234
L158:
  mov    0x80(%rsp),%edi
  neg    %edi
  movsd  D48(%rip),%xmm0
  call   <ldexp@plt>
  movapd %xmm0,%xmm1
  pxor   %xmm4,%xmm4
  cvtss2sd 0x28(%rsp),%xmm4
  movsd  %xmm4,0x8(%rsp)
  pxor   %xmm0,%xmm0
  cvtss2sd 0x2c(%rsp),%xmm0
  subsd  %xmm4,%xmm0
  mulsd  %xmm1,%xmm0
  addsd  D20(%rip),%xmm0
  cvtsd2ss %xmm0,%xmm0
  call   <floor@plt>
  lea    0x30(%rsp),%rdi
  call   <frexp@plt>
  mov    0x30(%rsp),%eax
  cmp    0x90(%rsp),%eax
  jle    L8
  sub    0x90(%rsp),%eax
  add    %eax,0x80(%rsp)
  mov    0x90(%rsp),%eax
  mov    %eax,0x30(%rsp)
L8:
  cmpl   $0x0,0x80(%rsp)
  je     L237
  mov    0x80(%rsp),%edi
  neg    %edi
  movsd  D48(%rip),%xmm0
  call   <ldexp@plt>
  mov    %r15,%rax
  lea    -0x1(%r12),%edx
  lea    0x4(%r15,%rdx,4),%rdx
L135:
  pxor   %xmm1,%xmm1
  cvtss2sd (%rax),%xmm1
  subsd  0x8(%rsp),%xmm1
  mulsd  %xmm0,%xmm1
  cvtsd2ss %xmm1,%xmm1
  movss  %xmm1,(%rax)
  add    $0x4,%rax
  cmp    %rdx,%rax
  jne    L135
  jmp    L137
L234:
  mov    0x18(%rsp),%edi
  neg    %edi
  movsd  D50(%rip),%xmm0
  call   <Int_Power@plt>
  pxor   %xmm1,%xmm1
  cvtss2sd 0x28(%rsp),%xmm1
  mulsd  %xmm0,%xmm1
  cvtsd2ss %xmm1,%xmm1
  movss  %xmm1,0x28(%rsp)
  pxor   %xmm1,%xmm1
  cvtss2sd 0x2c(%rsp),%xmm1
  mulsd  %xmm0,%xmm1
  cvtsd2ss %xmm1,%xmm1
  movss  %xmm1,0x2c(%rsp)
  mov    %r15,%rax
  lea    -0x1(%r12),%edx
  lea    0x4(%r15,%rdx,4),%rdx
L218:
  pxor   %xmm1,%xmm1
  cvtss2sd (%rax),%xmm1
  mulsd  %xmm0,%xmm1
  cvtsd2ss %xmm1,%xmm1
  movss  %xmm1,(%rax)
  add    $0x4,%rax
  cmp    %rdx,%rax
  jne    L218
  jmp    L158
L118:
  lea    D28(%rip),%rsi
  lea    D17(%rip),%rdi
  call   <fatal_error@plt>
  jmp    L63
L90:
  mov    $0x0,%eax
  call   <omp_get_num_threads@plt>
  mov    %eax,%ecx
  lea    -0x1(%rax,%r12,1),%eax
  mov    $0x0,%edx
  div    %ecx
  lea    0x7(%rax),%ebp
  and    $0xfffffff8,%ebp
  mov    %r12d,%r13d
  mov    $0x0,%ebx
L76:
  mov    0x30(%rsp),%ecx
  cmp    %ebp,%r13d
  mov    %ebp,%edx
  cmovbe %r13d,%edx
  mov    %ebx,%eax
  shr    $0x3,%eax
  imul   %ecx,%eax
  lea    0x5(%r14,%rax,1),%rsi
  mov    %ebx,%eax
  lea    (%r15,%rax,4),%rdi
  call   <flist2bitstream@plt>
  add    %ebp,%ebx
  sub    %ebp,%r13d
  cmp    %ebx,%r12d
  ja     L76
  jmp    L182
L50:
  lea    D28(%rip),%rsi
  lea    D17(%rip),%rdi
  call   <fatal_error@plt>
  jmp    L19
L170:
  call   <__stack_chk_fail@plt>
```

tool_calls: name: unpack_data
arguments: label: D30
datatype: f64
name: unpack_data
arguments: label: D48
datatype: f64
name: unpack_data
arguments: label: D20
datatype: f64
name: unpack_data
arguments: label: D50
datatype: f64
name: unpack_data
arguments: label: D28
datatype: f64
name: unpack_data
arguments: label: D17
datatype: string

tool: D30: 0

tool: D48: 1

tool: D20: 0.5

tool: D50: 10

tool: D28: 0

tool: D17: mk_sec5and7: memory allocation

assistant: ```c
int mk_sec5and7(float *data, unsigned int n, unsigned char **sec5, unsigned char **sec7, int use_scale, int dec_scale, int bin_scale, int wanted_bits, int max_bits) {
  float min_val, max_val, ncep_min_val;
  int nbits, binary_scale, j;
  double ref, frange, scale, dec_factor;
  size_t sec5_size, sec7_size;
  unsigned char *p;
  unsigned int i, k, di;
  int nthreads;
  binary_scale = bin_scale;
  if (n == 0) {
    nbits = 0;
    ref = ncep_min_val = 0.0;
  } else {
    min_max_array_all_defined(data, n, &min_val, &max_val);
    ncep_min_val = min_val;
    if (use_scale == 0) {
      ref = min_val;
      frange = max_val - ref;
      dec_scale = 0;
      if (frange != 0.0) {
        frexp(frange, &j);
        binary_scale = j - wanted_bits;
        nbits = wanted_bits;
        scale = ldexp(1.0, -binary_scale);
        frange = floor((max_val - ref) * scale + 0.5);
        frexp(frange, &j);
        if (j != nbits)
          binary_scale++;
      } else {
        binary_scale = nbits = 0;
        scale = 1;
      }
    } else {
      if (dec_scale) {
        dec_factor = Int_Power(10.0, -dec_scale);
        min_val *= dec_factor;
        max_val *= dec_factor;
#pragma omp parallel for
        for (i = 0; i < n; i++) {
          data[i] *= dec_factor;
        }
      }
      scale = ldexp(1.0, -binary_scale);
      ref = min_val;
      frange = floor((max_val - ref) * scale + 0.5);
      frexp(frange, &nbits);
      if (nbits > max_bits) {
        binary_scale += (nbits - max_bits);
        nbits = max_bits;
      }
    }
    if (binary_scale) {
      scale = ldexp(1.0, -binary_scale);
#pragma omp parallel for
      for (i = 0; i < n; i++) {
        data[i] = (data[i] - ref) * scale;
      }
    } else {
#pragma omp parallel for
      for (i = 0; i < n; i++) {
        data[i] = data[i] - ref;
      }
    }
  }
  sec5_size = 21;
  sec7_size = 5 + (nbits * (n / 8)) + (nbits * (n % 8) + 7) / 8;
  *sec7 = p = (unsigned char *)malloc(sec7_size);
  if (p == NULL)
    fatal_error("mk_sec5and7: memory allocation", "");
  uint_char(sec7_size, p);
  p[4] = 7;
  if (n != 0) {
#pragma omp parallel private(i, k)
    {
#pragma omp single
      {
        nthreads = omp_get_num_threads();
        di = (n + nthreads - 1) / nthreads;
        di = ((di + 7) | 7) ^ 7;
      }
#pragma omp for
      for (i = 0; i < n; i += di) {
        k = n - i;
        if (k > di)
          k = di;
        flist2bitstream(data + i, p + 5 + (i / 8) * nbits, k, nbits);
      }
    }
  }
  if (nbits == 0) {
    dec_scale = binary_scale = 0;
    ref = ncep_min_val;
  }
  *sec5 = p = (unsigned char *)malloc(sec5_size);
  if (p == NULL)
    fatal_error("mk_sec5and7: memory allocation", "");
  uint_char(sec5_size, p);
  p[4] = 5;
  uint_char(n, p + 5);
  uint2_char(0, p + 9);
  flt2ieee(ref, p + 11);
  int2_char(binary_scale, p + 15);
  int2_char(-dec_scale, p + 17);
  p[19] = nbits;
  p[20] = 0;
  return 0;
}
```