user: 请显示与下面列出的汇编代码相匹配的C语言实现:

```asm
<nextPermutation>:
  endbr64
  movslq %esi,%r11
  cmp    $0x1,%r11d
  jbe    L157
  mov    %r11d,%esi
  push   %rbp
  lea    -0x1(%r11),%r10d
  push   %rbx
  sub    $0x2,%esi
  js     L83
  movslq %r11d,%rax
  shl    $0x2,%rax
  mov    -0x4(%rdi,%rax,1),%ecx
  lea    -0x8(%rdi,%rax,1),%rax
  jmp    L110
  nopl   (%rax)
L92:
  sub    $0x1,%esi
  sub    $0x4,%rax
  cmp    $0xffffffff,%esi
  je     L251
L110:
  mov    %ecx,%edx
  mov    (%rax),%ecx
  cmp    %edx,%ecx
  jge    L92
  lea    0x1(%rsi),%r9d
  lea    (%r9,%r10,1),%ebx
  test   %r10d,%r10d
  js     L27
L51:
  movslq %r10d,%rdx
  jmp    L210
  cs nopw 0x0(%rax,%rax,1)
L81:
  sub    $0x1,%rdx
  test   %edx,%edx
  js     L43
L210:
  lea    0x0(,%rdx,4),%r8
  cmp    %ecx,(%rdi,%rdx,4)
  jle    L81
L17:
  cmp    $0xffffffff,%esi
  je     L4
L241:
  add    %rdi,%r8
  mov    (%rax),%edx
  mov    (%r8),%ecx
  mov    %ecx,(%rax)
  mov    %edx,(%r8)
L4:
  mov    %ebx,%eax
  shr    $0x1f,%eax
  add    %ebx,%eax
  sar    %eax
  cmp    %r9d,%eax
  jl     L233
  mov    %eax,%ebx
  movslq %r9d,%r8
  shl    $0x2,%r11
  sub    %r9d,%ebx
  lea    0x0(,%r8,4),%rcx
  lea    0x1(%rbx),%edx
  mov    %rdx,%rsi
  mov    %rdx,%rbp
  add    %r8,%rdx
  neg    %rsi
  shl    $0x2,%rdx
  lea    (%r11,%rsi,4),%rsi
  cmp    %rdx,%rsi
  setge  %dl
  cmp    %r11,%rcx
  setge  %sil
  or     %sil,%dl
  je     L273
  cmp    %r9d,%eax
  je     L273
  cmp    $0x2,%ebx
  jbe    L70
  mov    %ebp,%edx
  add    %rdi,%rcx
  lea    -0x10(%rdi,%r11,1),%rax
  shr    $0x2,%edx
  lea    -0x1(%rdx),%esi
  lea    0x10(%rcx),%rdx
  shl    $0x4,%rsi
  add    %rdx,%rsi
  jmp    L227
  nopl   (%rax)
L77:
  add    $0x10,%rdx
L227:
  movdqu (%rcx),%xmm0
  movdqu (%rax),%xmm2
  sub    $0x10,%rax
  pshufd $0x1b,%xmm2,%xmm1
  pshufd $0x1b,%xmm0,%xmm0
  movups %xmm1,(%rcx)
  mov    %rdx,%rcx
  movups %xmm0,0x10(%rax)
  cmp    %rsi,%rdx
  jne    L77
  mov    %ebp,%eax
  and    $0xfffffffc,%eax
  add    %eax,%r9d
  sub    %eax,%r10d
  cmp    %eax,%ebp
  je     L233
L144:
  sub    %eax,%ebp
  cmp    %eax,%ebx
  je     L128
  add    %rax,%r8
  neg    %rax
  lea    -0x8(%r11,%rax,4),%rax
  lea    (%rdi,%r8,4),%rdx
  add    %rdi,%rax
  movq   (%rdx),%xmm0
  movq   (%rax),%xmm1
  pshufd $0xe1,%xmm0,%xmm0
  pshufd $0xe1,%xmm1,%xmm1
  movq   %xmm1,(%rdx)
  movq   %xmm0,(%rax)
  mov    %ebp,%eax
  and    $0xfffffffe,%eax
  add    %eax,%r9d
  sub    %eax,%r10d
  cmp    %eax,%ebp
  je     L233
L128:
  movslq %r9d,%r9
  movslq %r10d,%r10
  lea    (%rdi,%r9,4),%rdx
  lea    (%rdi,%r10,4),%rax
  mov    (%rdx),%ecx
  mov    (%rax),%esi
  mov    %esi,(%rdx)
  mov    %ecx,(%rax)
L233:
  pop    %rbx
  pop    %rbp
  ret
  nopw   0x0(%rax,%rax,1)
L251:
  test   %r10d,%r10d
  js     L141
  mov    -0x4(%rdi),%ecx
  lea    -0x4(%rdi),%rax
  mov    %r10d,%ebx
  xor    %r9d,%r9d
  jmp    L51
  nopl   0x0(%rax,%rax,1)
L43:
  mov    $0xfffffffffffffffc,%r8
  jmp    L17
  nopl   0x0(%rax)
L157:
  ret
  nopl   0x0(%rax)
L273:
  add    %r8,%rbx
  add    %rdi,%rcx
  lea    -0x4(%rdi,%r11,1),%rax
  lea    0x4(%rdi,%rbx,4),%rdi
L275:
  mov    (%rax),%esi
  mov    (%rcx),%edx
  add    $0x4,%rcx
  sub    $0x4,%rax
  mov    %esi,-0x4(%rcx)
  mov    %edx,0x4(%rax)
  cmp    %rdi,%rcx
  jne    L275
  pop    %rbx
  pop    %rbp
  ret
L70:
  xor    %eax,%eax
  jmp    L144
L83:
  test   %r10d,%r10d
  js     L141
  mov    -0x4(%rdi),%ecx
  lea    -0x4(%rdi),%rax
  mov    %r10d,%ebx
  xor    %r9d,%r9d
  mov    $0xffffffff,%esi
  jmp    L51
L141:
  mov    %r10d,%ebx
  xor    %r9d,%r9d
  jmp    L4
L27:
  mov    $0xfffffffffffffffc,%r8
  jmp    L241
```

assistant: ```c
void nextPermutation(int *nums, int numsSize) {
  if (!numsSize || numsSize == 1)
    return;
  int i, chan_ind, part_ind, j;
  chan_ind = part_ind = -1;
  for (i = numsSize - 2; i >= 0; i--) {
    if (nums[i] < nums[i + 1]) {
      part_ind = i;
      break;
    }
  }
  for (i = numsSize - 1; i >= 0; i--) {
    if (nums[i] > nums[part_ind]) {
      chan_ind = i;
      break;
    }
  }
  if (part_ind >= 0) {
    i = nums[part_ind];
    nums[part_ind] = nums[chan_ind];
    nums[chan_ind] = i;
  }
  i = part_ind + 1;
  j = numsSize - 1;
  chan_ind = (i + j) / 2;
  for (; i <= chan_ind; i++, j--) {
    part_ind = nums[i];
    nums[i] = nums[j];
    nums[j] = part_ind;
  }
  return;
}
```