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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
void *memmove(void *dst, const void *src, size_t acount) {
  char *d;
  const char *s;
  if (((int)src < (int)dst) && ((((int)src) + acount) > (int)dst)) {
    d = ((char *)dst) + acount - 1;
    s = ((char *)src) + acount - 1;
    while (acount--)
      *d-- = *s--;
  } else {
    d = dst;
    s = src;
    while (acount--)
      *d++ = *s++;
  }
  return dst;
}


x86 assembly (clang, -O0):
<memmove>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x8(%rbp),%rcx
cmp    %ecx,%eax
jge    119f <memmove+0x9f>
mov    -0x10(%rbp),%rax
cltq
add    -0x18(%rbp),%rax
mov    -0x8(%rbp),%rcx
movslq %ecx,%rcx
cmp    %rcx,%rax
jbe    119f <memmove+0x9f>
mov    -0x8(%rbp),%rax
add    -0x18(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
add    -0x18(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x18(%rbp)
cmp    $0x0,%rax
je     119a <memmove+0x9a>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x28(%rbp)
mov    (%rax),%cl
mov    -0x20(%rbp),%rax
mov    %rax,%rdx
add    $0xffffffffffffffff,%rdx
mov    %rdx,-0x20(%rbp)
mov    %cl,(%rax)
jmp    115a <memmove+0x5a>
jmp    11f4 <memmove+0xf4>
mov    -0x8(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x18(%rbp)
cmp    $0x0,%rax
je     11ef <memmove+0xef>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x28(%rbp)
mov    (%rax),%cl
mov    -0x20(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x20(%rbp)
mov    %cl,(%rax)
jmp    11af <memmove+0xaf>
jmp    11f4 <memmove+0xf4>
mov    -0x8(%rbp),%rax
pop    %rbp
ret

x86 assembly (clang, -O2):
<memmove>:
push   %rbp
push   %r14
push   %rbx
mov    %rdi,%rax
cmp    %eax,%esi
jge    11f6 <memmove+0xf6>
movslq %esi,%rcx
add    %rdx,%rcx
movslq %eax,%rdi
cmp    %rdi,%rcx
jbe    11f6 <memmove+0xf6>
test   %rdx,%rdx
je     12bf <memmove+0x1bf>
lea    (%rsi,%rdx,1),%r9
lea    (%rax,%rdx,1),%r8
cmp    $0x4,%rdx
jb     114a <memmove+0x4a>
cmp    %rax,%r9
jbe    12f9 <memmove+0x1f9>
cmp    %rsi,%r8
jbe    12f9 <memmove+0x1f9>
mov    %r9,%rsi
mov    %r8,%rdi
mov    %rdx,%r10
lea    -0x1(%r10),%r8
mov    %r10,%rdx
and    $0x7,%rdx
je     118b <memmove+0x8b>
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl -0x1(%rsi),%ebx
add    $0xffffffffffffffff,%rsi
mov    %bl,-0x1(%rdi)
add    $0xffffffffffffffff,%rdi
add    $0x1,%rcx
cmp    %rcx,%rdx
jne    1170 <memmove+0x70>
sub    %rcx,%r10
cmp    $0x7,%r8
jb     12bf <memmove+0x1bf>
neg    %r10
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
movzbl -0x1(%rsi,%rcx,1),%edx
mov    %dl,-0x1(%rdi,%rcx,1)
movzbl -0x2(%rsi,%rcx,1),%edx
mov    %dl,-0x2(%rdi,%rcx,1)
movzbl -0x3(%rsi,%rcx,1),%edx
mov    %dl,-0x3(%rdi,%rcx,1)
movzbl -0x4(%rsi,%rcx,1),%edx
mov    %dl,-0x4(%rdi,%rcx,1)
movzbl -0x5(%rsi,%rcx,1),%edx
mov    %dl,-0x5(%rdi,%rcx,1)
movzbl -0x6(%rsi,%rcx,1),%edx
mov    %dl,-0x6(%rdi,%rcx,1)
movzbl -0x7(%rsi,%rcx,1),%edx
mov    %dl,-0x7(%rdi,%rcx,1)
movzbl -0x8(%rsi,%rcx,1),%edx
mov    %dl,-0x8(%rdi,%rcx,1)
add    $0xfffffffffffffff8,%rcx
cmp    %rcx,%r10
jne    11a0 <memmove+0xa0>
jmp    12bf <memmove+0x1bf>
test   %rdx,%rdx
je     12bf <memmove+0x1bf>
cmp    $0x8,%rdx
jb     121f <memmove+0x11f>
lea    (%rsi,%rdx,1),%rcx
cmp    %rax,%rcx
jbe    12c4 <memmove+0x1c4>
lea    (%rax,%rdx,1),%rcx
cmp    %rsi,%rcx
jbe    12c4 <memmove+0x1c4>
mov    %rsi,%rdi
mov    %rax,%rcx
mov    %rdx,%r9
lea    -0x1(%r9),%rbp
mov    %r9,%rbx
and    $0x7,%rbx
je     1259 <memmove+0x159>
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movzbl (%rdi,%rsi,1),%edx
mov    %dl,(%rcx,%rsi,1)
add    $0x1,%rsi
cmp    %rsi,%rbx
jne    1240 <memmove+0x140>
add    %rsi,%rdi
add    %rsi,%rcx
sub    %rsi,%r9
cmp    $0x7,%rbp
jb     12bf <memmove+0x1bf>
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    1270 <memmove+0x170>
pop    %rbx
pop    %r14
pop    %rbp
ret
cmp    $0x20,%rdx
jae    12d2 <memmove+0x1d2>
xor    %r8d,%r8d
jmp    13b9 <memmove+0x2b9>
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    130a <memmove+0x20a>
xor    %ecx,%ecx
jmp    1368 <memmove+0x268>
cmp    $0x10,%rdx
jae    13ef <memmove+0x2ef>
xor    %ecx,%ecx
jmp    14c3 <memmove+0x3c3>
and    $0xfffffffffffffffc,%rdi
xor    %ecx,%ecx
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    1310 <memmove+0x210>
test   %r9,%r9
je     13ab <memmove+0x2ab>
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    1390 <memmove+0x290>
cmp    %rdx,%r8
je     12bf <memmove+0x1bf>
test   $0x18,%dl
je     1416 <memmove+0x316>
mov    %rdx,%rbx
and    $0xfffffffffffffff8,%rbx
lea    (%rsi,%rbx,1),%rdi
lea    (%rax,%rbx,1),%rcx
mov    %edx,%r9d
and    $0x7,%r9d
nop
mov    (%rsi,%r8,1),%rbp
mov    %rbp,(%rax,%r8,1)
add    $0x8,%r8
cmp    %r8,%rbx
jne    13d0 <memmove+0x2d0>
cmp    %rdx,%rbx
jne    1228 <memmove+0x128>
jmp    12bf <memmove+0x1bf>
mov    %rdx,%rcx
and    $0xfffffffffffffff0,%rcx
lea    -0x10(%rcx),%rdi
mov    %rdi,%r11
shr    $0x4,%r11
add    $0x1,%r11
mov    %r11d,%r10d
and    $0x3,%r10d
cmp    $0x30,%rdi
jae    1428 <memmove+0x328>
xor    %edi,%edi
jmp    1477 <memmove+0x377>
and    $0x1f,%edx
lea    (%rax,%r8,1),%rcx
add    %r8,%rsi
mov    %rsi,%rdi
jmp    1225 <memmove+0x125>
and    $0xfffffffffffffffc,%r11
lea    -0x10(%r8),%r14
lea    -0x10(%r9),%rbx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
movups (%rbx,%rdi,1),%xmm0
movups %xmm0,(%r14,%rdi,1)
movups -0x10(%rbx,%rdi,1),%xmm0
movups %xmm0,-0x10(%r14,%rdi,1)
movups -0x20(%rbx,%rdi,1),%xmm0
movups %xmm0,-0x20(%r14,%rdi,1)
movups -0x30(%rbx,%rdi,1),%xmm0
movups %xmm0,-0x30(%r14,%rdi,1)
add    $0xffffffffffffffc0,%rdi
add    $0xfffffffffffffffc,%r11
jne    1440 <memmove+0x340>
neg    %rdi
test   %r10,%r10
je     14b5 <memmove+0x3b5>
mov    %rdx,%rbx
sub    %rdi,%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,%rdi
add    %rbx,%rdi
jne    14a0 <memmove+0x3a0>
cmp    %rdx,%rcx
je     12bf <memmove+0x1bf>
test   $0xc,%dl
je     1511 <memmove+0x411>
mov    %rdx,%r11
and    $0xfffffffffffffffc,%r11
mov    %r11,%rbx
neg    %rbx
mov    %r9,%rsi
sub    %r11,%rsi
mov    %r8,%rdi
sub    %r11,%rdi
mov    %edx,%r10d
and    $0x3,%r10d
neg    %rcx
cs nopw 0x0(%rax,%rax,1)
mov    -0x4(%r9,%rcx,1),%ebp
mov    %ebp,-0x4(%r8,%rcx,1)
add    $0xfffffffffffffffc,%rcx
cmp    %rcx,%rbx
jne    14f0 <memmove+0x3f0>
cmp    %rdx,%r11
jne    1153 <memmove+0x53>
jmp    12bf <memmove+0x1bf>
and    $0xf,%edx
sub    %rcx,%r8
sub    %rcx,%r9
jmp    114a <memmove+0x4a>

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

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