void MemoryMove(char *src, char *dst, int size) {
  int i;
  if (dst == src) {
    return;
  } else if (dst < src) {
    for (i = 0; i < size; i++)
      dst[i] = src[i];
  } else {
    for (i = size - 1; i >= 0; i--)
      dst[i] = src[i];
  }
}


x86 assembly (clang, -O0):
<MemoryMove>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    -0x10(%rbp),%rax
cmp    -0x8(%rbp),%rax
jne    1122 <MemoryMove+0x22>
jmp    11ad <MemoryMove+0xad>
mov    -0x10(%rbp),%rax
cmp    -0x8(%rbp),%rax
jae    116c <MemoryMove+0x6c>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1167 <MemoryMove+0x67>
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    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1137 <MemoryMove+0x37>
jmp    11a8 <MemoryMove+0xa8>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x18(%rbp)
cmpl   $0x0,-0x18(%rbp)
jl     11a3 <MemoryMove+0xa3>
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    1175 <MemoryMove+0x75>
jmp    11a8 <MemoryMove+0xa8>
jmp    11ad <MemoryMove+0xad>
pop    %rbp
ret

x86 assembly (clang, -O2):
<MemoryMove>:
push   %r14
push   %rbx
cmp    %rdi,%rsi
je     11c4 <MemoryMove+0xc4>
jae    119d <MemoryMove+0x9d>
test   %edx,%edx
jle    11c4 <MemoryMove+0xc4>
mov    %edx,%r9d
cmp    $0x8,%edx
jb     113c <MemoryMove+0x3c>
lea    (%rdi,%r9,1),%rax
cmp    %rsi,%rax
jbe    1211 <MemoryMove+0x111>
lea    (%rsi,%r9,1),%rax
cmp    %rdi,%rax
jbe    1211 <MemoryMove+0x111>
xor    %ecx,%ecx
mov    %rcx,%rax
not    %rax
add    %r9,%rax
mov    %r9,%rdx
and    $0x3,%rdx
je     1161 <MemoryMove+0x61>
movzbl (%rdi,%rcx,1),%ebx
mov    %bl,(%rsi,%rcx,1)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdx
jne    1150 <MemoryMove+0x50>
cmp    $0x3,%rax
jb     11c4 <MemoryMove+0xc4>
nopw   0x0(%rax,%rax,1)
movzbl (%rdi,%rcx,1),%eax
mov    %al,(%rsi,%rcx,1)
movzbl 0x1(%rdi,%rcx,1),%eax
mov    %al,0x1(%rsi,%rcx,1)
movzbl 0x2(%rdi,%rcx,1),%eax
mov    %al,0x2(%rsi,%rcx,1)
movzbl 0x3(%rdi,%rcx,1),%eax
mov    %al,0x3(%rsi,%rcx,1)
add    $0x4,%rcx
cmp    %rcx,%r9
jne    1170 <MemoryMove+0x70>
jmp    11c4 <MemoryMove+0xc4>
test   %edx,%edx
jle    11c4 <MemoryMove+0xc4>
mov    %edx,%r8d
cmp    $0x4,%edx
jae    11c8 <MemoryMove+0xc8>
mov    %r8,%rax
add    $0x1,%rax
lea    -0x2(%rax),%ecx
movzbl (%rdi,%rcx,1),%edx
mov    %dl,(%rsi,%rcx,1)
add    $0xffffffffffffffff,%rax
cmp    $0x1,%rax
ja     11b0 <MemoryMove+0xb0>
pop    %rbx
pop    %r14
ret
lea    -0x1(%r8),%r10
lea    -0x1(%rdx),%eax
cmp    %r10d,%eax
jb     11a9 <MemoryMove+0xa9>
mov    %r10,%rcx
shr    $0x20,%rcx
jne    11a9 <MemoryMove+0xa9>
lea    0x1(%rax),%rcx
sub    %r8,%rcx
lea    (%rsi,%rcx,1),%r9
lea    (%rdi,%rax,1),%rbx
add    $0x1,%rbx
cmp    %rbx,%r9
jae    1204 <MemoryMove+0x104>
add    %rsi,%rax
add    $0x1,%rax
add    %rdi,%rcx
cmp    %rax,%rcx
jb     11a9 <MemoryMove+0xa9>
cmp    $0x10,%edx
jae    1246 <MemoryMove+0x146>
xor    %r14d,%r14d
jmp    13e5 <MemoryMove+0x2e5>
cmp    $0x20,%edx
jae    121d <MemoryMove+0x11d>
xor    %ecx,%ecx
jmp    132e <MemoryMove+0x22e>
mov    %r9d,%ecx
and    $0xffffffe0,%ecx
lea    -0x20(%rcx),%rax
mov    %rax,%rdx
shr    $0x5,%rdx
add    $0x1,%rdx
mov    %edx,%r8d
and    $0x3,%r8d
cmp    $0x60,%rax
jae    1274 <MemoryMove+0x174>
xor    %eax,%eax
jmp    12d8 <MemoryMove+0x1d8>
mov    %r8d,%r14d
and    $0xfffffff0,%r14d
lea    -0x10(%r14),%rax
mov    %rax,%r11
shr    $0x4,%r11
add    $0x1,%r11
mov    %r11d,%r9d
and    $0x3,%r9d
cmp    $0x30,%rax
jae    135f <MemoryMove+0x25f>
xor    %edx,%edx
jmp    13b2 <MemoryMove+0x2b2>
and    $0xfffffffffffffffc,%rdx
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movups (%rdi,%rax,1),%xmm0
movups 0x10(%rdi,%rax,1),%xmm1
movups %xmm0,(%rsi,%rax,1)
movups %xmm1,0x10(%rsi,%rax,1)
movups 0x20(%rdi,%rax,1),%xmm0
movups 0x30(%rdi,%rax,1),%xmm1
movups %xmm0,0x20(%rsi,%rax,1)
movups %xmm1,0x30(%rsi,%rax,1)
movups 0x40(%rdi,%rax,1),%xmm0
movups 0x50(%rdi,%rax,1),%xmm1
movups %xmm0,0x40(%rsi,%rax,1)
movups %xmm1,0x50(%rsi,%rax,1)
movups 0x60(%rdi,%rax,1),%xmm0
movups 0x70(%rdi,%rax,1),%xmm1
movups %xmm0,0x60(%rsi,%rax,1)
movups %xmm1,0x70(%rsi,%rax,1)
sub    $0xffffffffffffff80,%rax
add    $0xfffffffffffffffc,%rdx
jne    1280 <MemoryMove+0x180>
test   %r8,%r8
je     131b <MemoryMove+0x21b>
lea    (%rsi,%rax,1),%rdx
add    $0x10,%rdx
add    %rdi,%rax
add    $0x10,%rax
shl    $0x5,%r8
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups -0x10(%rax,%rbx,1),%xmm0
movups (%rax,%rbx,1),%xmm1
movups %xmm0,-0x10(%rdx,%rbx,1)
movups %xmm1,(%rdx,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%r8
jne    1300 <MemoryMove+0x200>
cmp    %r9,%rcx
je     11c4 <MemoryMove+0xc4>
test   $0x18,%r9b
je     113e <MemoryMove+0x3e>
mov    %rcx,%rax
mov    %r9d,%ecx
and    $0xfffffff8,%ecx
nopw   0x0(%rax,%rax,1)
mov    (%rdi,%rax,1),%rdx
mov    %rdx,(%rsi,%rax,1)
add    $0x8,%rax
cmp    %rax,%rcx
jne    1340 <MemoryMove+0x240>
cmp    %r9,%rcx
je     11c4 <MemoryMove+0xc4>
jmp    113e <MemoryMove+0x3e>
and    $0xfffffffffffffffc,%r11
mov    $0xffffffcf,%eax
add    %r8,%rax
xor    %edx,%edx
mov    %r10d,%ecx
movups -0xf(%rdi,%rcx,1),%xmm0
movups %xmm0,-0xf(%rsi,%rcx,1)
lea    0x20(%rax),%ecx
movups -0xf(%rdi,%rcx,1),%xmm0
movups %xmm0,-0xf(%rsi,%rcx,1)
lea    0x10(%rax),%ecx
movups -0xf(%rdi,%rcx,1),%xmm0
movups %xmm0,-0xf(%rsi,%rcx,1)
mov    %eax,%ecx
movups -0xf(%rdi,%rcx,1),%xmm0
movups %xmm0,-0xf(%rsi,%rcx,1)
add    $0x40,%rdx
add    $0xffffffffffffffc0,%rax
add    $0xffffffffffffffc0,%r10
add    $0xfffffffffffffffc,%r11
jne    136d <MemoryMove+0x26d>
test   %r9,%r9
je     13d6 <MemoryMove+0x2d6>
not    %rdx
add    %r8,%rdx
nopl   (%rax)
mov    %edx,%eax
movups -0xf(%rdi,%rax,1),%xmm0
movups %xmm0,-0xf(%rsi,%rax,1)
add    $0xfffffffffffffff0,%rdx
add    $0xffffffffffffffff,%r9
jne    13c0 <MemoryMove+0x2c0>
cmp    %r8,%r14
je     11c4 <MemoryMove+0xc4>
test   $0xc,%r8b
je     1422 <MemoryMove+0x322>
mov    %r8d,%r9d
and    $0xfffffffc,%r9d
mov    %r8d,%eax
and    $0x3,%eax
mov    %r14,%rcx
not    %rcx
add    %r8,%rcx
sub    %r9,%r14
xchg   %ax,%ax
mov    %ecx,%edx
mov    -0x3(%rdi,%rdx,1),%ebx
mov    %ebx,-0x3(%rsi,%rdx,1)
add    $0xfffffffffffffffc,%rcx
add    $0x4,%r14
jne    1400 <MemoryMove+0x300>
cmp    %r8,%r9
jne    11ac <MemoryMove+0xac>
jmp    11c4 <MemoryMove+0xc4>
and    $0xf,%r8d
jmp    11a9 <MemoryMove+0xa9>

LLVM IR (-O0):
define void @MemoryMove(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 i8*, i8** %5
%9 = load i8*, i8** %4
%10 = icmp eq i8* %8, %9
br i1 %10, label %11, label %12
11: ; preds = %3
br label %56
12: ; preds = %3
%13 = load i8*, i8** %5
%14 = load i8*, i8** %4
%15 = icmp ult i8* %13, %14
br i1 %15, label %16, label %35
16: ; preds = %12
store i32 0, i32* %7
br label %17
17: ; preds = %31, %16
%18 = load i32, i32* %7
%19 = load i32, i32* %6
%20 = icmp slt i32 %18, %19
br i1 %20, label %21, label %34
21: ; preds = %17
%22 = load i8*, i8** %4
%23 = load i32, i32* %7
%24 = sext i32 %23 to i64
%25 = getelementptr inbounds i8, i8* %22, i64 %24
%26 = load i8, i8* %25
%27 = load i8*, i8** %5
%28 = load i32, i32* %7
%29 = sext i32 %28 to i64
%30 = getelementptr inbounds i8, i8* %27, i64 %29
store i8 %26, i8* %30
br label %31
31: ; preds = %21
%32 = load i32, i32* %7
%33 = add nsw i32 %32, 1
store i32 %33, i32* %7
br label %17
34: ; preds = %17
br label %55
35: ; preds = %12
%36 = load i32, i32* %6
%37 = sub nsw i32 %36, 1
store i32 %37, i32* %7
br label %38
38: ; preds = %51, %35
%39 = load i32, i32* %7
%40 = icmp sge i32 %39, 0
br i1 %40, label %41, label %54
41: ; preds = %38
%42 = load i8*, i8** %4
%43 = load i32, i32* %7
%44 = sext i32 %43 to i64
%45 = getelementptr inbounds i8, i8* %42, i64 %44
%46 = load i8, i8* %45
%47 = load i8*, i8** %5
%48 = load i32, i32* %7
%49 = sext i32 %48 to i64
%50 = getelementptr inbounds i8, i8* %47, i64 %49
store i8 %46, i8* %50
br label %51
51: ; preds = %41
%52 = load i32, i32* %7
%53 = add nsw i32 %52, -1
store i32 %53, i32* %7
br label %38
54: ; preds = %38
br label %55
55: ; preds = %54, %34
br label %56
56: ; preds = %11, %55
ret void
}

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