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


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    116c <memmove+0x6c>
jmp    1133 <memmove+0x33>
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x18(%rbp)
cmp    $0x0,%rax
je     1167 <memmove+0x67>
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x20(%rbp),%rax
mov    -0x18(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
jmp    1133 <memmove+0x33>
jmp    11b6 <memmove+0xb6>
jmp    1171 <memmove+0x71>
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x18(%rbp)
cmp    $0x0,%rax
je     11b1 <memmove+0xb1>
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    1171 <memmove+0x71>
jmp    11b6 <memmove+0xb6>
mov    -0x8(%rbp),%rax
pop    %rbp
ret

x86 assembly (clang, -O2):
<memmove>:
push   %rbx
mov    %rdi,%rax
cmp    %rdi,%rsi
jae    1177 <memmove+0x77>
test   %rdx,%rdx
je     128d <memmove+0x18d>
cmp    $0x4,%rdx
jb     1132 <memmove+0x32>
lea    (%rsi,%rdx,1),%rcx
cmp    %rax,%rcx
jbe    128f <memmove+0x18f>
lea    (%rax,%rdx,1),%rcx
cmp    %rsi,%rcx
jbe    128f <memmove+0x18f>
mov    %rdx,%r9
lea    -0x1(%r9),%rdx
mov    %r9,%rdi
and    $0x3,%rdi
je     1249 <memmove+0x149>
cs nopw 0x0(%rax,%rax,1)
lea    -0x1(%r9),%rcx
movzbl -0x1(%rsi,%r9,1),%ebx
mov    %bl,-0x1(%rax,%r9,1)
mov    %rcx,%r9
add    $0xffffffffffffffff,%rdi
jne    1150 <memmove+0x50>
cmp    $0x3,%rdx
jae    1252 <memmove+0x152>
jmp    128d <memmove+0x18d>
test   %rdx,%rdx
je     128d <memmove+0x18d>
cmp    $0x8,%rdx
jb     11a0 <memmove+0xa0>
lea    (%rsi,%rdx,1),%rcx
cmp    %rax,%rcx
jbe    129c <memmove+0x19c>
lea    (%rax,%rdx,1),%rcx
cmp    %rsi,%rcx
jbe    129c <memmove+0x19c>
mov    %rsi,%rdi
mov    %rax,%r11
mov    %rdx,%r9
lea    -0x1(%r9),%r8
mov    %r9,%rdx
and    $0x7,%rdx
je     11da <memmove+0xda>
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movzbl (%rdi,%rsi,1),%ecx
mov    %cl,(%r11,%rsi,1)
add    $0x1,%rsi
cmp    %rsi,%rdx
jne    11c0 <memmove+0xc0>
add    %rsi,%rdi
add    %rsi,%r11
sub    %rsi,%r9
cmp    $0x7,%r8
jb     128d <memmove+0x18d>
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
movzbl (%rdi,%rdx,1),%ecx
mov    %cl,(%r11,%rdx,1)
movzbl 0x1(%rdi,%rdx,1),%ecx
mov    %cl,0x1(%r11,%rdx,1)
movzbl 0x2(%rdi,%rdx,1),%ecx
mov    %cl,0x2(%r11,%rdx,1)
movzbl 0x3(%rdi,%rdx,1),%ecx
mov    %cl,0x3(%r11,%rdx,1)
movzbl 0x4(%rdi,%rdx,1),%ecx
mov    %cl,0x4(%r11,%rdx,1)
movzbl 0x5(%rdi,%rdx,1),%ecx
mov    %cl,0x5(%r11,%rdx,1)
movzbl 0x6(%rdi,%rdx,1),%ecx
mov    %cl,0x6(%r11,%rdx,1)
movzbl 0x7(%rdi,%rdx,1),%ecx
mov    %cl,0x7(%r11,%rdx,1)
add    $0x8,%rdx
cmp    %rdx,%r9
jne    11f0 <memmove+0xf0>
jmp    128d <memmove+0x18d>
mov    %r9,%rcx
cmp    $0x3,%rdx
jb     128d <memmove+0x18d>
mov    %rcx,%rdx
cs nopw 0x0(%rax,%rax,1)
nop
movzbl -0x1(%rsi,%rcx,1),%ebx
mov    %bl,-0x1(%rax,%rcx,1)
movzbl -0x2(%rsi,%rcx,1),%ebx
mov    %bl,-0x2(%rax,%rcx,1)
movzbl -0x3(%rsi,%rcx,1),%ebx
mov    %bl,-0x3(%rax,%rcx,1)
movzbl -0x4(%rsi,%rcx,1),%ebx
mov    %bl,-0x4(%rax,%rcx,1)
add    $0xfffffffffffffffc,%rdx
mov    %rdx,%rcx
jne    1260 <memmove+0x160>
pop    %rbx
ret
cmp    $0x10,%rdx
jae    12aa <memmove+0x1aa>
xor    %ebx,%ebx
jmp    13a8 <memmove+0x2a8>
cmp    $0x20,%rdx
jae    12d4 <memmove+0x1d4>
xor    %r8d,%r8d
jmp    14ab <memmove+0x3ab>
mov    %rdx,%rbx
and    $0xfffffffffffffff0,%rbx
lea    -0x10(%rbx),%rdi
mov    %rdi,%r9
shr    $0x4,%r9
add    $0x1,%r9
mov    %r9d,%r8d
and    $0x3,%r8d
cmp    $0x30,%rdi
jae    1302 <memmove+0x202>
xor    %edi,%edi
jmp    135b <memmove+0x25b>
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    13ef <memmove+0x2ef>
xor    %ecx,%ecx
jmp    1458 <memmove+0x358>
and    $0xfffffffffffffffc,%r9
lea    (%rax,%rdx,1),%r10
add    $0xfffffffffffffff0,%r10
lea    (%rsi,%rdx,1),%r11
add    $0xfffffffffffffff0,%r11
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movups (%r11,%rdi,1),%xmm0
movups %xmm0,(%r10,%rdi,1)
movups -0x10(%r11,%rdi,1),%xmm0
movups %xmm0,-0x10(%r10,%rdi,1)
movups -0x20(%r11,%rdi,1),%xmm0
movups %xmm0,-0x20(%r10,%rdi,1)
movups -0x30(%r11,%rdi,1),%xmm0
movups %xmm0,-0x30(%r10,%rdi,1)
add    $0xffffffffffffffc0,%rdi
add    $0xfffffffffffffffc,%r9
jne    1320 <memmove+0x220>
neg    %rdi
test   %r8,%r8
je     1396 <memmove+0x296>
mov    %rdx,%r10
sub    %rdi,%r10
lea    (%rax,%r10,1),%r9
add    $0xfffffffffffffff0,%r9
add    %rsi,%r10
add    $0xfffffffffffffff0,%r10
shl    $0x4,%r8
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movups (%r10,%rdi,1),%xmm0
movups %xmm0,(%r9,%rdi,1)
add    $0xfffffffffffffff0,%rdi
mov    %r8,%rcx
add    %rdi,%rcx
jne    1380 <memmove+0x280>
cmp    %rdx,%rbx
je     128d <memmove+0x18d>
test   $0xc,%dl
je     14ef <memmove+0x3ef>
mov    %rdx,%r8
and    $0xfffffffffffffffc,%r8
mov    %edx,%r9d
and    $0x3,%r9d
lea    (%rax,%rdx,1),%r10
add    $0xfffffffffffffffc,%r10
neg    %rbx
lea    (%rsi,%rdx,1),%r11
add    $0xfffffffffffffffc,%r11
mov    %r8,%rdi
neg    %rdi
nop
mov    (%r11,%rbx,1),%ecx
mov    %ecx,(%r10,%rbx,1)
add    $0xfffffffffffffffc,%rbx
cmp    %rbx,%rdi
jne    13d0 <memmove+0x2d0>
cmp    %rdx,%r8
jne    1135 <memmove+0x35>
jmp    128d <memmove+0x18d>
and    $0xfffffffffffffffc,%rdi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nop
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    1400 <memmove+0x300>
test   %r9,%r9
je     149d <memmove+0x39d>
lea    (%rax,%rcx,1),%r10
add    $0x10,%r10
add    %rsi,%rcx
add    $0x10,%rcx
shl    $0x5,%r9
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups -0x10(%rcx,%rdi,1),%xmm0
movups (%rcx,%rdi,1),%xmm1
movups %xmm0,-0x10(%r10,%rdi,1)
movups %xmm1,(%r10,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%r9
jne    1480 <memmove+0x380>
cmp    %rdx,%r8
je     128d <memmove+0x18d>
test   $0x18,%dl
je     14f7 <memmove+0x3f7>
mov    %rdx,%r10
and    $0xfffffffffffffff8,%r10
lea    (%rsi,%r10,1),%rdi
lea    (%rax,%r10,1),%r11
mov    %edx,%r9d
and    $0x7,%r9d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%rsi,%r8,1),%rcx
mov    %rcx,(%rax,%r8,1)
add    $0x8,%r8
cmp    %r8,%r10
jne    14d0 <memmove+0x3d0>
cmp    %rdx,%r10
jne    11a9 <memmove+0xa9>
jmp    128d <memmove+0x18d>
and    $0xf,%edx
jmp    1132 <memmove+0x32>
and    $0x1f,%edx
lea    (%rax,%r8,1),%r11
add    %r8,%rsi
mov    %rsi,%rdi
jmp    11a6 <memmove+0xa6>

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 %28
14: ; preds = %3
br label %15
15: ; preds = %19, %14
%16 = load i64, i64* %6
%17 = add i64 %16, -1
store i64 %17, i64* %6
%18 = icmp ne i64 %16, 0
br i1 %18, label %19, label %27
19: ; preds = %15
%20 = load i8*, i8** %8
%21 = load i64, i64* %6
%22 = getelementptr inbounds i8, i8* %20, i64 %21
%23 = load i8, i8* %22
%24 = load i8*, i8** %7
%25 = load i64, i64* %6
%26 = getelementptr inbounds i8, i8* %24, i64 %25
store i8 %23, i8* %26
br label %15
27: ; preds = %15
br label %40
28: ; preds = %3
br label %29
29: ; preds = %33, %28
%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 %40
40: ; preds = %39, %27
%41 = load i8*, i8** %4
ret i8* %41
}

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