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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
void *memcpy(void *, void const *, size_t);
void *memmove(void *dest, const void *src, size_t count) {
  size_t i;
  if ((uintptr_t)dest < (uintptr_t)src) {
    return memcpy(dest, src, count);
  }
  if ((uintptr_t)dest % sizeof(long) == 0 &&
      (uintptr_t)src % sizeof(long) == 0 && count % sizeof(long) == 0) {
    long *d = dest;
    const long *s = src;
    for (i = count / sizeof(long); i > 0; i--) {
      d[i - 1] = s[i - 1];
    }
  } else {
    char *d = dest;
    const char *s = src;
    for (i = count; i > 0; i--) {
      d[i - 1] = s[i - 1];
    }
  }
  return dest;
}


x86 assembly (clang, -O0):
<memmove>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%rcx
cmp    %rcx,%rax
jae    1157 <memmove+0x47>
mov    -0x10(%rbp),%rdi
mov    %rdi,-0x50(%rbp)
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdx
call   1030 <memcpy@plt>
mov    -0x50(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    1249 <memmove+0x139>
mov    -0x10(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    11ea <memmove+0xda>
mov    -0x18(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    11ea <memmove+0xda>
mov    -0x20(%rbp),%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    11ea <memmove+0xda>
mov    -0x10(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x20(%rbp),%rax
shr    $0x3,%rax
mov    %rax,-0x28(%rbp)
cmpq   $0x0,-0x28(%rbp)
jbe    11e5 <memmove+0xd5>
mov    -0x38(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    $0x1,%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x28(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x28(%rbp)
jmp    11a9 <memmove+0x99>
jmp    1241 <memmove+0x131>
mov    -0x10(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x28(%rbp)
cmpq   $0x0,-0x28(%rbp)
jbe    123c <memmove+0x12c>
mov    -0x48(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    $0x1,%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x40(%rbp),%rax
mov    -0x28(%rbp),%rcx
sub    $0x1,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x28(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x28(%rbp)
jmp    1202 <memmove+0xf2>
jmp    1241 <memmove+0x131>
mov    -0x10(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<memmove>:
push   %rbx
mov    %rdi,%rbx
cmp    %rsi,%rdi
jae    1126 <memmove+0x16>
mov    %rbx,%rdi
call   1030 <memcpy@plt>
mov    %rbx,%rax
pop    %rbx
ret
mov    %esi,%eax
or     %ebx,%eax
mov    %edx,%ecx
or     %eax,%ecx
test   $0x7,%cl
je     1191 <memmove+0x81>
test   %rdx,%rdx
je     1121 <memmove+0x11>
cmp    $0x4,%rdx
jb     1158 <memmove+0x48>
lea    (%rsi,%rdx,1),%rax
cmp    %rbx,%rax
jbe    1282 <memmove+0x172>
lea    (%rbx,%rdx,1),%rax
cmp    %rsi,%rax
jbe    1282 <memmove+0x172>
mov    %rdx,%rcx
lea    -0x1(%rcx),%r8
mov    %rcx,%rdi
and    $0x3,%rdi
je     123d <memmove+0x12d>
nopl   0x0(%rax)
lea    -0x1(%rcx),%rax
movzbl -0x1(%rsi,%rcx,1),%edx
mov    %dl,-0x1(%rbx,%rcx,1)
mov    %rax,%rcx
add    $0xffffffffffffffff,%rdi
jne    1170 <memmove+0x60>
cmp    $0x3,%r8
jb     1121 <memmove+0x11>
jmp    124a <memmove+0x13a>
cmp    $0x8,%rdx
jb     1121 <memmove+0x11>
mov    %rdx,%rax
shr    $0x3,%rax
cmp    $0x20,%rdx
jb     13cf <memmove+0x2bf>
and    $0xfffffffffffffff8,%rdx
lea    (%rsi,%rdx,1),%rcx
cmp    %rbx,%rcx
jbe    11c1 <memmove+0xb1>
add    %rbx,%rdx
cmp    %rsi,%rdx
ja     13cf <memmove+0x2bf>
mov    %rax,%r8
and    $0xfffffffffffffffc,%r8
lea    -0x4(%r8),%rcx
mov    %rcx,%r9
shr    $0x2,%r9
add    $0x1,%r9
test   %rcx,%rcx
je     139f <memmove+0x28f>
mov    %r9,%rdx
and    $0xfffffffffffffffe,%rdx
lea    (%rbx,%rax,8),%r10
add    $0xfffffffffffffff0,%r10
lea    (%rsi,%rax,8),%rcx
add    $0xfffffffffffffff0,%rcx
mov    $0xfffffffffffffffe,%rdi
xchg   %ax,%ax
movups (%rcx,%rdi,8),%xmm0
movups 0x10(%rcx,%rdi,8),%xmm1
movups %xmm1,0x10(%r10,%rdi,8)
movups %xmm0,(%r10,%rdi,8)
movups -0x20(%rcx,%rdi,8),%xmm0
movups -0x10(%rcx,%rdi,8),%xmm1
movups %xmm1,-0x10(%r10,%rdi,8)
movups %xmm0,-0x20(%r10,%rdi,8)
add    $0xfffffffffffffff8,%rdi
add    $0xfffffffffffffffe,%rdx
jne    1200 <memmove+0xf0>
add    $0x1,%rdi
jmp    13a6 <memmove+0x296>
mov    %rcx,%rax
cmp    $0x3,%r8
jb     1121 <memmove+0x11>
mov    %rax,%rcx
nopl   (%rax)
movzbl -0x1(%rsi,%rax,1),%edx
mov    %dl,-0x1(%rbx,%rax,1)
movzbl -0x2(%rsi,%rax,1),%edx
mov    %dl,-0x2(%rbx,%rax,1)
movzbl -0x3(%rsi,%rax,1),%edx
mov    %dl,-0x3(%rbx,%rax,1)
movzbl -0x4(%rsi,%rax,1),%edx
mov    %dl,-0x4(%rbx,%rax,1)
add    $0xfffffffffffffffc,%rcx
mov    %rcx,%rax
jne    1250 <memmove+0x140>
jmp    1121 <memmove+0x11>
cmp    $0x10,%rdx
jae    128f <memmove+0x17f>
xor    %eax,%eax
jmp    1358 <memmove+0x248>
mov    %rdx,%rax
and    $0xfffffffffffffff0,%rax
lea    -0x10(%rax),%rcx
mov    %rcx,%rdi
shr    $0x4,%rdi
add    $0x1,%rdi
mov    %edi,%r8d
and    $0x3,%r8d
cmp    $0x30,%rcx
jae    12b6 <memmove+0x1a6>
xor    %ecx,%ecx
jmp    130b <memmove+0x1fb>
and    $0xfffffffffffffffc,%rdi
lea    (%rbx,%rdx,1),%r9
add    $0xfffffffffffffff0,%r9
lea    (%rsi,%rdx,1),%r10
add    $0xfffffffffffffff0,%r10
xor    %ecx,%ecx
nopl   0x0(%rax)
movups (%r10,%rcx,1),%xmm0
movups %xmm0,(%r9,%rcx,1)
movups -0x10(%r10,%rcx,1),%xmm0
movups %xmm0,-0x10(%r9,%rcx,1)
movups -0x20(%r10,%rcx,1),%xmm0
movups %xmm0,-0x20(%r9,%rcx,1)
movups -0x30(%r10,%rcx,1),%xmm0
movups %xmm0,-0x30(%r9,%rcx,1)
add    $0xffffffffffffffc0,%rcx
add    $0xfffffffffffffffc,%rdi
jne    12d0 <memmove+0x1c0>
neg    %rcx
test   %r8,%r8
je     1346 <memmove+0x236>
mov    %rdx,%rdi
sub    %rcx,%rdi
lea    (%rbx,%rdi,1),%r9
add    $0xfffffffffffffff0,%r9
lea    (%rsi,%rdi,1),%r10
add    $0xfffffffffffffff0,%r10
shl    $0x4,%r8
xor    %ecx,%ecx
nopl   0x0(%rax)
movups (%r10,%rcx,1),%xmm0
movups %xmm0,(%r9,%rcx,1)
add    $0xfffffffffffffff0,%rcx
mov    %r8,%rdi
add    %rcx,%rdi
jne    1330 <memmove+0x220>
cmp    %rdx,%rax
je     1121 <memmove+0x11>
test   $0xc,%dl
je     1456 <memmove+0x346>
mov    %rdx,%r8
and    $0xfffffffffffffffc,%r8
mov    %edx,%ecx
and    $0x3,%ecx
lea    (%rbx,%rdx,1),%r9
add    $0xfffffffffffffffc,%r9
neg    %rax
lea    (%rsi,%rdx,1),%r10
add    $0xfffffffffffffffc,%r10
mov    %r8,%r11
neg    %r11
nopl   (%rax)
mov    (%r10,%rax,1),%edi
mov    %edi,(%r9,%rax,1)
add    $0xfffffffffffffffc,%rax
cmp    %rax,%r11
jne    1380 <memmove+0x270>
cmp    %rdx,%r8
je     1121 <memmove+0x11>
jmp    115b <memmove+0x4b>
mov    $0xffffffffffffffff,%rdi
test   $0x1,%r9b
je     13c3 <memmove+0x2b3>
add    %rax,%rdi
movups -0x18(%rsi,%rdi,8),%xmm0
movups -0x8(%rsi,%rdi,8),%xmm1
movups %xmm1,-0x8(%rbx,%rdi,8)
movups %xmm0,-0x18(%rbx,%rdi,8)
cmp    %r8,%rax
je     1121 <memmove+0x11>
and    $0x3,%eax
lea    -0x1(%rax),%r8
mov    %rax,%rdi
and    $0x3,%rdi
je     1403 <memmove+0x2f3>
nopl   0x0(%rax)
lea    -0x1(%rax),%rcx
mov    -0x8(%rsi,%rax,8),%rdx
mov    %rdx,-0x8(%rbx,%rax,8)
mov    %rcx,%rax
add    $0xffffffffffffffff,%rdi
jne    13e0 <memmove+0x2d0>
cmp    $0x3,%r8
jb     1121 <memmove+0x11>
jmp    1410 <memmove+0x300>
mov    %rax,%rcx
cmp    $0x3,%r8
jb     1121 <memmove+0x11>
mov    %rcx,%rax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    -0x8(%rsi,%rcx,8),%rdx
mov    %rdx,-0x8(%rbx,%rcx,8)
mov    -0x10(%rsi,%rcx,8),%rdx
mov    %rdx,-0x10(%rbx,%rcx,8)
mov    -0x18(%rsi,%rcx,8),%rdx
mov    %rdx,-0x18(%rbx,%rcx,8)
mov    -0x20(%rsi,%rcx,8),%rdx
mov    %rdx,-0x20(%rbx,%rcx,8)
add    $0xfffffffffffffffc,%rax
mov    %rax,%rcx
jne    1420 <memmove+0x310>
jmp    1121 <memmove+0x11>
and    $0xf,%edx
jmp    1158 <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 i64
%9 = alloca i64*
%10 = alloca i64*
%11 = alloca i8*
%12 = alloca i8*
store i8* %0, i8** %5
store i8* %1, i8** %6
store i64 %2, i64* %7
%13 = load i8*, i8** %5
%14 = ptrtoint i8* %13 to i64
%15 = load i8*, i8** %6
%16 = ptrtoint i8* %15 to i64
%17 = icmp ult i64 %14, %16
br i1 %17, label %18, label %22
18: ; preds = %3
%19 = load i8*, i8** %5
%20 = load i8*, i8** %6
%21 = load i64, i64* %7
store i8* %19, i8** %4
br label %83
22: ; preds = %3
%23 = load i8*, i8** %5
%24 = ptrtoint i8* %23 to i64
%25 = urem i64 %24, 8
%26 = icmp eq i64 %25, 0
br i1 %26, label %27, label %60
27: ; preds = %22
%28 = load i8*, i8** %6
%29 = ptrtoint i8* %28 to i64
%30 = urem i64 %29, 8
%31 = icmp eq i64 %30, 0
br i1 %31, label %32, label %60
32: ; preds = %27
%33 = load i64, i64* %7
%34 = urem i64 %33, 8
%35 = icmp eq i64 %34, 0
br i1 %35, label %36, label %60
36: ; preds = %32
%37 = load i8*, i8** %5
%38 = bitcast i8* %37 to i64*
store i64* %38, i64** %9
%39 = load i8*, i8** %6
%40 = bitcast i8* %39 to i64*
store i64* %40, i64** %10
%41 = load i64, i64* %7
%42 = udiv i64 %41, 8
store i64 %42, i64* %8
br label %43
43: ; preds = %56, %36
%44 = load i64, i64* %8
%45 = icmp ugt i64 %44, 0
br i1 %45, label %46, label %59
46: ; preds = %43
%47 = load i64*, i64** %10
%48 = load i64, i64* %8
%49 = sub i64 %48, 1
%50 = getelementptr inbounds i64, i64* %47, i64 %49
%51 = load i64, i64* %50
%52 = load i64*, i64** %9
%53 = load i64, i64* %8
%54 = sub i64 %53, 1
%55 = getelementptr inbounds i64, i64* %52, i64 %54
store i64 %51, i64* %55
br label %56
56: ; preds = %46
%57 = load i64, i64* %8
%58 = add i64 %57, -1
store i64 %58, i64* %8
br label %43
59: ; preds = %43
br label %81
60: ; preds = %32, %27, %22
%61 = load i8*, i8** %5
store i8* %61, i8** %11
%62 = load i8*, i8** %6
store i8* %62, i8** %12
%63 = load i64, i64* %7
store i64 %63, i64* %8
br label %64
64: ; preds = %77, %60
%65 = load i64, i64* %8
%66 = icmp ugt i64 %65, 0
br i1 %66, label %67, label %80
67: ; preds = %64
%68 = load i8*, i8** %12
%69 = load i64, i64* %8
%70 = sub i64 %69, 1
%71 = getelementptr inbounds i8, i8* %68, i64 %70
%72 = load i8, i8* %71
%73 = load i8*, i8** %11
%74 = load i64, i64* %8
%75 = sub i64 %74, 1
%76 = getelementptr inbounds i8, i8* %73, i64 %75
store i8 %72, i8* %76
br label %77
77: ; preds = %67
%78 = load i64, i64* %8
%79 = add i64 %78, -1
store i64 %79, i64* %8
br label %64
80: ; preds = %64
br label %81
81: ; preds = %80, %59
%82 = load i8*, i8** %5
store i8* %82, i8** %4
br label %83
83: ; preds = %81, %18
%84 = load i8*, i8** %4
ret i8* %84
}

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