LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/xocoder[P]m_kcptun/vendor/kcp/ikcp.c
// Function: ikcp_create
ikcpcb* ikcp_create(IUINT32 conv, void *user)
{
	ikcpcb *kcp = (ikcpcb*)ikcp_malloc(sizeof(struct IKCPCB));
	if (kcp == NULL) return NULL;
	kcp->conv = conv;
	kcp->user = user;
	kcp->snd_una = 0;
	kcp->snd_nxt = 0;
	kcp->rcv_nxt = 0;
	kcp->ts_recent = 0;
	kcp->ts_lastack = 0;
	kcp->ts_probe = 0;
	kcp->probe_wait = 0;
	kcp->snd_wnd = IKCP_WND_SND;
	kcp->rcv_wnd = IKCP_WND_RCV;
	kcp->rmt_wnd = IKCP_WND_RCV;
	kcp->cwnd = 0;
	kcp->incr = 0;
	kcp->probe = 0;
	kcp->mtu = IKCP_MTU_DEF;
	kcp->mss = kcp->mtu - IKCP_OVERHEAD;
	kcp->stream = 0;

	kcp->buffer = (char*)ikcp_malloc((kcp->mtu + IKCP_OVERHEAD) * 3);
	if (kcp->buffer == NULL) {
		ikcp_free(kcp);
		return NULL;
	}

	iqueue_init(&kcp->snd_queue);
	iqueue_init(&kcp->rcv_queue);
	iqueue_init(&kcp->snd_buf);
	iqueue_init(&kcp->rcv_buf);
	kcp->nrcv_buf = 0;
	kcp->nsnd_buf = 0;
	kcp->nrcv_que = 0;
	kcp->nsnd_que = 0;
	kcp->state = 0;
	kcp->acklist = NULL;
	kcp->ackblock = 0;
	kcp->ackcount = 0;
	kcp->rx_srtt = 0;
	kcp->rx_rttval = 0;
	kcp->rx_rto = IKCP_RTO_DEF;
	kcp->rx_minrto = IKCP_RTO_MIN;
	kcp->current = 0;
	kcp->interval = IKCP_INTERVAL;
	kcp->ts_flush = IKCP_INTERVAL;
	kcp->nodelay = 0;
	kcp->updated = 0;
	kcp->logmask = 0;
	kcp->ssthresh = IKCP_THRESH_INIT;
	kcp->fastresend = 0;
	kcp->nocwnd = 0;
	kcp->xmit = 0;
	kcp->dead_link = IKCP_DEADLINK;
	kcp->output = NULL;
	kcp->writelog = NULL;

	return kcp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movl %edi, %r15d
movl $0x108, %edi            # imm = 0x108
callq 0x281f
testq %rax, %rax
je 0x280f
movq %rax, %rbx
movl %r15d, (%rax)
movq %r14, 0xd8(%rax)
andq $0x0, 0x74(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
andl $0x0, 0x20(%rax)
movaps 0x7906(%rip), %xmm0     # 0xa010
movups %xmm0, 0x38(%rax)
andl $0x0, 0x80(%rax)
andl $0x0, 0x48(%rax)
movabsq $0x56000000578, %rax    # imm = 0x56000000578
movq %rax, 0x4(%rbx)
andl $0x0, 0xf0(%rbx)
movl $0x10b0, %edi           # imm = 0x10B0
callq 0x281f
movq %rax, 0xe0(%rbx)
testq %rax, %rax
je 0x2807
leaq 0x88(%rbx), %rax
movq %rax, 0x88(%rbx)
movq %rax, 0x90(%rbx)
leaq 0x98(%rbx), %rax
movq %rax, 0x98(%rbx)
movq %rax, 0xa0(%rbx)
leaq 0xa8(%rbx), %rax
movq %rax, 0xa8(%rbx)
movq %rax, 0xb0(%rbx)
movq %rbx, %rax
addq $0xb8, %rax
movq %rax, 0xb8(%rbx)
movq %rax, 0xc0(%rbx)
andl $0x0, 0xc(%rbx)
andq $0x0, 0x28(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x5c(%rbx)
movups %xmm0, 0xc8(%rbx)
movabsq $0x64000000c8, %rax     # imm = 0x64000000C8
movq %rax, 0x30(%rbx)
movabsq $0x6400000000, %rax     # imm = 0x6400000000
movq %rax, 0x4c(%rbx)
movl $0x64, 0x54(%rbx)
andq $0x0, 0x6c(%rbx)
andl $0x0, 0xf4(%rbx)
movl $0x2, 0x24(%rbx)
andq $0x0, 0xe8(%rbx)
andl $0x0, 0x58(%rbx)
movl $0x14, 0x7c(%rbx)
movups %xmm0, 0xf8(%rbx)
jmp 0x2811
movq %rbx, %rdi
callq 0x2838
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/xocoder[P]m_kcptun/vendor/kcp/ikcp.c
// Function: ikcp_free(void*)
static void ikcp_free(void *ptr) {
	if (ikcp_free_hook) {
		ikcp_free_hook(ptr);
	}	else {
		free(ptr);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xca3d(%rip), %rax      # 0xf280
testq %rax, %rax
je 0x284b
popq %rbp
jmpq *%rax
popq %rbp
jmp 0x2300
// File: /workspace/github_cpp_makefile_star2_O2/xocoder[P]m_kcptun/vendor/kcp/ikcp.c
// Function: ikcp_release
void ikcp_release(ikcpcb *kcp)
{
	assert(kcp);
	if (kcp) {
		IKCPSEG *seg;
		while (!iqueue_is_empty(&kcp->snd_buf)) {
			seg = iqueue_entry(kcp->snd_buf.next, IKCPSEG, node);
			iqueue_del(&seg->node);
			ikcp_segment_delete(kcp, seg);
		}
		while (!iqueue_is_empty(&kcp->rcv_buf)) {
			seg = iqueue_entry(kcp->rcv_buf.next, IKCPSEG, node);
			iqueue_del(&seg->node);
			ikcp_segment_delete(kcp, seg);
		}
		while (!iqueue_is_empty(&kcp->snd_queue)) {
			seg = iqueue_entry(kcp->snd_queue.next, IKCPSEG, node);
			iqueue_del(&seg->node);
			ikcp_segment_delete(kcp, seg);
		}
		while (!iqueue_is_empty(&kcp->rcv_queue)) {
			seg = iqueue_entry(kcp->rcv_queue.next, IKCPSEG, node);
			iqueue_del(&seg->node);
			ikcp_segment_delete(kcp, seg);
		}
		if (kcp->buffer) {
			ikcp_free(kcp->buffer);
		}
		if (kcp->acklist) {
			ikcp_free(kcp->acklist);
		}

		kcp->nrcv_buf = 0;
		kcp->nsnd_buf = 0;
		kcp->nrcv_que = 0;
		kcp->nsnd_que = 0;
		kcp->ackcount = 0;
		kcp->buffer = NULL;
		kcp->acklist = NULL;
		ikcp_free(kcp);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x2958
movq %rdi, %rbx
leaq 0xa8(%rdi), %r14
movq (%r14), %rdi
cmpq %rdi, %r14
je 0x288e
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%rcx)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
callq 0x2838
jmp 0x286b
leaq 0xb8(%rbx), %r14
movq (%r14), %rdi
cmpq %rdi, %r14
je 0x28b8
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%rcx)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
callq 0x2838
jmp 0x2895
leaq 0x88(%rbx), %r14
movq (%r14), %rdi
cmpq %rdi, %r14
je 0x28e2
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%rcx)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
callq 0x2838
jmp 0x28bf
leaq 0x98(%rbx), %r14
movq (%r14), %rdi
cmpq %rdi, %r14
je 0x290c
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%rcx)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
callq 0x2838
jmp 0x28e9
movq 0xe0(%rbx), %rdi
testq %rdi, %rdi
je 0x291d
callq 0x2838
movq 0xc8(%rbx), %rdi
testq %rdi, %rdi
je 0x292e
callq 0x2838
andl $0x0, 0xd0(%rbx)
andq $0x0, 0xe0(%rbx)
andq $0x0, 0xc8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x5c(%rbx)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2838
leaq 0x76e1(%rip), %rdi      # 0xa040
leaq 0x76de(%rip), %rsi      # 0xa044
leaq 0x76e9(%rip), %rcx      # 0xa056
movl $0x12d, %edx            # imm = 0x12D
callq 0x21b0
// File: /workspace/github_cpp_makefile_star2_O2/xocoder[P]m_kcptun/vendor/kcp/ikcp.c
// Function: ikcp_peeksize
int ikcp_peeksize(const ikcpcb *kcp)
{
	struct IQUEUEHEAD *p;
	IKCPSEG *seg;
	int length = 0;

	assert(kcp);

	if (iqueue_is_empty(&kcp->rcv_queue)) return -1;

	seg = iqueue_entry(kcp->rcv_queue.next, IKCPSEG, node);
	if (seg->frg == 0) return seg->len;

	if (kcp->nrcv_que < seg->frg + 1) return -1;

	for (p = kcp->rcv_queue.next; p != &kcp->rcv_queue; p = p->next) {
		seg = iqueue_entry(p, IKCPSEG, node);
		length += seg->len;
		if (seg->frg == 0) break;
	}

	return length;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x2bd0
leaq 0x98(%rdi), %rdx
movq 0x98(%rdi), %rcx
pushq $-0x1
popq %rax
cmpq %rcx, %rdx
je 0x2bce
movl 0x18(%rcx), %esi
testl %esi, %esi
je 0x2bcb
incl %esi
cmpl %esi, 0x64(%rdi)
jb 0x2bce
xorl %eax, %eax
cmpq %rdx, %rcx
je 0x2bce
addl 0x2c(%rcx), %eax
cmpl $0x0, 0x18(%rcx)
je 0x2bce
movq (%rcx), %rcx
jmp 0x2bb8
movl 0x2c(%rcx), %eax
popq %rbp
retq
leaq 0x7469(%rip), %rdi      # 0xa040
leaq 0x7466(%rip), %rsi      # 0xa044
leaq 0x74ce(%rip), %rcx      # 0xa0b3
movl $0x1bd, %edx            # imm = 0x1BD
callq 0x21b0
// File: /workspace/github_cpp_makefile_star2_O2/xocoder[P]m_kcptun/vendor/kcp/ikcp.c
// Function: ikcp_parse_data(IKCPCB*, IKCPSEG*)
void ikcp_parse_data(ikcpcb *kcp, IKCPSEG *newseg)
{
	struct IQUEUEHEAD *p, *prev;
	IUINT32 sn = newseg->sn;
	int repeat = 0;
	
	if (_itimediff(sn, kcp->rcv_nxt + kcp->rcv_wnd) >= 0 ||
		_itimediff(sn, kcp->rcv_nxt) < 0) {
		ikcp_segment_delete(kcp, newseg);
		return;
	}

	for (p = kcp->rcv_buf.prev; p != &kcp->rcv_buf; p = prev) {
		IKCPSEG *seg = iqueue_entry(p, IKCPSEG, node);
		prev = p->prev;
		if (seg->sn == sn) {
			repeat = 1;
			break;
		}
		if (_itimediff(sn, seg->sn) > 0) {
			break;
		}
	}

	if (repeat == 0) {
		iqueue_init(&newseg->node);
		iqueue_add(&newseg->node, p);
		kcp->nrcv_buf++;
	}	else {
		ikcp_segment_delete(kcp, newseg);
	}

#if 0
	ikcp_qprint("rcvbuf", &kcp->rcv_buf);
	printf("rcv_nxt=%lu\n", kcp->rcv_nxt);
#endif

	// move available data from rcv_buf -> rcv_queue
	while (! iqueue_is_empty(&kcp->rcv_buf)) {
		IKCPSEG *seg = iqueue_entry(kcp->rcv_buf.next, IKCPSEG, node);
		if (seg->sn == kcp->rcv_nxt && kcp->nrcv_que < kcp->rcv_wnd) {
			iqueue_del(&seg->node);
			kcp->nrcv_buf--;
			iqueue_add_tail(&seg->node, &kcp->rcv_queue);
			kcp->nrcv_que++;
			kcp->rcv_nxt++;
		}	else {
			break;
		}
	}

#if 0
	ikcp_qprint("queue", &kcp->rcv_queue);
	printf("rcv_nxt=%lu\n", kcp->rcv_nxt);
#endif

#if 1
//	printf("snd(buf=%d, queue=%d)\n", kcp->nsnd_buf, kcp->nsnd_que);
//	printf("rcv(buf=%d, queue=%d)\n", kcp->nrcv_buf, kcp->nrcv_que);
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl 0x24(%rsi), %eax
movl 0x18(%rdi), %ecx
cmpl %ecx, %eax
js 0x2ee6
movq %rdi, %rbx
addl 0x3c(%rdi), %ecx
movl %eax, %edx
subl %ecx, %edx
jns 0x2ee6
leaq 0xb8(%rbx), %r14
leaq 0xc0(%rbx), %rdx
movq (%rdx), %rcx
cmpq %r14, %rcx
je 0x2ecd
movl %eax, %edi
subl 0x24(%rcx), %edi
je 0x2ef2
leaq 0x8(%rcx), %rdx
testl %edi, %edi
jle 0x2eb6
movq %rsi, (%rsi)
movq %rcx, 0x8(%rsi)
movq (%rcx), %rax
movq %rax, (%rsi)
movq %rsi, 0x8(%rax)
movq %rsi, (%rcx)
incl 0x5c(%rbx)
jmp 0x2efa
movq %rsi, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2838
movq %rsi, %rdi
callq 0x2838
leaq 0x98(%rbx), %rax
xorps %xmm0, %xmm0
movq (%r14), %rdx
cmpq %rdx, %r14
je 0x2f54
movl 0x24(%rdx), %ecx
cmpl 0x18(%rbx), %ecx
jne 0x2f54
movl 0x64(%rbx), %esi
cmpl 0x3c(%rbx), %esi
jae 0x2f54
movq (%rdx), %rdi
movq 0x8(%rdx), %r8
movq %r8, 0x8(%rdi)
movq %rdi, (%r8)
movups %xmm0, (%rdx)
decl 0x5c(%rbx)
movq 0xa0(%rbx), %rdi
movq %rdi, 0x8(%rdx)
movq %rax, (%rdx)
movq %rdx, (%rdi)
movq %rdx, 0xa0(%rbx)
incl %esi
movl %esi, 0x64(%rbx)
incl %ecx
movl %ecx, 0x18(%rbx)
jmp 0x2f04
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/xocoder[P]m_kcptun/vendor/kcp/ikcp.c
// Function: ikcp_output(IKCPCB*, void const*, int)
static int ikcp_output(ikcpcb *kcp, const void *data, int size)
{
	assert(kcp);
	assert(kcp->output);
	if (ikcp_canlog(kcp, IKCP_LOG_OUTPUT)) {
		ikcp_log(kcp, IKCP_LOG_OUTPUT, "[RO] %ld bytes", (long)size);
	}
	if (size == 0) return 0;
	return kcp->output((const char*)data, size, kcp, kcp->user);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3a24
movq %rdi, %r14
cmpq $0x0, 0xf8(%rdi)
je 0x3a43
movl %edx, %ebx
movq %rsi, %r15
testb $0x1, 0xf4(%r14)
je 0x39f3
cmpq $0x0, 0x100(%r14)
je 0x39f3
movslq %ebx, %rcx
leaq 0x6808(%rip), %rdx      # 0xa1ee
pushq $0x1
popq %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x2600
testl %ebx, %ebx
je 0x3a19
movq 0xd8(%r14), %rcx
movq 0xf8(%r14), %rax
movq %r15, %rdi
movl %ebx, %esi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmpq *%rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6615(%rip), %rdi      # 0xa040
leaq 0x6612(%rip), %rsi      # 0xa044
leaq 0x677c(%rip), %rcx      # 0xa1b5
movl $0xcd, %edx
callq 0x21b0
leaq 0x6798(%rip), %rdi      # 0xa1e2
leaq 0x65f3(%rip), %rsi      # 0xa044
leaq 0x675d(%rip), %rcx      # 0xa1b5
movl $0xce, %edx
callq 0x21b0
// File: /workspace/github_cpp_makefile_star2_O2/xocoder[P]m_kcptun/vendor/kcp/ikcp.c
// Function: ikcp_update
void ikcp_update(ikcpcb *kcp, IUINT32 current)
{
	IINT32 slap;

	kcp->current = current;

	if (kcp->updated == 0) {
		kcp->updated = 1;
		kcp->ts_flush = kcp->current;
	}

	slap = _itimediff(kcp->current, kcp->ts_flush);

	if (slap >= 10000 || slap < -10000) {
		kcp->ts_flush = kcp->current;
		slap = 0;
	}

	if (slap >= 0) {
		kcp->ts_flush += kcp->interval;
		if (_itimediff(kcp->current, kcp->ts_flush) >= 0) {
			kcp->ts_flush = kcp->current + kcp->interval;
		}
		ikcp_flush(kcp);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %esi, 0x4c(%rdi)
cmpl $0x0, 0x70(%rdi)
je 0x3a74
movl 0x54(%rdi), %eax
jmp 0x3a80
movl $0x1, 0x70(%rdi)
movl %esi, 0x54(%rdi)
movl %esi, %eax
movl %esi, %edx
subl %eax, %edx
movslq %edx, %r8
addq $-0x2710, %r8           # imm = 0xD8F0
movl %esi, %ecx
cmpq $-0x4e20, %r8           # imm = 0xB1E0
jb 0x3a9f
movl %eax, %ecx
testl %edx, %edx
js 0x3ab4
movl 0x50(%rdi), %eax
addl %eax, %ecx
addl %esi, %eax
cmpl %ecx, %esi
cmovsl %ecx, %eax
movl %eax, 0x54(%rdi)
popq %rbp
jmp 0x34ea
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/xocoder[P]m_kcptun/vendor/kcp/ikcp.c
// Function: ikcp_check
IUINT32 ikcp_check(const ikcpcb *kcp, IUINT32 current)
{
	IUINT32 ts_flush = kcp->ts_flush;
	IINT32 tm_flush = 0x7fffffff;
	IINT32 tm_packet = 0x7fffffff;
	IUINT32 minimal = 0;
	struct IQUEUEHEAD *p;

	if (kcp->updated == 0) {
		return current;
	}

	if (_itimediff(current, ts_flush) >= 10000 ||
		_itimediff(current, ts_flush) < -10000) {
		ts_flush = current;
	}

	if (_itimediff(current, ts_flush) >= 0) {
		return current;
	}

	tm_flush = _itimediff(ts_flush, current);

	for (p = kcp->snd_buf.next; p != &kcp->snd_buf; p = p->next) {
		const IKCPSEG *seg = iqueue_entry(p, const IKCPSEG, node);
		IINT32 diff = _itimediff(seg->resendts, current);
		if (diff <= 0) {
			return current;
		}
		if (diff < tm_packet) tm_packet = diff;
	}

	minimal = (IUINT32)(tm_packet < tm_flush ? tm_packet : tm_flush);
	if (minimal >= kcp->interval) minimal = kcp->interval;

	return current + minimal;
}

// Assembly:
movl %esi, %eax
cmpl $0x0, 0x70(%rdi)
je 0x3ad8
movl 0x54(%rdi), %ecx
movl %eax, %edx
subl %ecx, %edx
addl $0xffffd8f0, %edx       # imm = 0xFFFFD8F0
cmpl $0xffffb1e0, %edx       # imm = 0xFFFFB1E0
cmovbl %eax, %ecx
cmpl %ecx, %eax
js 0x3ad9
retq
pushq %rbp
movq %rsp, %rbp
subl %eax, %ecx
leaq 0xa8(%rdi), %rsi
movl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
movq %rsi, %r8
movq (%r8), %r8
cmpq %rsi, %r8
je 0x3b0b
movl 0x30(%r8), %r9d
subl %eax, %r9d
cmpl %r9d, %edx
cmovgel %r9d, %edx
testl %r9d, %r9d
jg 0x3aee
jmp 0x3b1a
cmpl %ecx, %edx
cmovll %edx, %ecx
movl 0x50(%rdi), %edx
cmpl %edx, %ecx
cmovael %edx, %ecx
addl %ecx, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/xocoder[P]m_kcptun/vendor/kcp/ikcp.c
// Function: ikcp_setmtu
int ikcp_setmtu(ikcpcb *kcp, int mtu)
{
	char *buffer;
	if (mtu < 50 || mtu < (int)IKCP_OVERHEAD) 
		return -1;
	buffer = (char*)ikcp_malloc((mtu + IKCP_OVERHEAD) * 3);
	if (buffer == NULL) 
		return -2;
	kcp->mtu = mtu;
	kcp->mss = kcp->mtu - IKCP_OVERHEAD;
	ikcp_free(kcp->buffer);
	kcp->buffer = buffer;
	return 0;
}

// Assembly:
cmpl $0x32, %esi
jge 0x3b25
pushq $-0x1
popq %rax
retq
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
leal (%r14,%r14,2), %edi
addl $0x48, %edi
callq 0x281f
testq %rax, %rax
je 0x3b6c
movq %rax, %r15
movl %r14d, 0x4(%rbx)
addl $-0x18, %r14d
movl %r14d, 0x8(%rbx)
movq 0xe0(%rbx), %rdi
callq 0x2838
movq %r15, 0xe0(%rbx)
xorl %eax, %eax
jmp 0x3b6f
pushq $-0x2
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/xocoder[P]m_kcptun/vendor/kcp/ikcp.c
// Function: ikcp_nodelay
int ikcp_nodelay(ikcpcb *kcp, int nodelay, int interval, int resend, int nc)
{
	if (nodelay >= 0) {
		kcp->nodelay = nodelay;
		if (nodelay) {
			kcp->rx_minrto = IKCP_RTO_NDL;	
		}	
		else {
			kcp->rx_minrto = IKCP_RTO_MIN;
		}
	}
	if (interval >= 0) {
		if (interval > 5000) interval = 5000;
		else if (interval < 10) interval = 10;
		kcp->interval = interval;
	}
	if (resend >= 0) {
		kcp->fastresend = resend;
	}
	if (nc >= 0) {
		kcp->nocwnd = nc;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testl %esi, %esi
js 0x3bb5
movl %esi, 0x6c(%rdi)
movl $0x64, %eax
movl $0x1e, %esi
cmovel %eax, %esi
movl %esi, 0x34(%rdi)
testl %edx, %edx
js 0x3bd1
cmpl $0xb, %edx
movl $0xa, %eax
cmovael %edx, %eax
movl $0x1388, %edx           # imm = 0x1388
cmpl %edx, %eax
cmovael %edx, %eax
movl %eax, 0x50(%rdi)
testl %ecx, %ecx
js 0x3bdb
movl %ecx, 0xe8(%rdi)
testl %r8d, %r8d
js 0x3be7
movl %r8d, 0xec(%rdi)
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/xocoder[P]m_kcptun/vendor/kcp/ikcp.c
// Function: ikcp_wndsize
int ikcp_wndsize(ikcpcb *kcp, int sndwnd, int rcvwnd)
{
	if (kcp) {
		if (sndwnd > 0) {
			kcp->snd_wnd = sndwnd;
		}
		if (rcvwnd > 0) {   // must >= max fragment size
			kcp->rcv_wnd = _imax_(rcvwnd, IKCP_WND_RCV);
		}
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
je 0x3c10
testl %esi, %esi
jle 0x3bfb
movl %esi, 0x38(%rdi)
testl %edx, %edx
jle 0x3c10
cmpl $0x81, %edx
movl $0x80, %eax
cmovael %edx, %eax
movl %eax, 0x3c(%rdi)
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/xocoder[P]m_kcptun/vendor/m_net/src/mnet_core.c
// Function: mnet_init
int
mnet_init() {
   mnet_t *ss = _gmnet();
   if ( !ss->init ) {
#if MNET_OS_WIN
      WSADATA wdata;
      if (WSAStartup(MAKEWORD(2,2), &wdata) != 0) {
         mm_log(NULL, MNET_LOG_ERR, "fail to init !\n");
         return 0;
      }
      mm_log(NULL, MNET_LOG_VERBOSE, "init with select\n");
#else
      signal(SIGPIPE, SIG_IGN);
      _evt_init();
#endif
      ss->init = 1;
      return 1;
   }
   return 0;
}

// Assembly:
xorl %eax, %eax
cmpl $0x0, 0xb657(%rip)      # 0xf288
je 0x3c34
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
pushq $0xd
popq %rdi
pushq $0x1
popq %rsi
callq 0x22f0
cmpl $0x0, 0xb64c(%rip)      # 0xf298
jg 0x3cc9
movl $0x100, %edi            # imm = 0x100
callq 0x2420
movl %eax, 0xb63a(%rip)      # 0xf298
leaq 0x672b(%rip), %rdx      # 0xa390
pushq $0x3
popq %rsi
xorl %edi, %edi
movl %eax, %ecx
xorl %eax, %eax
callq 0x3eb5
movl $0x4, 0xb623(%rip)      # 0xf2a0
pushq $0x30
popq %rdi
callq *0xb5b2(%rip)           # 0xf238
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movq %rax, 0xb60d(%rip)      # 0xf2a8
movl $0x100, 0xb60b(%rip)    # imm = 0x100
movl $0xc00, %edi            # imm = 0xC00
callq *0xb588(%rip)           # 0xf238
movq %rax, %rbx
movl $0xc00, %edx            # imm = 0xC00
movq %rax, %rdi
xorl %esi, %esi
callq 0x2180
movq %rbx, 0xb5ef(%rip)      # 0xf2b8
movl $0x1, 0xb5b5(%rip)      # 0xf288
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/xocoder[P]m_kcptun/vendor/m_net/src/mnet_core.c
// Function: mnet_fini
void
mnet_fini() {
   mnet_t *ss = _gmnet();
   if ( ss->init ) {
      chann_t *n = ss->channs;
      while ( n ) {
         chann_t *next = n->next;
         _chann_disconnect_socket(ss, n);
         _chann_close_socket(ss, n);
         _chann_destroy(ss, n);
         n = next;
      }
#if MNET_OS_WIN
      WSACleanup();
#else
      _kev_get_flags(NULL); // for compile warning
      _kev_get_events(NULL);
      _evt_fini();
#endif
      ss->init = 0;
      memset(ss, 0, sizeof(*ss));
      mm_log(NULL, MNET_LOG_VERBOSE, "fini\n");
   }
}

// Assembly:
cmpl $0x0, 0xb5a4(%rip)      # 0xf288
je 0x3da7
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0xb598(%rip), %rbx      # 0xf290
testq %rbx, %rbx
je 0x3d1e
movq 0x58(%rbx), %r14
movq %rbx, %rdi
callq 0x3da8
movq %rbx, %rdi
callq 0x3df0
movq %rbx, %rdi
callq 0x3e3b
movq %r14, %rbx
jmp 0x3cf8
movl 0xb574(%rip), %edi      # 0xf298
testl %edi, %edi
je 0x3d71
callq 0x2440
movq 0xb574(%rip), %rdi      # 0xf2a8
callq *0xb50e(%rip)           # 0xf248
movq 0xb577(%rip), %rdi      # 0xf2b8
callq *0xb501(%rip)           # 0xf248
xorps %xmm0, %xmm0
movups %xmm0, 0xb55f(%rip)     # 0xf2b0
movups %xmm0, 0xb548(%rip)     # 0xf2a0
movl 0xb53a(%rip), %ecx      # 0xf298
leaq 0x6687(%rip), %rdx      # 0xa3ec
pushq $0x3
popq %rsi
xorl %edi, %edi
xorl %eax, %eax
callq 0x3eb5
xorps %xmm0, %xmm0
movups %xmm0, 0xb53d(%rip)     # 0xf2b8
movups %xmm0, 0xb526(%rip)     # 0xf2a8
movups %xmm0, 0xb50f(%rip)     # 0xf298
movups %xmm0, 0xb4f8(%rip)     # 0xf288
leaq 0x6466(%rip), %rdx      # 0xa1fd
pushq $0x3
popq %rsi
xorl %edi, %edi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x3eb5
retq
// File: /workspace/github_cpp_makefile_star2_O2/xocoder[P]m_kcptun/vendor/m_net/src/mnet_core.c
// Function: chann_disconnect_socket(s_mnet*, s_mchann*)
static int
_chann_disconnect_socket(mnet_t *ss, chann_t *n) {
   if (n->fd > 0) {
      mm_log(n, MNET_LOG_VERBOSE, "chann disconnect fd:%d\n", n->fd);
      close(n->fd);
      _rwb_destroy(&n->rwb_send);
      n->fd = -1;
      n->state = CHANN_STATE_DISCONNECT;
#if (MNET_OS_MACOX || MNET_OS_LINUX || MNET_OS_FreeBSD)
      n->epoll_events = 0;
#endif
      return 1;
   }
   return 0;
}

// Assembly:
movl (%rdi), %ecx
testl %ecx, %ecx
jle 0x3def
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x65ea(%rip), %rdx      # 0xa3a8
pushq $0x3
popq %rsi
xorl %eax, %eax
callq 0x3eb5
movl (%rbx), %edi
callq 0x2440
leaq 0x38(%rbx), %rdi
callq 0x517b
orl $-0x1, (%rbx)
movl $0x1, 0x10(%rbx)
andl $0x0, 0x88(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/xocoder[P]m_kcptun/vendor/m_net/src/mnet_core.c
// Function: chann_close_socket(s_mnet*, s_mchann*)
static void
_chann_close_socket(mnet_t *ss, chann_t *n) {
   if (n->state > CHANN_STATE_CLOSED) {
#if (MNET_OS_MACOX || MNET_OS_LINUX || MNET_OS_FreeBSD)
      n->del_next = ss->del_channs;
      if (ss->del_channs) {
         ss->del_channs->del_prev = n;
      }
      ss->del_channs = n;
#endif
      n->state = CHANN_STATE_CLOSED;
      n->cb = NULL;
      n->opaque = NULL;
      mm_log(n, MNET_LOG_VERBOSE, "chann close fd:%d\n", n->fd);
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x0, 0x10(%rdi)
jle 0x3e39
movq 0xb4bf(%rip), %rax      # 0xf2c0
movq %rax, 0x80(%rdi)
testq %rax, %rax
je 0x3e11
movq %rdi, 0x78(%rax)
movq %rdi, 0xb4a8(%rip)      # 0xf2c0
andl $0x0, 0x10(%rdi)
andq $0x0, 0x18(%rdi)
andq $0x0, 0x8(%rdi)
movl (%rdi), %ecx
leaq 0x6591(%rip), %rdx      # 0xa3c0
movl $0x3, %esi
xorl %eax, %eax
popq %rbp
jmp 0x3eb5
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/xocoder[P]m_kcptun/vendor/m_net/src/mnet_core.c
// Function: chann_destroy(s_mnet*, s_mchann*)
static void
_chann_destroy(mnet_t *ss, chann_t *n) {
   if (n->state >= CHANN_STATE_CLOSED) {
      if (n->next) { n->next->prev = n->prev; }
      if (n->prev) { n->prev->next = n->next; }
      else { ss->channs = n->next; }
      _rwb_destroy(&n->rwb_send);
      ss->chann_count--;
      mm_log(n, MNET_LOG_VERBOSE, "chann destroy, count %d\n", ss->chann_count);
      n->state = (chann_state_t)-1;
      mm_free(n);
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
cmpl $0x0, 0x10(%rdi)
js 0x3eae
movq %rdi, %rbx
movq 0x50(%rdi), %rcx
movq 0x58(%rdi), %rax
testq %rax, %rax
je 0x3e5b
movq %rcx, 0x50(%rax)
leaq 0x58(%rcx), %rdx
testq %rcx, %rcx
leaq 0xb427(%rip), %rcx      # 0xf290
cmovneq %rdx, %rcx
movq %rax, (%rcx)
leaq 0x38(%rbx), %rdi
callq 0x517b
movl 0xb40d(%rip), %ecx      # 0xf28c
decl %ecx
movl %ecx, 0xb405(%rip)      # 0xf28c
leaq 0x6545(%rip), %rdx      # 0xa3d3
pushq $0x3
popq %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x3eb5
orl $-0x1, 0x10(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmpq *0xb39a(%rip)           # 0xf248
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/xocoder[P]m_kcptun/vendor/m_net/src/mnet_core.c
// Function: mm_log(s_mchann*, int, char const*, ...)
static inline void mm_log(chann_t *n, int level, const char *fmt, ...) {
   if (level <= _log_level) {
      char buf[192];
      va_list argptr;
      va_start(argptr, fmt);
      vsprintf(buf, fmt, argptr);
      va_end(argptr);
      mnet_log(n, level, buf);
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
testb %al, %al
je 0x3ef2
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %rcx, -0xc8(%rbp)
movq %r8, -0xc0(%rbp)
movq %r9, -0xb8(%rbp)
cmpl %esi, 0xb343(%rip)      # 0xf250
jl 0x3f5b
movl %esi, %ebx
movq %rdi, %r14
leaq -0xe0(%rbp), %rcx
leaq -0x30(%rbp), %rax
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movabsq $0x3000000018, %rcx     # imm = 0x3000000018
movq %rcx, (%rax)
leaq -0x1a0(%rbp), %r15
movq %r15, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x2130
movq %r14, %rdi
movl %ebx, %esi
movq %r15, %rdx
callq *0xb2fd(%rip)           # 0xf258
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/xocoder[P]m_kcptun/vendor/m_net/src/mnet_core.c
// Function: mnet_setlog
void
mnet_setlog(int level, mnet_log_cb cb) {
   if (level >= 0) {
      _log_level = level;
   }
   if (cb) {
      mnet_log = cb;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testl %edi, %edi
js 0x3fa1
movl %edi, 0xb2af(%rip)      # 0xf250
testq %rsi, %rsi
je 0x3fad
movq %rsi, 0xb2ab(%rip)      # 0xf258
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/xocoder[P]m_kcptun/vendor/m_net/src/mnet_core.c
// Function: mnet_report
int
mnet_report(int level) {
   mnet_t *ss = _gmnet();
   if (ss->init) {
      if (level > 0) {
         mm_log(NULL, 0, "-------- channs(%d) --------\n", ss->chann_count);
         chann_t *n = ss->channs;
         while (n) {
            mm_log(NULL, 0, "chann:%p fd:%d state:%d %s:%d\n", n, n->fd, n->state, _chann_addr(n), _chann_port(n));
            n = n->next;
         }
         mm_log(NULL, 0, "------------------------\n");
      }
      return ss->chann_count;
   }
   return -1;
}

// Assembly:
cmpl $0x0, 0xb2d2(%rip)      # 0xf288
je 0x405f
testl %edi, %edi
jle 0x4058
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl 0xb2b7(%rip), %ecx      # 0xf28c
leaq 0x6227(%rip), %rdx      # 0xa203
xorl %edi, %edi
xorl %esi, %esi
xorl %eax, %eax
callq 0x3eb5
leaq 0xb2a2(%rip), %rbx      # 0xf290
leaq 0x622c(%rip), %r14      # 0xa221
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x403e
movl (%rbx), %r15d
movl 0x10(%rbx), %r12d
movq %rbx, %rdi
callq 0x4063
movq %rax, %r10
movzwl 0x22(%rbx), %eax
rolw $0x8, %ax
movzwl %ax, %r11d
xorl %edi, %edi
xorl %esi, %esi
movq %r14, %rdx
movq %rbx, %rcx
movl %r15d, %r8d
movl %r12d, %r9d
xorl %eax, %eax
pushq %r11
pushq %r10
callq 0x3eb5
popq %rax
popq %rcx
addq $0x58, %rbx
jmp 0x3ff5
leaq 0x61fb(%rip), %rdx      # 0xa240
xorl %edi, %edi
xorl %esi, %esi
xorl %eax, %eax
callq 0x3eb5
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
movl 0xb22e(%rip), %eax      # 0xf28c
retq
pushq $-0x1
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/xocoder[P]m_kcptun/vendor/m_net/src/mnet_core.c
// Function: mnet_resolve
int
mnet_resolve(char *host, int port, chann_type_t ctype, chann_addr_t *addr) {
   int ret = 0;
   if (host && addr) {
      struct sockaddr_in *valid_in = NULL;
      struct addrinfo hints, *ai=NULL, *curr=NULL;
      char buf[32] = {0};

      memset(&hints, 0, sizeof(hints));
      hints.ai_family = AF_INET;
      hints.ai_socktype = (ctype == CHANN_TYPE_DGRAM) ? SOCK_DGRAM : SOCK_STREAM;
      if (port > 0) { sprintf(buf, "%d", port); }
      if ( getaddrinfo(host, (port>0 ? buf : NULL), &hints, &ai) ) {
         mm_log(NULL, 0, "fail to resolve host !\n");
         goto fail;
      }

      for ( curr=ai; curr!=NULL; curr=curr->ai_next) {
         char ipstr[16] = {0};
         inet_ntop(AF_INET, &(((struct sockaddr_in *)(curr->ai_addr))->sin_addr), ipstr, 16);
         if (strlen(ipstr) > 7) { // '0.0.0.0'
            valid_in = (struct sockaddr_in*)curr->ai_addr;
            break;
         }
      }

      if (valid_in) {
         if (0 == getnameinfo((struct sockaddr*)valid_in, sizeof(*valid_in),
                              (char*)addr->ip, 16,NULL, 0, NI_NUMERICHOST))
         {
            ret = 1;
            addr->port = port;
         }
      }

     fail:
      freeaddrinfo(ai);
   }
   return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rcx, %r14
testq %rdi, %rdi
sete %al
testq %rcx, %rcx
sete %cl
xorl %r15d, %r15d
orb %al, %cl
jne 0x4138
movl %esi, %r8d
movq %rdi, %r12
andq $0x0, -0x38(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x90(%rbp)
movaps %xmm0, -0xa0(%rbp)
movaps %xmm0, -0x80(%rbp)
movaps %xmm0, -0x70(%rbp)
movaps %xmm0, -0x60(%rbp)
movl $0x2, -0x7c(%rbp)
xorl %eax, %eax
cmpl $0x2, %edx
sete %al
incl %eax
movl %eax, -0x78(%rbp)
testl %esi, %esi
movl %esi, -0x2c(%rbp)
jle 0x40fe
leaq 0x6172(%rip), %rsi      # 0xa25a
leaq -0xa0(%rbp), %rbx
movq %rbx, %rdi
movl %r8d, %edx
xorl %eax, %eax
callq 0x2080
jmp 0x4100
xorl %ebx, %ebx
leaq -0x80(%rbp), %rdx
leaq -0x38(%rbp), %r13
movq %r12, %rdi
movq %rbx, %rsi
movq %r13, %rcx
callq 0x2310
testl %eax, %eax
je 0x414d
leaq 0x613c(%rip), %rdx      # 0xa25d
xorl %r15d, %r15d
xorl %edi, %edi
xorl %esi, %esi
xorl %eax, %eax
callq 0x3eb5
movq -0x38(%rbp), %rdi
callq 0x2330
movl %r15d, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, -0x40(%rbp)
pushq $0x2
popq %r12
leaq -0x50(%rbp), %r14
pushq $0x10
popq %rbx
movq (%r13), %r13
xorl %r15d, %r15d
testq %r13, %r13
je 0x412f
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
movq 0x18(%r13), %rsi
addq $0x4, %rsi
movl %r12d, %edi
movq %r14, %rdx
movl %ebx, %ecx
callq 0x22c0
movq %r14, %rdi
callq 0x2100
cmpq $0x7, %rax
ja 0x4198
addq $0x28, %r13
jmp 0x415c
movq 0x18(%r13), %rdi
testq %rdi, %rdi
movq -0x40(%rbp), %rbx
je 0x412f
movl $0x1, (%rsp)
xorl %r15d, %r15d
pushq $0x10
popq %rcx
movl %ecx, %esi
movq %rbx, %rdx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x21a0
testl %eax, %eax
jne 0x412f
movl -0x2c(%rbp), %eax
movl %eax, 0x10(%rbx)
pushq $0x1
popq %r15
jmp 0x412f
// File: /workspace/github_cpp_makefile_star2_O2/xocoder[P]m_kcptun/vendor/m_net/src/mnet_core.c
// Function: mnet_parse_ipport
int
mnet_parse_ipport(const char *ipport, chann_addr_t *addr) {
   if (ipport && addr) {
      const char *p = strchr(ipport, ':');
      if (p >= ipport) {
         if ((p - ipport) >= 7) {
            addr->ip[p - ipport] = 0;
            strncpy(addr->ip, ipport, p - ipport);
         } else {
            strncpy(addr->ip, "0.0.0.0", 8);
         }
         addr->port = atoi(p+1);
         return 1;
      }
   }
   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
xorl %r12d, %r12d
orb %al, %cl
jne 0x4246
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x3a
popq %rsi
callq 0x20f0
movq %rax, %rdx
subq %r14, %rdx
jb 0x4246
movq %rax, %r15
cmpq $0x7, %rdx
jl 0x4227
movb $0x0, (%rbx,%rdx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2170
jmp 0x4234
movabsq $0x302e302e302e30, %rax # imm = 0x302E302E302E30
movq %rax, (%rbx)
incq %r15
movq %r15, %rdi
callq 0x23a0
movl %eax, 0x10(%rbx)
pushq $0x1
popq %r12
movl %r12d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/xocoder[P]m_kcptun/vendor/m_net/src/mnet_core.c
// Function: chann_create(s_mnet*, chann_type_t, chann_state_t)
static chann_t*
_chann_create(mnet_t *ss, chann_type_t type, chann_state_t state) {
   chann_t *n = (chann_t*)mm_malloc(sizeof(*n));
   n->state = state;
   n->type = type;
   n->next = ss->channs;
   if (ss->channs) {
      ss->channs->prev = n;
   }
   ss->channs = n;
   ss->chann_count++;
   mm_log(n, MNET_LOG_VERBOSE, "chann create, type:%d, count %d\n", type, ss->chann_count);
   return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r15d
movl %edi, %r14d
movl $0x90, %edi
callq *0xafbf(%rip)           # 0xf238
movq %rax, %rbx
movl $0x90, %edx
movq %rax, %rdi
xorl %esi, %esi
callq 0x2180
movl %r15d, 0x10(%rbx)
movl %r14d, 0x14(%rbx)
movq 0xaff6(%rip), %rax      # 0xf290
movq %rax, 0x58(%rbx)
testq %rax, %rax
je 0x42a7
movq %rbx, 0x50(%rax)
movq %rbx, 0xafe2(%rip)      # 0xf290
movl 0xafd7(%rip), %r8d      # 0xf28c
incl %r8d
movl %r8d, 0xafcd(%rip)      # 0xf28c
leaq 0x6144(%rip), %rdx      # 0xa40a
pushq $0x3
popq %rsi
movq %rbx, %rdi
movl %r14d, %ecx
xorl %eax, %eax
callq 0x3eb5
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/xocoder[P]m_kcptun/vendor/m_net/src/mnet_core.c
// Function: mnet_chann_connect
int
mnet_chann_connect(chann_t *n, const char *host, int port) {
   if (n && host && port>0) {
      int fd = _chann_open_socket(n, host, port, 0);
      if (fd > 0) {
         n->fd = fd;
         if (n->type == CHANN_TYPE_STREAM) {
            int r = connect(fd, (struct sockaddr*)&n->addr, n->addr_len);
            if (r >= 0 || errno==EINPROGRESS || errno==EWOULDBLOCK) {
               n->state = CHANN_STATE_CONNECTING;
               _evt_add(n, MNET_SET_WRITE);
               mm_log(n, MNET_LOG_VERBOSE, "chann fd:%d type:%d connecting...\n", fd, n->type);
               return 1;
            }
         } else {
            n->state = CHANN_STATE_CONNECTED;
            _evt_add(n, MNET_SET_READ);
            mm_log(n, MNET_LOG_VERBOSE, "chann fd:%d type:%d connected\n", fd, n->type);
            return 1;
         }
      }
      mm_log(n, MNET_LOG_ERR, "chann %p fail to connect %d:%s\n", n, errno, strerror(errno));
   }
   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
testl %edx, %edx
setle %al
xorl %r15d, %r15d
orb %cl, %al
jne 0x4408
movq %rdi, %rbx
xorl %ecx, %ecx
callq 0x4434
testl %eax, %eax
jle 0x43a6
movl %eax, %r14d
movl %eax, (%rbx)
cmpl $0x1, 0x14(%rbx)
jne 0x43d8
leaq 0x20(%rbx), %rsi
movl 0x30(%rbx), %edx
movl %r14d, %edi
callq 0x2230
testl %eax, %eax
js 0x4416
movl $0x2, 0x10(%rbx)
pushq $0x1
popq %r15
movq %rbx, %rdi
movl %r15d, %esi
callq 0x461f
movl 0x14(%rbx), %r8d
leaq 0x5ee1(%rip), %rdx      # 0xa275
pushq $0x3
popq %rsi
movq %rbx, %rdi
movl %r14d, %ecx
xorl %eax, %eax
callq 0x3eb5
jmp 0x4408
callq 0x2040
movl (%rax), %r14d
movl %r14d, %edi
callq 0x20e0
leaq 0x5efa(%rip), %rdx      # 0xa2b7
xorl %r15d, %r15d
pushq $0x1
popq %rsi
movq %rbx, %rdi
movq %rbx, %rcx
movl %r14d, %r8d
movq %rax, %r9
xorl %eax, %eax
callq 0x3eb5
jmp 0x4408
movl $0x3, 0x10(%rbx)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x461f
movl 0x14(%rbx), %r8d
leaq 0x5ea4(%rip), %rdx      # 0xa298
pushq $0x3
popq %rsi
movq %rbx, %rdi
movl %r14d, %ecx
xorl %eax, %eax
callq 0x3eb5
pushq $0x1
popq %r15
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x2040
movl (%rax), %ecx
cmpl $0x73, %ecx
je 0x4373
cmpl $0xb, %ecx
je 0x4373
jmp 0x43ab
// File: /workspace/github_cpp_makefile_star2_O2/xocoder[P]m_kcptun/vendor/m_net/src/mnet_core.c
// Function: evt_add(s_mchann*, int)
static int
_evt_add(chann_t *n, int set) {
   mnet_t *ss = _gmnet();
   struct s_event *chg = &ss->chg;
   if ( _evt_check_expand(chg) ) {
      mevent_t *kev = chg->array;
      memset(kev, 0, sizeof(mevent_t));
#if (MNET_OS_MACOX || MNET_OS_FreeBSD)
      kev->ident = n->fd;
      if (set == MNET_SET_READ) {
         kev->filter = EVFILT_READ;
      } else if (set == MNET_SET_WRITE) {
         kev->filter = EVFILT_WRITE;
      }
      kev->flags = EV_ADD | EV_EOF;
      kev->udata = (void*)n;
      if (kevent(ss->kq, chg->array, 1, NULL, 0, NULL) < 0) {
         mm_log(n, MNET_LOG_ERR, "kq fail to add fd:%d filter %x, errno %d:%s\n",
                n->fd, kev->filter, errno, strerror(errno));
         return 0;
      }
#else
      uint32_t events = 0;
      kev->data.ptr = (void*)n;
      if (set == MNET_SET_READ) {
         events = n->epoll_events | EPOLLIN | EPOLLRDHUP | EPOLLHUP;
      } else if (set == MNET_SET_WRITE) {
         events = n->epoll_events | EPOLLOUT | EPOLLRDHUP | EPOLLHUP;
      }
      kev->events = events;
      if (epoll_ctl(ss->kq, (n->epoll_events ? EPOLL_CTL_MOD : EPOLL_CTL_ADD), n->fd, kev) < 0) {
         mm_log(n, MNET_LOG_ERR, "epoll fail to add fd:%d filter %x, errno %d:%s\n",
                n->fd, n->epoll_events, errno, strerror(errno));
         return 0;
      }
      n->epoll_events = events;
#endif
      mm_log(n, MNET_LOG_VERBOSE, "add chann:%p fd:%d events\n", n, n->fd);
      return 1;
   }
   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %r14d
movq %rdi, %rbx
callq 0x5269
testl %eax, %eax
je 0x46f5
movq 0xac60(%rip), %rcx      # 0xf2a8
andl $0x0, (%rcx)
movq %rbx, 0x4(%rcx)
xorl %eax, %eax
testl %r14d, %r14d
setne %al
movl 0x88(%rbx), %edx
leal (%rax,%rax,2), %r14d
addl $0x2011, %r14d          # imm = 0x2011
orl %edx, %r14d
movl %r14d, (%rcx)
movl 0xac24(%rip), %edi      # 0xf298
xorl %eax, %eax
testl %edx, %edx
setne %al
leal 0x1(,%rax,2), %esi
movl (%rbx), %edx
callq 0x2350
testl %eax, %eax
js 0x46ba
movl %r14d, 0x88(%rbx)
movl (%rbx), %r8d
leaq 0x5ded(%rip), %rdx      # 0xa48b
pushq $0x3
popq %rsi
movq %rbx, %rdi
movq %rbx, %rcx
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3eb5
movl (%rbx), %r14d
movl 0x88(%rbx), %r15d
callq 0x2040
movl (%rax), %r12d
movl %r12d, %edi
callq 0x20e0
movq %rax, (%rsp)
leaq 0x5d7c(%rip), %rdx      # 0xa45b
pushq $0x1
popq %rsi
movq %rbx, %rdi
movl %r14d, %ecx
movl %r15d, %r8d
movl %r12d, %r9d
xorl %eax, %eax
callq 0x3eb5
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/xocoder[P]m_kcptun/vendor/m_net/src/mnet_core.c
// Function: mnet_chann_listen
int
mnet_chann_listen(chann_t *n, const char *host, int port, int backlog) {
   if (n && port>0) {
      int fd = _chann_open_socket(n, host, port, backlog | 1);
      if (fd > 0) {
         n->fd = fd;
         n->state = CHANN_STATE_LISTENING;
         _evt_add(n, MNET_SET_READ);
         mm_log(n, MNET_LOG_VERBOSE, "chann %p, fd:%d listen\n", n, fd);
         return 1;
      }
      mm_log(n, MNET_LOG_ERR, "chann %p fail to listen\n", n);
   }
   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
sete %al
testl %edx, %edx
setle %dil
xorl %r14d, %r14d
orb %al, %dil
jne 0x4790
orl $0x1, %ecx
movq %rbx, %rdi
callq 0x4434
testl %eax, %eax
jle 0x4776
movl %eax, %r14d
movl %eax, (%rbx)
movl $0x4, 0x10(%rbx)
movq %rbx, %rdi
xorl %esi, %esi
callq 0x461f
leaq 0x5b7a(%rip), %rdx      # 0xa2d7
pushq $0x3
popq %rsi
movq %rbx, %rdi
movq %rbx, %rcx
movl %r14d, %r8d
xorl %eax, %eax
callq 0x3eb5
pushq $0x1
popq %r14
jmp 0x4790
leaq 0x5b72(%rip), %rdx      # 0xa2ef
xorl %r14d, %r14d
pushq $0x1
popq %rsi
movq %rbx, %rdi
movq %rbx, %rcx
xorl %eax, %eax
callq 0x3eb5
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/xocoder[P]m_kcptun/vendor/m_net/src/mnet_core.c
// Function: mnet_chann_active_event
void
mnet_chann_active_event(chann_t *n, chann_event_t et, int active) {
   if ( n ) {
      if (et == CHANN_EVENT_SEND) {
         n->active_send_event = active;
         if (active) {
            _evt_add(n, MNET_SET_WRITE);
         } else {
            _evt_del(n, MNET_SET_WRITE);
         }
      }
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
sete %al
cmpl $0x2, %esi
setne %cl
orb %al, %cl
jne 0x47d1
movl %edx, 0x70(%rdi)
testl %edx, %edx
je 0x47d3
movl $0x1, %esi
popq %rbp
jmp 0x461f
popq %rbp
retq
popq %rbp
jmp 0x47d6
// File: /workspace/github_cpp_makefile_star2_O2/xocoder[P]m_kcptun/vendor/m_net/src/mnet_core.c
// Function: evt_del(s_mchann*, int)
static int
_evt_del(chann_t *n, int set) {
   mnet_t *ss = _gmnet();
   struct s_event *chg = &ss->chg;
   if ( _evt_check_expand(chg) ) {
      mevent_t *kev = chg->array;
      memset(kev, 0, sizeof(mevent_t));
#if (MNET_OS_MACOX || MNET_OS_FreeBSD)
      kev->ident = n->fd;
      if (set == MNET_SET_READ) {
         kev->filter = EVFILT_READ;
      } else if (set == MNET_SET_WRITE) {
         kev->filter = EVFILT_WRITE;         
      }
      kev->flags = EV_DELETE;
      kev->udata = (void*)n;
      if (kevent(ss->kq, chg->array, 1, NULL, 0, NULL) < 0) {
         mm_log(n, MNET_LOG_ERR, "kq fail to delete fd:%d filter %x, errno %d:%s\n",
                n->fd, kev->filter, errno, strerror(errno));
         return 0;
      }
#else
      uint32_t events = 0;
      kev->data.ptr = (void*)n;
      if (set == MNET_SET_READ) {
         events = n->epoll_events & ~EPOLLIN;
      } else if (set == MNET_SET_WRITE) {
         events = n->epoll_events & ~EPOLLOUT;
      }
      kev->events = events;
      if (epoll_ctl(ss->kq, events ? EPOLL_CTL_MOD : EPOLL_CTL_DEL, n->fd, kev) < 0) {
         mm_log(n, MNET_LOG_ERR, "epoll fail to add fd:%d filter %x, errno %d, %s\n",
                n->fd, n->epoll_events, errno, strerror(errno));
         return 0;
      }
      n->epoll_events = events;
#endif
      mm_log(n, MNET_LOG_VERBOSE, "del chann:%p fd:%d events\n", n, n->fd);
      return 1;
   }
   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x5269
testl %eax, %eax
je 0x4893
movq 0xaaac(%rip), %rcx      # 0xf2a8
andl $0x0, (%rcx)
movq %rbx, 0x4(%rcx)
movl 0x88(%rbx), %r14d
xorl %esi, %esi
andl $-0x5, %r14d
movl %r14d, (%rcx)
movl 0xaa7f(%rip), %edi      # 0xf298
sete %sil
xorl $0x3, %esi
movl (%rbx), %edx
callq 0x2350
testl %eax, %eax
js 0x4858
movl %r14d, 0x88(%rbx)
movl (%rbx), %r8d
leaq 0x5cb0(%rip), %rdx      # 0xa4ec
pushq $0x3
popq %rsi
movq %rbx, %rdi
movq %rbx, %rcx
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3eb5
movl (%rbx), %r14d
movl 0x88(%rbx), %r15d
callq 0x2040
movl (%rax), %r12d
movl %r12d, %edi
callq 0x20e0
movq %rax, (%rsp)
leaq 0x5c3e(%rip), %rdx      # 0xa4bb
pushq $0x1
popq %rsi
movq %rbx, %rdi
movl %r14d, %ecx
movl %r15d, %r8d
movl %r12d, %r9d
xorl %eax, %eax
callq 0x3eb5
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/xocoder[P]m_kcptun/vendor/m_net/src/mnet_core.c
// Function: mnet_chann_recv
int
mnet_chann_recv(chann_t *n, void *buf, int len) {
   if (n && buf && len>0 && n->state>=CHANN_STATE_CONNECTED) {
      int ret = 0;
      if (n->type == CHANN_TYPE_STREAM) {
         ret = (int)recv(n->fd, buf, len, 0);
      } else {
         n->addr_len = sizeof(n->addr);
         ret = (int)recvfrom(n->fd, buf, len, 0, (struct sockaddr*)&(n->addr), &(n->addr_len));
      }
      if (ret < 0) {
         if (errno == EWOULDBLOCK) {
            ret = 0;
         } else {
            mnet_t *ss = _gmnet();
            mm_log(n, MNET_LOG_ERR, "chann %p fd:%d, recv errno %d:%s\n",
                   n, n->fd, errno, strerror(errno));
            _chann_disconnect_socket(ss, n);
            _chann_msg(n, CHANN_EVENT_DISCONNECT, NULL, errno);
         }
      }
      n->bytes_recv += ret;
      return ret;
   }
   return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
testl %edx, %edx
setle %dil
pushq $-0x1
popq %rax
orb %cl, %dil
jne 0x4971
cmpl $0x3, 0x10(%rbx)
jl 0x4971
cmpl $0x1, 0x14(%rbx)
jne 0x48ee
movl (%rbx), %edi
movl %edx, %edx
xorl %ecx, %ecx
callq 0x20d0
jmp 0x4908
leaq 0x30(%rbx), %r9
movl $0x10, 0x30(%rbx)
movl (%rbx), %edi
movl %edx, %edx
leaq 0x20(%rbx), %r8
xorl %ecx, %ecx
callq 0x2200
movq %rax, %r14
testl %r14d, %r14d
jns 0x4967
callq 0x2040
movq %rax, %r15
movl (%rax), %r12d
xorl %eax, %eax
cmpl $0xb, %r12d
je 0x496a
movl (%rbx), %r13d
movl %r12d, %edi
callq 0x20e0
movq %rax, (%rsp)
leaq 0x59cf(%rip), %rdx      # 0xa308
pushq $0x1
popq %rsi
movq %rbx, %rdi
movq %rbx, %rcx
movl %r13d, %r8d
movl %r12d, %r9d
xorl %eax, %eax
callq 0x3eb5
movq %rbx, %rdi
callq 0x3da8
movl (%r15), %ecx
pushq $0x5
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x4980
movl %r14d, %eax
movslq %eax, %rcx
addq %rcx, 0x68(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/xocoder[P]m_kcptun/vendor/m_net/src/mnet_core.c
// Function: chann_msg(s_mchann*, chann_event_t, s_mchann*, int)
static void
_chann_msg(chann_t *n, chann_event_t event, chann_t *r, int err) {
   chann_msg_t e;
   e.event = event;
   e.err = err;
   e.n = n;
   e.r = r;
   e.opaque = n->opaque;
   if ( n->cb ) {
      n->cb( &e );
   } else {
      mm_log(n, MNET_LOG_ERR, "chann fd:%d no callback\n", n->fd);
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %esi, -0x20(%rbp)
movl %ecx, -0x1c(%rbp)
movq %rdi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movq 0x8(%rdi), %rax
movq %rax, -0x8(%rbp)
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x49b3
leaq -0x20(%rbp), %rdi
callq *%rax
addq $0x20, %rsp
popq %rbp
retq
movl (%rdi), %ecx
leaq 0x5b4b(%rip), %rdx      # 0xa507
pushq $0x1
popq %rsi
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
jmp 0x3eb5
// File: /workspace/github_cpp_makefile_star2_O2/xocoder[P]m_kcptun/vendor/m_net/src/mnet_core.c
// Function: rwb_cache(s_rwbuf_head*, unsigned char*, int)
static void
_rwb_cache(rwb_head_t *h, unsigned char *buf, int buf_len) {
   int buf_ptr = 0;
   while (buf_ptr < buf_len) {
      rwb_t *b = _rwb_create_tail(h);
      int len = _min_of((buf_len - buf_ptr), _rwb_available(b));
      memcpy(&b->buf[b->ptw], &buf[buf_ptr], len);
      b->ptw += len;
      buf_ptr += len;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, -0x30(%rbp)
movq %rdi, %r15
xorl %r14d, %r14d
movl %ebx, %r13d
subl %r14d, %r13d
jle 0x4c16
cmpl $0x0, 0x10(%r15)
jle 0x4ba7
movq 0x8(%r15), %r12
testq %r12, %r12
je 0x4b72
movl 0x4(%r12), %eax
cmpl $0x10000, %eax          # imm = 0x10000
jl 0x4bde
movl $0x10018, %edi          # imm = 0x10018
callq *0xa6bb(%rip)           # 0xf238
movq %rax, %r12
movl $0x10018, %edx          # imm = 0x10018
movq %rax, %rdi
xorl %esi, %esi
callq 0x2180
leaq 0x18(%r12), %rax
movq %rax, 0x10(%r12)
movq 0x8(%r15), %rax
movq %r12, 0x8(%rax)
movq %r12, 0x8(%r15)
jmp 0x4bd5
movl $0x10018, %edi          # imm = 0x10018
callq *0xa686(%rip)           # 0xf238
movq %rax, %r12
movl $0x10018, %edx          # imm = 0x10018
movq %rax, %rdi
xorl %esi, %esi
callq 0x2180
leaq 0x18(%r12), %rax
movq %rax, 0x10(%r12)
movq %r12, 0x8(%r15)
movq %r12, (%r15)
incl 0x10(%r15)
movl 0x4(%r12), %eax
movl $0x10000, %ecx          # imm = 0x10000
subl %eax, %ecx
cmpl %ecx, %r13d
cmovll %r13d, %ecx
movslq %eax, %rdi
addq 0x10(%r12), %rdi
movslq %r14d, %rsi
addq -0x30(%rbp), %rsi
movslq %ecx, %r13
movq %r13, %rdx
callq 0x2220
addl %r13d, 0x4(%r12)
addl %r14d, %r13d
movl %r13d, %r14d
jmp 0x4b4a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/xocoder[P]m_kcptun/vendor/m_net/src/mnet_core.c
// Function: chann_send(s_mchann*, void*, int)
static int
_chann_send(chann_t *n, void *buf, int len) {
   int ret = 0;
   if (n->type == CHANN_TYPE_STREAM) {
      ret = (int)send(n->fd, buf, len, 0);
   } else {
      ret = (int)sendto(n->fd, buf, len, 0, (struct sockaddr*)&n->addr, n->addr_len);
   }
   if (ret > 0) {
      n->bytes_send += ret;
   }
   return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %edi
cmpl $0x1, 0x14(%rbx)
movslq %edx, %rdx
jne 0x4c42
xorl %ecx, %ecx
callq 0x2160
jmp 0x4c51
leaq 0x20(%rbx), %r8
movl 0x30(%rbx), %r9d
xorl %ecx, %ecx
callq 0x2060
testl %eax, %eax
jle 0x4c61
movl %eax, %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
addq %rcx, 0x60(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/xocoder[P]m_kcptun/vendor/m_net/src/mnet_core.c
// Function: mnet_chann_set_bufsize
int
mnet_chann_set_bufsize(chann_t *n, int bufsize) {
   if (n && bufsize>0) {
      n->buf_size = bufsize;
      if (n->fd > 0) {
         return _set_bufsize(n->fd, bufsize);
      }
      return 1;
   }
   return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rdi, %rdi
sete %cl
testl %esi, %esi
setle %dl
xorl %eax, %eax
orb %cl, %dl
jne 0x4c8e
movl %esi, 0x74(%rdi)
movl (%rdi), %edi
testl %edi, %edi
jle 0x4c89
popq %rbp
jmp 0x4c90
movl $0x1, %eax
popq %rbp
retq