#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 */
char *__memcpy2__(char *dst, char *src, size_t len) {
  char *p, *q;
  if (dst - src >= len || dst < src)
    for (p = dst, q = src; p != dst + len;)
      *p++ = *q++;
  else
    for (p = dst + len - 1, q = src + len - 1; p != dst - 1;)
      *p-- = *q--;
  return dst;
}


x86 assembly (clang, -O0):
<__memcpy2__>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%rcx
sub    %rcx,%rax
cmp    -0x18(%rbp),%rax
jae    1133 <__memcpy2__+0x33>
mov    -0x8(%rbp),%rax
cmp    -0x10(%rbp),%rax
jae    1184 <__memcpy2__+0x84>
mov    -0x8(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x8(%rbp),%rcx
add    -0x18(%rbp),%rcx
cmp    %rcx,%rax
je     117f <__memcpy2__+0x7f>
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    1143 <__memcpy2__+0x43>
jmp    11e5 <__memcpy2__+0xe5>
mov    -0x8(%rbp),%rax
add    -0x18(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
add    -0x18(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x8(%rbp),%rcx
add    $0xffffffffffffffff,%rcx
cmp    %rcx,%rax
je     11e0 <__memcpy2__+0xe0>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x28(%rbp)
mov    (%rax),%cl
mov    -0x20(%rbp),%rax
mov    %rax,%rdx
add    $0xffffffffffffffff,%rdx
mov    %rdx,-0x20(%rbp)
mov    %cl,(%rax)
jmp    11a4 <__memcpy2__+0xa4>
jmp    11e5 <__memcpy2__+0xe5>
mov    -0x8(%rbp),%rax
pop    %rbp
ret

x86 assembly (clang, -O2):
<__memcpy2__>:
push   %rbx
mov    %rdi,%rax
mov    %rdi,%rcx
sub    %rsi,%rcx
jb     11b1 <__memcpy2__+0xb1>
cmp    %rdx,%rcx
jae    11b1 <__memcpy2__+0xb1>
lea    (%rsi,%rdx,1),%r8
cmp    $0x4,%rdx
jb     1139 <__memcpy2__+0x39>
cmp    %rax,%r8
jbe    127c <__memcpy2__+0x17c>
lea    (%rax,%rdx,1),%rcx
cmp    %rsi,%rcx
jbe    127c <__memcpy2__+0x17c>
mov    %r8,%rsi
mov    %rdx,%rcx
lea    -0x1(%rcx),%rdx
mov    %rcx,%rdi
and    $0x3,%rdi
je     1166 <__memcpy2__+0x66>
nopl   0x0(%rax)
movzbl -0x1(%rsi),%ebx
add    $0xffffffffffffffff,%rsi
mov    %bl,-0x1(%rax,%rcx,1)
add    $0xffffffffffffffff,%rcx
add    $0xffffffffffffffff,%rdi
jne    1150 <__memcpy2__+0x50>
cmp    $0x3,%rdx
jb     14ba <__memcpy2__+0x3ba>
lea    (%rcx,%rax,1),%rdx
add    $0xffffffffffffffff,%rdx
neg    %rcx
xor    %edi,%edi
nopl   (%rax)
movzbl -0x1(%rsi,%rdi,1),%ebx
mov    %bl,(%rdx,%rdi,1)
movzbl -0x2(%rsi,%rdi,1),%ebx
mov    %bl,-0x1(%rdx,%rdi,1)
movzbl -0x3(%rsi,%rdi,1),%ebx
mov    %bl,-0x2(%rdx,%rdi,1)
movzbl -0x4(%rsi,%rdi,1),%ebx
mov    %bl,-0x3(%rdx,%rdi,1)
add    $0xfffffffffffffffc,%rdi
cmp    %rdi,%rcx
jne    1180 <__memcpy2__+0x80>
jmp    14ba <__memcpy2__+0x3ba>
test   %rdx,%rdx
je     14ba <__memcpy2__+0x3ba>
lea    (%rax,%rdx,1),%r8
cmp    $0x8,%rdx
jb     11da <__memcpy2__+0xda>
lea    (%rsi,%rdx,1),%rcx
cmp    %rax,%rcx
jbe    1289 <__memcpy2__+0x189>
cmp    %rsi,%r8
jbe    1289 <__memcpy2__+0x189>
mov    %rsi,%rcx
mov    %rax,%rdi
mov    %r8d,%esi
sub    %edi,%esi
mov    %rdi,%rdx
not    %rdx
add    %r8,%rdx
and    $0x7,%rsi
je     1213 <__memcpy2__+0x113>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzbl (%rcx),%ebx
add    $0x1,%rcx
mov    %bl,(%rdi)
add    $0x1,%rdi
add    $0xffffffffffffffff,%rsi
jne    1200 <__memcpy2__+0x100>
cmp    $0x7,%rdx
jb     14ba <__memcpy2__+0x3ba>
xor    %edx,%edx
nop
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)
lea    (%rdi,%rdx,1),%rsi
add    $0x8,%rsi
add    $0x8,%rdx
cmp    %r8,%rsi
jne    1220 <__memcpy2__+0x120>
jmp    14ba <__memcpy2__+0x3ba>
cmp    $0x10,%rdx
jae    1297 <__memcpy2__+0x197>
xor    %edi,%edi
jmp    1387 <__memcpy2__+0x287>
cmp    $0x20,%rdx
jae    12be <__memcpy2__+0x1be>
xor    %r9d,%r9d
jmp    1485 <__memcpy2__+0x385>
mov    %rdx,%rdi
and    $0xfffffffffffffff0,%rdi
lea    -0x10(%rdi),%rcx
mov    %rcx,%r10
shr    $0x4,%r10
add    $0x1,%r10
mov    %r10d,%r9d
and    $0x3,%r9d
cmp    $0x30,%rcx
jae    12ec <__memcpy2__+0x1ec>
xor    %ecx,%ecx
jmp    1337 <__memcpy2__+0x237>
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    13d0 <__memcpy2__+0x2d0>
xor    %ecx,%ecx
jmp    1438 <__memcpy2__+0x338>
and    $0xfffffffffffffffc,%r10
lea    -0x10(%r8),%r11
lea    (%rdx,%rax,1),%rbx
add    $0xfffffffffffffff0,%rbx
xor    %ecx,%ecx
xchg   %ax,%ax
movups (%r11,%rcx,1),%xmm0
movups %xmm0,(%rbx,%rcx,1)
movups -0x10(%r11,%rcx,1),%xmm0
movups %xmm0,-0x10(%rbx,%rcx,1)
movups -0x20(%r11,%rcx,1),%xmm0
movups %xmm0,-0x20(%rbx,%rcx,1)
movups -0x30(%r11,%rcx,1),%xmm0
movups %xmm0,-0x30(%rbx,%rcx,1)
add    $0xffffffffffffffc0,%rcx
add    $0xfffffffffffffffc,%r10
jne    1300 <__memcpy2__+0x200>
neg    %rcx
test   %r9,%r9
je     1375 <__memcpy2__+0x275>
mov    %rdx,%rbx
sub    %rcx,%rbx
lea    (%rax,%rbx,1),%r10
add    $0xfffffffffffffff0,%r10
add    %rbx,%rsi
add    $0xfffffffffffffff0,%rsi
shl    $0x4,%r9
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
movups (%rsi,%rbx,1),%xmm0
movups %xmm0,(%r10,%rbx,1)
add    $0xfffffffffffffff0,%rbx
mov    %r9,%rcx
add    %rbx,%rcx
jne    1360 <__memcpy2__+0x260>
cmp    %rdx,%rdi
je     14ba <__memcpy2__+0x3ba>
test   $0xc,%dl
je     14bc <__memcpy2__+0x3bc>
mov    %rdx,%r9
and    $0xfffffffffffffffc,%r9
mov    %r9,%r10
neg    %r10
mov    %r8,%rsi
sub    %r9,%rsi
mov    %edx,%ecx
and    $0x3,%ecx
lea    (%rdx,%rax,1),%r11
add    $0xfffffffffffffffc,%r11
neg    %rdi
nopw   0x0(%rax,%rax,1)
mov    -0x4(%r8,%rdi,1),%ebx
mov    %ebx,(%r11,%rdi,1)
add    $0xfffffffffffffffc,%rdi
cmp    %rdi,%r10
jne    13b0 <__memcpy2__+0x2b0>
cmp    %rdx,%r9
jne    113f <__memcpy2__+0x3f>
jmp    14ba <__memcpy2__+0x3ba>
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,(%rax,%rcx,1)
movups %xmm1,0x10(%rax,%rcx,1)
movups 0x20(%rsi,%rcx,1),%xmm0
movups 0x30(%rsi,%rcx,1),%xmm1
movups %xmm0,0x20(%rax,%rcx,1)
movups %xmm1,0x30(%rax,%rcx,1)
movups 0x40(%rsi,%rcx,1),%xmm0
movups 0x50(%rsi,%rcx,1),%xmm1
movups %xmm0,0x40(%rax,%rcx,1)
movups %xmm1,0x50(%rax,%rcx,1)
movups 0x60(%rsi,%rcx,1),%xmm0
movups 0x70(%rsi,%rcx,1),%xmm1
movups %xmm0,0x60(%rax,%rcx,1)
movups %xmm1,0x70(%rax,%rcx,1)
sub    $0xffffffffffffff80,%rcx
add    $0xfffffffffffffffc,%rdi
jne    13e0 <__memcpy2__+0x2e0>
test   %r10,%r10
je     147b <__memcpy2__+0x37b>
lea    (%rax,%rcx,1),%rdi
add    $0x10,%rdi
add    %rsi,%rcx
add    $0x10,%rcx
shl    $0x5,%r10
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
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    1460 <__memcpy2__+0x360>
cmp    %rdx,%r9
je     14ba <__memcpy2__+0x3ba>
test   $0x18,%dl
je     14c7 <__memcpy2__+0x3c7>
mov    %rdx,%r10
and    $0xfffffffffffffff8,%r10
lea    (%rsi,%r10,1),%rcx
lea    (%rax,%r10,1),%rdi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%rsi,%r9,1),%rbx
mov    %rbx,(%rax,%r9,1)
add    $0x8,%r9
cmp    %r9,%r10
jne    14a0 <__memcpy2__+0x3a0>
cmp    %rdx,%r10
jne    11e0 <__memcpy2__+0xe0>
pop    %rbx
ret
and    $0xf,%edx
sub    %rdi,%r8
jmp    1139 <__memcpy2__+0x39>
lea    (%rax,%r9,1),%rdi
add    %r9,%rsi
mov    %rsi,%rcx
jmp    11e0 <__memcpy2__+0xe0>

LLVM IR (-O0):
define i8* @__memcpy2__(i8* %0, i8* %1, i64 %2) {
%4 = alloca i8*
%5 = alloca i8*
%6 = alloca i64
%7 = alloca i8*
%8 = alloca i8*
store i8* %0, i8** %4
store i8* %1, i8** %5
store i64 %2, i64* %6
%9 = load i8*, i8** %4
%10 = load i8*, i8** %5
%11 = ptrtoint i8* %9 to i64
%12 = ptrtoint i8* %10 to i64
%13 = sub i64 %11, %12
%14 = load i64, i64* %6
%15 = icmp uge i64 %13, %14
br i1 %15, label %20, label %16
16: ; preds = %3
%17 = load i8*, i8** %4
%18 = load i8*, i8** %5
%19 = icmp ult i8* %17, %18
br i1 %19, label %20, label %36
20: ; preds = %16, %3
%21 = load i8*, i8** %4
store i8* %21, i8** %7
%22 = load i8*, i8** %5
store i8* %22, i8** %8
br label %23
23: ; preds = %29, %20
%24 = load i8*, i8** %7
%25 = load i8*, i8** %4
%26 = load i64, i64* %6
%27 = getelementptr inbounds i8, i8* %25, i64 %26
%28 = icmp ne i8* %24, %27
br i1 %28, label %29, label %35
29: ; preds = %23
%30 = load i8*, i8** %8
%31 = getelementptr inbounds i8, i8* %30, i32 1
store i8* %31, i8** %8
%32 = load i8, i8* %30
%33 = load i8*, i8** %7
%34 = getelementptr inbounds i8, i8* %33, i32 1
store i8* %34, i8** %7
store i8 %32, i8* %33
br label %23
35: ; preds = %23
br label %57
36: ; preds = %16
%37 = load i8*, i8** %4
%38 = load i64, i64* %6
%39 = getelementptr inbounds i8, i8* %37, i64 %38
%40 = getelementptr inbounds i8, i8* %39, i64 -1
store i8* %40, i8** %7
%41 = load i8*, i8** %5
%42 = load i64, i64* %6
%43 = getelementptr inbounds i8, i8* %41, i64 %42
%44 = getelementptr inbounds i8, i8* %43, i64 -1
store i8* %44, i8** %8
br label %45
45: ; preds = %50, %36
%46 = load i8*, i8** %7
%47 = load i8*, i8** %4
%48 = getelementptr inbounds i8, i8* %47, i64 -1
%49 = icmp ne i8* %46, %48
br i1 %49, label %50, label %56
50: ; preds = %45
%51 = load i8*, i8** %8
%52 = getelementptr inbounds i8, i8* %51, i32 -1
store i8* %52, i8** %8
%53 = load i8, i8* %51
%54 = load i8*, i8** %7
%55 = getelementptr inbounds i8, i8* %54, i32 -1
store i8* %55, i8** %7
store i8 %53, i8* %54
br label %45
56: ; preds = %45
br label %57
57: ; preds = %56, %35
%58 = load i8*, i8** %4
ret i8* %58
}

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