LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/sharpyfox[P]citrusleaf-client/src/citrusleaf.c
// Function: citrusleaf_copy_bins
int citrusleaf_copy_bins(cl_bin **destbins, const cl_bin *srcbins, int n_bins)
{
	int rv;

	cl_bin *newbins = calloc(sizeof(struct cl_bin_s), n_bins);
	if (newbins == NULL) {
		return -1;
	}

	for (int i=0; i<n_bins; i++) {
		rv = citrusleaf_copy_bin(&newbins[i], &srcbins[i]);
		if (rv == -1) {
			// Unwind previous bin allocations.
			if (i > 0) {
				citrusleaf_bins_free(newbins, i);
			}
			free(newbins);
			return -1;
		}
	}

	*destbins = newbins;
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %r15
movslq %edx, %rsi
movl $0x40, %edi
movl %edx, %ebp
callq 0x2170
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testq %rax, %rax
je 0x48cc
movq %rax, %r14
testl %ebp, %ebp
movq %r15, (%rsp)
jle 0x4897
movl %ebp, %r15d
xorl %ebp, %ebp
movq %r14, %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x2240
leaq 0x20(%r13), %rdi
leaq 0x20(%r12), %rsi
callq 0x4725
cmpl $-0x1, %eax
je 0x48a2
incq %rbp
addq $0x40, %r12
addq $0x40, %r13
cmpq %rbp, %r15
jne 0x4869
movq (%rsp), %rax
xorl %ebx, %ebx
movq %r14, (%rax)
jmp 0x48cc
testq %rbp, %rbp
je 0x48c4
movq %r14, %r15
addq $0x38, %r15
movq (%r15), %rdi
testq %rdi, %rdi
je 0x48bb
callq 0x22c0
addq $0x40, %r15
decq %rbp
jne 0x48ae
movq %r14, %rdi
callq 0x22c0
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x40(%rsp), %r13d
addq $-0x8, %rsi
movw $0x302, (%rdi)          # imm = 0x302
movl %r9d, %ebp
movl %r8d, %r14d
movl %ecx, %r15d
movl %edx, %r12d
movq %rdi, %rbx
movl %esi, 0x2(%rdi)
shrq $0x20, %rsi
movw %si, 0x6(%rdi)
callq 0xc8a8
movl 0x48(%rsp), %eax
movzwl 0x50(%rsp), %edx
movzwl 0x58(%rsp), %ecx
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 %eax, 0x16(%rbx)
movw %dx, 0x1a(%rbx)
movw %cx, 0x1c(%rbx)
callq 0xc8c5
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_O3/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 0x499d
leaq 0xad41(%rip), %rax      # 0xf6bc
movslq (%rax,%rdx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq 0x28(%rdi), %rax
xorl %ebx, %ebx
addq %rax, (%rsi)
movl %ebx, %eax
popq %rbx
retq
movl %edx, %ebx
jmp 0x498d
addq $0x8, (%rsi)
xorl %ebx, %ebx
jmp 0x498d
leaq 0x11924(%rip), %rax     # 0x162c8
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpl $0x0, (%rax)
js 0x498d
leaq 0x1191b(%rip), %rax     # 0x162d0
leaq 0xae33(%rip), %rsi      # 0xf7ef
xorl %edi, %edi
movq (%rax), %rcx
xorl %eax, %eax
callq *%rcx
jmp 0x498d
// File: /workspace/github_c_makefile_star2_O3/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 0x519d
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
movq %r14, %rdi
movb $0x0, (%rbx,%rax)
addq $0x20, %rbx
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x51cf
// File: /workspace/github_c_makefile_star2_O3/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 0x52e3
leaq 0xa57e(%rip), %rax      # 0xf770
movq %rsi, %rbx
movq %rdi, %r14
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, %rdi
movq %r15, 0x8(%rbx)
callq 0x22e0
testq %rax, %rax
movq %rax, 0x10(%rbx)
movq %rax, 0x18(%rbx)
je 0x534d
movzbl 0x7(%r14), %ecx
movq %rax, %rdi
movq %r15, %rdx
leaq 0x8(%r14,%rcx), %rsi
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
leaq 0x1(%r15), %rdi
movq %r15, 0x8(%rbx)
callq 0x22e0
testq %rax, %rax
movq %rax, 0x10(%rbx)
movq %rax, 0x18(%rbx)
je 0x534d
movq %rax, %r12
movzbl 0x7(%r14), %eax
movq %r15, %rdx
movq %r12, %rdi
leaq 0x8(%r14,%rax), %rsi
callq 0x21b0
movb $0x0, (%r12,%r15)
jmp 0x534d
xorl %eax, %eax
movq %rax, 0x8(%rbx)
movq %rax, 0x18(%rbx)
jmp 0x534d
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 0x534d
testl %eax, %eax
je 0x5320
leaq 0x8(%r14,%rcx), %rdx
cmpl $0x1, %eax
je 0x5311
cmpl $0x8, %eax
jne 0x5324
movq (%rdx), %rcx
jmp 0x5346
leaq 0x10fde(%rip), %rax     # 0x162c8
cmpl $0x0, (%rax)
js 0x534d
leaq 0x10fda(%rip), %rax     # 0x162d0
leaq 0xa602(%rip), %rsi      # 0xf8ff
xorl %edi, %edi
movq (%rax), %rcx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmpq *%rcx
movzbl (%rdx), %ecx
cmpq $0x7e, %rcx
jbe 0x5349
testb %cl, %cl
jns 0x532e
jmp 0x5343
movl %eax, %ecx
jmp 0x5349
movb (%rdx), %cl
testb %cl, %cl
js 0x5343
testl %eax, %eax
jle 0x5359
xorl %ecx, %ecx
movzbl (%rdx), %esi
shlq $0x8, %rcx
incq %rdx
orq %rsi, %rcx
decl %eax
jne 0x5330
jmp 0x5349
movzbl %cl, %ecx
bswapq %rcx
movq %rcx, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
xorl %ecx, %ecx
jmp 0x5349
// File: /workspace/github_c_makefile_star2_O3/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
cmpb $0x1, 0x12d38(%rip)     # 0x183a0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %r8, 0x10(%rsp)
movl %r9d, 0xc(%rsp)
jne 0x56ee
movq %rcx, %r10
movl 0x70(%rsp), %ecx
movq 0x78(%rsp), %r14
movq %rdx, %r11
movq %rsi, %rbx
xorl %eax, %eax
leaq 0x18(%rsp), %r15
movabsq $0x200000000, %rdx      # imm = 0x200000000
leaq 0x20(%rsp), %r12
leaq 0xc(%rsp), %r13
leaq 0x10(%rsp), %rbp
movl $0x1, %esi
movq %rdx, 0x10(%r12)
movq %rax, (%r15)
movl $0x0, (%r12)
movb $0x0, 0x4(%r12)
xorl %edx, %edx
movq %rbx, %r8
movq %r11, %r9
movl %ecx, 0xc(%r12)
xorl %ecx, %ecx
pushq %rax
pushq %r15
pushq %r12
pushq %r14
pushq %r13
pushq %rax
pushq $0x1
pushq %rbp
pushq %rax
pushq %r10
callq 0x56fd
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_O3/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
cmpb $0x1, 0x126ad(%rip)     # 0x183a0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rcx, 0x8(%rsp)
movl %r8d, 0x4(%rsp)
jne 0x5d6e
movq 0x60(%rsp), %rbx
movq %rsi, %r11
xorl %eax, %eax
leaq 0x10(%rsp), %r14
movabsq $0x200000000, %rcx      # imm = 0x200000000
leaq 0x18(%rsp), %r15
movq %rdx, %r10
leaq 0x4(%rsp), %r12
leaq 0x8(%rsp), %r13
movl $0x1, %esi
xorl %edx, %edx
movq %rcx, 0x10(%r15)
movq %rax, (%r14)
movl $0x0, (%r15)
movb $0x0, 0x4(%r15)
movl %r9d, 0xc(%r15)
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 0x56fd
addq $0x50, %rsp
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/sharpyfox[P]citrusleaf-client/src/citrusleaf.c
// Function: citrusleaf_put
extern cl_rv
citrusleaf_put(cl_cluster *asc, const char *ns, const char *set, const cl_object *key, const cl_bin *values, int n_values, const cl_write_parameters *cl_w_p)
{
    if (!g_initialized) return(-1);

    	uint64_t trid=0;
	return( do_the_full_monte( asc, 0, CL_MSG_INFO2_WRITE, 0, ns, set, key, 0, 
			(cl_bin **) &values, CL_OP_WRITE, 0, &n_values, NULL, cl_w_p, 
			&trid, NULL) );
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
cmpb $0x1, 0x12610(%rip)     # 0x183a0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %r8, 0x10(%rsp)
movl %r9d, 0xc(%rsp)
jne 0x5def
movq 0x50(%rsp), %rax
movq %rdx, %r11
movq %rsi, %rbx
xorl %r14d, %r14d
leaq 0x18(%rsp), %r15
movq %rcx, %r10
leaq 0xc(%rsp), %r12
leaq 0x10(%rsp), %r13
xorl %esi, %esi
movl $0x1, %edx
xorl %ecx, %ecx
movq %r14, (%r15)
movq %rbx, %r8
movq %r11, %r9
pushq %r14
pushq %r15
pushq %rax
pushq %r14
pushq %r12
pushq %r14
pushq $0x0
pushq %r13
pushq %r14
pushq %r10
callq 0x56fd
addq $0x50, %rsp
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/sharpyfox[P]citrusleaf-client/src/citrusleaf.c
// Function: citrusleaf_put_digest
extern cl_rv
citrusleaf_put_digest(cl_cluster *asc, const char *ns, const cf_digest *digest, const cl_bin *values, int n_values, const cl_write_parameters *cl_w_p)
{
    if (!g_initialized) return(-1);

    
    	uint64_t trid=0;
	return( do_the_full_monte( asc, 0, CL_MSG_INFO2_WRITE, 0, ns, 0, 0, digest, 
			(cl_bin **) &values, CL_OP_WRITE, 0, &n_values, NULL, cl_w_p, 
			&trid, NULL) );
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
cmpb $0x1, 0x12593(%rip)     # 0x183a0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rcx, 0x10(%rsp)
movl %r8d, 0xc(%rsp)
jne 0x5e62
movq %r9, %r10
movq %rsi, %r9
xorl %eax, %eax
leaq 0x18(%rsp), %rbx
movq %rdx, %r11
leaq 0xc(%rsp), %r14
leaq 0x10(%rsp), %r15
xorl %esi, %esi
movl $0x1, %edx
xorl %ecx, %ecx
movq %r9, %r8
movq %rax, (%rbx)
xorl %r9d, %r9d
pushq %rax
pushq %rbx
pushq %r10
pushq %rax
pushq %r14
pushq %rax
pushq $0x0
pushq %r15
pushq %r11
pushq %rax
callq 0x56fd
addq $0x50, %rsp
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/sharpyfox[P]citrusleaf-client/src/citrusleaf.c
// Function: citrusleaf_restore
extern cl_rv
citrusleaf_restore(cl_cluster *asc, const char *ns, const cf_digest *digest, const char *set, const cl_bin *values, int n_values, const cl_write_parameters *cl_w_p)
{
    if (!g_initialized) return(-1);

    uint64_t trid=0;
	return( do_the_full_monte( asc, 0, CL_MSG_INFO2_WRITE, 0, ns, set, 0, digest, 
			(cl_bin **) &values, CL_OP_WRITE, 0, &n_values, NULL, cl_w_p, 
			&trid, NULL) );
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
cmpb $0x1, 0x1249c(%rip)     # 0x183a0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %r8, 0x10(%rsp)
movl %r9d, 0xc(%rsp)
jne 0x5f5f
movq 0x50(%rsp), %r14
movq %rcx, %r11
movq %rsi, %rbx
xorl %eax, %eax
leaq 0x18(%rsp), %r15
movq %rdx, %r10
leaq 0xc(%rsp), %r12
leaq 0x10(%rsp), %r13
xorl %esi, %esi
movl $0x1, %edx
xorl %ecx, %ecx
movq %rax, (%r15)
movq %rbx, %r8
movq %r11, %r9
pushq %rax
pushq %r15
pushq %r14
pushq %rax
pushq %r12
pushq %rax
pushq $0x0
pushq %r13
pushq %r10
pushq %rax
callq 0x56fd
addq $0x50, %rsp
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
cmpb $0x1, 0x1233e(%rip)     # 0x183a0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %r8, 0x8(%rsp)
movl %r9d, 0x4(%rsp)
jne 0x60bc
movq 0x40(%rsp), %rax
xorl %ebx, %ebx
leaq 0x10(%rsp), %r14
movq %rcx, %r10
movq %rdx, %r11
movq %rsi, %rcx
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 0xa1f8
addq $0x50, %rsp
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
cmpb $0x1, 0x122c6(%rip)     # 0x183a0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %r8, 0x8(%rsp)
movl %r9d, 0x4(%rsp)
jne 0x6135
movq 0x40(%rsp), %rax
xorl %ebx, %ebx
leaq 0x10(%rsp), %r14
movq %rcx, %r11
movq %rdx, %r10
movq %rsi, %rcx
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 0xa1f8
addq $0x50, %rsp
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
leaq 0x158(%rdi), %rbx
movq %rdi, %r14
movq %rbx, %rdi
callq 0x23b0
cmpl $0x0, 0x104(%r14)
je 0x6220
leaq 0xf8(%r14), %r15
xorl %ebp, %ebp
movq %rsp, %r12
xorl %r13d, %r13d
movq %r15, %rdi
movl %ebp, %esi
movq %r12, %rdx
callq 0xe7d4
movq (%rsp), %rax
incl %ebp
movzbl 0x18(%rax), %eax
xorl $0x1, %eax
addl %eax, %r13d
cmpl 0x104(%r14), %ebp
jb 0x61ec
cmpl $0x1, %r13d
movl $0x2, %ebp
sbbl $0x0, %ebp
jmp 0x6225
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_O3/sharpyfox[P]citrusleaf-client/src/citrusleaf.c
// Function: citrusleaf_delete
extern cl_rv
citrusleaf_delete(cl_cluster *asc, const char *ns, const char *set, const cl_object *key, const cl_write_parameters *cl_w_p)
{
    if (!g_initialized) return(-1);
    
    	uint64_t trid=0;
	return( do_the_full_monte( asc, 0, CL_MSG_INFO2_DELETE | CL_MSG_INFO2_WRITE, 0, 
			ns, set, key, 0, 0, 0, 0, 0, NULL, cl_w_p, &trid, NULL) );
}

// Assembly:
cmpb $0x1, 0x1215b(%rip)     # 0x183a0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jne 0x6287
pushq %rbx
subq $0x10, %rsp
xorl %eax, %eax
leaq 0x8(%rsp), %rbx
movq %r8, %r10
movq %rcx, %r11
movq %rdx, %r9
movq %rsi, %r8
xorl %esi, %esi
movl $0x3, %edx
xorl %ecx, %ecx
movq %rax, (%rbx)
pushq %rax
pushq %rbx
pushq %r10
pushq %rax
pushq %rax
pushq %rax
pushq $0x0
pushq %rax
pushq %rax
pushq %r11
callq 0x56fd
addq $0x60, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/sharpyfox[P]citrusleaf-client/src/citrusleaf.c
// Function: citrusleaf_delete_digest
extern cl_rv
citrusleaf_delete_digest(cl_cluster *asc, const char *ns, const cf_digest *digest, const cl_write_parameters *cl_w_p)
{
    if (!g_initialized) return(-1);
    
    	uint64_t trid=0;
	return( do_the_full_monte( asc, 0, CL_MSG_INFO2_DELETE | CL_MSG_INFO2_WRITE, 0, 
			ns, 0, 0, digest, 0, 0, 0, 0, NULL, cl_w_p, &trid, NULL) );
}

// Assembly:
cmpb $0x1, 0x12111(%rip)     # 0x183a0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jne 0x62d1
pushq %rbx
subq $0x10, %rsp
xorl %eax, %eax
leaq 0x8(%rsp), %rbx
movq %rcx, %r10
movq %rdx, %r11
movq %rsi, %r8
xorl %esi, %esi
movl $0x3, %edx
xorl %ecx, %ecx
xorl %r9d, %r9d
movq %rax, (%rbx)
pushq %rax
pushq %rbx
pushq %r10
pushq %rax
pushq %rax
pushq %rax
pushq $0x0
pushq %rax
pushq %r11
pushq %rax
callq 0x56fd
addq $0x60, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/sharpyfox[P]citrusleaf-client/src/citrusleaf.c
// Function: citrusleaf_exists_digest
extern cl_rv
citrusleaf_exists_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 | CL_MSG_INFO1_NOBINDATA, 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
cmpb $0x1, 0x11fbc(%rip)     # 0x183a0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %rcx, 0x8(%rsp)
movl %r8d, 0x4(%rsp)
jne 0x645f
movq 0x60(%rsp), %rbx
movq %rsi, %r11
xorl %eax, %eax
leaq 0x10(%rsp), %r14
movabsq $0x200000000, %rcx      # imm = 0x200000000
leaq 0x18(%rsp), %r15
movq %rdx, %r10
leaq 0x4(%rsp), %r12
leaq 0x8(%rsp), %r13
movl $0x21, %esi
xorl %edx, %edx
movq %rcx, 0x10(%r15)
movq %rax, (%r14)
movl $0x0, (%r15)
movb $0x0, 0x4(%r15)
movl %r9d, 0xc(%r15)
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 0x56fd
addq $0x50, %rsp
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
testq %r8, %r8
movq %rcx, %rax
movq %rdx, %r9
movq %r8, %r10
setne %cl
testq %r11, %r11
setne %dl
testb %dl, %cl
jne 0x64c2
leaq 0xfe2d(%rip), %rax      # 0x162c8
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpl $0x0, (%rax)
js 0x6533
leaq 0xfe20(%rip), %rax      # 0x162d0
leaq 0x93d4(%rip), %rsi      # 0xf88b
xorl %edi, %edi
movq (%rax), %rcx
xorl %eax, %eax
callq *%rcx
jmp 0x6533
cmpb $0x1, 0x11ed7(%rip)     # 0x183a0
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jne 0x6533
movl 0x50(%rsp), %ecx
movq 0x58(%rsp), %r14
xorl %ebx, %ebx
leaq 0x8(%rsp), %r15
movabsq $0x200000000, %rdx      # imm = 0x200000000
leaq 0x10(%rsp), %r12
movq %rsi, %r8
movl $0x3, %esi
movq %rbx, (%r10)
movl %ebx, (%r11)
movq %rdx, 0x10(%r12)
movq %rbx, (%r15)
movl %ebx, (%r12)
movb $0x0, 0x4(%r12)
xorl %edx, %edx
movl %ecx, 0xc(%r12)
xorl %ecx, %ecx
pushq %rbx
pushq %r15
pushq %r12
pushq %r14
pushq %r11
pushq %rbx
pushq $0x1
pushq %r10
pushq %rbx
pushq %rax
callq 0x56fd
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_O3/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
testq %rcx, %rcx
movq %rcx, %r10
movq %rdx, %rax
movq %r8, %r11
setne %cl
testq %r8, %r8
setne %dl
testb %dl, %cl
jne 0x6598
leaq 0xfd5a(%rip), %rax      # 0x162c8
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpl $0x0, (%rax)
js 0x6644
leaq 0xfd4d(%rip), %rax      # 0x162d0
leaq 0x9301(%rip), %rsi      # 0xf88b
xorl %edi, %edi
movq (%rax), %rcx
xorl %eax, %eax
callq *%rcx
jmp 0x6644
cmpb $0x1, 0x11e01(%rip)     # 0x183a0
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jne 0x6644
movq 0x58(%rsp), %r14
movq 0x50(%rsp), %rbx
xorl %ecx, %ecx
movq %rsi, %r8
movabsq $0x200000000, %rdx      # imm = 0x200000000
movq %rcx, (%r10)
movl %ecx, (%r11)
movq %rdx, 0x18(%rsp)
movq %rcx, (%rsp)
movl %ecx, 0x8(%rsp)
movb $0x0, 0xc(%rsp)
movl %r9d, 0x14(%rsp)
testq %r14, %r14
je 0x6610
movl $0x13, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r9d, %r9d
movq %rsp, %r15
leaq 0x8(%rsp), %r12
xorl %r13d, %r13d
pushq %r14
pushq %r15
pushq %r12
pushq %rbx
pushq %r11
pushq %r13
pushq $0x1
pushq %r10
pushq %rax
pushq %r13
jmp 0x6639
xorl %r14d, %r14d
movl $0x3, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r9d, %r9d
movq %rsp, %r15
leaq 0x8(%rsp), %r12
pushq %r14
pushq %r15
pushq %r12
pushq %rbx
pushq %r11
pushq %r14
pushq $0x1
pushq %r10
pushq %rax
pushq %r14
callq 0x56fd
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_O3/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
cmpb $0x1, 0x11d25(%rip)     # 0x183a0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %r8, 0x10(%rsp)
movl %r9d, 0xc(%rsp)
jne 0x6701
movq %rcx, %r10
movl 0x70(%rsp), %ecx
movq 0x78(%rsp), %r14
movq %rdx, %r11
movq %rsi, %rbx
xorl %eax, %eax
leaq 0x18(%rsp), %r15
movabsq $0x200000000, %rdx      # imm = 0x200000000
leaq 0x20(%rsp), %r12
leaq 0xc(%rsp), %r13
leaq 0x10(%rsp), %rbp
movl $0x9, %esi
movq %rdx, 0x10(%r12)
movq %rax, (%r15)
movl $0x0, (%r12)
movb $0x0, 0x4(%r12)
xorl %edx, %edx
movq %rbx, %r8
movq %r11, %r9
movl %ecx, 0xc(%r12)
xorl %ecx, %ecx
pushq %rax
pushq %r15
pushq %r12
pushq %r14
pushq %r13
pushq %rax
pushq $0x1
pushq %rbp
pushq %rax
pushq %r10
callq 0x56fd
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_O3/sharpyfox[P]citrusleaf-client/src/citrusleaf.c
// Function: citrusleaf_delete_verify
extern cl_rv
citrusleaf_delete_verify(cl_cluster *asc, const char *ns, const char *set, const cl_object *key, const cl_write_parameters *cl_w_p)
{
    if (!g_initialized) return(-1);
    
    	uint64_t trid=0;
	return( do_the_full_monte( asc, CL_MSG_INFO1_VERIFY, CL_MSG_INFO2_DELETE | CL_MSG_INFO2_WRITE, 
			0, ns, set, key, 0, 0, 0, 0, 0, NULL, cl_w_p, &trid, NULL) );
}

// Assembly:
cmpb $0x1, 0x11c89(%rip)     # 0x183a0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jne 0x675c
pushq %rbx
subq $0x10, %rsp
xorl %eax, %eax
leaq 0x8(%rsp), %rbx
movq %r8, %r10
movq %rcx, %r11
movq %rdx, %r9
movq %rsi, %r8
movl $0x8, %esi
movl $0x3, %edx
xorl %ecx, %ecx
movq %rax, (%rbx)
pushq %rax
pushq %rbx
pushq %r10
pushq %rax
pushq %rax
pushq %rax
pushq $0x0
pushq %rax
pushq %rax
pushq %r11
callq 0x56fd
addq $0x60, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rsi, %rbx
movq %rdi, %r14
testq %rdi, %rdi
movq %rdx, -0x30(%rbp)
je 0x678a
movq %r14, %rdi
callq 0x20e0
movslq %eax, %r12
jmp 0x678d
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 0x6850
leaq 0x8fe9(%rip), %rcx      # 0xf7a0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb %dl, (%r13)
movq 0x10(%rbx), %rsi
leaq 0x1(%r13), %rdi
movq %r15, %rdx
callq 0x21b0
incq %r15
testq %r12, %r12
je 0x6815
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 0x6824
movq -0x30(%rbp), %rdx
movq %r13, %rdi
movq %r15, %rsi
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 0x67c4
movb $0x1, (%r13)
movq 0x10(%rbx), %rax
bswapq %rax
movq %rax, 0x1(%r13)
jmp 0x67d4
leaq 0xfa71(%rip), %rax      # 0x162c8
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmpl $0x0, (%rax)
js 0x6826
leaq 0xfa68(%rip), %rax      # 0x162d0
leaq 0x904a(%rip), %rsi      # 0xf8b9
xorl %edi, %edi
movq (%rax), %rcx
xorl %eax, %eax
callq *%rcx
jmp 0x6826
// File: /workspace/github_c_makefile_star2_O3/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
cmpb $0x1, 0x11b11(%rip)     # 0x183a0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq %r8, 0x10(%rsp)
movl %r9d, 0x4(%rsp)
jne 0x6966
movq 0x60(%rsp), %rax
movl 0x58(%rsp), %ebp
movq 0x50(%rsp), %r14
movq %rcx, %rbx
movq %rdx, %r11
movq %rsi, %r10
testl %r9d, %r9d
movq $0x0, 0x8(%rsp)
jle 0x691a
movl %r9d, %ecx
addq $0x40, %r8
xorl %edx, %edx
xorl %esi, %esi
movl (%r8), %r9d
leal -0x2(%r9), %r15d
cmpl $0x8, %r15d
jae 0x6906
movl $0x1, %edx
testl %esi, %esi
setne %r9b
testl %edx, %edx
setne %r15b
andb %r9b, %r15b
cmpb $0x1, %r15b
je 0x6920
addq $0x48, %r8
decq %rcx
jne 0x68d4
jmp 0x692a
cmpl $0x1, %r9d
je 0x6913
testl %r9d, %r9d
je 0x68e1
jmp 0x68e6
movl $0x1, %esi
jmp 0x68e6
xorl %esi, %esi
xorl %edx, %edx
jmp 0x692a
movl $0x1, %esi
movl $0x1, %edx
xorl %ecx, %ecx
testl %ebp, %ebp
leaq 0x8(%rsp), %r12
leaq 0x4(%rsp), %r13
leaq 0x10(%rsp), %rbp
movq %r10, %r8
movq %r11, %r9
setne %cl
xorl %r15d, %r15d
shll $0x3, %ecx
pushq %r15
pushq %r12
pushq %r14
pushq %rax
pushq %r13
pushq %rbp
pushq $0x0
pushq %r15
pushq %r15
pushq %rbx
callq 0x56fd
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_O3/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 0xf93e(%rip), %rax      # 0x162c8
movl (%rax), %eax
cmpl $0x2, %eax
jl 0x69b5
leaq 0xf938(%rip), %rax      # 0x162d0
leaq 0x8f44(%rip), %rsi      # 0xf8e3
movl $0x2, %edi
movq (%rax), %rcx
leaq 0xf92a(%rip), %rax      # 0x162d8
movq (%rax), %rdx
xorl %eax, %eax
callq *%rcx
callq 0x23a0
leaq 0x119e3(%rip), %rcx     # 0x183a4
movl %eax, (%rcx)
xorl %eax, %eax
callq 0x851d
movb $0x1, 0x119cf(%rip)     # 0x183a0
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/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, 0x119c4(%rip)     # 0x183a0
jne 0x6a10
pushq %rax
callq 0x72ae
xorl %eax, %eax
callq 0xa0e9
xorl %eax, %eax
callq 0xadf5
leaq 0x11bdf(%rip), %rax     # 0x185d8
cmpb $0x1, (%rax)
jne 0x6a05
xorl %eax, %eax
callq 0xba43
movb $0x0, 0x11994(%rip)     # 0x183a0
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/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 $0x18, %rsp
cmpl $0x0, 0x104(%rdi)
je 0x6a99
leaq 0xf8(%rdi), %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %ebp, %ebp
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movl %ebp, %esi
leaq 0x10(%rsp), %rdx
callq 0xe7d4
movq 0x10(%rsp), %r13
cmpl $0x0, 0x2c(%r13)
je 0x6a8e
leaq 0x20(%r13), %r12
xorl %r15d, %r15d
movq %r12, %rdi
movl %r15d, %esi
callq 0xe834
movdqu (%rbx), %xmm0
movdqu (%rax), %xmm1
pcmpeqb %xmm0, %xmm1
pmovmskb %xmm1, %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
je 0x6a9c
incl %r15d
cmpl 0x2c(%r13), %r15d
jb 0x6a63
incl %ebp
cmpl 0x104(%r14), %ebp
jb 0x6a3f
xorl %r13d, %r13d
movq %r13, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x118ef(%rip), %rax     # 0x183a8
cmpl $0x0, (%rax)
je 0x6ba2
movl $0x180, %edi            # imm = 0x180
callq 0x22e0
movq %rax, %rbx
xorl %eax, %eax
testq %rbx, %rbx
je 0x6ba4
leaq 0x158(%rbx), %rdi
xorl %esi, %esi
movl %eax, 0x10(%rbx)
movw $0x1, 0x14(%rbx)
movb $0x0, 0x16(%rbx)
movl %eax, 0xf0(%rbx)
movq $0x1, 0x150(%rbx)
callq 0x2400
leaq 0x18(%rbx), %rdi
movl $0x8, %esi
movl $0xa, %edx
xorl %ecx, %ecx
callq 0xe409
leaq 0x60(%rbx), %rdi
movl $0x4, %esi
movl $0xa, %edx
xorl %ecx, %ecx
callq 0xe409
leaq 0xa8(%rbx), %rdi
movl $0x8, %esi
movl $0xa, %edx
xorl %ecx, %ecx
callq 0xe409
movq %rbx, %rdi
movl $0x8, %esi
movl $0xa, %edx
xorl %ecx, %ecx
addq $0xf8, %rdi
callq 0xe409
leaq 0x11846(%rip), %r14     # 0x183b0
movq %r14, %rdi
callq 0x23b0
leaq 0x1185f(%rip), %rdi     # 0x183d8
movq %rbx, %rsi
callq 0xc459
movq %r14, %rdi
callq 0x2190
movq %rbx, %rax
movw $0x0, 0x140(%rbx)
movq $0x0, 0x148(%rbx)
jmp 0x6ba4
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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
xorl %esi, %esi
movq %rdi, %rbx
callq 0xc1f8
testq %rax, %rax
jne 0x72a6
leaq 0x20(%rbx), %rdi
callq 0xe580
movq 0x70(%rbx), %rdi
movq %rsp, %rsi
xorl %edx, %edx
callq 0xccdc
testl %eax, %eax
jne 0x71d7
movq %rsp, %r14
movl (%rsp), %edi
callq 0x2550
movq 0x70(%rbx), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xccdc
testl %eax, %eax
je 0x71bd
movq 0x78(%rbx), %rdi
movq %rsp, %rsi
xorl %edx, %edx
callq 0xccdc
testl %eax, %eax
jne 0x7206
movq %rsp, %r14
movl (%rsp), %edi
callq 0x2550
movq 0x78(%rbx), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xccdc
testl %eax, %eax
je 0x71ec
movq 0x88(%rbx), %rdi
movq %rsp, %rsi
xorl %edx, %edx
callq 0xccdc
testl %eax, %eax
jne 0x723c
movq %rsp, %r14
movq (%rsp), %rdi
callq 0x22c0
movq 0x88(%rbx), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xccdc
testl %eax, %eax
je 0x721e
leaq 0x1137d(%rip), %rax     # 0x185c0
movq (%rax), %rdi
testq %rdi, %rdi
je 0x725a
leaq 0x2f9c(%rip), %rsi      # 0xa1ee
movq %rbx, %rdx
callq 0x441c
movl 0x80(%rbx), %edi
cmpl $-0x1, %edi
je 0x7274
callq 0x2550
movl $0xffffffff, 0x80(%rbx) # imm = 0xFFFFFFFF
movq 0x70(%rbx), %rdi
callq 0xc9f6
movq 0x78(%rbx), %rdi
callq 0xc9f6
movq 0x88(%rbx), %rdi
callq 0xc9f6
leaq 0x90(%rbx), %rdi
callq 0x22b0
movq %rbx, %rdi
callq 0xc241
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl 0xb4(%rdi), %r13d
movq %rdi, %r14
movq %rsi, %r15
movq %rdx, 0x8(%rsp)
addq $0xa8, %r14
testl %r13d, %r13d
jle 0x79dc
xorl %ebp, %ebp
leaq 0x10(%rsp), %r12
movq %r14, %rdi
movl %ebp, %esi
movq %r12, %rdx
callq 0xe7d4
movq 0x10(%rsp), %rbx
testq %rbx, %rbx
je 0x79d3
movq (%rbx), %rdi
movq %r15, %rsi
callq 0x2350
testl %eax, %eax
je 0x7a1d
incl %ebp
cmpl %ebp, %r13d
jne 0x79ad
jmp 0x79de
jne 0x7a34
movl $0x10, %edi
callq 0x22e0
testq %rax, %rax
je 0x7a34
movq %r15, %rdi
movq %rax, %r12
callq 0x24f0
movq 0x8(%rsp), %rdi
movq %rax, (%r12)
callq 0x24f0
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
movq %rax, 0x8(%r12)
movq %r12, (%rsi)
callq 0xe723
jmp 0x7a34
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_O3/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 %rdi, %r15
movl $0xb8, %edi
movq %rsi, %r14
callq 0xc222
movq %rax, %rbx
testq %rax, %rax
je 0x7d1f
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2240
leaq 0x20(%rbx), %r15
movl $0x10, %esi
movl $0x5, %edx
xorl %ecx, %ecx
movl $0x0, 0x14(%rbx)
movb $0x0, 0x18(%rbx)
movq %r15, %rdi
callq 0xe409
movq %r15, %rdi
movq %r14, %rsi
callq 0xe723
movl $0x4, %edi
movl $0x1, %esi
callq 0xc964
movl $0x4, %edi
movl $0x1, %esi
movq %rax, 0x70(%rbx)
callq 0xc964
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl $0x8, %edi
movl $0x1, %esi
movq %rax, 0x78(%rbx)
movl %ebp, 0x80(%rbx)
callq 0xc964
movq %rbx, %rdi
xorl %esi, %esi
movq %rax, 0x88(%rbx)
movl %ebp, 0x68(%rbx)
addq $0x90, %rdi
callq 0x2400
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x7d9a
movq %rdi, %rbx
leaq 0xf8(%rdi), %r14
movl $0x1, %r13d
movq %rsp, %r15
movl 0xf0(%rbx), %esi
movl $0x0, %eax
movq %r14, %rdi
movq %r15, %rdx
incl %esi
cmpl %ebp, %esi
cmovael %eax, %esi
movl %esi, 0xf0(%rbx)
callq 0xe7d4
movq (%rsp), %r12
cmpb $0x1, 0x18(%r12)
jne 0x7d90
leal 0x1(%r13), %eax
cmpl %ebp, %r13d
movl %eax, %r13d
jbe 0x7d55
movq %r12, %rdi
callq 0xc1e8
jmp 0x7d9d
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_O3/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
leaq 0x158(%rdi), %rbx
movq %rdi, %r14
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r12
movq %rbx, %rdi
callq 0x23b0
movl 0x140(%r14), %eax
movq %r14, %rdi
movq %r12, %rsi
movl %ebp, %ecx
decl %eax
andw (%r15), %ax
movzwl %ax, %edx
callq 0x8b85
testq %rax, %rax
je 0x7dfc
cmpb $0x0, 0x18(%rax)
movq %rax, %r15
je 0x7e09
movq %r14, %rdi
callq 0x7d2d
movq %rax, %r15
jmp 0x7e11
movq %r15, %rdi
callq 0xc1e8
movq %rbx, %rdi
callq 0x2190
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq