#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 *to, const void *from, size_t len) {
  unsigned long rem, chunks, tmp1, tmp2;
  unsigned char *tmp_to;
  unsigned char *tmp_from = (unsigned char *)from;
  chunks = len / 8;
  tmp_from -= 4;
  tmp_to = to - 4;
  if (!chunks)
    goto lessthan8;
  rem = (unsigned long)tmp_to % 4;
  if (rem)
    goto align;
copy_chunks:
  do {
    tmp1 = *(unsigned long *)(tmp_from + 4);
    tmp_from += 8;
    tmp2 = *(unsigned long *)tmp_from;
    *(unsigned long *)(tmp_to + 4) = tmp1;
    tmp_to += 8;
    *(unsigned long *)tmp_to = tmp2;
  } while (--chunks);
lessthan8:
  len = len % 8;
  if (len >= 4) {
    tmp_from += 4;
    tmp_to += 4;
    *(unsigned long *)(tmp_to) = *(unsigned long *)(tmp_from);
    len -= 4;
  }
  if (!len)
    return to;
  tmp_from += 3;
  tmp_to += 3;
  do {
    *++tmp_to = *++tmp_from;
  } while (--len);
  return to;
align:
  rem = 4 - rem;
  len -= rem;
  do {
    *(tmp_to + 4) = *(tmp_from + 4);
    ++tmp_from;
    ++tmp_to;
  } while (--rem);
  chunks = len / 8;
  if (chunks)
    goto copy_chunks;
  goto lessthan8;
}


