user: 这段汇编代码用C语言表示是什么样的？

```asm
<ptr_move>:
  endbr64
  push   %r15
  push   %r14
  push   %r13
  push   %r12
  push   %rbp
  push   %rbx
  sub    $0x1000,%rsp
  orq    $0x0,(%rsp)
  sub    $0x1000,%rsp
  orq    $0x0,(%rsp)
  sub    $0x28,%rsp
  mov    %rsi,%r15
  mov    %rdx,%rbx
  mov    %rcx,%r13
  mov    %rdi,%r12
  mov    %fs:0x28,%rax
  mov    %rax,0x2018(%rsp)
  xor    %eax,%eax
  add    %r15,%rbx
  call   <assert@plt>
  cmp    %r15,%r13
  jae    L4
  lea    0x0(%r13,%rbx,1),%rdx
  lea    (%r15,%r15,1),%rax
  cmp    %rax,%rdx
  jae    L11
L28:
  lea    0x10(%rsp),%rbp
  mov    %rbp,%rdi
  nopl   0x0(%rax)
L81:
  mov    %r15,%r8
  mov    %r13,%r14
  sub    %r13,%r8
  cmp    $0x400,%r8
  ja     L180
L281:
  lea    (%r12,%r14,8),%rcx
  xor    %eax,%eax
  nopl   0x0(%rax)
L156:
  mov    (%rcx,%rax,8),%rdx
  mov    %rax,%rsi
  mov    %rdx,(%rdi,%rax,8)
  add    $0x1,%rax
  cmp    %rax,%r8
  jne    L156
  mov    %rbx,%r10
  lea    (%rcx,%rax,8),%r9
  sub    %r15,%r10
  je     L286
  xor    %edx,%edx
  nopw   0x0(%rax,%rax,1)
L106:
  mov    (%r9,%rdx,8),%r8
  mov    %r8,(%rcx,%rdx,8)
  add    $0x1,%rdx
  cmp    %r10,%rdx
  jne    L106
  lea    (%rcx,%rdx,8),%rcx
L286:
  xor    %edx,%edx
  nopw   0x0(%rax,%rax,1)
L145:
  mov    (%rdi,%rdx,8),%r8
  mov    %r8,(%rcx,%rdx,8)
  mov    %rdx,%r8
  add    $0x1,%rdx
  cmp    %r8,%rsi
  jne    L145
  sub    %rax,%rbx
  cmp    %r14,%r13
  jae    L144
  mov    %r14,%r15
  jmp    L81
  nopl   0x0(%rax,%rax,1)
L4:
  cmp    %rbx,%r13
  jb     L151
  lea    0x1(%r13),%rsi
  lea    (%rbx,%rbx,1),%rdx
  lea    (%r15,%rsi,1),%rax
  cmp    %rax,%rdx
  ja     L105
  mov    %r15,%r13
L264:
  lea    0x10(%rsp),%rbp
  mov    %rbp,%rdi
  cmp    %rsi,%rbx
  jae    L151
  nopw   0x0(%rax,%rax,1)
L251:
  mov    %rsi,%r14
  mov    %rsi,%r15
  sub    %rbx,%r14
  lea    0x0(,%r14,8),%rcx
  cmp    $0x400,%r14
  ja     L231
L48:
  mov    %r14,%r10
  lea    (%r12,%r15,8),%r9
  mov    %r14,%rax
  neg    %r10
  shl    $0x3,%r10
  add    %r10,%rcx
  lea    (%r9,%r10,1),%rdx
  add    %rdi,%rcx
  nopl   0x0(%rax)
L127:
  mov    -0x8(%rdx,%rax,8),%r8
  mov    %r8,-0x8(%rcx,%rax,8)
  sub    $0x1,%rax
  jne    L127
  mov    %rbx,%rax
  sub    %r13,%rax
  je     L63
  mov    %rax,%r8
  neg    %r8
  shl    $0x3,%r8
  add    %r8,%rdx
  add    %r8,%r9
L283:
  mov    -0x8(%rdx,%rax,8),%r8
  mov    %r8,-0x8(%r9,%rax,8)
  sub    $0x1,%rax
  jne    L283
  lea    (%r9,%r10,1),%rdx
L63:
  mov    %r14,%rax
  nopw   0x0(%rax,%rax,1)
L168:
  mov    -0x8(%rcx,%rax,8),%r8
  mov    %r8,-0x8(%rdx,%rax,8)
  sub    $0x1,%rax
  jne    L168
  add    %r14,%r13
  cmp    %rsi,%r15
  jae    L144
  mov    %r15,%rbx
  jmp    L251
L144:
  cmp    %rbp,%rdi
  je     L151
  call   <free@plt>
L151:
  mov    0x2018(%rsp),%rax
  sub    %fs:0x28,%rax
  jne    L221
  add    $0x2028,%rsp
  pop    %rbx
  pop    %rbp
  pop    %r12
  pop    %r13
  pop    %r14
  pop    %r15
  ret
L11:
  mov    %rbx,%rsi
  mov    %r15,%rbx
  jmp    L264
  xchg   %ax,%ax
L180:
  lea    0x0(,%r8,8),%rdi
  mov    %r8,(%rsp)
  call   <malloc@plt>
  mov    (%rsp),%r8
  mov    %rax,%rdi
  test   %rax,%rax
  jne    L281
  lea    -0x400(%r15),%r14
  mov    %rbp,%rdi
  mov    $0x400,%r8d
  jmp    L281
  cs nopw 0x0(%rax,%rax,1)
L231:
  mov    %rcx,%rdi
  mov    %rsi,(%rsp)
  mov    %rcx,0x8(%rsp)
  call   <malloc@plt>
  mov    (%rsp),%rsi
  test   %rax,%rax
  mov    %rax,%rdi
  je     L43
  mov    0x8(%rsp),%rcx
  jmp    L48
  nopw   0x0(%rax,%rax,1)
L43:
  lea    0x400(%rbx),%r15
  mov    $0x2000,%ecx
  mov    %rbp,%rdi
  mov    $0x400,%r14d
  jmp    L48
L105:
  cmp    %rbx,%r15
  jae    L151
  mov    %r15,%r13
  mov    %rbx,%r15
  mov    %rsi,%rbx
  jmp    L28
L221:
  call   <__stack_chk_fail@plt>
```

