#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 *dest, const void *src, size_t n) {
  unsigned char *d = dest;
  const unsigned char *s = src;
  if (((uintptr_t)d & (sizeof(size_t) - 1)) !=
      ((uintptr_t)s & (sizeof(size_t) - 1)))
    goto misaligned;
  for (; ((uintptr_t)d & (sizeof(size_t) - 1)) && n; n--)
    *d++ = *s++;
  if (n) {
    size_t *wd = (void *)d;
    const size_t *ws = (const void *)s;
    for (; n >= (sizeof(size_t)); n -= (sizeof(size_t)))
      *wd++ = *ws++;
    d = (void *)wd;
    s = (const void *)ws;
  misaligned:
    for (; n; n--)
      *d++ = *s++;
  }
  return dest;
}


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)
mov    -0x10(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%rax
and    $0x7,%rax
mov    -0x28(%rbp),%rcx
and    $0x7,%rcx
cmp    %rcx,%rax
je     113e <memcpy+0x3e>
jmp    1213 <memcpy+0x113>
jmp    1143 <memcpy+0x43>
mov    -0x20(%rbp),%rcx
and    $0x7,%rcx
xor    %eax,%eax
cmp    $0x0,%rcx
mov    %al,-0x39(%rbp)
je     1165 <memcpy+0x65>
cmpq   $0x0,-0x18(%rbp)
setne  %al
mov    %al,-0x39(%rbp)
mov    -0x39(%rbp),%al
test   $0x1,%al
jne    1175 <memcpy+0x75>
jmp    11a8 <memcpy+0xa8>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
mov    (%rax),%cl
mov    -0x20(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x20(%rbp)
mov    %cl,(%rax)
mov    -0x18(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x18(%rbp)
jmp    1143 <memcpy+0x43>
cmpq   $0x0,-0x18(%rbp)
je     125b <memcpy+0x15b>
mov    -0x20(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0x38(%rbp)
cmpq   $0x8,-0x18(%rbp)
jb     1203 <memcpy+0x103>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x38(%rbp)
mov    (%rax),%rcx
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,-0x30(%rbp)
mov    %rcx,(%rax)
mov    -0x18(%rbp),%rax
sub    $0x8,%rax
mov    %rax,-0x18(%rbp)
jmp    11c3 <memcpy+0xc3>
mov    -0x30(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,-0x28(%rbp)
jmp    1218 <memcpy+0x118>
cmpq   $0x0,-0x18(%rbp)
je     1256 <memcpy+0x156>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
mov    (%rax),%cl
mov    -0x20(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x20(%rbp)
mov    %cl,(%rax)
mov    -0x18(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x18(%rbp)
jmp    1218 <memcpy+0x118>
jmp    125b <memcpy+0x15b>
mov    -0x8(%rbp),%rax
pop    %rbp
ret

x86 assembly (clang, -O2):
<memcpy>:
push   %r14
push   %rbx
mov    %rdi,%rax
mov    %esi,%ecx
xor    %eax,%ecx
test   $0x7,%cl
je     1120 <memcpy+0x20>
mov    %rax,%r10
test   %rdx,%rdx
jne    13e4 <memcpy+0x2e4>
jmp    149f <memcpy+0x39f>
test   %rdx,%rdx
setne  %r9b
test   $0x7,%al
je     126d <memcpy+0x16d>
test   %rdx,%rdx
je     126d <memcpy+0x16d>
lea    0x1(%rsi),%r8
mov    (%rsi),%cl
lea    0x1(%rax),%r10
mov    %cl,(%rax)
mov    %rdx,%rdi
add    $0xffffffffffffffff,%rdi
setne  %r9b
test   $0x7,%r10b
je     1276 <memcpy+0x176>
test   %rdi,%rdi
je     1276 <memcpy+0x176>
lea    0x2(%rsi),%r8
mov    0x1(%rsi),%cl
lea    0x2(%rax),%r10
mov    %cl,0x1(%rax)
mov    %rdx,%rdi
add    $0xfffffffffffffffe,%rdi
setne  %r9b
test   $0x7,%r10b
je     1276 <memcpy+0x176>
test   %rdi,%rdi
je     1276 <memcpy+0x176>
lea    0x3(%rsi),%r8
mov    0x2(%rsi),%cl
lea    0x3(%rax),%r10
mov    %cl,0x2(%rax)
mov    %rdx,%rdi
add    $0xfffffffffffffffd,%rdi
setne  %r9b
test   $0x7,%r10b
je     1276 <memcpy+0x176>
test   %rdi,%rdi
je     1276 <memcpy+0x176>
lea    0x4(%rsi),%r8
mov    0x3(%rsi),%cl
lea    0x4(%rax),%r10
mov    %cl,0x3(%rax)
mov    %rdx,%rdi
add    $0xfffffffffffffffc,%rdi
setne  %r9b
test   $0x7,%r10b
je     1276 <memcpy+0x176>
test   %rdi,%rdi
je     1276 <memcpy+0x176>
lea    0x5(%rsi),%r8
mov    0x4(%rsi),%cl
lea    0x5(%rax),%r10
mov    %cl,0x4(%rax)
mov    %rdx,%rdi
add    $0xfffffffffffffffb,%rdi
setne  %r9b
test   $0x7,%r10b
je     1276 <memcpy+0x176>
test   %rdi,%rdi
je     1276 <memcpy+0x176>
lea    0x6(%rsi),%r8
mov    0x5(%rsi),%cl
lea    0x6(%rax),%r10
mov    %cl,0x5(%rax)
mov    %rdx,%rdi
add    $0xfffffffffffffffa,%rdi
setne  %r9b
test   $0x7,%r10b
je     1276 <memcpy+0x176>
test   %rdi,%rdi
je     1276 <memcpy+0x176>
lea    0x7(%rsi),%r8
mov    0x6(%rsi),%cl
lea    0x7(%rax),%r10
mov    %cl,0x6(%rax)
mov    %rdx,%rdi
add    $0xfffffffffffffff9,%rdi
setne  %r9b
test   $0x7,%r10b
je     1276 <memcpy+0x176>
test   %rdi,%rdi
je     1276 <memcpy+0x176>
mov    0x7(%rsi),%cl
add    $0x8,%rsi
lea    0x8(%rax),%r10
mov    %cl,0x7(%rax)
add    $0xfffffffffffffff8,%rdx
setne  %r9b
mov    %rdx,%rdi
jmp    1273 <memcpy+0x173>
mov    %rdx,%rdi
mov    %rax,%r10
mov    %rsi,%r8
test   %r9b,%r9b
je     149f <memcpy+0x39f>
cmp    $0x8,%rdi
jb     1297 <memcpy+0x197>
lea    -0x8(%rdi),%r11
cmp    $0x18,%r11
jae    129f <memcpy+0x19f>
mov    %r8,%rsi
jmp    13c0 <memcpy+0x2c0>
mov    %r8,%rsi
jmp    13d8 <memcpy+0x2d8>
mov    %rdi,%rcx
and    $0xfffffffffffffff8,%rcx
lea    (%r8,%rcx,1),%rdx
cmp    %rdx,%r10
jae    12bf <memcpy+0x1bf>
add    %r10,%rcx
cmp    %rcx,%r8
jae    12bf <memcpy+0x1bf>
mov    %r8,%rsi
jmp    13c0 <memcpy+0x2c0>
shr    $0x3,%r11
add    $0x1,%r11
mov    %r11,%r9
and    $0xfffffffffffffffc,%r9
lea    -0x4(%r9),%rcx
mov    %rcx,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0xc,%rcx
jae    12ec <memcpy+0x1ec>
xor    %ecx,%ecx
jmp    1368 <memcpy+0x268>
and    $0xfffffffffffffffc,%rsi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups (%r8,%rcx,8),%xmm0
movups 0x10(%r8,%rcx,8),%xmm1
movups %xmm0,(%r10,%rcx,8)
movups %xmm1,0x10(%r10,%rcx,8)
movups 0x20(%r8,%rcx,8),%xmm0
movups 0x30(%r8,%rcx,8),%xmm1
movups %xmm0,0x20(%r10,%rcx,8)
movups %xmm1,0x30(%r10,%rcx,8)
movups 0x40(%r8,%rcx,8),%xmm0
movups 0x50(%r8,%rcx,8),%xmm1
movups %xmm0,0x40(%r10,%rcx,8)
movups %xmm1,0x50(%r10,%rcx,8)
movups 0x60(%r8,%rcx,8),%xmm0
movups 0x70(%r8,%rcx,8),%xmm1
movups %xmm0,0x60(%r10,%rcx,8)
movups %xmm1,0x70(%r10,%rcx,8)
add    $0x10,%rcx
add    $0xfffffffffffffffc,%rsi
jne    1300 <memcpy+0x200>
lea    0x0(,%r9,8),%r14
test   %rdx,%rdx
je     13ab <memcpy+0x2ab>
lea    (%r10,%rcx,8),%rsi
add    $0x10,%rsi
lea    (%r8,%rcx,8),%rcx
add    $0x10,%rcx
shl    $0x5,%rdx
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movups -0x10(%rcx,%rbx,1),%xmm0
movups (%rcx,%rbx,1),%xmm1
movups %xmm0,-0x10(%rsi,%rbx,1)
movups %xmm1,(%rsi,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%rdx
jne    1390 <memcpy+0x290>
lea    (%r8,%r9,8),%rsi
lea    (%r10,%r9,8),%r10
sub    %r14,%rdi
cmp    %r9,%r11
je     13d8 <memcpy+0x2d8>
nopl   0x0(%rax,%rax,1)
mov    (%rsi),%rcx
add    $0x8,%rsi
mov    %rcx,(%r10)
add    $0x8,%r10
add    $0xfffffffffffffff8,%rdi
cmp    $0x7,%rdi
ja     13c0 <memcpy+0x2c0>
mov    %rdi,%rdx
test   %rdx,%rdx
je     149f <memcpy+0x39f>
cmp    $0x8,%rdx
jb     1404 <memcpy+0x304>
lea    (%rsi,%rdx,1),%rcx
cmp    %rcx,%r10
jae    14a3 <memcpy+0x3a3>
lea    (%r10,%rdx,1),%rcx
cmp    %rcx,%rsi
jae    14a3 <memcpy+0x3a3>
mov    %rsi,%rcx
mov    %r10,%rdi
mov    %rdx,%r9
lea    -0x1(%r9),%r8
mov    %r9,%rbx
and    $0x7,%rbx
je     1439 <memcpy+0x339>
xor    %esi,%esi
nopl   0x0(%rax)
movzbl (%rcx,%rsi,1),%edx
mov    %dl,(%rdi,%rsi,1)
add    $0x1,%rsi
cmp    %rsi,%rbx
jne    1420 <memcpy+0x320>
add    %rsi,%rcx
add    %rsi,%rdi
sub    %rsi,%r9
cmp    $0x7,%r8
jb     149f <memcpy+0x39f>
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl (%rcx,%rdx,1),%ebx
mov    %bl,(%rdi,%rdx,1)
movzbl 0x1(%rcx,%rdx,1),%ebx
mov    %bl,0x1(%rdi,%rdx,1)
movzbl 0x2(%rcx,%rdx,1),%ebx
mov    %bl,0x2(%rdi,%rdx,1)
movzbl 0x3(%rcx,%rdx,1),%ebx
mov    %bl,0x3(%rdi,%rdx,1)
movzbl 0x4(%rcx,%rdx,1),%ebx
mov    %bl,0x4(%rdi,%rdx,1)
movzbl 0x5(%rcx,%rdx,1),%ebx
mov    %bl,0x5(%rdi,%rdx,1)
movzbl 0x6(%rcx,%rdx,1),%ebx
mov    %bl,0x6(%rdi,%rdx,1)
movzbl 0x7(%rcx,%rdx,1),%ebx
mov    %bl,0x7(%rdi,%rdx,1)
add    $0x8,%rdx
cmp    %rdx,%r9
jne    1450 <memcpy+0x350>
pop    %rbx
pop    %r14
ret
cmp    $0x20,%rdx
jae    14b1 <memcpy+0x3b1>
xor    %r8d,%r8d
jmp    1589 <memcpy+0x489>
mov    %rdx,%r8
and    $0xffffffffffffffe0,%r8
lea    -0x20(%r8),%rcx
mov    %rcx,%rdi
shr    $0x5,%rdi
add    $0x1,%rdi
mov    %edi,%r9d
and    $0x3,%r9d
cmp    $0x60,%rcx
jae    14d8 <memcpy+0x3d8>
xor    %ecx,%ecx
jmp    1540 <memcpy+0x440>
and    $0xfffffffffffffffc,%rdi
xor    %ecx,%ecx
xchg   %ax,%ax
movups (%rsi,%rcx,1),%xmm0
movups 0x10(%rsi,%rcx,1),%xmm1
movups %xmm0,(%r10,%rcx,1)
movups %xmm1,0x10(%r10,%rcx,1)
movups 0x20(%rsi,%rcx,1),%xmm0
movups 0x30(%rsi,%rcx,1),%xmm1
movups %xmm0,0x20(%r10,%rcx,1)
movups %xmm1,0x30(%r10,%rcx,1)
movups 0x40(%rsi,%rcx,1),%xmm0
movups 0x50(%rsi,%rcx,1),%xmm1
movups %xmm0,0x40(%r10,%rcx,1)
movups %xmm1,0x50(%r10,%rcx,1)
movups 0x60(%rsi,%rcx,1),%xmm0
movups 0x70(%rsi,%rcx,1),%xmm1
movups %xmm0,0x60(%r10,%rcx,1)
movups %xmm1,0x70(%r10,%rcx,1)
sub    $0xffffffffffffff80,%rcx
add    $0xfffffffffffffffc,%rdi
jne    14e0 <memcpy+0x3e0>
test   %r9,%r9
je     157b <memcpy+0x47b>
lea    (%r10,%rcx,1),%rdi
add    $0x10,%rdi
add    %rsi,%rcx
add    $0x10,%rcx
shl    $0x5,%r9
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
movups -0x10(%rcx,%rbx,1),%xmm0
movups (%rcx,%rbx,1),%xmm1
movups %xmm0,-0x10(%rdi,%rbx,1)
movups %xmm1,(%rdi,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%r9
jne    1560 <memcpy+0x460>
cmp    %r8,%rdx
je     149f <memcpy+0x39f>
test   $0x18,%dl
je     15bf <memcpy+0x4bf>
mov    %rdx,%r11
and    $0xfffffffffffffff8,%r11
lea    (%rsi,%r11,1),%rcx
lea    (%r10,%r11,1),%rdi
mov    %edx,%r9d
and    $0x7,%r9d
nop
mov    (%rsi,%r8,1),%rbx
mov    %rbx,(%r10,%r8,1)
add    $0x8,%r8
cmp    %r8,%r11
jne    15a0 <memcpy+0x4a0>
cmp    %r11,%rdx
jne    140d <memcpy+0x30d>
jmp    149f <memcpy+0x39f>
and    $0x1f,%edx
add    %r8,%r10
add    %r8,%rsi
jmp    1404 <memcpy+0x304>

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 i8*
%9 = alloca i64*
%10 = alloca i64*
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 i8*, i8** %5
store i8* %12, i8** %8
%13 = load i8*, i8** %7
%14 = ptrtoint i8* %13 to i64
%15 = and i64 %14, 7
%16 = load i8*, i8** %8
%17 = ptrtoint i8* %16 to i64
%18 = and i64 %17, 7
%19 = icmp ne i64 %15, %18
br i1 %19, label %20, label %21
20: ; preds = %3
br label %66
21: ; preds = %3
br label %22
22: ; preds = %38, %21
%23 = load i8*, i8** %7
%24 = ptrtoint i8* %23 to i64
%25 = and i64 %24, 7
%26 = icmp ne i64 %25, 0
br i1 %26, label %27, label %30
27: ; preds = %22
%28 = load i64, i64* %6
%29 = icmp ne i64 %28, 0
br label %30
30: ; preds = %27, %22
%31 = phi i1 [ false, %22 ], [ %29, %27 ]
br i1 %31, label %32, label %41
32: ; preds = %30
%33 = load i8*, i8** %8
%34 = getelementptr inbounds i8, i8* %33, i32 1
store i8* %34, i8** %8
%35 = load i8, i8* %33
%36 = load i8*, i8** %7
%37 = getelementptr inbounds i8, i8* %36, i32 1
store i8* %37, i8** %7
store i8 %35, i8* %36
br label %38
38: ; preds = %32
%39 = load i64, i64* %6
%40 = add i64 %39, -1
store i64 %40, i64* %6
br label %22
41: ; preds = %30
%42 = load i64, i64* %6
%43 = icmp ne i64 %42, 0
br i1 %43, label %44, label %80
44: ; preds = %41
%45 = load i8*, i8** %7
%46 = bitcast i8* %45 to i64*
store i64* %46, i64** %9
%47 = load i8*, i8** %8
%48 = bitcast i8* %47 to i64*
store i64* %48, i64** %10
br label %49
49: ; preds = %58, %44
%50 = load i64, i64* %6
%51 = icmp uge i64 %50, 8
br i1 %51, label %52, label %61
52: ; preds = %49
%53 = load i64*, i64** %10
%54 = getelementptr inbounds i64, i64* %53, i32 1
store i64* %54, i64** %10
%55 = load i64, i64* %53
%56 = load i64*, i64** %9
%57 = getelementptr inbounds i64, i64* %56, i32 1
store i64* %57, i64** %9
store i64 %55, i64* %56
br label %58
58: ; preds = %52
%59 = load i64, i64* %6
%60 = sub i64 %59, 8
store i64 %60, i64* %6
br label %49
61: ; preds = %49
%62 = load i64*, i64** %9
%63 = bitcast i64* %62 to i8*
store i8* %63, i8** %7
%64 = load i64*, i64** %10
%65 = bitcast i64* %64 to i8*
store i8* %65, i8** %8
br label %66
66: ; preds = %61, %20
br label %67
67: ; preds = %76, %66
%68 = load i64, i64* %6
%69 = icmp ne i64 %68, 0
br i1 %69, label %70, label %79
70: ; preds = %67
%71 = load i8*, i8** %8
%72 = getelementptr inbounds i8, i8* %71, i32 1
store i8* %72, i8** %8
%73 = load i8, i8* %71
%74 = load i8*, i8** %7
%75 = getelementptr inbounds i8, i8* %74, i32 1
store i8* %75, i8** %7
store i8 %73, i8* %74
br label %76
76: ; preds = %70
%77 = load i64, i64* %6
%78 = add i64 %77, -1
store i64 %78, i64* %6
br label %67
79: ; preds = %67
br label %80
80: ; preds = %79, %41
%81 = load i8*, i8** %4
ret i8* %81
}

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