#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 */
int /*<<< orphan*/ XIOdebug(char *, size_t);
void *memcpy(void *a, const void *b, size_t n) {
  if ((((int)a | (int)b | (int)n) & 3) == 0) {
    int *wa, *wb;
    n >>= 2;
    for (wa = (int *)a, wb = (int *)b; n-- > 0;)
      *wa++ = *wb++;
  } else {
    char *ca = (char *)a, *cb = (char *)b;
    int pdiff = cb - ca;
    XIOdebug("Copy %d bytes\n", n);
    for (; n-- > 0; ca++)
      ca[0] = ca[pdiff];
  }
  return a;
}


x86 assembly (clang, -O0):
<memcpy>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%rcx
or     %ecx,%eax
mov    -0x18(%rbp),%rcx
or     %ecx,%eax
and    $0x3,%eax
cmp    $0x0,%eax
jne    11a1 <memcpy+0x91>
mov    -0x18(%rbp),%rax
shr    $0x2,%rax
mov    %rax,-0x18(%rbp)
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
jbe    119c <memcpy+0x8c>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x28(%rbp)
mov    (%rax),%ecx
mov    -0x20(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x20(%rbp)
mov    %ecx,(%rax)
jmp    115c <memcpy+0x4c>
jmp    120f <memcpy+0xff>
mov    -0x8(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x30(%rbp),%rcx
sub    %rcx,%rax
mov    %eax,-0x3c(%rbp)
mov    -0x18(%rbp),%rsi
lea    0xe36(%rip),%rdi
call   1030 <XIOdebug@plt>
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x18(%rbp)
cmp    $0x0,%rax
jbe    120a <memcpy+0xfa>
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,1),%cl
mov    -0x30(%rbp),%rax
mov    %cl,(%rax)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    11cf <memcpy+0xbf>
jmp    120f <memcpy+0xff>
mov    -0x8(%rbp),%rax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<memcpy>:
push   %r15
push   %r14
push   %rbx
mov    %rdx,%r15
mov    %rsi,%rbx
mov    %rdi,%r14
mov    %ebx,%eax
or     %r14d,%eax
mov    %r15d,%ecx
or     %eax,%ecx
test   $0x3,%cl
je     1214 <memcpy+0x104>
lea    0xec8(%rip),%rdi
mov    %r15,%rsi
call   1030 <XIOdebug@plt>
test   %r15,%r15
je     14f0 <memcpy+0x3e0>
sub    %r14d,%ebx
movslq %ebx,%r8
cmp    $0x8,%r15
jb     1176 <memcpy+0x66>
lea    (%r8,%r15,1),%rax
add    %r14,%rax
cmp    %r14,%rax
jbe    12dc <memcpy+0x1cc>
lea    (%r14,%r15,1),%rax
lea    (%r14,%r8,1),%rcx
cmp    %rax,%rcx
jae    12dc <memcpy+0x1cc>
mov    %r15,%rdx
mov    %r14,%rsi
lea    -0x1(%rdx),%rcx
mov    %rdx,%rax
and    $0x7,%rax
je     11a5 <memcpy+0x95>
nopl   0x0(%rax)
add    $0xffffffffffffffff,%rdx
movzbl (%rsi,%r8,1),%ebx
mov    %bl,(%rsi)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rax
jne    1190 <memcpy+0x80>
cmp    $0x7,%rcx
jb     14f0 <memcpy+0x3e0>
lea    (%r8,%rsi,1),%rax
add    $0x7,%rax
xor    %ecx,%ecx
nopl   0x0(%rax)
movzbl -0x7(%rax,%rcx,1),%ebx
mov    %bl,(%rsi,%rcx,1)
movzbl -0x6(%rax,%rcx,1),%ebx
mov    %bl,0x1(%rsi,%rcx,1)
movzbl -0x5(%rax,%rcx,1),%ebx
mov    %bl,0x2(%rsi,%rcx,1)
movzbl -0x4(%rax,%rcx,1),%ebx
mov    %bl,0x3(%rsi,%rcx,1)
movzbl -0x3(%rax,%rcx,1),%ebx
mov    %bl,0x4(%rsi,%rcx,1)
movzbl -0x2(%rax,%rcx,1),%ebx
mov    %bl,0x5(%rsi,%rcx,1)
movzbl -0x1(%rax,%rcx,1),%ebx
mov    %bl,0x6(%rsi,%rcx,1)
movzbl (%rax,%rcx,1),%ebx
mov    %bl,0x7(%rsi,%rcx,1)
add    $0x8,%rcx
cmp    %rcx,%rdx
jne    11c0 <memcpy+0xb0>
jmp    14f0 <memcpy+0x3e0>
cmp    $0x4,%r15
jb     14f0 <memcpy+0x3e0>
mov    %r15,%rax
shr    $0x2,%rax
cmp    $0x20,%r15
jb     1248 <memcpy+0x138>
and    $0xfffffffffffffffc,%r15
lea    (%rbx,%r15,1),%rcx
cmp    %r14,%rcx
jbe    1311 <memcpy+0x201>
add    %r14,%r15
cmp    %rbx,%r15
jbe    1311 <memcpy+0x201>
mov    %r14,%rdx
lea    -0x1(%rax),%rcx
mov    %rax,%rsi
and    $0x7,%rsi
je     1276 <memcpy+0x166>
nopl   0x0(%rax,%rax,1)
add    $0xffffffffffffffff,%rax
mov    (%rbx),%edi
add    $0x4,%rbx
mov    %edi,(%rdx)
add    $0x4,%rdx
add    $0xffffffffffffffff,%rsi
jne    1260 <memcpy+0x150>
cmp    $0x7,%rcx
jb     14f0 <memcpy+0x3e0>
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%rbx,%rcx,4),%esi
mov    %esi,(%rdx,%rcx,4)
mov    0x4(%rbx,%rcx,4),%esi
mov    %esi,0x4(%rdx,%rcx,4)
mov    0x8(%rbx,%rcx,4),%esi
mov    %esi,0x8(%rdx,%rcx,4)
mov    0xc(%rbx,%rcx,4),%esi
mov    %esi,0xc(%rdx,%rcx,4)
mov    0x10(%rbx,%rcx,4),%esi
mov    %esi,0x10(%rdx,%rcx,4)
mov    0x14(%rbx,%rcx,4),%esi
mov    %esi,0x14(%rdx,%rcx,4)
mov    0x18(%rbx,%rcx,4),%esi
mov    %esi,0x18(%rdx,%rcx,4)
mov    0x1c(%rbx,%rcx,4),%esi
mov    %esi,0x1c(%rdx,%rcx,4)
add    $0x8,%rcx
cmp    %rcx,%rax
jne    1290 <memcpy+0x180>
jmp    14f0 <memcpy+0x3e0>
cmp    $0x20,%r15
jae    12e9 <memcpy+0x1d9>
xor    %ecx,%ecx
jmp    13ef <memcpy+0x2df>
mov    %r15,%rcx
and    $0xffffffffffffffe0,%rcx
lea    -0x20(%rcx),%rax
mov    %rax,%rsi
shr    $0x5,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0x60,%rax
jae    133d <memcpy+0x22d>
xor    %edi,%edi
jmp    13a8 <memcpy+0x298>
mov    %rax,%r8
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rcx
mov    %rcx,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0x18,%rcx
jae    142f <memcpy+0x31f>
xor    %edi,%edi
jmp    14b0 <memcpy+0x3a0>
and    $0xfffffffffffffffc,%rsi
lea    0x70(%r14),%rbx
lea    (%r14,%r8,1),%rax
add    $0x70,%rax
xor    %edi,%edi
nop
movups -0x70(%rax,%rdi,1),%xmm0
movups -0x60(%rax,%rdi,1),%xmm1
movups %xmm0,-0x70(%rbx,%rdi,1)
movups %xmm1,-0x60(%rbx,%rdi,1)
movups -0x50(%rax,%rdi,1),%xmm0
movups -0x40(%rax,%rdi,1),%xmm1
movups %xmm0,-0x50(%rbx,%rdi,1)
movups %xmm1,-0x40(%rbx,%rdi,1)
movups -0x30(%rax,%rdi,1),%xmm0
movups -0x20(%rax,%rdi,1),%xmm1
movups %xmm0,-0x30(%rbx,%rdi,1)
movups %xmm1,-0x20(%rbx,%rdi,1)
movups -0x10(%rax,%rdi,1),%xmm0
movups (%rax,%rdi,1),%xmm1
movups %xmm0,-0x10(%rbx,%rdi,1)
movups %xmm1,(%rbx,%rdi,1)
sub    $0xffffffffffffff80,%rdi
add    $0xfffffffffffffffc,%rsi
jne    1350 <memcpy+0x240>
test   %rdx,%rdx
je     13dc <memcpy+0x2cc>
lea    (%rdi,%r14,1),%rax
add    $0x10,%rax
cs nopw 0x0(%rax,%rax,1)
nop
movups -0x10(%rax,%r8,1),%xmm0
movups (%rax,%r8,1),%xmm1
movups %xmm0,-0x10(%rax)
movups %xmm1,(%rax)
add    $0x20,%rax
add    $0xffffffffffffffff,%rdx
jne    13c0 <memcpy+0x2b0>
cmp    %r15,%rcx
je     14f0 <memcpy+0x3e0>
test   $0x18,%r15b
je     1509 <memcpy+0x3f9>
mov    %r15,%rax
and    $0xfffffffffffffff8,%rax
mov    %r15d,%edx
and    $0x7,%edx
lea    (%r14,%rax,1),%rsi
lea    (%r14,%rcx,1),%rdi
sub    %rax,%rcx
nopw   0x0(%rax,%rax,1)
mov    (%rdi,%r8,1),%rbx
mov    %rbx,(%rdi)
add    $0x8,%rdi
add    $0x8,%rcx
jne    1410 <memcpy+0x300>
cmp    %r15,%rax
jne    117c <memcpy+0x6c>
jmp    14f0 <memcpy+0x3e0>
movabs $0x3ffffffffffffff8,%rcx
ff ff 3f
add    $0x4,%rcx
and    %rcx,%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups (%rbx,%rdi,4),%xmm0
movups 0x10(%rbx,%rdi,4),%xmm1
movups %xmm0,(%r14,%rdi,4)
movups %xmm1,0x10(%r14,%rdi,4)
movups 0x20(%rbx,%rdi,4),%xmm0
movups 0x30(%rbx,%rdi,4),%xmm1
movups %xmm0,0x20(%r14,%rdi,4)
movups %xmm1,0x30(%r14,%rdi,4)
movups 0x40(%rbx,%rdi,4),%xmm0
movups 0x50(%rbx,%rdi,4),%xmm1
movups %xmm0,0x40(%r14,%rdi,4)
movups %xmm1,0x50(%r14,%rdi,4)
movups 0x60(%rbx,%rdi,4),%xmm0
movups 0x70(%rbx,%rdi,4),%xmm1
movups %xmm0,0x60(%r14,%rdi,4)
movups %xmm1,0x70(%r14,%rdi,4)
add    $0x20,%rdi
add    $0xfffffffffffffffc,%rsi
jne    1450 <memcpy+0x340>
test   %rdx,%rdx
je     14eb <memcpy+0x3db>
lea    (%rbx,%rdi,4),%rsi
add    $0x10,%rsi
lea    (%r14,%rdi,4),%rdi
add    $0x10,%rdi
shl    $0x5,%rdx
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movups -0x10(%rsi,%rcx,1),%xmm0
movups (%rsi,%rcx,1),%xmm1
movups %xmm0,-0x10(%rdi,%rcx,1)
movups %xmm1,(%rdi,%rcx,1)
add    $0x20,%rcx
cmp    %rcx,%rdx
jne    14d0 <memcpy+0x3c0>
cmp    %r8,%rax
jne    14f9 <memcpy+0x3e9>
mov    %r14,%rax
pop    %rbx
pop    %r14
pop    %r15
ret
and    $0x7,%eax
lea    (%r14,%r8,4),%rdx
lea    (%rbx,%r8,4),%rbx
jmp    124b <memcpy+0x13b>
add    %r14,%rcx
and    $0x1f,%r15d
mov    %r15,%rdx
mov    %rcx,%rsi
jmp    117c <memcpy+0x6c>

LLVM IR (-O0):
@.str = [15 x i8] c"Copy %d bytes\0A\00"
define i8* @memcpy(i8* %0, i8* %1, i64 %2) {
%4 = alloca i8*
%5 = alloca i8*
%6 = alloca i64
%7 = alloca i32*
%8 = alloca i32*
%9 = alloca i8*
%10 = alloca i8*
%11 = alloca i32
store i8* %0, i8** %4
store i8* %1, i8** %5
store i64 %2, i64* %6
%12 = load i8*, i8** %4
%13 = ptrtoint i8* %12 to i32
%14 = load i8*, i8** %5
%15 = ptrtoint i8* %14 to i32
%16 = or i32 %13, %15
%17 = load i64, i64* %6
%18 = trunc i64 %17 to i32
%19 = or i32 %16, %18
%20 = and i32 %19, 3
%21 = icmp eq i32 %20, 0
br i1 %21, label %22, label %40
22: ; preds = %3
%23 = load i64, i64* %6
%24 = lshr i64 %23, 2
store i64 %24, i64* %6
%25 = load i8*, i8** %4
%26 = bitcast i8* %25 to i32*
store i32* %26, i32** %7
%27 = load i8*, i8** %5
%28 = bitcast i8* %27 to i32*
store i32* %28, i32** %8
br label %29
29: ; preds = %33, %22
%30 = load i64, i64* %6
%31 = add i64 %30, -1
store i64 %31, i64* %6
%32 = icmp ugt i64 %30, 0
br i1 %32, label %33, label %39
33: ; preds = %29
%34 = load i32*, i32** %8
%35 = getelementptr inbounds i32, i32* %34, i32 1
store i32* %35, i32** %8
%36 = load i32, i32* %34
%37 = load i32*, i32** %7
%38 = getelementptr inbounds i32, i32* %37, i32 1
store i32* %38, i32** %7
store i32 %36, i32* %37
br label %29
39: ; preds = %29
br label %67
40: ; preds = %3
%41 = load i8*, i8** %4
store i8* %41, i8** %9
%42 = load i8*, i8** %5
store i8* %42, i8** %10
%43 = load i8*, i8** %10
%44 = load i8*, i8** %9
%45 = ptrtoint i8* %43 to i64
%46 = ptrtoint i8* %44 to i64
%47 = sub i64 %45, %46
%48 = trunc i64 %47 to i32
store i32 %48, i32* %11
%49 = load i64, i64* %6
%50 = call i32 @XIOdebug(i8* getelementptr inbounds ([15 x i8], [15 x i8]* @.str, i64 0, i64 0), i64 %49)
br label %51
51: ; preds = %63, %40
%52 = load i64, i64* %6
%53 = add i64 %52, -1
store i64 %53, i64* %6
%54 = icmp ugt i64 %52, 0
br i1 %54, label %55, label %66
55: ; preds = %51
%56 = load i8*, i8** %9
%57 = load i32, i32* %11
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds i8, i8* %56, i64 %58
%60 = load i8, i8* %59
%61 = load i8*, i8** %9
%62 = getelementptr inbounds i8, i8* %61, i64 0
store i8 %60, i8* %62
br label %63
63: ; preds = %55
%64 = load i8*, i8** %9
%65 = getelementptr inbounds i8, i8* %64, i32 1
store i8* %65, i8** %9
br label %51
66: ; preds = %51
br label %67
67: ; preds = %66, %39
%68 = load i8*, i8** %4
ret i8* %68
}

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