void smartcopy(unsigned to, unsigned from, unsigned len) {
  unsigned char *dst = (unsigned char *)to;
  unsigned char *src = (unsigned char *)from;
  if (to < from) {
    for (; len > 0; len--) {
      *dst++ = *src++;
    }
  } else if (to > from) {
    for (src += len, dst += len; len > 0; len--) {
      *--dst = *--src;
    }
  }
}


x86 assembly (clang, -O0):
<smartcopy>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
mov    -0x4(%rbp),%eax
mov    %rax,-0x18(%rbp)
mov    -0x8(%rbp),%eax
mov    %rax,-0x20(%rbp)
mov    -0x4(%rbp),%eax
cmp    -0x8(%rbp),%eax
jae    116b <smartcopy+0x6b>
jmp    112c <smartcopy+0x2c>
cmpl   $0x0,-0xc(%rbp)
jbe    1166 <smartcopy+0x66>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
mov    (%rax),%cl
mov    -0x18(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x18(%rbp)
mov    %cl,(%rax)
mov    -0xc(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xc(%rbp)
jmp    112c <smartcopy+0x2c>
jmp    11dd <smartcopy+0xdd>
mov    -0x4(%rbp),%eax
cmp    -0x8(%rbp),%eax
jbe    11d8 <smartcopy+0xd8>
mov    -0xc(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,%ecx
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0xc(%rbp),%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,%ecx
add    %rcx,%rax
mov    %rax,-0x18(%rbp)
cmpl   $0x0,-0xc(%rbp)
jbe    11d3 <smartcopy+0xd3>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x20(%rbp)
mov    -0x1(%rax),%cl
mov    -0x18(%rbp),%rax
mov    %rax,%rdx
add    $0xffffffffffffffff,%rdx
mov    %rdx,-0x18(%rbp)
mov    %cl,-0x1(%rax)
mov    -0xc(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xc(%rbp)
jmp    1197 <smartcopy+0x97>
jmp    11d8 <smartcopy+0xd8>
jmp    11dd <smartcopy+0xdd>
pop    %rbp
ret

x86 assembly (clang, -O2):
<smartcopy>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %edi,%r11d
mov    %esi,%eax
cmp    %esi,%edi
jae    11e3 <smartcopy+0xe3>
test   %edx,%edx
je     12c0 <smartcopy+0x1c0>
lea    -0x1(%rdx),%r8d
cmp    $0x7,%r8d
jb     114b <smartcopy+0x4b>
lea    (%rax,%r8,1),%rcx
add    $0x1,%rcx
cmp    %r11,%rcx
jbe    12cb <smartcopy+0x1cb>
lea    (%r11,%r8,1),%rcx
add    $0x1,%rcx
cmp    %rax,%rcx
jbe    12cb <smartcopy+0x1cb>
mov    %rax,%rcx
mov    %r11,%rdi
lea    -0x1(%rdx),%eax
test   $0x7,%dl
je     1177 <smartcopy+0x77>
mov    %edx,%ebp
and    $0x7,%ebp
xor    %esi,%esi
movzbl (%rcx,%rsi,1),%ebx
mov    %bl,(%rdi,%rsi,1)
add    $0x1,%rsi
cmp    %esi,%ebp
jne    1160 <smartcopy+0x60>
add    %rsi,%rcx
add    %rsi,%rdi
sub    %esi,%edx
cmp    $0x7,%eax
jb     12c0 <smartcopy+0x1c0>
mov    %edx,%eax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzbl (%rcx,%rdx,1),%ebx
mov    %bl,(%rdi,%rdx,1)
movzbl 0x1(%rcx,%rdx,1),%ebx
mov    %bl,0x1(%rdi,%rdx,1)
movzbl 0x2(%rcx,%rdx,1),%ebx
mov    %bl,0x2(%rdi,%rdx,1)
movzbl 0x3(%rcx,%rdx,1),%ebx
mov    %bl,0x3(%rdi,%rdx,1)
movzbl 0x4(%rcx,%rdx,1),%ebx
mov    %bl,0x4(%rdi,%rdx,1)
movzbl 0x5(%rcx,%rdx,1),%ebx
mov    %bl,0x5(%rdi,%rdx,1)
movzbl 0x6(%rcx,%rdx,1),%ebx
mov    %bl,0x6(%rdi,%rdx,1)
movzbl 0x7(%rcx,%rdx,1),%ebx
mov    %bl,0x7(%rdi,%rdx,1)
add    $0x8,%rdx
cmp    %edx,%eax
jne    1190 <smartcopy+0x90>
jmp    12c0 <smartcopy+0x1c0>
jbe    12c0 <smartcopy+0x1c0>
test   %edx,%edx
je     12c0 <smartcopy+0x1c0>
mov    %edx,%r15d
lea    (%r11,%r15,1),%r10
lea    (%rax,%r15,1),%r13
lea    -0x1(%rdx),%r8d
cmp    $0x3,%r8d
jb     1228 <smartcopy+0x128>
mov    %r8,%rcx
not    %rcx
add    %r15,%rcx
lea    (%r11,%rcx,1),%rsi
cmp    %r13,%rsi
jae    12e2 <smartcopy+0x1e2>
add    %rax,%rcx
cmp    %r10,%rcx
jae    12e2 <smartcopy+0x1e2>
mov    %r13,%rax
mov    %r10,%rcx
lea    -0x1(%rdx),%esi
mov    %edx,%edi
and    $0x7,%edi
je     125a <smartcopy+0x15a>
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
movzbl -0x1(%rax),%r8d
add    $0xffffffffffffffff,%rax
mov    %r8b,-0x1(%rcx)
add    $0xffffffffffffffff,%rcx
add    $0x1,%ebx
cmp    %ebx,%edi
jne    1240 <smartcopy+0x140>
sub    %ebx,%edx
cmp    $0x7,%esi
jb     12c0 <smartcopy+0x1c0>
neg    %edx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movzbl -0x1(%rax,%rsi,1),%ebx
mov    %bl,-0x1(%rcx,%rsi,1)
movzbl -0x2(%rax,%rsi,1),%ebx
mov    %bl,-0x2(%rcx,%rsi,1)
movzbl -0x3(%rax,%rsi,1),%ebx
mov    %bl,-0x3(%rcx,%rsi,1)
movzbl -0x4(%rax,%rsi,1),%ebx
mov    %bl,-0x4(%rcx,%rsi,1)
movzbl -0x5(%rax,%rsi,1),%ebx
mov    %bl,-0x5(%rcx,%rsi,1)
movzbl -0x6(%rax,%rsi,1),%ebx
mov    %bl,-0x6(%rcx,%rsi,1)
movzbl -0x7(%rax,%rsi,1),%ebx
mov    %bl,-0x7(%rcx,%rsi,1)
movzbl -0x8(%rax,%rsi,1),%ebx
mov    %bl,-0x8(%rcx,%rsi,1)
add    $0xfffffffffffffff8,%rsi
cmp    %esi,%edx
jne    1270 <smartcopy+0x170>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
movabs $0x1ffffffe0,%r9
cmp    $0x1f,%r8d
jae    12f9 <smartcopy+0x1f9>
xor    %esi,%esi
jmp    140e <smartcopy+0x30e>
movabs $0x1ffffffe0,%r9
cmp    $0xf,%r8d
jae    1324 <smartcopy+0x224>
xor    %esi,%esi
jmp    14e3 <smartcopy+0x3e3>
lea    0x1(%r8),%r10
mov    %r10,%rsi
and    %r9,%rsi
lea    -0x20(%rsi),%rcx
mov    %rcx,%rdi
shr    $0x5,%rdi
add    $0x1,%rdi
mov    %edi,%ebx
and    $0x3,%ebx
cmp    $0x60,%rcx
jae    1356 <smartcopy+0x256>
xor    %ecx,%ecx
jmp    13c0 <smartcopy+0x2c0>
lea    0x1(%r8),%r14
lea    0x10(%r9),%rsi
and    %r14,%rsi
lea    -0x10(%rsi),%rcx
mov    %rcx,%rbx
shr    $0x4,%rbx
add    $0x1,%rbx
mov    %ebx,%r12d
and    $0x3,%r12d
cmp    $0x30,%rcx
jae    144f <smartcopy+0x34f>
xor    %ecx,%ecx
jmp    1494 <smartcopy+0x394>
and    $0xfffffffffffffffc,%rdi
xor    %ecx,%ecx
nopl   0x0(%rax)
movups (%rax,%rcx,1),%xmm0
movups 0x10(%rax,%rcx,1),%xmm1
movups %xmm0,(%r11,%rcx,1)
movups %xmm1,0x10(%r11,%rcx,1)
movups 0x20(%rax,%rcx,1),%xmm0
movups 0x30(%rax,%rcx,1),%xmm1
movups %xmm0,0x20(%r11,%rcx,1)
movups %xmm1,0x30(%r11,%rcx,1)
movups 0x40(%rax,%rcx,1),%xmm0
movups 0x50(%rax,%rcx,1),%xmm1
movups %xmm0,0x40(%r11,%rcx,1)
movups %xmm1,0x50(%r11,%rcx,1)
movups 0x60(%rax,%rcx,1),%xmm0
movups 0x70(%rax,%rcx,1),%xmm1
movups %xmm0,0x60(%r11,%rcx,1)
movups %xmm1,0x70(%r11,%rcx,1)
sub    $0xffffffffffffff80,%rcx
add    $0xfffffffffffffffc,%rdi
jne    1360 <smartcopy+0x260>
test   %rbx,%rbx
je     13fb <smartcopy+0x2fb>
lea    (%r11,%rcx,1),%rdi
add    $0x10,%rdi
add    %rax,%rcx
add    $0x10,%rcx
shl    $0x5,%rbx
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movups -0x10(%rcx,%rbp,1),%xmm0
movups (%rcx,%rbp,1),%xmm1
movups %xmm0,-0x10(%rdi,%rbp,1)
movups %xmm1,(%rdi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rbx
jne    13e0 <smartcopy+0x2e0>
cmp    %rsi,%r10
je     12c0 <smartcopy+0x1c0>
test   $0x18,%r10b
je     1531 <smartcopy+0x431>
add    $0x1,%r8
add    $0x18,%r9
and    %r8,%r9
lea    (%rax,%r9,1),%rcx
lea    (%r11,%r9,1),%rdi
sub    %r9d,%edx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%rax,%rsi,1),%rbp
mov    %rbp,(%r11,%rsi,1)
add    $0x8,%rsi
cmp    %rsi,%r9
jne    1430 <smartcopy+0x330>
cmp    %r9,%r8
jne    1151 <smartcopy+0x51>
jmp    12c0 <smartcopy+0x1c0>
and    $0xfffffffffffffffc,%rbx
lea    -0x10(%r13),%rdi
lea    -0x10(%r10),%rbp
xor    %ecx,%ecx
nopl   (%rax)
movups (%rdi,%rcx,1),%xmm0
movups %xmm0,0x0(%rbp,%rcx,1)
movups -0x10(%rdi,%rcx,1),%xmm0
movups %xmm0,-0x10(%rbp,%rcx,1)
movups -0x20(%rdi,%rcx,1),%xmm0
movups %xmm0,-0x20(%rbp,%rcx,1)
movups -0x30(%rdi,%rcx,1),%xmm0
movups %xmm0,-0x30(%rbp,%rcx,1)
add    $0xffffffffffffffc0,%rcx
add    $0xfffffffffffffffc,%rbx
jne    1460 <smartcopy+0x360>
neg    %rcx
test   %r12,%r12
je     14d4 <smartcopy+0x3d4>
sub    %rcx,%r15
lea    (%r11,%r15,1),%rcx
add    $0xfffffffffffffff0,%rcx
add    %r15,%rax
add    $0xfffffffffffffff0,%rax
shl    $0x4,%r12
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups (%rax,%rdi,1),%xmm0
movups %xmm0,(%rcx,%rdi,1)
add    $0xfffffffffffffff0,%rdi
mov    %r12,%rbp
add    %rdi,%rbp
jne    14c0 <smartcopy+0x3c0>
cmp    %rsi,%r14
je     12c0 <smartcopy+0x1c0>
test   $0xc,%r14b
je     153e <smartcopy+0x43e>
add    $0x1,%r8
add    $0x1c,%r9
and    %r8,%r9
mov    %r9,%rdi
neg    %rdi
mov    %r13,%rax
sub    %r9,%rax
mov    %r10,%rcx
sub    %r9,%rcx
sub    %r9d,%edx
neg    %rsi
cs nopw 0x0(%rax,%rax,1)
mov    -0x4(%r13,%rsi,1),%ebp
mov    %ebp,-0x4(%r10,%rsi,1)
add    $0xfffffffffffffffc,%rsi
cmp    %rsi,%rdi
jne    1510 <smartcopy+0x410>
cmp    %r9,%r8
jne    122e <smartcopy+0x12e>
jmp    12c0 <smartcopy+0x1c0>
sub    %esi,%edx
add    %rsi,%r11
add    %rsi,%rax
jmp    114b <smartcopy+0x4b>
sub    %esi,%edx
sub    %rsi,%r10
sub    %rsi,%r13
jmp    1228 <smartcopy+0x128>

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

LLVM IR (-O2):
define void @smartcopy(i32 %0, i32 %1, i32 %2) {
%4 = zext i32 %0 to i64
%5 = inttoptr i64 %4 to i8*
%6 = zext i32 %1 to i64
%7 = inttoptr i64 %6 to i8*
%8 = icmp ult i32 %0, %1
br i1 %8, label %9, label %187
9: ; preds = %3
%10 = icmp eq i32 %2, 0
br i1 %10, label %384, label %11
11: ; preds = %9
%12 = add i32 %2, -1
%13 = zext i32 %12 to i64
%14 = add nuw nsw i64 %13, 1
%15 = icmp ult i32 %12, 7
br i1 %15, label %134, label %16
16: ; preds = %11
%17 = add i32 %2, -1
%18 = zext i32 %17 to i64
%19 = add nuw nsw i64 %18, 1
%20 = getelementptr i8, i8* %5, i64 %19
%21 = getelementptr i8, i8* %7, i64 %19
%22 = icmp ugt i8* %21, %5
%23 = icmp ugt i8* %20, %7
%24 = and i1 %22, %23
br i1 %24, label %134, label %25
25: ; preds = %16
%26 = icmp ult i32 %12, 31
br i1 %26, label %113, label %27
27: ; preds = %25
%28 = and i64 %14, 8589934560
%29 = add nsw i64 %28, -32
%30 = lshr exact i64 %29, 5
%31 = add nuw nsw i64 %30, 1
%32 = and i64 %31, 3
%33 = icmp ult i64 %29, 96
br i1 %33, label %85, label %34
34: ; preds = %27
%35 = and i64 %31, 1152921504606846972
br label %36
36: ; preds = %36, %34
%37 = phi i64 [ 0, %34 ], [ %82, %36 ]
%38 = phi i64 [ 0, %34 ], [ %83, %36 ]
%39 = getelementptr i8, i8* %7, i64 %37
%40 = getelementptr i8, i8* %5, i64 %37
%41 = bitcast i8* %39 to <16 x i8>*
%42 = load <16 x i8>, <16 x i8>* %41
%43 = getelementptr i8, i8* %39, i64 16
%44 = bitcast i8* %43 to <16 x i8>*
%45 = load <16 x i8>, <16 x i8>* %44
%46 = bitcast i8* %40 to <16 x i8>*
store <16 x i8> %42, <16 x i8>* %46
%47 = getelementptr i8, i8* %40, i64 16
%48 = bitcast i8* %47 to <16 x i8>*
store <16 x i8> %45, <16 x i8>* %48
%49 = or i64 %37, 32
%50 = getelementptr i8, i8* %7, i64 %49
%51 = getelementptr i8, i8* %5, i64 %49
%52 = bitcast i8* %50 to <16 x i8>*
%53 = load <16 x i8>, <16 x i8>* %52
%54 = getelementptr i8, i8* %50, i64 16
%55 = bitcast i8* %54 to <16 x i8>*
%56 = load <16 x i8>, <16 x i8>* %55
%57 = bitcast i8* %51 to <16 x i8>*
store <16 x i8> %53, <16 x i8>* %57
%58 = getelementptr i8, i8* %51, i64 16
%59 = bitcast i8* %58 to <16 x i8>*
store <16 x i8> %56, <16 x i8>* %59
%60 = or i64 %37, 64
%61 = getelementptr i8, i8* %7, i64 %60
%62 = getelementptr i8, i8* %5, i64 %60
%63 = bitcast i8* %61 to <16 x i8>*
%64 = load <16 x i8>, <16 x i8>* %63
%65 = getelementptr i8, i8* %61, i64 16
%66 = bitcast i8* %65 to <16 x i8>*
%67 = load <16 x i8>, <16 x i8>* %66
%68 = bitcast i8* %62 to <16 x i8>*
store <16 x i8> %64, <16 x i8>* %68
%69 = getelementptr i8, i8* %62, i64 16
%70 = bitcast i8* %69 to <16 x i8>*
store <16 x i8> %67, <16 x i8>* %70
%71 = or i64 %37, 96
%72 = getelementptr i8, i8* %7, i64 %71
%73 = getelementptr i8, i8* %5, i64 %71
%74 = bitcast i8* %72 to <16 x i8>*
%75 = load <16 x i8>, <16 x i8>* %74
%76 = getelementptr i8, i8* %72, i64 16
%77 = bitcast i8* %76 to <16 x i8>*
%78 = load <16 x i8>, <16 x i8>* %77
%79 = bitcast i8* %73 to <16 x i8>*
store <16 x i8> %75, <16 x i8>* %79
%80 = getelementptr i8, i8* %73, i64 16
%81 = bitcast i8* %80 to <16 x i8>*
store <16 x i8> %78, <16 x i8>* %81
%82 = add nuw i64 %37, 128
%83 = add i64 %38, 4
%84 = icmp eq i64 %83, %35
br i1 %84, label %85, label %36
85: ; preds = %36, %27
%86 = phi i64 [ 0, %27 ], [ %82, %36 ]
%87 = icmp eq i64 %32, 0
br i1 %87, label %104, label %88
88: ; preds = %85, %88
%89 = phi i64 [ %101, %88 ], [ %86, %85 ]
%90 = phi i64 [ %102, %88 ], [ 0, %85 ]
%91 = getelementptr i8, i8* %7, i64 %89
%92 = getelementptr i8, i8* %5, i64 %89
%93 = bitcast i8* %91 to <16 x i8>*
%94 = load <16 x i8>, <16 x i8>* %93
%95 = getelementptr i8, i8* %91, i64 16
%96 = bitcast i8* %95 to <16 x i8>*
%97 = load <16 x i8>, <16 x i8>* %96
%98 = bitcast i8* %92 to <16 x i8>*
store <16 x i8> %94, <16 x i8>* %98
%99 = getelementptr i8, i8* %92, i64 16
%100 = bitcast i8* %99 to <16 x i8>*
store <16 x i8> %97, <16 x i8>* %100
%101 = add nuw i64 %89, 32
%102 = add i64 %90, 1
%103 = icmp eq i64 %102, %32
br i1 %103, label %104, label %88
104: ; preds = %88, %85
%105 = icmp eq i64 %14, %28
br i1 %105, label %384, label %106
106: ; preds = %104
%107 = trunc i64 %28 to i32
%108 = sub i32 %2, %107
%109 = getelementptr i8, i8* %5, i64 %28
%110 = getelementptr i8, i8* %7, i64 %28
%111 = and i64 %14, 24
%112 = icmp eq i64 %111, 0
br i1 %112, label %134, label %113
113: ; preds = %25, %106
%114 = phi i64 [ %28, %106 ], [ 0, %25 ]
%115 = add i32 %2, -1
%116 = zext i32 %115 to i64
%117 = add nuw nsw i64 %116, 1
%118 = and i64 %117, 8589934584
%119 = getelementptr i8, i8* %7, i64 %118
%120 = getelementptr i8, i8* %5, i64 %118
%121 = trunc i64 %118 to i32
%122 = sub i32 %2, %121
br label %123
123: ; preds = %123, %113
%124 = phi i64 [ %114, %113 ], [ %130, %123 ]
%125 = getelementptr i8, i8* %7, i64 %124
%126 = getelementptr i8, i8* %5, i64 %124
%127 = bitcast i8* %125 to <8 x i8>*
%128 = load <8 x i8>, <8 x i8>* %127
%129 = bitcast i8* %126 to <8 x i8>*
store <8 x i8> %128, <8 x i8>* %129
%130 = add nuw i64 %124, 8
%131 = icmp eq i64 %130, %118
br i1 %131, label %132, label %123
132: ; preds = %123
%133 = icmp eq i64 %117, %118
br i1 %133, label %384, label %134
134: ; preds = %16, %11, %106, %132
%135 = phi i8* [ %7, %11 ], [ %7, %16 ], [ %110, %106 ], [ %119, %132 ]
%136 = phi i8* [ %5, %11 ], [ %5, %16 ], [ %109, %106 ], [ %120, %132 ]
%137 = phi i32 [ %2, %11 ], [ %2, %16 ], [ %108, %106 ], [ %122, %132 ]
%138 = add i32 %137, -1
%139 = and i32 %137, 7
%140 = icmp eq i32 %139, 0
br i1 %140, label %152, label %141
141: ; preds = %134, %141
%142 = phi i8* [ %146, %141 ], [ %135, %134 ]
%143 = phi i8* [ %148, %141 ], [ %136, %134 ]
%144 = phi i32 [ %149, %141 ], [ %137, %134 ]
%145 = phi i32 [ %150, %141 ], [ 0, %134 ]
%146 = getelementptr inbounds i8, i8* %142, i64 1
%147 = load i8, i8* %142
%148 = getelementptr inbounds i8, i8* %143, i64 1
store i8 %147, i8* %143
%149 = add i32 %144, -1
%150 = add i32 %145, 1
%151 = icmp eq i32 %150, %139
br i1 %151, label %152, label %141
152: ; preds = %141, %134
%153 = phi i8* [ %135, %134 ], [ %146, %141 ]
%154 = phi i8* [ %136, %134 ], [ %148, %141 ]
%155 = phi i32 [ %137, %134 ], [ %149, %141 ]
%156 = icmp ult i32 %138, 7
br i1 %156, label %384, label %157
157: ; preds = %152, %157
%158 = phi i8* [ %182, %157 ], [ %153, %152 ]
%159 = phi i8* [ %184, %157 ], [ %154, %152 ]
%160 = phi i32 [ %185, %157 ], [ %155, %152 ]
%161 = getelementptr inbounds i8, i8* %158, i64 1
%162 = load i8, i8* %158
%163 = getelementptr inbounds i8, i8* %159, i64 1
store i8 %162, i8* %159
%164 = getelementptr inbounds i8, i8* %158, i64 2
%165 = load i8, i8* %161
%166 = getelementptr inbounds i8, i8* %159, i64 2
store i8 %165, i8* %163
%167 = getelementptr inbounds i8, i8* %158, i64 3
%168 = load i8, i8* %164
%169 = getelementptr inbounds i8, i8* %159, i64 3
store i8 %168, i8* %166
%170 = getelementptr inbounds i8, i8* %158, i64 4
%171 = load i8, i8* %167
%172 = getelementptr inbounds i8, i8* %159, i64 4
store i8 %171, i8* %169
%173 = getelementptr inbounds i8, i8* %158, i64 5
%174 = load i8, i8* %170
%175 = getelementptr inbounds i8, i8* %159, i64 5
store i8 %174, i8* %172
%176 = getelementptr inbounds i8, i8* %158, i64 6
%177 = load i8, i8* %173
%178 = getelementptr inbounds i8, i8* %159, i64 6
store i8 %177, i8* %175
%179 = getelementptr inbounds i8, i8* %158, i64 7
%180 = load i8, i8* %176
%181 = getelementptr inbounds i8, i8* %159, i64 7
store i8 %180, i8* %178
%182 = getelementptr inbounds i8, i8* %158, i64 8
%183 = load i8, i8* %179
%184 = getelementptr inbounds i8, i8* %159, i64 8
store i8 %183, i8* %181
%185 = add i32 %160, -8
%186 = icmp eq i32 %185, 0
br i1 %186, label %384, label %157
187: ; preds = %3
%188 = icmp ule i32 %0, %1
%189 = zext i32 %2 to i64
%190 = icmp eq i32 %2, 0
%191 = or i1 %188, %190
br i1 %191, label %384, label %192
192: ; preds = %187
%193 = getelementptr i8, i8* %5, i64 %189
%194 = getelementptr i8, i8* %7, i64 %189
%195 = add i32 %2, -1
%196 = zext i32 %195 to i64
%197 = add nuw nsw i64 %196, 1
%198 = icmp ult i32 %195, 3
br i1 %198, label %331, label %199
199: ; preds = %192
%200 = add i32 %2, -1
%201 = zext i32 %200 to i64
%202 = xor i64 %201, -1
%203 = add nsw i64 %202, %189
%204 = getelementptr i8, i8* %5, i64 %203
%205 = getelementptr i8, i8* %7, i64 %203
%206 = icmp ult i8* %204, %194
%207 = icmp ult i8* %205, %193
%208 = and i1 %206, %207
br i1 %208, label %331, label %209
209: ; preds = %199
%210 = icmp ult i32 %195, 15
br i1 %210, label %302, label %211
211: ; preds = %209
%212 = and i64 %197, 8589934576
%213 = add nsw i64 %212, -16
%214 = lshr exact i64 %213, 4
%215 = add nuw nsw i64 %214, 1
%216 = and i64 %215, 3
%217 = icmp ult i64 %213, 48
br i1 %217, label %270, label %218
218: ; preds = %211
%219 = and i64 %215, 2305843009213693948
%220 = getelementptr i8, i8* %194, i64 -1
%221 = getelementptr i8, i8* %193, i64 -1
%222 = getelementptr inbounds i8, i8* %220, i64 -15
%223 = getelementptr inbounds i8, i8* %221, i64 -15
%224 = getelementptr i8, i8* %194, i64 -1
%225 = getelementptr i8, i8* %193, i64 -1
%226 = getelementptr inbounds i8, i8* %224, i64 -15
%227 = getelementptr inbounds i8, i8* %225, i64 -15
%228 = getelementptr i8, i8* %194, i64 -1
%229 = getelementptr i8, i8* %193, i64 -1
%230 = getelementptr inbounds i8, i8* %228, i64 -15
%231 = getelementptr inbounds i8, i8* %229, i64 -15
%232 = getelementptr i8, i8* %194, i64 -1
%233 = getelementptr i8, i8* %193, i64 -1
%234 = getelementptr inbounds i8, i8* %232, i64 -15
%235 = getelementptr inbounds i8, i8* %233, i64 -15
br label %236
236: ; preds = %236, %218
%237 = phi i64 [ 0, %218 ], [ %267, %236 ]
%238 = phi i64 [ 0, %218 ], [ %268, %236 ]
%239 = sub i64 0, %237
%240 = sub i64 0, %237
%241 = getelementptr inbounds i8, i8* %222, i64 %239
%242 = bitcast i8* %241 to <16 x i8>*
%243 = load <16 x i8>, <16 x i8>* %242
%244 = getelementptr inbounds i8, i8* %223, i64 %240
%245 = bitcast i8* %244 to <16 x i8>*
store <16 x i8> %243, <16 x i8>* %245
%246 = sub nuw nsw i64 -16, %237
%247 = sub nuw nsw i64 -16, %237
%248 = getelementptr inbounds i8, i8* %226, i64 %246
%249 = bitcast i8* %248 to <16 x i8>*
%250 = load <16 x i8>, <16 x i8>* %249
%251 = getelementptr inbounds i8, i8* %227, i64 %247
%252 = bitcast i8* %251 to <16 x i8>*
store <16 x i8> %250, <16 x i8>* %252
%253 = sub nuw nsw i64 -32, %237
%254 = sub nuw nsw i64 -32, %237
%255 = getelementptr inbounds i8, i8* %230, i64 %253
%256 = bitcast i8* %255 to <16 x i8>*
%257 = load <16 x i8>, <16 x i8>* %256
%258 = getelementptr inbounds i8, i8* %231, i64 %254
%259 = bitcast i8* %258 to <16 x i8>*
store <16 x i8> %257, <16 x i8>* %259
%260 = sub nuw nsw i64 -48, %237
%261 = sub nuw nsw i64 -48, %237
%262 = getelementptr inbounds i8, i8* %234, i64 %260
%263 = bitcast i8* %262 to <16 x i8>*
%264 = load <16 x i8>, <16 x i8>* %263
%265 = getelementptr inbounds i8, i8* %235, i64 %261
%266 = bitcast i8* %265 to <16 x i8>*
store <16 x i8> %264, <16 x i8>* %266
%267 = add nuw i64 %237, 64
%268 = add i64 %238, 4
%269 = icmp eq i64 %268, %219
br i1 %269, label %270, label %236
270: ; preds = %236, %211
%271 = phi i64 [ 0, %211 ], [ %267, %236 ]
%272 = icmp eq i64 %216, 0
br i1 %272, label %291, label %273
273: ; preds = %270
%274 = getelementptr i8, i8* %194, i64 -1
%275 = getelementptr i8, i8* %193, i64 -1
%276 = getelementptr inbounds i8, i8* %274, i64 -15
%277 = getelementptr inbounds i8, i8* %275, i64 -15
br label %278
278: ; preds = %278, %273
%279 = phi i64 [ %271, %273 ], [ %288, %278 ]
%280 = phi i64 [ 0, %273 ], [ %289, %278 ]
%281 = sub i64 0, %279
%282 = sub i64 0, %279
%283 = getelementptr inbounds i8, i8* %276, i64 %281
%284 = bitcast i8* %283 to <16 x i8>*
%285 = load <16 x i8>, <16 x i8>* %284
%286 = getelementptr inbounds i8, i8* %277, i64 %282
%287 = bitcast i8* %286 to <16 x i8>*
store <16 x i8> %285, <16 x i8>* %287
%288 = add nuw i64 %279, 16
%289 = add i64 %280, 1
%290 = icmp eq i64 %289, %216
br i1 %290, label %291, label %278
291: ; preds = %278, %270
%292 = icmp eq i64 %197, %212
br i1 %292, label %384, label %293
293: ; preds = %291
%294 = trunc i64 %212 to i32
%295 = sub i32 %2, %294
%296 = sub nsw i64 0, %212
%297 = getelementptr i8, i8* %193, i64 %296
%298 = sub nsw i64 0, %212
%299 = getelementptr i8, i8* %194, i64 %298
%300 = and i64 %197, 12
%301 = icmp eq i64 %300, 0
br i1 %301, label %331, label %302
302: ; preds = %209, %293
%303 = phi i64 [ %212, %293 ], [ 0, %209 ]
%304 = add i32 %2, -1
%305 = zext i32 %304 to i64
%306 = add nuw nsw i64 %305, 1
%307 = and i64 %306, 8589934588
%308 = sub nsw i64 0, %307
%309 = getelementptr i8, i8* %194, i64 %308
%310 = sub nsw i64 0, %307
%311 = getelementptr i8, i8* %193, i64 %310
%312 = trunc i64 %307 to i32
%313 = sub i32 %2, %312
%314 = getelementptr i8, i8* %194, i64 -1
%315 = getelementptr i8, i8* %193, i64 -1
%316 = getelementptr inbounds i8, i8* %314, i64 -3
%317 = getelementptr inbounds i8, i8* %315, i64 -3
br label %318
318: ; preds = %318, %302
%319 = phi i64 [ %303, %302 ], [ %327, %318 ]
%320 = sub i64 0, %319
%321 = sub i64 0, %319
%322 = getelementptr inbounds i8, i8* %316, i64 %320
%323 = bitcast i8* %322 to <4 x i8>*
%324 = load <4 x i8>, <4 x i8>* %323
%325 = getelementptr inbounds i8, i8* %317, i64 %321
%326 = bitcast i8* %325 to <4 x i8>*
store <4 x i8> %324, <4 x i8>* %326
%327 = add nuw i64 %319, 4
%328 = icmp eq i64 %327, %307
br i1 %328, label %329, label %318
329: ; preds = %318
%330 = icmp eq i64 %306, %307
br i1 %330, label %384, label %331
331: ; preds = %199, %192, %293, %329
%332 = phi i8* [ %194, %192 ], [ %194, %199 ], [ %299, %293 ], [ %309, %329 ]
%333 = phi i8* [ %193, %192 ], [ %193, %199 ], [ %297, %293 ], [ %311, %329 ]
%334 = phi i32 [ %2, %192 ], [ %2, %199 ], [ %295, %293 ], [ %313, %329 ]
%335 = add i32 %334, -1
%336 = and i32 %334, 7
%337 = icmp eq i32 %336, 0
br i1 %337, label %349, label %338
338: ; preds = %331, %338
%339 = phi i8* [ %343, %338 ], [ %332, %331 ]
%340 = phi i8* [ %345, %338 ], [ %333, %331 ]
%341 = phi i32 [ %346, %338 ], [ %334, %331 ]
%342 = phi i32 [ %347, %338 ], [ 0, %331 ]
%343 = getelementptr inbounds i8, i8* %339, i64 -1
%344 = load i8, i8* %343
%345 = getelementptr inbounds i8, i8* %340, i64 -1
store i8 %344, i8* %345
%346 = add i32 %341, -1
%347 = add i32 %342, 1
%348 = icmp eq i32 %347, %336
br i1 %348, label %349, label %338
349: ; preds = %338, %331
%350 = phi i8* [ %332, %331 ], [ %343, %338 ]
%351 = phi i8* [ %333, %331 ], [ %345, %338 ]
%352 = phi i32 [ %334, %331 ], [ %346, %338 ]
%353 = icmp ult i32 %335, 7
br i1 %353, label %384, label %354
354: ; preds = %349, %354
%355 = phi i8* [ %379, %354 ], [ %350, %349 ]
%356 = phi i8* [ %381, %354 ], [ %351, %349 ]
%357 = phi i32 [ %382, %354 ], [ %352, %349 ]
%358 = getelementptr inbounds i8, i8* %355, i64 -1
%359 = load i8, i8* %358
%360 = getelementptr inbounds i8, i8* %356, i64 -1
store i8 %359, i8* %360
%361 = getelementptr inbounds i8, i8* %355, i64 -2
%362 = load i8, i8* %361
%363 = getelementptr inbounds i8, i8* %356, i64 -2
store i8 %362, i8* %363
%364 = getelementptr inbounds i8, i8* %355, i64 -3
%365 = load i8, i8* %364
%366 = getelementptr inbounds i8, i8* %356, i64 -3
store i8 %365, i8* %366
%367 = getelementptr inbounds i8, i8* %355, i64 -4
%368 = load i8, i8* %367
%369 = getelementptr inbounds i8, i8* %356, i64 -4
store i8 %368, i8* %369
%370 = getelementptr inbounds i8, i8* %355, i64 -5
%371 = load i8, i8* %370
%372 = getelementptr inbounds i8, i8* %356, i64 -5
store i8 %371, i8* %372
%373 = getelementptr inbounds i8, i8* %355, i64 -6
%374 = load i8, i8* %373
%375 = getelementptr inbounds i8, i8* %356, i64 -6
store i8 %374, i8* %375
%376 = getelementptr inbounds i8, i8* %355, i64 -7
%377 = load i8, i8* %376
%378 = getelementptr inbounds i8, i8* %356, i64 -7
store i8 %377, i8* %378
%379 = getelementptr inbounds i8, i8* %355, i64 -8
%380 = load i8, i8* %379
%381 = getelementptr inbounds i8, i8* %356, i64 -8
store i8 %380, i8* %381
%382 = add i32 %357, -8
%383 = icmp eq i32 %382, 0
br i1 %383, label %384, label %354
384: ; preds = %349, %354, %152, %157, %291, %329, %104, %132, %9, %187
ret void
}