#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;
typedef int uint16_t;

/* Variables and functions */
extern void pdf_buf_pack_16(uint16_t *in, uint8_t *out, size_t in_len) {
  size_t i;
  size_t j = 0;
  for (i = 0; i < in_len; i++) {
    uint16_t v = in[i];
    out[j++] = v >> 8;
    out[j++] = v;
  }
}


x86 assembly (clang, -O0):
<pdf_buf_pack_16>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movq   $0x0,-0x28(%rbp)
movq   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%rax
cmp    -0x18(%rbp),%rax
jae    1182 <pdf_buf_pack_16+0x82>
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%edx
sar    $0x8,%edx
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x28(%rbp)
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%edx
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x28(%rbp)
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x20(%rbp)
jmp    1120 <pdf_buf_pack_16+0x20>
pop    %rbp
ret

x86 assembly (clang, -O2):
<pdf_buf_pack_16>:
push   %r14
push   %rbx
test   %rdx,%rdx
je     11a5 <pdf_buf_pack_16+0xa5>
mov    %rdx,%r9
cmp    $0x4,%rdx
jae    11a9 <pdf_buf_pack_16+0xa9>
xor    %r14d,%r14d
xor    %eax,%eax
mov    %r14,%rcx
not    %rcx
test   $0x1,%r9b
je     1151 <pdf_buf_pack_16+0x51>
mov    (%rdi,%r14,4),%r8d
mov    %r8d,%r10d
sar    $0x8,%r10d
lea    0x0(,%rax,4),%r11
mov    %r10d,(%rsi,%rax,4)
add    $0x2,%rax
or     $0x4,%r11
mov    %r8d,(%rsi,%r11,1)
or     $0x1,%r14
add    %r9,%rcx
je     11a5 <pdf_buf_pack_16+0xa5>
cs nopw 0x0(%rax,%rax,1)
mov    (%rdi,%r14,4),%edx
mov    %edx,%ecx
sar    $0x8,%ecx
mov    %ecx,(%rsi,%rax,4)
lea    0x0(,%rax,4),%rcx
or     $0x4,%rcx
mov    %edx,(%rsi,%rcx,1)
mov    0x4(%rdi,%r14,4),%ecx
mov    %ecx,%edx
sar    $0x8,%edx
lea    0x8(,%rax,4),%rbx
mov    %edx,0x8(%rsi,%rax,4)
or     $0x4,%rbx
mov    %ecx,(%rsi,%rbx,1)
add    $0x2,%r14
add    $0x4,%rax
cmp    %r14,%r9
jne    1160 <pdf_buf_pack_16+0x60>
pop    %rbx
pop    %r14
ret
lea    -0x1(%r9),%rax
mov    $0x8,%ecx
mul    %rcx
seto   %r8b
lea    (%rsi,%rax,1),%rcx
xor    %r14d,%r14d
cmp    %rsi,%rcx
jb     111c <pdf_buf_pack_16+0x1c>
test   %r8b,%r8b
jne    111c <pdf_buf_pack_16+0x1c>
lea    0x4(%rsi),%rcx
add    %rsi,%rax
add    $0x4,%rax
cmp    %rcx,%rax
jb     111c <pdf_buf_pack_16+0x1c>
mov    $0x0,%eax
test   %r8b,%r8b
jne    111e <pdf_buf_pack_16+0x1e>
lea    (%rdi,%r9,4),%rax
cmp    %rsi,%rax
jbe    120a <pdf_buf_pack_16+0x10a>
lea    (%rsi,%r9,8),%rax
cmp    %rdi,%rax
ja     1119 <pdf_buf_pack_16+0x19>
mov    %r9,%r14
and    $0xfffffffffffffffc,%r14
lea    -0x4(%r14),%rax
mov    %rax,%r8
shr    $0x2,%r8
add    $0x1,%r8
test   %rax,%rax
je     1300 <pdf_buf_pack_16+0x200>
mov    %r8,%rcx
and    $0xfffffffffffffffe,%rcx
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movq   (%rdi,%rax,4),%xmm0
movq   0x8(%rdi,%rax,4),%xmm1
movdqa %xmm0,%xmm2
psrad  $0x8,%xmm2
movdqa %xmm1,%xmm3
psrad  $0x8,%xmm3
punpckldq %xmm0,%xmm2
movdqu %xmm2,(%rsi,%rax,8)
punpckldq %xmm1,%xmm3
movdqu %xmm3,0x10(%rsi,%rax,8)
movq   0x10(%rdi,%rax,4),%xmm0
movq   0x18(%rdi,%rax,4),%xmm1
movdqa %xmm0,%xmm2
psrad  $0x8,%xmm2
movdqa %xmm1,%xmm3
psrad  $0x8,%xmm3
punpckldq %xmm0,%xmm2
movdqu %xmm2,0x20(%rsi,%rax,8)
punpckldq %xmm1,%xmm3
movdqu %xmm3,0x30(%rsi,%rax,8)
add    $0x8,%rax
add    $0xfffffffffffffffe,%rcx
jne    1240 <pdf_buf_pack_16+0x140>
test   $0x1,%r8b
je     12ee <pdf_buf_pack_16+0x1ee>
movq   (%rdi,%rax,4),%xmm0
movq   0x8(%rdi,%rax,4),%xmm1
movdqa %xmm0,%xmm2
psrad  $0x8,%xmm2
movdqa %xmm1,%xmm3
psrad  $0x8,%xmm3
lea    0x0(,%rax,8),%rcx
or     $0x14,%rcx
punpckldq %xmm0,%xmm2
movdqu %xmm2,(%rsi,%rax,8)
punpckldq %xmm1,%xmm3
movdqu %xmm3,-0x4(%rsi,%rcx,1)
cmp    %r9,%r14
je     11a5 <pdf_buf_pack_16+0xa5>
lea    (%r14,%r14,1),%rax
jmp    111e <pdf_buf_pack_16+0x1e>
xor    %eax,%eax
test   $0x1,%r8b
jne    12b2 <pdf_buf_pack_16+0x1b2>
jmp    12ee <pdf_buf_pack_16+0x1ee>

