user: What would the C source look like for the assembly code provided here:

```asm
<qsufsort>:
  endbr64
  push   %r15
  push   %r14
  push   %r13
  push   %r12
  push   %rbp
  push   %rbx
  sub    $0x418,%rsp
  mov    %rdi,%rbx
  mov    %rsi,%rbp
  mov    %rdx,%rdi
  mov    %ecx,%r12d
  mov    %fs:0x28,%rax
  mov    %rax,0x408(%rsp)
  xor    %eax,%eax
  mov    %rsp,%rax
  lea    0x400(%rsp),%rcx
  mov    %rax,%rdx
L21:
  movl   $0x0,(%rdx)
  add    $0x4,%rdx
  cmp    %rcx,%rdx
  jne    L21
  test   %r12d,%r12d
  jle    L106
  mov    %rdi,%rdx
  lea    -0x1(%r12),%esi
  lea    0x8(%rdi,%rsi,8),%r8
L112:
  mov    (%rdx),%rsi
  addl   $0x1,(%rsp,%rsi,4)
  add    $0x8,%rdx
  cmp    %r8,%rdx
  jne    L112
L106:
  lea    0x4(%rsp),%rdx
L198:
  mov    -0x4(%rdx),%esi
  add    %esi,(%rdx)
  add    $0x4,%rdx
  cmp    %rcx,%rdx
  jne    L198
  lea    0x3f8(%rsp),%rdx
L73:
  mov    %rdx,%rcx
  mov    (%rdx),%esi
  mov    %esi,0x4(%rdx)
  sub    $0x4,%rdx
  cmp    %rax,%rcx
  jne    L73
  movl   $0x0,(%rsp)
  test   %r12d,%r12d
  jle    L68
  mov    %r12d,%r8d
  mov    $0x0,%ecx
L48:
  mov    (%rdi,%rcx,8),%rsi
  mov    (%rsp,%rsi,4),%edx
  add    $0x1,%edx
  mov    %edx,(%rsp,%rsi,4)
  movslq %edx,%rdx
  mov    %ecx,(%rbx,%rdx,4)
  add    $0x1,%rcx
  cmp    %rcx,%r8
  jne    L48
  mov    %r12d,(%rbx)
  mov    $0x0,%edx
L142:
  mov    (%rdi,%rdx,8),%rcx
  mov    (%rsp,%rcx,4),%ecx
  mov    %ecx,0x0(%rbp,%rdx,4)
  add    $0x1,%rdx
  cmp    %rdx,%r8
  jne    L142
L68:
  movslq %r12d,%rdx
  movl   $0x0,0x0(%rbp,%rdx,4)
  lea    0x3fc(%rax),%rsi
  jmp    L216
L104:
  add    $0x4,%rax
  cmp    %rsi,%rax
  je     L161
L216:
  mov    0x4(%rax),%ecx
  mov    (%rax),%edi
  lea    0x1(%rdi),%edx
  cmp    %edx,%ecx
  jne    L104
  movslq %ecx,%rcx
  movl   $0xffffffff,(%rbx,%rcx,4)
  jmp    L104
L161:
  movl   $0xffffffff,(%rbx)
  mov    %r12d,%r15d
  not    %r15d
  mov    $0x1,%r14d
  test   %r12d,%r12d
  jne    L147
  movslq 0x0(%rbp),%rax
  movl   $0x0,(%rbx,%rax,4)
  jmp    L84
L33:
  sub    %ecx,%eax
  sub    %ecx,%edx
  jmp    L233
L256:
  movslq (%rsi),%rax
  mov    0x0(%rbp,%rax,4),%r13d
  add    $0x1,%r13d
  mov    %r13d,%ecx
  sub    %edx,%ecx
  mov    %r14d,%r8d
  mov    %rbp,%rsi
  mov    %rbx,%rdi
  call   <split@plt>
  mov    %r13d,%edx
  mov    $0x0,%eax
L233:
  cmp    %edx,%r12d
  jl     L17
L227:
  movslq %edx,%rcx
  lea    (%rbx,%rcx,4),%rsi
  mov    (%rsi),%ecx
  test   %ecx,%ecx
  js     L33
  test   %eax,%eax
  je     L256
  mov    %edx,%ecx
  sub    %eax,%ecx
  movslq %ecx,%rcx
  neg    %eax
  mov    %eax,(%rbx,%rcx,4)
  jmp    L256
L17:
  test   %eax,%eax
  je     L193
  sub    %eax,%edx
  movslq %edx,%rdx
  neg    %eax
  mov    %eax,(%rbx,%rdx,4)
L193:
  add    %r14d,%r14d
  cmp    %r15d,(%rbx)
  je     L89
L147:
  mov    $0x0,%eax
  mov    $0x0,%edx
  test   %r12d,%r12d
  jns    L227
  jmp    L193
L89:
  test   %r12d,%r12d
  js     L84
  mov    $0x0,%eax
L207:
  movslq 0x0(%rbp,%rax,4),%rdx
  mov    %eax,(%rbx,%rdx,4)
  add    $0x1,%rax
  cmp    %eax,%r12d
  jge    L207
L84:
  mov    0x408(%rsp),%rax
  sub    %fs:0x28,%rax
  jne    L20
  add    $0x418,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
L20:
  call   <__stack_chk_fail@plt>
```

assistant: ```c
void qsufsort(int32_t *I, int32_t *V, u_char *old, int32_t oldsize) {
  int32_t buckets[256];
  int32_t i, h, len;
  for (i = 0; i < 256; i++)
    buckets[i] = 0;
  for (i = 0; i < oldsize; i++)
    buckets[old[i]]++;
  for (i = 1; i < 256; i++)
    buckets[i] += buckets[i - 1];
  for (i = 255; i > 0; i--)
    buckets[i] = buckets[i - 1];
  buckets[0] = 0;
  for (i = 0; i < oldsize; i++)
    I[++buckets[old[i]]] = i;
  I[0] = oldsize;
  for (i = 0; i < oldsize; i++)
    V[i] = buckets[old[i]];
  V[oldsize] = 0;
  for (i = 1; i < 256; i++)
    if (buckets[i] == buckets[i - 1] + 1)
      I[buckets[i]] = -1;
  I[0] = -1;
  for (h = 1; I[0] != -(oldsize + 1); h += h) {
    len = 0;
    for (i = 0; i < oldsize + 1;) {
      if (I[i] < 0) {
        len -= I[i];
        i -= I[i];
      } else {
        if (len)
          I[i - len] = -len;
        len = V[I[i]] + 1 - i;
        split(I, V, i, len, h);
        i += len;
        len = 0;
      };
    };
    if (len)
      I[i - len] = -len;
  };
  for (i = 0; i < oldsize + 1; i++)
    I[V[i]] = i;
}
```