LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/sharpyfox[P]citrusleaf-client/src/cf_queue.c
// Function: cf_queue_push_limit
bool
cf_queue_push_limit(cf_queue *q, void *ptr, uint32_t limit)
{
	QUEUE_LOCK(q);
	uint32_t size = CF_Q_SZ(q);

	if (size >= limit) {
		QUEUE_UNLOCK(q);
		return false;
	}

	/* Check queue length */
	if (size == q->allocsz) {
		/* resize is a pain for circular buffers */
		if (0 != cf_queue_resize(q, q->allocsz + CF_QUEUE_ALLOCSZ)) {
			QUEUE_UNLOCK(q);
			return false;
		}
	}

	memcpy(CF_Q_ELEM_PTR(q,q->write_offset), ptr, q->elementsz);
	q->write_offset++;
	// we're at risk of overflow if the write offset is that high
	if (q->write_offset & 0xC0000000) cf_queue_unwrap(q);

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

	QUEUE_UNLOCK(q);
	return true;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
cmpb $0x1, (%rdi)
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
jne 0xc0d6
leaq 0x18(%rbx), %rdi
callq 0x23b0
movl 0x8(%rbx), %eax
movl %eax, %esi
subl 0xc(%rbx), %esi
cmpl %ebp, %esi
jae 0xc0f8
movl 0x4(%rbx), %ecx
cmpl %ecx, %esi
jne 0xc118
addl $0x40, %esi
movq %rbx, %rdi
callq 0xbf16
testl %eax, %eax
je 0xc112
xorl %ebp, %ebp
cmpb $0x0, (%rbx)
je 0xc10b
addq $0x18, %rbx
movq %rbx, %rdi
callq 0x2190
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
movl 0x4(%rbx), %ecx
movl 0x8(%rbx), %eax
xorl %edx, %edx
movq %r14, %rsi
divl %ecx
movl %edx, %edi
movq 0x10(%rbx), %rdx
imulq %rdx, %rdi
addq 0x70(%rbx), %rdi
callq 0x21b0
movl 0x8(%rbx), %eax
incl %eax
cmpl $0x40000000, %eax       # imm = 0x40000000
movl %eax, 0x8(%rbx)
jb 0xc149
movq %rbx, %rdi
callq 0xc005
movb (%rbx), %al
cmpb $0x1, %al
jne 0xc15a
leaq 0x40(%rbx), %rdi
callq 0x2030
movb (%rbx), %al
movb $0x1, %bpl
testb $0x1, %al
jne 0xc0ff
jmp 0xc10b
// File: /workspace/github_c_makefile_star2_O2/sharpyfox[P]citrusleaf-client/src/cf_queue.c
// Function: cf_queue_delete_offset
void
cf_queue_delete_offset(cf_queue *q, uint32_t index)
{
	index %= q->allocsz;
	uint32_t r_index = q->read_offset % q->allocsz;
	uint32_t w_index = q->write_offset % q->allocsz;
	
	// assumes index is validated!
	
	// if we're deleting the one at the head, just increase the readoffset
	if (index == r_index) {
		q->read_offset++;
		return;
	}
	// if we're deleting the tail just decrease the write offset
	if (w_index && (index == w_index - 1)) {
		q->write_offset--;
		return;
	}
	// and the memory copy is overlapping, so must use memmove
	if (index > r_index) {
		memmove( &q->queue[ (r_index + 1) * q->elementsz ],
			     &q->queue[ r_index * q->elementsz ],
				 (index - r_index) * q->elementsz );
		q->read_offset++;
		return;
	}
	
	if (index < w_index) {
		memmove( &q->queue[ index * q->elementsz ],
			     &q->queue[ (index + 1) * q->elementsz ],
			     (w_index - index - 1) * q->elementsz);
		q->write_offset--;
		return;
	}
	
//	cf_debug(CF_QUEUE,"QUEUE_DELETE_OFFSET: FAIL FAIL FAIL FAIL");

}

// Assembly:
pushq %rbx
movl 0x4(%rdi), %r9d
movq %rdi, %rbx
movl %esi, %eax
xorl %edx, %edx
movl 0x8(%rdi), %edi
divl %r9d
movl 0xc(%rbx), %r8d
movl %edx, %ecx
xorl %edx, %edx
movl %r8d, %eax
divl %r9d
movl %edi, %eax
movl %edx, %esi
xorl %edx, %edx
divl %r9d
cmpl %esi, %ecx
jne 0xc2fd
incl %r8d
movl %r8d, 0xc(%rbx)
jmp 0xc378
movl %edx, %eax
addl $-0x1, %eax
setae %r8b
cmpl %eax, %ecx
setne %al
orb %r8b, %al
jne 0xc317
decl %edi
movl %edi, 0x8(%rbx)
jmp 0xc378
movl %ecx, %eax
subl %esi, %eax
jbe 0xc349
movq 0x10(%rbx), %rcx
movq 0x70(%rbx), %rdx
leal 0x1(%rsi), %edi
movl %esi, %esi
imulq %rcx, %rdi
imulq %rcx, %rsi
imulq %rcx, %rax
addq %rdx, %rdi
addq %rdx, %rsi
movq %rax, %rdx
callq 0x2460
incl 0xc(%rbx)
jmp 0xc378
cmpl %edx, %ecx
jae 0xc378
movq 0x10(%rbx), %rax
movq 0x70(%rbx), %r8
movl %ecx, %edi
leal 0x1(%rcx), %esi
notl %ecx
addl %ecx, %edx
imulq %rax, %rdi
imulq %rax, %rsi
imulq %rax, %rdx
addq %r8, %rdi
addq %r8, %rsi
callq 0x2460
decl 0x8(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xc3d4
cmpb $0x1, (%rdi)
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
jne 0xc39d
leaq 0x18(%rbx), %rdi
callq 0x23b0
movl 0x8(%rbx), %eax
movl 0xc(%rbx), %ebp
cmpl %ebp, %eax
je 0xc3e3
cmpl %eax, %ebp
jae 0xc3e3
movl %ebp, %eax
xorl %edx, %edx
movq %r14, %rsi
divl 0x4(%rbx)
movl %edx, %edi
imulq 0x10(%rbx), %rdi
addq 0x70(%rbx), %rdi
callq *%r15
cmpl $-0x1, %eax
je 0xc3e3
cmpl $-0x2, %eax
je 0xc3d9
movl 0x8(%rbx), %eax
incl %ebp
jmp 0xc3a7
pushq $-0x1
popq %rbp
jmp 0xc3f6
movq %rbx, %rdi
movl %ebp, %esi
callq 0xc2c7
xorl %ebp, %ebp
cmpb $0x1, (%rbx)
jne 0xc3f6
addq $0x18, %rbx
movq %rbx, %rdi
callq 0x2190
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xc43b
cmpb $0x1, (%rdi)
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
jne 0xc429
leaq 0x18(%rbx), %rdi
callq 0x23b0
movl 0x8(%rbx), %r13d
movl 0xc(%rbx), %r15d
cmpl %r15d, %r13d
jne 0xc440
pushq $-0x2
popq %rbp
jmp 0xc494
pushq $-0x1
popq %rbp
jmp 0xc4a5
xorl %r12d, %r12d
cmpl %r13d, %r15d
jae 0xc489
movl %r15d, %eax
xorl %edx, %edx
movq %r14, %rsi
divl 0x4(%rbx)
movl %edx, %edi
movq 0x10(%rbx), %rdx
imulq %rdx, %rdi
addq 0x70(%rbx), %rdi
callq 0x2260
testl %eax, %eax
jne 0xc481
movq %rbx, %rdi
movl %r15d, %esi
callq 0xc2c7
testb %bpl, %bpl
jne 0xc486
movl 0x8(%rbx), %r13d
movb $0x1, %r12b
incl %r15d
jmp 0xc443
movb $0x1, %r12b
movzbl %r12b, %eax
andl $0x1, %eax
leal -0x2(%rax,%rax), %ebp
cmpb $0x1, (%rbx)
jne 0xc4a5
addq $0x18, %rbx
movq %rbx, %rdi
callq 0x2190
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
pushq $0x78
popq %rdi
callq 0x22e0
testq %rax, %rax
je 0xc573
movq %r14, %rdi
xorl %esi, %esi
movq %rax, %rbx
movb %bpl, (%rax)
callq 0xbe10
testq %rax, %rax
movq %rax, 0x8(%rbx)
je 0xc56b
movq %r14, %rdi
xorl %esi, %esi
movq %rax, %r15
callq 0xbe10
testq %rax, %rax
movq %rax, 0x10(%rbx)
je 0xc563
movq %r14, %rdi
xorl %esi, %esi
movq %rax, %r12
callq 0xbe10
testq %rax, %rax
movq %rax, 0x18(%rbx)
je 0xc557
testb %bpl, %bpl
je 0xc575
leaq 0x20(%rbx), %r14
xorl %esi, %esi
movq %r14, %rdi
callq 0x2400
testl %eax, %eax
jne 0xc54a
movq %rbx, %rdi
xorl %esi, %esi
addq $0x48, %rdi
callq 0x22d0
testl %eax, %eax
je 0xc575
movq %r14, %rdi
callq 0x22b0
movq 0x18(%rbx), %rdi
callq 0xbe9d
movq 0x10(%rbx), %r12
movq %r12, %rdi
callq 0xbe9d
movq 0x8(%rbx), %r15
movq %r15, %rdi
callq 0xbe9d
movq %rbx, %rdi
callq 0x22c0
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0xbe9d
movq 0x10(%rbx), %rdi
callq 0xbe9d
movq 0x8(%rbx), %rdi
callq 0xbe9d
cmpb $0x1, (%rbx)
jne 0xc5b7
leaq 0x20(%rbx), %rdi
callq 0x22b0
leaq 0x48(%rbx), %rdi
callq 0x2530
movq %rbx, %rdi
popq %rbx
jmp 0x22c0
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpb $0x1, (%rdi)
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
jne 0xc5de
leaq 0x20(%rbx), %rdi
callq 0x23b0
decl %r15d
pushq $-0x1
popq %rbp
cmpl $0x2, %r15d
ja 0xc614
shll $0x3, %r15d
movq %rbx, %rax
movq %r14, %rsi
subq %r15, %rax
movq 0x18(%rax), %rdi
callq 0xc01b
testl %eax, %eax
jne 0xc614
xorl %ebp, %ebp
cmpb $0x1, (%rbx)
jne 0xc614
leaq 0x48(%rbx), %rdi
callq 0x2030
cmpb $0x1, (%rbx)
jne 0xc625
addq $0x20, %rbx
movq %rbx, %rdi
callq 0x2190
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpb $0x1, (%rdi)
movq %rdi, %rbx
jne 0xc7a8
leaq 0x20(%rbx), %rdi
callq 0x23b0
movq 0x18(%rbx), %rdi
callq 0xbedd
movq 0x10(%rbx), %rdi
movl %eax, %ebp
callq 0xbedd
movq 0x8(%rbx), %rdi
movl %eax, %r14d
callq 0xbedd
cmpb $0x1, (%rbx)
movl %eax, %r15d
jne 0xc7dc
addq $0x20, %rbx
movq %rbx, %rdi
callq 0x2190
addl %ebp, %r14d
addl %r15d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r14
pushq %rbx
pushq %rax
pushq $0x2
popq %rdi
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x20a0
cmpl $-0x1, %eax
je 0xc84f
movl %eax, %ebx
pushq $0x3
popq %rsi
movl %eax, %edi
xorl %edx, %edx
xorl %eax, %eax
callq 0x2450
testl %eax, %eax
js 0xc880
orl $0x800, %eax            # imm = 0x800
pushq $0x4
popq %rsi
movl %eax, %edx
movl %ebx, %edi
xorl %eax, %eax
callq 0x2450
testl %eax, %eax
js 0xc89c
leaq 0x4(%rsp), %rcx
movl $0x1, (%rcx)
pushq $0x6
popq %rsi
pushq $0x1
popq %rdx
pushq $0x4
popq %r8
movl %ebx, %edi
callq 0x24d0
jmp 0xc8ca
leaq 0x8a72(%rip), %rax      # 0x152c8
pushq $-0x1
popq %rbx
cmpl $0x0, (%rax)
jle 0xc8ca
leaq 0x8a6b(%rip), %rax      # 0x152d0
movq (%rax), %r14
callq 0x2040
movl (%rax), %edx
leaq 0x2f79(%rip), %rsi      # 0xf7ef
pushq $0x1
popq %rdi
xorl %eax, %eax
callq *%r14
jmp 0xc8ca
leaq 0x8a41(%rip), %rax      # 0x152c8
cmpl $0x0, (%rax)
jle 0xc8c0
leaq 0x8a3d(%rip), %rax      # 0x152d0
leaq 0x2f79(%rip), %rsi      # 0xf813
jmp 0xc8b6
leaq 0x8a25(%rip), %rax      # 0x152c8
cmpl $0x0, (%rax)
jle 0xc8c0
leaq 0x8a21(%rip), %rax      # 0x152d0
leaq 0x2f79(%rip), %rsi      # 0xf82f
movq (%rax), %rcx
pushq $0x1
popq %rdi
xorl %eax, %eax
callq *%rcx
movl %ebx, %edi
callq 0x2550
pushq $-0x1
popq %rbx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
je 0xcdcf
movb $0x0, (%rbx)
callq 0x2040
movl (%rax), %edi
pushq $0x40
popq %rdx
movq %rbx, %rsi
callq 0x2100
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
xorl %r15d, %r15d
pushq $0x3
popq %rsi
xorl %edx, %edx
xorl %eax, %eax
callq 0x2450
cmpl $-0x1, %eax
cmovel %r15d, %eax
btl $0xb, %eax
jae 0xd2f5
andl $0xfffff7ff, %eax       # imm = 0xFFFFF7FF
pushq $0x4
popq %rsi
movl %eax, %edx
movl %ebp, %edi
xorl %eax, %eax
callq 0x2450
cmpl $-0x1, %eax
je 0xd337
xorl %r15d, %r15d
pushq $0x9
popq %r12
movq %rbx, %rdx
leaq (%r14,%r15), %rsi
movl %ebp, %edi
subq %r15, %rdx
callq 0x2390
testl %eax, %eax
js 0xd31d
je 0xd332
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
addq %rax, %r15
jmp 0xd329
callq 0x2040
movl (%rax), %eax
cmpl $0x6e, %eax
jne 0xd33a
cmpq %rbx, %r15
jb 0xd2fc
xorl %eax, %eax
jmp 0xd33a
movl %r12d, %eax
jmp 0xd33a
pushq $0x2
popq %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %ebx
xorl %ebp, %ebp
pushq $0x3
popq %rsi
xorl %edx, %edx
xorl %eax, %eax
callq 0x2450
cmpl $-0x1, %eax
cmovel %ebp, %eax
movl %eax, %ebp
andl $0x800, %ebp            # imm = 0x800
je 0xd389
andl $0xfffff7ff, %eax       # imm = 0xFFFFF7FF
pushq $0x4
popq %rsi
movl %eax, %edx
movl %ebx, %edi
xorl %eax, %eax
callq 0x2450
cmpl $-0x1, %eax
je 0xd3d8
xorl %r12d, %r12d
movq %r14, %rdx
leaq (%r15,%r12), %rsi
movl %ebx, %edi
subq %r12, %rdx
callq 0x20c0
testl %eax, %eax
js 0xd3ab
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
addq %rax, %r12
jmp 0xd3b7
callq 0x2040
movl (%rax), %eax
cmpl $0x6e, %eax
jne 0xd3db
cmpq %r14, %r12
jb 0xd38c
pushq $0x4
popq %rsi
movl %ebx, %edi
movl %ebp, %edx
xorl %eax, %eax
callq 0x2450
movl %eax, %ecx
xorl %eax, %eax
cmpl $-0x1, %ecx
sete %al
addl %eax, %eax
jmp 0xd3db
pushq $0x2
popq %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %rbx
pushq %rax
movl %edi, %ebp
pushq $0x10
popq %rdx
callq 0x21d0
xorl %ebx, %ebx
testl %eax, %eax
je 0xd4b6
callq 0x2040
movl (%rax), %ecx
cmpl $0x73, %ecx
je 0xd4b6
leaq 0x7e60(%rip), %rax      # 0x152c8
cmpl $0x6f, %ecx
jne 0xd491
movl (%rax), %eax
pushq $-0x1
popq %rbx
cmpl $0x3, %eax
jl 0xd4b6
leaq 0x7e52(%rip), %rax      # 0x152d0
leaq 0x2796(%rip), %rsi      # 0xfc1b
movq (%rax), %rcx
pushq $0x3
popq %rdi
xorl %eax, %eax
callq *%rcx
jmp 0xd4b6
movl (%rax), %eax
pushq $-0x1
popq %rbx
cmpl $0x2, %eax
jl 0xd4b6
leaq 0x7e2e(%rip), %rax      # 0x152d0
leaq 0x2791(%rip), %rsi      # 0xfc3a
movq (%rax), %r8
pushq $0x2
popq %rdi
movl %ebp, %edx
xorl %eax, %eax
callq *%r8
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0xc7f0
movl %eax, %edi
movq %r14, %rsi
movl %eax, %ebx
callq 0xd442
testl %eax, %eax
je 0xd4e5
movl %ebx, %edi
callq 0x2550
pushq $-0x1
popq %rbx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movl %esi, %r14d
movl %edi, %r15d
pushq $0x48
popq %rdi
callq 0x22e0
testq %rax, %rax
je 0xd574
movl %r15d, (%rax)
movl %ebp, 0x4(%rax)
movl %r14d, 0x8(%rax)
andl $0x0, 0xc(%rax)
andw $0x0, 0x18(%rax)
movq %rax, %rbx
testl %r14d, %r14d
je 0xd578
movl %r14d, %edi
imull %r15d, %edi
callq 0x22e0
testq %rax, %rax
movq %rax, 0x10(%rbx)
jne 0xd57f
movq %rbx, %rdi
callq 0x22c0
xorl %ebx, %ebx
jmp 0xd5aa
andq $0x0, 0x10(%rbx)
xorl %eax, %eax
testb $0x2, %bpl
je 0xd596
imull %r15d, %r14d
movq %rax, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x2140
testb $0x1, %bpl
je 0xd5aa
movq %rbx, %rdi
xorl %esi, %esi
addq $0x20, %rdi
callq 0x2400
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, (%rdi)
movl %ecx, 0x4(%rdi)
movl %edx, 0x8(%rdi)
andl $0x0, 0xc(%rdi)
movl %ecx, %ebp
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
testl %edx, %edx
movw $0x1, 0x18(%rdi)
je 0xd5fb
movl %r14d, %edi
imull %r15d, %edi
callq 0x22e0
testq %rax, %rax
movq %rax, 0x10(%rbx)
jne 0xd602
pushq $-0x1
popq %r14
jmp 0xd633
andq $0x0, 0x10(%rbx)
xorl %eax, %eax
testb $0x2, %bpl
je 0xd619
imull %r15d, %r14d
movq %rax, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0x2140
xorl %r14d, %r14d
testb $0x1, %bpl
je 0xd633
addq $0x20, %rbx
xorl %esi, %esi
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x2400
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %rbx
pushq %rax
movl %r8d, %ebp
movl %ecx, %r8d
movq %rdx, %rcx
xorl %edx, %edx
movl %esi, (%rdi)
movq %rdi, %rbx
movl %r8d, %eax
movl %ebp, 0x4(%rdi)
divl %esi
movl %eax, 0x8(%rdi)
andl $0x0, 0xc(%rdi)
testb $0x2, %bpl
movw $0x101, 0x18(%rdi)      # imm = 0x101
movq %rcx, 0x10(%rdi)
je 0xd680
movslq %r8d, %rdx
movq %rcx, %rdi
xorl %esi, %esi
callq 0x2140
testb $0x1, %bpl
jne 0xd68d
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
addq $0x20, %rbx
xorl %esi, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2400
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
testb $0x1, 0x4(%rdi)
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
je 0xd6be
leaq 0x20(%rbx), %rdi
callq 0x23b0
movl (%rbx), %eax
movq %r15, %rdi
movl %eax, (%r14)
movl 0x4(%rbx), %eax
movl %eax, 0x4(%r14)
movl 0xc(%rbx), %eax
movl %eax, 0x8(%r14)
movl %eax, 0xc(%r14)
movw $0x101, 0x18(%r14)      # imm = 0x101
movq %r15, 0x10(%r14)
movl 0xc(%rbx), %edx
movq 0x10(%rbx), %rsi
imull (%rbx), %edx
callq 0x21b0
testb $0x1, 0x4(%r14)
je 0xd707
addq $0x20, %r14
xorl %esi, %esi
movq %r14, %rdi
callq 0x2400
testb $0x1, 0x4(%rbx)
jne 0xd713
popq %rbx
popq %r14
popq %r15
retq
addq $0x20, %rbx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x2190
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
testb $0x1, 0x4(%rdi)
movq %rdi, %rbx
je 0xd737
leaq 0x20(%rbx), %rdi
callq 0x22b0
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0xd74b
cmpb $0x0, 0x19(%rbx)
jne 0xd74b
callq 0x22c0
cmpb $0x0, 0x18(%rbx)
je 0xd753
popq %rbx
retq
movq %rbx, %rdi
popq %rbx
jmp 0x22c0
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r14
pushq %rbx
testb $0x1, 0x4(%rdi)
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
je 0xd777
leaq 0x20(%rbx), %rdi
callq 0x23b0
cmpl %ebp, 0x8(%rbx)
jbe 0xd7ad
movl (%rbx), %edx
movq %r14, %rsi
movl %edx, %edi
imull %ebp, %edi
addq 0x10(%rbx), %rdi
callq 0x21b0
cmpl %ebp, 0xc(%rbx)
jae 0xd797
movl %ebp, 0xc(%rbx)
xorl %ebp, %ebp
testb $0x1, 0x4(%rbx)
je 0xd7b0
addq $0x20, %rbx
movq %rbx, %rdi
callq 0x2190
jmp 0xd7b0
pushq $-0x1
popq %rbp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl 0x8(%rdi), %r14d
movl 0xc(%rdi), %edi
movq %rsi, %r13
leal 0x1(%rdi), %eax
cmpl %r14d, %eax
jae 0xd7e3
movq 0x10(%rbx), %r15
jmp 0xd88e
movl 0x4(%rbx), %eax
addl %edi, %edi
cmpl $0x33, %edi
pushq $0x32
popq %rbp
movq 0x10(%rbx), %r12
cmovael %edi, %ebp
testb $0x4, %al
cmovel %edi, %ebp
testq %r12, %r12
je 0xd805
cmpb $0x1, 0x19(%rbx)
jne 0xd84f
movq %r13, 0x10(%rsp)
movl (%rbx), %r13d
movl %eax, 0xc(%rsp)
movl %r13d, %edi
imull %ebp, %edi
callq 0x22e0
testq %rax, %rax
je 0xd8b2
cmpb $0x1, 0x19(%rbx)
movq %rax, %r15
jne 0xd844
imull %r14d, %r13d
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x21b0
movb $0x0, 0x19(%rbx)
movq 0x10(%rsp), %r13
movl 0xc(%rsp), %eax
jmp 0xd867
movl (%rbx), %esi
movq %r12, %rdi
imull %ebp, %esi
callq 0x2470
testq %rax, %rax
je 0xd8b2
movq %rax, %r15
movl 0x4(%rbx), %eax
testb $0x2, %al
movq %r15, 0x10(%rbx)
je 0xd888
movl 0x8(%rbx), %eax
movl (%rbx), %edi
movl %ebp, %edx
xorl %esi, %esi
subl %eax, %edx
imull %eax, %edi
addq %r15, %rdi
addl $0x2, %edx
callq 0x2140
movl %ebp, 0x8(%rbx)
movl 0xc(%rbx), %edi
movl (%rbx), %edx
movq %r13, %rsi
imull %edx, %edi
addq %r15, %rdi
callq 0x21b0
incl 0xc(%rbx)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $-0x1
popq %rax
jmp 0xd8a3
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r14
pushq %rbx
testb $0x1, 0x4(%rdi)
movq %rsi, %r14
movq %rdi, %rbx
je 0xd8d0
leaq 0x20(%rbx), %rdi
callq 0x23b0
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd7b7
testb $0x1, 0x4(%rbx)
movl %eax, %ebp
je 0xd8ef
addq $0x20, %rbx
movq %rbx, %rdi
callq 0x2190
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testb $0x1, 0x4(%rdi)
movq %rsi, %r14
movq %rdi, %rbx
je 0xd913
leaq 0x20(%rbx), %rdi
callq 0x23b0
movq 0x10(%rbx), %r15
movl (%rbx), %r12d
movl 0xc(%rbx), %ebp
subl $0x1, %ebp
jb 0xd939
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x2260
testl %eax, %eax
je 0xd948
addq %r12, %r15
jmp 0xd91d
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd7b7
movl %eax, %ebp
jmp 0xd94a
xorl %ebp, %ebp
testb $0x1, 0x4(%rbx)
je 0xd95c
addq $0x20, %rbx
movq %rbx, %rdi
callq 0x2190
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testb $0x1, 0x4(%rdi)
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %rbx
je 0xd986
leaq 0x20(%rbx), %rdi
callq 0x23b0
cmpl %r15d, 0x8(%rbx)
jbe 0xd9b7
movl (%rbx), %edx
movq %r14, %rdi
imull %edx, %r15d
addq 0x10(%rbx), %r15
movq %r15, %rsi
callq 0x21b0
xorl %ebp, %ebp
testb $0x1, 0x4(%rbx)
je 0xd9ba
addq $0x20, %rbx
movq %rbx, %rdi
callq 0x2190
jmp 0xd9ba
pushq $-0x1
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r14
pushq %rbx
pushq %rax
testb $0x1, 0x4(%rdi)
movl %esi, %ebx
movq %rdi, %r14
je 0xd9df
leaq 0x20(%r14), %rdi
callq 0x23b0
cmpl %ebx, 0x8(%r14)
jbe 0xda02
imull (%r14), %ebx
addq 0x10(%r14), %rbx
testb $0x1, 0x4(%r14)
je 0xda04
addq $0x20, %r14
movq %r14, %rdi
callq 0x2190
jmp 0xda04
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x0, 0x4(%rdi)
je 0xda43
cmpl %esi, 0x8(%rdi)
movl %esi, %ebx
movq %rdi, %r14
jbe 0xda43
leaq 0x20(%r14), %r12
movq %rdx, %r15
movq %r12, %rdi
callq 0x23b0
movq %r12, (%r15)
imull (%r14), %ebx
addq 0x10(%r14), %rbx
jmp 0xda45
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %rbx
pushq %rax
testb $0x1, 0x4(%rdi)
movl %esi, %ebp
movq %rdi, %rbx
je 0xda6b
leaq 0x20(%rbx), %rdi
callq 0x23b0
movl 0xc(%rbx), %edx
cmpl %ebp, %edx
jbe 0xdab9
leal -0x1(%rdx), %eax
cmpl %ebp, %eax
je 0xdaa0
movl (%rbx), %ecx
movq 0x10(%rbx), %rax
movl %ecx, %edi
movl %ecx, %esi
imull %ebp, %edi
incl %ebp
subl %ebp, %edx
imull %ebp, %esi
addq %rax, %rdi
imull %ecx, %edx
addq %rax, %rsi
callq 0x2460
movl 0xc(%rbx), %eax
decl %eax
movl %eax, 0xc(%rbx)
xorl %ebp, %ebp
testb $0x1, 0x4(%rbx)
je 0xdabc
addq $0x20, %rbx
movq %rbx, %rdi
callq 0x2190
jmp 0xdabc
pushq $-0x1
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testb $0x1, 0x4(%rdi)
movl %edx, %r14d
movl %esi, %ebp
movq %rdi, %rbx
je 0xdae3
leaq 0x20(%rbx), %rdi
callq 0x23b0
pushq $-0x1
popq %r15
cmpl %r14d, %ebp
jae 0xdb47
movl 0xc(%rbx), %edx
cmpl %r14d, %edx
jbe 0xdb47
leal -0x1(%rdx), %eax
cmpl %r14d, %eax
je 0xdb25
movl (%rbx), %ecx
movq 0x10(%rbx), %rax
leal 0x1(%r14), %r8d
subl %r8d, %edx
movl %ecx, %esi
movl %ecx, %edi
imull %ecx, %edx
imull %ebp, %edi
imull %r8d, %esi
addq %rax, %rdi
addq %rax, %rsi
callq 0x2460
movl 0xc(%rbx), %edx
notl %r14d
xorl %r15d, %r15d
addl %ebp, %r14d
addl %edx, %r14d
movl %r14d, 0xc(%rbx)
testb $0x1, 0x4(%rbx)
je 0xdb47
addq $0x20, %rbx
movq %rbx, %rdi
callq 0x2190
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
testb $0x1, 0x4(%rdi)
movq %rdi, %rbx
je 0xdb68
leaq 0x20(%rbx), %rdi
callq 0x23b0
movl 0x8(%rbx), %eax
testl %eax, %eax
je 0xdb8c
movl 0xc(%rbx), %esi
cmpl %eax, %esi
je 0xdb8c
movq 0x10(%rbx), %rdi
imull %eax, %esi
callq 0x2470
movq %rax, 0x10(%rbx)
movl 0xc(%rbx), %eax
movl %eax, 0x8(%rbx)
testb $0x1, 0x4(%rbx)
jne 0xdb94
popq %rbx
retq
addq $0x20, %rbx
movq %rbx, %rdi
popq %rbx
jmp 0x2190
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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:
incq %rdi
movzbl -0x1(%rdi), %eax
testl %eax, %eax
je 0xdbc8
cmpl $0x9, %eax
jne 0xdba4
movq %rdi, (%rsi)
movzbl (%rdi), %eax
testl %eax, %eax
je 0xdbc8
cmpl $0xa, %eax
je 0xdbcc
incq %rdi
jmp 0xdbb7
pushq $-0x1
popq %rax
retq
xorl %eax, %eax
movb $0x0, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/sharpyfox[P]citrusleaf-client/src/cl_info.c
// Function: citrusleaf_info
int
citrusleaf_info(char *hostname, short port, char *names, char **values, int timeout_ms)
{
	int rv = -1;
	cf_vector sockaddr_in_v;
	cf_vector_init(&sockaddr_in_v, sizeof( struct sockaddr_in ), 5, 0);
	if (0 != cl_lookup(NULL, hostname, port, &sockaddr_in_v)) {
		cf_debug("Could not find host %s", hostname);
		goto Done;
	}
	
	for (uint i=0; i < cf_vector_size(&sockaddr_in_v) ; i++) 
	{
		struct sockaddr_in  sa_in;
		cf_vector_get(&sockaddr_in_v, i, &sa_in);

		if (0 == citrusleaf_info_host(&sa_in, names, values, timeout_ms, false)) {
			rv = 0;
			goto Done;
		}
	}
	
Done:
	cf_vector_destroy( &sockaddr_in_v );	
	return(rv);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %r8d, %ebx
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %r13
movl %esi, %ebp
leaq 0x10(%rsp), %rdi
pushq $0x10
popq %rsi
pushq $0x5
popq %rdx
xorl %ecx, %ecx
xorl %r12d, %r12d
callq 0xd5b8
xorl %edi, %edi
movq %r13, %rsi
movl %ebp, %edx
leaq 0x10(%rsp), %rcx
movq %r13, 0x8(%rsp)
callq 0x84a4
testl %eax, %eax
je 0xded7
leaq 0x741a(%rip), %rax      # 0x152c8
movl (%rax), %eax
pushq $-0x1
popq %rbp
cmpl $0x3, %eax
jl 0xdf14
leaq 0x7411(%rip), %rax      # 0x152d0
leaq 0x1dad(%rip), %rsi      # 0xfc73
movq (%rax), %rcx
pushq $0x3
popq %rdi
movq 0x8(%rsp), %rdx
xorl %eax, %eax
callq *%rcx
jmp 0xdf14
leaq 0x58(%rsp), %r13
xorl %ebp, %ebp
cmpl 0x1c(%rsp), %r12d
jae 0xdf11
leaq 0x10(%rsp), %rdi
movl %r12d, %esi
movq %r13, %rdx
callq 0xd967
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %ebx, %ecx
xorl %r8d, %r8d
callq 0xdbd2
incl %r12d
testl %eax, %eax
jne 0xdede
jmp 0xdf14
pushq $-0x1
popq %rbp
leaq 0x10(%rsp), %rdi
callq 0xd724
movl %ebp, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/sonicse[P]dbf2mysql/dbf2mysql.c
// Function: check_table
int check_table(MYSQL *sock, char *table) {
    MYSQL_RES *result;
    MYSQL_ROW row;

    if ((result = mysql_list_tables(sock, NULL)) == NULL)
        return 0;
    while ((row = mysql_fetch_row(result)) != NULL) {
        if (strcmp((char *) row[0], table) == 0) {
            mysql_free_result(result);
            return 1;
        }
    }
    mysql_free_result(result);
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
xorl %ebx, %ebx
xorl %esi, %esi
callq 0x2030
testq %rax, %rax
je 0x2500
movq %rax, %r14
pushq $0x1
popq %rbx
movq %r14, %rdi
callq 0x21e0
testq %rax, %rax
je 0x24f6
movq (%rax), %rdi
movq %r15, %rsi
callq 0x22b0
testl %eax, %eax
jne 0x24d8
jmp 0x24f8
xorl %ebx, %ebx
movq %r14, %rdi
callq 0x21d0
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/sonicse[P]dbf2mysql/dbf2mysql.c
// Function: usage
void usage(void) {
    printf("dbf2mysql %s\n", VERSION);
    printf("usage: dbf2mysql [-h hostname] [-d dbase] [-t table] [-p primary key]\n");
    printf("                 [-o field[,field]] [-s oldname=newname[,oldname=newname]]\n");
    printf("                 [-i field[,field]] [-c] [-f] [-F] [-n] [-r] [-u|-l] \n");
    printf("                 [-v[v]] [-x] [-q]  [-P password] [-U user] [-C charset]\n");
    printf("                 dbf-file\n");
}

// Assembly:
pushq %rax
leaq 0x3bfd(%rip), %rdi      # 0x610d
leaq 0x3c04(%rip), %rsi      # 0x611b
xorl %eax, %eax
callq 0x2050
leaq 0x4244(%rip), %rdi      # 0x6769
callq 0x22f0
leaq 0x427e(%rip), %rdi      # 0x67af
callq 0x22f0
leaq 0x42bd(%rip), %rdi      # 0x67fa
callq 0x22f0
leaq 0x42f7(%rip), %rdi      # 0x6840
callq 0x22f0
leaq 0x4334(%rip), %rdi      # 0x6889
popq %rax
jmp 0x22f0
// File: /workspace/github_c_makefile_star2_O2/sonicse[P]dbf2mysql/dbf2mysql.c
// Function: do_onlyfields
void do_onlyfields(char *flist, dbhead *dbh) {
    char *s, *flist2;
    int i, match;

    if (flist == NULL) return;

    if (verbose > 2)
        printf("Removing not specified fields\n");

    if ((flist2 = malloc(strlen(flist) * sizeof (char) + 1)) == NULL) {
        fprintf(stderr, "Memory allocation error in function do_onlyfields\n");
        dbf_close(&dbh);
        exit(1);
    }

    if (verbose > 2)
        printf("Used fields: ");
    for (i = 0; i < dbh -> db_nfields; i++) {
        strcpy(flist2, flist);
        match = 0;
        for (s = strtok(flist2, ","); s != NULL; s = strtok(NULL, ",")) {
            if (strcasecmp(s, dbh -> db_fields[i].db_name) == 0) {
                match = 1;
                if (verbose > 1)
                    printf("%s", s);
            }
        }
        if (match == 0) dbh -> db_fields[i].db_name[0] = '\0';
    }
    if (verbose > 2)
        printf("\n");
    free(flist2);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, 0x20(%rsp)
movq %rdi, 0x10(%rsp)
testq %rdi, %rdi
je 0x269e
movq %rsi, %rbx
cmpl $0x3, 0x6c8a(%rip)      # 0x9210
jl 0x2594
leaq 0x4314(%rip), %rdi      # 0x68a3
callq 0x22f0
movq 0x10(%rsp), %rdi
callq 0x20d0
leaq 0x1(%rax), %rdi
callq 0x2280
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x26ad
cmpl $0x3, 0x6c54(%rip)      # 0x9210
jl 0x25cc
leaq 0x3b8e(%rip), %rdi      # 0x6153
xorl %eax, %eax
callq 0x2050
leaq 0x3e7d(%rip), %r12      # 0x6450
pushq $0x1
popq %r15
xorl %r13d, %r13d
movzbl 0x32(%rbx), %eax
cmpq %rax, %r13
jae 0x2675
movq 0x8(%rsp), %r14
movq %r14, %rdi
movq 0x10(%rsp), %rsi
callq 0x21b0
movq %r14, %rdi
movq %r12, %rsi
callq 0x2310
movq %rax, %rbp
xorl %r14d, %r14d
movq %r13, 0x18(%rsp)
imulq $0xf, %r13, %r13
testq %rbp, %rbp
je 0x265a
movq 0x40(%rbx), %rsi
addq %r13, %rsi
movq %rbp, %rdi
callq 0x2210
testl %eax, %eax
jne 0x264b
cmpl $0x2, 0x6bde(%rip)      # 0x9210
movl %r15d, %r14d
jl 0x264b
leaq 0x3b23(%rip), %rdi      # 0x6161
movq %rbp, %rsi
xorl %eax, %eax
callq 0x2050
movl %r15d, %r14d
xorl %edi, %edi
movq %r12, %rsi
callq 0x2310
movq %rax, %rbp
jmp 0x2613
testl %r14d, %r14d
jne 0x2668
movq 0x40(%rbx), %rax
movb $0x0, (%rax,%r13)
movq 0x18(%rsp), %r13
incq %r13
jmp 0x25da
cmpl $0x3, 0x6b94(%rip)      # 0x9210
jl 0x2686
pushq $0xa
popq %rdi
callq 0x22a0
movq 0x8(%rsp), %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2230
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x6924(%rip), %rax      # 0x8fd8
movq (%rax), %rcx
leaq 0x3a62(%rip), %rdi      # 0x6120
pushq $0x32
popq %rsi
pushq $0x1
popq %rdx
callq 0x23a0
leaq 0x20(%rsp), %rdi
callq 0x4310
pushq $0x1
popq %rdi
callq 0x2250
// File: /workspace/github_c_makefile_star2_O2/sonicse[P]dbf2mysql/dbf.c
// Function: cp866_cp1251
void cp866_cp1251( char* s ) {
    char *c;
    for( c=s; *c!=0; ++c ) {
        if( *c>-129 && *c<-80 )
            *c += 64;
        else if( *c>-33 && *c<-16 )
            *c += 16;
    }
}

// Assembly:
movb (%rdi), %al
testb %al, %al
je 0x3c49
movb $0x40, %cl
cmpb $-0x50, %al
jl 0x3c40
movl %eax, %edx
andb $-0x10, %dl
movb $0x10, %cl
cmpb $-0x20, %dl
jne 0x3c44
orb %cl, %al
movb %al, (%rdi)
incq %rdi
jmp 0x3c28
retq
// File: /workspace/github_c_makefile_star2_O2/sonicse[P]dbf2mysql/dbf.c
// Function: dbf_close
void dbf_close(dbhead **dbhp)
{
    close((*dbhp)->db_fd);

    free((*dbhp)->db_fields);
    (*dbhp)->db_fields = NULL;	/* Defend against getting called twice */

    free((*dbhp)->db_buff);
    (*dbhp)->db_buff = NULL;

    if ((*dbhp)->db_memo != DBF_MTYPE_NONE)
    {
	/* since memo files aren't on stdin this works */
	if ((*dbhp)->db_memofd > 0)
	    close((*dbhp)->db_memofd);
	(*dbhp)->db_memofd = 0;
	free((*dbhp)->mb_buffer);
	(*dbhp)->mb_buffer = NULL;
	(*dbhp)->mb_bufsiz = 0;
    }

    free(*dbhp);
    *dbhp = NULL;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movl (%rax), %edi
callq 0x23b0
movq (%rbx), %rax
movq 0x40(%rax), %rdi
callq 0x2230
movq (%rbx), %rax
andq $0x0, 0x40(%rax)
movq (%rbx), %rax
movq 0x38(%rax), %rdi
callq 0x2230
movq (%rbx), %rax
andq $0x0, 0x38(%rax)
movq (%rbx), %rdi
cmpb $0x0, 0x10(%rdi)
je 0x437d
movl 0x50(%rdi), %eax
testl %eax, %eax
jle 0x4360
movl %eax, %edi
callq 0x23b0
movq (%rbx), %rdi
andl $0x0, 0x50(%rdi)
movq 0x58(%rdi), %rdi
callq 0x2230
movq (%rbx), %rax
andq $0x0, 0x58(%rax)
movq (%rbx), %rdi
andq $0x0, 0x60(%rdi)
callq 0x2230
andq $0x0, (%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/sonicse[P]dbf2mysql/dbf.c
// Function: dbf_write_head
int	dbf_write_head(dbhead *dbh) {
	dbf_header	head;
	time_t now;
	struct tm *dbf_time;

	if (lseek(dbh->db_fd, 0, SEEK_SET) == -1) {
		return DBF_ERROR;
	}

/* fill up the diskheader */

/* Set dataarea of head to '\0' */
	memset(&head,'\0',sizeof(dbf_header));

	head.dbh_dbt = DBH_NORMAL;
	if (dbh->db_memo) head.dbh_dbt = DBH_MEMO;

	now = time((time_t *)NULL); 
	dbf_time = localtime(&now);
	head.dbh_year = dbf_time->tm_year;
	head.dbh_month = dbf_time->tm_mon + 1; /* Months since January + 1 */
	head.dbh_day = dbf_time->tm_mday;

	put_long(head.dbh_records, dbh->db_records);
	put_short(head.dbh_hlen, dbh->db_hlen);
	put_short(head.dbh_rlen, dbh->db_rlen);
	
	if (write(dbh->db_fd, &head, sizeof(dbf_header)) == -1 ) {
		return DBF_ERROR;
	}

	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movl (%rdi), %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2390
cmpq $-0x1, %rax
je 0x443b
leaq 0xc(%rsp), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0xc(%r14)
movups %xmm0, (%r14)
cmpb $0x0, 0x10(%rbx)
pushq $0x3
popq %rax
movl $0x83, %ecx
cmovel %eax, %ecx
movb %cl, -0x4(%r14)
xorl %edi, %edi
callq 0x21a0
movq %rsp, %rdi
movq %rax, (%rdi)
callq 0x2160
movb 0x14(%rax), %cl
movb %cl, -0x3(%r14)
movb 0x10(%rax), %cl
incb %cl
movb %cl, -0x2(%r14)
movb 0xc(%rax), %al
movb %al, -0x1(%r14)
movq 0x20(%rbx), %rsi
movq %r14, %rdi
callq 0x51e2
leaq 0x10(%rsp), %rdi
movswl 0x18(%rbx), %esi
callq 0x51e9
leaq 0x12(%rsp), %rdi
movswl 0x30(%rbx), %esi
callq 0x51e9
movl (%rbx), %edi
leaq 0x8(%rsp), %rsi
pushq $0x20
popq %rdx
callq 0x20a0
movq %rax, %rcx
xorl %eax, %eax
cmpq $-0x1, %rcx
sete %al
negl %eax
jmp 0x443e
pushq $-0x1
popq %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq