#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(const void *src0, void *dst0, int 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    %edx,-0x14(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x28(%rbp)
movslq -0x14(%rbp),%rax
cmp    $0x20,%rax
jb     125f <memcpy+0x15f>
mov    -0x28(%rbp),%rax
and    $0x7,%rax
mov    -0x20(%rbp),%rcx
and    $0x7,%rcx
or     %rcx,%rax
cmp    $0x0,%rax
jne    125f <memcpy+0x15f>
mov    -0x20(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0x38(%rbp)
movslq -0x14(%rbp),%rax
cmp    $0x20,%rax
jb     1208 <memcpy+0x108>
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)
movslq -0x14(%rbp),%rax
sub    $0x20,%rax
mov    %eax,-0x14(%rbp)
jmp    115a <memcpy+0x5a>
jmp    120d <memcpy+0x10d>
movslq -0x14(%rbp),%rax
cmp    $0x8,%rax
jb     124f <memcpy+0x14f>
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)
movslq -0x14(%rbp),%rax
sub    $0x8,%rax
mov    %eax,-0x14(%rbp)
jmp    120d <memcpy+0x10d>
mov    -0x30(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,-0x28(%rbp)
jmp    1264 <memcpy+0x164>
mov    -0x14(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x14(%rbp)
cmp    $0x0,%eax
je     129f <memcpy+0x19f>
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    1264 <memcpy+0x164>
mov    -0x10(%rbp),%rax
pop    %rbp
ret

x86 assembly (clang, -O2):
<memcpy>:
push   %r15
push   %r14
push   %rbx
mov    %rsi,%rax
cmp    $0x20,%edx
jae    111d <memcpy+0x1d>
mov    %rax,%r10
test   %edx,%edx
jne    1310 <memcpy+0x210>
jmp    13e6 <memcpy+0x2e6>
mov    %eax,%ecx
or     %edi,%ecx
test   $0x7,%cl
je     112e <memcpy+0x2e>
mov    %rax,%r10
jmp    1310 <memcpy+0x210>
lea    -0x20(%rdx),%esi
test   $0x20,%sil
jne    1166 <memcpy+0x66>
mov    (%rdi),%rcx
mov    %rcx,(%rax)
mov    0x8(%rdi),%rcx
mov    %rcx,0x8(%rax)
mov    0x10(%rdi),%rcx
mov    %rcx,0x10(%rax)
mov    0x18(%rdi),%rcx
add    $0x20,%rdi
lea    0x20(%rax),%r10
mov    %rcx,0x18(%rax)
mov    %esi,%ecx
cmp    $0x20,%esi
jae    1170 <memcpy+0x70>
jmp    11c3 <memcpy+0xc3>
mov    %rax,%r10
mov    %edx,%ecx
cmp    $0x20,%esi
jb     11c3 <memcpy+0xc3>
mov    (%rdi),%rdx
mov    %rdx,(%r10)
mov    0x8(%rdi),%rdx
mov    %rdx,0x8(%r10)
mov    0x10(%rdi),%rdx
mov    %rdx,0x10(%r10)
mov    0x18(%rdi),%rdx
mov    %rdx,0x18(%r10)
mov    0x20(%rdi),%rdx
mov    %rdx,0x20(%r10)
mov    0x28(%rdi),%rdx
mov    %rdx,0x28(%r10)
mov    0x30(%rdi),%rdx
mov    %rdx,0x30(%r10)
mov    0x38(%rdi),%rdx
add    $0x40,%rdi
mov    %rdx,0x38(%r10)
add    $0x40,%r10
add    $0xffffffc0,%ecx
cmp    $0x1f,%ecx
ja     1170 <memcpy+0x70>
lea    0x20(%rcx),%edx
mov    %ecx,%esi
cmp    $0x8,%esi
jb     1306 <memcpy+0x206>
add    $0xffffffd8,%edx
cmp    $0x18,%edx
jb     12f0 <memcpy+0x1f0>
mov    %edx,%ecx
and    $0xfffffff8,%ecx
lea    (%rdi,%rcx,1),%rbx
add    $0x8,%rbx
cmp    %rbx,%r10
jae    11fa <memcpy+0xfa>
add    %r10,%rcx
add    $0x8,%rcx
cmp    %rcx,%rdi
jb     12f0 <memcpy+0x1f0>
shr    $0x3,%edx
add    $0x1,%edx
mov    %edx,%r8d
and    $0xfffffffc,%r8d
lea    -0x4(%r8),%rbx
mov    %rbx,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %ecx,%r9d
and    $0x3,%r9d
cmp    $0xc,%rbx
jae    1227 <memcpy+0x127>
xor    %ebx,%ebx
jmp    1290 <memcpy+0x190>
and    $0xfffffffffffffffc,%rcx
xor    %ebx,%ebx
nopl   (%rax)
movups (%rdi,%rbx,8),%xmm0
movups 0x10(%rdi,%rbx,8),%xmm1
movups %xmm0,(%r10,%rbx,8)
movups %xmm1,0x10(%r10,%rbx,8)
movups 0x20(%rdi,%rbx,8),%xmm0
movups 0x30(%rdi,%rbx,8),%xmm1
movups %xmm0,0x20(%r10,%rbx,8)
movups %xmm1,0x30(%r10,%rbx,8)
movups 0x40(%rdi,%rbx,8),%xmm0
movups 0x50(%rdi,%rbx,8),%xmm1
movups %xmm0,0x40(%r10,%rbx,8)
movups %xmm1,0x50(%r10,%rbx,8)
movups 0x60(%rdi,%rbx,8),%xmm0
movups 0x70(%rdi,%rbx,8),%xmm1
movups %xmm0,0x60(%r10,%rbx,8)
movups %xmm1,0x70(%r10,%rbx,8)
add    $0x10,%rbx
add    $0xfffffffffffffffc,%rcx
jne    1230 <memcpy+0x130>
lea    0x0(,%r8,8),%r11d
test   %r9,%r9
je     12dd <memcpy+0x1dd>
lea    (%r10,%rbx,8),%r14
add    $0x10,%r14
lea    (%rdi,%rbx,8),%rbx
add    $0x10,%rbx
shl    $0x5,%r9
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x10(%rbx,%rcx,1),%xmm0
movups (%rbx,%rcx,1),%xmm1
movups %xmm0,-0x10(%r14,%rcx,1)
movups %xmm1,(%r14,%rcx,1)
add    $0x20,%rcx
cmp    %rcx,%r9
jne    12c0 <memcpy+0x1c0>
lea    (%rdi,%r8,8),%rdi
lea    (%r10,%r8,8),%r10
sub    %r11d,%esi
cmp    %rdx,%r8
je     1306 <memcpy+0x206>
nopl   (%rax)
mov    (%rdi),%rcx
add    $0x8,%rdi
mov    %rcx,(%r10)
add    $0x8,%r10
add    $0xfffffff8,%esi
cmp    $0x7,%esi
ja     12f0 <memcpy+0x1f0>
mov    %esi,%edx
test   %edx,%edx
je     13e6 <memcpy+0x2e6>
lea    -0x1(%rdx),%r8d
cmp    $0x7,%r8d
jb     133c <memcpy+0x23c>
lea    (%rdi,%r8,1),%rcx
add    $0x1,%rcx
cmp    %rcx,%r10
jae    13ec <memcpy+0x2ec>
lea    (%r10,%r8,1),%rcx
add    $0x1,%rcx
cmp    %rcx,%rdi
jae    13ec <memcpy+0x2ec>
mov    %rdi,%r14
mov    %r10,%rsi
lea    -0x1(%rdx),%r8d
test   $0x7,%dl
je     1378 <memcpy+0x278>
mov    %edx,%edi
and    $0x7,%edi
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl (%r14,%rbx,1),%ecx
mov    %cl,(%rsi,%rbx,1)
add    $0x1,%rbx
cmp    %ebx,%edi
jne    1360 <memcpy+0x260>
add    %rbx,%r14
add    %rbx,%rsi
sub    %ebx,%edx
cmp    $0x7,%r8d
jb     13e6 <memcpy+0x2e6>
mov    %edx,%edx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl (%r14,%rdi,1),%ecx
mov    %cl,(%rsi,%rdi,1)
movzbl 0x1(%r14,%rdi,1),%ecx
mov    %cl,0x1(%rsi,%rdi,1)
movzbl 0x2(%r14,%rdi,1),%ecx
mov    %cl,0x2(%rsi,%rdi,1)
movzbl 0x3(%r14,%rdi,1),%ecx
mov    %cl,0x3(%rsi,%rdi,1)
movzbl 0x4(%r14,%rdi,1),%ecx
mov    %cl,0x4(%rsi,%rdi,1)
movzbl 0x5(%r14,%rdi,1),%ecx
mov    %cl,0x5(%rsi,%rdi,1)
movzbl 0x6(%r14,%rdi,1),%ecx
mov    %cl,0x6(%rsi,%rdi,1)
movzbl 0x7(%r14,%rdi,1),%ecx
mov    %cl,0x7(%rsi,%rdi,1)
add    $0x8,%rdi
cmp    %edi,%edx
jne    1390 <memcpy+0x290>
pop    %rbx
pop    %r14
pop    %r15
ret
movabs $0x1ffffffe0,%r9
cmp    $0x1f,%r8d
jae    1404 <memcpy+0x304>
xor    %r11d,%r11d
jmp    14ea <memcpy+0x3ea>
lea    0x1(%r8),%r14
mov    %r14,%r11
and    %r9,%r11
lea    -0x20(%r11),%rcx
mov    %rcx,%rbx
shr    $0x5,%rbx
add    $0x1,%rbx
mov    %ebx,%r15d
and    $0x3,%r15d
cmp    $0x60,%rcx
jae    142e <memcpy+0x32e>
xor    %ecx,%ecx
jmp    14a0 <memcpy+0x3a0>
and    $0xfffffffffffffffc,%rbx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups (%rdi,%rcx,1),%xmm0
movups 0x10(%rdi,%rcx,1),%xmm1
movups %xmm0,(%r10,%rcx,1)
movups %xmm1,0x10(%r10,%rcx,1)
movups 0x20(%rdi,%rcx,1),%xmm0
movups 0x30(%rdi,%rcx,1),%xmm1
movups %xmm0,0x20(%r10,%rcx,1)
movups %xmm1,0x30(%r10,%rcx,1)
movups 0x40(%rdi,%rcx,1),%xmm0
movups 0x50(%rdi,%rcx,1),%xmm1
movups %xmm0,0x40(%r10,%rcx,1)
movups %xmm1,0x50(%r10,%rcx,1)
movups 0x60(%rdi,%rcx,1),%xmm0
movups 0x70(%rdi,%rcx,1),%xmm1
movups %xmm0,0x60(%r10,%rcx,1)
movups %xmm1,0x70(%r10,%rcx,1)
sub    $0xffffffffffffff80,%rcx
add    $0xfffffffffffffffc,%rbx
jne    1440 <memcpy+0x340>
test   %r15,%r15
je     14db <memcpy+0x3db>
lea    (%r10,%rcx,1),%rbx
add    $0x10,%rbx
add    %rdi,%rcx
add    $0x10,%rcx
shl    $0x5,%r15
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movups -0x10(%rcx,%rsi,1),%xmm0
movups (%rcx,%rsi,1),%xmm1
movups %xmm0,-0x10(%rbx,%rsi,1)
movups %xmm1,(%rbx,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%r15
jne    14c0 <memcpy+0x3c0>
cmp    %r11,%r14
je     13e6 <memcpy+0x2e6>
test   $0x18,%r14b
je     151f <memcpy+0x41f>
add    $0x1,%r8
add    $0x18,%r9
and    %r8,%r9
lea    (%rdi,%r9,1),%r14
lea    (%r10,%r9,1),%rsi
sub    %r9d,%edx
mov    (%rdi,%r11,1),%rbx
mov    %rbx,(%r10,%r11,1)
add    $0x8,%r11
cmp    %r11,%r9
jne    1500 <memcpy+0x400>
cmp    %r9,%r8
jne    1342 <memcpy+0x242>
jmp    13e6 <memcpy+0x2e6>
sub    %r11d,%edx
add    %r11,%r10
add    %r11,%rdi
jmp    133c <memcpy+0x23c>

LLVM IR (-O0):
define i8* @memcpy(i8* %0, i8* %1, i32 %2) {
%4 = alloca i8*
%5 = alloca i8*
%6 = alloca i32
%7 = alloca i8*
%8 = alloca i8*
%9 = alloca i64*
%10 = alloca i64*
store i8* %0, i8** %4
store i8* %1, i8** %5
store i32 %2, i32* %6
%11 = load i8*, i8** %5
store i8* %11, i8** %7
%12 = load i8*, i8** %4
store i8* %12, i8** %8
%13 = load i32, i32* %6
%14 = sext i32 %13 to i64
%15 = icmp ult i64 %14, 32
br i1 %15, label %79, label %16
16: ; preds = %3
%17 = load i8*, i8** %8
%18 = ptrtoint i8* %17 to i64
%19 = and i64 %18, 7
%20 = load i8*, i8** %7
%21 = ptrtoint i8* %20 to i64
%22 = and i64 %21, 7
%23 = or i64 %19, %22
%24 = icmp ne i64 %23, 0
br i1 %24, label %79, label %25
25: ; preds = %16
%26 = load i8*, i8** %7
%27 = bitcast i8* %26 to i64*
store i64* %27, i64** %9
%28 = load i8*, i8** %8
%29 = bitcast i8* %28 to i64*
store i64* %29, i64** %10
br label %30
30: ; preds = %34, %25
%31 = load i32, i32* %6
%32 = sext i32 %31 to i64
%33 = icmp uge i64 %32, 32
br i1 %33, label %34, label %59
34: ; preds = %30
%35 = load i64*, i64** %10
%36 = getelementptr inbounds i64, i64* %35, i32 1
store i64* %36, i64** %10
%37 = load i64, i64* %35
%38 = load i64*, i64** %9
%39 = getelementptr inbounds i64, i64* %38, i32 1
store i64* %39, i64** %9
store i64 %37, i64* %38
%40 = load i64*, i64** %10
%41 = getelementptr inbounds i64, i64* %40, i32 1
store i64* %41, i64** %10
%42 = load i64, i64* %40
%43 = load i64*, i64** %9
%44 = getelementptr inbounds i64, i64* %43, i32 1
store i64* %44, i64** %9
store i64 %42, i64* %43
%45 = load i64*, i64** %10
%46 = getelementptr inbounds i64, i64* %45, i32 1
store i64* %46, i64** %10
%47 = load i64, i64* %45
%48 = load i64*, i64** %9
%49 = getelementptr inbounds i64, i64* %48, i32 1
store i64* %49, i64** %9
store i64 %47, i64* %48
%50 = load i64*, i64** %10
%51 = getelementptr inbounds i64, i64* %50, i32 1
store i64* %51, i64** %10
%52 = load i64, i64* %50
%53 = load i64*, i64** %9
%54 = getelementptr inbounds i64, i64* %53, i32 1
store i64* %54, i64** %9
store i64 %52, i64* %53
%55 = load i32, i32* %6
%56 = sext i32 %55 to i64
%57 = sub i64 %56, 32
%58 = trunc i64 %57 to i32
store i32 %58, i32* %6
br label %30
59: ; preds = %30
br label %60
60: ; preds = %64, %59
%61 = load i32, i32* %6
%62 = sext i32 %61 to i64
%63 = icmp uge i64 %62, 8
br i1 %63, label %64, label %74
64: ; preds = %60
%65 = load i64*, i64** %10
%66 = getelementptr inbounds i64, i64* %65, i32 1
store i64* %66, i64** %10
%67 = load i64, i64* %65
%68 = load i64*, i64** %9
%69 = getelementptr inbounds i64, i64* %68, i32 1
store i64* %69, i64** %9
store i64 %67, i64* %68
%70 = load i32, i32* %6
%71 = sext i32 %70 to i64
%72 = sub i64 %71, 8
%73 = trunc i64 %72 to i32
store i32 %73, i32* %6
br label %60
74: ; preds = %60
%75 = load i64*, i64** %9
%76 = bitcast i64* %75 to i8*
store i8* %76, i8** %7
%77 = load i64*, i64** %10
%78 = bitcast i64* %77 to i8*
store i8* %78, i8** %8
br label %79
79: ; preds = %74, %16, %3
br label %80
80: ; preds = %84, %79
%81 = load i32, i32* %6
%82 = add nsw i32 %81, -1
store i32 %82, i32* %6
%83 = icmp ne i32 %81, 0
br i1 %83, label %84, label %90
84: ; preds = %80
%85 = load i8*, i8** %8
%86 = getelementptr inbounds i8, i8* %85, i32 1
store i8* %86, i8** %8
%87 = load i8, i8* %85
%88 = load i8*, i8** %7
%89 = getelementptr inbounds i8, i8* %88, i32 1
store i8* %89, i8** %7
store i8 %87, i8* %88
br label %80
90: ; preds = %80
%91 = load i8*, i8** %5
ret i8* %91
}

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