#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ memcpyU16(unsigned short *, unsigned short const *,
                             unsigned long);
void fastMemcpyU16(unsigned short *to, const unsigned short *from,
                   unsigned long len) {
  const unsigned short *src16;
  const unsigned long *src32;
  unsigned short *dst16;
  unsigned long *dst32;
  unsigned long cnt;
  if ((len < 16) || (((unsigned long)to & 2) != ((unsigned long)from & 2))) {
    memcpyU16(to, from, len);
    return;
  }
  dst16 = to;
  src16 = from;
  if ((unsigned long)dst16 & 2) {
    *dst16++ = *src16++;
    len--;
  }
  dst32 = (unsigned long *)dst16;
  src32 = (unsigned long *)src16;
  cnt = len >> 4;
  while (cnt--) {
    *dst32++ = *src32++;
    *dst32++ = *src32++;
    *dst32++ = *src32++;
    *dst32++ = *src32++;
    *dst32++ = *src32++;
    *dst32++ = *src32++;
    *dst32++ = *src32++;
    *dst32++ = *src32++;
  }
  cnt = (len >> 1) & 7;
  while (cnt--)
    *dst32++ = *src32++;
  if (len & 1)
    *((unsigned short *)dst32) = *((unsigned short *)src32);
}


x86 assembly (clang, -O0):
<fastMemcpyU16>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
cmpq   $0x10,-0x18(%rbp)
jb     1148 <fastMemcpyU16+0x38>
mov    -0x8(%rbp),%rax
and    $0x2,%rax
mov    -0x10(%rbp),%rcx
and    $0x2,%rcx
cmp    %rcx,%rax
je     115e <fastMemcpyU16+0x4e>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x18(%rbp),%rdx
call   1030 <memcpyU16@plt>
jmp    137c <fastMemcpyU16+0x26c>
mov    -0x8(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x30(%rbp),%rax
and    $0x2,%rax
cmp    $0x0,%rax
je     11b0 <fastMemcpyU16+0xa0>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x2,%rcx
mov    %rcx,-0x20(%rbp)
mov    (%rax),%cx
mov    -0x30(%rbp),%rax
mov    %rax,%rdx
add    $0x2,%rdx
mov    %rdx,-0x30(%rbp)
mov    %cx,(%rax)
mov    -0x18(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x18(%rbp)
mov    -0x30(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
shr    $0x4,%rax
mov    %rax,-0x40(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x40(%rbp)
cmp    $0x0,%rax
je     130a <fastMemcpyU16+0x1fa>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x28(%rbp)
mov    (%rax),%rcx
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,-0x38(%rbp)
mov    %rcx,(%rax)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x28(%rbp)
mov    (%rax),%rcx
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,-0x38(%rbp)
mov    %rcx,(%rax)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x28(%rbp)
mov    (%rax),%rcx
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,-0x38(%rbp)
mov    %rcx,(%rax)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x28(%rbp)
mov    (%rax),%rcx
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,-0x38(%rbp)
mov    %rcx,(%rax)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x28(%rbp)
mov    (%rax),%rcx
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,-0x38(%rbp)
mov    %rcx,(%rax)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x28(%rbp)
mov    (%rax),%rcx
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,-0x38(%rbp)
mov    %rcx,(%rax)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x28(%rbp)
mov    (%rax),%rcx
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,-0x38(%rbp)
mov    %rcx,(%rax)
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x28(%rbp)
mov    (%rax),%rcx
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,-0x38(%rbp)
mov    %rcx,(%rax)
jmp    11cc <fastMemcpyU16+0xbc>
mov    -0x18(%rbp),%rax
shr    $0x1,%rax
and    $0x7,%rax
mov    %rax,-0x40(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x40(%rbp)
cmp    $0x0,%rax
je     135c <fastMemcpyU16+0x24c>
mov    -0x28(%rbp),%rax
mov    %rax,%rcx
add    $0x8,%rcx
mov    %rcx,-0x28(%rbp)
mov    (%rax),%rcx
mov    -0x38(%rbp),%rax
mov    %rax,%rdx
add    $0x8,%rdx
mov    %rdx,-0x38(%rbp)
mov    %rcx,(%rax)
jmp    131a <fastMemcpyU16+0x20a>
mov    -0x18(%rbp),%rax
and    $0x1,%rax
cmp    $0x0,%rax
je     137c <fastMemcpyU16+0x26c>
mov    -0x28(%rbp),%rax
mov    (%rax),%cx
mov    -0x38(%rbp),%rax
mov    %cx,(%rax)
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<fastMemcpyU16>:
cmp    $0x10,%rdx
jb     114f <fastMemcpyU16+0x3f>
mov    %edi,%eax
and    $0x2,%eax
mov    %esi,%ecx
and    $0x2,%ecx
cmp    %rcx,%rax
jne    114f <fastMemcpyU16+0x3f>
test   %rax,%rax
je     1154 <fastMemcpyU16+0x44>
movzwl (%rsi),%eax
add    $0x2,%rsi
mov    %ax,(%rdi)
add    $0x2,%rdi
add    $0xffffffffffffffff,%rdx
cmp    $0x10,%rdx
jae    1154 <fastMemcpyU16+0x44>
mov    $0xf,%edx
mov    $0x7,%r8d
jmp    11bc <fastMemcpyU16+0xac>
jmp    1030 <memcpyU16@plt>
mov    %rdx,%rax
shr    $0x4,%rax
nopl   0x0(%rax,%rax,1)
mov    (%rsi),%rcx
mov    %rcx,(%rdi)
mov    0x8(%rsi),%rcx
mov    %rcx,0x8(%rdi)
mov    0x10(%rsi),%rcx
mov    %rcx,0x10(%rdi)
mov    0x18(%rsi),%rcx
mov    %rcx,0x18(%rdi)
mov    0x20(%rsi),%rcx
mov    %rcx,0x20(%rdi)
mov    0x28(%rsi),%rcx
mov    %rcx,0x28(%rdi)
mov    0x30(%rsi),%rcx
mov    %rcx,0x30(%rdi)
mov    0x38(%rsi),%rcx
add    $0x40,%rsi
mov    %rcx,0x38(%rdi)
add    $0x40,%rdi
add    $0xffffffffffffffff,%rax
jne    1160 <fastMemcpyU16+0x50>
mov    %edx,%r8d
shr    %r8d
and    $0x7,%r8d
je     12ba <fastMemcpyU16+0x1aa>
cmp    $0x4,%r8d
jb     11dc <fastMemcpyU16+0xcc>
lea    (%rsi,%r8,8),%rax
cmp    %rax,%rdi
jae    1293 <fastMemcpyU16+0x183>
lea    (%rdi,%r8,8),%rax
cmp    %rax,%rsi
jae    1293 <fastMemcpyU16+0x183>
mov    %rdi,%r10
mov    %rsi,%rax
lea    -0x1(%r8),%r9
test   %r8,%r8
je     1222 <fastMemcpyU16+0x112>
xor    %esi,%esi
xor    %edi,%edi
nop
mov    (%rax,%rdi,8),%rcx
mov    %rcx,(%r10,%rdi,8)
add    $0x1,%rdi
add    $0xfffffffffffffff8,%rsi
mov    %r8,%rcx
sub    %rdi,%rcx
jne    11f0 <fastMemcpyU16+0xe0>
sub    %rsi,%r10
sub    %rsi,%rax
mov    %rax,%rsi
mov    %r10,%rdi
mov    %rcx,%r8
cmp    $0x7,%r9
jae    122c <fastMemcpyU16+0x11c>
jmp    12ba <fastMemcpyU16+0x1aa>
cmp    $0x7,%r9
jb     12ba <fastMemcpyU16+0x1aa>
xor    %esi,%esi
xor    %edi,%edi
mov    (%rax,%rdi,8),%rcx
mov    %rcx,(%r10,%rdi,8)
mov    0x8(%rax,%rdi,8),%rcx
mov    %rcx,0x8(%r10,%rdi,8)
mov    0x10(%rax,%rdi,8),%rcx
mov    %rcx,0x10(%r10,%rdi,8)
mov    0x18(%rax,%rdi,8),%rcx
mov    %rcx,0x18(%r10,%rdi,8)
mov    0x20(%rax,%rdi,8),%rcx
mov    %rcx,0x20(%r10,%rdi,8)
mov    0x28(%rax,%rdi,8),%rcx
mov    %rcx,0x28(%r10,%rdi,8)
mov    0x30(%rax,%rdi,8),%rcx
mov    %rcx,0x30(%r10,%rdi,8)
mov    0x38(%rax,%rdi,8),%rcx
mov    %rcx,0x38(%r10,%rdi,8)
add    $0x8,%rdi
add    $0xffffffffffffffc0,%rsi
cmp    %rdi,%r8
jne    1230 <fastMemcpyU16+0x120>
sub    %rsi,%r10
sub    %rsi,%rax
jmp    12b4 <fastMemcpyU16+0x1a4>
mov    %r8d,%ecx
and    $0xfffffffc,%ecx
lea    (%rdi,%rcx,8),%r10
lea    (%rsi,%rcx,8),%rax
movups (%rsi),%xmm0
movups 0x10(%rsi),%xmm1
movups %xmm0,(%rdi)
movups %xmm1,0x10(%rdi)
cmp    %rcx,%r8
jne    12c6 <fastMemcpyU16+0x1b6>
mov    %rax,%rsi
mov    %r10,%rdi
test   $0x1,%dl
je     12c5 <fastMemcpyU16+0x1b5>
movzwl (%rsi),%eax
mov    %ax,(%rdi)
ret
and    $0x3,%r8d
jmp    11e2 <fastMemcpyU16+0xd2>

LLVM IR (-O0):
define void @fastMemcpyU16(i16* %0, i16* %1, i64 %2) {
%4 = alloca i16*
%5 = alloca i16*
%6 = alloca i64
%7 = alloca i16*
%8 = alloca i64*
%9 = alloca i16*
%10 = alloca i64*
%11 = alloca i64
store i16* %0, i16** %4
store i16* %1, i16** %5
store i64 %2, i64* %6
%12 = load i64, i64* %6
%13 = icmp ult i64 %12, 16
br i1 %13, label %22, label %14
14: ; preds = %3
%15 = load i16*, i16** %4
%16 = ptrtoint i16* %15 to i64
%17 = and i64 %16, 2
%18 = load i16*, i16** %5
%19 = ptrtoint i16* %18 to i64
%20 = and i64 %19, 2
%21 = icmp ne i64 %17, %20
br i1 %21, label %22, label %27
22: ; preds = %14, %3
%23 = load i16*, i16** %4
%24 = load i16*, i16** %5
%25 = load i64, i64* %6
%26 = call i32 @memcpyU16(i16* %23, i16* %24, i64 %25)
br label %118
27: ; preds = %14
%28 = load i16*, i16** %4
store i16* %28, i16** %9
%29 = load i16*, i16** %5
store i16* %29, i16** %7
%30 = load i16*, i16** %9
%31 = ptrtoint i16* %30 to i64
%32 = and i64 %31, 2
%33 = icmp ne i64 %32, 0
br i1 %33, label %34, label %42
34: ; preds = %27
%35 = load i16*, i16** %7
%36 = getelementptr inbounds i16, i16* %35, i32 1
store i16* %36, i16** %7
%37 = load i16, i16* %35
%38 = load i16*, i16** %9
%39 = getelementptr inbounds i16, i16* %38, i32 1
store i16* %39, i16** %9
store i16 %37, i16* %38
%40 = load i64, i64* %6
%41 = add i64 %40, -1
store i64 %41, i64* %6
br label %42
42: ; preds = %34, %27
%43 = load i16*, i16** %9
%44 = bitcast i16* %43 to i64*
store i64* %44, i64** %10
%45 = load i16*, i16** %7
%46 = bitcast i16* %45 to i64*
store i64* %46, i64** %8
%47 = load i64, i64* %6
%48 = lshr i64 %47, 4
store i64 %48, i64* %11
br label %49
49: ; preds = %53, %42
%50 = load i64, i64* %11
%51 = add i64 %50, -1
store i64 %51, i64* %11
%52 = icmp ne i64 %50, 0
br i1 %52, label %53, label %94
53: ; preds = %49
%54 = load i64*, i64** %8
%55 = getelementptr inbounds i64, i64* %54, i32 1
store i64* %55, i64** %8
%56 = load i64, i64* %54
%57 = load i64*, i64** %10
%58 = getelementptr inbounds i64, i64* %57, i32 1
store i64* %58, i64** %10
store i64 %56, i64* %57
%59 = load i64*, i64** %8
%60 = getelementptr inbounds i64, i64* %59, i32 1
store i64* %60, i64** %8
%61 = load i64, i64* %59
%62 = load i64*, i64** %10
%63 = getelementptr inbounds i64, i64* %62, i32 1
store i64* %63, i64** %10
store i64 %61, i64* %62
%64 = load i64*, i64** %8
%65 = getelementptr inbounds i64, i64* %64, i32 1
store i64* %65, i64** %8
%66 = load i64, i64* %64
%67 = load i64*, i64** %10
%68 = getelementptr inbounds i64, i64* %67, i32 1
store i64* %68, i64** %10
store i64 %66, i64* %67
%69 = load i64*, i64** %8
%70 = getelementptr inbounds i64, i64* %69, i32 1
store i64* %70, i64** %8
%71 = load i64, i64* %69
%72 = load i64*, i64** %10
%73 = getelementptr inbounds i64, i64* %72, i32 1
store i64* %73, i64** %10
store i64 %71, i64* %72
%74 = load i64*, i64** %8
%75 = getelementptr inbounds i64, i64* %74, i32 1
store i64* %75, i64** %8
%76 = load i64, i64* %74
%77 = load i64*, i64** %10
%78 = getelementptr inbounds i64, i64* %77, i32 1
store i64* %78, i64** %10
store i64 %76, i64* %77
%79 = load i64*, i64** %8
%80 = getelementptr inbounds i64, i64* %79, i32 1
store i64* %80, i64** %8
%81 = load i64, i64* %79
%82 = load i64*, i64** %10
%83 = getelementptr inbounds i64, i64* %82, i32 1
store i64* %83, i64** %10
store i64 %81, i64* %82
%84 = load i64*, i64** %8
%85 = getelementptr inbounds i64, i64* %84, i32 1
store i64* %85, i64** %8
%86 = load i64, i64* %84
%87 = load i64*, i64** %10
%88 = getelementptr inbounds i64, i64* %87, i32 1
store i64* %88, i64** %10
store i64 %86, i64* %87
%89 = load i64*, i64** %8
%90 = getelementptr inbounds i64, i64* %89, i32 1
store i64* %90, i64** %8
%91 = load i64, i64* %89
%92 = load i64*, i64** %10
%93 = getelementptr inbounds i64, i64* %92, i32 1
store i64* %93, i64** %10
store i64 %91, i64* %92
br label %49
94: ; preds = %49
%95 = load i64, i64* %6
%96 = lshr i64 %95, 1
%97 = and i64 %96, 7
store i64 %97, i64* %11
br label %98
98: ; preds = %102, %94
%99 = load i64, i64* %11
%100 = add i64 %99, -1
store i64 %100, i64* %11
%101 = icmp ne i64 %99, 0
br i1 %101, label %102, label %108
102: ; preds = %98
%103 = load i64*, i64** %8
%104 = getelementptr inbounds i64, i64* %103, i32 1
store i64* %104, i64** %8
%105 = load i64, i64* %103
%106 = load i64*, i64** %10
%107 = getelementptr inbounds i64, i64* %106, i32 1
store i64* %107, i64** %10
store i64 %105, i64* %106
br label %98
108: ; preds = %98
%109 = load i64, i64* %6
%110 = and i64 %109, 1
%111 = icmp ne i64 %110, 0
br i1 %111, label %112, label %118
112: ; preds = %108
%113 = load i64*, i64** %8
%114 = bitcast i64* %113 to i16*
%115 = load i16, i16* %114
%116 = load i64*, i64** %10
%117 = bitcast i64* %116 to i16*
store i16 %115, i16* %117
br label %118
118: ; preds = %22, %112, %108
ret void
}

LLVM IR (-O2):
define void @fastMemcpyU16(i16* %0, i16* %1, i64 %2) {
%4 = icmp ult i64 %2, 16
br i1 %4, label %11, label %5
5: ; preds = %3
%6 = ptrtoint i16* %0 to i64
%7 = and i64 %6, 2
%8 = ptrtoint i16* %1 to i64
%9 = and i64 %8, 2
%10 = icmp eq i64 %7, %9
br i1 %10, label %13, label %11
11: ; preds = %5, %3
%12 = tail call i32 @memcpyU16(i16* %0, i16* %1, i64 %2)
br label %156
13: ; preds = %5
%14 = icmp eq i64 %7, 0
br i1 %14, label %15, label %18
15: ; preds = %13
%16 = bitcast i16* %0 to i64*
%17 = bitcast i16* %1 to i64*
br label %26
18: ; preds = %13
%19 = getelementptr inbounds i16, i16* %1, i64 1
%20 = load i16, i16* %1
%21 = getelementptr inbounds i16, i16* %0, i64 1
store i16 %20, i16* %0
%22 = add i64 %2, -1
%23 = bitcast i16* %21 to i64*
%24 = bitcast i16* %19 to i64*
%25 = icmp ult i64 %22, 16
br i1 %25, label %65, label %26
26: ; preds = %15, %18
%27 = phi i64* [ %17, %15 ], [ %24, %18 ]
%28 = phi i64* [ %16, %15 ], [ %23, %18 ]
%29 = phi i64 [ %2, %15 ], [ %22, %18 ]
%30 = lshr i64 %29, 4
br label %31
31: ; preds = %26, %31
%32 = phi i64 [ %35, %31 ], [ %30, %26 ]
%33 = phi i64* [ %59, %31 ], [ %28, %26 ]
%34 = phi i64* [ %57, %31 ], [ %27, %26 ]
%35 = add nsw i64 %32, -1
%36 = getelementptr inbounds i64, i64* %34, i64 1
%37 = load i64, i64* %34
%38 = getelementptr inbounds i64, i64* %33, i64 1
store i64 %37, i64* %33
%39 = getelementptr inbounds i64, i64* %34, i64 2
%40 = load i64, i64* %36
%41 = getelementptr inbounds i64, i64* %33, i64 2
store i64 %40, i64* %38
%42 = getelementptr inbounds i64, i64* %34, i64 3
%43 = load i64, i64* %39
%44 = getelementptr inbounds i64, i64* %33, i64 3
store i64 %43, i64* %41
%45 = getelementptr inbounds i64, i64* %34, i64 4
%46 = load i64, i64* %42
%47 = getelementptr inbounds i64, i64* %33, i64 4
store i64 %46, i64* %44
%48 = getelementptr inbounds i64, i64* %34, i64 5
%49 = load i64, i64* %45
%50 = getelementptr inbounds i64, i64* %33, i64 5
store i64 %49, i64* %47
%51 = getelementptr inbounds i64, i64* %34, i64 6
%52 = load i64, i64* %48
%53 = getelementptr inbounds i64, i64* %33, i64 6
store i64 %52, i64* %50
%54 = getelementptr inbounds i64, i64* %34, i64 7
%55 = load i64, i64* %51
%56 = getelementptr inbounds i64, i64* %33, i64 7
store i64 %55, i64* %53
%57 = getelementptr inbounds i64, i64* %34, i64 8
%58 = load i64, i64* %54
%59 = getelementptr inbounds i64, i64* %33, i64 8
store i64 %58, i64* %56
%60 = icmp eq i64 %35, 0
br i1 %60, label %61, label %31
61: ; preds = %31
%62 = lshr i64 %29, 1
%63 = and i64 %62, 7
%64 = icmp eq i64 %63, 0
br i1 %64, label %146, label %65
65: ; preds = %18, %61
%66 = phi i64 [ %63, %61 ], [ 7, %18 ]
%67 = phi i64* [ %59, %61 ], [ %23, %18 ]
%68 = phi i64* [ %57, %61 ], [ %24, %18 ]
%69 = phi i64 [ %29, %61 ], [ 15, %18 ]
%70 = icmp ult i64 %66, 4
br i1 %70, label %91, label %71
71: ; preds = %65
%72 = getelementptr i64, i64* %67, i64 %66
%73 = getelementptr i64, i64* %68, i64 %66
%74 = icmp ult i64* %67, %73
%75 = icmp ult i64* %68, %72
%76 = and i1 %74, %75
br i1 %76, label %91, label %77
77: ; preds = %71
%78 = and i64 %66, 4
%79 = getelementptr i64, i64* %67, i64 %78
%80 = getelementptr i64, i64* %68, i64 %78
%81 = and i64 %66, 3
%82 = bitcast i64* %68 to <2 x i64>*
%83 = load <2 x i64>, <2 x i64>* %82
%84 = getelementptr i64, i64* %68, i64 2
%85 = bitcast i64* %84 to <2 x i64>*
%86 = load <2 x i64>, <2 x i64>* %85
%87 = bitcast i64* %67 to <2 x i64>*
store <2 x i64> %83, <2 x i64>* %87
%88 = getelementptr i64, i64* %67, i64 2
%89 = bitcast i64* %88 to <2 x i64>*
store <2 x i64> %86, <2 x i64>* %89
%90 = icmp eq i64 %66, %78
br i1 %90, label %146, label %91
91: ; preds = %71, %65, %77
%92 = phi i64 [ %66, %71 ], [ %66, %65 ], [ %81, %77 ]
%93 = phi i64* [ %67, %71 ], [ %67, %65 ], [ %79, %77 ]
%94 = phi i64* [ %68, %71 ], [ %68, %65 ], [ %80, %77 ]
%95 = add nsw i64 %92, -1
%96 = and i64 %92, 7
%97 = icmp eq i64 %96, 0
br i1 %97, label %109, label %98
98: ; preds = %91, %98
%99 = phi i64 [ %103, %98 ], [ %92, %91 ]
%100 = phi i64* [ %106, %98 ], [ %93, %91 ]
%101 = phi i64* [ %104, %98 ], [ %94, %91 ]
%102 = phi i64 [ %107, %98 ], [ 0, %91 ]
%103 = add nsw i64 %99, -1
%104 = getelementptr inbounds i64, i64* %101, i64 1
%105 = load i64, i64* %101
%106 = getelementptr inbounds i64, i64* %100, i64 1
store i64 %105, i64* %100
%107 = add i64 %102, 1
%108 = icmp eq i64 %107, %96
br i1 %108, label %109, label %98
109: ; preds = %98, %91
%110 = phi i64* [ undef, %91 ], [ %104, %98 ]
%111 = phi i64* [ undef, %91 ], [ %106, %98 ]
%112 = phi i64 [ %92, %91 ], [ %103, %98 ]
%113 = phi i64* [ %93, %91 ], [ %106, %98 ]
%114 = phi i64* [ %94, %91 ], [ %104, %98 ]
%115 = icmp ult i64 %95, 7
br i1 %115, label %146, label %116
116: ; preds = %109, %116
%117 = phi i64 [ %141, %116 ], [ %112, %109 ]
%118 = phi i64* [ %144, %116 ], [ %113, %109 ]
%119 = phi i64* [ %142, %116 ], [ %114, %109 ]
%120 = getelementptr inbounds i64, i64* %119, i64 1
%121 = load i64, i64* %119
%122 = getelementptr inbounds i64, i64* %118, i64 1
store i64 %121, i64* %118
%123 = getelementptr inbounds i64, i64* %119, i64 2
%124 = load i64, i64* %120
%125 = getelementptr inbounds i64, i64* %118, i64 2
store i64 %124, i64* %122
%126 = getelementptr inbounds i64, i64* %119, i64 3
%127 = load i64, i64* %123
%128 = getelementptr inbounds i64, i64* %118, i64 3
store i64 %127, i64* %125
%129 = getelementptr inbounds i64, i64* %119, i64 4
%130 = load i64, i64* %126
%131 = getelementptr inbounds i64, i64* %118, i64 4
store i64 %130, i64* %128
%132 = getelementptr inbounds i64, i64* %119, i64 5
%133 = load i64, i64* %129
%134 = getelementptr inbounds i64, i64* %118, i64 5
store i64 %133, i64* %131
%135 = getelementptr inbounds i64, i64* %119, i64 6
%136 = load i64, i64* %132
%137 = getelementptr inbounds i64, i64* %118, i64 6
store i64 %136, i64* %134
%138 = getelementptr inbounds i64, i64* %119, i64 7
%139 = load i64, i64* %135
%140 = getelementptr inbounds i64, i64* %118, i64 7
store i64 %139, i64* %137
%141 = add nsw i64 %117, -8
%142 = getelementptr inbounds i64, i64* %119, i64 8
%143 = load i64, i64* %138
%144 = getelementptr inbounds i64, i64* %118, i64 8
store i64 %143, i64* %140
%145 = icmp eq i64 %141, 0
br i1 %145, label %146, label %116
146: ; preds = %109, %116, %77, %61
%147 = phi i64 [ %29, %61 ], [ %69, %77 ], [ %69, %116 ], [ %69, %109 ]
%148 = phi i64* [ %57, %61 ], [ %80, %77 ], [ %110, %109 ], [ %142, %116 ]
%149 = phi i64* [ %59, %61 ], [ %79, %77 ], [ %111, %109 ], [ %144, %116 ]
%150 = and i64 %147, 1
%151 = icmp eq i64 %150, 0
br i1 %151, label %156, label %152
152: ; preds = %146
%153 = bitcast i64* %148 to i16*
%154 = load i16, i16* %153
%155 = bitcast i64* %149 to i16*
store i16 %154, i16* %155
br label %156
156: ; preds = %146, %152, %11
ret void
}