#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 *memcpy(void *, void const *, size_t);
void *memmove(void *s1, const void *s2, size_t n) {
  const void *lasts;
  void *lastd;
  void *retval;
  if (n == 0) {
    return s1;
  }
  lasts = s2 + (n - 1);
  lastd = s1 + (n - 1);
  if (((s1 < s2) || (s1 > lasts)) && ((lastd < s2) || (lastd > lasts)))
    return memcpy(s1, s2, n);
  retval = s1;
  if (s1 < s2)
    while (n--)
      *(char *)s1++ = *(char *)s2++;
  else
    while (n--)
      *(char *)lastd-- = *(char *)lasts--;
  return retval;
}


x86 assembly (clang, -O0):
<memmove>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
cmpq   $0x0,-0x20(%rbp)
jne    113c <memmove+0x2c>
mov    -0x10(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    126e <memmove+0x15e>
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%rcx
sub    $0x1,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
sub    $0x1,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x10(%rbp),%rax
cmp    -0x18(%rbp),%rax
jb     117e <memmove+0x6e>
mov    -0x10(%rbp),%rax
cmp    -0x28(%rbp),%rax
jbe    11bc <memmove+0xac>
mov    -0x30(%rbp),%rax
cmp    -0x18(%rbp),%rax
jb     119a <memmove+0x8a>
mov    -0x30(%rbp),%rax
cmp    -0x28(%rbp),%rax
jbe    11bc <memmove+0xac>
mov    -0x10(%rbp),%rdi
mov    %rdi,-0x40(%rbp)
mov    -0x18(%rbp),%rsi
mov    -0x20(%rbp),%rdx
call   1030 <memcpy@plt>
mov    -0x40(%rbp),%rax
mov    %rax,-0x8(%rbp)
jmp    126e <memmove+0x15e>
mov    -0x10(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
cmp    -0x18(%rbp),%rax
jae    121c <memmove+0x10c>
jmp    11d7 <memmove+0xc7>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x20(%rbp)
cmp    $0x0,%rax
je     1217 <memmove+0x107>
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x18(%rbp)
mov    (%rax),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,(%rax)
jmp    11d7 <memmove+0xc7>
jmp    1266 <memmove+0x156>
jmp    1221 <memmove+0x111>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x20(%rbp)
cmp    $0x0,%rax
je     1261 <memmove+0x151>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x28(%rbp)
mov    (%rax),%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0xffffffffffffffff,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
jmp    1221 <memmove+0x111>
jmp    1266 <memmove+0x156>
mov    -0x38(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<memmove>:
push   %r14
push   %rbx
push   %rax
mov    %rdi,%r14
test   %rdx,%rdx
je     12d9 <memmove+0x1c9>
lea    (%rsi,%rdx,1),%r9
add    $0xffffffffffffffff,%r9
lea    (%r14,%rdx,1),%r8
add    $0xffffffffffffffff,%r8
cmp    %rsi,%r14
jb     113a <memmove+0x2a>
cmp    %r14,%r9
jae    114c <memmove+0x3c>
cmp    %rsi,%r14
ja     12d1 <memmove+0x1c1>
cmp    %rsi,%r8
jb     12d1 <memmove+0x1c1>
cmp    %rsi,%r14
jae    1214 <memmove+0x104>
cmp    $0x8,%rdx
jb     1175 <memmove+0x65>
lea    (%rsi,%rdx,1),%rax
cmp    %r14,%rax
jbe    12e4 <memmove+0x1d4>
lea    (%r14,%rdx,1),%rax
cmp    %rsi,%rax
jbe    12e4 <memmove+0x1d4>
mov    %rdx,%r8
mov    %rsi,%rbx
mov    %r14,%rdi
lea    -0x1(%r8),%rsi
mov    %r8,%rdx
and    $0x7,%rdx
je     11a9 <memmove+0x99>
xor    %ecx,%ecx
nopl   (%rax)
movzbl (%rbx,%rcx,1),%eax
mov    %al,(%rdi,%rcx,1)
add    $0x1,%rcx
cmp    %rcx,%rdx
jne    1190 <memmove+0x80>
sub    %rcx,%r8
add    %rcx,%rbx
add    %rcx,%rdi
cmp    $0x7,%rsi
jb     12d9 <memmove+0x1c9>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nop
movzbl (%rbx,%rax,1),%ecx
mov    %cl,(%rdi,%rax,1)
movzbl 0x1(%rbx,%rax,1),%ecx
mov    %cl,0x1(%rdi,%rax,1)
movzbl 0x2(%rbx,%rax,1),%ecx
mov    %cl,0x2(%rdi,%rax,1)
movzbl 0x3(%rbx,%rax,1),%ecx
mov    %cl,0x3(%rdi,%rax,1)
movzbl 0x4(%rbx,%rax,1),%ecx
mov    %cl,0x4(%rdi,%rax,1)
movzbl 0x5(%rbx,%rax,1),%ecx
mov    %cl,0x5(%rdi,%rax,1)
movzbl 0x6(%rbx,%rax,1),%ecx
mov    %cl,0x6(%rdi,%rax,1)
movzbl 0x7(%rbx,%rax,1),%ecx
mov    %cl,0x7(%rdi,%rax,1)
add    $0x8,%rax
cmp    %rax,%r8
jne    11c0 <memmove+0xb0>
jmp    12d9 <memmove+0x1c9>
cmp    $0x4,%rdx
jb     1234 <memmove+0x124>
lea    (%rsi,%rdx,1),%rax
cmp    %r14,%rax
jbe    12f1 <memmove+0x1e1>
lea    (%r14,%rdx,1),%rax
cmp    %rsi,%rax
jbe    12f1 <memmove+0x1e1>
mov    %r8,%rsi
mov    %r9,%rax
mov    %rdx,%rcx
lea    -0x1(%rcx),%r8
mov    %rcx,%rdi
and    $0x7,%rdi
je     1269 <memmove+0x159>
xor    %ebx,%ebx
nopl   0x0(%rax)
movzbl (%rax),%edx
add    $0xffffffffffffffff,%rax
mov    %dl,(%rsi)
add    $0xffffffffffffffff,%rsi
add    $0x1,%rbx
cmp    %rbx,%rdi
jne    1250 <memmove+0x140>
sub    %rbx,%rcx
cmp    $0x7,%r8
jb     12d9 <memmove+0x1c9>
neg    %rcx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzbl (%rax,%rdx,1),%ebx
mov    %bl,(%rsi,%rdx,1)
movzbl -0x1(%rax,%rdx,1),%ebx
mov    %bl,-0x1(%rsi,%rdx,1)
movzbl -0x2(%rax,%rdx,1),%ebx
mov    %bl,-0x2(%rsi,%rdx,1)
movzbl -0x3(%rax,%rdx,1),%ebx
mov    %bl,-0x3(%rsi,%rdx,1)
movzbl -0x4(%rax,%rdx,1),%ebx
mov    %bl,-0x4(%rsi,%rdx,1)
movzbl -0x5(%rax,%rdx,1),%ebx
mov    %bl,-0x5(%rsi,%rdx,1)
movzbl -0x6(%rax,%rdx,1),%ebx
mov    %bl,-0x6(%rsi,%rdx,1)
movzbl -0x7(%rax,%rdx,1),%ebx
mov    %bl,-0x7(%rsi,%rdx,1)
add    $0xfffffffffffffff8,%rdx
cmp    %rdx,%rcx
jne    1280 <memmove+0x170>
jmp    12d9 <memmove+0x1c9>
mov    %r14,%rdi
call   1030 <memcpy@plt>
mov    %r14,%rax
add    $0x8,%rsp
pop    %rbx
pop    %r14
ret
cmp    $0x20,%rdx
jae    12fe <memmove+0x1ee>
xor    %eax,%eax
jmp    140d <memmove+0x2fd>
cmp    $0x10,%rdx
jae    1328 <memmove+0x218>
xor    %edi,%edi
jmp    14e2 <memmove+0x3d2>
mov    %rdx,%rax
and    $0xffffffffffffffe0,%rax
lea    -0x20(%rax),%rcx
mov    %rcx,%rdi
shr    $0x5,%rdi
add    $0x1,%rdi
mov    %edi,%r8d
and    $0x3,%r8d
cmp    $0x60,%rcx
jae    1356 <memmove+0x246>
xor    %ebx,%ebx
jmp    13c0 <memmove+0x2b0>
mov    %rdx,%rdi
and    $0xfffffffffffffff0,%rdi
lea    -0x10(%rdi),%rax
mov    %rax,%rcx
shr    $0x4,%rcx
add    $0x1,%rcx
mov    %ecx,%r10d
and    $0x3,%r10d
cmp    $0x30,%rax
jae    144f <memmove+0x33f>
xor    %ebx,%ebx
jmp    1497 <memmove+0x387>
and    $0xfffffffffffffffc,%rdi
xor    %ebx,%ebx
nopl   0x0(%rax)
movups (%rsi,%rbx,1),%xmm0
movups 0x10(%rsi,%rbx,1),%xmm1
movups %xmm0,(%r14,%rbx,1)
movups %xmm1,0x10(%r14,%rbx,1)
movups 0x20(%rsi,%rbx,1),%xmm0
movups 0x30(%rsi,%rbx,1),%xmm1
movups %xmm0,0x20(%r14,%rbx,1)
movups %xmm1,0x30(%r14,%rbx,1)
movups 0x40(%rsi,%rbx,1),%xmm0
movups 0x50(%rsi,%rbx,1),%xmm1
movups %xmm0,0x40(%r14,%rbx,1)
movups %xmm1,0x50(%r14,%rbx,1)
movups 0x60(%rsi,%rbx,1),%xmm0
movups 0x70(%rsi,%rbx,1),%xmm1
movups %xmm0,0x60(%r14,%rbx,1)
movups %xmm1,0x70(%r14,%rbx,1)
sub    $0xffffffffffffff80,%rbx
add    $0xfffffffffffffffc,%rdi
jne    1360 <memmove+0x250>
test   %r8,%r8
je     13fb <memmove+0x2eb>
lea    (%r14,%rbx,1),%rdi
add    $0x10,%rdi
add    %rsi,%rbx
add    $0x10,%rbx
shl    $0x5,%r8
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
movups -0x10(%rbx,%rcx,1),%xmm0
movups (%rbx,%rcx,1),%xmm1
movups %xmm0,-0x10(%rdi,%rcx,1)
movups %xmm1,(%rdi,%rcx,1)
add    $0x20,%rcx
cmp    %rcx,%r8
jne    13e0 <memmove+0x2d0>
cmp    %rdx,%rax
je     12d9 <memmove+0x1c9>
test   $0x18,%dl
je     1531 <memmove+0x421>
mov    %rdx,%r9
and    $0xfffffffffffffff8,%r9
mov    %edx,%r8d
and    $0x7,%r8d
lea    (%rsi,%r9,1),%rbx
lea    (%r14,%r9,1),%rdi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%rsi,%rax,1),%rcx
mov    %rcx,(%r14,%rax,1)
add    $0x8,%rax
cmp    %rax,%r9
jne    1430 <memmove+0x320>
cmp    %rdx,%r9
jne    117e <memmove+0x6e>
jmp    12d9 <memmove+0x1c9>
and    $0xfffffffffffffffc,%rcx
lea    -0xf(%r8),%r11
lea    -0xf(%r9),%rax
xor    %ebx,%ebx
nopl   (%rax)
movups (%rax,%rbx,1),%xmm0
movups %xmm0,(%r11,%rbx,1)
movups -0x10(%rax,%rbx,1),%xmm0
movups %xmm0,-0x10(%r11,%rbx,1)
movups -0x20(%rax,%rbx,1),%xmm0
movups %xmm0,-0x20(%r11,%rbx,1)
movups -0x30(%rax,%rbx,1),%xmm0
movups %xmm0,-0x30(%r11,%rbx,1)
add    $0xffffffffffffffc0,%rbx
add    $0xfffffffffffffffc,%rcx
jne    1460 <memmove+0x350>
neg    %rbx
test   %r10,%r10
je     14d4 <memmove+0x3c4>
mov    %rdx,%rcx
sub    %rbx,%rcx
lea    (%rsi,%rcx,1),%rax
add    $0xfffffffffffffff0,%rax
add    %r14,%rcx
add    $0xfffffffffffffff0,%rcx
shl    $0x4,%r10
xor    %esi,%esi
nopw   0x0(%rax,%rax,1)
movups (%rax,%rsi,1),%xmm0
movups %xmm0,(%rcx,%rsi,1)
add    $0xfffffffffffffff0,%rsi
mov    %r10,%rbx
add    %rsi,%rbx
jne    14c0 <memmove+0x3b0>
cmp    %rdx,%rdi
je     12d9 <memmove+0x1c9>
test   $0xc,%dl
je     1546 <memmove+0x436>
mov    %rdx,%r10
and    $0xfffffffffffffffc,%r10
mov    %r10,%r11
neg    %r11
mov    %r8,%rsi
sub    %r10,%rsi
mov    %r9,%rax
sub    %r10,%rax
mov    %edx,%ecx
and    $0x3,%ecx
neg    %rdi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    -0x3(%r9,%rdi,1),%ebx
mov    %ebx,-0x3(%r8,%rdi,1)
add    $0xfffffffffffffffc,%rdi
cmp    %rdi,%r11
jne    1510 <memmove+0x400>
cmp    %rdx,%r10
jne    123d <memmove+0x12d>
jmp    12d9 <memmove+0x1c9>
lea    (%r14,%rax,1),%rdi
add    %rax,%rsi
and    $0x1f,%edx
mov    %rdx,%r8
mov    %rsi,%rbx
jmp    117e <memmove+0x6e>
and    $0xf,%edx
sub    %rdi,%r9
sub    %rdi,%r8
jmp    1234 <memmove+0x124>

LLVM IR (-O0):
define i8* @memmove(i8* %0, i8* %1, i64 %2) {
%4 = alloca i8*
%5 = alloca i8*
%6 = alloca i8*
%7 = alloca i64
%8 = alloca i8*
%9 = alloca i8*
%10 = alloca i8*
store i8* %0, i8** %5
store i8* %1, i8** %6
store i64 %2, i64* %7
%11 = load i64, i64* %7
%12 = icmp eq i64 %11, 0
br i1 %12, label %13, label %15
13: ; preds = %3
%14 = load i8*, i8** %5
store i8* %14, i8** %4
br label %74
15: ; preds = %3
%16 = load i8*, i8** %6
%17 = load i64, i64* %7
%18 = sub i64 %17, 1
%19 = getelementptr i8, i8* %16, i64 %18
store i8* %19, i8** %8
%20 = load i8*, i8** %5
%21 = load i64, i64* %7
%22 = sub i64 %21, 1
%23 = getelementptr i8, i8* %20, i64 %22
store i8* %23, i8** %9
%24 = load i8*, i8** %5
%25 = load i8*, i8** %6
%26 = icmp ult i8* %24, %25
br i1 %26, label %31, label %27
27: ; preds = %15
%28 = load i8*, i8** %5
%29 = load i8*, i8** %8
%30 = icmp ugt i8* %28, %29
br i1 %30, label %31, label %43
31: ; preds = %27, %15
%32 = load i8*, i8** %9
%33 = load i8*, i8** %6
%34 = icmp ult i8* %32, %33
br i1 %34, label %39, label %35
35: ; preds = %31
%36 = load i8*, i8** %9
%37 = load i8*, i8** %8
%38 = icmp ugt i8* %36, %37
br i1 %38, label %39, label %43
39: ; preds = %35, %31
%40 = load i8*, i8** %5
%41 = load i8*, i8** %6
%42 = load i64, i64* %7
store i8* %40, i8** %4
br label %74
43: ; preds = %35, %27
%44 = load i8*, i8** %5
store i8* %44, i8** %10
%45 = load i8*, i8** %5
%46 = load i8*, i8** %6
%47 = icmp ult i8* %45, %46
br i1 %47, label %48, label %60
48: ; preds = %43
br label %49
49: ; preds = %53, %48
%50 = load i64, i64* %7
%51 = add i64 %50, -1
store i64 %51, i64* %7
%52 = icmp ne i64 %50, 0
br i1 %52, label %53, label %59
53: ; preds = %49
%54 = load i8*, i8** %6
%55 = getelementptr inbounds i8, i8* %54, i32 1
store i8* %55, i8** %6
%56 = load i8, i8* %54
%57 = load i8*, i8** %5
%58 = getelementptr inbounds i8, i8* %57, i32 1
store i8* %58, i8** %5
store i8 %56, i8* %57
br label %49
59: ; preds = %49
br label %72
60: ; preds = %43
br label %61
61: ; preds = %65, %60
%62 = load i64, i64* %7
%63 = add i64 %62, -1
store i64 %63, i64* %7
%64 = icmp ne i64 %62, 0
br i1 %64, label %65, label %71
65: ; preds = %61
%66 = load i8*, i8** %8
%67 = getelementptr inbounds i8, i8* %66, i32 -1
store i8* %67, i8** %8
%68 = load i8, i8* %66
%69 = load i8*, i8** %9
%70 = getelementptr inbounds i8, i8* %69, i32 -1
store i8* %70, i8** %9
store i8 %68, i8* %69
br label %61
71: ; preds = %61
br label %72
72: ; preds = %71, %59
%73 = load i8*, i8** %10
store i8* %73, i8** %4
br label %74
74: ; preds = %72, %39, %13
%75 = load i8*, i8** %4
ret i8* %75
}

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