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

```asm
<idwt2D_neo_a>:
  endbr64
  push   %r15
  push   %r14
  mov    %r8d,%r14d
  push   %r13
  mov    %rdi,%r13
  push   %r12
  push   %rbp
  push   %rbx
  mov    %r9d,%ebx
  sub    $0x78,%rsp
  mov    0xb0(%rsp),%rax
  mov    0xe0(%rsp),%ebp
  mov    %rsi,0x8(%rsp)
  mov    %rdx,0x60(%rsp)
  mov    0xc8(%rsp),%r15
  mov    %rax,0x28(%rsp)
  mov    0xb8(%rsp),%rax
  mov    %rcx,0x68(%rsp)
  mov    0xd0(%rsp),%r12d
  mov    %rax,0x30(%rsp)
  mov    0xc0(%rsp),%rax
  mov    %r9d,0x20(%rsp)
  mov    %rax,(%rsp)
  mov    0xd8(%rsp),%rax
  mov    %rax,0x50(%rsp)
  mov    0xe8(%rsp),%eax
  mov    %eax,0x24(%rsp)
  mov    %r9d,%eax
  imul   %ebp,%eax
  shl    $0x3,%eax
  mov    %eax,%edi
  mov    %eax,0x44(%rsp)
  call   <malloc@plt>
  mov    0x44(%rsp),%edi
  mov    %rax,0x38(%rsp)
  call   <malloc@plt>
  mov    %rax,0x48(%rsp)
  test   %ebx,%ebx
  jle    L26
  movslq %ebp,%rax
  mov    0x8(%rsp),%rsi
  movslq %r14d,%rbx
  mov    0x38(%rsp),%r10
  shl    $0x3,%rbx
  mov    %r13,%rdi
  mov    %r14d,0x18(%rsp)
  mov    %r12d,%r9d
  mov    %ebp,0x40(%rsp)
  mov    %rbx,%r12
  xor    %r13d,%r13d
  mov    %rsi,%r14
  lea    0x0(,%rax,8),%rcx
  mov    %rdi,%rbx
  mov    %r10,%rbp
  mov    %rcx,0x8(%rsp)
  nopw   0x0(%rax,%rax,1)
L8:
  mov    0x40(%rsp),%eax
  mov    %rbx,%rdi
  mov    %r15,%r8
  mov    %r14,%rsi
  add    %r12,%rbx
  add    %r12,%r14
  push   %rax
  push   %rbp
  mov    0x10(%rsp),%rcx
  mov    0x28(%rsp),%edx
  mov    %r9d,0x20(%rsp)
  call   <idwt_neo@plt>
  add    0x18(%rsp),%rbp
  mov    %r13d,%r11d
  pop    %rdi
  lea    0x1(%r13),%r13d
  pop    %r8
  cmp    %r13d,0x20(%rsp)
  mov    0x10(%rsp),%r9d
  jne    L8
  mov    0x40(%rsp),%ebp
  mov    0x20(%rsp),%esi
  mov    %r12,%rbx
  mov    %r9d,%r12d
  mov    0x38(%rsp),%r13
  mov    0x48(%rsp),%rcx
  mov    %r11d,0x10(%rsp)
  mov    %ebp,%r9d
  mov    %esi,%r8d
  mov    %ebp,%edx
  mov    0x18(%rsp),%r14d
  mov    %r13,%rdi
  call   <matrix_tran@plt>
  mov    %r13,%rdi
  xor    %r13d,%r13d
  call   <free@plt>
  mov    0x44(%rsp),%edi
  call   <malloc@plt>
  mov    0x10(%rsp),%r11d
  mov    %r15,%r8
  mov    %r12d,%r9d
  mov    0x60(%rsp),%rdi
  mov    0x68(%rsp),%rsi
  mov    %ebp,0x40(%rsp)
  mov    %r14d,%r15d
  mov    %rax,0x58(%rsp)
  mov    %rbx,%rbp
  mov    %rax,%r14
  mov    %r11d,0x38(%rsp)
  mov    %rsi,%r12
  mov    %rdi,%rbx
  nopl   0x0(%rax,%rax,1)
L59:
  mov    0x40(%rsp),%eax
  mov    %r12,%rsi
  mov    %rbx,%rdi
  mov    %r15d,%edx
  add    %rbp,%rbx
  add    %rbp,%r12
  push   %rax
  push   %r14
  mov    0x10(%rsp),%rcx
  mov    %r9d,0x28(%rsp)
  mov    %r8,0x20(%rsp)
  call   <idwt_neo@plt>
  add    0x18(%rsp),%r14
  mov    %r13d,%eax
  pop    %rcx
  add    $0x1,%r13d
  pop    %rsi
  cmp    %eax,0x38(%rsp)
  mov    0x10(%rsp),%r8
  mov    0x18(%rsp),%r9d
  jne    L59
  mov    0x40(%rsp),%ebp
  mov    %r9d,%r12d
L10:
  mov    0x44(%rsp),%edi
  call   <malloc@plt>
  mov    0x58(%rsp),%rbx
  mov    %ebp,%r9d
  mov    %ebp,%edx
  mov    0x20(%rsp),%r13d
  mov    %rax,%rcx
  mov    %rax,0x10(%rsp)
  mov    %rax,%r14
  mov    %rbx,%rdi
  mov    %r13d,%r8d
  mov    %r13d,%esi
  call   <matrix_tran@plt>
  mov    %rbx,%rdi
  call   <free@plt>
  mov    0x24(%rsp),%ebx
  mov    %ebx,%edi
  imul   %ebp,%edi
  shl    $0x3,%edi
  call   <malloc@plt>
  mov    %rax,0x18(%rsp)
  mov    %rax,%r15
  test   %ebp,%ebp
  jle    L3
  movslq %ebx,%rax
  movslq %r13d,%r10
  mov    0x48(%rsp),%r13
  mov    %ebp,(%rsp)
  shl    $0x3,%rax
  shl    $0x3,%r10
  xor    %ebx,%ebx
  mov    %rax,0x8(%rsp)
  mov    %r10,%rbp
  nopl   (%rax)
L13:
  mov    0x24(%rsp),%eax
  mov    %r14,%rsi
  mov    %r13,%rdi
  mov    %r12d,%r9d
  add    $0x1,%ebx
  add    %rbp,%r13
  add    %rbp,%r14
  push   %rax
  push   %r15
  mov    0x40(%rsp),%r8
  mov    0x38(%rsp),%rcx
  mov    0x30(%rsp),%edx
  call   <idwt_neo@plt>
  add    0x18(%rsp),%r15
  pop    %rax
  pop    %rdx
  cmp    %ebx,(%rsp)
  jne    L13
  mov    (%rsp),%ebp
L3:
  mov    0x48(%rsp),%rdi
  call   <free@plt>
  mov    0x10(%rsp),%rdi
  call   <free@plt>
  mov    0x18(%rsp),%rbx
  mov    0x24(%rsp),%edx
  mov    %ebp,%esi
  mov    0x50(%rsp),%rcx
  mov    %ebp,%r8d
  mov    %rbx,%rdi
  mov    %edx,%r9d
  call   <matrix_tran@plt>
  add    $0x78,%rsp
  mov    %rbx,%rdi
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  jmp    1080 <free@plt>
  nopl   0x0(%rax,%rax,1)
L26:
  mov    0x20(%rsp),%esi
  mov    0x38(%rsp),%rbx
  mov    %ebp,%r9d
  mov    %ebp,%edx
  mov    0x48(%rsp),%rcx
  mov    %esi,%r8d
  mov    %rbx,%rdi
  call   <matrix_tran@plt>
  mov    %rbx,%rdi
  call   <free@plt>
  mov    0x44(%rsp),%edi
  call   <malloc@plt>
  mov    %rax,0x58(%rsp)
  jmp    L10
```

