char *memcpy(s1, s2, n)
register char *s1, *s2;
register int n;
{
  char *ret = s1;
  if (s2 <= s1 && s2 + (n - 1) >= s1) {
    s1 += n;
    s2 += n;
    while (n-- > 0)
      *--s1 = *--s2;
  } else
    while (n-- > 0)
      *s1++ = *s2++;
  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
cmp    -0x8(%rbp),%rax
ja     11a3 <memcpy+0xa3>
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
add    %rcx,%rax
cmp    -0x8(%rbp),%rax
jb     11a3 <memcpy+0xa3>
mov    -0x14(%rbp),%ecx
mov    -0x8(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x8(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x10(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x10(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x14(%rbp)
cmp    $0x0,%eax
jle    119e <memcpy+0x9e>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x10(%rbp)
mov    -0x1(%rax),%cl
mov    -0x8(%rbp),%rax
mov    %rax,%rdx
add    $0xffffffffffffffff,%rdx
mov    %rdx,-0x8(%rbp)
mov    %cl,-0x1(%rax)
jmp    1161 <memcpy+0x61>
jmp    11e8 <memcpy+0xe8>
jmp    11a8 <memcpy+0xa8>
mov    -0x14(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x14(%rbp)
cmp    $0x0,%eax
jle    11e3 <memcpy+0xe3>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
mov    (%rax),%cl
mov    -0x8(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x8(%rbp)
mov    %cl,(%rax)
jmp    11a8 <memcpy+0xa8>
jmp    11e8 <memcpy+0xe8>
mov    -0x20(%rbp),%rax
pop    %rbp
ret

x86 assembly (clang, -O2):
<memcpy>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %rdi,%rax
cmp    %rdi,%rsi
ja     1120 <memcpy+0x20>
lea    -0x1(%rdx),%ecx
movslq %ecx,%rdi
add    %rsi,%rdi
cmp    %rax,%rdi
jae    1178 <memcpy+0x78>
test   %edx,%edx
jle    144c <memcpy+0x34c>
lea    -0x1(%rdx),%r8d
cmp    $0x7,%r8d
jb     1154 <memcpy+0x54>
lea    (%rsi,%r8,1),%rcx
add    $0x1,%rcx
cmp    %rax,%rcx
jbe    11da <memcpy+0xda>
lea    (%rax,%r8,1),%rcx
add    $0x1,%rcx
cmp    %rsi,%rcx
jbe    11da <memcpy+0xda>
mov    %rax,%rcx
mov    %rsi,%rdi
add    $0x1,%edx
xor    %esi,%esi
nop
movzbl (%rdi,%rsi,1),%ebx
mov    %bl,(%rcx,%rsi,1)
add    $0x1,%rsi
add    $0xffffffff,%edx
cmp    $0x1,%edx
ja     1160 <memcpy+0x60>
jmp    144c <memcpy+0x34c>
test   %edx,%edx
jle    144c <memcpy+0x34c>
movslq %edx,%r14
lea    (%rsi,%r14,1),%r9
lea    (%rax,%r14,1),%r11
cmp    $0x3,%ecx
jb     11ad <memcpy+0xad>
mov    %ecx,%r8d
mov    %r8,%rdi
not    %rdi
add    %r14,%rdi
lea    (%rax,%rdi,1),%rbp
cmp    %r9,%rbp
jae    121e <memcpy+0x11e>
add    %rsi,%rdi
cmp    %r11,%rdi
jae    121e <memcpy+0x11e>
mov    %r11,%rsi
mov    %r9,%rbp
add    $0x1,%edx
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movzbl -0x1(%rbp,%rcx,1),%ebx
mov    %bl,-0x1(%rsi,%rcx,1)
add    $0xffffffffffffffff,%rcx
lea    (%rdx,%rcx,1),%edi
cmp    $0x1,%edi
ja     11c0 <memcpy+0xc0>
jmp    144c <memcpy+0x34c>
movabs $0x1ffffffe0,%r10
cmp    $0x1f,%r8d
jae    11f1 <memcpy+0xf1>
xor    %ebx,%ebx
jmp    12fa <memcpy+0x1fa>
lea    0x1(%r8),%r9
mov    %r9,%rbx
and    %r10,%rbx
lea    -0x20(%rbx),%rcx
mov    %rcx,%rdi
shr    $0x5,%rdi
add    $0x1,%rdi
mov    %edi,%r11d
and    $0x3,%r11d
cmp    $0x60,%rcx
jae    123c <memcpy+0x13c>
xor    %ecx,%ecx
jmp    12a8 <memcpy+0x1a8>
lea    0x1(%r8),%r12
movabs $0x1ffffffe0,%r10
cmp    $0xf,%ecx
jae    132f <memcpy+0x22f>
xor    %ecx,%ecx
jmp    13ff <memcpy+0x2ff>
and    $0xfffffffffffffffc,%rdi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups (%rsi,%rcx,1),%xmm0
movups 0x10(%rsi,%rcx,1),%xmm1
movups %xmm0,(%rax,%rcx,1)
movups %xmm1,0x10(%rax,%rcx,1)
movups 0x20(%rsi,%rcx,1),%xmm0
movups 0x30(%rsi,%rcx,1),%xmm1
movups %xmm0,0x20(%rax,%rcx,1)
movups %xmm1,0x30(%rax,%rcx,1)
movups 0x40(%rsi,%rcx,1),%xmm0
movups 0x50(%rsi,%rcx,1),%xmm1
movups %xmm0,0x40(%rax,%rcx,1)
movups %xmm1,0x50(%rax,%rcx,1)
movups 0x60(%rsi,%rcx,1),%xmm0
movups 0x70(%rsi,%rcx,1),%xmm1
movups %xmm0,0x60(%rax,%rcx,1)
movups %xmm1,0x70(%rax,%rcx,1)
sub    $0xffffffffffffff80,%rcx
add    $0xfffffffffffffffc,%rdi
jne    1250 <memcpy+0x150>
test   %r11,%r11
je     12eb <memcpy+0x1eb>
lea    (%rsi,%rcx,1),%rdi
add    $0x10,%rdi
add    %rax,%rcx
add    $0x10,%rcx
shl    $0x5,%r11
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups -0x10(%rdi,%rbp,1),%xmm0
movups (%rdi,%rbp,1),%xmm1
movups %xmm0,-0x10(%rcx,%rbp,1)
movups %xmm1,(%rcx,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%r11
jne    12d0 <memcpy+0x1d0>
cmp    %rbx,%r9
je     144c <memcpy+0x34c>
test   $0x18,%r9b
je     1356 <memcpy+0x256>
add    $0x1,%r8
add    $0x18,%r10
and    %r8,%r10
lea    (%rax,%r10,1),%rcx
sub    %r10d,%edx
lea    (%rsi,%r10,1),%rdi
mov    (%rsi,%rbx,1),%rbp
mov    %rbp,(%rax,%rbx,1)
add    $0x8,%rbx
cmp    %rbx,%r10
jne    1310 <memcpy+0x210>
cmp    %r10,%r8
jne    115a <memcpy+0x5a>
jmp    144c <memcpy+0x34c>
lea    0x10(%r10),%rcx
and    %r12,%rcx
lea    -0x10(%rcx),%rdi
mov    %rdi,%rbx
shr    $0x4,%rbx
add    $0x1,%rbx
mov    %ebx,%r15d
and    $0x3,%r15d
cmp    $0x30,%rdi
jae    1366 <memcpy+0x266>
xor    %edi,%edi
jmp    13b9 <memcpy+0x2b9>
add    %rbx,%rsi
sub    %ebx,%edx
add    %rax,%rbx
mov    %rbx,%rcx
jmp    1157 <memcpy+0x57>
and    $0xfffffffffffffffc,%rbx
lea    -0x10(%r9),%r13
lea    -0x10(%r11),%rbp
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movups 0x0(%r13,%rdi,1),%xmm0
movups %xmm0,0x0(%rbp,%rdi,1)
movups -0x10(%r13,%rdi,1),%xmm0
movups %xmm0,-0x10(%rbp,%rdi,1)
movups -0x20(%r13,%rdi,1),%xmm0
movups %xmm0,-0x20(%rbp,%rdi,1)
movups -0x30(%r13,%rdi,1),%xmm0
movups %xmm0,-0x30(%rbp,%rdi,1)
add    $0xffffffffffffffc0,%rdi
add    $0xfffffffffffffffc,%rbx
jne    1380 <memcpy+0x280>
neg    %rdi
test   %r15,%r15
je     13f4 <memcpy+0x2f4>
sub    %rdi,%r14
add    %r14,%rsi
add    $0xfffffffffffffff0,%rsi
lea    (%rax,%r14,1),%rdi
add    $0xfffffffffffffff0,%rdi
shl    $0x4,%r15
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
movups (%rsi,%rbx,1),%xmm0
movups %xmm0,(%rdi,%rbx,1)
add    $0xfffffffffffffff0,%rbx
mov    %r15,%rbp
add    %rbx,%rbp
jne    13e0 <memcpy+0x2e0>
cmp    %rcx,%r12
je     144c <memcpy+0x34c>
test   $0xc,%r12b
je     1457 <memcpy+0x357>
add    $0x1,%r8
add    $0x1c,%r10
and    %r8,%r10
mov    %r11,%rsi
sub    %r10,%rsi
sub    %r10d,%edx
mov    %r9,%rbp
sub    %r10,%rbp
neg    %rcx
and    $0xfffffffffffffffc,%r12
neg    %r12
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    -0x4(%r9,%rcx,1),%edi
mov    %edi,-0x4(%r11,%rcx,1)
add    $0xfffffffffffffffc,%rcx
cmp    %rcx,%r12
jne    1430 <memcpy+0x330>
cmp    %r10,%r8
jne    11b3 <memcpy+0xb3>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
sub    %rcx,%r9
sub    %ecx,%edx
sub    %rcx,%r11
jmp    11ad <memcpy+0xad>

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

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