LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/lotuskip[P]yuxtapa/client/base.cpp
// Function: Base::more_chat_ind()
void Base::more_chat_ind()
{
	wmove(windows[CHAT_WIN], scr_y - VIEWSIZE - 1, scr_x - 4);
	change_colour(windows[CHAT_WIN], BASE_BLUE);
	waddstr(windows[CHAT_WIN], "[+]");
	wrefresh(windows[CHAT_WIN]);
	return_cursor(cursor_in_view);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x10f0e(%rip), %rdi     # 0x17978
movzwl 0x10ee7(%rip), %esi     # 0x17958
addl $-0x18, %esi
movzwl 0x10edf(%rip), %edx     # 0x1795a
addl $-0x4, %edx
callq 0x4230
movq 0x10eee(%rip), %rdi     # 0x17978
movl $0x400, %esi            # imm = 0x400
callq 0x41c0
movq 0x10edd(%rip), %rdi     # 0x17978
leaq 0x95b4(%rip), %rsi      # 0x10056
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x4680
movq 0x10ec5(%rip), %rdi     # 0x17978
callq 0x4420
movzbl 0x10ed1(%rip), %edi     # 0x17990
xorl $0x1, %edi
popq %rbp
jmp 0x697f
// File: /workspace/github_cpp_makefile_star2_O3/lotuskip[P]yuxtapa/client/base.cpp
// Function: Base::less_chat_ind()
void Base::less_chat_ind()
{
	wmove(windows[CHAT_WIN], 0, scr_x - 4);
	change_colour(windows[CHAT_WIN], BASE_BLUE);
	waddstr(windows[CHAT_WIN], "[-]");
	wrefresh(windows[CHAT_WIN]);
	return_cursor(cursor_in_view);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x10ea5(%rip), %rdi     # 0x17978
movzwl 0x10e80(%rip), %edx     # 0x1795a
addl $-0x4, %edx
xorl %esi, %esi
callq 0x4230
movq 0x10e8d(%rip), %rdi     # 0x17978
movl $0x400, %esi            # imm = 0x400
callq 0x41c0
movq 0x10e7c(%rip), %rdi     # 0x17978
leaq 0x9557(%rip), %rsi      # 0x1005a
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x4680
movq 0x10e64(%rip), %rdi     # 0x17978
callq 0x4420
movzbl 0x10e70(%rip), %edi     # 0x17990
xorl $0x1, %edi
popq %rbp
jmp 0x697f
// File: /workspace/github_cpp_makefile_star2_O3/lotuskip[P]yuxtapa/client/base.cpp
// Function: Base::print_view(char const*)
void Base::print_view(const char *source)
{
	// The view has a sequence of pairs (colour, symbol):
	char x, y;
	for(y = 0; y < VIEWSIZE; ++y)
	{
		wmove(windows[VIEW_WIN], y, 0);
		for(x = 0; x < VIEWSIZE; ++x)
		{
			change_colour(windows[VIEW_WIN], *source);
			waddch(windows[VIEW_WIN], *(++source));
			++source;
		}
	}
	wrefresh(windows[VIEW_WIN]);
	return_cursor(cursor_in_view);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movq 0x10e2d(%rip), %rdi     # 0x17988
movl %r14d, %esi
xorl %edx, %edx
callq 0x4230
xorl %r15d, %r15d
movq 0x10e19(%rip), %rdi     # 0x17988
movzbl (%rbx,%r15), %esi
callq 0x68ee
movq 0x10e08(%rip), %rdi     # 0x17988
movsbl 0x1(%rbx,%r15), %esi
callq 0x45b0
addq $0x2, %r15
cmpb $0x2e, %r15b
jne 0x6b68
incl %r14d
addq %r15, %rbx
cmpl $0x17, %r14d
jne 0x6b54
movq 0x10de0(%rip), %rdi     # 0x17988
callq 0x4420
movzbl 0x10ddc(%rip), %edi     # 0x17990
xorl $0x1, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x697f
// File: /workspace/github_cpp_makefile_star2_O3/lotuskip[P]yuxtapa/client/base.cpp
// Function: Base::viewtick()
void Base::viewtick()
{
	wmove(windows[STAT_WIN], 4, 53);
	change_colour(windows[STAT_WIN], C_WALL_LIT);
	waddstr(windows[STAT_WIN], anim_syms[animind].c_str());
	wrefresh(windows[STAT_WIN]);
	if(++animind == anim_syms.size())
		animind = 0;
	return_cursor(cursor_in_view);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x10d40(%rip), %rdi     # 0x17970
movl $0x4, %esi
movl $0x35, %edx
callq 0x4230
movq 0x10d2a(%rip), %rdi     # 0x17970
cmpl $0x2, 0x10d0f(%rip)     # 0x1795c
movl $0x200f00, %eax         # imm = 0x200F00
movl $0x2e00, %esi           # imm = 0x2E00
cmovel %eax, %esi
callq 0x41c0
movq 0x10d0a(%rip), %rdi     # 0x17970
movzbl 0x10d25(%rip), %eax     # 0x17992
movq 0x10ccc(%rip), %rcx     # 0x17940
shll $0x5, %eax
movq (%rcx,%rax), %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x4680
movq 0x10ce4(%rip), %rdi     # 0x17970
callq 0x4420
movb 0x10cfb(%rip), %al      # 0x17992
incb %al
movb %al, 0x10cf3(%rip)      # 0x17992
movzbl %al, %eax
movq 0x10c9f(%rip), %rcx     # 0x17948
subq 0x10c90(%rip), %rcx     # 0x17940
sarq $0x5, %rcx
cmpq %rax, %rcx
jne 0x6cc0
movb $0x0, 0x10cd2(%rip)     # 0x17992
movzbl 0x10cc9(%rip), %edi     # 0x17990
xorl $0x1, %edi
popq %rbp
jmp 0x697f
// File: /workspace/github_cpp_makefile_star2_O3/lotuskip[P]yuxtapa/client/base.cpp
// Function: Base::print_walk(bool)
void Base::print_walk(const bool w)
{
	wmove(windows[STAT_WIN], 4, 55);
	change_colour(windows[STAT_WIN], C_WALL_LIT);
	waddch(windows[STAT_WIN], walk_syms[w]);
	wrefresh(windows[STAT_WIN]);
	return_cursor(cursor_in_view);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
movq 0x10c91(%rip), %rdi     # 0x17970
movl $0x4, %esi
movl $0x37, %edx
callq 0x4230
movq 0x10c7b(%rip), %rdi     # 0x17970
cmpl $0x2, 0x10c60(%rip)     # 0x1795c
movl $0x200f00, %eax         # imm = 0x200F00
movl $0x2e00, %esi           # imm = 0x2E00
cmovel %eax, %esi
callq 0x41c0
movq 0x10c5b(%rip), %rdi     # 0x17970
movl %ebx, %eax
leaq 0x959f(%rip), %rcx      # 0x102bd
movsbl (%rax,%rcx), %esi
callq 0x45b0
movq 0x10c42(%rip), %rdi     # 0x17970
callq 0x4420
movzbl 0x10c56(%rip), %edi     # 0x17990
xorl $0x1, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x697f
// File: /workspace/github_cpp_makefile_star2_O3/lotuskip[P]yuxtapa/client/class_cpv.cpp
// Function: ClassCPV::move(e_Dir)
void ClassCPV::move(const e_Dir d)
{
	if(clientstate == CS_NORMAL) // regular movement
		Network::send_action(XN_MOVE, d);
	else if(clientstate == CS_AIMING) // moving the aimer
	{
		aimer = aimer.in(d);
		if(aimer.x > VIEWSIZE/2) aimer.x--;
		else if(aimer.x < -VIEWSIZE/2) aimer.x++;
		if(aimer.y > VIEWSIZE/2) aimer.y--;
		else if(aimer.y < -VIEWSIZE/2) aimer.y++;
		redraw_view();
	}
	else if(clientstate == CS_DIR) // waiting for dir input (and now got it!)
	{
		if(myclass == C_FIGHTER)
			Network::send_action(XN_CIRCLE_ATTACK, d);
		else if(myclass == C_HEALER)
			Network::send_action(XN_HEAL, d);
		else if(myclass == C_MINER)
			Network::send_action(XN_MINE, d);
		else if(myclass == C_COMBAT_MAGE)
			Network::send_action(XN_ZAP, d);
		clientstate = CS_NORMAL;
	}	
	// else ignore
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl %edi, %edx
leaq 0x10831(%rip), %rbx     # 0x17e80
movl (%rbx), %eax
cmpl $0x7, %eax
je 0x76f4
cmpl $0x6, %eax
je 0x767c
testl %eax, %eax
jne 0x7734
movzbl %dl, %esi
movl $0x4, %edi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xc85e
leaq 0x106bd(%rip), %rsi     # 0x17d40
leaq -0xc(%rbp), %rbx
movq %rbx, %rdi
callq 0xfb10
movl (%rbx), %eax
movl %eax, 0x106a9(%rip)     # 0x17d40
movq %rbx, %rdi
callq 0xfa9e
movzwl 0x1069a(%rip), %eax     # 0x17d40
movw $0xffff, %cx            # imm = 0xFFFF
cmpw $0xb, %ax
jg 0x76ba
movw $0x1, %cx
cmpw $-0xc, %ax
jg 0x76c6
movswl %cx, %ecx
addl %eax, %ecx
movw %cx, 0x1067a(%rip)      # 0x17d40
movzwl 0x10675(%rip), %eax     # 0x17d42
movw $0xffff, %cx            # imm = 0xFFFF
cmpw $0xb, %ax
jg 0x76e1
movw $0x1, %cx
cmpw $-0xc, %ax
jg 0x76ed
movswl %cx, %ecx
addl %eax, %ecx
movw %cx, 0x10655(%rip)      # 0x17d42
callq 0xead1
jmp 0x7734
movl 0xfcbe(%rip), %ecx      # 0x173b8
addl $-0x2, %ecx
cmpl $0x5, %ecx
ja 0x772e
movl $0x39, %eax
btl %ecx, %eax
jae 0x772e
shll $0x3, %ecx
movabsq $0xc0b0a0a0a07, %rdi    # imm = 0xC0B0A0A0A07
shrq %cl, %rdi
movl $0xff, %eax
andl %eax, %edx
andl %eax, %edi
movl %edx, %esi
xorl %edx, %edx
callq 0xc85e
movl $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/lotuskip[P]yuxtapa/client/class_cpv.cpp
// Function: ClassCPV::five()
void ClassCPV::five()
{
	if(clientstate == CS_AIMING)
	{
		if(aimer.x || aimer.y)
		{
			aimer.x = aimer.y = 0;
			redraw_view();
		}
	}	
	else if(clientstate == CS_DIR && myclass == C_HEALER) 
	{
		Network::send_action(XN_HEAL, MAX_D); // heal self
		clientstate = CS_NORMAL;
	}
	// else ignore
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x10738(%rip), %rbx     # 0x17e80
movl (%rbx), %eax
cmpl $0x6, %eax
jne 0x7774
movzwl 0x105ec(%rip), %eax     # 0x17d42
orw 0x105e3(%rip), %ax      # 0x17d40
je 0x7799
movl $0x0, 0x105d7(%rip)     # 0x17d40
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xead1
cmpl $0x7, %eax
jne 0x7799
cmpl $0x7, 0xfc38(%rip)      # 0x173b8
jne 0x7799
movl $0xc, %edi
movl $0x8, %esi
xorl %edx, %edx
callq 0xc85e
movl $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/lotuskip[P]yuxtapa/client/class_cpv.cpp
// Function: ClassCPV::state_change(unsigned char, unsigned char)
void ClassCPV::state_change(const unsigned char cl, const unsigned char t)
{
	myteam = e_Team(t);
	hp = 0; // we are dead until further notice (the further notice being a status update)

	// print PC info:
	if((myclass = e_Class(cl)) == NO_CLASS) // spectator
		Base::print_str("Spectator  ", team_colour[T_SPEC], PC_INFO_X, 3, STAT_WIN, false);
	else // actual class 
	{
		Base::print_str(pcview_classname[myclass].c_str(), team_colour[myteam],
			PC_INFO_X, 3, STAT_WIN, false);
		dam_die = classes[myclass].dam_die;
		dv = classes[myclass].dv;
		pv = classes[myclass].pv;
	}
	// Clear the rest:
	for(char y = 4; y < 7; ++y)
		Base::print_str("          ", team_colour[T_SPEC], PC_INFO_X, y, STAT_WIN, false);
	Base::print_str("    ", team_colour[T_SPEC], 52, 3, STAT_WIN, false); // map area

	// class/team change requires any class-specific action to end:
	if(clientstate >= CS_AIMING)
	{
		clientstate = CS_NORMAL;
		redraw_view();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, 0xfacc(%rip)      # 0x173bc
movb $0x0, 0x1044d(%rip)     # 0x17d44
movl %edi, 0xfabb(%rip)      # 0x173b8
cmpl $0xb, %edi
jne 0x7925
leaq 0x8b5a(%rip), %rdi      # 0x10463
movl $0x27, %esi
movl $0x25, %edx
movl $0x3, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x686d
jmp 0x7990
movzbl %dil, %eax
shll $0x5, %eax
leaq 0x102ad(%rip), %rcx     # 0x17be0
movq (%rax,%rcx), %rdi
movzbl %sil, %eax
leaq 0x8a0a(%rip), %rcx      # 0x1034c
movzbl (%rax,%rcx), %esi
movl $0x25, %edx
movl $0x3, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x686d
movl 0xfa57(%rip), %eax      # 0x173b8
leaq (%rax,%rax,2), %rcx
leaq (%rax,%rcx,4), %rax
leaq 0x89e0(%rip), %rcx      # 0x10350
movb 0x6(%rcx,%rax), %dl
movb 0x8(%rcx,%rax), %sil
movb %dl, 0x103c6(%rip)      # 0x17d45
movb %sil, 0x103c0(%rip)     # 0x17d46
movb 0x9(%rcx,%rax), %al
movb %al, 0x103b7(%rip)      # 0x17d47
movb $0x4, %bl
leaq 0x8ad6(%rip), %r14      # 0x1046f
movsbl %bl, %ebx
movq %r14, %rdi
movl $0x27, %esi
movl $0x25, %edx
movl %ebx, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x686d
incb %bl
cmpb $0x7, %bl
jne 0x7999
leaq 0x8ab1(%rip), %rdi      # 0x10475
movl $0x27, %esi
movl $0x34, %edx
movl $0x3, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x686d
leaq 0x1049b(%rip), %rax     # 0x17e80
cmpl $0x5, (%rax)
jle 0x79f9
movl $0x0, (%rax)
popq %rbx
popq %r14
popq %rbp
jmp 0xead1
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/lotuskip[P]yuxtapa/client/input.cpp
// Function: (anonymous namespace)::init_type()
void init_type()
{
	typed_str.clear();
	viewn_str.clear();
	Base::type_cursor((type_pos = str_syms = 0));
	printb_pos = 0;
	prev_str_it = prev_strs.end();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
xorl %ebx, %ebx
movq %rbx, 0xea81(%rip)      # 0x17ea8
movq 0xea72(%rip), %rax      # 0x17ea0
movb %bl, (%rax)
movq %rbx, 0xea91(%rip)      # 0x17ec8
movq 0xea82(%rip), %rax      # 0x17ec0
movb %bl, (%rax)
movw %bx, 0xeaab(%rip)       # 0x17ef2
movw %bx, 0xea92(%rip)       # 0x17ee0
xorl %edi, %edi
callq 0x6bf4
movw %bx, 0xea94(%rip)       # 0x17ef0
movq 0xea2d(%rip), %rax      # 0x17e90
movq %rax, 0xea7e(%rip)      # 0x17ee8
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/lotuskip[P]yuxtapa/client/input.cpp
// Function: (anonymous namespace)::typing_done()
void typing_done()
{
	if(!viewn_str.empty())
	{
		if(prev_strs.empty() || viewn_str != prev_strs.back())
		{
			prev_strs.push_back(viewn_str);
			if(prev_strs.size() > 1000)
				prev_strs.erase(prev_strs.begin());
		}
		Config::do_aliasing(viewn_str);
		Network::send_line(viewn_str, clientstate == CS_TYPE_CHAT);
	}
	Base::print_str("", 0, 0, MSG_WIN_Y-1, MSG_WIN, true);
	Base::def_cursor();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0xea4a(%rip), %rdx      # 0x17ec8
testq %rdx, %rdx
je 0x950d
movq 0xea02(%rip), %rax      # 0x17e90
cmpq %rax, 0xe9f3(%rip)      # 0x17e88
je 0x94b1
cmpq -0x18(%rax), %rdx
jne 0x94b1
movq -0x20(%rax), %rsi
movq 0xea18(%rip), %rdi      # 0x17ec0
callq 0x43a0
testl %eax, %eax
je 0x94e9
leaq 0xe9d0(%rip), %rdi      # 0x17e88
leaq 0xea01(%rip), %rsi      # 0x17ec0
callq 0x9584
movq 0xe9c5(%rip), %rax      # 0x17e90
movq 0xe9b6(%rip), %rsi      # 0x17e88
subq %rsi, %rax
cmpq $0x7d01, %rax           # imm = 0x7D01
jb 0x94e9
leaq 0xe9a4(%rip), %rdi      # 0x17e88
callq 0x97a0
leaq 0xe9d0(%rip), %rbx      # 0x17ec0
movq %rbx, %rdi
callq 0xe0a8
xorl %esi, %esi
cmpl $0x1, 0xe97f(%rip)      # 0x17e80
sete %sil
movq %rbx, %rdi
callq 0xc98e
leaq 0x6f65(%rip), %rdi      # 0x10479
xorl %esi, %esi
xorl %edx, %edx
movl $0xe, %ecx
movl $0x2, %r8d
movl $0x1, %r9d
callq 0x686d
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x6bc6
// File: /workspace/github_cpp_makefile_star2_O3/lotuskip[P]yuxtapa/client/msg.cpp
// Function: add_msg(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned char)
void add_msg(const string &s, const unsigned char cp)
{
	/* First check if this new message is identical with the previous (this
	 * happens especially if someone keeps shouting something */
	if(check_repeat_msg(s, cp))
		return;

	// The rest goes for non-repeating messages:

	if(bottom_idx == MSG_WIN_Y-1) // screen buffer full
	{
		// check if STAY_TIME has passed:
		if(reference.update() - last_add < STAY_TIME)
		{
			// time not passed, put the message in queue to be displayed later
			msgavail.push_back(MsgBufferLine(s,cp));
			return;
		}
		else
			move_msgs();
	}
	msgbuffer[bottom_idx].text = s;
	msgbuffer[bottom_idx].cpair = cp;
	++bottom_idx;
	redraw_msgs();
	last_add.update();
	last_move.update(); // also delay moving
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl %esi, %ebx
movq %rdi, %r14
movq (%rdi), %rdi
movq 0x8(%r14), %rsi
movl %ebx, %edx
callq 0x9ccf
testb %al, %al
je 0x9be2
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movb 0xe430(%rip), %al       # 0x18018
cmpb $0xe, %al
jne 0x9c55
leaq 0xe42d(%rip), %rdi      # 0x18020
callq 0xf1b4
leaq 0xe3f9(%rip), %rsi      # 0x17ff8
movq %rax, %rdi
callq 0xf1ce
cmpl $0x2ed, %eax            # imm = 0x2ED
ja 0x9c4a
movzbl %bl, %edx
leaq -0x38(%rbp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9ff4
leaq 0xe321(%rip), %rdi      # 0x17f48
movq %rbx, %rsi
callq 0x9d74
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9bd9
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x4390
jmp 0x9bd9
callq 0xa035
movb 0xe3c3(%rip), %al       # 0x18018
movsbq %al, %rdi
callq 0xa17e
movq %rax, %rdi
movq %r14, %rsi
callq 0x4200
movsbq 0xe3a7(%rip), %r14      # 0x18018
movq %r14, %rdi
callq 0xa17e
movb %bl, 0x20(%rax)
leal 0x1(%r14), %eax
movb %al, 0xe392(%rip)       # 0x18018
callq 0xa205
leaq 0xe366(%rip), %rdi      # 0x17ff8
callq 0xf1b4
leaq 0xe34a(%rip), %rdi      # 0x17fe8
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0xf1b4
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9cc7
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x4390
movq %rbx, %rdi
callq 0x4660
// File: /workspace/github_cpp_makefile_star2_O3/lotuskip[P]yuxtapa/client/msg.cpp
// Function: (anonymous namespace)::check_repeat_msg(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned char)
bool check_repeat_msg(const string &s, const unsigned char cp)
{
	if(bottom_idx && s == msgbuffer[bottom_idx-1].text
		&& cp == msgbuffer[bottom_idx-1].cpair)
	{
		if(msgbuffer[bottom_idx-1].repeat != '+' - '1' // this value is -1
			&& ++(msgbuffer[bottom_idx-1].repeat) > 8)
			msgbuffer[bottom_idx-1].repeat = '+' - '1';
		redraw_msgs();
		last_move.update(); /* only update this! Then the next 
			message can be printed without unnecessary delay */
		return true;
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movsbq 0xe333(%rip), %rbx      # 0x18018
testq %rbx, %rbx
je 0x9d63
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %r13
decq %rbx
movq %rbx, %rdi
callq 0xa17e
cmpq %r12, 0x8(%rax)
jne 0x9d63
movq %rax, %r14
testq %r12, %r12
je 0x9d2a
movq (%r14), %rsi
movq %r13, %rdi
movq %r12, %rdx
callq 0x43a0
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
jne 0x9d65
cmpb %r15b, 0x20(%r14)
je 0x9d30
jmp 0x9d65
cmpb %r15b, 0x20(%r14)
jne 0x9d63
movb 0x21(%r14), %al
cmpb $-0x6, %al
je 0x9d4e
incb %al
movb %al, 0x21(%r14)
cmpb $0x9, %al
jl 0x9d4e
movq %rbx, %rdi
callq 0xa17e
movb $-0x6, 0x21(%rax)
callq 0xa205
leaq 0xe28e(%rip), %rdi      # 0x17fe8
callq 0xf1b4
movb $0x1, %al
jmp 0x9d65
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/lotuskip[P]yuxtapa/client/msg.cpp
// Function: (anonymous namespace)::move_msgs()
void move_msgs()
{
	if(bottom_idx)
	{
		msgbuffer.pop_front();
		msgbuffer.push_back(MsgBufferLine());
		--bottom_idx;
		last_move.update();
		for(char y = 0; y < bottom_idx/2; ++y)
			msgbuffer[y].dimmen();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
cmpb $0x0, 0xdfcf(%rip)      # 0x18018
je 0xa139
leaq 0xdea2(%rip), %rdi      # 0x17ef8
callq 0xa470
leaq -0x28(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x640f(%rip), %rdx      # 0x10479
leaq -0x38(%rbp), %rbx
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x891a
leaq -0x50(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
leaq -0x60(%rbp), %rdi
callq 0x731a
leaq -0x60(%rbp), %rsi
movw $0x0, 0x20(%rsi)
leaq 0xde53(%rip), %rdi      # 0x17ef8
callq 0x9d74
movq -0x60(%rbp), %rdi
cmpq %r15, %rdi
je 0xa0bf
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x4390
movq -0x38(%rbp), %rdi
cmpq %r14, %rdi
je 0xa0d4
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x4390
decb 0xdf3e(%rip)            # 0x18018
leaq 0xdf07(%rip), %rdi      # 0x17fe8
callq 0xf1b4
movzbl 0xdf2a(%rip), %r14d     # 0x18018
cmpb $0x2, %r14b
jl 0xa139
shrl %r14d
xorl %ebx, %ebx
movl $0x8, %r15d
movq %rbx, %rdi
callq 0xa17e
movzbl 0x20(%rax), %ecx
testb $-0x9, %cl
je 0xa131
leal -0x9(%rcx), %edx
leal -0x8(%rcx), %esi
leal -0x14(%rcx), %edi
cmpb $0x2b, %cl
movzbl %dil, %ecx
cmovbl %r15d, %ecx
cmpb $0x7, %dl
movzbl %sil, %edx
cmovael %ecx, %edx
movb %dl, 0x20(%rax)
incq %rbx
cmpq %rbx, %r14
jne 0xa0ff
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r15, %rdi
je 0xa161
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x4390
jmp 0xa161
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r14, %rdi
je 0xa176
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x4390
movq %rbx, %rdi
callq 0x4660
// File: /workspace/github_cpp_makefile_star2_O3/lotuskip[P]yuxtapa/client/msg.cpp
// Function: (anonymous namespace)::redraw_msgs()
void redraw_msgs()
{
	string tmp_str;
	for(char y = 0; y < MSG_WIN_Y-1; ++y)
	{
		if(msgbuffer[y].repeat)
		{
			tmp_str = msgbuffer[y].text;
			if(num_syms(tmp_str) > MSG_WIN_X-4) // 4: len(" [?]")
				del_syms(tmp_str, MSG_WIN_X-4);
			tmp_str += " [";
			tmp_str += char(msgbuffer[y].repeat + '1');
			tmp_str += ']';
			Base::print_str(tmp_str.c_str(), msgbuffer[y].cpair,
				0, y, MSG_WIN, true);
		}
		else
			Base::print_str(msgbuffer[y].text.c_str(), msgbuffer[y].cpair,
				0, y, MSG_WIN, true);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
xorl %ebx, %ebx
leaq -0x40(%rbp), %r14
leaq 0x640c(%rip), %r15      # 0x10644
movq %rbx, %rdi
callq 0xa17e
cmpb $0x0, 0x21(%rax)
je 0xa2a9
movq %r14, %rdi
movq %rax, %rsi
callq 0x4200
movq %r14, %rdi
callq 0xf738
cmpw $0x36, %ax
jl 0xa26c
movq %r14, %rdi
movl $0x35, %esi
callq 0xf81e
movq %r14, %rdi
movq %r15, %rsi
callq 0x46e0
movq %rbx, %rdi
callq 0xa17e
movb 0x21(%rax), %al
addb $0x31, %al
movsbl %al, %esi
movq %r14, %rdi
callq 0x4300
movq %r14, %rdi
movl $0x5d, %esi
callq 0x4300
movq %rbx, %rdi
callq 0xa17e
movq %r14, %rcx
jmp 0xa2ac
movq %rax, %rcx
movq (%rcx), %rdi
movzbl 0x20(%rax), %esi
movsbl %bl, %ecx
xorl %edx, %edx
movl $0x2, %r8d
movl $0x1, %r9d
callq 0x686d
incq %rbx
cmpq $0xe, %rbx
jne 0xa238
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0xa2eb
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x4390
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0xa310
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x4390
movq %rbx, %rdi
callq 0x4660
// File: /workspace/github_cpp_makefile_star2_O3/lotuskip[P]yuxtapa/client/msg.cpp
// Function: upd_msgs()
void upd_msgs()
{
	// add messages in avail, if any:
	if(!msgavail.empty() && reference.update() - last_add >= STAY_TIME)
	{
		if(check_repeat_msg(msgavail.front().text, msgavail.front().cpair))
			msgavail.pop_front();
		else
		{
			move_msgs();
			msgbuffer[bottom_idx] = msgavail.front();
			msgavail.pop_front();
			++bottom_idx;
			last_add.update();
			redraw_msgs();
		}
	}
	else if(reference.update() - last_move >= MOVE_FREQ)
	{
		move_msgs();
		redraw_msgs();
	}

	// clock check:
	if(reference.update() - last_second >= 1000)
	{
		if(maptime)
			--maptime;
		if(spawntime)
			--spawntime;
		redraw_clocks();
		last_second.update();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0xdc4f(%rip), %rax      # 0x17f78
cmpq 0xdc28(%rip), %rax      # 0x17f58
je 0xa380
leaq 0xdce7(%rip), %rdi      # 0x18020
callq 0xf1b4
leaq 0xdcb3(%rip), %rsi      # 0x17ff8
movq %rax, %rdi
callq 0xf1ce
cmpl $0x2ee, %eax            # imm = 0x2EE
jb 0xa380
movq 0xdbfd(%rip), %rax      # 0x17f58
movzbl 0x20(%rax), %edx
movq (%rax), %rdi
movq 0x8(%rax), %rsi
callq 0x9ccf
testb %al, %al
je 0xa3a9
leaq 0xdbd2(%rip), %rdi      # 0x17f48
callq 0xa470
jmp 0xa400
leaq 0xdc99(%rip), %rdi      # 0x18020
callq 0xf1b4
leaq 0xdc55(%rip), %rsi      # 0x17fe8
movq %rax, %rdi
callq 0xf1ce
cmpl $0xdac, %eax            # imm = 0xDAC
jb 0xa400
callq 0xa035
jmp 0xa3fb
callq 0xa035
leaq 0xdb93(%rip), %rbx      # 0x17f48
movq 0xdb9c(%rip), %r14      # 0x17f58
movsbq 0xdc54(%rip), %rdi      # 0x18018
callq 0xa17e
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x4200
movzwl 0x20(%r14), %eax
movw %ax, 0x20(%r15)
movq %rbx, %rdi
callq 0xa470
incb 0xdc29(%rip)            # 0x18018
leaq 0xdc02(%rip), %rdi      # 0x17ff8
callq 0xf1b4
callq 0xa205
leaq 0xdc19(%rip), %rdi      # 0x18020
callq 0xf1b4
leaq 0xdbf5(%rip), %rsi      # 0x18008
movq %rax, %rdi
callq 0xf1ce
cmpl $0x3e8, %eax            # imm = 0x3E8
jb 0xa464
movzwl 0xdc07(%rip), %eax      # 0x18030
testw %ax, %ax
je 0xa437
decl %eax
movw %ax, 0xdbf9(%rip)       # 0x18030
movb 0xdbf5(%rip), %al       # 0x18032
testb %al, %al
je 0xa449
decb %al
movb %al, 0xdbe9(%rip)       # 0x18032
callq 0xa4f3
leaq 0xdbb3(%rip), %rdi      # 0x18008
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xf1b4
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/lotuskip[P]yuxtapa/client/msg.cpp
// Function: (anonymous namespace)::redraw_clocks()
void redraw_clocks()
{
	unsigned short mins = maptime/60;
	unsigned short secs = maptime%60;
	string timestr = "";
	if(mins < 10)
		timestr += ' ';
	timestr += lex_cast(mins);
	timestr += ':';
	if(secs < 10)
		timestr += '0';
	timestr += lex_cast(secs);
	Base::print_str(timestr.c_str(), 7, 51, 6, STAT_WIN, true);

	timestr.clear();
	if(spawntime < 10)
		timestr += ' ';
	timestr += lex_cast(spawntime);
	Base::print_str(timestr.c_str(), 7, 54, 7, STAT_WIN, true);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movzwl 0xdb26(%rip), %r12d     # 0x18030
leaq -0x50(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x5f60(%rip), %rdx      # 0x10479
leaq -0x60(%rbp), %rdi
movq %rdx, %rsi
callq 0x891a
cmpl $0x257, %r12d           # imm = 0x257
ja 0xa53c
leaq -0x60(%rbp), %rdi
movl $0x20, %esi
callq 0x4300
imull $0x8889, %r12d, %ebx    # imm = 0x8889
shrl $0x15, %ebx
leaq -0x40(%rbp), %rdi
movl %ebx, %esi
callq 0xfcfb
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
leaq -0x60(%rbp), %rdi
callq 0x4120
leaq -0x30(%rbp), %r15
movq -0x10(%r15), %rdi
cmpq %r15, %rdi
je 0xa57b
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x4390
leaq -0x60(%rbp), %rdi
movl $0x3a, %esi
callq 0x4300
imull $0x3c, %ebx, %eax
subl %eax, %r12d
cmpw $0x9, %r12w
ja 0xa5a4
leaq -0x60(%rbp), %rdi
movl $0x30, %esi
callq 0x4300
movzwl %r12w, %esi
leaq -0x40(%rbp), %rdi
callq 0xfcfb
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
leaq -0x60(%rbp), %rdi
callq 0x4120
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0xa5d7
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x4390
movq -0x60(%rbp), %rdi
movl $0x7, %esi
movl $0x33, %edx
movl $0x6, %ecx
xorl %r8d, %r8d
movl $0x1, %r9d
callq 0x686d
movq $0x0, -0x58(%rbp)
movq -0x60(%rbp), %rax
movb $0x0, (%rax)
movb 0xda25(%rip), %al       # 0x18032
cmpb $0x9, %al
ja 0xa625
leaq -0x60(%rbp), %rdi
movl $0x20, %esi
callq 0x4300
movb 0xda0d(%rip), %al       # 0x18032
movzbl %al, %esi
leaq -0x40(%rbp), %rdi
callq 0xfcfb
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
leaq -0x60(%rbp), %rdi
callq 0x4120
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0xa657
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x4390
movq -0x60(%rbp), %rdi
movl $0x7, %esi
movl $0x36, %edx
movl $0x7, %ecx
xorl %r8d, %r8d
movl $0x1, %r9d
callq 0x686d
movq -0x60(%rbp), %rdi
cmpq %r14, %rdi
je 0xa68d
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x4390
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0xa69e
jmp 0xa6ce
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
jne 0xa6be
jmp 0xa6d1
jmp 0xa6ce
movq %rax, %rbx
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa6d1
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x4390
jmp 0xa6d1
jmp 0xa6ce
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r14, %rdi
je 0xa6e6
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x4390
movq %rbx, %rdi
callq 0x4660
// File: /workspace/github_cpp_makefile_star2_O3/lotuskip[P]yuxtapa/client/msg.cpp
// Function: (anonymous namespace)::redraw_chat()
void redraw_chat()
{
	char num = min(int(Base::num_chat_lines_to_show()), int(num_chat_lines - chat_top));
	for(char i = 0; i < num; ++i)
	{
		Base::incr_print_start(0, i, CHAT_WIN);
		Base::incr_print(chatbuffer[chat_top+i].speaker.c_str(), 3, CHAT_WIN);
		Base::incr_print(team_ind[chatbuffer[chat_top+i].team],
			team_colour[chatbuffer[chat_top+i].team], CHAT_WIN);
		Base::incr_print(chatbuffer[chat_top+i].text.c_str(), 7, CHAT_WIN);
		Base::incr_print_end(CHAT_WIN, true);
	}
	// if necessary, print indicators of there being more messages:
	if(chat_top)
		Base::less_chat_ind();
	if(chat_top + num < num_chat_lines)
		Base::more_chat_ind();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x6b29
movzbl %al, %ecx
movswl 0xd0b6(%rip), %edx      # 0x18034
movswl 0xd0b1(%rip), %eax      # 0x18036
subl %eax, %edx
cmpl %ecx, %edx
cmovgel %ecx, %edx
movsbl %dl, %r14d
testl %r14d, %r14d
jle 0xb051
xorl %r13d, %r13d
leaq 0xbd8d(%rip), %r15      # 0x16d30
leaq 0x56d2(%rip), %r12      # 0x1067c
xorl %ebx, %ebx
movsbl %bl, %ebx
xorl %edi, %edi
movl %ebx, %esi
movl $0x1, %edx
callq 0x69d0
movswq 0xd071(%rip), %rdi      # 0x18036
movslq %r13d, %r13
addq %r13, %rdi
callq 0xb294
movq 0x20(%rax), %rdi
movl $0x3, %esi
movl $0x1, %edx
callq 0x69eb
movswq 0xd04b(%rip), %rdi      # 0x18036
addq %r13, %rdi
callq 0xb294
movzbl 0x40(%rax), %eax
movq (%r15,%rax,8), %rdi
movzbl (%rax,%r12), %esi
movl $0x1, %edx
callq 0x69eb
movswq 0xd024(%rip), %rdi      # 0x18036
addq %r13, %rdi
callq 0xb294
movq (%rax), %rdi
movl $0x7, %esi
movl $0x1, %edx
callq 0x69eb
movl $0x1, %edi
movl $0x1, %esi
callq 0x6a26
incb %bl
movsbl %bl, %r13d
cmpl %r13d, %r14d
jg 0xafac
movzwl 0xcfe5(%rip), %eax      # 0x18036
testw %ax, %ax
je 0xb064
callq 0x6ac8
movswl 0xcfd4(%rip), %eax      # 0x18036
jmp 0xb066
xorl %eax, %eax
addl %eax, %r14d
movswl 0xcfc4(%rip), %eax      # 0x18034
addq $0x8, %rsp
cmpl %eax, %r14d
jge 0xb088
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6a5f
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/lotuskip[P]yuxtapa/client/msg.cpp
// Function: clocksync(unsigned short, unsigned char)
void clocksync(const unsigned short t, const unsigned char spawn)
{
	maptime = t;
	spawntime = spawn;
	redraw_clocks();
	last_second.update();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movw %di, 0xcf36(%rip)       # 0x18030
movb %sil, 0xcf31(%rip)      # 0x18032
callq 0xa4f3
leaq 0xcefb(%rip), %rdi      # 0x18008
popq %rbp
jmp 0xf1b4
nop
// File: /workspace/github_cpp_makefile_star2_O3/lotuskip[P]yuxtapa/client/network.cpp
// Function: Network::disconnect()
void Network::disconnect()
{
	send_buffer.clear();
	send_buffer.add((unsigned char)MID_QUIT);
	send_buffer.add(cur_id);
	do_send();
	freeaddrinfo(servinfo);
	close(s_me);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0xc51d(%rip), %rbx      # 0x18978
movq %rbx, %rdi
callq 0xf218
movq %rbx, %rdi
movl $0x2, %esi
callq 0xf22c
movzwl 0xcde1(%rip), %esi      # 0x19258
movq %rbx, %rdi
callq 0xf240
movl 0xcdbb(%rip), %edi      # 0x19240
movswq 0xc4f3(%rip), %rdx      # 0x18980
movq 0xcda4(%rip), %rax      # 0x19238
movq 0x18(%rax), %r8
movl 0x10(%rax), %r9d
leaq 0xc4df(%rip), %rsi      # 0x18982
xorl %ecx, %ecx
callq 0x4060
movq 0xcd7f(%rip), %rdi      # 0x19230
callq 0x44d0
movl 0xcd84(%rip), %edi      # 0x19240
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4700
// File: /workspace/github_cpp_makefile_star2_O3/lotuskip[P]yuxtapa/client/network.cpp
// Function: Network::send_action(unsigned char, unsigned char, unsigned char)
void Network::send_action(const unsigned char xncode, const unsigned char var1, const unsigned char var2)
{
	if(Config::act_per_turn())
	{
		if(axn_counter)
			return;
	}
	else if(reftimer.update() - last_sent_axn < 50) // every 50 ms at most?
		return;
	// If here, may send:
	send_buffer.clear();
	send_buffer.add((unsigned char)MID_TAKE_ACTION);
	send_buffer.add(cur_id);
	send_buffer.add(curturn);
	send_buffer.add(axn_counter);
	send_buffer.add(xncode);
	if(xncode == XN_MOVE || xncode == XN_SHOOT || xncode == XN_ZAP
		|| xncode == XN_CIRCLE_ATTACK || xncode == XN_HEAL || xncode == XN_MINE)
	{
		send_buffer.add(static_cast<unsigned char>(var1));
		if(xncode == XN_SHOOT)
			send_buffer.add(static_cast<unsigned char>(var2));
	}
	do_send();
	++axn_counter;
	last_sent_axn.update();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %r15d
movl %edi, %r14d
callq 0xe03b
testb %al, %al
je 0xc895
cmpb $0x0, 0xc9d8(%rip)      # 0x1925c
je 0xc8b5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xc9c4(%rip), %rdi      # 0x19260
callq 0xf1b4
leaq 0xc9a0(%rip), %rsi      # 0x19248
movq %rax, %rdi
callq 0xf1ce
cmpl $0x32, %eax
jb 0xc886
leaq 0xc0bc(%rip), %r12      # 0x18978
movq %r12, %rdi
callq 0xf218
movq %r12, %rdi
movl $0x7, %esi
callq 0xf22c
movzwl 0xc980(%rip), %esi      # 0x19258
movq %r12, %rdi
callq 0xf240
movzwl 0xc973(%rip), %esi      # 0x1925a
movq %r12, %rdi
callq 0xf240
movzbl 0xc966(%rip), %esi      # 0x1925c
movq %r12, %rdi
callq 0xf22c
movzbl %r14b, %r13d
movq %r12, %rdi
movl %r13d, %esi
callq 0xf22c
cmpb $0xc, %r13b
ja 0xc943
movl $0x1cb0, %eax           # imm = 0x1CB0
btl %r13d, %eax
jae 0xc943
movzbl %r15b, %esi
leaq 0xc04f(%rip), %rdi      # 0x18978
callq 0xf22c
cmpb $0x5, %r14b
jne 0xc943
movzbl %bl, %esi
leaq 0xc03a(%rip), %rdi      # 0x18978
callq 0xf22c
movl 0xc8f7(%rip), %edi      # 0x19240
movswq 0xc02f(%rip), %rdx      # 0x18980
movq 0xc8e0(%rip), %rax      # 0x19238
movq 0x18(%rax), %r8
movl 0x10(%rax), %r9d
leaq 0xc01b(%rip), %rsi      # 0x18982
xorl %ecx, %ecx
callq 0x4060
incb 0xc8e8(%rip)            # 0x1925c
leaq 0xc8cd(%rip), %rdi      # 0x19248
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xf1b4
// File: /workspace/github_cpp_makefile_star2_O3/lotuskip[P]yuxtapa/client/network.cpp
// Function: Network::send_line(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
void Network::send_line(const string &s, const bool chat)
{
	send_buffer.clear();
	if(chat)
		send_buffer.add((unsigned char)MID_SAY_CHAT);
	else
		send_buffer.add((unsigned char)MID_SAY_ALOUD);
	send_buffer.add(cur_id);
	if(s.size() <= MAXIMUM_STR_LEN)	
		send_buffer.add(s);
	else
		send_buffer.add(s.substr(0, low_bound(s, MAXIMUM_STR_LEN)));
	do_send();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %esi, %r14d
movq %rdi, %rbx
leaq 0xbfd0(%rip), %r15      # 0x18978
movq %r15, %rdi
callq 0xf218
xorb $0x1, %r14b
movzbl %r14b, %eax
leal 0x4(,%rax,2), %esi
movq %r15, %rdi
callq 0xf22c
movzwl 0xc88a(%rip), %esi      # 0x19258
movq %r15, %rdi
callq 0xf240
cmpq $0x15e, 0x8(%rbx)       # imm = 0x15E
ja 0xc9f1
leaq 0xbf91(%rip), %rdi      # 0x18978
movq %rbx, %rsi
callq 0xf26a
jmp 0xca3b
movq %rbx, %rdi
movl $0x15e, %esi            # imm = 0x15E
callq 0xf907
movswq %ax, %rcx
leaq -0x38(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x43b0
leaq 0xbf5e(%rip), %rdi      # 0x18978
movq %r14, %rsi
callq 0xf26a
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xca3b
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x4390
movl 0xc7ff(%rip), %edi      # 0x19240
movswq 0xbf37(%rip), %rdx      # 0x18980
movq 0xc7e8(%rip), %rax      # 0x19238
movq 0x18(%rax), %r8
movl 0x10(%rax), %r9d
leaq 0xbf23(%rip), %rsi      # 0x18982
xorl %ecx, %ecx
callq 0x4060
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xca8d
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x4390
movq %rbx, %rdi
callq 0x4660
// File: /workspace/github_cpp_makefile_star2_O3/lotuskip[P]yuxtapa/client/network.cpp
// Function: Network::send_spawn(unsigned char)
void Network::send_spawn(const unsigned char newclass)
{
	send_buffer.clear();
	send_buffer.add((unsigned char)MID_SPAWN_AXN);
	send_buffer.add(cur_id);
	send_buffer.add(newclass);
	do_send();	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
leaq 0xbed3(%rip), %r14      # 0x18978
movq %r14, %rdi
callq 0xf218
movq %r14, %rdi
movl $0x8, %esi
callq 0xf22c
movzwl 0xc797(%rip), %esi      # 0x19258
movq %r14, %rdi
callq 0xf240
movq %r14, %rdi
movl %ebx, %esi
callq 0xf22c
movl 0xc767(%rip), %edi      # 0x19240
movswq 0xbe9f(%rip), %rdx      # 0x18980
movq 0xc750(%rip), %rax      # 0x19238
movq 0x18(%rax), %r8
movl 0x10(%rax), %r9d
leaq 0xbe8b(%rip), %rsi      # 0x18982
xorl %ecx, %ecx
popq %rbx
popq %r14
popq %rbp
jmp 0x4060
// File: /workspace/github_cpp_makefile_star2_O3/lotuskip[P]yuxtapa/client/network.cpp
// Function: Network::send_switch()
void Network::send_switch()
{
	send_buffer.clear();
	send_buffer.add((unsigned char)MID_TEAM_SWITCH);
	send_buffer.add(cur_id);
	do_send();	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0xbe69(%rip), %rbx      # 0x18978
movq %rbx, %rdi
callq 0xf218
movq %rbx, %rdi
movl $0x9, %esi
callq 0xf22c
movzwl 0xc72d(%rip), %esi      # 0x19258
movq %rbx, %rdi
callq 0xf240
movl 0xc707(%rip), %edi      # 0x19240
movswq 0xbe3f(%rip), %rdx      # 0x18980
movq 0xc6f0(%rip), %rax      # 0x19238
movq 0x18(%rax), %r8
movl 0x10(%rax), %r9d
leaq 0xbe2b(%rip), %rsi      # 0x18982
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4060
// File: /workspace/github_cpp_makefile_star2_O3/lotuskip[P]yuxtapa/client/network.cpp
// Function: Network::send_teami_req()
void Network::send_teami_req()
{
	send_buffer.clear();
	send_buffer.add((unsigned char)MID_TEAM_INFO);
	send_buffer.add(cur_id);
	do_send();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0xbe07(%rip), %rbx      # 0x18978
movq %rbx, %rdi
callq 0xf218
movq %rbx, %rdi
movl $0x5, %esi
callq 0xf22c
movzwl 0xc6cb(%rip), %esi      # 0x19258
movq %rbx, %rdi
callq 0xf240
movl 0xc6a5(%rip), %edi      # 0x19240
movswq 0xbddd(%rip), %rdx      # 0x18980
movq 0xc68e(%rip), %rax      # 0x19238
movq 0x18(%rax), %r8
movl 0x10(%rax), %r9d
leaq 0xbdc9(%rip), %rsi      # 0x18982
xorl %ecx, %ecx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4060
// File: /workspace/github_cpp_makefile_star2_O3/lotuskip[P]yuxtapa/client/settings.cpp
// Function: Config::save_msg_memory()
void Config::save_msg_memory()
{
	ofstream cmfile((confdir_str + "chatmemory").c_str());
	if(stored_msgs)
	{
		if(!cmfile)
			cerr << "Warning: failed to save chat memory." << endl;
		else
		{
			while(prev_strs.size() > (unsigned int)stored_msgs)
				prev_strs.erase(prev_strs.begin());
			while(!prev_strs.empty())
			{
				cmfile << prev_strs.front() << endl;
				prev_strs.erase(prev_strs.begin());
			}
		}
	}
	// else opening the file causes it to be emptied
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
leaq -0x28(%rbp), %r14
movq %r14, -0x10(%r14)
movq 0xb719(%rip), %rsi      # 0x19540
movq 0xb71a(%rip), %rdx      # 0x19548
addq %rsi, %rdx
leaq -0x38(%rbp), %rbx
movq %rbx, %rdi
callq 0x731a
leaq 0x2d2e(%rip), %rsi      # 0x10b72
movq %rbx, %rdi
callq 0x46e0
movq -0x38(%rbp), %rsi
leaq -0x238(%rbp), %rdi
movl $0x10, %edx
callq 0x43e0
movq -0x38(%rbp), %rdi
cmpq %r14, %rdi
je 0xde76
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x4390
cmpw $0x0, 0x954e(%rip)      # 0x173cc
je 0xdedf
movq -0x238(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x218(%rbp,%rax)
je 0xdf23
movq 0x9150(%rip), %rbx      # 0x16ff0
leaq 0x2cd6(%rip), %rsi      # 0x10b7d
movl $0x24, %edx
movq %rbx, %rdi
callq 0x4410
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x4360
movsbl %al, %esi
movq 0x911e(%rip), %rdi      # 0x16ff0
callq 0x4040
movq %rax, %rdi
callq 0x4250
movq 0x90d2(%rip), %rax      # 0x16fb8
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq -0x230(%rbp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, -0x238(%rbp,%rcx)
callq 0x42f0
leaq -0x140(%rbp), %rdi
callq 0x4140
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x9f5e(%rip), %rbx      # 0x17e88
movq (%rbx), %rsi
movq 0x8(%rbx), %rax
subq %rsi, %rax
sarq $0x5, %rax
movswq 0x948c(%rip), %rcx      # 0x173cc
movl %ecx, %ecx
cmpq %rcx, %rax
jbe 0xdf51
movq %rbx, %rdi
callq 0x97a0
jmp 0xdf2a
leaq -0x238(%rbp), %r14
movq (%rbx), %rax
cmpq 0x8(%rbx), %rax
je 0xdedf
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %r14, %rdi
callq 0x4410
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x4360
movsbl %al, %esi
movq %r15, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x4250
movq (%rbx), %rsi
movq %rbx, %rdi
callq 0x97a0
jmp 0xdf58
jmp 0xdfad
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r14, %rdi
je 0xdfdc
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x4390
jmp 0xdfdc
jmp 0xdfcd
jmp 0xdfcd
jmp 0xdfcd
movq %rax, %rbx
leaq -0x238(%rbp), %rdi
callq 0x4540
movq %rbx, %rdi
callq 0x4660
// File: /workspace/github_cpp_makefile_star2_O3/lotuskip[P]yuxtapa/client/settings.cpp
// Function: Config::do_aliasing(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void Config::do_aliasing(string &s)
{
	size_t i;
	for(map<string,string>::iterator it = aliases.begin(); it != aliases.end(); ++it)
	{
		if((i = s.find(it->first)) != string::npos)
		{
			s.replace(i, it->first.size(), it->second);
			break;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0xb4bf(%rip), %r14      # 0x19578
leaq 0xb4a8(%rip), %r15      # 0x19568
cmpq %r15, %r14
je 0xe0f0
movq %rdi, %rbx
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rcx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x4650
cmpq $-0x1, %rax
jne 0xe0fb
movq %r14, %rdi
callq 0x4270
movq %rax, %r14
cmpq %r15, %rax
jne 0xe0c8
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x28(%r14), %rdx
movq 0x40(%r14), %rcx
movq 0x48(%r14), %r8
movq %rbx, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4400
// File: /workspace/github_cpp_makefile_star2_O3/lotuskip[P]yuxtapa/client/view.cpp
// Function: (anonymous namespace)::draw_titles()
void draw_titles()
{
	char len;
	char *pos = &(viewbuffer[VIEWSIZE*VIEWSIZE*2+1]);
	char x, y;
	char syms;
	for(char num = viewbuffer[VIEWSIZE*VIEWSIZE*2]; num > 0; --num)
	{
		y = *(pos+1); // pos&pos+1 are x/y pair, string begins at pos+2.
		len = strlen(pos+2);
		// If we are alive, don't draw any title coming to the center (that
		// would be our OWN title)
		if(*pos != VIEWSIZE/2 || y != VIEWSIZE/2 || !ClassCPV::im_alive())
		{
			// x-position might need shifting so the string doesn't go over the edge:
			syms = num_syms(string(pos+2));
			x = *pos - syms/2;
			if(x < 0)
				x = 0;
			else if(x + syms > VIEWSIZE)
				x = VIEWSIZE - syms;
			Base::print_str(pos+2, TITLE_CPAIR, x, y, VIEW_WIN);
		}
		pos += len+3; // lenght of string + '\0' + 2 chars
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movb 0xb13c(%rip), %r13b     # 0x19ae2
testb %r13b, %r13b
jle 0xeaa2
leaq -0x48(%rbp), %r12
incb %r13b
leaq 0xb126(%rip), %rbx      # 0x19ae3
movb 0x1(%rbx), %r15b
leaq 0x2(%rbx), %rdi
movq %rdi, -0x60(%rbp)
callq 0x41b0
movq %rax, %r14
movb (%rbx), %al
xorb $0xb, %al
movb %r15b, -0x29(%rbp)
xorb $0xb, %r15b
orb %al, %r15b
jne 0xe9ef
callq 0x786d
testb %al, %al
jne 0xea8a
movq %r14, -0x38(%rbp)
movq %r12, -0x58(%rbp)
movq -0x60(%rbp), %r15
movq %r15, %rdi
callq 0x41b0
leaq (%rax,%r15), %rdx
leaq -0x58(%rbp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x891a
movq %r14, %rdi
callq 0xf738
movl %eax, %r14d
movq -0x58(%rbp), %rdi
cmpq %r12, %rdi
je 0xea36
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x4390
movb (%rbx), %al
movl %r14d, %ecx
shrb $0x7, %cl
addb %r14b, %cl
sarb %cl
subb %cl, %al
js 0xea63
movzwl %r14w, %ecx
movsbl %cl, %ecx
movzbl %al, %edx
addl %edx, %ecx
movb $0x17, %al
subb %r14b, %al
cmpl $0x18, %ecx
movzbl %al, %eax
cmovll %edx, %eax
jmp 0xea65
xorl %eax, %eax
leaq -0x48(%rbp), %r12
movq -0x38(%rbp), %r14
movsbl %al, %edx
movsbl -0x29(%rbp), %ecx
movq %r15, %rdi
movl $0x6a, %esi
movl $0x3, %r8d
xorl %r9d, %r9d
callq 0x686d
movsbq %r14b, %rax
addq %rax, %rbx
addq $0x3, %rbx
decb %r13b
cmpb $0x1, %r13b
jg 0xe9bd
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x58(%rbp), %rdi
cmpq %r12, %rdi
je 0xeac9
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x4390
movq %rbx, %rdi
callq 0x4660
// File: /workspace/github_cpp_makefile_star2_O3/lotuskip[P]yuxtapa/client/view.cpp
// Function: diff_titles()
void diff_titles()
{
	// cf. "draw_titles()"
	char *pos = &(viewbuffer[VIEWSIZE*VIEWSIZE*2+1]);
	string s = "";
	for(char num = viewbuffer[VIEWSIZE*VIEWSIZE*2]; num > 0; --num)
	{
		if(*pos != VIEWSIZE/2 || *(pos+1) != VIEWSIZE/2 || !ClassCPV::im_alive())
		{
			s += (pos+2);
			s += ", ";
		}
		pos += strlen(pos+2)+3;
	}
	if(!s.empty())
		s.erase(s.size()-2);
	s.insert(0, "Titles: ");
	add_to_chat(s, "", T_NO_TEAM);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
leaq -0x38(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x1675(%rip), %rdx      # 0x10479
leaq -0x48(%rbp), %rdi
movq %rdx, %rsi
callq 0x891a
movb 0xaccb(%rip), %r12b     # 0x19ae2
testb %r12b, %r12b
jle 0xee78
incb %r12b
leaq 0xacbd(%rip), %r13      # 0x19ae3
leaq -0x48(%rbp), %rbx
leaq 0x1d72(%rip), %r14      # 0x10ba3
cmpb $0xb, (%r13)
jne 0xee48
cmpb $0xb, 0x1(%r13)
jne 0xee48
callq 0x786d
testb %al, %al
jne 0xee5f
leaq 0x2(%r13), %rsi
movq %rbx, %rdi
callq 0x46e0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x46e0
leaq 0x2(%r13), %rdi
callq 0x41b0
addq %rax, %r13
addq $0x3, %r13
decb %r12b
cmpb $0x1, %r12b
jg 0xee31
movq -0x40(%rbp), %rax
testq %rax, %rax
je 0xee9b
leaq -0x2(%rax), %rdx
cmpq $0x1, %rax
je 0xef1b
movq %rdx, -0x40(%rbp)
movq -0x48(%rbp), %rax
movb $0x0, (%rax,%rdx)
leaq 0x1d04(%rip), %rcx      # 0x10ba6
leaq -0x48(%rbp), %rdi
movl $0x8, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x4400
leaq -0x58(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x15b5(%rip), %rdx      # 0x10479
leaq -0x68(%rbp), %rdi
movq %rdx, %rsi
callq 0x891a
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
movl $0x3, %edx
callq 0xa6ee
movq -0x68(%rbp), %rdi
cmpq %r14, %rdi
je 0xeef7
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x4390
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0xef0c
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x4390
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1cab(%rip), %rdi      # 0x10bcd
leaq 0x1c90(%rip), %rsi      # 0x10bb9
movl $0x1, %ecx
xorl %eax, %eax
callq 0x4560
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r14, %rdi
je 0xef56
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x4390
jmp 0xef56
jmp 0xef53
jmp 0xef53
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0xef6b
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x4390
movq %rbx, %rdi
callq 0x4660
// File: /workspace/github_cpp_makefile_star2_O3/lotuskip[P]yuxtapa/common/netutils.cpp
// Function: SerialBuffer::add(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void SerialBuffer::add(const string &str)
{
	copy(str.begin(), str.end(), pos);
	pos += str.size();
	*pos = '\0';
	++pos;
	num += str.size()+1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rdx
testq %rdx, %rdx
je 0xf291
movq (%r14), %rsi
movq (%rbx), %rdi
callq 0x4620
movq 0x8(%r14), %rax
jmp 0xf293
xorl %eax, %eax
movq (%rbx), %rcx
leaq (%rcx,%rax), %rdx
movq %rdx, (%rbx)
movb $0x0, (%rcx,%rax)
incq (%rbx)
movzwl 0x8(%r14), %eax
addw 0x8(%rbx), %ax
incl %eax
movw %ax, 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/lotuskip[P]yuxtapa/common/netutils.cpp
// Function: SerialBuffer::write_compressed(char*, unsigned short)
void SerialBuffer::write_compressed(char *buffer, const unsigned short len)
{
	uLongf res_size = BUFFER_SIZE; // actually this is not how much room there is, but
	// we'll never run out of room here anyway.

	// leave room in the beginning for the size short
	compress((Bytef*)(pos+2), &res_size, (Bytef*)buffer, len);
	add((unsigned short)res_size); //NOTE: pos has not been moved, so this writes right before the compressed data
	pos += res_size;
	num += res_size;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rax
movq %rdi, %rbx
leaq -0x18(%rbp), %r14
movq $0x800, (%r14)          # imm = 0x800
movq (%rdi), %rdi
addq $0x2, %rdi
movl %edx, %ecx
movq %r14, %rsi
movq %rax, %rdx
callq 0x40c0
movzwl (%r14), %eax
rolw $0x8, %ax
movq (%rbx), %rcx
movb %al, (%rcx)
movq (%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, (%rbx)
incw 0x8(%rbx)
movb %ah, 0x1(%rcx)
movq (%rbx), %rax
movq (%r14), %rcx
movzwl 0x8(%rbx), %edx
addw %cx, %dx
addq %rcx, %rax
incq %rax
movq %rax, (%rbx)
incl %edx
movw %dx, 0x8(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop