LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/sharpyfox[P]citrusleaf-client/src/citrusleaf.c
// Function: cl_write_header
uint8_t *
cl_write_header(uint8_t *buf, size_t msg_sz, uint info1, uint info2, uint info3, uint32_t generation, uint32_t record_ttl, uint32_t transaction_ttl, uint32_t n_fields, uint32_t n_ops )
{
	as_msg *msg = (as_msg *) buf;
	
	msg->proto.version = CL_PROTO_VERSION;
	msg->proto.type = CL_PROTO_TYPE_CL_MSG;
	msg->proto.sz = msg_sz - sizeof(cl_proto);
	cl_proto_swap(&msg->proto);
	msg->m.header_sz = sizeof(cl_msg);
	msg->m.info1 = info1;
	msg->m.info2 = info2;
	msg->m.info3 = info3;
	msg->m.unused = 0;
	msg->m.result_code = 0;
	msg->m.generation = generation;
	msg->m.record_ttl = record_ttl;
	msg->m.transaction_ttl = transaction_ttl;
	msg->m.n_fields = n_fields;
	msg->m.n_ops = n_ops;
	cl_msg_swap_header(&msg->m);
	return (buf + sizeof(as_msg));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebp
movl %r8d, %r14d
movl %ecx, %r15d
movl %edx, %r12d
movq %rdi, %rbx
movl 0x40(%rsp), %r13d
movw $0x302, (%rdi)          # imm = 0x302
addq $-0x8, %rsi
movl %esi, 0x2(%rdi)
shrq $0x20, %rsi
movw %si, 0x6(%rdi)
callq 0xccb0
leaq 0x8(%rbx), %rdi
movb $0x16, 0x8(%rbx)
movb %r12b, 0x9(%rbx)
movb %r15b, 0xa(%rbx)
movb %r14b, 0xb(%rbx)
movw $0x0, 0xc(%rbx)
movl %ebp, 0xe(%rbx)
movl %r13d, 0x12(%rbx)
movl 0x48(%rsp), %eax
movl %eax, 0x16(%rbx)
movzwl 0x50(%rsp), %eax
movw %ax, 0x1a(%rbx)
movzwl 0x58(%rsp), %eax
movw %ax, 0x1c(%rbx)
callq 0xcccd
addq $0x1e, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/sharpyfox[P]citrusleaf-client/src/citrusleaf.c
// Function: cl_value_to_op_get_size
int
cl_value_to_op_get_size(cl_bin *v, size_t *sz)
{
	switch(v->object.type) {
		case CL_NULL:
			break;
		case CL_INT:
			*sz += value_to_op_int_sz(v->object.u.i64);
			break;
		case CL_STR:
			*sz += v->object.sz;
			break;
		case CL_PYTHON_BLOB:
		case CL_RUBY_BLOB:
		case CL_JAVA_BLOB:
		case CL_CSHARP_BLOB:
		case CL_BLOB:
		case CL_PHP_BLOB:
			*sz += v->object.sz;
			break;
		default:
			cf_error("internal error value_to_op get size has unknown value type %d", v->object.type);
			return(-1);
	}
	return(0);
}

// Assembly:
pushq %rbx
movl 0x20(%rdi), %edx
cmpq $0xb, %rdx
ja 0x49f9
leaq 0xbce3(%rip), %rax      # 0x106bc
movslq (%rax,%rdx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq 0x28(%rdi), %rax
addq %rax, (%rsi)
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
retq
movl %edx, %ebx
jmp 0x49eb
addq $0x8, (%rsi)
jmp 0x49e9
leaq 0x128c8(%rip), %rax     # 0x172c8
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpl $0x0, (%rax)
js 0x49eb
leaq 0x128bf(%rip), %rax     # 0x172d0
movq (%rax), %rcx
leaq 0xbdb6(%rip), %rsi      # 0x107d1
xorl %edi, %edi
xorl %eax, %eax
callq *%rcx
jmp 0x49eb
// File: /workspace/github_c_makefile_star2_O1/sharpyfox[P]citrusleaf-client/src/citrusleaf.c
// Function: cl_set_value_particular
void
cl_set_value_particular(cl_msg_op *op, cl_bin *value)
{
	if (op->name_sz > sizeof(value->bin_name)) {
#ifdef DEBUG		
		cf_debug("Set Value Particular: bad response from server");
#endif	
		return;
	}
	
	memcpy(value->bin_name, op->name, op->name_sz);
	value->bin_name[op->name_sz] = 0;
	set_object(op, &value->object);
}

// Assembly:
movzbl 0x7(%rdi), %edx
cmpq $0x20, %rdx
jbe 0x5203
retq
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rdi), %rsi
movq %rbx, %rdi
callq 0x21b0
movzbl 0x7(%r14), %eax
movb $0x0, (%rbx,%rax)
addq $0x20, %rbx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x5235
// File: /workspace/github_c_makefile_star2_O1/sharpyfox[P]citrusleaf-client/src/citrusleaf.c
// Function: set_object
static int
set_object(cl_msg_op *op, cl_object *obj)
{
	int rv = 0;
	
	obj->type = op->particle_type;
	
	switch(op->particle_type) {
		case CL_NULL:
			obj->sz = 0;
			obj->free = 0;
			break;
		case CL_INT:
			obj->sz = 0; // unused in integer case
			obj->free = 0;
			rv = op_to_value_int(cl_msg_op_get_value_p(op), cl_msg_op_get_value_sz(op),&(obj->u.i64));
			break;
		case CL_STR:
			obj->sz = cl_msg_op_get_value_sz(op);
			obj->free = obj->u.str = malloc(obj->sz+1);
			if (obj->free == NULL)	return(-1);
			memcpy(obj->u.str, cl_msg_op_get_value_p(op), obj->sz);
			obj->u.str[obj->sz] = 0;
			break;
		case CL_BLOB:
		case CL_JAVA_BLOB:
		case CL_CSHARP_BLOB:
		case CL_PYTHON_BLOB:
		case CL_RUBY_BLOB:
		case CL_PHP_BLOB:
			obj->sz = cl_msg_op_get_value_sz(op);
			obj->free = obj->u.blob = malloc(obj->sz);
			if (obj->free == 0)	return(-1);
			memcpy(obj->u.blob, cl_msg_op_get_value_p(op), obj->sz);
			break;
		default:
			cf_error("parse: received unknown object type %d", op->particle_type);
			return(-1);
	}
	return(rv);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movzbl 0x5(%rdi), %eax
movl %eax, (%rsi)
movzbl 0x5(%rdi), %edx
cmpq $0xb, %rdx
ja 0x5350
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xb4ea(%rip), %rax      # 0x10748
movslq (%rax,%rdx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movl (%r14), %r15d
movzbl 0x7(%r14), %eax
subl %eax, %r15d
addl $-0x4, %r15d
movq %r15, 0x8(%rbx)
movq %r15, %rdi
callq 0x22e0
movq %rax, 0x10(%rbx)
movq %rax, 0x18(%rbx)
testq %rax, %rax
je 0x53bf
movzbl 0x7(%r14), %ecx
leaq 0x8(%r14,%rcx), %rsi
movq %rax, %rdi
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x21b0
movl (%r14), %r15d
movzbl 0x7(%r14), %eax
subl %eax, %r15d
addl $-0x4, %r15d
movq %r15, 0x8(%rbx)
leaq 0x1(%r15), %rdi
callq 0x22e0
movq %rax, 0x10(%rbx)
movq %rax, 0x18(%rbx)
testq %rax, %rax
je 0x53bf
movq %rax, %r12
movzbl 0x7(%r14), %eax
leaq 0x8(%r14,%rax), %rsi
movq %r12, %rdi
movq %r15, %rdx
callq 0x21b0
movb $0x0, (%r12,%r15)
jmp 0x53bf
xorl %eax, %eax
movq %rax, 0x8(%rbx)
movq %rax, 0x18(%rbx)
jmp 0x53bf
xorl %eax, %eax
movq %rax, 0x8(%rbx)
movq %rax, 0x18(%rbx)
movzbl 0x7(%r14), %ecx
movl (%r14), %eax
subl %ecx, %eax
addl $-0x4, %eax
cmpl $0x8, %eax
jg 0x53bf
testl %eax, %eax
je 0x53aa
leaq 0x8(%r14,%rcx), %rcx
cmpl $0x1, %eax
je 0x537e
cmpl $0x8, %eax
jne 0x5387
movq (%rcx), %rax
bswapq %rax
movq %rax, 0x10(%rbx)
jmp 0x53bf
leaq 0x11f71(%rip), %rax     # 0x172c8
cmpl $0x0, (%rax)
js 0x53bf
leaq 0x11f6d(%rip), %rax     # 0x172d0
movq (%rax), %rcx
leaq 0xb574(%rip), %rsi      # 0x108e1
xorl %edi, %edi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmpq *%rcx
movzbl (%rcx), %edx
cmpq $0x7e, %rdx
jbe 0x53bb
movzbl (%rcx), %edx
testb %dl, %dl
js 0x53b4
testl %eax, %eax
jle 0x53b9
xorl %esi, %esi
shlq $0x8, %rsi
movzbl (%rcx), %edx
orq %rsi, %rdx
incq %rcx
decl %eax
movq %rdx, %rsi
jne 0x5394
jmp 0x53bb
movq $0x0, 0x10(%rbx)
jmp 0x53bf
bswapq %rdx
jmp 0x53bb
xorl %edx, %edx
movq %rdx, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/sharpyfox[P]citrusleaf-client/src/citrusleaf.c
// Function: citrusleaf_get
extern cl_rv
citrusleaf_get(cl_cluster *asc, const char *ns, const char *set, const cl_object *key, cl_bin *values, int n_values, int timeout_ms, uint32_t *cl_gen)
{
    if (!g_initialized) return(-1);

    	uint64_t trid=0;
	cl_write_parameters cl_w_p;
	cl_write_parameters_set_default(&cl_w_p);
	cl_w_p.timeout_ms = timeout_ms;

	return( do_the_full_monte( asc, CL_MSG_INFO1_READ, 0, 0, ns, set, key, 0, &values, 
			CL_OP_READ, 0, &n_values, cl_gen, &cl_w_p, &trid, NULL) );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, 0x10(%rsp)
movl %r9d, 0xc(%rsp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpb $0x1, 0x13c70(%rip)     # 0x193a0
jne 0x57a7
movq %rcx, %r10
movq %rdx, %r11
movq %rsi, %rbx
movq 0x78(%rsp), %r14
movl 0x70(%rsp), %ecx
xorl %eax, %eax
leaq 0x18(%rsp), %r15
movq %rax, (%r15)
movabsq $0x200000000, %rdx      # imm = 0x200000000
leaq 0x20(%rsp), %r12
movq %rdx, 0x10(%r12)
movl $0x0, (%r12)
movb $0x0, 0x4(%r12)
movl %ecx, 0xc(%r12)
leaq 0xc(%rsp), %r13
leaq 0x10(%rsp), %rbp
movl $0x1, %esi
xorl %edx, %edx
xorl %ecx, %ecx
movq %rbx, %r8
movq %r11, %r9
pushq %rax
pushq %r15
pushq %r12
pushq %r14
pushq %r13
pushq %rax
pushq $0x1
pushq %rbp
pushq %rax
pushq %r10
callq 0x57b6
addq $0x50, %rsp
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/sharpyfox[P]citrusleaf-client/src/citrusleaf.c
// Function: citrusleaf_get_digest
extern cl_rv
citrusleaf_get_digest(cl_cluster *asc, const char *ns, const cf_digest *digest, cl_bin *values, int n_values, int timeout_ms, uint32_t *cl_gen)
{
	
    if (!g_initialized) return(-1);
    
    	uint64_t trid=0;
	cl_write_parameters cl_w_p;
	cl_write_parameters_set_default(&cl_w_p);
	cl_w_p.timeout_ms = timeout_ms;

	return( do_the_full_monte( asc, CL_MSG_INFO1_READ, 0, 0, ns, 0,0, digest, &values, 
			CL_OP_READ, 0, &n_values, cl_gen, &cl_w_p, &trid, NULL) );
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rcx, 0x8(%rsp)
movl %r8d, 0x4(%rsp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpb $0x1, 0x135af(%rip)     # 0x193a0
jne 0x5e5d
movq %rdx, %r10
movq %rsi, %r11
movq 0x60(%rsp), %rbx
xorl %eax, %eax
leaq 0x10(%rsp), %r14
movq %rax, (%r14)
movabsq $0x200000000, %rcx      # imm = 0x200000000
leaq 0x18(%rsp), %r15
movq %rcx, 0x10(%r15)
movl $0x0, (%r15)
movb $0x0, 0x4(%r15)
movl %r9d, 0xc(%r15)
leaq 0x4(%rsp), %r12
leaq 0x8(%rsp), %r13
movl $0x1, %esi
xorl %edx, %edx
xorl %ecx, %ecx
movq %r11, %r8
xorl %r9d, %r9d
pushq %rax
pushq %r14
pushq %r15
pushq %rbx
pushq %r12
pushq %rax
pushq $0x1
pushq %r13
pushq %r10
pushq %rax
callq 0x57b6
addq $0x50, %rsp
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/sharpyfox[P]citrusleaf-client/src/citrusleaf.c
// Function: citrusleaf_async_put_forget
extern cl_rv
citrusleaf_async_put_forget(cl_cluster *asc, const char *ns, const char *set, const cl_object *key,
	const cl_bin *bins, int n_bins, const cl_write_parameters *cl_w_p)
{
	if (!g_initialized) return(-1);
	uint64_t trid = 0;

	return( cl_do_async_monte( asc, 0, CL_MSG_INFO2_WRITE, ns, set, key, 0, (cl_bin **) &bins,
		CL_OP_WRITE, 0, &n_bins, NULL, cl_w_p, &trid, 0) );
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, 0x8(%rsp)
movl %r9d, 0x4(%rsp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpb $0x1, 0x13240(%rip)     # 0x193a0
jne 0x61ab
movq %rcx, %r10
movq %rdx, %r11
movq %rsi, %rcx
movq 0x40(%rsp), %rax
xorl %ebx, %ebx
leaq 0x10(%rsp), %r14
movq %rbx, (%r14)
subq $0x8, %rsp
leaq 0xc(%rsp), %r15
leaq 0x10(%rsp), %r12
xorl %esi, %esi
movl $0x1, %edx
movq %r11, %r8
movq %r10, %r9
pushq %rbx
pushq %r14
pushq %rax
pushq %rbx
pushq %r15
pushq %rbx
pushq $0x0
pushq %r12
pushq %rbx
callq 0xa508
addq $0x50, %rsp
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/sharpyfox[P]citrusleaf-client/src/citrusleaf.c
// Function: citrusleaf_async_put_digest_forget
extern cl_rv
citrusleaf_async_put_digest_forget(cl_cluster *asc, const char *ns, const cf_digest *d, const char *set,
	const cl_bin *bins, int n_bins, const cl_write_parameters *cl_w_p)
{
	if (!g_initialized) return(-1);
	uint64_t trid = 0;

	return( cl_do_async_monte( asc, 0, CL_MSG_INFO2_WRITE, ns, set, 0, d, (cl_bin **) &bins,
		CL_OP_WRITE, 0, &n_bins, NULL, cl_w_p, &trid, 0) );
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, 0x8(%rsp)
movl %r9d, 0x4(%rsp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpb $0x1, 0x131c8(%rip)     # 0x193a0
jne 0x6224
movq %rcx, %r11
movq %rdx, %r10
movq %rsi, %rcx
movq 0x40(%rsp), %rax
xorl %ebx, %ebx
leaq 0x10(%rsp), %r14
movq %rbx, (%r14)
subq $0x8, %rsp
leaq 0xc(%rsp), %r15
leaq 0x10(%rsp), %r12
xorl %esi, %esi
movl $0x1, %edx
movq %r11, %r8
xorl %r9d, %r9d
pushq %rbx
pushq %r14
pushq %rax
pushq %rbx
pushq %r15
pushq %rbx
pushq $0x0
pushq %r12
pushq %r10
callq 0xa508
addq $0x50, %rsp
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/sharpyfox[P]citrusleaf-client/src/citrusleaf.c
// Function: citrusleaf_check_cluster_health
extern cl_rvclient
citrusleaf_check_cluster_health(cl_cluster *asc)
{
	int number_of_nodes_alive = 0;

	pthread_mutex_lock(&asc->LOCK);
	for (uint i = 0; i < cf_vector_size(&asc->node_v); i++) {
		cl_cluster_node *cn = cf_vector_pointer_get(&asc->node_v, i);

		if (cn->dunned == false){
			number_of_nodes_alive++;
		}
	}
	pthread_mutex_unlock(&asc->LOCK);

	if (number_of_nodes_alive > 0)
		return CITRUSLEAF_FAIL_DC_UP;
	else
		return CITRUSLEAF_FAIL_DC_DOWN;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x158(%rdi), %rbx
movq %rbx, %rdi
callq 0x23b0
cmpl $0x0, 0x104(%r14)
je 0x630f
leaq 0xf8(%r14), %r15
xorl %ebp, %ebp
movq %rsp, %r12
xorl %r13d, %r13d
movq %r15, %rdi
movl %ebp, %esi
movq %r12, %rdx
callq 0xec6f
movq (%rsp), %rax
movzbl 0x18(%rax), %eax
xorl $0x1, %eax
addl %eax, %r13d
incl %ebp
cmpl 0x104(%r14), %ebp
jb 0x62db
cmpl $0x1, %r13d
movl $0x2, %ebp
sbbl $0x0, %ebp
jmp 0x6314
movl $0x1, %ebp
movq %rbx, %rdi
callq 0x2190
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/sharpyfox[P]citrusleaf-client/src/citrusleaf.c
// Function: citrusleaf_exists_key
extern cl_rv
citrusleaf_exists_key(cl_cluster *asc, const char *ns, const char *set, const cl_object *key, cl_bin *values, int n_values, int timeout_ms, uint32_t *cl_gen)
{
    if (!g_initialized) return(-1);

    	uint64_t trid=0;
	cl_write_parameters cl_w_p;
	cl_write_parameters_set_default(&cl_w_p);
	cl_w_p.timeout_ms = timeout_ms;

	return( do_the_full_monte( asc, CL_MSG_INFO1_READ | CL_MSG_INFO1_NOBINDATA, 0, 0, 
			ns, set, key, 0, &values, CL_OP_READ, 0, &n_values, cl_gen, 
			&cl_w_p, &trid, NULL) );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, 0x10(%rsp)
movl %r9d, 0xc(%rsp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpb $0x1, 0x12f67(%rip)     # 0x193a0
jne 0x64b0
movq %rcx, %r10
movq %rdx, %r11
movq %rsi, %rbx
movq 0x78(%rsp), %r14
movl 0x70(%rsp), %ecx
xorl %eax, %eax
leaq 0x18(%rsp), %r15
movq %rax, (%r15)
movabsq $0x200000000, %rdx      # imm = 0x200000000
leaq 0x20(%rsp), %r12
movq %rdx, 0x10(%r12)
movl $0x0, (%r12)
movb $0x0, 0x4(%r12)
movl %ecx, 0xc(%r12)
leaq 0xc(%rsp), %r13
leaq 0x10(%rsp), %rbp
movl $0x21, %esi
xorl %edx, %edx
xorl %ecx, %ecx
movq %rbx, %r8
movq %r11, %r9
pushq %rax
pushq %r15
pushq %r12
pushq %r14
pushq %r13
pushq %rax
pushq $0x1
pushq %rbp
pushq %rax
pushq %r10
callq 0x57b6
addq $0x50, %rsp
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/sharpyfox[P]citrusleaf-client/src/citrusleaf.c
// Function: citrusleaf_get_all
extern cl_rv
citrusleaf_get_all(cl_cluster *asc, const char *ns, const char *set, const cl_object *key, cl_bin **values, int *n_values, int timeout_ms, uint32_t *cl_gen)
{
	if ((values == 0) || (n_values == 0)) {
		cf_error("citrusleaf_get_all: illegal parameters passed");
		return(-1);
	}
    if (!g_initialized) return(-1);

	*values = 0;
	*n_values = 0;

    	uint64_t trid=0;
	cl_write_parameters cl_w_p;
	cl_write_parameters_set_default(&cl_w_p);
	cl_w_p.timeout_ms = timeout_ms;
	
	return( do_the_full_monte( asc, CL_MSG_INFO1_READ | CL_MSG_INFO1_GET_ALL, 0, 0, 
			ns, set, key, 0/*dig*/, values, CL_OP_READ, 0, n_values, 
			cl_gen, &cl_w_p, &trid, NULL) );
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %r11
movq %r8, %r10
movq %rcx, %rax
movq %rdx, %r9
testq %r8, %r8
setne %cl
testq %r11, %r11
setne %dl
testb %dl, %cl
jne 0x65b1
leaq 0x10d3e(%rip), %rax     # 0x172c8
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpl $0x0, (%rax)
js 0x6622
leaq 0x10d31(%rip), %rax     # 0x172d0
movq (%rax), %rcx
leaq 0xa2c4(%rip), %rsi      # 0x1086d
xorl %edi, %edi
xorl %eax, %eax
callq *%rcx
jmp 0x6622
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpb $0x1, 0x12de3(%rip)     # 0x193a0
jne 0x6622
movq %rsi, %r8
movq 0x58(%rsp), %r14
movl 0x50(%rsp), %ecx
xorl %ebx, %ebx
movq %rbx, (%r10)
movl %ebx, (%r11)
leaq 0x8(%rsp), %r15
movq %rbx, (%r15)
movabsq $0x200000000, %rdx      # imm = 0x200000000
leaq 0x10(%rsp), %r12
movq %rdx, 0x10(%r12)
movl %ebx, (%r12)
movb $0x0, 0x4(%r12)
movl %ecx, 0xc(%r12)
movl $0x3, %esi
xorl %edx, %edx
xorl %ecx, %ecx
pushq %rbx
pushq %r15
pushq %r12
pushq %r14
pushq %r11
pushq %rbx
pushq $0x1
pushq %r10
pushq %rbx
pushq %rax
callq 0x57b6
addq $0x50, %rsp
movl %eax, %ebx
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/sharpyfox[P]citrusleaf-client/src/citrusleaf.c
// Function: citrusleaf_get_all_digest_getsetname
extern cl_rv
citrusleaf_get_all_digest_getsetname(cl_cluster *asc, const char *ns, const cf_digest *digest, 
	cl_bin **values, int *n_values, int timeout_ms, uint32_t *cl_gen, char **setname)
{
	if ((values == 0) || (n_values == 0)) {
		cf_error("citrusleaf_get_all: illegal parameters passed");
		return(-1);
	}
    if (!g_initialized) return(-1);

	*values = 0;
	*n_values = 0;

    	uint64_t trid=0;
	cl_write_parameters cl_w_p;
	cl_write_parameters_set_default(&cl_w_p);
	cl_w_p.timeout_ms = timeout_ms;

	int info1 = CL_MSG_INFO1_READ | CL_MSG_INFO1_GET_ALL;
	// Currently, the setname is returned only if XDS bit is set (for backward compatibility reasons).
	// This will/should be made the default in the future.
	if (setname != NULL) {
		info1 |= CL_MSG_INFO1_XDS;
	}
	
	return( do_the_full_monte( asc, info1, 0, 0, ns, 0, 0, digest, values, 
			CL_OP_READ, 0, n_values, cl_gen, &cl_w_p, &trid, setname) );
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %r8, %r11
movq %rcx, %r10
movq %rdx, %rax
testq %rcx, %rcx
setne %cl
testq %r8, %r8
setne %dl
testb %dl, %cl
jne 0x6684
leaq 0x10c6b(%rip), %rax     # 0x172c8
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpl $0x0, (%rax)
js 0x6700
leaq 0x10c5e(%rip), %rax     # 0x172d0
movq (%rax), %rcx
leaq 0xa1f1(%rip), %rsi      # 0x1086d
xorl %edi, %edi
xorl %eax, %eax
callq *%rcx
jmp 0x6700
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpb $0x1, 0x12d10(%rip)     # 0x193a0
jne 0x6700
movq %rsi, %r8
movq 0x58(%rsp), %r15
movq 0x50(%rsp), %r14
xorl %ebx, %ebx
movq %rbx, (%r10)
movl %ebx, (%r11)
movq %rsp, %r12
movq %rbx, (%r12)
movabsq $0x200000000, %rcx      # imm = 0x200000000
leaq 0x8(%rsp), %r13
movq %rcx, 0x10(%r13)
movl %ebx, (%r13)
movb $0x0, 0x4(%r13)
movl %r9d, 0xc(%r13)
xorl %esi, %esi
testq %r15, %r15
setne %sil
shll $0x4, %esi
orl $0x3, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r9d, %r9d
pushq %r15
pushq %r12
pushq %r13
pushq %r14
pushq %r11
pushq %rbx
pushq $0x1
pushq %r10
pushq %rax
pushq %rbx
callq 0x57b6
addq $0x50, %rsp
movl %eax, %ebx
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/sharpyfox[P]citrusleaf-client/src/citrusleaf.c
// Function: citrusleaf_verify
extern cl_rv
citrusleaf_verify(cl_cluster *asc, const char *ns, const char *set, const cl_object *key, const cl_bin *values, int n_values, int timeout_ms, uint32_t *cl_gen)
{
    if (!g_initialized) return(-1);
    

    	uint64_t trid=0;
	cl_write_parameters cl_w_p;
	cl_write_parameters_set_default(&cl_w_p);
	cl_w_p.timeout_ms = timeout_ms;
	
	return( do_the_full_monte( asc, CL_MSG_INFO1_READ | CL_MSG_INFO1_VERIFY, 0, 0, 
			ns, set, key, 0, (cl_bin **) &values, CL_OP_READ, 0, &n_values, 
			cl_gen, &cl_w_p, &trid, NULL) );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, 0x10(%rsp)
movl %r9d, 0xc(%rsp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpb $0x1, 0x12c5a(%rip)     # 0x193a0
jne 0x67bd
movq %rcx, %r10
movq %rdx, %r11
movq %rsi, %rbx
movq 0x78(%rsp), %r14
movl 0x70(%rsp), %ecx
xorl %eax, %eax
leaq 0x18(%rsp), %r15
movq %rax, (%r15)
movabsq $0x200000000, %rdx      # imm = 0x200000000
leaq 0x20(%rsp), %r12
movq %rdx, 0x10(%r12)
movl $0x0, (%r12)
movb $0x0, 0x4(%r12)
movl %ecx, 0xc(%r12)
leaq 0xc(%rsp), %r13
leaq 0x10(%rsp), %rbp
movl $0x9, %esi
xorl %edx, %edx
xorl %ecx, %ecx
movq %rbx, %r8
movq %r11, %r9
pushq %rax
pushq %r15
pushq %r12
pushq %r14
pushq %r13
pushq %rax
pushq $0x1
pushq %rbp
pushq %rax
pushq %r10
callq 0x57b6
addq $0x50, %rsp
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/sharpyfox[P]citrusleaf-client/src/citrusleaf.c
// Function: citrusleaf_calculate_digest
extern int
citrusleaf_calculate_digest(const char *set, const cl_object *key, cf_digest *digest)
{
	int set_len = set ? strlen(set) : 0;
	
	// make the key as it's laid out for digesting
	// THIS IS A STRIPPED DOWN VERSION OF THE CODE IN write_fields ABOVE
	// MUST STAY IN SYNC!!!
	uint8_t k[key->sz + 1];
	switch (key->type) {
		case CL_STR:
			k[0] = key->type;
			memcpy(&k[1], key->u.str, key->sz);
			break;
		case CL_INT:
			k[0] = key->type;
			value_to_op_int(key->u.i64,&k[1]);
			break;
		case CL_BLOB:
		case CL_JAVA_BLOB:
		case CL_CSHARP_BLOB:
		case CL_PYTHON_BLOB:
		case CL_RUBY_BLOB:
		case CL_PHP_BLOB:
			k[0] = key->type;
			memcpy(&k[1], key->u.blob, key->sz);
			break;
		default:
			cf_error(" transmit key: unknown citrusleaf type %d", key->type);
			return(-1);
	}

	cf_digest_compute2((char *)set, set_len, k, key->sz + 1, digest);
	
	return(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, -0x30(%rbp)
movq %rsi, %rbx
movq %rdi, %r14
testq %rdi, %rdi
je 0x6846
movq %r14, %rdi
callq 0x20e0
movslq %eax, %r12
jmp 0x6849
xorl %r12d, %r12d
movq 0x8(%rbx), %r15
movq %rsp, %r13
leaq 0x10(%r15), %rax
andq $-0x10, %rax
subq %rax, %r13
movq %r13, %rsp
movl (%rbx), %edx
leal -0x1(%rdx), %eax
cmpl $0xa, %eax
ja 0x690c
leaq 0x9f05(%rip), %rcx      # 0x10778
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb %dl, (%r13)
leaq 0x1(%r13), %rdi
movq 0x10(%rbx), %rsi
movq %r15, %rdx
callq 0x21b0
incq %r15
testq %r12, %r12
je 0x68d1
leaq -0x90(%rbp), %rbx
movq %rbx, %rdi
callq 0x2370
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x23c0
movq %rbx, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x23c0
movq -0x30(%rbp), %rdi
movq %rbx, %rsi
callq 0x2490
jmp 0x68e0
movq %r13, %rdi
movq %r15, %rsi
movq -0x30(%rbp), %rdx
callq 0x2480
xorl %ebx, %ebx
movl %ebx, %eax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb $0x3, (%r13)
jmp 0x6880
movb $0x1, (%r13)
movq 0x10(%rbx), %rax
bswapq %rax
movq %rax, 0x1(%r13)
jmp 0x6890
leaq 0x109b5(%rip), %rax     # 0x172c8
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpl $0x0, (%rax)
js 0x68e2
leaq 0x109ac(%rip), %rax     # 0x172d0
movq (%rax), %rcx
leaq 0x9f6d(%rip), %rsi      # 0x1089b
xorl %edi, %edi
xorl %eax, %eax
callq *%rcx
jmp 0x68e2
// File: /workspace/github_c_makefile_star2_O1/sharpyfox[P]citrusleaf-client/src/citrusleaf.c
// Function: citrusleaf_operate
extern cl_rv
citrusleaf_operate(cl_cluster *asc, const char *ns, const char *set, const cl_object *key, cl_operation *operations, int n_operations, const cl_write_parameters *cl_w_p,  int replace, uint32_t *generation)
{
    if (!g_initialized) return(-1);
    
	// see if there are any read or write bits ---
	//   (this is slightly obscure c usage....)
	int info1 = 0, info2 = 0, info3 = 0;
	uint64_t trid=0;

	for (int i=0;i<n_operations;i++) {
		switch (operations[i].op) {
		case CL_OP_WRITE:
		case CL_OP_MC_INCR:
		case CL_OP_INCR:
		case CL_OP_APPEND:
		case CL_OP_PREPEND:
		case CL_OP_MC_APPEND:
		case CL_OP_MC_PREPEND:
		case CL_OP_MC_TOUCH:
		case CL_OP_TOUCH:
			info2 = CL_MSG_INFO2_WRITE;
			break;
		case CL_OP_READ:
			info1 = CL_MSG_INFO1_READ;
			break;
		default:
			break;
		}
		
		if (info1 && info2) break;
	}
	

	if (replace)
		info3 = CL_MSG_INFO3_REPLACE;

	return( do_the_full_monte( asc, info1, info2, info3, ns, set, key, 0, 0, 0, 
			&operations, &n_operations, generation, cl_w_p, &trid, NULL) );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, 0x10(%rsp)
movl %r9d, 0x4(%rsp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpb $0x1, 0x12a46(%rip)     # 0x193a0
jne 0x6a22
movq %rcx, %rbx
movq %rdx, %r11
movq %rsi, %r10
movq 0x60(%rsp), %rax
movl 0x58(%rsp), %ebp
movq 0x50(%rsp), %r14
movq $0x0, 0x8(%rsp)
testl %r9d, %r9d
jle 0x69d6
movl %r9d, %ecx
addq $0x40, %r8
xorl %edx, %edx
xorl %esi, %esi
movl (%r8), %r9d
leal -0x2(%r9), %r15d
cmpl $0x8, %r15d
jae 0x69c2
movl $0x1, %edx
testl %esi, %esi
setne %r9b
testl %edx, %edx
setne %r15b
andb %r9b, %r15b
cmpb $0x1, %r15b
je 0x69dc
addq $0x48, %r8
decq %rcx
jne 0x6990
jmp 0x69e6
cmpl $0x1, %r9d
je 0x69cf
testl %r9d, %r9d
je 0x699d
jmp 0x69a2
movl $0x1, %esi
jmp 0x69a2
xorl %esi, %esi
xorl %edx, %edx
jmp 0x69e6
movl $0x1, %esi
movl $0x1, %edx
xorl %ecx, %ecx
testl %ebp, %ebp
setne %cl
shll $0x3, %ecx
xorl %r15d, %r15d
leaq 0x8(%rsp), %r12
leaq 0x4(%rsp), %r13
leaq 0x10(%rsp), %rbp
movq %r10, %r8
movq %r11, %r9
pushq %r15
pushq %r12
pushq %r14
pushq %rax
pushq %r13
pushq %rbp
pushq $0x0
pushq %r15
pushq %r15
pushq %rbx
callq 0x57b6
addq $0x50, %rsp
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/sharpyfox[P]citrusleaf-client/src/citrusleaf.c
// Function: citrusleaf_init
int citrusleaf_init() 
{
	extern char *citrusleaf_build_string;
	cf_info("Aerospike client version %s", citrusleaf_build_string);

	// remember the process id which is spawning the background threads.
	// only this process can call a pthread_join() on the threads that it spawned.
	g_init_pid = getpid();

	citrusleaf_cluster_init();

#ifdef DEBUG_HISTOGRAM	
    if (NULL == (cf_hist = cf_histogram_create("transaction times")))
        cf_error("couldn't create histogram for client");
#endif	

    g_initialized = true;
    
	return(0);
}

// Assembly:
pushq %rax
leaq 0x10882(%rip), %rax     # 0x172c8
movl (%rax), %eax
cmpl $0x2, %eax
jl 0x6a71
leaq 0x1087c(%rip), %rax     # 0x172d0
movq (%rax), %rcx
leaq 0x1087a(%rip), %rax     # 0x172d8
movq (%rax), %rdx
leaq 0x9e5d(%rip), %rsi      # 0x108c5
movl $0x2, %edi
xorl %eax, %eax
callq *%rcx
callq 0x23a0
leaq 0x12927(%rip), %rcx     # 0x193a4
movl %eax, (%rcx)
xorl %eax, %eax
callq 0x877e
movb $0x1, 0x12913(%rip)     # 0x193a0
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/sharpyfox[P]citrusleaf-client/src/citrusleaf.c
// Function: citrusleaf_shutdown
void citrusleaf_shutdown(void) {

	if (g_initialized == false)
		return;

	citrusleaf_cluster_shutdown();
	citrusleaf_batch_shutdown();
	citrusleaf_async_shutdown();

	if (g_shared_memory) {
		citrusleaf_shm_free();
	}

	g_initialized = false;
}

// Assembly:
cmpb $0x1, 0x12908(%rip)     # 0x193a0
jne 0x6acc
pushq %rax
callq 0x73e8
xorl %eax, %eax
callq 0xa3f6
xorl %eax, %eax
callq 0xb107
leaq 0x12b23(%rip), %rax     # 0x195d8
cmpb $0x1, (%rax)
jne 0x6ac1
xorl %eax, %eax
callq 0xbe02
movb $0x0, 0x128d8(%rip)     # 0x193a0
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/sharpyfox[P]citrusleaf-client/src/cl_cluster.c
// Function: cl_cluster_node_get_byaddr
cl_cluster_node *
cl_cluster_node_get_byaddr(cl_cluster *asc, struct sockaddr_in *sa_in)
{
	// No need to lock nodes list because this function is only called by
	// cluster_tend() thread which has exclusive write access.
	for (uint i=0;i<cf_vector_size(&asc->node_v);i++) {
		cl_cluster_node *cn = cf_vector_pointer_get(&asc->node_v, i);
		for (uint j=0;j<cf_vector_size(&cn->sockaddr_in_v);j++) {
			struct sockaddr_in *node_sa_in = cf_vector_getp(&cn->sockaddr_in_v, j);
			if (memcmp(sa_in, node_sa_in, sizeof(struct sockaddr_in) ) == 0 ) {
				return(cn);
			}
		}
	}
	return(0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, 0x8(%rsp)
cmpl $0x0, 0x104(%rdi)
je 0x6ba7
leaq 0xf8(%rdi), %rax
movq %rax, 0x18(%rsp)
xorl %ebp, %ebp
movq %rdi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movl %ebp, %esi
leaq 0x20(%rsp), %rdx
callq 0xec6f
movq 0x20(%rsp), %rbx
cmpl $0x0, 0x2c(%rbx)
setne %r15b
je 0x6b8f
leaq 0x20(%rbx), %r13
movq %r13, %rdi
xorl %esi, %esi
callq 0xeccf
movq 0x8(%rsp), %rcx
movdqu (%rcx), %xmm0
movdqu (%rax), %xmm1
pcmpeqb %xmm0, %xmm1
pmovmskb %xmm1, %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
cmoveq %rbx, %r14
je 0x6b8f
movl $0x1, %r12d
cmpl 0x2c(%rbx), %r12d
setb %r15b
jae 0x6b8f
movq %r13, %rdi
movl %r12d, %esi
callq 0xeccf
movq 0x8(%rsp), %rcx
movdqu (%rcx), %xmm0
movdqu (%rax), %xmm1
pcmpeqb %xmm0, %xmm1
pmovmskb %xmm1, %eax
incl %r12d
cmpl $0xffff, %eax           # imm = 0xFFFF
cmoveq %rbx, %r14
jne 0x6b57
testb %r15b, %r15b
jne 0x6baa
incl %ebp
movq 0x10(%rsp), %rax
cmpl 0x104(%rax), %ebp
jb 0x6b03
xorl %r14d, %r14d
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/sharpyfox[P]citrusleaf-client/src/cl_cluster.c
// Function: citrusleaf_cluster_create
cl_cluster *
citrusleaf_cluster_create(void)
{
    if (! g_clust_initialized )    return(0);
    
	cl_cluster *asc = malloc(sizeof(cl_cluster));
	if (!asc)	return(0);
	
	asc->state = 0;
	asc->follow = true;
	asc->nbconnect = false;
	asc->found_all = false;
	asc->last_node = 0;
	asc->ref_count = 1;
	// Default is 0 so the cluster uses global tend period.
	// For the cluster user has to specifically set the own
	// value
	asc->tend_speed = 0;
	
	pthread_mutex_init(&asc->LOCK, 0);
	
	cf_vector_pointer_init(&asc->host_str_v, 10, 0);
	cf_vector_integer_init(&asc->host_port_v, 10, 0);
	cf_vector_pointer_init(&asc->host_addr_map_v, 10, 0);
	cf_vector_pointer_init(&asc->node_v, 10, 0);
	
	pthread_mutex_lock(&cluster_ll_LOCK);
	cf_ll_append(&cluster_ll, (cf_ll_element *) asc);
	pthread_mutex_unlock(&cluster_ll_LOCK);
	
	asc->n_partitions = 0;
	asc->partition_table_head = 0;
	
	return(asc);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x127e1(%rip), %rax     # 0x193a8
cmpl $0x0, (%rax)
je 0x6cb0
movl $0x180, %edi            # imm = 0x180
callq 0x22e0
movq %rax, %rbx
xorl %eax, %eax
testq %rbx, %rbx
je 0x6cb2
movl %eax, 0x10(%rbx)
movw $0x1, 0x14(%rbx)
movb $0x0, 0x16(%rbx)
movl %eax, 0xf0(%rbx)
movq $0x1, 0x150(%rbx)
leaq 0x158(%rbx), %rdi
xorl %esi, %esi
callq 0x2400
leaq 0x18(%rbx), %rdi
movl $0x8, %esi
movl $0xa, %edx
xorl %ecx, %ecx
callq 0xe894
leaq 0x60(%rbx), %rdi
movl $0x4, %esi
movl $0xa, %edx
xorl %ecx, %ecx
callq 0xe894
leaq 0xa8(%rbx), %rdi
movl $0x8, %esi
movl $0xa, %edx
xorl %ecx, %ecx
callq 0xe894
movq %rbx, %rdi
addq $0xf8, %rdi
movl $0x8, %esi
movl $0xa, %edx
xorl %ecx, %ecx
callq 0xe894
leaq 0x12738(%rip), %r14     # 0x193b0
movq %r14, %rdi
callq 0x23b0
leaq 0x12751(%rip), %rdi     # 0x193d8
movq %rbx, %rsi
callq 0xc839
movq %r14, %rdi
callq 0x2190
movw $0x0, 0x140(%rbx)
movq $0x0, 0x148(%rbx)
movq %rbx, %rax
jmp 0x6cb2
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/sharpyfox[P]citrusleaf-client/src/cl_cluster.c
// Function: citrusleaf_cluster_release_or_destroy
void
citrusleaf_cluster_release_or_destroy(cl_cluster **asc) {
#ifdef DEBUG
	if (asc && *asc) {
		cf_debug("release or destroy for cluster object - %p. ref_count = %d", *asc, (*asc)->ref_count);
	} else {
		cf_debug("release or destroy - asc is  NULL");
	}
#endif

	if (!asc || !(*asc))
		return;

	pthread_mutex_lock(&(*asc)->LOCK);
	if ((*asc)->ref_count > 0) {
		(*asc)->ref_count--;

		if (0 == (*asc)->ref_count) {
			pthread_mutex_unlock(&(*asc)->LOCK);
			// Destroy the object as reference count is 0
			#ifdef DEBUG
			cf_debug("destroying the cluster object as reference count is 0");
			#endif
			citrusleaf_cluster_destroy(*asc);
			*asc = NULL;
			return;
		}
	}
	pthread_mutex_unlock(&(*asc)->LOCK);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x7161
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x7161
addq $0x158, %rdi            # imm = 0x158
callq 0x23b0
movq (%rbx), %rax
movl 0x150(%rax), %ecx
testl %ecx, %ecx
je 0x7138
decl %ecx
movl %ecx, 0x150(%rax)
movq (%rbx), %rdi
cmpl $0x0, 0x150(%rdi)
je 0x7146
movl $0x158, %edi            # imm = 0x158
addq (%rbx), %rdi
popq %rbx
jmp 0x2190
addq $0x158, %rdi            # imm = 0x158
callq 0x2190
movq (%rbx), %rdi
callq 0x7163
movq $0x0, (%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/sharpyfox[P]citrusleaf-client/src/cl_cluster.c
// Function: cl_cluster_node_release
void
cl_cluster_node_release(cl_cluster_node *cn)
{
	int i;
	cl_async_work *aw;
	if (0 == cf_client_rc_release(cn)) {
		
		cf_vector_destroy(&cn->sockaddr_in_v);
		
		// Drain out the queue and close the FDs
		int rv;
		do {
			int	fd;
			rv = cf_queue_pop(cn->conn_q, &fd, CF_QUEUE_NOWAIT);
			if (rv == CF_QUEUE_OK)
				close(fd);
		} while (rv == CF_QUEUE_OK);
		do {
			int	fd;
			rv = cf_queue_pop(cn->conn_q_asyncfd, &fd, CF_QUEUE_NOWAIT);
			if (rv == CF_QUEUE_OK)
				close(fd);
		} while (rv == CF_QUEUE_OK);

		do {
			//When we reach this point, ideally there should not be any workitems.
			rv = cf_queue_pop(cn->asyncwork_q, &aw, CF_QUEUE_NOWAIT);
			if (rv == CF_QUEUE_OK) {
				free(aw);
			}
		} while (rv == CF_QUEUE_OK);

		//We want to delete all the workitems of this node
		if (g_cl_async_hashtab) {
			shash_reduce_delete(g_cl_async_hashtab, cl_del_node_asyncworkitems, cn);
		}

		//Now that all the workitems are released the FD can be closed
		if (cn->asyncfd != -1) {
			close(cn->asyncfd);
			cn->asyncfd = -1;
		}

		cf_queue_destroy(cn->conn_q);
		cf_queue_destroy(cn->conn_q_asyncfd);
		cf_queue_destroy(cn->asyncwork_q);
		pthread_mutex_destroy(&cn->LOCK);
		cf_client_rc_free(cn);
	}
	
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %esi, %esi
callq 0xc5d4
testq %rax, %rax
jne 0x73e0
leaq 0x20(%rbx), %rdi
callq 0xea0d
movq 0x70(%rbx), %rdi
movq %rsp, %rsi
xorl %edx, %edx
callq 0xd0df
testl %eax, %eax
jne 0x7311
movq %rsp, %r14
movl (%rsp), %edi
callq 0x2550
movq 0x70(%rbx), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xd0df
testl %eax, %eax
je 0x72f7
movq 0x78(%rbx), %rdi
movq %rsp, %rsi
xorl %edx, %edx
callq 0xd0df
testl %eax, %eax
jne 0x7340
movq %rsp, %r14
movl (%rsp), %edi
callq 0x2550
movq 0x78(%rbx), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xd0df
testl %eax, %eax
je 0x7326
movq 0x88(%rbx), %rdi
movq %rsp, %rsi
xorl %edx, %edx
callq 0xd0df
testl %eax, %eax
jne 0x7376
movq %rsp, %r14
movq (%rsp), %rdi
callq 0x22c0
movq 0x88(%rbx), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xd0df
testl %eax, %eax
je 0x7358
leaq 0x12243(%rip), %rax     # 0x195c0
movq (%rax), %rdi
testq %rdi, %rdi
je 0x7394
leaq 0x3172(%rip), %rsi      # 0xa4fe
movq %rbx, %rdx
callq 0x4445
movl 0x80(%rbx), %edi
cmpl $-0x1, %edi
je 0x73ae
callq 0x2550
movl $0xffffffff, 0x80(%rbx) # imm = 0xFFFFFFFF
movq 0x70(%rbx), %rdi
callq 0xcdfe
movq 0x78(%rbx), %rdi
callq 0xcdfe
movq 0x88(%rbx), %rdi
callq 0xcdfe
leaq 0x90(%rbx), %rdi
callq 0x22b0
movq %rbx, %rdi
callq 0xc61d
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/sharpyfox[P]citrusleaf-client/src/cl_cluster.c
// Function: citrusleaf_cluster_add_addr_map
void
citrusleaf_cluster_add_addr_map(cl_cluster *asc, char *orig, char *alt)
{
	int	i, vsz;
	cl_addrmap *oldmap=NULL, *newmap=NULL;


	//Search if the given mapping already exists
	vsz = asc->host_addr_map_v.len;
	for (i=0; i<vsz; i++)
	{
		oldmap = cf_vector_pointer_get(&asc->host_addr_map_v, i);
		if (oldmap && strcmp(oldmap->orig, orig) == 0) {
			//The original address is already in the map. update its alternative.
			free(oldmap->alt); //free the old string.
			oldmap->alt = strdup(alt);
			return;
		}
	}

	//We need to add the supplied map only if does not already exist
	if (i==vsz) {
		cl_addrmap *newmap = (cl_addrmap *) malloc(sizeof(struct cl_addrmap));
		if (newmap == NULL) {
			return;
		}

		newmap->orig = strdup(orig);
		newmap->alt = strdup(alt);
		cf_vector_pointer_append(&asc->host_addr_map_v, newmap);
		//cf_debug("Adding the mapping %x:%s->%s", newmap, orig, alt);
	} 
	else {
		//cf_debug("Mapping %s->%s already exists", oldmap->orig, oldmap->alt);
	}

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movl 0xb4(%rdi), %r13d
addq $0xa8, %r14
testl %r13d, %r13d
jle 0x7b4e
movq %rbx, 0x8(%rsp)
xorl %ebp, %ebp
leaq 0x10(%rsp), %r12
movq %r14, %rdi
movl %ebp, %esi
movq %r12, %rdx
callq 0xec6f
movq 0x10(%rsp), %rbx
testq %rbx, %rbx
je 0x7b3d
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x2350
testl %eax, %eax
je 0x7b92
incl %ebp
cmpl %ebp, %r13d
jne 0x7b17
movl %r13d, %eax
movq 0x8(%rsp), %rbx
jmp 0x7b50
xorl %eax, %eax
cmpl %r13d, %eax
jne 0x7ba9
movl $0x10, %edi
callq 0x22e0
testq %rax, %rax
je 0x7ba9
movq %rax, %r12
movq %r15, %rdi
callq 0x24f0
movq %rax, (%r12)
movq %rbx, %rdi
callq 0x24f0
movq %rax, 0x8(%r12)
leaq 0x10(%rsp), %rsi
movq %r12, (%rsi)
movq %r14, %rdi
callq 0xeb9c
jmp 0x7ba9
movq 0x8(%rbx), %rdi
callq 0x22c0
movq 0x8(%rsp), %rdi
callq 0x24f0
movq %rax, 0x8(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/sharpyfox[P]citrusleaf-client/src/cl_cluster.c
// Function: cl_cluster_node_create
cl_cluster_node *
cl_cluster_node_create(char *name, struct sockaddr_in *sa_in)
{
	int i;
	cl_cluster_node *cn = cf_client_rc_alloc( sizeof(cl_cluster_node ) );
	if (!cn)	return(0);
	
	strcpy(cn->name, name);

	cn->dun_score = 0;
	cn->dunned = false;
	
	cf_vector_init(&cn->sockaddr_in_v, sizeof( struct sockaddr_in ), 5, 0);
	cf_vector_append(&cn->sockaddr_in_v, sa_in);
	
	cn->conn_q = cf_queue_create( sizeof(int), true );
	cn->conn_q_asyncfd = cf_queue_create( sizeof(int), true );

	cn->asyncfd = -1;
	cn->asyncwork_q = cf_queue_create(sizeof(cl_async_work *), true);
	
	cn->partition_generation = 0xFFFFFFFF;
	
	pthread_mutex_init(&cn->LOCK, 0);
	
	return(cn);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movl $0xb8, %edi
callq 0xc5fe
testq %rax, %rax
je 0x7ea1
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2240
movl $0x0, 0x14(%rbx)
movb $0x0, 0x18(%rbx)
leaq 0x20(%rbx), %r15
movq %r15, %rdi
movl $0x10, %esi
movl $0x5, %edx
xorl %ecx, %ecx
callq 0xe894
movq %r15, %rdi
movq %r14, %rsi
callq 0xeb9c
movl $0x4, %edi
movl $0x1, %esi
callq 0xcd6c
movq %rax, 0x70(%rbx)
movl $0x4, %edi
movl $0x1, %esi
callq 0xcd6c
movq %rax, 0x78(%rbx)
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, 0x80(%rbx)
movl $0x8, %edi
movl $0x1, %esi
callq 0xcd6c
movq %rax, 0x88(%rbx)
movl %ebp, 0x68(%rbx)
movq %rbx, %rdi
addq $0x90, %rdi
xorl %esi, %esi
callq 0x2400
jmp 0x7ea3
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/sharpyfox[P]citrusleaf-client/src/cl_cluster.c
// Function: cl_cluster_node_get_random
cl_cluster_node *
cl_cluster_node_get_random(cl_cluster *asc)
{
	cl_cluster_node *cn;
	
	uint node_v_sz = cf_vector_size(&asc->node_v);
	if (node_v_sz == 0) {
#ifdef DEBUG		
		cf_debug("cluster node get: no nodes in this cluster");
#endif		
		return(0);
	}

	uint i=0;
	do {
		asc->last_node ++;
		if (asc->last_node >= node_v_sz)	asc->last_node = 0;
		int node_i = asc->last_node;

#ifdef DEBUG_VERBOSE		
		cf_debug("cluster node get: vsize %d choosing %d",
			cf_vector_size(&asc->node_v), node_i);
#endif		

		cn = cf_vector_pointer_get(&asc->node_v, node_i);
		i++;
        
	} while( (cn->dunned == true) && (i <= node_v_sz) );

#ifdef DEBUG    
    cf_debug("   random node chosen: %s",cn->name);
#endif    
    
	// grab a reservation
	cf_client_rc_reserve(cn);

	return(cn);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x104(%rdi), %ebp
testl %ebp, %ebp
je 0x7f1e
movq %rdi, %rbx
leaq 0xf8(%rdi), %r14
movl $0x1, %r13d
movq %rsp, %r15
movl 0xf0(%rbx), %esi
incl %esi
cmpl %ebp, %esi
movl $0x0, %eax
cmovael %eax, %esi
movl %esi, 0xf0(%rbx)
movq %r14, %rdi
movq %r15, %rdx
callq 0xec6f
movq (%rsp), %r12
cmpb $0x1, 0x18(%r12)
jne 0x7f14
cmpl %ebp, %r13d
leal 0x1(%r13), %eax
movl %eax, %r13d
jbe 0x7ed9
movq %r12, %rdi
callq 0xc5c4
jmp 0x7f21
xorl %r12d, %r12d
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/sharpyfox[P]citrusleaf-client/src/cl_cluster.c
// Function: cl_cluster_node_get
cl_cluster_node *
cl_cluster_node_get(cl_cluster *asc, const char *ns, const cf_digest *d, bool write)
{
	cl_cluster_node	*cn;	
	pthread_mutex_lock(&asc->LOCK);

	// first, try to get one that matches this digest
	cn = cl_partition_table_get(asc, (char *)ns, cl_partition_getid(asc->n_partitions, (cf_digest *) d) , write);
	if (cn && (cn->dunned == false)) {
#ifdef DEBUG_VERBOSE		
		cf_debug("cluster node get: found match key %"PRIx64" node %s (%s):",
											*(uint64_t*)d, cn->name, write?"write":"read");
#endif		
		cf_client_rc_reserve(cn);
		pthread_mutex_unlock(&asc->LOCK);
		return(cn);
	}
#ifdef DEBUG_VERBOSE	
	cf_debug("cluster node get: not found, try random key %"PRIx64, *(uint64_t *)d);
#endif	
	
	cn = cl_cluster_node_get_random(asc);
	pthread_mutex_unlock(&asc->LOCK);
	return(cn);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
leaq 0x158(%rdi), %rbx
movq %rbx, %rdi
callq 0x23b0
movl 0x140(%r14), %eax
decl %eax
andw (%r15), %ax
movzwl %ax, %edx
movq %r14, %rdi
movq %r12, %rsi
movl %ebp, %ecx
callq 0x8deb
testq %rax, %rax
je 0x7f80
movq %rax, %r15
cmpb $0x0, 0x18(%rax)
je 0x7f8d
movq %r14, %rdi
callq 0x7eb1
movq %rax, %r15
jmp 0x7f95
movq %r15, %rdi
callq 0xc5c4
movq %rbx, %rdi
callq 0x2190
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/sharpyfox[P]citrusleaf-client/src/cl_cluster.c
// Function: cl_cluster_get_node_names
void 
cl_cluster_get_node_names(cl_cluster *asc, int *n_nodes, char **node_names)
{
	pthread_mutex_lock(&asc->LOCK);
	uint size = cf_vector_size(&asc->node_v);
	*n_nodes = size;

	if (size == 0) {
		*node_names = 0;
		pthread_mutex_unlock(&asc->LOCK);
		return;
	}

	*node_names = malloc(NODE_NAME_SIZE * size);
	if (*node_names == 0) {
		pthread_mutex_unlock(&asc->LOCK);
		return;
	}

	char *nptr = *node_names;
	for (uint i = 0; i < size; i++) {
		cl_cluster_node *cn = cf_vector_pointer_get(&asc->node_v, i);
		memcpy(nptr, cn->name, NODE_NAME_SIZE);
		nptr += NODE_NAME_SIZE;
	}
	pthread_mutex_unlock(&asc->LOCK);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
leaq 0x158(%rdi), %rbx
movq %rbx, %rdi
callq 0x23b0
movl 0x104(%r14), %r13d
movl %r13d, (%r15)
testl %r13d, %r13d
je 0x8036
leal (,%r13,4), %eax
leal (%rax,%rax,4), %edi
callq 0x22e0
movq %rax, (%r12)
testq %rax, %rax
je 0x803e
movq %rax, %r15
addq $0xf8, %r14
xorl %ebp, %ebp
movq %rsp, %r12
movq %r14, %rdi
movl %ebp, %esi
movq %r12, %rdx
callq 0xec6f
movq (%rsp), %rax
movl 0x10(%rax), %ecx
movl %ecx, 0x10(%r15)
movq (%rax), %rcx
movq 0x8(%rax), %rax
movq %rax, 0x8(%r15)
movq %rcx, (%r15)
addq $0x14, %r15
incl %ebp
cmpl %ebp, %r13d
jne 0x8003
jmp 0x803e
movq $0x0, (%r12)
movq %rbx, %rdi
callq 0x2190
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/sharpyfox[P]citrusleaf-client/src/cl_cluster.c
// Function: cl_cluster_node_get_byname
cl_cluster_node *
cl_cluster_node_get_byname(cl_cluster *asc, char *name)
{
	pthread_mutex_lock(&asc->LOCK);

	for (uint i = 0; i < cf_vector_size(&asc->node_v); i++) {
		cl_cluster_node *cn = cf_vector_pointer_get(&asc->node_v, i);
		if (strcmp(name, cn->name) == 0) {
			pthread_mutex_unlock(&asc->LOCK);
			return(cn);
		}
	}
	pthread_mutex_unlock(&asc->LOCK);
	return(0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, 0x18(%rsp)
movq %rdi, %r15
addq $0x158, %rdi            # imm = 0x158
movq %rdi, 0x8(%rsp)
callq 0x23b0
cmpl $0x0, 0x104(%r15)
setne %r14b
je 0x80de
leaq 0xf8(%r15), %r13
xorl %ebp, %ebp
movq %r13, %rdi
movl %ebp, %esi
leaq 0x20(%rsp), %rdx
callq 0xec6f
movq 0x20(%rsp), %r12
movq 0x18(%rsp), %rdi
movq %r12, %rsi
callq 0x2350
movl %eax, %ebx
testl %eax, %eax
jne 0x80c9
movq 0x8(%rsp), %rdi
callq 0x2190
movq %r12, 0x10(%rsp)
testl %ebx, %ebx
je 0x80de
incl %ebp
cmpl 0x104(%r15), %ebp
setb %r14b
jb 0x8093
jmp 0x80de
testb $0x1, %r14b
movq 0x10(%rsp), %rax
jne 0x80f5
movq 0x8(%rsp), %rdi
callq 0x2190
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/sharpyfox[P]citrusleaf-client/src/cl_cluster.c
// Function: str_split
static void
str_split(char split_c, char *str, cf_vector *v)
{
	char *prev = str;
	while (*str) {
		if (split_c == *str) {
			*str = 0;
			cf_vector_append(v, &prev);
			prev = str+1;
		}
		str++;
	}
	if (prev != str) {
		cf_vector_append(v, &prev);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rsi, (%rsp)
movb (%rsi), %al
testb %al, %al
je 0x840a
movl %edi, %ebp
incq %r14
movq %rsp, %r15
cmpb %bpl, %al
jne 0x83fd
movb $0x0, -0x1(%r14)
movq %rbx, %rdi
movq %r15, %rsi
callq 0xeb9c
movq %r14, (%rsp)
movb (%r14), %al
incq %r14
testb %al, %al
jne 0x83e4
decq %r14
cmpq %r14, (%rsp)
je 0x841b
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xeb9c
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/sharpyfox[P]citrusleaf-client/src/cl_cluster.c
// Function: cl_cluster_node_fd_put
void
cl_cluster_node_fd_put(cl_cluster_node *cn, int fd, bool asyncfd)
{
#if ONEASYNCFD
	return;	//FD does not get closed. It just lies around.
#endif
	cf_queue *q;
	if (asyncfd == true) {
		q = cn->conn_q_asyncfd;
		// Async queue is used by XDS. It can open lot of connections 
		// depending on batch-size. Dont worry about limiting the pool.
		cf_queue_push(q, &fd);
	} else {
		q = cn->conn_q;
		if (! cf_queue_push_limit(q, &fd, 300)) {
			close(fd);
		}
	}
}

// Assembly:
pushq %rax
movl %esi, 0x4(%rsp)
testl %edx, %edx
je 0x86c9
movq 0x78(%rdi), %rdi
leaq 0x4(%rsp), %rsi
callq 0xcf8b
jmp 0x86e9
movq 0x70(%rdi), %rdi
leaq 0x4(%rsp), %rsi
movl $0x12c, %edx            # imm = 0x12C
callq 0xd033
testb %al, %al
jne 0x86e9
movl 0x4(%rsp), %edi
callq 0x2550
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O1/sharpyfox[P]citrusleaf-client/src/cl_cluster.c
// Function: cluster_get_n_partitions
void
cluster_get_n_partitions( cl_cluster *asc, cf_vector *sockaddr_in_v )
{
	// check if someone found the value
	if (asc->n_partitions != 0)
		return;

	for (uint i=0;i<cf_vector_size(sockaddr_in_v);i++) {
		struct sockaddr_in *sa_in = cf_vector_getp(sockaddr_in_v, i);
		int n_partitions = 0;

		if (cl_get_n_partitions(sa_in, &n_partitions) != 0) {
			continue;
		}
		asc->n_partitions = n_partitions;
		break;
	}
}

// Assembly:
cmpw $0x0, 0x140(%rdi)
je 0x86f6
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
cmpl $0x0, 0xc(%rsi)
je 0x8747
movq %rdi, %rbx
xorl %ebp, %ebp
leaq 0x4(%rsp), %r15
movq %r14, %rdi
movl %ebp, %esi
callq 0xeccf
movl $0x0, 0x4(%rsp)
movq %rax, %rdi
movq %r15, %rsi
callq 0xc484
testl %eax, %eax
je 0x873b
incl %ebp
cmpl 0xc(%r14), %ebp
jb 0x8710
jmp 0x8747
movzwl 0x4(%rsp), %eax
movw %ax, 0x140(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/sharpyfox[P]citrusleaf-client/src/cl_cluster.c
// Function: citrusleaf_cluster_init
int citrusleaf_cluster_init()
{
    if (g_clust_initialized) {
    	return(0);
	}
    
    // No destruction function is used.
	// NOTE: A destruction function should not be used because elements
	// in this list are used even after they are removed from the list.
	// Refer to the function citrusleaf_cluster_destroy() for more info.
	cf_ll_init(&cluster_ll, 0, false);
	
    g_clust_initialized = 1;
   	g_clust_tend_speed = 1;
	pthread_create( &tender_thr, 0, cluster_tender_fn, 0);

	return(0);	
}

// Assembly:
pushq %rbx
leaq 0x10c22(%rip), %rbx     # 0x193a8
cmpl $0x0, (%rbx)
jne 0x87bf
leaq 0x10c46(%rip), %rdi     # 0x193d8
xorl %esi, %esi
xorl %edx, %edx
callq 0xcc7f
movl $0x1, %eax
movl %eax, (%rbx)
movl %eax, 0xeb18(%rip)      # 0x172c0
leaq 0x10c71(%rip), %rdi     # 0x19420
leaq 0xd(%rip), %rdx         # 0x87c3
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x24e0
xorl %eax, %eax
popq %rbx
retq