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

```asm
<construct_array_with_main_lobe>:
  endbr64
  push   %rbp
  mov    %rsp,%rbp
  push   %r14
  mov    %rsi,%r14
  push   %r13
  mov    %rdi,%r13
  push   %r12
  mov    %rdx,%r12
  push   %rbx
  sub    $0x20,%rsp
  mov    %fs:0x28,%rax
  mov    %rax,-0x28(%rbp)
  xor    %eax,%eax
  movslq (%rsi),%rax
  mov    %rsp,%rcx
  mov    %rax,%rsi
  lea    0xf(,%rax,8),%rax
  mov    %rax,%rdx
  and    $0xfffffffffffff000,%rax
  sub    %rax,%rcx
  and    $0xfffffffffffffff0,%rdx
  cmp    %rcx,%rsp
  je     L130
L154:
  sub    $0x1000,%rsp
  orq    $0x0,0xff8(%rsp)
  cmp    %rcx,%rsp
  jne    L154
L130:
  and    $0xfff,%edx
  sub    %rdx,%rsp
  test   %rdx,%rdx
  jne    L55
L75:
  lea    -0x30(%rbp),%rcx
  lea    -0x34(%rbp),%rdx
  mov    %r13,%rdi
  mov    %rsp,%rbx
  mov    $0x1,%r8d
  call   <amplitudeloc@plt>
  movslq (%r14),%rdx
  mov    -0x34(%rbp),%ecx
  xor    %eax,%eax
  movsd  -0x30(%rbp),%xmm3
  mov    %rdx,%rdi
  test   %edx,%edx
  jle    L97
  nopl   (%rax)
L84:
  movsd  0x0(%r13,%rax,8),%xmm0
  divsd  %xmm3,%xmm0
  movsd  %xmm0,(%rbx,%rax,8)
  add    $0x1,%rax
  cmp    %rax,%rdx
  jne    L84
L97:
  lea    -0x1(%rdi),%esi
  xor    %edx,%edx
  test   %ecx,%ecx
  jne    L145
L14:
  cmp    %esi,%edx
  jge    L76
  movq   D23(%rip),%xmm2
  movsd  D42(%rip),%xmm1
  movslq %edx,%rax
  jmp    L85
  nopw   0x0(%rax,%rax,1)
L70:
  add    $0x1,%rax
  cmp    %eax,%esi
  jle    L76
L85:
  movsd  (%rbx,%rax,8),%xmm0
  andpd  %xmm2,%xmm0
  comisd %xmm0,%xmm1
  jbe    L70
  mov    %eax,%esi
L76:
  movslq %edi,%rdx
  xor    %eax,%eax
  test   %edi,%edi
  jle    L134
  movapd %xmm3,%xmm5
  movsd  D42(%rip),%xmm4
  andpd  D23(%rip),%xmm5
  movsd  D31(%rip),%xmm2
  jmp    L193
L207:
  movapd %xmm3,%xmm0
  movsd  (%rbx,%rax,8),%xmm1
  divsd  %xmm5,%xmm0
  subsd  %xmm4,%xmm1
  mulsd  %xmm1,%xmm0
  divsd  %xmm2,%xmm0
  movsd  %xmm0,(%r12,%rax,8)
  add    $0x1,%rax
  cmp    %rax,%rdx
  je     L134
L193:
  cmp    %eax,%ecx
  jge    L174
  cmp    %eax,%esi
  jg     L207
L174:
  pxor   %xmm0,%xmm0
  movsd  %xmm0,(%r12,%rax,8)
  add    $0x1,%rax
  cmp    %rax,%rdx
  jne    L193
L134:
  mov    -0x28(%rbp),%rax
  sub    %fs:0x28,%rax
  jne    L109
  lea    -0x20(%rbp),%rsp
  xor    %eax,%eax
  pop    %rbx
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %rbp
  ret
  nopl   0x0(%rax)
L145:
  lea    -0x1(%rcx),%edx
  test   %edx,%edx
  jle    L183
  movq   D23(%rip),%xmm2
  movsd  D42(%rip),%xmm1
  movslq %edx,%rax
  nopw   0x0(%rax,%rax,1)
L71:
  movsd  (%rbx,%rax,8),%xmm0
  mov    %eax,%ecx
  andpd  %xmm2,%xmm0
  comisd %xmm0,%xmm1
  ja     L14
  sub    $0x1,%rax
  test   %eax,%eax
  jg     L71
L183:
  xor    %ecx,%ecx
  jmp    L14
  nopl   0x0(%rax)
L55:
  orq    $0x0,-0x8(%rsp,%rdx,1)
  jmp    L75
L109:
  call   <__stack_chk_fail@plt>
```

tool_calls: name: parse_data
arguments: tag: D23
type: qword[2]
name: parse_data
arguments: tag: D42
type: f64
name: parse_data
arguments: tag: D31
type: byte[8]

tool: {"D23": [0x7fffffffffffffff,0x0000000000000000]}

tool: D42: 0.1

tool: {"D31": [0xcd,0xcc,0xcc,0xcc,0xcc,0xcc,0xec,0x3f]}

assistant: ```c
int construct_array_with_main_lobe(double *array_in, int *npts_in, double *array_out) {
  int amplitudeloc(double *array, int len, int *max_amp_loc, double *amplitude, int flag);
  int npts_peak_min, npts_peak_max, npts_peak;
  double peak_max, peak_min, value_peak;
  int count, flag;
  double cut_min = 0.1;
  double cut_max = 1.0;
  double array_tmp[*npts_in];
  amplitudeloc(array_in, *npts_in, &npts_peak_max, &peak_max, 1);
  if (value_peak == 0)
    value_peak = 1;
  npts_peak = npts_peak_max;
  value_peak = peak_max;
  for (count = 0; count < *npts_in; count++) {
    array_tmp[count] = array_in[count] / value_peak;
  }
  if (npts_peak == 0)
    npts_peak = 1;
  int ONSET = 0;
  int ENDSET = *npts_in - 1;
  for (count = npts_peak - 1; count > 0; count--) {
    if (fabs(array_tmp[count]) < cut_min) {
      ONSET = count;
      break;
    }
  }
  for (count = npts_peak - 1; count < *npts_in - 1; count++) {
    if (fabs(array_tmp[count]) < cut_min) {
      ENDSET = count;
      break;
    }
  }
  for (count = 0; count < *npts_in; count++) {
    if (count <= ONSET || count >= ENDSET)
      array_out[count] = 0;
    else {
      array_out[count] = value_peak / fabs(value_peak) * (array_tmp[count] - cut_min) / (1 - cut_min);
    }
  }
  return 0;
}
```