user: 下面的汇编指令对应的C源代码是什么:

```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
L91:
  movl   $0x0,(%rdx)
  add    $0x4,%rdx
  cmp    %rcx,%rdx
  jne    L91
  test   %r12d,%r12d
  jle    L152
  mov    %rdi,%rdx
  lea    -0x1(%r12),%esi
  lea    0x8(%rdi,%rsi,8),%r8
L170:
  mov    (%rdx),%rsi
  addl   $0x1,(%rsp,%rsi,4)
  add    $0x8,%rdx
  cmp    %r8,%rdx
  jne    L170
L152:
  lea    0x4(%rsp),%rdx
L136:
  mov    -0x4(%rdx),%esi
  add    %esi,(%rdx)
  add    $0x4,%rdx
  cmp    %rcx,%rdx
  jne    L136
  lea    0x3f8(%rsp),%rdx
L114:
  mov    %rdx,%rcx
  mov    (%rdx),%esi
  mov    %esi,0x4(%rdx)
  sub    $0x4,%rdx
  cmp    %rax,%rcx
  jne    L114
  movl   $0x0,(%rsp)
  test   %r12d,%r12d
  jle    L74
  mov    %r12d,%r8d
  mov    $0x0,%ecx
L232:
  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    L232
  mov    %r12d,(%rbx)
  mov    $0x0,%edx
L116:
  mov    (%rdi,%rdx,8),%rcx
  mov    (%rsp,%rcx,4),%ecx
  mov    %ecx,0x0(%rbp,%rdx,4)
  add    $0x1,%rdx
  cmp    %rdx,%r8
  jne    L116
L74:
  movslq %r12d,%rdx
  movl   $0x0,0x0(%rbp,%rdx,4)
  lea    0x3fc(%rax),%rsi
  jmp    L71
L165:
  add    $0x4,%rax
  cmp    %rsi,%rax
  je     L31
L71:
  mov    0x4(%rax),%ecx
  mov    (%rax),%edi
  lea    0x1(%rdi),%edx
  cmp    %edx,%ecx
  jne    L165
  movslq %ecx,%rcx
  movl   $0xffffffff,(%rbx,%rcx,4)
  jmp    L165
L31:
  movl   $0xffffffff,(%rbx)
  mov    %r12d,%r15d
  not    %r15d
  mov    $0x1,%r14d
  test   %r12d,%r12d
  jne    L78
  movslq 0x0(%rbp),%rax
  movl   $0x0,(%rbx,%rax,4)
  jmp    L193
L90:
  sub    %ecx,%eax
  sub    %ecx,%edx
  jmp    L158
L182:
  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
L158:
  cmp    %edx,%r12d
  jl     L194
L212:
  movslq %edx,%rcx
  lea    (%rbx,%rcx,4),%rsi
  mov    (%rsi),%ecx
  test   %ecx,%ecx
  js     L90
  test   %eax,%eax
  je     L182
  mov    %edx,%ecx
  sub    %eax,%ecx
  movslq %ecx,%rcx
  neg    %eax
  mov    %eax,(%rbx,%rcx,4)
  jmp    L182
L194:
  test   %eax,%eax
  je     L144
  sub    %eax,%edx
  movslq %edx,%rdx
  neg    %eax
  mov    %eax,(%rbx,%rdx,4)
L144:
  add    %r14d,%r14d
  cmp    %r15d,(%rbx)
  je     L109
L78:
  mov    $0x0,%eax
  mov    $0x0,%edx
  test   %r12d,%r12d
  jns    L212
  jmp    L144
L109:
  test   %r12d,%r12d
  js     L193
  mov    $0x0,%eax
L180:
  movslq 0x0(%rbp,%rax,4),%rdx
  mov    %eax,(%rbx,%rdx,4)
  add    $0x1,%rax
  cmp    %eax,%r12d
  jge    L180
L193:
  mov    0x408(%rsp),%rax
  sub    %fs:0x28,%rax
  jne    L237
  add    $0x418,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
L237:
  call   <__stack_chk_fail@plt>
```

assistant: ```c
void qsufsort(off_t *I, off_t *V, u_char *old, off_t oldsize) {
  off_t buckets[256];
  off_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;
}
```