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


x86 assembly (clang, -O0):
<memmove>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
cmp    -0x20(%rbp),%rax
jbe    1191 <memmove+0x91>
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)
cmpq   $0x0,-0x18(%rbp)
je     118c <memmove+0x8c>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x20(%rbp)
mov    (%rax),%cl
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0xffffffffffffffff,%rdx
mov    %rdx,-0x28(%rbp)
mov    %cl,(%rax)
mov    -0x18(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x18(%rbp)
jmp    114e <memmove+0x4e>
jmp    11ec <memmove+0xec>
mov    -0x28(%rbp),%rax
cmp    -0x20(%rbp),%rax
jae    11e7 <memmove+0xe7>
jmp    11a4 <memmove+0xa4>
cmpq   $0x0,-0x18(%rbp)
je     11e2 <memmove+0xe2>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
mov    (%rax),%cl
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    %cl,(%rax)
mov    -0x18(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x18(%rbp)
jmp    11a4 <memmove+0xa4>
jmp    11e7 <memmove+0xe7>
jmp    11ec <memmove+0xec>
mov    -0x8(%rbp),%rax
pop    %rbp
ret

x86 assembly (clang, -O2):
<memmove>:
push   %rbp
push   %r14
push   %rbx
mov    %rdi,%rax
cmp    %rsi,%rdi
jbe    11e4 <memmove+0xe4>
mov    %rdx,%r9
sub    $0x1,%r9
jb     12af <memmove+0x1af>
lea    (%rax,%r9,1),%r8
add    %rsi,%r9
cmp    $0x4,%rdx
jb     1144 <memmove+0x44>
lea    (%rsi,%rdx,1),%rcx
cmp    %rax,%rcx
jbe    12b4 <memmove+0x1b4>
lea    (%rax,%rdx,1),%rcx
cmp    %rsi,%rcx
jbe    12b4 <memmove+0x1b4>
mov    %r8,%rsi
mov    %r9,%rcx
mov    %rdx,%r10
lea    -0x1(%r10),%r8
mov    %r10,%rdi
and    $0x7,%rdi
je     1179 <memmove+0x79>
xor    %edx,%edx
nopl   0x0(%rax)
movzbl (%rcx),%ebx
add    $0xffffffffffffffff,%rcx
mov    %bl,(%rsi)
add    $0xffffffffffffffff,%rsi
add    $0x1,%rdx
cmp    %rdx,%rdi
jne    1160 <memmove+0x60>
sub    %rdx,%r10
cmp    $0x7,%r8
jb     12af <memmove+0x1af>
neg    %r10
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movzbl (%rcx,%rdx,1),%ebx
mov    %bl,(%rsi,%rdx,1)
movzbl -0x1(%rcx,%rdx,1),%ebx
mov    %bl,-0x1(%rsi,%rdx,1)
movzbl -0x2(%rcx,%rdx,1),%ebx
mov    %bl,-0x2(%rsi,%rdx,1)
movzbl -0x3(%rcx,%rdx,1),%ebx
mov    %bl,-0x3(%rsi,%rdx,1)
movzbl -0x4(%rcx,%rdx,1),%ebx
mov    %bl,-0x4(%rsi,%rdx,1)
movzbl -0x5(%rcx,%rdx,1),%ebx
mov    %bl,-0x5(%rsi,%rdx,1)
movzbl -0x6(%rcx,%rdx,1),%ebx
mov    %bl,-0x6(%rsi,%rdx,1)
movzbl -0x7(%rcx,%rdx,1),%ebx
mov    %bl,-0x7(%rsi,%rdx,1)
add    $0xfffffffffffffff8,%rdx
cmp    %rdx,%r10
jne    1190 <memmove+0x90>
jmp    12af <memmove+0x1af>
jae    12af <memmove+0x1af>
test   %rdx,%rdx
je     12af <memmove+0x1af>
cmp    $0x8,%rdx
jb     1213 <memmove+0x113>
lea    (%rsi,%rdx,1),%rcx
cmp    %rax,%rcx
jbe    12c1 <memmove+0x1c1>
lea    (%rax,%rdx,1),%rcx
cmp    %rsi,%rcx
jbe    12c1 <memmove+0x1c1>
mov    %rdx,%r8
mov    %rsi,%rcx
mov    %rax,%rdi
lea    -0x1(%r8),%rbp
mov    %r8,%rbx
and    $0x7,%rbx
je     1249 <memmove+0x149>
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movzbl (%rcx,%rsi,1),%edx
mov    %dl,(%rdi,%rsi,1)
add    $0x1,%rsi
cmp    %rsi,%rbx
jne    1230 <memmove+0x130>
sub    %rsi,%r8
add    %rsi,%rcx
add    %rsi,%rdi
cmp    $0x7,%rbp
jb     12af <memmove+0x1af>
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
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,%r8
jne    1260 <memmove+0x160>
pop    %rbx
pop    %r14
pop    %rbp
ret
cmp    $0x10,%rdx
jae    12cf <memmove+0x1cf>
xor    %edi,%edi
jmp    13c7 <memmove+0x2c7>
cmp    $0x20,%rdx
jae    12f9 <memmove+0x1f9>
xor    %r9d,%r9d
jmp    14c9 <memmove+0x3c9>
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    1327 <memmove+0x227>
xor    %ecx,%ecx
jmp    1377 <memmove+0x277>
mov    %rdx,%r9
and    $0xffffffffffffffe0,%r9
lea    -0x20(%r9),%rcx
mov    %rcx,%rdi
shr    $0x5,%rdi
add    $0x1,%rdi
mov    %edi,%r8d
and    $0x3,%r8d
cmp    $0x60,%rcx
jae    1411 <memmove+0x311>
xor    %ecx,%ecx
jmp    1478 <memmove+0x378>
and    $0xfffffffffffffffc,%r11
lea    -0xf(%r8),%r14
lea    -0xf(%r9),%rbx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nop
movups (%rbx,%rcx,1),%xmm0
movups %xmm0,(%r14,%rcx,1)
movups -0x10(%rbx,%rcx,1),%xmm0
movups %xmm0,-0x10(%r14,%rcx,1)
movups -0x20(%rbx,%rcx,1),%xmm0
movups %xmm0,-0x20(%r14,%rcx,1)
movups -0x30(%rbx,%rcx,1),%xmm0
movups %xmm0,-0x30(%r14,%rcx,1)
add    $0xffffffffffffffc0,%rcx
add    $0xfffffffffffffffc,%r11
jne    1340 <memmove+0x240>
neg    %rcx
test   %r10,%r10
je     13b5 <memmove+0x2b5>
mov    %rdx,%rbx
sub    %rcx,%rbx
lea    (%rsi,%rbx,1),%r11
add    $0xfffffffffffffff0,%r11
lea    (%rax,%rbx,1),%rsi
add    $0xfffffffffffffff0,%rsi
shl    $0x4,%r10
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movups (%r11,%rbx,1),%xmm0
movups %xmm0,(%rsi,%rbx,1)
add    $0xfffffffffffffff0,%rbx
mov    %r10,%rcx
add    %rbx,%rcx
jne    13a0 <memmove+0x2a0>
cmp    %rdx,%rdi
je     12af <memmove+0x1af>
test   $0xc,%dl
je     14ff <memmove+0x3ff>
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
nopw   0x0(%rax,%rax,1)
mov    -0x3(%r9,%rdi,1),%ebp
mov    %ebp,-0x3(%r8,%rdi,1)
add    $0xfffffffffffffffc,%rdi
cmp    %rdi,%rbx
jne    13f0 <memmove+0x2f0>
cmp    %rdx,%r11
jne    114d <memmove+0x4d>
jmp    12af <memmove+0x1af>
and    $0xfffffffffffffffc,%rdi
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
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    1420 <memmove+0x320>
test   %r8,%r8
je     14bb <memmove+0x3bb>
lea    (%rax,%rcx,1),%rdi
add    $0x10,%rdi
add    %rsi,%rcx
add    $0x10,%rcx
shl    $0x5,%r8
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,%r8
jne    14a0 <memmove+0x3a0>
cmp    %rdx,%r9
je     12af <memmove+0x1af>
test   $0x18,%dl
je     150d <memmove+0x40d>
mov    %rdx,%rbx
and    $0xfffffffffffffff8,%rbx
mov    %edx,%r8d
and    $0x7,%r8d
lea    (%rsi,%rbx,1),%rcx
lea    (%rax,%rbx,1),%rdi
nop
mov    (%rsi,%r9,1),%rbp
mov    %rbp,(%rax,%r9,1)
add    $0x8,%r9
cmp    %r9,%rbx
jne    14e0 <memmove+0x3e0>
cmp    %rdx,%rbx
jne    121c <memmove+0x11c>
jmp    12af <memmove+0x1af>
and    $0xf,%edx
sub    %rdi,%r9
sub    %rdi,%r8
jmp    1144 <memmove+0x44>
lea    (%rax,%r9,1),%rdi
add    %r9,%rsi
and    $0x1f,%edx
mov    %rdx,%r8
mov    %rsi,%rcx
jmp    121c <memmove+0x11c>

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

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