LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_msgpack.c
// Function: pack_string_header
static int
pack_string_header(as_packer *pk, uint32_t size, bool resize)
{
	if (size < 32) {
		return pack_byte(pk, (uint8_t)(0xa0 | size), resize);
	}

	if (size < 256) {
		return pack_type_uint8(pk, 0xd9, (uint8_t)size, resize);
	}

	if (size < 65536) {
		return pack_type_uint16(pk, 0xda, (uint16_t)size, resize);
	}

	return pack_type_uint32(pk, 0xdb, size, resize);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
andb $0x1, %al
movb %al, -0x15(%rbp)
cmpl $0x20, -0x14(%rbp)
jae 0xf38f
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
orl $0xa0, %eax
movb %al, %cl
movb -0x15(%rbp), %al
andb $0x1, %al
movzbl %cl, %esi
movzbl %al, %edx
callq 0xdaa0
movl %eax, -0x4(%rbp)
jmp 0xf404
cmpl $0x100, -0x14(%rbp)     # imm = 0x100
jae 0xf3bb
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
movb %al, %cl
movb -0x15(%rbp), %al
movl $0xd9, %esi
andb $0x1, %al
movzbl %cl, %edx
movzbl %al, %ecx
callq 0xf540
movl %eax, -0x4(%rbp)
jmp 0xf404
cmpl $0x10000, -0x14(%rbp)   # imm = 0x10000
jae 0xf3e8
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
movw %ax, %cx
movb -0x15(%rbp), %al
movl $0xda, %esi
andb $0x1, %al
movzwl %cx, %edx
movzbl %al, %ecx
callq 0xf5f0
movl %eax, -0x4(%rbp)
jmp 0xf404
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %edx
movb -0x15(%rbp), %al
movl $0xdb, %esi
andb $0x1, %al
movzbl %al, %ecx
callq 0xf010
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: as_pack_str_with_type
int
as_pack_str_with_type(as_packer *pk, uint8_t type, const uint8_t *buf,
		uint32_t sz)
{
	int rc = pack_string_header(pk, sz + 1, false);

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

	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %esi
addl $0x1, %esi
xorl %edx, %edx
callq 0xf350
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jne 0xf47a
cmpq $0x0, -0x20(%rbp)
je 0xf47a
movq -0x10(%rbp), %rdi
xorl %edx, %edx
movzbl -0x11(%rbp), %esi
callq 0xdaa0
movl %eax, -0x28(%rbp)
cmpl $0x0, %eax
jne 0xf478
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %edx
xorl %ecx, %ecx
callq 0xf1e0
movl %eax, -0x4(%rbp)
jmp 0xf480
jmp 0xf47a
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
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_bin
int
as_pack_bin(as_packer *pk, const uint8_t *buf, uint32_t sz)
{
	int rc;

	if (sz < (1 << 8)) {
		rc = pack_type_uint8(pk, 0xc4, (uint8_t)sz, false);
	}
	else if (sz < (1 << 16)) {
		rc = pack_type_uint16(pk, 0xc5, (uint16_t)sz, false);
	}
	else {
		rc = pack_type_uint32(pk, 0xc6, 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)
cmpl $0x100, -0x1c(%rbp)     # imm = 0x100
jae 0xf4c7
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl $0xc4, %esi
xorl %ecx, %ecx
movzbl %al, %edx
callq 0xf540
movl %eax, -0x20(%rbp)
jmp 0xf503
cmpl $0x10000, -0x1c(%rbp)   # imm = 0x10000
jae 0xf4eb
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl $0xc5, %esi
xorl %ecx, %ecx
movzwl %ax, %edx
callq 0xf5f0
movl %eax, -0x20(%rbp)
jmp 0xf501
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %edx
movl $0xc6, %esi
xorl %ecx, %ecx
callq 0xf010
movl %eax, -0x20(%rbp)
jmp 0xf503
cmpl $0x0, -0x20(%rbp)
jne 0xf527
cmpq $0x0, -0x18(%rbp)
je 0xf527
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
xorl %ecx, %ecx
callq 0xf1e0
movl %eax, -0x4(%rbp)
jmp 0xf52d
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%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_type_uint8
static inline int
pack_type_uint8(as_packer *pk, unsigned char type, uint8_t val, bool resize)
{
	if (pk->buffer) {
		if (pk->offset + 2 > pk->capacity) {
			if (! resize || pack_resize(pk, 2) != 0) {
				return -1;
			}
		}
		unsigned char *p = pk->buffer + pk->offset;
		*p++ = type;
		*p = val;
	}
	return advance_offset(pk, 2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %cl, %al
movb %dl, %cl
movb %sil, %dl
movq %rdi, -0x10(%rbp)
movb %dl, -0x11(%rbp)
movb %cl, -0x12(%rbp)
andb $0x1, %al
movb %al, -0x13(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xf5d3
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
addl $0x2, %eax
movq -0x10(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
jbe 0xf5a0
testb $0x1, -0x13(%rbp)
je 0xf595
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x111d0
cmpl $0x0, %eax
je 0xf59e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xf5e4
jmp 0xf5a0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x18(%rcx), %ecx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movb -0x11(%rbp), %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
movb -0x12(%rbp), %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x112e0
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_uint16
static inline int
pack_type_uint16(as_packer *pk, unsigned char type, uint16_t val, bool resize)
{
	if (pk->buffer) {
		if (pk->offset + 3 > pk->capacity) {
			if (! resize || pack_resize(pk, 3) != 0) {
				return -1;
			}
		}
		uint16_t swapped = cf_swap_to_be16(val);
		unsigned char *s = (unsigned char *)&swapped;
		unsigned char *p = pk->buffer + pk->offset;
		*p++ = type;
		*p++ = *s++;
		*p = *s;
	}
	return advance_offset(pk, 3);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %cl, %al
movw %dx, %cx
movb %sil, %dl
movq %rdi, -0x10(%rbp)
movb %dl, -0x11(%rbp)
movw %cx, -0x14(%rbp)
andb $0x1, %al
movb %al, -0x15(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xf6c6
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
addl $0x3, %eax
movq -0x10(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
jbe 0xf659
testb $0x1, -0x15(%rbp)
je 0xf64b
movq -0x10(%rbp), %rdi
movl $0x3, %esi
callq 0x111d0
cmpl $0x0, %eax
je 0xf657
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xf6d7
jmp 0xf659
movzwl -0x14(%rbp), %edi
callq 0x11a70
movw %ax, -0x18(%rbp)
leaq -0x18(%rbp), %rax
movq %rax, -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 -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movb (%rax), %cl
movq -0x28(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x28(%rbp)
movb %cl, (%rax)
movq -0x20(%rbp), %rax
movb (%rax), %cl
movq -0x28(%rbp), %rax
movb %cl, (%rax)
movq -0x10(%rbp), %rdi
movl $0x3, %esi
callq 0x112e0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_msgpack.c
// Function: as_pack_list_header
int
as_pack_list_header(as_packer *pk, uint32_t ele_count)
{
	int rc;

	if (ele_count < 16) {
		rc = pack_byte(pk, (uint8_t)(0x90 | ele_count), false);
	}
	else if (ele_count < (1 << 16)) {
		rc = pack_type_uint16(pk, 0xdc, (uint16_t)ele_count, false);
	}
	else {
		rc = pack_type_uint32(pk, 0xdd, ele_count, false);
	}

	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x10, -0xc(%rbp)
jae 0xf710
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
orl $0x90, %eax
xorl %edx, %edx
movzbl %al, %esi
callq 0xdaa0
movl %eax, -0x10(%rbp)
jmp 0xf74c
cmpl $0x10000, -0xc(%rbp)    # imm = 0x10000
jae 0xf734
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
movl $0xdc, %esi
xorl %ecx, %ecx
movzwl %ax, %edx
callq 0xf5f0
movl %eax, -0x10(%rbp)
jmp 0xf74a
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
movl $0xdd, %esi
xorl %ecx, %ecx
callq 0xf010
movl %eax, -0x10(%rbp)
jmp 0xf74c
movl -0x10(%rbp), %eax
addq $0x10, %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_pack_list_header_get_size
uint32_t
as_pack_list_header_get_size(uint32_t ele_count)
{
	if (ele_count < 16) {
		return 1;
	}
	else if (ele_count < (1 << 16)) {
		return 3;
	}
	else {
		return 5;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
cmpl $0x10, -0x8(%rbp)
jae 0xf776
movl $0x1, -0x4(%rbp)
jmp 0xf78f
cmpl $0x10000, -0x8(%rbp)    # imm = 0x10000
jae 0xf788
movl $0x3, -0x4(%rbp)
jmp 0xf78f
movl $0x5, -0x4(%rbp)
movl -0x4(%rbp), %eax
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_map_header_internal
static inline int
pack_map_header_internal(as_packer *pk, uint32_t ele_count, bool resize)
{
	int rc;

	if (ele_count < 16) {
		rc = pack_byte(pk, (uint8_t)(0x80 | ele_count), resize);
	}
	else if (ele_count < (1 << 16)) {
		rc = pack_type_uint16(pk, 0xde, (uint16_t)ele_count, resize);
	}
	else {
		rc = pack_type_uint32(pk, 0xdf, ele_count, resize);
	}

	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
andb $0x1, %al
movb %al, -0xd(%rbp)
cmpl $0x10, -0xc(%rbp)
jae 0xf80f
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
orl $0x80, %eax
movb %al, %cl
movb -0xd(%rbp), %al
andb $0x1, %al
movzbl %cl, %esi
movzbl %al, %edx
callq 0xdaa0
movl %eax, -0x14(%rbp)
jmp 0xf85a
cmpl $0x10000, -0xc(%rbp)    # imm = 0x10000
jae 0xf83c
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %eax
movw %ax, %cx
movb -0xd(%rbp), %al
movl $0xde, %esi
andb $0x1, %al
movzwl %cx, %edx
movzbl %al, %ecx
callq 0xf5f0
movl %eax, -0x14(%rbp)
jmp 0xf858
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %edx
movb -0xd(%rbp), %al
movl $0xdf, %esi
andb $0x1, %al
movzbl %al, %ecx
callq 0xf010
movl %eax, -0x14(%rbp)
jmp 0xf85a
movl -0x14(%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_ext_header_get_size
uint32_t
as_pack_ext_header_get_size(uint32_t content_size)
{
	if (content_size == 1 || content_size == 2 || content_size == 4 ||
			content_size == 8 || content_size == 16) {
		return 1 + 1;
	}
	else if (content_size < (1 << 8)) {
		return 1 + 1 + 1;
	}
	else if (content_size < (1 << 16)) {
		return 1 + 2 + 1;
	}

	return 1 + 4 + 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
cmpl $0x1, -0x8(%rbp)
je 0xf895
cmpl $0x2, -0x8(%rbp)
je 0xf895
cmpl $0x4, -0x8(%rbp)
je 0xf895
cmpl $0x8, -0x8(%rbp)
je 0xf895
cmpl $0x10, -0x8(%rbp)
jne 0xf89e
movl $0x2, -0x4(%rbp)
jmp 0xf8cd
cmpl $0x100, -0x8(%rbp)      # imm = 0x100
jae 0xf8b0
movl $0x3, -0x4(%rbp)
jmp 0xf8cd
cmpl $0x10000, -0x8(%rbp)    # imm = 0x10000
jae 0xf8c2
movl $0x4, -0x4(%rbp)
jmp 0xf8cd
jmp 0xf8c4
jmp 0xf8c6
movl $0x6, -0x4(%rbp)
movl -0x4(%rbp), %eax
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_ext_header_internal
static inline int
pack_ext_header_internal(as_packer *pk, uint32_t content_size, uint8_t type,
		bool resize)
{
	int rc;

	if (content_size == 1) {
		rc = pack_byte(pk, 0xd4, resize);
	}
	else if (content_size == 2) {
		rc = pack_byte(pk, 0xd5, resize);
	}
	else if (content_size == 4) {
		rc = pack_byte(pk, 0xd6, resize);
	}
	else if (content_size == 8) {
		rc = pack_byte(pk, 0xd7, resize);
	}
	else if (content_size == 16) {
		rc = pack_byte(pk, 0xd8, resize);
	}
	else if (content_size < (1 << 8)) {
		rc = pack_type_uint8(pk, 0xc7, (uint8_t)content_size, resize);
	}
	else if (content_size < (1 << 16)) {
		rc = pack_type_uint16(pk, 0xc8, (uint16_t)content_size, resize);
	}
	else {
		rc = pack_type_uint32(pk, 0xc9, content_size, resize);
	}

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

	return pack_byte(pk, type, resize);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %cl, %al
movb %dl, %cl
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movb %cl, -0x15(%rbp)
andb $0x1, %al
movb %al, -0x16(%rbp)
cmpl $0x1, -0x14(%rbp)
jne 0xf94f
movq -0x10(%rbp), %rdi
movb -0x16(%rbp), %al
movl $0xd4, %esi
andb $0x1, %al
movzbl %al, %edx
callq 0xdaa0
movl %eax, -0x1c(%rbp)
jmp 0xfa5d
cmpl $0x2, -0x14(%rbp)
jne 0xf973
movq -0x10(%rbp), %rdi
movb -0x16(%rbp), %al
movl $0xd5, %esi
andb $0x1, %al
movzbl %al, %edx
callq 0xdaa0
movl %eax, -0x1c(%rbp)
jmp 0xfa5b
cmpl $0x4, -0x14(%rbp)
jne 0xf997
movq -0x10(%rbp), %rdi
movb -0x16(%rbp), %al
movl $0xd6, %esi
andb $0x1, %al
movzbl %al, %edx
callq 0xdaa0
movl %eax, -0x1c(%rbp)
jmp 0xfa59
cmpl $0x8, -0x14(%rbp)
jne 0xf9bb
movq -0x10(%rbp), %rdi
movb -0x16(%rbp), %al
movl $0xd7, %esi
andb $0x1, %al
movzbl %al, %edx
callq 0xdaa0
movl %eax, -0x1c(%rbp)
jmp 0xfa57
cmpl $0x10, -0x14(%rbp)
jne 0xf9dc
movq -0x10(%rbp), %rdi
movb -0x16(%rbp), %al
movl $0xd8, %esi
andb $0x1, %al
movzbl %al, %edx
callq 0xdaa0
movl %eax, -0x1c(%rbp)
jmp 0xfa55
cmpl $0x100, -0x14(%rbp)     # imm = 0x100
jae 0xfa08
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
movb %al, %cl
movb -0x16(%rbp), %al
movl $0xc7, %esi
andb $0x1, %al
movzbl %cl, %edx
movzbl %al, %ecx
callq 0xf540
movl %eax, -0x1c(%rbp)
jmp 0xfa53
cmpl $0x10000, -0x14(%rbp)   # imm = 0x10000
jae 0xfa35
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %eax
movw %ax, %cx
movb -0x16(%rbp), %al
movl $0xc8, %esi
andb $0x1, %al
movzwl %cx, %edx
movzbl %al, %ecx
callq 0xf5f0
movl %eax, -0x1c(%rbp)
jmp 0xfa51
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %edx
movb -0x16(%rbp), %al
movl $0xc9, %esi
andb $0x1, %al
movzbl %al, %ecx
callq 0xf010
movl %eax, -0x1c(%rbp)
jmp 0xfa53
jmp 0xfa55
jmp 0xfa57
jmp 0xfa59
jmp 0xfa5b
jmp 0xfa5d
cmpl $0x0, -0x1c(%rbp)
je 0xfa6b
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xfa85
movq -0x10(%rbp), %rdi
movb -0x15(%rbp), %cl
movb -0x16(%rbp), %al
andb $0x1, %al
movzbl %cl, %esi
movzbl %al, %edx
callq 0xdaa0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_msgpack.c
// Function: as_pack_buf_ext_header
int
as_pack_buf_ext_header(uint8_t *buf, uint32_t size, uint32_t content_size,
		uint8_t type)
{
	as_packer pk = {
			.head = NULL,
			.tail = NULL,
			.buffer = buf,
			.offset = 0,
			.capacity = size
	};

	return as_pack_ext_header(&pk, content_size, type);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %cl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x20(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x10(%rbp), %esi
leaq -0x38(%rbp), %rdi
movzbl -0x11(%rbp), %edx
callq 0x87d0
addq $0x40, %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: bytes_internal_type_to_as_val_t
static inline as_val_t
bytes_internal_type_to_as_val_t(uint8_t type)
{
	if (type == AS_BYTES_STRING) {
		return AS_STRING;
	}
	else if (type == AS_BYTES_GEOJSON) {
		return AS_GEOJSON;
	}

	// All other types are considered AS_BYTES.
	return AS_BYTES;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x2(%rbp)
movzbl -0x2(%rbp), %eax
cmpl $0x3, %eax
jne 0xfd59
movb $0x4, -0x1(%rbp)
jmp 0xfd6e
movzbl -0x2(%rbp), %eax
cmpl $0x17, %eax
jne 0xfd68
movb $0xb, -0x1(%rbp)
jmp 0xfd6e
jmp 0xfd6a
movb $0x9, -0x1(%rbp)
movb -0x1(%rbp), %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: as_unpack_buf_peek_type
as_val_t
as_unpack_buf_peek_type(const uint8_t *buf, uint32_t size)
{
	const as_unpacker pk = {
			.buffer = buf,
			.offset = 0,
			.length = size,
	};

	return as_unpack_peek_type(&pk);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x8490
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_unpack_boolean
int
as_unpack_boolean(as_unpacker *pk, bool *value)
{
	uint8_t type = pk->buffer[pk->offset++];

	if (type == 0xc3 || type == 0xc2) {
		*value = type == 0xc3;
		return 0;
	}

	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%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, -0x19(%rbp)
movzbl -0x19(%rbp), %eax
cmpl $0xc3, %eax
je 0xfe00
movzbl -0x19(%rbp), %eax
cmpl $0xc2, %eax
jne 0xfe1e
movzbl -0x19(%rbp), %eax
cmpl $0xc3, %eax
sete %cl
movq -0x18(%rbp), %rax
andb $0x1, %cl
movb %cl, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0xfe25
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
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_unpack_blob_size
int64_t
as_unpack_blob_size(as_unpacker *pk)
{
	if (pk->offset >= pk->length) {
		return -1;
	}

	uint8_t type = pk->buffer[pk->offset++];
	uint32_t size = pk->length - pk->offset;

	switch (type) {
	case 0xc4:
	case 0xd9: // string/raw bytes with 8 bit header
		if (size < 1) {
			return -2;
		}
		return (int64_t)pk->buffer[pk->offset++];

	case 0xc5:
	case 0xda: // string/raw bytes with 16 bit header
		if (size < 2) {
			return -3;
		}
		return (int64_t)extract_uint16(pk);

	case 0xc6:
	case 0xdb: // string/raw bytes with 32 bit header
		if (size < 4) {
			return -4;
		}
		return (int64_t)extract_uint32(pk);

	default:
		if ((type & 0xe0) == 0xa0) { // raw bytes with 8 bit combined header
			return type & 0x1f;
		}
		break;
	}

	return -5;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jb 0x10359
movq $-0x1, -0x8(%rbp)
jmp 0x1046c
movq -0x10(%rbp), %rdx
movq (%rdx), %rax
movl 0x8(%rdx), %ecx
movl %ecx, %esi
incl %esi
movl %esi, 0x8(%rdx)
movb (%rax,%rcx), %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
movl 0xc(%rax), %eax
subl %ecx, %eax
movl %eax, -0x18(%rbp)
movzbl -0x11(%rbp), %eax
movl %eax, -0x1c(%rbp)
subl $0xc4, %eax
je 0x103cb
jmp 0x1038f
movl -0x1c(%rbp), %eax
subl $0xc5, %eax
je 0x10400
jmp 0x1039b
movl -0x1c(%rbp), %eax
subl $0xc6, %eax
je 0x10422
jmp 0x103a7
movl -0x1c(%rbp), %eax
subl $0xd9, %eax
je 0x103cb
jmp 0x103b3
movl -0x1c(%rbp), %eax
subl $0xda, %eax
je 0x10400
jmp 0x103bf
movl -0x1c(%rbp), %eax
subl $0xdb, %eax
je 0x10422
jmp 0x10443
cmpl $0x1, -0x18(%rbp)
jae 0x103de
movq $-0x2, -0x8(%rbp)
jmp 0x1046c
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
movzbl (%rax,%rcx), %eax
movq %rax, -0x8(%rbp)
jmp 0x1046c
cmpl $0x2, -0x18(%rbp)
jae 0x10410
movq $-0x3, -0x8(%rbp)
jmp 0x1046c
movq -0x10(%rbp), %rdi
callq 0xe6a0
movzwl %ax, %eax
movq %rax, -0x8(%rbp)
jmp 0x1046c
cmpl $0x4, -0x18(%rbp)
jae 0x10432
movq $-0x4, -0x8(%rbp)
jmp 0x1046c
movq -0x10(%rbp), %rdi
callq 0xe6f0
movl %eax, %eax
movq %rax, -0x8(%rbp)
jmp 0x1046c
movzbl -0x11(%rbp), %eax
andl $0xe0, %eax
cmpl $0xa0, %eax
jne 0x10462
movzbl -0x11(%rbp), %eax
andl $0x1f, %eax
cltq
movq %rax, -0x8(%rbp)
jmp 0x1046c
jmp 0x10464
movq $-0x5, -0x8(%rbp)
movq -0x8(%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: as_unpack_double
int
as_unpack_double(as_unpacker *pk, double *x)
{
	if (pk->offset >= pk->length) {
		return -1;
	}

	uint8_t type = pk->buffer[pk->offset++];
	uint32_t size = pk->length - pk->offset;

	switch (type) {
	case 0xca: // float
		if (size < 4) {
			return -2;
		}
		*x = (double)extract_float(pk);
		break;
	case 0xcb: // double
		if (size < 8) {
			return -3;
		}
		*x = extract_double(pk);
		break;
	default:
		return -4;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jb 0x106fc
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x10796
movq -0x10(%rbp), %rdx
movq (%rdx), %rax
movl 0x8(%rdx), %ecx
movl %ecx, %esi
incl %esi
movl %esi, 0x8(%rdx)
movb (%rax,%rcx), %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
movl 0xc(%rax), %eax
subl %ecx, %eax
movl %eax, -0x20(%rbp)
movzbl -0x19(%rbp), %eax
movl %eax, -0x24(%rbp)
subl $0xca, %eax
je 0x1073e
jmp 0x10732
movl -0x24(%rbp), %eax
subl $0xcb, %eax
je 0x10764
jmp 0x10786
cmpl $0x4, -0x20(%rbp)
jae 0x1074d
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x10796
movq -0x10(%rbp), %rdi
callq 0xe5d0
cvtss2sd %xmm0, %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
jmp 0x1078f
cmpl $0x8, -0x20(%rbp)
jae 0x10773
movl $0xfffffffd, -0x4(%rbp) # imm = 0xFFFFFFFD
jmp 0x10796
movq -0x10(%rbp), %rdi
callq 0xe620
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
jmp 0x1078f
movl $0xfffffffc, -0x4(%rbp) # imm = 0xFFFFFFFC
jmp 0x10796
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_msgpack.c
// Function: as_unpack_buf_list_element_count
int64_t
as_unpack_buf_list_element_count(const uint8_t *buf, uint32_t size)
{
	as_unpacker pk = {
			.buffer = buf,
			.offset = 0,
			.length = size,
	};

	return as_unpack_list_header_element_count(&pk);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x86e0
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_unpack_list_header_element_count
int64_t
as_unpack_list_header_element_count(as_unpacker *pk)
{
	if (pk->offset >= pk->length) {
		return -1;
	}

	uint8_t type = pk->buffer[pk->offset++];
	uint32_t size = pk->length - pk->offset;

	switch (type) {
	case 0xdc: // list with 16 bit header
		if (size < 2) {
			return -2;
		}
		return extract_uint16(pk);
	case 0xdd: // list with 32 bit header
		if (size < 4) {
			return -3;
		}
		return (int64_t)extract_uint32(pk);
	default:
		break;
	}

	if ((type & 0xf0) == 0x90) { // list with 8 bit combined header
		return (int64_t)(type & 0x0f);
	}

	return -4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jb 0x10be9
movq $-0x1, -0x8(%rbp)
jmp 0x10c97
movq -0x10(%rbp), %rdx
movq (%rdx), %rax
movl 0x8(%rdx), %ecx
movl %ecx, %esi
incl %esi
movl %esi, 0x8(%rdx)
movb (%rax,%rcx), %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
movl 0xc(%rax), %eax
subl %ecx, %eax
movl %eax, -0x18(%rbp)
movzbl -0x11(%rbp), %eax
movl %eax, -0x1c(%rbp)
subl $0xdc, %eax
je 0x10c2b
jmp 0x10c1f
movl -0x1c(%rbp), %eax
subl $0xdd, %eax
je 0x10c4d
jmp 0x10c6e
cmpl $0x2, -0x18(%rbp)
jae 0x10c3b
movq $-0x2, -0x8(%rbp)
jmp 0x10c97
movq -0x10(%rbp), %rdi
callq 0xe6a0
movzwl %ax, %eax
movq %rax, -0x8(%rbp)
jmp 0x10c97
cmpl $0x4, -0x18(%rbp)
jae 0x10c5d
movq $-0x3, -0x8(%rbp)
jmp 0x10c97
movq -0x10(%rbp), %rdi
callq 0xe6f0
movl %eax, %eax
movq %rax, -0x8(%rbp)
jmp 0x10c97
jmp 0x10c70
movzbl -0x11(%rbp), %eax
andl $0xf0, %eax
cmpl $0x90, %eax
jne 0x10c8f
movzbl -0x11(%rbp), %eax
andl $0xf, %eax
cltq
movq %rax, -0x8(%rbp)
jmp 0x10c97
movq $-0x4, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %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: as_unpack_map_header_element_count
int64_t
as_unpack_map_header_element_count(as_unpacker *pk)
{
	if (pk->offset >= pk->length) {
		return -1;
	}

	uint8_t type = pk->buffer[pk->offset++];
	uint32_t size = pk->length - pk->offset;

	switch (type) {
	case 0xde: // map with 16 bit header
		if (size < 2) {
			return -2;
		}
		return extract_uint16(pk);
	case 0xdf: // map with 32 bit header
		if (size < 4) {
			return -3;
		}
		return extract_uint32(pk);
	default:
		break;
	}

	if ((type & 0xf0) == 0x80) { // map with 8 bit combined header
		return type & 0x0f;
	}

	return -4;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jb 0x10cd9
movq $-0x1, -0x8(%rbp)
jmp 0x10d87
movq -0x10(%rbp), %rdx
movq (%rdx), %rax
movl 0x8(%rdx), %ecx
movl %ecx, %esi
incl %esi
movl %esi, 0x8(%rdx)
movb (%rax,%rcx), %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
movl 0xc(%rax), %eax
subl %ecx, %eax
movl %eax, -0x18(%rbp)
movzbl -0x11(%rbp), %eax
movl %eax, -0x1c(%rbp)
subl $0xde, %eax
je 0x10d1b
jmp 0x10d0f
movl -0x1c(%rbp), %eax
subl $0xdf, %eax
je 0x10d3d
jmp 0x10d5e
cmpl $0x2, -0x18(%rbp)
jae 0x10d2b
movq $-0x2, -0x8(%rbp)
jmp 0x10d87
movq -0x10(%rbp), %rdi
callq 0xe6a0
movzwl %ax, %eax
movq %rax, -0x8(%rbp)
jmp 0x10d87
cmpl $0x4, -0x18(%rbp)
jae 0x10d4d
movq $-0x3, -0x8(%rbp)
jmp 0x10d87
movq -0x10(%rbp), %rdi
callq 0xe6f0
movl %eax, %eax
movq %rax, -0x8(%rbp)
jmp 0x10d87
jmp 0x10d60
movzbl -0x11(%rbp), %eax
andl $0xf0, %eax
cmpl $0x80, %eax
jne 0x10d7f
movzbl -0x11(%rbp), %eax
andl $0xf, %eax
cltq
movq %rax, -0x8(%rbp)
jmp 0x10d87
movq $-0x4, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %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: as_unpack_buf_compare
msgpack_compare_t
as_unpack_buf_compare(const uint8_t *buf1, uint32_t size1, const uint8_t *buf2,
		uint32_t size2)
{
	as_unpacker pk1 = {
			.buffer = buf1,
			.offset = 0,
			.length = size1
	};
	as_unpacker pk2 = {
			.buffer = buf2,
			.offset = 0,
			.length = size2
	};
	as_val_t type;

	return msgpack_compare_internal(&pk1, &pk2, 0, &type);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x28(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x0, -0x38(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x34(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x40(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
leaq -0x41(%rbp), %rcx
callq 0x10e40
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_msgpack.c
// Function: msgpack_compare_internal
static inline msgpack_compare_t
msgpack_compare_internal(as_unpacker *pk1, as_unpacker *pk2, size_t depth,
		as_val_t *type)
{
	msgpack_compare_t ret = msgpack_peek_compare_type(pk1, pk2, type);

	if (ret == MSGPACK_COMPARE_ERROR || ret == MSGPACK_COMPARE_END) {
		return MSGPACK_COMPARE_ERROR;
	}

	if (ret != MSGPACK_COMPARE_EQUAL || *type == AS_CMP_WILDCARD) {
		if (as_unpack_size(pk1) < 0) {
			return MSGPACK_COMPARE_ERROR;
		}

		if (as_unpack_size(pk2) < 0) {
			return MSGPACK_COMPARE_ERROR;
		}

		return ret;
	}

	return msgpack_compare_type(pk1, pk2, *type, depth);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x120e0
movl %eax, -0x2c(%rbp)
cmpl $-0x2, -0x2c(%rbp)
je 0x10e78
cmpl $-0x1, -0x2c(%rbp)
jne 0x10e81
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x10ee8
cmpl $0x1, -0x2c(%rbp)
jne 0x10e93
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
cmpl $0xd, %eax
jne 0x10ecb
movq -0x10(%rbp), %rdi
callq 0x89e0
cmpq $0x0, %rax
jge 0x10eab
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x10ee8
movq -0x18(%rbp), %rdi
callq 0x89e0
cmpq $0x0, %rax
jge 0x10ec3
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x10ee8
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x10ee8
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rax
movb (%rax), %al
movq -0x20(%rbp), %rcx
movzbl %al, %edx
callq 0x12200
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %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: pack_resize
static int
pack_resize(as_packer *pk, uint32_t sz)
{
	// Add current buffer to linked list and allocate a new buffer
	as_packer_buffer *entry =
			(as_packer_buffer *)cf_malloc(sizeof(as_packer_buffer));

	if (! entry) {
		return -1;
	}

	entry->buffer = pk->buffer;
	entry->length = pk->offset;
	entry->next = 0;

	size_t newcap = (size_t)((sz > (uint32_t)pk->capacity) ? sz : pk->capacity);

	if (! (pk->buffer = (unsigned char *)cf_malloc(newcap))) {
		cf_free(entry);
		return -1;
	}

	pk->capacity = (int)newcap;
	pk->offset = 0;

	if (pk->tail) {
		pk->tail->next = entry;
		pk->tail = entry;
	}
	else {
		pk->head = entry;
		pk->tail = entry;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x18, %edi
callq 0x8090
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x11200
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x112d7
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
jbe 0x1123d
movl -0x14(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x11247
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, %eax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x8090
movq -0x10(%rbp), %rcx
movq %rax, 0x10(%rcx)
cmpq $0x0, %rax
jne 0x11279
movq -0x20(%rbp), %rdi
callq 0x8aa0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x112d7
movq -0x28(%rbp), %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x1c(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x112b9
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x112d0
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_msgpack.c
// Function: advance_offset
static inline int
advance_offset(as_packer *pk, uint32_t sz)
{
	uint64_t offset = (uint64_t)pk->offset + sz;

	if (offset > INT32_MAX) {
		return -1;
	}

	pk->offset = (uint32_t)offset;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
movl -0x14(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
cmpq $0x7fffffff, -0x20(%rbp) # imm = 0x7FFFFFFF
jbe 0x1130f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x11323
movq -0x20(%rbp), %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x18(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_msgpack.c
// Function: pack_map_foreach
static bool
pack_map_foreach(const as_val* key, const as_val* val, void* udata)
{
	as_packer* pk = (as_packer*)udata;
	int rc = as_pack_val(pk, (as_val*)key);

	if (rc == 0) {
		rc = as_pack_val(pk, (as_val*)val);
	}

	return rc == 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x8b90
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x11512
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8b90
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
sete %al
andb $0x1, %al
addq $0x30, %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: unpack_map_create_list
static int
unpack_map_create_list(as_unpacker *pk, uint32_t size, as_val **val)
{
	// Create list of key value pairs.
	as_arraylist *list = as_arraylist_new(2 * size, 2 * size);

	if (! list) {
		return -1;
	}

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

		if (as_unpack_val(pk, &k) != 0) {
			as_arraylist_destroy(list);
			return -2;
		}

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

		if (k && v) {
			as_arraylist_append(list, k);
			as_arraylist_append(list, v);
		}
		else {
			as_val_destroy(k);
			as_val_destroy(v);
		}
	}

	*val = (as_val *)list;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl -0x14(%rbp), %edi
shll %edi
movl -0x14(%rbp), %esi
shll %esi
callq 0x85d0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x11719
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x117ee
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x117dc
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x8760
cmpl $0x0, %eax
je 0x11763
movq -0x28(%rbp), %rdi
callq 0x88b0
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x117ee
movq -0x10(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x8760
cmpl $0x0, %eax
je 0x11790
movq -0x38(%rbp), %rdi
callq 0x8550
movq -0x28(%rbp), %rdi
callq 0x88b0
movl $0xfffffffd, -0x4(%rbp) # imm = 0xFFFFFFFD
jmp 0x117ee
cmpq $0x0, -0x38(%rbp)
je 0x117ba
cmpq $0x0, -0x40(%rbp)
je 0x117ba
movq -0x28(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x8470
movq -0x28(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x8470
jmp 0x117cc
movq -0x38(%rbp), %rdi
callq 0x8550
movq -0x40(%rbp), %rdi
callq 0x8550
jmp 0x117ce
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x11720
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %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: unpack_orderedmap
static int
unpack_orderedmap(as_unpacker* pk, uint32_t ele_count, as_val** val,
		uint8_t flags)
{
	as_orderedmap *map = as_orderedmap_new(ele_count);

	if (map == NULL) {
		return -2;
	}

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

		if (as_unpack_val(pk, &k) != 0) {
			as_orderedmap_destroy(map);
			return -3;
		}

		if (as_unpack_val(pk, &v) != 0) {
			as_val_destroy(k);
			as_orderedmap_destroy(map);
			return -4;
		}

		if (k == NULL || v == NULL || as_orderedmap_set(map, k, v) < 0) {
			as_val_destroy(k);
			as_val_destroy(v);
			as_orderedmap_destroy(map);
			return -5;
		}
	}

	*val = (as_val*)map;
	as_orderedmap_set_flags(map, flags);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movb %al, -0x21(%rbp)
movl -0x14(%rbp), %edi
callq 0x8430
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x11837
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x11925
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x11906
movq $0x0, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x8760
cmpl $0x0, %eax
je 0x11881
movq -0x30(%rbp), %rdi
callq 0x8a90
movl $0xfffffffd, -0x4(%rbp) # imm = 0xFFFFFFFD
jmp 0x11925
movq -0x10(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x8760
cmpl $0x0, %eax
je 0x118ae
movq -0x40(%rbp), %rdi
callq 0x8550
movq -0x30(%rbp), %rdi
callq 0x8a90
movl $0xfffffffc, -0x4(%rbp) # imm = 0xFFFFFFFC
jmp 0x11925
cmpq $0x0, -0x40(%rbp)
je 0x118d2
cmpq $0x0, -0x48(%rbp)
je 0x118d2
movq -0x30(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0x8260
cmpl $0x0, %eax
jge 0x118f6
movq -0x40(%rbp), %rdi
callq 0x8550
movq -0x48(%rbp), %rdi
callq 0x8550
movq -0x30(%rbp), %rdi
callq 0x8a90
movl $0xfffffffb, -0x4(%rbp) # imm = 0xFFFFFFFB
jmp 0x11925
jmp 0x118f8
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x1183e
movq -0x30(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rdi
movzbl -0x21(%rbp), %esi
callq 0x11930
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_msgpack.c
// Function: pack_type_uint64
static inline int
pack_type_uint64(as_packer *pk, unsigned char type, uint64_t val, bool resize)
{
	if (pk->buffer) {
		if (pk->offset + 9 > pk->capacity) {
			if (! resize || pack_resize(pk, 9) != 0) {
				return -1;
			}
		}
		uint64_t swapped = cf_swap_to_be64(val);
		unsigned char *p = pk->buffer + pk->offset;
		*p++ = type;
		memcpy(p, &swapped, 8);
	}
	return advance_offset(pk, 9);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %cl, %al
movb %sil, %cl
movq %rdi, -0x10(%rbp)
movb %cl, -0x11(%rbp)
movq %rdx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x11a11
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
addl $0x9, %eax
movq -0x10(%rbp), %rcx
cmpl 0x1c(%rcx), %eax
jbe 0x119cf
testb $0x1, -0x21(%rbp)
je 0x119c4
movq -0x10(%rbp), %rdi
movl $0x9, %esi
callq 0x111d0
cmpl $0x0, %eax
je 0x119cd
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x11a22
jmp 0x119cf
movq -0x20(%rbp), %rdi
callq 0x11a30
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x18(%rcx), %ecx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movb -0x11(%rbp), %cl
movq -0x38(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x38(%rbp)
movb %cl, (%rax)
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rdi
movl $0x9, %esi
callq 0x112e0
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_msgpack.c
// Function: unpack_list_elements_size
static int64_t
unpack_list_elements_size(as_unpacker *pk, uint32_t ele_count, uint32_t depth)
{
	if (++depth > MSGPACK_COMPARE_MAX_DEPTH) {
		msgpack_parse_memblock *block = msgpack_parse_memblock_create(NULL);
		msgpack_parse_state *state = msgpack_parse_memblock_next(&block);

		state->index = 0;
		state->map_pair = 0;
		state->len = ele_count;
		state->type = AS_LIST;

		int64_t ret = unpack_size_non_recursive(pk, block, state);

		msgpack_parse_memblock_destroy(block);

		return ret;
	}

	int64_t total = 0;

	for (uint32_t i = 0; i < ele_count; i++) {
		int64_t ret = unpack_size_internal(pk, depth);

		if (ret < 0) {
			return -1;
		}

		total += ret;
	}

	return total;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
cmpl $0x100, %eax            # imm = 0x100
jbe 0x11b19
xorl %eax, %eax
movl %eax, %edi
callq 0x11ca0
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x11ce0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x28(%rbp), %rax
movb $0x0, 0x10(%rax)
movl -0x14(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x28(%rbp), %rax
movb $0x5, 0x11(%rax)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x11d50
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x11ef0
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x11b70
movq $0x0, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x11b68
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0xfe70
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jge 0x11b51
movq $-0x1, -0x8(%rbp)
jmp 0x11b70
movq -0x48(%rbp), %rax
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x11b28
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %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: unpack_map_elements_size
static int64_t
unpack_map_elements_size(as_unpacker *pk, uint32_t ele_count, uint32_t depth)
{
	if (++depth > MSGPACK_COMPARE_MAX_DEPTH) {
		msgpack_parse_memblock *block = msgpack_parse_memblock_create(NULL);
		msgpack_parse_state *state = msgpack_parse_memblock_next(&block);

		state->index = 0;
		state->map_pair = 0;
		state->len = ele_count;
		state->type = AS_MAP;

		int64_t ret = unpack_size_non_recursive(pk, block, state);
		msgpack_parse_memblock_destroy(block);

		return ret;
	}

	int64_t total = 0;

	for (uint32_t i = 0; i < ele_count; i++) {
		int64_t ret = unpack_size_internal(pk, depth);

		if (ret < 0) {
			return -1;
		}

		total += ret;
		ret = unpack_size_internal(pk, depth);

		if (ret < 0) {
			return -2;
		}

		total += ret;
	}

	return total;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
cmpl $0x100, %eax            # imm = 0x100
jbe 0x11c0c
xorl %eax, %eax
movl %eax, %edi
callq 0x11ca0
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x11ce0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x28(%rbp), %rax
movb $0x0, 0x10(%rax)
movl -0x14(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x28(%rbp), %rax
movb $0x6, 0x11(%rax)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x11d50
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
callq 0x11ef0
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x11c90
movq $0x0, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x11c88
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0xfe70
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jge 0x11c44
movq $-0x1, -0x8(%rbp)
jmp 0x11c90
movq -0x48(%rbp), %rax
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0xfe70
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jge 0x11c71
movq $-0x2, -0x8(%rbp)
jmp 0x11c90
movq -0x48(%rbp), %rax
addq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x11c1b
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %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: msgpack_parse_memblock_create
static msgpack_parse_memblock *
msgpack_parse_memblock_create(msgpack_parse_memblock *prev)
{
	msgpack_parse_memblock *p = cf_malloc(sizeof(msgpack_parse_memblock));
	p->prev = prev;
	p->count = 0;
	return p;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1810, %edi           # imm = 0x1810
callq 0x8090
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x1808(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_msgpack.c
// Function: msgpack_parse_memblock_next
static msgpack_parse_state *
msgpack_parse_memblock_next(msgpack_parse_memblock **block)
{
	msgpack_parse_memblock *ptr = *block;

	if (ptr->count >= MSGPACK_PARSE_MEMBLOCK_STATE_COUNT) {
		ptr = msgpack_parse_memblock_create(ptr);
		*block = ptr;
	}

	return &ptr->buffer[ptr->count++];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x100, 0x1808(%rax) # imm = 0x100
jb 0x11d20
movq -0x10(%rbp), %rdi
callq 0x11ca0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq -0x10(%rbp), %rdx
movq 0x1808(%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0x1808(%rdx)
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_msgpack.c
// Function: msgpack_parse_memblock_destroy
static void
msgpack_parse_memblock_destroy(msgpack_parse_memblock *block)
{
	while (block) {
		msgpack_parse_memblock *p = block;
		block = block->prev;
		cf_free(p);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x11f21
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8aa0
jmp 0x11efc
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: msgpack_parse_memblock_prev
static msgpack_parse_state *
msgpack_parse_memblock_prev(msgpack_parse_memblock **block)
{
	msgpack_parse_memblock *ptr = *block;

	if (ptr->count <= 1) {
		ptr = ptr->prev;
		cf_free(*block);
		*block = ptr;
	}
	else {
		ptr->count--;
	}

	// No check for NULL ptr here, use has_prev to make sure it doesn't happen.

	return &ptr->buffer[ptr->count - 1];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x1, 0x1808(%rax)
ja 0x11fb9
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x8aa0
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x11fcf
movq -0x10(%rbp), %rax
movq 0x1808(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x1808(%rax)
movq -0x10(%rbp), %rax
addq $0x8, %rax
movq -0x10(%rbp), %rcx
movq 0x1808(%rcx), %rcx
subq $0x1, %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)