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

```asm
<_inv_postaud>:
  endbr64
  push   %r15
  push   %r14
  push   %r13
  push   %r12
  push   %rbp
  push   %rbx
  sub    $0x28,%rsp
  mov    %rdi,%r12
  mov    %rsi,%rbp
  mov    %edx,%r14d
  divsd  D14(%rip),%xmm0
  movsd  %xmm0,0x8(%rsp)
  mulsd  %xmm0,%xmm0
  addsd  D83(%rip),%xmm0
  call   <sqrt@plt>
  pxor   %xmm0,%xmm0
  cvtsi2sd %rax,%xmm0
  addsd  0x8(%rsp),%xmm0
  cvttsd2si %xmm0,%rdi
  call   <log@plt>
  lea    -0x1(%r14),%ebx
  cmpq   $0x0,D42(%rip)
  je     L35
  cmp    $0x1,%ebx
  jle    L14
L21:
  mov    $0x1,%r13d
L18:
  pxor   %xmm0,%xmm0
  cvtss2sd (%r12,%r13,4),%xmm0
  mov    D113(%rip),%rax
  movq   %rax,%xmm1
  call   <pow@plt>
  movapd %xmm0,%xmm1
  mov    D42(%rip),%rax
  pxor   %xmm0,%xmm0
  cvtss2sd (%rax,%r13,4),%xmm0
  mulsd  %xmm1,%xmm0
  cvtsd2ss %xmm0,%xmm0
  movss  %xmm0,0x0(%rbp,%r13,4)
  add    $0x1,%r13
  cmp    %r13d,%ebx
  jg     L18
L14:
  movl   $0x0,0x0(%rbp)
  movslq %ebx,%rbx
  movl   $0x0,0x0(%rbp,%rbx,4)
  mov    %r14d,%eax
  add    $0x28,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
L35:
  mov    %eax,%r13d
  lea    0x0(,%r14,4),%edi
  call   <malloc@plt>
  mov    %rax,D13(%rip)
  cmp    $0x1,%ebx
  jle    L14
  pxor   %xmm0,%xmm0
  cvtsi2sd %r13d,%xmm0
  mulsd  D13(%rip),%xmm0
  cvtsd2ss %xmm0,%xmm0
  pxor   %xmm1,%xmm1
  cvtsi2ss %ebx,%xmm1
  divss  %xmm1,%xmm0
  movss  %xmm0,0x1c(%rsp)
  lea    -0x3(%r14),%eax
  mov    %rax,0x10(%rsp)
  mov    $0x0,%r13d
L11:
  lea    0x1(%r13),%eax
  pxor   %xmm0,%xmm0
  cvtsi2ss %eax,%xmm0
  mulss  0x1c(%rsp),%xmm0
  cvtss2sd %xmm0,%xmm0
  divsd  D13(%rip),%xmm0
  movsd  %xmm0,0x8(%rsp)
  call   <exp@plt>
  mov    %eax,%r15d
  movsd  0x8(%rsp),%xmm0
  xorpd  D131(%rip),%xmm0
  call   <exp@plt>
  sub    %eax,%r15d
  pxor   %xmm0,%xmm0
  cvtsi2sd %r15d,%xmm0
  mulsd  D116(%rip),%xmm0
  cvtsd2ss %xmm0,%xmm0
  mulss  %xmm0,%xmm0
  movss  D76(%rip),%xmm1
  addss  %xmm0,%xmm1
  divss  %xmm0,%xmm1
  lea    0x1(%r13),%rax
  movaps %xmm0,%xmm2
  addss  D70(%rip),%xmm2
  addss  D99(%rip),%xmm0
  divss  %xmm0,%xmm2
  mulss  %xmm1,%xmm1
  mulss  %xmm1,%xmm2
  mov    D13(%rip),%rdx
  movss  %xmm2,(%rdx,%rax,4)
  mov    %r13,%rdx
  mov    %rax,%r13
  cmp    %rdx,0x10(%rsp)
  jne    L11
  jmp    L21
```

tool_calls: name: read_data
arguments: label: D14
type_infered: f64
name: read_data
arguments: label: D83
type_infered: f64
name: read_data
arguments: label: D113
type_infered: byte[8]
name: read_data
arguments: label: D13
type_infered: f64
name: read_data
arguments: label: D131
type_infered: byte[16]
name: read_data
arguments: label: D116
type_infered: f64
name: read_data
arguments: label: D76
type_infered: f32
name: read_data
arguments: label: D70
type_infered: f32
name: read_data
arguments: label: D99
type_infered: f32

tool: D14: 1200

tool: D83: 1

tool: {"D113": [0x3e,0xf8,0xe0,0x83,0x0f,0x3e,0x08,0x40]}

tool: D13: 6

tool: {"D131": [0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00]}

tool: D116: 300

tool: D76: 160000

tool: D70: 9610000

tool: D99: 1440000

assistant: ```c
int _inv_postaud(float *input, float *output, int len, double srate) {
  int i, lastfilt;
  float step_barks;
  float f_bark_mid, f_hz_mid;
  float ftmp, fsq, nyqbar;
  double tmp;
  char funcname[] = "inv_postaud";
  static float *inveql = NULL;
  int nfilts = len;
  int first_good = 1;
  tmp = srate / 1200.;
  nyqbar = 6. * log((srate / 1200.) + sqrt(tmp * tmp + 1.));
  step_barks = nyqbar / (float)(nfilts - 1);
  lastfilt = nfilts - first_good;
  if (inveql == NULL) {
    inveql = (float *)malloc(nfilts * sizeof(float));
    for (i = first_good; i < lastfilt; i++) {
      f_bark_mid = i * step_barks;
      f_hz_mid = 300. * (exp((double)f_bark_mid / 6.) - exp(-(double)f_bark_mid / 6.));
      fsq = (f_hz_mid * f_hz_mid);
      ftmp = fsq + 1.6e5;
      inveql[i] = (ftmp / fsq) * (ftmp / fsq) * ((fsq + (float)9.61e6) / (fsq + (float)1.44e6));
    }
  }
  for (i = first_good; i < lastfilt; i++) {
    tmp = pow((double)input[i], 1.0 / .33);
    output[i] = tmp * inveql[i];
  }
  for (i = first_good; i > 0; i--) {
    output[i - 1] = 0;
  }
  for (i = lastfilt; i < nfilts; i++) {
    output[i] = 0;
  }
  return (nfilts);
}
```