#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 /*<<< orphan*/ uint8_t;

/* Variables and functions */
int /*<<< orphan*/ assert(int);
scalar_t__ calloc(int, size_t);
int /*<<< orphan*/ memset(int /*<<< orphan*/ *, int /*<<< orphan*/, size_t);
scalar_t__ realloc(size_t *, size_t);
size_t _ProtoBufBytes(uint8_t **bytes, const void *data, size_t dataLen) {
  if (data || dataLen == 0) {
    if (!*bytes)
      do {
        size_t _array_cap = (dataLen);
        assert(_array_cap >= 0);
        (*bytes) = (void *)((size_t *)calloc(1, _array_cap * sizeof(*(*bytes)) +
                                                    sizeof(size_t) * 2) +
                            2);
        assert((*bytes) != NULL);
        (((size_t *)(*bytes))[-2]) = _array_cap;
        (((size_t *)(*bytes))[-1]) = 0;
      } while (0);
    do {
      assert((*bytes) != NULL);
      memset((*bytes), 0, (((size_t *)(*bytes))[-1]) * sizeof(*(*bytes)));
      (((size_t *)(*bytes))[-1]) = 0;
    } while (0);
    do {
      assert((*bytes) != NULL);
      size_t _array_cnt = (dataLen), _array_i = (((size_t *)(*bytes))[-1]),
             _array_j = 0;
      assert(((const uint8_t *)data) != NULL || _array_cnt == 0);
      assert(_array_cnt >= 0);
      if (_array_i + _array_cnt > (((size_t *)(*bytes))[-2]))
        do {
          size_t _array_cap = ((_array_i + _array_cnt) * 3 / 2);
          assert((*bytes) != NULL);
          assert(_array_cap >= (((size_t *)(*bytes))[-1]));
          (*bytes) = (void *)((size_t *)realloc((size_t *)(*bytes) - 2,
                                                _array_cap * sizeof(*(*bytes)) +
                                                    sizeof(size_t) * 2) +
                              2);
          assert((*bytes) != NULL);
          if (_array_cap > (((size_t *)(*bytes))[-2]))
            memset((*bytes) + (((size_t *)(*bytes))[-2]), 0,
                   (_array_cap - (((size_t *)(*bytes))[-2])) *
                       sizeof(*(*bytes)));
          (((size_t *)(*bytes))[-2]) = _array_cap;
        } while (0);
      while (_array_j < _array_cnt)
        (*bytes)[_array_i++] = ((const uint8_t *)data)[_array_j++];
      (((size_t *)(*bytes))[-1]) += _array_cnt;
    } while (0);
  }
  return (*bytes) ? (((size_t *)(*bytes))[-1]) : 0;
}


