#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 *membcpy(void *dest, const void *src, size_t n) {
  do {
    const unsigned long *isrc = (const unsigned long *)(src + n);
    unsigned long *idst = (unsigned long *)(dest + n);
    const unsigned char *csrc;
    unsigned char *cdst;
    for (; n >= sizeof(unsigned long); n -= sizeof(unsigned long))
      *idst-- = *isrc--;
    csrc = (const unsigned char *)isrc;
    cdst = (unsigned char *)idst;
    while (n--)
      *cdst-- = *csrc--;
  } while (0);
  return (dest);
}


x86 assembly (clang, -O0):
<membcpy>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x10(%rbp),%rax
add    -0x18(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x8(%rbp),%rax
add    -0x18(%rbp),%rax
mov    %rax,-0x28(%rbp)
cmpq   $0x8,-0x18(%rbp)
jb     1168 <membcpy+0x68>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffff8,%rcx
mov    %rcx,-0x20(%rbp)
mov    (%rax),%rcx
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0xfffffffffffffff8,%rdx
mov    %rdx,-0x28(%rbp)
mov    %rcx,(%rax)
mov    -0x18(%rbp),%rax
sub    $0x8,%rax
mov    %rax,-0x18(%rbp)
jmp    1128 <membcpy+0x28>
mov    -0x20(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x18(%rbp)
cmp    $0x0,%rax
je     11b8 <membcpy+0xb8>
mov    -0x30(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x30(%rbp)
mov    (%rax),%cl
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0xffffffffffffffff,%rdx
mov    %rdx,-0x38(%rbp)
mov    %cl,(%rax)
jmp    1178 <membcpy+0x78>
jmp    11bd <membcpy+0xbd>
mov    -0x8(%rbp),%rax
pop    %rbp
ret

x86 assembly (clang, -O2):
<membcpy>:
push   %rbp
push   %r14
push   %rbx
mov    %rdi,%rax
lea    (%rsi,%rdx,1),%r8
lea    (%rdi,%rdx,1),%rcx
cmp    $0x8,%rdx
jb     1228 <membcpy+0x128>
lea    -0x8(%rdx),%r14
cmp    $0x18,%r14
jb     1210 <membcpy+0x110>
mov    %r14,%rbx
and    $0xfffffffffffffff8,%rbx
mov    %rdx,%rdi
sub    %rbx,%rdi
lea    (%rax,%rdi,1),%r9
lea    (%rsi,%rdx,1),%rbx
add    $0x8,%rbx
cmp    %rbx,%r9
jae    1159 <membcpy+0x59>
lea    (%rax,%rdx,1),%rbx
add    $0x8,%rbx
add    %rsi,%rdi
cmp    %rbx,%rdi
jb     1210 <membcpy+0x110>
mov    %r14,%r10
shr    $0x3,%r10
add    $0x1,%r10
mov    %r10,%r9
and    $0xfffffffffffffffc,%r9
lea    -0x4(%r9),%rdi
mov    %rdi,%r11
shr    $0x2,%r11
add    $0x1,%r11
test   %rdi,%rdi
je     11c9 <membcpy+0xc9>
mov    %r11,%rdi
and    $0xfffffffffffffffe,%rdi
add    %r14,%rsi
add    %rax,%r14
xor    %ebx,%ebx
xchg   %ax,%ax
movups -0x10(%rsi,%rbx,8),%xmm0
movups (%rsi,%rbx,8),%xmm1
movups %xmm1,(%r14,%rbx,8)
movups %xmm0,-0x10(%r14,%rbx,8)
movups -0x30(%rsi,%rbx,8),%xmm0
movups -0x20(%rsi,%rbx,8),%xmm1
movups %xmm1,-0x20(%r14,%rbx,8)
movups %xmm0,-0x30(%r14,%rbx,8)
add    $0xfffffffffffffff8,%rbx
add    $0xfffffffffffffffe,%rdi
jne    1190 <membcpy+0x90>
neg    %rbx
jmp    11cb <membcpy+0xcb>
xor    %ebx,%ebx
lea    0x0(,%r9,8),%rsi
test   $0x1,%r11b
je     11fb <membcpy+0xfb>
shl    $0x3,%rbx
mov    %rcx,%r11
sub    %rbx,%r11
mov    %r8,%rdi
sub    %rbx,%rdi
movups -0x18(%rdi),%xmm0
movups -0x8(%rdi),%xmm1
movups %xmm1,-0x8(%r11)
movups %xmm0,-0x18(%r11)
sub    %rsi,%rcx
sub    %rsi,%r8
sub    %rsi,%rdx
cmp    %r9,%r10
je     1228 <membcpy+0x128>
nopl   0x0(%rax)
mov    (%r8),%rsi
add    $0xfffffffffffffff8,%r8
mov    %rsi,(%rcx)
add    $0xfffffffffffffff8,%rcx
add    $0xfffffffffffffff8,%rdx
cmp    $0x7,%rdx
ja     1210 <membcpy+0x110>
test   %rdx,%rdx
je     12ff <membcpy+0x1ff>
cmp    $0x4,%rdx
jb     1260 <membcpy+0x160>
mov    $0x1,%esi
sub    %rdx,%rsi
lea    (%rcx,%rsi,1),%rdi
lea    0x1(%r8),%rbx
cmp    %rbx,%rdi
jae    1304 <membcpy+0x204>
lea    0x1(%rcx),%rdi
add    %r8,%rsi
cmp    %rdi,%rsi
jae    1304 <membcpy+0x204>
mov    %rcx,%rdi
mov    %r8,%rsi
mov    %rdx,%r10
lea    -0x1(%r10),%rbp
mov    %r10,%rdx
and    $0x7,%rdx
je     1299 <membcpy+0x199>
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movzbl (%rsi),%ecx
add    $0xffffffffffffffff,%rsi
mov    %cl,(%rdi)
add    $0xffffffffffffffff,%rdi
add    $0x1,%rbx
cmp    %rbx,%rdx
jne    1280 <membcpy+0x180>
sub    %rbx,%r10
cmp    $0x7,%rbp
jb     12ff <membcpy+0x1ff>
neg    %r10
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzbl (%rsi,%rcx,1),%edx
mov    %dl,(%rdi,%rcx,1)
movzbl -0x1(%rsi,%rcx,1),%edx
mov    %dl,-0x1(%rdi,%rcx,1)
movzbl -0x2(%rsi,%rcx,1),%edx
mov    %dl,-0x2(%rdi,%rcx,1)
movzbl -0x3(%rsi,%rcx,1),%edx
mov    %dl,-0x3(%rdi,%rcx,1)
movzbl -0x4(%rsi,%rcx,1),%edx
mov    %dl,-0x4(%rdi,%rcx,1)
movzbl -0x5(%rsi,%rcx,1),%edx
mov    %dl,-0x5(%rdi,%rcx,1)
movzbl -0x6(%rsi,%rcx,1),%edx
mov    %dl,-0x6(%rdi,%rcx,1)
movzbl -0x7(%rsi,%rcx,1),%edx
mov    %dl,-0x7(%rdi,%rcx,1)
add    $0xfffffffffffffff8,%rcx
cmp    %rcx,%r10
jne    12b0 <membcpy+0x1b0>
pop    %rbx
pop    %r14
pop    %rbp
ret
cmp    $0x10,%rdx
jae    1312 <membcpy+0x212>
xor    %r9d,%r9d
jmp    13c3 <membcpy+0x2c3>
mov    %rdx,%r9
and    $0xfffffffffffffff0,%r9
lea    -0x10(%r9),%rdi
mov    %rdi,%rsi
shr    $0x4,%rsi
add    $0x1,%rsi
mov    %esi,%r10d
and    $0x3,%r10d
cmp    $0x30,%rdi
jae    1339 <membcpy+0x239>
xor    %edi,%edi
jmp    1379 <membcpy+0x279>
and    $0xfffffffffffffffc,%rsi
xor    %edi,%edi
nop
movups -0xf(%r8,%rdi,1),%xmm0
movups %xmm0,-0xf(%rcx,%rdi,1)
movups -0x1f(%r8,%rdi,1),%xmm0
movups %xmm0,-0x1f(%rcx,%rdi,1)
movups -0x2f(%r8,%rdi,1),%xmm0
movups %xmm0,-0x2f(%rcx,%rdi,1)
movups -0x3f(%r8,%rdi,1),%xmm0
movups %xmm0,-0x3f(%rcx,%rdi,1)
add    $0xffffffffffffffc0,%rdi
add    $0xfffffffffffffffc,%rsi
jne    1340 <membcpy+0x240>
neg    %rdi
test   %r10,%r10
je     13b5 <membcpy+0x2b5>
mov    $0xfffffffffffffff9,%rbx
sub    %rdi,%rbx
lea    (%r8,%rbx,1),%r11
add    $0xfffffffffffffff8,%r11
lea    (%rcx,%rbx,1),%rdi
add    $0xfffffffffffffff8,%rdi
shl    $0x4,%r10
xor    %ebx,%ebx
xchg   %ax,%ax
movups (%r11,%rbx,1),%xmm0
movups %xmm0,(%rdi,%rbx,1)
add    $0xfffffffffffffff0,%rbx
mov    %r10,%rsi
add    %rbx,%rsi
jne    13a0 <membcpy+0x2a0>
cmp    %r9,%rdx
je     12ff <membcpy+0x1ff>
test   $0xc,%dl
je     1411 <membcpy+0x311>
mov    %rdx,%r11
and    $0xfffffffffffffffc,%r11
mov    %r11,%rbx
neg    %rbx
mov    %rcx,%rdi
sub    %r11,%rdi
mov    %r8,%rsi
sub    %r11,%rsi
mov    %edx,%r10d
and    $0x3,%r10d
neg    %r9
cs nopw 0x0(%rax,%rax,1)
mov    -0x3(%r8,%r9,1),%ebp
mov    %ebp,-0x3(%rcx,%r9,1)
add    $0xfffffffffffffffc,%r9
cmp    %r9,%rbx
jne    13f0 <membcpy+0x2f0>
cmp    %r11,%rdx
jne    1269 <membcpy+0x169>
jmp    12ff <membcpy+0x1ff>
and    $0xf,%edx
sub    %r9,%r8
sub    %r9,%rcx
jmp    1260 <membcpy+0x160>

LLVM IR (-O0):
define i8* @membcpy(i8* %0, i8* %1, i64 %2) {
%4 = alloca i8*
%5 = alloca i8*
%6 = alloca i64
%7 = alloca i64*
%8 = alloca i64*
%9 = alloca i8*
%10 = alloca i8*
store i8* %0, i8** %4
store i8* %1, i8** %5
store i64 %2, i64* %6
br label %11
11: ; preds = %3
%12 = load i8*, i8** %5
%13 = load i64, i64* %6
%14 = getelementptr i8, i8* %12, i64 %13
%15 = bitcast i8* %14 to i64*
store i64* %15, i64** %7
%16 = load i8*, i8** %4
%17 = load i64, i64* %6
%18 = getelementptr i8, i8* %16, i64 %17
%19 = bitcast i8* %18 to i64*
store i64* %19, i64** %8
br label %20
20: ; preds = %29, %11
%21 = load i64, i64* %6
%22 = icmp uge i64 %21, 8
br i1 %22, label %23, label %32
23: ; preds = %20
%24 = load i64*, i64** %7
%25 = getelementptr inbounds i64, i64* %24, i32 -1
store i64* %25, i64** %7
%26 = load i64, i64* %24
%27 = load i64*, i64** %8
%28 = getelementptr inbounds i64, i64* %27, i32 -1
store i64* %28, i64** %8
store i64 %26, i64* %27
br label %29
29: ; preds = %23
%30 = load i64, i64* %6
%31 = sub i64 %30, 8
store i64 %31, i64* %6
br label %20
32: ; preds = %20
%33 = load i64*, i64** %7
%34 = bitcast i64* %33 to i8*
store i8* %34, i8** %9
%35 = load i64*, i64** %8
%36 = bitcast i64* %35 to i8*
store i8* %36, i8** %10
br label %37
37: ; preds = %41, %32
%38 = load i64, i64* %6
%39 = add i64 %38, -1
store i64 %39, i64* %6
%40 = icmp ne i64 %38, 0
br i1 %40, label %41, label %47
41: ; preds = %37
%42 = load i8*, i8** %9
%43 = getelementptr inbounds i8, i8* %42, i32 -1
store i8* %43, i8** %9
%44 = load i8, i8* %42
%45 = load i8*, i8** %10
%46 = getelementptr inbounds i8, i8* %45, i32 -1
store i8* %46, i8** %10
store i8 %44, i8* %45
br label %37
47: ; preds = %37
br label %48
48: ; preds = %47
%49 = load i8*, i8** %4
ret i8* %49
}

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