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

```asm
<ShuffleSortedArray>:
  endbr64
  push   %r15
  push   %r14
  push   %r13
  push   %r12
  push   %rbp
  push   %rbx
  sub    $0x228,%rsp
  mov    %rdi,%r12
  mov    %esi,%ebp
  mov    %fs:0x28,%rax
  mov    %rax,0x218(%rsp)
  xor    %eax,%eax
  mov    $0x0,%ebx
  mov    $0x0,%r13d
  lea    D7(%rip),%r14
  cmp    $0x1,%esi
  jg     L100
  jmp    L8
L3:
  sub    $0x1,%r13d
  movslq %r13d,%rax
  mov    0x10(%rsp,%rax,8),%ebx
  mov    0x14(%rsp,%rax,8),%r15d
  jmp    L94
  movslq %ebx,%rbx
  shl    $0x2,%rbx
  lea    (%r12,%rbx,1),%rdx
  mov    (%rdx),%ecx
  lea    0x4(%r12,%rbx,1),%rax
  mov    (%rax),%esi
  mov    %esi,(%rdx)
  mov    %ecx,(%rax)
L29:
  test   %r13d,%r13d
  jne    L3
L8:
  mov    0x218(%rsp),%rax
  sub    %fs:0x28,%rax
  jne    L101
  add    $0x228,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
  movslq %ebx,%rbx
  shl    $0x2,%rbx
  lea    (%r12,%rbx,1),%rdx
  mov    (%rdx),%ecx
  lea    0x8(%r12,%rbx,1),%rax
  mov    (%rax),%esi
  mov    %esi,(%rdx)
  mov    %ecx,(%rax)
  jmp    L29
  movslq %ebx,%rbx
  shl    $0x2,%rbx
  lea    (%r12,%rbx,1),%rdx
  mov    (%rdx),%ecx
  lea    0x8(%r12,%rbx,1),%rax
  mov    (%rax),%esi
  mov    %esi,(%rdx)
  mov    %ecx,(%rax)
  lea    0xc(%r12,%rbx,1),%rdx
  mov    (%rdx),%ecx
  lea    0x10(%r12,%rbx,1),%rax
  mov    (%rax),%esi
  mov    %esi,(%rdx)
  mov    %ecx,(%rax)
  jmp    L29
  movslq %ebx,%rbx
  shl    $0x2,%rbx
  lea    (%r12,%rbx,1),%rax
  mov    (%rax),%ecx
  lea    0xc(%r12,%rbx,1),%rdx
  mov    (%rdx),%esi
  mov    %esi,(%rax)
  lea    0x8(%r12,%rbx,1),%rax
  mov    (%rax),%esi
  mov    %esi,(%rdx)
  mov    %ecx,(%rax)
  lea    0x10(%r12,%rbx,1),%rdx
  mov    (%rdx),%ecx
  lea    0x14(%r12,%rbx,1),%rax
  mov    (%rax),%esi
  mov    %esi,(%rdx)
  mov    %ecx,(%rax)
  jmp    L29
  movslq %ebx,%rbx
  shl    $0x2,%rbx
  lea    (%r12,%rbx,1),%rax
  mov    (%rax),%ecx
  lea    0x10(%r12,%rbx,1),%rdx
  mov    (%rdx),%esi
  mov    %esi,(%rax)
  lea    0xc(%r12,%rbx,1),%rax
  mov    (%rax),%esi
  mov    %esi,(%rdx)
  mov    %ecx,(%rax)
  lea    0x4(%r12,%rbx,1),%rdx
  mov    (%rdx),%ecx
  lea    0x8(%r12,%rbx,1),%rax
  mov    (%rax),%esi
  mov    %esi,(%rdx)
  mov    %ecx,(%rax)
  lea    0x14(%r12,%rbx,1),%rdx
  mov    (%rdx),%ecx
  lea    0x18(%r12,%rbx,1),%rax
  mov    (%rax),%esi
  mov    %esi,(%rdx)
  mov    %ecx,(%rax)
  jmp    L29
L62:
  mov    %ebp,%eax
  shr    $0x1f,%eax
  add    %ebp,%eax
  sar    %eax
  mov    %eax,%edi
  mov    %eax,%r15d
  lea    (%rax,%rbx,1),%eax
  cltq
  mov    (%r12,%rax,4),%eax
  mov    %eax,0x8(%rsp)
  movslq %ebx,%rax
  shl    $0x2,%rax
  lea    (%r12,%rax,1),%rcx
  mov    %edi,0xc(%rsp)
  lea    0x0(,%rdi,4),%edx
  lea    0x4(%r12,%rax,1),%rdi
  mov    %rcx,(%rsp)
  mov    %rcx,%rsi
  call   <memmove@plt>
  mov    (%rsp),%rcx
  mov    0x8(%rsp),%eax
  mov    %eax,(%rcx)
  add    $0x1,%ebx
  movslq %r13d,%rdx
  mov    0xc(%rsp),%edi
  lea    (%rdi,%rbx,1),%eax
  mov    %eax,0x10(%rsp,%rdx,8)
  lea    -0x1(%rbp),%ecx
  mov    %ecx,%eax
  shr    $0x1f,%eax
  add    %ecx,%eax
  sar    %eax
  mov    %eax,0x14(%rsp,%rdx,8)
  add    $0x1,%r13d
  cmp    $0x3,%ebp
  jg     L37
  test   %r13d,%r13d
  je     L8
L37:
  cmp    $0x3,%ebp
  jle    L3
L94:
  mov    %r15d,%ebp
L100:
  cmp    $0x8,%ebp
  ja     L62
  mov    %ebp,%eax
  movslq (%r14,%rax,4),%rax
  add    %r14,%rax
  notrack jmp *%rax
L101:
  call   <__stack_chk_fail@plt>
```