x86 assembly (clang, -O0):
<_ProtoBufBytes>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
cmpq   $0x0,-0x10(%rbp)
jne    116a <_ProtoBufBytes+0x2a>
cmpq   $0x0,-0x18(%rbp)
jne    140c <_ProtoBufBytes+0x2cc>
mov    -0x8(%rbp),%rax
cmpq   $0x0,(%rax)
jne    11f3 <_ProtoBufBytes+0xb3>
jmp    117d <_ProtoBufBytes+0x3d>
mov    -0x18(%rbp),%rax
mov    %rax,-0x20(%rbp)
cmpq   $0x0,-0x20(%rbp)
setae  %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
mov    -0x20(%rbp),%rsi
shl    $0x2,%rsi
add    $0x10,%rsi
mov    $0x1,%edi
call   1040 <calloc@plt>
mov    %rax,%rcx
add    $0x10,%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x8(%rbp),%rax
cmpq   $0x0,(%rax)
setne  %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
mov    -0x20(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    %rcx,-0x10(%rax)
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
movq   $0x0,-0x8(%rax)
jmp    11f3 <_ProtoBufBytes+0xb3>
jmp    11f8 <_ProtoBufBytes+0xb8>
mov    -0x8(%rbp),%rax
cmpq   $0x0,(%rax)
setne  %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
mov    -0x8(%rbp),%rax
mov    (%rax),%rdi
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    -0x8(%rax),%rdx
shl    $0x2,%rdx
xor    %esi,%esi
call   1030 <memset@plt>
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
movq   $0x0,-0x8(%rax)
jmp    123e <_ProtoBufBytes+0xfe>
mov    -0x8(%rbp),%rax
cmpq   $0x0,(%rax)
setne  %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
mov    -0x18(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    -0x8(%rax),%rax
mov    %rax,-0x30(%rbp)
movq   $0x0,-0x38(%rbp)
mov    -0x10(%rbp),%rcx
mov    $0x1,%al
cmp    $0x0,%rcx
mov    %al,-0x41(%rbp)
jne    1290 <_ProtoBufBytes+0x150>
cmpq   $0x0,-0x28(%rbp)
sete   %al
mov    %al,-0x41(%rbp)
mov    -0x41(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
cmpq   $0x0,-0x28(%rbp)
setae  %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
mov    -0x30(%rbp),%rax
add    -0x28(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    (%rcx),%rcx
cmp    -0x10(%rcx),%rax
jbe    13ad <_ProtoBufBytes+0x26d>
jmp    12cd <_ProtoBufBytes+0x18d>
mov    -0x30(%rbp),%rax
add    -0x28(%rbp),%rax
imul   $0x3,%rax,%rax
shr    $0x1,%rax
mov    %rax,-0x40(%rbp)
mov    -0x8(%rbp),%rax
cmpq   $0x0,(%rax)
setne  %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
mov    -0x40(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    (%rcx),%rcx
cmp    -0x8(%rcx),%rax
setae  %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
mov    -0x8(%rbp),%rax
mov    (%rax),%rdi
add    $0xfffffffffffffff0,%rdi
mov    -0x40(%rbp),%rsi
shl    $0x2,%rsi
add    $0x10,%rsi
call   1060 <realloc@plt>
mov    %rax,%rcx
add    $0x10,%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x8(%rbp),%rax
cmpq   $0x0,(%rax)
setne  %al
and    $0x1,%al
movzbl %al,%edi
call   1050 <assert@plt>
mov    -0x40(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    (%rcx),%rcx
cmp    -0x10(%rcx),%rax
jbe    1399 <_ProtoBufBytes+0x259>
mov    -0x8(%rbp),%rax
mov    (%rax),%rdi
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    -0x10(%rax),%rax
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x40(%rbp),%rdx
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
sub    -0x10(%rax),%rdx
shl    $0x2,%rdx
xor    %esi,%esi
call   1030 <memset@plt>
mov    -0x40(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    %rcx,-0x10(%rax)
jmp    13ad <_ProtoBufBytes+0x26d>
jmp    13b2 <_ProtoBufBytes+0x272>
mov    -0x38(%rbp),%rax
cmp    -0x28(%rbp),%rax
jae    13f4 <_ProtoBufBytes+0x2b4>
mov    -0x10(%rbp),%rax
mov    -0x38(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x38(%rbp)
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    -0x30(%rbp),%rcx
mov    %rcx,%rsi
add    $0x1,%rsi
mov    %rsi,-0x30(%rbp)
mov    %edx,(%rax,%rcx,4)
jmp    13b2 <_ProtoBufBytes+0x272>
mov    -0x28(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
add    -0x8(%rax),%rcx
mov    %rcx,-0x8(%rax)
jmp    140c <_ProtoBufBytes+0x2cc>
mov    -0x8(%rbp),%rax
cmpq   $0x0,(%rax)
je     142e <_ProtoBufBytes+0x2ee>
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    -0x8(%rax),%rax
mov    %rax,-0x50(%rbp)
jmp    1439 <_ProtoBufBytes+0x2f9>
xor    %eax,%eax
mov    %rax,-0x50(%rbp)
jmp    1439 <_ProtoBufBytes+0x2f9>
mov    -0x50(%rbp),%rax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<_ProtoBufBytes>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %rdx,%r14
mov    %rsi,%r12
mov    %rdi,%r15
mov    (%rdi),%rax
test   %rsi,%rsi
jne    1171 <_ProtoBufBytes+0x31>
test   %r14,%r14
je     1171 <_ProtoBufBytes+0x31>
test   %rax,%rax
jne    1414 <_ProtoBufBytes+0x2d4>
xor    %eax,%eax
jmp    1418 <_ProtoBufBytes+0x2d8>
test   %rax,%rax
jne    11b2 <_ProtoBufBytes+0x72>
mov    $0x1,%edi
call   1050 <assert@plt>
lea    0x10(,%r14,4),%rsi
mov    $0x1,%edi
call   1040 <calloc@plt>
add    $0x10,%rax
mov    %rax,(%r15)
mov    $0x1,%edi
call   1050 <assert@plt>
mov    (%r15),%rax
mov    %r14,-0x10(%rax)
movq   $0x0,-0x8(%rax)
mov    $0x1,%edi
call   1050 <assert@plt>
mov    (%r15),%rdi
mov    -0x8(%rdi),%rdx
shl    $0x2,%rdx
xor    %esi,%esi
call   1030 <memset@plt>
mov    (%r15),%rax
movq   $0x0,-0x8(%rax)
xor    %edi,%edi
test   %rax,%rax
setne  %dil
call   1050 <assert@plt>
mov    (%r15),%rax
mov    -0x8(%rax),%rbx
mov    $0x1,%edi
call   1050 <assert@plt>
mov    $0x1,%edi
call   1050 <assert@plt>
lea    (%rbx,%r14,1),%r13
mov    (%r15),%rax
cmp    -0x10(%rax),%r13
jbe    1283 <_ProtoBufBytes+0x143>
lea    0x0(,%r13,2),%rbp
add    %r13,%rbp
shr    %rbp
mov    $0x1,%edi
call   1050 <assert@plt>
mov    (%r15),%rax
xor    %edi,%edi
cmp    -0x8(%rax),%rbp
setae  %dil
call   1050 <assert@plt>
mov    (%r15),%rdi
add    $0xfffffffffffffff0,%rdi
lea    0x10(,%rbp,4),%rsi
call   1060 <realloc@plt>
add    $0x10,%rax
mov    %rax,(%r15)
mov    $0x1,%edi
call   1050 <assert@plt>
mov    (%r15),%rax
mov    -0x10(%rax),%rcx
mov    %rbp,%rdx
sub    %rcx,%rdx
jbe    127f <_ProtoBufBytes+0x13f>
lea    (%rax,%rcx,4),%rdi
shl    $0x2,%rdx
xor    %esi,%esi
call   1030 <memset@plt>
mov    (%r15),%rax
mov    %rbp,-0x10(%rax)
test   %r14,%r14
je     1410 <_ProtoBufBytes+0x2d0>
cmp    $0x8,%r14
jb     12b0 <_ProtoBufBytes+0x170>
lea    (%rax,%rbx,4),%rcx
lea    (%r12,%r14,4),%rdx
cmp    %rcx,%rdx
jbe    133c <_ProtoBufBytes+0x1fc>
lea    (%rax,%r13,4),%rcx
cmp    %r12,%rcx
jbe    133c <_ProtoBufBytes+0x1fc>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %r14,%rdx
mov    %r14,%rsi
and    $0x3,%rsi
je     12e5 <_ProtoBufBytes+0x1a5>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%r12,%rcx,4),%edi
add    $0x1,%rcx
mov    %edi,(%rax,%rbx,4)
add    $0x1,%rbx
add    $0xffffffffffffffff,%rsi
jne    12d0 <_ProtoBufBytes+0x190>
cmp    $0x3,%rdx
jb     1410 <_ProtoBufBytes+0x2d0>
lea    (%rax,%rbx,4),%rdx
add    $0xc,%rdx
mov    %r14,%rsi
sub    %rcx,%rsi
lea    (%r12,%rcx,4),%rcx
add    $0xc,%rcx
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
mov    -0xc(%rcx,%rdi,4),%ebp
mov    %ebp,-0xc(%rdx,%rdi,4)
mov    -0x8(%rcx,%rdi,4),%ebp
mov    %ebp,-0x8(%rdx,%rdi,4)
mov    -0x4(%rcx,%rdi,4),%ebp
mov    %ebp,-0x4(%rdx,%rdi,4)
mov    (%rcx,%rdi,4),%ebp
mov    %ebp,(%rdx,%rdi,4)
add    $0x4,%rdi
cmp    %rdi,%rsi
jne    1310 <_ProtoBufBytes+0x1d0>
jmp    1410 <_ProtoBufBytes+0x2d0>
mov    %r14,%rcx
and    $0xfffffffffffffff8,%rcx
lea    -0x8(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0x18,%rdi
jae    1361 <_ProtoBufBytes+0x221>
xor    %edi,%edi
jmp    13d1 <_ProtoBufBytes+0x291>
and    $0xfffffffffffffffc,%rsi
lea    (%rax,%rbx,4),%rbp
add    $0x70,%rbp
xor    %edi,%edi
nop
movups (%r12,%rdi,4),%xmm0
movups 0x10(%r12,%rdi,4),%xmm1
movups %xmm0,-0x70(%rbp,%rdi,4)
movups %xmm1,-0x60(%rbp,%rdi,4)
movups 0x20(%r12,%rdi,4),%xmm0
movups 0x30(%r12,%rdi,4),%xmm1
movups %xmm0,-0x50(%rbp,%rdi,4)
movups %xmm1,-0x40(%rbp,%rdi,4)
movups 0x40(%r12,%rdi,4),%xmm0
movups 0x50(%r12,%rdi,4),%xmm1
movups %xmm0,-0x30(%rbp,%rdi,4)
movups %xmm1,-0x20(%rbp,%rdi,4)
movups 0x60(%r12,%rdi,4),%xmm0
movups 0x70(%r12,%rdi,4),%xmm1
movups %xmm0,-0x10(%rbp,%rdi,4)
movups %xmm1,0x0(%rbp,%rdi,4)
add    $0x20,%rdi
add    $0xfffffffffffffffc,%rsi
jne    1370 <_ProtoBufBytes+0x230>
test   %rdx,%rdx
je     140b <_ProtoBufBytes+0x2cb>
lea    (%r12,%rdi,4),%rsi
add    $0x10,%rsi
add    %rbx,%rdi
lea    (%rax,%rdi,4),%rdi
add    $0x10,%rdi
shl    $0x5,%rdx
xor    %ebp,%ebp
nop
movups -0x10(%rsi,%rbp,1),%xmm0
movups (%rsi,%rbp,1),%xmm1
movups %xmm0,-0x10(%rdi,%rbp,1)
movups %xmm1,(%rdi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rdx
jne    13f0 <_ProtoBufBytes+0x2b0>
cmp    %r14,%rcx
jne    1427 <_ProtoBufBytes+0x2e7>
add    %r14,-0x8(%rax)
mov    -0x8(%rax),%rax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
add    %rcx,%rbx
jmp    12b2 <_ProtoBufBytes+0x172>

LLVM IR (-O0):
define i64 @_ProtoBufBytes(i32** %0, i8* %1, i64 %2) {
%4 = alloca i32**
%5 = alloca i8*
%6 = alloca i64
%7 = alloca i64
%8 = alloca i64
%9 = alloca i64
%10 = alloca i64
%11 = alloca i64
store i32** %0, i32*** %4
store i8* %1, i8** %5
store i64 %2, i64* %6
%12 = load i8*, i8** %5
%13 = icmp ne i8* %12, null
br i1 %13, label %17, label %14
14: ; preds = %3
%15 = load i64, i64* %6
%16 = icmp eq i64 %15, 0
br i1 %16, label %17, label %205
17: ; preds = %14, %3
%18 = load i32**, i32*** %4
%19 = load i32*, i32** %18
%20 = icmp ne i32* %19, null
br i1 %20, label %52, label %21
21: ; preds = %17
br label %22
22: ; preds = %21
%23 = load i64, i64* %6
store i64 %23, i64* %7
%24 = load i64, i64* %7
%25 = icmp uge i64 %24, 0
%26 = zext i1 %25 to i32
%27 = call i32 @assert(i32 %26)
%28 = load i64, i64* %7
%29 = mul i64 %28, 4
%30 = add i64 %29, 16
%31 = call i64 @calloc(i32 1, i64 %30)
%32 = inttoptr i64 %31 to i64*
%33 = getelementptr inbounds i64, i64* %32, i64 2
%34 = bitcast i64* %33 to i8*
%35 = bitcast i8* %34 to i32*
%36 = load i32**, i32*** %4
store i32* %35, i32** %36
%37 = load i32**, i32*** %4
%38 = load i32*, i32** %37
%39 = icmp ne i32* %38, null
%40 = zext i1 %39 to i32
%41 = call i32 @assert(i32 %40)
%42 = load i64, i64* %7
%43 = load i32**, i32*** %4
%44 = load i32*, i32** %43
%45 = bitcast i32* %44 to i64*
%46 = getelementptr inbounds i64, i64* %45, i64 -2
store i64 %42, i64* %46
%47 = load i32**, i32*** %4
%48 = load i32*, i32** %47
%49 = bitcast i32* %48 to i64*
%50 = getelementptr inbounds i64, i64* %49, i64 -1
store i64 0, i64* %50
br label %51
51: ; preds = %22
br label %52
52: ; preds = %51, %17
br label %53
53: ; preds = %52
%54 = load i32**, i32*** %4
%55 = load i32*, i32** %54
%56 = icmp ne i32* %55, null
%57 = zext i1 %56 to i32
%58 = call i32 @assert(i32 %57)
%59 = load i32**, i32*** %4
%60 = load i32*, i32** %59
%61 = load i32**, i32*** %4
%62 = load i32*, i32** %61
%63 = bitcast i32* %62 to i64*
%64 = getelementptr inbounds i64, i64* %63, i64 -1
%65 = load i64, i64* %64
%66 = mul i64 %65, 4
%67 = call i32 @memset(i32* %60, i32 0, i64 %66)
%68 = load i32**, i32*** %4
%69 = load i32*, i32** %68
%70 = bitcast i32* %69 to i64*
%71 = getelementptr inbounds i64, i64* %70, i64 -1
store i64 0, i64* %71
br label %72
72: ; preds = %53
br label %73
73: ; preds = %72
%74 = load i32**, i32*** %4
%75 = load i32*, i32** %74
%76 = icmp ne i32* %75, null
%77 = zext i1 %76 to i32
%78 = call i32 @assert(i32 %77)
%79 = load i64, i64* %6
store i64 %79, i64* %8
%80 = load i32**, i32*** %4
%81 = load i32*, i32** %80
%82 = bitcast i32* %81 to i64*
%83 = getelementptr inbounds i64, i64* %82, i64 -1
%84 = load i64, i64* %83
store i64 %84, i64* %9
store i64 0, i64* %10
%85 = load i8*, i8** %5
%86 = bitcast i8* %85 to i32*
%87 = icmp ne i32* %86, null
br i1 %87, label %91, label %88
88: ; preds = %73
%89 = load i64, i64* %8
%90 = icmp eq i64 %89, 0
br label %91
91: ; preds = %88, %73
%92 = phi i1 [ true, %73 ], [ %90, %88 ]
%93 = zext i1 %92 to i32
%94 = call i32 @assert(i32 %93)
%95 = load i64, i64* %8
%96 = icmp uge i64 %95, 0
%97 = zext i1 %96 to i32
%98 = call i32 @assert(i32 %97)
%99 = load i64, i64* %9
%100 = load i64, i64* %8
%101 = add i64 %99, %100
%102 = load i32**, i32*** %4
%103 = load i32*, i32** %102
%104 = bitcast i32* %103 to i64*
%105 = getelementptr inbounds i64, i64* %104, i64 -2
%106 = load i64, i64* %105
%107 = icmp ugt i64 %101, %106
br i1 %107, label %108, label %179
108: ; preds = %91
br label %109
109: ; preds = %108
%110 = load i64, i64* %9
%111 = load i64, i64* %8
%112 = add i64 %110, %111
%113 = mul i64 %112, 3
%114 = udiv i64 %113, 2
store i64 %114, i64* %11
%115 = load i32**, i32*** %4
%116 = load i32*, i32** %115
%117 = icmp ne i32* %116, null
%118 = zext i1 %117 to i32
%119 = call i32 @assert(i32 %118)
%120 = load i64, i64* %11
%121 = load i32**, i32*** %4
%122 = load i32*, i32** %121
%123 = bitcast i32* %122 to i64*
%124 = getelementptr inbounds i64, i64* %123, i64 -1
%125 = load i64, i64* %124
%126 = icmp uge i64 %120, %125
%127 = zext i1 %126 to i32
%128 = call i32 @assert(i32 %127)
%129 = load i32**, i32*** %4
%130 = load i32*, i32** %129
%131 = bitcast i32* %130 to i64*
%132 = getelementptr inbounds i64, i64* %131, i64 -2
%133 = load i64, i64* %11
%134 = mul i64 %133, 4
%135 = add i64 %134, 16
%136 = call i64 @realloc(i64* %132, i64 %135)
%137 = inttoptr i64 %136 to i64*
%138 = getelementptr inbounds i64, i64* %137, i64 2
%139 = bitcast i64* %138 to i8*
%140 = bitcast i8* %139 to i32*
%141 = load i32**, i32*** %4
store i32* %140, i32** %141
%142 = load i32**, i32*** %4
%143 = load i32*, i32** %142
%144 = icmp ne i32* %143, null
%145 = zext i1 %144 to i32
%146 = call i32 @assert(i32 %145)
%147 = load i64, i64* %11
%148 = load i32**, i32*** %4
%149 = load i32*, i32** %148
%150 = bitcast i32* %149 to i64*
%151 = getelementptr inbounds i64, i64* %150, i64 -2
%152 = load i64, i64* %151
%153 = icmp ugt i64 %147, %152
br i1 %153, label %154, label %172
154: ; preds = %109
%155 = load i32**, i32*** %4
%156 = load i32*, i32** %155
%157 = load i32**, i32*** %4
%158 = load i32*, i32** %157
%159 = bitcast i32* %158 to i64*
%160 = getelementptr inbounds i64, i64* %159, i64 -2
%161 = load i64, i64* %160
%162 = getelementptr inbounds i32, i32* %156, i64 %161
%163 = load i64, i64* %11
%164 = load i32**, i32*** %4
%165 = load i32*, i32** %164
%166 = bitcast i32* %165 to i64*
%167 = getelementptr inbounds i64, i64* %166, i64 -2
%168 = load i64, i64* %167
%169 = sub i64 %163, %168
%170 = mul i64 %169, 4
%171 = call i32 @memset(i32* %162, i32 0, i64 %170)
br label %172
172: ; preds = %154, %109
%173 = load i64, i64* %11
%174 = load i32**, i32*** %4
%175 = load i32*, i32** %174
%176 = bitcast i32* %175 to i64*
%177 = getelementptr inbounds i64, i64* %176, i64 -2
store i64 %173, i64* %177
br label %178
178: ; preds = %172
br label %179
179: ; preds = %178, %91
br label %180
180: ; preds = %184, %179
%181 = load i64, i64* %10
%182 = load i64, i64* %8
%183 = icmp ult i64 %181, %182
br i1 %183, label %184, label %196
184: ; preds = %180
%185 = load i8*, i8** %5
%186 = bitcast i8* %185 to i32*
%187 = load i64, i64* %10
%188 = add i64 %187, 1
store i64 %188, i64* %10
%189 = getelementptr inbounds i32, i32* %186, i64 %187
%190 = load i32, i32* %189
%191 = load i32**, i32*** %4
%192 = load i32*, i32** %191
%193 = load i64, i64* %9
%194 = add i64 %193, 1
store i64 %194, i64* %9
%195 = getelementptr inbounds i32, i32* %192, i64 %193
store i32 %190, i32* %195
br label %180
196: ; preds = %180
%197 = load i64, i64* %8
%198 = load i32**, i32*** %4
%199 = load i32*, i32** %198
%200 = bitcast i32* %199 to i64*
%201 = getelementptr inbounds i64, i64* %200, i64 -1
%202 = load i64, i64* %201
%203 = add i64 %202, %197
store i64 %203, i64* %201
br label %204
204: ; preds = %196
br label %205
205: ; preds = %204, %14
%206 = load i32**, i32*** %4
%207 = load i32*, i32** %206
%208 = icmp ne i32* %207, null
br i1 %208, label %209, label %215
209: ; preds = %205
%210 = load i32**, i32*** %4
%211 = load i32*, i32** %210
%212 = bitcast i32* %211 to i64*
%213 = getelementptr inbounds i64, i64* %212, i64 -1
%214 = load i64, i64* %213
br label %216
215: ; preds = %205
br label %216
216: ; preds = %215, %209
%217 = phi i64 [ %214, %209 ], [ 0, %215 ]
ret i64 %217
}

LLVM IR (-O2):
define i64 @_ProtoBufBytes(i32** nocapture %0, i8* %1, i64 %2) {
%4 = icmp ne i8* %1, null
%5 = icmp eq i64 %2, 0
%6 = or i1 %4, %5
%7 = load i32*, i32** %0
%8 = icmp eq i32* %7, null
br i1 %6, label %9, label %236
9: ; preds = %3
br i1 %8, label %10, label %22
10: ; preds = %9
%11 = tail call i32 @assert(i32 1)
%12 = shl i64 %2, 2
%13 = add i64 %12, 16
%14 = tail call i64 @calloc(i32 1, i64 %13)
%15 = inttoptr i64 %14 to i64*
%16 = getelementptr inbounds i64, i64* %15, i64 2
%17 = bitcast i32** %0 to i64**
store i64* %16, i64** %17
%18 = tail call i32 @assert(i32 1)
%19 = load i64*, i64** %17
%20 = getelementptr inbounds i64, i64* %19, i64 -2
store i64 %2, i64* %20
%21 = getelementptr inbounds i64, i64* %19, i64 -1
store i64 0, i64* %21
br label %22
22: ; preds = %9, %10
%23 = bitcast i32** %0 to i64**
%24 = tail call i32 @assert(i32 1)
%25 = load i32*, i32** %0
%26 = getelementptr inbounds i32, i32* %25, i64 -2
%27 = bitcast i32* %26 to i64*
%28 = load i64, i64* %27
%29 = shl i64 %28, 2
%30 = tail call i32 @memset(i32* %25, i32 0, i64 %29)
%31 = load i64*, i64** %23
%32 = getelementptr inbounds i64, i64* %31, i64 -1
store i64 0, i64* %32
%33 = icmp ne i64* %31, null
%34 = zext i1 %33 to i32
%35 = tail call i32 @assert(i32 %34)
%36 = load i64*, i64** %23
%37 = getelementptr inbounds i64, i64* %36, i64 -1
%38 = load i64, i64* %37
%39 = bitcast i8* %1 to i32*
%40 = tail call i32 @assert(i32 1)
%41 = tail call i32 @assert(i32 1)
%42 = add i64 %38, %2
%43 = load i32*, i32** %0
%44 = getelementptr inbounds i32, i32* %43, i64 -4
%45 = bitcast i32* %44 to i64*
%46 = load i64, i64* %45
%47 = icmp ugt i64 %42, %46
%48 = bitcast i32* %43 to i64*
br i1 %47, label %49, label %84
49: ; preds = %22
%50 = mul i64 %42, 3
%51 = lshr i64 %50, 1
%52 = tail call i32 @assert(i32 1)
%53 = load i64*, i64** %23
%54 = getelementptr inbounds i64, i64* %53, i64 -1
%55 = load i64, i64* %54
%56 = icmp uge i64 %51, %55
%57 = zext i1 %56 to i32
%58 = tail call i32 @assert(i32 %57)
%59 = load i64*, i64** %23
%60 = getelementptr inbounds i64, i64* %59, i64 -2
%61 = shl i64 %51, 2
%62 = add i64 %61, 16
%63 = tail call i64 @realloc(i64* %60, i64 %62)
%64 = inttoptr i64 %63 to i64*
%65 = getelementptr inbounds i64, i64* %64, i64 2
store i64* %65, i64** %23
%66 = tail call i32 @assert(i32 1)
%67 = load i32*, i32** %0
%68 = getelementptr inbounds i32, i32* %67, i64 -4
%69 = bitcast i32* %68 to i64*
%70 = load i64, i64* %69
%71 = icmp ugt i64 %51, %70
%72 = bitcast i32* %67 to i64*
br i1 %71, label %73, label %80
73: ; preds = %49
%74 = getelementptr inbounds i32, i32* %67, i64 %70
%75 = sub i64 %51, %70
%76 = shl i64 %75, 2
%77 = tail call i32 @memset(i32* %74, i32 0, i64 %76)
%78 = load i64*, i64** %23
%79 = bitcast i64* %78 to i32*
br label %80
80: ; preds = %73, %49
%81 = phi i64* [ %78, %73 ], [ %72, %49 ]
%82 = phi i32* [ %79, %73 ], [ %67, %49 ]
%83 = getelementptr inbounds i64, i64* %81, i64 -2
store i64 %51, i64* %83
br label %84
84: ; preds = %80, %22
%85 = phi i64* [ %81, %80 ], [ %48, %22 ]
%86 = phi i32* [ %82, %80 ], [ %43, %22 ]
br i1 %5, label %231, label %87
87: ; preds = %84
%88 = icmp ult i64 %2, 8
br i1 %88, label %185, label %89
89: ; preds = %87
%90 = getelementptr i32, i32* %86, i64 %38
%91 = bitcast i32* %90 to i8*
%92 = add i64 %38, %2
%93 = getelementptr i32, i32* %86, i64 %92
%94 = bitcast i32* %93 to i8*
%95 = shl i64 %2, 2
%96 = getelementptr i8, i8* %1, i64 %95
%97 = icmp ugt i8* %96, %91
%98 = icmp ugt i8* %94, %1
%99 = and i1 %97, %98
br i1 %99, label %185, label %100
100: ; preds = %89
%101 = and i64 %2, -8
%102 = add i64 %38, %101
%103 = add i64 %101, -8
%104 = lshr exact i64 %103, 3
%105 = add nuw nsw i64 %104, 1
%106 = and i64 %105, 3
%107 = icmp ult i64 %103, 24
br i1 %107, label %163, label %108
108: ; preds = %100
%109 = and i64 %105, 4611686018427387900
br label %110
110: ; preds = %110, %108
%111 = phi i64 [ 0, %108 ], [ %160, %110 ]
%112 = phi i64 [ 0, %108 ], [ %161, %110 ]
%113 = add i64 %38, %111
%114 = getelementptr inbounds i32, i32* %39, i64 %111
%115 = bitcast i32* %114 to <4 x i32>*
%116 = load <4 x i32>, <4 x i32>* %115
%117 = getelementptr inbounds i32, i32* %114, i64 4
%118 = bitcast i32* %117 to <4 x i32>*
%119 = load <4 x i32>, <4 x i32>* %118
%120 = getelementptr inbounds i32, i32* %86, i64 %113
%121 = bitcast i32* %120 to <4 x i32>*
store <4 x i32> %116, <4 x i32>* %121
%122 = getelementptr inbounds i32, i32* %120, i64 4
%123 = bitcast i32* %122 to <4 x i32>*
store <4 x i32> %119, <4 x i32>* %123
%124 = or i64 %111, 8
%125 = add i64 %38, %124
%126 = getelementptr inbounds i32, i32* %39, i64 %124
%127 = bitcast i32* %126 to <4 x i32>*
%128 = load <4 x i32>, <4 x i32>* %127
%129 = getelementptr inbounds i32, i32* %126, i64 4
%130 = bitcast i32* %129 to <4 x i32>*
%131 = load <4 x i32>, <4 x i32>* %130
%132 = getelementptr inbounds i32, i32* %86, i64 %125
%133 = bitcast i32* %132 to <4 x i32>*
store <4 x i32> %128, <4 x i32>* %133
%134 = getelementptr inbounds i32, i32* %132, i64 4
%135 = bitcast i32* %134 to <4 x i32>*
store <4 x i32> %131, <4 x i32>* %135
%136 = or i64 %111, 16
%137 = add i64 %38, %136
%138 = getelementptr inbounds i32, i32* %39, i64 %136
%139 = bitcast i32* %138 to <4 x i32>*
%140 = load <4 x i32>, <4 x i32>* %139
%141 = getelementptr inbounds i32, i32* %138, i64 4
%142 = bitcast i32* %141 to <4 x i32>*
%143 = load <4 x i32>, <4 x i32>* %142
%144 = getelementptr inbounds i32, i32* %86, i64 %137
%145 = bitcast i32* %144 to <4 x i32>*
store <4 x i32> %140, <4 x i32>* %145
%146 = getelementptr inbounds i32, i32* %144, i64 4
%147 = bitcast i32* %146 to <4 x i32>*
store <4 x i32> %143, <4 x i32>* %147
%148 = or i64 %111, 24
%149 = add i64 %38, %148
%150 = getelementptr inbounds i32, i32* %39, i64 %148
%151 = bitcast i32* %150 to <4 x i32>*
%152 = load <4 x i32>, <4 x i32>* %151
%153 = getelementptr inbounds i32, i32* %150, i64 4
%154 = bitcast i32* %153 to <4 x i32>*
%155 = load <4 x i32>, <4 x i32>* %154
%156 = getelementptr inbounds i32, i32* %86, i64 %149
%157 = bitcast i32* %156 to <4 x i32>*
store <4 x i32> %152, <4 x i32>* %157
%158 = getelementptr inbounds i32, i32* %156, i64 4
%159 = bitcast i32* %158 to <4 x i32>*
store <4 x i32> %155, <4 x i32>* %159
%160 = add nuw i64 %111, 32
%161 = add i64 %112, 4
%162 = icmp eq i64 %161, %109
br i1 %162, label %163, label %110
163: ; preds = %110, %100
%164 = phi i64 [ 0, %100 ], [ %160, %110 ]
%165 = icmp eq i64 %106, 0
br i1 %165, label %183, label %166
166: ; preds = %163, %166
%167 = phi i64 [ %180, %166 ], [ %164, %163 ]
%168 = phi i64 [ %181, %166 ], [ 0, %163 ]
%169 = add i64 %38, %167
%170 = getelementptr inbounds i32, i32* %39, i64 %167
%171 = bitcast i32* %170 to <4 x i32>*
%172 = load <4 x i32>, <4 x i32>* %171
%173 = getelementptr inbounds i32, i32* %170, i64 4
%174 = bitcast i32* %173 to <4 x i32>*
%175 = load <4 x i32>, <4 x i32>* %174
%176 = getelementptr inbounds i32, i32* %86, i64 %169
%177 = bitcast i32* %176 to <4 x i32>*
store <4 x i32> %172, <4 x i32>* %177
%178 = getelementptr inbounds i32, i32* %176, i64 4
%179 = bitcast i32* %178 to <4 x i32>*
store <4 x i32> %175, <4 x i32>* %179
%180 = add nuw i64 %167, 8
%181 = add i64 %168, 1
%182 = icmp eq i64 %181, %106
br i1 %182, label %183, label %166
183: ; preds = %166, %163
%184 = icmp eq i64 %101, %2
br i1 %184, label %231, label %185
185: ; preds = %89, %87, %183
%186 = phi i64 [ %38, %89 ], [ %38, %87 ], [ %102, %183 ]
%187 = phi i64 [ 0, %89 ], [ 0, %87 ], [ %101, %183 ]
%188 = xor i64 %187, -1
%189 = add i64 %188, %2
%190 = and i64 %2, 3
%191 = icmp eq i64 %190, 0
br i1 %191, label %203, label %192
192: ; preds = %185, %192
%193 = phi i64 [ %199, %192 ], [ %186, %185 ]
%194 = phi i64 [ %196, %192 ], [ %187, %185 ]
%195 = phi i64 [ %201, %192 ], [ 0, %185 ]
%196 = add nuw i64 %194, 1
%197 = getelementptr inbounds i32, i32* %39, i64 %194
%198 = load i32, i32* %197
%199 = add i64 %193, 1
%200 = getelementptr inbounds i32, i32* %86, i64 %193
store i32 %198, i32* %200
%201 = add i64 %195, 1
%202 = icmp eq i64 %201, %190
br i1 %202, label %203, label %192
203: ; preds = %192, %185
%204 = phi i64 [ %186, %185 ], [ %199, %192 ]
%205 = phi i64 [ %187, %185 ], [ %196, %192 ]
%206 = icmp ult i64 %189, 3
br i1 %206, label %231, label %207
207: ; preds = %203, %207
%208 = phi i64 [ %228, %207 ], [ %204, %203 ]
%209 = phi i64 [ %225, %207 ], [ %205, %203 ]
%210 = add nuw i64 %209, 1
%211 = getelementptr inbounds i32, i32* %39, i64 %209
%212 = load i32, i32* %211
%213 = add i64 %208, 1
%214 = getelementptr inbounds i32, i32* %86, i64 %208
store i32 %212, i32* %214
%215 = add nuw i64 %209, 2
%216 = getelementptr inbounds i32, i32* %39, i64 %210
%217 = load i32, i32* %216
%218 = add i64 %208, 2
%219 = getelementptr inbounds i32, i32* %86, i64 %213
store i32 %217, i32* %219
%220 = add nuw i64 %209, 3
%221 = getelementptr inbounds i32, i32* %39, i64 %215
%222 = load i32, i32* %221
%223 = add i64 %208, 3
%224 = getelementptr inbounds i32, i32* %86, i64 %218
store i32 %222, i32* %224
%225 = add nuw i64 %209, 4
%226 = getelementptr inbounds i32, i32* %39, i64 %220
%227 = load i32, i32* %226
%228 = add i64 %208, 4
%229 = getelementptr inbounds i32, i32* %86, i64 %223
store i32 %227, i32* %229
%230 = icmp eq i64 %225, %2
br i1 %230, label %231, label %207
231: ; preds = %203, %207, %183, %84
%232 = getelementptr inbounds i64, i64* %85, i64 -1
%233 = load i64, i64* %232
%234 = add i64 %233, %2
store i64 %234, i64* %232
%235 = bitcast i64* %85 to i32*
br label %237
236: ; preds = %3
br i1 %8, label %242, label %237
237: ; preds = %231, %236
%238 = phi i32* [ %235, %231 ], [ %7, %236 ]
%239 = getelementptr inbounds i32, i32* %238, i64 -2
%240 = bitcast i32* %239 to i64*
%241 = load i64, i64* %240
br label %242
242: ; preds = %236, %237
%243 = phi i64 [ %241, %237 ], [ 0, %236 ]
ret i64 %243
}