void __cmovh(short *dest, const short *src, unsigned len) {
  unsigned i;
  unsigned num = len >> 1;
  char *dest_byte = (char *)dest;
  const char *src_byte = (const char *)src;
  if (dest_byte < src_byte || dest_byte > src_byte + len) {
    for (i = 0; i < num; i++)
      dest[i] = src[i];
    if ((len & 1) != 0)
      dest_byte[len - 1] = src_byte[len - 1];
  } else {
    while (len-- > 0)
      dest_byte[len] = src_byte[len];
  }
}


x86 assembly (clang, -O0):
<__cmovh>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    -0x14(%rbp),%eax
shr    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rax
cmp    -0x30(%rbp),%rax
jb     114d <__cmovh+0x4d>
mov    -0x28(%rbp),%rax
mov    -0x30(%rbp),%rcx
mov    -0x14(%rbp),%edx
add    %rdx,%rcx
cmp    %rcx,%rax
jbe    11b6 <__cmovh+0xb6>
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jae    1184 <__cmovh+0x84>
mov    -0x10(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    (%rax,%rcx,2),%dx
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %dx,(%rax,%rcx,2)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1154 <__cmovh+0x54>
mov    -0x14(%rbp),%eax
and    $0x1,%eax
cmp    $0x0,%eax
je     11b1 <__cmovh+0xb1>
mov    -0x30(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
mov    %ecx,%ecx
mov    (%rax,%rcx,1),%dl
mov    -0x28(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
mov    %ecx,%ecx
mov    %dl,(%rax,%rcx,1)
jmp    11ed <__cmovh+0xed>
jmp    11bb <__cmovh+0xbb>
mov    -0x14(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x14(%rbp)
cmp    $0x0,%eax
jbe    11e8 <__cmovh+0xe8>
mov    -0x30(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    (%rax,%rcx,1),%dl
mov    -0x28(%rbp),%rax
mov    -0x14(%rbp),%ecx
mov    %dl,(%rax,%rcx,1)
jmp    11bb <__cmovh+0xbb>
jmp    11ed <__cmovh+0xed>
pop    %rbp
ret

x86 assembly (clang, -O2):
<__cmovh>:
push   %rbx
cmp    %rsi,%rdi
jb     1175 <__cmovh+0x75>
mov    %edx,%r9d
lea    (%rsi,%r9,1),%rax
cmp    %rdi,%rax
jb     1175 <__cmovh+0x75>
test   %edx,%edx
je     138b <__cmovh+0x28b>
cmp    $0x4,%edx
jb     1135 <__cmovh+0x35>
cmp    %rdi,%rax
jbe    1272 <__cmovh+0x172>
lea    (%rdi,%r9,1),%rax
cmp    %rsi,%rax
jbe    1272 <__cmovh+0x172>
mov    %r9,%rcx
lea    -0x1(%rcx),%r8
mov    %rcx,%rdx
and    $0x3,%rdx
je     1224 <__cmovh+0x124>
nopl   0x0(%rax)
lea    -0x1(%rcx),%rax
movzbl -0x1(%rsi,%rcx,1),%ebx
mov    %bl,-0x1(%rdi,%rcx,1)
mov    %rax,%rcx
add    $0xffffffffffffffff,%rdx
jne    1150 <__cmovh+0x50>
cmp    $0x3,%r8
jae    1231 <__cmovh+0x131>
jmp    138b <__cmovh+0x28b>
cmp    $0x2,%edx
jb     1386 <__cmovh+0x286>
mov    %edx,%eax
shr    %eax
cmp    $0x2,%eax
mov    $0x1,%r9d
cmovae %eax,%r9d
cmp    $0x10,%r9d
jb     11af <__cmovh+0xaf>
lea    (%rsi,%r9,2),%rax
cmp    %rdi,%rax
jbe    127e <__cmovh+0x17e>
lea    (%rdi,%r9,2),%rax
cmp    %rsi,%rax
jbe    127e <__cmovh+0x17e>
xor    %ecx,%ecx
mov    %rcx,%r8
not    %r8
add    %r9,%r8
mov    %r9,%rax
and    $0x3,%rax
je     11e2 <__cmovh+0xe2>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movzwl (%rsi,%rcx,2),%ebx
mov    %bx,(%rdi,%rcx,2)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rax
jne    11d0 <__cmovh+0xd0>
cmp    $0x3,%r8
jb     1386 <__cmovh+0x286>
nopl   0x0(%rax)
movzwl (%rsi,%rcx,2),%eax
mov    %ax,(%rdi,%rcx,2)
movzwl 0x2(%rsi,%rcx,2),%eax
mov    %ax,0x2(%rdi,%rcx,2)
movzwl 0x4(%rsi,%rcx,2),%eax
mov    %ax,0x4(%rdi,%rcx,2)
movzwl 0x6(%rsi,%rcx,2),%eax
mov    %ax,0x6(%rdi,%rcx,2)
add    $0x4,%rcx
cmp    %rcx,%r9
jne    11f0 <__cmovh+0xf0>
jmp    1386 <__cmovh+0x286>
mov    %rcx,%rax
cmp    $0x3,%r8
jb     138b <__cmovh+0x28b>
mov    %rax,%rcx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzbl -0x1(%rsi,%rax,1),%edx
mov    %dl,-0x1(%rdi,%rax,1)
movzbl -0x2(%rsi,%rax,1),%edx
mov    %dl,-0x2(%rdi,%rax,1)
movzbl -0x3(%rsi,%rax,1),%edx
mov    %dl,-0x3(%rdi,%rax,1)
movzbl -0x4(%rsi,%rax,1),%edx
mov    %dl,-0x4(%rdi,%rax,1)
add    $0xfffffffffffffffc,%rcx
mov    %rcx,%rax
jne    1240 <__cmovh+0x140>
jmp    138b <__cmovh+0x28b>
cmp    $0x10,%edx
jae    12a7 <__cmovh+0x1a7>
xor    %ebx,%ebx
jmp    1434 <__cmovh+0x334>
mov    %r9d,%ecx
and    $0xfffffff0,%ecx
lea    -0x10(%rcx),%rax
mov    %rax,%r10
shr    $0x4,%r10
add    $0x1,%r10
mov    %r10d,%r8d
and    $0x3,%r8d
cmp    $0x30,%rax
jae    12d4 <__cmovh+0x1d4>
xor    %eax,%eax
jmp    1338 <__cmovh+0x238>
mov    %r9d,%ebx
and    $0xfffffff0,%ebx
lea    -0x10(%rbx),%rax
mov    %rax,%rdx
shr    $0x4,%rdx
add    $0x1,%rdx
mov    %edx,%r8d
and    $0x3,%r8d
cmp    $0x30,%rax
jae    1398 <__cmovh+0x298>
xor    %eax,%eax
jmp    13eb <__cmovh+0x2eb>
and    $0xfffffffffffffffc,%r10
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movups (%rsi,%rax,2),%xmm0
movups 0x10(%rsi,%rax,2),%xmm1
movups %xmm0,(%rdi,%rax,2)
movups %xmm1,0x10(%rdi,%rax,2)
movups 0x20(%rsi,%rax,2),%xmm0
movups 0x30(%rsi,%rax,2),%xmm1
movups %xmm0,0x20(%rdi,%rax,2)
movups %xmm1,0x30(%rdi,%rax,2)
movups 0x40(%rsi,%rax,2),%xmm0
movups 0x50(%rsi,%rax,2),%xmm1
movups %xmm0,0x40(%rdi,%rax,2)
movups %xmm1,0x50(%rdi,%rax,2)
movups 0x60(%rsi,%rax,2),%xmm0
movups 0x70(%rsi,%rax,2),%xmm1
movups %xmm0,0x60(%rdi,%rax,2)
movups %xmm1,0x70(%rdi,%rax,2)
add    $0x40,%rax
add    $0xfffffffffffffffc,%r10
jne    12e0 <__cmovh+0x1e0>
test   %r8,%r8
je     137d <__cmovh+0x27d>
lea    (%rdi,%rax,2),%r10
add    $0x10,%r10
lea    (%rsi,%rax,2),%rax
add    $0x10,%rax
shl    $0x5,%r8
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x10(%rax,%rbx,1),%xmm0
movups (%rax,%rbx,1),%xmm1
movups %xmm0,-0x10(%r10,%rbx,1)
movups %xmm1,(%r10,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%r8
jne    1360 <__cmovh+0x260>
cmp    %r9,%rcx
jne    11b1 <__cmovh+0xb1>
test   $0x1,%dl
jne    138d <__cmovh+0x28d>
pop    %rbx
ret
add    $0xffffffff,%edx
mov    (%rsi,%rdx,1),%al
mov    %al,(%rdi,%rdx,1)
pop    %rbx
ret
and    $0xfffffffffffffffc,%rdx
lea    (%rdi,%r9,1),%r10
add    $0xfffffffffffffff0,%r10
lea    (%rsi,%r9,1),%r11
add    $0xfffffffffffffff0,%r11
xor    %eax,%eax
xchg   %ax,%ax
movups (%r11,%rax,1),%xmm0
movups %xmm0,(%r10,%rax,1)
movups -0x10(%r11,%rax,1),%xmm0
movups %xmm0,-0x10(%r10,%rax,1)
movups -0x20(%r11,%rax,1),%xmm0
movups %xmm0,-0x20(%r10,%rax,1)
movups -0x30(%r11,%rax,1),%xmm0
movups %xmm0,-0x30(%r10,%rax,1)
add    $0xffffffffffffffc0,%rax
add    $0xfffffffffffffffc,%rdx
jne    13b0 <__cmovh+0x2b0>
neg    %rax
test   %r8,%r8
je     1425 <__cmovh+0x325>
mov    %r9,%rcx
sub    %rax,%rcx
lea    (%rdi,%rcx,1),%r10
add    $0xfffffffffffffff0,%r10
add    %rsi,%rcx
add    $0xfffffffffffffff0,%rcx
shl    $0x4,%r8
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movups (%rcx,%rdx,1),%xmm0
movups %xmm0,(%r10,%rdx,1)
add    $0xfffffffffffffff0,%rdx
mov    %r8,%rax
add    %rdx,%rax
jne    1410 <__cmovh+0x310>
cmp    %r9,%rbx
je     138b <__cmovh+0x28b>
test   $0xc,%r9b
je     147f <__cmovh+0x37f>
mov    %r9d,%r8d
and    $0xfffffffc,%r8d
mov    %r9d,%ecx
and    $0x3,%ecx
lea    (%rdi,%r9,1),%r10
add    $0xfffffffffffffffc,%r10
neg    %rbx
lea    (%rsi,%r9,1),%r11
add    $0xfffffffffffffffc,%r11
mov    %r8,%rdx
neg    %rdx
nopw   0x0(%rax,%rax,1)
mov    (%r11,%rbx,1),%eax
mov    %eax,(%r10,%rbx,1)
add    $0xfffffffffffffffc,%rbx
cmp    %rbx,%rdx
jne    1460 <__cmovh+0x360>
cmp    %r9,%r8
jne    1138 <__cmovh+0x38>
jmp    138b <__cmovh+0x28b>
and    $0xf,%r9d
jmp    1135 <__cmovh+0x35>

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

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