#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 *vdest, const void *vsrc, size_t count) {
  const char *src = vsrc;
  char *dest = vdest;
  if (dest <= src) {
    while (count--) {
      *dest++ = *src++;
    }
  } else {
    src += count - 1;
    dest += count - 1;
    while (count--) {
      *dest-- = *src--;
    }
  }
  return vdest;
}


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
ja     1178 <memmove+0x78>
jmp    1133 <memmove+0x33>
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x18(%rbp)
cmp    $0x0,%rax
je     1173 <memmove+0x73>
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)
jmp    1133 <memmove+0x33>
jmp    11dd <memmove+0xdd>
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)
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x18(%rbp)
cmp    $0x0,%rax
je     11d8 <memmove+0xd8>
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)
jmp    1198 <memmove+0x98>
jmp    11dd <memmove+0xdd>
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    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 (%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>
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    %rax,%rdi
mov    %rsi,%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 (%rcx,%rsi,1),%edx
mov    %dl,(%rdi,%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 (%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    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    (%rsi,%rcx,1),%rdi
add    $0x10,%rdi
add    %rax,%rcx
add    $0x10,%rcx
shl    $0x5,%r9
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups -0x10(%rdi,%rbx,1),%xmm0
movups (%rdi,%rbx,1),%xmm1
movups %xmm0,-0x10(%rcx,%rbx,1)
movups %xmm1,(%rcx,%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    (%rax,%r10,1),%rdi
lea    (%rsi,%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 (%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    1430 <memmove+0x330>
neg    %rcx
test   %r10,%r10
je     14a5 <memmove+0x3a5>
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    1490 <memmove+0x390>
cmp    %rdx,%rdi
je     12af <memmove+0x1af>
test   $0xc,%dl
je     1512 <memmove+0x412>
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(%r9,%rdi,1),%ebp
mov    %ebp,-0x3(%r8,%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
add    %r8,%rsi
add    %rax,%r8
mov    %r8,%rdi
jmp    1210 <memmove+0x110>
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*
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 ule i8* %11, %12
br i1 %13, label %14, label %26
14: ; preds = %3
br label %15
15: ; preds = %19, %14
%16 = load i64, i64* %6
%17 = add i64 %16, -1
store i64 %17, i64* %6
%18 = icmp ne i64 %16, 0
br i1 %18, label %19, label %25
19: ; preds = %15
%20 = load i8*, i8** %7
%21 = getelementptr inbounds i8, i8* %20, i32 1
store i8* %21, i8** %7
%22 = load i8, i8* %20
%23 = load i8*, i8** %8
%24 = getelementptr inbounds i8, i8* %23, i32 1
store i8* %24, i8** %8
store i8 %22, i8* %23
br label %15
25: ; preds = %15
br label %46
26: ; preds = %3
%27 = load i64, i64* %6
%28 = sub i64 %27, 1
%29 = load i8*, i8** %7
%30 = getelementptr inbounds i8, i8* %29, i64 %28
store i8* %30, i8** %7
%31 = load i64, i64* %6
%32 = sub i64 %31, 1
%33 = load i8*, i8** %8
%34 = getelementptr inbounds i8, i8* %33, i64 %32
store i8* %34, i8** %8
br label %35
35: ; preds = %39, %26
%36 = load i64, i64* %6
%37 = add i64 %36, -1
store i64 %37, i64* %6
%38 = icmp ne i64 %36, 0
br i1 %38, label %39, label %45
39: ; preds = %35
%40 = load i8*, i8** %7
%41 = getelementptr inbounds i8, i8* %40, i32 -1
store i8* %41, i8** %7
%42 = load i8, i8* %40
%43 = load i8*, i8** %8
%44 = getelementptr inbounds i8, i8* %43, i32 -1
store i8* %44, i8** %8
store i8 %42, i8* %43
br label %35
45: ; preds = %35
br label %46
46: ; preds = %45, %25
%47 = load i8*, i8** %4
ret i8* %47
}

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