#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 *_dst, const void *_src, unsigned int size) {
  unsigned int *dst = _dst;
  const unsigned int *src = _src;
  if (!((unsigned int)dst & 3) && !((unsigned int)src & 3))
    while (size > 3) {
      *dst++ = *src++;
      size -= 4;
    }
  unsigned char *cdst = (unsigned char *)dst;
  unsigned char *csrc = (unsigned char *)src;
  while (size--) {
    *cdst++ = *csrc++;
  }
  return _dst;
}


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    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%rax
and    $0x3,%eax
cmp    $0x0,%eax
jne    1183 <memcpy+0x83>
mov    -0x28(%rbp),%rax
and    $0x3,%eax
cmp    $0x0,%eax
jne    1183 <memcpy+0x83>
jmp    1144 <memcpy+0x44>
cmpl   $0x3,-0x14(%rbp)
jbe    117e <memcpy+0x7e>
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)
mov    -0x14(%rbp),%eax
sub    $0x4,%eax
mov    %eax,-0x14(%rbp)
jmp    1144 <memcpy+0x44>
jmp    1183 <memcpy+0x83>
mov    -0x20(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x14(%rbp)
cmp    $0x0,%eax
je     11ce <memcpy+0xce>
mov    -0x38(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x38(%rbp)
mov    (%rax),%cl
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cl,(%rax)
jmp    1193 <memcpy+0x93>
mov    -0x8(%rbp),%rax
pop    %rbp
ret

x86 assembly (clang, -O2):
<memcpy>:
push   %r15
push   %r14
push   %rbx
mov    %rdi,%rax
test   $0x3,%al
je     11ec <memcpy+0xec>
mov    %rax,%r11
test   %edx,%edx
je     11e6 <memcpy+0xe6>
lea    -0x1(%rdx),%r8d
cmp    $0x7,%r8d
jb     1147 <memcpy+0x47>
lea    (%rsi,%r8,1),%rcx
add    $0x1,%rcx
cmp    %r11,%rcx
jbe    1215 <memcpy+0x115>
lea    (%r11,%r8,1),%rcx
add    $0x1,%rcx
cmp    %rsi,%rcx
jbe    1215 <memcpy+0x115>
mov    %rsi,%r14
mov    %r11,%rdi
lea    -0x1(%rdx),%r8d
test   $0x7,%dl
je     1178 <memcpy+0x78>
mov    %edx,%esi
and    $0x7,%esi
xor    %ebx,%ebx
nopl   (%rax)
movzbl (%r14,%rbx,1),%ecx
mov    %cl,(%rdi,%rbx,1)
add    $0x1,%rbx
cmp    %ebx,%esi
jne    1160 <memcpy+0x60>
add    %rbx,%r14
add    %rbx,%rdi
sub    %ebx,%edx
cmp    $0x7,%r8d
jb     11e6 <memcpy+0xe6>
mov    %edx,%edx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl (%r14,%rsi,1),%ecx
mov    %cl,(%rdi,%rsi,1)
movzbl 0x1(%r14,%rsi,1),%ecx
mov    %cl,0x1(%rdi,%rsi,1)
movzbl 0x2(%r14,%rsi,1),%ecx
mov    %cl,0x2(%rdi,%rsi,1)
movzbl 0x3(%r14,%rsi,1),%ecx
mov    %cl,0x3(%rdi,%rsi,1)
movzbl 0x4(%r14,%rsi,1),%ecx
mov    %cl,0x4(%rdi,%rsi,1)
movzbl 0x5(%r14,%rsi,1),%ecx
mov    %cl,0x5(%rdi,%rsi,1)
movzbl 0x6(%r14,%rsi,1),%ecx
mov    %cl,0x6(%rdi,%rsi,1)
movzbl 0x7(%r14,%rsi,1),%ecx
mov    %cl,0x7(%rdi,%rsi,1)
add    $0x8,%rsi
cmp    %esi,%edx
jne    1190 <memcpy+0x90>
pop    %rbx
pop    %r14
pop    %r15
ret
cmp    $0x4,%edx
jb     1110 <memcpy+0x10>
mov    %esi,%ecx
and    $0x3,%ecx
test   %rcx,%rcx
jne    1110 <memcpy+0x10>
lea    -0x4(%rdx),%r9d
cmp    $0x1c,%r9d
jae    122d <memcpy+0x12d>
mov    %rax,%r11
jmp    1470 <memcpy+0x370>
movabs $0x1ffffffe0,%r9
cmp    $0x1f,%r8d
jae    1254 <memcpy+0x154>
xor    %r10d,%r10d
jmp    136e <memcpy+0x26e>
mov    %r9d,%ecx
and    $0xfffffffc,%ecx
lea    (%rsi,%rcx,1),%rdi
add    $0x4,%rdi
cmp    %rax,%rdi
jbe    1281 <memcpy+0x181>
add    %rax,%rcx
add    $0x4,%rcx
cmp    %rsi,%rcx
jbe    1281 <memcpy+0x181>
mov    %rax,%r11
jmp    1470 <memcpy+0x370>
lea    0x1(%r8),%r14
mov    %r14,%r10
and    %r9,%r10
lea    -0x20(%r10),%rcx
mov    %rcx,%rbx
shr    $0x5,%rbx
add    $0x1,%rbx
mov    %ebx,%r15d
and    $0x3,%r15d
cmp    $0x60,%rcx
jae    12b7 <memcpy+0x1b7>
xor    %ecx,%ecx
jmp    1320 <memcpy+0x220>
shr    $0x2,%r9d
add    $0x1,%r9d
mov    %r9d,%r8d
and    $0xfffffff8,%r8d
lea    -0x8(%r8),%rcx
mov    %rcx,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%r11d
and    $0x3,%r11d
cmp    $0x18,%rcx
jae    13af <memcpy+0x2af>
xor    %ebx,%ebx
jmp    1418 <memcpy+0x318>
and    $0xfffffffffffffffc,%rbx
xor    %ecx,%ecx
nopl   (%rax)
movups (%rsi,%rcx,1),%xmm0
movups 0x10(%rsi,%rcx,1),%xmm1
movups %xmm0,(%r11,%rcx,1)
movups %xmm1,0x10(%r11,%rcx,1)
movups 0x20(%rsi,%rcx,1),%xmm0
movups 0x30(%rsi,%rcx,1),%xmm1
movups %xmm0,0x20(%r11,%rcx,1)
movups %xmm1,0x30(%r11,%rcx,1)
movups 0x40(%rsi,%rcx,1),%xmm0
movups 0x50(%rsi,%rcx,1),%xmm1
movups %xmm0,0x40(%r11,%rcx,1)
movups %xmm1,0x50(%r11,%rcx,1)
movups 0x60(%rsi,%rcx,1),%xmm0
movups 0x70(%rsi,%rcx,1),%xmm1
movups %xmm0,0x60(%r11,%rcx,1)
movups %xmm1,0x70(%r11,%rcx,1)
sub    $0xffffffffffffff80,%rcx
add    $0xfffffffffffffffc,%rbx
jne    12c0 <memcpy+0x1c0>
test   %r15,%r15
je     135b <memcpy+0x25b>
lea    (%r11,%rcx,1),%rbx
add    $0x10,%rbx
add    %rsi,%rcx
add    $0x10,%rcx
shl    $0x5,%r15
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
movups -0x10(%rcx,%rdi,1),%xmm0
movups (%rcx,%rdi,1),%xmm1
movups %xmm0,-0x10(%rbx,%rdi,1)
movups %xmm1,(%rbx,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%r15
jne    1340 <memcpy+0x240>
cmp    %r10,%r14
je     11e6 <memcpy+0xe6>
test   $0x18,%r14b
je     148a <memcpy+0x38a>
add    $0x1,%r8
add    $0x18,%r9
and    %r8,%r9
lea    (%rsi,%r9,1),%r14
lea    (%r11,%r9,1),%rdi
sub    %r9d,%edx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%rsi,%r10,1),%rbx
mov    %rbx,(%r11,%r10,1)
add    $0x8,%r10
cmp    %r10,%r9
jne    1390 <memcpy+0x290>
cmp    %r9,%r8
jne    114d <memcpy+0x4d>
jmp    11e6 <memcpy+0xe6>
and    $0xfffffffffffffffc,%rdi
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
movups (%rsi,%rbx,4),%xmm0
movups 0x10(%rsi,%rbx,4),%xmm1
movups %xmm0,(%rax,%rbx,4)
movups %xmm1,0x10(%rax,%rbx,4)
movups 0x20(%rsi,%rbx,4),%xmm0
movups 0x30(%rsi,%rbx,4),%xmm1
movups %xmm0,0x20(%rax,%rbx,4)
movups %xmm1,0x30(%rax,%rbx,4)
movups 0x40(%rsi,%rbx,4),%xmm0
movups 0x50(%rsi,%rbx,4),%xmm1
movups %xmm0,0x40(%rax,%rbx,4)
movups %xmm1,0x50(%rax,%rbx,4)
movups 0x60(%rsi,%rbx,4),%xmm0
movups 0x70(%rsi,%rbx,4),%xmm1
movups %xmm0,0x60(%rax,%rbx,4)
movups %xmm1,0x70(%rax,%rbx,4)
add    $0x20,%rbx
add    $0xfffffffffffffffc,%rdi
jne    13c0 <memcpy+0x2c0>
lea    0x0(,%r8,4),%r10d
test   %r11,%r11
je     145b <memcpy+0x35b>
lea    (%rsi,%rbx,4),%rdi
add    $0x10,%rdi
lea    (%rax,%rbx,4),%rbx
add    $0x10,%rbx
shl    $0x5,%r11
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movups -0x10(%rdi,%rcx,1),%xmm0
movups (%rdi,%rcx,1),%xmm1
movups %xmm0,-0x10(%rbx,%rcx,1)
movups %xmm1,(%rbx,%rcx,1)
add    $0x20,%rcx
cmp    %rcx,%r11
jne    1440 <memcpy+0x340>
sub    %r10d,%edx
lea    (%rax,%r8,4),%r11
lea    (%rsi,%r8,4),%rsi
cmp    %r9,%r8
je     1113 <memcpy+0x13>
nop
mov    (%rsi),%ecx
add    $0x4,%rsi
mov    %ecx,(%r11)
add    $0x4,%r11
add    $0xfffffffc,%edx
cmp    $0x3,%edx
ja     1470 <memcpy+0x370>
jmp    1113 <memcpy+0x13>
sub    %r10d,%edx
add    %r10,%r11
add    %r10,%rsi
jmp    1147 <memcpy+0x47>

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 i32*
%9 = alloca i8*
%10 = alloca i8*
store i8* %0, i8** %4
store i8* %1, i8** %5
store i32 %2, i32* %6
%11 = load i8*, i8** %4
%12 = bitcast i8* %11 to i32*
store i32* %12, i32** %7
%13 = load i8*, i8** %5
%14 = bitcast i8* %13 to i32*
store i32* %14, i32** %8
%15 = load i32*, i32** %7
%16 = ptrtoint i32* %15 to i32
%17 = and i32 %16, 3
%18 = icmp ne i32 %17, 0
br i1 %18, label %37, label %19
19: ; preds = %3
%20 = load i32*, i32** %8
%21 = ptrtoint i32* %20 to i32
%22 = and i32 %21, 3
%23 = icmp ne i32 %22, 0
br i1 %23, label %37, label %24
24: ; preds = %19
br label %25
25: ; preds = %28, %24
%26 = load i32, i32* %6
%27 = icmp ugt i32 %26, 3
br i1 %27, label %28, label %36
28: ; preds = %25
%29 = load i32*, i32** %8
%30 = getelementptr inbounds i32, i32* %29, i32 1
store i32* %30, i32** %8
%31 = load i32, i32* %29
%32 = load i32*, i32** %7
%33 = getelementptr inbounds i32, i32* %32, i32 1
store i32* %33, i32** %7
store i32 %31, i32* %32
%34 = load i32, i32* %6
%35 = sub i32 %34, 4
store i32 %35, i32* %6
br label %25
36: ; preds = %25
br label %37
37: ; preds = %36, %19, %3
%38 = load i32*, i32** %7
%39 = bitcast i32* %38 to i8*
store i8* %39, i8** %9
%40 = load i32*, i32** %8
%41 = bitcast i32* %40 to i8*
store i8* %41, i8** %10
br label %42
42: ; preds = %46, %37
%43 = load i32, i32* %6
%44 = add i32 %43, -1
store i32 %44, i32* %6
%45 = icmp ne i32 %43, 0
br i1 %45, label %46, label %52
46: ; preds = %42
%47 = load i8*, i8** %10
%48 = getelementptr inbounds i8, i8* %47, i32 1
store i8* %48, i8** %10
%49 = load i8, i8* %47
%50 = load i8*, i8** %9
%51 = getelementptr inbounds i8, i8* %50, i32 1
store i8* %51, i8** %9
store i8 %49, i8* %50
br label %42
52: ; preds = %42
%53 = load i8*, i8** %4
ret i8* %53
}

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