user: Demonstrate the C code that generates the assembly output below:

```asm
<memcpy>:
  endbr64
  mov    %rdi,%r9
  mov    %rsi,%rax
  mov    %rdx,%r8
  cmp    $0x1f,%rdx
  jbe    L149
  mov    %rdi,%rcx
  or     %rsi,%rcx
  and    $0x7,%ecx
  jne    L120
  lea    0x1f(%rdi),%rdx
  lea    -0x20(%r8),%rdi
  sub    %rsi,%rdx
  cmp    $0x3e,%rdx
  jbe    L248
  mov    %rdi,%rsi
  xor    %edx,%edx
  shr    $0x5,%rsi
  add    $0x1,%rsi
  nopl   0x0(%rax,%rax,1)
L28:
  movdqu 0x10(%rax,%rdx,1),%xmm0
  movdqu (%rax,%rdx,1),%xmm2
  add    $0x1,%rcx
  movups %xmm2,(%r9,%rdx,1)
  movups %xmm0,0x10(%r9,%rdx,1)
  add    $0x20,%rdx
  cmp    %rsi,%rcx
  jb     L28
L20:
  and    $0xffffffffffffffe0,%rdi
  mov    %r8,%rcx
  lea    0x20(%rdi),%r10
  and    $0x1f,%ecx
  add    %r10,%rax
  add    %r9,%r10
  test   $0x18,%r8b
  je     L223
  mov    (%rax),%rdx
  mov    %rdx,(%r10)
  lea    -0x8(%rcx),%rdx
  cmp    $0x7,%rdx
  jbe    L2
  mov    0x8(%rax),%rsi
  sub    $0x10,%rcx
  mov    %rsi,0x8(%r10)
  cmp    $0x7,%rcx
  jbe    L2
  mov    0x10(%rax),%rcx
  mov    %rcx,0x10(%r10)
L2:
  shr    $0x3,%rdx
  and    $0x7,%r8d
  lea    0x8(,%rdx,8),%rdx
  lea    -0x1(%r8),%rdi
  add    %rdx,%r10
  add    %rdx,%rax
  test   %r8,%r8
  jne    L118
L201:
  mov    %r9,%rax
  ret
  xchg   %ax,%ax
L149:
  mov    %rdi,%r10
L130:
  lea    -0x1(%r8),%rdi
  test   %r8,%r8
  je     L201
L118:
  lea    0x1(%rax),%rcx
  mov    %r10,%rdx
  sub    %rcx,%rdx
  cmp    $0xe,%rdx
  jbe    L107
  cmp    $0x6,%rdi
  jbe    L107
  cmp    $0xe,%rdi
  jbe    L276
L238:
  lea    -0x10(%r8),%rdx
  xor    %esi,%esi
  shr    $0x4,%rdx
  lea    0x1(%rdx),%rcx
  xor    %edx,%edx
  nopl   0x0(%rax)
L204:
  movdqu (%rax,%rdx,1),%xmm1
  add    $0x1,%rsi
  movups %xmm1,(%r10,%rdx,1)
  add    $0x10,%rdx
  cmp    %rsi,%rcx
  ja     L204
  shl    $0x4,%rcx
  mov    %rcx,%rdx
  lea    (%r10,%rcx,1),%rsi
  lea    (%rax,%rcx,1),%r11
  sub    %rcx,%rdi
  mov    %rdi,%rcx
  cmp    %rdx,%r8
  je     L201
  lea    0x1(%rdi),%r8
  cmp    $0x6,%rdi
  jbe    L56
L138:
  mov    (%rax,%rdx,1),%rax
  mov    %rax,(%r10,%rdx,1)
  mov    %r8,%rax
  and    $0xfffffffffffffff8,%rax
  add    %rax,%rsi
  add    %rax,%r11
  sub    %rax,%rcx
  cmp    %r8,%rax
  je     L201
L56:
  movzbl (%r11),%eax
  mov    %al,(%rsi)
  test   %rcx,%rcx
  je     L201
  movzbl 0x1(%r11),%eax
  mov    %al,0x1(%rsi)
  cmp    $0x1,%rcx
  je     L201
  movzbl 0x2(%r11),%eax
  mov    %al,0x2(%rsi)
  cmp    $0x2,%rcx
  je     L201
  movzbl 0x3(%r11),%eax
  mov    %al,0x3(%rsi)
  cmp    $0x3,%rcx
  je     L201
  movzbl 0x4(%r11),%eax
  mov    %al,0x4(%rsi)
  cmp    $0x4,%rcx
  je     L201
  movzbl 0x5(%r11),%eax
  mov    %al,0x5(%rsi)
  cmp    $0x5,%rcx
  je     L201
  movzbl 0x6(%r11),%eax
  mov    %al,0x6(%rsi)
  mov    %r9,%rax
  ret
  nopl   0x0(%rax)
L120:
  lea    -0x1(%rdx),%rdi
  lea    0x1(%rsi),%rcx
  mov    %r9,%rdx
  mov    %r9,%r10
  sub    %rcx,%rdx
  cmp    $0xe,%rdx
  ja     L238
L107:
  xor    %edx,%edx
  nopl   (%rax)
L206:
  movzbl (%rax,%rdx,1),%ecx
  mov    %cl,(%r10,%rdx,1)
  mov    %rdx,%rcx
  add    $0x1,%rdx
  cmp    %rcx,%rdi
  jne    L206
  mov    %r9,%rax
  ret
L276:
  mov    %rdi,%rcx
  mov    %rax,%r11
  mov    %r10,%rsi
  xor    %edx,%edx
  jmp    L138
L223:
  mov    %rcx,%r8
  jmp    L130
L248:
  mov    %rdi,%rdx
  mov    %rsi,%rcx
  and    $0xffffffffffffffe0,%rdx
  lea    0x20(%r9,%rdx,1),%r10
  mov    %r9,%rdx
  nopw   0x0(%rax,%rax,1)
L170:
  mov    (%rcx),%rsi
  add    $0x20,%rcx
  add    $0x20,%rdx
  mov    %rsi,-0x20(%rdx)
  mov    -0x18(%rcx),%rsi
  mov    %rsi,-0x18(%rdx)
  mov    -0x10(%rcx),%rsi
  mov    %rsi,-0x10(%rdx)
  mov    -0x8(%rcx),%rsi
  mov    %rsi,-0x8(%rdx)
  cmp    %r10,%rdx
  jne    L170
  jmp    L20
```

assistant: ```c
void *memcpy(void *dst_, const void *src_, size_t n) {
  char *dst = dst_;
  long *aligned_dst;
  const char *src = src_;
  const long *aligned_src;
  if (n >= (sizeof(long)) * 4 && !(((long)(intptr_t)src | (long)(intptr_t)dst) & (sizeof(long) - 1))) {
    aligned_dst = (long *)dst;
    aligned_src = (long *)src;
    for (; n >= (sizeof(long)) * 4; n -= (sizeof(long)) * 4) {
      *aligned_dst++ = *aligned_src++;
      *aligned_dst++ = *aligned_src++;
      *aligned_dst++ = *aligned_src++;
      *aligned_dst++ = *aligned_src++;
    }
    for (; n >= (sizeof(long)); n -= (sizeof(long))) {
      *aligned_dst++ = *aligned_src++;
    }
    dst = (char *)aligned_dst;
    src = (char *)aligned_src;
  }
  while (n--) {
    *dst++ = *src++;
  }
  return dst_;
}
```