user: 请将这段汇编代码片段转换成等效的C代码:

```asm
<hybwin>:
  endbr64
  push   %rbp
  mov    %esi,%r10d
  mov    %edx,%esi
  mov    %rcx,%r11
  mov    %rsp,%rbp
  push   %r15
  mov    %r9,%r15
  push   %r14
  mov    %edi,%r14d
  push   %r13
  push   %r12
  push   %rbx
  mov    %r8,%rbx
  sub    $0x48,%rsp
  mov    %edi,-0x48(%rbp)
  mov    0x10(%rbp),%r12
  mov    %edx,-0x54(%rbp)
  lea    (%r14,%r10,1),%edx
  mov    %rsp,%r8
  add    %esi,%r14d
  mov    0x18(%rbp),%rdi
  mov    %fs:0x28,%rax
  mov    %rax,-0x38(%rbp)
  xor    %eax,%eax
  lea    (%rdx,%rsi,1),%eax
  mov    %r14d,-0x50(%rbp)
  movslq %eax,%rcx
  lea    0xf(,%rcx,4),%rcx
  mov    %rcx,%rsi
  and    $0xfffffffffffff000,%rcx
  sub    %rcx,%r8
  and    $0xfffffffffffffff0,%rsi
  cmp    %r8,%rsp
  je     L21
L273:
  sub    $0x1000,%rsp
  orq    $0x0,0xff8(%rsp)
  cmp    %r8,%rsp
  jne    L273
L21:
  and    $0xfff,%esi
  sub    %rsi,%rsp
  test   %rsi,%rsi
  jne    L133
L241:
  mov    -0x48(%rbp),%ecx
  mov    %rsp,%r8
  add    $0x1,%ecx
  movslq %ecx,%rsi
  shl    $0x2,%rsi
  lea    0xf(%rsi),%r13
  mov    %rsi,-0x70(%rbp)
  mov    %rsp,%rsi
  mov    %r13,%r9
  mov    %r13,%r14
  and    $0xfffffffffffff000,%r9
  and    $0xfffffffffffffff0,%r14
  sub    %r9,%rsi
  cmp    %rsi,%rsp
  je     L78
L251:
  sub    $0x1000,%rsp
  orq    $0x0,0xff8(%rsp)
  cmp    %rsi,%rsp
  jne    L251
L78:
  mov    %r14,%rsi
  and    $0xfff,%esi
  sub    %rsi,%rsp
  test   %rsi,%rsi
  jne    L214
L239:
  mov    %r13,%rsi
  mov    %rsp,%r9
  mov    %r13,%r14
  mov    %rsp,-0x60(%rbp)
  and    $0xfffffffffffff000,%rsi
  and    $0xfffffffffffffff0,%r14
  sub    %rsi,%r9
  cmp    %r9,%rsp
  je     L255
L75:
  sub    $0x1000,%rsp
  orq    $0x0,0xff8(%rsp)
  cmp    %r9,%rsp
  jne    L75
L255:
  mov    %r14,%rsi
  and    $0xfff,%esi
  sub    %rsi,%rsp
  test   %rsi,%rsi
  je     L164
  orq    $0x0,-0x8(%rsp,%rsi,1)
L164:
  mov    -0x50(%rbp),%r9d
  mov    %rsp,%r13
  test   %r9d,%r9d
  jle    L79
  movslq %r10d,%r14
  lea    0x0(,%r14,4),%r9
  lea    (%r11,%r9,1),%rsi
  neg    %r9
  mov    %rsi,-0x68(%rbp)
  mov    -0x50(%rbp),%esi
  sub    $0x1,%esi
  add    %rsi,%r14
  mov    -0x68(%rbp),%rsi
  lea    0x4(%r11,%r14,4),%r14
  nopw   0x0(%rax,%rax,1)
L247:
  movss  (%rsi),%xmm1
  add    $0x4,%rsi
  movss  %xmm1,-0x4(%rsi,%r9,1)
  cmp    %r14,%rsi
  jne    L247
L79:
  test   %r10d,%r10d
  jle    L118
  movslq -0x50(%rbp),%rsi
  movslq %r10d,%r14
  lea    (%r11,%rsi,4),%r9
  xor    %esi,%esi
  cs nopw 0x0(%rax,%rax,1)
L41:
  movss  (%rbx,%rsi,4),%xmm1
  movss  %xmm1,(%r9,%rsi,4)
  add    $0x1,%rsi
  cmp    %rsi,%r14
  jne    L41
L118:
  movss  (%r11),%xmm1
  movss  (%r12),%xmm2
  lea    -0x1(%rax),%r9d
  xor    %esi,%esi
  cmp    $0x1,%eax
  jle    L77
  xchg   %ax,%ax
L274:
  movaps %xmm1,%xmm3
  movss  0x4(%r11,%rsi,4),%xmm1
  mulss  %xmm2,%xmm3
  movss  0x4(%r12,%rsi,4),%xmm2
  movss  %xmm3,(%r8,%rsi,4)
  add    $0x1,%rsi
  cmp    %rsi,%r9
  jne    L274
  lea    (%r8,%r9,4),%rsi
L289:
  mulss  %xmm2,%xmm1
  movss  %xmm1,(%rsi)
  mov    -0x48(%rbp),%esi
  test   %esi,%esi
  js     L4
  movslq -0x48(%rbp),%rsi
  mov    -0x70(%rbp),%rbx
  pxor   %xmm3,%xmm3
  mov    -0x60(%rbp),%r12
  lea    -0x4(%r8,%rbx,1),%rbx
  mov    %rsi,-0x50(%rbp)
  shl    $0x2,%rsi
  movss  (%rbx),%xmm4
  mov    %rsi,-0x48(%rbp)
  mov    %rbx,%r14
  mov    %rbx,%r11
  sub    %rsi,%r14
  movaps %xmm4,%xmm1
  nopl   0x0(%rax)
L231:
  subss  %xmm3,%xmm3
  movaps %xmm4,%xmm2
  cmp    $0x1,%r10d
  jle    L285
  xor    %esi,%esi
  nop
L179:
  mulss  %xmm2,%xmm1
  movss  0x4(%rbx,%rsi,4),%xmm2
  addss  %xmm1,%xmm3
  movss  0x4(%r11,%rsi,4),%xmm1
  add    $0x1,%rsi
  lea    (%rcx,%rsi,1),%r9d
  cmp    %edx,%r9d
  jl     L179
L285:
  mulss  %xmm2,%xmm1
  add    $0x4,%r12
  addss  %xmm1,%xmm3
  movss  %xmm3,-0x4(%r12)
  cmp    %r11,%r14
  je     L201
  movss  -0x4(%r11),%xmm1
  sub    $0x4,%r11
  jmp    L231
L133:
  orq    $0x0,-0x8(%rsp,%rsi,1)
  jmp    L241
L214:
  orq    $0x0,-0x8(%rsp,%rsi,1)
  jmp    L239
L237:
  xor    %eax,%eax
  nopw   0x0(%rax,%rax,1)
L22:
  movss  (%rdi,%rax,1),%xmm0
  addss  0x0(%r13,%rax,1),%xmm0
  movss  %xmm0,(%r15,%rax,1)
  add    $0x4,%rax
  cmp    %rax,%r9
  jne    L22
L4:
  movss  D8(%rip),%xmm0
  mulss  (%r15),%xmm0
  movss  %xmm0,(%r15)
  mov    -0x38(%rbp),%rax
  sub    %fs:0x28,%rax
  jne    L186
  lea    -0x28(%rbp),%rsp
  pop    %rbx
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  pop    %rbp
  ret
  nopw   0x0(%rax,%rax,1)
L201:
  mov    -0x50(%rbp),%rbx
  mov    -0x60(%rbp),%rsi
  xor    %ecx,%ecx
  lea    0x4(,%rbx,4),%r9
  nopw   0x0(%rax,%rax,1)
L25:
  movss  (%rdi,%rcx,1),%xmm1
  mulss  %xmm0,%xmm1
  addss  (%rsi,%rcx,1),%xmm1
  movss  %xmm1,(%rdi,%rcx,1)
  add    $0x4,%rcx
  cmp    %rcx,%r9
  jne    L25
  movslq %edx,%rcx
  mov    -0x54(%rbp),%r12d
  mov    %r13,%rbx
  pxor   %xmm1,%xmm1
  lea    (%r8,%rcx,4),%r8
  lea    0x1(%rdx),%r10d
  movss  (%r8),%xmm3
  mov    %r8,%r11
  mov    %r8,%rsi
  sub    -0x48(%rbp),%r11
  movaps %xmm3,%xmm0
  nopl   0x0(%rax)
L291:
  subss  %xmm1,%xmm1
  movaps %xmm3,%xmm2
  cmp    $0x1,%r12d
  jle    L40
  xor    %edx,%edx
  nop
L131:
  mulss  %xmm2,%xmm0
  movss  0x4(%r8,%rdx,4),%xmm2
  addss  %xmm0,%xmm1
  movss  0x4(%rsi,%rdx,4),%xmm0
  add    $0x1,%rdx
  lea    (%r10,%rdx,1),%ecx
  cmp    %ecx,%eax
  jg     L131
L40:
  mulss  %xmm0,%xmm2
  add    $0x4,%rbx
  addss  %xmm2,%xmm1
  movss  %xmm1,-0x4(%rbx)
  cmp    %rsi,%r11
  je     L237
  movss  -0x4(%rsi),%xmm0
  sub    $0x4,%rsi
  jmp    L291
L77:
  mov    %r8,%rsi
  jmp    L289
L186:
  call   <__stack_chk_fail@plt>
```

