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

```asm
<scramble>:
  endbr64
  push   %r15
  push   %r14
  push   %r13
  movslq %esi,%r13
  push   %r12
  mov    %r13d,%esi
  mov    %rdi,%r12
  mov    %r13d,%r14d
  push   %rbp
  mov    %r13d,%ebp
  sar    $0x2,%r14d
  push   %rbx
  sar    %ebp
  movslq %ebp,%r15
  sub    $0x18,%rsp
  call   <bitrev@plt>
  mov    %ebp,%esi
  mov    %r12,%rdi
  call   <bitrev@plt>
  lea    0x0(,%r15,4),%rdx
  mov    %ebp,%esi
  lea    (%r12,%rdx,1),%rbx
  mov    %rdx,0x8(%rsp)
  mov    %rbx,%rdi
  call   <bitrev@plt>
  test   %r14d,%r14d
  jle    L25
  movslq %r14d,%rax
  lea    -0x1(%r13),%edi
  shl    $0x2,%r13
  mov    0x8(%rsp),%rdx
  lea    (%r15,%rax,1),%rsi
  neg    %rax
  mov    %r14d,%ecx
  lea    0x0(%r13,%rax,4),%rax
  shl    $0x2,%rsi
  cmp    %rax,%rsi
  setle  %al
  cmp    %r13,%rdx
  setge  %dl
  or     %dl,%al
  je     L91
  cmp    $0x1,%r14d
  je     L91
  lea    -0x1(%r14),%eax
  cmp    $0x2,%eax
  jbe    L12
  mov    %r14d,%esi
  lea    -0x10(%r12,%r13,1),%rcx
  mov    %rbx,%rax
  shr    $0x2,%esi
  lea    -0x10(%rcx),%rdx
  lea    -0x1(%rsi),%r8d
  mov    %rdx,%rsi
  shl    $0x4,%r8
  sub    %r8,%rsi
  jmp    L103
  nopl   (%rax)
L78:
  sub    $0x10,%rdx
L103:
  movups (%rcx),%xmm0
  movups (%rax),%xmm1
  add    $0x10,%rax
  shufps $0x1b,%xmm1,%xmm1
  shufps $0x1b,%xmm0,%xmm0
  movups %xmm1,(%rcx)
  mov    %rdx,%rcx
  movups %xmm0,-0x10(%rax)
  cmp    %rsi,%rdx
  jne    L78
  mov    %r14d,%eax
  and    $0xfffffffc,%eax
  sub    %eax,%edi
  add    %eax,%ebp
  cmp    %eax,%r14d
  je     L25
  mov    %r14d,%ecx
  sub    %eax,%ecx
  cmp    $0x1,%ecx
  je     L106
L20:
  mov    %rax,%rdx
  add    %r15,%rax
  neg    %rdx
  lea    (%r12,%rax,4),%rax
  lea    -0x8(%r13,%rdx,4),%rdx
  movq   (%rax),%xmm1
  add    %r12,%rdx
  movq   (%rdx),%xmm0
  shufps $0xe1,%xmm1,%xmm1
  movlps %xmm1,(%rdx)
  shufps $0xe1,%xmm0,%xmm0
  movlps %xmm0,(%rax)
  mov    %ecx,%eax
  and    $0xfffffffe,%eax
  sub    %eax,%edi
  add    %eax,%ebp
  cmp    %eax,%ecx
  je     L25
L106:
  movslq %edi,%rax
  lea    (%r12,%rax,4),%rdx
  movslq %ebp,%rax
  lea    (%r12,%rax,4),%rax
  movss  (%rdx),%xmm0
  movss  (%rax),%xmm1
  movss  %xmm1,(%rdx)
  movss  %xmm0,(%rax)
L25:
  add    $0x18,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
  nopl   0x0(%rax,%rax,1)
L91:
  lea    -0x1(%r14),%ecx
  lea    -0x4(%r12,%r13,1),%rdx
  mov    %rbx,%rax
  add    %r15,%rcx
  lea    0x4(%r12,%rcx,4),%rcx
  nopl   0x0(%rax)
L89:
  movss  (%rdx),%xmm0
  movss  (%rax),%xmm1
  add    $0x4,%rax
  sub    $0x4,%rdx
  movss  %xmm1,0x4(%rdx)
  movss  %xmm0,-0x4(%rax)
  cmp    %rcx,%rax
  jne    L89
  add    $0x18,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
L12:
  xor    %eax,%eax
  jmp    L20
```

assistant: ```c
void scramble(float *f, int len) {
  float temp;
  int i, ii1, ii2, halflen, qtrlen;
  halflen = len >> 1;
  qtrlen = halflen >> 1;
  bitrev(f, len);
  bitrev(&f[0], halflen);
  bitrev(&f[halflen], halflen);
  ii1 = len - 1;
  ii2 = halflen;
  for (i = 0; i <= qtrlen - 1; i++) {
    temp = f[ii1];
    f[ii1] = f[ii2];
    f[ii2] = temp;
    ii1--;
    ii2++;
  }
}
```