LLVM IR (-O0):
define void @pdf_buf_pack_16(i32* %0, i32* %1, i64 %2) {
%4 = alloca i32*
%5 = alloca i32*
%6 = alloca i64
%7 = alloca i64
%8 = alloca i64
%9 = alloca i32
store i32* %0, i32** %4
store i32* %1, i32** %5
store i64 %2, i64* %6
store i64 0, i64* %8
store i64 0, i64* %7
br label %10
10: ; preds = %30, %3
%11 = load i64, i64* %7
%12 = load i64, i64* %6
%13 = icmp ult i64 %11, %12
br i1 %13, label %14, label %33
14: ; preds = %10
%15 = load i32*, i32** %4
%16 = load i64, i64* %7
%17 = getelementptr inbounds i32, i32* %15, i64 %16
%18 = load i32, i32* %17
store i32 %18, i32* %9
%19 = load i32, i32* %9
%20 = ashr i32 %19, 8
%21 = load i32*, i32** %5
%22 = load i64, i64* %8
%23 = add i64 %22, 1
store i64 %23, i64* %8
%24 = getelementptr inbounds i32, i32* %21, i64 %22
store i32 %20, i32* %24
%25 = load i32, i32* %9
%26 = load i32*, i32** %5
%27 = load i64, i64* %8
%28 = add i64 %27, 1
store i64 %28, i64* %8
%29 = getelementptr inbounds i32, i32* %26, i64 %27
store i32 %25, i32* %29
br label %30
30: ; preds = %14
%31 = load i64, i64* %7
%32 = add i64 %31, 1
store i64 %32, i64* %7
br label %10
33: ; preds = %10
ret void
}

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