#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 *dst0, const void *src0, size_t len0) {
  char *dst = dst0;
  const char *src = src0;
  long *aligned_dst;
  const long *aligned_src;
  if (!((len0) < (sizeof(long) << 2)) &&
      !(((long)src & (sizeof(long) - 1)) | ((long)dst & (sizeof(long) - 1)))) {
    aligned_dst = (long *)dst;
    aligned_src = (long *)src;
    while (len0 >= (sizeof(long) << 2)) {
      *aligned_dst++ = *aligned_src++;
      *aligned_dst++ = *aligned_src++;
      *aligned_dst++ = *aligned_src++;
      *aligned_dst++ = *aligned_src++;
      len0 -= (sizeof(long) << 2);
    }
    while (len0 >= (sizeof(long))) {
      *aligned_dst++ = *aligned_src++;
      len0 -= (sizeof(long));
    }
    dst = (char *)aligned_dst;
    src = (char *)aligned_src;
  }
  while (len0--)
    *dst++ = *src++;
  return dst0;
}


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)
cmpq   $0x20,-0x18(%rbp)
jb     1259 <memcpy+0x159>
mov    -0x28(%rbp),%rax
and    $0x7,%rax
mov    -0x20(%rbp),%rcx
and    $0x7,%rcx
or     %rcx,%rax
cmp    $0x0,%rax
jne    1259 <memcpy+0x159>
mov    -0x20(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0x38(%rbp)
cmpq   $0x20,-0x18(%rbp)
jb     1204 <memcpy+0x104>
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    -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    -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    -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    $0x20,%rax
mov    %rax,-0x18(%rbp)
jmp    1158 <memcpy+0x58>
jmp    1209 <memcpy+0x109>
cmpq   $0x8,-0x18(%rbp)
jb     1249 <memcpy+0x149>
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    1209 <memcpy+0x109>
mov    -0x30(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,-0x28(%rbp)
jmp    125e <memcpy+0x15e>
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x18(%rbp)
cmp    $0x0,%rax
je     129e <memcpy+0x19e>
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)
jmp    125e <memcpy+0x15e>
mov    -0x8(%rbp),%rax
pop    %rbp
ret

x86 assembly (clang, -O2):
<memcpy>:
push   %r14
push   %rbx
mov    %rdi,%rax
cmp    $0x20,%rdx
jae    1120 <memcpy+0x20>
mov    %rax,%r8
test   %rdx,%rdx
je     11ef <memcpy+0xef>
cmp    $0x8,%rdx
jae    1136 <memcpy+0x36>
jmp    1150 <memcpy+0x50>
mov    %esi,%ecx
or     %eax,%ecx
test   $0x7,%cl
je     11f3 <memcpy+0xf3>
mov    %rax,%r8
cmp    $0x8,%rdx
jb     1150 <memcpy+0x50>
lea    (%rsi,%rdx,1),%rcx
cmp    %rcx,%r8
jae    122e <memcpy+0x12e>
lea    (%r8,%rdx,1),%rcx
cmp    %rcx,%rsi
jae    122e <memcpy+0x12e>
mov    %rsi,%rcx
mov    %r8,%rdi
mov    %rdx,%r10
lea    -0x1(%r10),%r8
mov    %r10,%rbx
and    $0x7,%rbx
je     1189 <memcpy+0x89>
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movzbl (%rcx,%rsi,1),%edx
mov    %dl,(%rdi,%rsi,1)
add    $0x1,%rsi
cmp    %rsi,%rbx
jne    1170 <memcpy+0x70>
add    %rsi,%rcx
add    %rsi,%rdi
sub    %rsi,%r10
cmp    $0x7,%r8
jb     11ef <memcpy+0xef>
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,%r10
jne    11a0 <memcpy+0xa0>
pop    %rbx
pop    %r14
ret
lea    -0x20(%rdx),%rdi
test   $0x20,%dil
jne    1240 <memcpy+0x140>
mov    (%rsi),%rcx
mov    %rcx,(%rax)
mov    0x8(%rsi),%rcx
mov    %rcx,0x8(%rax)
mov    0x10(%rsi),%rcx
mov    %rcx,0x10(%rax)
mov    0x18(%rsi),%rcx
add    $0x20,%rsi
lea    0x20(%rax),%r8
mov    %rcx,0x18(%rax)
mov    %rdi,%rcx
cmp    $0x20,%rdi
jae    1250 <memcpy+0x150>
jmp    12a7 <memcpy+0x1a7>
cmp    $0x20,%rdx
jae    1319 <memcpy+0x219>
xor    %r9d,%r9d
jmp    13f9 <memcpy+0x2f9>
mov    %rax,%r8
mov    %rdx,%rcx
cmp    $0x20,%rdi
jb     12a7 <memcpy+0x1a7>
nopl   0x0(%rax)
mov    (%rsi),%rdx
mov    %rdx,(%r8)
mov    0x8(%rsi),%rdx
mov    %rdx,0x8(%r8)
mov    0x10(%rsi),%rdx
mov    %rdx,0x10(%r8)
mov    0x18(%rsi),%rdx
mov    %rdx,0x18(%r8)
mov    0x20(%rsi),%rdx
mov    %rdx,0x20(%r8)
mov    0x28(%rsi),%rdx
mov    %rdx,0x28(%r8)
mov    0x30(%rsi),%rdx
mov    %rdx,0x30(%r8)
mov    0x38(%rsi),%rdx
add    $0x40,%rsi
mov    %rdx,0x38(%r8)
add    $0x40,%r8
add    $0xffffffffffffffc0,%rcx
cmp    $0x1f,%rcx
ja     1250 <memcpy+0x150>
lea    0x20(%rcx),%rdx
mov    %rcx,%rdi
cmp    $0x8,%rdi
jb     1528 <memcpy+0x428>
add    $0xffffffffffffffd8,%rdx
cmp    $0x18,%rdx
jb     1510 <memcpy+0x410>
mov    %rdx,%rcx
and    $0xfffffffffffffff8,%rcx
lea    (%rsi,%rcx,1),%rbx
add    $0x8,%rbx
cmp    %rbx,%r8
jae    12e3 <memcpy+0x1e3>
add    %r8,%rcx
add    $0x8,%rcx
cmp    %rcx,%rsi
jb     1510 <memcpy+0x410>
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %rdx,%r9
and    $0xfffffffffffffffc,%r9
lea    -0x4(%r9),%rcx
mov    %rcx,%r11
shr    $0x2,%r11
add    $0x1,%r11
mov    %r11d,%r10d
and    $0x3,%r10d
cmp    $0xc,%rcx
jae    143d <memcpy+0x33d>
xor    %ecx,%ecx
jmp    14b0 <memcpy+0x3b0>
mov    %rdx,%r9
and    $0xffffffffffffffe0,%r9
lea    -0x20(%r9),%rcx
mov    %rcx,%rdi
shr    $0x5,%rdi
add    $0x1,%rdi
mov    %edi,%r10d
and    $0x3,%r10d
cmp    $0x60,%rcx
jae    1340 <memcpy+0x240>
xor    %ecx,%ecx
jmp    13b0 <memcpy+0x2b0>
and    $0xfffffffffffffffc,%rdi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
movups (%rsi,%rcx,1),%xmm0
movups 0x10(%rsi,%rcx,1),%xmm1
movups %xmm0,(%r8,%rcx,1)
movups %xmm1,0x10(%r8,%rcx,1)
movups 0x20(%rsi,%rcx,1),%xmm0
movups 0x30(%rsi,%rcx,1),%xmm1
movups %xmm0,0x20(%r8,%rcx,1)
movups %xmm1,0x30(%r8,%rcx,1)
movups 0x40(%rsi,%rcx,1),%xmm0
movups 0x50(%rsi,%rcx,1),%xmm1
movups %xmm0,0x40(%r8,%rcx,1)
movups %xmm1,0x50(%r8,%rcx,1)
movups 0x60(%rsi,%rcx,1),%xmm0
movups 0x70(%rsi,%rcx,1),%xmm1
movups %xmm0,0x60(%r8,%rcx,1)
movups %xmm1,0x70(%r8,%rcx,1)
sub    $0xffffffffffffff80,%rcx
add    $0xfffffffffffffffc,%rdi
jne    1350 <memcpy+0x250>
test   %r10,%r10
je     13eb <memcpy+0x2eb>
lea    (%r8,%rcx,1),%rdi
add    $0x10,%rdi
add    %rsi,%rcx
add    $0x10,%rcx
shl    $0x5,%r10
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,%r10
jne    13d0 <memcpy+0x2d0>
cmp    %r9,%rdx
je     11ef <memcpy+0xef>
test   $0x18,%dl
je     142f <memcpy+0x32f>
mov    %rdx,%r11
and    $0xfffffffffffffff8,%r11
lea    (%rsi,%r11,1),%rcx
lea    (%r8,%r11,1),%rdi
mov    %edx,%r10d
and    $0x7,%r10d
nop
mov    (%rsi,%r9,1),%rbx
mov    %rbx,(%r8,%r9,1)
add    $0x8,%r9
cmp    %r9,%r11
jne    1410 <memcpy+0x310>
cmp    %r11,%rdx
jne    1159 <memcpy+0x59>
jmp    11ef <memcpy+0xef>
and    $0x1f,%edx
add    %r9,%r8
add    %r9,%rsi
jmp    1150 <memcpy+0x50>
and    $0xfffffffffffffffc,%r11
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups (%rsi,%rcx,8),%xmm0
movups 0x10(%rsi,%rcx,8),%xmm1
movups %xmm0,(%r8,%rcx,8)
movups %xmm1,0x10(%r8,%rcx,8)
movups 0x20(%rsi,%rcx,8),%xmm0
movups 0x30(%rsi,%rcx,8),%xmm1
movups %xmm0,0x20(%r8,%rcx,8)
movups %xmm1,0x30(%r8,%rcx,8)
movups 0x40(%rsi,%rcx,8),%xmm0
movups 0x50(%rsi,%rcx,8),%xmm1
movups %xmm0,0x40(%r8,%rcx,8)
movups %xmm1,0x50(%r8,%rcx,8)
movups 0x60(%rsi,%rcx,8),%xmm0
movups 0x70(%rsi,%rcx,8),%xmm1
movups %xmm0,0x60(%r8,%rcx,8)
movups %xmm1,0x70(%r8,%rcx,8)
add    $0x10,%rcx
add    $0xfffffffffffffffc,%r11
jne    1450 <memcpy+0x350>
lea    0x0(,%r9,8),%r11
test   %r10,%r10
je     14fd <memcpy+0x3fd>
lea    (%r8,%rcx,8),%r14
add    $0x10,%r14
lea    (%rsi,%rcx,8),%rcx
add    $0x10,%rcx
shl    $0x5,%r10
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x10(%rcx,%rbx,1),%xmm0
movups (%rcx,%rbx,1),%xmm1
movups %xmm0,-0x10(%r14,%rbx,1)
movups %xmm1,(%r14,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%r10
jne    14e0 <memcpy+0x3e0>
lea    (%rsi,%r9,8),%rsi
lea    (%r8,%r9,8),%r8
sub    %r11,%rdi
cmp    %r9,%rdx
je     1528 <memcpy+0x428>
nopl   (%rax)
mov    (%rsi),%rcx
add    $0x8,%rsi
mov    %rcx,(%r8)
add    $0x8,%r8
add    $0xfffffffffffffff8,%rdi
cmp    $0x7,%rdi
ja     1510 <memcpy+0x410>
mov    %rdi,%rdx
test   %rdx,%rdx
jne    1118 <memcpy+0x18>
jmp    11ef <memcpy+0xef>

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

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