assistant: ```c
void ptr_move(void *array, size_t off, size_t n, size_t pos) {
  size_t i, end;
  void **src, **dst;
  void *fxd[1024], **buf;
  assert(array);
  if ((pos >= off) && (pos < off + n))
    return;
  if (pos < off) {
    end = off + n;
    off = pos;
    pos = end - n;
  } else {
    end = pos + 1;
    pos = off + n;
  }
  buf = fxd;
  if (pos + pos > end + off) {
    while (pos > off) {
      n = pos - off;
      if (n > 1024) {
        buf = (void **)malloc(n * sizeof(void *));
        if (!buf) {
          buf = fxd;
          n = 1024;
        }
      }
      src = (void **)array + pos - n;
      dst = buf;
      for (i = n; i > 0; i--)
        *dst++ = *src++;
      dst = (void **)array + pos - n;
      for (i = end - pos; i > 0; i--)
        *dst++ = *src++;
      src = buf;
      for (i = n; i > 0; i--)
        *dst++ = *src++;
      pos -= n;
      end -= n;
    }
  } else {
    while (end > pos) {
      n = end - pos;
      if (n > 1024) {
        buf = (void **)malloc(n * sizeof(void *));
        if (!buf) {
          buf = fxd;
          n = 1024;
        }
      }
      src = (void **)array + pos + n;
      dst = buf + n;
      for (i = n; i > 0; i--)
        *--dst = *--src;
      dst = (void **)array + pos + n;
      for (i = pos - off; i > 0; i--)
        *--dst = *--src;
      src = buf + n;
      for (i = n; i > 0; i--)
        *--dst = *--src;
      pos += n;
      off += n;
    }
  }
  if (buf != fxd)
    free(buf);
}
```