#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
void *memcpy(void *dst, const void *src, size_t nbytes) {
  void *ret = dst;
  unsigned n;
  if (nbytes >= sizeof(unsigned) &&
      ((uintptr_t)src & (sizeof(unsigned) - 1)) == 0 &&
      ((uintptr_t)dst & (sizeof(unsigned) - 1)) == 0) {
    unsigned *d = (unsigned *)dst;
    unsigned *s = (unsigned *)src;
    n = ((nbytes >> 2) + 15) / 16;
    switch ((nbytes >> 2) % 16) {
    case 0:
      do {
        *d++ = *s++;
      case 15:
        *d++ = *s++;
      case 14:
        *d++ = *s++;
      case 13:
        *d++ = *s++;
      case 12:
        *d++ = *s++;
      case 11:
        *d++ = *s++;
      case 10:
        *d++ = *s++;
      case 9:
        *d++ = *s++;
      case 8:
        *d++ = *s++;
      case 7:
        *d++ = *s++;
      case 6:
        *d++ = *s++;
      case 5:
        *d++ = *s++;
      case 4:
        *d++ = *s++;
      case 3:
        *d++ = *s++;
      case 2:
        *d++ = *s++;
      case 1:
        *d++ = *s++;
      } while (--n > 0);
    }
    nbytes = nbytes & 0x3;
    if (nbytes) {
      dst = (unsigned char *)d;
      src = (const unsigned char *)s;
    }
  }
  while (nbytes) {
    *(unsigned char *)dst = *(const unsigned char *)src;
    dst = (char *)dst + 1;
    src = (const char *)src + 1;
    --nbytes;
  }
  return ret;
}


