LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/citrusleaf/cf_b64.c
// Function: cf_b64_validate_and_decode_in_place
bool
cf_b64_validate_and_decode_in_place(uint8_t* in_out, uint32_t in_len,
		uint32_t* out_size)
{
	if (! is_valid_encoded((const char*)in_out, in_len)) {
		return false;
	}

	cf_b64_decode_in_place(in_out, in_len, out_size);

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x20410
testb $0x1, %al
jne 0x20539
movb $0x0, -0x1(%rbp)
jmp 0x2054d
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x8200
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/citrusleaf/cf_crypto.c
// Function: cf_SHA1Reset
static int
cf_SHA1Reset(cf_SHA1Context *context)
{
	if (! context) {
		return cf_shaNull;
	}

	context->Length_Low = 0;
	context->Length_High = 0;
	context->Message_Block_Index = 0;

	context->Intermediate_Hash[0] = 0x67452301;
	context->Intermediate_Hash[1] = 0xEFCDAB89;
	context->Intermediate_Hash[2] = 0x98BADCFE;
	context->Intermediate_Hash[3] = 0x10325476;
	context->Intermediate_Hash[4] = 0xC3D2E1F0;

	context->Computed = 0;
	context->Corrupted = 0;

	return cf_shaSuccess;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x205d8
movl $0x1, -0x4(%rbp)
jmp 0x2064b
movq -0x10(%rbp), %rax
movl $0x0, 0x14(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
movw $0x0, 0x1c(%rax)
movq -0x10(%rbp), %rax
movl $0x67452301, (%rax)     # imm = 0x67452301
movq -0x10(%rbp), %rax
movl $0xefcdab89, 0x4(%rax)  # imm = 0xEFCDAB89
movq -0x10(%rbp), %rax
movl $0x98badcfe, 0x8(%rax)  # imm = 0x98BADCFE
movq -0x10(%rbp), %rax
movl $0x10325476, 0xc(%rax)  # imm = 0x10325476
movq -0x10(%rbp), %rax
movl $0xc3d2e1f0, 0x10(%rax) # imm = 0xC3D2E1F0
movq -0x10(%rbp), %rax
movl $0x0, 0x60(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x64(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/citrusleaf/cf_crypto.c
// Function: cf_SHA1Input
static int
cf_SHA1Input(cf_SHA1Context *context, const uint8_t *message_array,
		unsigned length)
{
	if (! length) {
		return cf_shaSuccess;
	}

	if (! context || ! message_array) {
		return cf_shaNull;
	}

	if (context->Computed) {
		context->Corrupted = cf_shaStateError;
		return cf_shaStateError;
	}

	if (context->Corrupted) {
		return context->Corrupted;
	}

	while(length-- && ! context->Corrupted) {
		context->Message_Block[context->Message_Block_Index++] =
				(*message_array & 0xFF);

		context->Length_Low += 8;

		if (context->Length_Low == 0) {
			context->Length_High++;

			if (context->Length_High == 0) {
				/* Message is too long */
				context->Corrupted = 1;
			}
		}

		if (context->Message_Block_Index == 64) {
			cf_SHA1ProcessMessageBlock(context);
		}

		message_array++;
	}

	return cf_shaSuccess;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x20675
movl $0x0, -0x4(%rbp)
jmp 0x20792
cmpq $0x0, -0x10(%rbp)
je 0x20683
cmpq $0x0, -0x18(%rbp)
jne 0x2068f
movl $0x1, -0x4(%rbp)
jmp 0x20792
movq -0x10(%rbp), %rax
cmpl $0x0, 0x60(%rax)
je 0x206b0
movq -0x10(%rbp), %rax
movl $0x3, 0x64(%rax)
movl $0x3, -0x4(%rbp)
jmp 0x20792
movq -0x10(%rbp), %rax
cmpl $0x0, 0x64(%rax)
je 0x206c9
movq -0x10(%rbp), %rax
movl 0x64(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x20792
jmp 0x206cb
movl -0x1c(%rbp), %ecx
movl %ecx, %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x1d(%rbp)
je 0x206f0
movq -0x10(%rbp), %rax
cmpl $0x0, 0x64(%rax)
setne %al
xorb $-0x1, %al
movb %al, -0x1d(%rbp)
movb -0x1d(%rbp), %al
testb $0x1, %al
jne 0x206fc
jmp 0x2078b
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
andl $0xff, %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rsi
movw 0x1c(%rsi), %cx
movw %cx, %di
addw $0x1, %di
movw %di, 0x1c(%rsi)
movswq %cx, %rcx
movb %dl, 0x1e(%rax,%rcx)
movq -0x10(%rbp), %rax
movl 0x14(%rax), %ecx
addl $0x8, %ecx
movl %ecx, 0x14(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x14(%rax)
jne 0x20764
movq -0x10(%rbp), %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jne 0x20762
movq -0x10(%rbp), %rax
movl $0x1, 0x64(%rax)
jmp 0x20764
movq -0x10(%rbp), %rax
movswl 0x1c(%rax), %eax
cmpl $0x40, %eax
jne 0x2077a
movq -0x10(%rbp), %rdi
callq 0x23d70
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x206cb
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/citrusleaf/cf_crypto.c
// Function: cf_SHA1Result
static int
cf_SHA1Result( cf_SHA1Context *context, uint8_t Message_Digest[CF_SHA1HashSize])
{
	int i;

	if (! context || ! Message_Digest) {
		return cf_shaNull;
	}

	if (context->Corrupted) {
		return context->Corrupted;
	}

	if (! context->Computed) {
		cf_SHA1PadMessage(context);

		for (i = 0; i < 64; ++i) {
			context->Message_Block[i] = 0;
		}

		context->Length_Low = 0;
		context->Length_High = 0;
		context->Computed = 1;
	}

	for (i = 0; i < CF_SHA1HashSize; ++i) {
		Message_Digest[i] =
				context->Intermediate_Hash[i >> 2] >> 8 * (3 - (i & 0x03));
	}

	return cf_shaSuccess;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x207be
cmpq $0x0, -0x18(%rbp)
jne 0x207ca
movl $0x1, -0x4(%rbp)
jmp 0x2088a
movq -0x10(%rbp), %rax
cmpl $0x0, 0x64(%rax)
je 0x207e3
movq -0x10(%rbp), %rax
movl 0x64(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x2088a
movq -0x10(%rbp), %rax
cmpl $0x0, 0x60(%rax)
jne 0x2083c
movq -0x10(%rbp), %rdi
callq 0x24260
movl $0x0, -0x1c(%rbp)
cmpl $0x40, -0x1c(%rbp)
jge 0x2081b
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb $0x0, 0x1e(%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x207fd
movq -0x10(%rbp), %rax
movl $0x0, 0x14(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
movl $0x1, 0x60(%rax)
movl $0x0, -0x1c(%rbp)
cmpl $0x14, -0x1c(%rbp)
jge 0x20883
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
sarl $0x2, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl -0x1c(%rbp), %edx
andl $0x3, %edx
movl $0x3, %ecx
subl %edx, %ecx
shll $0x3, %ecx
shrl %cl, %eax
movb %al, %dl
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x20843
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/citrusleaf/cf_crypto.c
// Function: cf_RIPEMD160
int
cf_RIPEMD160(const unsigned char* input, size_t ilen, unsigned char* output)
{
	int ret;
	cf_RIPEMD160_CTX ctx;

	if ((ret = cf_RIPEMD160_Init(&ctx)) != 0) {
		return ret;
	}

	if ((ret = cf_RIPEMD160_Update(&ctx, input, ilen)) != 0) {
		return ret;
	}

	if ((ret = cf_RIPEMD160_Final(output, &ctx)) != 0) {
		return ret;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x8980
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
je 0x208d0
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x20915
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x80(%rbp), %rdi
callq 0x84d0
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
je 0x208f1
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x20915
movq -0x20(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x8670
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
je 0x2090e
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x20915
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/citrusleaf/cf_crypto.c
// Function: cf_RIPEMD160_Init
int
cf_RIPEMD160_Init(cf_RIPEMD160_CTX* ctx)
{
	memset(ctx, 0, sizeof(cf_RIPEMD160_CTX));

	ctx->total[0] = 0;
	ctx->total[1] = 0;

	ctx->state[0] = 0x67452301;
	ctx->state[1] = 0xEFCDAB89;
	ctx->state[2] = 0x98BADCFE;
	ctx->state[3] = 0x10325476;
	ctx->state[4] = 0xC3D2E1F0;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x5c, %edx
callq 0x8480
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
movl $0x67452301, 0x8(%rax)  # imm = 0x67452301
movq -0x8(%rbp), %rax
movl $0xefcdab89, 0xc(%rax)  # imm = 0xEFCDAB89
movq -0x8(%rbp), %rax
movl $0x98badcfe, 0x10(%rax) # imm = 0x98BADCFE
movq -0x8(%rbp), %rax
movl $0x10325476, 0x14(%rax) # imm = 0x10325476
movq -0x8(%rbp), %rax
movl $0xc3d2e1f0, 0x18(%rax) # imm = 0xC3D2E1F0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/citrusleaf/cf_crypto.c
// Function: cf_RIPEMD160_Update
int
cf_RIPEMD160_Update(cf_RIPEMD160_CTX* ctx, const void* v_input, size_t ilen)
{
	const unsigned char* input = (const unsigned char*)v_input;

	int ret;

	if (ilen == 0) {
		return 0;
	}

	size_t left = ctx->total[0] & 0x3F;
	uint32_t fill = (uint32_t)(64 - left);

	ctx->total[0] += (uint32_t) ilen;
	ctx->total[0] &= 0xFFFFFFFF;

	if (ctx->total[0] < (uint32_t) ilen) {
		ctx->total[1]++;
	}

	if (left && ilen >= fill) {
		memcpy((void*)(ctx->buffer + left), input, fill);

		if ((ret = cf_ripemd160_process(ctx, ctx->buffer)) != 0) {
			return ret;
		}

		input += fill;
		ilen  -= fill;
		left = 0;
	}

	while (ilen >= 64) {
		if ((ret = cf_ripemd160_process(ctx, input)) != 0) {
			return ret;
		}

		input += 64;
		ilen  -= 64;
	}

	if (ilen > 0) {
		memcpy((void*)(ctx->buffer + left), input, ilen);
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x209cf
movl $0x0, -0x4(%rbp)
jmp 0x20afe
movq -0x10(%rbp), %rax
movl (%rax), %eax
andl $0x3f, %eax
movl %eax, %eax
movq %rax, -0x38(%rbp)
movl $0x40, %eax
subq -0x38(%rbp), %rax
movl %eax, -0x3c(%rbp)
movq -0x20(%rbp), %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
andl $-0x1, %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq -0x20(%rbp), %rcx
cmpl %ecx, %eax
jae 0x20a1e
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
cmpq $0x0, -0x38(%rbp)
je 0x20a97
movq -0x20(%rbp), %rax
movl -0x3c(%rbp), %ecx
cmpq %rcx, %rax
jb 0x20a97
movq -0x10(%rbp), %rdi
addq $0x1c, %rdi
addq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl -0x3c(%rbp), %eax
movl %eax, %edx
callq 0x86b0
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x1c, %rsi
callq 0x20e10
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
je 0x20a6f
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x20afe
movl -0x3c(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movl -0x3c(%rbp), %eax
movl %eax, %ecx
movq -0x20(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x38(%rbp)
jmp 0x20a99
cmpq $0x40, -0x20(%rbp)
jb 0x20ad7
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x20e10
movl %eax, -0x2c(%rbp)
cmpl $0x0, %eax
je 0x20abd
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x20afe
movq -0x28(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
subq $0x40, %rax
movq %rax, -0x20(%rbp)
jmp 0x20a99
cmpq $0x0, -0x20(%rbp)
jbe 0x20af7
movq -0x10(%rbp), %rdi
addq $0x1c, %rdi
addq -0x38(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x86b0
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/citrusleaf/cf_ll.c
// Function: cf_ll_prepend_lockfree
void cf_ll_prepend_lockfree(cf_ll * ll, cf_ll_element * e) {
	// empty list
	if (ll->head == 0) { 
		ll->head = e;
		ll->tail = e;
		e->next = 0;
		e->prev = 0;
	}

	// at least one element - add to head
	else {
		e->next = ll->head;
		e->prev = 0;
		
		ll->head->prev = e;
		ll->head = e;
	}
	
	ll->sz++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x24446
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
jmp 0x2447a
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/citrusleaf/cf_ll.c
// Function: cf_ll_size
uint32_t cf_ll_size(cf_ll *ll) {
	LL_LOCK(ll);
	uint32_t sz = ll->sz;
	LL_UNLOCK(ll);
	return(sz);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
testb $0x1, 0x1c(%rax)
je 0x24b63
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
callq 0x8c60
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
testb $0x1, 0x1c(%rax)
je 0x24b84
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
callq 0x8740
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/citrusleaf/cf_ll.c
// Function: cf_ll_search_lockfree
cf_ll_element * cf_ll_search_lockfree(cf_ll *ll, cf_ll_element *e, bool forward, cf_ll_reduce_fn fn) {
	if (ll->head == NULL) {
		return NULL;
	}
	int rv = 0;
	cf_ll_element *cur = forward ? ll->head : ll->tail;
	
	while (cur) {
		rv = (*fn) (cur, (void*)e);

		if (rv == CF_LL_REDUCE_MATCHED) {
			return cur;
		}
		else if (rv == CF_LL_REDUCE_NOT_MATCHED) {
			cur = forward ? cur->next : cur->prev;
			rv = 0;
		}
		else {
			return NULL;
		}
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x24bc2
movq $0x0, -0x8(%rbp)
jmp 0x24c64
movl $0x0, -0x2c(%rbp)
testb $0x1, -0x19(%rbp)
je 0x24bdc
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
jmp 0x24be8
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x24c5c
movq -0x28(%rbp), %rax
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
movl %eax, -0x2c(%rbp)
cmpl $0x3, -0x2c(%rbp)
jne 0x24c18
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x24c64
cmpl $0x4, -0x2c(%rbp)
jne 0x24c4e
testb $0x1, -0x19(%rbp)
je 0x24c31
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
jmp 0x24c3d
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x2c(%rbp)
jmp 0x24c58
movq $0x0, -0x8(%rbp)
jmp 0x24c64
jmp 0x24c5a
jmp 0x24bf0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/citrusleaf/cf_ll.c
// Function: cf_ll_search
cf_ll_element * cf_ll_search(cf_ll *ll, cf_ll_element *e, bool forward, cf_ll_reduce_fn fn) 
{
	LL_LOCK(ll);
	
	cf_ll_element * ele = NULL;
	ele = cf_ll_search_lockfree(ll, e, forward, fn);

	LL_UNLOCK(ll);

	return ele;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
testb $0x1, 0x1c(%rax)
je 0x24ca2
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
callq 0x8c60
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movb -0x11(%rbp), %al
movq -0x20(%rbp), %rcx
andb $0x1, %al
movzbl %al, %edx
callq 0x8660
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
testb $0x1, 0x1c(%rax)
je 0x24cde
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
callq 0x8740
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/citrusleaf/cf_ll.c
// Function: cf_ll_getIterator
cf_ll_iterator * cf_ll_getIterator(cf_ll * ll, bool forward)
{
	cf_ll_iterator *iter = NULL;
	iter = (cf_ll_iterator *)cf_malloc(sizeof(cf_ll_iterator));
	if (iter == NULL) {
		return NULL;
	}
	iter->forward = forward;
	iter->next = iter->forward ? ll->head : ll->tail;
	return iter;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x10, %edi
callq 0x8090
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x24d2b
movq $0x0, -0x8(%rbp)
jmp 0x24d6e
movb -0x11(%rbp), %cl
movq -0x20(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x8(%rax)
movq -0x20(%rbp), %rax
testb $0x1, 0x8(%rax)
je 0x24d4f
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x24d5b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/citrusleaf/cf_ll.c
// Function: cf_ll_getNext
cf_ll_element * cf_ll_getNext(cf_ll_iterator *iter)
{
	if (!iter) return NULL;
	cf_ll_element * ele = iter->next;
	if (ele != NULL) {
		iter->next = iter->forward ? ele->next : ele->prev;
	}
	return ele;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x24dc9
movq $0x0, -0x8(%rbp)
jmp 0x24e11
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x24e09
movq -0x10(%rbp), %rax
testb $0x1, 0x8(%rax)
je 0x24df2
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x24dfe
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/citrusleaf/cf_ll.c
// Function: cf_ll_index
cf_ll_element *cf_ll_index(cf_ll *ll, int index)
{
	cf_ll_element *ele = NULL;
	if (index < 0) {
		index = (-index) - 1;
		ele = ll->tail;
		while (index-- && ele) {
			ele = ele->prev;
		}
	}
	else {
		ele = ll->head;
		while (index-- && ele) {
			ele = ele->next;
		}
	}
	return ele;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq $0x0, -0x18(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x24e89
xorl %eax, %eax
subl -0xc(%rbp), %eax
subl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x19(%rbp)
je 0x24e70
cmpq $0x0, -0x18(%rbp)
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x24e79
jmp 0x24e87
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x24e50
jmp 0x24ecc
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x1a(%rbp)
je 0x24eb4
cmpq $0x0, -0x18(%rbp)
setne %al
movb %al, -0x1a(%rbp)
movb -0x1a(%rbp), %al
testb $0x1, %al
jne 0x24ebd
jmp 0x24eca
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x24e94
jmp 0x24ecc
movq -0x18(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/citrusleaf/cf_ll.c
// Function: cf_ll_init
int  cf_ll_init(cf_ll *ll, cf_ll_destructor destroy_fn, bool uselock) {
	ll->head = 0;
	ll->tail = 0;
	ll->destroy_fn = destroy_fn;
	ll->sz = 0;
	ll->uselock = uselock;
	if (uselock) {
		pthread_mutex_init(&ll->LOCK, 0);
	}
	return(0);	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x18(%rax)
movb -0x11(%rbp), %cl
movq -0x8(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x1c(%rax)
testb $0x1, -0x11(%rbp)
je 0x24f49
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x8c20
xorl %eax, %eax
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/citrusleaf/cf_queue.c
// Function: cf_queue_init
bool
cf_queue_init(cf_queue *q, size_t element_sz, uint32_t capacity,
		bool threadsafe)
{
	q->alloc_sz = capacity;
	q->write_offset = q->read_offset = 0;
	q->n_eles = 0;
	q->element_sz = element_sz;
	q->threadsafe = threadsafe;
	q->free_struct = false;

	q->elements = (uint8_t*)cf_malloc(capacity * element_sz);

	if (! q->elements) {
		return false;
	}

	if (! q->threadsafe) {
		return true;
	}

	if (0 != pthread_mutex_init(&q->LOCK, NULL)) {
		cf_free(q->elements);
		return false;
	}

	if (0 != pthread_cond_init(&q->CV, NULL)) {
		pthread_mutex_destroy(&q->LOCK);
		cf_free(q->elements);
		return false;
	}

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
andb $0x1, %al
movb %al, -0x1d(%rbp)
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movb -0x1d(%rbp), %cl
movq -0x10(%rbp), %rax
andb $0x1, %cl
movb %cl, (%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x1(%rax)
movl -0x1c(%rbp), %eax
movl %eax, %edi
imulq -0x18(%rbp), %rdi
callq 0x8090
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x78(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x78(%rax)
jne 0x24ff0
movb $0x0, -0x1(%rbp)
jmp 0x25068
movq -0x10(%rbp), %rax
testb $0x1, (%rax)
jne 0x24fff
movb $0x1, -0x1(%rbp)
jmp 0x25068
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x8c20
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x2502b
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rdi
callq 0x8aa0
movb $0x0, -0x1(%rbp)
jmp 0x25068
movq -0x10(%rbp), %rdi
addq $0x48, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x86f0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x25064
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x8350
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rdi
callq 0x8aa0
movb $0x0, -0x1(%rbp)
jmp 0x25068
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
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/citrusleaf/cf_queue.c
// Function: cf_queue_create
cf_queue *
cf_queue_create(size_t element_sz, bool threadsafe)
{
	cf_queue *q = (cf_queue*)cf_malloc(sizeof(cf_queue));

	if (! q) {
		return NULL;
	}

	if (! cf_queue_init(q, element_sz, CF_QUEUE_ALLOCSZ, threadsafe)) {
		cf_free(q);
		return NULL;
	}

	q->free_struct = true;

	return q;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movl $0x80, %edi
callq 0x8090
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x250b3
movq $0x0, -0x8(%rbp)
jmp 0x250f4
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movb -0x11(%rbp), %al
movl $0x40, %edx
andb $0x1, %al
movzbl %al, %ecx
callq 0x8c70
testb $0x1, %al
jne 0x250e4
movq -0x20(%rbp), %rdi
callq 0x8aa0
movq $0x0, -0x8(%rbp)
jmp 0x250f4
movq -0x20(%rbp), %rax
movb $0x1, 0x1(%rax)
movq -0x20(%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/citrusleaf/cf_queue.c
// Function: cf_queue_destroy
void
cf_queue_destroy(cf_queue *q)
{
	if (q->threadsafe) {
		pthread_cond_destroy(&q->CV);
		pthread_mutex_destroy(&q->LOCK);
	}

	cf_free(q->elements);

	if (q->free_struct) {
		memset(q, 0, sizeof(cf_queue));
		cf_free(q);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
testb $0x1, (%rax)
je 0x2512f
movq -0x8(%rbp), %rdi
addq $0x48, %rdi
callq 0x8a60
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
callq 0x8350
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rdi
callq 0x8aa0
movq -0x8(%rbp), %rax
testb $0x1, 0x1(%rax)
je 0x2515f
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0x8480
movq -0x8(%rbp), %rdi
callq 0x8aa0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/citrusleaf/cf_queue.c
// Function: cf_queue_push
int
cf_queue_push(cf_queue *q, const void *ptr)
{
	cf_queue_lock(q);

	// Check queue length.
	if (CF_Q_SZ(q) == q->alloc_sz) {
		if (0 != cf_queue_resize(q, q->alloc_sz * 2)) {
			cf_queue_unlock(q);
			return CF_QUEUE_ERR;
		}
	}

	// TODO - if queues are power of 2, this can be a shift.
	memcpy(CF_Q_ELEM_PTR(q, q->write_offset), ptr, q->element_sz);
	q->write_offset++;
	q->n_eles++;
	cf_queue_unwrap(q);

	if (q->threadsafe) {
		pthread_cond_signal(&q->CV);
	}

	cf_queue_unlock(q);
	return CF_QUEUE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x25260
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x10(%rbp), %rcx
subl 0x8(%rcx), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jne 0x251d1
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %esi
shll %esi
callq 0x25290
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x251cf
movq -0x10(%rbp), %rdi
callq 0x25420
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x25251
jmp 0x251d1
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x10(%rbp), %rcx
xorl %edx, %edx
divl 0x4(%rcx)
movl %edx, %eax
movq -0x10(%rbp), %rcx
imulq 0x18(%rcx), %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdx
callq 0x86b0
movq -0x10(%rbp), %rax
movl 0xc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rdi
callq 0x25450
movq -0x10(%rbp), %rax
testb $0x1, (%rax)
je 0x25241
movq -0x10(%rbp), %rdi
addq $0x48, %rdi
callq 0x8580
movq -0x10(%rbp), %rdi
callq 0x25420
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/citrusleaf/cf_queue.c
// Function: cf_queue_unwrap
static inline void
cf_queue_unwrap(cf_queue *q)
{
	if ((q->write_offset & 0xC0000000) != 0) {
		int sz = CF_Q_SZ(q);

		q->read_offset %= q->alloc_sz;
		q->write_offset = q->read_offset + sz;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
andl $0xc0000000, %eax       # imm = 0xC0000000
cmpl $0x0, %eax
je 0x254a8
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x8(%rbp), %rcx
subl 0x8(%rcx), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl 0x8(%rax), %eax
xorl %edx, %edx
divl %ecx
movq -0x18(%rbp), %rax
movl %edx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
addl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/citrusleaf/cf_queue.c
// Function: cf_queue_push_limit
bool
cf_queue_push_limit(cf_queue *q, const void *ptr, uint32_t limit)
{
	cf_queue_lock(q);

	uint32_t size = CF_Q_SZ(q);

	if (size >= limit) {
		cf_queue_unlock(q);
		return false;
	}

	if (size == q->alloc_sz) {
		if (0 != cf_queue_resize(q, q->alloc_sz * 2)) {
			cf_queue_unlock(q);
			return false;
		}
	}

	// TODO - if queues are power of 2, this can be a shift.
	memcpy(CF_Q_ELEM_PTR(q, q->write_offset), ptr, q->element_sz);
	q->write_offset++;
	q->n_eles++;
	cf_queue_unwrap(q);

	if (q->threadsafe) {
		pthread_cond_signal(&q->CV);
	}

	cf_queue_unlock(q);
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x25260
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x10(%rbp), %rcx
subl 0x8(%rcx), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jb 0x254f7
movq -0x10(%rbp), %rdi
callq 0x25420
movb $0x0, -0x1(%rbp)
jmp 0x255ab
movl -0x20(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jne 0x2552e
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %esi
shll %esi
callq 0x25290
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x2552c
movq -0x10(%rbp), %rdi
callq 0x25420
movb $0x0, -0x1(%rbp)
jmp 0x255ab
jmp 0x2552e
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x10(%rbp), %rcx
xorl %edx, %edx
divl 0x4(%rcx)
movl %edx, %eax
movq -0x10(%rbp), %rcx
imulq 0x18(%rcx), %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdx
callq 0x86b0
movq -0x10(%rbp), %rax
movl 0xc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rdi
callq 0x25450
movq -0x10(%rbp), %rax
testb $0x1, (%rax)
je 0x2559e
movq -0x10(%rbp), %rdi
addq $0x48, %rdi
callq 0x8580
movq -0x10(%rbp), %rdi
callq 0x25420
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/citrusleaf/cf_queue.c
// Function: cf_queue_push_unique
int
cf_queue_push_unique(cf_queue *q, const void *ptr)
{
	cf_queue_lock(q);

	// Check if element is already queued.
	if (CF_Q_SZ(q) != 0) {
		for (uint32_t i = q->read_offset; i < q->write_offset; i++) {
			if (0 == memcmp(CF_Q_ELEM_PTR(q, i), ptr, q->element_sz)) {
				// Element is already queued.
				// TODO - return 0 if all callers regard this as normal?
				cf_queue_unlock(q);
				return -2;
			}
		}
	}

	if (CF_Q_SZ(q) == q->alloc_sz) {
		if (0 != cf_queue_resize(q, q->alloc_sz * 2)) {
			cf_queue_unlock(q);
			return CF_QUEUE_ERR;
		}
	}

	// TODO - if queues are power of 2, this can be a shift.
	memcpy(CF_Q_ELEM_PTR(q, q->write_offset), ptr, q->element_sz);
	q->write_offset++;
	q->n_eles++;
	cf_queue_unwrap(q);

	if (q->threadsafe) {
		pthread_cond_signal(&q->CV);
	}

	cf_queue_unlock(q);
	return CF_QUEUE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x25260
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x10(%rbp), %rcx
subl 0x8(%rcx), %eax
cmpl $0x0, %eax
je 0x25a31
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jae 0x25a2f
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rdi
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
xorl %edx, %edx
divl 0x4(%rcx)
movl %edx, %eax
movq -0x10(%rbp), %rcx
imulq 0x18(%rcx), %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdx
callq 0x8510
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x25a22
movq -0x10(%rbp), %rdi
callq 0x25420
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x25af9
jmp 0x25a24
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x259c6
jmp 0x25a31
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x10(%rbp), %rcx
subl 0x8(%rcx), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jne 0x25a79
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %esi
shll %esi
callq 0x25290
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x25a77
movq -0x10(%rbp), %rdi
callq 0x25420
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x25af9
jmp 0x25a79
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x10(%rbp), %rcx
xorl %edx, %edx
divl 0x4(%rcx)
movl %edx, %eax
movq -0x10(%rbp), %rcx
imulq 0x18(%rcx), %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdx
callq 0x86b0
movq -0x10(%rbp), %rax
movl 0xc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rdi
callq 0x25450
movq -0x10(%rbp), %rax
testb $0x1, (%rax)
je 0x25ae9
movq -0x10(%rbp), %rdi
addq $0x48, %rdi
callq 0x8580
movq -0x10(%rbp), %rdi
callq 0x25420
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/citrusleaf/cf_queue.c
// Function: cf_queue_push_head
int
cf_queue_push_head(cf_queue *q, const void *ptr)
{
	cf_queue_lock(q);

	if (CF_Q_SZ(q) == q->alloc_sz) {
		if (0 != cf_queue_resize(q, q->alloc_sz * 2)) {
			cf_queue_unlock(q);
			return CF_QUEUE_ERR;
		}
	}

	if (q->read_offset == 0) {
		q->read_offset += q->alloc_sz;
		q->write_offset += q->alloc_sz;
	}

	q->read_offset--;
	memcpy(CF_Q_ELEM_PTR(q, q->read_offset), ptr, q->element_sz);
	q->n_eles++;
	cf_queue_unwrap(q);

	if (q->threadsafe) {
		pthread_cond_signal(&q->CV);
	}

	cf_queue_unlock(q);
	return CF_QUEUE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x25260
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x10(%rbp), %rcx
subl 0x8(%rcx), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jne 0x25b71
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %esi
shll %esi
callq 0x25290
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x25b6f
movq -0x10(%rbp), %rdi
callq 0x25420
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x25c1d
jmp 0x25b71
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x25b9d
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x10(%rbp), %rax
addl 0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x10(%rbp), %rax
addl 0xc(%rax), %ecx
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x10(%rbp), %rcx
xorl %edx, %edx
divl 0x4(%rcx)
movl %edx, %eax
movq -0x10(%rbp), %rcx
imulq 0x18(%rcx), %rax
addq %rax, %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdx
callq 0x86b0
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rdi
callq 0x25450
movq -0x10(%rbp), %rax
testb $0x1, (%rax)
je 0x25c0d
movq -0x10(%rbp), %rdi
addq $0x48, %rdi
callq 0x8580
movq -0x10(%rbp), %rdi
callq 0x25420
movl $0x0, -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/citrusleaf/cf_queue.c
// Function: cf_queue_peek
int
cf_queue_peek(cf_queue *q, void *buf)
{
	cf_queue_lock(q);

	if (CF_Q_EMPTY(q)) {
		cf_queue_unlock(q);
		return CF_QUEUE_EMPTY;
	}

	memcpy(buf, CF_Q_ELEM_PTR(q, q->read_offset), q->element_sz);

	cf_queue_unlock(q);
	return CF_QUEUE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x25260
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jne 0x25c6b
movq -0x10(%rbp), %rdi
callq 0x25420
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x25cb2
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x78(%rax), %rsi
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x10(%rbp), %rcx
xorl %edx, %edx
divl 0x4(%rcx)
movl %edx, %eax
movq -0x10(%rbp), %rcx
imulq 0x18(%rcx), %rax
addq %rax, %rsi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdx
callq 0x86b0
movq -0x10(%rbp), %rdi
callq 0x25420
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/citrusleaf/cf_queue.c
// Function: cf_queue_reduce
int
cf_queue_reduce(cf_queue *q, cf_queue_reduce_fn cb, void *udata)
{
	cf_queue_lock(q);

	if (CF_Q_SZ(q) != 0) {
		for (uint32_t i = q->read_offset; i < q->write_offset; i++) {
			int rv = cb(CF_Q_ELEM_PTR(q, i), udata);

			if (rv == 0) {
				continue;
			}

			if (rv == -1) {
				// Found what it was looking for, stop reducing.
				break;
			}

			if (rv == -2) {
				// Delete, and stop reducing.
				cf_queue_delete_offset(q, i);
				break;
			}
		}
	}

	cf_queue_unlock(q);
	return CF_QUEUE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x25260
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x8(%rbp), %rcx
subl 0x8(%rcx), %eax
cmpl $0x0, %eax
je 0x260f4
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jae 0x260f2
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rdi
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
xorl %edx, %edx
divl 0x4(%rcx)
movq -0x28(%rbp), %rax
movl %edx, %ecx
movq -0x8(%rbp), %rdx
imulq 0x18(%rdx), %rcx
addq %rcx, %rdi
movq -0x18(%rbp), %rsi
callq *%rax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jne 0x260c9
jmp 0x260e7
cmpl $-0x1, -0x20(%rbp)
jne 0x260d1
jmp 0x260f2
cmpl $-0x2, -0x20(%rbp)
jne 0x260e5
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x8380
jmp 0x260f2
jmp 0x260e7
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2607e
jmp 0x260f4
movq -0x8(%rbp), %rdi
callq 0x25420
xorl %eax, %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/citrusleaf/cf_queue.c
// Function: cf_queue_reduce_reverse
int
cf_queue_reduce_reverse(cf_queue *q, cf_queue_reduce_fn cb, void *udata)
{
	cf_queue_lock(q);

	if (CF_Q_SZ(q) != 0) {
		for (int i = (int)q->write_offset - 1; i >= (int)q->read_offset; i--) {
			int rv = cb(CF_Q_ELEM_PTR(q, i), udata);

			if (rv == 0) {
				continue;
			}

			if (rv == -1) {
				// Found what it was looking for, stop reducing.
				break;
			}

			if (rv == -2) {
				// Delete, and stop reducing.
				cf_queue_delete_offset(q, i);
				break;
			}
		}
	}

	cf_queue_unlock(q);
	return CF_QUEUE_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x25260
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x8(%rbp), %rcx
subl 0x8(%rcx), %eax
cmpl $0x0, %eax
je 0x263b7
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jl 0x263b5
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rdi
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
xorl %edx, %edx
divl 0x4(%rcx)
movq -0x28(%rbp), %rax
movl %edx, %ecx
movq -0x8(%rbp), %rdx
imulq 0x18(%rdx), %rcx
addq %rcx, %rdi
movq -0x18(%rbp), %rsi
callq *%rax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
jne 0x2638c
jmp 0x263aa
cmpl $-0x1, -0x20(%rbp)
jne 0x26394
jmp 0x263b5
cmpl $-0x2, -0x20(%rbp)
jne 0x263a8
movq -0x8(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x8380
jmp 0x263b5
jmp 0x263aa
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x26341
jmp 0x263b7
movq -0x8(%rbp), %rdi
callq 0x25420
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/citrusleaf/cf_queue.c
// Function: cf_queue_delete
int
cf_queue_delete(cf_queue *q, const void *ptr, bool only_one)
{
	cf_queue_lock(q);

	bool found = false;

	if (CF_Q_SZ(q) != 0) {
		for (uint32_t i = q->read_offset; i < q->write_offset; i++) {
			int rv = 0;

			// If buf is null, rv is always 0 and we delete all elements.
			if (ptr) {
				rv = memcmp(CF_Q_ELEM_PTR(q, i), ptr, q->element_sz);
			}

			if (rv == 0) {
				cf_queue_delete_offset(q, i);
				found = true;

				if (only_one) {
					break;
				}
			}
		}
	}

	cf_queue_unlock(q);
	return found ? CF_QUEUE_OK : CF_QUEUE_EMPTY;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
callq 0x25260
movb $0x0, -0x12(%rbp)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x8(%rbp), %rcx
subl 0x8(%rcx), %eax
cmpl $0x0, %eax
je 0x26494
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jae 0x26492
movl $0x0, -0x1c(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x26465
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rdi
movl -0x18(%rbp), %eax
movq -0x8(%rbp), %rcx
xorl %edx, %edx
divl 0x4(%rcx)
movl %edx, %eax
movq -0x8(%rbp), %rcx
imulq 0x18(%rcx), %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdx
callq 0x8510
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x26485
movq -0x8(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x8380
movb $0x1, -0x12(%rbp)
testb $0x1, -0x11(%rbp)
je 0x26483
jmp 0x26492
jmp 0x26485
jmp 0x26487
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x26415
jmp 0x26494
movq -0x8(%rbp), %rdi
callq 0x25420
movb -0x12(%rbp), %dl
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
xorl %ecx, %ecx
testb $0x1, %dl
cmovnel %ecx, %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/citrusleaf/cf_random.c
// Function: cf_get_rand_buf
int
cf_get_rand_buf(uint8_t *buf, int len)
{
	if ((uint32_t)len >= sizeof(rand_buf))  return(-1);

	pthread_mutex_lock(&rand_buf_lock);

	if (rand_buf_off < (uint32_t)len ) {
		if (-1 == cf_rand_reload()) {
			pthread_mutex_unlock(&rand_buf_lock);
			return(-1);
		}
	}

	rand_buf_off -= len;
	memcpy(buf, &rand_buf[rand_buf_off] ,len);

	pthread_mutex_unlock(&rand_buf_lock);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpq $0x2000, %rax           # imm = 0x2000
jb 0x26513
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x26592
leaq 0xb2e6(%rip), %rdi      # 0x31800
callq 0x8c60
movl 0xb303(%rip), %eax      # 0x31828
cmpl -0x14(%rbp), %eax
jae 0x26551
callq 0x265a0
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
jne 0x2654f
leaq 0xb2bf(%rip), %rdi      # 0x31800
callq 0x8740
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x26592
jmp 0x26551
movl -0x14(%rbp), %ecx
movl 0xb2ce(%rip), %eax      # 0x31828
subl %ecx, %eax
movl %eax, 0xb2c6(%rip)      # 0x31828
movq -0x10(%rbp), %rdi
movl 0xb2bc(%rip), %eax      # 0x31828
leaq 0xb2bd(%rip), %rsi      # 0x31830
addq %rax, %rsi
movslq -0x14(%rbp), %rdx
callq 0x86b0
leaq 0xb27a(%rip), %rdi      # 0x31800
callq 0x8740
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/citrusleaf/cf_random.c
// Function: cf_rand_reload
static int
cf_rand_reload(void)
{
	if (seeded == 0) {
		int rfd = open("/dev/urandom", O_RDONLY);

		if (rfd < 0) {
#if ! defined ENHANCED_ALLOC
			as_log_error("Failed to open '/dev/urandom'");
#endif

			return -1;
		}

		int rsz = (int)read(rfd, rand_buf, SEED_SZ);

		if (rsz < SEED_SZ) {
#if ! defined ENHANCED_ALLOC
			as_log_error("Failed to seed random number generator");
#endif
			close(rfd);

			return -1;
		}

		close(rfd);
		RAND_seed(rand_buf, rsz);
		seeded = 1;
	}

	if (RAND_bytes(rand_buf, sizeof(rand_buf)) != 1) {
#if ! defined ENHANCED_ALLOC
		as_log_error("Failed to reload random buffer");
#endif
		return -1;
	}

	rand_buf_off = sizeof(rand_buf);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpl $0x0, 0xd281(%rip)      # 0x33830
jne 0x2669a
leaq 0x1288(%rip), %rdi      # 0x27844
xorl %esi, %esi
movb $0x0, %al
callq 0x8960
movl %eax, -0x8(%rbp)
cmpl $0x0, -0x8(%rbp)
jge 0x26611
movq 0x99f3(%rip), %rax      # 0x2ffc8
cmpq $0x0, 0x8(%rax)
je 0x26605
xorl %edi, %edi
leaq 0x126c(%rip), %rsi      # 0x27851
leaq 0x1274(%rip), %rdx      # 0x27860
movl $0x2d, %ecx
leaq 0x1288(%rip), %r8       # 0x27880
movq 0x99c9(%rip), %r9       # 0x2ffc8
movb $0x0, %al
callq *0x8(%r9)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x26701
movl -0x8(%rbp), %edi
leaq 0xb215(%rip), %rsi      # 0x31830
movl $0x40, %edx
callq 0x84f0
movl %eax, -0xc(%rbp)
cmpl $0x40, -0xc(%rbp)
jge 0x26679
movq 0x9993(%rip), %rax      # 0x2ffc8
cmpq $0x0, 0x8(%rax)
je 0x26665
xorl %edi, %edi
leaq 0x120c(%rip), %rsi      # 0x27851
leaq 0x1214(%rip), %rdx      # 0x27860
movl $0x37, %ecx
leaq 0x1246(%rip), %r8       # 0x2789e
movq 0x9969(%rip), %r9       # 0x2ffc8
movb $0x0, %al
callq *0x8(%r9)
movl -0x8(%rbp), %edi
callq 0x84c0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x26701
movl -0x8(%rbp), %edi
callq 0x84c0
movl -0xc(%rbp), %esi
leaq 0xb1a5(%rip), %rdi      # 0x31830
callq 0x8160
movl $0x1, 0xd196(%rip)      # 0x33830
leaq 0xb18f(%rip), %rdi      # 0x31830
movl $0x2000, %esi           # imm = 0x2000
callq 0x82e0
cmpl $0x1, %eax
je 0x266f0
movq 0x9911(%rip), %rax      # 0x2ffc8
cmpq $0x0, 0x8(%rax)
je 0x266e7
xorl %edi, %edi
leaq 0x118a(%rip), %rsi      # 0x27851
leaq 0x1192(%rip), %rdx      # 0x27860
movl $0x45, %ecx
leaq 0x11eb(%rip), %r8       # 0x278c5
movq 0x98e7(%rip), %r9       # 0x2ffc8
movb $0x0, %al
callq *0x8(%r9)
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x26701
movl $0x2000, 0xb12e(%rip)   # imm = 0x2000
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/citrusleaf/cf_random.c
// Function: cf_get_rand64
uint64_t
cf_get_rand64(void)
{
	pthread_mutex_lock(&rand_buf_lock);

	if (rand_buf_off < sizeof(uint64_t) ) {
		if (cf_rand_reload() == -1) {
			pthread_mutex_unlock(&rand_buf_lock);
			return 0;
		}
	}

	rand_buf_off -= sizeof(uint64_t);

	uint64_t r = *(uint64_t *) (&rand_buf[rand_buf_off]);

	pthread_mutex_unlock(&rand_buf_lock);

	return r;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0xb0e1(%rip), %rdi      # 0x31800
callq 0x8c60
movl 0xb0fe(%rip), %eax      # 0x31828
cmpq $0x8, %rax
jae 0x26752
callq 0x265a0
cmpl $-0x1, %eax
jne 0x26750
leaq 0xb0bf(%rip), %rdi      # 0x31800
callq 0x8740
movq $0x0, -0x8(%rbp)
jmp 0x2678d
jmp 0x26752
movl 0xb0d0(%rip), %eax      # 0x31828
subq $0x8, %rax
movl %eax, 0xb0c6(%rip)      # 0x31828
movl 0xb0c0(%rip), %eax      # 0x31828
movl %eax, %ecx
leaq 0xb0bf(%rip), %rax      # 0x31830
movq (%rax,%rcx), %rax
movq %rax, -0x10(%rbp)
leaq 0xb080(%rip), %rdi      # 0x31800
callq 0x8740
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)