assistant: ```c
void ShuffleSortedArray(int *array, int count) {
  struct {
    int first, count;
  } aStack[64];
  int stk = 0;
  int first = 0;
  int tmp;
  while (count > 1 || stk) {
    if (count <= 1) {
      stk--;
      first = aStack[stk].first;
      count = aStack[stk].count;
    }
    switch (count) {
    case 2:
    case 3:
      tmp = array[first];
      array[first] = array[first + 1];
      array[first + 1] = tmp;
      count = 0;
      break;
    case 4:
      tmp = array[first];
      array[first] = array[first + 2];
      array[first + 2] = tmp;
      count = 0;
      break;
    case 5:
      tmp = array[first];
      array[first] = array[first + 2];
      array[first + 2] = tmp;
      tmp = array[first + 3];
      array[first + 3] = array[first + 4];
      array[first + 4] = tmp;
      count = 0;
      break;
    case 6:
    case 7:
      tmp = array[first];
      array[first] = array[first + 3];
      array[first + 3] = array[first + 2];
      array[first + 2] = tmp;
      tmp = array[first + 4];
      array[first + 4] = array[first + 5];
      array[first + 5] = tmp;
      count = 0;
      break;
    case 8:
      tmp = array[first];
      array[first] = array[first + 4];
      array[first + 4] = array[first + 3];
      array[first + 3] = tmp;
      tmp = array[first + 1];
      array[first + 1] = array[first + 2];
      array[first + 2] = tmp;
      tmp = array[first + 5];
      array[first + 5] = array[first + 6];
      array[first + 6] = tmp;
      count = 0;
      break;
    default:
      tmp = array[first + count / 2];
      memmove(&array[first + 1], &array[first], sizeof(array[0]) * (count / 2));
      array[first] = tmp;
      first++;
      aStack[stk].first = first + count / 2;
      aStack[stk].count = (count - 1) / 2;
      stk++;
      count = count / 2;
      break;
    }
  }
}
```