#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 size) {
  void *p = s1;
  char *c1 = (char *)s1;
  char *c2 = (char *)s2;
  if (c1 > c2) {
    c1 += size - 1;
    c2 += size - 1;
    while (0 < size--)
      *c1-- = *c2--;
  } else {
    while (0 < size--)
      *c1++ = *c2++;
  }
  return p;
}


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    -0x8(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rax
cmp    -0x30(%rbp),%rax
jbe    119c <memmove+0x9c>
mov    -0x18(%rbp),%rax
sub    $0x1,%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
sub    $0x1,%rax
add    -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x18(%rbp),%rcx
mov    %rcx,%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x18(%rbp)
xor    %eax,%eax
cmp    %rcx,%rax
jae    1197 <memmove+0x97>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%cl
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0xffffffffffffffff,%rdx
mov    %rdx,-0x28(%rbp)
mov    %cl,(%rax)
jmp    1156 <memmove+0x56>
jmp    11e7 <memmove+0xe7>
jmp    11a1 <memmove+0xa1>
mov    -0x18(%rbp),%rcx
mov    %rcx,%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x18(%rbp)
xor    %eax,%eax
cmp    %rcx,%rax
jae    11e2 <memmove+0xe2>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%cl
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x28(%rbp)
mov    %cl,(%rax)
jmp    11a1 <memmove+0xa1>
jmp    11e7 <memmove+0xe7>
mov    -0x20(%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    (%rsi,%r9,1),%r8
add    %rax,%r9
cmp    $0x4,%rdx
jb     1144 <memmove+0x44>
lea    (%rsi,%rdx,1),%rcx
cmp    %rax,%rcx
jbe    12c2 <memmove+0x1c2>
lea    (%rax,%rdx,1),%rcx
cmp    %rsi,%rcx
jbe    12c2 <memmove+0x1c2>
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 (%rsi),%ebx
add    $0xffffffffffffffff,%rsi
mov    %bl,(%rcx)
add    $0xffffffffffffffff,%rcx
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 (%rsi,%rdx,1),%ebx
mov    %bl,(%rcx,%rdx,1)
movzbl -0x1(%rsi,%rdx,1),%ebx
mov    %bl,-0x1(%rcx,%rdx,1)
movzbl -0x2(%rsi,%rdx,1),%ebx
mov    %bl,-0x2(%rcx,%rdx,1)
movzbl -0x3(%rsi,%rdx,1),%ebx
mov    %bl,-0x3(%rcx,%rdx,1)
movzbl -0x4(%rsi,%rdx,1),%ebx
mov    %bl,-0x4(%rcx,%rdx,1)
movzbl -0x5(%rsi,%rdx,1),%ebx
mov    %bl,-0x5(%rcx,%rdx,1)
movzbl -0x6(%rsi,%rdx,1),%ebx
mov    %bl,-0x6(%rcx,%rdx,1)
movzbl -0x7(%rsi,%rdx,1),%ebx
mov    %bl,-0x7(%rcx,%rdx,1)
add    $0xfffffffffffffff8,%rdx
cmp    %rdx,%r10
jne    1190 <memmove+0x90>
jmp    12af <memmove+0x1af>
test   %rdx,%rdx
je     12af <memmove+0x1af>
cmp    $0x8,%rdx
jb     120d <memmove+0x10d>
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    %rsi,%rdi
mov    %rax,%rcx
mov    %rdx,%r9
lea    -0x1(%r9),%r8
mov    %r9,%rbx
and    $0x7,%rbx
je     1249 <memmove+0x149>
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nop
movzbl (%rdi,%rsi,1),%edx
mov    %dl,(%rcx,%rsi,1)
add    $0x1,%rsi
cmp    %rsi,%rbx
jne    1230 <memmove+0x130>
add    %rsi,%rdi
add    %rsi,%rcx
sub    %rsi,%r9
cmp    $0x7,%r8
jb     12af <memmove+0x1af>
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl (%rdi,%rdx,1),%ebx
mov    %bl,(%rcx,%rdx,1)
movzbl 0x1(%rdi,%rdx,1),%ebx
mov    %bl,0x1(%rcx,%rdx,1)
movzbl 0x2(%rdi,%rdx,1),%ebx
mov    %bl,0x2(%rcx,%rdx,1)
movzbl 0x3(%rdi,%rdx,1),%ebx
mov    %bl,0x3(%rcx,%rdx,1)
movzbl 0x4(%rdi,%rdx,1),%ebx
mov    %bl,0x4(%rcx,%rdx,1)
movzbl 0x5(%rdi,%rdx,1),%ebx
mov    %bl,0x5(%rcx,%rdx,1)
movzbl 0x6(%rdi,%rdx,1),%ebx
mov    %bl,0x6(%rcx,%rdx,1)
movzbl 0x7(%rdi,%rdx,1),%ebx
mov    %bl,0x7(%rcx,%rdx,1)
add    $0x8,%rdx
cmp    %rdx,%r9
jne    1260 <memmove+0x160>
pop    %rbx
pop    %r14
pop    %rbp
ret
cmp    $0x20,%rdx
jae    12cf <memmove+0x1cf>
xor    %r8d,%r8d
jmp    13dd <memmove+0x2dd>
cmp    $0x10,%rdx
jae    12f9 <memmove+0x1f9>
xor    %edi,%edi
jmp    14b3 <memmove+0x3b3>
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    1327 <memmove+0x227>
xor    %ecx,%ecx
jmp    1388 <memmove+0x288>
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    141f <memmove+0x31f>
xor    %ecx,%ecx
jmp    1467 <memmove+0x367>
and    $0xfffffffffffffffc,%rdi
xor    %ecx,%ecx
nopl   (%rax)
movups (%rsi,%rcx,1),%xmm0
movups 0x10(%rsi,%rcx,1),%xmm1
movups %xmm0,(%rax,%rcx,1)
movups %xmm1,0x10(%rax,%rcx,1)
movups 0x20(%rsi,%rcx,1),%xmm0
movups 0x30(%rsi,%rcx,1),%xmm1
movups %xmm0,0x20(%rax,%rcx,1)
movups %xmm1,0x30(%rax,%rcx,1)
movups 0x40(%rsi,%rcx,1),%xmm0
movups 0x50(%rsi,%rcx,1),%xmm1
movups %xmm0,0x40(%rax,%rcx,1)
movups %xmm1,0x50(%rax,%rcx,1)
movups 0x60(%rsi,%rcx,1),%xmm0
movups 0x70(%rsi,%rcx,1),%xmm1
movups %xmm0,0x60(%rax,%rcx,1)
movups %xmm1,0x70(%rax,%rcx,1)
sub    $0xffffffffffffff80,%rcx
add    $0xfffffffffffffffc,%rdi
jne    1330 <memmove+0x230>
test   %r9,%r9
je     13cb <memmove+0x2cb>
lea    (%rax,%rcx,1),%rdi
add    $0x10,%rdi
add    %rsi,%rcx
add    $0x10,%rcx
shl    $0x5,%r9
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups -0x10(%rcx,%rbx,1),%xmm0
movups (%rcx,%rbx,1),%xmm1
movups %xmm0,-0x10(%rdi,%rbx,1)
movups %xmm1,(%rdi,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%r9
jne    13b0 <memmove+0x2b0>
cmp    %rdx,%r8
je     12af <memmove+0x1af>
test   $0x18,%dl
je     1501 <memmove+0x401>
mov    %rdx,%r10
and    $0xfffffffffffffff8,%r10
lea    (%rsi,%r10,1),%rdi
lea    (%rax,%r10,1),%rcx
mov    %edx,%r9d
and    $0x7,%r9d
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%rsi,%r8,1),%rbx
mov    %rbx,(%rax,%r8,1)
add    $0x8,%r8
cmp    %r8,%r10
jne    1400 <memmove+0x300>
cmp    %rdx,%r10
jne    1216 <memmove+0x116>
jmp    12af <memmove+0x1af>
and    $0xfffffffffffffffc,%r11
lea    -0xf(%r8),%r14
lea    -0xf(%r9),%rbx
xor    %ecx,%ecx
nopl   (%rax)
movups (%r14,%rcx,1),%xmm0
movups %xmm0,(%rbx,%rcx,1)
movups -0x10(%r14,%rcx,1),%xmm0
movups %xmm0,-0x10(%rbx,%rcx,1)
movups -0x20(%r14,%rcx,1),%xmm0
movups %xmm0,-0x20(%rbx,%rcx,1)
movups -0x30(%r14,%rcx,1),%xmm0
movups %xmm0,-0x30(%rbx,%rcx,1)
add    $0xffffffffffffffc0,%rcx
add    $0xfffffffffffffffc,%r11
jne    1430 <memmove+0x330>
neg    %rcx
test   %r10,%r10
je     14a5 <memmove+0x3a5>
mov    %rdx,%rbx
sub    %rcx,%rbx
lea    (%rax,%rbx,1),%r11
add    $0xfffffffffffffff0,%r11
add    %rbx,%rsi
add    $0xfffffffffffffff0,%rsi
shl    $0x4,%r10
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
movups (%rsi,%rbx,1),%xmm0
movups %xmm0,(%r11,%rbx,1)
add    $0xfffffffffffffff0,%rbx
mov    %r10,%rcx
add    %rbx,%rcx
jne    1490 <memmove+0x390>
cmp    %rdx,%rdi
je     12af <memmove+0x1af>
test   $0xc,%dl
je     1513 <memmove+0x413>
mov    %rdx,%r11
and    $0xfffffffffffffffc,%r11
mov    %r11,%rbx
neg    %rbx
mov    %r8,%rsi
sub    %r11,%rsi
mov    %r9,%rcx
sub    %r11,%rcx
mov    %edx,%r10d
and    $0x3,%r10d
neg    %rdi
cs nopw 0x0(%rax,%rax,1)
mov    -0x3(%r8,%rdi,1),%ebp
mov    %ebp,-0x3(%r9,%rdi,1)
add    $0xfffffffffffffffc,%rdi
cmp    %rdi,%rbx
jne    14e0 <memmove+0x3e0>
cmp    %rdx,%r11
jne    114d <memmove+0x4d>
jmp    12af <memmove+0x1af>
and    $0x1f,%edx
lea    (%rax,%r8,1),%rcx
add    %r8,%rsi
mov    %rsi,%rdi
jmp    1213 <memmove+0x113>
and    $0xf,%edx
sub    %rdi,%r9
sub    %rdi,%r8
jmp    1144 <memmove+0x44>

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

LLVM IR (-O2):
define i8* @memmove(i8* returned writeonly %0, i8* %1, i64 %2) {
%4 = icmp ugt i8* %0, %1
br i1 %4, label %142, label %5
5: ; preds = %3
%6 = icmp eq i64 %2, 0
br i1 %6, label %343, label %7
7: ; preds = %5
%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 %343, 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 %343, 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 %343, label %313
142: ; preds = %3
%143 = add i64 %2, -1
%144 = icmp eq i64 %2, 0
br i1 %144, label %343, label %145
145: ; preds = %142
%146 = getelementptr inbounds i8, i8* %1, i64 %143
%147 = getelementptr inbounds i8, i8* %0, i64 %143
%148 = icmp ult i64 %2, 4
br i1 %148, label %260, label %149
149: ; preds = %145
%150 = getelementptr i8, i8* %0, i64 %2
%151 = getelementptr i8, i8* %1, i64 %2
%152 = icmp ugt i8* %151, %0
%153 = icmp ugt i8* %150, %1
%154 = and i1 %152, %153
br i1 %154, label %260, label %155
155: ; preds = %149
%156 = icmp ult i64 %2, 16
br i1 %156, label %237, label %157
157: ; preds = %155
%158 = and i64 %2, -16
%159 = add i64 %158, -16
%160 = lshr exact i64 %159, 4
%161 = add nuw nsw i64 %160, 1
%162 = and i64 %161, 3
%163 = icmp ult i64 %159, 48
br i1 %163, label %208, label %164
164: ; preds = %157
%165 = and i64 %161, 2305843009213693948
%166 = getelementptr i8, i8* %146, i64 -15
%167 = getelementptr i8, i8* %147, i64 -15
%168 = getelementptr i8, i8* %146, i64 -15
%169 = getelementptr i8, i8* %147, i64 -15
%170 = getelementptr i8, i8* %146, i64 -15
%171 = getelementptr i8, i8* %147, i64 -15
%172 = getelementptr i8, i8* %146, i64 -15
%173 = getelementptr i8, i8* %147, i64 -15
br label %174
174: ; preds = %174, %164
%175 = phi i64 [ 0, %164 ], [ %205, %174 ]
%176 = phi i64 [ 0, %164 ], [ %206, %174 ]
%177 = sub i64 0, %175
%178 = sub i64 0, %175
%179 = getelementptr i8, i8* %166, i64 %177
%180 = bitcast i8* %179 to <16 x i8>*
%181 = load <16 x i8>, <16 x i8>* %180
%182 = getelementptr i8, i8* %167, i64 %178
%183 = bitcast i8* %182 to <16 x i8>*
store <16 x i8> %181, <16 x i8>* %183
%184 = sub nuw nsw i64 -16, %175
%185 = sub nuw nsw i64 -16, %175
%186 = getelementptr i8, i8* %168, i64 %184
%187 = bitcast i8* %186 to <16 x i8>*
%188 = load <16 x i8>, <16 x i8>* %187
%189 = getelementptr i8, i8* %169, i64 %185
%190 = bitcast i8* %189 to <16 x i8>*
store <16 x i8> %188, <16 x i8>* %190
%191 = sub nuw nsw i64 -32, %175
%192 = sub nuw nsw i64 -32, %175
%193 = getelementptr i8, i8* %170, i64 %191
%194 = bitcast i8* %193 to <16 x i8>*
%195 = load <16 x i8>, <16 x i8>* %194
%196 = getelementptr i8, i8* %171, i64 %192
%197 = bitcast i8* %196 to <16 x i8>*
store <16 x i8> %195, <16 x i8>* %197
%198 = sub nuw nsw i64 -48, %175
%199 = sub nuw nsw i64 -48, %175
%200 = getelementptr i8, i8* %172, i64 %198
%201 = bitcast i8* %200 to <16 x i8>*
%202 = load <16 x i8>, <16 x i8>* %201
%203 = getelementptr i8, i8* %173, i64 %199
%204 = bitcast i8* %203 to <16 x i8>*
store <16 x i8> %202, <16 x i8>* %204
%205 = add nuw i64 %175, 64
%206 = add i64 %176, 4
%207 = icmp eq i64 %206, %165
br i1 %207, label %208, label %174
208: ; preds = %174, %157
%209 = phi i64 [ 0, %157 ], [ %205, %174 ]
%210 = icmp eq i64 %162, 0
br i1 %210, label %227, label %211
211: ; preds = %208
%212 = getelementptr i8, i8* %146, i64 -15
%213 = getelementptr i8, i8* %147, i64 -15
br label %214
214: ; preds = %214, %211
%215 = phi i64 [ %209, %211 ], [ %224, %214 ]
%216 = phi i64 [ 0, %211 ], [ %225, %214 ]
%217 = sub i64 0, %215
%218 = sub i64 0, %215
%219 = getelementptr i8, i8* %212, i64 %217
%220 = bitcast i8* %219 to <16 x i8>*
%221 = load <16 x i8>, <16 x i8>* %220
%222 = getelementptr i8, i8* %213, i64 %218
%223 = bitcast i8* %222 to <16 x i8>*
store <16 x i8> %221, <16 x i8>* %223
%224 = add nuw i64 %215, 16
%225 = add i64 %216, 1
%226 = icmp eq i64 %225, %162
br i1 %226, label %227, label %214
227: ; preds = %214, %208
%228 = icmp eq i64 %158, %2
br i1 %228, label %343, label %229
229: ; preds = %227
%230 = and i64 %2, 15
%231 = sub i64 0, %158
%232 = getelementptr i8, i8* %147, i64 %231
%233 = sub i64 0, %158
%234 = getelementptr i8, i8* %146, i64 %233
%235 = and i64 %2, 12
%236 = icmp eq i64 %235, 0
br i1 %236, label %260, label %237
237: ; preds = %155, %229
%238 = phi i64 [ %158, %229 ], [ 0, %155 ]
%239 = and i64 %2, -4
%240 = sub i64 0, %239
%241 = getelementptr i8, i8* %146, i64 %240
%242 = sub i64 0, %239
%243 = getelementptr i8, i8* %147, i64 %242
%244 = and i64 %2, 3
%245 = getelementptr i8, i8* %146, i64 -3
%246 = getelementptr i8, i8* %147, i64 -3
br label %247
247: ; preds = %247, %237
%248 = phi i64 [ %238, %237 ], [ %256, %247 ]
%249 = sub i64 0, %248
%250 = sub i64 0, %248
%251 = getelementptr i8, i8* %245, i64 %249
%252 = bitcast i8* %251 to <4 x i8>*
%253 = load <4 x i8>, <4 x i8>* %252
%254 = getelementptr i8, i8* %246, i64 %250
%255 = bitcast i8* %254 to <4 x i8>*
store <4 x i8> %253, <4 x i8>* %255
%256 = add nuw i64 %248, 4
%257 = icmp eq i64 %256, %239
br i1 %257, label %258, label %247
258: ; preds = %247
%259 = icmp eq i64 %239, %2
br i1 %259, label %343, label %260
260: ; preds = %149, %145, %229, %258
%261 = phi i8* [ %146, %145 ], [ %146, %149 ], [ %234, %229 ], [ %241, %258 ]
%262 = phi i8* [ %147, %145 ], [ %147, %149 ], [ %232, %229 ], [ %243, %258 ]
%263 = phi i64 [ %2, %145 ], [ %2, %149 ], [ %230, %229 ], [ %244, %258 ]
%264 = add i64 %263, -1
%265 = and i64 %263, 7
%266 = icmp eq i64 %265, 0
br i1 %266, label %278, label %267
267: ; preds = %260, %267
%268 = phi i8* [ %273, %267 ], [ %261, %260 ]
%269 = phi i8* [ %275, %267 ], [ %262, %260 ]
%270 = phi i64 [ %272, %267 ], [ %263, %260 ]
%271 = phi i64 [ %276, %267 ], [ 0, %260 ]
%272 = add i64 %270, -1
%273 = getelementptr inbounds i8, i8* %268, i64 -1
%274 = load i8, i8* %268
%275 = getelementptr inbounds i8, i8* %269, i64 -1
store i8 %274, i8* %269
%276 = add i64 %271, 1
%277 = icmp eq i64 %276, %265
br i1 %277, label %278, label %267
278: ; preds = %267, %260
%279 = phi i8* [ %261, %260 ], [ %273, %267 ]
%280 = phi i8* [ %262, %260 ], [ %275, %267 ]
%281 = phi i64 [ %263, %260 ], [ %272, %267 ]
%282 = icmp ult i64 %264, 7
br i1 %282, label %343, label %283
283: ; preds = %278, %283
%284 = phi i8* [ %309, %283 ], [ %279, %278 ]
%285 = phi i8* [ %311, %283 ], [ %280, %278 ]
%286 = phi i64 [ %308, %283 ], [ %281, %278 ]
%287 = getelementptr inbounds i8, i8* %284, i64 -1
%288 = load i8, i8* %284
%289 = getelementptr inbounds i8, i8* %285, i64 -1
store i8 %288, i8* %285
%290 = getelementptr inbounds i8, i8* %284, i64 -2
%291 = load i8, i8* %287
%292 = getelementptr inbounds i8, i8* %285, i64 -2
store i8 %291, i8* %289
%293 = getelementptr inbounds i8, i8* %284, i64 -3
%294 = load i8, i8* %290
%295 = getelementptr inbounds i8, i8* %285, i64 -3
store i8 %294, i8* %292
%296 = getelementptr inbounds i8, i8* %284, i64 -4
%297 = load i8, i8* %293
%298 = getelementptr inbounds i8, i8* %285, i64 -4
store i8 %297, i8* %295
%299 = getelementptr inbounds i8, i8* %284, i64 -5
%300 = load i8, i8* %296
%301 = getelementptr inbounds i8, i8* %285, i64 -5
store i8 %300, i8* %298
%302 = getelementptr inbounds i8, i8* %284, i64 -6
%303 = load i8, i8* %299
%304 = getelementptr inbounds i8, i8* %285, i64 -6
store i8 %303, i8* %301
%305 = getelementptr inbounds i8, i8* %284, i64 -7
%306 = load i8, i8* %302
%307 = getelementptr inbounds i8, i8* %285, i64 -7
store i8 %306, i8* %304
%308 = add i64 %286, -8
%309 = getelementptr inbounds i8, i8* %284, i64 -8
%310 = load i8, i8* %305
%311 = getelementptr inbounds i8, i8* %285, i64 -8
store i8 %310, i8* %307
%312 = icmp eq i64 %308, 0
br i1 %312, label %343, label %283
313: ; preds = %137, %313
%314 = phi i8* [ %339, %313 ], [ %138, %137 ]
%315 = phi i8* [ %341, %313 ], [ %139, %137 ]
%316 = phi i64 [ %338, %313 ], [ %140, %137 ]
%317 = getelementptr inbounds i8, i8* %314, i64 1
%318 = load i8, i8* %314
%319 = getelementptr inbounds i8, i8* %315, i64 1
store i8 %318, i8* %315
%320 = getelementptr inbounds i8, i8* %314, i64 2
%321 = load i8, i8* %317
%322 = getelementptr inbounds i8, i8* %315, i64 2
store i8 %321, i8* %319
%323 = getelementptr inbounds i8, i8* %314, i64 3
%324 = load i8, i8* %320
%325 = getelementptr inbounds i8, i8* %315, i64 3
store i8 %324, i8* %322
%326 = getelementptr inbounds i8, i8* %314, i64 4
%327 = load i8, i8* %323
%328 = getelementptr inbounds i8, i8* %315, i64 4
store i8 %327, i8* %325
%329 = getelementptr inbounds i8, i8* %314, i64 5
%330 = load i8, i8* %326
%331 = getelementptr inbounds i8, i8* %315, i64 5
store i8 %330, i8* %328
%332 = getelementptr inbounds i8, i8* %314, i64 6
%333 = load i8, i8* %329
%334 = getelementptr inbounds i8, i8* %315, i64 6
store i8 %333, i8* %331
%335 = getelementptr inbounds i8, i8* %314, i64 7
%336 = load i8, i8* %332
%337 = getelementptr inbounds i8, i8* %315, i64 7
store i8 %336, i8* %334
%338 = add i64 %316, -8
%339 = getelementptr inbounds i8, i8* %314, i64 8
%340 = load i8, i8* %335
%341 = getelementptr inbounds i8, i8* %315, i64 8
store i8 %340, i8* %337
%342 = icmp eq i64 %338, 0
br i1 %342, label %343, label %313
343: ; preds = %137, %313, %278, %283, %94, %117, %227, %258, %5, %142
ret i8* %0
}