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

```asm
<dedisperse_kernel_lagged>:
  endbr64
  push   %r15
  push   %r14
  mov    %rdi,%r14
  mov    %edx,%edi
  push   %r13
  not    %edi
  mov    %edx,%r13d
  push   %r12
  and    $0x1,%edi
  mov    %r8d,%r12d
  push   %rbp
  mov    %rsi,%rbp
  push   %rbx
  mov    %ecx,%ebx
  sub    $0x18,%rsp
  call   <assert@plt>
  mov    %r13d,%eax
  shr    $0x1f,%eax
  add    %r13d,%eax
  sar    %eax
  mov    %eax,0x4(%rsp)
  cmp    $0x1,%r13d
  jle    L93
  mov    %eax,%r11d
  movslq %r12d,%rax
  lea    0x1(%r12),%r13d
  mov    %r14,%rsi
  mov    %rax,%r8
  mov    %rax,0x8(%rsp)
  mov    %r12d,%eax
  lea    (%r12,%rbx,1),%edx
  neg    %r8
  lea    0x4(,%rax,4),%r9
  xor    %r10d,%r10d
  shl    $0x2,%r8
  lea    -0x1(%r12),%edi
  nopl   0x0(%rax)
L46:
  test   %r12d,%r12d
  jle    L6
  mov    0x8(%rsi),%r15
  mov    0x0(%rbp,%r10,8),%r14
  xor    %eax,%eax
L90:
  movss  (%r15,%rax,4),%xmm0
  mov    %rax,%rcx
  movss  %xmm0,(%r14,%rax,4)
  add    $0x1,%rax
  cmp    %rcx,%rdi
  jne    L90
L6:
  cmp    %ebx,%r12d
  jge    L97
  mov    (%rsi),%rcx
  mov    0x8(%rsi),%r15
  mov    0x0(%rbp,%r10,8),%r14
  mov    0x8(%rsp),%rax
  add    %r8,%rcx
  nopl   0x0(%rax)
L20:
  movss  (%rcx,%rax,4),%xmm0
  addss  (%r15,%rax,4),%xmm0
  movss  %xmm0,(%r14,%rax,4)
  add    $0x1,%rax
  cmp    %eax,%ebx
  jg     L20
L97:
  cmp    %edx,%ebx
  jge    L127
  mov    (%rsi),%rcx
  mov    0x0(%rbp,%r10,8),%r14
  movslq %ebx,%rax
  add    %r8,%rcx
  nopl   0x0(%rax,%rax,1)
L12:
  movss  (%rcx,%rax,4),%xmm0
  movss  %xmm0,(%r14,%rax,4)
  add    $0x1,%rax
  cmp    %eax,%edx
  jg     L12
L127:
  test   %r12d,%r12d
  js     L92
  movslq %r11d,%rax
  mov    0x8(%rsi),%r14
  mov    0x0(%rbp,%rax,8),%rcx
  xor    %eax,%eax
  xchg   %ax,%ax
L60:
  movss  (%r14,%rax,1),%xmm0
  movss  %xmm0,(%rcx,%rax,1)
  add    $0x4,%rax
  cmp    %rax,%r9
  jne    L60
L92:
  cmp    %r13d,%ebx
  jle    L79
  mov    (%rsi),%rcx
  movslq %r11d,%rax
  mov    0x8(%rsi),%r15
  mov    0x0(%rbp,%rax,8),%r14
  movslq %r13d,%rax
  add    %r8,%rcx
  xchg   %ax,%ax
L81:
  movss  -0x4(%rcx,%rax,4),%xmm0
  addss  (%r15,%rax,4),%xmm0
  movss  %xmm0,(%r14,%rax,4)
  add    $0x1,%rax
  cmp    %eax,%ebx
  jg     L81
L79:
  cmp    %edx,%ebx
  jg     L107
  mov    (%rsi),%rcx
  movslq %r11d,%rax
  mov    0x0(%rbp,%rax,8),%r14
  movslq %ebx,%rax
  add    %r8,%rcx
  nop
L100:
  movss  -0x4(%rcx,%rax,4),%xmm0
  movss  %xmm0,(%r14,%rax,4)
  add    $0x1,%rax
  cmp    %eax,%edx
  jge    L100
L107:
  add    $0x1,%r10
  add    $0x10,%rsi
  add    $0x1,%r11d
  cmp    %r10d,0x4(%rsp)
  jg     L46
L93:
  add    $0x18,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
```

assistant: ```c
void dedisperse_kernel_lagged(float **in, float **out, int n, int m, int s) {
  assert(n % 2 == 0);
  int npair = n / 2;
  for (int jj = 0; jj < npair; jj++) {
    for (int i = 0; i < s; i++)
      out[jj][i] = in[2 * jj + 1][i];
    for (int i = s; i < m; i++)
      out[jj][i] = in[2 * jj][i - s] + in[2 * jj + 1][i];
    for (int i = m; i < m + s; i++)
      out[jj][i] = in[2 * jj][i - s];
    for (int i = 0; i < s + 1; i++)
      out[jj + npair][i] = in[2 * jj + 1][i];
    for (int i = s + 1; i < m; i++)
      out[jj + npair][i] = in[2 * jj][i - s - 1] + in[2 * jj + 1][i];
    for (int i = m; i < m + s + 1; i++)
      out[jj + npair][i] = in[2 * jj][i - s - 1];
  }
}
```