LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_iterator.c
// Function: as_iterator_destroy
void as_iterator_destroy(as_iterator * iterator)
{
    as_util_hook(destroy, 1, iterator);
	iterator->data = NULL;
	iterator->hooks = NULL;
    if ( iterator->free ) {
    	cf_free(iterator);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xc4b4
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xc4b4
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
cmpq $0x0, (%rax)
je 0xc4b4
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
andb $0x1, %al
movzbl %al, %eax
jmp 0xc4b6
jmp 0xc4b6
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
testb $0x1, (%rax)
je 0xc4e0
movq -0x8(%rbp), %rdi
callq 0x8aa0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_list.c
// Function: as_list_cons
as_list * as_list_cons(as_list * list, bool free, const as_list_hooks * hooks)
{
	if ( !list ) return list;

	as_val_cons((as_val *) list, AS_LIST, free);
	list->hooks = hooks;
	list->flags = 0;
	return list;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xc519
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xc54e
movq -0x10(%rbp), %rdi
movb -0x11(%rbp), %al
movl $0x5, %esi
andb $0x1, %al
movzbl %al, %edx
callq 0xc560
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_list.c
// Function: as_list_val_tostring
char * as_list_val_tostring(const as_val * v) 
{
	as_list_val_tostring_data data = {
		.buf = NULL,
		.blk = 256,
		.cap = 1024,
		.pos = 0,
		.sep = false
	};

	data.buf = (char *) cf_calloc(data.cap, sizeof(char));

	strcpy(data.buf, "[");
	data.pos += 1;

	if ( v ) {
		as_list_foreach((as_list *) v, as_list_val_tostring_foreach, &data);
	}

	if ( data.pos + 2 >= data.cap ) {
		data.buf = cf_realloc(data.buf, sizeof(char) * (data.cap + 2));
		data.cap += 2;
	}

	data.buf[data.pos] = ']';
	data.buf[data.pos + 1] = 0;
	
	return data.buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq 0x1a8f5(%rip), %rax     # 0x27058
movq %rax, -0x20(%rbp)
movq 0x1a8f2(%rip), %rax     # 0x27060
movq %rax, -0x18(%rbp)
movq 0x1a8ef(%rip), %rax     # 0x27068
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %edi
movl $0x1, %esi
callq 0x8a00
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq 0x1a8d5(%rip), %rsi     # 0x27070
callq 0x81b0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xc7c4
movq -0x8(%rbp), %rdi
leaq 0xe5(%rip), %rsi        # 0xc8a0
leaq -0x20(%rbp), %rdx
callq 0xc820
movl -0x10(%rbp), %eax
addl $0x2, %eax
cmpl -0x14(%rbp), %eax
jb 0xc7f3
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
addl $0x2, %eax
movl %eax, %eax
movl %eax, %esi
shlq $0x0, %rsi
callq 0x85b0
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rax
movl -0x10(%rbp), %ecx
movb $0x5d, (%rax,%rcx)
movq -0x20(%rbp), %rax
movl -0x10(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, %ecx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_list.c
// Function: as_list_val_tostring_foreach
static bool as_list_val_tostring_foreach(as_val * val, void * udata)
{
	as_list_val_tostring_data * data = (as_list_val_tostring_data *) udata;

	char * str = as_val_tostring(val);

	if ( !str ) {
		str = (char *)NULL_STR;
	}

	uint32_t len = (uint32_t)strlen(str);

	if ( data->pos + len + 2 >= data->cap ) {
		uint32_t adj = ((len+2) > data->blk) ? len+2 : data->blk;
		data->buf = cf_realloc(data->buf, sizeof(char) * (data->cap + adj));
		data->cap += adj;
	}

	if ( data->sep ) {
		data->buf[data->pos] = ',';
		data->buf[data->pos + 1] = ' ';
		data->pos += 2;
	}

	memcpy(data->buf + data->pos, str, len);
	data->pos += len;
	data->sep = true;

	if ( str != NULL_STR ) {
		cf_free(str);
	}

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x82f0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xc8d7
movq 0x236cd(%rip), %rax     # 0x2ffa0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x82b0
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
addl -0x24(%rbp), %eax
addl $0x2, %eax
movq -0x18(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jb 0xc958
movl -0x24(%rbp), %eax
addl $0x2, %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jbe 0xc913
movl -0x24(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x2c(%rbp)
jmp 0xc91d
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movl 0xc(%rax), %eax
addl -0x28(%rbp), %eax
movl %eax, %eax
movl %eax, %esi
shlq $0x0, %rsi
callq 0x85b0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl -0x28(%rbp), %ecx
movq -0x18(%rbp), %rax
addl 0xc(%rax), %ecx
movl %ecx, 0xc(%rax)
movq -0x18(%rbp), %rax
testb $0x1, 0x14(%rax)
je 0xc998
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movl 0x10(%rcx), %ecx
movb $0x2c, (%rax,%rcx)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
movl 0x10(%rcx), %ecx
addl $0x1, %ecx
movl %ecx, %ecx
movb $0x20, (%rax,%rcx)
movq -0x18(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x2, %ecx
movl %ecx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
addq %rax, %rdi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %eax
movl %eax, %edx
callq 0x86b0
movl -0x24(%rbp), %ecx
movq -0x18(%rbp), %rax
addl 0x10(%rax), %ecx
movl %ecx, 0x10(%rax)
movq -0x18(%rbp), %rax
movb $0x1, 0x14(%rax)
movq 0x235cd(%rip), %rax     # 0x2ffa0
cmpq %rax, -0x20(%rbp)
je 0xc9e2
movq -0x20(%rbp), %rdi
callq 0x8aa0
movb $0x1, %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_map.c
// Function: as_map_cons
as_map* as_map_cons(as_map* map, bool free, uint32_t flags, const as_map_hooks* hooks)
{
	if ( !map ) return map;

	as_val_cons((as_val*) map, AS_MAP, free);
	map->flags = flags;
	map->hooks = hooks;
	return map;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xca1c
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xca50
movq -0x10(%rbp), %rdi
movb -0x11(%rbp), %al
movl $0x6, %esi
andb $0x1, %al
movzbl %al, %edx
callq 0xca60
movl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_map.c
// Function: as_map_val_tostring
char * as_map_val_tostring(const as_val* v)
{
	as_map_val_tostring_data data = {
		.buf = NULL,
		.blk = 1024,
		.cap = 1024,
		.pos = 0,
		.sep = false
	};

	data.buf = (char *) cf_calloc(data.cap, sizeof(char));

	strcpy(data.buf, "{");
	data.pos += 1;
	
	if ( v ) {
		as_map_foreach((as_map*) v, as_map_val_tostring_foreach, &data);
	}

	if ( data.pos + 2 >= data.cap ) {
		data.buf = cf_realloc(data.buf, sizeof(char) * (data.cap + 2));
		data.cap += 2;
	}

	data.buf[data.pos] = '}';
	data.buf[data.pos + 1] = 0;
	
	return data.buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq 0x1a42d(%rip), %rax     # 0x27090
movq %rax, -0x20(%rbp)
movq 0x1a42a(%rip), %rax     # 0x27098
movq %rax, -0x18(%rbp)
movq 0x1a427(%rip), %rax     # 0x270a0
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %edi
movl $0x1, %esi
callq 0x8a00
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq 0x1a40d(%rip), %rsi     # 0x270a8
callq 0x81b0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xccc4
movq -0x8(%rbp), %rdi
leaq 0xe5(%rip), %rsi        # 0xcda0
leaq -0x20(%rbp), %rdx
callq 0xcd20
movl -0x10(%rbp), %eax
addl $0x2, %eax
cmpl -0x14(%rbp), %eax
jb 0xccf3
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
addl $0x2, %eax
movl %eax, %eax
movl %eax, %esi
shlq $0x0, %rsi
callq 0x85b0
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rax
movl -0x10(%rbp), %ecx
movb $0x7d, (%rax,%rcx)
movq -0x20(%rbp), %rax
movl -0x10(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, %ecx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_module.c
// Function: as_module_configure
int as_module_configure(as_module * m, void * config) {
    as_module_event e = {
        .type = AS_MODULE_EVENT_CONFIGURE,
        .data.config = config
    };
    return as_module_update(m, &e);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x8110
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_msgpack.c
// Function: as_bytes_cmp
static inline msgpack_compare_t
as_bytes_cmp(as_bytes* v1, as_bytes* v2)
{
	uint32_t s1 = as_bytes_size((const as_bytes*)v1);
	uint32_t s2 = as_bytes_size((const as_bytes*)v2);
	uint32_t min_sz = s1 < s2 ? s1 : s2;
	int c = memcmp(as_bytes_get((const as_bytes*)v1),
			as_bytes_get((const as_bytes*)v2), min_sz);

	MSGPACK_COMPARE_RET_LESS_OR_GREATER(c, 0);
	MSGPACK_COMPARE_RET_LESS_OR_GREATER(s1, s2);

	return MSGPACK_COMPARE_EQUAL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x11000
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x11000
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jae 0xd628
movl -0x1c(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0xd62e
movl -0x20(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
callq 0x11030
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x11030
movq -0x38(%rbp), %rdi
movq %rax, %rsi
movl -0x24(%rbp), %eax
movl %eax, %edx
callq 0x8510
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jge 0xd66d
movl $0x0, -0x4(%rbp)
jmp 0xd6a5
cmpl $0x0, -0x28(%rbp)
jle 0xd67c
movl $0x2, -0x4(%rbp)
jmp 0xd6a5
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jae 0xd68d
movl $0x0, -0x4(%rbp)
jmp 0xd6a5
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jbe 0xd69e
movl $0x2, -0x4(%rbp)
jmp 0xd6a5
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_msgpack.c
// Function: as_list_cmp
static msgpack_compare_t
as_list_cmp(const as_list* list1, const as_list* list2)
{
	uint32_t s1 = as_list_size(list1);
	uint32_t s2 = as_list_size(list2);
	uint32_t min_sz = s1 < s2 ? s1 : s2;

	for (uint32_t i = 0; i < min_sz; i++) {
		as_val* v1 = as_list_get(list1, i);
		as_val* v2 = as_list_get(list2, i);

		if (as_val_type(v1) == AS_CMP_WILDCARD ||
				as_val_type(v2) == AS_CMP_WILDCARD) {
			return MSGPACK_COMPARE_EQUAL;
		}

		msgpack_compare_t cmp = as_val_cmp(v1, v2);

		if (cmp != MSGPACK_COMPARE_EQUAL) {
			return cmp;
		}
	}

	MSGPACK_COMPARE_RET_LESS_OR_GREATER(s1, s2);

	return MSGPACK_COMPARE_EQUAL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x11080
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x11080
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jae 0xd6e8
movl -0x1c(%rbp), %eax
movl %eax, -0x40(%rbp)
jmp 0xd6ee
movl -0x20(%rbp), %eax
movl %eax, -0x40(%rbp)
movl -0x40(%rbp), %eax
movl %eax, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jae 0xd7a4
movq -0x10(%rbp), %rdi
movl -0x28(%rbp), %esi
callq 0x110e0
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movl -0x28(%rbp), %esi
callq 0x110e0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0xd73b
movq -0x30(%rbp), %rax
movzbl 0x4(%rax), %eax
movl %eax, -0x44(%rbp)
jmp 0xd742
xorl %eax, %eax
movl %eax, -0x44(%rbp)
jmp 0xd742
movl -0x44(%rbp), %eax
cmpl $0xd, %eax
je 0xd76d
cmpq $0x0, -0x38(%rbp)
je 0xd75e
movq -0x38(%rbp), %rax
movzbl 0x4(%rax), %eax
movl %eax, -0x48(%rbp)
jmp 0xd765
xorl %eax, %eax
movl %eax, -0x48(%rbp)
jmp 0xd765
movl -0x48(%rbp), %eax
cmpl $0xd, %eax
jne 0xd776
movl $0x1, -0x4(%rbp)
jmp 0xd7cd
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x80a0
movl %eax, -0x3c(%rbp)
cmpl $0x1, -0x3c(%rbp)
je 0xd794
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xd7cd
jmp 0xd796
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xd6fb
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jae 0xd7b5
movl $0x0, -0x4(%rbp)
jmp 0xd7cd
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jbe 0xd7c6
movl $0x2, -0x4(%rbp)
jmp 0xd7cd
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_msgpack.c
// Function: as_map_cmp
static msgpack_compare_t
as_map_cmp(const as_map* map1, const as_map* map2)
{
	// Map ordering documented at https://docs.aerospike.com/server/guide/data-types/cdt-ordering
	uint32_t size1 = as_map_size(map1);
	uint32_t size2 = as_map_size(map2);

	MSGPACK_COMPARE_RET_LESS_OR_GREATER(size1, size2);

	uint32_t sz = as_map_size(map1);
	as_orderedmap_iterator it1;
	as_orderedmap_iterator it2;

	as_orderedmap_iterator_init(&it1, (const as_orderedmap*)map1);
	as_orderedmap_iterator_init(&it2, (const as_orderedmap*)map2);

	for (uint32_t i = 0; i < sz; i++) {
		as_pair* p1 = (as_pair*)as_orderedmap_iterator_next(&it1);
		as_pair* p2 = (as_pair*)as_orderedmap_iterator_next(&it2);
		msgpack_compare_t cmp = as_val_cmp(as_pair_1(p1), as_pair_1(p2));

		if (cmp != MSGPACK_COMPARE_EQUAL) {
			return cmp;
		}
	}

	return MSGPACK_COMPARE_EQUAL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x11140
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x11140
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jae 0xd81f
movl $0x0, -0x4(%rbp)
jmp 0xd8fd
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jbe 0xd833
movl $0x2, -0x4(%rbp)
jmp 0xd8fd
movq -0x10(%rbp), %rdi
callq 0x11140
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x8570
movq -0x18(%rbp), %rsi
leaq -0xa8(%rbp), %rdi
callq 0x8570
movl $0x0, -0xac(%rbp)
movl -0xac(%rbp), %eax
cmpl -0x24(%rbp), %eax
jae 0xd8f6
leaq -0x68(%rbp), %rdi
callq 0x82a0
movq %rax, -0xb8(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x82a0
movq %rax, -0xc0(%rbp)
movq -0xb8(%rbp), %rdi
callq 0x111a0
movq %rax, -0xd0(%rbp)
movq -0xc0(%rbp), %rdi
callq 0x111a0
movq -0xd0(%rbp), %rdi
movq %rax, %rsi
callq 0x80a0
movl %eax, -0xc4(%rbp)
cmpl $0x1, -0xc4(%rbp)
je 0xd8e0
movl -0xc4(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xd8fd
jmp 0xd8e2
movl -0xac(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xac(%rbp)
jmp 0xd866
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xd0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_msgpack.c
// Function: pack_byte
static inline int
pack_byte(as_packer *pk, uint8_t val, bool resize)
{
	if (pk->buffer) {
		if (pk->offset + 1 > pk->capacity) {
			if (! resize || pack_resize(pk, 1) != 0) {
				return -1;
			}
		}
		*(pk->buffer + pk->offset) = val;
	}
	return advance_offset(pk, 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movb %sil, %cl
movq %rdi, -0x10(%rbp)
movb %cl, -0x11(%rbp)
andb $0x1, %al
movb %al, -0x12(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xdb10
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
addl $0x1, %eax
movq -0x10(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
jbe 0xdafb
testb $0x1, -0x12(%rbp)
je 0xdaf0
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x111d0
cmpl $0x0, %eax
je 0xdaf9
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xdb21
jmp 0xdafb
movb -0x11(%rbp), %dl
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x18(%rcx), %ecx
movb %dl, (%rax,%rcx)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x112e0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_msgpack.c
// Function: pack_string
static int
pack_string(as_packer *pk, as_string *s)
{
	uint32_t length = (uint32_t)as_string_len(s);
	int rc = pack_string_header(pk, length + 1, true);

	if (rc == 0) {
		rc = pack_byte(pk, AS_BYTES_STRING, true);
	}

	if (rc == 0) {
		rc = pack_append(pk, (unsigned char*)s->value, length, true);
	}

	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8370
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
addl $0x1, %esi
movl $0x1, %edx
callq 0xf350
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jne 0xdc4f
movq -0x8(%rbp), %rdi
movl $0x3, %esi
movl $0x1, %edx
callq 0xdaa0
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jne 0xdc71
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movl -0x14(%rbp), %edx
movl $0x1, %ecx
callq 0xf1e0
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_msgpack.c
// Function: pack_bytes
static int
pack_bytes(as_packer *pk, const as_bytes *b)
{
	int rc = pack_byte_array_header(pk, b->size + 1);

	if (rc == 0) {
		rc = pack_byte(pk, b->type, true);
	}

	if (rc == 0) {
		rc = pack_append(pk, b->value, b->size, true);
	}

	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0xc(%rax), %esi
addl $0x1, %esi
callq 0xf1b0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0xdcc7
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %eax
movl $0x1, %edx
movzbl %al, %esi
callq 0xdaa0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0xdced
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x10(%rbp), %rax
movl 0xc(%rax), %edx
movl $0x1, %ecx
callq 0xf1e0
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_msgpack.c
// Function: pack_list
static int
pack_list(as_packer *pk, as_list *l)
{
	uint32_t size = as_list_size(l);
	int rc;

	if (size < 16) {
		rc = pack_byte(pk, (uint8_t)(0x90 | size), true);
	}
	else if (size < 65536) {
		rc = pack_type_uint16(pk, 0xdc, (uint16_t)size, true);
	}
	else {
		rc = pack_type_uint32(pk, 0xdd, size, true);
	}

	if (rc == 0) {
		rc = as_list_foreach(l, pack_list_foreach, pk) ? 0 : 1;
	}

	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x11080
movl %eax, -0x14(%rbp)
cmpl $0x10, -0x14(%rbp)
jae 0xdd40
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %eax
orl $0x90, %eax
movl $0x1, %edx
movzbl %al, %esi
callq 0xdaa0
movl %eax, -0x18(%rbp)
jmp 0xdd82
cmpl $0x10000, -0x14(%rbp)   # imm = 0x10000
jae 0xdd67
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %eax
movl $0xdc, %esi
movl $0x1, %ecx
movzwl %ax, %edx
callq 0xf5f0
movl %eax, -0x18(%rbp)
jmp 0xdd80
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %edx
movl $0xdd, %esi
movl $0x1, %ecx
callq 0xf010
movl %eax, -0x18(%rbp)
jmp 0xdd82
cmpl $0x0, -0x18(%rbp)
jne 0xddae
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rdx
leaq 0x3679(%rip), %rsi      # 0x11410
callq 0x11390
movb %al, %dl
movl $0x1, %eax
xorl %ecx, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_msgpack.c
// Function: pack_map
static int
pack_map(as_packer* pk, const as_map* m)
{
	uint32_t ele_count = as_map_size(m);

	if ((m->flags & AS_PACKED_MAP_FLAG_K_ORDERED) != 0) {
		ele_count++;

		int rc = pack_map_header_internal(pk, ele_count, true);

		if (rc != 0) {
			return rc;
		}

		rc = pack_ext_header_internal(pk, 0, m->flags, true);

		if (rc != 0) {
			return rc;
		}

		rc = pack_nil_internal(pk, true);

		if (rc != 0) {
			return rc;
		}
	}
	else if ((m->flags & AS_PACKED_MAP_FLAG_V_ORDERED) != 0) {
		// Only V ordered should not be possible.
		return -1;
	}
	else if (pack_map_header_internal(pk, ele_count, true) != 0) {
		return -1;
	}

	return as_map_foreach(m, pack_map_foreach, pk) ? 0 : 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x11140
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xde68
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl $0x1, %edx
callq 0xf7d0
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
je 0xde19
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xdec9
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
xorl %esi, %esi
movl $0x1, %ecx
movzbl %al, %edx
callq 0xf910
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
je 0xde47
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xdec9
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0xebc0
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
je 0xde66
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xdec9
jmp 0xdea3
movq -0x18(%rbp), %rax
movl 0x8(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0xde80
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xdec9
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl $0x1, %edx
callq 0xf7d0
cmpl $0x0, %eax
je 0xde9f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xdec9
jmp 0xdea1
jmp 0xdea3
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x361e(%rip), %rsi      # 0x114d0
callq 0x11450
movb %al, %dl
movl $0x1, %eax
xorl %ecx, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_msgpack.c
// Function: pack_pair
static int
pack_pair(as_packer *pk, as_pair *p)
{
	unsigned char v = (unsigned char)(0x90 | 2);
	int rc = pack_append(pk, &v, 1, true);

	if (rc == 0) {
		rc = as_pack_val(pk, as_pair_1(p));

		if (rc == 0) {
			rc = as_pack_val(pk, as_pair_2(p));
		}
	}

	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $-0x6e, -0x11(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x11(%rbp), %rsi
movl $0x1, %ecx
movl %ecx, %edx
callq 0xf1e0
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jne 0xdf79
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x111a0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
callq 0x8b90
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jne 0xdf77
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x11530
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x8b90
movl %eax, -0x18(%rbp)
jmp 0xdf79
movl -0x18(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_msgpack.c
// Function: pack_geojson
static int
pack_geojson(as_packer *pk, as_geojson *s)
{
	uint32_t length = (uint32_t)as_geojson_len(s);
	int rc = pack_byte_array_header(pk, length + 1);

	if (rc == 0) {
		rc = pack_byte(pk, AS_BYTES_GEOJSON, true);
	}

	if (rc == 0) {
		rc = pack_append(pk, (unsigned char*)s->value, length, true);
	}

	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8b50
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
addl $0x1, %esi
callq 0xf1b0
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jne 0xdfda
movq -0x8(%rbp), %rdi
movl $0x17, %esi
movl $0x1, %edx
callq 0xdaa0
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jne 0xdffc
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movl -0x14(%rbp), %edx
movl $0x1, %ecx
callq 0xf1e0
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_msgpack.c
// Function: as_unpack_peek_is_ext
bool
as_unpack_peek_is_ext(const as_unpacker *pk)
{
	if (pk->offset >= pk->length) {
		return false;
	}

	uint8_t type = pk->buffer[pk->offset];

	switch (type) {
	case 0xd4:
	case 0xd5:
	case 0xd6:
	case 0xd7:
	case 0xd8:
	case 0xc7:
	case 0xc8:
	case 0xc9:
		return true;
	default:
		break;
	}

	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jb 0xe4ce
movb $0x0, -0x1(%rbp)
jmp 0xe50c
movq -0x10(%rbp), %rcx
movq (%rcx), %rax
movl 0x8(%rcx), %ecx
movb (%rax,%rcx), %al
movb %al, -0x11(%rbp)
movzbl -0x11(%rbp), %eax
movl %eax, -0x18(%rbp)
addl $0xffffff39, %eax       # imm = 0xFFFFFF39
subl $0x3, %eax
jb 0xe500
jmp 0xe4f1
movl -0x18(%rbp), %eax
addl $0xffffff2c, %eax       # imm = 0xFFFFFF2C
subl $0x4, %eax
ja 0xe506
jmp 0xe500
movb $0x1, -0x1(%rbp)
jmp 0xe50c
jmp 0xe508
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_msgpack.c
// Function: extract_float
static inline float
extract_float(as_unpacker *pk)
{
	uint32_t v = *(uint32_t *)(pk->buffer + pk->offset);
	uint32_t swapped = cf_swap_from_be32(v);
	pk->offset += 4;
	return *(float*)&swapped;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x8(%rcx), %ecx
movl (%rax,%rcx), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edi
callq 0x11560
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x4, %ecx
movl %ecx, 0x8(%rax)
movss -0x10(%rbp), %xmm0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_msgpack.c
// Function: extract_double
static inline double
extract_double(as_unpacker *pk)
{
	uint64_t v = *(uint64_t *)(pk->buffer + pk->offset);
	uint64_t swapped = cf_swap_from_be64(v);
	pk->offset += 8;
	return *(double*)&swapped;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x8(%rcx), %ecx
movq (%rax,%rcx), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x115c0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x8, %ecx
movl %ecx, 0x8(%rax)
movsd -0x18(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_msgpack.c
// Function: extract_uint16
static inline uint16_t
extract_uint16(as_unpacker *pk)
{
	uint16_t v = *(uint16_t *)(pk->buffer + pk->offset);
	uint16_t swapped = cf_swap_from_be16(v);
	pk->offset += 2;
	return swapped;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x8(%rcx), %ecx
movw (%rax,%rcx), %ax
movw %ax, -0xa(%rbp)
movzwl -0xa(%rbp), %edi
callq 0x11690
movw %ax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x2, %ecx
movl %ecx, 0x8(%rax)
movw -0xc(%rbp), %ax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_msgpack.c
// Function: extract_uint32
static inline uint32_t
extract_uint32(as_unpacker *pk)
{
	uint32_t v = *(uint32_t *)(pk->buffer + pk->offset);
	uint32_t swapped = cf_swap_from_be32(v);
	pk->offset += 4;
	return swapped;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x8(%rcx), %ecx
movl (%rax,%rcx), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edi
callq 0x11560
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x4, %ecx
movl %ecx, 0x8(%rax)
movl -0x10(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_msgpack.c
// Function: extract_uint64
static inline uint64_t
extract_uint64(as_unpacker *pk)
{
	uint64_t v = *(uint64_t *)(pk->buffer + pk->offset);
	uint64_t swapped = cf_swap_from_be64(v);
	pk->offset += 8;
	return swapped;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x8(%rcx), %ecx
movq (%rax,%rcx), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x115c0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x8, %ecx
movl %ecx, 0x8(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_msgpack.c
// Function: unpack_list
static int
unpack_list(as_unpacker *pk, uint32_t size, as_val **val)
{
	uint8_t flags = 0;

	// Skip ext element key which is only at the start for metadata.
	if (size != 0 && as_unpack_peek_is_ext(pk)) {
		as_msgpack_ext ext;

		if (as_unpack_ext(pk, &ext) != 0) {
			return -1;
		}

		flags = ext.type;
		size--;
	}

	as_arraylist *list = as_arraylist_new(size, 8);

	if (! list) {
		return -2;
	}

	for (uint32_t i = 0; i < size; i++) {
		as_val *v = NULL;

		if (as_unpack_val(pk, &v) != 0 || ! v) {
			as_arraylist_destroy(list);
			return -3;
		}

		as_arraylist_set(list, i, v);
	}

	*val = (as_val *)list;
	list->_.flags = flags;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0xe999
movq -0x10(%rbp), %rdi
callq 0x88c0
testb $0x1, %al
jne 0xe96c
jmp 0xe999
movq -0x10(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x8bb0
cmpl $0x0, %eax
je 0xe98a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xea34
movb -0x30(%rbp), %al
movb %al, -0x21(%rbp)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edi
movl $0x8, %esi
callq 0x85d0
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0xe9ba
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0xea34
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0xea17
movq $0x0, -0x58(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x8760
cmpl $0x0, %eax
jne 0xe9ea
cmpq $0x0, -0x58(%rbp)
jne 0xe9fc
movq -0x48(%rbp), %rdi
callq 0x88b0
movl $0xfffffffd, -0x4(%rbp) # imm = 0xFFFFFFFD
jmp 0xea34
movq -0x48(%rbp), %rdi
movl -0x4c(%rbp), %esi
movq -0x58(%rbp), %rdx
callq 0x8cb0
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0xe9c1
movq -0x48(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movzbl -0x21(%rbp), %ecx
movq -0x48(%rbp), %rax
movl %ecx, 0x8(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_msgpack.c
// Function: unpack_map
static int
unpack_map(as_unpacker* pk, uint32_t ele_count, as_val** val)
{
	uint8_t flags = 0;

	// Skip ext element key which is only at the start for metadata.
	if (ele_count != 0 && as_unpack_peek_is_ext(pk)) {
		as_msgpack_ext ext;

		if (as_unpack_ext(pk, &ext) != 0 || as_unpack_size(pk) < 0) {
			return -1;
		}

		flags = ext.type;
		ele_count--;
	}

	// Check preserve order bit.
	if ((flags & AS_PACKED_MAP_FLAG_PRESERVE_ORDER) != 0) {
		return unpack_map_create_list(pk, ele_count, val);
	}

	return unpack_orderedmap(pk, ele_count, val, flags);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0xeaa5
movq -0x10(%rbp), %rdi
callq 0x88c0
testb $0x1, %al
jne 0xea6c
jmp 0xeaa5
movq -0x10(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x8bb0
cmpl $0x0, %eax
jne 0xea8d
movq -0x10(%rbp), %rdi
callq 0x89e0
cmpq $0x0, %rax
jge 0xea96
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xeadd
movb -0x30(%rbp), %al
movb %al, -0x21(%rbp)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
movzbl -0x21(%rbp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0xeac6
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x116e0
movl %eax, -0x4(%rbp)
jmp 0xeadd
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
movzbl -0x21(%rbp), %ecx
callq 0x11800
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_msgpack.c
// Function: unpack_ext
static inline int
unpack_ext(as_unpacker *pk, uint8_t type, as_val **v)
{
	uint8_t ext_type = pk->buffer[pk->offset++];
	uint8_t data = pk->buffer[pk->offset++];

	if (ext_type == ASVAL_CMP_EXT_TYPE) {
		if (data == ASVAL_CMP_WILDCARD) {
			*v = (as_val *)&as_cmp_wildcard;
			return 0;
		}
		else if (data == ASVAL_CMP_INF) {
			*v = (as_val *)&as_cmp_inf;
			return 0;
		}
	}

	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rdx
movl 0x8(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x8(%rdx)
movl %ecx, %ecx
movb (%rax,%rcx), %al
movb %al, -0x21(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rdx
movl 0x8(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x8(%rdx)
movl %ecx, %ecx
movb (%rax,%rcx), %al
movb %al, -0x22(%rbp)
movzbl -0x21(%rbp), %eax
cmpl $0xff, %eax
jne 0xeb8d
movzbl -0x22(%rbp), %eax
cmpl $0x0, %eax
jne 0xeb69
movq -0x20(%rbp), %rax
movq 0x21433(%rip), %rcx     # 0x2ff90
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0xeb94
movzbl -0x22(%rbp), %eax
cmpl $0x1, %eax
jne 0xeb89
movq -0x20(%rbp), %rax
movq 0x2142b(%rip), %rcx     # 0x2ffa8
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0xeb94
jmp 0xeb8b
jmp 0xeb8d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_msgpack.c
// Function: as_pack_uint64_size
uint32_t
as_pack_uint64_size(uint64_t val)
{
	if (val < (1ULL << 7)) {
		return 1;
	}

	if (val < (1ULL << 8)) {
		return 2;
	}

	if (val < (1ULL << 16)) {
		return 3;
	}

	if (val < (1ULL << 32)) {
		return 5;
	}

	return 9;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x80, -0x10(%rbp)
jae 0xec8b
movl $0x1, -0x4(%rbp)
jmp 0xecd1
cmpq $0x100, -0x10(%rbp)     # imm = 0x100
jae 0xec9e
movl $0x2, -0x4(%rbp)
jmp 0xecd1
cmpq $0x10000, -0x10(%rbp)   # imm = 0x10000
jae 0xecb1
movl $0x3, -0x4(%rbp)
jmp 0xecd1
movabsq $0x100000000, %rax      # imm = 0x100000000
cmpq %rax, -0x10(%rbp)
jae 0xecca
movl $0x5, -0x4(%rbp)
jmp 0xecd1
movl $0x9, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_msgpack.c
// Function: as_pack_int64_size
uint32_t
as_pack_int64_size(int64_t val)
{
	if (val >= 0) {
		return as_pack_uint64_size((uint64_t)val);
	}

	if (val >= -(1LL << 5)) {
		return 1;
	}

	if (val >= -(1LL << 7)) {
		return 1 + 1;
	}

	if (val >= -(1LL << 15)) {
		return 1 + 2;
	}

	if (val >= -(1LL << 31)) {
		return 1 + 4;
	}

	return 1 + 8;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jl 0xed01
movq -0x10(%rbp), %rdi
callq 0x8640
movl %eax, -0x4(%rbp)
jmp 0xed4e
cmpq $-0x20, -0x10(%rbp)
jl 0xed11
movl $0x1, -0x4(%rbp)
jmp 0xed4e
cmpq $-0x80, -0x10(%rbp)
jl 0xed21
movl $0x2, -0x4(%rbp)
jmp 0xed4e
cmpq $-0x8000, -0x10(%rbp)   # imm = 0x8000
jl 0xed34
movl $0x3, -0x4(%rbp)
jmp 0xed4e
cmpq $-0x80000000, -0x10(%rbp) # imm = 0x80000000
jl 0xed47
movl $0x5, -0x4(%rbp)
jmp 0xed4e
movl $0x9, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_msgpack.c
// Function: pack_uint64
static inline int
pack_uint64(as_packer *pk, uint64_t val, bool resize)
{
	if (val < (1ULL << 7)) {
		return pack_byte(pk, (uint8_t)val, resize);
	}

	if (val < (1ULL << 8)) {
		return pack_type_uint8(pk, 0xcc, (uint8_t)val, resize);
	}

	if (val < (1ULL << 16)) {
		return pack_type_uint16(pk, 0xcd, (uint16_t)val, resize);
	}

	if (val < (1ULL << 32)) {
		return pack_type_uint32(pk, 0xce, (uint32_t)val, resize);
	}

	return pack_type_uint64(pk, 0xcf, val, resize);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
cmpq $0x80, -0x18(%rbp)
jae 0xedd3
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movb %al, %cl
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %cl, %esi
movzbl %al, %edx
callq 0xdaa0
movl %eax, -0x4(%rbp)
jmp 0xee7e
cmpq $0x100, -0x18(%rbp)     # imm = 0x100
jae 0xee01
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movb %al, %cl
movb -0x19(%rbp), %al
movl $0xcc, %esi
andb $0x1, %al
movzbl %cl, %edx
movzbl %al, %ecx
callq 0xf540
movl %eax, -0x4(%rbp)
jmp 0xee7e
cmpq $0x10000, -0x18(%rbp)   # imm = 0x10000
jae 0xee30
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movw %ax, %cx
movb -0x19(%rbp), %al
movl $0xcd, %esi
andb $0x1, %al
movzwl %cx, %edx
movzbl %al, %ecx
callq 0xf5f0
movl %eax, -0x4(%rbp)
jmp 0xee7e
movabsq $0x100000000, %rax      # imm = 0x100000000
cmpq %rax, -0x18(%rbp)
jae 0xee61
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %edx
movb -0x19(%rbp), %al
movl $0xce, %esi
andb $0x1, %al
movzbl %al, %ecx
callq 0xf010
movl %eax, -0x4(%rbp)
jmp 0xee7e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movb -0x19(%rbp), %al
movl $0xcf, %esi
andb $0x1, %al
movzbl %al, %ecx
callq 0x11970
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_msgpack.c
// Function: pack_int64
static inline int
pack_int64(as_packer *pk, int64_t val, bool resize)
{
	if (val >= 0) {
		return pack_uint64(pk, (uint64_t)val, resize);
	}

	if (val >= -(1LL << 5)) {
		return pack_byte(pk, (uint8_t)(0xe0 | (val + 32)), resize);
	}

	if (val >= -(1LL << 7)) {
		return pack_type_uint8(pk, 0xd0, (uint8_t)val, resize);
	}

	if (val >= -(1LL << 15)) {
		return pack_type_uint16(pk, 0xd1, (uint16_t)val, resize);
	}

	if (val >= -(1LL << 31)) {
		return pack_type_uint32(pk, 0xd2, (uint32_t)val, resize);
	}

	return pack_type_uint64(pk, 0xd3, (uint64_t)val, resize);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
cmpq $0x0, -0x18(%rbp)
jl 0xeefb
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0xed90
movl %eax, -0x4(%rbp)
jmp 0xefd0
cmpq $-0x20, -0x18(%rbp)
jl 0xef2e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
addq $0x20, %rax
orq $0xe0, %rax
movb %al, %cl
movb -0x19(%rbp), %al
andb $0x1, %al
movzbl %cl, %esi
movzbl %al, %edx
callq 0xdaa0
movl %eax, -0x4(%rbp)
jmp 0xefd0
cmpq $-0x80, -0x18(%rbp)
jl 0xef59
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movb %al, %cl
movb -0x19(%rbp), %al
movl $0xd0, %esi
andb $0x1, %al
movzbl %cl, %edx
movzbl %al, %ecx
callq 0xf540
movl %eax, -0x4(%rbp)
jmp 0xefd0
cmpq $-0x8000, -0x18(%rbp)   # imm = 0x8000
jl 0xef88
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movw %ax, %cx
movb -0x19(%rbp), %al
movl $0xd1, %esi
andb $0x1, %al
movzwl %cx, %edx
movzbl %al, %ecx
callq 0xf5f0
movl %eax, -0x4(%rbp)
jmp 0xefd0
cmpq $-0x80000000, -0x18(%rbp) # imm = 0x80000000
jl 0xefb3
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movl %eax, %edx
movb -0x19(%rbp), %al
movl $0xd2, %esi
andb $0x1, %al
movzbl %al, %ecx
callq 0xf010
movl %eax, -0x4(%rbp)
jmp 0xefd0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movb -0x19(%rbp), %al
movl $0xd3, %esi
andb $0x1, %al
movzbl %al, %ecx
callq 0x11970
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_msgpack.c
// Function: pack_type_uint32
static inline int
pack_type_uint32(as_packer *pk, unsigned char type, uint32_t val, bool resize)
{
	if (pk->buffer) {
		if (pk->offset + 5 > pk->capacity) {
			if (! resize || pack_resize(pk, 5) != 0) {
				return -1;
			}
		}
		uint32_t swapped = cf_swap_to_be32(val);
		unsigned char *p = pk->buffer + pk->offset;
		*p++ = type;
		memcpy(p, &swapped, 4);
	}
	return advance_offset(pk, 5);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %cl, %al
movb %sil, %cl
movq %rdi, -0x10(%rbp)
movb %cl, -0x11(%rbp)
movl %edx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xf0ac
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
addl $0x5, %eax
movq -0x10(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
jbe 0xf06e
testb $0x1, -0x19(%rbp)
je 0xf063
movq -0x10(%rbp), %rdi
movl $0x5, %esi
callq 0x111d0
cmpl $0x0, %eax
je 0xf06c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xf0bd
jmp 0xf06e
movl -0x18(%rbp), %edi
callq 0x11a50
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x18(%rcx), %ecx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movb -0x11(%rbp), %cl
movq -0x28(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x28(%rbp)
movb %cl, (%rax)
movq -0x28(%rbp), %rax
movl -0x20(%rbp), %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rdi
movl $0x5, %esi
callq 0x112e0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_msgpack.c
// Function: as_pack_bytes
int
as_pack_bytes(as_packer *pk, const uint8_t *buf, uint32_t sz)
{
	int rc = pack_byte_array_header(pk, sz + 1);

	if (rc == 0) {
		rc = pack_byte(pk, AS_BYTES_BLOB, true);
	}

	if (rc == 0) {
		rc = pack_append(pk, buf, sz, false);
	}
	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
addl $0x1, %esi
callq 0xf1b0
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jne 0xf181
movq -0x8(%rbp), %rdi
movl $0x4, %esi
movl $0x1, %edx
callq 0xdaa0
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jne 0xf19c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
xorl %ecx, %ecx
callq 0xf1e0
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_msgpack.c
// Function: pack_append
static inline int
pack_append(as_packer *pk, const unsigned char *src, uint32_t sz, bool resize)
{
	if (pk->buffer) {
		if (pk->offset + sz > pk->capacity) {
			if (! resize || pack_resize(pk, sz) != 0) {
				return -1;
			}
		}
		memcpy(pk->buffer + pk->offset, src, (size_t)sz);
	}
	return advance_offset(pk, sz);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
andb $0x1, %al
movb %al, -0x1d(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xf25a
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
addl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
jbe 0xf23a
testb $0x1, -0x1d(%rbp)
je 0xf22f
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x111d0
cmpl $0x0, %eax
je 0xf238
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xf269
jmp 0xf23a
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %eax
movl %eax, %edx
callq 0x86b0
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x112e0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_msgpack.c
// Function: as_pack_bin_size
uint32_t
as_pack_bin_size(uint32_t buf_sz)
{
	if (buf_sz < (1 << 8)) {
		return 2 + buf_sz;
	}

	if (buf_sz < (1 << 16)) {
		return 3 + buf_sz;
	}

	return 5 + buf_sz;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
cmpl $0x100, -0x8(%rbp)      # imm = 0x100
jae 0xf2cb
movl -0x8(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x4(%rbp)
jmp 0xf2e8
cmpl $0x10000, -0x8(%rbp)    # imm = 0x10000
jae 0xf2df
movl -0x8(%rbp), %eax
addl $0x3, %eax
movl %eax, -0x4(%rbp)
jmp 0xf2e8
movl -0x8(%rbp), %eax
addl $0x5, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_msgpack.c
// Function: as_pack_str
int
as_pack_str(as_packer *pk, const uint8_t *buf, uint32_t sz)
{
	int rc = pack_string_header(pk, sz, false);

	if (rc == 0 && buf) {
		return pack_append(pk, buf, sz, false);
	}

	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %esi
xorl %edx, %edx
callq 0xf350
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jne 0xf338
cmpq $0x0, -0x18(%rbp)
je 0xf338
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
xorl %ecx, %ecx
callq 0xf1e0
movl %eax, -0x4(%rbp)
jmp 0xf33e
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)