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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
void *memcpy(void *dst_, const void *src_, size_t n) {
  char *dst = dst_;
  long *aligned_dst;
  const char *src = src_;
  const long *aligned_src;
  if (n >= (sizeof(long)) * 4 &&
      !(((long)(intptr_t)src | (long)(intptr_t)dst) & (sizeof(long) - 1))) {
    aligned_dst = (long *)dst;
    aligned_src = (long *)src;
    for (; n >= (sizeof(long)) * 4; n -= (sizeof(long)) * 4) {
      *aligned_dst++ = *aligned_src++;
      *aligned_dst++ = *aligned_src++;
      *aligned_dst++ = *aligned_src++;
      *aligned_dst++ = *aligned_src++;
    }
    for (; n >= (sizeof(long)); n -= (sizeof(long))) {
      *aligned_dst++ = *aligned_src++;
    }
    dst = (char *)aligned_dst;
    src = (char *)aligned_src;
  }
  while (n--) {
    *dst++ = *src++;
  }
  return dst_;
}


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,-0x30(%rbp)
cmpq   $0x20,-0x18(%rbp)
jb     1255 <memcpy+0x155>
mov    -0x30(%rbp),%rax
mov    -0x20(%rbp),%rcx
or     %rcx,%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    1255 <memcpy+0x155>
mov    -0x20(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,-0x38(%rbp)
cmpq   $0x20,-0x18(%rbp)
jb     1200 <memcpy+0x100>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x38(%rbp)
mov    (%rax),%rcx
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,-0x28(%rbp)
mov    %rcx,(%rax)
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x38(%rbp)
mov    (%rax),%rcx
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,-0x28(%rbp)
mov    %rcx,(%rax)
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x38(%rbp)
mov    (%rax),%rcx
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,-0x28(%rbp)
mov    %rcx,(%rax)
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x38(%rbp)
mov    (%rax),%rcx
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,-0x28(%rbp)
mov    %rcx,(%rax)
mov    -0x18(%rbp),%rax
sub    $0x20,%rax
mov    %rax,-0x18(%rbp)
jmp    1154 <memcpy+0x54>
jmp    1205 <memcpy+0x105>
cmpq   $0x8,-0x18(%rbp)
jb     1245 <memcpy+0x145>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x38(%rbp)
mov    (%rax),%rcx
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,-0x28(%rbp)
mov    %rcx,(%rax)
mov    -0x18(%rbp),%rax
sub    $0x8,%rax
mov    %rax,-0x18(%rbp)
jmp    1205 <memcpy+0x105>
mov    -0x28(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,-0x30(%rbp)
jmp    125a <memcpy+0x15a>
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x18(%rbp)
cmp    $0x0,%rax
je     129a <memcpy+0x19a>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%cl
mov    -0x20(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x20(%rbp)
mov    %cl,(%rax)
jmp    125a <memcpy+0x15a>
mov    -0x8(%rbp),%rax
pop    %rbp
ret

x86 assembly (clang, -O2):
<memcpy>:
push   %r14
push   %rbx
mov    %rdi,%rax
cmp    $0x20,%rdx
jb     111d <memcpy+0x1d>
mov    %esi,%ecx
or     %eax,%ecx
test   $0x7,%cl
je     112e <memcpy+0x2e>
mov    %rax,%r8
jmp    1334 <memcpy+0x234>
mov    %rax,%r8
test   %rdx,%rdx
jne    1334 <memcpy+0x234>
jmp    13ef <memcpy+0x2ef>
lea    -0x20(%rdx),%rdi
test   $0x20,%dil
jne    1169 <memcpy+0x69>
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    1180 <memcpy+0x80>
jmp    11d7 <memcpy+0xd7>
mov    %rax,%r8
mov    %rdx,%rcx
cmp    $0x20,%rdi
jb     11d7 <memcpy+0xd7>
cs nopw 0x0(%rax,%rax,1)
nop
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     1180 <memcpy+0x80>
lea    0x20(%rcx),%rdx
mov    %rcx,%rdi
cmp    $0x8,%rdi
jb     1328 <memcpy+0x228>
add    $0xffffffffffffffd8,%rdx
cmp    $0x18,%rdx
jb     1310 <memcpy+0x210>
mov    %rdx,%rcx
and    $0xfffffffffffffff8,%rcx
lea    (%rsi,%rcx,1),%rbx
add    $0x8,%rbx
cmp    %rbx,%r8
jae    1213 <memcpy+0x113>
add    %r8,%rcx
add    $0x8,%rcx
cmp    %rcx,%rsi
jb     1310 <memcpy+0x210>
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    1242 <memcpy+0x142>
xor    %ecx,%ecx
jmp    12b0 <memcpy+0x1b0>
and    $0xfffffffffffffffc,%r11
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
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    1250 <memcpy+0x150>
lea    0x0(,%r9,8),%r11
test   %r10,%r10
je     12fd <memcpy+0x1fd>
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    12e0 <memcpy+0x1e0>
lea    (%rsi,%r9,8),%rsi
lea    (%r8,%r9,8),%r8
sub    %r11,%rdi
cmp    %r9,%rdx
je     1328 <memcpy+0x228>
nopl   (%rax)
mov    (%rsi),%rcx
add    $0x8,%rsi
mov    %rcx,(%r8)
add    $0x8,%r8
add    $0xfffffffffffffff8,%rdi
cmp    $0x7,%rdi
ja     1310 <memcpy+0x210>
mov    %rdi,%rdx
test   %rdx,%rdx
je     13ef <memcpy+0x2ef>
cmp    $0x8,%rdx
jb     1354 <memcpy+0x254>
lea    (%rsi,%rdx,1),%rcx
cmp    %rcx,%r8
jae    13f3 <memcpy+0x2f3>
lea    (%r8,%rdx,1),%rcx
cmp    %rcx,%rsi
jae    13f3 <memcpy+0x2f3>
mov    %rsi,%rcx
mov    %r8,%rdi
mov    %rdx,%r10
lea    -0x1(%r10),%r8
mov    %r10,%rbx
and    $0x7,%rbx
je     1389 <memcpy+0x289>
xor    %esi,%esi
nopl   0x0(%rax)
movzbl (%rcx,%rsi,1),%edx
mov    %dl,(%rdi,%rsi,1)
add    $0x1,%rsi
cmp    %rsi,%rbx
jne    1370 <memcpy+0x270>
add    %rsi,%rcx
add    %rsi,%rdi
sub    %rsi,%r10
cmp    $0x7,%r8
jb     13ef <memcpy+0x2ef>
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    13a0 <memcpy+0x2a0>
pop    %rbx
pop    %r14
ret
cmp    $0x20,%rdx
jae    1401 <memcpy+0x301>
xor    %r9d,%r9d
jmp    14d9 <memcpy+0x3d9>
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    1428 <memcpy+0x328>
xor    %ecx,%ecx
jmp    1490 <memcpy+0x390>
and    $0xfffffffffffffffc,%rdi
xor    %ecx,%ecx
xchg   %ax,%ax
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    1430 <memcpy+0x330>
test   %r10,%r10
je     14cb <memcpy+0x3cb>
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    14b0 <memcpy+0x3b0>
cmp    %r9,%rdx
je     13ef <memcpy+0x2ef>
test   $0x18,%dl
je     150f <memcpy+0x40f>
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    14f0 <memcpy+0x3f0>
cmp    %r11,%rdx
jne    135d <memcpy+0x25d>
jmp    13ef <memcpy+0x2ef>
and    $0x1f,%edx
add    %r9,%r8
add    %r9,%rsi
jmp    1354 <memcpy+0x254>

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

LLVM IR (-O2):
define i8* @memcpy(i8* returned %0, i8* %1, i64 %2) {
%4 = icmp ugt i64 %2, 31
br i1 %4, label %5, label %201
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* %1 to i64*
%13 = bitcast i8* %0 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* %12
%21 = getelementptr inbounds i8, i8* %0, i64 8
%22 = bitcast i8* %21 to i64*
store i64 %20, i64* %13
%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* [ %12, %11 ], [ %34, %17 ]
%41 = phi i64* [ %13, %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 [ %196, %195 ], [ %2, %3 ]
%203 = phi i8* [ %199, %195 ], [ %0, %3 ]
%204 = phi i8* [ %200, %195 ], [ %1, %3 ]
%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
}