user: Converte this assembly snippet into its equivalent C code:

```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     L302
L9:
  sub    $0x1000,%rsp
  orq    $0x0,0xff8(%rsp)
  cmp    %rsi,%rsp
  jne    L9
L302:
  and    $0xfff,%ecx
  sub    %rcx,%rsp
  test   %rcx,%rcx
  jne    L317
L48:
  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     L31
L115:
  sub    $0x1000,%rsp
  orq    $0x0,0xff8(%rsp)
  cmp    %rdi,%rsp
  jne    L115
L31:
  and    $0xfff,%esi
  sub    %rsi,%rsp
  test   %rsi,%rsi
  jne    L293
L133:
  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     L82
L356:
  sub    $0x1000,%rsp
  orq    $0x0,0xff8(%rsp)
  cmp    %r8,%rsp
  jne    L356
L82:
  and    $0xfff,%edi
  sub    %rdi,%rsp
  test   %rdi,%rdi
  je     L49
  orq    $0x0,-0x8(%rsp,%rdi,1)
L49:
  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     L435
L268:
  sub    $0x1000,%rsp
  orq    $0x0,0xff8(%rsp)
  cmp    %r9,%rsp
  jne    L268
L435:
  and    $0xfff,%r8d
  sub    %r8,%rsp
  test   %r8,%r8
  je     L80
  orq    $0x0,-0x8(%rsp,%r8,1)
L80:
  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     L368
L319:
  sub    $0x1000,%rsp
  orq    $0x0,0xff8(%rsp)
  cmp    %r13,%rsp
  jne    L319
L368:
  mov    %r9,%rax
  and    $0xfff,%eax
  sub    %rax,%rsp
  test   %rax,%rax
  je     L187
  orq    $0x0,-0x8(%rsp,%rax,1)
L187:
  movss  (%rdx),%xmm8
  movss  D22(%rip),%xmm6
  lea    0xf(%rsp),%r9
  and    $0xfffffffffffffff0,%r9
  addss  %xmm7,%xmm8
  comiss %xmm8,%xmm6
  ja     L221
  movaps %xmm8,%xmm4
  pxor   %xmm0,%xmm0
  mulss  %xmm8,%xmm4
  mulss  D3(%rip),%xmm4
  mulss  %xmm4,%xmm8
  movaps %xmm4,%xmm10
  addss  %xmm0,%xmm10
  addss  %xmm0,%xmm8
L42:
  movl   $0x0,(%rdi)
  movl   $0x0,(%r9)
  movss  %xmm10,(%rcx)
  movss  %xmm10,(%rsi)
  movss  %xmm8,(%r8)
  cmp    $0x1,%r10d
  jle    L1
  movaps %xmm10,%xmm13
  movaps %xmm6,%xmm5
  movaps %xmm0,%xmm12
  mov    $0x1,%eax
  movaps %xmm0,%xmm11
  xchg   %ax,%ax
L140:
  movss  (%rdx,%rax,4),%xmm4
  addss  %xmm7,%xmm4
  comiss %xmm4,%xmm6
  ja     L358
  movaps %xmm4,%xmm9
  movaps %xmm5,%xmm14
  movaps %xmm5,%xmm15
  mulss  %xmm4,%xmm9
  addss  %xmm6,%xmm5
  mulss  %xmm9,%xmm14
  addss  %xmm9,%xmm10
  mulss  %xmm4,%xmm9
  movss  %xmm10,(%rcx,%rax,4)
  mulss  %xmm14,%xmm15
  addss  %xmm14,%xmm13
  mulss  %xmm14,%xmm4
  addss  %xmm9,%xmm8
  movss  %xmm13,(%rsi,%rax,4)
  movss  %xmm8,(%r8,%rax,4)
  addss  %xmm15,%xmm11
  addss  %xmm4,%xmm12
  movss  %xmm11,(%rdi,%rax,4)
  movss  %xmm12,(%r9,%rax,4)
  add    $0x1,%rax
  cmp    %rax,%r12
  jne    L140
L1:
  mov    (%r11),%rax
  mov    %rax,%r12
  sar    $0x10,%r12
  mov    %r12d,%edx
  test   %r12d,%r12d
  jns    L169
  mov    $0x1,%r14d
  movaps %xmm0,%xmm5
  jmp    L112
  nopl   0x0(%rax)
L127:
  mov    %r15,%r14
L112:
  neg    %edx
  movzwl %ax,%eax
  movaps %xmm0,%xmm15
  mov    %r14d,%r13d
  movslq %edx,%rdx
  movss  (%rsi,%rax,4),%xmm4
  movss  (%r9,%rax,4),%xmm1
  lea    0x1(%r14),%r15
  subss  (%rsi,%rdx,4),%xmm4
  subss  (%r9,%rdx,4),%xmm1
  movss  (%rcx,%rdx,4),%xmm9
  movss  (%r8,%rdx,4),%xmm8
  addss  (%rcx,%rax,4),%xmm9
  addss  (%r8,%rax,4),%xmm8
  movss  (%rdi,%rdx,4),%xmm2
  movaps %xmm1,%xmm10
  addss  (%rdi,%rax,4),%xmm2
  mulss  %xmm4,%xmm10
  mov    (%r11,%r14,8),%rax
  mulss  %xmm9,%xmm1
  movaps %xmm8,%xmm3
  mulss  %xmm4,%xmm8
  mov    %rax,%r12
  mulss  %xmm2,%xmm3
  sar    $0x10,%r12
  mulss  %xmm4,%xmm4
  mov    %r12d,%edx
  mulss  %xmm9,%xmm2
  subss  %xmm8,%xmm1
  subss  %xmm10,%xmm3
  subss  %xmm4,%xmm2
  movaps %xmm1,%xmm4
  mulss  %xmm5,%xmm4
  addss  %xmm6,%xmm5
  addss  %xmm3,%xmm4
  divss  %xmm2,%xmm4
  maxss  %xmm4,%xmm15
  movaps %xmm15,%xmm4
  subss  %xmm7,%xmm4
  movss  %xmm4,-0x4(%rbx,%r14,4)
  test   %r12d,%r12d
  js     L127
L93:
  lea    0x1(%r13),%r12d
  movzwl %ax,%eax
  movslq %r12d,%r12
  cmp    %eax,%r10d
  jg     L161
  jmp    L58
  nopw   0x0(%rax,%rax,1)
L315:
  mov    %r15,%r12
L161:
  movslq %edx,%rdx
  movss  (%rsi,%rax,4),%xmm4
  movss  (%rdi,%rax,4),%xmm2
  mov    %r12d,%r13d
  subss  (%rsi,%rdx,4),%xmm4
  movss  (%rcx,%rax,4),%xmm9
  movaps %xmm0,%xmm11
  lea    0x1(%r12),%r15
  subss  (%rcx,%rdx,4),%xmm9
  movss  (%r8,%rax,4),%xmm8
  movss  (%r9,%rax,4),%xmm1
  subss  (%r8,%rdx,4),%xmm8
  subss  (%r9,%rdx,4),%xmm1
  subss  (%rdi,%rdx,4),%xmm2
  mov    (%r11,%r12,8),%rax
  movaps %xmm8,%xmm3
  mulss  %xmm4,%xmm8
  movaps %xmm1,%xmm10
  mov    %rax,%rdx
  movzwl %ax,%eax
  mulss  %xmm9,%xmm1
  sar    $0x10,%rdx
  mulss  %xmm2,%xmm3
  mulss  %xmm4,%xmm10
  mulss  %xmm9,%xmm2
  mulss  %xmm4,%xmm4
  subss  %xmm8,%xmm1
  subss  %xmm10,%xmm3
  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     L315
L58:
  cmp    %r13d,%r10d
  jle    L175
  lea    -0x1(%r10),%edx
  movslq %r13d,%r11
  sub    %r13d,%edx
  lea    (%rbx,%r11,4),%rax
  add    %r11,%rdx
  lea    0x4(%rbx,%rdx,4),%rdx
  nop
L183:
  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    %rdx,%rax
  jne    L183
L175:
  mov    -0x44(%rbp),%eax
  test   %eax,%eax
  jle    L448
  mov    -0x44(%rbp),%eax
  mov    %eax,%edx
  sar    %edx
  mov    %edx,%r11d
  mov    %edx,-0x48(%rbp)
  sub    %eax,%r11d
  movslq %edx,%rax
  jns    L96
  movslq -0x44(%rbp),%r13
  lea    0x1(%rax),%edx
  xor    %r12d,%r12d
  mov    %r11d,%r14d
  movslq %edx,%rdx
  sub    %rax,%r13
  neg    %rax
  shl    $0x2,%r13
  lea    (%rbx,%rax,4),%r15
  nopl   0x0(%rax)
L366:
  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    L341
  movss  %xmm4,-0x4(%r15,%rdx,4)
L341:
  add    $0x1,%r12d
  mov    %r14d,%r11d
  movslq %edx,%rax
  sub    $0x4,%r13
  addss  %xmm6,%xmm0
  add    $0x1,%rdx
  add    %r12d,%r11d
  js     L366
L78:
  cmp    %eax,%r10d
  jle    L275
  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)
L423:
  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    L234
  movss  %xmm4,-0x4(%rbx,%rdx,4)
L234:
  movslq %r13d,%rax
  mov    %edx,%r12d
  lea    (%r14,%rdx,1),%r11d
  add    $0x1,%r13d
  addss  %xmm6,%xmm0
  add    $0x1,%rdx
  cmp    %eax,%r10d
  jg     L423
L275:
  cmp    %r12d,%r10d
  jle    L448
  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)
L291:
  movaps %xmm1,%xmm4
  movss  (%rax),%xmm5
  mulss  %xmm0,%xmm4
  addss  %xmm3,%xmm4
  divss  %xmm2,%xmm4
  subss  %xmm7,%xmm4
  comiss %xmm4,%xmm5
  jbe    L306
  movss  %xmm4,(%rax)
L306:
  add    $0x4,%rax
  addss  %xmm6,%xmm0
  cmp    %rax,%rdx
  jne    L291
L448:
  mov    -0x38(%rbp),%rax
  sub    %fs:0x28,%rax
  jne    L200
  lea    -0x28(%rbp),%rsp
  pop    %rbx
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  pop    %rbp
  ret
  nop
L317:
  orq    $0x0,-0x8(%rsp,%rcx,1)
  jmp    L48
L293:
  orq    $0x0,-0x8(%rsp,%rsi,1)
  jmp    L133
  cs nopw 0x0(%rax,%rax,1)
L358:
  movaps %xmm5,%xmm4
  addss  %xmm5,%xmm13
  addss  %xmm5,%xmm12
  mulss  %xmm5,%xmm4
  addss  %xmm6,%xmm10
  addss  %xmm6,%xmm8
  addss  %xmm6,%xmm5
  movss  %xmm13,(%rsi,%rax,4)
  movss  %xmm10,(%rcx,%rax,4)
  movss  %xmm8,(%r8,%rax,4)
  addss  %xmm4,%xmm11
  movss  %xmm12,(%r9,%rax,4)
  movss  %xmm11,(%rdi,%rax,4)
  add    $0x1,%rax
  cmp    %r12,%rax
  jne    L140
  jmp    L1
L221:
  movss  D3(%rip),%xmm8
  pxor   %xmm0,%xmm0
  movaps %xmm8,%xmm10
  jmp    L42
  nopw   0x0(%rax,%rax,1)
L169:
  xor    %r14d,%r14d
  movaps %xmm0,%xmm5
  xor    %r13d,%r13d
  jmp    L93
L96:
  xor    %r12d,%r12d
  jmp    L78
L200:
  call   <__stack_chk_fail@plt>
```

tool_calls: name: extract_symbolic_data
arguments: data_label: D22
type_guessed: byte[4]
name: extract_symbolic_data
arguments: data_label: D3
type_guessed: byte[4]

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

tool: {"D3": [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;
  }
}
```