bcopy(old, new, n) register char *old, *new;
register int n;
{
  if (old <= new &&old + (n - 1) >= new) {
    old += n;
    new += n;
    while (n-- > 0)
      *--new = *--old;
  } else
    while (n-- > 0)
      *new ++ = *old++;
}


x86 assembly (clang, -O0):
<bcopy>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
mov    -0x10(%rbp),%rax
cmp    -0x18(%rbp),%rax
ja     119b <bcopy+0x9b>
mov    -0x10(%rbp),%rax
mov    -0x1c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
add    %rcx,%rax
cmp    -0x18(%rbp),%rax
jb     119b <bcopy+0x9b>
mov    -0x1c(%rbp),%ecx
mov    -0x10(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x10(%rbp)
mov    -0x1c(%rbp),%ecx
mov    -0x18(%rbp),%rax
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x1c(%rbp)
cmp    $0x0,%eax
jle    1196 <bcopy+0x96>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x10(%rbp)
mov    -0x1(%rax),%cl
mov    -0x18(%rbp),%rax
mov    %rax,%rdx
add    $0xffffffffffffffff,%rdx
mov    %rdx,-0x18(%rbp)
mov    %cl,-0x1(%rax)
jmp    1159 <bcopy+0x59>
jmp    11e0 <bcopy+0xe0>
jmp    11a0 <bcopy+0xa0>
mov    -0x1c(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x1c(%rbp)
cmp    $0x0,%eax
jle    11db <bcopy+0xdb>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
mov    (%rax),%cl
mov    -0x18(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x18(%rbp)
mov    %cl,(%rax)
jmp    11a0 <bcopy+0xa0>
jmp    11e0 <bcopy+0xe0>
mov    -0x4(%rbp),%eax
pop    %rbp
ret

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

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

LLVM IR (-O2):
define i32 @bcopy(i8* %0, i8* writeonly %1, i32 %2) {
%4 = icmp ugt i8* %0, %1
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* %0, i64 %7
%9 = icmp ult i8* %8, %1
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* %1, i64 %22
%24 = getelementptr i8, i8* %0, i64 %22
%25 = icmp ult i8* %23, %15
%26 = icmp ult i8* %24, %14
%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* %14, i64 -1
%40 = getelementptr i8, i8* %15, i64 -1
%41 = getelementptr inbounds i8, i8* %40, i64 -15
%42 = getelementptr inbounds i8, i8* %39, i64 -15
%43 = getelementptr i8, i8* %14, i64 -1
%44 = getelementptr i8, i8* %15, i64 -1
%45 = getelementptr inbounds i8, i8* %44, i64 -15
%46 = getelementptr inbounds i8, i8* %43, i64 -15
%47 = getelementptr i8, i8* %14, i64 -1
%48 = getelementptr i8, i8* %15, i64 -1
%49 = getelementptr inbounds i8, i8* %48, i64 -15
%50 = getelementptr inbounds i8, i8* %47, i64 -15
%51 = getelementptr i8, i8* %14, i64 -1
%52 = getelementptr i8, i8* %15, 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* %14, i64 -1
%94 = getelementptr i8, i8* %15, 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* %15, i64 %113
%115 = sub nsw i64 0, %31
%116 = getelementptr i8, i8* %14, i64 %115
%117 = trunc i64 %31 to i32
%118 = sub i32 %2, %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 = trunc i64 %125 to i32
%127 = sub i32 %2, %126
%128 = sub nsw i64 0, %125
%129 = getelementptr i8, i8* %14, i64 %128
%130 = sub nsw i64 0, %125
%131 = getelementptr i8, i8* %15, i64 %130
%132 = getelementptr i8, i8* %14, i64 -1
%133 = getelementptr i8, i8* %15, 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 i32 [ %2, %13 ], [ %2, %19 ], [ %118, %112 ], [ %127, %147 ]
%151 = phi i8* [ %14, %13 ], [ %14, %19 ], [ %116, %112 ], [ %129, %147 ]
%152 = phi i8* [ %15, %13 ], [ %15, %19 ], [ %114, %112 ], [ %131, %147 ]
br label %153
153: ; preds = %149, %153
%154 = phi i32 [ %157, %153 ], [ %150, %149 ]
%155 = phi i8* [ %160, %153 ], [ %151, %149 ]
%156 = phi i8* [ %158, %153 ], [ %152, %149 ]
%157 = add nsw i32 %154, -1
%158 = getelementptr inbounds i8, i8* %156, i64 -1
%159 = load i8, i8* %158
%160 = getelementptr inbounds i8, i8* %155, i64 -1
store i8 %159, i8* %160
%161 = icmp ugt i32 %154, 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* %1, i64 %172
%174 = getelementptr i8, i8* %0, i64 %172
%175 = icmp ugt i8* %174, %1
%176 = icmp ugt i8* %173, %0
%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* %1, i64 %190
%193 = getelementptr i8, i8* %0, 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* %1, i64 %202
%204 = getelementptr i8, i8* %0, 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* %1, i64 %213
%215 = getelementptr i8, i8* %0, 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* %1, i64 %224
%226 = getelementptr i8, i8* %0, 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* %1, i64 %242
%245 = getelementptr i8, i8* %0, 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* %0, i64 %181
%261 = getelementptr i8, i8* %1, i64 %181
%262 = trunc i64 %181 to i32
%263 = sub i32 %2, %262
%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 = trunc i64 %271 to i32
%273 = sub i32 %2, %272
%274 = getelementptr i8, i8* %1, i64 %271
%275 = getelementptr i8, i8* %0, i64 %271
br label %276
276: ; preds = %276, %266
%277 = phi i64 [ %267, %266 ], [ %283, %276 ]
%278 = getelementptr i8, i8* %1, i64 %277
%279 = getelementptr i8, i8* %0, 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 i32 [ %2, %164 ], [ %2, %169 ], [ %263, %259 ], [ %273, %285 ]
%289 = phi i8* [ %1, %164 ], [ %1, %169 ], [ %261, %259 ], [ %274, %285 ]
%290 = phi i8* [ %0, %164 ], [ %0, %169 ], [ %260, %259 ], [ %275, %285 ]
br label %291
291: ; preds = %287, %291
%292 = phi i32 [ %295, %291 ], [ %288, %287 ]
%293 = phi i8* [ %298, %291 ], [ %289, %287 ]
%294 = phi i8* [ %296, %291 ], [ %290, %287 ]
%295 = add nsw i32 %292, -1
%296 = getelementptr inbounds i8, i8* %294, i64 1
%297 = load i8, i8* %294
%298 = getelementptr inbounds i8, i8* %293, i64 1
store i8 %297, i8* %293
%299 = icmp ugt i32 %292, 1
br i1 %299, label %291, label %300
300: ; preds = %153, %291, %110, %147, %257, %285, %10, %162
ret i32 undef
}