#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 *memmove(void *destination, const void *source, size_t n) {
  char *dest = (char *)destination;
  char *src = (char *)source;
  if (dest == src)
    return destination;
  if (src < dest && dest < src + n) {
    src += n;
    dest += n;
    while (n-- > 0)
      *--dest = *--src;
  } else {
    while (n-- > 0)
      *dest++ = *src++;
  }
  return destination;
}


x86 assembly (clang, -O0):
<memmove>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rax
cmp    -0x30(%rbp),%rax
jne    113b <memmove+0x3b>
mov    -0x10(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    120f <memmove+0x10f>
mov    -0x30(%rbp),%rax
cmp    -0x28(%rbp),%rax
jae    11bd <memmove+0xbd>
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
add    -0x20(%rbp),%rcx
cmp    %rcx,%rax
jae    11bd <memmove+0xbd>
mov    -0x20(%rbp),%rax
add    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x20(%rbp),%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x20(%rbp)
cmp    $0x0,%rax
jbe    11b8 <memmove+0xb8>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x30(%rbp)
mov    -0x1(%rax),%cl
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0xffffffffffffffff,%rdx
mov    %rdx,-0x28(%rbp)
mov    %cl,-0x1(%rax)
jmp    1176 <memmove+0x76>
jmp    1207 <memmove+0x107>
jmp    11c2 <memmove+0xc2>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x20(%rbp)
cmp    $0x0,%rax
jbe    1202 <memmove+0x102>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%cl
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    %cl,(%rax)
jmp    11c2 <memmove+0xc2>
jmp    1207 <memmove+0x107>
mov    -0x10(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
pop    %rbp
ret

x86 assembly (clang, -O2):
<memmove>:
push   %rbp
push   %r14
push   %rbx
mov    %rdi,%rax
cmp    %rsi,%rdi
je     12af <memmove+0x1af>
jbe    11e6 <memmove+0xe6>
lea    (%rsi,%rdx,1),%r9
cmp    %rax,%r9
jbe    11e6 <memmove+0xe6>
test   %rdx,%rdx
je     12af <memmove+0x1af>
lea    (%rax,%rdx,1),%r8
cmp    $0x4,%rdx
jb     1148 <memmove+0x48>
cmp    %rax,%r9
jbe    12e9 <memmove+0x1e9>
cmp    %rsi,%r8
jbe    12e9 <memmove+0x1e9>
mov    %r9,%rsi
mov    %r8,%rcx
mov    %rdx,%r10
lea    -0x1(%r10),%r8
mov    %r10,%rdi
and    $0x7,%rdi
je     117b <memmove+0x7b>
xor    %edx,%edx
movzbl -0x1(%rsi),%ebx
add    $0xffffffffffffffff,%rsi
mov    %bl,-0x1(%rcx)
add    $0xffffffffffffffff,%rcx
add    $0x1,%rdx
cmp    %rdx,%rdi
jne    1160 <memmove+0x60>
sub    %rdx,%r10
cmp    $0x7,%r8
jb     12af <memmove+0x1af>
neg    %r10
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movzbl -0x1(%rsi,%rdx,1),%ebx
mov    %bl,-0x1(%rcx,%rdx,1)
movzbl -0x2(%rsi,%rdx,1),%ebx
mov    %bl,-0x2(%rcx,%rdx,1)
movzbl -0x3(%rsi,%rdx,1),%ebx
mov    %bl,-0x3(%rcx,%rdx,1)
movzbl -0x4(%rsi,%rdx,1),%ebx
mov    %bl,-0x4(%rcx,%rdx,1)
movzbl -0x5(%rsi,%rdx,1),%ebx
mov    %bl,-0x5(%rcx,%rdx,1)
movzbl -0x6(%rsi,%rdx,1),%ebx
mov    %bl,-0x6(%rcx,%rdx,1)
movzbl -0x7(%rsi,%rdx,1),%ebx
mov    %bl,-0x7(%rcx,%rdx,1)
movzbl -0x8(%rsi,%rdx,1),%ebx
mov    %bl,-0x8(%rcx,%rdx,1)
add    $0xfffffffffffffff8,%rdx
cmp    %rdx,%r10
jne    1190 <memmove+0x90>
jmp    12af <memmove+0x1af>
test   %rdx,%rdx
je     12af <memmove+0x1af>
cmp    $0x8,%rdx
jb     120f <memmove+0x10f>
lea    (%rsi,%rdx,1),%rcx
cmp    %rax,%rcx
jbe    12b4 <memmove+0x1b4>
lea    (%rax,%rdx,1),%rcx
cmp    %rsi,%rcx
jbe    12b4 <memmove+0x1b4>
mov    %rsi,%rdi
mov    %rax,%rcx
mov    %rdx,%r9
lea    -0x1(%r9),%rbp
mov    %r9,%rbx
and    $0x7,%rbx
je     1249 <memmove+0x149>
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movzbl (%rdi,%rsi,1),%edx
mov    %dl,(%rcx,%rsi,1)
add    $0x1,%rsi
cmp    %rsi,%rbx
jne    1230 <memmove+0x130>
add    %rsi,%rdi
add    %rsi,%rcx
sub    %rsi,%r9
cmp    $0x7,%rbp
jb     12af <memmove+0x1af>
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl (%rdi,%rdx,1),%ebx
mov    %bl,(%rcx,%rdx,1)
movzbl 0x1(%rdi,%rdx,1),%ebx
mov    %bl,0x1(%rcx,%rdx,1)
movzbl 0x2(%rdi,%rdx,1),%ebx
mov    %bl,0x2(%rcx,%rdx,1)
movzbl 0x3(%rdi,%rdx,1),%ebx
mov    %bl,0x3(%rcx,%rdx,1)
movzbl 0x4(%rdi,%rdx,1),%ebx
mov    %bl,0x4(%rcx,%rdx,1)
movzbl 0x5(%rdi,%rdx,1),%ebx
mov    %bl,0x5(%rcx,%rdx,1)
movzbl 0x6(%rdi,%rdx,1),%ebx
mov    %bl,0x6(%rcx,%rdx,1)
movzbl 0x7(%rdi,%rdx,1),%ebx
mov    %bl,0x7(%rcx,%rdx,1)
add    $0x8,%rdx
cmp    %rdx,%r9
jne    1260 <memmove+0x160>
pop    %rbx
pop    %r14
pop    %rbp
ret
cmp    $0x20,%rdx
jae    12c2 <memmove+0x1c2>
xor    %r8d,%r8d
jmp    13a9 <memmove+0x2a9>
mov    %rdx,%r8
and    $0xffffffffffffffe0,%r8
lea    -0x20(%r8),%rcx
mov    %rcx,%rdi
shr    $0x5,%rdi
add    $0x1,%rdi
mov    %edi,%r9d
and    $0x3,%r9d
cmp    $0x60,%rcx
jae    12fa <memmove+0x1fa>
xor    %ecx,%ecx
jmp    1358 <memmove+0x258>
cmp    $0x10,%rdx
jae    13df <memmove+0x2df>
xor    %edi,%edi
jmp    14a3 <memmove+0x3a3>
and    $0xfffffffffffffffc,%rdi
xor    %ecx,%ecx
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    1300 <memmove+0x200>
test   %r9,%r9
je     139b <memmove+0x29b>
lea    (%rax,%rcx,1),%rdi
add    $0x10,%rdi
add    %rsi,%rcx
add    $0x10,%rcx
shl    $0x5,%r9
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,%r9
jne    1380 <memmove+0x280>
cmp    %rdx,%r8
je     12af <memmove+0x1af>
test   $0x18,%dl
je     1406 <memmove+0x306>
mov    %rdx,%rbx
and    $0xfffffffffffffff8,%rbx
lea    (%rsi,%rbx,1),%rdi
lea    (%rax,%rbx,1),%rcx
mov    %edx,%r9d
and    $0x7,%r9d
nop
mov    (%rsi,%r8,1),%rbp
mov    %rbp,(%rax,%r8,1)
add    $0x8,%r8
cmp    %r8,%rbx
jne    13c0 <memmove+0x2c0>
cmp    %rdx,%rbx
jne    1218 <memmove+0x118>
jmp    12af <memmove+0x1af>
mov    %rdx,%rdi
and    $0xfffffffffffffff0,%rdi
lea    -0x10(%rdi),%rcx
mov    %rcx,%r11
shr    $0x4,%r11
add    $0x1,%r11
mov    %r11d,%r10d
and    $0x3,%r10d
cmp    $0x30,%rcx
jae    1418 <memmove+0x318>
xor    %ecx,%ecx
jmp    145d <memmove+0x35d>
and    $0x1f,%edx
lea    (%rax,%r8,1),%rcx
add    %r8,%rsi
mov    %rsi,%rdi
jmp    1215 <memmove+0x115>
and    $0xfffffffffffffffc,%r11
lea    -0x10(%r9),%r14
lea    -0x10(%r8),%rbx
xor    %ecx,%ecx
movups (%r14,%rcx,1),%xmm0
movups %xmm0,(%rbx,%rcx,1)
movups -0x10(%r14,%rcx,1),%xmm0
movups %xmm0,-0x10(%rbx,%rcx,1)
movups -0x20(%r14,%rcx,1),%xmm0
movups %xmm0,-0x20(%rbx,%rcx,1)
movups -0x30(%r14,%rcx,1),%xmm0
movups %xmm0,-0x30(%rbx,%rcx,1)
add    $0xffffffffffffffc0,%rcx
add    $0xfffffffffffffffc,%r11
jne    1426 <memmove+0x326>
neg    %rcx
test   %r10,%r10
je     1495 <memmove+0x395>
mov    %rdx,%rbx
sub    %rcx,%rbx
lea    (%rax,%rbx,1),%r11
add    $0xfffffffffffffff0,%r11
add    %rbx,%rsi
add    $0xfffffffffffffff0,%rsi
shl    $0x4,%r10
xor    %ebx,%ebx
nopl   (%rax)
movups (%rsi,%rbx,1),%xmm0
movups %xmm0,(%r11,%rbx,1)
add    $0xfffffffffffffff0,%rbx
mov    %r10,%rcx
add    %rbx,%rcx
jne    1480 <memmove+0x380>
cmp    %rdx,%rdi
je     12af <memmove+0x1af>
test   $0xc,%dl
je     14f1 <memmove+0x3f1>
mov    %rdx,%r11
and    $0xfffffffffffffffc,%r11
mov    %r11,%rbx
neg    %rbx
mov    %r9,%rsi
sub    %r11,%rsi
mov    %r8,%rcx
sub    %r11,%rcx
mov    %edx,%r10d
and    $0x3,%r10d
neg    %rdi
cs nopw 0x0(%rax,%rax,1)
mov    -0x4(%r9,%rdi,1),%ebp
mov    %ebp,-0x4(%r8,%rdi,1)
add    $0xfffffffffffffffc,%rdi
cmp    %rdi,%rbx
jne    14d0 <memmove+0x3d0>
cmp    %rdx,%r11
jne    1151 <memmove+0x51>
jmp    12af <memmove+0x1af>
and    $0xf,%edx
sub    %rdi,%r8
sub    %rdi,%r9
jmp    1148 <memmove+0x48>

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

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