#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 num) {
  const unsigned char *sp;
  unsigned char *dp;
  if (destination < source) {
    sp = (const unsigned char *)source;
    dp = (unsigned char *)destination;
    while (num) {
      *dp = *sp;
      dp++;
      sp++;
      num--;
    }
  } else {
    while (num) {
      sp = (unsigned char *)source + num - 1;
      dp = (unsigned char *)destination + num - 1;
      *dp = *sp;
      num--;
    }
  }
  return destination;
}


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
cmp    -0x10(%rbp),%rax
jae    1173 <memmove+0x73>
mov    -0x10(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x28(%rbp)
cmpq   $0x0,-0x18(%rbp)
je     116e <memmove+0x6e>
mov    -0x20(%rbp),%rax
mov    (%rax),%cl
mov    -0x28(%rbp),%rax
mov    %cl,(%rax)
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x18(%rbp)
jmp    112e <memmove+0x2e>
jmp    11c5 <memmove+0xc5>
jmp    1178 <memmove+0x78>
cmpq   $0x0,-0x18(%rbp)
je     11c0 <memmove+0xc0>
mov    -0x10(%rbp),%rax
add    -0x18(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x20(%rbp)
mov    -0x8(%rbp),%rax
add    -0x18(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%cl
mov    -0x28(%rbp),%rax
mov    %cl,(%rax)
mov    -0x18(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x18(%rbp)
jmp    1178 <memmove+0x78>
jmp    11c5 <memmove+0xc5>
mov    -0x8(%rbp),%rax
pop    %rbp
ret

x86 assembly (clang, -O2):
<memmove>:
push   %rbx
mov    %rdi,%rax
cmp    %rsi,%rdi
jae    11d1 <memmove+0xd1>
test   %rdx,%rdx
je     124a <memmove+0x14a>
cmp    $0x8,%rdx
jb     1136 <memmove+0x36>
lea    (%rsi,%rdx,1),%rcx
cmp    %rax,%rcx
jbe    124c <memmove+0x14c>
lea    (%rax,%rdx,1),%rcx
cmp    %rsi,%rcx
jbe    124c <memmove+0x14c>
mov    %rax,%rdi
mov    %rsi,%rcx
mov    %rdx,%r9
lea    -0x1(%r9),%r8
mov    %r9,%rdx
and    $0x7,%rdx
je     1169 <memmove+0x69>
xor    %esi,%esi
xchg   %ax,%ax
movzbl (%rcx,%rsi,1),%ebx
mov    %bl,(%rdi,%rsi,1)
add    $0x1,%rsi
cmp    %rsi,%rdx
jne    1150 <memmove+0x50>
add    %rsi,%rdi
add    %rsi,%rcx
sub    %rsi,%r9
cmp    $0x7,%r8
jb     124a <memmove+0x14a>
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nop
movzbl (%rcx,%rdx,1),%ebx
mov    %bl,(%rdi,%rdx,1)
movzbl 0x1(%rcx,%rdx,1),%ebx
mov    %bl,0x1(%rdi,%rdx,1)
movzbl 0x2(%rcx,%rdx,1),%ebx
mov    %bl,0x2(%rdi,%rdx,1)
movzbl 0x3(%rcx,%rdx,1),%ebx
mov    %bl,0x3(%rdi,%rdx,1)
movzbl 0x4(%rcx,%rdx,1),%ebx
mov    %bl,0x4(%rdi,%rdx,1)
movzbl 0x5(%rcx,%rdx,1),%ebx
mov    %bl,0x5(%rdi,%rdx,1)
movzbl 0x6(%rcx,%rdx,1),%ebx
mov    %bl,0x6(%rdi,%rdx,1)
movzbl 0x7(%rcx,%rdx,1),%ebx
mov    %bl,0x7(%rdi,%rdx,1)
add    $0x8,%rdx
cmp    %rdx,%r9
jne    1180 <memmove+0x80>
jmp    124a <memmove+0x14a>
test   %rdx,%rdx
je     124a <memmove+0x14a>
cmp    $0x4,%rdx
jb     11ee <memmove+0xee>
lea    (%rsi,%rdx,1),%rcx
cmp    %rax,%rcx
jbe    125a <memmove+0x15a>
lea    (%rax,%rdx,1),%rcx
cmp    %rsi,%rcx
jbe    125a <memmove+0x15a>
mov    %rdx,%rdi
lea    -0x1(%rdi),%rcx
mov    %rdi,%rdx
and    $0x3,%rdx
je     1213 <memmove+0x113>
xchg   %ax,%ax
movzbl -0x1(%rsi,%rdi,1),%ebx
mov    %bl,-0x1(%rax,%rdi,1)
add    $0xffffffffffffffff,%rdi
add    $0xffffffffffffffff,%rdx
jne    1200 <memmove+0x100>
cmp    $0x3,%rcx
jb     124a <memmove+0x14a>
nopl   0x0(%rax)
movzbl -0x1(%rsi,%rdi,1),%ecx
mov    %cl,-0x1(%rax,%rdi,1)
movzbl -0x2(%rsi,%rdi,1),%ecx
mov    %cl,-0x2(%rax,%rdi,1)
movzbl -0x3(%rsi,%rdi,1),%ecx
mov    %cl,-0x3(%rax,%rdi,1)
movzbl -0x4(%rsi,%rdi,1),%ecx
mov    %cl,-0x4(%rax,%rdi,1)
add    $0xfffffffffffffffc,%rdi
jne    1220 <memmove+0x120>
pop    %rbx
ret
cmp    $0x20,%rdx
jae    1267 <memmove+0x167>
xor    %r8d,%r8d
jmp    137f <memmove+0x27f>
cmp    $0x10,%rdx
jae    1291 <memmove+0x191>
xor    %ebx,%ebx
jmp    1464 <memmove+0x364>
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    12bf <memmove+0x1bf>
xor    %ecx,%ecx
jmp    1328 <memmove+0x228>
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    13bf <memmove+0x2bf>
xor    %edi,%edi
jmp    141b <memmove+0x31b>
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    12d0 <memmove+0x1d0>
test   %r9,%r9
je     136d <memmove+0x26d>
lea    (%rsi,%rcx,1),%r10
add    $0x10,%r10
add    %rax,%rcx
add    $0x10,%rcx
shl    $0x5,%r9
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups -0x10(%r10,%rdi,1),%xmm0
movups (%r10,%rdi,1),%xmm1
movups %xmm0,-0x10(%rcx,%rdi,1)
movups %xmm1,(%rcx,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%r9
jne    1350 <memmove+0x250>
cmp    %rdx,%r8
je     124a <memmove+0x14a>
test   $0x18,%dl
je     14af <memmove+0x3af>
mov    %rdx,%r10
and    $0xfffffffffffffff8,%r10
lea    (%rax,%r10,1),%rdi
lea    (%rsi,%r10,1),%rcx
mov    %edx,%r9d
and    $0x7,%r9d
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%rsi,%r8,1),%rbx
mov    %rbx,(%rax,%r8,1)
add    $0x8,%r8
cmp    %r8,%r10
jne    13a0 <memmove+0x2a0>
cmp    %rdx,%r10
jne    113f <memmove+0x3f>
jmp    124a <memmove+0x14a>
and    $0xfffffffffffffffc,%r9
lea    (%rax,%rdx,1),%r10
add    $0xfffffffffffffff0,%r10
lea    (%rsi,%rdx,1),%r11
add    $0xfffffffffffffff0,%r11
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nop
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    13e0 <memmove+0x2e0>
neg    %rdi
test   %r8,%r8
je     1456 <memmove+0x356>
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    1440 <memmove+0x340>
cmp    %rdx,%rbx
je     124a <memmove+0x14a>
test   $0xc,%dl
je     14c0 <memmove+0x3c0>
mov    %rdx,%r8
and    $0xfffffffffffffffc,%r8
mov    %edx,%edi
and    $0x3,%edi
mov    %r8,%r9
neg    %r9
neg    %rbx
lea    (%rax,%rdx,1),%r10
add    $0xfffffffffffffffc,%r10
lea    (%rsi,%rdx,1),%r11
add    $0xfffffffffffffffc,%r11
nopl   0x0(%rax)
mov    (%r11,%rbx,1),%ecx
mov    %ecx,(%r10,%rbx,1)
add    $0xfffffffffffffffc,%rbx
cmp    %rbx,%r9
jne    1490 <memmove+0x390>
cmp    %rdx,%r8
jne    11f1 <memmove+0xf1>
jmp    124a <memmove+0x14a>
and    $0x1f,%edx
add    %r8,%rsi
add    %rax,%r8
mov    %r8,%rdi
jmp    1139 <memmove+0x39>
and    $0xf,%edx
jmp    11ee <memmove+0xee>

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

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