void shift_left(unsigned short *buffer, int len, int shift) {
  int shift1, shift2;
  int i;
  unsigned short reminder;
  shift1 = shift / (sizeof(unsigned short) * 8);
  shift2 = shift % (sizeof(unsigned short) * 8);
  for (i = 0; i < len - shift1; i++)
    buffer[i] = buffer[i + shift1];
  for (; i < len; i++)
    buffer[i] = 0;
  if (shift2 == 0)
    return;
  for (i = 0; i < len - 1; i++) {
    buffer[i] <<= shift2;
    reminder = buffer[i + 1] >> ((sizeof(unsigned short) * 8) - shift2);
    buffer[i] |= reminder;
  }
  buffer[len - 1] <<= shift2;
}


x86 assembly (clang, -O0):
<shift_left>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
movslq -0x10(%rbp),%rax
shr    $0x4,%rax
mov    %eax,-0x14(%rbp)
movslq -0x10(%rbp),%rax
and    $0xf,%rax
mov    %eax,-0x18(%rbp)
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    -0x14(%rbp),%ecx
cmp    %ecx,%eax
jge    1167 <shift_left+0x67>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    -0x14(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,2),%dx
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    112b <shift_left+0x2b>
jmp    116c <shift_left+0x6c>
mov    -0x1c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1194 <shift_left+0x94>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movw   $0x0,(%rax,%rcx,2)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    116c <shift_left+0x6c>
cmpl   $0x0,-0x18(%rbp)
jne    11a3 <shift_left+0xa3>
jmp    1241 <shift_left+0x141>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    121f <shift_left+0x11f>
mov    -0x18(%rbp),%ecx
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rdx
mov    %rdx,-0x28(%rbp)
movzwl (%rax,%rdx,2),%edx
shl    %cl,%edx
mov    -0x28(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzwl (%rax,%rcx,2),%eax
movslq -0x18(%rbp),%rdx
mov    $0x10,%ecx
sub    %rdx,%rcx
sar    %cl,%eax
mov    %ax,-0x1e(%rbp)
movzwl -0x1e(%rbp),%esi
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movzwl (%rax,%rcx,2),%edx
or     %esi,%edx
mov    %dx,(%rax,%rcx,2)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    11aa <shift_left+0xaa>
mov    -0x18(%rbp),%ecx
mov    -0x8(%rbp),%rax
mov    -0xc(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
mov    %rdx,-0x30(%rbp)
movzwl (%rax,%rdx,2),%edx
shl    %cl,%edx
mov    -0x30(%rbp),%rcx
mov    %dx,(%rax,%rcx,2)
pop    %rbp
ret

x86 assembly (clang, -O2):
<shift_left>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
mov    %edx,%r12d
mov    %esi,%r14d
mov    %rdi,%rbx
mov    %edx,%ecx
sar    $0x4,%ecx
mov    %esi,%r10d
sub    %ecx,%r10d
test   %r10d,%r10d
jle    11e1 <shift_left+0xd1>
movslq %ecx,%r8
mov    %r10d,%ecx
cmp    $0x10,%r10d
jb     1163 <shift_left+0x53>
lea    (%r8,%rcx,1),%rdx
lea    (%rbx,%rdx,2),%rdx
cmp    %rbx,%rdx
jbe    1234 <shift_left+0x124>
lea    (%rbx,%rcx,2),%rdx
lea    (%rbx,%r8,2),%rsi
cmp    %rdx,%rsi
jae    1234 <shift_left+0x124>
xor    %esi,%esi
mov    %rsi,%rdx
not    %rdx
add    %rcx,%rdx
mov    %rcx,%rdi
and    $0x3,%rdi
je     1193 <shift_left+0x83>
lea    (%rbx,%r8,2),%rbp
nopl   0x0(%rax,%rax,1)
movzwl 0x0(%rbp,%rsi,2),%eax
mov    %ax,(%rbx,%rsi,2)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rdi
jne    1180 <shift_left+0x70>
cmp    $0x3,%rdx
jb     11e4 <shift_left+0xd4>
lea    0x6(%rbx),%rdx
lea    (%rbx,%r8,2),%rdi
add    $0x6,%rdi
cs nopw 0x0(%rax,%rax,1)
nop
movzwl -0x6(%rdi,%rsi,2),%eax
mov    %ax,-0x6(%rdx,%rsi,2)
movzwl -0x4(%rdi,%rsi,2),%eax
mov    %ax,-0x4(%rdx,%rsi,2)
movzwl -0x2(%rdi,%rsi,2),%eax
mov    %ax,-0x2(%rdx,%rsi,2)
movzwl (%rdi,%rsi,2),%eax
mov    %ax,(%rdx,%rsi,2)
add    $0x4,%rsi
cmp    %rsi,%rcx
jne    11b0 <shift_left+0xa0>
jmp    11e4 <shift_left+0xd4>
xor    %r10d,%r10d
mov    %r12d,%r15d
and    $0xf,%r15d
cmp    %r14d,%r10d
jge    120c <shift_left+0xfc>
mov    %r10d,%eax
lea    (%rbx,%rax,2),%rdi
not    %r10d
add    %r14d,%r10d
lea    (%r10,%r10,1),%rdx
add    $0x2,%rdx
xor    %esi,%esi
call   1030 <memset@plt>
test   %r15d,%r15d
je     1320 <shift_left+0x210>
lea    -0x1(%r14),%eax
cmp    $0x2,%r14d
jl     1311 <shift_left+0x201>
mov    %eax,%edx
movzwl (%rbx),%edi
cmp    $0x8,%eax
jae    1260 <shift_left+0x150>
xor    %esi,%esi
jmp    12f0 <shift_left+0x1e0>
mov    %ecx,%esi
and    $0xfffffff0,%esi
lea    -0x10(%rsi),%rdx
mov    %rdx,%rdi
shr    $0x4,%rdi
add    $0x1,%rdi
mov    %edi,%r9d
and    $0x3,%r9d
cmp    $0x30,%rdx
jae    1329 <shift_left+0x219>
xor    %ebp,%ebp
jmp    139c <shift_left+0x28c>
mov    %edx,%esi
and    $0xfffffff8,%esi
movd   %edi,%xmm0
pslldq $0xe,%xmm0
movd   %r12d,%xmm1
xor    %ecx,%ecx
movdqa 0xd83(%rip),%xmm3
movdqa %xmm1,%xmm2
pandn  %xmm3,%xmm2
pslldq $0xe,%xmm2
psrldq $0xe,%xmm2
pand   %xmm3,%xmm1
pslldq $0xe,%xmm1
psrldq $0xe,%xmm1
nopl   (%rax)
movdqa %xmm0,%xmm3
movdqu 0x2(%rbx,%rcx,2),%xmm0
movdqa %xmm0,%xmm4
pslldq $0x2,%xmm4
psrldq $0xe,%xmm3
por    %xmm4,%xmm3
psllw  %xmm1,%xmm3
movdqa %xmm0,%xmm4
psrlw  $0x1,%xmm4
psrlw  %xmm2,%xmm4
por    %xmm3,%xmm4
movdqu %xmm4,(%rbx,%rcx,2)
add    $0x8,%rcx
cmp    %rcx,%rsi
jne    12a0 <shift_left+0x190>
cmp    %rdx,%rsi
je     1311 <shift_left+0x201>
pextrw $0x7,%xmm0,%edi
nopl   0x0(%rax)
movzwl 0x2(%rbx,%rsi,2),%ebp
mov    %r12d,%ecx
and    $0xf,%cl
shld   %cl,%bp,%di
mov    %di,(%rbx,%rsi,2)
lea    0x1(%rsi),%rcx
mov    %ebp,%edi
mov    %rcx,%rsi
cmp    %rcx,%rdx
jne    12f0 <shift_left+0x1e0>
cltq
movzwl (%rbx,%rax,2),%edx
mov    %r15d,%ecx
shl    %cl,%edx
mov    %dx,(%rbx,%rax,2)
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret
and    $0xfffffffffffffffc,%rdi
lea    (%rbx,%r8,2),%rdx
add    $0x70,%rdx
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movups -0x70(%rdx,%rbp,2),%xmm0
movups -0x60(%rdx,%rbp,2),%xmm1
movups %xmm0,(%rbx,%rbp,2)
movups %xmm1,0x10(%rbx,%rbp,2)
movups -0x50(%rdx,%rbp,2),%xmm0
movups -0x40(%rdx,%rbp,2),%xmm1
movups %xmm0,0x20(%rbx,%rbp,2)
movups %xmm1,0x30(%rbx,%rbp,2)
movups -0x30(%rdx,%rbp,2),%xmm0
movups -0x20(%rdx,%rbp,2),%xmm1
movups %xmm0,0x40(%rbx,%rbp,2)
movups %xmm1,0x50(%rbx,%rbp,2)
movdqu -0x10(%rdx,%rbp,2),%xmm0
movdqu (%rdx,%rbp,2),%xmm1
movdqu %xmm0,0x60(%rbx,%rbp,2)
movdqu %xmm1,0x70(%rbx,%rbp,2)
add    $0x40,%rbp
add    $0xfffffffffffffffc,%rdi
jne    1340 <shift_left+0x230>
test   %r9,%r9
je     13df <shift_left+0x2cf>
lea    (%rbx,%rbp,2),%rdx
add    $0x10,%rdx
lea    (%rdx,%r8,2),%rdi
shl    $0x5,%r9
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movdqu -0x10(%rdi,%rbp,1),%xmm0
movdqu (%rdi,%rbp,1),%xmm1
movdqu %xmm0,-0x10(%rdx,%rbp,1)
movdqu %xmm1,(%rdx,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%r9
jne    13c0 <shift_left+0x2b0>
cmp    %rcx,%rsi
je     11e4 <shift_left+0xd4>
jmp    1165 <shift_left+0x55>

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

LLVM IR (-O2):
define void @shift_left(i16* nocapture %0, i32 %1, i32 %2) {
%4 = ashr i32 %2, 4
%5 = and i32 %2, 15
%6 = sub i32 %1, %4
%7 = icmp sgt i32 %6, 0
br i1 %7, label %8, label %123
8: ; preds = %3
%9 = sext i32 %4 to i64
%10 = zext i32 %6 to i64
%11 = icmp ult i32 %6, 16
br i1 %11, label %104, label %12
12: ; preds = %8
%13 = getelementptr i16, i16* %0, i64 %10
%14 = getelementptr i16, i16* %0, i64 %9
%15 = add nsw i64 %9, %10
%16 = getelementptr i16, i16* %0, i64 %15
%17 = icmp ugt i16* %16, %0
%18 = icmp ult i16* %14, %13
%19 = and i1 %17, %18
br i1 %19, label %104, label %20
20: ; preds = %12
%21 = and i64 %10, 4294967280
%22 = add nsw i64 %21, -16
%23 = lshr exact i64 %22, 4
%24 = add nuw nsw i64 %23, 1
%25 = and i64 %24, 3
%26 = icmp ult i64 %22, 48
br i1 %26, label %82, label %27
27: ; preds = %20
%28 = and i64 %24, 2305843009213693948
br label %29
29: ; preds = %29, %27
%30 = phi i64 [ 0, %27 ], [ %79, %29 ]
%31 = phi i64 [ 0, %27 ], [ %80, %29 ]
%32 = add nsw i64 %30, %9
%33 = getelementptr inbounds i16, i16* %0, i64 %32
%34 = bitcast i16* %33 to <8 x i16>*
%35 = load <8 x i16>, <8 x i16>* %34
%36 = getelementptr inbounds i16, i16* %33, i64 8
%37 = bitcast i16* %36 to <8 x i16>*
%38 = load <8 x i16>, <8 x i16>* %37
%39 = getelementptr inbounds i16, i16* %0, i64 %30
%40 = bitcast i16* %39 to <8 x i16>*
store <8 x i16> %35, <8 x i16>* %40
%41 = getelementptr inbounds i16, i16* %39, i64 8
%42 = bitcast i16* %41 to <8 x i16>*
store <8 x i16> %38, <8 x i16>* %42
%43 = or i64 %30, 16
%44 = add nsw i64 %43, %9
%45 = getelementptr inbounds i16, i16* %0, i64 %44
%46 = bitcast i16* %45 to <8 x i16>*
%47 = load <8 x i16>, <8 x i16>* %46
%48 = getelementptr inbounds i16, i16* %45, i64 8
%49 = bitcast i16* %48 to <8 x i16>*
%50 = load <8 x i16>, <8 x i16>* %49
%51 = getelementptr inbounds i16, i16* %0, i64 %43
%52 = bitcast i16* %51 to <8 x i16>*
store <8 x i16> %47, <8 x i16>* %52
%53 = getelementptr inbounds i16, i16* %51, i64 8
%54 = bitcast i16* %53 to <8 x i16>*
store <8 x i16> %50, <8 x i16>* %54
%55 = or i64 %30, 32
%56 = add nsw i64 %55, %9
%57 = getelementptr inbounds i16, i16* %0, i64 %56
%58 = bitcast i16* %57 to <8 x i16>*
%59 = load <8 x i16>, <8 x i16>* %58
%60 = getelementptr inbounds i16, i16* %57, i64 8
%61 = bitcast i16* %60 to <8 x i16>*
%62 = load <8 x i16>, <8 x i16>* %61
%63 = getelementptr inbounds i16, i16* %0, i64 %55
%64 = bitcast i16* %63 to <8 x i16>*
store <8 x i16> %59, <8 x i16>* %64
%65 = getelementptr inbounds i16, i16* %63, i64 8
%66 = bitcast i16* %65 to <8 x i16>*
store <8 x i16> %62, <8 x i16>* %66
%67 = or i64 %30, 48
%68 = add nsw i64 %67, %9
%69 = getelementptr inbounds i16, i16* %0, i64 %68
%70 = bitcast i16* %69 to <8 x i16>*
%71 = load <8 x i16>, <8 x i16>* %70
%72 = getelementptr inbounds i16, i16* %69, i64 8
%73 = bitcast i16* %72 to <8 x i16>*
%74 = load <8 x i16>, <8 x i16>* %73
%75 = getelementptr inbounds i16, i16* %0, i64 %67
%76 = bitcast i16* %75 to <8 x i16>*
store <8 x i16> %71, <8 x i16>* %76
%77 = getelementptr inbounds i16, i16* %75, i64 8
%78 = bitcast i16* %77 to <8 x i16>*
store <8 x i16> %74, <8 x i16>* %78
%79 = add nuw i64 %30, 64
%80 = add i64 %31, 4
%81 = icmp eq i64 %80, %28
br i1 %81, label %82, label %29
82: ; preds = %29, %20
%83 = phi i64 [ 0, %20 ], [ %79, %29 ]
%84 = icmp eq i64 %25, 0
br i1 %84, label %102, label %85
85: ; preds = %82, %85
%86 = phi i64 [ %99, %85 ], [ %83, %82 ]
%87 = phi i64 [ %100, %85 ], [ 0, %82 ]
%88 = add nsw i64 %86, %9
%89 = getelementptr inbounds i16, i16* %0, i64 %88
%90 = bitcast i16* %89 to <8 x i16>*
%91 = load <8 x i16>, <8 x i16>* %90
%92 = getelementptr inbounds i16, i16* %89, i64 8
%93 = bitcast i16* %92 to <8 x i16>*
%94 = load <8 x i16>, <8 x i16>* %93
%95 = getelementptr inbounds i16, i16* %0, i64 %86
%96 = bitcast i16* %95 to <8 x i16>*
store <8 x i16> %91, <8 x i16>* %96
%97 = getelementptr inbounds i16, i16* %95, i64 8
%98 = bitcast i16* %97 to <8 x i16>*
store <8 x i16> %94, <8 x i16>* %98
%99 = add nuw i64 %86, 16
%100 = add i64 %87, 1
%101 = icmp eq i64 %100, %25
br i1 %101, label %102, label %85
102: ; preds = %85, %82
%103 = icmp eq i64 %21, %10
br i1 %103, label %123, label %104
104: ; preds = %12, %8, %102
%105 = phi i64 [ 0, %12 ], [ 0, %8 ], [ %21, %102 ]
%106 = xor i64 %105, -1
%107 = add nsw i64 %106, %10
%108 = and i64 %10, 3
%109 = icmp eq i64 %108, 0
br i1 %109, label %120, label %110
110: ; preds = %104, %110
%111 = phi i64 [ %117, %110 ], [ %105, %104 ]
%112 = phi i64 [ %118, %110 ], [ 0, %104 ]
%113 = add nsw i64 %111, %9
%114 = getelementptr inbounds i16, i16* %0, i64 %113
%115 = load i16, i16* %114
%116 = getelementptr inbounds i16, i16* %0, i64 %111
store i16 %115, i16* %116
%117 = add nuw nsw i64 %111, 1
%118 = add i64 %112, 1
%119 = icmp eq i64 %118, %108
br i1 %119, label %120, label %110
120: ; preds = %110, %104
%121 = phi i64 [ %105, %104 ], [ %117, %110 ]
%122 = icmp ult i64 %107, 3
br i1 %122, label %123, label %135
123: ; preds = %120, %135, %102, %3
%124 = phi i32 [ 0, %3 ], [ %6, %102 ], [ %6, %135 ], [ %6, %120 ]
%125 = icmp slt i32 %124, %1
br i1 %125, label %126, label %158
126: ; preds = %123
%127 = zext i32 %124 to i64
%128 = getelementptr i16, i16* %0, i64 %127
%129 = bitcast i16* %128 to i8*
%130 = xor i32 %124, -1
%131 = add i32 %130, %1
%132 = zext i32 %131 to i64
%133 = shl nuw nsw i64 %132, 1
%134 = add nuw nsw i64 %133, 2
br label %158
135: ; preds = %120, %135
%136 = phi i64 [ %156, %135 ], [ %121, %120 ]
%137 = add nsw i64 %136, %9
%138 = getelementptr inbounds i16, i16* %0, i64 %137
%139 = load i16, i16* %138
%140 = getelementptr inbounds i16, i16* %0, i64 %136
store i16 %139, i16* %140
%141 = add nuw nsw i64 %136, 1
%142 = add nsw i64 %141, %9
%143 = getelementptr inbounds i16, i16* %0, i64 %142
%144 = load i16, i16* %143
%145 = getelementptr inbounds i16, i16* %0, i64 %141
store i16 %144, i16* %145
%146 = add nuw nsw i64 %136, 2
%147 = add nsw i64 %146, %9
%148 = getelementptr inbounds i16, i16* %0, i64 %147
%149 = load i16, i16* %148
%150 = getelementptr inbounds i16, i16* %0, i64 %146
store i16 %149, i16* %150
%151 = add nuw nsw i64 %136, 3
%152 = add nsw i64 %151, %9
%153 = getelementptr inbounds i16, i16* %0, i64 %152
%154 = load i16, i16* %153
%155 = getelementptr inbounds i16, i16* %0, i64 %151
store i16 %154, i16* %155
%156 = add nuw nsw i64 %136, 4
%157 = icmp eq i64 %156, %10
br i1 %157, label %123, label %135
158: ; preds = %126, %123
%159 = icmp eq i32 %5, 0
br i1 %159, label %209, label %160
160: ; preds = %158
%161 = add i32 %1, -1
%162 = icmp sgt i32 %1, 1
br i1 %162, label %163, label %202
163: ; preds = %160
%164 = zext i32 %161 to i64
%165 = load i16, i16* %0
%166 = icmp ult i32 %161, 8
br i1 %166, label %189, label %167
167: ; preds = %163
%168 = and i64 %164, 4294967288
%169 = insertelement <8 x i16> poison, i16 %165, i64 7
%170 = trunc i32 %2 to i16
%171 = insertelement <8 x i16> undef, i16 %170, i64 0
%172 = shufflevector <8 x i16> %171, <8 x i16> poison, <8 x i32> zeroinitializer
br label %173
173: ; preds = %173, %167
%174 = phi i64 [ 0, %167 ], [ %184, %173 ]
%175 = phi <8 x i16> [ %169, %167 ], [ %180, %173 ]
%176 = getelementptr inbounds i16, i16* %0, i64 %174
%177 = or i64 %174, 1
%178 = getelementptr inbounds i16, i16* %0, i64 %177
%179 = bitcast i16* %178 to <8 x i16>*
%180 = load <8 x i16>, <8 x i16>* %179
%181 = shufflevector <8 x i16> %175, <8 x i16> %180, <8 x i32> <i32 7, i32 8, i32 9, i32 10, i32 11, i32 12, i32 13, i32 14>
%182 = call <8 x i16> @llvm.fshl.v8i16(<8 x i16> %181, <8 x i16> %180, <8 x i16> %172)
%183 = bitcast i16* %176 to <8 x i16>*
store <8 x i16> %182, <8 x i16>* %183
%184 = add nuw i64 %174, 8
%185 = icmp eq i64 %184, %168
br i1 %185, label %186, label %173
186: ; preds = %173
%187 = icmp eq i64 %168, %164
%188 = extractelement <8 x i16> %180, i64 7
br i1 %187, label %202, label %189
189: ; preds = %163, %186
%190 = phi i16 [ %188, %186 ], [ %165, %163 ]
%191 = phi i64 [ %168, %186 ], [ 0, %163 ]
%192 = trunc i32 %2 to i16
br label %193
193: ; preds = %189, %193
%194 = phi i16 [ %199, %193 ], [ %190, %189 ]
%195 = phi i64 [ %197, %193 ], [ %191, %189 ]
%196 = getelementptr inbounds i16, i16* %0, i64 %195
%197 = add nuw nsw i64 %195, 1
%198 = getelementptr inbounds i16, i16* %0, i64 %197
%199 = load i16, i16* %198
%200 = call i16 @llvm.fshl.i16(i16 %194, i16 %199, i16 %192)
store i16 %200, i16* %196
%201 = icmp eq i64 %197, %164
br i1 %201, label %202, label %193
202: ; preds = %193, %186, %160
%203 = sext i32 %161 to i64
%204 = getelementptr inbounds i16, i16* %0, i64 %203
%205 = load i16, i16* %204
%206 = zext i16 %205 to i32
%207 = shl i32 %206, %5
%208 = trunc i32 %207 to i16
store i16 %208, i16* %204
br label %209
209: ; preds = %158, %202
ret void
}