int rdbEncodeInteger(long long value, unsigned char *enc) {
  if (value >= -(1 << 7) && value <= (1 << 7) - 1) {
    enc[0] = (3 << 6) | 0;
    enc[1] = value & 0xFF;
    return 2;
  } else if (value >= -(1 << 15) && value <= (1 << 15) - 1) {
    enc[0] = (3 << 6) | 1;
    enc[1] = value & 0xFF;
    enc[2] = (value >> 8) & 0xFF;
    return 3;
  } else if (value >= -((long long)1 << 31) &&
             value <= ((long long)1 << 31) - 1) {
    enc[0] = (3 << 6) | 2;
    enc[1] = value & 0xFF;
    enc[2] = (value >> 8) & 0xFF;
    enc[3] = (value >> 16) & 0xFF;
    enc[4] = (value >> 24) & 0xFF;
    return 5;
  } else {
    return 0;
  }
}


x86 assembly (clang, -O0):
<rdbEncodeInteger>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
cmpq   $0xffffffffffffff80,-0x10(%rbp)
jl     1148 <rdbEncodeInteger+0x48>
cmpq   $0x7f,-0x10(%rbp)
jg     1148 <rdbEncodeInteger+0x48>
mov    -0x18(%rbp),%rax
movb   $0xc0,(%rax)
mov    -0x10(%rbp),%rax
and    $0xff,%rax
mov    %al,%cl
mov    -0x18(%rbp),%rax
mov    %cl,0x1(%rax)
movl   $0x2,-0x4(%rbp)
jmp    122f <rdbEncodeInteger+0x12f>
cmpq   $0xffffffffffff8000,-0x10(%rbp)
ff
jl     11a1 <rdbEncodeInteger+0xa1>
cmpq   $0x7fff,-0x10(%rbp)
jg     11a1 <rdbEncodeInteger+0xa1>
mov    -0x18(%rbp),%rax
movb   $0xc1,(%rax)
mov    -0x10(%rbp),%rax
and    $0xff,%rax
mov    %al,%cl
mov    -0x18(%rbp),%rax
mov    %cl,0x1(%rax)
mov    -0x10(%rbp),%rax
sar    $0x8,%rax
and    $0xff,%rax
mov    %al,%cl
mov    -0x18(%rbp),%rax
mov    %cl,0x2(%rax)
movl   $0x3,-0x4(%rbp)
jmp    122f <rdbEncodeInteger+0x12f>
cmpq   $0xffffffff80000000,-0x10(%rbp)
80
jl     1228 <rdbEncodeInteger+0x128>
cmpq   $0x7fffffff,-0x10(%rbp)
7f
jg     1228 <rdbEncodeInteger+0x128>
mov    -0x18(%rbp),%rax
movb   $0xc2,(%rax)
mov    -0x10(%rbp),%rax
and    $0xff,%rax
mov    %al,%cl
mov    -0x18(%rbp),%rax
mov    %cl,0x1(%rax)
mov    -0x10(%rbp),%rax
sar    $0x8,%rax
and    $0xff,%rax
mov    %al,%cl
mov    -0x18(%rbp),%rax
mov    %cl,0x2(%rax)
mov    -0x10(%rbp),%rax
sar    $0x10,%rax
and    $0xff,%rax
mov    %al,%cl
mov    -0x18(%rbp),%rax
mov    %cl,0x3(%rax)
mov    -0x10(%rbp),%rax
sar    $0x18,%rax
and    $0xff,%rax
mov    %al,%cl
mov    -0x18(%rbp),%rax
mov    %cl,0x4(%rax)
movl   $0x5,-0x4(%rbp)
jmp    122f <rdbEncodeInteger+0x12f>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<rdbEncodeInteger>:
mov    %rdi,%rcx
movsbq %cl,%rax
cmp    %rdi,%rax
jne    111b <rdbEncodeInteger+0x1b>
movb   $0xc0,(%rsi)
mov    $0x2,%eax
mov    $0x1,%edx
jmp    1165 <rdbEncodeInteger+0x65>
movswq %cx,%rax
cmp    %rcx,%rax
jne    113a <rdbEncodeInteger+0x3a>
movb   $0xc1,(%rsi)
mov    %cl,0x1(%rsi)
shr    $0x8,%rcx
mov    $0x3,%eax
mov    $0x2,%edx
jmp    1165 <rdbEncodeInteger+0x65>
movslq %ecx,%rdx
xor    %eax,%eax
cmp    %rcx,%rdx
jne    1168 <rdbEncodeInteger+0x68>
movb   $0xc2,(%rsi)
mov    %cl,0x1(%rsi)
mov    %ch,0x2(%rsi)
mov    %rcx,%rax
shr    $0x10,%rax
mov    %al,0x3(%rsi)
shr    $0x18,%rcx
mov    $0x5,%eax
mov    $0x4,%edx
mov    %cl,(%rsi,%rdx,1)
ret

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

LLVM IR (-O2):
define i32 @rdbEncodeInteger(i64 %0, i8* nocapture writeonly %1) {
%3 = add i64 %0, 128
%4 = icmp ult i64 %3, 256
br i1 %4, label %5, label %6
5: ; preds = %2
store i8 -64, i8* %1
br label %26
6: ; preds = %2
%7 = add i64 %0, 32768
%8 = icmp ult i64 %7, 65536
br i1 %8, label %9, label %13
9: ; preds = %6
store i8 -63, i8* %1
%10 = trunc i64 %0 to i8
%11 = getelementptr inbounds i8, i8* %1, i64 1
store i8 %10, i8* %11
%12 = lshr i64 %0, 8
br label %26
13: ; preds = %6
%14 = add i64 %0, 2147483648
%15 = icmp ult i64 %14, 4294967296
br i1 %15, label %16, label %32
16: ; preds = %13
store i8 -62, i8* %1
%17 = trunc i64 %0 to i8
%18 = getelementptr inbounds i8, i8* %1, i64 1
store i8 %17, i8* %18
%19 = lshr i64 %0, 8
%20 = trunc i64 %19 to i8
%21 = getelementptr inbounds i8, i8* %1, i64 2
store i8 %20, i8* %21
%22 = lshr i64 %0, 16
%23 = trunc i64 %22 to i8
%24 = getelementptr inbounds i8, i8* %1, i64 3
store i8 %23, i8* %24
%25 = lshr i64 %0, 24
br label %26
26: ; preds = %5, %9, %16
%27 = phi i64 [ %25, %16 ], [ %12, %9 ], [ %0, %5 ]
%28 = phi i64 [ 4, %16 ], [ 2, %9 ], [ 1, %5 ]
%29 = phi i32 [ 5, %16 ], [ 3, %9 ], [ 2, %5 ]
%30 = trunc i64 %27 to i8
%31 = getelementptr inbounds i8, i8* %1, i64 %28
store i8 %30, i8* %31
br label %32
32: ; preds = %26, %13
%33 = phi i32 [ 0, %13 ], [ %29, %26 ]
ret i32 %33
}