void backmove2(register char *from, register char *to, register int length) {
  int i;
  from += length;
  to += length;
  if (length >= 8 &&
      !(((long)((long *)from) | (long)((long *)to)) & (sizeof(long) - 1))) {
    length -= 4;
    do {
      *--to = *--from;
      length -= 4;
    } while (length > 0);
    length = 4 + length;
  }
  i = -1;
  while (i >= -length) {
    to[i] = from[i];
    i--;
  }
}


x86 assembly (clang, -O0):
<backmove2>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
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)
cmpl   $0x8,-0x14(%rbp)
jl     119d <backmove2+0x9d>
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%rcx
or     %rcx,%rax
and    $0x7,%rax
cmp    $0x0,%rax
jne    119d <backmove2+0x9d>
mov    -0x14(%rbp),%eax
sub    $0x4,%eax
mov    %eax,-0x14(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x8(%rbp)
mov    -0x1(%rax),%cl
mov    -0x10(%rbp),%rax
mov    %rax,%rdx
add    $0xffffffffffffffff,%rdx
mov    %rdx,-0x10(%rbp)
mov    %cl,-0x1(%rax)
mov    -0x14(%rbp),%eax
sub    $0x4,%eax
mov    %eax,-0x14(%rbp)
cmpl   $0x0,-0x14(%rbp)
jg     115d <backmove2+0x5d>
mov    -0x14(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x14(%rbp)
movl   $0xffffffff,-0x18(%rbp)
mov    -0x18(%rbp),%eax
xor    %ecx,%ecx
sub    -0x14(%rbp),%ecx
cmp    %ecx,%eax
jl     11d8 <backmove2+0xd8>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,1),%dl
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x18(%rbp)
jmp    11a4 <backmove2+0xa4>
pop    %rbp
ret

x86 assembly (clang, -O2):
<backmove2>:
push   %rbp
push   %r15
push   %r14
push   %rbx
movslq %edx,%r9
lea    (%rdi,%r9,1),%rbp
lea    (%rsi,%r9,1),%rcx
cmp    $0x8,%r9d
jl     1196 <backmove2+0x96>
mov    %ebp,%eax
or     %ecx,%eax
test   $0x7,%al
jne    1269 <backmove2+0x169>
xor    %ebx,%ebx
mov    %edx,%r8d
sub    $0x8,%r8d
cmovb  %ebx,%r8d
add    $0x3,%r8d
cmp    $0x3c,%r8d
jb     1242 <backmove2+0x142>
mov    %edx,%eax
sub    $0x8,%eax
cmovb  %ebx,%eax
add    $0x3,%eax
shr    $0x2,%eax
not    %rax
add    %r9,%rax
lea    (%rsi,%rax,1),%rbx
cmp    %rbp,%rbx
jae    1167 <backmove2+0x67>
add    %rdi,%rax
cmp    %rcx,%rax
jb     1242 <backmove2+0x142>
shr    $0x2,%r8d
add    $0x1,%r8d
mov    %r8d,%r10d
and    $0xfffffff0,%r10d
lea    -0x10(%r10),%rax
mov    %rax,%r14
shr    $0x4,%r14
add    $0x1,%r14
mov    %r14d,%r11d
and    $0x3,%r11d
cmp    $0x30,%rax
jae    11a3 <backmove2+0xa3>
xor    %ebx,%ebx
jmp    11f7 <backmove2+0xf7>
test   %edx,%edx
jg     1269 <backmove2+0x169>
jmp    13f2 <backmove2+0x2f2>
and    $0xfffffffffffffffc,%r14
lea    -0x10(%rbp),%r15
lea    -0x10(%rcx),%rax
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups (%r15,%rbx,1),%xmm0
movups %xmm0,(%rax,%rbx,1)
movups -0x10(%r15,%rbx,1),%xmm0
movups %xmm0,-0x10(%rax,%rbx,1)
movups -0x20(%r15,%rbx,1),%xmm0
movups %xmm0,-0x20(%rax,%rbx,1)
movups -0x30(%r15,%rbx,1),%xmm0
movups %xmm0,-0x30(%rax,%rbx,1)
add    $0xffffffffffffffc0,%rbx
add    $0xfffffffffffffffc,%r14
jne    11c0 <backmove2+0xc0>
neg    %rbx
lea    0x0(,%r10,4),%r14d
test   %r11,%r11
je     1234 <backmove2+0x134>
sub    %rbx,%r9
add    %r9,%rsi
add    $0xfffffffffffffff0,%rsi
add    %r9,%rdi
add    $0xfffffffffffffff0,%rdi
shl    $0x4,%r11
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movups (%rdi,%rbx,1),%xmm0
movups %xmm0,(%rsi,%rbx,1)
add    $0xfffffffffffffff0,%rbx
mov    %r11,%rax
add    %rbx,%rax
jne    1220 <backmove2+0x120>
sub    %r10,%rbp
sub    %r10,%rcx
sub    %r14d,%edx
cmp    %r8,%r10
je     1269 <backmove2+0x169>
mov    %edx,%esi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    -0x4(%rsi),%edx
movzbl -0x1(%rbp),%eax
add    $0xffffffffffffffff,%rbp
mov    %al,-0x1(%rcx)
add    $0xffffffffffffffff,%rcx
cmp    $0x8,%esi
mov    %edx,%esi
ja     1250 <backmove2+0x150>
neg    %edx
movslq %edx,%rdx
cmp    $0xffffffffffffffff,%rdx
mov    $0xffffffffffffffff,%rsi
mov    $0xffffffffffffffff,%r9
cmovl  %rdx,%r9
neg    %r9
cmp    $0x4,%r9
jb     13ce <backmove2+0x2ce>
cmp    $0xffffffffffffffff,%rdx
mov    $0xffffffffffffffff,%rsi
mov    $0xffffffffffffffff,%rdi
cmovl  %rdx,%rdi
lea    (%rcx,%rdi,1),%rax
cmp    %rbp,%rax
jae    12bc <backmove2+0x1bc>
add    %rbp,%rdi
cmp    %rcx,%rdi
jb     13ce <backmove2+0x2ce>
cmp    $0x10,%r9
jae    12c9 <backmove2+0x1c9>
xor    %edi,%edi
jmp    1380 <backmove2+0x280>
mov    %r9,%rdi
and    $0xfffffffffffffff0,%rdi
lea    -0x10(%rdi),%rax
mov    %rax,%rbx
shr    $0x4,%rbx
add    $0x1,%rbx
mov    %ebx,%r8d
and    $0x3,%r8d
cmp    $0x30,%rax
jae    12f0 <backmove2+0x1f0>
xor    %esi,%esi
jmp    1335 <backmove2+0x235>
and    $0xfffffffffffffffc,%rbx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
movups -0x10(%rbp,%rsi,1),%xmm0
movups %xmm0,-0x10(%rcx,%rsi,1)
movups -0x20(%rbp,%rsi,1),%xmm0
movups %xmm0,-0x20(%rcx,%rsi,1)
movups -0x30(%rbp,%rsi,1),%xmm0
movups %xmm0,-0x30(%rcx,%rsi,1)
movups -0x40(%rbp,%rsi,1),%xmm0
movups %xmm0,-0x40(%rcx,%rsi,1)
add    $0xffffffffffffffc0,%rsi
add    $0xfffffffffffffffc,%rbx
jne    1300 <backmove2+0x200>
neg    %rsi
test   %r8,%r8
je     1375 <backmove2+0x275>
mov    $0xfffffffffffffff0,%rax
sub    %rsi,%rax
lea    (%rcx,%rax,1),%r10
add    %rbp,%rax
shl    $0x4,%r8
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups (%rax,%rbx,1),%xmm0
movups %xmm0,(%r10,%rbx,1)
add    $0xfffffffffffffff0,%rbx
mov    %r8,%rsi
add    %rbx,%rsi
jne    1360 <backmove2+0x260>
cmp    %r9,%rdi
je     13f2 <backmove2+0x2f2>
test   $0xc,%r9b
je     13c8 <backmove2+0x2c8>
cmp    $0xffffffffffffffff,%rdx
mov    $0xffffffffffffffff,%r9
cmovl  %rdx,%r9
neg    %r9
mov    %r9,%r8
and    $0xfffffffffffffffc,%r8
mov    %r8,%rsi
not    %rsi
neg    %rdi
mov    %r8,%rbx
neg    %rbx
nopl   0x0(%rax,%rax,1)
mov    -0x4(%rbp,%rdi,1),%eax
mov    %eax,-0x4(%rcx,%rdi,1)
add    $0xfffffffffffffffc,%rdi
cmp    %rdi,%rbx
jne    13b0 <backmove2+0x2b0>
cmp    %r9,%r8
jne    13ce <backmove2+0x2ce>
jmp    13f2 <backmove2+0x2f2>
not    %rdi
mov    %rdi,%rsi
add    $0x1,%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl -0x1(%rbp,%rsi,1),%eax
mov    %al,-0x1(%rcx,%rsi,1)
add    $0xffffffffffffffff,%rsi
cmp    %rdx,%rsi
jg     13e0 <backmove2+0x2e0>
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret

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

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