#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 encoding;

/* Variables and functions */
int /*<<< orphan*/ memcpy(unsigned char *, unsigned char *, unsigned char);
unsigned int zipEncodeLength(unsigned char *p, unsigned char encoding,
                             unsigned int rawlen) {
  unsigned char len = 1, buf[5];
  if ((((encoding)&0xc0) < 0xc0)) {
    if (rawlen <= 0x3f) {
      if (!p)
        return len;
      buf[0] = (0 << 6) | rawlen;
    } else if (rawlen <= 0x3fff) {
      len += 1;
      if (!p)
        return len;
      buf[0] = (1 << 6) | ((rawlen >> 8) & 0x3f);
      buf[1] = rawlen & 0xff;
    } else {
      len += 4;
      if (!p)
        return len;
      buf[0] = (2 << 6);
      buf[1] = (rawlen >> 24) & 0xff;
      buf[2] = (rawlen >> 16) & 0xff;
      buf[3] = (rawlen >> 8) & 0xff;
      buf[4] = rawlen & 0xff;
    }
  } else {
    if (!p)
      return len;
    buf[0] = encoding;
  }
  memcpy(p, buf, len);
  return len;
}


x86 assembly (clang, -O0):
<zipEncodeLength>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %sil,%al
mov    %rdi,-0x10(%rbp)
mov    %al,-0x11(%rbp)
mov    %edx,-0x18(%rbp)
movb   $0x1,-0x19(%rbp)
movzbl -0x11(%rbp),%eax
and    $0xc0,%eax
cmp    $0xc0,%eax
jge    121d <zipEncodeLength+0x10d>
cmpl   $0x3f,-0x18(%rbp)
ja     116c <zipEncodeLength+0x5c>
cmpq   $0x0,-0x10(%rbp)
jne    115e <zipEncodeLength+0x4e>
movzbl -0x19(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    1254 <zipEncodeLength+0x144>
mov    -0x18(%rbp),%eax
or     $0x0,%eax
mov    %al,-0x1e(%rbp)
jmp    1218 <zipEncodeLength+0x108>
cmpl   $0x3fff,-0x18(%rbp)
ja     11b9 <zipEncodeLength+0xa9>
movzbl -0x19(%rbp),%eax
add    $0x1,%eax
mov    %al,-0x19(%rbp)
cmpq   $0x0,-0x10(%rbp)
jne    119a <zipEncodeLength+0x8a>
movzbl -0x19(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    1254 <zipEncodeLength+0x144>
mov    -0x18(%rbp),%eax
shr    $0x8,%eax
and    $0x3f,%eax
or     $0x40,%eax
mov    %al,-0x1e(%rbp)
mov    -0x18(%rbp),%eax
and    $0xff,%eax
mov    %al,-0x1d(%rbp)
jmp    1213 <zipEncodeLength+0x103>
movzbl -0x19(%rbp),%eax
add    $0x4,%eax
mov    %al,-0x19(%rbp)
cmpq   $0x0,-0x10(%rbp)
jne    11da <zipEncodeLength+0xca>
movzbl -0x19(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    1254 <zipEncodeLength+0x144>
movb   $0x80,-0x1e(%rbp)
mov    -0x18(%rbp),%eax
shr    $0x18,%eax
and    $0xff,%eax
mov    %al,-0x1d(%rbp)
mov    -0x18(%rbp),%eax
shr    $0x10,%eax
and    $0xff,%eax
mov    %al,-0x1c(%rbp)
mov    -0x18(%rbp),%eax
shr    $0x8,%eax
and    $0xff,%eax
mov    %al,-0x1b(%rbp)
mov    -0x18(%rbp),%eax
and    $0xff,%eax
mov    %al,-0x1a(%rbp)
jmp    1218 <zipEncodeLength+0x108>
jmp    123a <zipEncodeLength+0x12a>
cmpq   $0x0,-0x10(%rbp)
jne    1234 <zipEncodeLength+0x124>
movzbl -0x19(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    1254 <zipEncodeLength+0x144>
mov    -0x11(%rbp),%al
mov    %al,-0x1e(%rbp)
mov    -0x10(%rbp),%rdi
lea    -0x1e(%rbp),%rsi
mov    -0x19(%rbp),%al
movzbl %al,%edx
call   1030 <memcpy@plt>
movzbl -0x19(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<zipEncodeLength>:
push   %rbx
sub    $0x10,%rsp
cmp    $0xbf,%sil
jbe    1127 <zipEncodeLength+0x17>
test   %rdi,%rdi
je     1148 <zipEncodeLength+0x38>
mov    %sil,0xb(%rsp)
jmp    1135 <zipEncodeLength+0x25>
cmp    $0x3f,%edx
ja     1155 <zipEncodeLength+0x45>
test   %rdi,%rdi
je     1148 <zipEncodeLength+0x38>
mov    %dl,0xb(%rsp)
mov    $0x1,%al
movzbl %al,%ebx
lea    0xb(%rsp),%rsi
mov    %ebx,%edx
call   1030 <memcpy@plt>
jmp    114d <zipEncodeLength+0x3d>
mov    $0x1,%ebx
mov    %ebx,%eax
add    $0x10,%rsp
pop    %rbx
ret
cmp    $0x3fff,%edx
ja     1175 <zipEncodeLength+0x65>
test   %rdi,%rdi
je     119d <zipEncodeLength+0x8d>
mov    %edx,%eax
shr    $0x8,%eax
or     $0x40,%al
mov    %al,0xb(%rsp)
mov    %dl,0xc(%rsp)
mov    $0x2,%al
jmp    1137 <zipEncodeLength+0x27>
test   %rdi,%rdi
je     11a4 <zipEncodeLength+0x94>
movb   $0x80,0xb(%rsp)
mov    %edx,%eax
shr    $0x18,%eax
mov    %al,0xc(%rsp)
mov    %edx,%eax
shr    $0x10,%eax
mov    %al,0xd(%rsp)
mov    %dh,0xe(%rsp)
mov    %dl,0xf(%rsp)
mov    $0x5,%al
jmp    1137 <zipEncodeLength+0x27>
mov    $0x2,%ebx
jmp    114d <zipEncodeLength+0x3d>
mov    $0x5,%ebx
jmp    114d <zipEncodeLength+0x3d>

LLVM IR (-O0):
define i32 @zipEncodeLength(i8* %0, i8 zeroext %1, i32 %2) {
%4 = alloca i32
%5 = alloca i8*
%6 = alloca i8
%7 = alloca i32
%8 = alloca i8
%9 = alloca [5 x i8]
store i8* %0, i8** %5
store i8 %1, i8* %6
store i32 %2, i32* %7
store i8 1, i8* %8
%10 = load i8, i8* %6
%11 = zext i8 %10 to i32
%12 = and i32 %11, 192
%13 = icmp slt i32 %12, 192
br i1 %13, label %14, label %85
14: ; preds = %3
%15 = load i32, i32* %7
%16 = icmp ule i32 %15, 63
br i1 %16, label %17, label %28
17: ; preds = %14
%18 = load i8*, i8** %5
%19 = icmp ne i8* %18, null
br i1 %19, label %23, label %20
20: ; preds = %17
%21 = load i8, i8* %8
%22 = zext i8 %21 to i32
store i32 %22, i32* %4
br label %101
23: ; preds = %17
%24 = load i32, i32* %7
%25 = or i32 0, %24
%26 = trunc i32 %25 to i8
%27 = getelementptr inbounds [5 x i8], [5 x i8]* %9, i64 0, i64 0
store i8 %26, i8* %27
br label %84
28: ; preds = %14
%29 = load i32, i32* %7
%30 = icmp ule i32 %29, 16383
br i1 %30, label %31, label %52
31: ; preds = %28
%32 = load i8, i8* %8
%33 = zext i8 %32 to i32
%34 = add nsw i32 %33, 1
%35 = trunc i32 %34 to i8
store i8 %35, i8* %8
%36 = load i8*, i8** %5
%37 = icmp ne i8* %36, null
br i1 %37, label %41, label %38
38: ; preds = %31
%39 = load i8, i8* %8
%40 = zext i8 %39 to i32
store i32 %40, i32* %4
br label %101
41: ; preds = %31
%42 = load i32, i32* %7
%43 = lshr i32 %42, 8
%44 = and i32 %43, 63
%45 = or i32 64, %44
%46 = trunc i32 %45 to i8
%47 = getelementptr inbounds [5 x i8], [5 x i8]* %9, i64 0, i64 0
store i8 %46, i8* %47
%48 = load i32, i32* %7
%49 = and i32 %48, 255
%50 = trunc i32 %49 to i8
%51 = getelementptr inbounds [5 x i8], [5 x i8]* %9, i64 0, i64 1
store i8 %50, i8* %51
br label %83
52: ; preds = %28
%53 = load i8, i8* %8
%54 = zext i8 %53 to i32
%55 = add nsw i32 %54, 4
%56 = trunc i32 %55 to i8
store i8 %56, i8* %8
%57 = load i8*, i8** %5
%58 = icmp ne i8* %57, null
br i1 %58, label %62, label %59
59: ; preds = %52
%60 = load i8, i8* %8
%61 = zext i8 %60 to i32
store i32 %61, i32* %4
br label %101
62: ; preds = %52
%63 = getelementptr inbounds [5 x i8], [5 x i8]* %9, i64 0, i64 0
store i8 -128, i8* %63
%64 = load i32, i32* %7
%65 = lshr i32 %64, 24
%66 = and i32 %65, 255
%67 = trunc i32 %66 to i8
%68 = getelementptr inbounds [5 x i8], [5 x i8]* %9, i64 0, i64 1
store i8 %67, i8* %68
%69 = load i32, i32* %7
%70 = lshr i32 %69, 16
%71 = and i32 %70, 255
%72 = trunc i32 %71 to i8
%73 = getelementptr inbounds [5 x i8], [5 x i8]* %9, i64 0, i64 2
store i8 %72, i8* %73
%74 = load i32, i32* %7
%75 = lshr i32 %74, 8
%76 = and i32 %75, 255
%77 = trunc i32 %76 to i8
%78 = getelementptr inbounds [5 x i8], [5 x i8]* %9, i64 0, i64 3
store i8 %77, i8* %78
%79 = load i32, i32* %7
%80 = and i32 %79, 255
%81 = trunc i32 %80 to i8
%82 = getelementptr inbounds [5 x i8], [5 x i8]* %9, i64 0, i64 4
store i8 %81, i8* %82
br label %83
83: ; preds = %62, %41
br label %84
84: ; preds = %83, %23
br label %94
85: ; preds = %3
%86 = load i8*, i8** %5
%87 = icmp ne i8* %86, null
br i1 %87, label %91, label %88
88: ; preds = %85
%89 = load i8, i8* %8
%90 = zext i8 %89 to i32
store i32 %90, i32* %4
br label %101
91: ; preds = %85
%92 = load i8, i8* %6
%93 = getelementptr inbounds [5 x i8], [5 x i8]* %9, i64 0, i64 0
store i8 %92, i8* %93
br label %94
94: ; preds = %91, %84
%95 = load i8*, i8** %5
%96 = getelementptr inbounds [5 x i8], [5 x i8]* %9, i64 0, i64 0
%97 = load i8, i8* %8
%98 = call i32 @memcpy(i8* %95, i8* %96, i8 zeroext %97)
%99 = load i8, i8* %8
%100 = zext i8 %99 to i32
store i32 %100, i32* %4
br label %101
101: ; preds = %94, %88, %59, %38, %20
%102 = load i32, i32* %4
ret i32 %102
}

LLVM IR (-O2):
define i32 @zipEncodeLength(i8* %0, i8 zeroext %1, i32 %2) {
%4 = alloca [5 x i8]
%5 = getelementptr inbounds [5 x i8], [5 x i8]* %4, i64 0, i64 0
%6 = icmp ugt i8 %1, -65
br i1 %6, label %36, label %7
7: ; preds = %3
%8 = icmp ult i32 %2, 64
br i1 %8, label %9, label %13
9: ; preds = %7
%10 = icmp eq i8* %0, null
br i1 %10, label %43, label %11
11: ; preds = %9
%12 = trunc i32 %2 to i8
store i8 %12, i8* %5
br label %39
13: ; preds = %7
%14 = icmp ult i32 %2, 16384
%15 = icmp eq i8* %0, null
br i1 %14, label %16, label %23
16: ; preds = %13
br i1 %15, label %43, label %17
17: ; preds = %16
%18 = lshr i32 %2, 8
%19 = trunc i32 %18 to i8
%20 = or i8 %19, 64
store i8 %20, i8* %5
%21 = trunc i32 %2 to i8
%22 = getelementptr inbounds [5 x i8], [5 x i8]* %4, i64 0, i64 1
store i8 %21, i8* %22
br label %39
23: ; preds = %13
br i1 %15, label %43, label %24
24: ; preds = %23
store i8 -128, i8* %5
%25 = lshr i32 %2, 24
%26 = trunc i32 %25 to i8
%27 = getelementptr inbounds [5 x i8], [5 x i8]* %4, i64 0, i64 1
store i8 %26, i8* %27
%28 = lshr i32 %2, 16
%29 = trunc i32 %28 to i8
%30 = getelementptr inbounds [5 x i8], [5 x i8]* %4, i64 0, i64 2
store i8 %29, i8* %30
%31 = lshr i32 %2, 8
%32 = trunc i32 %31 to i8
%33 = getelementptr inbounds [5 x i8], [5 x i8]* %4, i64 0, i64 3
store i8 %32, i8* %33
%34 = trunc i32 %2 to i8
%35 = getelementptr inbounds [5 x i8], [5 x i8]* %4, i64 0, i64 4
store i8 %34, i8* %35
br label %39
36: ; preds = %3
%37 = icmp eq i8* %0, null
br i1 %37, label %43, label %38
38: ; preds = %36
store i8 %1, i8* %5
br label %39
39: ; preds = %11, %24, %17, %38
%40 = phi i8 [ 1, %11 ], [ 2, %17 ], [ 5, %24 ], [ 1, %38 ]
%41 = call i32 @memcpy(i8* %0, i8* %5, i8 zeroext %40)
%42 = zext i8 %40 to i32
br label %43
43: ; preds = %36, %23, %16, %9, %39
%44 = phi i32 [ %42, %39 ], [ 1, %9 ], [ 2, %16 ], [ 5, %23 ], [ 1, %36 ]
ret i32 %44
}