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

/* Variables and functions */
void PackPacket(uint64_t packet_addr_l, uint16_t pcf, uint8_t *packet_data,
                int packet_length, uint8_t *packet_packed) {
  int c;
  uint64_t packet_header = packet_addr_l;
  packet_header <<= 9;
  packet_header |= pcf;
  for (c = 0; c < 7; c++) {
    packet_packed[c] = (packet_header >> ((6 - c) * 8)) & 0xFF;
  }
  for (c = 0; c < packet_length; c++) {
    packet_packed[c + 7] = packet_data[c];
  }
}


x86 assembly (clang, -O0):
<PackPacket>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8,-0x20(%rbp)
mov    -0x4(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
shl    $0x9,%eax
mov    %eax,-0x28(%rbp)
mov    -0x8(%rbp),%eax
or     -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
movl   $0x0,-0x24(%rbp)
cmpl   $0x7,-0x24(%rbp)
jge    116d <PackPacket+0x6d>
mov    -0x28(%rbp),%edx
mov    $0x6,%ecx
sub    -0x24(%rbp),%ecx
shl    $0x3,%ecx
sar    %cl,%edx
and    $0xff,%edx
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1134 <PackPacket+0x34>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11a9 <PackPacket+0xa9>
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0x7,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1174 <PackPacket+0x74>
pop    %rbp
ret

x86 assembly (clang, -O2):
<PackPacket>:
push   %rbx
mov    %edi,%eax
shl    $0x9,%eax
or     %esi,%eax
mov    %eax,%edi
movzbl %ah,%ebx
shr    $0x18,%eax
mov    %eax,0xc(%r8)
shr    $0x10,%edi
movzbl %dil,%eax
mov    %eax,0x10(%r8)
mov    %ebx,0x14(%r8)
movzbl %sil,%eax
mov    %eax,0x18(%r8)
test   %ecx,%ecx
jle    1293 <PackPacket+0x193>
mov    %ecx,%r9d
cmp    $0x8,%ecx
jb     1155 <PackPacket+0x55>
lea    0x1c(%r8),%rax
lea    (%rdx,%r9,4),%rcx
cmp    %rcx,%rax
jae    11c1 <PackPacket+0xc1>
lea    (%r8,%r9,4),%rax
add    $0x1c,%rax
cmp    %rdx,%rax
jbe    11c1 <PackPacket+0xc1>
xor    %ecx,%ecx
mov    %rcx,%rax
not    %rax
add    %r9,%rax
mov    %r9,%rsi
and    $0x3,%rsi
je     1182 <PackPacket+0x82>
nopl   0x0(%rax)
mov    (%rdx,%rcx,4),%edi
mov    %edi,0x1c(%r8,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    1170 <PackPacket+0x70>
cmp    $0x3,%rax
jb     1293 <PackPacket+0x193>
nopl   0x0(%rax)
mov    (%rdx,%rcx,4),%eax
mov    %eax,0x1c(%r8,%rcx,4)
mov    0x4(%rdx,%rcx,4),%eax
mov    %eax,0x20(%r8,%rcx,4)
mov    0x8(%rdx,%rcx,4),%eax
mov    %eax,0x24(%r8,%rcx,4)
mov    0xc(%rdx,%rcx,4),%eax
mov    %eax,0x28(%r8,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r9
jne    1190 <PackPacket+0x90>
jmp    1293 <PackPacket+0x193>
mov    %r9d,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%eax
and    $0x3,%eax
cmp    $0x18,%rdi
jae    11e5 <PackPacket+0xe5>
xor    %edi,%edi
jmp    1254 <PackPacket+0x154>
and    $0xfffffffffffffffc,%rsi
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movups (%rdx,%rdi,4),%xmm0
movups 0x10(%rdx,%rdi,4),%xmm1
movups %xmm0,0x1c(%r8,%rdi,4)
movups %xmm1,0x2c(%r8,%rdi,4)
movups 0x20(%rdx,%rdi,4),%xmm0
movups 0x30(%rdx,%rdi,4),%xmm1
movups %xmm0,0x3c(%r8,%rdi,4)
movups %xmm1,0x4c(%r8,%rdi,4)
movups 0x40(%rdx,%rdi,4),%xmm0
movups 0x50(%rdx,%rdi,4),%xmm1
movups %xmm0,0x5c(%r8,%rdi,4)
movups %xmm1,0x6c(%r8,%rdi,4)
movups 0x60(%rdx,%rdi,4),%xmm0
movups 0x70(%rdx,%rdi,4),%xmm1
movups %xmm0,0x7c(%r8,%rdi,4)
movups %xmm1,0x8c(%r8,%rdi,4)
add    $0x20,%rdi
add    $0xfffffffffffffffc,%rsi
jne    11f0 <PackPacket+0xf0>
test   %rax,%rax
je     128a <PackPacket+0x18a>
nopl   0x0(%rax)
movups (%rdx,%rdi,4),%xmm0
movups 0x10(%rdx,%rdi,4),%xmm1
lea    0x0(,%rdi,4),%rsi
or     $0x1c,%rsi
movups %xmm0,(%r8,%rsi,1)
movups %xmm1,0x10(%r8,%rsi,1)
add    $0x8,%rdi
add    $0xffffffffffffffff,%rax
jne    1260 <PackPacket+0x160>
cmp    %r9,%rcx
jne    1157 <PackPacket+0x57>
pop    %rbx
ret

LLVM IR (-O0):
define void @PackPacket(i32 %0, i32 %1, i32* %2, i32 %3, i32* %4) {
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32*
%9 = alloca i32
%10 = alloca i32*
%11 = alloca i32
%12 = alloca i32
store i32 %0, i32* %6
store i32 %1, i32* %7
store i32* %2, i32** %8
store i32 %3, i32* %9
store i32* %4, i32** %10
%13 = load i32, i32* %6
store i32 %13, i32* %12
%14 = load i32, i32* %12
%15 = shl i32 %14, 9
store i32 %15, i32* %12
%16 = load i32, i32* %7
%17 = load i32, i32* %12
%18 = or i32 %17, %16
store i32 %18, i32* %12
store i32 0, i32* %11
br label %19
19: ; preds = %33, %5
%20 = load i32, i32* %11
%21 = icmp slt i32 %20, 7
br i1 %21, label %22, label %36
22: ; preds = %19
%23 = load i32, i32* %12
%24 = load i32, i32* %11
%25 = sub nsw i32 6, %24
%26 = mul nsw i32 %25, 8
%27 = ashr i32 %23, %26
%28 = and i32 %27, 255
%29 = load i32*, i32** %10
%30 = load i32, i32* %11
%31 = sext i32 %30 to i64
%32 = getelementptr inbounds i32, i32* %29, i64 %31
store i32 %28, i32* %32
br label %33
33: ; preds = %22
%34 = load i32, i32* %11
%35 = add nsw i32 %34, 1
store i32 %35, i32* %11
br label %19
36: ; preds = %19
store i32 0, i32* %11
br label %37
37: ; preds = %52, %36
%38 = load i32, i32* %11
%39 = load i32, i32* %9
%40 = icmp slt i32 %38, %39
br i1 %40, label %41, label %55
41: ; preds = %37
%42 = load i32*, i32** %8
%43 = load i32, i32* %11
%44 = sext i32 %43 to i64
%45 = getelementptr inbounds i32, i32* %42, i64 %44
%46 = load i32, i32* %45
%47 = load i32*, i32** %10
%48 = load i32, i32* %11
%49 = add nsw i32 %48, 7
%50 = sext i32 %49 to i64
%51 = getelementptr inbounds i32, i32* %47, i64 %50
store i32 %46, i32* %51
br label %52
52: ; preds = %41
%53 = load i32, i32* %11
%54 = add nsw i32 %53, 1
store i32 %54, i32* %11
br label %37
55: ; preds = %37
ret void
}

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