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

```asm
<ss_mintrosort>:
  endbr64
  push   %r15
  mov    %rsi,%r15
  push   %r14
  mov    %r8d,%r14d
  push   %r13
  mov    %rdx,%r13
  push   %r12
  push   %rbp
  push   %rbx
  mov    %rcx,%rbx
  sub    $0x228,%rsp
  mov    %rdi,0x8(%rsp)
  mov    %rcx,%rdi
  sub    %rdx,%rdi
  sar    $0x2,%rdi
  mov    %fs:0x28,%rax
  mov    %rax,0x218(%rsp)
  xor    %eax,%eax
  call   <ss_ilg@plt>
  movl   $0x0,(%rsp)
  mov    %eax,%ebp
L825:
  mov    %rbx,%rax
  sub    %r13,%rax
  cmp    $0x20,%rax
  jg     L105
  cmp    $0x4,%rax
  jg     L426
L298:
  mov    $0x1,%edi
  call   <assert@plt>
  mov    (%rsp),%eax
  test   %eax,%eax
  jne    L56
  mov    0x218(%rsp),%rax
  sub    %fs:0x28,%rax
  jne    L713
  add    $0x228,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
  nopl   (%rax)
L105:
  mov    0x8(%rsp),%rcx
  movslq %r14d,%rdi
  lea    (%rcx,%rdi,1),%r12
  test   %ebp,%ebp
  je     L700
  lea    -0x1(%rbp),%eax
  movd   %r14d,%xmm3
  movd   %eax,%xmm4
  mov    %eax,0x10(%rsp)
  punpckldq %xmm4,%xmm3
  movq   %xmm3,0x30(%rsp)
  test   %eax,%eax
  js     L409
  mov    %rbx,%rcx
  mov    %r13,%rdx
  mov    %r15,%rsi
  mov    %r12,%rdi
  call   <ss_pivot@plt>
  mov    %r13,%r9
  movslq (%rax),%rcx
  mov    %rcx,%rdx
  movslq (%r15,%rcx,4),%rcx
  movzbl (%r12,%rcx,1),%r10d
  mov    0x0(%r13),%ecx
  mov    %edx,0x0(%r13)
  mov    %r10d,%r8d
  mov    %ecx,(%rax)
  jmp    L565
L183:
  movslq (%r9),%rax
  movslq (%r15,%rax,4),%rax
  movzbl (%r12,%rax,1),%eax
  cmp    %eax,%r10d
  jne    L76
L565:
  mov    %r9,%rdx
  add    $0x4,%r9
  cmp    %r9,%rbx
  ja     L183
  mov    %r9,%rax
L355:
  mov    %rbx,%rcx
  jmp    L415
  nopl   0x0(%rax)
L84:
  movslq (%rcx),%rdi
  mov    %rdi,%rsi
  movslq (%r15,%rdi,4),%rdi
  movzbl (%r12,%rdi,1),%edi
  cmp    %edi,%r10d
  jne    L862
L415:
  mov    %rcx,%rdx
  sub    $0x4,%rcx
  cmp    %rcx,%rax
  jb     L84
  nopl   0x0(%rax)
L714:
  cmp    %rcx,%r9
  jbe    L410
  movslq 0x0(%r13),%rax
  movslq (%r15,%rax,4),%rax
  cmp    -0x1(%r12,%rax,1),%r8b
  ja     L9
L187:
  add    $0x1,%r14d
  jmp    L825
L700:
  sar    $0x2,%rax
  mov    %r13,%rdx
  mov    %r15,%rsi
  mov    %r12,%rdi
  mov    %eax,%ecx
  call   <ss_heapsort@plt>
L409:
  movslq 0x0(%r13),%rax
  lea    0x4(%r13),%rdx
  movslq (%r15,%rax,4),%r8
  movzbl (%r12,%r8,1),%eax
  cmp    %rdx,%rbx
  jbe    L98
  nopl   0x0(%rax,%rax,1)
L726:
  mov    %eax,%ecx
  movslq (%rdx),%rax
  movslq (%r15,%rax,4),%rax
  movzbl (%r12,%rax,1),%eax
  cmp    %ecx,%eax
  je     L628
  mov    %rdx,%rsi
  sub    %r13,%rsi
  cmp    $0x4,%rsi
  jg     L556
  mov    %rdx,%r13
L628:
  add    $0x4,%rdx
  cmp    %rdx,%rbx
  ja     L726
  movslq 0x0(%r13),%rcx
  mov    %r13,%rsi
  mov    %rdx,%r13
  movslq (%r15,%rcx,4),%r8
L166:
  movzbl -0x1(%r12,%r8,1),%ecx
  movq   %rdx,%xmm1
  movq   %rbx,%xmm7
  punpcklqdq %xmm7,%xmm1
  cmp    %eax,%ecx
  jl     L414
L306:
  mov    %rdx,%r12
  movq   %rsi,%xmm0
  movq   %rdx,%xmm2
  mov    %rbx,%rax
  sub    %rsi,%r12
  sub    %rdx,%rax
  punpcklqdq %xmm2,%xmm0
  cmp    %rax,%r12
  jg     L268
  mov    $0xffffffff,%ebp
  cmp    $0x4,%r12
  jle    L825
  mov    (%rsp),%ebx
  xor    %edi,%edi
  mov    %rsi,0x20(%rsp)
  mov    %rdx,0x10(%rsp)
  cmp    $0xf,%ebx
  movaps %xmm1,0x30(%rsp)
  setle  %dil
  call   <assert@plt>
  movslq %ebx,%rax
  mov    %r12,%rdi
  add    $0x1,%ebx
  movdqa 0x30(%rsp),%xmm1
  lea    (%rax,%rax,2),%rax
  sar    $0x2,%rdi
  shl    $0x3,%rax
  mov    %r14d,0xa0(%rsp,%rax,1)
  add    $0x1,%r14d
  movl   $0xffffffff,0xa4(%rsp,%rax,1)
  movups %xmm1,0x90(%rsp,%rax,1)
  call   <ss_ilg@plt>
  mov    %ebx,(%rsp)
  mov    0x20(%rsp),%r13
  mov    0x10(%rsp),%rbx
  mov    %eax,%ebp
  jmp    L825
L56:
  subl   $0x1,(%rsp)
  movslq (%rsp),%rax
  lea    (%rax,%rax,2),%rax
  shl    $0x3,%rax
  mov    0x90(%rsp,%rax,1),%r13
  mov    0x98(%rsp,%rax,1),%rbx
  mov    0xa0(%rsp,%rax,1),%r14d
  mov    0xa4(%rsp,%rax,1),%ebp
  jmp    L825
L426:
  mov    0x8(%rsp),%rdi
  mov    %r14d,%r8d
  mov    %rbx,%rcx
  mov    %r13,%rdx
  mov    %r15,%rsi
  call   <ss_insertionsort@plt>
  jmp    L298
L862:
  mov    %rcx,%r11
  jl     L227
L320:
  mov    %rcx,%rdx
  mov    %r11,%rcx
  nopl   0x0(%rax,%rax,1)
L62:
  mov    (%rax),%edi
  mov    %esi,(%rax)
  add    $0x4,%rax
  mov    %edi,(%rdx)
  cmp    %rax,%rdx
  ja     L29
  jmp    L834
  nopl   0x0(%rax)
L720:
  jne    L639
  mov    (%r9),%edi
  add    $0x4,%r9
  mov    %edi,(%rax)
  mov    %esi,-0x4(%r9)
L639:
  add    $0x4,%rax
  cmp    %rax,%rdx
  jbe    L834
L29:
  movslq (%rax),%rdi
  mov    %rdi,%rsi
  movslq (%r15,%rdi,4),%rdi
  movzbl (%r12,%rdi,1),%edi
  cmp    %edi,%r10d
  jge    L720
L834:
  sub    $0x4,%rdx
  cmp    %rdx,%rax
  jb     L330
  jmp    L714
  nopw   0x0(%rax,%rax,1)
L781:
  jne    L647
  mov    (%rcx),%edi
  sub    $0x4,%rcx
  mov    %edi,(%rdx)
  mov    %esi,0x4(%rcx)
L647:
  sub    $0x4,%rdx
  cmp    %rax,%rdx
  jbe    L714
L330:
  movslq (%rdx),%rdi
  mov    %rdi,%rsi
  movslq (%r15,%rdi,4),%rdi
  movzbl (%r12,%rdi,1),%edi
  cmp    %edi,%r10d
  jle    L781
  cmp    %rax,%rdx
  ja     L62
  jmp    L714
  nopl   0x0(%rax)
L76:
  mov    %r9,%rax
  jle    L355
  lea    0x8(%rdx),%rax
  cmp    %rbx,%rax
  jb     L748
  jmp    L355
  nop
L465:
  jne    L739
  mov    (%r9),%ecx
  add    $0x4,%r9
  mov    %ecx,(%rax)
  mov    %edx,-0x4(%r9)
L739:
  add    $0x4,%rax
  cmp    %rax,%rbx
  jbe    L355
L748:
  movslq (%rax),%rcx
  mov    %rcx,%rdx
  movslq (%r15,%rcx,4),%rcx
  movzbl (%r12,%rcx,1),%ecx
  cmp    %ecx,%r10d
  jge    L465
  jmp    L355
L268:
  sar    $0x2,%r12
  movaps %xmm0,0x10(%rsp)
  mov    %r12d,%ebp
  lea    0x1(%r14),%r12d
  cmp    $0x4,%rax
  jle    L295
  xor    %edi,%edi
  cmpl   $0xf,(%rsp)
  setle  %dil
  call   <assert@plt>
  movslq (%rsp),%rax
  movdqa 0x10(%rsp),%xmm0
  mov    %ebp,%edi
  mov    $0xffffffff,%ebp
  lea    (%rax,%rax,2),%rdx
  shl    $0x3,%rdx
  mov    %r12d,0xa0(%rsp,%rdx,1)
  mov    %rdx,0x10(%rsp)
  movups %xmm0,0x90(%rsp,%rdx,1)
  call   <ss_ilg@plt>
  mov    0x10(%rsp),%rdx
  mov    %eax,0xa4(%rsp,%rdx,1)
  mov    (%rsp),%eax
  add    $0x1,%eax
  mov    %eax,(%rsp)
  jmp    L825
L410:
  lea    -0x4(%rax),%rsi
  mov    %r9,%rdx
  mov    %rsi,0x20(%rsp)
  mov    %rax,%rsi
  sub    %r13,%rdx
  sub    %r9,%rsi
  sar    $0x2,%rdx
  mov    %rsi,0x40(%rsp)
  sar    $0x2,%rsi
  cmp    %esi,%edx
  cmovg  %esi,%edx
  mov    %rax,%rsi
  movslq %edx,%r10
  lea    0x0(,%r10,4),%rdi
  sub    %rdi,%rsi
  test   %edx,%edx
  jle    L656
  mov    %rax,%r9
  sub    %rdi,%r9
  add    $0x10,%r9
  cmp    %r9,%r13
  lea    0x10(%r13),%r9
  setae  %r11b
  cmp    %r9,%rsi
  setae  %r9b
  or     %r11b,%r9b
  je     L649
  cmp    $0x1,%edx
  je     L649
  mov    %edx,%r11d
  cmp    $0x3,%edx
  jle    L839
  mov    %edx,%r10d
  xor    %r9d,%r9d
  shr    $0x2,%r10d
  shl    $0x4,%r10
  nopl   0x0(%rax,%rax,1)
L231:
  movdqu 0x0(%r13,%r9,1),%xmm0
  movdqu (%rsi,%r9,1),%xmm5
  movups %xmm5,0x0(%r13,%r9,1)
  movups %xmm0,(%rsi,%r9,1)
  add    $0x10,%r9
  cmp    %r10,%r9
  jne    L231
  mov    %edx,%ebp
  and    $0xfffffffc,%ebp
  mov    %ebp,%r10d
  lea    0x0(,%r10,4),%r11
  lea    0x0(%r13,%r11,1),%r9
  add    %r11,%rsi
  cmp    %edx,%ebp
  je     L656
  sub    %ebp,%edx
  mov    %edx,%r11d
  cmp    $0x1,%edx
  je     L276
L20:
  shl    $0x2,%r10
  lea    0x0(%r13,%r10,1),%rdx
  sub    %rdi,%r10
  add    %rax,%r10
  mov    (%rdx),%rbp
  mov    (%r10),%rdi
  mov    %rdi,(%rdx)
  mov    %rbp,(%r10)
  mov    %r11d,%r10d
  and    $0xfffffffe,%r10d
  mov    %r10d,%edx
  shl    $0x2,%rdx
  add    %rdx,%r9
  add    %rdx,%rsi
  cmp    %r11d,%r10d
  je     L656
L276:
  mov    (%r9),%edx
  mov    (%rsi),%r10d
  mov    %r10d,(%r9)
  mov    %edx,(%rsi)
L656:
  mov    %rbx,%rdx
  mov    %rcx,%r11
  sub    0x20(%rsp),%r11
  sub    %rcx,%rdx
  mov    %rdx,%rcx
  mov    %r11,%rdx
  sar    $0x2,%rcx
  sar    $0x2,%rdx
  sub    $0x1,%ecx
  cmp    %edx,%ecx
  cmovg  %edx,%ecx
  mov    %rbx,%rdx
  movslq %ecx,%r9
  lea    0x0(,%r9,4),%rbp
  sub    %rbp,%rdx
  test   %ecx,%ecx
  jle    L387
  mov    %rbx,%rsi
  sub    %rbp,%rsi
  add    $0x10,%rsi
  cmp    %rsi,%rax
  lea    0x10(%rax),%rsi
  setae  %r10b
  cmp    %rsi,%rdx
  setae  %sil
  or     %r10b,%sil
  je     L926
  cmp    $0x1,%ecx
  je     L926
  mov    %ecx,%r10d
  cmp    $0x3,%ecx
  jle    L362
  mov    %ecx,%r9d
  xor    %esi,%esi
  shr    $0x2,%r9d
  shl    $0x4,%r9
  nopw   0x0(%rax,%rax,1)
L584:
  movdqu (%rax,%rsi,1),%xmm0
  movdqu (%rdx,%rsi,1),%xmm6
  movups %xmm6,(%rax,%rsi,1)
  movups %xmm0,(%rdx,%rsi,1)
  add    $0x10,%rsi
  cmp    %r9,%rsi
  jne    L584
  mov    %ecx,%edi
  and    $0xfffffffc,%edi
  mov    %edi,%r9d
  lea    0x0(,%r9,4),%r10
  lea    (%rax,%r10,1),%rsi
  add    %r10,%rdx
  cmp    %ecx,%edi
  je     L387
  sub    %edi,%ecx
  mov    %ecx,%r10d
  cmp    $0x1,%ecx
  je     L321
L797:
  shl    $0x2,%r9
  add    %r9,%rax
  sub    %rbp,%r9
  add    %rbx,%r9
  mov    (%rax),%rcx
  mov    (%r9),%rdi
  mov    %rdi,(%rax)
  mov    %rcx,(%r9)
  mov    %r10d,%ecx
  and    $0xfffffffe,%ecx
  mov    %ecx,%eax
  shl    $0x2,%rax
  add    %rax,%rsi
  add    %rax,%rdx
  cmp    %r10d,%ecx
  je     L387
L321:
  mov    (%rsi),%eax
  mov    (%rdx),%ecx
  mov    %ecx,(%rsi)
  mov    %eax,(%rdx)
L387:
  mov    0x40(%rsp),%rax
  mov    %rbx,%rcx
  movq   %r13,%xmm1
  movq   %rbx,%xmm7
  sub    %r11,%rcx
  add    %r13,%rax
  movq   %rcx,%xmm0
  mov    %rcx,0x20(%rsp)
  movq   %rax,%xmm5
  mov    %rax,0x50(%rsp)
  mov    %rax,%rdx
  movslq (%rax),%rax
  punpcklqdq %xmm5,%xmm1
  punpcklqdq %xmm7,%xmm0
  movslq (%r15,%rax,4),%rax
  cmp    -0x1(%r12,%rax,1),%r8b
  ja     L468
L198:
  mov    (%rsp),%ecx
  mov    0x20(%rsp),%rax
  xor    %edi,%edi
  movq   %rdx,%xmm2
  lea    0x1(%r14),%esi
  movq   %rax,%xmm7
  lea    0x1(%rcx),%ebp
  sub    %rdx,%rax
  cmp    $0xf,%ecx
  setle  %dil
  mov    %rax,%r8
  punpcklqdq %xmm7,%xmm2
  xor    %r9d,%r9d
  cmp    $0xf,%ebp
  mov    %esi,0x80(%rsp)
  setle  %r9b
  sar    $0x2,%r8
  add    $0x2,%ecx
  mov    %ecx,0x60(%rsp)
  mov    %r8d,%r12d
  cmp    %r11,0x40(%rsp)
  jg     L361
  cmp    %rax,%r11
  jle    L763
  cmp    %rax,0x40(%rsp)
  mov    %rdx,0x30(%rsp)
  mov    %r9d,0x40(%rsp)
  jg     L319
  call   <assert@plt>
  movslq (%rsp),%rax
  mov    0x40(%rsp),%edi
  movslq %ebp,%rbp
  mov    0x20(%rsp),%rcx
  lea    (%rax,%rax,2),%rax
  shl    $0x3,%rax
  mov    %rbx,0x98(%rsp,%rax,1)
  mov    0x10(%rsp),%ebx
  mov    %rcx,0x90(%rsp,%rax,1)
  mov    %ebx,0xa4(%rsp,%rax,1)
  lea    0x0(%rbp,%rbp,2),%rbx
  mov    %r14d,0xa0(%rsp,%rax,1)
  shl    $0x3,%rbx
  call   <assert@plt>
  mov    0x30(%rsp),%rdx
  mov    0x20(%rsp),%rcx
  mov    %r12d,%edi
  mov    0x80(%rsp),%eax
  mov    %rdx,0x90(%rsp,%rbx,1)
  mov    %rcx,0x98(%rsp,%rbx,1)
  mov    %eax,0xa0(%rsp,%rbx,1)
  call   <ss_ilg@plt>
  mov    0x10(%rsp),%ebp
  mov    %eax,0xa4(%rsp,%rbx,1)
  mov    0x60(%rsp),%eax
  mov    0x50(%rsp),%rbx
  mov    %eax,(%rsp)
  jmp    L825
L556:
  movslq 0x0(%r13),%rax
  mov    %r13,%rsi
  mov    %rdx,%r13
  movslq (%r15,%rax,4),%r8
  mov    %ecx,%eax
  jmp    L166
L9:
  mov    %r13,%rsi
  mov    %r14d,%ecx
  mov    %rbx,%rdx
  mov    %r15,%rdi
  call   <ss_partition@plt>
  mov    %rbx,%rdi
  sub    %rax,%rdi
  mov    %rax,%r13
  sar    $0x2,%rdi
  call   <ss_ilg@plt>
  mov    %eax,%ebp
  jmp    L187
L414:
  mov    %r14d,%ecx
  mov    %r15,%rdi
  mov    %rdx,0x10(%rsp)
  movaps %xmm1,0x20(%rsp)
  call   <ss_partition@plt>
  movdqa 0x20(%rsp),%xmm1
  mov    0x10(%rsp),%rdx
  mov    %rax,%rsi
  jmp    L306
L295:
  mov    %ebp,%edi
  mov    %rsi,0x20(%rsp)
  mov    %r12d,%r14d
  mov    %rdx,0x10(%rsp)
  call   <ss_ilg@plt>
  mov    0x10(%rsp),%rbx
  mov    0x20(%rsp),%r13
  mov    %eax,%ebp
  jmp    L825
L361:
  cmp    %rax,0x40(%rsp)
  jle    L126
  movaps %xmm2,0x40(%rsp)
  cmp    %rax,%r11
  jg     L899
  mov    %r9d,0x30(%rsp)
  movslq %ebp,%rbp
  call   <assert@plt>
  movslq (%rsp),%rax
  mov    0x50(%rsp),%rcx
  lea    0x0(%rbp,%rbp,2),%rbp
  mov    0x30(%rsp),%edi
  shl    $0x3,%rbp
  lea    (%rax,%rax,2),%rax
  shl    $0x3,%rax
  mov    %r13,0x90(%rsp,%rax,1)
  mov    0x10(%rsp),%r13d
  mov    %rcx,0x98(%rsp,%rax,1)
  mov    %r13d,0xa4(%rsp,%rax,1)
  mov    %r14d,0xa0(%rsp,%rax,1)
  call   <assert@plt>
  movdqa 0x40(%rsp),%xmm2
  mov    0x80(%rsp),%eax
  mov    %r12d,%edi
  mov    %eax,0xa0(%rsp,%rbp,1)
  movups %xmm2,0x90(%rsp,%rbp,1)
  call   <ss_ilg@plt>
  mov    %eax,0xa4(%rsp,%rbp,1)
  mov    0x60(%rsp),%eax
  mov    %r13d,%ebp
  mov    0x20(%rsp),%r13
  mov    %eax,(%rsp)
  jmp    L825
L468:
  mov    0x50(%rsp),%rsi
  mov    %rcx,%rdx
  mov    %r15,%rdi
  mov    %r14d,%ecx
  mov    %r11,0x80(%rsp)
  movaps %xmm1,0x70(%rsp)
  movaps %xmm0,0x60(%rsp)
  call   <ss_partition@plt>
  movdqa 0x70(%rsp),%xmm1
  movdqa 0x60(%rsp),%xmm0
  mov    0x80(%rsp),%r11
  mov    %rax,%rdx
  jmp    L198
L227:
  sub    $0x8,%rdx
  cmp    %rdx,%rax
  jb     L123
  jmp    L714
  nop
L872:
  jne    L0
  mov    (%rcx),%edi
  sub    $0x4,%rcx
  mov    %edi,(%rdx)
  mov    %esi,0x4(%rcx)
L0:
  sub    $0x4,%rdx
  cmp    %rdx,%rax
  jae    L714
L123:
  movslq (%rdx),%rdi
  mov    %rdi,%rsi
  movslq (%r15,%rdi,4),%rdi
  movzbl (%r12,%rdi,1),%edi
  cmp    %edi,%r10d
  jle    L872
  cmp    %rdx,%rax
  jae    L714
  mov    %rcx,%r11
  mov    %rdx,%rcx
  jmp    L320
L319:
  call   <assert@plt>
  movslq (%rsp),%rax
  mov    0x40(%rsp),%edi
  movslq %ebp,%rbp
  mov    0x20(%rsp),%rcx
  lea    (%rax,%rax,2),%rax
  shl    $0x3,%rax
  mov    %rbx,0x98(%rsp,%rax,1)
  mov    0x10(%rsp),%ebx
  mov    %rcx,0x90(%rsp,%rax,1)
  mov    %r14d,0xa0(%rsp,%rax,1)
  mov    %ebx,0xa4(%rsp,%rax,1)
  call   <assert@plt>
  mov    0x50(%rsp),%rsi
  lea    0x0(%rbp,%rbp,2),%rax
  mov    %r12d,%edi
  shl    $0x3,%rax
  mov    %r13,0x90(%rsp,%rax,1)
  mov    %r14d,0xa0(%rsp,%rax,1)
  mov    %ebx,0xa4(%rsp,%rax,1)
  mov    %rsi,0x98(%rsp,%rax,1)
  call   <ss_ilg@plt>
  mov    0x20(%rsp),%rbx
  mov    0x30(%rsp),%r13
  mov    %eax,%ebp
  mov    0x60(%rsp),%eax
  mov    0x80(%rsp),%r14d
  mov    %eax,(%rsp)
  jmp    L825
L899:
  mov    %r9d,0x8c(%rsp)
  movslq %ebp,%rbp
  mov    %rdx,0x40(%rsp)
  movaps %xmm0,0x50(%rsp)
  movaps %xmm1,0x70(%rsp)
  call   <assert@plt>
  movslq (%rsp),%rax
  movdqa 0x70(%rsp),%xmm1
  mov    0x30(%rsp),%rbx
  mov    0x8c(%rsp),%edi
  lea    (%rax,%rax,2),%rax
  shl    $0x3,%rax
  mov    %rbx,0xa0(%rsp,%rax,1)
  movups %xmm1,0x90(%rsp,%rax,1)
  call   <assert@plt>
  mov    0x10(%rsp),%ebx
  lea    0x0(%rbp,%rbp,2),%rax
  mov    %r12d,%edi
  movdqa 0x50(%rsp),%xmm0
  shl    $0x3,%rax
  mov    %r14d,0xa0(%rsp,%rax,1)
  mov    %ebx,0xa4(%rsp,%rax,1)
  movups %xmm0,0x90(%rsp,%rax,1)
  call   <ss_ilg@plt>
  mov    0x20(%rsp),%rbx
  mov    0x40(%rsp),%r13
  mov    %eax,%ebp
  mov    0x60(%rsp),%eax
  mov    0x80(%rsp),%r14d
  mov    %eax,(%rsp)
  jmp    L825
L649:
  lea    (%rsi,%r10,4),%r10
  mov    %r13,%rdx
L171:
  mov    (%rdx),%edi
  mov    (%rsi),%r9d
  add    $0x4,%rsi
  add    $0x4,%rdx
  mov    %r9d,-0x4(%rdx)
  mov    %edi,-0x4(%rsi)
  cmp    %r10,%rsi
  jne    L171
  jmp    L656
L926:
  lea    (%rdx,%r9,4),%r9
L554:
  mov    (%rax),%ecx
  mov    (%rdx),%esi
  add    $0x4,%rdx
  add    $0x4,%rax
  mov    %esi,-0x4(%rax)
  mov    %ecx,-0x4(%rdx)
  cmp    %rdx,%r9
  jne    L554
  jmp    L387
L763:
  mov    %r9d,0x40(%rsp)
  movslq %ebp,%rbp
  mov    %rdx,0x30(%rsp)
  call   <assert@plt>
  movslq (%rsp),%rax
  mov    0x30(%rsp),%rdx
  mov    %r12d,%edi
  mov    0x80(%rsp),%esi
  lea    (%rax,%rax,2),%rcx
  mov    0x20(%rsp),%rax
  shl    $0x3,%rcx
  mov    %rdx,0x90(%rsp,%rcx,1)
  mov    %esi,0xa0(%rsp,%rcx,1)
  mov    %rax,0x98(%rsp,%rcx,1)
  mov    %rcx,(%rsp)
  call   <ss_ilg@plt>
  mov    (%rsp),%rcx
  mov    0x40(%rsp),%edi
  mov    %eax,0xa4(%rsp,%rcx,1)
  call   <assert@plt>
  lea    0x0(%rbp,%rbp,2),%rax
  mov    0x20(%rsp),%rcx
  shl    $0x3,%rax
  mov    %rbx,0x98(%rsp,%rax,1)
  mov    0x10(%rsp),%ebx
  mov    %rcx,0x90(%rsp,%rax,1)
  mov    %ebx,0xa4(%rsp,%rax,1)
  mov    %ebx,%ebp
  mov    0x50(%rsp),%rbx
  mov    %r14d,0xa0(%rsp,%rax,1)
  mov    0x60(%rsp),%eax
  mov    %eax,(%rsp)
  jmp    L825
L126:
  mov    %r9d,0x40(%rsp)
  movslq %ebp,%rbp
  mov    %rdx,0x30(%rsp)
  call   <assert@plt>
  movslq (%rsp),%rax
  mov    0x30(%rsp),%rdx
  mov    %r12d,%edi
  mov    0x80(%rsp),%esi
  lea    (%rax,%rax,2),%rcx
  mov    0x20(%rsp),%rax
  shl    $0x3,%rcx
  mov    %rdx,0x90(%rsp,%rcx,1)
  mov    %esi,0xa0(%rsp,%rcx,1)
  mov    %rax,0x98(%rsp,%rcx,1)
  mov    %rcx,(%rsp)
  call   <ss_ilg@plt>
  mov    (%rsp),%rcx
  mov    0x40(%rsp),%edi
  mov    %eax,0xa4(%rsp,%rcx,1)
  call   <assert@plt>
  mov    0x50(%rsp),%rcx
  lea    0x0(%rbp,%rbp,2),%rax
  shl    $0x3,%rax
  mov    %rcx,0x98(%rsp,%rax,1)
  mov    0x10(%rsp),%ecx
  mov    %r13,0x90(%rsp,%rax,1)
  mov    0x20(%rsp),%r13
  mov    %ecx,0xa4(%rsp,%rax,1)
  mov    %ecx,%ebp
  mov    0x60(%rsp),%ecx
  mov    %r14d,0xa0(%rsp,%rax,1)
  mov    %ecx,(%rsp)
  jmp    L825
L98:
  mov    %r13,%rsi
  mov    %rdx,%r13
  jmp    L166
L839:
  mov    %r13,%r9
  xor    %r10d,%r10d
  jmp    L20
L362:
  mov    %rax,%rsi
  xor    %r9d,%r9d
  jmp    L797
L713:
  call   <__stack_chk_fail@plt>
```

