// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/src/cl_async.c
// Function: cl_do_async_monte
int
cl_do_async_monte(cl_cluster *asc, int info1, int info2, const char *ns, const char *set, const cl_object *key,
			const cf_digest *digest, cl_bin **values, cl_operator operator, cl_operation **operations, 
			int *n_values, uint32_t *cl_gen, const cl_write_parameters *cl_w_p, uint64_t *trid, void *udata)

{
	cl_async_work	*workitem = NULL;

	uint8_t		wr_stack_buf[STACK_BUF_SZ];
	uint8_t		*wr_buf = wr_stack_buf;
	size_t		wr_buf_sz = sizeof(wr_stack_buf);
	int        	progress_timeout_ms;
	uint64_t 	deadline_ms;
	uint64_t	starttime, endtime;
	bool 		network_error;
	int 		fd = -1;
	int		rv = CITRUSLEAF_FAIL_CLIENT;	//Assume that this is a failure;

	as_msg 		msg;
	cf_digest	d_ret;
	cl_cluster_node	*node = 0;

#if ONEASYNCFD
	if (shash_get_size(g_cl_async_hashtab) >= g_async_h_szlimit) {
		//cf_error("Async hashtab is full. Cannot insert any more elements");
		return CITRUSLEAF_FAIL_ASYNCQ_FULL;
	}
#else
	//If the async buffer is at the max limit, do not entertain more requests.
	if (cf_queue_sz(g_cl_async_q) >= cf_atomic32_get(g_async_q_szlimit)) {
		//cf_error("Async buffer is full. Cannot insert any more elements");
		return CITRUSLEAF_FAIL_ASYNCQ_FULL;
	}
#endif

	//Allocate memory for work item that will be added to the async work list

	if (cf_queue_sz(g_cl_workitems_freepool_q) > 0) {
		cf_queue_pop(g_cl_workitems_freepool_q, &workitem, CF_QUEUE_FOREVER);
	} else {
		workitem = malloc(sizeof(cl_async_work));
		if (workitem == NULL) {
			return CITRUSLEAF_FAIL_CLIENT;
		}
	}

	//Compile the write buffer to be sent to the cluster
	if (n_values && ( values || operations) ){
		cl_compile(info1, info2, 0, ns, set, key, digest, values?*values:NULL, operator, operations?*operations:NULL,
				*n_values , &wr_buf, &wr_buf_sz, cl_w_p, &d_ret, *trid,NULL);
	}else{
		cl_compile(info1, info2, 0, ns, set, key, digest, 0, 0, 0, 0, &wr_buf, &wr_buf_sz, cl_w_p, &d_ret, *trid,NULL);
	}	

	deadline_ms = 0;
	progress_timeout_ms = 0;
	if (cl_w_p && cl_w_p->timeout_ms) {
		deadline_ms = cf_getms() + cl_w_p->timeout_ms;
		// policy: if asking for a long timeout, give enough time to try twice
		if (cl_w_p->timeout_ms > 700) {
			progress_timeout_ms = cl_w_p->timeout_ms / 2;
		}
		else {
			progress_timeout_ms = cl_w_p->timeout_ms;
		}
	}
	else {
		progress_timeout_ms = g_async_nw_progress_timeout;
	}

	//Initialize the async work unit
	workitem->trid = *trid;
	workitem->deadline = deadline_ms;
	workitem->starttime = cf_getms();
	workitem->udata = udata;

	int try = 0;
	// retry request based on the write_policy
	do {
		network_error = false;
		try++;
#ifdef DEBUG		
		if (try > 1) {
			cf_debug("request retrying try %d tid %zu", try, (uint64_t)pthread_self());
		}
#endif        

		// Get an FD from a cluster. First get the probable node for the given digest.
		node = cl_cluster_node_get(asc, ns, &d_ret, info2 & CL_MSG_INFO2_WRITE ? true : false);
		if (!node) {
#ifdef DEBUG
			cf_debug("warning: no healthy nodes in cluster, retrying");
#endif
			usleep(10000);	//Sleep for 10ms
			goto Retry;
		}

		// Now get the dedicated async FD of this node
		starttime = cf_getms();
		fd = cl_cluster_node_fd_get(node, true, asc->nbconnect);
		endtime = cf_getms();
		if ((endtime - starttime) > 10) {
			cf_debug("Time to get FD for a node (>10ms)=%"PRIu64, (endtime - starttime));
		}
		if (fd == -1) {
#ifdef DEBUG			
			cf_debug("warning: node %s has no async file descriptors, retrying transaction (tid %zu)",node->name,(uint64_t)pthread_self() );
#endif			
			usleep(1000);
			goto Retry;
		}

		// Hate special cases, but we have to clear the verify bit on delete verify
		if ( (info2 & CL_MSG_INFO2_DELETE) && (info1 & CL_MSG_INFO1_VERIFY))
		{
			as_msg *msgp = (as_msg *)wr_buf;
			msgp->m.info1 &= ~CL_MSG_INFO1_VERIFY;
		}
		
		// Send the command to the node
		starttime = cf_getms();
		rv = cf_socket_write_timeout(fd, wr_buf, wr_buf_sz, deadline_ms, progress_timeout_ms);
		endtime = cf_getms();
		if ((endtime - starttime) > 10) {
			cf_debug("Time to write to the socket (>10ms)=%"PRIu64, (endtime - starttime));
		}
		if (rv != 0) {
			cf_debug("Citrusleaf: write timeout or error when writing header to server - %d fd %d errno %d (tid %zu)",
					rv,fd,errno,(uint64_t)pthread_self());
			if (rv != ETIMEDOUT)
				network_error = true;
			goto Retry;
		}
		goto Ok;

Retry:
		if (network_error == true) {
			/* 
			 * In case of Async work (for XDS), it may be extreme to
			 * dun a node in case of network error. We just cleanup
			 * things and retry to connect to the remote cluster.
			 * The network error may be a transient one. As this is a
			 * network error, its is better to wait for some significant
			 * time before retrying.
			 */
			sleep(1);	//Sleep for 1sec
#if ONEASYNCFD
//Do not close the FD
#else
			cf_error("async sender: Closing the fd %d because of network error", fd);
			close(fd);
			fd = -1;
#endif
		}

		if (fd != -1) {
			cf_error("async sender: Closing the fd %d because of retry", fd);
			close(fd);
			fd = -1;
		}

		if (node) {
			cl_cluster_node_put(node); 
			node = 0; 
		}

		if (deadline_ms && (deadline_ms < cf_getms() ) ) {
#ifdef DEBUG            
			cf_debug("async sender: out of time : deadline %"PRIu64" now %"PRIu64, deadline_ms, cf_getms());
#endif            
			rv = CITRUSLEAF_FAIL_TIMEOUT;
			goto Error;
		}
	} while ( (cl_w_p == 0) || (cl_w_p->w_pol == CL_WRITE_RETRY) );

Error:	
#ifdef DEBUG	
	cf_debug("exiting with failure: network_error %d wpol %d timeleft %d rv %d",
			(int)network_error, (int)(cl_w_p ? cl_w_p->w_pol : 0), 
			(int)(deadline_ms - cf_getms() ), rv );
#endif	

	if (wr_buf != wr_stack_buf) {
		free(wr_buf);
	}

#if ONEASYNCFD
	//Do not close the FD
#else
	//If it is a network error, the fd would be closed and set to -1.
	//So, we reach this place with a valid FD in case of timeout.
	if (fd != -1) {
		cf_error("async sender: Closing the fd %d because of timeout", fd);
		close(fd);
	}
#endif

	return(rv);
Ok:
	/*
	 * We cannot release the node here as the asyc FD associated
	 * with this node may get closed. We should do it only when
	 * we got back the ack for the async command that we just did.
	 */

	//As we sent the command successfully, add it to the async work list
	workitem->node = node;
	workitem->fd = fd;
	//We are storing only the pointer to the workitem
#if ONEASYNCFD
	if (shash_put_unique(g_cl_async_hashtab, trid, &workitem) != SHASH_OK) {
		//This should always succeed.
		cf_error("Unable to add unique entry into the hash table");
	}
	cf_queue_push(node->asyncwork_q, &workitem);	//Also put in the node's q
#else
	cf_queue_push(g_cl_async_q, &workitem);
#endif

	if (wr_buf != wr_stack_buf) {
		free(wr_buf);
	}

	rv = CITRUSLEAF_OK;
	return rv;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x4188, %rsp           # imm = 0x4188
movq 0x4200(%rsp), %rax
movq 0x41f8(%rsp), %rax
movq 0x41f0(%rsp), %rax
movq 0x41e8(%rsp), %rax
movq 0x41e0(%rsp), %rax
movq 0x41d8(%rsp), %rax
movl 0x41d0(%rsp), %eax
movq 0x41c8(%rsp), %rax
movq 0x41c0(%rsp), %rax
movq %rdi, 0x4178(%rsp)
movl %esi, 0x4174(%rsp)
movl %edx, 0x4170(%rsp)
movq %rcx, 0x4168(%rsp)
movq %r8, 0x4160(%rsp)
movq %r9, 0x4158(%rsp)
movq $0x0, 0x4150(%rsp)
leaq 0x150(%rsp), %rax
movq %rax, 0x148(%rsp)
movq $0x4000, 0x140(%rsp) # imm = 0x4000
movl $0xffffffff, 0x118(%rsp) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x114(%rsp) # imm = 0xFFFFFFFF
movq $0x0, 0xd8(%rsp)
leaq 0x10629(%rip), %rax     # 0x20490
movq (%rax), %rdi
callq 0x14070
cmpl 0x10633(%rip), %eax     # 0x204a8
jl 0xfe87
movl $0xfffffffd, 0x4184(%rsp) # imm = 0xFFFFFFFD
jmp 0x10710
leaq 0x10622(%rip), %rax     # 0x204b0
movq (%rax), %rdi
callq 0x14070
cmpl $0x0, %eax
jle 0xfeb9
leaq 0x1060e(%rip), %rax     # 0x204b0
movq (%rax), %rdi
leaq 0x4150(%rsp), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x14590
jmp 0xfee8
movl $0x30, %edi
callq 0x2310
movq %rax, 0x4150(%rsp)
cmpq $0x0, 0x4150(%rsp)
jne 0xfee6
movl $0xffffffff, 0x4184(%rsp) # imm = 0xFFFFFFFF
jmp 0x10710
jmp 0xfee8
cmpq $0x0, 0x41e0(%rsp)
je 0x100a5
cmpq $0x0, 0x41c8(%rsp)
jne 0xff11
cmpq $0x0, 0x41d8(%rsp)
je 0x100a5
movl 0x4174(%rsp), %eax
movl %eax, 0xa0(%rsp)
movl 0x4170(%rsp), %eax
movl %eax, 0xa4(%rsp)
movq 0x4168(%rsp), %rax
movq %rax, 0xa8(%rsp)
movq 0x4160(%rsp), %rax
movq %rax, 0xb0(%rsp)
movq 0x4158(%rsp), %rax
movq %rax, 0xb8(%rsp)
movq 0x41c0(%rsp), %rax
movq %rax, 0xc0(%rsp)
cmpq $0x0, 0x41c8(%rsp)
je 0xff8d
movq 0x41c8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x98(%rsp)
jmp 0xff99
xorl %eax, %eax
movq %rax, 0x98(%rsp)
jmp 0xff99
movq 0x98(%rsp), %rax
movq %rax, 0x88(%rsp)
movl 0x41d0(%rsp), %eax
movl %eax, 0x94(%rsp)
cmpq $0x0, 0x41d8(%rsp)
je 0xffd7
movq 0x41d8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x80(%rsp)
jmp 0xffe3
xorl %eax, %eax
movq %rax, 0x80(%rsp)
jmp 0xffe3
movq 0x88(%rsp), %r13
movq 0xc0(%rsp), %r12
movq 0xb8(%rsp), %r9
movq 0xb0(%rsp), %r8
movl 0xa4(%rsp), %esi
movl 0xa0(%rsp), %edi
movq 0x80(%rsp), %r15
movq 0x41e0(%rsp), %rax
movl (%rax), %ebp
movq 0x41f0(%rsp), %r11
movq 0x41f8(%rsp), %rax
movq (%rax), %rax
xorl %edx, %edx
leaq 0x148(%rsp), %r14
leaq 0x140(%rsp), %rbx
leaq 0xe2(%rsp), %r10
xorl %ecx, %ecx
movq 0xa8(%rsp), %rcx
movq %r12, (%rsp)
movl 0x94(%rsp), %r12d
movq %r13, 0x8(%rsp)
movl %r12d, 0x10(%rsp)
movq %r15, 0x18(%rsp)
movl %ebp, 0x20(%rsp)
movq %r14, 0x28(%rsp)
movq %rbx, 0x30(%rsp)
movq %r11, 0x38(%rsp)
movq %r10, 0x40(%rsp)
movq %rax, 0x48(%rsp)
movq $0x0, 0x50(%rsp)
callq 0x5fb0
jmp 0x10150
movl 0x4174(%rsp), %edi
movl 0x4170(%rsp), %esi
movq 0x4168(%rsp), %rcx
movq 0x4160(%rsp), %r8
movq 0x4158(%rsp), %r9
movq 0x41c0(%rsp), %r15
movq 0x41f0(%rsp), %r11
movq 0x41f8(%rsp), %rax
movq (%rax), %rax
xorl %edx, %edx
xorl %r10d, %r10d
leaq 0x148(%rsp), %r14
leaq 0x140(%rsp), %rbx
leaq 0xe2(%rsp), %r10
movq %r15, (%rsp)
movq $0x0, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movl $0x0, 0x20(%rsp)
movq %r14, 0x28(%rsp)
movq %rbx, 0x30(%rsp)
movq %r11, 0x38(%rsp)
movq %r10, 0x40(%rsp)
movq %rax, 0x48(%rsp)
movq $0x0, 0x50(%rsp)
callq 0x5fb0
movq $0x0, 0x130(%rsp)
movl $0x0, 0x13c(%rsp)
cmpq $0x0, 0x41f0(%rsp)
je 0x101dd
movq 0x41f0(%rsp), %rax
cmpl $0x0, 0xc(%rax)
je 0x101dd
callq 0x110d0
movq 0x41f0(%rsp), %rcx
movslq 0xc(%rcx), %rcx
addq %rcx, %rax
movq %rax, 0x130(%rsp)
movq 0x41f0(%rsp), %rax
cmpl $0x2bc, 0xc(%rax)       # imm = 0x2BC
jle 0x101c9
movq 0x41f0(%rsp), %rax
movl 0xc(%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, 0x13c(%rsp)
jmp 0x101db
movq 0x41f0(%rsp), %rax
movl 0xc(%rax), %eax
movl %eax, 0x13c(%rsp)
jmp 0x101ea
movl 0xe0f1(%rip), %eax      # 0x1e2d4
movl %eax, 0x13c(%rsp)
movq 0x41f8(%rsp), %rax
movq (%rax), %rcx
movq 0x4150(%rsp), %rax
movq %rcx, (%rax)
movq 0x130(%rsp), %rcx
movq 0x4150(%rsp), %rax
movq %rcx, 0x8(%rax)
callq 0x110d0
movq %rax, %rcx
movq 0x4150(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x4200(%rsp), %rcx
movq 0x4150(%rsp), %rax
movq %rcx, 0x28(%rax)
movl $0x0, 0xd4(%rsp)
movb $0x0, 0x11f(%rsp)
movl 0xd4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xd4(%rsp)
movq 0x4178(%rsp), %rdi
movq 0x4168(%rsp), %rsi
movl 0x4170(%rsp), %edx
andl $0x1, %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
cmpl $0x0, %eax
setne %al
movzbl %al, %ecx
andl $0x1, %ecx
leaq 0xe2(%rsp), %rdx
callq 0xb760
movq %rax, 0xd8(%rsp)
cmpq $0x0, 0xd8(%rsp)
jne 0x102c2
movl $0x2710, %edi           # imm = 0x2710
callq 0x2390
jmp 0x104e7
callq 0x110d0
movq %rax, 0x128(%rsp)
movq 0xd8(%rsp), %rdi
movq 0x4178(%rsp), %rax
movb 0x15(%rax), %al
movl $0x1, %esi
andb $0x1, %al
movzbl %al, %edx
callq 0xc160
movl %eax, 0x118(%rsp)
callq 0x110d0
movq %rax, 0x120(%rsp)
movq 0x120(%rsp), %rax
subq 0x128(%rsp), %rax
cmpq $0xa, %rax
jbe 0x10359
leaq 0xdfb6(%rip), %rax      # 0x1e2d8
movl (%rax), %ecx
movl $0x3, %eax
cmpl %ecx, %eax
jg 0x10357
leaq 0xdfac(%rip), %rax      # 0x1e2e0
movq (%rax), %rcx
movq 0x120(%rsp), %rdx
subq 0x128(%rsp), %rdx
movl $0x3, %edi
leaq 0x8db8(%rip), %rsi      # 0x1910b
movb $0x0, %al
callq *%rcx
jmp 0x10359
cmpl $-0x1, 0x118(%rsp)
jne 0x10372
movl $0x3e8, %edi            # imm = 0x3E8
callq 0x2390
jmp 0x104e7
movl 0x4170(%rsp), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x103b2
movl 0x4174(%rsp), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x103b2
movq 0x148(%rsp), %rax
movq %rax, 0xc8(%rsp)
movq 0xc8(%rsp), %rax
movzbl 0x9(%rax), %ecx
andl $-0x9, %ecx
movb %cl, 0x9(%rax)
callq 0x110d0
movq %rax, 0x128(%rsp)
movl 0x118(%rsp), %edi
movq 0x148(%rsp), %rsi
movq 0x140(%rsp), %rdx
movq 0x130(%rsp), %rcx
movl 0x13c(%rsp), %r8d
callq 0x15c90
movl %eax, 0x114(%rsp)
callq 0x110d0
movq %rax, 0x120(%rsp)
movq 0x120(%rsp), %rax
subq 0x128(%rsp), %rax
cmpq $0xa, %rax
jbe 0x10453
leaq 0xdebc(%rip), %rax      # 0x1e2d8
movl (%rax), %ecx
movl $0x3, %eax
cmpl %ecx, %eax
jg 0x10451
leaq 0xdeb2(%rip), %rax      # 0x1e2e0
movq (%rax), %rcx
movq 0x120(%rsp), %rdx
subq 0x128(%rsp), %rdx
movl $0x3, %edi
leaq 0x8ce4(%rip), %rsi      # 0x19131
movb $0x0, %al
callq *%rcx
jmp 0x10453
cmpl $0x0, 0x114(%rsp)
je 0x104e2
leaq 0xde70(%rip), %rax      # 0x1e2d8
movl (%rax), %ecx
movl $0x3, %eax
cmpl %ecx, %eax
jg 0x104ce
leaq 0xde66(%rip), %rax      # 0x1e2e0
movq (%rax), %rax
movq %rax, 0x78(%rsp)
movl 0x114(%rsp), %eax
movl %eax, 0x6c(%rsp)
movl 0x118(%rsp), %eax
movl %eax, 0x70(%rsp)
callq 0x2040
movl (%rax), %eax
movl %eax, 0x74(%rsp)
callq 0x2240
movl 0x6c(%rsp), %edx
movl 0x70(%rsp), %ecx
movl 0x74(%rsp), %r8d
movq 0x78(%rsp), %r10
movq %rax, %r9
movl $0x3, %edi
leaq 0x8c90(%rip), %rsi      # 0x19159
movb $0x0, %al
callq *%r10
cmpl $0x6e, 0x114(%rsp)
je 0x104e0
movb $0x1, 0x11f(%rsp)
jmp 0x104e7
jmp 0x10698
movb 0x11f(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x10546
movl $0x1, %edi
callq 0x21b0
leaq 0xddcf(%rip), %rax      # 0x1e2d8
movl (%rax), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jg 0x1052f
leaq 0xddc8(%rip), %rax      # 0x1e2e0
movq (%rax), %rcx
movl 0x118(%rsp), %edx
xorl %edi, %edi
leaq 0x8c8d(%rip), %rsi      # 0x191b8
movb $0x0, %al
callq *%rcx
movl 0x118(%rsp), %edi
callq 0x2570
movl $0xffffffff, 0x118(%rsp) # imm = 0xFFFFFFFF
cmpl $-0x1, 0x118(%rsp)
je 0x10594
leaq 0xdd81(%rip), %rax      # 0x1e2d8
movl (%rax), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jg 0x1057d
leaq 0xdd7a(%rip), %rax      # 0x1e2e0
movq (%rax), %rcx
movl 0x118(%rsp), %edx
xorl %edi, %edi
leaq 0x8c78(%rip), %rsi      # 0x191f1
movb $0x0, %al
callq *%rcx
movl 0x118(%rsp), %edi
callq 0x2570
movl $0xffffffff, 0x118(%rsp) # imm = 0xFFFFFFFF
cmpq $0x0, 0xd8(%rsp)
je 0x105b8
movq 0xd8(%rsp), %rdi
callq 0xbe40
movq $0x0, 0xd8(%rsp)
cmpq $0x0, 0x130(%rsp)
je 0x105ef
movq 0x130(%rsp), %rax
movq %rax, 0x60(%rsp)
callq 0x110d0
movq %rax, %rcx
movq 0x60(%rsp), %rax
cmpq %rcx, %rax
jae 0x105ef
movl $0xfffffffe, 0x114(%rsp) # imm = 0xFFFFFFFE
jmp 0x10623
jmp 0x105f1
movb $0x1, %al
cmpq $0x0, 0x41f0(%rsp)
movb %al, 0x5f(%rsp)
je 0x10615
movq 0x41f0(%rsp), %rax
cmpl $0x2, 0x14(%rax)
sete %al
movb %al, 0x5f(%rsp)
movb 0x5f(%rsp), %al
testb $0x1, %al
jne 0x10247
jmp 0x10623
movq 0x148(%rsp), %rax
leaq 0x150(%rsp), %rcx
cmpq %rcx, %rax
je 0x10645
movq 0x148(%rsp), %rdi
callq 0x22e0
cmpl $-0x1, 0x118(%rsp)
je 0x10688
leaq 0xdc82(%rip), %rax      # 0x1e2d8
movl (%rax), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jg 0x1067c
leaq 0xdc7b(%rip), %rax      # 0x1e2e0
movq (%rax), %rcx
movl 0x118(%rsp), %edx
xorl %edi, %edi
leaq 0x8baa(%rip), %rsi      # 0x19222
movb $0x0, %al
callq *%rcx
movl 0x118(%rsp), %edi
callq 0x2570
movl 0x114(%rsp), %eax
movl %eax, 0x4184(%rsp)
jmp 0x10710
movq 0xd8(%rsp), %rcx
movq 0x4150(%rsp), %rax
movq %rcx, 0x18(%rax)
movl 0x118(%rsp), %ecx
movq 0x4150(%rsp), %rax
movl %ecx, 0x20(%rax)
leaq 0xfdcb(%rip), %rax      # 0x20490
movq (%rax), %rdi
leaq 0x4150(%rsp), %rsi
callq 0x14300
movq 0x148(%rsp), %rax
leaq 0x150(%rsp), %rcx
cmpq %rcx, %rax
je 0x106f7
movq 0x148(%rsp), %rdi
callq 0x22e0
movl $0x0, 0x114(%rsp)
movl 0x114(%rsp), %eax
movl %eax, 0x4184(%rsp)
movl 0x4184(%rsp), %eax
addq $0x4188, %rsp           # imm = 0x4188
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)