LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_msgpack.c
// Function: msgpack_parse_state_list_size_init
static bool
msgpack_parse_state_list_size_init(msgpack_parse_state *state, as_unpacker *pk)
{
	int64_t len = as_unpack_list_header_element_count(pk);

	if (len < 0) {
		return false;
	}

	state->index = 0;
	state->map_pair = 0;
	state->len = (uint32_t)len;
	state->type = AS_LIST;

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x86e0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jge 0x1202a
movb $0x0, -0x1(%rbp)
jmp 0x12056
movq -0x10(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x10(%rax)
movq -0x20(%rbp), %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movb $0x5, 0x11(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
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: msgpack_parse_state_map_size_init
static bool
msgpack_parse_state_map_size_init(msgpack_parse_state *state, as_unpacker *pk)
{
	int64_t len = as_unpack_map_header_element_count(pk);

	if (len < 0) {
		return false;
	}

	state->index = 0;
	state->map_pair = 0;
	state->len = (uint32_t)len;
	state->type = AS_MAP;

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8c00
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jge 0x1209a
movb $0x0, -0x1(%rbp)
jmp 0x120c6
movq -0x10(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x10(%rax)
movq -0x20(%rbp), %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movb $0x6, 0x11(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
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: msgpack_peek_compare_type
static inline msgpack_compare_t
msgpack_peek_compare_type(const as_unpacker *pk1, const as_unpacker *pk2,
		as_val_t *type)
{
	int n1 = pk1->length - pk1->offset;
	int n2 = pk2->length - pk2->offset;

	*type = AS_UNDEF;

	if (n1 == 0 || n2 == 0) {
		MSGPACK_COMPARE_RET_LESS_OR_GREATER(n1, n2);

		return MSGPACK_COMPARE_END;
	}

	as_val_t type1 = as_unpack_peek_type(pk1);
	as_val_t type2 = as_unpack_peek_type(pk2);

	if (type1 == AS_UNDEF || type2 == AS_UNDEF) {
		return MSGPACK_COMPARE_ERROR;
	}

	if (type1 == AS_CMP_WILDCARD || type2 == AS_CMP_WILDCARD) {
		*type = AS_CMP_WILDCARD;

		return MSGPACK_COMPARE_EQUAL;
	}

	MSGPACK_COMPARE_RET_LESS_OR_GREATER(type1, type2);

	*type = type1;

	return MSGPACK_COMPARE_EQUAL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x10(%rbp), %rcx
subl 0x8(%rcx), %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x18(%rbp), %rcx
subl 0x8(%rcx), %eax
movl %eax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
cmpl $0x0, -0x24(%rbp)
je 0x12129
cmpl $0x0, -0x28(%rbp)
jne 0x1215d
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0x1213d
movl $0x0, -0x4(%rbp)
jmp 0x121ec
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jle 0x12151
movl $0x2, -0x4(%rbp)
jmp 0x121ec
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x121ec
movq -0x10(%rbp), %rdi
callq 0x8490
movb %al, -0x29(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8490
movb %al, -0x2a(%rbp)
movzbl -0x29(%rbp), %eax
cmpl $0x0, %eax
je 0x12187
movzbl -0x2a(%rbp), %eax
cmpl $0x0, %eax
jne 0x12190
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x121ec
movzbl -0x29(%rbp), %eax
cmpl $0xd, %eax
je 0x121a2
movzbl -0x2a(%rbp), %eax
cmpl $0xd, %eax
jne 0x121b2
movq -0x20(%rbp), %rax
movb $0xd, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x121ec
movzbl -0x29(%rbp), %eax
movzbl -0x2a(%rbp), %ecx
cmpl %ecx, %eax
jge 0x121c7
movl $0x0, -0x4(%rbp)
jmp 0x121ec
movzbl -0x29(%rbp), %eax
movzbl -0x2a(%rbp), %ecx
cmpl %ecx, %eax
jle 0x121dc
movl $0x2, -0x4(%rbp)
jmp 0x121ec
movb -0x29(%rbp), %cl
movq -0x20(%rbp), %rax
movb %cl, (%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %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: msgpack_compare_int
static inline msgpack_compare_t
msgpack_compare_int(as_unpacker *pk1, as_unpacker *pk2)
{
	int64_t v1 = 0;
	int64_t v2 = 0;

	if (as_unpack_int64(pk1, &v1) != 0
			|| as_unpack_int64(pk2, &v2) != 0) {
		return MSGPACK_COMPARE_ERROR;
	}

	MSGPACK_COMPARE_RET_LESS_OR_GREATER(v1, v2);

	return MSGPACK_COMPARE_EQUAL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x8b80
cmpl $0x0, %eax
jne 0x123e4
movq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x8b80
cmpl $0x0, %eax
je 0x123ed
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x1241a
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jge 0x12400
movl $0x0, -0x4(%rbp)
jmp 0x1241a
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jle 0x12413
movl $0x2, -0x4(%rbp)
jmp 0x1241a
movl $0x1, -0x4(%rbp)
movl -0x4(%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: msgpack_compare_blob
static inline msgpack_compare_t
msgpack_compare_blob(as_unpacker *pk1, as_unpacker *pk2)
{
	int64_t len1 = msgpack_get_blob_len(pk1);
	int64_t len2 = msgpack_get_blob_len(pk2);

	if (len1 < 0 || len2 < 0) {
		return MSGPACK_COMPARE_ERROR;
	}

	return msgpack_compare_blob_internal(pk1, (uint32_t)len1, pk2, (uint32_t)len2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x12a70
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x12a70
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
jl 0x12468
cmpq $0x0, -0x28(%rbp)
jge 0x12471
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x1248d
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movl %eax, %esi
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rax
movl %eax, %ecx
callq 0x12af0
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: msgpack_compare_double
static inline msgpack_compare_t
msgpack_compare_double(as_unpacker *pk1, as_unpacker *pk2)
{
	double v1 = 0;
	double v2 = 0;

	if (as_unpack_double(pk1, &v1) != 0
			|| as_unpack_double(pk2, &v2) != 0) {
		return MSGPACK_COMPARE_ERROR;
	}

	MSGPACK_COMPARE_RET_LESS_OR_GREATER(v1, v2);

	return MSGPACK_COMPARE_EQUAL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x8ba0
cmpl $0x0, %eax
jne 0x12a24
movq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x8ba0
cmpl $0x0, %eax
je 0x12a2d
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x12a62
movsd -0x20(%rbp), %xmm1
movsd -0x28(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x12a46
movl $0x0, -0x4(%rbp)
jmp 0x12a62
movsd -0x20(%rbp), %xmm0
ucomisd -0x28(%rbp), %xmm0
jbe 0x12a5b
movl $0x2, -0x4(%rbp)
jmp 0x12a62
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %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_get_blob_len
static inline int64_t
msgpack_get_blob_len(as_unpacker *pk)
{
	int64_t len = as_unpack_blob_size(pk);

	if (len == 0) {
		return -1;
	}

	// Adjust for 1 byte type.
	len--;
	pk->offset++;

	int64_t left = pk->length - pk->offset;

	if (len > left) {
		return left;
	}

	return len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x81f0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x12a9a
movq $-0x1, -0x8(%rbp)
jmp 0x12ae3
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x10(%rbp), %rcx
subl 0x8(%rcx), %eax
movl %eax, %eax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jle 0x12adb
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x12ae3
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
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: msgpack_compare_blob_internal
static msgpack_compare_t
msgpack_compare_blob_internal(as_unpacker *pk1, uint32_t len1, as_unpacker *pk2,
	uint32_t len2)
{
	uint32_t minlen = (len1 < len2) ? len1 : len2;

	uint32_t offset1 = pk1->offset;
	uint32_t offset2 = pk2->offset;

	pk1->offset += len1;
	pk2->offset += len2;

	for (uint32_t i = 0; i < minlen; i++) {
		unsigned char c1 = pk1->buffer[offset1++];
		unsigned char c2 = pk2->buffer[offset2++];

		MSGPACK_COMPARE_RET_LESS_OR_GREATER(c1, c2);
	}

	MSGPACK_COMPARE_RET_LESS_OR_GREATER(len1, len2);

	return MSGPACK_COMPARE_EQUAL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x24(%rbp), %eax
jae 0x12b12
movl -0x14(%rbp), %eax
movl %eax, -0x3c(%rbp)
jmp 0x12b18
movl -0x24(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x30(%rbp)
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
addl 0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
movl -0x24(%rbp), %ecx
movq -0x20(%rbp), %rax
addl 0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x28(%rbp), %eax
jae 0x12bc6
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl -0x2c(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x2c(%rbp)
movl %ecx, %ecx
movb (%rax,%rcx), %al
movb %al, -0x35(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl -0x30(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x30(%rbp)
movl %ecx, %ecx
movb (%rax,%rcx), %al
movb %al, -0x36(%rbp)
movzbl -0x35(%rbp), %eax
movzbl -0x36(%rbp), %ecx
cmpl %ecx, %eax
jge 0x12ba4
movl $0x0, -0x4(%rbp)
jmp 0x12bef
movzbl -0x35(%rbp), %eax
movzbl -0x36(%rbp), %ecx
cmpl %ecx, %eax
jle 0x12bb9
movl $0x2, -0x4(%rbp)
jmp 0x12bef
jmp 0x12bbb
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x12b53
movl -0x14(%rbp), %eax
cmpl -0x24(%rbp), %eax
jae 0x12bd7
movl $0x0, -0x4(%rbp)
jmp 0x12bef
movl -0x14(%rbp), %eax
cmpl -0x24(%rbp), %eax
jbe 0x12be8
movl $0x2, -0x4(%rbp)
jmp 0x12bef
movl $0x1, -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: msgpack_parse_state_list_cmp_init
static bool
msgpack_parse_state_list_cmp_init(msgpack_parse_state *state, as_unpacker *pk1,
		as_unpacker *pk2)
{
	int64_t len1 = as_unpack_list_header_element_count(pk1);
	int64_t len2 = as_unpack_list_header_element_count(pk2);
	int64_t minlen = (len1 < len2) ? len1 : len2;

	if (minlen < 0) {
		return false;
	}

	state->len1 = (uint32_t)len1;
	state->len2 = (uint32_t)len2;
	state->index = 0;
	state->map_pair = 0;
	state->len = (uint32_t)minlen;
	state->type = AS_LIST;
	state->default_compare_type = msgpack_compare_int64_t(len1, len2);

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x86e0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x86e0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jge 0x12c42
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x12c4a
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jge 0x12c5f
movb $0x0, -0x1(%rbp)
jmp 0x12cba
movq -0x28(%rbp), %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x30(%rbp), %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x10(%rax)
movq -0x38(%rbp), %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movb $0x5, 0x11(%rax)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x130e0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x14(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %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: msgpack_compare_unwind_all
static bool
msgpack_compare_unwind_all(as_unpacker *pk1, as_unpacker *pk2,
		msgpack_parse_memblock **block)
{
	if ((*block)->count == 0) {
		return true;
	}

	const msgpack_parse_state *state = &(*block)->buffer[(*block)->count - 1];

	while (true) {
		if (! msgpack_compare_unwind(pk1, pk2, state)) {
			return false;
		}

		if (! msgpack_parse_memblock_has_prev(*block)) {
			break;
		}

		state = msgpack_parse_memblock_prev(block);
	}

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x1808(%rax)
jne 0x1300b
movb $0x1, -0x1(%rbp)
jmp 0x13073
movq -0x20(%rbp), %rax
movq (%rax), %rax
addq $0x8, %rax
movq -0x20(%rbp), %rcx
movq (%rcx), %rcx
movq 0x1808(%rcx), %rcx
subq $0x1, %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x13120
testb $0x1, %al
jne 0x1304e
movb $0x0, -0x1(%rbp)
jmp 0x13073
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x11f30
testb $0x1, %al
jne 0x13060
jmp 0x1306f
movq -0x20(%rbp), %rdi
callq 0x11f70
movq %rax, -0x28(%rbp)
jmp 0x13033
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
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: msgpack_skip
static bool
msgpack_skip(as_unpacker *pk, size_t n)
{
	for (size_t i = 0; i < n; i++) {
		if (as_unpack_size(pk) < 0) {
			return false;
		}
	}

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x130c7
movq -0x10(%rbp), %rdi
callq 0x89e0
cmpq $0x0, %rax
jge 0x130b7
movb $0x0, -0x1(%rbp)
jmp 0x130cb
jmp 0x130b9
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x13098
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
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: msgpack_compare_unwind
static bool
msgpack_compare_unwind(as_unpacker *pk1, as_unpacker *pk2,
		const msgpack_parse_state *state)
{
	if (state->type == AS_LIST) {
		if (! msgpack_skip(pk1, state->len1 - state->index)) {
			return false;
		}

		if (! msgpack_skip(pk2, state->len2 - state->index)) {
			return false;
		}
	}
	else if (state->type == AS_MAP) {
		if (! msgpack_skip(pk1,
				2 * (state->len1 - state->index) - state->map_pair)) {
			return false;
		}

		if (! msgpack_skip(pk2,
				2 * (state->len2 - state->index) - state->map_pair)) {
			return false;
		}
	}

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movzbl 0x11(%rax), %eax
cmpl $0x5, %eax
jne 0x1318f
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movl (%rax), %eax
movq -0x20(%rbp), %rcx
subl 0xc(%rcx), %eax
movl %eax, %eax
movl %eax, %esi
callq 0x13080
testb $0x1, %al
jne 0x13168
movb $0x0, -0x1(%rbp)
jmp 0x13205
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x20(%rbp), %rcx
subl 0xc(%rcx), %eax
movl %eax, %eax
movl %eax, %esi
callq 0x13080
testb $0x1, %al
jne 0x1318d
movb $0x0, -0x1(%rbp)
jmp 0x13205
jmp 0x13201
movq -0x20(%rbp), %rax
movzbl 0x11(%rax), %eax
cmpl $0x6, %eax
jne 0x131ff
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movl (%rax), %eax
movq -0x20(%rbp), %rcx
subl 0xc(%rcx), %eax
shll %eax
movq -0x20(%rbp), %rcx
movzbl 0x10(%rcx), %ecx
subl %ecx, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x13080
testb $0x1, %al
jne 0x131cc
movb $0x0, -0x1(%rbp)
jmp 0x13205
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x20(%rbp), %rcx
subl 0xc(%rcx), %eax
shll %eax
movq -0x20(%rbp), %rcx
movzbl 0x10(%rcx), %ecx
subl %ecx, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x13080
testb $0x1, %al
jne 0x131fd
movb $0x0, -0x1(%rbp)
jmp 0x13205
jmp 0x131ff
jmp 0x13201
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_msgpack.c
// Function: msgpack_parse_state_map_cmp_init
static bool
msgpack_parse_state_map_cmp_init(msgpack_parse_state *state, as_unpacker *pk1,
		as_unpacker *pk2)
{
	int64_t len1 = as_unpack_map_header_element_count(pk1);
	int64_t len2 = as_unpack_map_header_element_count(pk2);
	int64_t minlen = (len1 < len2) ? len1 : len2;

	if (minlen < 0) {
		return false;
	}

	state->len1 = (uint32_t)len1;
	state->len2 = (uint32_t)len2;
	state->index = 0;
	state->map_pair = 0;
	state->len = (uint32_t)minlen;
	state->type = AS_MAP;
	state->default_compare_type = msgpack_compare_int64_t(len1, len2);

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8c00
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x8c00
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jge 0x13252
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x1325a
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jge 0x1326f
movb $0x0, -0x1(%rbp)
jmp 0x132ca
movq -0x28(%rbp), %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x30(%rbp), %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x10(%rax)
movq -0x38(%rbp), %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movb $0x6, 0x11(%rax)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x130e0
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x14(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %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: compare_ext
static msgpack_compare_t
compare_ext(as_unpacker *pk1, as_unpacker *pk2)
{
	as_msgpack_ext ext1;
	as_msgpack_ext ext2;

	if (as_unpack_ext(pk1, &ext1) != 0) {
		return MSGPACK_COMPARE_ERROR;
	}

	if (as_unpack_ext(pk2, &ext2) != 0) {
		return MSGPACK_COMPARE_ERROR;
	}

	MSGPACK_COMPARE_RET_LESS_OR_GREATER(ext1.type, ext2.type);

	int64_t minsz = ext1.size < ext2.size ? ext1.size : ext2.size;
	int cmp = memcmp(ext1.data, ext2.data, minsz);

	MSGPACK_COMPARE_RET_LESS_OR_GREATER(cmp, 0);
	MSGPACK_COMPARE_RET_LESS_OR_GREATER(ext1.size, ext2.size);

	return MSGPACK_COMPARE_EQUAL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x8bb0
cmpl $0x0, %eax
je 0x1330e
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x133d3
movq -0x18(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x8bb0
cmpl $0x0, %eax
je 0x1332c
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x133d3
movzbl -0x20(%rbp), %eax
movzbl -0x38(%rbp), %ecx
cmpl %ecx, %eax
jge 0x13344
movl $0x0, -0x4(%rbp)
jmp 0x133d3
movzbl -0x20(%rbp), %eax
movzbl -0x38(%rbp), %ecx
cmpl %ecx, %eax
jle 0x13359
movl $0x2, -0x4(%rbp)
jmp 0x133d3
movl -0x28(%rbp), %eax
cmpl -0x40(%rbp), %eax
jae 0x13369
movl -0x28(%rbp), %eax
movl %eax, -0x58(%rbp)
jmp 0x1336f
movl -0x40(%rbp), %eax
movl %eax, -0x58(%rbp)
movl -0x58(%rbp), %eax
movl %eax, %eax
movq %rax, -0x50(%rbp)
movq -0x30(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x50(%rbp), %rdx
callq 0x8510
movl %eax, -0x54(%rbp)
cmpl $0x0, -0x54(%rbp)
jge 0x1339b
movl $0x0, -0x4(%rbp)
jmp 0x133d3
cmpl $0x0, -0x54(%rbp)
jle 0x133aa
movl $0x2, -0x4(%rbp)
jmp 0x133d3
movl -0x28(%rbp), %eax
cmpl -0x40(%rbp), %eax
jae 0x133bb
movl $0x0, -0x4(%rbp)
jmp 0x133d3
movl -0x28(%rbp), %eax
cmpl -0x40(%rbp), %eax
jbe 0x133cc
movl $0x2, -0x4(%rbp)
jmp 0x133d3
movl $0x1, -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_serializer.c
// Function: as_msgpack_serializer_serialize_presized
static int32_t as_msgpack_serializer_serialize_presized(as_serializer *s, const as_val *v, uint8_t *buf)
{
	as_packer packer = {
		.buffer = buf,
		// Prevent extra allocation.
		// buf should contain (pre-sized) space for the unpacking.
		.capacity = INT32_MAX,
		.offset = 0,
		.head = 0,
		.tail = 0,
	};

	if (as_pack_val(&packer, v) != 0) {
		return -1;
	}

	return packer.offset;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq $0x0, -0x40(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x28(%rbp)
movl $0x7fffffff, -0x24(%rbp) # imm = 0x7FFFFFFF
movq -0x18(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x8b90
cmpl $0x0, %eax
je 0x13705
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1370b
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %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_serializer.c
// Function: as_msgpack_serializer_deserialize
static int as_msgpack_serializer_deserialize(as_serializer *s, as_buffer *buff, as_val **v)
{
	as_unpacker unpacker = {
			.buffer = buff->data,
			.length = buff->size,
			.offset = 0,
	};

	return as_unpack_val(&unpacker, v);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x8760
addq $0x30, %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_serializer.c
// Function: as_msgpack_serializer_serialize_getsize
static uint32_t as_msgpack_serializer_serialize_getsize(as_serializer *s, const as_val *v)
{
	as_packer packer = {
			.buffer   = NULL,	// no buffer means the request is for size
			.capacity = 0,
			.offset   = 0,
			.head     = 0,
			.tail     = 0,
	};

	if (as_pack_val(&packer, v) != 0) {
		return 0;
	}

	return packer.offset;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x8480
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x8b90
cmpl $0x0, %eax
je 0x137ab
movl $0x0, -0x4(%rbp)
jmp 0x137b1
movl -0x20(%rbp), %eax
movl %eax, -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_orderedmap.c
// Function: as_orderedmap_init
as_orderedmap*
as_orderedmap_init(as_orderedmap* map, uint32_t capacity)
{
	if (map == NULL) {
		return NULL;
	}

	as_map_cons((as_map*)map, false, 1, &as_orderedmap_map_hooks);

	return as_orderedmap_cons(map, capacity);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x13820
movq $0x0, -0x8(%rbp)
jmp 0x13847
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x1, %edx
leaq 0x1c2e6(%rip), %rcx     # 0x2fb18
callq 0x8940
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x13860
movq %rax, -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_orderedmap.c
// Function: as_orderedmap_cons
static as_orderedmap*
as_orderedmap_cons(as_orderedmap* map, uint32_t capacity)
{
	map->count = 0;
	map->capacity = ((capacity + 8) / 8) * 8; // can add 1 without realloc

	size_t size = map->capacity * sizeof(map_entry);

	map->table = (map_entry*)cf_malloc(size);

	if (map->table == NULL) {
		return NULL;
	}

	map->hold_count = 0;
	map->hold_table = NULL;
	map->hold_locations = NULL;

	return map;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl $0x0, 0x18(%rax)
movl -0x14(%rbp), %ecx
addl $0x8, %ecx
shrl $0x3, %ecx
shll $0x3, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x1c(%rax)
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %eax
shlq $0x4, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x8090
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x138c5
movq $0x0, -0x8(%rbp)
jmp 0x138f0
movq -0x10(%rbp), %rax
movl $0x0, 0x28(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x38(%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_orderedmap.c
// Function: as_orderedmap_new
as_orderedmap*
as_orderedmap_new(uint32_t capacity)
{
	as_orderedmap* map = (as_orderedmap*)cf_malloc(sizeof(as_orderedmap));

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

	as_map_cons((as_map*)map, true, 1, &as_orderedmap_map_hooks);

	return as_orderedmap_cons(map, capacity);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movl $0x40, %edi
callq 0x8090
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x1392a
movq $0x0, -0x8(%rbp)
jmp 0x13951
movq -0x18(%rbp), %rdi
movl $0x1, %edx
leaq 0x1c1de(%rip), %rcx     # 0x2fb18
movl %edx, %esi
callq 0x8940
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x13860
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_orderedmap.c
// Function: as_orderedmap_release
bool
as_orderedmap_release(as_orderedmap* map)
{
	if (map == NULL) {
		return false;
	}

	as_orderedmap_clear(map);
	cf_free(map->table);

	if (map->hold_table != NULL) {
		cf_free(map->hold_table);
		cf_free(map->hold_locations);
	}

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x13979
movb $0x0, -0x1(%rbp)
jmp 0x139b8
movq -0x10(%rbp), %rdi
callq 0x81d0
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x8aa0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x139b4
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x8aa0
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x8aa0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
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_orderedmap.c
// Function: as_orderedmap_clear
int
as_orderedmap_clear(as_orderedmap* map)
{
	if (map == NULL) {
		return -1;
	}

	for (uint32_t ix = 0; ix < map->count; ix++) {
		as_val_destroy(map->table[ix].key);
		as_val_destroy(map->table[ix].value);
	}

	map->count = 0;

	for (uint32_t ix = 0; ix < map->hold_count; ix++) {
		as_val_destroy(map->hold_table[ix].key);
		as_val_destroy(map->hold_table[ix].value);
	}

	map->hold_count = 0;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x139ef
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x13ab2
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jae 0x13a42
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x14(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x8550
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x14(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0x8550
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x139f6
movq -0x10(%rbp), %rax
movl $0x0, 0x18(%rax)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jae 0x13aa0
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movl -0x18(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x8550
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movl -0x18(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0x8550
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x13a54
movq -0x10(%rbp), %rax
movl $0x0, 0x28(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_orderedmap.c
// Function: as_orderedmap_get
as_val*
as_orderedmap_get(const as_orderedmap* map, const as_val* key)
{
	if (map == NULL || ! is_valid_key_type(key)) {
		return NULL;
	}

	uint32_t ix;

	if (key_find(map->table, map->count, key, &ix, false)) {
		return (as_val*)map->table[ix].value;
	}

	if (key_find(map->hold_table, map->hold_count, key, &ix, false)) {
		return (as_val*)map->hold_table[ix].value;
	}

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x13b54
movq -0x18(%rbp), %rdi
callq 0x13c00
testb $0x1, %al
jne 0x13b61
movq $0x0, -0x8(%rbp)
jmp 0x13beb
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x18(%rax), %esi
movq -0x18(%rbp), %rdx
leaq -0x1c(%rbp), %rcx
xorl %r8d, %r8d
callq 0x13c80
testb $0x1, %al
jne 0x13b86
jmp 0x13ba2
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x1c(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x13beb
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x28(%rax), %esi
movq -0x18(%rbp), %rdx
leaq -0x1c(%rbp), %rcx
xorl %r8d, %r8d
callq 0x13c80
testb $0x1, %al
jne 0x13bc7
jmp 0x13be3
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movl -0x1c(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x13beb
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
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_orderedmap.c
// Function: is_valid_key_type
static bool
is_valid_key_type(const as_val* key)
{
	if (key == NULL) {
		return false;
	}

	switch (as_val_type(key)) {
	case AS_INTEGER:
	case AS_STRING:
		break;
	case AS_BYTES:
		return as_bytes_get_type((as_bytes*)key) == AS_BYTES_BLOB;
	default:
		return false;
	}

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x13c19
movb $0x0, -0x1(%rbp)
jmp 0x13c70
cmpq $0x0, -0x10(%rbp)
je 0x13c2d
movq -0x10(%rbp), %rax
movzbl 0x4(%rax), %eax
movl %eax, -0x14(%rbp)
jmp 0x13c34
xorl %eax, %eax
movl %eax, -0x14(%rbp)
jmp 0x13c34
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
addl $-0x3, %eax
subl $0x2, %eax
jb 0x13c4e
jmp 0x13c44
movl -0x18(%rbp), %eax
subl $0x9, %eax
je 0x13c50
jmp 0x13c66
jmp 0x13c6c
movq -0x10(%rbp), %rdi
callq 0x14750
cmpl $0x4, %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x13c70
movb $0x0, -0x1(%rbp)
jmp 0x13c70
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_orderedmap.c
// Function: key_find
static bool
key_find(const map_entry* table, uint32_t count, const as_val* key,
		uint32_t* ix_r, bool check_last_first)
{
	int64_t low = 0;
	int64_t high = (int64_t)count - 1;

	while (low <= high) {
		int64_t ix;

		// On the first iteration, probe at the end when 'check_last_first' is
		// set. Otherwise, fall back to binary search.
		if (check_last_first) {
			check_last_first = false;
			ix = high;
		}
		else {
			ix = (low + high) / 2;
		}

		msgpack_compare_t cmp = as_val_cmp(key, table[ix].key);

		if (cmp == MSGPACK_COMPARE_GREATER) {
			low = ix + 1;
		}
		else if (cmp == MSGPACK_COMPARE_LESS) {
			high = ix - 1;
		}
		else if (cmp == MSGPACK_COMPARE_EQUAL) {
			*ix_r = (uint32_t)ix;
			return true;
		}
		else {
			*ix_r = UINT32_MAX; // error
			return false;
		}
	}

	*ix_r = (uint32_t)low; // location to insert the key at

	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %r8b, %al
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
andb $0x1, %al
movb %al, -0x29(%rbp)
movq $0x0, -0x38(%rbp)
movl -0x14(%rbp), %eax
subq $0x1, %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
jg 0x13d5f
testb $0x1, -0x29(%rbp)
je 0x13cd4
movb $0x0, -0x29(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0x13cea
movq -0x38(%rbp), %rax
addq -0x40(%rbp), %rax
movl $0x2, %ecx
cqto
idivq %rcx
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq -0x48(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
callq 0x80a0
movl %eax, -0x4c(%rbp)
cmpl $0x2, -0x4c(%rbp)
jne 0x13d1c
movq -0x48(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x13d5a
cmpl $0x0, -0x4c(%rbp)
jne 0x13d30
movq -0x48(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x40(%rbp)
jmp 0x13d58
cmpl $0x1, -0x4c(%rbp)
jne 0x13d48
movq -0x48(%rbp), %rax
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x13d6f
movq -0x28(%rbp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movb $0x0, -0x1(%rbp)
jmp 0x13d6f
jmp 0x13d5a
jmp 0x13cb2
movq -0x38(%rbp), %rax
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_orderedmap.c
// Function: as_orderedmap_remove
int
as_orderedmap_remove(as_orderedmap* map, const as_val* key)
{
	if (map == NULL || ! is_valid_key_type(key)) {
		return -1;
	}

	if (! as_orderedmap_merge(map)) {
		return -1;
	}

	uint32_t ix;

	if (key_find(map->table, map->count, key, &ix, false)) {
		as_val_destroy(map->table[ix].key);
		as_val_destroy(map->table[ix].value);
		memmove(&map->table[ix], &map->table[ix + 1],
				sizeof(map_entry) * (map->count - (ix + 1)));
		map->count--;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x14384
movq -0x18(%rbp), %rdi
callq 0x13c00
testb $0x1, %al
jne 0x14390
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1445f
movq -0x10(%rbp), %rdi
callq 0x14190
testb $0x1, %al
jne 0x143a9
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1445f
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x18(%rax), %esi
movq -0x18(%rbp), %rdx
leaq -0x1c(%rbp), %rcx
xorl %r8d, %r8d
callq 0x13c80
testb $0x1, %al
jne 0x143d1
jmp 0x14458
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x1c(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x8550
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x1c(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0x8550
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movl -0x1c(%rbp), %eax
shlq $0x4, %rax
addq %rax, %rdi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
shlq $0x4, %rax
addq %rax, %rsi
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
subl %ecx, %eax
movl %eax, %eax
movl %eax, %edx
shlq $0x4, %rdx
callq 0x8970
movq -0x10(%rbp), %rax
movl 0x18(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x18(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_orderedmap.c
// Function: as_orderedmap_foreach
bool
as_orderedmap_foreach(const as_orderedmap* map,
		as_map_foreach_callback callback, void* udata)
{
	if (map == NULL) {
		return false;
	}

	if (! as_orderedmap_merge((as_orderedmap*)map)) {
		return false;
	}

	for (uint32_t ix = 0; ix < map->count; ix++) {
		if (! callback(map->table[ix].key, map->table[ix].value, udata)) {
			return false;
		}
	}

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x14491
movb $0x0, -0x1(%rbp)
jmp 0x14507
movq -0x10(%rbp), %rdi
callq 0x14190
testb $0x1, %al
jne 0x144a4
movb $0x0, -0x1(%rbp)
jmp 0x14507
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x18(%rcx), %eax
jae 0x14503
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
movl -0x24(%rbp), %edx
shlq $0x4, %rdx
addq %rdx, %rcx
movq (%rcx), %rdi
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
movl -0x24(%rbp), %edx
shlq $0x4, %rdx
addq %rdx, %rcx
movq 0x8(%rcx), %rsi
movq -0x20(%rbp), %rdx
callq *%rax
testb $0x1, %al
jne 0x144f6
movb $0x0, -0x1(%rbp)
jmp 0x14507
jmp 0x144f8
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x144ab
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
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_orderedmap.c
// Function: as_orderedmap_iterator_init
as_orderedmap_iterator*
as_orderedmap_iterator_init(as_orderedmap_iterator* it,
		const as_orderedmap* map)
{
	if (map != NULL && ! as_orderedmap_merge((as_orderedmap*)map)) {
		return NULL;
	}

	if (it == NULL) {
		return NULL;
	}

	as_iterator_init((as_iterator*)it, false, NULL,
			&as_orderedmap_iterator_hooks);
	it->ix = 0;
	it->map = map;

	return it;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1454e
movq -0x18(%rbp), %rdi
callq 0x14190
testb $0x1, %al
jne 0x1454e
movq $0x0, -0x8(%rbp)
jmp 0x14594
cmpq $0x0, -0x10(%rbp)
jne 0x1455f
movq $0x0, -0x8(%rbp)
jmp 0x14594
movq -0x10(%rbp), %rdi
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x1b600(%rip), %rcx     # 0x2fb70
callq 0x8ab0
movq -0x10(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_orderedmap.c
// Function: as_orderedmap_iterator_new
as_orderedmap_iterator*
as_orderedmap_iterator_new(const as_orderedmap* map)
{
	if (map != NULL && ! as_orderedmap_merge((as_orderedmap*)map)) {
		return NULL;
	}

	as_orderedmap_iterator* it =
			(as_orderedmap_iterator*)cf_malloc(sizeof(as_orderedmap_iterator));

	if (it == NULL) {
		return NULL;
	}

	as_iterator_init((as_iterator*)it, true, NULL,
			&as_orderedmap_iterator_hooks);
	it->ix = 0;
	it->map = map;

	return it;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x145ca
movq -0x10(%rbp), %rdi
callq 0x14190
testb $0x1, %al
jne 0x145ca
movq $0x0, -0x8(%rbp)
jmp 0x14621
movl $0x40, %edi
callq 0x8090
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x145e9
movq $0x0, -0x8(%rbp)
jmp 0x14621
movq -0x18(%rbp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
leaq 0x1b573(%rip), %rcx     # 0x2fb70
callq 0x8ab0
movq -0x18(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%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_orderedmap.c
// Function: as_orderedmap_iterator_next
const as_val*
as_orderedmap_iterator_next(as_orderedmap_iterator* it)
{
	if (it->ix >= it->map->count) {
		return NULL;
	}

	as_pair_init(&it->pair, it->map->table[it->ix].key,
			it->map->table[it->ix].value);
	it->ix++;

	return (as_val*)&it->pair;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpl 0x18(%rcx), %eax
jb 0x146da
movq $0x0, -0x8(%rbp)
jmp 0x1473b
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x20(%rcx), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x20(%rcx), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdx
callq 0x8410
movq -0x10(%rbp), %rax
movl 0x20(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x20(%rax)
movq -0x10(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
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_pair.c
// Function: as_pair_init
as_pair * as_pair_init(as_pair * pair, as_val * _1, as_val * _2)
{
	if ( !pair ) return pair;

	as_val_init((as_val *) pair, AS_PAIR, false);
	pair->_1 = _1;
	pair->_2 = _2;
	return pair;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x149f5
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x14a25
movq -0x10(%rbp), %rdi
movl $0x8, %esi
xorl %edx, %edx
callq 0x14a30
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 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
nop
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_pair.c
// Function: as_pair_new
as_pair * as_pair_new(as_val * _1, as_val * _2)
{
	as_pair * pair = (as_pair *) cf_malloc(sizeof(as_pair));
	if ( !pair ) return pair;

	as_val_init((as_val *) pair, AS_PAIR, true);
	pair->_1 = _1;
	pair->_2 = _2;
	return pair;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x18, %edi
callq 0x8090
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x14a9f
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x14ad2
movq -0x20(%rbp), %rdi
movl $0x8, %esi
movl $0x1, %edx
callq 0x14a30
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_pair.c
// Function: as_pair_val_tostring
char *as_pair_val_tostring(const as_val * v)
{
	as_pair * p = as_pair_fromval(v);
	if ( p == NULL ) return NULL;

	char * a = as_val_tostring(p->_1);
	size_t al = strlen(a);
	char * b = as_val_tostring(p->_2);
	size_t bl = strlen(b);
	
	size_t l = al + bl + 5;
	char * str = (char *) cf_malloc(sizeof(char) * l);
	if (!str) return str;

	strcpy(str, "(");
	strcpy(str+1, a);
	strcpy(str+1+al,", ");
	strcpy(str+1+al+2, b);
	strcpy(str+1+al+2+bl,")");
	*(str+1+al+2+bl+1) = '\0';
	
	cf_free(a);
	cf_free(b);

	return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x14c90
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x14b6d
movq $0x0, -0x8(%rbp)
jmp 0x14c7f
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x82f0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x82b0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x82f0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x82b0
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
addq -0x38(%rbp), %rax
addq $0x5, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
shlq $0x0, %rdi
callq 0x8090
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0x14bde
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x14c7f
movq -0x48(%rbp), %rdi
leaq 0x12773(%rip), %rsi     # 0x2735c
callq 0x81b0
movq -0x48(%rbp), %rdi
addq $0x1, %rdi
movq -0x20(%rbp), %rsi
callq 0x81b0
movq -0x48(%rbp), %rdi
addq $0x1, %rdi
addq -0x28(%rbp), %rdi
leaq 0x1274c(%rip), %rsi     # 0x2735e
callq 0x81b0
movq -0x48(%rbp), %rdi
addq $0x1, %rdi
addq -0x28(%rbp), %rdi
addq $0x2, %rdi
movq -0x30(%rbp), %rsi
callq 0x81b0
movq -0x48(%rbp), %rdi
addq $0x1, %rdi
addq -0x28(%rbp), %rdi
addq $0x2, %rdi
addq -0x38(%rbp), %rdi
leaq 0x12940(%rip), %rsi     # 0x2758b
callq 0x81b0
movq -0x48(%rbp), %rax
addq $0x1, %rax
addq -0x28(%rbp), %rax
movq -0x38(%rbp), %rcx
movb $0x0, 0x3(%rax,%rcx)
movq -0x20(%rbp), %rdi
callq 0x8aa0
movq -0x30(%rbp), %rdi
callq 0x8aa0
movq -0x48(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_password.c
// Function: as_password_prompt_hash
bool
as_password_prompt_hash(const char* password, char* hash)
{
	char pass[AS_PASSWORD_HASH_SIZE];
	
	if (password && *password) {
		as_strncpy(pass, password, sizeof(pass));
	}
	else {
		as_password_prompt(pass, sizeof(pass));
	}
	
	return as_password_get_constant_hash(pass, hash);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x14e57
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x14e57
leaq -0x50(%rbp), %rdi
movq -0x8(%rbp), %rsi
movl $0x40, %edx
callq 0x81e0
jmp 0x14e65
leaq -0x50(%rbp), %rdi
movl $0x40, %esi
callq 0x14e80
leaq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x8af0
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_password.c
// Function: as_password_prompt
static void
as_password_prompt(char* password, int size)
{
	// Turn off echo.
	as_set_echo(false);

	// Prompt for password.
	printf("Enter Password: ");
	fflush(stdout);

	// Read password until newline.
	char* s = fgets(password, size, stdin);

	if (s) {
		int len = (int)strlen(password);

		if (password[len - 1] == '\n') {
			password[--len] = 0;
		}
	}
	else {
		password[0] = 0;
	}

	// Restore echo.
	as_set_echo(true);
	printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
xorl %edi, %edi
callq 0x14f90
leaq 0x124e7(%rip), %rdi     # 0x27384
movb $0x0, %al
callq 0x8310
movq 0x1b0dd(%rip), %rax     # 0x2ff88
movq (%rax), %rdi
callq 0x87a0
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movq 0x1b0d7(%rip), %rax     # 0x2ff98
movq (%rax), %rdx
callq 0x8530
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x14f0c
movq -0x8(%rbp), %rdi
callq 0x82b0
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0x14f0a
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $-0x1, %ecx
movl %ecx, -0x1c(%rbp)
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
jmp 0x14f13
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
movl $0x1, %edi
callq 0x14f90
leaq 0x12471(%rip), %rdi     # 0x27395
movb $0x0, %al
callq 0x8310
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)