#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 */
char *memcpy(char *dst, const char *src, int n) {
  int cnt;
  char *ret;
  ret = dst;
  cnt = (int)src % 4;
  while ((cnt > 0) && (n > 0)) {
    *dst = *src;
    cnt--;
    n--;
    dst++;
    src++;
  }
  while (n >= 4) {
    if (((int)dst % 4) == 0) {
      *((int *)dst) = *((int *)src);
    } else if (((int)dst % 2) == 0) {
      *((short *)dst) = *((short *)src);
      *((short *)(dst + 2)) = *((short *)(src + 2));
    } else {
      *dst = *src;
      *((short *)(dst + 1)) = *((short *)(src + 1));
      *(dst + 3) = *(src + 3);
    }
    n -= 4;
    src += 4;
    dst += 4;
  }
  while (n > 0) {
    *dst = *src;
    n--;
    dst++;
    src++;
  }
  return (ret);
}


x86 assembly (clang, -O0):
<memcpy>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
mov    $0x4,%ecx
cltd
idiv   %ecx
mov    %edx,-0x18(%rbp)
xor    %eax,%eax
cmpl   $0x0,-0x18(%rbp)
mov    %al,-0x21(%rbp)
jle    113f <memcpy+0x3f>
cmpl   $0x0,-0x14(%rbp)
setg   %al
mov    %al,-0x21(%rbp)
mov    -0x21(%rbp),%al
test   $0x1,%al
jne    114f <memcpy+0x4f>
jmp    118a <memcpy+0x8a>
mov    -0x10(%rbp),%rax
mov    (%rax),%cl
mov    -0x8(%rbp),%rax
mov    %cl,(%rax)
mov    -0x18(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x18(%rbp)
mov    -0x14(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
mov    -0x8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8(%rbp)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    1126 <memcpy+0x26>
jmp    118f <memcpy+0x8f>
cmpl   $0x4,-0x14(%rbp)
jl     124c <memcpy+0x14c>
mov    -0x8(%rbp),%rax
mov    $0x4,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    11bf <memcpy+0xbf>
mov    -0x10(%rbp),%rax
mov    (%rax),%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,(%rax)
jmp    1226 <memcpy+0x126>
mov    -0x8(%rbp),%rax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x0,%edx
jne    11f7 <memcpy+0xf7>
mov    -0x10(%rbp),%rax
mov    (%rax),%cx
mov    -0x8(%rbp),%rax
mov    %cx,(%rax)
mov    -0x10(%rbp),%rax
mov    0x2(%rax),%cx
mov    -0x8(%rbp),%rax
mov    %cx,0x2(%rax)
jmp    1221 <memcpy+0x121>
mov    -0x10(%rbp),%rax
mov    (%rax),%cl
mov    -0x8(%rbp),%rax
mov    %cl,(%rax)
mov    -0x10(%rbp),%rax
mov    0x1(%rax),%cx
mov    -0x8(%rbp),%rax
mov    %cx,0x1(%rax)
mov    -0x10(%rbp),%rax
mov    0x3(%rax),%cl
mov    -0x8(%rbp),%rax
mov    %cl,0x3(%rax)
jmp    1226 <memcpy+0x126>
mov    -0x14(%rbp),%eax
sub    $0x4,%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x8(%rbp)
jmp    118f <memcpy+0x8f>
jmp    1251 <memcpy+0x151>
cmpl   $0x0,-0x14(%rbp)
jle    128d <memcpy+0x18d>
mov    -0x10(%rbp),%rax
mov    (%rax),%cl
mov    -0x8(%rbp),%rax
mov    %cl,(%rax)
mov    -0x14(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x14(%rbp)
mov    -0x8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8(%rbp)
mov    -0x10(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x10(%rbp)
jmp    1251 <memcpy+0x151>
mov    -0x20(%rbp),%rax
pop    %rbp
ret

x86 assembly (clang, -O2):
<memcpy>:
push   %r15
push   %r14
push   %r12
push   %rbx
lea    0x3(%rsi),%ecx
test   %esi,%esi
cmovns %esi,%ecx
mov    %rdi,%rax
and    $0xfffffffc,%ecx
mov    %esi,%edi
sub    %ecx,%edi
test   %edi,%edi
jle    1193 <memcpy+0x93>
test   %edx,%edx
jle    1193 <memcpy+0x93>
lea    -0x1(%rdi),%ebx
lea    -0x1(%rdx),%ecx
cmp    %ebx,%ecx
mov    %ebx,%r8d
cmovb  %ecx,%r8d
test   %ebx,%ebx
cmove  %ebx,%r8d
cmp    $0x1f,%r8d
jb     1167 <memcpy+0x67>
cmp    %ebx,%ecx
cmovae %ebx,%ecx
test   %ebx,%ebx
cmove  %ebx,%ecx
lea    (%rsi,%rcx,1),%rbx
add    $0x1,%rbx
cmp    %rax,%rbx
jbe    1274 <memcpy+0x174>
add    %rax,%rcx
add    $0x1,%rcx
cmp    %rsi,%rcx
jbe    1274 <memcpy+0x174>
mov    %rax,%r12
mov    %edx,%ebx
nopl   0x0(%rax)
movzbl (%rsi),%edx
mov    %dl,(%r12)
lea    -0x1(%rbx),%edx
add    $0x1,%r12
add    $0x1,%rsi
cmp    $0x2,%edi
jb     1196 <memcpy+0x96>
add    $0xffffffff,%edi
cmp    $0x1,%ebx
mov    %edx,%ebx
ja     1170 <memcpy+0x70>
jmp    1196 <memcpy+0x96>
mov    %rax,%r12
cmp    $0x4,%edx
jl     11fc <memcpy+0xfc>
mov    %r12d,%ebx
jmp    11bb <memcpy+0xbb>
mov    (%rsi),%edi
mov    %edi,(%r12)
lea    -0x4(%rdx),%edi
add    $0x4,%rsi
add    $0x4,%r12
add    $0x4,%ebx
cmp    $0x7,%edx
mov    %edi,%edx
jbe    11fe <memcpy+0xfe>
test   $0x3,%bl
je     11a0 <memcpy+0xa0>
test   $0x1,%bl
jne    11e0 <memcpy+0xe0>
movzwl (%rsi),%edi
mov    %di,(%r12)
movzwl 0x2(%rsi),%edi
mov    %di,0x2(%r12)
jmp    11a6 <memcpy+0xa6>
nopl   0x0(%rax)
movzbl (%rsi),%ecx
mov    %cl,(%r12)
movzwl 0x1(%rsi),%ecx
mov    %cx,0x1(%r12)
movzbl 0x3(%rsi),%ecx
mov    %cl,0x3(%r12)
jmp    11a6 <memcpy+0xa6>
mov    %edx,%edi
test   %edi,%edi
jle    1254 <memcpy+0x154>
lea    -0x1(%rdi),%r8d
cmp    $0x7,%r8d
jb     1226 <memcpy+0x126>
lea    (%rsi,%r8,1),%rdx
add    $0x1,%rdx
cmp    %rdx,%r12
jae    125c <memcpy+0x15c>
lea    (%r12,%r8,1),%rdx
add    $0x1,%rdx
cmp    %rdx,%rsi
jae    125c <memcpy+0x15c>
mov    %r12,%r10
mov    %rsi,%rbx
add    $0x1,%edi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl (%rbx,%rcx,1),%edx
mov    %dl,(%r10,%rcx,1)
add    $0x1,%rcx
add    $0xffffffff,%edi
cmp    $0x1,%edi
ja     1240 <memcpy+0x140>
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
ret
movabs $0x1ffffffe0,%r9
cmp    $0x1f,%r8d
jae    12a2 <memcpy+0x1a2>
xor    %r14d,%r14d
jmp    144c <memcpy+0x34c>
add    $0x1,%r8
mov    %r8,%r9
and    $0xffffffffffffffe0,%r9
lea    -0x20(%r9),%rbx
mov    %rbx,%rcx
shr    $0x5,%rcx
add    $0x1,%rcx
mov    %ecx,%r10d
and    $0x3,%r10d
cmp    $0x60,%rbx
jae    12d3 <memcpy+0x1d3>
xor    %ebx,%ebx
jmp    1338 <memcpy+0x238>
lea    0x1(%r8),%r10
mov    %r10,%r14
and    %r9,%r14
lea    -0x20(%r14),%rbx
mov    %rbx,%rdx
shr    $0x5,%rdx
add    $0x1,%rdx
mov    %edx,%r11d
and    $0x3,%r11d
cmp    $0x60,%rbx
jae    1398 <memcpy+0x298>
xor    %ebx,%ebx
jmp    1400 <memcpy+0x300>
and    $0xfffffffffffffffc,%rcx
xor    %ebx,%ebx
nopl   0x0(%rax)
movups (%rsi,%rbx,1),%xmm0
movups 0x10(%rsi,%rbx,1),%xmm1
movups %xmm0,(%rax,%rbx,1)
movups %xmm1,0x10(%rax,%rbx,1)
movups 0x20(%rsi,%rbx,1),%xmm0
movups 0x30(%rsi,%rbx,1),%xmm1
movups %xmm0,0x20(%rax,%rbx,1)
movups %xmm1,0x30(%rax,%rbx,1)
movups 0x40(%rsi,%rbx,1),%xmm0
movups 0x50(%rsi,%rbx,1),%xmm1
movups %xmm0,0x40(%rax,%rbx,1)
movups %xmm1,0x50(%rax,%rbx,1)
movups 0x60(%rsi,%rbx,1),%xmm0
movups 0x70(%rsi,%rbx,1),%xmm1
movups %xmm0,0x60(%rax,%rbx,1)
movups %xmm1,0x70(%rax,%rbx,1)
sub    $0xffffffffffffff80,%rbx
add    $0xfffffffffffffffc,%rcx
jne    12e0 <memcpy+0x1e0>
test   %r10,%r10
je     137d <memcpy+0x27d>
lea    (%rsi,%rbx,1),%r11
add    $0x10,%r11
add    %rax,%rbx
add    $0x10,%rbx
shl    $0x5,%r10
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups -0x10(%r11,%rcx,1),%xmm0
movups (%r11,%rcx,1),%xmm1
movups %xmm0,-0x10(%rbx,%rcx,1)
movups %xmm1,(%rbx,%rcx,1)
add    $0x20,%rcx
cmp    %rcx,%r10
jne    1360 <memcpy+0x260>
lea    (%rax,%r9,1),%r12
sub    %r9d,%edx
add    %r9,%rsi
cmp    %r9,%r8
je     1196 <memcpy+0x96>
sub    %r9d,%edi
jmp    116a <memcpy+0x6a>
and    $0xfffffffffffffffc,%rdx
xor    %ebx,%ebx
xchg   %ax,%ax
movups (%rsi,%rbx,1),%xmm0
movups 0x10(%rsi,%rbx,1),%xmm1
movups %xmm0,(%r12,%rbx,1)
movups %xmm1,0x10(%r12,%rbx,1)
movups 0x20(%rsi,%rbx,1),%xmm0
movups 0x30(%rsi,%rbx,1),%xmm1
movups %xmm0,0x20(%r12,%rbx,1)
movups %xmm1,0x30(%r12,%rbx,1)
movups 0x40(%rsi,%rbx,1),%xmm0
movups 0x50(%rsi,%rbx,1),%xmm1
movups %xmm0,0x40(%r12,%rbx,1)
movups %xmm1,0x50(%r12,%rbx,1)
movups 0x60(%rsi,%rbx,1),%xmm0
movups 0x70(%rsi,%rbx,1),%xmm1
movups %xmm0,0x60(%r12,%rbx,1)
movups %xmm1,0x70(%r12,%rbx,1)
sub    $0xffffffffffffff80,%rbx
add    $0xfffffffffffffffc,%rdx
jne    13a0 <memcpy+0x2a0>
test   %r11,%r11
je     143d <memcpy+0x33d>
lea    (%rsi,%rbx,1),%r15
add    $0x10,%r15
add    %r12,%rbx
add    $0x10,%rbx
shl    $0x5,%r11
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movups -0x10(%r15,%rdx,1),%xmm0
movups (%r15,%rdx,1),%xmm1
movups %xmm0,-0x10(%rbx,%rdx,1)
movups %xmm1,(%rbx,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%r11
jne    1420 <memcpy+0x320>
cmp    %r14,%r10
je     1254 <memcpy+0x154>
test   $0x18,%r10b
je     148f <memcpy+0x38f>
add    $0x1,%r8
add    $0x18,%r9
and    %r8,%r9
lea    (%r12,%r9,1),%r10
sub    %r9d,%edi
lea    (%rsi,%r9,1),%rbx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%rsi,%r14,1),%rdx
mov    %rdx,(%r12,%r14,1)
add    $0x8,%r14
cmp    %r14,%r9
jne    1470 <memcpy+0x370>
cmp    %r9,%r8
jne    122c <memcpy+0x12c>
jmp    1254 <memcpy+0x154>
add    %r14,%rsi
sub    %r14d,%edi
add    %r14,%r12
jmp    1226 <memcpy+0x126>

LLVM IR (-O0):
define i8* @memcpy(i8* %0, i8* %1, i32 %2) {
%4 = alloca i8*
%5 = alloca i8*
%6 = alloca i32
%7 = alloca i32
%8 = alloca i8*
store i8* %0, i8** %4
store i8* %1, i8** %5
store i32 %2, i32* %6
%9 = load i8*, i8** %4
store i8* %9, i8** %8
%10 = load i8*, i8** %5
%11 = ptrtoint i8* %10 to i32
%12 = srem i32 %11, 4
store i32 %12, i32* %7
br label %13
13: ; preds = %21, %3
%14 = load i32, i32* %7
%15 = icmp sgt i32 %14, 0
br i1 %15, label %16, label %19
16: ; preds = %13
%17 = load i32, i32* %6
%18 = icmp sgt i32 %17, 0
br label %19
19: ; preds = %16, %13
%20 = phi i1 [ false, %13 ], [ %18, %16 ]
br i1 %20, label %21, label %33
21: ; preds = %19
%22 = load i8*, i8** %5
%23 = load i8, i8* %22
%24 = load i8*, i8** %4
store i8 %23, i8* %24
%25 = load i32, i32* %7
%26 = add nsw i32 %25, -1
store i32 %26, i32* %7
%27 = load i32, i32* %6
%28 = add nsw i32 %27, -1
store i32 %28, i32* %6
%29 = load i8*, i8** %4
%30 = getelementptr inbounds i8, i8* %29, i32 1
store i8* %30, i8** %4
%31 = load i8*, i8** %5
%32 = getelementptr inbounds i8, i8* %31, i32 1
store i8* %32, i8** %5
br label %13
33: ; preds = %19
br label %34
34: ; preds = %83, %33
%35 = load i32, i32* %6
%36 = icmp sge i32 %35, 4
br i1 %36, label %37, label %90
37: ; preds = %34
%38 = load i8*, i8** %4
%39 = ptrtoint i8* %38 to i32
%40 = srem i32 %39, 4
%41 = icmp eq i32 %40, 0
br i1 %41, label %42, label %48
42: ; preds = %37
%43 = load i8*, i8** %5
%44 = bitcast i8* %43 to i32*
%45 = load i32, i32* %44
%46 = load i8*, i8** %4
%47 = bitcast i8* %46 to i32*
store i32 %45, i32* %47
br label %83
48: ; preds = %37
%49 = load i8*, i8** %4
%50 = ptrtoint i8* %49 to i32
%51 = srem i32 %50, 2
%52 = icmp eq i32 %51, 0
br i1 %52, label %53, label %66
53: ; preds = %48
%54 = load i8*, i8** %5
%55 = bitcast i8* %54 to i16*
%56 = load i16, i16* %55
%57 = load i8*, i8** %4
%58 = bitcast i8* %57 to i16*
store i16 %56, i16* %58
%59 = load i8*, i8** %5
%60 = getelementptr inbounds i8, i8* %59, i64 2
%61 = bitcast i8* %60 to i16*
%62 = load i16, i16* %61
%63 = load i8*, i8** %4
%64 = getelementptr inbounds i8, i8* %63, i64 2
%65 = bitcast i8* %64 to i16*
store i16 %62, i16* %65
br label %82
66: ; preds = %48
%67 = load i8*, i8** %5
%68 = load i8, i8* %67
%69 = load i8*, i8** %4
store i8 %68, i8* %69
%70 = load i8*, i8** %5
%71 = getelementptr inbounds i8, i8* %70, i64 1
%72 = bitcast i8* %71 to i16*
%73 = load i16, i16* %72
%74 = load i8*, i8** %4
%75 = getelementptr inbounds i8, i8* %74, i64 1
%76 = bitcast i8* %75 to i16*
store i16 %73, i16* %76
%77 = load i8*, i8** %5
%78 = getelementptr inbounds i8, i8* %77, i64 3
%79 = load i8, i8* %78
%80 = load i8*, i8** %4
%81 = getelementptr inbounds i8, i8* %80, i64 3
store i8 %79, i8* %81
br label %82
82: ; preds = %66, %53
br label %83
83: ; preds = %82, %42
%84 = load i32, i32* %6
%85 = sub nsw i32 %84, 4
store i32 %85, i32* %6
%86 = load i8*, i8** %5
%87 = getelementptr inbounds i8, i8* %86, i64 4
store i8* %87, i8** %5
%88 = load i8*, i8** %4
%89 = getelementptr inbounds i8, i8* %88, i64 4
store i8* %89, i8** %4
br label %34
90: ; preds = %34
br label %91
91: ; preds = %94, %90
%92 = load i32, i32* %6
%93 = icmp sgt i32 %92, 0
br i1 %93, label %94, label %104
94: ; preds = %91
%95 = load i8*, i8** %5
%96 = load i8, i8* %95
%97 = load i8*, i8** %4
store i8 %96, i8* %97
%98 = load i32, i32* %6
%99 = add nsw i32 %98, -1
store i32 %99, i32* %6
%100 = load i8*, i8** %4
%101 = getelementptr inbounds i8, i8* %100, i32 1
store i8* %101, i8** %4
%102 = load i8*, i8** %5
%103 = getelementptr inbounds i8, i8* %102, i32 1
store i8* %103, i8** %5
br label %91
104: ; preds = %91
%105 = load i8*, i8** %8
ret i8* %105
}

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