assistant: ```c
void idwt2D_neo_a(double *matrixInApprox, double *matrixInColDetail, double *matrixInRowDetail, double *matrixInDetail, int matrixInRow, int matrixInCol, double *lowReR, double *hiReR, double *lowReC, double *hiReC, int filterLen, double *matrixOut, int matrixOutRow, int matrixOutCol) {
  int row, col;
  int filterOutLength;
  int matrixInRowM, matrixInColM;
  char c = 'b';
  double *matrixOutApproxPre, *matrixOutDetailPre;
  double *matrixOutApproxTemp, *matrixOutDetailTemp;
  double *matrixOutPre;
  matrixInRowM = matrixInRow;
  matrixInColM = matrixInCol;
  filterOutLength = 2 * matrixInRowM + filterLen - 1;
  matrixOutApproxPre = malloc(matrixOutRow * matrixInColM * sizeof(double));
  matrixOutApproxTemp = malloc(matrixOutRow * matrixInColM * sizeof(double));
  for (col = 0; col < matrixInColM; col++)
    idwt_neo((matrixInApprox + col * matrixInRowM), (matrixInColDetail + col * matrixInRowM), matrixInRowM, lowReC, hiReC, filterLen, (matrixOutApproxPre + col * matrixOutRow), matrixOutRow);
  matrix_tran(matrixOutApproxPre, matrixInColM, matrixOutRow, matrixOutApproxTemp, matrixInColM, matrixOutRow);
  free(matrixOutApproxPre);
  matrixOutDetailPre = malloc(matrixOutRow * matrixInColM * sizeof(double));
  for (col = 0; col < matrixInColM; col++)
    idwt_neo((matrixInRowDetail + col * matrixInRowM), (matrixInDetail + col * matrixInRowM), matrixInRowM, lowReC, hiReC, filterLen, (matrixOutDetailPre + col * matrixOutRow), matrixOutRow);
  matrixOutDetailTemp = malloc(matrixOutRow * matrixInColM * sizeof(double));
  matrix_tran(matrixOutDetailPre, matrixInColM, matrixOutRow, matrixOutDetailTemp, matrixInColM, matrixOutRow);
  free(matrixOutDetailPre);
  filterOutLength = 2 * matrixInColM + filterLen - 1;
  matrixOutPre = malloc(matrixOutRow * matrixOutCol * sizeof(double));
  for (row = 0; row < matrixOutRow; row++)
    idwt_neo((matrixOutApproxTemp + row * matrixInColM), (matrixOutDetailTemp + row * matrixInColM), matrixInColM, lowReR, hiReR, filterLen, (matrixOutPre + row * matrixOutCol), matrixOutCol);
  free(matrixOutApproxTemp);
  free(matrixOutDetailTemp);
  matrix_tran(matrixOutPre, matrixOutRow, matrixOutCol, matrixOut, matrixOutRow, matrixOutCol);
  free(matrixOutPre);
  return;
}
```