LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/tests/loop_c/src/shash.c
// Function: shash_destroy
void
shash_destroy(shash *h)
{
	shash_elem *e_table = h->table;
	for (uint i=0;i<h->table_len;i++) {
		if (e_table->next) {
			shash_elem *e = e_table->next;
			shash_elem *t;
			while (e) {
				t = e->next;
				free(e);
				e = t;
			}
		}
		e_table = (shash_elem *) (((uint8_t *)e_table) + SHASH_ELEM_SZ(h));
	}

	if (h->flags & SHASH_CR_MT_BIGLOCK) {
		pthread_mutex_destroy(&h->biglock);
	}
	if (h->flags & SHASH_CR_MT_MANYLOCK) {
		for (uint i=0;i<h->table_len;i++) {
			pthread_mutex_destroy(&(h->lock_table[i]));
		}
		free(h->lock_table);
	}

	free(h->table);
	free(h);	
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
movq 0x30(%rsp), %rcx
cmpl 0x18(%rcx), %eax
jae 0x53d6
movq 0x28(%rsp), %rax
cmpq $0x0, (%rax)
je 0x53a2
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x53a0
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x22e0
movq 0x10(%rsp), %rax
movq %rax, 0x18(%rsp)
jmp 0x5375
jmp 0x53a2
movq 0x28(%rsp), %rax
movq 0x30(%rsp), %rcx
movl 0x4(%rcx), %ecx
addq $0x10, %rcx
movq 0x30(%rsp), %rdx
movl 0x8(%rdx), %edx
addq %rdx, %rcx
addq %rcx, %rax
movq %rax, 0x28(%rsp)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x534f
movq 0x30(%rsp), %rax
movl 0xc(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x53f4
movq 0x30(%rsp), %rdi
addq $0x28, %rdi
callq 0x22d0
movq 0x30(%rsp), %rax
movl 0xc(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x544e
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x30(%rsp), %rcx
cmpl 0x18(%rcx), %eax
jae 0x5440
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rdi
movl 0xc(%rsp), %eax
imulq $0x28, %rax, %rax
addq %rax, %rdi
callq 0x22d0
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x540c
movq 0x30(%rsp), %rax
movq 0x50(%rax), %rdi
callq 0x22e0
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x22e0
movq 0x30(%rsp), %rdi
callq 0x22e0
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/src/citrusleaf.c
// Function: citrusleaf_object_init_str
void citrusleaf_object_init_str(cl_object *o, const char *str)
{
	o->type = CL_STR;
	o->sz = strlen(str);
	o->u.str = (char *) str;
	o->free = 0;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movl $0x3, (%rax)
movq 0x8(%rsp), %rdi
callq 0x2100
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0x18(%rax)
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/src/citrusleaf.c
// Function: citrusleaf_object_init_str2
void citrusleaf_object_init_str2(cl_object *o, const char *str, size_t len)
{
	o->type = CL_STR;
	o->sz = len;
	o->u.str = (char *) str;
	o->free = 0;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x8(%rsp), %rax
movl $0x3, (%rax)
movq -0x18(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x18(%rax)
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/src/citrusleaf.c
// Function: citrusleaf_object_init_int
void citrusleaf_object_init_int(cl_object *o, int64_t i)
{
	o->type = CL_INT;
	o->sz = sizeof(o->u.i64);
	o->u.i64 = i;
	o->free = 0;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movl $0x1, (%rax)
movq -0x8(%rsp), %rax
movq $0x8, 0x8(%rax)
movq -0x10(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x18(%rax)
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/src/citrusleaf.c
// Function: citrusleaf_object_init_blob
void citrusleaf_object_init_blob(cl_object *o, const void *blob, size_t len)
{
	o->type = CL_BLOB;
	o->sz = len;
	o->u.blob = (void *) blob;
	o->free = 0;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x8(%rsp), %rax
movl $0x4, (%rax)
movq -0x18(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x18(%rax)
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/src/citrusleaf.c
// Function: citrusleaf_object_init_blob2
void citrusleaf_object_init_blob2(cl_object *o, const void *blob, size_t len, cl_type t)
{
	o->type = t;
	o->sz = len;
	o->u.blob = (void *) blob;
	o->free = 0;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movl %ecx, -0x1c(%rsp)
movl -0x1c(%rsp), %ecx
movq -0x8(%rsp), %rax
movl %ecx, (%rax)
movq -0x18(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x18(%rax)
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/src/citrusleaf.c
// Function: citrusleaf_object_init_blob_type
void citrusleaf_object_init_blob_type(cl_object *o, int blob_type, void *blob, size_t len)
{
	o->type = blob_type;
	o->sz = len;
	o->u.blob = blob;
	o->free = 0;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movl -0xc(%rsp), %ecx
movq -0x8(%rsp), %rax
movl %ecx, (%rax)
movq -0x20(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x18(%rax)
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/src/citrusleaf.c
// Function: citrusleaf_copy_object
int citrusleaf_copy_object(cl_object *destobj, const cl_object *srcobj)
{
	destobj->type = srcobj->type;
	destobj->sz = srcobj->sz;
	destobj->free = 0; //By default assume that there is nothing to free

	//Each of the types of bins needs a different treatment in copying.
	switch(srcobj->type) {
		case CL_NULL:
			break;
		case CL_INT:
			destobj->u.i64 = srcobj->u.i64;
			break;
		case CL_STR:
			destobj->free = destobj->u.str = malloc(destobj->sz+1);
			if (destobj->free == NULL) {
				return -1;
			}
			memcpy(destobj->u.str, srcobj->u.str, destobj->sz);
			destobj->u.str[destobj->sz] = 0;
			break;
		case CL_BLOB:
		case CL_DIGEST:
		case CL_JAVA_BLOB:
		case CL_CSHARP_BLOB:
		case CL_PYTHON_BLOB:
		case CL_RUBY_BLOB:
		case CL_PHP_BLOB:
			destobj->free = destobj->u.blob = malloc(destobj->sz);
			if (destobj->free == NULL) {
				return -1;
			}
			memcpy(destobj->u.blob, srcobj->u.blob, destobj->sz);
			break;
		default:
			cf_error("Encountered an unknown bin type %d", srcobj->type);
			return -1;
			break;
	}

	return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movl (%rax), %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x10(%rsp), %rax
movl (%rax), %eax
movq %rax, 0x8(%rsp)
subq $0xb, %rax
ja 0x5898
movq 0x8(%rsp), %rax
leaq 0x12f3b(%rip), %rcx     # 0x186d8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x58cf
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x10(%rax)
jmp 0x58cf
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdi
addq $0x1, %rdi
callq 0x2310
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x18(%rsp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x5802
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x58d7
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdx
callq 0x21e0
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x18(%rsp), %rcx
movq 0x8(%rcx), %rcx
movb $0x0, (%rax,%rcx)
jmp 0x58cf
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x2310
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x18(%rsp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x5876
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x58d7
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdx
callq 0x21e0
jmp 0x58cf
leaq 0x18a39(%rip), %rax     # 0x1e2d8
movl (%rax), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jg 0x58c5
leaq 0x18a32(%rip), %rax     # 0x1e2e0
movq (%rax), %rcx
movq 0x10(%rsp), %rax
movl (%rax), %edx
xorl %edi, %edi
leaq 0x12f57(%rip), %rsi     # 0x18818
movb $0x0, %al
callq *%rcx
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x58d7
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movslq 0x1c(%rsp), %rsi
movl $0x40, %edi
callq 0x21a0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x595b
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x59ec
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jge 0x59d7
movq 0x10(%rsp), %rdi
movslq 0xc(%rsp), %rax
shlq $0x6, %rax
addq %rax, %rdi
movq 0x20(%rsp), %rsi
movslq 0xc(%rsp), %rax
shlq $0x6, %rax
addq %rax, %rsi
callq 0x58e0
movl %eax, 0x18(%rsp)
cmpl $-0x1, 0x18(%rsp)
jne 0x59c8
cmpl $0x0, 0xc(%rsp)
jle 0x59b4
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
callq 0x56d0
movq 0x10(%rsp), %rdi
callq 0x22e0
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x59ec
jmp 0x59ca
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x5963
movq 0x10(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, (%rax)
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movl 0x48(%rsp), %eax
movl 0x40(%rsp), %eax
movl 0x38(%rsp), %eax
movl 0x30(%rsp), %eax
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movl %ecx, 0x10(%rsp)
movl %r8d, 0xc(%rsp)
movl %r9d, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movb $0x2, (%rax)
movq (%rsp), %rax
movb $0x3, 0x1(%rax)
movq 0x18(%rsp), %rcx
movq (%rsp), %rax
addq $-0x8, %rcx
movl %ecx, %edx
movl %edx, 0x2(%rax)
shrq $0x20, %rcx
movw %cx, 0x6(%rax)
movq (%rsp), %rdi
callq 0x13a70
movq (%rsp), %rax
movb $0x16, 0x8(%rax)
movl 0x14(%rsp), %eax
movb %al, %cl
movq (%rsp), %rax
movb %cl, 0x9(%rax)
movl 0x10(%rsp), %eax
movb %al, %cl
movq (%rsp), %rax
movb %cl, 0xa(%rax)
movl 0xc(%rsp), %eax
movb %al, %cl
movq (%rsp), %rax
movb %cl, 0xb(%rax)
movq (%rsp), %rax
movb $0x0, 0xc(%rax)
movq (%rsp), %rax
movb $0x0, 0xd(%rax)
movl 0x8(%rsp), %ecx
movq (%rsp), %rax
movl %ecx, 0xe(%rax)
movl 0x30(%rsp), %ecx
movq (%rsp), %rax
movl %ecx, 0x12(%rax)
movl 0x38(%rsp), %ecx
movq (%rsp), %rax
movl %ecx, 0x16(%rax)
movl 0x40(%rsp), %eax
movw %ax, %cx
movq (%rsp), %rax
movw %cx, 0x1a(%rax)
movl 0x48(%rsp), %eax
movw %ax, %cx
movq (%rsp), %rax
movw %cx, 0x1c(%rax)
movq (%rsp), %rdi
addq $0x8, %rdi
callq 0x13af0
movq 0x20(%rsp), %rax
addq $0x1e, %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movl 0x20(%rax), %eax
movq %rax, 0x8(%rsp)
subq $0xb, %rax
ja 0x5b95
movq 0x8(%rsp), %rax
leaq 0x12bcb(%rip), %rcx     # 0x18708
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x5bcd
movq 0x18(%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x5be0
movslq %eax, %rcx
movq 0x10(%rsp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
jmp 0x5bcd
movq 0x18(%rsp), %rax
movq 0x28(%rax), %rcx
movq 0x10(%rsp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
jmp 0x5bcd
movq 0x18(%rsp), %rax
movq 0x28(%rax), %rcx
movq 0x10(%rsp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
jmp 0x5bcd
leaq 0x1873c(%rip), %rax     # 0x1e2d8
movl (%rax), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jg 0x5bc3
leaq 0x18735(%rip), %rax     # 0x1e2e0
movq (%rax), %rcx
movq 0x18(%rsp), %rax
movl 0x20(%rax), %edx
xorl %edi, %edi
leaq 0x12c7c(%rip), %rsi     # 0x1883b
movb $0x0, %al
callq *%rcx
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x5bd5
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/src/citrusleaf.c
// Function: value_to_op_int
static int
value_to_op_int(int64_t value, uint8_t *data)
{
#ifdef OSX
	uint64_t swapped = OSSwapHostToBigInt64(value);
#else // Linux
	uint64_t swapped = __cpu_to_be64((__u64) value);  // swap in place
#endif
	memcpy(data, &swapped, sizeof(uint64_t));
	return(8);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x7210
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, (%rax)
movl $0x8, %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/src/citrusleaf.c
// Function: value_to_op_two_ints
static int
value_to_op_two_ints(void *value, uint8_t *data)
{
	int64_t value1  = *(int64_t *)value;
	int64_t value2  = *(int64_t *)((uint8_t *)value + sizeof(int64_t));

#ifdef OSX
	uint64_t swapped1 = OSSwapHostToBigInt64(value1);
	uint64_t swapped2 = OSSwapHostToBigInt64(value2);
#else // Linux
	uint64_t swapped1 = __cpu_to_be64((__u64) value1);  // swap in place
	uint64_t swapped2 = __cpu_to_be64((__u64) value2);  // swap in place
#endif
	memcpy(data, &swapped1, sizeof(uint64_t));
	memcpy(data + sizeof(uint64_t), &swapped2, sizeof(uint64_t));

	return (2*sizeof(uint64_t));
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
callq 0x7210
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x7210
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rax
movq 0x20(%rsp), %rcx
movq %rcx, (%rax)
movq 0x38(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl $0x10, %eax
addq $0x48, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movzbl 0x7(%rax), %eax
cmpq $0x20, %rax
jbe 0x6b3f
jmp 0x6b82
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
addq $0x8, %rsi
movq 0x10(%rsp), %rax
movzbl 0x7(%rax), %eax
movl %eax, %edx
callq 0x21e0
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movzbl 0x7(%rcx), %ecx
movb $0x0, (%rax,%rcx)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x20, %rsi
callq 0x6b90
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/src/citrusleaf.c
// Function: set_value_search
static int
set_value_search(cl_msg_op *op, cl_bin *values, cl_operation *operations, int n_values)
{
	// currently have to loop through the values to find the right one
	// how that sucks! it's easy to fix eventuallythough
	int i;
	cl_bin *value = 0;
	for (i=0;i<n_values;i++)
	{	
		value = values ? &(values[i]) : &(operations[i].bin);
		if (memcmp(value->bin_name, op->name, op->name_sz) == 0)
			break;
	}
	if (i == n_values) {
#ifdef DEBUG		
		cf_debug("set value: but value wasn't there to begin with. Don't understand.");
#endif		
		return(-1);
	}
	
	// copy
	set_object(op, &value->object);
	return(0);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movq $0x0, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x14(%rsp), %eax
jge 0x72e3
cmpq $0x0, 0x20(%rsp)
je 0x7291
movq 0x20(%rsp), %rax
movslq 0x10(%rsp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq %rax, (%rsp)
jmp 0x72a6
movq 0x18(%rsp), %rax
movslq 0x10(%rsp), %rcx
imulq $0x48, %rcx, %rcx
addq %rcx, %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rsi
addq $0x8, %rsi
movq 0x28(%rsp), %rax
movzbl 0x7(%rax), %eax
movl %eax, %edx
callq 0x2110
cmpl $0x0, %eax
jne 0x72d4
jmp 0x72e3
jmp 0x72d6
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x7268
movl 0x10(%rsp), %eax
cmpl 0x14(%rsp), %eax
jne 0x72f7
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x7312
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x20, %rsi
callq 0x6b90
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %r15
pushq %r14
pushq %rbx
subq $0xb0, %rsp
movq 0xd8(%rsp), %rax
movl 0xd0(%rsp), %eax
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq %rcx, 0x88(%rsp)
movq %r8, 0x80(%rsp)
movl %r9d, 0x7c(%rsp)
testb $0x1, 0x19041(%rip)     # 0x203b0
jne 0x7381
movl $0xffffffff, 0xac(%rsp) # imm = 0xFFFFFFFF
jmp 0x7435
movq $0x0, 0x70(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x7450
movl 0xd0(%rsp), %eax
movl %eax, 0x64(%rsp)
movq 0xa0(%rsp), %rdi
movq 0x98(%rsp), %r8
movq 0x90(%rsp), %r9
movq 0x88(%rsp), %r15
movq 0xd8(%rsp), %r11
movl $0x1, %esi
xorl %ecx, %ecx
xorl %eax, %eax
leaq 0x80(%rsp), %r14
leaq 0x7c(%rsp), %rbx
leaq 0x58(%rsp), %r10
leaq 0x70(%rsp), %rax
movl %ecx, %edx
movq %r15, (%rsp)
movq $0x0, 0x8(%rsp)
movq %r14, 0x10(%rsp)
movl $0x1, 0x18(%rsp)
movq $0x0, 0x20(%rsp)
movq %rbx, 0x28(%rsp)
movq %r11, 0x30(%rsp)
movq %r10, 0x38(%rsp)
movq %rax, 0x40(%rsp)
movq $0x0, 0x48(%rsp)
callq 0x74b0
movl %eax, 0xac(%rsp)
movl 0xac(%rsp), %eax
addq $0xb0, %rsp
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbx
subq $0xa0, %rsp
movq 0xc0(%rsp), %rax
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movq %rcx, 0x78(%rsp)
movl %r8d, 0x74(%rsp)
movl %r9d, 0x70(%rsp)
testb $0x1, 0x1839e(%rip)     # 0x203b0
jne 0x8024
movl $0xffffffff, 0x9c(%rsp) # imm = 0xFFFFFFFF
jmp 0x80cd
movq $0x0, 0x68(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x7450
movl 0x70(%rsp), %eax
movl %eax, 0x5c(%rsp)
movq 0x90(%rsp), %rdi
movq 0x88(%rsp), %r8
movq 0x80(%rsp), %r15
movq 0xc0(%rsp), %r11
movl $0x1, %esi
xorl %ecx, %ecx
xorl %eax, %eax
movl %eax, %r9d
leaq 0x78(%rsp), %r14
leaq 0x74(%rsp), %rbx
leaq 0x50(%rsp), %r10
leaq 0x68(%rsp), %rax
movl %ecx, %edx
movq $0x0, (%rsp)
movq %r15, 0x8(%rsp)
movq %r14, 0x10(%rsp)
movl $0x1, 0x18(%rsp)
movq $0x0, 0x20(%rsp)
movq %rbx, 0x28(%rsp)
movq %r11, 0x30(%rsp)
movq %r10, 0x38(%rsp)
movq %rax, 0x40(%rsp)
movq $0x0, 0x48(%rsp)
callq 0x74b0
movl %eax, 0x9c(%rsp)
movl 0x9c(%rsp), %eax
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %r15
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %r14
pushq %rbx
subq $0x98, %rsp
movq 0xb0(%rsp), %rax
movq %rdi, 0x88(%rsp)
movq %rsi, 0x80(%rsp)
movq %rdx, 0x78(%rsp)
movq %rcx, 0x70(%rsp)
movq %r8, 0x68(%rsp)
movl %r9d, 0x64(%rsp)
testb $0x1, 0x18283(%rip)     # 0x203b0
jne 0x813f
movl $0xffffffff, 0x94(%rsp) # imm = 0xFFFFFFFF
jmp 0x81d4
movq $0x0, 0x58(%rsp)
movq 0x88(%rsp), %rdi
movq 0x80(%rsp), %r8
movq 0x78(%rsp), %r9
movq 0x70(%rsp), %r14
movq 0xb0(%rsp), %r10
xorl %ecx, %ecx
movl $0x1, %edx
xorl %eax, %eax
leaq 0x68(%rsp), %rbx
leaq 0x64(%rsp), %r11
leaq 0x58(%rsp), %rax
movl %ecx, %esi
movq %r14, (%rsp)
movq $0x0, 0x8(%rsp)
movq %rbx, 0x10(%rsp)
movl $0x0, 0x18(%rsp)
movq $0x0, 0x20(%rsp)
movq %r11, 0x28(%rsp)
movq $0x0, 0x30(%rsp)
movq %r10, 0x38(%rsp)
movq %rax, 0x40(%rsp)
movq $0x0, 0x48(%rsp)
callq 0x74b0
movl %eax, 0x94(%rsp)
movl 0x94(%rsp), %eax
addq $0x98, %rsp
popq %rbx
popq %r14
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %r14
pushq %rbx
subq $0x98, %rsp
movq %rdi, 0x88(%rsp)
movq %rsi, 0x80(%rsp)
movq %rdx, 0x78(%rsp)
movq %rcx, 0x70(%rsp)
movl %r8d, 0x6c(%rsp)
movq %r9, 0x60(%rsp)
testb $0x1, 0x1818b(%rip)     # 0x203b0
jne 0x8237
movl $0xffffffff, 0x94(%rsp) # imm = 0xFFFFFFFF
jmp 0x82c7
movq $0x0, 0x58(%rsp)
movq 0x88(%rsp), %rdi
movq 0x80(%rsp), %r8
movq 0x78(%rsp), %r14
movq 0x60(%rsp), %r10
xorl %ecx, %ecx
movl $0x1, %edx
xorl %eax, %eax
movl %eax, %r9d
leaq 0x70(%rsp), %rbx
leaq 0x6c(%rsp), %r11
leaq 0x58(%rsp), %rax
movl %ecx, %esi
movq $0x0, (%rsp)
movq %r14, 0x8(%rsp)
movq %rbx, 0x10(%rsp)
movl $0x0, 0x18(%rsp)
movq $0x0, 0x20(%rsp)
movq %r11, 0x28(%rsp)
movq $0x0, 0x30(%rsp)
movq %r10, 0x38(%rsp)
movq %rax, 0x40(%rsp)
movq $0x0, 0x48(%rsp)
callq 0x74b0
movl %eax, 0x94(%rsp)
movl 0x94(%rsp), %eax
addq $0x98, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/src/citrusleaf.c
// Function: citrusleaf_put_replace
cl_rv
citrusleaf_put_replace(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, CL_MSG_INFO3_REPLACE, ns, 
			set, key, 0, (cl_bin **) &values, CL_OP_WRITE, 0, &n_values, 
			NULL, cl_w_p, &trid, NULL) );
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq 0xb0(%rsp), %rax
movq %rdi, 0x88(%rsp)
movq %rsi, 0x80(%rsp)
movq %rdx, 0x78(%rsp)
movq %rcx, 0x70(%rsp)
movq %r8, 0x68(%rsp)
movl %r9d, 0x64(%rsp)
testb $0x1, 0x18093(%rip)     # 0x203b0
jne 0x832f
movl $0xffffffff, 0x94(%rsp) # imm = 0xFFFFFFFF
jmp 0x83c7
movq $0x0, 0x58(%rsp)
movq 0x88(%rsp), %rdi
movq 0x80(%rsp), %r8
movq 0x78(%rsp), %r9
movq 0x70(%rsp), %r14
movq 0xb0(%rsp), %r10
xorl %esi, %esi
movl $0x1, %edx
movl $0x8, %ecx
xorl %eax, %eax
leaq 0x68(%rsp), %rbx
leaq 0x64(%rsp), %r11
leaq 0x58(%rsp), %rax
movq %r14, (%rsp)
movq $0x0, 0x8(%rsp)
movq %rbx, 0x10(%rsp)
movl $0x0, 0x18(%rsp)
movq $0x0, 0x20(%rsp)
movq %r11, 0x28(%rsp)
movq $0x0, 0x30(%rsp)
movq %r10, 0x38(%rsp)
movq %rax, 0x40(%rsp)
movq $0x0, 0x48(%rsp)
callq 0x74b0
movl %eax, 0x94(%rsp)
movl 0x94(%rsp), %eax
addq $0x98, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %r14
pushq %rbx
subq $0x98, %rsp
movq 0xb0(%rsp), %rax
movq %rdi, 0x88(%rsp)
movq %rsi, 0x80(%rsp)
movq %rdx, 0x78(%rsp)
movq %rcx, 0x70(%rsp)
movq %r8, 0x68(%rsp)
movl %r9d, 0x64(%rsp)
testb $0x1, 0x17f93(%rip)     # 0x203b0
jne 0x842f
movl $0xffffffff, 0x94(%rsp) # imm = 0xFFFFFFFF
jmp 0x84c4
movq $0x0, 0x58(%rsp)
movq 0x88(%rsp), %rdi
movq 0x80(%rsp), %r8
movq 0x70(%rsp), %r9
movq 0x78(%rsp), %r14
movq 0xb0(%rsp), %r10
xorl %ecx, %ecx
movl $0x1, %edx
xorl %eax, %eax
leaq 0x68(%rsp), %rbx
leaq 0x64(%rsp), %r11
leaq 0x58(%rsp), %rax
movl %ecx, %esi
movq $0x0, (%rsp)
movq %r14, 0x8(%rsp)
movq %rbx, 0x10(%rsp)
movl $0x0, 0x18(%rsp)
movq $0x0, 0x20(%rsp)
movq %r11, 0x28(%rsp)
movq $0x0, 0x30(%rsp)
movq %r10, 0x38(%rsp)
movq %rax, 0x40(%rsp)
movq $0x0, 0x48(%rsp)
callq 0x74b0
movl %eax, 0x94(%rsp)
movl 0x94(%rsp), %eax
addq $0x98, %rsp
popq %rbx
popq %r14
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbx
subq $0x90, %rsp
movq 0xa0(%rsp), %rax
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq %rcx, 0x68(%rsp)
movq %r8, 0x60(%rsp)
movl %r9d, 0x5c(%rsp)
testb $0x1, 0x17ca8(%rip)     # 0x203b0
jne 0x871a
movl $0xffffffff, 0x8c(%rsp) # imm = 0xFFFFFFFF
jmp 0x87a5
movq $0x0, 0x50(%rsp)
movq 0x80(%rsp), %rdi
movq 0x78(%rsp), %rcx
movq 0x70(%rsp), %r8
movq 0x68(%rsp), %r9
movq 0xa0(%rsp), %r10
xorl %esi, %esi
movl $0x1, %edx
xorl %eax, %eax
leaq 0x60(%rsp), %rbx
leaq 0x5c(%rsp), %r11
leaq 0x50(%rsp), %rax
movq $0x0, (%rsp)
movq %rbx, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq %r11, 0x20(%rsp)
movq $0x0, 0x28(%rsp)
movq %r10, 0x30(%rsp)
movq %rax, 0x38(%rsp)
movq $0x0, 0x40(%rsp)
callq 0xfd90
movl %eax, 0x8c(%rsp)
movl 0x8c(%rsp), %eax
addq $0x90, %rsp
popq %rbx
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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 %r14
pushq %rbx
subq $0x88, %rsp
movq 0xa0(%rsp), %rax
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movq %rdx, 0x68(%rsp)
movq %rcx, 0x60(%rsp)
movq %r8, 0x58(%rsp)
movl %r9d, 0x54(%rsp)
testb $0x1, 0x17bb9(%rip)     # 0x203b0
jne 0x8809
movl $0xffffffff, 0x84(%rsp) # imm = 0xFFFFFFFF
jmp 0x8890
movq $0x0, 0x48(%rsp)
movq 0x78(%rsp), %rdi
movq 0x70(%rsp), %rcx
movq 0x60(%rsp), %r8
movq 0x68(%rsp), %r14
movq 0xa0(%rsp), %r10
xorl %esi, %esi
movl $0x1, %edx
xorl %eax, %eax
movl %eax, %r9d
leaq 0x58(%rsp), %rbx
leaq 0x54(%rsp), %r11
leaq 0x48(%rsp), %rax
movq %r14, (%rsp)
movq %rbx, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq %r11, 0x20(%rsp)
movq $0x0, 0x28(%rsp)
movq %r10, 0x30(%rsp)
movq %rax, 0x38(%rsp)
movq $0x0, 0x40(%rsp)
callq 0xfd90
movl %eax, 0x84(%rsp)
movl 0x84(%rsp), %eax
addq $0x88, %rsp
popq %rbx
popq %r14
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x18(%rsp), %rdi
addq $0x158, %rdi            # imm = 0x158
callq 0x23e0
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
movl %eax, 0x4(%rsp)
movq 0x18(%rsp), %rdi
addq $0xf8, %rdi
callq 0x8a70
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
jae 0x8a33
movq 0x18(%rsp), %rdi
addq $0xf8, %rdi
movl 0x10(%rsp), %esi
callq 0x8a80
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movb 0x18(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x8a24
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x8a26
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x89ca
movq 0x18(%rsp), %rdi
addq $0x158, %rdi            # imm = 0x158
callq 0x21c0
cmpl $0x0, 0x14(%rsp)
jle 0x8a55
movl $0x2, 0x24(%rsp)
jmp 0x8a5d
movl $0x1, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movq %rdx, 0x68(%rsp)
movq %rcx, 0x60(%rsp)
movq %r8, 0x58(%rsp)
testb $0x1, 0x178d9(%rip)     # 0x203b0
jne 0x8ae9
movl $0xffffffff, 0x84(%rsp) # imm = 0xFFFFFFFF
jmp 0x8b73
movq $0x0, 0x50(%rsp)
movq 0x78(%rsp), %rdi
movq 0x70(%rsp), %r8
movq 0x68(%rsp), %r9
movq 0x60(%rsp), %r11
movq 0x58(%rsp), %r10
xorl %ecx, %ecx
movl $0x3, %edx
xorl %eax, %eax
leaq 0x50(%rsp), %rax
movl %ecx, %esi
movq %r11, (%rsp)
movq $0x0, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movl $0x0, 0x18(%rsp)
movq $0x0, 0x20(%rsp)
movq $0x0, 0x28(%rsp)
movq $0x0, 0x30(%rsp)
movq %r10, 0x38(%rsp)
movq %rax, 0x40(%rsp)
movq $0x0, 0x48(%rsp)
callq 0x74b0
movl %eax, 0x84(%rsp)
movl 0x84(%rsp), %eax
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movq %rdx, 0x68(%rsp)
movq %rcx, 0x60(%rsp)
testb $0x1, 0x177fe(%rip)     # 0x203b0
jne 0x8bc4
movl $0xffffffff, 0x84(%rsp) # imm = 0xFFFFFFFF
jmp 0x8c4c
movq $0x0, 0x58(%rsp)
movq 0x78(%rsp), %rdi
movq 0x70(%rsp), %r8
movq 0x68(%rsp), %r11
movq 0x60(%rsp), %r10
xorl %ecx, %ecx
movl $0x3, %edx
xorl %eax, %eax
movl %eax, %r9d
leaq 0x58(%rsp), %rax
movl %ecx, %esi
movq $0x0, (%rsp)
movq %r11, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movl $0x0, 0x18(%rsp)
movq $0x0, 0x20(%rsp)
movq $0x0, 0x28(%rsp)
movq $0x0, 0x30(%rsp)
movq %r10, 0x38(%rsp)
movq %rax, 0x40(%rsp)
movq $0x0, 0x48(%rsp)
callq 0x74b0
movl %eax, 0x84(%rsp)
movl 0x84(%rsp), %eax
addq $0x88, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/src/citrusleaf.c
// Function: citrusleaf_async_delete_digest_xdr
extern cl_rv
citrusleaf_async_delete_digest_xdr(cl_cluster *asc, const char *ns, const cf_digest *digest, const cl_write_parameters *cl_w_p, void *udata)
{
    if (!g_initialized) return(-1);
    
    	uint64_t trid=0;
	return( cl_do_async_monte( asc, CL_MSG_INFO1_XDS, CL_MSG_INFO2_DELETE | CL_MSG_INFO2_WRITE, ns,
			NULL, 0, digest, NULL, CL_OP_WRITE, 0, NULL, NULL, cl_w_p, &trid, udata));
}

// Assembly:
pushq %rbx
subq $0x80, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movq %r8, 0x50(%rsp)
testb $0x1, 0x17728(%rip)     # 0x203b0
jne 0x8c97
movl $0xffffffff, 0x7c(%rsp) # imm = 0xFFFFFFFF
jmp 0x8d1c
movq $0x0, 0x48(%rsp)
movq 0x70(%rsp), %rdi
movq 0x68(%rsp), %rcx
movq 0x60(%rsp), %rbx
movq 0x58(%rsp), %r11
movq 0x50(%rsp), %rax
movl $0x10, %esi
movl $0x3, %edx
xorl %r8d, %r8d
movl %r8d, %r9d
xorl %r8d, %r8d
leaq 0x48(%rsp), %r10
movq %r9, %r8
movq %rbx, (%rsp)
movq $0x0, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq $0x0, 0x20(%rsp)
movq $0x0, 0x28(%rsp)
movq %r11, 0x30(%rsp)
movq %r10, 0x38(%rsp)
movq %rax, 0x40(%rsp)
callq 0xfd90
movl %eax, 0x7c(%rsp)
movl 0x7c(%rsp), %eax
addq $0x80, %rsp
popq %rbx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbx
subq $0xb0, %rsp
movq 0xd8(%rsp), %rax
movl 0xd0(%rsp), %eax
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq %rcx, 0x88(%rsp)
movq %r8, 0x80(%rsp)
movq %r9, 0x78(%rsp)
cmpq $0x0, 0x80(%rsp)
je 0x8fdb
cmpq $0x0, 0x78(%rsp)
jne 0x9011
leaq 0x152f6(%rip), %rax     # 0x1e2d8
movl (%rax), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jg 0x9001
leaq 0x152ef(%rip), %rax     # 0x1e2e0
movq (%rax), %rcx
xorl %edi, %edi
leaq 0xf8da(%rip), %rsi      # 0x188d7
movb $0x0, %al
callq *%rcx
movl $0xffffffff, 0xac(%rsp) # imm = 0xFFFFFFFF
jmp 0x90f8
testb $0x1, 0x17398(%rip)     # 0x203b0
jne 0x902a
movl $0xffffffff, 0xac(%rsp) # imm = 0xFFFFFFFF
jmp 0x90f8
movq 0x80(%rsp), %rax
movq $0x0, (%rax)
movq 0x78(%rsp), %rax
movl $0x0, (%rax)
movq $0x0, 0x70(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x7450
movl 0xd0(%rsp), %eax
movl %eax, 0x64(%rsp)
movq 0xa0(%rsp), %rdi
movq 0x98(%rsp), %r8
movq 0x90(%rsp), %r9
movq 0x88(%rsp), %r15
movq 0x80(%rsp), %r14
movq 0x78(%rsp), %rbx
movq 0xd8(%rsp), %r11
movl $0x3, %esi
xorl %ecx, %ecx
xorl %eax, %eax
leaq 0x58(%rsp), %r10
leaq 0x70(%rsp), %rax
movl %ecx, %edx
movq %r15, (%rsp)
movq $0x0, 0x8(%rsp)
movq %r14, 0x10(%rsp)
movl $0x1, 0x18(%rsp)
movq $0x0, 0x20(%rsp)
movq %rbx, 0x28(%rsp)
movq %r11, 0x30(%rsp)
movq %r10, 0x38(%rsp)
movq %rax, 0x40(%rsp)
movq $0x0, 0x48(%rsp)
callq 0x74b0
movl %eax, 0xac(%rsp)
movl 0xac(%rsp), %eax
addq $0xb0, %rsp
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %r12
pushq %rbx
subq $0xb8, %rsp
movq 0xe8(%rsp), %rax
movq 0xe0(%rsp), %rax
movq %rdi, 0xa8(%rsp)
movq %rsi, 0xa0(%rsp)
movq %rdx, 0x98(%rsp)
movq %rcx, 0x90(%rsp)
movq %r8, 0x88(%rsp)
movl %r9d, 0x84(%rsp)
cmpq $0x0, 0x90(%rsp)
je 0x9174
cmpq $0x0, 0x88(%rsp)
jne 0x91aa
leaq 0x1515d(%rip), %rax     # 0x1e2d8
movl (%rax), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jg 0x919a
leaq 0x15156(%rip), %rax     # 0x1e2e0
movq (%rax), %rcx
xorl %edi, %edi
leaq 0xf741(%rip), %rsi      # 0x188d7
movb $0x0, %al
callq *%rcx
movl $0xffffffff, 0xb4(%rsp) # imm = 0xFFFFFFFF
jmp 0x92b3
testb $0x1, 0x171ff(%rip)     # 0x203b0
jne 0x91c3
movl $0xffffffff, 0xb4(%rsp) # imm = 0xFFFFFFFF
jmp 0x92b3
movq 0x90(%rsp), %rax
movq $0x0, (%rax)
movq 0x88(%rsp), %rax
movl $0x0, (%rax)
movq $0x0, 0x78(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x7450
movl 0x84(%rsp), %eax
movl %eax, 0x6c(%rsp)
movl $0x3, 0x5c(%rsp)
cmpq $0x0, 0xe8(%rsp)
je 0x921c
movl 0x5c(%rsp), %eax
orl $0x10, %eax
movl %eax, 0x5c(%rsp)
movq 0xa8(%rsp), %rdi
movl 0x5c(%rsp), %esi
movq 0xa0(%rsp), %r8
movq 0x98(%rsp), %r12
movq 0x90(%rsp), %r15
movq 0x88(%rsp), %r14
movq 0xe0(%rsp), %rbx
movq 0xe8(%rsp), %rax
xorl %ecx, %ecx
xorl %edx, %edx
movl %edx, %r9d
leaq 0x60(%rsp), %r11
leaq 0x78(%rsp), %r10
movl %ecx, %edx
movq $0x0, (%rsp)
movq %r12, 0x8(%rsp)
movq %r15, 0x10(%rsp)
movl $0x1, 0x18(%rsp)
movq $0x0, 0x20(%rsp)
movq %r14, 0x28(%rsp)
movq %rbx, 0x30(%rsp)
movq %r11, 0x38(%rsp)
movq %r10, 0x40(%rsp)
movq %rax, 0x48(%rsp)
callq 0x74b0
movl %eax, 0xb4(%rsp)
movl 0xb4(%rsp), %eax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movq %rdx, 0x68(%rsp)
movq %rcx, 0x60(%rsp)
movq %r8, 0x58(%rsp)
testb $0x1, 0x16f19(%rip)     # 0x203b0
jne 0x94a9
movl $0xffffffff, 0x84(%rsp) # imm = 0xFFFFFFFF
jmp 0x9536
movq $0x0, 0x50(%rsp)
movq 0x78(%rsp), %rdi
movq 0x70(%rsp), %r8
movq 0x68(%rsp), %r9
movq 0x60(%rsp), %r11
movq 0x58(%rsp), %r10
movl $0x8, %esi
movl $0x3, %edx
xorl %ecx, %ecx
xorl %eax, %eax
leaq 0x50(%rsp), %rax
movq %r11, (%rsp)
movq $0x0, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movl $0x0, 0x18(%rsp)
movq $0x0, 0x20(%rsp)
movq $0x0, 0x28(%rsp)
movq $0x0, 0x30(%rsp)
movq %r10, 0x38(%rsp)
movq %rax, 0x40(%rsp)
movq $0x0, 0x48(%rsp)
callq 0x74b0
movl %eax, 0x84(%rsp)
movl 0x84(%rsp), %eax
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x957a
movq -0x10(%rbp), %rdi
callq 0x2100
movq %rax, -0x48(%rbp)
jmp 0x9582
xorl %eax, %eax
movq %rax, -0x48(%rbp)
jmp 0x9582
movq -0x48(%rbp), %rax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
movq %rdx, %rax
incq %rax
movq %rsp, %rcx
movq %rcx, -0x30(%rbp)
addq $0x10, %rdx
andq $-0x10, %rdx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, -0x58(%rbp)
movq %rcx, %rsp
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x50(%rbp)
subl $0xa, %eax
ja 0x9652
movq -0x50(%rbp), %rax
leaq 0xf213(%rip), %rcx      # 0x187ec
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x58(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %eax
movb %al, (%rdi)
addq $0x1, %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x21e0
jmp 0x968e
movq -0x58(%rbp), %rsi
movq -0x18(%rbp), %rax
movl (%rax), %eax
movb %al, (%rsi)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
addq $0x1, %rsi
callq 0x5ef0
jmp 0x968e
movq -0x58(%rbp), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %eax
movb %al, (%rdi)
addq $0x1, %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x21e0
jmp 0x968e
leaq 0x14c7f(%rip), %rax     # 0x1e2d8
movl (%rax), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jg 0x967e
leaq 0x14c78(%rip), %rax     # 0x1e2e0
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movl (%rax), %edx
xorl %edi, %edi
leaq 0xf28b(%rip), %rsi      # 0x18905
movb $0x0, %al
callq *%rcx
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl $0x1, -0x3c(%rbp)
jmp 0x96bd
movq -0x58(%rbp), %rdx
movq -0x10(%rbp), %rdi
movslq -0x24(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq -0x20(%rbp), %r8
callq 0x96d0
movl $0x0, -0x4(%rbp)
movl $0x1, -0x3c(%rbp)
movq -0x30(%rbp), %rax
movq %rax, %rsp
movl -0x4(%rbp), %eax
movq %rbp, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/src/../include/citrusleaf/cf_digest.h
// Function: cf_digest_compute2
static inline void
cf_digest_compute2(void *data1, size_t len1, void *data2, size_t len2, cf_digest *d)
{
	if (len1 == 0) {
		RIPEMD160((const unsigned char *) data2, len2, (unsigned char *) d->digest);
	}
	else {
		RIPEMD160_CTX c;
		RIPEMD160_Init(&c);
		RIPEMD160_Update(&c, data1, len1);
		RIPEMD160_Update(&c, data2, len2);
		RIPEMD160_Final( (unsigned char *)(d->digest), &c);
	}
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq %rcx, 0x68(%rsp)
movq %r8, 0x60(%rsp)
cmpq $0x0, 0x78(%rsp)
jne 0x9711
movq 0x70(%rsp), %rdi
movq 0x68(%rsp), %rsi
movq 0x60(%rsp), %rdx
callq 0x24a0
jmp 0x974d
movq %rsp, %rdi
callq 0x23a0
movq 0x80(%rsp), %rsi
movq 0x78(%rsp), %rdx
movq %rsp, %rdi
callq 0x23f0
movq 0x70(%rsp), %rsi
movq 0x68(%rsp), %rdx
movq %rsp, %rdi
callq 0x23f0
movq 0x60(%rsp), %rdi
movq %rsp, %rsi
callq 0x24b0
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)
nop