#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 */
typedef int uint8_t;

/* Variables and functions */
uint8_t *pack10(uint8_t *outbuf, unsigned short int *inbuf, size_t count) {
  unsigned short int *inp = inbuf;
  uint8_t *outp = outbuf;
  while (inp < (inbuf + count)) {
    *outp++ = *inp & 0xff;
    *outp = *inp++ >> 8;
    *outp++ += (*inp << 2) & 0xfc;
    *outp = *inp++ >> 6;
    *outp++ += (*inp << 4) & 0xf0;
    *outp = *inp++ >> 4;
    *outp++ += (*inp << 6) & 0xc0;
    *outp++ = *inp++ >> 2;
  }
  return outp;
}


x86 assembly (clang, -O0):
<pack10>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    -0x18(%rbp),%rdx
shl    $0x1,%rdx
add    %rdx,%rcx
cmp    %rcx,%rax
jae    123f <pack10+0x13f>
mov    -0x20(%rbp),%rax
movzwl (%rax),%ecx
and    $0xff,%ecx
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x28(%rbp)
mov    %ecx,(%rax)
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x2,%rcx
mov    %rcx,-0x20(%rbp)
movzwl (%rax),%ecx
sar    $0x8,%ecx
mov    -0x28(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x20(%rbp),%rax
movzwl (%rax),%ecx
shl    $0x2,%ecx
and    $0xfc,%ecx
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x28(%rbp)
add    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x2,%rcx
mov    %rcx,-0x20(%rbp)
movzwl (%rax),%ecx
sar    $0x6,%ecx
mov    -0x28(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x20(%rbp),%rax
movzwl (%rax),%ecx
shl    $0x4,%ecx
and    $0xf0,%ecx
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x28(%rbp)
add    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x2,%rcx
mov    %rcx,-0x20(%rbp)
movzwl (%rax),%ecx
sar    $0x4,%ecx
mov    -0x28(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x20(%rbp),%rax
movzwl (%rax),%ecx
shl    $0x6,%ecx
and    $0xc0,%ecx
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x28(%rbp)
add    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x2,%rcx
mov    %rcx,-0x20(%rbp)
movzwl (%rax),%ecx
sar    $0x2,%ecx
mov    -0x28(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x28(%rbp)
mov    %ecx,(%rax)
jmp    1120 <pack10+0x20>
mov    -0x28(%rbp),%rax
pop    %rbp
ret

x86 assembly (clang, -O2):
<pack10>:
mov    %rdi,%rax
test   %rdx,%rdx
jle    1166 <pack10+0x66>
lea    (%rsi,%rdx,2),%r8
nopl   0x0(%rax)
movzwl (%rsi),%edx
movzbl %dl,%edi
mov    %edi,(%rax)
shr    $0x8,%edx
movzwl 0x2(%rsi),%edi
mov    %edi,%ecx
and    $0x3f,%ecx
lea    (%rdx,%rcx,4),%ecx
mov    %ecx,0x4(%rax)
shr    $0x6,%edi
movzwl 0x4(%rsi),%ecx
mov    %ecx,%edx
shl    $0x4,%edx
movzbl %dl,%edx
add    %edi,%edx
mov    %edx,0x8(%rax)
shr    $0x4,%ecx
movzwl 0x6(%rsi),%edx
mov    %edx,%edi
shl    $0x6,%edi
movzbl %dil,%edi
add    %ecx,%edi
mov    %edi,0xc(%rax)
shr    $0x2,%edx
mov    %edx,0x10(%rax)
add    $0x14,%rax
add    $0x8,%rsi
cmp    %r8,%rsi
jb     1110 <pack10+0x10>
ret

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

LLVM IR (-O2):
define i32* @pack10(i32* writeonly %0, i16* %1, i64 %2) {
%4 = getelementptr inbounds i16, i16* %1, i64 %2
%5 = icmp sgt i64 %2, 0
br i1 %5, label %6, label %45
6: ; preds = %3, %6
%7 = phi i32* [ %43, %6 ], [ %0, %3 ]
%8 = phi i16* [ %40, %6 ], [ %1, %3 ]
%9 = load i16, i16* %8
%10 = and i16 %9, 255
%11 = zext i16 %10 to i32
%12 = getelementptr inbounds i32, i32* %7, i64 1
store i32 %11, i32* %7
%13 = getelementptr inbounds i16, i16* %8, i64 1
%14 = lshr i16 %9, 8
%15 = zext i16 %14 to i32
%16 = load i16, i16* %13
%17 = zext i16 %16 to i32
%18 = shl nuw nsw i32 %17, 2
%19 = and i32 %18, 252
%20 = getelementptr inbounds i32, i32* %7, i64 2
%21 = add nuw nsw i32 %19, %15
store i32 %21, i32* %12
%22 = getelementptr inbounds i16, i16* %8, i64 2
%23 = lshr i16 %16, 6
%24 = zext i16 %23 to i32
%25 = load i16, i16* %22
%26 = zext i16 %25 to i32
%27 = shl nuw nsw i32 %26, 4
%28 = and i32 %27, 240
%29 = getelementptr inbounds i32, i32* %7, i64 3
%30 = add nuw nsw i32 %28, %24
store i32 %30, i32* %20
%31 = getelementptr inbounds i16, i16* %8, i64 3
%32 = lshr i16 %25, 4
%33 = zext i16 %32 to i32
%34 = load i16, i16* %31
%35 = zext i16 %34 to i32
%36 = shl nuw nsw i32 %35, 6
%37 = and i32 %36, 192
%38 = getelementptr inbounds i32, i32* %7, i64 4
%39 = add nuw nsw i32 %37, %33
store i32 %39, i32* %29
%40 = getelementptr inbounds i16, i16* %8, i64 4
%41 = lshr i16 %34, 2
%42 = zext i16 %41 to i32
%43 = getelementptr inbounds i32, i32* %7, i64 5
store i32 %42, i32* %38
%44 = icmp ult i16* %40, %4
br i1 %44, label %6, label %45
45: ; preds = %6, %3
%46 = phi i32* [ %0, %3 ], [ %43, %6 ]
ret i32* %46
}