// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/src/cl_batch.c
// Function: do_batch_monte
static int
do_batch_monte(cl_cluster *asc, int info1, int info2, char *ns, cf_digest *digests, cl_cluster_node **nodes, 
	int n_digests, cl_bin *bins, cl_operator operator, cl_operation *operations, int n_ops,
	cl_cluster_node *node, int n_node_digests, citrusleaf_get_many_cb cb, void *udata)
{
	int rv = -1;

	uint8_t		rd_stack_buf[STACK_BUF_SZ];	
	uint8_t		*rd_buf = 0;
	size_t		rd_buf_sz = 0;
	uint8_t		wr_stack_buf[STACK_BUF_SZ];
	uint8_t		*wr_buf = wr_stack_buf;
	size_t		wr_buf_sz = sizeof(wr_stack_buf);

	// we have a list of many keys
//	if (0 == bins && CL_MSG_INFO1_READ == info1) info1 |= CL_MSG_INFO1_GET_ALL;
	rv = batch_compile(info1, info2, ns, digests, nodes, n_digests, node, n_node_digests, bins, operator, operations, n_ops, 
		&wr_buf, &wr_buf_sz, 0);
	if (rv != 0) {
		cf_error("do batch monte: batch compile failed: some kind of intermediate error");
		return (rv);
	}

	
#ifdef DEBUG_VERBOSE
	dump_buf("sending request to cluster:", wr_buf, wr_buf_sz);
#endif	

	int fd = cl_cluster_node_fd_get(node, false, asc->nbconnect);
	if (fd == -1) {
#ifdef DEBUG			
		cf_debug("warning: node %s has no file descriptors, retrying transaction", node->name);
#endif
		return(-1);
	}
	
	// send it to the cluster - non blocking socket, but we're blocking
	if (0 != cf_socket_write_forever(fd, wr_buf, wr_buf_sz)) {
#ifdef DEBUG			
		cf_debug("Citrusleaf: write timeout or error when writing header to server - %d fd %d errno %d", rv, fd, errno);
#endif
		return(-1);
	}

	cl_proto 		proto;
	bool done = false;
	
	do { // multiple CL proto per response
		
		// Now turn around and read a fine cl_pro - that's the first 8 bytes that has types and lenghts
		if ((rv = cf_socket_read_forever(fd, (uint8_t *) &proto, sizeof(cl_proto) ) ) ) {
			cf_error("network error: errno %d fd %d", rv, fd);
			return(-1);
		}
#ifdef DEBUG_VERBOSE
		dump_buf("read proto header from cluster", (uint8_t *) &proto, sizeof(cl_proto));
#endif	
		cl_proto_swap(&proto);

		if (proto.version != CL_PROTO_VERSION) {
			cf_error("network error: received protocol message of wrong version %d", proto.version);
			return(-1);
		}
		if ((proto.type != CL_PROTO_TYPE_CL_MSG) && (proto.type != CL_PROTO_TYPE_CL_MSG_COMPRESSED)) {
			cf_error("network error: received incorrect message version %d", proto.type);
			return(-1);
		}
		
		// second read for the remainder of the message - expect this to cover lots of data, many lines
		//
		// if there's no error
		rd_buf_sz =  proto.sz;
		if (rd_buf_sz > 0) {
                                                         
			if (rd_buf_sz > sizeof(rd_stack_buf))
				rd_buf = malloc(rd_buf_sz);
			else
				rd_buf = rd_stack_buf;
			if (rd_buf == NULL)		return (-1);

			if ((rv = cf_socket_read_forever(fd, rd_buf, rd_buf_sz))) {
				cf_error("network error: errno %d fd %d", rv, fd);
				if (rd_buf != rd_stack_buf)	{ free(rd_buf); }
				return(-1);
			}
// this one's a little much: printing the entire body before printing the other bits			
#ifdef DEBUG_VERBOSE
			dump_buf("read msg body header (multiple msgs)", rd_buf, rd_buf_sz);
#endif	
		}
		
		if (proto.type == CL_PROTO_TYPE_CL_MSG_COMPRESSED) {
			
			uint8_t *new_rd_buf   = NULL;
			size_t  new_rd_buf_sz = 0;
			
			rv = batch_decompress(rd_buf, rd_buf_sz, &new_rd_buf, &new_rd_buf_sz);
			if (rv != 0) {
				cf_error("could not decompress compressed message: error %d", rv);
				if (rd_buf != rd_stack_buf)	{ free(rd_buf); }
				return -1;
			}				
				
			if (rd_buf != rd_stack_buf)	{ free(rd_buf); }
			rd_buf = new_rd_buf;
			rd_buf_sz = new_rd_buf_sz;
			
			// also re-touch the proto - not certain if this matters
			proto.sz = rd_buf_sz;
			proto.type = CL_PROTO_TYPE_CL_MSG;

		}
		
		// process all the cl_msg in this proto
		uint8_t *buf = rd_buf;
		uint pos = 0;
		cl_bin stack_bins[STACK_BINS];
		cl_bin *bins_local;
		
		while (pos < rd_buf_sz) {

#ifdef DEBUG_VERBOSE
			dump_buf("individual message header", buf, sizeof(cl_msg));
#endif	
			
			uint8_t *buf_start = buf;
			cl_msg *msg = (cl_msg *) buf;
			cl_msg_swap_header(msg);
			buf += sizeof(cl_msg);
			
			if (msg->header_sz != sizeof(cl_msg)) {
				cf_error("received cl msg of unexpected size: expecting %zd found %d, internal error",
					sizeof(cl_msg),msg->header_sz);
				return(-1);
			}

			// parse through the fields
			cf_digest *keyd = 0;
			char ns_ret[33] = {0};
			char *set_ret = NULL;
			cl_msg_field *mf = (cl_msg_field *)buf;
			for (int i=0;i<msg->n_fields;i++) {
				cl_msg_swap_field(mf);
				if (mf->type == CL_MSG_FIELD_TYPE_KEY) {
					cf_error("read: found a key - unexpected");
				}
				else if (mf->type == CL_MSG_FIELD_TYPE_DIGEST_RIPE) {
					keyd = (cf_digest *) mf->data;
				}
				else if (mf->type == CL_MSG_FIELD_TYPE_NAMESPACE) {
					memcpy(ns_ret, mf->data, cl_msg_field_get_value_sz(mf));
					ns_ret[ cl_msg_field_get_value_sz(mf) ] = 0;
				}
				else if (mf->type == CL_MSG_FIELD_TYPE_SET) {
					uint32_t set_name_len = cl_msg_field_get_value_sz(mf);
					set_ret = (char *)malloc(set_name_len + 1);
					memcpy(set_ret, mf->data, set_name_len);
					set_ret[ set_name_len ] = '\0';
				}
				mf = cl_msg_field_get_next(mf);
			}
			buf = (uint8_t *) mf;

#ifdef DEBUG_VERBOSE
			cf_debug("message header fields: nfields %u nops %u",msg->n_fields,msg->n_ops);
#endif


			if (msg->n_ops > STACK_BINS) {
				bins_local = malloc(sizeof(cl_bin) * msg->n_ops);
			}
			else {
				bins_local = stack_bins;
			}
			if (bins_local == NULL) {
				if (set_ret) {
					free(set_ret);
				}
				return (-1);
			}

			// parse through the bins/ops
			cl_msg_op *op = (cl_msg_op *)buf;
			for (int i=0;i<msg->n_ops;i++) {

				cl_msg_swap_op(op);

#ifdef DEBUG_VERBOSE
				cf_debug("op receive: %p size %d op %d ptype %d pversion %d namesz %d",
					op,op->op_sz, op->op, op->particle_type, op->version, op->name_sz);
#endif			

#ifdef DEBUG_VERBOSE
				dump_buf("individual op (host order)", (uint8_t *) op, op->op_sz + sizeof(uint32_t));
#endif	

				cl_set_value_particular(op, &bins_local[i]);
				op = cl_msg_op_get_next(op);
			}
			buf = (uint8_t *) op;
			
			// Keep processing batch on OK and NOTFOUND return codes.
			// All other return codes indicate a error has occurred and the batch was aborted.
			if (msg->result_code != CL_RESULT_OK && msg->result_code != CL_RESULT_NOTFOUND) {
				rv = (int)msg->result_code;
				done = true;
			}

			if (msg->info3 & CL_MSG_INFO3_LAST)	{
#ifdef DEBUG				
				cf_debug("received final message");
#endif				
				done = true;
			}

			if (cb && (msg->n_ops || (msg->info1 & CL_MSG_INFO1_NOBINDATA))) {
				// (Note:  In the key exists case, there is no bin data.)
				(*cb) ( ns_ret, keyd, set_ret, msg->generation, msg->record_ttl, bins_local, msg->n_ops, false /*islast*/, udata);
				rv = 0;
			}

			if (bins_local != stack_bins) {
				free(bins_local);
				bins_local = 0;
			}

			if (set_ret) {
				free(set_ret);
				set_ret = NULL;
			}

			// don't have to free object internals. They point into the read buffer, where
			// a pointer is required
			pos += buf - buf_start;
			
		}
		
		if (rd_buf && (rd_buf != rd_stack_buf))	{
			free(rd_buf);
			rd_buf = 0;
		}

	} while ( done == false );

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

	// We should close the connection fd in case of error
	// to throw away any unread data on connection socket.
	// Instead if we put back fd into pull the subsequent
	// call will read stale data.

	if (rv == 0) {
		cl_cluster_node_fd_put(node, fd, false);
	} else {
		close(fd);
	}

#ifdef DEBUG_VERBOSE	
	cf_debug("exited loop: rv %d", rv );
#endif	
	
	return(rv);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x9a58, %rsp           # imm = 0x9A58
movq 0x9ad0(%rsp), %rax
movq 0x9ac8(%rsp), %rax
movl 0x9ac0(%rsp), %eax
movq 0x9ab8(%rsp), %rax
movl 0x9ab0(%rsp), %eax
movq 0x9aa8(%rsp), %rax
movl 0x9aa0(%rsp), %eax
movq 0x9a98(%rsp), %rax
movl 0x9a90(%rsp), %eax
movq %rdi, 0x9a48(%rsp)
movl %esi, 0x9a44(%rsp)
movl %edx, 0x9a40(%rsp)
movq %rcx, 0x9a38(%rsp)
movq %r8, 0x9a30(%rsp)
movq %r9, 0x9a28(%rsp)
movl $0xffffffff, 0x9a24(%rsp) # imm = 0xFFFFFFFF
movq $0x0, 0x5a18(%rsp)
movq $0x0, 0x5a10(%rsp)
leaq 0x1a10(%rsp), %rax
movq %rax, 0x1a08(%rsp)
movq $0x4000, 0x1a00(%rsp) # imm = 0x4000
movl 0x9a44(%rsp), %edi
movl 0x9a40(%rsp), %esi
movq 0x9a38(%rsp), %rdx
movq 0x9a30(%rsp), %rcx
movq 0x9a28(%rsp), %r8
movl 0x9a90(%rsp), %r9d
movq 0x9ab8(%rsp), %r12
movl 0x9ac0(%rsp), %r15d
movq 0x9a98(%rsp), %r14
movl 0x9aa0(%rsp), %ebp
movq 0x9aa8(%rsp), %rbx
movl 0x9ab0(%rsp), %r11d
leaq 0x1a08(%rsp), %r10
leaq 0x1a00(%rsp), %rax
xorl %r13d, %r13d
movq %r12, (%rsp)
movl %r15d, 0x8(%rsp)
movq %r14, 0x10(%rsp)
movl %ebp, 0x18(%rsp)
movq %rbx, 0x20(%rsp)
movl %r11d, 0x28(%rsp)
movq %r10, 0x30(%rsp)
movq %rax, 0x38(%rsp)
movq $0x0, 0x40(%rsp)
callq 0xf3c0
movl %eax, 0x9a24(%rsp)
cmpl $0x0, 0x9a24(%rsp)
je 0xea60
leaq 0xf8aa(%rip), %rax      # 0x1e2d8
movl (%rax), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jg 0xea4d
leaq 0xf8a3(%rip), %rax      # 0x1e2e0
movq (%rax), %rcx
xorl %edi, %edi
leaq 0xa4e7(%rip), %rsi      # 0x18f30
movb $0x0, %al
callq *%rcx
movl 0x9a24(%rsp), %eax
movl %eax, 0x9a54(%rsp)
jmp 0xf3a7
movq 0x9ab8(%rsp), %rdi
movq 0x9a48(%rsp), %rax
movb 0x15(%rax), %al
xorl %esi, %esi
andb $0x1, %al
movzbl %al, %edx
callq 0xc160
movl %eax, 0x19fc(%rsp)
cmpl $-0x1, 0x19fc(%rsp)
jne 0xeaa0
movl $0xffffffff, 0x9a54(%rsp) # imm = 0xFFFFFFFF
jmp 0xf3a7
movl 0x19fc(%rsp), %edi
movq 0x1a08(%rsp), %rsi
movq 0x1a00(%rsp), %rdx
callq 0x166a0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0xead4
movl $0xffffffff, 0x9a54(%rsp) # imm = 0xFFFFFFFF
jmp 0xf3a7
movb $0x0, 0x19f3(%rsp)
movl 0x19fc(%rsp), %edi
leaq 0x19f4(%rsp), %rsi
movl $0x8, %edx
callq 0x16590
movl %eax, 0x9a24(%rsp)
cmpl $0x0, %eax
je 0xeb46
leaq 0xf7d0(%rip), %rax      # 0x1e2d8
movl (%rax), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jg 0xeb36
leaq 0xf7c9(%rip), %rax      # 0x1e2e0
movq (%rax), %r8
movl 0x9a24(%rsp), %edx
movl 0x19fc(%rsp), %ecx
xorl %edi, %edi
leaq 0xa445(%rip), %rsi      # 0x18f76
movb $0x0, %al
callq *%r8
movl $0xffffffff, 0x9a54(%rsp) # imm = 0xFFFFFFFF
jmp 0xf3a7
leaq 0x19f4(%rsp), %rdi
callq 0x13a70
movzbl 0x19f4(%rsp), %eax
cmpl $0x2, %eax
je 0xeb9e
leaq 0xf771(%rip), %rax      # 0x1e2d8
movl (%rax), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jg 0xeb8e
leaq 0xf76a(%rip), %rax      # 0x1e2e0
movq (%rax), %rcx
movzbl 0x19f4(%rsp), %edx
xorl %edi, %edi
leaq 0xa40a(%rip), %rsi      # 0x18f94
movb $0x0, %al
callq *%rcx
movl $0xffffffff, 0x9a54(%rsp) # imm = 0xFFFFFFFF
jmp 0xf3a7
movzbl 0x19f5(%rsp), %eax
cmpl $0x3, %eax
je 0xebf6
movzbl 0x19f5(%rsp), %eax
cmpl $0x4, %eax
je 0xebf6
leaq 0xf719(%rip), %rax      # 0x1e2d8
movl (%rax), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jg 0xebe6
leaq 0xf712(%rip), %rax      # 0x1e2e0
movq (%rax), %rcx
movzbl 0x19f5(%rsp), %edx
xorl %edi, %edi
leaq 0xa3ef(%rip), %rsi      # 0x18fd1
movb $0x0, %al
callq *%rcx
movl $0xffffffff, 0x9a54(%rsp) # imm = 0xFFFFFFFF
jmp 0xf3a7
movl 0x19f6(%rsp), %eax
movzwl 0x19fa(%rsp), %ecx
shlq $0x20, %rcx
orq %rcx, %rax
movq %rax, 0x5a10(%rsp)
cmpq $0x0, 0x5a10(%rsp)
jbe 0xed04
cmpq $0x4000, 0x5a10(%rsp) # imm = 0x4000
jbe 0xec48
movq 0x5a10(%rsp), %rdi
callq 0x2310
movq %rax, 0x5a18(%rsp)
jmp 0xec58
leaq 0x5a20(%rsp), %rax
movq %rax, 0x5a18(%rsp)
cmpq $0x0, 0x5a18(%rsp)
jne 0xec73
movl $0xffffffff, 0x9a54(%rsp) # imm = 0xFFFFFFFF
jmp 0xf3a7
movl 0x19fc(%rsp), %edi
movq 0x5a18(%rsp), %rsi
movq 0x5a10(%rsp), %rdx
callq 0x16590
movl %eax, 0x9a24(%rsp)
cmpl $0x0, %eax
je 0xed02
leaq 0xf636(%rip), %rax      # 0x1e2d8
movl (%rax), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jg 0xecd0
leaq 0xf62f(%rip), %rax      # 0x1e2e0
movq (%rax), %r8
movl 0x9a24(%rsp), %edx
movl 0x19fc(%rsp), %ecx
xorl %edi, %edi
leaq 0xa2ab(%rip), %rsi      # 0x18f76
movb $0x0, %al
callq *%r8
movq 0x5a18(%rsp), %rax
leaq 0x5a20(%rsp), %rcx
cmpq %rcx, %rax
je 0xecf2
movq 0x5a18(%rsp), %rdi
callq 0x22e0
movl $0xffffffff, 0x9a54(%rsp) # imm = 0xFFFFFFFF
jmp 0xf3a7
jmp 0xed04
movzbl 0x19f5(%rsp), %eax
cmpl $0x4, %eax
jne 0xee29
movq $0x0, 0x19e8(%rsp)
movq $0x0, 0x19e0(%rsp)
movq 0x5a18(%rsp), %rdi
movq 0x5a10(%rsp), %rsi
leaq 0x19e8(%rsp), %rdx
leaq 0x19e0(%rsp), %rcx
callq 0xf8e0
movl %eax, 0x9a24(%rsp)
cmpl $0x0, 0x9a24(%rsp)
je 0xedc2
leaq 0xf56e(%rip), %rax      # 0x1e2d8
movl (%rax), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jg 0xed90
leaq 0xf567(%rip), %rax      # 0x1e2e0
movq (%rax), %rcx
movl 0x9a24(%rsp), %edx
xorl %edi, %edi
leaq 0xa27a(%rip), %rsi      # 0x19006
movb $0x0, %al
callq *%rcx
movq 0x5a18(%rsp), %rax
leaq 0x5a20(%rsp), %rcx
cmpq %rcx, %rax
je 0xedb2
movq 0x5a18(%rsp), %rdi
callq 0x22e0
movl $0xffffffff, 0x9a54(%rsp) # imm = 0xFFFFFFFF
jmp 0xf3a7
movq 0x5a18(%rsp), %rax
leaq 0x5a20(%rsp), %rcx
cmpq %rcx, %rax
je 0xede4
movq 0x5a18(%rsp), %rdi
callq 0x22e0
movq 0x19e8(%rsp), %rax
movq %rax, 0x5a18(%rsp)
movq 0x19e0(%rsp), %rax
movq %rax, 0x5a10(%rsp)
movq 0x5a10(%rsp), %rax
movl %eax, %ecx
movl %ecx, 0x19f6(%rsp)
shrq $0x20, %rax
movw %ax, 0x19fa(%rsp)
movb $0x3, 0x19f5(%rsp)
movq 0x5a18(%rsp), %rax
movq %rax, 0x19d8(%rsp)
movl $0x0, 0x19d4(%rsp)
movl 0x19d4(%rsp), %eax
cmpq 0x5a10(%rsp), %rax
jae 0xf2ed
movq 0x19d8(%rsp), %rax
movq %rax, 0xc0(%rsp)
movq 0x19d8(%rsp), %rax
movq %rax, 0xb8(%rsp)
movq 0xb8(%rsp), %rdi
callq 0x13af0
movq 0x19d8(%rsp), %rax
addq $0x16, %rax
movq %rax, 0x19d8(%rsp)
movq 0xb8(%rsp), %rax
movzbl (%rax), %eax
cmpq $0x16, %rax
je 0xeef2
leaq 0xf426(%rip), %rax      # 0x1e2d8
movl (%rax), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jg 0xeee2
leaq 0xf41f(%rip), %rax      # 0x1e2e0
movq (%rax), %r8
movq 0xb8(%rsp), %rax
movzbl (%rax), %ecx
xorl %edi, %edi
leaq 0xa160(%rip), %rsi      # 0x19038
movl $0x16, %edx
movb $0x0, %al
callq *%r8
movl $0xffffffff, 0x9a54(%rsp) # imm = 0xFFFFFFFF
jmp 0xf3a7
movq $0x0, 0xb0(%rsp)
leaq 0x80(%rsp), %rdi
xorl %esi, %esi
movl $0x21, %edx
callq 0x2170
movq $0x0, 0x78(%rsp)
movq 0x19d8(%rsp), %rax
movq %rax, 0x70(%rsp)
movl $0x0, 0x6c(%rsp)
movl 0x6c(%rsp), %eax
movq 0xb8(%rsp), %rcx
movzwl 0x12(%rcx), %ecx
cmpl %ecx, %eax
jge 0xf087
movq 0x70(%rsp), %rdi
callq 0x13cd0
movq 0x70(%rsp), %rax
movzbl 0x4(%rax), %eax
cmpl $0x2, %eax
jne 0xef8b
leaq 0xf371(%rip), %rax      # 0x1e2d8
movl (%rax), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jg 0xef86
leaq 0xf36a(%rip), %rax      # 0x1e2e0
movq (%rax), %rcx
xorl %edi, %edi
leaq 0xa101(%rip), %rsi      # 0x19083
movb $0x0, %al
callq *%rcx
jmp 0xf068
movq 0x70(%rsp), %rax
movzbl 0x4(%rax), %eax
cmpl $0x4, %eax
jne 0xefaf
movq 0x70(%rsp), %rax
addq $0x5, %rax
movq %rax, 0xb0(%rsp)
jmp 0xf066
movq 0x70(%rsp), %rax
movzbl 0x4(%rax), %eax
cmpl $0x0, %eax
jne 0xf00b
leaq 0x80(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x70(%rsp), %rax
addq $0x5, %rax
movq %rax, 0x50(%rsp)
movq 0x70(%rsp), %rdi
callq 0xfab0
movq 0x48(%rsp), %rdi
movq 0x50(%rsp), %rsi
movl %eax, %eax
movl %eax, %edx
callq 0x21e0
movq 0x70(%rsp), %rdi
callq 0xfab0
movl %eax, %eax
movb $0x0, 0x80(%rsp,%rax)
jmp 0xf064
movq 0x70(%rsp), %rax
movzbl 0x4(%rax), %eax
cmpl $0x1, %eax
jne 0xf062
movq 0x70(%rsp), %rdi
callq 0xfab0
movl %eax, 0x68(%rsp)
movl 0x68(%rsp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x2310
movq %rax, 0x78(%rsp)
movq 0x78(%rsp), %rdi
movq 0x70(%rsp), %rsi
addq $0x5, %rsi
movl 0x68(%rsp), %eax
movl %eax, %edx
callq 0x21e0
movq 0x78(%rsp), %rax
movl 0x68(%rsp), %ecx
movb $0x0, (%rax,%rcx)
jmp 0xf064
jmp 0xf066
jmp 0xf068
movq 0x70(%rsp), %rdi
callq 0xfac0
movq %rax, 0x70(%rsp)
movl 0x6c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x6c(%rsp)
jmp 0xef30
movq 0x70(%rsp), %rax
movq %rax, 0x19d8(%rsp)
movq 0xb8(%rsp), %rax
movzwl 0x14(%rax), %eax
cmpl $0x64, %eax
jle 0xf0c6
movq 0xb8(%rsp), %rax
movzwl 0x14(%rax), %eax
movl %eax, %edi
shlq $0x6, %rdi
callq 0x2310
movq %rax, 0xc8(%rsp)
jmp 0xf0d6
leaq 0xd0(%rsp), %rax
movq %rax, 0xc8(%rsp)
cmpq $0x0, 0xc8(%rsp)
jne 0xf103
cmpq $0x0, 0x78(%rsp)
je 0xf0f3
movq 0x78(%rsp), %rdi
callq 0x22e0
movl $0xffffffff, 0x9a54(%rsp) # imm = 0xFFFFFFFF
jmp 0xf3a7
movq 0x19d8(%rsp), %rax
movq %rax, 0x60(%rsp)
movl $0x0, 0x5c(%rsp)
movl 0x5c(%rsp), %eax
movq 0xb8(%rsp), %rcx
movzwl 0x14(%rcx), %ecx
cmpl %ecx, %eax
jge 0xf170
movq 0x60(%rsp), %rdi
callq 0x13b70
movq 0x60(%rsp), %rdi
movq 0xc8(%rsp), %rsi
movslq 0x5c(%rsp), %rax
shlq $0x6, %rax
addq %rax, %rsi
callq 0x6b20
movq 0x60(%rsp), %rdi
callq 0xfae0
movq %rax, 0x60(%rsp)
movl 0x5c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x5c(%rsp)
jmp 0xf118
movq 0x60(%rsp), %rax
movq %rax, 0x19d8(%rsp)
movq 0xb8(%rsp), %rax
movzbl 0x5(%rax), %eax
cmpl $0x0, %eax
je 0xf1ba
movq 0xb8(%rsp), %rax
movzbl 0x5(%rax), %eax
cmpl $0x2, %eax
je 0xf1ba
movq 0xb8(%rsp), %rax
movzbl 0x5(%rax), %eax
movl %eax, 0x9a24(%rsp)
movb $0x1, 0x19f3(%rsp)
movq 0xb8(%rsp), %rax
movzbl 0x3(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xf1d6
movb $0x1, 0x19f3(%rsp)
cmpq $0x0, 0x9ac8(%rsp)
je 0xf27b
movq 0xb8(%rsp), %rax
movzwl 0x14(%rax), %eax
cmpl $0x0, %eax
jne 0xf20a
movq 0xb8(%rsp), %rax
movzbl 0x1(%rax), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0xf27b
movq 0x9ac8(%rsp), %rax
leaq 0x80(%rsp), %rdi
movq 0xb0(%rsp), %rsi
movq 0x78(%rsp), %rdx
movq 0xb8(%rsp), %rcx
movl 0x6(%rcx), %ecx
movq 0xb8(%rsp), %r8
movl 0xa(%r8), %r8d
movq 0xc8(%rsp), %r9
movq 0xb8(%rsp), %r10
movzwl 0x14(%r10), %r11d
movq 0x9ad0(%rsp), %r10
xorl %ebx, %ebx
movl %r11d, (%rsp)
movl $0x0, 0x8(%rsp)
movq %r10, 0x10(%rsp)
callq *%rax
movl $0x0, 0x9a24(%rsp)
movq 0xc8(%rsp), %rax
leaq 0xd0(%rsp), %rcx
cmpq %rcx, %rax
je 0xf2a9
movq 0xc8(%rsp), %rdi
callq 0x22e0
movq $0x0, 0xc8(%rsp)
cmpq $0x0, 0x78(%rsp)
je 0xf2c4
movq 0x78(%rsp), %rdi
callq 0x22e0
movq $0x0, 0x78(%rsp)
movq 0x19d8(%rsp), %rcx
movq 0xc0(%rsp), %rax
subq %rax, %rcx
movl 0x19d4(%rsp), %eax
addq %rcx, %rax
movl %eax, 0x19d4(%rsp)
jmp 0xee44
cmpq $0x0, 0x5a18(%rsp)
je 0xf326
movq 0x5a18(%rsp), %rax
leaq 0x5a20(%rsp), %rcx
cmpq %rcx, %rax
je 0xf326
movq 0x5a18(%rsp), %rdi
callq 0x22e0
movq $0x0, 0x5a18(%rsp)
jmp 0xf328
movb 0x19f3(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0xeadc
movq 0x1a08(%rsp), %rax
leaq 0x1a10(%rsp), %rcx
cmpq %rcx, %rax
je 0xf36b
movq 0x1a08(%rsp), %rdi
callq 0x22e0
movq $0x0, 0x1a08(%rsp)
cmpl $0x0, 0x9a24(%rsp)
jne 0xf38d
movq 0x9ab8(%rsp), %rdi
movl 0x19fc(%rsp), %esi
xorl %edx, %edx
callq 0xc230
jmp 0xf399
movl 0x19fc(%rsp), %edi
callq 0x2570
movl 0x9a24(%rsp), %eax
movl %eax, 0x9a54(%rsp)
movl 0x9a54(%rsp), %eax
addq $0x9a58, %rsp           # imm = 0x9A58
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq