void copy_bytes_down(to_cp, from_cp, nr_bytes) register char *to_cp, *from_cp;
register int nr_bytes;
{
  if ((int)to_cp % sizeof(int) == 0 && (int)from_cp % sizeof(int) == 0 &&
      nr_bytes % sizeof(int) == 0) {
    register int *to_ip, *from_ip, *end_ip;
    nr_bytes /= sizeof(int);
    to_ip = (int *)to_cp;
    from_ip = (int *)from_cp;
    end_ip = from_ip - 1;
    from_ip = from_ip + nr_bytes - 1;
    to_ip = to_ip + nr_bytes - 1;
    while (from_ip != end_ip)
      *to_ip-- = *from_ip--;
  } else {
    register char *end_cp;
    end_cp = from_cp - 1;
    from_cp = from_cp + nr_bytes - 1;
    to_cp = to_cp + nr_bytes - 1;
    while (from_cp != end_cp)
      *to_cp-- = *from_cp--;
  }
}


x86 assembly (clang, -O0):
<copy_bytes_down>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    -0x8(%rbp),%rax
cltq
and    $0x3,%rax
cmp    $0x0,%rax
jne    11d8 <copy_bytes_down+0xd8>
mov    -0x10(%rbp),%rax
cltq
and    $0x3,%rax
cmp    $0x0,%rax
jne    11d8 <copy_bytes_down+0xd8>
movslq -0x14(%rbp),%rax
and    $0x3,%rax
cmp    $0x0,%rax
jne    11d8 <copy_bytes_down+0xd8>
movslq -0x14(%rbp),%rax
shr    $0x2,%rax
mov    %eax,-0x14(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rax
movslq -0x14(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x14(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
cmp    -0x30(%rbp),%rax
je     11d3 <copy_bytes_down+0xd3>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0xfffffffffffffffc,%rcx
mov    %rcx,-0x28(%rbp)
mov    (%rax),%ecx
mov    -0x20(%rbp),%rax
mov    %rax,%rdx
add    $0xfffffffffffffffc,%rdx
mov    %rdx,-0x20(%rbp)
mov    %ecx,(%rax)
jmp    119e <copy_bytes_down+0x9e>
jmp    1244 <copy_bytes_down+0x144>
mov    -0x10(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x38(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
add    %rcx,%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
add    %rcx,%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x8(%rbp)
mov    -0x10(%rbp),%rax
cmp    -0x38(%rbp),%rax
je     123f <copy_bytes_down+0x13f>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x10(%rbp)
mov    (%rax),%cl
mov    -0x8(%rbp),%rax
mov    %rax,%rdx
add    $0xffffffffffffffff,%rdx
mov    %rdx,-0x8(%rbp)
mov    %cl,(%rax)
jmp    120a <copy_bytes_down+0x10a>
jmp    1244 <copy_bytes_down+0x144>
pop    %rbp
ret

x86 assembly (clang, -O2):
<copy_bytes_down>:
push   %r14
push   %rbx
test   $0x3,%dl
jne    1246 <copy_bytes_down+0x146>
mov    %esi,%eax
or     %edi,%eax
and    $0x3,%eax
test   %rax,%rax
jne    1246 <copy_bytes_down+0x146>
sar    $0x2,%edx
movslq %edx,%r11
lea    0x0(,%r11,4),%rax
test   %rax,%rax
je     1310 <copy_bytes_down+0x210>
lea    (%rsi,%r11,4),%rax
add    $0xfffffffffffffffc,%rax
movabs $0x3fffffffffffffff,%r14
ff ff 3f
lea    (%rdi,%r11,4),%rcx
lea    -0x1(%r11),%r9
and    %r14,%r9
cmp    $0x7,%r9
jb     121c <copy_bytes_down+0x11c>
lea    (%rsi,%r11,4),%rdx
cmp    %rdi,%rdx
jbe    1170 <copy_bytes_down+0x70>
lea    (%rdi,%r11,4),%rdx
cmp    %rsi,%rdx
ja     121c <copy_bytes_down+0x11c>
add    $0x1,%r9
mov    %r9,%r8
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rdx
mov    %rdx,%r10
shr    $0x3,%r10
add    $0x1,%r10
test   %rdx,%rdx
je     1347 <copy_bytes_down+0x247>
add    $0xffffffffffffffff,%r14
and    %r10,%r14
lea    (%rdi,%r11,4),%rbx
add    $0xfffffffffffffff0,%rbx
lea    (%rsi,%r11,4),%rdx
add    $0xfffffffffffffff0,%rdx
xor    %edi,%edi
nopl   0x0(%rax)
movups -0x10(%rdx,%rdi,4),%xmm0
movups (%rdx,%rdi,4),%xmm1
movups %xmm1,(%rbx,%rdi,4)
movups %xmm0,-0x10(%rbx,%rdi,4)
movups -0x30(%rdx,%rdi,4),%xmm0
movups -0x20(%rdx,%rdi,4),%xmm1
movups %xmm1,-0x20(%rbx,%rdi,4)
movups %xmm0,-0x30(%rbx,%rdi,4)
add    $0xfffffffffffffff0,%rdi
add    $0xfffffffffffffffe,%r14
jne    11b0 <copy_bytes_down+0xb0>
neg    %rdi
test   $0x1,%r10b
je     1209 <copy_bytes_down+0x109>
shl    $0x2,%rdi
mov    %rax,%rdx
sub    %rdi,%rdx
mov    %rcx,%rbx
sub    %rdi,%rbx
movups -0x1c(%rdx),%xmm0
movups -0xc(%rdx),%xmm1
movups %xmm1,-0x10(%rbx)
movups %xmm0,-0x20(%rbx)
cmp    %r8,%r9
je     1310 <copy_bytes_down+0x210>
shl    $0x2,%r8
sub    %r8,%rax
sub    %r8,%rcx
add    $0xfffffffffffffffc,%rsi
add    $0xfffffffffffffffc,%rcx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%rax),%edx
mov    %edx,(%rcx)
add    $0xfffffffffffffffc,%rax
add    $0xfffffffffffffffc,%rcx
cmp    %rsi,%rax
jne    1230 <copy_bytes_down+0x130>
jmp    1310 <copy_bytes_down+0x210>
test   %edx,%edx
je     1310 <copy_bytes_down+0x210>
movslq %edx,%r8
lea    (%rdi,%r8,1),%r10
cmp    $0x4,%edx
jb     1270 <copy_bytes_down+0x170>
lea    (%rsi,%r8,1),%rax
cmp    %rdi,%rax
jbe    1314 <copy_bytes_down+0x214>
cmp    %rsi,%r10
jbe    1314 <copy_bytes_down+0x214>
mov    %r10,%rdi
mov    %r8,%rdx
lea    -0x1(%rdx),%rax
mov    %rdx,%rcx
and    $0x7,%rcx
je     12a6 <copy_bytes_down+0x1a6>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movzbl -0x1(%rsi,%rdx,1),%ebx
add    $0xffffffffffffffff,%rdx
mov    %bl,-0x1(%rdi)
add    $0xffffffffffffffff,%rdi
add    $0xffffffffffffffff,%rcx
jne    1290 <copy_bytes_down+0x190>
cmp    $0x7,%rax
jb     1310 <copy_bytes_down+0x210>
lea    (%rdx,%rsi,1),%rax
add    $0xffffffffffffffff,%rax
neg    %rdx
xor    %ecx,%ecx
nopl   0x0(%rax)
movzbl (%rax,%rcx,1),%ebx
mov    %bl,-0x1(%rdi,%rcx,1)
movzbl -0x1(%rax,%rcx,1),%ebx
mov    %bl,-0x2(%rdi,%rcx,1)
movzbl -0x2(%rax,%rcx,1),%ebx
mov    %bl,-0x3(%rdi,%rcx,1)
movzbl -0x3(%rax,%rcx,1),%ebx
mov    %bl,-0x4(%rdi,%rcx,1)
movzbl -0x4(%rax,%rcx,1),%ebx
mov    %bl,-0x5(%rdi,%rcx,1)
movzbl -0x5(%rax,%rcx,1),%ebx
mov    %bl,-0x6(%rdi,%rcx,1)
movzbl -0x6(%rax,%rcx,1),%ebx
mov    %bl,-0x7(%rdi,%rcx,1)
movzbl -0x7(%rax,%rcx,1),%ebx
mov    %bl,-0x8(%rdi,%rcx,1)
add    $0xfffffffffffffff8,%rcx
cmp    %rcx,%rdx
jne    12c0 <copy_bytes_down+0x1c0>
pop    %rbx
pop    %r14
ret
cmp    $0x10,%edx
jae    1320 <copy_bytes_down+0x220>
xor    %ecx,%ecx
jmp    13f4 <copy_bytes_down+0x2f4>
mov    %r8,%rcx
and    $0xfffffffffffffff0,%rcx
lea    -0x10(%rcx),%rax
mov    %rax,%r11
shr    $0x4,%r11
add    $0x1,%r11
mov    %r11d,%r9d
and    $0x3,%r9d
cmp    $0x30,%rax
jae    1358 <copy_bytes_down+0x258>
xor    %eax,%eax
jmp    13a7 <copy_bytes_down+0x2a7>
xor    %edi,%edi
test   $0x1,%r10b
jne    11e9 <copy_bytes_down+0xe9>
jmp    1209 <copy_bytes_down+0x109>
and    $0xfffffffffffffffc,%r11
lea    -0x10(%r10),%r14
lea    (%r8,%rsi,1),%rbx
add    $0xfffffffffffffff0,%rbx
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movups (%rbx,%rax,1),%xmm0
movups %xmm0,(%r14,%rax,1)
movups -0x10(%rbx,%rax,1),%xmm0
movups %xmm0,-0x10(%r14,%rax,1)
movups -0x20(%rbx,%rax,1),%xmm0
movups %xmm0,-0x20(%r14,%rax,1)
movups -0x30(%rbx,%rax,1),%xmm0
movups %xmm0,-0x30(%r14,%rax,1)
add    $0xffffffffffffffc0,%rax
add    $0xfffffffffffffffc,%r11
jne    1370 <copy_bytes_down+0x270>
neg    %rax
test   %r9,%r9
je     13e5 <copy_bytes_down+0x2e5>
mov    %r8,%rbx
sub    %rax,%rbx
lea    (%rsi,%rbx,1),%r11
add    $0xfffffffffffffff0,%r11
add    %rbx,%rdi
add    $0xfffffffffffffff0,%rdi
shl    $0x4,%r9
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
movups (%r11,%rbx,1),%xmm0
movups %xmm0,(%rdi,%rbx,1)
add    $0xfffffffffffffff0,%rbx
mov    %r9,%rax
add    %rbx,%rax
jne    13d0 <copy_bytes_down+0x2d0>
cmp    %r8,%rcx
je     1310 <copy_bytes_down+0x210>
test   $0xc,%r8b
je     143f <copy_bytes_down+0x33f>
mov    %r8,%r9
and    $0xfffffffffffffffc,%r9
mov    %r9,%r11
neg    %r11
mov    %r10,%rdi
sub    %r9,%rdi
and    $0x3,%edx
lea    (%r8,%rsi,1),%rbx
add    $0xfffffffffffffffc,%rbx
neg    %rcx
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%rbx,%rcx,1),%eax
mov    %eax,-0x4(%r10,%rcx,1)
add    $0xfffffffffffffffc,%rcx
cmp    %rcx,%r11
jne    1420 <copy_bytes_down+0x320>
cmp    %r8,%r9
jne    1276 <copy_bytes_down+0x176>
jmp    1310 <copy_bytes_down+0x210>
and    $0xf,%edx
sub    %rcx,%r10
mov    %r10,%rdi
jmp    1276 <copy_bytes_down+0x176>

LLVM IR (-O0):
define void @copy_bytes_down(i8* %0, i8* %1, i32 %2) {
%4 = alloca i8*
%5 = alloca i8*
%6 = alloca i32
%7 = alloca i32*
%8 = alloca i32*
%9 = alloca i32*
%10 = alloca i8*
store i8* %0, i8** %4
store i8* %1, i8** %5
store i32 %2, i32* %6
%11 = load i8*, i8** %4
%12 = ptrtoint i8* %11 to i32
%13 = sext i32 %12 to i64
%14 = urem i64 %13, 4
%15 = icmp eq i64 %14, 0
br i1 %15, label %16, label %59
16: ; preds = %3
%17 = load i8*, i8** %5
%18 = ptrtoint i8* %17 to i32
%19 = sext i32 %18 to i64
%20 = urem i64 %19, 4
%21 = icmp eq i64 %20, 0
br i1 %21, label %22, label %59
22: ; preds = %16
%23 = load i32, i32* %6
%24 = sext i32 %23 to i64
%25 = urem i64 %24, 4
%26 = icmp eq i64 %25, 0
br i1 %26, label %27, label %59
27: ; preds = %22
%28 = load i32, i32* %6
%29 = sext i32 %28 to i64
%30 = udiv i64 %29, 4
%31 = trunc i64 %30 to i32
store i32 %31, i32* %6
%32 = load i8*, i8** %4
%33 = bitcast i8* %32 to i32*
store i32* %33, i32** %7
%34 = load i8*, i8** %5
%35 = bitcast i8* %34 to i32*
store i32* %35, i32** %8
%36 = load i32*, i32** %8
%37 = getelementptr inbounds i32, i32* %36, i64 -1
store i32* %37, i32** %9
%38 = load i32*, i32** %8
%39 = load i32, i32* %6
%40 = sext i32 %39 to i64
%41 = getelementptr inbounds i32, i32* %38, i64 %40
%42 = getelementptr inbounds i32, i32* %41, i64 -1
store i32* %42, i32** %8
%43 = load i32*, i32** %7
%44 = load i32, i32* %6
%45 = sext i32 %44 to i64
%46 = getelementptr inbounds i32, i32* %43, i64 %45
%47 = getelementptr inbounds i32, i32* %46, i64 -1
store i32* %47, i32** %7
br label %48
48: ; preds = %52, %27
%49 = load i32*, i32** %8
%50 = load i32*, i32** %9
%51 = icmp ne i32* %49, %50
br i1 %51, label %52, label %58
52: ; preds = %48
%53 = load i32*, i32** %8
%54 = getelementptr inbounds i32, i32* %53, i32 -1
store i32* %54, i32** %8
%55 = load i32, i32* %53
%56 = load i32*, i32** %7
%57 = getelementptr inbounds i32, i32* %56, i32 -1
store i32* %57, i32** %7
store i32 %55, i32* %56
br label %48
58: ; preds = %48
br label %83
59: ; preds = %22, %16, %3
%60 = load i8*, i8** %5
%61 = getelementptr inbounds i8, i8* %60, i64 -1
store i8* %61, i8** %10
%62 = load i8*, i8** %5
%63 = load i32, i32* %6
%64 = sext i32 %63 to i64
%65 = getelementptr inbounds i8, i8* %62, i64 %64
%66 = getelementptr inbounds i8, i8* %65, i64 -1
store i8* %66, i8** %5
%67 = load i8*, i8** %4
%68 = load i32, i32* %6
%69 = sext i32 %68 to i64
%70 = getelementptr inbounds i8, i8* %67, i64 %69
%71 = getelementptr inbounds i8, i8* %70, i64 -1
store i8* %71, i8** %4
br label %72
72: ; preds = %76, %59
%73 = load i8*, i8** %5
%74 = load i8*, i8** %10
%75 = icmp ne i8* %73, %74
br i1 %75, label %76, label %82
76: ; preds = %72
%77 = load i8*, i8** %5
%78 = getelementptr inbounds i8, i8* %77, i32 -1
store i8* %78, i8** %5
%79 = load i8, i8* %77
%80 = load i8*, i8** %4
%81 = getelementptr inbounds i8, i8* %80, i32 -1
store i8* %81, i8** %4
store i8 %79, i8* %80
br label %72
82: ; preds = %72
br label %83
83: ; preds = %82, %58
ret void
}

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