assistant: ```c
void ss_mintrosort(const unsigned char *T, const int *PA, int *first, int *last, int depth) {
  struct {
    int *a, *b, c;
    int d;
  } stack[(16)];
  const unsigned char *Td;
  int *a, *b, *c, *d, *e, *f;
  int s, t;
  int ssize;
  int limit;
  int v, x = 0;
  for (ssize = 0, limit = ss_ilg(last - first);;) {
    if ((last - first) <= (8)) {
      if (1 < (last - first)) {
        ss_insertionsort(T, PA, first, last, depth);
      }
      do {
        assert(0 <= ssize);
        if (ssize == 0) {
          return;
        }
        (first) = stack[--ssize].a, (last) = stack[ssize].b, (depth) = stack[ssize].c, (limit) = stack[ssize].d;
      } while (0);
      continue;
    }
    Td = T + depth;
    if (limit-- == 0) {
      ss_heapsort(Td, PA, first, last - first);
    }
    if (limit < 0) {
      for (a = first + 1, v = Td[PA[*first]]; a < last; ++a) {
        if ((x = Td[PA[*a]]) != v) {
          if (1 < (a - first)) {
            break;
          }
          v = x;
          first = a;
        }
      }
      if (Td[PA[*first] - 1] < v) {
        first = ss_partition(PA, first, a, depth);
      }
      if ((a - first) <= (last - a)) {
        if (1 < (a - first)) {
          do {
            assert(ssize < (16));
            stack[ssize].a = (a), stack[ssize].b = (last), stack[ssize].c = (depth), stack[ssize++].d = (-1);
          } while (0);
          last = a, depth += 1, limit = ss_ilg(a - first);
        } else {
          first = a, limit = -1;
        }
      } else {
        if (1 < (last - a)) {
          do {
            assert(ssize < (16));
            stack[ssize].a = (first), stack[ssize].b = (a), stack[ssize].c = (depth + 1), stack[ssize++].d = (ss_ilg(a - first));
          } while (0);
          first = a, limit = -1;
        } else {
          last = a, depth += 1, limit = ss_ilg(a - first);
        }
      }
      continue;
    }
    a = ss_pivot(Td, PA, first, last);
    v = Td[PA[*a]];
    do {
      t = (*first);
      (*first) = (*a);
      (*a) = t;
    } while (0);
    for (b = first; (++b < last) && ((x = Td[PA[*b]]) == v);) {
    }
    if (((a = b) < last) && (x < v)) {
      for (; (++b < last) && ((x = Td[PA[*b]]) <= v);) {
        if (x == v) {
          do {
            t = (*b);
            (*b) = (*a);
            (*a) = t;
          } while (0);
          ++a;
        }
      }
    }
    for (c = last; (b < --c) && ((x = Td[PA[*c]]) == v);) {
    }
    if ((b < (d = c)) && (x > v)) {
      for (; (b < --c) && ((x = Td[PA[*c]]) >= v);) {
        if (x == v) {
          do {
            t = (*c);
            (*c) = (*d);
            (*d) = t;
          } while (0);
          --d;
        }
      }
    }
    for (; b < c;) {
      do {
        t = (*b);
        (*b) = (*c);
        (*c) = t;
      } while (0);
      for (; (++b < c) && ((x = Td[PA[*b]]) <= v);) {
        if (x == v) {
          do {
            t = (*b);
            (*b) = (*a);
            (*a) = t;
          } while (0);
          ++a;
        }
      }
      for (; (b < --c) && ((x = Td[PA[*c]]) >= v);) {
        if (x == v) {
          do {
            t = (*c);
            (*c) = (*d);
            (*d) = t;
          } while (0);
          --d;
        }
      }
    }
    if (a <= d) {
      c = b - 1;
      if ((s = a - first) > (t = b - a)) {
        s = t;
      }
      for (e = first, f = b - s; 0 < s; --s, ++e, ++f) {
        do {
          t = (*e);
          (*e) = (*f);
          (*f) = t;
        } while (0);
      }
      if ((s = d - c) > (t = last - d - 1)) {
        s = t;
      }
      for (e = b, f = last - s; 0 < s; --s, ++e, ++f) {
        do {
          t = (*e);
          (*e) = (*f);
          (*f) = t;
        } while (0);
      }
      a = first + (b - a), c = last - (d - c);
      b = (v <= Td[PA[*a] - 1]) ? a : ss_partition(PA, a, c, depth);
      if ((a - first) <= (last - c)) {
        if ((last - c) <= (c - b)) {
          do {
            assert(ssize < (16));
            stack[ssize].a = (b), stack[ssize].b = (c), stack[ssize].c = (depth + 1), stack[ssize++].d = (ss_ilg(c - b));
          } while (0);
          do {
            assert(ssize < (16));
            stack[ssize].a = (c), stack[ssize].b = (last), stack[ssize].c = (depth), stack[ssize++].d = (limit);
          } while (0);
          last = a;
        } else if ((a - first) <= (c - b)) {
          do {
            assert(ssize < (16));
            stack[ssize].a = (c), stack[ssize].b = (last), stack[ssize].c = (depth), stack[ssize++].d = (limit);
          } while (0);
          do {
            assert(ssize < (16));
            stack[ssize].a = (b), stack[ssize].b = (c), stack[ssize].c = (depth + 1), stack[ssize++].d = (ss_ilg(c - b));
          } while (0);
          last = a;
        } else {
          do {
            assert(ssize < (16));
            stack[ssize].a = (c), stack[ssize].b = (last), stack[ssize].c = (depth), stack[ssize++].d = (limit);
          } while (0);
          do {
            assert(ssize < (16));
            stack[ssize].a = (first), stack[ssize].b = (a), stack[ssize].c = (depth), stack[ssize++].d = (limit);
          } while (0);
          first = b, last = c, depth += 1, limit = ss_ilg(c - b);
        }
      } else {
        if ((a - first) <= (c - b)) {
          do {
            assert(ssize < (16));
            stack[ssize].a = (b), stack[ssize].b = (c), stack[ssize].c = (depth + 1), stack[ssize++].d = (ss_ilg(c - b));
          } while (0);
          do {
            assert(ssize < (16));
            stack[ssize].a = (first), stack[ssize].b = (a), stack[ssize].c = (depth), stack[ssize++].d = (limit);
          } while (0);
          first = c;
        } else if ((last - c) <= (c - b)) {
          do {
            assert(ssize < (16));
            stack[ssize].a = (first), stack[ssize].b = (a), stack[ssize].c = (depth), stack[ssize++].d = (limit);
          } while (0);
          do {
            assert(ssize < (16));
            stack[ssize].a = (b), stack[ssize].b = (c), stack[ssize].c = (depth + 1), stack[ssize++].d = (ss_ilg(c - b));
          } while (0);
          first = c;
        } else {
          do {
            assert(ssize < (16));
            stack[ssize].a = (first), stack[ssize].b = (a), stack[ssize].c = (depth), stack[ssize++].d = (limit);
          } while (0);
          do {
            assert(ssize < (16));
            stack[ssize].a = (c), stack[ssize].b = (last), stack[ssize].c = (depth), stack[ssize++].d = (limit);
          } while (0);
          first = b, last = c, depth += 1, limit = ss_ilg(c - b);
        }
      }
    } else {
      limit += 1;
      if (Td[PA[*first] - 1] < v) {
        first = ss_partition(PA, first, last, depth);
        limit = ss_ilg(last - first);
      }
      depth += 1;
    }
  }
}
```