#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 *dest, const void *src, size_t n) {
  unsigned char *d = dest;
  const unsigned char *s = src;
  if (s < d && d < s + n) {
    d += n - 1;
    s += n - 1;
    while (n--) {
      *d-- = *s--;
    }
  } else {
    while (n--) {
      *d++ = *s++;
    }
  }
  return dest;
}


x86 assembly (clang, -O0):
<memmove>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
cmp    -0x20(%rbp),%rax
jae    11a8 <memmove+0xa8>
mov    -0x20(%rbp),%rax
mov    -0x28(%rbp),%rcx
add    -0x18(%rbp),%rcx
cmp    %rcx,%rax
jae    11a8 <memmove+0xa8>
mov    -0x18(%rbp),%rax
sub    $0x1,%rax
add    -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
sub    $0x1,%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x18(%rbp)
cmp    $0x0,%rax
je     11a3 <memmove+0xa3>
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    1163 <memmove+0x63>
jmp    11f2 <memmove+0xf2>
jmp    11ad <memmove+0xad>
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x18(%rbp)
cmp    $0x0,%rax
je     11ed <memmove+0xed>
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    11ad <memmove+0xad>
jmp    11f2 <memmove+0xf2>
mov    -0x8(%rbp),%rax
pop    %rbp
ret

x86 assembly (clang, -O2):
<memmove>:
push   %rbp
push   %r14
push   %rbx
mov    %rdi,%rax
lea    (%rsi,%rdx,1),%rcx
cmp    %rdi,%rsi
jae    11f4 <memmove+0xf4>
cmp    %rax,%rcx
jbe    11f4 <memmove+0xf4>
mov    %rdx,%r9
sub    $0x1,%r9
jb     12bf <memmove+0x1bf>
lea    (%rsi,%r9,1),%r8
add    %rax,%r9
cmp    $0x4,%rdx
jb     114d <memmove+0x4d>
cmp    %rax,%rcx
jbe    12d2 <memmove+0x1d2>
lea    (%rax,%rdx,1),%rcx
cmp    %rsi,%rcx
jbe    12d2 <memmove+0x1d2>
mov    %r8,%rsi
mov    %r9,%rcx
mov    %rdx,%r10
lea    -0x1(%r10),%r8
mov    %r10,%rdi
and    $0x7,%rdi
je     1189 <memmove+0x89>
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nop
movzbl (%rsi),%ebx
add    $0xffffffffffffffff,%rsi
mov    %bl,(%rcx)
add    $0xffffffffffffffff,%rcx
add    $0x1,%rdx
cmp    %rdx,%rdi
jne    1170 <memmove+0x70>
sub    %rdx,%r10
cmp    $0x7,%r8
jb     12bf <memmove+0x1bf>
neg    %r10
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movzbl (%rsi,%rdx,1),%ebx
mov    %bl,(%rcx,%rdx,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)
add    $0xfffffffffffffff8,%rdx
cmp    %rdx,%r10
jne    11a0 <memmove+0xa0>
jmp    12bf <memmove+0x1bf>
test   %rdx,%rdx
je     12bf <memmove+0x1bf>
cmp    $0x8,%rdx
jb     1219 <memmove+0x119>
cmp    %rax,%rcx
jbe    12c4 <memmove+0x1c4>
lea    (%rax,%rdx,1),%rcx
cmp    %rsi,%rcx
jbe    12c4 <memmove+0x1c4>
mov    %rsi,%rdi
mov    %rax,%rcx
mov    %rdx,%r9
lea    -0x1(%r9),%r8
mov    %r9,%rbx
and    $0x7,%rbx
je     1259 <memmove+0x159>
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl (%rdi,%rsi,1),%edx
mov    %dl,(%rcx,%rsi,1)
add    $0x1,%rsi
cmp    %rsi,%rbx
jne    1240 <memmove+0x140>
add    %rsi,%rdi
add    %rsi,%rcx
sub    %rsi,%r9
cmp    $0x7,%r8
jb     12bf <memmove+0x1bf>
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    1270 <memmove+0x170>
pop    %rbx
pop    %r14
pop    %rbp
ret
cmp    $0x20,%rdx
jae    12df <memmove+0x1df>
xor    %r8d,%r8d
jmp    13ed <memmove+0x2ed>
cmp    $0x10,%rdx
jae    1309 <memmove+0x209>
xor    %edi,%edi
jmp    14c3 <memmove+0x3c3>
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    1337 <memmove+0x237>
xor    %ecx,%ecx
jmp    1398 <memmove+0x298>
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    142f <memmove+0x32f>
xor    %ecx,%ecx
jmp    1477 <memmove+0x377>
and    $0xfffffffffffffffc,%rdi
xor    %ecx,%ecx
nopl   (%rax)
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    1340 <memmove+0x240>
test   %r9,%r9
je     13db <memmove+0x2db>
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    13c0 <memmove+0x2c0>
cmp    %rdx,%r8
je     12bf <memmove+0x1bf>
test   $0x18,%dl
je     1511 <memmove+0x411>
mov    %rdx,%r10
and    $0xfffffffffffffff8,%r10
lea    (%rsi,%r10,1),%rdi
lea    (%rax,%r10,1),%rcx
mov    %edx,%r9d
and    $0x7,%r9d
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%rsi,%r8,1),%rbx
mov    %rbx,(%rax,%r8,1)
add    $0x8,%r8
cmp    %r8,%r10
jne    1410 <memmove+0x310>
cmp    %rdx,%r10
jne    1222 <memmove+0x122>
jmp    12bf <memmove+0x1bf>
and    $0xfffffffffffffffc,%r11
lea    -0xf(%r8),%r14
lea    -0xf(%r9),%rbx
xor    %ecx,%ecx
nopl   (%rax)
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    1440 <memmove+0x340>
neg    %rcx
test   %r10,%r10
je     14b5 <memmove+0x3b5>
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
nopw   0x0(%rax,%rax,1)
movups (%rsi,%rbx,1),%xmm0
movups %xmm0,(%r11,%rbx,1)
add    $0xfffffffffffffff0,%rbx
mov    %r10,%rcx
add    %rbx,%rcx
jne    14a0 <memmove+0x3a0>
cmp    %rdx,%rdi
je     12bf <memmove+0x1bf>
test   $0xc,%dl
je     1523 <memmove+0x423>
mov    %rdx,%r11
and    $0xfffffffffffffffc,%r11
mov    %r11,%rbx
neg    %rbx
mov    %r8,%rsi
sub    %r11,%rsi
mov    %r9,%rcx
sub    %r11,%rcx
mov    %edx,%r10d
and    $0x3,%r10d
neg    %rdi
cs nopw 0x0(%rax,%rax,1)
mov    -0x3(%r8,%rdi,1),%ebp
mov    %ebp,-0x3(%r9,%rdi,1)
add    $0xfffffffffffffffc,%rdi
cmp    %rdi,%rbx
jne    14f0 <memmove+0x3f0>
cmp    %rdx,%r11
jne    1156 <memmove+0x56>
jmp    12bf <memmove+0x1bf>
and    $0x1f,%edx
lea    (%rax,%r8,1),%rcx
add    %r8,%rsi
mov    %rsi,%rdi
jmp    121f <memmove+0x11f>
and    $0xf,%edx
sub    %rdi,%r9
sub    %rdi,%r8
jmp    114d <memmove+0x4d>

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

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