int ccnl_ccnb_mkHeader(unsigned char *buf, unsigned int num, unsigned int tt) {
  unsigned char tmp[100];
  int len = 0, i;
  *tmp = 0x80 | ((num & 0x0f) << 3) | tt;
  len = 1;
  num = num >> 4;
  while (num > 0) {
    tmp[len++] = num & 0x7f;
    num = num >> 7;
  }
  for (i = len - 1; i >= 0; i--)
    *buf++ = tmp[i];
  return len;
}


x86 assembly (clang, -O0):
<ccnl_ccnb_mkHeader>:
push   %rbp
mov    %rsp,%rbp
sub    $0x10,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
movl   $0x0,-0x84(%rbp)
mov    -0xc(%rbp),%eax
and    $0xf,%eax
shl    $0x3,%eax
or     $0x80,%eax
or     -0x10(%rbp),%eax
mov    %al,-0x80(%rbp)
movl   $0x1,-0x84(%rbp)
mov    -0xc(%rbp),%eax
shr    $0x4,%eax
mov    %eax,-0xc(%rbp)
cmpl   $0x0,-0xc(%rbp)
jbe    117a <ccnl_ccnb_mkHeader+0x7a>
mov    -0xc(%rbp),%eax
and    $0x7f,%eax
mov    %al,%cl
mov    -0x84(%rbp),%eax
mov    %eax,%edx
add    $0x1,%edx
mov    %edx,-0x84(%rbp)
cltq
mov    %cl,-0x80(%rbp,%rax,1)
mov    -0xc(%rbp),%eax
shr    $0x7,%eax
mov    %eax,-0xc(%rbp)
jmp    1143 <ccnl_ccnb_mkHeader+0x43>
mov    -0x84(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x88(%rbp)
cmpl   $0x0,-0x88(%rbp)
jl     11c6 <ccnl_ccnb_mkHeader+0xc6>
movslq -0x88(%rbp),%rax
mov    -0x80(%rbp,%rax,1),%cl
mov    -0x8(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x8(%rbp)
mov    %cl,(%rax)
mov    -0x88(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x88(%rbp)
jmp    1189 <ccnl_ccnb_mkHeader+0x89>
mov    -0x84(%rbp),%eax
add    $0x10,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<ccnl_ccnb_mkHeader>:
lea    0x0(,%rsi,8),%eax
or     %edx,%eax
or     $0x80,%al
mov    %al,-0x68(%rsp)
mov    $0x1,%ecx
cmp    $0x10,%esi
jb     114a <ccnl_ccnb_mkHeader+0x4a>
shr    $0x4,%esi
mov    $0x1,%ecx
mov    %esi,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %esi,%edx
and    $0x7f,%dl
mov    %dl,-0x68(%rsp,%rcx,1)
add    $0x1,%rcx
shr    $0x7,%eax
cmp    $0x80,%esi
mov    %eax,%esi
jae    1130 <ccnl_ccnb_mkHeader+0x30>
mov    %ecx,%eax
cmp    $0x8,%ecx
jae    115c <ccnl_ccnb_mkHeader+0x5c>
mov    %rax,%rdx
mov    %rdi,%rsi
jmp    1263 <ccnl_ccnb_mkHeader+0x163>
cmp    $0x10,%eax
jae    1169 <ccnl_ccnb_mkHeader+0x69>
xor    %r9d,%r9d
jmp    120a <ccnl_ccnb_mkHeader+0x10a>
mov    %eax,%r9d
and    $0xfffffff0,%r9d
lea    -0x68(%rsp),%rcx
movdqu -0x10(%rax,%rcx,1),%xmm1
pxor   %xmm0,%xmm0
movdqa %xmm1,%xmm2
punpcklbw %xmm0,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
punpckhbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm2,%xmm1
movdqu %xmm1,(%rdi)
cmp    $0x10,%r9
je     11f0 <ccnl_ccnb_mkHeader+0xf0>
movdqu -0x20(%rax,%rcx,1),%xmm1
movdqa %xmm1,%xmm2
punpcklbw %xmm0,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
punpckhbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm0
pshuflw $0x1b,%xmm0,%xmm0
pshufhw $0x1b,%xmm0,%xmm0
packuswb %xmm2,%xmm0
movdqu %xmm0,0x10(%rdi)
cmp    %rax,%r9
je     1285 <ccnl_ccnb_mkHeader+0x185>
test   $0x8,%al
jne    120a <ccnl_ccnb_mkHeader+0x10a>
add    %r9,%rdi
mov    %eax,%edx
and    $0xf,%edx
jmp    1154 <ccnl_ccnb_mkHeader+0x54>
mov    %eax,%r8d
and    $0xfffffff8,%r8d
mov    %eax,%edx
and    $0x7,%edx
lea    (%rdi,%r8,1),%rsi
mov    %rax,%rcx
sub    %r9,%rcx
add    %rsp,%rcx
add    $0xffffffffffffff90,%rcx
pxor   %xmm0,%xmm0
nopl   0x0(%rax,%rax,1)
movq   (%rcx),%xmm1
punpcklbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm1,%xmm1
movq   %xmm1,(%rdi,%r9,1)
add    $0x8,%r9
add    $0xfffffffffffffff8,%rcx
cmp    %r9,%r8
jne    1230 <ccnl_ccnb_mkHeader+0x130>
cmp    %rax,%r8
je     1285 <ccnl_ccnb_mkHeader+0x185>
add    $0x1,%rdx
nopw   0x0(%rax,%rax,1)
movzbl -0x6a(%rsp,%rdx,1),%ecx
mov    %cl,(%rsi)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rdx
cmp    $0x1,%rdx
ja     1270 <ccnl_ccnb_mkHeader+0x170>
ret

LLVM IR (-O0):
define i32 @ccnl_ccnb_mkHeader(i8* %0, i32 %1, i32 %2) {
%4 = alloca i8*
%5 = alloca i32
%6 = alloca i32
%7 = alloca [100 x i8]
%8 = alloca i32
%9 = alloca i32
store i8* %0, i8** %4
store i32 %1, i32* %5
store i32 %2, i32* %6
store i32 0, i32* %8
%10 = load i32, i32* %5
%11 = and i32 %10, 15
%12 = shl i32 %11, 3
%13 = or i32 128, %12
%14 = load i32, i32* %6
%15 = or i32 %13, %14
%16 = trunc i32 %15 to i8
%17 = getelementptr inbounds [100 x i8], [100 x i8]* %7, i64 0, i64 0
store i8 %16, i8* %17
store i32 1, i32* %8
%18 = load i32, i32* %5
%19 = lshr i32 %18, 4
store i32 %19, i32* %5
br label %20
20: ; preds = %23, %3
%21 = load i32, i32* %5
%22 = icmp ugt i32 %21, 0
br i1 %22, label %23, label %33
23: ; preds = %20
%24 = load i32, i32* %5
%25 = and i32 %24, 127
%26 = trunc i32 %25 to i8
%27 = load i32, i32* %8
%28 = add nsw i32 %27, 1
store i32 %28, i32* %8
%29 = sext i32 %27 to i64
%30 = getelementptr inbounds [100 x i8], [100 x i8]* %7, i64 0, i64 %29
store i8 %26, i8* %30
%31 = load i32, i32* %5
%32 = lshr i32 %31, 7
store i32 %32, i32* %5
br label %20
33: ; preds = %20
%34 = load i32, i32* %8
%35 = sub nsw i32 %34, 1
store i32 %35, i32* %9
br label %36
36: ; preds = %46, %33
%37 = load i32, i32* %9
%38 = icmp sge i32 %37, 0
br i1 %38, label %39, label %49
39: ; preds = %36
%40 = load i32, i32* %9
%41 = sext i32 %40 to i64
%42 = getelementptr inbounds [100 x i8], [100 x i8]* %7, i64 0, i64 %41
%43 = load i8, i8* %42
%44 = load i8*, i8** %4
%45 = getelementptr inbounds i8, i8* %44, i32 1
store i8* %45, i8** %4
store i8 %43, i8* %44
br label %46
46: ; preds = %39
%47 = load i32, i32* %9
%48 = add nsw i32 %47, -1
store i32 %48, i32* %9
br label %36
49: ; preds = %36
%50 = load i32, i32* %8
ret i32 %50
}

LLVM IR (-O2):
define i32 @ccnl_ccnb_mkHeader(i8* nocapture writeonly %0, i32 %1, i32 %2) {
%4 = alloca [100 x i8]
%5 = getelementptr inbounds [100 x i8], [100 x i8]* %4, i64 0, i64 0
%6 = shl i32 %1, 3
%7 = or i32 %6, %2
%8 = trunc i32 %7 to i8
%9 = or i8 %8, -128
store i8 %9, i8* %5
%10 = icmp ult i32 %1, 16
br i1 %10, label %15, label %11
11: ; preds = %3
%12 = lshr i32 %1, 4
br label %70
13: ; preds = %70
%14 = trunc i64 %75 to i32
br label %15
15: ; preds = %13, %3
%16 = phi i32 [ 1, %3 ], [ %14, %13 ]
%17 = zext i32 %16 to i64
%18 = icmp ult i32 %16, 8
br i1 %18, label %67, label %19
19: ; preds = %15
%20 = icmp ult i32 %16, 16
br i1 %20, label %47, label %21
21: ; preds = %19
%22 = and i64 %17, 4294967280
%23 = add nsw i64 %17, -1
%24 = getelementptr inbounds [100 x i8], [100 x i8]* %4, i64 0, i64 %23
%25 = getelementptr inbounds i8, i8* %24, i64 -15
%26 = bitcast i8* %25 to <16 x i8>*
%27 = load <16 x i8>, <16 x i8>* %26
%28 = shufflevector <16 x i8> %27, <16 x i8> poison, <16 x i32> <i32 15, i32 14, i32 13, i32 12, i32 11, i32 10, i32 9, i32 8, i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%29 = bitcast i8* %0 to <16 x i8>*
store <16 x i8> %28, <16 x i8>* %29
%30 = icmp eq i64 %22, 16
br i1 %30, label %40, label %31
31: ; preds = %21
%32 = getelementptr i8, i8* %0, i64 16
%33 = add nsw i64 %17, -17
%34 = getelementptr inbounds [100 x i8], [100 x i8]* %4, i64 0, i64 %33
%35 = getelementptr inbounds i8, i8* %34, i64 -15
%36 = bitcast i8* %35 to <16 x i8>*
%37 = load <16 x i8>, <16 x i8>* %36
%38 = shufflevector <16 x i8> %37, <16 x i8> poison, <16 x i32> <i32 15, i32 14, i32 13, i32 12, i32 11, i32 10, i32 9, i32 8, i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%39 = bitcast i8* %32 to <16 x i8>*
store <16 x i8> %38, <16 x i8>* %39
br label %40
40: ; preds = %31, %21
%41 = icmp eq i64 %22, %17
br i1 %41, label %87, label %42
42: ; preds = %40
%43 = getelementptr i8, i8* %0, i64 %22
%44 = and i64 %17, 15
%45 = and i64 %17, 8
%46 = icmp eq i64 %45, 0
br i1 %46, label %67, label %47
47: ; preds = %19, %42
%48 = phi i64 [ %22, %42 ], [ 0, %19 ]
%49 = and i64 %17, 4294967288
%50 = and i64 %17, 7
%51 = getelementptr i8, i8* %0, i64 %49
br label %52
52: ; preds = %52, %47
%53 = phi i64 [ %48, %47 ], [ %63, %52 ]
%54 = getelementptr i8, i8* %0, i64 %53
%55 = xor i64 %53, -1
%56 = add i64 %55, %17
%57 = getelementptr inbounds [100 x i8], [100 x i8]* %4, i64 0, i64 %56
%58 = getelementptr inbounds i8, i8* %57, i64 -7
%59 = bitcast i8* %58 to <8 x i8>*
%60 = load <8 x i8>, <8 x i8>* %59
%61 = shufflevector <8 x i8> %60, <8 x i8> poison, <8 x i32> <i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%62 = bitcast i8* %54 to <8 x i8>*
store <8 x i8> %61, <8 x i8>* %62
%63 = add nuw i64 %53, 8
%64 = icmp eq i64 %63, %49
br i1 %64, label %65, label %52
65: ; preds = %52
%66 = icmp eq i64 %49, %17
br i1 %66, label %87, label %67
67: ; preds = %15, %42, %65
%68 = phi i64 [ %17, %15 ], [ %44, %42 ], [ %50, %65 ]
%69 = phi i8* [ %0, %15 ], [ %43, %42 ], [ %51, %65 ]
br label %79
70: ; preds = %11, %70
%71 = phi i64 [ 1, %11 ], [ %75, %70 ]
%72 = phi i32 [ %12, %11 ], [ %77, %70 ]
%73 = trunc i32 %72 to i8
%74 = and i8 %73, 127
%75 = add nuw nsw i64 %71, 1
%76 = getelementptr inbounds [100 x i8], [100 x i8]* %4, i64 0, i64 %71
store i8 %74, i8* %76
%77 = lshr i32 %72, 7
%78 = icmp ult i32 %72, 128
br i1 %78, label %13, label %70
79: ; preds = %67, %79
%80 = phi i64 [ %82, %79 ], [ %68, %67 ]
%81 = phi i8* [ %85, %79 ], [ %69, %67 ]
%82 = add nsw i64 %80, -1
%83 = getelementptr inbounds [100 x i8], [100 x i8]* %4, i64 0, i64 %82
%84 = load i8, i8* %83
%85 = getelementptr inbounds i8, i8* %81, i64 1
store i8 %84, i8* %81
%86 = icmp ugt i64 %80, 1
br i1 %86, label %79, label %87
87: ; preds = %79, %65, %40
ret i32 %16
}