tool_calls: name: unpack_data
arguments: label: D8
type: byte[4]

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

assistant: ```c
void hybwin(int lpsize, int framesize, int nrsize, float old_input[], float new_input[], float output[], float window[], float rec[], float decay) {
  int N1 = lpsize + framesize;
  int N2 = lpsize + nrsize;
  int N3 = lpsize + framesize + nrsize;
  int i;
  float ws[N3];
  float tmp1[lpsize + 1], tmp2[lpsize + 1];
  for (i = 0; i < N2; i++)
    old_input[i] = old_input[i + framesize];
  for (i = 0; i < framesize; i++)
    old_input[N2 + i] = new_input[i];
  {
    typeof(&old_input[0]) __xp = old_input;
    typeof(&window[0]) __yp = window;
    typeof(&ws[0]) __zp = ws;
    int i;
    typeof(old_input[0]) __xi = *__xp++;
    typeof(window[0]) __yi = *__yp++;
    typeof(ws[0]) __zi;
    for (i = 1; i < N3; i++) {
      __zi = __xi * __yi;
      __xi = *__xp++;
      __yi = *__yp++;
      *__zp++ = __zi;
    }
    __zi = __xi * __yi;
    *__zp = __zi;
  };
  {
    int __k, __i, __M1 = lpsize + 1;
    typeof(&tmp1[0]) __rp = tmp1;
    typeof(*tmp1) __corr = 0;
    for (__k = 0; __k <= lpsize; __k++) {
      typeof(*tmp1) __t;
      typeof(&ws[0]) __xip = ws + lpsize, __xkp = __xip - __k;
      typeof(ws[0]) __xi, __xk;
      __corr = __corr - __corr;
      __xi = *__xip++;
      __xk = *__xkp++;
      for (__i = __M1; __i < N1; __i++) {
        __t = __xi * __xk;
        __xi = *__xip++;
        __corr += __t;
        __xk = *__xkp++;
      }
      __t = __xi * __xk;
      __corr += __t;
      *(__rp++) = __corr;
    }
  };
  for (i = 0; i <= lpsize; i++)
    rec[i] = decay * rec[i] + tmp1[i];
  {
    int __k, __i, __M1 = N1 + 1;
    typeof(&tmp2[0]) __rp = tmp2;
    typeof(*tmp2) __corr = 0;
    for (__k = 0; __k <= lpsize; __k++) {
      typeof(*tmp2) __t;
      typeof(&ws[0]) __xip = ws + N1, __xkp = __xip - __k;
      typeof(ws[0]) __xi, __xk;
      __corr = __corr - __corr;
      __xi = *__xip++;
      __xk = *__xkp++;
      for (__i = __M1; __i < N3; __i++) {
        __t = __xi * __xk;
        __xi = *__xip++;
        __corr += __t;
        __xk = *__xkp++;
      }
      __t = __xi * __xk;
      __corr += __t;
      *(__rp++) = __corr;
    }
  };
  for (i = 0; i <= lpsize; i++)
    output[i] = rec[i] + tmp2[i];
  output[0] *= (257. / 256.);
}
```