LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/src/cf_queue.c
// Function: cf_queue_reduce
int 
cf_queue_reduce(cf_queue *q,  cf_queue_reduce_fn cb, void *udata)
{
	if (NULL == q)
		return(-1);

	QUEUE_LOCK(q);	

	if (CF_Q_SZ(q)) {
		
		// it would be faster to have a local variable to hold the index,
		// and do it in uint8_ts or something, but a delete
		// will change the read and write offset, so this is simpler for now
		// can optimize if necessary later....
		
		for (uint32_t i = q->read_offset ;
			 i < q->write_offset ;
			 i++)
		{
			
			int rv = cb(CF_Q_ELEM_PTR(q, i), udata);
			
			// rv == 0 i snormal case, just increment to next point
			if (rv == -1) {
				break; // found what it was looking for
			}
			else if (rv == -2) { // delete!
				cf_queue_delete_offset(q, i);
				goto Found;
			}
		};
	}
	
Found:	
	QUEUE_UNLOCK(q);

	return(0);
	
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
xorl %eax, %eax
cmpq 0x28(%rsp), %rax
jne 0x14999
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x14a79
movq 0x28(%rsp), %rax
testb $0x1, (%rax)
je 0x149b1
movq 0x28(%rsp), %rdi
addq $0x18, %rdi
callq 0x23e0
movq 0x28(%rsp), %rax
movl 0x8(%rax), %eax
movq 0x28(%rsp), %rcx
subl 0xc(%rcx), %eax
cmpl $0x0, %eax
je 0x14a57
movq 0x28(%rsp), %rax
movl 0xc(%rax), %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq 0x28(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jae 0x14a55
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq 0x70(%rax), %rdi
movl 0x14(%rsp), %eax
movq 0x28(%rsp), %rcx
xorl %edx, %edx
divl 0x4(%rcx)
movq 0x8(%rsp), %rax
movl %edx, %ecx
movq 0x28(%rsp), %rdx
imulq 0x10(%rdx), %rcx
addq %rcx, %rdi
movq 0x18(%rsp), %rsi
callq *%rax
movl %eax, 0x10(%rsp)
cmpl $-0x1, 0x10(%rsp)
jne 0x14a2d
jmp 0x14a55
cmpl $-0x2, 0x10(%rsp)
jne 0x14a44
movq 0x28(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x147f0
jmp 0x14a59
jmp 0x14a46
jmp 0x14a48
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x149d6
jmp 0x14a57
jmp 0x14a59
movq 0x28(%rsp), %rax
testb $0x1, (%rax)
je 0x14a71
movq 0x28(%rsp), %rdi
addq $0x18, %rdi
callq 0x21c0
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/src/cf_queue.c
// Function: cf_queue_delete
int
cf_queue_delete(cf_queue *q, void *buf, bool only_one)
{
	if (NULL == q)
		return(CF_QUEUE_ERR);

	QUEUE_LOCK(q);
	
	bool found = false;
	
	if (CF_Q_SZ(q)) {

		for (uint32_t i = q->read_offset ;
			 i < q->write_offset ;
			 i++)
		{
			
			int rv = memcmp(CF_Q_ELEM_PTR(q,i), buf, q->elementsz);
			
			if (rv == 0) { // delete!
				cf_queue_delete_offset(q, i);
				found = true;
				if (only_one == true)	goto Done;
			}
		};
	}

Done:
	QUEUE_UNLOCK(q);

	if (found == false)
		return(CF_QUEUE_EMPTY);
	else
		return(CF_QUEUE_OK);
}

// Assembly:
subq $0x28, %rsp
movb %dl, %al
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
andb $0x1, %al
movb %al, 0xf(%rsp)
xorl %eax, %eax
cmpq 0x18(%rsp), %rax
jne 0x14abc
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x14bc3
movq 0x18(%rsp), %rax
testb $0x1, (%rax)
je 0x14ad4
movq 0x18(%rsp), %rdi
addq $0x18, %rdi
callq 0x23e0
movb $0x0, 0xe(%rsp)
movq 0x18(%rsp), %rax
movl 0x8(%rax), %eax
movq 0x18(%rsp), %rcx
subl 0xc(%rcx), %eax
cmpl $0x0, %eax
je 0x14b89
movq 0x18(%rsp), %rax
movl 0xc(%rax), %eax
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jae 0x14b87
movq 0x18(%rsp), %rax
movq 0x70(%rax), %rdi
movl 0x8(%rsp), %eax
movq 0x18(%rsp), %rcx
xorl %edx, %edx
divl 0x4(%rcx)
movl %edx, %eax
movq 0x18(%rsp), %rcx
imulq 0x10(%rcx), %rax
addq %rax, %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdx
callq 0x2110
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jne 0x14b75
movq 0x18(%rsp), %rdi
movl 0x8(%rsp), %esi
callq 0x147f0
movb $0x1, 0xe(%rsp)
movb 0xf(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x14b73
jmp 0x14b8b
jmp 0x14b75
jmp 0x14b77
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x14afe
jmp 0x14b89
jmp 0x14b8b
movq 0x18(%rsp), %rax
testb $0x1, (%rax)
je 0x14ba3
movq 0x18(%rsp), %rdi
addq $0x18, %rdi
callq 0x21c0
movb 0xe(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x14bbb
movl $0xfffffffe, 0x24(%rsp) # imm = 0xFFFFFFFE
jmp 0x14bc3
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/src/cf_queue.c
// Function: cf_queue_priority_create
cf_queue_priority *
cf_queue_priority_create(size_t elementsz, bool threadsafe)
{
	cf_queue_priority *q = (cf_queue_priority*)malloc(sizeof(cf_queue_priority));
	if (!q)	return(0);
	
	q->threadsafe = threadsafe;
	q->low_q = cf_queue_create(elementsz, false);
	if (!q->low_q) 		goto Fail1;
	q->medium_q = cf_queue_create(elementsz, false);
	if (!q->medium_q)	goto Fail2;
	q->high_q = cf_queue_create(elementsz, false);
	if (!q->high_q)		goto Fail3;
	
	if (threadsafe == false)
		return(q);
#ifdef EXTERNAL_LOCKS
	q->LOCK = cf_hooked_mutex_alloc();
	if (!q->LOCK ) goto Fail5;
#else	
	if (0 != pthread_mutex_init(&q->LOCK, NULL))
		goto Fail4;

	if (0 != pthread_cond_init(&q->CV, NULL))
		goto Fail5;
#endif // EXTERNAL_LOCKS
	
	return(q);
	
Fail5:	
#ifdef EXTERNAL_LOCKS
	cf_hooked_mutex_free(q->LOCK);
#else
	pthread_mutex_destroy(&q->LOCK);
Fail4:	
#endif // EXTERNAL_LOCKS
	cf_queue_destroy(q->high_q);
Fail3:	
	cf_queue_destroy(q->medium_q);
Fail2:	
	cf_queue_destroy(q->low_q);
Fail1:	
	free(q);
	return(0);
}

// Assembly:
subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x18(%rsp)
andb $0x1, %al
movb %al, 0x17(%rsp)
movl $0x78, %edi
callq 0x2310
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x14c07
movq $0x0, 0x20(%rsp)
jmp 0x14d39
movb 0x17(%rsp), %cl
movq 0x8(%rsp), %rax
andb $0x1, %cl
movb %cl, (%rax)
movq 0x18(%rsp), %rdi
xorl %esi, %esi
callq 0x13e70
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x14c3e
jmp 0x14d26
movq 0x18(%rsp), %rdi
xorl %esi, %esi
callq 0x13e70
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x14c67
jmp 0x14d18
movq 0x18(%rsp), %rdi
xorl %esi, %esi
callq 0x13e70
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x14c8d
jmp 0x14d0a
movb 0x17(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x14caa
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x14d39
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2430
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x14cc6
jmp 0x14cfc
movq 0x8(%rsp), %rdi
addq $0x48, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x22f0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x14ce2
jmp 0x14cee
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x14d39
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
callq 0x22d0
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x13ff0
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x13ff0
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x13ff0
movq 0x8(%rsp), %rdi
callq 0x22e0
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/src/cf_queue.c
// Function: cf_queue_priority_destroy
void 
cf_queue_priority_destroy(cf_queue_priority *q)
{
	cf_queue_destroy(q->high_q);
	cf_queue_destroy(q->medium_q);
	cf_queue_destroy(q->low_q);
	if (q->threadsafe) {
#ifdef EXTERNAL_LOCKS
		cf_hooked_mutex_free(q->LOCK);
#else
		pthread_mutex_destroy(&q->LOCK);
		pthread_cond_destroy(&q->CV);
#endif // EXTERNAL_LOCKS
	}
	free(q);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x13ff0
movq (%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x13ff0
movq (%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x13ff0
movq (%rsp), %rax
testb $0x1, (%rax)
je 0x14d9f
movq (%rsp), %rdi
addq $0x20, %rdi
callq 0x22d0
movq (%rsp), %rdi
addq $0x48, %rdi
callq 0x2560
movq (%rsp), %rdi
callq 0x22e0
popq %rax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/src/cf_queue.c
// Function: cf_queue_priority_push
int 
cf_queue_priority_push(cf_queue_priority *q, void *ptr, int pri)
{
	
	QUEUE_LOCK(q);
	
	int rv;
	if (pri == CF_QUEUE_PRIORITY_HIGH)
		rv = cf_queue_push(q->high_q, ptr);
	else if (pri == CF_QUEUE_PRIORITY_MEDIUM)
		rv = cf_queue_push(q->medium_q, ptr);
	else if (pri == CF_QUEUE_PRIORITY_LOW)
		rv = cf_queue_push(q->low_q, ptr);
	else {
		rv = -1;
	}

#ifndef EXTERNAL_LOCKS
	if (rv == 0 && q->threadsafe)
		pthread_cond_signal(&q->CV);
#endif 

	QUEUE_UNLOCK(q);
		
	return(rv);	
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl %edx, 0x4(%rsp)
movq 0x10(%rsp), %rax
testb $0x1, (%rax)
je 0x14dda
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
callq 0x23e0
cmpl $0x1, 0x4(%rsp)
jne 0x14df9
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x14300
movl %eax, (%rsp)
jmp 0x14e42
cmpl $0x2, 0x4(%rsp)
jne 0x14e18
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x14300
movl %eax, (%rsp)
jmp 0x14e40
cmpl $0x3, 0x4(%rsp)
jne 0x14e37
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x14300
movl %eax, (%rsp)
jmp 0x14e3e
movl $0xffffffff, (%rsp)     # imm = 0xFFFFFFFF
jmp 0x14e40
jmp 0x14e42
cmpl $0x0, (%rsp)
jne 0x14e60
movq 0x10(%rsp), %rax
testb $0x1, (%rax)
je 0x14e60
movq 0x10(%rsp), %rdi
addq $0x48, %rdi
callq 0x2030
movq 0x10(%rsp), %rax
testb $0x1, (%rax)
je 0x14e78
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
callq 0x21c0
movl (%rsp), %eax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/src/cf_queue.c
// Function: cf_queue_priority_sz
int
cf_queue_priority_sz(cf_queue_priority *q)
{
	int rv = 0;
	QUEUE_LOCK(q);
	rv += cf_queue_sz(q->high_q);
	rv += cf_queue_sz(q->medium_q);
	rv += cf_queue_sz(q->low_q);
	QUEUE_UNLOCK(q);
	return(rv);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movq 0x10(%rsp), %rax
testb $0x1, (%rax)
je 0x15189
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
callq 0x23e0
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x14070
addl 0xc(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x14070
addl 0xc(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x14070
addl 0xc(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rax
testb $0x1, (%rax)
je 0x151e3
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
callq 0x21c0
movl 0xc(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/src/cf_socket.c
// Function: cf_socket_create_nb
int
cf_socket_create_nb()
{
	// Create the socket.
	int fd = socket(AF_INET, SOCK_STREAM, 0);

	if (-1 == fd) {
		cf_warn("could not allocate socket, errno %d", errno);
		return -1;
	}

    // Make the socket nonblocking.
	int flags = fcntl(fd, F_GETFL, 0);

    if (flags < 0) {
		cf_warn("could not read socket flags");
		close(fd);
        return -1;
	}

    if (fcntl(fd, F_SETFL, flags | O_NONBLOCK) < 0) {
		cf_warn("could not set socket nonblocking");
		close(fd);
        return -1;
	}

	int f = 1;
	setsockopt(fd, SOL_TCP, TCP_NODELAY, &f, sizeof(f));

	return fd;
}

// Assembly:
subq $0x18, %rsp
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x20c0
movl %eax, 0x10(%rsp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl 0x10(%rsp), %eax
jne 0x1525c
leaq 0x90bd(%rip), %rax      # 0x1e2d8
movl (%rax), %ecx
movl $0x1, %eax
cmpl %ecx, %eax
jg 0x1524f
leaq 0x90b3(%rip), %rax      # 0x1e2e0
movq (%rax), %rax
movq %rax, (%rsp)
callq 0x2040
movq (%rsp), %rcx
movl (%rax), %edx
movl $0x1, %edi
leaq 0x45fb(%rip), %rsi      # 0x19846
movb $0x0, %al
callq *%rcx
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
jmp 0x15347
movl 0x10(%rsp), %edi
movl $0x3, %esi
xorl %edx, %edx
movb $0x0, %al
callq 0x2470
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jge 0x152bb
leaq 0x9058(%rip), %rax      # 0x1e2d8
movl (%rax), %ecx
movl $0x1, %eax
cmpl %ecx, %eax
jg 0x152a5
leaq 0x904e(%rip), %rax      # 0x1e2e0
movq (%rax), %rcx
movl $0x1, %edi
leaq 0x45c9(%rip), %rsi      # 0x1986a
movb $0x0, %al
callq *%rcx
movl 0x10(%rsp), %edi
callq 0x2570
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
jmp 0x15347
movl 0x10(%rsp), %edi
movl 0xc(%rsp), %edx
orl $0x800, %edx            # imm = 0x800
movl $0x4, %esi
movb $0x0, %al
callq 0x2470
cmpl $0x0, %eax
jge 0x15319
leaq 0x8ff7(%rip), %rax      # 0x1e2d8
movl (%rax), %ecx
movl $0x1, %eax
cmpl %ecx, %eax
jg 0x15306
leaq 0x8fed(%rip), %rax      # 0x1e2e0
movq (%rax), %rcx
movl $0x1, %edi
leaq 0x4584(%rip), %rsi      # 0x19886
movb $0x0, %al
callq *%rcx
movl 0x10(%rsp), %edi
callq 0x2570
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
jmp 0x15347
movl $0x1, 0x8(%rsp)
movl 0x10(%rsp), %edi
movl $0x6, %esi
movl $0x1, %edx
leaq 0x8(%rsp), %rcx
movl $0x4, %r8d
callq 0x24f0
movl 0x10(%rsp), %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/src/cf_socket.c
// Function: my_strerror_r
static char *
my_strerror_r(const int err, char *errbuf, size_t errbuf_len)
{
	if (errbuf) {
		errbuf[0] = '\0';
		strerror_r(errno, errbuf, errbuf_len);
	}
	
	return errbuf;
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x15c86
movq 0x8(%rsp), %rax
movb $0x0, (%rax)
callq 0x2040
movl (%rax), %edi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq 0x2130
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/src/cf_socket.c
// Function: cf_socket_read_forever
int
cf_socket_read_forever(int fd, uint8_t *buf, size_t buf_len)
{
	// one way is to make sure the fd is blocking, and block
	int flags;
	if (-1 == (flags = fcntl(fd, F_GETFL, 0)))
		flags = 0;
	if (flags & O_NONBLOCK) {
		if (-1 == fcntl(fd, F_SETFL, flags & ~O_NONBLOCK)) {
			return(ENOENT);
		}
	}

	size_t pos = 0;
	do {
		int r_bytes = read(fd, buf + pos, buf_len - pos );
		if (r_bytes < 0) { // don't combine these into one line! think about it!
			if (errno != ETIMEDOUT) {
				return(errno);
			}
		}
		else if (r_bytes == 0) {
			// blocking read returns 0 bytes socket timedout at server side
			// is closed
			return EBADF;
		}
		else {
			pos += r_bytes;
		}
	} while (pos < buf_len);

	return(0);
}

// Assembly:
subq $0x38, %rsp
movl %edi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl 0x30(%rsp), %edi
movl $0x3, %esi
xorl %edx, %edx
movb $0x0, %al
callq 0x2470
movl %eax, %ecx
movl %ecx, 0x1c(%rsp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
jne 0x165cb
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0x1660d
movl 0x30(%rsp), %edi
movl 0x1c(%rsp), %edx
andl $0xfffff7ff, %edx       # imm = 0xFFFFF7FF
movl $0x4, %esi
movb $0x0, %al
callq 0x2470
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
jne 0x1660b
movl $0x2, 0x34(%rsp)
jmp 0x1668f
jmp 0x1660d
movq $0x0, 0x10(%rsp)
movl 0x30(%rsp), %edi
movq 0x28(%rsp), %rsi
addq 0x10(%rsp), %rsi
movq 0x20(%rsp), %rdx
subq 0x10(%rsp), %rdx
callq 0x23c0
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jge 0x16657
callq 0x2040
cmpl $0x6e, (%rax)
je 0x16655
callq 0x2040
movl (%rax), %eax
movl %eax, 0x34(%rsp)
jmp 0x1668f
jmp 0x16679
cmpl $0x0, 0xc(%rsp)
jne 0x16668
movl $0x9, 0x34(%rsp)
jmp 0x1668f
movslq 0xc(%rsp), %rax
addq 0x10(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x16679
jmp 0x1667b
movq 0x10(%rsp), %rax
cmpq 0x20(%rsp), %rax
jb 0x16616
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/cf_socket.c
// Function: cf_socket_write_forever
int
cf_socket_write_forever(int fd, uint8_t *buf, size_t buf_len)
{
	// one way is to make sure the fd is blocking, and block
	int flags;
	if (-1 == (flags = fcntl(fd, F_GETFL, 0)))
		flags = 0;
	if (flags & O_NONBLOCK) {
		if (-1 == fcntl(fd, F_SETFL, flags & ~O_NONBLOCK)) {
			return(ENOENT);
		}
	}

	size_t pos = 0;
	do {
		int r_bytes = write(fd, buf + pos, buf_len - pos );
		if (r_bytes < 0) { // don't combine these into one line! think about it!
			if (errno != ETIMEDOUT) {
				return(errno);
			}
		}
		else {
			pos += r_bytes;
		}
	} while (pos < buf_len);

	if (-1 == fcntl(fd, F_SETFL, flags & O_NONBLOCK)) {
		return(ENOENT);
	}

	return(0);
}

// Assembly:
subq $0x38, %rsp
movl %edi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl 0x30(%rsp), %edi
movl $0x3, %esi
xorl %edx, %edx
movb $0x0, %al
callq 0x2470
movl %eax, %ecx
movl %ecx, 0x1c(%rsp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
jne 0x166db
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0x1671d
movl 0x30(%rsp), %edi
movl 0x1c(%rsp), %edx
andl $0xfffff7ff, %edx       # imm = 0xFFFFF7FF
movl $0x4, %esi
movb $0x0, %al
callq 0x2470
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
jne 0x1671b
movl $0x2, 0x34(%rsp)
jmp 0x167bb
jmp 0x1671d
movq $0x0, 0x10(%rsp)
movl 0x30(%rsp), %edi
movq 0x28(%rsp), %rsi
addq 0x10(%rsp), %rsi
movq 0x20(%rsp), %rdx
subq 0x10(%rsp), %rdx
callq 0x20e0
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jge 0x16767
callq 0x2040
cmpl $0x6e, (%rax)
je 0x16765
callq 0x2040
movl (%rax), %eax
movl %eax, 0x34(%rsp)
jmp 0x167bb
jmp 0x16776
movslq 0xc(%rsp), %rax
addq 0x10(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x16778
movq 0x10(%rsp), %rax
cmpq 0x20(%rsp), %rax
jb 0x16726
movl 0x30(%rsp), %edi
movl 0x1c(%rsp), %edx
andl $0x800, %edx            # imm = 0x800
movl $0x4, %esi
movb $0x0, %al
callq 0x2470
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl %ecx, %eax
jne 0x167b3
movl $0x2, 0x34(%rsp)
jmp 0x167bb
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/cf_socket.c
// Function: cf_socket_start_connect_nb
int
cf_socket_start_connect_nb(int fd, struct sockaddr_in* sa)
{
	if (0 != connect(fd, (struct sockaddr*)sa, sizeof(*sa))) {
        if (! IS_CONNECTING()) {
        	if (errno == ECONNREFUSED) {
        		cf_debug("host refused socket connection");
        	}
        	else {
        		cf_info("could not connect nonblocking socket %d, errno %d", fd, errno);
        	}

        	return -1;
		}
	}

	return 0;
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl 0x20(%rsp), %edi
movq 0x18(%rsp), %rsi
movl $0x10, %edx
callq 0x2200
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x1693a
callq 0x2040
cmpl $0x73, (%rax)
je 0x16938
callq 0x2040
cmpl $0x6f, (%rax)
jne 0x168e2
leaq 0x7a1d(%rip), %rax      # 0x1e2d8
movl (%rax), %ecx
movl $0x3, %eax
cmpl %ecx, %eax
jg 0x168e0
leaq 0x7a13(%rip), %rax      # 0x1e2e0
movq (%rax), %rcx
movl $0x3, %edi
leaq 0x3396(%rip), %rsi      # 0x19c72
movb $0x0, %al
callq *%rcx
jmp 0x1692e
leaq 0x79ef(%rip), %rax      # 0x1e2d8
movl (%rax), %ecx
movl $0x2, %eax
cmpl %ecx, %eax
jg 0x1692c
leaq 0x79e5(%rip), %rax      # 0x1e2e0
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movl 0x20(%rsp), %eax
movl %eax, 0xc(%rsp)
callq 0x2040
movl 0xc(%rsp), %edx
movq 0x10(%rsp), %r8
movl (%rax), %ecx
movl $0x2, %edi
leaq 0x336a(%rip), %rsi      # 0x19c91
movb $0x0, %al
callq *%r8
jmp 0x1692e
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x16942
jmp 0x1693a
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/src/cf_socket.c
// Function: cf_socket_create_and_connect_nb
int
cf_socket_create_and_connect_nb(struct sockaddr_in* sa)
{
	// Create the socket.
	int fd = cf_socket_create_nb();

	// Initiate non-blocking connect.
	if (0 != cf_socket_start_connect_nb(fd, sa)) {
		cf_close(fd);
		return -1;
	}

	return fd;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
callq 0x151f0
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %edi
movq 0x8(%rsp), %rsi
callq 0x16870
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x1698b
movl 0x4(%rsp), %edi
callq 0x2570
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
jmp 0x16993
movl 0x4(%rsp), %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/src/cf_vector.c
// Function: cf_vector_create
cf_vector *
cf_vector_create( uint32_t value_len, uint32_t init_sz, unsigned int flags)
{
	cf_vector *v;

	v = (cf_vector*)malloc(sizeof(cf_vector));
	if (!v)	return(0);

	v->value_len = value_len;
	v->flags = flags;
	v->alloc_len = init_sz;
	v->len = 0;
	v->stack_struct = false;
	v->stack_vector = false;
	if (init_sz) {
		v->vector = (uint8_t*)malloc(init_sz * value_len);
		if (!v->vector)	{
			free(v);
			return(0);
		}
	}
	else
		v->vector = 0;
	if (flags & VECTOR_FLAG_INITZERO)
		memset((void*)v->vector, 0, init_sz * value_len);
	if (flags & VECTOR_FLAG_BIGLOCK){
#ifdef EXTERNAL_LOCKS
		v->LOCK = cf_hooked_mutex_alloc();
#else
		pthread_mutex_init(&v->LOCK, 0);
#endif // EXTERNAL_LOCKS
	}
	return(v);
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x1c(%rsp)
movl %esi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movl $0x48, %edi
callq 0x2310
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x16a55
movq $0x0, 0x20(%rsp)
jmp 0x16b3c
movl 0x1c(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, (%rax)
movl 0x14(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x4(%rax)
movl 0x18(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0xc(%rax)
movq 0x8(%rsp), %rax
movb $0x0, 0x18(%rax)
movq 0x8(%rsp), %rax
movb $0x0, 0x19(%rax)
cmpl $0x0, 0x18(%rsp)
je 0x16ade
movl 0x18(%rsp), %eax
imull 0x1c(%rsp), %eax
movl %eax, %eax
movl %eax, %edi
callq 0x2310
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x16adc
movq 0x8(%rsp), %rdi
callq 0x22e0
movq $0x0, 0x20(%rsp)
jmp 0x16b3c
jmp 0x16aeb
movq 0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
movl 0x14(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x16b14
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
movl 0x18(%rsp), %eax
imull 0x1c(%rsp), %eax
movl %eax, %eax
movl %eax, %edx
xorl %esi, %esi
callq 0x2170
movl 0x14(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x16b32
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2430
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/src/cf_vector.c
// Function: cf_vector_init
int
cf_vector_init(cf_vector *v, uint32_t value_len, uint32_t init_sz, unsigned int flags)
{
	v->value_len = value_len;
	v->flags = flags;
	v->alloc_len = init_sz;
	v->len = 0;
	v->stack_struct = true;
	v->stack_vector = false;
	if (init_sz) {
		v->vector = (uint8_t*)malloc(init_sz * value_len);
		if (!v->vector)	return(-1);
	}
	else
		v->vector = 0;
	if (flags & VECTOR_FLAG_INITZERO)
		memset((void*)v->vector, 0, init_sz * value_len);
	if (flags & VECTOR_FLAG_BIGLOCK){
#ifdef EXTERNAL_LOCKS
		v->LOCK = cf_hooked_mutex_alloc();
#else
		pthread_mutex_init(&v->LOCK, 0);
#endif // EXTERNAL_LOCKS
	}
	return(0);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movl %edx, 0x10(%rsp)
movl %ecx, 0xc(%rsp)
movl 0x14(%rsp), %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
movl 0xc(%rsp), %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x4(%rax)
movl 0x10(%rsp), %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x18(%rsp), %rax
movl $0x0, 0xc(%rax)
movq 0x18(%rsp), %rax
movb $0x1, 0x18(%rax)
movq 0x18(%rsp), %rax
movb $0x0, 0x19(%rax)
cmpl $0x0, 0x10(%rsp)
je 0x16be3
movl 0x10(%rsp), %eax
imull 0x14(%rsp), %eax
movl %eax, %eax
movl %eax, %edi
callq 0x2310
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x16be1
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x16c3f
jmp 0x16bf0
movq 0x18(%rsp), %rax
movq $0x0, 0x10(%rax)
movl 0xc(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x16c19
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
movl 0x10(%rsp), %eax
imull 0x14(%rsp), %eax
movl %eax, %eax
movl %eax, %edx
xorl %esi, %esi
callq 0x2170
movl 0xc(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x16c37
movq 0x18(%rsp), %rdi
addq $0x20, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2430
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/src/cf_vector.c
// Function: cf_vector_init_smalloc
void
cf_vector_init_smalloc(cf_vector *v, uint32_t value_len, uint8_t *sbuf, int sbuf_sz, unsigned int flags)
{
	v->value_len = value_len;
	v->flags = flags;
	v->alloc_len = sbuf_sz / value_len;
	v->len = 0;
	v->stack_struct = true;
	v->stack_vector = true;
	v->vector = sbuf;
	if (flags & VECTOR_FLAG_INITZERO)
		memset((void*)v->vector, 0, sbuf_sz);
	if (flags & VECTOR_FLAG_BIGLOCK){
#ifdef EXTERNAL_LOCKS
	v->LOCK = cf_hooked_mutex_alloc();
#else
		pthread_mutex_init(&v->LOCK, 0);
#endif
	}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movl %ecx, 0xc(%rsp)
movl %r8d, 0x8(%rsp)
movl 0x1c(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, (%rax)
movl 0x8(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x4(%rax)
movl 0xc(%rsp), %eax
xorl %edx, %edx
divl 0x1c(%rsp)
movl %eax, %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x20(%rsp), %rax
movl $0x0, 0xc(%rax)
movq 0x20(%rsp), %rax
movb $0x1, 0x18(%rax)
movq 0x20(%rsp), %rax
movb $0x1, 0x19(%rax)
movq 0x10(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x10(%rax)
movl 0x8(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x16ce3
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rdi
movslq 0xc(%rsp), %rdx
xorl %esi, %esi
callq 0x2170
movl 0x8(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x16d01
movq 0x20(%rsp), %rdi
addq $0x20, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2430
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/src/cf_vector.c
// Function: cf_vector_clone_stack
void
cf_vector_clone_stack(cf_vector *v, cf_vector *target, uint8_t *target_buf)
{
	if (v->flags & VECTOR_FLAG_BIGLOCK)
		VECTOR_LOCK(v);

	target->value_len = v->value_len;
	target->flags = v->flags;
	target->alloc_len = v->len;
	target->len = v->len;
	target->stack_struct = true;
	target->stack_vector = true;
	target->vector = target_buf;
	memcpy(target->vector, v->vector, v->value_len * v->len);

	if (target->flags & VECTOR_FLAG_BIGLOCK){
#ifdef EXTERNAL_LOCKS
		target->LOCK = cf_hooked_mutex_alloc();
#else
		pthread_mutex_init(&target->LOCK, 0);
#endif
	}

	if (v->flags & VECTOR_FLAG_BIGLOCK)
		VECTOR_UNLOCK(v);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x10(%rsp), %rax
movl 0x4(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x16d40
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
callq 0x23e0
movq 0x10(%rsp), %rax
movl (%rax), %ecx
movq 0x8(%rsp), %rax
movl %ecx, (%rax)
movq 0x10(%rsp), %rax
movl 0x4(%rax), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x4(%rax)
movq 0x10(%rsp), %rax
movl 0xc(%rax), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x10(%rsp), %rax
movl 0xc(%rax), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0xc(%rax)
movq 0x8(%rsp), %rax
movb $0x1, 0x18(%rax)
movq 0x8(%rsp), %rax
movb $0x1, 0x19(%rax)
movq (%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0x10(%rsp), %rax
movl (%rax), %eax
movq 0x10(%rsp), %rcx
imull 0xc(%rcx), %eax
movl %eax, %eax
movl %eax, %edx
callq 0x21e0
movq 0x8(%rsp), %rax
movl 0x4(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x16dea
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2430
movq 0x10(%rsp), %rax
movl 0x4(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x16e08
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
callq 0x21c0
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/src/cf_vector.c
// Function: cf_vector_destroy
void
cf_vector_destroy(cf_vector *v)
{
	if (v->flags & VECTOR_FLAG_BIGLOCK){
#ifdef EXTERNAL_LOCKS
		cf_hooked_mutex_free(v->LOCK);
#else
		pthread_mutex_destroy(&v->LOCK);
#endif // EXTERNAL_LOCKS
	}
	if (v->vector && (v->stack_vector == false))	free(v->vector);
	if (v->stack_struct == false) free(v);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movl 0x4(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x16e31
movq (%rsp), %rdi
addq $0x20, %rdi
callq 0x22d0
movq (%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x16e5a
movq (%rsp), %rax
movb 0x19(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x16e5a
movq (%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x22e0
movq (%rsp), %rax
movb 0x18(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x16e74
movq (%rsp), %rdi
callq 0x22e0
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/src/cf_vector.c
// Function: cf_vector_set
int
cf_vector_set(cf_vector *v, uint32_t index, void *value)
{
	if (v->flags & VECTOR_FLAG_BIGLOCK)
		VECTOR_LOCK(v);

	// Return error if index is not within current array bounds.
	if (index >= v->alloc_len)
		return(-1);

	memcpy(v->vector + (index * v->value_len), value, v->value_len);
	if (index > v->len)	v->len = index;
	if (v->flags & VECTOR_FLAG_BIGLOCK)
		VECTOR_UNLOCK(v);
	return(0);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rax
movl 0x4(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x16eb0
movq 0x18(%rsp), %rdi
addq $0x20, %rdi
callq 0x23e0
movl 0x14(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jb 0x16ec8
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x16f35
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
movl 0x14(%rsp), %eax
movq 0x18(%rsp), %rcx
imull (%rcx), %eax
movl %eax, %eax
addq %rax, %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rax
movl (%rax), %eax
movl %eax, %edx
callq 0x21e0
movl 0x14(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl 0xc(%rcx), %eax
jbe 0x16f0f
movl 0x14(%rsp), %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0xc(%rax)
movq 0x18(%rsp), %rax
movl 0x4(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x16f2d
movq 0x18(%rsp), %rdi
addq $0x20, %rdi
callq 0x21c0
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/cf_vector.c
// Function: cf_vector_append_lockfree
int
cf_vector_append_lockfree(cf_vector *v, void *value)
{
	if (v->len + 1 >= v->alloc_len)
		if (0 != cf_vector_resize(v, v->len * 2))	return(-1);
	memcpy(v->vector + (v->len * v->value_len), value, v->value_len);
	v->len ++;
	return(0);
	
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq 0x8(%rsp), %rax
movl 0xc(%rax), %eax
addl $0x1, %eax
movq 0x8(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jb 0x16f8a
movq 0x8(%rsp), %rdi
movq 0x8(%rsp), %rax
movl 0xc(%rax), %esi
shll %esi
callq 0x16fe0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x16f88
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
jmp 0x16fd0
jmp 0x16f8a
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x8(%rsp), %rax
movl 0xc(%rax), %eax
movq 0x8(%rsp), %rcx
imull (%rcx), %eax
movl %eax, %eax
addq %rax, %rdi
movq (%rsp), %rsi
movq 0x8(%rsp), %rax
movl (%rax), %eax
movl %eax, %edx
callq 0x21e0
movq 0x8(%rsp), %rax
movl 0xc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rax)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/src/cf_vector.c
// Function: cf_vector_resize
static int
cf_vector_resize(cf_vector *v, uint32_t new_sz)
{
	if (v->flags & VECTOR_FLAG_BIGRESIZE) {
		if (new_sz < 50)	new_sz = 50;
	}
	uint8_t *_t;
	if (v->vector == 0 || v->stack_vector) {
		_t = (uint8_t*)malloc(new_sz * v->value_len);
		if (!_t)	return(-1);
		if (v->stack_vector) {
			memcpy(_t, v->vector, v->alloc_len * v->value_len); 
			v->stack_vector = false;
		}
	}
	else
		_t = (uint8_t*)realloc(v->vector, (new_sz) * v->value_len);
	if (!_t)	return(-1);
	v->vector = _t;
	if (v->flags & VECTOR_FLAG_INITZERO)
		memset((void*)(v->vector + (v->alloc_len * v->value_len)), 0, (new_sz + 2) - v->alloc_len);
	v->alloc_len = new_sz;
	return(0);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rax
movl 0x4(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x1700e
cmpl $0x32, 0x14(%rsp)
jae 0x1700c
movl $0x32, 0x14(%rsp)
jmp 0x1700e
movq 0x18(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x17025
movq 0x18(%rsp), %rax
testb $0x1, 0x19(%rax)
je 0x17091
movl 0x14(%rsp), %eax
movq 0x18(%rsp), %rcx
imull (%rcx), %eax
movl %eax, %eax
movl %eax, %edi
callq 0x2310
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x17054
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x17130
movq 0x18(%rsp), %rax
testb $0x1, 0x19(%rax)
je 0x1708f
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0x18(%rsp), %rax
movl 0x8(%rax), %eax
movq 0x18(%rsp), %rcx
imull (%rcx), %eax
movl %eax, %eax
movl %eax, %edx
callq 0x21e0
movq 0x18(%rsp), %rax
movb $0x0, 0x19(%rax)
jmp 0x170b4
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
movl 0x14(%rsp), %eax
movq 0x18(%rsp), %rcx
imull (%rcx), %eax
movl %eax, %eax
movl %eax, %esi
callq 0x2490
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x170c6
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x17130
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rax
movl 0x4(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x1711c
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x18(%rsp), %rax
movl 0x8(%rax), %eax
movq 0x18(%rsp), %rcx
imull (%rcx), %eax
movl %eax, %eax
addq %rax, %rdi
movl 0x14(%rsp), %eax
addl $0x2, %eax
movq 0x18(%rsp), %rcx
subl 0x8(%rcx), %eax
movl %eax, %eax
movl %eax, %edx
xorl %esi, %esi
callq 0x2170
movl 0x14(%rsp), %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x8(%rax)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/src/cf_vector.c
// Function: cf_vector_append
int
cf_vector_append(cf_vector *v, void *value)
{
	int rv;
	if (v->flags & VECTOR_FLAG_BIGLOCK)
		VECTOR_LOCK(v);
	rv = cf_vector_append_lockfree(v, value);
	if (v->flags & VECTOR_FLAG_BIGLOCK)
		VECTOR_UNLOCK(v);
	return(rv);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movl 0x4(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x1716c
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
callq 0x23e0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x16f40
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rax
movl 0x4(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x1719d
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
callq 0x21c0
movl 0x4(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/src/cf_vector.c
// Function: cf_vector_append_unique
int
cf_vector_append_unique(cf_vector *v, void *value)
{
	int rv=0;
	if (v->flags & VECTOR_FLAG_BIGLOCK)
		VECTOR_LOCK(v);
	uint8_t	*_b = v->vector;
	uint32_t	_l = v->value_len;
	for (unsigned int i=0;i<v->len;i++) {
		if (0 == memcmp(value, _b, _l)) {
			goto Found;
		}
		_b += _l;
	}
	rv = cf_vector_append_lockfree(v, value);
Found:	
	if (v->flags & VECTOR_FLAG_BIGLOCK)
		VECTOR_UNLOCK(v);
	return(rv);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x20(%rsp), %rax
movl 0x4(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x171e4
movq 0x20(%rsp), %rdi
addq $0x20, %rdi
callq 0x23e0
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x4(%rsp)
movl $0x0, (%rsp)
movl (%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl 0xc(%rcx), %eax
jae 0x1724e
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl 0x4(%rsp), %eax
movl %eax, %edx
callq 0x2110
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x17230
jmp 0x17261
movl 0x4(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0x17204
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x16f40
movl %eax, 0x14(%rsp)
movq 0x20(%rsp), %rax
movl 0x4(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x1727f
movq 0x20(%rsp), %rdi
addq $0x20, %rdi
callq 0x21c0
movl 0x14(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/src/cf_vector.c
// Function: cf_vector_get
int
cf_vector_get(cf_vector *v, uint32_t index, void *value_p)
{
	if (v->flags & VECTOR_FLAG_BIGLOCK)
		VECTOR_LOCK(v);
	if (index >= v->alloc_len)
		return(-1);
	memcpy(value_p, v->vector + (index * v->value_len), v->value_len);
	if (v->flags & VECTOR_FLAG_BIGLOCK)
		VECTOR_UNLOCK(v);
	return(0);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rax
movl 0x4(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x172c0
movq 0x18(%rsp), %rdi
addq $0x20, %rdi
callq 0x23e0
movl 0x14(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jb 0x172d8
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x1732b
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rsi
movl 0x14(%rsp), %eax
movq 0x18(%rsp), %rcx
imull (%rcx), %eax
movl %eax, %eax
addq %rax, %rsi
movq 0x18(%rsp), %rax
movl (%rax), %eax
movl %eax, %edx
callq 0x21e0
movq 0x18(%rsp), %rax
movl 0x4(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x17323
movq 0x18(%rsp), %rdi
addq $0x20, %rdi
callq 0x21c0
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/src/cf_vector.c
// Function: cf_vector_getp
void *
cf_vector_getp(cf_vector *v, uint32_t index)
{
	if (v->flags & VECTOR_FLAG_BIGLOCK)
		VECTOR_LOCK(v);
	if (index >= v->alloc_len)
		return(0);
	void *r = v->vector + (index * v->value_len);
	if (v->flags & VECTOR_FLAG_BIGLOCK)
		VECTOR_UNLOCK(v);
	return( r );
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rax
movl 0x4(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x1736b
movq 0x18(%rsp), %rdi
addq $0x20, %rdi
callq 0x23e0
movl 0x14(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jb 0x17384
movq $0x0, 0x20(%rsp)
jmp 0x173cb
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movl 0x14(%rsp), %ecx
movq 0x18(%rsp), %rdx
imull (%rdx), %ecx
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movl 0x4(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x173c1
movq 0x18(%rsp), %rdi
addq $0x20, %rdi
callq 0x21c0
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/src/cf_vector.c
// Function: cf_vector_getp_vlock
void *
cf_vector_getp_vlock(cf_vector *v, uint32_t index, pthread_mutex_t **vlock)
{
	if (!v->flags & VECTOR_FLAG_BIGLOCK)
		return(0);
	if (index >= v->alloc_len)
		return(0);
	VECTOR_LOCK(v);
	*vlock = &v->LOCK;
	return(v->vector + (index * v->value_len));
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rax
cmpl $0x0, 0x4(%rax)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x17418
movq $0x0, 0x20(%rsp)
jmp 0x1746f
movl 0x14(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jb 0x17431
movq $0x0, 0x20(%rsp)
jmp 0x1746f
movq 0x18(%rsp), %rdi
addq $0x20, %rdi
callq 0x23e0
movq 0x18(%rsp), %rcx
addq $0x20, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movl 0x14(%rsp), %ecx
movq 0x18(%rsp), %rdx
imull (%rdx), %ecx
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/src/cf_vector.c
// Function: cf_vector_delete
int
cf_vector_delete(cf_vector *v, uint32_t index)
{
	if (v->flags & VECTOR_FLAG_BIGLOCK)
		VECTOR_LOCK(v);
	// check bounds
	if (index >= v->len)
		return (-1);
	// check for last - no copy
	if (index != v->len - 1) {
		memmove(v->vector + (index * v->value_len), 
				v->vector + ((index+1) * v->value_len),
				(v->len - (index+1)) * v->value_len );
	}
	v->len --;
	
	if (v->flags & VECTOR_FLAG_BIGLOCK)
		VECTOR_UNLOCK(v);
	return(0);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl %esi, 0x4(%rsp)
movq 0x8(%rsp), %rax
movl 0x4(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x174ab
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
callq 0x23e0
movl 0x4(%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl 0xc(%rcx), %eax
jb 0x174c6
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
jmp 0x17566
movl 0x4(%rsp), %eax
movq 0x8(%rsp), %rcx
movl 0xc(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
je 0x17532
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
movl 0x4(%rsp), %eax
movq 0x8(%rsp), %rcx
imull (%rcx), %eax
movl %eax, %eax
addq %rax, %rdi
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rsi
movl 0x4(%rsp), %eax
addl $0x1, %eax
movq 0x8(%rsp), %rcx
imull (%rcx), %eax
movl %eax, %eax
addq %rax, %rsi
movq 0x8(%rsp), %rax
movl 0xc(%rax), %eax
movl 0x4(%rsp), %ecx
addl $0x1, %ecx
subl %ecx, %eax
movq 0x8(%rsp), %rcx
imull (%rcx), %eax
movl %eax, %eax
movl %eax, %edx
callq 0x2480
movq 0x8(%rsp), %rax
movl 0xc(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0xc(%rax)
movq 0x8(%rsp), %rax
movl 0x4(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x1755e
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
callq 0x21c0
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/src/cf_vector.c
// Function: cf_vector_delete_range
int
cf_vector_delete_range(cf_vector *v, uint32_t idx_start, uint32_t idx_end)
{
	if (v->flags & VECTOR_FLAG_BIGLOCK)
		VECTOR_LOCK(v);
	// check bounds
	if (idx_start >= idx_end)
		return (-1);
	if (idx_start >= v->len)
		return(-1);
	if (idx_end >= v->len)
		return(-1);
	
	// Copy down if not at end
	if (idx_end != v->len - 1) {
		memmove( v->vector + (idx_start * v->value_len),
				v->vector + ((idx_end+1) * v->value_len),
			    (v->len - (idx_end+1)) * v->value_len );
	
	}
	v->len -= (idx_end - idx_start) + 1;
	
	if (v->flags & VECTOR_FLAG_BIGLOCK)
		VECTOR_UNLOCK(v);
	return(0);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl %esi, 0x4(%rsp)
movl %edx, (%rsp)
movq 0x8(%rsp), %rax
movl 0x4(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x1759e
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
callq 0x23e0
movl 0x4(%rsp), %eax
cmpl (%rsp), %eax
jb 0x175b4
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
jmp 0x1768f
movl 0x4(%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl 0xc(%rcx), %eax
jb 0x175cf
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
jmp 0x1768f
movl (%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl 0xc(%rcx), %eax
jb 0x175e9
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
jmp 0x1768f
movl (%rsp), %eax
movq 0x8(%rsp), %rcx
movl 0xc(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
je 0x17652
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
movl 0x4(%rsp), %eax
movq 0x8(%rsp), %rcx
imull (%rcx), %eax
movl %eax, %eax
addq %rax, %rdi
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rsi
movl (%rsp), %eax
addl $0x1, %eax
movq 0x8(%rsp), %rcx
imull (%rcx), %eax
movl %eax, %eax
addq %rax, %rsi
movq 0x8(%rsp), %rax
movl 0xc(%rax), %eax
movl (%rsp), %ecx
addl $0x1, %ecx
subl %ecx, %eax
movq 0x8(%rsp), %rcx
imull (%rcx), %eax
movl %eax, %eax
movl %eax, %edx
callq 0x2480
movl (%rsp), %edx
subl 0x4(%rsp), %edx
addl $0x1, %edx
movq 0x8(%rsp), %rax
movl 0xc(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0xc(%rax)
movq 0x8(%rsp), %rax
movl 0x4(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x17687
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
callq 0x21c0
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/src/cf_vector.c
// Function: cf_vector_compact
void
cf_vector_compact(cf_vector *v)
{
	if (v->flags & VECTOR_FLAG_BIGLOCK)
		VECTOR_LOCK(v);
	if (v->alloc_len && (v->len != v->alloc_len)) {
		v->vector = (uint8_t*)realloc(v->vector, v->len * v->alloc_len);
		v->alloc_len = v->len;
	}
	if (v->flags & VECTOR_FLAG_BIGLOCK)
		VECTOR_UNLOCK(v);
	return;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movl 0x4(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x176c1
movq (%rsp), %rdi
addq $0x20, %rdi
callq 0x23e0
movq (%rsp), %rax
cmpl $0x0, 0x8(%rax)
je 0x17714
movq (%rsp), %rax
movl 0xc(%rax), %eax
movq (%rsp), %rcx
cmpl 0x8(%rcx), %eax
je 0x17714
movq (%rsp), %rax
movq 0x10(%rax), %rdi
movq (%rsp), %rax
movl 0xc(%rax), %eax
movq (%rsp), %rcx
imull 0x8(%rcx), %eax
movl %eax, %eax
movl %eax, %esi
callq 0x2490
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq (%rsp), %rax
movl 0xc(%rax), %ecx
movq (%rsp), %rax
movl %ecx, 0x8(%rax)
movq (%rsp), %rax
movl 0x4(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x17730
movq (%rsp), %rdi
addq $0x20, %rdi
callq 0x21c0
popq %rax
retq
nop
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/src/cl_info.c
// Function: citrusleaf_info_parse_single
int
citrusleaf_info_parse_single(char *values, char **value)
{
	while (*values && (*values != '\t'))
		values++;
	if (*values == 0)	return(-1);
	values++;
	*value = values;
	while (*values && (*values != '\n'))
		values++;
	if (*values == 0)	return(-1);
	*values = 0;
	return(0);
	
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x19(%rsp)
je 0x1776f
movq -0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x9, %eax
setne %al
movb %al, -0x19(%rsp)
movb -0x19(%rsp), %al
testb $0x1, %al
jne 0x17779
jmp 0x17789
movq -0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rsp)
jmp 0x1774a
movq -0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x177a3
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x17824
movq -0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rcx
movq -0x18(%rsp), %rax
movq %rcx, (%rax)
movq -0x10(%rsp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x1a(%rsp)
je 0x177e3
movq -0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
setne %al
movb %al, -0x1a(%rsp)
movb -0x1a(%rsp), %al
testb $0x1, %al
jne 0x177ed
jmp 0x177fd
movq -0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rsp)
jmp 0x177be
movq -0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x17814
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x17824
movq -0x10(%rsp), %rax
movb $0x0, (%rax)
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax)