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

```asm
<bark_noise_hybridmp>:
  endbr64
  push   %rbp
  mov    %rsi,%r11
  movaps %xmm0,%xmm7
  mov    %rsp,%rbp
  push   %r15
  push   %r14
  push   %r13
  push   %r12
  movslq %edi,%r12
  push   %rbx
  mov    %rcx,%rbx
  mov    %r12,%r10
  sub    $0x28,%rsp
  mov    %r8d,-0x44(%rbp)
  mov    %rsp,%rsi
  mov    %fs:0x28,%rax
  mov    %rax,-0x38(%rbp)
  xor    %eax,%eax
  lea    0x17(,%r12,4),%rax
  mov    %rax,%rdi
  mov    %rax,%rcx
  and    $0xfffffffffffff000,%rdi
  and    $0xfffffffffffffff0,%rcx
  sub    %rdi,%rsi
  cmp    %rsi,%rsp
  je     L210
L223:
  sub    $0x1000,%rsp
  orq    $0x0,0xff8(%rsp)
  cmp    %rsi,%rsp
  jne    L223
L210:
  and    $0xfff,%ecx
  sub    %rcx,%rsp
  test   %rcx,%rcx
  jne    L4
L218:
  mov    %rax,%r8
  mov    %rsp,%rdi
  lea    0xf(%rsp),%rcx
  mov    %rax,%rsi
  and    $0xfffffffffffff000,%r8
  and    $0xfffffffffffffff0,%rcx
  and    $0xfffffffffffffff0,%rsi
  sub    %r8,%rdi
  cmp    %rdi,%rsp
  je     L229
L222:
  sub    $0x1000,%rsp
  orq    $0x0,0xff8(%rsp)
  cmp    %rdi,%rsp
  jne    L222
L229:
  and    $0xfff,%esi
  sub    %rsi,%rsp
  test   %rsi,%rsi
  jne    L228
L79:
  mov    %rax,%r9
  mov    %rsp,%r8
  lea    0xf(%rsp),%rsi
  mov    %rax,%rdi
  and    $0xfffffffffffff000,%r9
  and    $0xfffffffffffffff0,%rsi
  and    $0xfffffffffffffff0,%rdi
  sub    %r9,%r8
  cmp    %r8,%rsp
  je     L369
L176:
  sub    $0x1000,%rsp
  orq    $0x0,0xff8(%rsp)
  cmp    %r8,%rsp
  jne    L176
L369:
  and    $0xfff,%edi
  sub    %rdi,%rsp
  test   %rdi,%rdi
  je     L123
  orq    $0x0,-0x8(%rsp,%rdi,1)
L123:
  mov    %rax,%r13
  mov    %rsp,%r9
  lea    0xf(%rsp),%rdi
  mov    %rax,%r8
  and    $0xfffffffffffff000,%r13
  and    $0xfffffffffffffff0,%rdi
  and    $0xfffffffffffffff0,%r8
  sub    %r13,%r9
  cmp    %r9,%rsp
  je     L336
L345:
  sub    $0x1000,%rsp
  orq    $0x0,0xff8(%rsp)
  cmp    %r9,%rsp
  jne    L345
L336:
  and    $0xfff,%r8d
  sub    %r8,%rsp
  test   %r8,%r8
  je     L445
  orq    $0x0,-0x8(%rsp,%r8,1)
L445:
  mov    %rax,%r9
  mov    %rsp,%r13
  and    $0xfffffffffffff000,%rax
  lea    0xf(%rsp),%r8
  sub    %rax,%r13
  and    $0xfffffffffffffff0,%r9
  and    $0xfffffffffffffff0,%r8
  cmp    %r13,%rsp
  je     L49
L151:
  sub    $0x1000,%rsp
  orq    $0x0,0xff8(%rsp)
  cmp    %r13,%rsp
  jne    L151
L49:
  mov    %r9,%rax
  and    $0xfff,%eax
  sub    %rax,%rsp
  test   %rax,%rax
  je     L201
  orq    $0x0,-0x8(%rsp,%rax,1)
L201:
  movss  (%rdx),%xmm9
  movss  D4(%rip),%xmm6
  lea    0xf(%rsp),%r9
  and    $0xfffffffffffffff0,%r9
  addss  %xmm7,%xmm9
  comiss %xmm9,%xmm6
  ja     L122
  movaps %xmm9,%xmm4
  pxor   %xmm0,%xmm0
  mulss  %xmm9,%xmm4
  mulss  D6(%rip),%xmm4
  mulss  %xmm4,%xmm9
  movaps %xmm4,%xmm10
  addss  %xmm0,%xmm10
  addss  %xmm0,%xmm9
L42:
  movl   $0x0,(%rdi)
  movl   $0x0,(%r9)
  movss  %xmm10,(%rcx)
  movss  %xmm10,(%rsi)
  movss  %xmm9,(%r8)
  cmp    $0x1,%r10d
  jle    L340
  movaps %xmm10,%xmm15
  mov    $0x1,%eax
  movaps %xmm6,%xmm8
  movaps %xmm0,%xmm12
  movaps %xmm0,%xmm11
  jmp    L8
  nopl   0x0(%rax)
L29:
  movaps %xmm5,%xmm14
  movaps %xmm8,%xmm4
  movaps %xmm5,%xmm13
  mulss  %xmm5,%xmm14
  mulss  %xmm14,%xmm4
  mulss  %xmm14,%xmm13
  mulss  %xmm4,%xmm5
L83:
  addss  %xmm4,%xmm15
  mulss  %xmm8,%xmm4
  addss  %xmm14,%xmm10
  addss  %xmm13,%xmm9
  addss  %xmm5,%xmm12
  addss  %xmm6,%xmm8
  movss  %xmm10,(%rcx,%rax,4)
  movss  %xmm15,(%rsi,%rax,4)
  addss  %xmm4,%xmm11
  movss  %xmm9,(%r8,%rax,4)
  movss  %xmm12,(%r9,%rax,4)
  movss  %xmm11,(%rdi,%rax,4)
  add    $0x1,%rax
  cmp    %rax,%r12
  je     L340
L8:
  movss  (%rdx,%rax,4),%xmm5
  addss  %xmm7,%xmm5
  comiss %xmm5,%xmm6
  jbe    L29
  movaps %xmm8,%xmm5
  movaps %xmm8,%xmm4
  movaps %xmm6,%xmm13
  movaps %xmm6,%xmm14
  jmp    L83
  nopl   0x0(%rax)
L4:
  orq    $0x0,-0x8(%rsp,%rcx,1)
  jmp    L218
L228:
  orq    $0x0,-0x8(%rsp,%rsi,1)
  jmp    L79
  xchg   %ax,%ax
L340:
  mov    (%r11),%rax
  mov    %rax,%r12
  sar    $0x10,%r12
  mov    %r12d,%edx
  test   %r12d,%r12d
  jns    L395
  mov    $0x1,%r14d
  movaps %xmm0,%xmm5
  jmp    L221
  nopl   0x0(%rax)
L220:
  mov    %r15,%r14
L221:
  neg    %edx
  movzwl %ax,%eax
  movaps %xmm0,%xmm13
  mov    %r14d,%r13d
  movslq %edx,%rdx
  movss  (%rsi,%rax,4),%xmm4
  movss  (%rcx,%rax,4),%xmm2
  lea    0x1(%r14),%r15
  subss  (%rsi,%rdx,4),%xmm4
  movss  (%rdi,%rax,4),%xmm9
  addss  (%rdi,%rdx,4),%xmm9
  addss  (%rcx,%rdx,4),%xmm2
  movss  (%r8,%rax,4),%xmm8
  movss  (%r9,%rax,4),%xmm1
  addss  (%r8,%rdx,4),%xmm8
  subss  (%r9,%rdx,4),%xmm1
  movaps %xmm4,%xmm10
  movaps %xmm9,%xmm3
  mov    (%r11,%r14,8),%rax
  mulss  %xmm8,%xmm3
  mov    %rax,%r12
  mulss  %xmm1,%xmm10
  sar    $0x10,%r12
  mulss  %xmm2,%xmm1
  mov    %r12d,%edx
  mulss  %xmm4,%xmm8
  mulss  %xmm9,%xmm2
  mulss  %xmm4,%xmm4
  subss  %xmm10,%xmm3
  subss  %xmm8,%xmm1
  subss  %xmm4,%xmm2
  movaps %xmm1,%xmm4
  mulss  %xmm5,%xmm4
  addss  %xmm6,%xmm5
  addss  %xmm3,%xmm4
  divss  %xmm2,%xmm4
  maxss  %xmm4,%xmm13
  movaps %xmm13,%xmm4
  subss  %xmm7,%xmm4
  movss  %xmm4,-0x4(%rbx,%r14,4)
  test   %r12d,%r12d
  js     L220
L209:
  lea    0x1(%r13),%r12d
  movzwl %ax,%eax
  movslq %r12d,%r12
  cmp    %eax,%r10d
  jg     L241
  jmp    L310
  nopw   0x0(%rax,%rax,1)
L50:
  mov    %r15,%r12
L241:
  movslq %edx,%rdx
  movss  (%rsi,%rax,4),%xmm4
  movss  (%rcx,%rax,4),%xmm2
  mov    %r12d,%r13d
  subss  (%rsi,%rdx,4),%xmm4
  movss  (%rdi,%rax,4),%xmm9
  movaps %xmm0,%xmm11
  lea    0x1(%r12),%r15
  subss  (%rdi,%rdx,4),%xmm9
  subss  (%rcx,%rdx,4),%xmm2
  movss  (%r8,%rax,4),%xmm8
  movss  (%r9,%rax,4),%xmm1
  subss  (%r8,%rdx,4),%xmm8
  subss  (%r9,%rdx,4),%xmm1
  movaps %xmm4,%xmm10
  movaps %xmm9,%xmm3
  mov    (%r11,%r12,8),%rax
  mulss  %xmm8,%xmm3
  mov    %rax,%rdx
  movzwl %ax,%eax
  mulss  %xmm1,%xmm10
  sar    $0x10,%rdx
  mulss  %xmm2,%xmm1
  mulss  %xmm4,%xmm8
  mulss  %xmm9,%xmm2
  mulss  %xmm4,%xmm4
  subss  %xmm10,%xmm3
  subss  %xmm8,%xmm1
  subss  %xmm4,%xmm2
  movaps %xmm1,%xmm4
  mulss  %xmm5,%xmm4
  addss  %xmm6,%xmm5
  addss  %xmm3,%xmm4
  divss  %xmm2,%xmm4
  maxss  %xmm4,%xmm11
  movaps %xmm11,%xmm4
  subss  %xmm7,%xmm4
  movss  %xmm4,(%rbx,%r14,4)
  mov    %r12,%r14
  cmp    %eax,%r10d
  jg     L50
L310:
  cmp    %r13d,%r10d
  jle    L155
  lea    -0x1(%r10),%edx
  movslq %r13d,%r11
  sub    %r13d,%edx
  lea    (%rbx,%r11,4),%rax
  add    %r11,%rdx
  lea    0x4(%rbx,%rdx,4),%rdx
  nopw   0x0(%rax,%rax,1)
L70:
  movaps %xmm1,%xmm4
  movaps %xmm0,%xmm12
  add    $0x4,%rax
  mulss  %xmm5,%xmm4
  addss  %xmm6,%xmm5
  addss  %xmm3,%xmm4
  divss  %xmm2,%xmm4
  maxss  %xmm4,%xmm12
  movaps %xmm12,%xmm4
  subss  %xmm7,%xmm4
  movss  %xmm4,-0x4(%rax)
  cmp    %rax,%rdx
  jne    L70
L155:
  mov    -0x44(%rbp),%eax
  test   %eax,%eax
  jle    L107
  mov    -0x44(%rbp),%eax
  mov    %eax,%edx
  sar    %edx
  mov    %edx,%r11d
  mov    %edx,-0x48(%rbp)
  sub    %eax,%r11d
  jns    L311
  movslq -0x48(%rbp),%rax
  movslq -0x44(%rbp),%r13
  xor    %r12d,%r12d
  mov    %r11d,%r14d
  lea    0x1(%rax),%edx
  sub    %rax,%r13
  neg    %rax
  movslq %edx,%rdx
  shl    $0x2,%r13
  lea    (%rbx,%rax,4),%r15
  nopl   (%rax)
L23:
  movss  -0x4(%rsi,%rdx,4),%xmm4
  movss  -0x4(%rdi,%rdx,4),%xmm8
  subss  (%rsi,%r13,1),%xmm4
  addss  (%rdi,%r13,1),%xmm8
  movss  -0x4(%rcx,%rdx,4),%xmm2
  movss  -0x4(%r8,%rdx,4),%xmm5
  addss  (%rcx,%r13,1),%xmm2
  addss  (%r8,%r13,1),%xmm5
  movss  -0x4(%r9,%rdx,4),%xmm1
  movaps %xmm4,%xmm9
  movaps %xmm8,%xmm3
  subss  (%r9,%r13,1),%xmm1
  mulss  %xmm5,%xmm3
  mulss  %xmm1,%xmm9
  mulss  %xmm4,%xmm5
  mulss  %xmm2,%xmm1
  mulss  %xmm4,%xmm4
  mulss  %xmm8,%xmm2
  subss  %xmm9,%xmm3
  subss  %xmm5,%xmm1
  movss  -0x4(%r15,%rdx,4),%xmm5
  subss  %xmm4,%xmm2
  movaps %xmm1,%xmm4
  mulss  %xmm0,%xmm4
  addss  %xmm3,%xmm4
  divss  %xmm2,%xmm4
  subss  %xmm7,%xmm4
  comiss %xmm4,%xmm5
  jbe    L178
  movss  %xmm4,-0x4(%r15,%rdx,4)
L178:
  add    $0x1,%r12d
  mov    %r14d,%r11d
  movslq %edx,%rax
  sub    $0x4,%r13
  addss  %xmm6,%xmm0
  add    $0x1,%rdx
  add    %r12d,%r11d
  js     L23
L350:
  cmp    %eax,%r10d
  jle    L104
  mov    -0x48(%rbp),%r15d
  add    $0x1,%r12d
  movslq %r12d,%rdx
  lea    (%r15,%r12,1),%r13d
  sub    -0x44(%rbp),%r15d
  mov    %r15d,%r14d
  nopw   0x0(%rax,%rax,1)
L144:
  movslq %r11d,%r11
  movss  (%rsi,%rax,4),%xmm4
  movss  (%rcx,%rax,4),%xmm2
  subss  (%rsi,%r11,4),%xmm4
  movss  (%rdi,%rax,4),%xmm8
  subss  (%rdi,%r11,4),%xmm8
  subss  (%rcx,%r11,4),%xmm2
  movss  (%r8,%rax,4),%xmm5
  movss  (%r9,%rax,4),%xmm1
  subss  (%r8,%r11,4),%xmm5
  subss  (%r9,%r11,4),%xmm1
  movaps %xmm4,%xmm9
  movaps %xmm8,%xmm3
  mulss  %xmm5,%xmm3
  mulss  %xmm1,%xmm9
  mulss  %xmm4,%xmm5
  mulss  %xmm2,%xmm1
  mulss  %xmm4,%xmm4
  mulss  %xmm8,%xmm2
  subss  %xmm9,%xmm3
  subss  %xmm5,%xmm1
  movss  -0x4(%rbx,%rdx,4),%xmm5
  subss  %xmm4,%xmm2
  movaps %xmm1,%xmm4
  mulss  %xmm0,%xmm4
  addss  %xmm3,%xmm4
  divss  %xmm2,%xmm4
  subss  %xmm7,%xmm4
  comiss %xmm4,%xmm5
  jbe    L428
  movss  %xmm4,-0x4(%rbx,%rdx,4)
L428:
  movslq %r13d,%rax
  mov    %edx,%r12d
  lea    (%r14,%rdx,1),%r11d
  add    $0x1,%r13d
  addss  %xmm6,%xmm0
  add    $0x1,%rdx
  cmp    %eax,%r10d
  jg     L144
L104:
  cmp    %r12d,%r10d
  jle    L107
  sub    $0x1,%r10d
  movslq %r12d,%rdx
  sub    %r12d,%r10d
  lea    (%rbx,%rdx,4),%rax
  add    %rdx,%r10
  lea    0x4(%rbx,%r10,4),%rdx
  nopw   0x0(%rax,%rax,1)
L120:
  movaps %xmm1,%xmm4
  movss  (%rax),%xmm5
  mulss  %xmm0,%xmm4
  addss  %xmm3,%xmm4
  divss  %xmm2,%xmm4
  subss  %xmm7,%xmm4
  comiss %xmm4,%xmm5
  jbe    L447
  movss  %xmm4,(%rax)
L447:
  add    $0x4,%rax
  addss  %xmm6,%xmm0
  cmp    %rax,%rdx
  jne    L120
L107:
  mov    -0x38(%rbp),%rax
  sub    %fs:0x28,%rax
  jne    L317
  lea    -0x28(%rbp),%rsp
  pop    %rbx
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  pop    %rbp
  ret
L122:
  movss  D6(%rip),%xmm9
  pxor   %xmm0,%xmm0
  movaps %xmm9,%xmm10
  jmp    L42
  nopl   0x0(%rax)
L395:
  xor    %r14d,%r14d
  movaps %xmm0,%xmm5
  xor    %r13d,%r13d
  jmp    L209
L311:
  movslq %edx,%rax
  xor    %r12d,%r12d
  jmp    L350
L317:
  call   <__stack_chk_fail@plt>
```

tool_calls: name: extract_symbolic_data
arguments: tag: D4
type_infered: byte[4]
name: extract_symbolic_data
arguments: tag: D6
type_infered: byte[4]

tool: {"D4": [0x00,0x00,0x80,0x3f]}

tool: {"D6": [0x00,0x00,0x00,0x3f]}

assistant: ```c
void bark_noise_hybridmp(int n, const long *b, const float *f, float *noise, const float offset, const int fixed) {
  float *N = alloca(n * sizeof(*N));
  float *X = alloca(n * sizeof(*N));
  float *XX = alloca(n * sizeof(*N));
  float *Y = alloca(n * sizeof(*N));
  float *XY = alloca(n * sizeof(*N));
  float tN, tX, tXX, tY, tXY;
  int i;
  int lo, hi;
  float R, A, B, D;
  float w, x, y;
  tN = tX = tXX = tY = tXY = 0.f;
  y = f[0] + offset;
  if (y < 1.f)
    y = 1.f;
  w = y * y * .5;
  tN += w;
  tX += w;
  tY += w * y;
  N[0] = tN;
  X[0] = tX;
  XX[0] = tXX;
  Y[0] = tY;
  XY[0] = tXY;
  for (i = 1, x = 1.f; i < n; i++, x += 1.f) {
    y = f[i] + offset;
    if (y < 1.f)
      y = 1.f;
    w = y * y;
    tN += w;
    tX += w * x;
    tXX += w * x * x;
    tY += w * y;
    tXY += w * x * y;
    N[i] = tN;
    X[i] = tX;
    XX[i] = tXX;
    Y[i] = tY;
    XY[i] = tXY;
  }
  for (i = 0, x = 0.f;; i++, x += 1.f) {
    lo = b[i] >> 16;
    if (lo >= 0)
      break;
    hi = b[i] & 0xffff;
    tN = N[hi] + N[-lo];
    tX = X[hi] - X[-lo];
    tXX = XX[hi] + XX[-lo];
    tY = Y[hi] + Y[-lo];
    tXY = XY[hi] - XY[-lo];
    A = tY * tXX - tX * tXY;
    B = tN * tXY - tX * tY;
    D = tN * tXX - tX * tX;
    R = (A + x * B) / D;
    if (R < 0.f)
      R = 0.f;
    noise[i] = R - offset;
  }
  for (;; i++, x += 1.f) {
    lo = b[i] >> 16;
    hi = b[i] & 0xffff;
    if (hi >= n)
      break;
    tN = N[hi] - N[lo];
    tX = X[hi] - X[lo];
    tXX = XX[hi] - XX[lo];
    tY = Y[hi] - Y[lo];
    tXY = XY[hi] - XY[lo];
    A = tY * tXX - tX * tXY;
    B = tN * tXY - tX * tY;
    D = tN * tXX - tX * tX;
    R = (A + x * B) / D;
    if (R < 0.f)
      R = 0.f;
    noise[i] = R - offset;
  }
  for (; i < n; i++, x += 1.f) {
    R = (A + x * B) / D;
    if (R < 0.f)
      R = 0.f;
    noise[i] = R - offset;
  }
  if (fixed <= 0)
    return;
  for (i = 0, x = 0.f;; i++, x += 1.f) {
    hi = i + fixed / 2;
    lo = hi - fixed;
    if (lo >= 0)
      break;
    tN = N[hi] + N[-lo];
    tX = X[hi] - X[-lo];
    tXX = XX[hi] + XX[-lo];
    tY = Y[hi] + Y[-lo];
    tXY = XY[hi] - XY[-lo];
    A = tY * tXX - tX * tXY;
    B = tN * tXY - tX * tY;
    D = tN * tXX - tX * tX;
    R = (A + x * B) / D;
    if (R - offset < noise[i])
      noise[i] = R - offset;
  }
  for (;; i++, x += 1.f) {
    hi = i + fixed / 2;
    lo = hi - fixed;
    if (hi >= n)
      break;
    tN = N[hi] - N[lo];
    tX = X[hi] - X[lo];
    tXX = XX[hi] - XX[lo];
    tY = Y[hi] - Y[lo];
    tXY = XY[hi] - XY[lo];
    A = tY * tXX - tX * tXY;
    B = tN * tXY - tX * tY;
    D = tN * tXX - tX * tX;
    R = (A + x * B) / D;
    if (R - offset < noise[i])
      noise[i] = R - offset;
  }
  for (; i < n; i++, x += 1.f) {
    R = (A + x * B) / D;
    if (R - offset < noise[i])
      noise[i] = R - offset;
  }
}
```