LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_arraylist.c
// Function: as_arraylist_take
as_arraylist*
as_arraylist_take(const as_arraylist* list, uint32_t n)
{
	uint32_t		sz		= list->size;
	uint32_t		c		= n < sz ? n : sz;
	as_arraylist*	list2	= as_arraylist_new(c, list->block_size);

	list2->size = c;
	for(uint32_t i = 0; i < c; i++) {
		if (list->elements[i]) {
			as_val_reserve(list->elements[i]);
			list2->elements[i] = list->elements[i];
		}
		else {
			list2->elements[i] = 0;
		}
	}

	return list2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x20(%rax), %eax
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jae 0x9e89
movl -0xc(%rbp), %eax
movl %eax, -0x28(%rbp)
jmp 0x9e8f
movl -0x10(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edi
movq -0x8(%rbp), %rax
movl 0x18(%rax), %esi
callq 0x85d0
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x20(%rax)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x9f27
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x24(%rbp), %ecx
cmpq $0x0, (%rax,%rcx,8)
je 0x9f07
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x24(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
callq 0x8420
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x24(%rbp), %ecx
movq (%rax,%rcx,8), %rdx
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x24(%rbp), %ecx
movq %rdx, (%rax,%rcx,8)
jmp 0x9f1a
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movl -0x24(%rbp), %ecx
movq $0x0, (%rax,%rcx,8)
jmp 0x9f1c
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x9eb9
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_arraylist.c
// Function: as_arraylist_foreach
bool
as_arraylist_foreach(const as_arraylist* list, as_list_foreach_callback callback, void* udata)
{
	for(uint32_t i = 0; i < list->size; i++) {
		if (! callback(list->elements[i], 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)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x20(%rcx), %eax
jae 0x9f97
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rcx
movl -0x24(%rbp), %edx
movq (%rcx,%rdx,8), %rdi
movq -0x20(%rbp), %rsi
callq *%rax
testb $0x1, %al
jne 0x9f8a
movb $0x0, -0x1(%rbp)
jmp 0x9f9b
jmp 0x9f8c
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x9f5b
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
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_arraylist_iterator.c
// Function: as_arraylist_iterator_init
as_arraylist_iterator * as_arraylist_iterator_init(as_arraylist_iterator * iterator, const as_arraylist * list)
{
	if ( !iterator ) return iterator;

	as_iterator_init((as_iterator *) iterator, false, NULL, &as_arraylist_iterator_hooks);
	iterator->list = list;
	iterator->pos = 0;
	return iterator;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xa641
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xa676
movq -0x10(%rbp), %rdi
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %edx
movq 0x2597e(%rip), %rcx     # 0x2ffd0
callq 0x8ab0
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_arraylist_iterator.c
// Function: as_arraylist_iterator_new
as_arraylist_iterator * as_arraylist_iterator_new(const as_arraylist * list)
{
	as_arraylist_iterator * iterator = (as_arraylist_iterator *) cf_malloc(sizeof(as_arraylist_iterator));
	if ( !iterator ) return iterator;

	as_iterator_init((as_iterator *) iterator, true, NULL, &as_arraylist_iterator_hooks);
	iterator->list = list;
	iterator->pos = 0;
	return iterator;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x28, %edi
callq 0x8090
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xa6ab
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xa6e3
movq -0x18(%rbp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
movq 0x25911(%rip), %rcx     # 0x2ffd0
callq 0x8ab0
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x20(%rax)
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_arraylist_iterator.c
// Function: as_arraylist_iterator_next
const as_val * as_arraylist_iterator_next(as_arraylist_iterator * iterator) 
{
	if ( iterator->pos < iterator->list->size ) {
		as_val * val = *(iterator->list->elements + iterator->pos);
		iterator->pos++;
		return val;
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %eax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
cmpl 0x20(%rcx), %eax
jae 0xa7ce
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x20(%rcx), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x20(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xa7d6
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_boolean.c
// Function: as_boolean_cons
static inline as_boolean * as_boolean_cons(as_boolean * boolean, bool free, bool value)
{
	if ( !boolean ) return boolean;

	as_val_cons((as_val *) boolean, AS_BOOLEAN, free);
	boolean->value = value;
	return boolean;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movb %sil, %cl
movq %rdi, -0x10(%rbp)
andb $0x1, %cl
movb %cl, -0x11(%rbp)
andb $0x1, %al
movb %al, -0x12(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xa89d
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xa8c8
movq -0x10(%rbp), %rdi
movb -0x11(%rbp), %al
movl $0x2, %esi
andb $0x1, %al
movzbl %al, %edx
callq 0xaaa0
movb -0x12(%rbp), %cl
movq -0x10(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x8(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_boolean.c
// Function: as_boolean_val_tostring
char * as_boolean_val_tostring(const as_val * v)
{
	if ( as_val_type(v) != AS_BOOLEAN ) return NULL;

	as_boolean * b = (as_boolean *) v;
	char * str = (char *) cf_malloc(sizeof(char) * 6);
    if (!str) return str;
	memset(str, 0, 6);
	if ( b->value ) {
		strcpy(str,"true");
	}
	else {
		strcpy(str,"false");
	}
	return str;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xaa10
movq -0x10(%rbp), %rax
movzbl 0x4(%rax), %eax
movl %eax, -0x24(%rbp)
jmp 0xaa17
xorl %eax, %eax
movl %eax, -0x24(%rbp)
jmp 0xaa17
movl -0x24(%rbp), %eax
cmpl $0x2, %eax
je 0xaa29
movq $0x0, -0x8(%rbp)
jmp 0xaa94
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x6, %edi
callq 0x8090
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xaa50
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xaa94
movq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0x6, %edx
callq 0x8480
movq -0x18(%rbp), %rax
testb $0x1, 0x8(%rax)
je 0xaa7c
movq -0x20(%rbp), %rdi
leaq 0x1c5a3(%rip), %rsi     # 0x27018
callq 0x81b0
jmp 0xaa8c
movq -0x20(%rbp), %rdi
leaq 0x1c596(%rip), %rsi     # 0x2701d
callq 0x81b0
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/include/aerospike/as_val.h
// Function: as_val_cons
static inline as_val * as_val_cons(as_val * val, as_val_t type, bool free) 
{
	if ( !val ) return val;

    val->type = type; 
    val->free = free; 
    val->count = 1;
    return val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dl, %al
movb %sil, %cl
movq %rdi, -0x10(%rbp)
movb %cl, -0x11(%rbp)
andb $0x1, %al
movb %al, -0x12(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xaac6
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xaaef
movb -0x11(%rbp), %cl
movq -0x10(%rbp), %rax
movb %cl, 0x4(%rax)
movb -0x12(%rbp), %cl
movq -0x10(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x5(%rax)
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_buffer.c
// Function: as_buffer_init
int as_buffer_init(as_buffer * b) {
    b->capacity = 0;
    b->size = 0;
    b->data = NULL;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
xorl %eax, %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_buffer.c
// Function: as_buffer_destroy
void as_buffer_destroy(as_buffer * b) {
	if ( b->data ) { 
		cf_free(b->data);
		b->data = 0; 
	}
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xab60
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x8aa0
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_buffer_pool.c
// Function: as_buffer_pool_init
int
as_buffer_pool_init(as_buffer_pool* pool, uint32_t header_size, uint32_t buffer_size)
{
	// Initialize empty queue.
	pool->queue = cf_queue_create(sizeof(void*), true);
	pool->header_size = header_size;
	pool->buffer_size = buffer_size;
	return (pool->queue)? 0 : -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl $0x8, %edi
movl $0x1, %esi
callq 0x8890
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
cmpq $0x0, %rdx
cmovnel %ecx, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_buffer_pool.c
// Function: as_buffer_pool_pop
int
as_buffer_pool_pop(as_buffer_pool* pool, uint32_t size, as_buffer_result* buffer)
{
	size += pool->header_size;
	
	if (size > pool->buffer_size) {
		// Requested size is greater than fixed buffer size.
		// Allocate new buffer, but don't put back into pool.
		buffer->data = cf_malloc(size);
		
		if (! buffer->data) {
			return -1;
		}
		
		buffer->capacity = size - pool->header_size;
		return 2;
	}
	
	// Pop existing buffer from queue.
	int rc = cf_queue_pop(pool->queue, &buffer->data, CF_QUEUE_NOWAIT);
	
	if (rc == CF_QUEUE_OK) {
		buffer->capacity = pool->buffer_size - pool->header_size;
		return 0;
	}
	
	if (rc == CF_QUEUE_EMPTY) {
		// Queue is empty.  Create new buffer.  Queue can grow indefinitely.
		buffer->data = cf_malloc(pool->buffer_size);
		
		if (! buffer->data) {
			return -1;
		}
		
		buffer->capacity = pool->buffer_size - pool->header_size;
		return 1;
	}
	// Queue failure.
	return -2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jbe 0xac43
movl -0x14(%rbp), %eax
movl %eax, %edi
callq 0x8090
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xac26
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xacd2
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
subl 0x8(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movl $0x2, -0x4(%rbp)
jmp 0xacd2
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
xorl %edx, %edx
callq 0x88e0
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0xac7c
movq -0x10(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0x10(%rbp), %rax
subl 0x8(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movl $0x0, -0x4(%rbp)
jmp 0xacd2
cmpl $-0x2, -0x24(%rbp)
jne 0xaccb
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, %edi
callq 0x8090
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xacad
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xacd2
movq -0x10(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0x10(%rbp), %rax
subl 0x8(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movl $0x1, -0x4(%rbp)
jmp 0xacd2
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
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_buffer_pool.c
// Function: as_buffer_pool_push
int
as_buffer_pool_push(as_buffer_pool* pool, void* buffer, uint32_t capacity)
{
	if (capacity + pool->header_size <= pool->buffer_size) {
		// Put buffer back into pool.
		if (cf_queue_push(pool->queue, &buffer) == CF_QUEUE_OK) {
			return 0;
		}
		else {
			cf_free(buffer);
			return -1;
		}
	}
	else {
		// Do not put large buffers back into pool.
		cf_free(buffer);
		return -2;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
addl 0x8(%rcx), %eax
movq -0x10(%rbp), %rcx
cmpl 0xc(%rcx), %eax
ja 0xad36
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq -0x18(%rbp), %rsi
callq 0x82d0
cmpl $0x0, %eax
jne 0xad24
movl $0x0, -0x4(%rbp)
jmp 0xad46
movq -0x18(%rbp), %rdi
callq 0x8aa0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xad46
movq -0x18(%rbp), %rdi
callq 0x8aa0
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_buffer_pool.c
// Function: as_buffer_pool_push_limit
int
as_buffer_pool_push_limit(as_buffer_pool* pool, void* buffer, uint32_t capacity, uint32_t max_buffers)
{
	if (capacity + pool->header_size <= pool->buffer_size) {
		// Put buffer back into pool up to a limit.
		if (cf_queue_push_limit(pool->queue, &buffer, max_buffers)) {
			// Success.
			return 0;
		}
		else {
			cf_free(buffer);
			return -1;
		}
	}
	else {
		// Do not put large buffers back into pool.
		cf_free(buffer);
		return -2;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
addl 0x8(%rcx), %eax
movq -0x10(%rbp), %rcx
cmpl 0xc(%rcx), %eax
ja 0xadad
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl -0x20(%rbp), %edx
leaq -0x18(%rbp), %rsi
callq 0x8ae0
testb $0x1, %al
jne 0xad92
jmp 0xad9b
movl $0x0, -0x4(%rbp)
jmp 0xadbd
movq -0x18(%rbp), %rdi
callq 0x8aa0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xadbd
movq -0x18(%rbp), %rdi
callq 0x8aa0
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_buffer_pool.c
// Function: as_buffer_pool_drop_buffers
int
as_buffer_pool_drop_buffers(as_buffer_pool* pool, int buffer_count)
{
	// Number of buffers in pool may grow too large if burst of concurrent buffer usage happens.
	// Delete buffer_count buffers from pool.
	void* buffer;
	int count = 0;
	
	while (count < buffer_count) {
		if (cf_queue_pop(pool->queue, &buffer, CF_QUEUE_NOWAIT) == CF_QUEUE_OK) {
			cf_free(buffer);
			count++;
		}
		else {
			break;
		}
	}
	return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xae1d
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x88e0
cmpl $0x0, %eax
jne 0xae19
movq -0x18(%rbp), %rdi
callq 0x8aa0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xae1b
jmp 0xae1d
jmp 0xade6
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_buffer_pool.c
// Function: as_buffer_pool_destroy
void
as_buffer_pool_destroy(as_buffer_pool* pool)
{
	// Empty and destroy queue.
	void* buffer;
	while (cf_queue_pop(pool->queue, &buffer, CF_QUEUE_NOWAIT) == CF_QUEUE_OK) {
		cf_free(buffer);
	}
	cf_queue_destroy(pool->queue);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq -0x10(%rbp), %rsi
xorl %edx, %edx
callq 0x88e0
cmpl $0x0, %eax
jne 0xae5e
movq -0x10(%rbp), %rdi
callq 0x8aa0
jmp 0xae3c
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x83d0
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_bytes.c
// Function: as_bytes_cons
static inline as_bytes * as_bytes_cons(
	as_bytes * bytes, bool free, 
	uint32_t capacity, uint32_t size, uint8_t * value, 
	bool value_free, as_bytes_type type)
{
	if ( !bytes ) return bytes;

    as_val_cons((as_val *) bytes, AS_BYTES, free);
    bytes->capacity = capacity;
    bytes->size = size;
    bytes->value = value;
    bytes->free = value_free;
    bytes->type = AS_BYTES_BLOB;

    if ( value == NULL && size == 0 && capacity > 0 ) {
	    bytes->value = cf_calloc(capacity, sizeof(uint8_t));
    }
    
	return bytes;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %r9b, %al
movl 0x10(%rbp), %r9d
movq %rdi, -0x10(%rbp)
andb $0x1, %sil
movb %sil, -0x11(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
andb $0x1, %al
movb %al, -0x29(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xaeee
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xaf71
movq -0x10(%rbp), %rdi
movb -0x11(%rbp), %al
movl $0x9, %esi
andb $0x1, %al
movzbl %al, %edx
callq 0xb9e0
movl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movb -0x29(%rbp), %cl
movq -0x10(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x18(%rax)
movq -0x10(%rbp), %rax
movl $0x4, 0x1c(%rax)
cmpq $0x0, -0x28(%rbp)
jne 0xaf69
cmpl $0x0, -0x1c(%rbp)
jne 0xaf69
cmpl $0x0, -0x18(%rbp)
jbe 0xaf69
movl -0x18(%rbp), %eax
movl %eax, %edi
movl $0x1, %esi
callq 0x8a00
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%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/aerospike/as_bytes.c
// Function: as_bytes_copy
uint32_t as_bytes_copy(const as_bytes * bytes, uint32_t index, uint8_t * value, uint32_t size)
{
	uint32_t sz = index + size > bytes->size ? 0 : size;
	if ( sz == 0 ) return sz;
	memcpy(value, &bytes->value[index], sz);
    return sz;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl -0x14(%rbp), %eax
addl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jbe 0xb0cc
xorl %eax, %eax
movl %eax, -0x2c(%rbp)
jmp 0xb0d2
movl -0x24(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jne 0xb0e6
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xb108
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movl -0x14(%rbp), %eax
addq %rax, %rsi
movl -0x28(%rbp), %eax
movl %eax, %edx
callq 0x86b0
movl -0x28(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_bytes.c
// Function: as_bytes_get_var_int
uint32_t as_bytes_get_var_int(const as_bytes * bytes, uint32_t index, uint32_t * value)
{
	uint8_t* begin = bytes->value + index;
	uint8_t* p = begin;
	uint32_t val = 0;
	uint32_t shift = 0;
	uint8_t b;
	
	do {
		b = *p++;
		val |= (b & 0x7F) << shift;
		shift += 7;
	} while ((b & 0x80));
	
	*value = val;
	return (uint32_t)(p - begin);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0xc(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movb (%rax), %al
movb %al, -0x31(%rbp)
movzbl -0x31(%rbp), %eax
andl $0x7f, %eax
movl -0x30(%rbp), %ecx
shll %cl, %eax
orl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x30(%rbp), %eax
addl $0x7, %eax
movl %eax, -0x30(%rbp)
movzbl -0x31(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
jne 0xb157
movl -0x2c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
subq %rcx, %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_bytes.c
// Function: as_bytes_set
bool as_bytes_set(as_bytes * bytes, uint32_t index, const uint8_t * value, uint32_t size)
{
    if ( index + size > bytes->capacity ) return false;
    memcpy(&bytes->value[index], value, size);
    if ( index + size > bytes->size ) {
    	bytes->size = index + size;
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl -0x14(%rbp), %eax
addl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jbe 0xb1db
movb $0x0, -0x1(%rbp)
jmp 0xb217
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0x14(%rbp), %eax
addq %rax, %rdi
movq -0x20(%rbp), %rsi
movl -0x24(%rbp), %eax
movl %eax, %edx
callq 0x86b0
movl -0x14(%rbp), %eax
addl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jbe 0xb213
movl -0x14(%rbp), %ecx
addl -0x24(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xc(%rax)
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_bytes.c
// Function: as_bytes_set_var_int
uint32_t as_bytes_set_var_int(const as_bytes * bytes, uint32_t index, uint32_t value)
{
	uint8_t* begin = bytes->value + index;
	uint8_t* end = bytes->value + bytes->capacity;
	uint8_t* p = begin;
	
	while (p < end && value >= 0x80) {
		*p++ = (uint8_t)(value | 0x80);
		value >>= 7;
	}
	
	if (p < end) {
		*p++ = (uint8_t)value;
		return (uint32_t)(p - begin);
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x14(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x8(%rcx), %ecx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rcx
xorl %eax, %eax
cmpq -0x28(%rbp), %rcx
movb %al, -0x31(%rbp)
jae 0xb28a
cmpl $0x80, -0x18(%rbp)
setae %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0xb293
jmp 0xb2b9
movl -0x18(%rbp), %eax
orl $0x80, %eax
movb %al, %cl
movq -0x30(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x30(%rbp)
movb %cl, (%rax)
movl -0x18(%rbp), %eax
shrl $0x7, %eax
movl %eax, -0x18(%rbp)
jmp 0xb26e
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0xb2e9
movl -0x18(%rbp), %eax
movb %al, %cl
movq -0x30(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x30(%rbp)
movb %cl, (%rax)
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
subq %rcx, %rax
movl %eax, -0x4(%rbp)
jmp 0xb2f0
movl $0x0, -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_bytes.c
// Function: as_bytes_ensure
bool as_bytes_ensure(as_bytes * bytes, uint32_t capacity, bool resize)
{
	if ( capacity <= bytes->capacity ) return true;
	if ( !resize ) return false;

	uint8_t * buffer = NULL;

	if ( bytes->free ) {
		// this is a previously cf_malloc'd value
		buffer = cf_realloc(bytes->value, capacity);
		if ( !buffer ) {
			// allocation failed, so return false.
			return false;
		}
	}
	else {
		// this is a previously stack alloc'd value
		buffer = cf_malloc(capacity);
		if ( !buffer ) {
			// allocation failed, so return false.
			return false;
		}
		// copy the bytes
		memcpy(buffer, bytes->value, bytes->size);
	}

	bytes->free = true;
	bytes->value = buffer;
	bytes->capacity = capacity;

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
andb $0x1, %al
movb %al, -0x15(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
ja 0xb3ab
movb $0x1, -0x1(%rbp)
jmp 0xb448
testb $0x1, -0x15(%rbp)
jne 0xb3ba
movb $0x0, -0x1(%rbp)
jmp 0xb448
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0x18(%rax)
je 0xb3f1
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x85b0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xb3ef
movb $0x0, -0x1(%rbp)
jmp 0xb448
jmp 0xb426
movl -0x14(%rbp), %eax
movl %eax, %edi
callq 0x8090
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xb40c
movb $0x0, -0x1(%rbp)
jmp 0xb448
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, %edx
callq 0x86b0
movq -0x10(%rbp), %rax
movb $0x1, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
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/aerospike/as_bytes.c
// Function: as_bytes_val_hashcode
uint32_t as_bytes_val_hashcode(const as_val * v)
{
    as_bytes * bytes = as_bytes_fromval(v);
    if ( bytes == NULL || bytes->value == NULL ) return 0;
    uint32_t hash = 0;
    uint8_t * buf = bytes->value;
    int len = bytes->size;
    while ( len-- ) {
        int b = *buf++;
        hash = b + (hash << 6) + (hash << 16) - hash;
    }
    return hash;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb4b0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xb52b
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0xb534
movl $0x0, -0x4(%rbp)
jmp 0xb597
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x2c(%rbp)
cmpl $0x0, %eax
je 0xb591
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movzbl (%rax), %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
movl -0x1c(%rbp), %ecx
shll $0x6, %ecx
addl %ecx, %eax
movl -0x1c(%rbp), %ecx
shll $0x10, %ecx
addl %ecx, %eax
subl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0xb551
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_bytes.c
// Function: as_bytes_val_tostring
char * as_bytes_val_tostring(const as_val * v)
{
    as_bytes * bytes = as_bytes_fromval(v);
    if ( !bytes || !bytes->value || !bytes->size ) {
    	return NULL;
    }

    uint8_t * 	s = bytes->value;
    uint32_t 	sl = bytes->size;
    size_t		st = (4 * sl) + 3;
    char * 		str = (char *) cf_malloc(st);

    if ( !str ) {
    	return NULL;
    }
    
    int j=0;
    for ( uint32_t i=0; i < sl; i++ ) {
        str[j] = as_hex_chars[(s[i] >> 4) & 0xf];
        str[j+1] = as_hex_chars[s[i] & 0xf];
        str[j+2] = ' ';
        j += 3;
    }
    j--; // chomp
    
    str[j] = 0;
    
    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xb4b0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xb5d5
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xb5d5
movq -0x18(%rbp), %rax
cmpl $0x0, 0xc(%rax)
jne 0xb5e2
movq $0x0, -0x8(%rbp)
jmp 0xb6d7
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
shll $0x2, %eax
addl $0x3, %eax
movl %eax, %eax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x8090
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0xb628
movq $0x0, -0x8(%rbp)
jmp 0xb6d7
movl $0x0, -0x3c(%rbp)
movl $0x0, -0x40(%rbp)
movl -0x40(%rbp), %eax
cmpl -0x24(%rbp), %eax
jae 0xb6ba
movq -0x20(%rbp), %rax
movl -0x40(%rbp), %ecx
movzbl (%rax,%rcx), %eax
sarl $0x4, %eax
andl $0xf, %eax
movslq %eax, %rcx
movq 0x2497f(%rip), %rax     # 0x2ffd8
movb (%rax,%rcx), %dl
movq -0x38(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x20(%rbp), %rax
movl -0x40(%rbp), %ecx
movzbl (%rax,%rcx), %eax
andl $0xf, %eax
movslq %eax, %rcx
movq 0x24959(%rip), %rax     # 0x2ffd8
movb (%rax,%rcx), %dl
movq -0x38(%rbp), %rax
movl -0x3c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq -0x38(%rbp), %rax
movl -0x3c(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movb $0x20, (%rax,%rcx)
movl -0x3c(%rbp), %eax
addl $0x3, %eax
movl %eax, -0x3c(%rbp)
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0xb636
movl -0x3c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x3c(%rbp)
movq -0x38(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %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_bytes.c
// Function: as_bytes_to_string
bool
as_bytes_to_string(const uint8_t* bytes, uint32_t bytes_size, char* str, uint32_t str_size)
{
	// Ensure hex string has enough space including null terminator.
	if ((bytes_size * 2 + 1) > str_size) {
		if (str_size > 0) {
			*str = 0;
		}
		return false;
	}

	while (bytes_size > 0) {
		uint8_t b = *bytes++;
		*str++ = as_hex_chars[(b >> 4) & 0xf];
		*str++ = as_hex_chars[b & 0xf];
		bytes_size--;
	}
	*str = 0;
	return true;
}

// 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
shll %eax
addl $0x1, %eax
cmpl -0x24(%rbp), %eax
jbe 0xb722
cmpl $0x0, -0x24(%rbp)
jbe 0xb71c
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
movb $0x0, -0x1(%rbp)
jmp 0xb7a1
jmp 0xb724
cmpl $0x0, -0x14(%rbp)
jbe 0xb796
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb (%rax), %al
movb %al, -0x25(%rbp)
movzbl -0x25(%rbp), %eax
sarl $0x4, %eax
andl $0xf, %eax
movslq %eax, %rcx
movq 0x24886(%rip), %rax     # 0x2ffd8
movb (%rax,%rcx), %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
movzbl -0x25(%rbp), %eax
andl $0xf, %eax
movslq %eax, %rcx
movq 0x24861(%rip), %rax     # 0x2ffd8
movb (%rax,%rcx), %cl
movq -0x20(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rbp)
movb %cl, (%rax)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xb724
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_bytes.c
// Function: as_bytes_to_string_with_prefix
bool
as_bytes_to_string_with_prefix(
	const uint8_t* bytes, uint32_t bytes_size, char* str, uint32_t str_size
	)
{
	if (as_bytes_to_string(bytes, bytes_size, str + 2, str_size - 2)) {
		*str++ = '0';
		*str = 'x';
		return true;
	}

	if (str_size > 0) {
		*str = 0;
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
addq $0x2, %rdx
movl -0x24(%rbp), %ecx
subl $0x2, %ecx
callq 0x80e0
testb $0x1, %al
jne 0xb7e6
jmp 0xb805
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movb $0x30, (%rax)
movq -0x20(%rbp), %rax
movb $0x78, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0xb816
cmpl $0x0, -0x24(%rbp)
jbe 0xb812
movq -0x20(%rbp), %rax
movb $0x0, (%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_bytes.c
// Function: as_bytes_from_string
int
as_bytes_from_string(uint8_t* bytes, uint32_t bytes_size, const char* str)
{
	// Skip prefix if it exists.
	if (*str == '0' && *(str+1) == 'x') {
		str += 2;
	}

	int len = (int)strlen(str);
	int count = len / 2;
	int rem = len - (count * 2);

	// Hex string length must be even (2 chars per byte).
	if (rem != 0) {
		return -1;
	}

	// Byte array must have enough space.
	if ((uint32_t)count > bytes_size) {
		return -1;
	}

	uint8_t hb; // high byte
	uint8_t lb; // low byte

	while (*str) {
		hb = hex_char_to_byte(*str++);

		if (hb == 0xff) {
			return -1;
		}

		lb = hex_char_to_byte(*str++);

		if (lb == 0xff) {
			return -1;
		}
		*bytes++ = (hb << 4) + lb;
	}
	return count;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jne 0xb868
movq -0x20(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x78, %eax
jne 0xb868
movq -0x20(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x82b0
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
movl -0x28(%rbp), %ecx
shll %ecx
subl %ecx, %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0xb8a1
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xb94b
movl -0x28(%rbp), %eax
cmpl -0x14(%rbp), %eax
jbe 0xb8b5
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xb94b
jmp 0xb8b7
movq -0x20(%rbp), %rax
cmpb $0x0, (%rax)
je 0xb945
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movsbl (%rax), %edi
callq 0xb960
movb %al, -0x2d(%rbp)
movzbl -0x2d(%rbp), %eax
cmpl $0xff, %eax
jne 0xb8f2
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xb94b
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movsbl (%rax), %edi
callq 0xb960
movb %al, -0x2e(%rbp)
movzbl -0x2e(%rbp), %eax
cmpl $0xff, %eax
jne 0xb920
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xb94b
movzbl -0x2d(%rbp), %eax
shll $0x4, %eax
movzbl -0x2e(%rbp), %ecx
addl %ecx, %eax
movb %al, %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
jmp 0xb8b7
movl -0x28(%rbp), %eax
movl %eax, -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_bytes.c
// Function: hex_char_to_byte
static inline uint8_t
hex_char_to_byte(const char c)
{
    if (c >= '0' && c <= '9') {
		return (uint8_t)(c - '0');
	}

    if (c >= 'A' && c <= 'F') {
		return (uint8_t)(c - 'A' + 10);
	}

    if (c >= 'a' && c <= 'f') {
		return (unsigned char)(c - 'a' + 10);
	}
    return 0xff;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x2(%rbp)
movsbl -0x2(%rbp), %eax
cmpl $0x30, %eax
jl 0xb988
movsbl -0x2(%rbp), %eax
cmpl $0x39, %eax
jg 0xb988
movsbl -0x2(%rbp), %eax
subl $0x30, %eax
movb %al, -0x1(%rbp)
jmp 0xb9ce
movsbl -0x2(%rbp), %eax
cmpl $0x41, %eax
jl 0xb9a9
movsbl -0x2(%rbp), %eax
cmpl $0x46, %eax
jg 0xb9a9
movsbl -0x2(%rbp), %eax
subl $0x41, %eax
addl $0xa, %eax
movb %al, -0x1(%rbp)
jmp 0xb9ce
movsbl -0x2(%rbp), %eax
cmpl $0x61, %eax
jl 0xb9ca
movsbl -0x2(%rbp), %eax
cmpl $0x66, %eax
jg 0xb9ca
movsbl -0x2(%rbp), %eax
subl $0x61, %eax
addl $0xa, %eax
movb %al, -0x1(%rbp)
jmp 0xb9ce
movb $-0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_double.c
// Function: as_double_cons
static as_double*
as_double_cons(as_double* value_ptr, bool free, double value)
{
	if (!value_ptr ) {
		return value_ptr;
	}

	as_val_cons((as_val*)value_ptr, AS_DOUBLE, free);
	value_ptr->value = value;
	return value_ptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movsd %xmm0, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xba9a
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xbac6
movq -0x10(%rbp), %rdi
movb -0x11(%rbp), %al
movl $0xa, %esi
andb $0x1, %al
movzbl %al, %edx
callq 0xbc40
movsd -0x20(%rbp), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, 0x8(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_double.c
// Function: as_double_val_destroy
void
as_double_val_destroy(as_val* val)
{
	as_double* value_ptr = as_double_fromval(val);
	
	if (!value_ptr ) {
		return;
	}
	value_ptr->value = 0.0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xbb50
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xbb32
jmp 0xbb3e
movq -0x10(%rbp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%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_double.c
// Function: as_double_val_hashcode
uint32_t
as_double_val_hashcode(const as_val* val)
{
	as_double* value_ptr = as_double_fromval(val);
	
	if (!value_ptr) {
		return 0;
	}
	
	uint64_t v = *(uint64_t*)&value_ptr->value;
	return (uint32_t)(v ^ (v >> 32));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xbb50
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xbbc9
movl $0x0, -0x4(%rbp)
jmp 0xbbe7
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x20(%rbp), %rcx
shrq $0x20, %rcx
xorq %rcx, %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_double.c
// Function: as_double_val_tostring
char*
as_double_val_tostring(const as_val * val)
{
	as_double* value_ptr = (as_double*)val;
	char* str = (char*)cf_malloc(sizeof(char) * 64);
	sprintf(str, "%.16g", value_ptr->value);
	return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x40, %edi
callq 0x8090
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movsd 0x8(%rax), %xmm0
leaq 0x1b41b(%rip), %rsi     # 0x27041
movb $0x1, %al
callq 0x8b70
movq -0x18(%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_geojson.c
// Function: as_geojson_cons
static inline as_geojson * as_geojson_cons(as_geojson * string, bool free, char * value, size_t len, bool value_free)
{
	if ( !string ) return string;

	as_val_cons((as_val *) string, AS_GEOJSON, free);
	string->free = value_free;
	string->value = value;
	string->len = len;
	return string;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %r8b, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %sil
movb %sil, -0x11(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
andb $0x1, %al
movb %al, -0x29(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xbde5
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xbe28
movq -0x10(%rbp), %rdi
movb -0x11(%rbp), %al
movl $0xb, %esi
andb $0x1, %al
movzbl %al, %edx
callq 0xc150
movb -0x29(%rbp), %cl
movq -0x10(%rbp), %rax
andb $0x1, %cl
movb %cl, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
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_geojson.c
// Function: as_geojson_len
size_t as_geojson_len(as_geojson * string)
{
	if (string->value == NULL) {
		return 0;
	}
	if (string->len == SIZE_MAX) {
		string->len = strlen(string->value);
	}
	return string->len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0xbf71
movq $0x0, -0x8(%rbp)
jmp 0xbfa0
movq -0x10(%rbp), %rax
cmpq $-0x1, 0x18(%rax)
jne 0xbf94
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x82b0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_geojson.c
// Function: as_geojson_val_destroy
void as_geojson_val_destroy(as_val * v)
{
	as_geojson * string = as_geojson_fromval(v);
	if ( !string ) return;

	if ( string->value && string->free ) {
		cf_free(string->value);
	}
	
	string->value = NULL;
	string->free = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xbd20
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xbfd2
jmp 0xc008
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xbff4
movq -0x10(%rbp), %rax
testb $0x1, 0x8(%rax)
je 0xbff4
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x8aa0
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movb $0x0, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_geojson.c
// Function: as_geojson_val_hashcode
uint32_t as_geojson_val_hashcode(const as_val * v)
{
	as_geojson * string = as_geojson_fromval(v);
	if ( string == NULL || string->value == NULL) return 0;
	uint32_t hash = 0;
	int c;
	char * str = string->value;
	while ( (c = *str++) ) {
		hash = c + (hash << 6) + (hash << 16) - hash;
	}
	return hash;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xbd20
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xc03b
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0xc044
movl $0x0, -0x4(%rbp)
jmp 0xc092
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movsbl (%rax), %eax
movl %eax, -0x20(%rbp)
cmpl $0x0, %eax
je 0xc08c
movl -0x20(%rbp), %eax
movl -0x1c(%rbp), %ecx
shll $0x6, %ecx
addl %ecx, %eax
movl -0x1c(%rbp), %ecx
shll $0x10, %ecx
addl %ecx, %eax
subl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0xc057
movl -0x1c(%rbp), %eax
movl %eax, -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_geojson.c
// Function: as_geojson_val_tostring
char * as_geojson_val_tostring(const as_val * v)
{
	as_geojson * s = (as_geojson *) v;
	if (s->value == NULL) return(NULL);
	size_t sl = as_geojson_len(s);
	size_t st = 3 + sl;
	char * str = (char *) cf_malloc(sizeof(char) * st);
	if (!str) return str;
	*(str + 0) = '\"';
	strcpy(str + 1, s->value);
	*(str + 1 + sl) = '\"';
	*(str + 1 + sl + 1) = '\0';
	return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0xc0c9
movq $0x0, -0x8(%rbp)
jmp 0xc142
movq -0x18(%rbp), %rdi
callq 0x8b50
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x3, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
shlq $0x0, %rdi
callq 0x8090
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0xc104
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xc142
movq -0x30(%rbp), %rax
movb $0x22, (%rax)
movq -0x30(%rbp), %rdi
addq $0x1, %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x81b0
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movb $0x22, 0x1(%rax,%rcx)
movq -0x30(%rbp), %rax
movq -0x20(%rbp), %rcx
movb $0x0, 0x2(%rax,%rcx)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_integer.c
// Function: as_integer_cons
static as_integer * as_integer_cons(as_integer * integer, bool free, int64_t value)
{
	if ( !integer ) return integer;

	as_val_cons((as_val *) integer, AS_INTEGER, free);
	integer->value = value;
	return integer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xc209
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xc233
movq -0x10(%rbp), %rdi
movb -0x11(%rbp), %al
movl $0x3, %esi
andb $0x1, %al
movzbl %al, %edx
callq 0xc3b0
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%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_integer.c
// Function: as_integer_val_tostring
char * as_integer_val_tostring(const as_val * v)
{
	as_integer * i = (as_integer *) v;
	char * str = (char *) cf_malloc(sizeof(char) * 32);
	memset(str, 0, 32);
	sprintf(str, "%" PRId64, i->value);
	return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl $0x20, %edi
callq 0x8090
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x8480
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0x1acb2(%rip), %rsi     # 0x27047
movb $0x0, %al
callq 0x8b70
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_iterator.c
// Function: as_iterator_init
as_iterator * as_iterator_init(as_iterator * iterator, bool free, void * data, const as_iterator_hooks * hooks)
{
	if ( !iterator ) return iterator;

	iterator->free = free;
	iterator->data = data;
	iterator->hooks = hooks;
	return iterator;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xc439
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xc465
movb -0x11(%rbp), %cl
movq -0x10(%rbp), %rax
andb $0x1, %cl
movb %cl, (%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)