x86 assembly (clang, -O0):
<memcpy>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x20(%rbp)
cmpq   $0x4,-0x18(%rbp)
jb     13fe <memcpy+0x2fe>
mov    -0x10(%rbp),%rax
and    $0x3,%rax
cmp    $0x0,%rax
jne    13fe <memcpy+0x2fe>
mov    -0x8(%rbp),%rax
and    $0x3,%rax
cmp    $0x0,%rax
jne    13fe <memcpy+0x2fe>
mov    -0x8(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x18(%rbp),%rax
shr    $0x2,%rax
add    $0xf,%rax
shr    $0x4,%rax
mov    %eax,-0x24(%rbp)
mov    -0x18(%rbp),%eax
shr    $0x2,%eax
and    $0xf,%eax
mov    %eax,%ecx
mov    %rcx,-0x40(%rbp)
sub    $0xf,%eax
ja     13d2 <memcpy+0x2d2>
mov    -0x40(%rbp),%rax
lea    0xe73(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
jmp    119b <memcpy+0x9b>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x38(%rbp)
mov    (%rax),%ecx
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x30(%rbp)
mov    %ecx,(%rax)
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x38(%rbp)
mov    (%rax),%ecx
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x30(%rbp)
mov    %ecx,(%rax)
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x38(%rbp)
mov    (%rax),%ecx
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x30(%rbp)
mov    %ecx,(%rax)
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x38(%rbp)
mov    (%rax),%ecx
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x30(%rbp)
mov    %ecx,(%rax)
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x38(%rbp)
mov    (%rax),%ecx
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x30(%rbp)
mov    %ecx,(%rax)
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x38(%rbp)
mov    (%rax),%ecx
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x30(%rbp)
mov    %ecx,(%rax)
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x38(%rbp)
mov    (%rax),%ecx
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x30(%rbp)
mov    %ecx,(%rax)
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x38(%rbp)
mov    (%rax),%ecx
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x30(%rbp)
mov    %ecx,(%rax)
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x38(%rbp)
mov    (%rax),%ecx
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x30(%rbp)
mov    %ecx,(%rax)
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x38(%rbp)
mov    (%rax),%ecx
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x30(%rbp)
mov    %ecx,(%rax)
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x38(%rbp)
mov    (%rax),%ecx
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x30(%rbp)
mov    %ecx,(%rax)
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x38(%rbp)
mov    (%rax),%ecx
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x30(%rbp)
mov    %ecx,(%rax)
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x38(%rbp)
mov    (%rax),%ecx
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x30(%rbp)
mov    %ecx,(%rax)
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x38(%rbp)
mov    (%rax),%ecx
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x30(%rbp)
mov    %ecx,(%rax)
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x38(%rbp)
mov    (%rax),%ecx
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x30(%rbp)
mov    %ecx,(%rax)
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x38(%rbp)
mov    (%rax),%ecx
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x30(%rbp)
mov    %ecx,(%rax)
mov    -0x24(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x24(%rbp)
cmp    $0x0,%eax
ja     119b <memcpy+0x9b>
jmp    13d2 <memcpy+0x2d2>
mov    -0x18(%rbp),%rax
and    $0x3,%rax
mov    %rax,-0x18(%rbp)
cmpq   $0x0,-0x18(%rbp)
je     13f9 <memcpy+0x2f9>
mov    -0x30(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,-0x10(%rbp)
jmp    13fe <memcpy+0x2fe>
jmp    1403 <memcpy+0x303>
cmpq   $0x0,-0x18(%rbp)
je     1443 <memcpy+0x343>
mov    -0x10(%rbp),%rax
mov    (%rax),%cl
mov    -0x8(%rbp),%rax
mov    %cl,(%rax)
mov    -0x8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8(%rbp)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
mov    -0x18(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x18(%rbp)
jmp    1403 <memcpy+0x303>
mov    -0x20(%rbp),%rax
pop    %rbp
ret

x86 assembly (clang, -O2):
<memcpy>:
push   %rbx
mov    %rdi,%rax
mov    %esi,%ecx
or     %eax,%ecx
and    $0x3,%ecx
cmp    $0x4,%rdx
jb     113f <memcpy+0x3f>
test   %rcx,%rcx
jne    113f <memcpy+0x3f>
mov    %rdx,%rcx
shr    $0x2,%rcx
lea    0xf(%rcx),%r8
shr    $0x4,%r8
and    $0xf,%ecx
lea    0xed1(%rip),%rdi
movslq (%rdi,%rcx,4),%r9
add    %rdi,%r9
mov    %rax,%rcx
mov    %rsi,%rdi
jmp    *%r9
mov    %rax,%rcx
test   %rdx,%rdx
jne    124f <memcpy+0x14f>
jmp    1317 <memcpy+0x217>
mov    (%rdi),%r9d
add    $0x4,%rdi
mov    %r9d,(%rcx)
add    $0x4,%rcx
mov    (%rdi),%r9d
add    $0x4,%rdi
mov    %r9d,(%rcx)
add    $0x4,%rcx
mov    (%rdi),%r9d
add    $0x4,%rdi
mov    %r9d,(%rcx)
add    $0x4,%rcx
mov    (%rdi),%r9d
add    $0x4,%rdi
mov    %r9d,(%rcx)
add    $0x4,%rcx
mov    (%rdi),%r9d
add    $0x4,%rdi
mov    %r9d,(%rcx)
add    $0x4,%rcx
mov    (%rdi),%r9d
add    $0x4,%rdi
mov    %r9d,(%rcx)
add    $0x4,%rcx
mov    (%rdi),%r9d
add    $0x4,%rdi
mov    %r9d,(%rcx)
add    $0x4,%rcx
mov    (%rdi),%r9d
add    $0x4,%rdi
mov    %r9d,(%rcx)
add    $0x4,%rcx
mov    (%rdi),%r9d
add    $0x4,%rdi
mov    %r9d,(%rcx)
add    $0x4,%rcx
mov    (%rdi),%r9d
add    $0x4,%rdi
mov    %r9d,(%rcx)
add    $0x4,%rcx
mov    (%rdi),%r9d
add    $0x4,%rdi
mov    %r9d,(%rcx)
add    $0x4,%rcx
mov    (%rdi),%r9d
add    $0x4,%rdi
mov    %r9d,(%rcx)
add    $0x4,%rcx
mov    (%rdi),%r9d
add    $0x4,%rdi
mov    %r9d,(%rcx)
add    $0x4,%rcx
mov    (%rdi),%r9d
add    $0x4,%rdi
mov    %r9d,(%rcx)
add    $0x4,%rcx
mov    (%rdi),%r9d
add    $0x4,%rdi
mov    %r9d,(%rcx)
add    $0x4,%rcx
mov    (%rdi),%r9d
add    $0x4,%rdi
mov    %r9d,(%rcx)
add    $0x4,%rcx
add    $0xffffffff,%r8d
jne    1150 <memcpy+0x50>
and    $0x3,%rdx
cmovne %rdi,%rsi
cmove  %rax,%rcx
test   %rdx,%rdx
je     1317 <memcpy+0x217>
cmp    $0x8,%rdx
jb     126f <memcpy+0x16f>
lea    (%rcx,%rdx,1),%r8
lea    (%rsi,%rdx,1),%rdi
cmp    %rdi,%rcx
jae    1319 <memcpy+0x219>
cmp    %r8,%rsi
jae    1319 <memcpy+0x219>
mov    %rcx,%r10
mov    %rdx,%r9
mov    %rsi,%rdi
lea    -0x1(%r9),%rcx
mov    %r9,%rsi
and    $0x7,%rsi
je     12aa <memcpy+0x1aa>
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movzbl (%rdi,%rdx,1),%ebx
mov    %bl,(%r10,%rdx,1)
add    $0x1,%rdx
cmp    %rdx,%rsi
jne    1290 <memcpy+0x190>
add    %rdx,%r10
sub    %rdx,%r9
add    %rdx,%rdi
cmp    $0x7,%rcx
jb     1317 <memcpy+0x217>
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl (%rdi,%rcx,1),%edx
mov    %dl,(%r10,%rcx,1)
movzbl 0x1(%rdi,%rcx,1),%edx
mov    %dl,0x1(%r10,%rcx,1)
movzbl 0x2(%rdi,%rcx,1),%edx
mov    %dl,0x2(%r10,%rcx,1)
movzbl 0x3(%rdi,%rcx,1),%edx
mov    %dl,0x3(%r10,%rcx,1)
movzbl 0x4(%rdi,%rcx,1),%edx
mov    %dl,0x4(%r10,%rcx,1)
movzbl 0x5(%rdi,%rcx,1),%edx
mov    %dl,0x5(%r10,%rcx,1)
movzbl 0x6(%rdi,%rcx,1),%edx
mov    %dl,0x6(%r10,%rcx,1)
movzbl 0x7(%rdi,%rcx,1),%edx
mov    %dl,0x7(%r10,%rcx,1)
add    $0x8,%rcx
cmp    %rcx,%r9
jne    12c0 <memcpy+0x1c0>
pop    %rbx
ret
xor    %r8d,%r8d
cmp    $0x20,%rdx
jb     1420 <memcpy+0x320>
mov    %rdx,%r8
and    $0xffffffffffffffe0,%r8
lea    -0x20(%r8),%r11
mov    %r11,%r10
shr    $0x5,%r10
add    $0x1,%r10
mov    %r10d,%r9d
and    $0x3,%r9d
xor    %edi,%edi
cmp    $0x60,%r11
jb     13b8 <memcpy+0x2b8>
and    $0xfffffffffffffffc,%r10
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups (%rsi,%rdi,1),%xmm0
movups 0x10(%rsi,%rdi,1),%xmm1
movups %xmm0,(%rcx,%rdi,1)
movups %xmm1,0x10(%rcx,%rdi,1)
movups 0x20(%rsi,%rdi,1),%xmm0
movups 0x30(%rsi,%rdi,1),%xmm1
movups %xmm0,0x20(%rcx,%rdi,1)
movups %xmm1,0x30(%rcx,%rdi,1)
movups 0x40(%rsi,%rdi,1),%xmm0
movups 0x50(%rsi,%rdi,1),%xmm1
movups %xmm0,0x40(%rcx,%rdi,1)
movups %xmm1,0x50(%rcx,%rdi,1)
movups 0x60(%rsi,%rdi,1),%xmm0
movups 0x70(%rsi,%rdi,1),%xmm1
movups %xmm0,0x60(%rcx,%rdi,1)
movups %xmm1,0x70(%rcx,%rdi,1)
sub    $0xffffffffffffff80,%rdi
add    $0xfffffffffffffffc,%r10
jne    1360 <memcpy+0x260>
test   %r9,%r9
je     13ff <memcpy+0x2ff>
lea    (%rsi,%rdi,1),%r10
add    $0x10,%r10
lea    (%rcx,%rdi,1),%r11
add    $0x10,%r11
shl    $0x5,%r9
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x10(%r10,%rdi,1),%xmm0
movups (%r10,%rdi,1),%xmm1
movups %xmm0,-0x10(%r11,%rdi,1)
movups %xmm1,(%r11,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%r9
jne    13e0 <memcpy+0x2e0>
cmp    %r8,%rdx
je     1317 <memcpy+0x217>
lea    (%rsi,%r8,1),%rdi
mov    %edx,%r9d
and    $0x1f,%r9d
lea    (%rcx,%r8,1),%r10
test   $0x18,%dl
je     1278 <memcpy+0x178>
mov    %rdx,%r11
and    $0xfffffffffffffff8,%r11
lea    (%rcx,%r11,1),%r10
mov    %edx,%r9d
and    $0x7,%r9d
lea    (%rsi,%r11,1),%rdi
cs nopw 0x0(%rax,%rax,1)
mov    (%rsi,%r8,1),%rbx
mov    %rbx,(%rcx,%r8,1)
add    $0x8,%r8
cmp    %r8,%r11
jne    1440 <memcpy+0x340>
cmp    %r11,%rdx
jne    1278 <memcpy+0x178>
jmp    1317 <memcpy+0x217>

LLVM IR (-O0):
define i8* @memcpy(i8* %0, i8* %1, i64 %2) {
%4 = alloca i8*
%5 = alloca i8*
%6 = alloca i64
%7 = alloca i8*
%8 = alloca i32
%9 = alloca i32*
%10 = alloca i32*
store i8* %0, i8** %4
store i8* %1, i8** %5
store i64 %2, i64* %6
%11 = load i8*, i8** %4
store i8* %11, i8** %7
%12 = load i64, i64* %6
%13 = icmp uge i64 %12, 4
br i1 %13, label %14, label %150
14: ; preds = %3
%15 = load i8*, i8** %5
%16 = ptrtoint i8* %15 to i64
%17 = and i64 %16, 3
%18 = icmp eq i64 %17, 0
br i1 %18, label %19, label %150
19: ; preds = %14
%20 = load i8*, i8** %4
%21 = ptrtoint i8* %20 to i64
%22 = and i64 %21, 3
%23 = icmp eq i64 %22, 0
br i1 %23, label %24, label %150
24: ; preds = %19
%25 = load i8*, i8** %4
%26 = bitcast i8* %25 to i32*
store i32* %26, i32** %9
%27 = load i8*, i8** %5
%28 = bitcast i8* %27 to i32*
store i32* %28, i32** %10
%29 = load i64, i64* %6
%30 = lshr i64 %29, 2
%31 = add i64 %30, 15
%32 = udiv i64 %31, 16
%33 = trunc i64 %32 to i32
store i32 %33, i32* %8
%34 = load i64, i64* %6
%35 = lshr i64 %34, 2
%36 = urem i64 %35, 16
switch i64 %36, label %139 [
i64 0, label %37
i64 15, label %44
i64 14, label %50
i64 13, label %56
i64 12, label %62
i64 11, label %68
i64 10, label %74
i64 9, label %80
i64 8, label %86
i64 7, label %92
i64 6, label %98
i64 5, label %104
i64 4, label %110
i64 3, label %116
i64 2, label %122
i64 1, label %128
]
37: ; preds = %24
br label %38
38: ; preds = %134, %37
%39 = load i32*, i32** %10
%40 = getelementptr inbounds i32, i32* %39, i32 1
store i32* %40, i32** %10
%41 = load i32, i32* %39
%42 = load i32*, i32** %9
%43 = getelementptr inbounds i32, i32* %42, i32 1
store i32* %43, i32** %9
store i32 %41, i32* %42
br label %44
44: ; preds = %24, %38
%45 = load i32*, i32** %10
%46 = getelementptr inbounds i32, i32* %45, i32 1
store i32* %46, i32** %10
%47 = load i32, i32* %45
%48 = load i32*, i32** %9
%49 = getelementptr inbounds i32, i32* %48, i32 1
store i32* %49, i32** %9
store i32 %47, i32* %48
br label %50
50: ; preds = %24, %44
%51 = load i32*, i32** %10
%52 = getelementptr inbounds i32, i32* %51, i32 1
store i32* %52, i32** %10
%53 = load i32, i32* %51
%54 = load i32*, i32** %9
%55 = getelementptr inbounds i32, i32* %54, i32 1
store i32* %55, i32** %9
store i32 %53, i32* %54
br label %56
56: ; preds = %24, %50
%57 = load i32*, i32** %10
%58 = getelementptr inbounds i32, i32* %57, i32 1
store i32* %58, i32** %10
%59 = load i32, i32* %57
%60 = load i32*, i32** %9
%61 = getelementptr inbounds i32, i32* %60, i32 1
store i32* %61, i32** %9
store i32 %59, i32* %60
br label %62
62: ; preds = %24, %56
%63 = load i32*, i32** %10
%64 = getelementptr inbounds i32, i32* %63, i32 1
store i32* %64, i32** %10
%65 = load i32, i32* %63
%66 = load i32*, i32** %9
%67 = getelementptr inbounds i32, i32* %66, i32 1
store i32* %67, i32** %9
store i32 %65, i32* %66
br label %68
68: ; preds = %24, %62
%69 = load i32*, i32** %10
%70 = getelementptr inbounds i32, i32* %69, i32 1
store i32* %70, i32** %10
%71 = load i32, i32* %69
%72 = load i32*, i32** %9
%73 = getelementptr inbounds i32, i32* %72, i32 1
store i32* %73, i32** %9
store i32 %71, i32* %72
br label %74
74: ; preds = %24, %68
%75 = load i32*, i32** %10
%76 = getelementptr inbounds i32, i32* %75, i32 1
store i32* %76, i32** %10
%77 = load i32, i32* %75
%78 = load i32*, i32** %9
%79 = getelementptr inbounds i32, i32* %78, i32 1
store i32* %79, i32** %9
store i32 %77, i32* %78
br label %80
80: ; preds = %24, %74
%81 = load i32*, i32** %10
%82 = getelementptr inbounds i32, i32* %81, i32 1
store i32* %82, i32** %10
%83 = load i32, i32* %81
%84 = load i32*, i32** %9
%85 = getelementptr inbounds i32, i32* %84, i32 1
store i32* %85, i32** %9
store i32 %83, i32* %84
br label %86
86: ; preds = %24, %80
%87 = load i32*, i32** %10
%88 = getelementptr inbounds i32, i32* %87, i32 1
store i32* %88, i32** %10
%89 = load i32, i32* %87
%90 = load i32*, i32** %9
%91 = getelementptr inbounds i32, i32* %90, i32 1
store i32* %91, i32** %9
store i32 %89, i32* %90
br label %92
92: ; preds = %24, %86
%93 = load i32*, i32** %10
%94 = getelementptr inbounds i32, i32* %93, i32 1
store i32* %94, i32** %10
%95 = load i32, i32* %93
%96 = load i32*, i32** %9
%97 = getelementptr inbounds i32, i32* %96, i32 1
store i32* %97, i32** %9
store i32 %95, i32* %96
br label %98
98: ; preds = %24, %92
%99 = load i32*, i32** %10
%100 = getelementptr inbounds i32, i32* %99, i32 1
store i32* %100, i32** %10
%101 = load i32, i32* %99
%102 = load i32*, i32** %9
%103 = getelementptr inbounds i32, i32* %102, i32 1
store i32* %103, i32** %9
store i32 %101, i32* %102
br label %104
104: ; preds = %24, %98
%105 = load i32*, i32** %10
%106 = getelementptr inbounds i32, i32* %105, i32 1
store i32* %106, i32** %10
%107 = load i32, i32* %105
%108 = load i32*, i32** %9
%109 = getelementptr inbounds i32, i32* %108, i32 1
store i32* %109, i32** %9
store i32 %107, i32* %108
br label %110
110: ; preds = %24, %104
%111 = load i32*, i32** %10
%112 = getelementptr inbounds i32, i32* %111, i32 1
store i32* %112, i32** %10
%113 = load i32, i32* %111
%114 = load i32*, i32** %9
%115 = getelementptr inbounds i32, i32* %114, i32 1
store i32* %115, i32** %9
store i32 %113, i32* %114
br label %116
116: ; preds = %24, %110
%117 = load i32*, i32** %10
%118 = getelementptr inbounds i32, i32* %117, i32 1
store i32* %118, i32** %10
%119 = load i32, i32* %117
%120 = load i32*, i32** %9
%121 = getelementptr inbounds i32, i32* %120, i32 1
store i32* %121, i32** %9
store i32 %119, i32* %120
br label %122
122: ; preds = %24, %116
%123 = load i32*, i32** %10
%124 = getelementptr inbounds i32, i32* %123, i32 1
store i32* %124, i32** %10
%125 = load i32, i32* %123
%126 = load i32*, i32** %9
%127 = getelementptr inbounds i32, i32* %126, i32 1
store i32* %127, i32** %9
store i32 %125, i32* %126
br label %128
128: ; preds = %24, %122
%129 = load i32*, i32** %10
%130 = getelementptr inbounds i32, i32* %129, i32 1
store i32* %130, i32** %10
%131 = load i32, i32* %129
%132 = load i32*, i32** %9
%133 = getelementptr inbounds i32, i32* %132, i32 1
store i32* %133, i32** %9
store i32 %131, i32* %132
br label %134
134: ; preds = %128
%135 = load i32, i32* %8
%136 = add i32 %135, -1
store i32 %136, i32* %8
%137 = icmp ugt i32 %136, 0
br i1 %137, label %38, label %138
138: ; preds = %134
br label %139
139: ; preds = %138, %24
%140 = load i64, i64* %6
%141 = and i64 %140, 3
store i64 %141, i64* %6
%142 = load i64, i64* %6
%143 = icmp ne i64 %142, 0
br i1 %143, label %144, label %149
144: ; preds = %139
%145 = load i32*, i32** %9
%146 = bitcast i32* %145 to i8*
store i8* %146, i8** %4
%147 = load i32*, i32** %10
%148 = bitcast i32* %147 to i8*
store i8* %148, i8** %5
br label %149
149: ; preds = %144, %139
br label %150
150: ; preds = %149, %19, %14, %3
br label %151
151: ; preds = %154, %150
%152 = load i64, i64* %6
%153 = icmp ne i64 %152, 0
br i1 %153, label %154, label %164
154: ; preds = %151
%155 = load i8*, i8** %5
%156 = load i8, i8* %155
%157 = load i8*, i8** %4
store i8 %156, i8* %157
%158 = load i8*, i8** %4
%159 = getelementptr inbounds i8, i8* %158, i64 1
store i8* %159, i8** %4
%160 = load i8*, i8** %5
%161 = getelementptr inbounds i8, i8* %160, i64 1
store i8* %161, i8** %5
%162 = load i64, i64* %6
%163 = add i64 %162, -1
store i64 %163, i64* %6
br label %151
164: ; preds = %151
%165 = load i8*, i8** %7
ret i8* %165
}

LLVM IR (-O2):
define i8* @memcpy(i8* returned %0, i8* %1, i64 %2) {
%4 = icmp ugt i64 %2, 3
%5 = ptrtoint i8* %1 to i64
%6 = ptrtoint i8* %0 to i64
%7 = or i64 %5, %6
%8 = and i64 %7, 3
%9 = icmp eq i64 %8, 0
%10 = and i1 %4, %9
br i1 %10, label %11, label %141
11: ; preds = %3
%12 = bitcast i8* %0 to i32*
%13 = bitcast i8* %1 to i32*
%14 = lshr i64 %2, 2
%15 = add nuw nsw i64 %14, 15
%16 = lshr i64 %15, 4
%17 = trunc i64 %16 to i32
%18 = and i64 %14, 15
switch i64 %18, label %133 [
i64 0, label %19
i64 15, label %26
i64 14, label %33
i64 13, label %40
i64 12, label %47
i64 11, label %54
i64 10, label %61
i64 9, label %68
i64 8, label %75
i64 7, label %82
i64 6, label %89
i64 5, label %96
i64 4, label %103
i64 3, label %110
i64 2, label %117
i64 1, label %124
]
19: ; preds = %11, %124
%20 = phi i32 [ %131, %124 ], [ %17, %11 ]
%21 = phi i32* [ %130, %124 ], [ %12, %11 ]
%22 = phi i32* [ %128, %124 ], [ %13, %11 ]
%23 = getelementptr inbounds i32, i32* %22, i64 1
%24 = load i32, i32* %22
%25 = getelementptr inbounds i32, i32* %21, i64 1
store i32 %24, i32* %21
br label %26
26: ; preds = %11, %19
%27 = phi i32 [ %20, %19 ], [ %17, %11 ]
%28 = phi i32* [ %25, %19 ], [ %12, %11 ]
%29 = phi i32* [ %23, %19 ], [ %13, %11 ]
%30 = getelementptr inbounds i32, i32* %29, i64 1
%31 = load i32, i32* %29
%32 = getelementptr inbounds i32, i32* %28, i64 1
store i32 %31, i32* %28
br label %33
33: ; preds = %11, %26
%34 = phi i32 [ %27, %26 ], [ %17, %11 ]
%35 = phi i32* [ %32, %26 ], [ %12, %11 ]
%36 = phi i32* [ %30, %26 ], [ %13, %11 ]
%37 = getelementptr inbounds i32, i32* %36, i64 1
%38 = load i32, i32* %36
%39 = getelementptr inbounds i32, i32* %35, i64 1
store i32 %38, i32* %35
br label %40
40: ; preds = %11, %33
%41 = phi i32 [ %34, %33 ], [ %17, %11 ]
%42 = phi i32* [ %39, %33 ], [ %12, %11 ]
%43 = phi i32* [ %37, %33 ], [ %13, %11 ]
%44 = getelementptr inbounds i32, i32* %43, i64 1
%45 = load i32, i32* %43
%46 = getelementptr inbounds i32, i32* %42, i64 1
store i32 %45, i32* %42
br label %47
47: ; preds = %11, %40
%48 = phi i32 [ %41, %40 ], [ %17, %11 ]
%49 = phi i32* [ %46, %40 ], [ %12, %11 ]
%50 = phi i32* [ %44, %40 ], [ %13, %11 ]
%51 = getelementptr inbounds i32, i32* %50, i64 1
%52 = load i32, i32* %50
%53 = getelementptr inbounds i32, i32* %49, i64 1
store i32 %52, i32* %49
br label %54
54: ; preds = %11, %47
%55 = phi i32 [ %48, %47 ], [ %17, %11 ]
%56 = phi i32* [ %53, %47 ], [ %12, %11 ]
%57 = phi i32* [ %51, %47 ], [ %13, %11 ]
%58 = getelementptr inbounds i32, i32* %57, i64 1
%59 = load i32, i32* %57
%60 = getelementptr inbounds i32, i32* %56, i64 1
store i32 %59, i32* %56
br label %61
61: ; preds = %11, %54
%62 = phi i32 [ %55, %54 ], [ %17, %11 ]
%63 = phi i32* [ %60, %54 ], [ %12, %11 ]
%64 = phi i32* [ %58, %54 ], [ %13, %11 ]
%65 = getelementptr inbounds i32, i32* %64, i64 1
%66 = load i32, i32* %64
%67 = getelementptr inbounds i32, i32* %63, i64 1
store i32 %66, i32* %63
br label %68
68: ; preds = %11, %61
%69 = phi i32 [ %62, %61 ], [ %17, %11 ]
%70 = phi i32* [ %67, %61 ], [ %12, %11 ]
%71 = phi i32* [ %65, %61 ], [ %13, %11 ]
%72 = getelementptr inbounds i32, i32* %71, i64 1
%73 = load i32, i32* %71
%74 = getelementptr inbounds i32, i32* %70, i64 1
store i32 %73, i32* %70
br label %75
75: ; preds = %11, %68
%76 = phi i32 [ %69, %68 ], [ %17, %11 ]
%77 = phi i32* [ %74, %68 ], [ %12, %11 ]
%78 = phi i32* [ %72, %68 ], [ %13, %11 ]
%79 = getelementptr inbounds i32, i32* %78, i64 1
%80 = load i32, i32* %78
%81 = getelementptr inbounds i32, i32* %77, i64 1
store i32 %80, i32* %77
br label %82
82: ; preds = %11, %75
%83 = phi i32 [ %76, %75 ], [ %17, %11 ]
%84 = phi i32* [ %81, %75 ], [ %12, %11 ]
%85 = phi i32* [ %79, %75 ], [ %13, %11 ]
%86 = getelementptr inbounds i32, i32* %85, i64 1
%87 = load i32, i32* %85
%88 = getelementptr inbounds i32, i32* %84, i64 1
store i32 %87, i32* %84
br label %89
89: ; preds = %11, %82
%90 = phi i32 [ %83, %82 ], [ %17, %11 ]
%91 = phi i32* [ %88, %82 ], [ %12, %11 ]
%92 = phi i32* [ %86, %82 ], [ %13, %11 ]
%93 = getelementptr inbounds i32, i32* %92, i64 1
%94 = load i32, i32* %92
%95 = getelementptr inbounds i32, i32* %91, i64 1
store i32 %94, i32* %91
br label %96
96: ; preds = %11, %89
%97 = phi i32 [ %90, %89 ], [ %17, %11 ]
%98 = phi i32* [ %95, %89 ], [ %12, %11 ]
%99 = phi i32* [ %93, %89 ], [ %13, %11 ]
%100 = getelementptr inbounds i32, i32* %99, i64 1
%101 = load i32, i32* %99
%102 = getelementptr inbounds i32, i32* %98, i64 1
store i32 %101, i32* %98
br label %103
103: ; preds = %11, %96
%104 = phi i32 [ %97, %96 ], [ %17, %11 ]
%105 = phi i32* [ %102, %96 ], [ %12, %11 ]
%106 = phi i32* [ %100, %96 ], [ %13, %11 ]
%107 = getelementptr inbounds i32, i32* %106, i64 1
%108 = load i32, i32* %106
%109 = getelementptr inbounds i32, i32* %105, i64 1
store i32 %108, i32* %105
br label %110
110: ; preds = %11, %103
%111 = phi i32 [ %104, %103 ], [ %17, %11 ]
%112 = phi i32* [ %109, %103 ], [ %12, %11 ]
%113 = phi i32* [ %107, %103 ], [ %13, %11 ]
%114 = getelementptr inbounds i32, i32* %113, i64 1
%115 = load i32, i32* %113
%116 = getelementptr inbounds i32, i32* %112, i64 1
store i32 %115, i32* %112
br label %117
117: ; preds = %11, %110
%118 = phi i32 [ %111, %110 ], [ %17, %11 ]
%119 = phi i32* [ %116, %110 ], [ %12, %11 ]
%120 = phi i32* [ %114, %110 ], [ %13, %11 ]
%121 = getelementptr inbounds i32, i32* %120, i64 1
%122 = load i32, i32* %120
%123 = getelementptr inbounds i32, i32* %119, i64 1
store i32 %122, i32* %119
br label %124
124: ; preds = %11, %117
%125 = phi i32 [ %17, %11 ], [ %118, %117 ]
%126 = phi i32* [ %12, %11 ], [ %123, %117 ]
%127 = phi i32* [ %13, %11 ], [ %121, %117 ]
%128 = getelementptr inbounds i32, i32* %127, i64 1
%129 = load i32, i32* %127
%130 = getelementptr inbounds i32, i32* %126, i64 1
store i32 %129, i32* %126
%131 = add i32 %125, -1
%132 = icmp eq i32 %131, 0
br i1 %132, label %134, label %19
133: ; preds = %11
unreachable
134: ; preds = %124
%135 = and i64 %2, 3
%136 = icmp eq i64 %135, 0
%137 = bitcast i32* %130 to i8*
%138 = bitcast i32* %128 to i8*
%139 = select i1 %136, i8* %1, i8* %138
%140 = select i1 %136, i8* %0, i8* %137
br label %141
141: ; preds = %134, %3
%142 = phi i8* [ %139, %134 ], [ %1, %3 ]
%143 = phi i64 [ %135, %134 ], [ %2, %3 ]
%144 = phi i8* [ %140, %134 ], [ %0, %3 ]
%145 = icmp eq i64 %143, 0
br i1 %145, label %311, label %146
146: ; preds = %141
%147 = icmp ult i64 %143, 8
br i1 %147, label %258, label %148
148: ; preds = %146
%149 = getelementptr i8, i8* %144, i64 %143
%150 = getelementptr i8, i8* %142, i64 %143
%151 = icmp ult i8* %144, %150
%152 = icmp ult i8* %142, %149
%153 = and i1 %151, %152
br i1 %153, label %258, label %154
154: ; preds = %148
%155 = icmp ult i64 %143, 32
br i1 %155, label %241, label %156
156: ; preds = %154
%157 = and i64 %143, -32
%158 = add i64 %157, -32
%159 = lshr exact i64 %158, 5
%160 = add nuw nsw i64 %159, 1
%161 = and i64 %160, 3
%162 = icmp ult i64 %158, 96
br i1 %162, label %214, label %163
163: ; preds = %156
%164 = and i64 %160, 1152921504606846972
br label %165
165: ; preds = %165, %163
%166 = phi i64 [ 0, %163 ], [ %211, %165 ]
%167 = phi i64 [ 0, %163 ], [ %212, %165 ]
%168 = getelementptr i8, i8* %144, i64 %166
%169 = getelementptr i8, i8* %142, i64 %166
%170 = bitcast i8* %169 to <16 x i8>*
%171 = load <16 x i8>, <16 x i8>* %170
%172 = getelementptr i8, i8* %169, i64 16
%173 = bitcast i8* %172 to <16 x i8>*
%174 = load <16 x i8>, <16 x i8>* %173
%175 = bitcast i8* %168 to <16 x i8>*
store <16 x i8> %171, <16 x i8>* %175
%176 = getelementptr i8, i8* %168, i64 16
%177 = bitcast i8* %176 to <16 x i8>*
store <16 x i8> %174, <16 x i8>* %177
%178 = or i64 %166, 32
%179 = getelementptr i8, i8* %144, i64 %178
%180 = getelementptr i8, i8* %142, i64 %178
%181 = bitcast i8* %180 to <16 x i8>*
%182 = load <16 x i8>, <16 x i8>* %181
%183 = getelementptr i8, i8* %180, i64 16
%184 = bitcast i8* %183 to <16 x i8>*
%185 = load <16 x i8>, <16 x i8>* %184
%186 = bitcast i8* %179 to <16 x i8>*
store <16 x i8> %182, <16 x i8>* %186
%187 = getelementptr i8, i8* %179, i64 16
%188 = bitcast i8* %187 to <16 x i8>*
store <16 x i8> %185, <16 x i8>* %188
%189 = or i64 %166, 64
%190 = getelementptr i8, i8* %144, i64 %189
%191 = getelementptr i8, i8* %142, i64 %189
%192 = bitcast i8* %191 to <16 x i8>*
%193 = load <16 x i8>, <16 x i8>* %192
%194 = getelementptr i8, i8* %191, i64 16
%195 = bitcast i8* %194 to <16 x i8>*
%196 = load <16 x i8>, <16 x i8>* %195
%197 = bitcast i8* %190 to <16 x i8>*
store <16 x i8> %193, <16 x i8>* %197
%198 = getelementptr i8, i8* %190, i64 16
%199 = bitcast i8* %198 to <16 x i8>*
store <16 x i8> %196, <16 x i8>* %199
%200 = or i64 %166, 96
%201 = getelementptr i8, i8* %144, i64 %200
%202 = getelementptr i8, i8* %142, i64 %200
%203 = bitcast i8* %202 to <16 x i8>*
%204 = load <16 x i8>, <16 x i8>* %203
%205 = getelementptr i8, i8* %202, i64 16
%206 = bitcast i8* %205 to <16 x i8>*
%207 = load <16 x i8>, <16 x i8>* %206
%208 = bitcast i8* %201 to <16 x i8>*
store <16 x i8> %204, <16 x i8>* %208
%209 = getelementptr i8, i8* %201, i64 16
%210 = bitcast i8* %209 to <16 x i8>*
store <16 x i8> %207, <16 x i8>* %210
%211 = add nuw i64 %166, 128
%212 = add i64 %167, 4
%213 = icmp eq i64 %212, %164
br i1 %213, label %214, label %165
214: ; preds = %165, %156
%215 = phi i64 [ 0, %156 ], [ %211, %165 ]
%216 = icmp eq i64 %161, 0
br i1 %216, label %233, label %217
217: ; preds = %214, %217
%218 = phi i64 [ %230, %217 ], [ %215, %214 ]
%219 = phi i64 [ %231, %217 ], [ 0, %214 ]
%220 = getelementptr i8, i8* %144, i64 %218
%221 = getelementptr i8, i8* %142, i64 %218
%222 = bitcast i8* %221 to <16 x i8>*
%223 = load <16 x i8>, <16 x i8>* %222
%224 = getelementptr i8, i8* %221, i64 16
%225 = bitcast i8* %224 to <16 x i8>*
%226 = load <16 x i8>, <16 x i8>* %225
%227 = bitcast i8* %220 to <16 x i8>*
store <16 x i8> %223, <16 x i8>* %227
%228 = getelementptr i8, i8* %220, i64 16
%229 = bitcast i8* %228 to <16 x i8>*
store <16 x i8> %226, <16 x i8>* %229
%230 = add nuw i64 %218, 32
%231 = add i64 %219, 1
%232 = icmp eq i64 %231, %161
br i1 %232, label %233, label %217
233: ; preds = %217, %214
%234 = icmp eq i64 %143, %157
br i1 %234, label %311, label %235
235: ; preds = %233
%236 = getelementptr i8, i8* %142, i64 %157
%237 = and i64 %143, 31
%238 = getelementptr i8, i8* %144, i64 %157
%239 = and i64 %143, 24
%240 = icmp eq i64 %239, 0
br i1 %240, label %258, label %241
241: ; preds = %154, %235
%242 = phi i64 [ %157, %235 ], [ 0, %154 ]
%243 = and i64 %143, -8
%244 = getelementptr i8, i8* %144, i64 %243
%245 = and i64 %143, 7
%246 = getelementptr i8, i8* %142, i64 %243
br label %247
247: ; preds = %247, %241
%248 = phi i64 [ %242, %241 ], [ %254, %247 ]
%249 = getelementptr i8, i8* %144, i64 %248
%250 = getelementptr i8, i8* %142, i64 %248
%251 = bitcast i8* %250 to <8 x i8>*
%252 = load <8 x i8>, <8 x i8>* %251
%253 = bitcast i8* %249 to <8 x i8>*
store <8 x i8> %252, <8 x i8>* %253
%254 = add nuw i64 %248, 8
%255 = icmp eq i64 %254, %243
br i1 %255, label %256, label %247
256: ; preds = %247
%257 = icmp eq i64 %143, %243
br i1 %257, label %311, label %258
258: ; preds = %148, %146, %235, %256
%259 = phi i8* [ %144, %146 ], [ %144, %148 ], [ %238, %235 ], [ %244, %256 ]
%260 = phi i64 [ %143, %146 ], [ %143, %148 ], [ %237, %235 ], [ %245, %256 ]
%261 = phi i8* [ %142, %146 ], [ %142, %148 ], [ %236, %235 ], [ %246, %256 ]
%262 = add i64 %260, -1
%263 = and i64 %260, 7
%264 = icmp eq i64 %263, 0
br i1 %264, label %276, label %265
265: ; preds = %258, %265
%266 = phi i8* [ %271, %265 ], [ %259, %258 ]
%267 = phi i64 [ %273, %265 ], [ %260, %258 ]
%268 = phi i8* [ %272, %265 ], [ %261, %258 ]
%269 = phi i64 [ %274, %265 ], [ 0, %258 ]
%270 = load i8, i8* %268
store i8 %270, i8* %266
%271 = getelementptr inbounds i8, i8* %266, i64 1
%272 = getelementptr inbounds i8, i8* %268, i64 1
%273 = add i64 %267, -1
%274 = add i64 %269, 1
%275 = icmp eq i64 %274, %263
br i1 %275, label %276, label %265
276: ; preds = %265, %258
%277 = phi i8* [ %259, %258 ], [ %271, %265 ]
%278 = phi i64 [ %260, %258 ], [ %273, %265 ]
%279 = phi i8* [ %261, %258 ], [ %272, %265 ]
%280 = icmp ult i64 %262, 7
br i1 %280, label %311, label %281
281: ; preds = %276, %281
%282 = phi i8* [ %307, %281 ], [ %277, %276 ]
%283 = phi i64 [ %309, %281 ], [ %278, %276 ]
%284 = phi i8* [ %308, %281 ], [ %279, %276 ]
%285 = load i8, i8* %284
store i8 %285, i8* %282
%286 = getelementptr inbounds i8, i8* %282, i64 1
%287 = getelementptr inbounds i8, i8* %284, i64 1
%288 = load i8, i8* %287
store i8 %288, i8* %286
%289 = getelementptr inbounds i8, i8* %282, i64 2
%290 = getelementptr inbounds i8, i8* %284, i64 2
%291 = load i8, i8* %290
store i8 %291, i8* %289
%292 = getelementptr inbounds i8, i8* %282, i64 3
%293 = getelementptr inbounds i8, i8* %284, i64 3
%294 = load i8, i8* %293
store i8 %294, i8* %292
%295 = getelementptr inbounds i8, i8* %282, i64 4
%296 = getelementptr inbounds i8, i8* %284, i64 4
%297 = load i8, i8* %296
store i8 %297, i8* %295
%298 = getelementptr inbounds i8, i8* %282, i64 5
%299 = getelementptr inbounds i8, i8* %284, i64 5
%300 = load i8, i8* %299
store i8 %300, i8* %298
%301 = getelementptr inbounds i8, i8* %282, i64 6
%302 = getelementptr inbounds i8, i8* %284, i64 6
%303 = load i8, i8* %302
store i8 %303, i8* %301
%304 = getelementptr inbounds i8, i8* %282, i64 7
%305 = getelementptr inbounds i8, i8* %284, i64 7
%306 = load i8, i8* %305
store i8 %306, i8* %304
%307 = getelementptr inbounds i8, i8* %282, i64 8
%308 = getelementptr inbounds i8, i8* %284, i64 8
%309 = add i64 %283, -8
%310 = icmp eq i64 %309, 0
br i1 %310, label %311, label %281
311: ; preds = %276, %281, %233, %256, %141
ret i8* %0
}