x86 assembly (clang, -O0):
<memcpy>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x20(%rbp),%rax
shr    $0x3,%rax
mov    %rax,-0x30(%rbp)
mov    -0x50(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x50(%rbp)
mov    -0x10(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x48(%rbp)
cmpq   $0x0,-0x30(%rbp)
jne    114c <memcpy+0x4c>
jmp    11d3 <memcpy+0xd3>
mov    -0x48(%rbp),%rax
and    $0x3,%rax
mov    %rax,-0x28(%rbp)
cmpq   $0x0,-0x28(%rbp)
je     1168 <memcpy+0x68>
jmp    1293 <memcpy+0x193>
jmp    116d <memcpy+0x6d>
jmp    1172 <memcpy+0x72>
mov    -0x50(%rbp),%rax
mov    0x4(%rax),%rax
mov    %rax,-0x38(%rbp)
mov    -0x50(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x50(%rbp)
mov    -0x50(%rbp),%rax
mov    (%rax),%rax
mov    %rax,-0x40(%rbp)
mov    -0x38(%rbp),%rcx
mov    -0x48(%rbp),%rax
mov    %rcx,0x4(%rax)
mov    -0x48(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x48(%rbp)
mov    -0x40(%rbp),%rcx
mov    -0x48(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x30(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x30(%rbp)
cmp    $0x0,%rax
jne    1172 <memcpy+0x72>
jmp    11d3 <memcpy+0xd3>
mov    -0x20(%rbp),%rax
and    $0x7,%rax
mov    %rax,-0x20(%rbp)
cmpq   $0x4,-0x20(%rbp)
jb     121c <memcpy+0x11c>
mov    -0x50(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x50(%rbp)
mov    -0x48(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x48(%rbp)
mov    -0x50(%rbp),%rax
mov    (%rax),%rcx
mov    -0x48(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x20(%rbp),%rax
sub    $0x4,%rax
mov    %rax,-0x20(%rbp)
cmpq   $0x0,-0x20(%rbp)
jne    1234 <memcpy+0x134>
mov    -0x10(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    130c <memcpy+0x20c>
mov    -0x50(%rbp),%rax
add    $0x3,%rax
mov    %rax,-0x50(%rbp)
mov    -0x48(%rbp),%rax
add    $0x3,%rax
mov    %rax,-0x48(%rbp)
mov    -0x50(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x50(%rbp)
mov    0x1(%rax),%cl
mov    -0x48(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x48(%rbp)
mov    %cl,0x1(%rax)
mov    -0x20(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x20(%rbp)
cmp    $0x0,%rax
jne    124c <memcpy+0x14c>
mov    -0x10(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    130c <memcpy+0x20c>
mov    $0x4,%eax
sub    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rcx
mov    -0x20(%rbp),%rax
sub    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0x50(%rbp),%rax
mov    0x4(%rax),%cl
mov    -0x48(%rbp),%rax
mov    %cl,0x4(%rax)
mov    -0x50(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x50(%rbp)
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
mov    -0x28(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x28(%rbp)
cmp    $0x0,%rax
jne    12af <memcpy+0x1af>
mov    -0x20(%rbp),%rax
shr    $0x3,%rax
mov    %rax,-0x30(%rbp)
cmpq   $0x0,-0x30(%rbp)
je     1307 <memcpy+0x207>
jmp    116d <memcpy+0x6d>
jmp    11d3 <memcpy+0xd3>
mov    -0x8(%rbp),%rax
pop    %rbp
ret

x86 assembly (clang, -O2):
<memcpy>:
push   %r15
push   %r14
push   %rbx
mov    %rdi,%rax
lea    -0x4(%rsi),%r8
lea    -0x4(%rdi),%r15
cmp    $0x8,%rdx
jb     1223 <memcpy+0x123>
mov    %r15,%rdi
and    $0x3,%rdi
je     1172 <memcpy+0x72>
or     $0xfffffffffffffffc,%r15
mov    (%rsi),%cl
mov    %cl,(%rax)
cmp    $0x3,%rdi
jne    113b <memcpy+0x3b>
add    $0xfffffffffffffffd,%rsi
lea    -0x3(%rax),%rdi
jmp    115f <memcpy+0x5f>
mov    0x1(%rsi),%cl
mov    %cl,0x1(%rax)
cmp    $0x2,%rdi
jne    1151 <memcpy+0x51>
add    $0xfffffffffffffffe,%rsi
lea    -0x2(%rax),%rdi
jmp    115f <memcpy+0x5f>
mov    0x2(%rsi),%cl
mov    %cl,0x2(%rax)
add    $0xffffffffffffffff,%rsi
lea    -0x1(%rax),%rdi
mov    %rsi,%r8
add    %r15,%rdx
mov    %rdi,%r15
cmp    $0x8,%rdx
jb     1223 <memcpy+0x123>
mov    %rdx,%r9
shr    $0x3,%r9
lea    -0x1(%r9),%r10
mov    %r9,%r11
and    $0x3,%r11
je     11b4 <memcpy+0xb4>
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
mov    0x4(%r8),%rdi
mov    0x8(%r8),%rsi
add    $0x8,%r8
mov    %rdi,0x4(%r15)
mov    %rsi,0x8(%r15)
add    $0x8,%r15
add    $0x1,%rbx
cmp    %rbx,%r11
jne    1190 <memcpy+0x90>
sub    %rbx,%r9
cmp    $0x3,%r10
jb     1223 <memcpy+0x123>
xor    %edi,%edi
xor    %ebx,%ebx
xchg   %ax,%ax
mov    0x4(%r8,%rbx,8),%rsi
mov    0x8(%r8,%rbx,8),%rcx
mov    %rsi,0x4(%r15,%rbx,8)
mov    %rcx,0x8(%r15,%rbx,8)
mov    0xc(%r8,%rbx,8),%rcx
mov    0x10(%r8,%rbx,8),%rsi
mov    %rcx,0xc(%r15,%rbx,8)
mov    %rsi,0x10(%r15,%rbx,8)
mov    0x14(%r8,%rbx,8),%rcx
mov    0x18(%r8,%rbx,8),%rsi
mov    %rcx,0x14(%r15,%rbx,8)
mov    %rsi,0x18(%r15,%rbx,8)
mov    0x1c(%r8,%rbx,8),%rcx
mov    0x20(%r8,%rbx,8),%rsi
mov    %rcx,0x1c(%r15,%rbx,8)
mov    %rsi,0x20(%r15,%rbx,8)
add    $0x4,%rbx
add    $0xffffffffffffffe0,%rdi
cmp    %rbx,%r9
jne    11c0 <memcpy+0xc0>
sub    %rdi,%r15
sub    %rdi,%r8
and    $0x7,%edx
cmp    $0x4,%rdx
jb     1240 <memcpy+0x140>
mov    0x4(%r8),%rcx
add    $0x4,%r8
mov    %rcx,0x4(%r15)
add    $0x4,%r15
add    $0xfffffffffffffffc,%rdx
test   %rdx,%rdx
je     1321 <memcpy+0x221>
lea    0x3(%r8),%rsi
lea    0x3(%r15),%rdi
cmp    $0x8,%rdx
jb     1281 <memcpy+0x181>
lea    0x4(%r15),%rcx
lea    (%r8,%rdx,1),%rbx
add    $0x4,%rbx
cmp    %rbx,%rcx
jae    1327 <memcpy+0x227>
lea    (%r15,%rdx,1),%rcx
add    $0x4,%rcx
lea    0x4(%r8),%rbx
cmp    %rcx,%rbx
jae    1327 <memcpy+0x227>
mov    %rdx,%r10
lea    -0x1(%r10),%r8
mov    %r10,%rbx
and    $0x7,%rbx
je     12bb <memcpy+0x1bb>
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movzbl 0x1(%rsi,%rdx,1),%ecx
mov    %cl,0x1(%rdi,%rdx,1)
add    $0x1,%rdx
cmp    %rdx,%rbx
jne    12a0 <memcpy+0x1a0>
sub    %rdx,%r10
add    %rdx,%rdi
add    %rdx,%rsi
cmp    $0x7,%r8
jb     1321 <memcpy+0x221>
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movzbl 0x1(%rsi,%rcx,1),%edx
mov    %dl,0x1(%rdi,%rcx,1)
movzbl 0x2(%rsi,%rcx,1),%edx
mov    %dl,0x2(%rdi,%rcx,1)
movzbl 0x3(%rsi,%rcx,1),%edx
mov    %dl,0x3(%rdi,%rcx,1)
movzbl 0x4(%rsi,%rcx,1),%edx
mov    %dl,0x4(%rdi,%rcx,1)
movzbl 0x5(%rsi,%rcx,1),%edx
mov    %dl,0x5(%rdi,%rcx,1)
movzbl 0x6(%rsi,%rcx,1),%edx
mov    %dl,0x6(%rdi,%rcx,1)
movzbl 0x7(%rsi,%rcx,1),%edx
mov    %dl,0x7(%rdi,%rcx,1)
movzbl 0x8(%rsi,%rcx,1),%edx
mov    %dl,0x8(%rdi,%rcx,1)
add    $0x8,%rcx
cmp    %rcx,%r10
jne    12d0 <memcpy+0x1d0>
pop    %rbx
pop    %r14
pop    %r15
ret
cmp    $0x20,%rdx
jae    1335 <memcpy+0x235>
xor    %r9d,%r9d
jmp    142d <memcpy+0x32d>
mov    %rdx,%r9
and    $0xffffffffffffffe0,%r9
lea    -0x20(%r9),%rcx
mov    %rcx,%r11
shr    $0x5,%r11
add    $0x1,%r11
mov    %r11d,%r10d
and    $0x3,%r10d
cmp    $0x60,%rcx
jae    135c <memcpy+0x25c>
xor    %ebx,%ebx
jmp    13da <memcpy+0x2da>
and    $0xfffffffffffffffc,%r11
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups 0x4(%r8,%rbx,1),%xmm0
movups 0x14(%r8,%rbx,1),%xmm1
movups %xmm0,0x4(%r15,%rbx,1)
movups %xmm1,0x14(%r15,%rbx,1)
movups 0x24(%r8,%rbx,1),%xmm0
movups 0x34(%r8,%rbx,1),%xmm1
movups %xmm0,0x24(%r15,%rbx,1)
movups %xmm1,0x34(%r15,%rbx,1)
movups 0x44(%r8,%rbx,1),%xmm0
movups 0x54(%r8,%rbx,1),%xmm1
movups %xmm0,0x44(%r15,%rbx,1)
movups %xmm1,0x54(%r15,%rbx,1)
movups 0x64(%r8,%rbx,1),%xmm0
movups 0x74(%r8,%rbx,1),%xmm1
movups %xmm0,0x64(%r15,%rbx,1)
movups %xmm1,0x74(%r15,%rbx,1)
sub    $0xffffffffffffff80,%rbx
add    $0xfffffffffffffffc,%r11
jne    1370 <memcpy+0x270>
test   %r10,%r10
je     141f <memcpy+0x31f>
lea    (%r15,%rbx,1),%r11
add    $0x14,%r11
lea    (%r8,%rbx,1),%r14
add    $0x14,%r14
shl    $0x5,%r10
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
movups -0x10(%r14,%rbx,1),%xmm0
movups (%r14,%rbx,1),%xmm1
movups %xmm0,-0x10(%r11,%rbx,1)
movups %xmm1,(%r11,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%r10
jne    1400 <memcpy+0x300>
cmp    %r9,%rdx
je     1321 <memcpy+0x221>
test   $0x18,%dl
je     1471 <memcpy+0x371>
mov    %rdx,%rbx
and    $0xfffffffffffffff8,%rbx
mov    %edx,%r10d
and    $0x7,%r10d
add    %rbx,%rdi
add    %rbx,%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    0x4(%r8,%r9,1),%rcx
mov    %rcx,0x4(%r15,%r9,1)
add    $0x8,%r9
cmp    %r9,%rbx
jne    1450 <memcpy+0x350>
cmp    %rbx,%rdx
jne    1284 <memcpy+0x184>
jmp    1321 <memcpy+0x221>
add    %r9,%rsi
add    %r9,%rdi
and    $0x1f,%edx
jmp    1281 <memcpy+0x181>

LLVM IR (-O0):
define i8* @memcpy(i8* %0, i8* %1, i64 %2) {
%4 = alloca i8*
%5 = alloca i8*
%6 = alloca i8*
%7 = alloca i64
%8 = alloca i64
%9 = alloca i64
%10 = alloca i64
%11 = alloca i64
%12 = alloca i8*
%13 = alloca i8*
store i8* %0, i8** %5
store i8* %1, i8** %6
store i64 %2, i64* %7
%14 = load i8*, i8** %6
store i8* %14, i8** %13
%15 = load i64, i64* %7
%16 = udiv i64 %15, 8
store i64 %16, i64* %9
%17 = load i8*, i8** %13
%18 = getelementptr inbounds i8, i8* %17, i64 -4
store i8* %18, i8** %13
%19 = load i8*, i8** %5
%20 = getelementptr i8, i8* %19, i64 -4
store i8* %20, i8** %12
%21 = load i64, i64* %9
%22 = icmp ne i64 %21, 0
br i1 %22, label %24, label %23
23: ; preds = %3
br label %57
24: ; preds = %3
%25 = load i8*, i8** %12
%26 = ptrtoint i8* %25 to i64
%27 = urem i64 %26, 4
store i64 %27, i64* %8
%28 = load i64, i64* %8
%29 = icmp ne i64 %28, 0
br i1 %29, label %30, label %31
30: ; preds = %24
br label %96
31: ; preds = %24
br label %32
32: ; preds = %121, %31
br label %33
33: ; preds = %52, %32
%34 = load i8*, i8** %13
%35 = getelementptr inbounds i8, i8* %34, i64 4
%36 = bitcast i8* %35 to i64*
%37 = load i64, i64* %36
store i64 %37, i64* %10
%38 = load i8*, i8** %13
%39 = getelementptr inbounds i8, i8* %38, i64 8
store i8* %39, i8** %13
%40 = load i8*, i8** %13
%41 = bitcast i8* %40 to i64*
%42 = load i64, i64* %41
store i64 %42, i64* %11
%43 = load i64, i64* %10
%44 = load i8*, i8** %12
%45 = getelementptr inbounds i8, i8* %44, i64 4
%46 = bitcast i8* %45 to i64*
store i64 %43, i64* %46
%47 = load i8*, i8** %12
%48 = getelementptr inbounds i8, i8* %47, i64 8
store i8* %48, i8** %12
%49 = load i64, i64* %11
%50 = load i8*, i8** %12
%51 = bitcast i8* %50 to i64*
store i64 %49, i64* %51
br label %52
52: ; preds = %33
%53 = load i64, i64* %9
%54 = add i64 %53, -1
store i64 %54, i64* %9
%55 = icmp ne i64 %54, 0
br i1 %55, label %33, label %56
56: ; preds = %52
br label %57
57: ; preds = %122, %56, %23
%58 = load i64, i64* %7
%59 = urem i64 %58, 8
store i64 %59, i64* %7
%60 = load i64, i64* %7
%61 = icmp uge i64 %60, 4
br i1 %61, label %62, label %74
62: ; preds = %57
%63 = load i8*, i8** %13
%64 = getelementptr inbounds i8, i8* %63, i64 4
store i8* %64, i8** %13
%65 = load i8*, i8** %12
%66 = getelementptr inbounds i8, i8* %65, i64 4
store i8* %66, i8** %12
%67 = load i8*, i8** %13
%68 = bitcast i8* %67 to i64*
%69 = load i64, i64* %68
%70 = load i8*, i8** %12
%71 = bitcast i8* %70 to i64*
store i64 %69, i64* %71
%72 = load i64, i64* %7
%73 = sub i64 %72, 4
store i64 %73, i64* %7
br label %74
74: ; preds = %62, %57
%75 = load i64, i64* %7
%76 = icmp ne i64 %75, 0
br i1 %76, label %79, label %77
77: ; preds = %74
%78 = load i8*, i8** %5
store i8* %78, i8** %4
br label %123
79: ; preds = %74
%80 = load i8*, i8** %13
%81 = getelementptr inbounds i8, i8* %80, i64 3
store i8* %81, i8** %13
%82 = load i8*, i8** %12
%83 = getelementptr inbounds i8, i8* %82, i64 3
store i8* %83, i8** %12
br label %84
84: ; preds = %90, %79
%85 = load i8*, i8** %13
%86 = getelementptr inbounds i8, i8* %85, i32 1
store i8* %86, i8** %13
%87 = load i8, i8* %86
%88 = load i8*, i8** %12
%89 = getelementptr inbounds i8, i8* %88, i32 1
store i8* %89, i8** %12
store i8 %87, i8* %89
br label %90
90: ; preds = %84
%91 = load i64, i64* %7
%92 = add i64 %91, -1
store i64 %92, i64* %7
%93 = icmp ne i64 %92, 0
br i1 %93, label %84, label %94
94: ; preds = %90
%95 = load i8*, i8** %5
store i8* %95, i8** %4
br label %123
96: ; preds = %30
%97 = load i64, i64* %8
%98 = sub i64 4, %97
store i64 %98, i64* %8
%99 = load i64, i64* %8
%100 = load i64, i64* %7
%101 = sub i64 %100, %99
store i64 %101, i64* %7
br label %102
102: ; preds = %112, %96
%103 = load i8*, i8** %13
%104 = getelementptr inbounds i8, i8* %103, i64 4
%105 = load i8, i8* %104
%106 = load i8*, i8** %12
%107 = getelementptr inbounds i8, i8* %106, i64 4
store i8 %105, i8* %107
%108 = load i8*, i8** %13
%109 = getelementptr inbounds i8, i8* %108, i32 1
store i8* %109, i8** %13
%110 = load i8*, i8** %12
%111 = getelementptr inbounds i8, i8* %110, i32 1
store i8* %111, i8** %12
br label %112
112: ; preds = %102
%113 = load i64, i64* %8
%114 = add i64 %113, -1
store i64 %114, i64* %8
%115 = icmp ne i64 %114, 0
br i1 %115, label %102, label %116
116: ; preds = %112
%117 = load i64, i64* %7
%118 = udiv i64 %117, 8
store i64 %118, i64* %9
%119 = load i64, i64* %9
%120 = icmp ne i64 %119, 0
br i1 %120, label %121, label %122
121: ; preds = %116
br label %32
122: ; preds = %116
br label %57
123: ; preds = %94, %77
%124 = load i8*, i8** %4
ret i8* %124
}

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