LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_string_builder.c
// Function: as_sb_increase_capacity
static bool
as_sb_increase_capacity(as_string_builder* sb, uint32_t min_capacity)
{
	uint32_t capacity = sb->capacity * 2;

	if (capacity < min_capacity) {
		capacity = min_capacity;
	}

	if (sb->free) {
		// String already allocated on heap.  Realloc.
		char* data = cf_realloc(sb->data, capacity);
		
		if (data) {
			sb->data = data;
			sb->capacity = capacity;
			return true;
		}
	}
	else {
		// String allocated on stack.  Transfer to heap.
		char* data = cf_malloc(capacity);
		
		if (data) {
			memcpy(data, sb->data, sb->length);
			data[sb->length] = 0;
			sb->data = data;
			sb->capacity = capacity;
			sb->free = true;
			return true;
		}
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
shll %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x16fe9
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0x11(%rax)
je 0x1702c
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl -0x18(%rbp), %eax
movl %eax, %esi
callq 0x85b0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1702a
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x17092
jmp 0x1708e
movl -0x18(%rbp), %eax
movl %eax, %edi
callq 0x8090
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x1708c
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, %edx
callq 0x86b0
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0xc(%rcx), %ecx
movb $0x0, (%rax,%rcx)
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movb $0x1, 0x11(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x17092
jmp 0x1708e
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_string_builder.c
// Function: as_sb_append_char
static inline bool
as_sb_append_char(as_string_builder* sb, char value)
{
	if (sb->length + 1 < sb->capacity) {
		sb->data[sb->length++] = value;
		sb->data[sb->length] = 0;
		return true;
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
addl $0x1, %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jae 0x170f7
movb -0x11(%rbp), %dl
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rsi
movl 0xc(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0xc(%rsi)
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movl 0xc(%rcx), %ecx
movb $0x0, (%rax,%rcx)
movb $0x1, -0x1(%rbp)
jmp 0x170fb
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_string_builder.c
// Function: as_sb_append_byte
static bool
as_sb_append_byte(as_string_builder* sb, uint8_t b)
{
	if (sb->length + 3 < sb->capacity) {
		sb->data[sb->length++] = as_hex_chars[(b >> 4) & 0xf];
		sb->data[sb->length++] = as_hex_chars[b & 0xf];
		sb->data[sb->length++] = ' ';
		sb->data[sb->length] = 0;
		return true;
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
addl $0x3, %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jae 0x171ca
movzbl -0x11(%rbp), %eax
sarl $0x4, %eax
andl $0xf, %eax
movslq %eax, %rcx
movq 0x18e8f(%rip), %rax     # 0x2ffd8
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rsi
movl 0xc(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0xc(%rsi)
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movzbl -0x11(%rbp), %eax
andl $0xf, %eax
movslq %eax, %rcx
movq 0x18e60(%rip), %rax     # 0x2ffd8
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rsi
movl 0xc(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0xc(%rsi)
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rdx
movl 0xc(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0xc(%rdx)
movl %ecx, %ecx
movb $0x20, (%rax,%rcx)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movl 0xc(%rcx), %ecx
movb $0x0, (%rax,%rcx)
movb $0x1, -0x1(%rbp)
jmp 0x171ce
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_thread_pool.c
// Function: as_thread_worker
void*
as_thread_worker(void* data)
{
	as_thread_pool* pool = data;

	as_thread_set_name("tpool");

	// Run variable tasks.
	as_thread_pool_task task;

	// Retrieve tasks from queue and execute.
	while (cf_queue_pop(pool->dispatch_queue, &task, CF_QUEUE_FOREVER) == CF_QUEUE_OK) {
		// A null task indicates thread should be shut down.
		if (! task.task_fn) {
			break;
		}

		// Run task
		task.task_fn(task.task_data);
	}

	// Run the finalization function, if present.
	if (pool->fini_fn) {
		pool->fini_fn();
	}
	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x100fa(%rip), %rdi     # 0x273f5
callq 0x17350
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0x20(%rbp), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x88e0
cmpl $0x0, %eax
jne 0x17330
cmpq $0x0, -0x20(%rbp)
jne 0x17324
jmp 0x17330
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rdi
callq *%rax
jmp 0x17300
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x17342
movq -0x10(%rbp), %rax
callq *0x10(%rax)
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_thread_pool.c
// Function: as_thread_pool_init
int
as_thread_pool_init(as_thread_pool* pool, uint32_t thread_size)
{
	if (thread_size != 0) {
		pool->threads = cf_calloc(thread_size, sizeof(pthread_t));
		pool->dispatch_queue = cf_queue_create(sizeof(as_thread_pool_task), true);
	}
	else {
		pool->threads = NULL;
		pool->dispatch_queue = NULL;
	}
	pool->fini_fn = NULL;
	pool->thread_size = 0;

	// Start threads.
	for (uint32_t i = 0; i < thread_size; i++) {
		if (pthread_create(&pool->threads[i], NULL, as_thread_worker, pool) == 0) {
			pool->thread_size++;
		}
	}
	return (pool->thread_size == thread_size)? 0 : -3;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x173ca
movl -0xc(%rbp), %eax
movl %eax, %edi
movl $0x8, %esi
callq 0x8a00
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movl $0x10, %edi
movl $0x1, %esi
callq 0x8890
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x173e1
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x18(%rax)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x1744b
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl -0x10(%rbp), %eax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rcx
xorl %eax, %eax
movl %eax, %esi
movq 0x18bb9(%rip), %rdx     # 0x2ffe0
callq 0x8950
cmpl $0x0, %eax
jne 0x1743e
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
jmp 0x17440
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x173ff
movq -0x8(%rbp), %rax
movl 0x18(%rax), %edx
movl -0xc(%rbp), %esi
movl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
xorl %ecx, %ecx
cmpl %esi, %edx
cmovel %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_thread_pool.c
// Function: as_thread_pool_queue_task
int
as_thread_pool_queue_task(as_thread_pool* pool, as_task_fn task_fn, void* task)
{
	if (pool->thread_size == 0) {
		// No threads are running to process task.
		return -1;
	}

	// Queue variable task.
	as_thread_pool_task vtask;
	vtask.task_fn = task_fn;
	vtask.task_data = task;

	if (cf_queue_push(pool->dispatch_queue, &vtask) != CF_QUEUE_OK) {
		return -2;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jne 0x17497
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x174cd
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0x30(%rbp), %rsi
callq 0x82d0
cmpl $0x0, %eax
je 0x174c6
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x174cd
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_thread_pool.c
// Function: as_thread_pool_destroy
int
as_thread_pool_destroy(as_thread_pool* pool)
{
	// Prevent double destroy.
	uint32_t thread_size = as_fas_uint32(&pool->thread_size, 0);

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

	// Tells worker threads to stop by setting NULL task_fn. We do this to allow the
	// workers to "wait forever" on processing the work dispatch queue, which has
	// minimum impact when the queue is empty. This also means all queued requests
	// get processed before shutting down.
	as_thread_pool_task task;
	task.task_fn = NULL;
	task.task_data = NULL;

	// Send shutdown signal for variable tasks.
	for (uint32_t i = 0; i < thread_size; i++) {
		cf_queue_push(pool->dispatch_queue, &task);
	}

	// Wait till threads finish.
	for (uint32_t i = 0; i < thread_size; i++) {
		pthread_join(pool->threads[i], NULL);
	}

	cf_free(pool->threads);
	cf_queue_destroy(pool->dispatch_queue);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
xorl %esi, %esi
callq 0x175b0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x17510
movl $0x0, -0x4(%rbp)
jmp 0x1759c
movq $0x0, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x1754b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0x28(%rbp), %rsi
callq 0x82d0
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x17527
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x1757c
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl -0x30(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x8bc0
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x17552
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x8aa0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x83d0
movl $0x0, -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_timer.c
// Function: as_timer_init
as_timer * as_timer_init(as_timer * timer, void * source, const as_timer_hooks * hooks) {
    if ( timer == NULL ) return timer;
    timer->source = source;
    timer->hooks = hooks;
    return timer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x17601
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x17621
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_timer.c
// Function: as_timer_new
as_timer * as_timer_new(void * source, const as_timer_hooks * hooks) {
    as_timer * timer = (as_timer *) cf_malloc(sizeof(as_timer));
    if (!timer) return timer;
    timer->source = source;
    timer->hooks = hooks;
    return timer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x18, %edi
callq 0x8090
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x1765f
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1767f
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_timer.c
// Function: as_timer_destroy
int as_timer_destroy(as_timer * timer) {
    int rc = as_util_hook(destroy, 1, timer);
    if ( rc == 0 && timer->is_malloc ) {
        cf_free(timer);
    }
    return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x176d2
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x176d2
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
cmpq $0x0, (%rax)
je 0x176d2
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
movl %eax, -0x10(%rbp)
jmp 0x176dc
movl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x176dc
movl -0x10(%rbp), %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x176fa
movq -0x8(%rbp), %rax
testb $0x1, (%rax)
je 0x176fa
movq -0x8(%rbp), %rdi
callq 0x8aa0
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_val.c
// Function: as_val_val_destroy
as_val * as_val_val_destroy(as_val * v)
{
	if (v == NULL || !v->count) {
		return v;
	}

	// if we reach the last reference, call the destructor, and free
	if (as_aaf_uint32_rls(&v->count, -1) == 0) {
		// Subsequent destructor may require an 'acquire' barrier.
		as_fence_acq();

		as_val_destroy_callbacks[v->type](v);

		if (v->free) {
			cf_free(v);
		}
		v = NULL;
	}
	return v;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1786c
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x17876
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x178c7
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x178e0
cmpl $0x0, %eax
jne 0x178bf
movq -0x10(%rbp), %rax
movzbl 0x4(%rax), %eax
movl %eax, %ecx
leaq 0x18376(%rip), %rax     # 0x2fc10
movq (%rax,%rcx,8), %rax
movq -0x10(%rbp), %rdi
callq *%rax
movq -0x10(%rbp), %rax
testb $0x1, 0x5(%rax)
je 0x178b7
movq -0x10(%rbp), %rdi
callq 0x8aa0
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_val.c
// Function: as_val_tobool
bool as_val_tobool(const as_val* v)
{
	if (!v) {
		return false;
	}

	if (v->type == AS_BOOLEAN) {
		return ((as_boolean*)v)->value;
	}

	if (v->type == AS_INTEGER) {
		return ((as_integer*)v)->value;
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x179c5
movb $0x0, -0x1(%rbp)
jmp 0x17a04
movq -0x10(%rbp), %rax
movzbl 0x4(%rax), %eax
cmpl $0x2, %eax
jne 0x179e0
movq -0x10(%rbp), %rax
movb 0x8(%rax), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x17a04
movq -0x10(%rbp), %rax
movzbl 0x4(%rax), %eax
cmpl $0x3, %eax
jne 0x17a00
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x17a04
movb $0x0, -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_vector.c
// Function: as_vector_init
void
as_vector_init(as_vector* vector, uint32_t item_size, uint32_t capacity)
{
	vector->list = cf_malloc(capacity * item_size);
	vector->capacity = capacity;
	vector->item_size = item_size;
	vector->size = 0;
	vector->flags = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0x10(%rbp), %eax
imull -0xc(%rbp), %eax
movl %eax, %eax
movl %eax, %edi
callq 0x8090
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x14(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_vector.c
// Function: as_vector_create
as_vector*
as_vector_create(uint32_t item_size, uint32_t capacity)
{
	as_vector* vector = cf_malloc(sizeof(as_vector));
	as_vector_init(vector, item_size, capacity);
	vector->flags = FLAGS_HEAP | FLAGS_CREATED;
	return vector;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x18, %edi
callq 0x8090
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl -0x4(%rbp), %esi
movl -0x8(%rbp), %edx
callq 0x8690
movq -0x10(%rbp), %rax
movl $0x3, 0x14(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_vector.c
// Function: as_vector_destroy
void
as_vector_destroy(as_vector* vector)
{
	if (vector->flags & FLAGS_HEAP) {
		cf_free(vector->list);
		
		if (vector->flags & FLAGS_CREATED) {
			cf_free(vector);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x17b71
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x8aa0
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x17b6f
movq -0x8(%rbp), %rdi
callq 0x8aa0
jmp 0x17b71
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_vector.c
// Function: as_vector_increase_capacity
void
as_vector_increase_capacity(as_vector* vector)
{
	if (vector->flags & FLAGS_HEAP) {
		vector->capacity *= 2;
		vector->list = cf_realloc(vector->list, vector->capacity * vector->item_size);
	}
	else {
		uint32_t capacity = vector->capacity * 2;
		void* tmp = cf_malloc(capacity * vector->item_size);
		memcpy(tmp, vector->list, vector->capacity * vector->item_size);
		vector->list = tmp;
		vector->capacity = capacity;
		vector->flags |= FLAGS_HEAP;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x14(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x17bd2
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
shll %ecx
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x8(%rbp), %rcx
imull 0x10(%rcx), %eax
movl %eax, %eax
movl %eax, %esi
callq 0x85b0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x17c3b
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
shll %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
imull 0x10(%rcx), %eax
movl %eax, %eax
movl %eax, %edi
callq 0x8090
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x8(%rbp), %rcx
imull 0x10(%rcx), %eax
movl %eax, %eax
movl %eax, %edx
callq 0x86b0
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl 0x14(%rax), %ecx
orl $0x1, %ecx
movl %ecx, 0x14(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_vector.c
// Function: as_vector_append_unique
bool
as_vector_append_unique(as_vector* vector, void* value)
{
	char* item = vector->list;
	for (uint32_t i = 0; i < vector->size; i++) {
		if (memcmp(item, value, vector->item_size) == 0) {
			return false;
		}
		item += vector->item_size;
	}
	as_vector_append(vector, value);
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jae 0x17cbe
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, %edx
callq 0x8510
cmpl $0x0, %eax
jne 0x17c9f
movb $0x0, -0x1(%rbp)
jmp 0x17ccf
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x17c72
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x17ce0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/include/aerospike/as_vector.h
// Function: as_vector_append
static inline void
as_vector_append(as_vector* vector, void* value)
{
	if (vector->size >= vector->capacity) {
		as_vector_increase_capacity(vector);
	}
	memcpy((uint8_t *)vector->list + (vector->size * vector->item_size), value, vector->item_size);
	vector->size++;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jb 0x17d09
movq -0x8(%rbp), %rdi
callq 0x8030
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x8(%rbp), %rcx
imull 0x10(%rcx), %eax
movl %eax, %eax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, %edx
callq 0x86b0
movq -0x8(%rbp), %rax
movl 0xc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/as_vector.c
// Function: as_vector_to_array
void*
as_vector_to_array(as_vector* vector, uint32_t* size)
{
	size_t len = vector->size * vector->item_size;
	void* array = cf_malloc(len);
	memcpy(array, vector->list, len);
	*size = vector->size;
	return array;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x8(%rbp), %rcx
imull 0x10(%rcx), %eax
movl %eax, %eax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8090
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
movq -0x18(%rbp), %rdx
callq 0x86b0
movq -0x8(%rbp), %rax
movl 0xc(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%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_vector.c
// Function: as_vector_remove
bool
as_vector_remove(as_vector* vector, uint32_t index)
{
	if (index >= vector->size) {
		return false;
	}

	memmove((uint8_t*)vector->list + (index * vector->item_size),
		    (uint8_t*)vector->list + ((index + 1) * vector->item_size),
		    (vector->size - index - 1) * vector->item_size);

	vector->size--;
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jb 0x17dd1
movb $0x0, -0x1(%rbp)
jmp 0x17e31
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
imull 0x10(%rcx), %eax
movl %eax, %eax
addq %rax, %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movl -0x14(%rbp), %eax
addl $0x1, %eax
movq -0x10(%rbp), %rcx
imull 0x10(%rcx), %eax
movl %eax, %eax
addq %rax, %rsi
movq -0x10(%rbp), %rax
movl 0xc(%rax), %eax
subl -0x14(%rbp), %eax
subl $0x1, %eax
movq -0x10(%rbp), %rcx
imull 0x10(%rcx), %eax
movl %eax, %eax
movl %eax, %edx
callq 0x8970
movq -0x10(%rbp), %rax
movl 0xc(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0xc(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/crypt_blowfish.c
// Function: crypt_output_magic
int _crypt_output_magic(const char *setting, char *output, int size)
{
	if (size < 3)
		return -1;

	output[0] = '*';
	output[1] = '0';
	output[2] = '\0';

	if (setting[0] == '*' && setting[1] == '0')
		output[1] = '1';

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
cmpl $0x3, -0x1c(%rbp)
jge 0x17e5e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x17e9d
movq -0x18(%rbp), %rax
movb $0x2a, (%rax)
movq -0x18(%rbp), %rax
movb $0x30, 0x1(%rax)
movq -0x18(%rbp), %rax
movb $0x0, 0x2(%rax)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2a, %eax
jne 0x17e96
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x30, %eax
jne 0x17e96
movq -0x18(%rbp), %rax
movb $0x31, 0x1(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/crypt_blowfish.c
// Function: crypt_gensalt_blowfish_rn
char *_crypt_gensalt_blowfish_rn(const char *prefix, unsigned long count,
	const char *input, int size, char *output, int output_size)
{
	if (size < 16 || output_size < 7 + 22 + 1 ||
	    (count && (count < 4 || count > 31)) ||
	    prefix[0] != '$' || prefix[1] != '2' ||
	    (prefix[2] != 'a' && prefix[2] != 'y')) {
		if (output_size > 0) output[0] = '\0';
		__set_errno((output_size < 7 + 22 + 1) ? ERANGE : EINVAL);
		return NULL;
	}

	if (!count) count = 5;

	output[0] = '$';
	output[1] = '2';
	output[2] = prefix[2];
	output[3] = '$';
	output[4] = '0' + (char)(count / 10);
	output[5] = '0' + (char)(count % 10);
	output[6] = '$';

	BF_encode(&output[7], (const BF_word *)input, 16);
	output[7 + 22] = '\0';

	return output;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq %r8, -0x30(%rbp)
movl %r9d, -0x34(%rbp)
cmpl $0x10, -0x24(%rbp)
jl 0x1e9c3
cmpl $0x1e, -0x34(%rbp)
jl 0x1e9c3
cmpq $0x0, -0x18(%rbp)
je 0x1e990
cmpq $0x4, -0x18(%rbp)
jb 0x1e9c3
cmpq $0x1f, -0x18(%rbp)
ja 0x1e9c3
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x24, %eax
jne 0x1e9c3
movq -0x10(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x32, %eax
jne 0x1e9c3
movq -0x10(%rbp), %rax
movsbl 0x2(%rax), %eax
cmpl $0x61, %eax
je 0x1e9fd
movq -0x10(%rbp), %rax
movsbl 0x2(%rax), %eax
cmpl $0x79, %eax
je 0x1e9fd
cmpl $0x0, -0x34(%rbp)
jle 0x1e9d0
movq -0x30(%rbp), %rax
movb $0x0, (%rax)
movl -0x34(%rbp), %edx
movl $0x16, %eax
movl $0x22, %ecx
cmpl $0x1e, %edx
cmovll %ecx, %eax
movl %eax, -0x38(%rbp)
callq 0x8170
movl -0x38(%rbp), %ecx
movl %ecx, (%rax)
movq $0x0, -0x8(%rbp)
jmp 0x1ea9b
cmpq $0x0, -0x18(%rbp)
jne 0x1ea0c
movq $0x5, -0x18(%rbp)
movq -0x30(%rbp), %rax
movb $0x24, (%rax)
movq -0x30(%rbp), %rax
movb $0x32, 0x1(%rax)
movq -0x10(%rbp), %rax
movb 0x2(%rax), %cl
movq -0x30(%rbp), %rax
movb %cl, 0x2(%rax)
movq -0x30(%rbp), %rax
movb $0x24, 0x3(%rax)
movq -0x18(%rbp), %rax
movl $0xa, %ecx
xorl %edx, %edx
divq %rcx
movsbl %al, %eax
addl $0x30, %eax
movb %al, %cl
movq -0x30(%rbp), %rax
movb %cl, 0x4(%rax)
movq -0x18(%rbp), %rax
movl $0xa, %ecx
xorl %edx, %edx
divq %rcx
movb %dl, %al
movsbl %al, %eax
addl $0x30, %eax
movb %al, %cl
movq -0x30(%rbp), %rax
movb %cl, 0x5(%rax)
movq -0x30(%rbp), %rax
movb $0x24, 0x6(%rax)
movq -0x30(%rbp), %rdi
addq $0x7, %rdi
movq -0x20(%rbp), %rsi
movl $0x10, %edx
callq 0x1eab0
movq -0x30(%rbp), %rax
movb $0x0, 0x1d(%rax)
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/crypt_blowfish.c
// Function: BF_swap
static void BF_swap(BF_word *x, int count)
{
	static int endianness_check = 1;
	char *is_little_endian = (char *)&endianness_check;
	BF_word tmp;

	if (*is_little_endian)
	do {
		tmp = *x;
		tmp = (tmp << 16) | (tmp >> 16);
		*x++ = ((tmp & 0x00FF00FF) << 8) | ((tmp >> 8) & 0x00FF00FF);
	} while (--count);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0x1293e(%rip), %rax     # 0x317e0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
je 0x1ef05
jmp 0x1eeb1
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
shll $0x10, %eax
movl -0x1c(%rbp), %ecx
shrl $0x10, %ecx
orl %ecx, %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
andl $0xff00ff, %ecx         # imm = 0xFF00FF
shll $0x8, %ecx
movl -0x1c(%rbp), %eax
shrl $0x8, %eax
andl $0xff00ff, %eax         # imm = 0xFF00FF
orl %eax, %ecx
movq -0x8(%rbp), %rax
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, -0x8(%rbp)
movl %ecx, (%rax)
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $0x0, %eax
jne 0x1eeb1
jmp 0x1ef05
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/ssl_util.c
// Function: as_tls_match_name
bool as_tls_match_name(X509 *x509, const char *name, bool allow_wildcard)
{
	// We've neutered the actual calls to no need the apr_pool_t or
	// server_rec arguments.
	//
	return modssl_X509_match_name((apr_pool_t *) NULL,
								  x509,
								  name,
								  allow_wildcard,
								  (server_rec *) NULL);
}

// 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), %rsi
movq -0x10(%rbp), %rdx
movb -0x11(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rdi
callq 0x1ef60
cmpl $0x0, %eax
setne %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/ssl_util.c
// Function: getIDs
static BOOL getIDs(apr_pool_t *p, X509 *x509, apr_array_header_t **ids)
{
    X509_NAME *subj;
    int i = -1;

    /* First, the DNS-IDs (dNSName entries in the subjectAltName extension) */
    if (!x509 ||
        (modssl_X509_getSAN(p, x509, GEN_DNS, NULL, -1, ids) == FALSE && !*ids)) {
        *ids = NULL;
        return FALSE;
    }

    /* Second, the CN-IDs (commonName attributes in the subject DN) */
    subj = X509_get_subject_name(x509);
    while ((i = X509_NAME_get_index_by_NID(subj, NID_commonName, i)) != -1) {
        APR_ARRAY_PUSH(*ids, const char *) = 
            modssl_X509_NAME_ENTRY_to_string(p, X509_NAME_get_entry(subj, i));
    }

    return as_apr_is_empty_array(*ids) ? FALSE : TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0xffffffff, -0x2c(%rbp) # imm = 0xFFFFFFFF
cmpq $0x0, -0x18(%rbp)
je 0x1f471
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %r9
movl $0x2, %edx
xorl %eax, %eax
movl %eax, %ecx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
callq 0x1f590
cmpl $0x0, %eax
jne 0x1f485
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x1f485
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movl $0x0, -0x4(%rbp)
jmp 0x1f502
movq -0x18(%rbp), %rdi
callq 0x8320
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movl -0x2c(%rbp), %edx
movl $0xd, %esi
callq 0x89c0
movl %eax, -0x2c(%rbp)
cmpl $-0x1, %eax
je 0x1f4e4
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rdi
movl -0x2c(%rbp), %esi
callq 0x87e0
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x1f7e0
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x1f820
movq -0x38(%rbp), %rcx
movq %rcx, (%rax)
jmp 0x1f492
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x1f8d0
movl %eax, %edx
movl $0x1, %eax
xorl %ecx, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/ssl_util.c
// Function: as_array_destroy
static void as_array_destroy(apr_array_header_t * arr)
{
	for (int ii = 0; ii < arr->nelts; ++ii) {
		char ** ptr = (char **) (arr->elts + (ii * arr->elt_size));
		cf_free(*ptr);
	}
	if (arr->elts) {
		cf_free(arr->elts);
	}
	cf_free(arr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x1f563
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rdx
imull 0x8(%rdx), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x8aa0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1f523
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x1f57b
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x8aa0
movq -0x8(%rbp), %rdi
callq 0x8aa0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/ssl_util.c
// Function: as_apr_array_push
static void * as_apr_array_push(apr_array_header_t * arr)
{
	// If we don't have enough space double up.
	if (arr->nelts == arr->nalloc) {
		if (arr->nalloc == 0) {
			arr->nalloc = 16;
		} else {
			arr->nalloc *= 2;
		}
		size_t newsz = arr->nalloc * arr->elt_size;
		arr->elts = cf_realloc(arr->elts, newsz);
	}

	// Point to the first unused location.
	void * ptr = arr->elts + (arr->nelts * arr->elt_size);

	// We'll have one more element now.
	++arr->nelts;
	
    return ptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jne 0x1f890
movq -0x8(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x1f853
movq -0x8(%rbp), %rax
movl $0x10, 0x10(%rax)
jmp 0x1f85f
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
shll %ecx
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movq -0x8(%rbp), %rcx
imull 0x8(%rcx), %eax
cltq
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x85b0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0xc(%rcx), %ecx
movq -0x8(%rbp), %rdx
imull 0x8(%rdx), %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0xc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/aerospike/ssl_util.c
// Function: as_apr_array_make
static apr_array_header_t * as_apr_array_make(apr_pool_t * pp,
                                    size_t nelts,
                                    size_t eltsz)
{
	// This routine isn't prepared for non-zero nelts; extend
	// it if this is needed in the future ...
	assert(nelts == 0);

	apr_array_header_t * arr = cf_malloc(sizeof(apr_array_header_t));
	arr->pool = NULL;
	arr->elt_size = (int)eltsz;
	arr->nelts = (int)nelts;
	arr->nalloc = (int)nelts;
	arr->elts = NULL;
    return arr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1f90d
jmp 0x1f92c
leaq 0x7c2a(%rip), %rdi      # 0x2753e
leaq 0x7b96(%rip), %rsi      # 0x274b1
movl $0x58, %edx
leaq 0x7c22(%rip), %rcx      # 0x27549
callq 0x8400
movl $0x20, %edi
callq 0x8090
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
movq -0x18(%rbp), %rax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x10(%rbp), %rax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x20(%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/ssl_util.c
// Function: asn1_string_to_utf8
static char *asn1_string_to_utf8(apr_pool_t *p, ASN1_STRING *asn1str)
{
    char *result = NULL;
    BIO *bio;
    int len;

    if ((bio = BIO_new(BIO_s_mem())) == NULL)
        return NULL;

    ASN1_STRING_print_ex(bio, asn1str, ASN1_STRFLGS_ESC_CTRL|
                                       ASN1_STRFLGS_UTF8_CONVERT);
    len = BIO_pending(bio);
    if (len > 0) {
		result = cf_malloc(len+1);
        len = BIO_read(bio, result, len);
        result[len] = NUL;
    }
    BIO_free(bio);
    return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
callq 0x8c40
movq %rax, %rdi
callq 0x87f0
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x1f9c9
movq $0x0, -0x8(%rbp)
jmp 0x1fa3b
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x12, %edx
callq 0x83b0
movq -0x28(%rbp), %rdi
movl $0xa, %esi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x8800
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jle 0x1fa2a
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0x8090
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x2c(%rbp), %edx
callq 0x8290
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x28(%rbp), %rdi
callq 0x8830
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
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/ssl_util.c
// Function: parse_otherName_value
static void parse_otherName_value(apr_pool_t *p, ASN1_TYPE *value,
                                  const char *onf, apr_array_header_t **entries)
{
    const char *str;
    int nid = onf ? OBJ_txt2nid(onf) : NID_undef;

    if (!value || (nid == NID_undef) || !*entries)
       return;

    /* 
     * Currently supported otherName forms (values for "onf"):
     * "msUPN" (1.3.6.1.4.1.311.20.2.3): Microsoft User Principal Name
     * "id-on-dnsSRV" (1.3.6.1.5.5.7.8.7): SRVName, as specified in RFC 4985
     */
    if ((nid == NID_ms_upn) && (value->type == V_ASN1_UTF8STRING) &&
        (str = asn1_string_to_utf8(p, value->value.utf8string))) {
        APR_ARRAY_PUSH(*entries, const char *) = str;
    } else if (strEQ(onf, "id-on-dnsSRV") &&
               (value->type == V_ASN1_IA5STRING) &&
               (str = asn1_string_to_utf8(p, value->value.ia5string))) {
        APR_ARRAY_PUSH(*entries, const char *) = str;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1fa7d
movq -0x18(%rbp), %rdi
callq 0x8130
movl %eax, -0x30(%rbp)
jmp 0x1fa84
xorl %eax, %eax
movl %eax, -0x30(%rbp)
jmp 0x1fa84
movl -0x30(%rbp), %eax
movl %eax, -0x2c(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1faa1
cmpl $0x0, -0x2c(%rbp)
je 0x1faa1
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x1faa6
jmp 0x1fb46
cmpl $0x289, -0x2c(%rbp)     # imm = 0x289
jne 0x1faf0
movq -0x10(%rbp), %rax
cmpl $0xc, (%rax)
jne 0x1faf0
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x1f990
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x1faf0
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x1f820
movq -0x38(%rbp), %rcx
movq %rcx, (%rax)
jmp 0x1fb46
movq -0x18(%rbp), %rdi
leaq 0x7a92(%rip), %rsi      # 0x2758d
callq 0x8610
cmpl $0x0, %eax
jne 0x1fb44
movq -0x10(%rbp), %rax
cmpl $0x16, (%rax)
jne 0x1fb44
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x1f990
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x1fb44
movq -0x28(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x1f820
movq -0x40(%rbp), %rcx
movq %rcx, (%rax)
jmp 0x1fb46
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/citrusleaf/cf_alloc.c
// Function: cf_rc_alloc
void*
cf_rc_alloc(size_t sz)
{
	cf_rc_hdr* head = malloc(sizeof(cf_rc_hdr) + sz);

	head->count = 1;
	head->sz = (uint32_t)sz;

	return head + 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
callq 0x8790
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
movq -0x8(%rbp), %rax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
addq $0x8, %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/citrusleaf/cf_alloc.c
// Function: cf_rc_release
uint32_t
cf_rc_release(void* addr)
{
	cf_rc_hdr* head = (cf_rc_hdr*)addr - 1;
	uint32_t rc = as_aaf_uint32_rls(&head->count, -1);

	if (rc == 0) {
		// Subsequent destructor may require an 'acquire' barrier.
		as_fence_acq();
	}

	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $-0x8, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x1fd80
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x1fd6f
movl -0x14(%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_alloc.c
// Function: cf_rc_releaseandfree
uint32_t
cf_rc_releaseandfree(void* addr)
{
	cf_rc_hdr* head = (cf_rc_hdr*)addr - 1;
	uint32_t rc = as_aaf_uint32_rls(&head->count, -1);

	if (rc == 0) {
		free(head);
	}

	return rc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $-0x8, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x1fd80
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x1fde8
movq -0x10(%rbp), %rdi
callq 0x8100
movl -0x14(%rbp), %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_b64.c
// Function: cf_b64_decode
void
cf_b64_decode(const char* in, uint32_t in_len, uint8_t* out, uint32_t* out_size)
{
	uint32_t i = 0;
	uint32_t j = 0;

	while (i < in_len) {
		uint8_t i0 = (uint8_t)in[i];
		uint8_t i1 = (uint8_t)in[i + 1];
		uint8_t i2 = (uint8_t)in[i + 2];
		uint8_t i3 = (uint8_t)in[i + 3];

		out[j]     = (DA[i0] << 2) | (DA[i1] >> 4);
		out[j + 1] = (DA[i1] << 4) | (DA[i2] >> 2);
		out[j + 2] = (DA[i2] << 6) |  DA[i3];

		i += 4;
		j += 3;
	}

	if (out_size) {
		if (i != 0) {
			if (in[i - 1] == '=') {
				j--;
			}

			if (in[i - 2] == '=') {
				j--;
			}
		}

		*out_size = j;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x201b0
movq -0x8(%rbp), %rax
movl -0x24(%rbp), %ecx
movb (%rax,%rcx), %al
movb %al, -0x29(%rbp)
movq -0x8(%rbp), %rax
movl -0x24(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, %ecx
movb (%rax,%rcx), %al
movb %al, -0x2a(%rbp)
movq -0x8(%rbp), %rax
movl -0x24(%rbp), %ecx
addl $0x2, %ecx
movl %ecx, %ecx
movb (%rax,%rcx), %al
movb %al, -0x2b(%rbp)
movq -0x8(%rbp), %rax
movl -0x24(%rbp), %ecx
addl $0x3, %ecx
movl %ecx, %ecx
movb (%rax,%rcx), %al
movb %al, -0x2c(%rbp)
movzbl -0x29(%rbp), %eax
movl %eax, %ecx
leaq 0x74e3(%rip), %rax      # 0x275e0
movzbl (%rax,%rcx), %eax
shll $0x2, %eax
movzbl -0x2a(%rbp), %ecx
movl %ecx, %edx
leaq 0x74cf(%rip), %rcx      # 0x275e0
movzbl (%rcx,%rdx), %ecx
sarl $0x4, %ecx
orl %ecx, %eax
movb %al, %dl
movq -0x18(%rbp), %rax
movl -0x28(%rbp), %ecx
movb %dl, (%rax,%rcx)
movzbl -0x2a(%rbp), %eax
movl %eax, %ecx
leaq 0x74ad(%rip), %rax      # 0x275e0
movzbl (%rax,%rcx), %eax
shll $0x4, %eax
movzbl -0x2b(%rbp), %ecx
movl %ecx, %edx
leaq 0x7499(%rip), %rcx      # 0x275e0
movzbl (%rcx,%rdx), %ecx
sarl $0x2, %ecx
orl %ecx, %eax
movb %al, %dl
movq -0x18(%rbp), %rax
movl -0x28(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movzbl -0x2b(%rbp), %eax
movl %eax, %ecx
leaq 0x7472(%rip), %rax      # 0x275e0
movzbl (%rax,%rcx), %eax
shll $0x6, %eax
movzbl -0x2c(%rbp), %ecx
movl %ecx, %edx
leaq 0x745e(%rip), %rcx      # 0x275e0
movzbl (%rcx,%rdx), %ecx
orl %ecx, %eax
movb %al, %dl
movq -0x18(%rbp), %rax
movl -0x28(%rbp), %ecx
addl $0x2, %ecx
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movl -0x24(%rbp), %eax
addl $0x4, %eax
movl %eax, -0x24(%rbp)
movl -0x28(%rbp), %eax
addl $0x3, %eax
movl %eax, -0x28(%rbp)
jmp 0x200a1
cmpq $0x0, -0x20(%rbp)
je 0x20204
cmpl $0x0, -0x24(%rbp)
je 0x201fb
movq -0x8(%rbp), %rax
movl -0x24(%rbp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movsbl (%rax,%rcx), %eax
cmpl $0x3d, %eax
jne 0x201db
movl -0x28(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movl -0x24(%rbp), %ecx
subl $0x2, %ecx
movl %ecx, %ecx
movsbl (%rax,%rcx), %eax
cmpl $0x3d, %eax
jne 0x201f9
movl -0x28(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x201fb
movl -0x28(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/citrusleaf/cf_b64.c
// Function: cf_b64_validate_and_decode
bool
cf_b64_validate_and_decode(const char* in, uint32_t in_len, uint8_t* out,
		uint32_t* out_size)
{
	if (! is_valid_encoded(in, in_len)) {
		return false;
	}

	cf_b64_decode(in, in_len, out, out_size);

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x20410
testb $0x1, %al
jne 0x203ed
movb $0x0, -0x1(%rbp)
jmp 0x20405
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x8280
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/aerospike[P]aerospike-common/src/main/citrusleaf/cf_b64.c
// Function: is_valid_encoded
static bool
is_valid_encoded(const char* in, uint32_t in_len)
{
	if (! in || in_len == 0 || (in_len & 3) != 0) {
		return false;
	}

	const uint8_t* end = (const uint8_t*)in + in_len - 2;
	const uint8_t* read = (const uint8_t*)in;

	while (read < end) {
		if (! VA[*read++]) {
			return false;
		}
	}

	if (*read == '=') {
		return *(read + 1) == '=';
	}

	if (! VA[*read++]) {
		return false;
	}

	return *read == '=' || VA[*read];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x20433
cmpl $0x0, -0x14(%rbp)
je 0x20433
movl -0x14(%rbp), %eax
andl $0x3, %eax
cmpl $0x0, %eax
je 0x2043c
movb $0x0, -0x1(%rbp)
jmp 0x20500
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addq %rcx, %rax
addq $-0x2, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x20489
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x7265(%rip), %rax      # 0x276e0
testb $0x1, (%rax,%rcx)
jne 0x20487
movb $0x0, -0x1(%rbp)
jmp 0x20500
jmp 0x20456
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x3d, %eax
jne 0x204aa
movq -0x28(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0x3d, %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x20500
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x721b(%rip), %rax      # 0x276e0
testb $0x1, (%rax,%rcx)
jne 0x204d1
movb $0x0, -0x1(%rbp)
jmp 0x20500
movq -0x28(%rbp), %rax
movzbl (%rax), %ecx
movb $0x1, %al
cmpl $0x3d, %ecx
movb %al, -0x29(%rbp)
je 0x204f8
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
movl %eax, %ecx
leaq 0x71ee(%rip), %rax      # 0x276e0
movb (%rax,%rcx), %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw (%rax,%rax)