#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 */
typedef int uint;

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


x86 assembly (clang, -O0):
<memmove>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%rax
cmp    -0x28(%rbp),%rax
jae    11a6 <memmove+0xa6>
mov    -0x20(%rbp),%rax
movslq -0x14(%rbp),%rcx
add    %rcx,%rax
cmp    -0x28(%rbp),%rax
jbe    11a6 <memmove+0xa6>
mov    -0x14(%rbp),%ecx
mov    -0x20(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x28(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x14(%rbp)
cmp    $0x0,%eax
jle    11a1 <memmove+0xa1>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x20(%rbp)
mov    -0x1(%rax),%cl
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0xffffffffffffffff,%rdx
mov    %rdx,-0x28(%rbp)
mov    %cl,-0x1(%rax)
jmp    1164 <memmove+0x64>
jmp    11eb <memmove+0xeb>
jmp    11ab <memmove+0xab>
mov    -0x14(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x14(%rbp)
cmp    $0x0,%eax
jle    11e6 <memmove+0xe6>
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    11ab <memmove+0xab>
jmp    11eb <memmove+0xeb>
mov    -0x8(%rbp),%rax
pop    %rbp
ret

x86 assembly (clang, -O2):
<memmove>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %rdi,%rax
cmp    %rdi,%rsi
jae    1187 <memmove+0x87>
movslq %edx,%r12
lea    (%rsi,%r12,1),%r15
cmp    %rax,%r15
jbe    1187 <memmove+0x87>
test   %edx,%edx
jle    11d3 <memmove+0xd3>
lea    (%rax,%r12,1),%r9
lea    -0x1(%rdx),%r8d
cmp    $0x3,%r8d
jb     1156 <memmove+0x56>
mov    %r8,%rcx
not    %rcx
add    %r12,%rcx
lea    (%rax,%rcx,1),%rdi
cmp    %r15,%rdi
jae    1222 <memmove+0x122>
add    %rsi,%rcx
cmp    %r9,%rcx
jae    1222 <memmove+0x122>
mov    %r9,%rsi
mov    %r15,%rbp
add    $0x1,%edx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl -0x1(%rbp,%rcx,1),%ebx
mov    %bl,-0x1(%rsi,%rcx,1)
add    $0xffffffffffffffff,%rcx
lea    (%rdx,%rcx,1),%edi
cmp    $0x1,%edi
ja     1170 <memmove+0x70>
jmp    11d3 <memmove+0xd3>
test   %edx,%edx
jle    11d3 <memmove+0xd3>
lea    -0x1(%rdx),%r8d
cmp    $0x7,%r8d
jb     11af <memmove+0xaf>
lea    (%rsi,%r8,1),%rcx
add    $0x1,%rcx
cmp    %rax,%rcx
jbe    11de <memmove+0xde>
lea    (%rax,%r8,1),%rcx
add    $0x1,%rcx
cmp    %rsi,%rcx
jbe    11de <memmove+0xde>
mov    %rax,%rcx
mov    %rsi,%rdi
add    $0x1,%edx
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movzbl (%rdi,%rsi,1),%ebx
mov    %bl,(%rcx,%rsi,1)
add    $0x1,%rsi
add    $0xffffffff,%edx
cmp    $0x1,%edx
ja     11c0 <memmove+0xc0>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
movabs $0x1ffffffe0,%r10
cmp    $0x1f,%r8d
jae    11f5 <memmove+0xf5>
xor    %ebx,%ebx
jmp    12fa <memmove+0x1fa>
lea    0x1(%r8),%r9
mov    %r9,%rbx
and    %r10,%rbx
lea    -0x20(%rbx),%rcx
mov    %rcx,%rdi
shr    $0x5,%rdi
add    $0x1,%rdi
mov    %edi,%r11d
and    $0x3,%r11d
cmp    $0x60,%rcx
jae    1241 <memmove+0x141>
xor    %ecx,%ecx
jmp    12a8 <memmove+0x1a8>
lea    0x1(%r8),%r11
movabs $0x1ffffffe0,%r10
cmp    $0xf,%r8d
jae    132f <memmove+0x22f>
xor    %edi,%edi
jmp    1403 <memmove+0x303>
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    1250 <memmove+0x150>
test   %r11,%r11
je     12eb <memmove+0x1eb>
lea    (%rsi,%rcx,1),%rdi
add    $0x10,%rdi
add    %rax,%rcx
add    $0x10,%rcx
shl    $0x5,%r11
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups -0x10(%rdi,%rbp,1),%xmm0
movups (%rdi,%rbp,1),%xmm1
movups %xmm0,-0x10(%rcx,%rbp,1)
movups %xmm1,(%rcx,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%r11
jne    12d0 <memmove+0x1d0>
cmp    %rbx,%r9
je     11d3 <memmove+0xd3>
test   $0x18,%r9b
je     1356 <memmove+0x256>
add    $0x1,%r8
add    $0x18,%r10
and    %r8,%r10
lea    (%rax,%r10,1),%rcx
lea    (%rsi,%r10,1),%rdi
sub    %r10d,%edx
mov    (%rsi,%rbx,1),%rbp
mov    %rbp,(%rax,%rbx,1)
add    $0x8,%rbx
cmp    %rbx,%r10
jne    1310 <memmove+0x210>
cmp    %r10,%r8
jne    11b5 <memmove+0xb5>
jmp    11d3 <memmove+0xd3>
lea    0x10(%r10),%rdi
and    %r11,%rdi
lea    -0x10(%rdi),%rbx
mov    %rbx,%rcx
shr    $0x4,%rcx
add    $0x1,%rcx
mov    %ecx,%r14d
and    $0x3,%r14d
cmp    $0x30,%rbx
jae    1366 <memmove+0x266>
xor    %ebx,%ebx
jmp    13b9 <memmove+0x2b9>
sub    %ebx,%edx
add    %rbx,%rsi
add    %rax,%rbx
mov    %rbx,%rcx
jmp    11b2 <memmove+0xb2>
and    $0xfffffffffffffffc,%rcx
lea    -0x10(%r15),%r13
lea    -0x10(%r9),%rbp
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups 0x0(%r13,%rbx,1),%xmm0
movups %xmm0,0x0(%rbp,%rbx,1)
movups -0x10(%r13,%rbx,1),%xmm0
movups %xmm0,-0x10(%rbp,%rbx,1)
movups -0x20(%r13,%rbx,1),%xmm0
movups %xmm0,-0x20(%rbp,%rbx,1)
movups -0x30(%r13,%rbx,1),%xmm0
movups %xmm0,-0x30(%rbp,%rbx,1)
add    $0xffffffffffffffc0,%rbx
add    $0xfffffffffffffffc,%rcx
jne    1380 <memmove+0x280>
neg    %rbx
test   %r14,%r14
je     13f4 <memmove+0x2f4>
sub    %rbx,%r12
lea    (%rsi,%r12,1),%rcx
add    $0xfffffffffffffff0,%rcx
lea    (%rax,%r12,1),%rsi
add    $0xfffffffffffffff0,%rsi
shl    $0x4,%r14
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
movups (%rcx,%rbx,1),%xmm0
movups %xmm0,(%rsi,%rbx,1)
add    $0xfffffffffffffff0,%rbx
mov    %r14,%rbp
add    %rbx,%rbp
jne    13e0 <memmove+0x2e0>
cmp    %rdi,%r11
je     11d3 <memmove+0xd3>
test   $0xc,%r11b
je     1451 <memmove+0x351>
add    $0x1,%r8
add    $0x1c,%r10
and    %r8,%r10
mov    %r9,%rsi
sub    %r10,%rsi
mov    %r15,%rbp
sub    %r10,%rbp
sub    %r10d,%edx
neg    %rdi
and    $0xfffffffffffffffc,%r11
neg    %r11
nopw   0x0(%rax,%rax,1)
mov    -0x4(%r15,%rdi,1),%ecx
mov    %ecx,-0x4(%r9,%rdi,1)
add    $0xfffffffffffffffc,%rdi
cmp    %rdi,%r11
jne    1430 <memmove+0x330>
cmp    %r10,%r8
jne    115c <memmove+0x5c>
jmp    11d3 <memmove+0xd3>
sub    %edi,%edx
sub    %rdi,%r15
sub    %rdi,%r9
jmp    1156 <memmove+0x56>

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

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