LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/lotuskip[P]yuxtapa/client/base.cpp
// Function: (anonymous namespace)::update_screen_size(int)
void update_screen_size(const int sig)
{
	signal(SIGWINCH, SIG_IGN);
	endwin();
	refresh();
	signal(SIGWINCH, update_screen_size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
pushq $0x1c
popq %rbx
pushq $0x1
popq %rsi
movl %ebx, %edi
callq 0x4450
callq 0x4690
callq 0x40c0
leaq -0x24(%rip), %rsi       # 0x6111
movl %ebx, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4450
// File: /workspace/github_cpp_makefile_star2_O2/lotuskip[P]yuxtapa/client/base.cpp
// Function: Base::deinit_ncurses()
void Base::deinit_ncurses()
{
	int i;
	if(colmode == CM_FULL)
	{
		// restore original colours: (this gives a nice shutdown "animation", too)
		for(i = 0; i < MAX_PREDEF_COLOUR-BASE_COLOURS; ++i)
			init_color(i+BASE_COLOURS, term_colours[3*i], term_colours[3*i+1],
				term_colours[3*i+2]);
		delete[] term_colours;
	}
	for(i = 0; i < MAX_WIN; ++i)
		delwin(windows[i]);
	echo();
	endwin();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
cmpl $0x0, 0x1080c(%rip)     # 0x1695c
jne 0x619e
pushq $0x4
popq %r14
movw $0x10, %bx
cmpq $0x184, %r14            # imm = 0x184
je 0x618d
movq 0x107f6(%rip), %rax     # 0x16960
movswl -0x4(%rax,%r14), %esi
movswl -0x2(%rax,%r14), %edx
movswl (%rax,%r14), %ecx
movswl %bx, %ebx
movl %ebx, %edi
callq 0x4580
addq $0x6, %r14
incl %ebx
jmp 0x615a
movq 0x107cc(%rip), %rdi     # 0x16960
testq %rdi, %rdi
je 0x619e
callq 0x44d0
xorl %ebx, %ebx
leaq 0x107c9(%rip), %r14     # 0x16970
cmpq $0x20, %rbx
je 0x61bc
movq (%rbx,%r14), %rdi
callq 0x43d0
addq $0x8, %rbx
jmp 0x61a7
callq 0x4410
popq %rbx
popq %r14
popq %rbp
jmp 0x4690
// File: /workspace/github_cpp_makefile_star2_O2/lotuskip[P]yuxtapa/client/base.cpp
// Function: Base::print_str(char const*, unsigned char, char, char, e_Win, bool)
void Base::print_str(const char *cs, const unsigned char cpair, const char x,
	const char y, const e_Win targetwin, const bool cteol)
{
	wmove(windows[targetwin], y, x);
	change_colour(windows[targetwin], cpair);
	waddstr(windows[targetwin], cs);
	if(cteol)
		wclrtoeol(windows[targetwin]);
	wrefresh(windows[targetwin]);
	return_cursor(cursor_in_view);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %esi, %r14d
movq %rdi, %r15
movl %r8d, %r12d
leaq 0x10785(%rip), %r13     # 0x16970
movq (%r13,%r12,8), %rdi
movl %ecx, %esi
callq 0x4250
movq (%r13,%r12,8), %rdi
movl %r14d, %esi
callq 0x6249
movq (%r13,%r12,8), %rdi
pushq $-0x1
popq %rdx
movq %r15, %rsi
callq 0x4670
testl %ebx, %ebx
je 0x6222
movq (%r13,%r12,8), %rdi
callq 0x4510
movq (%r13,%r12,8), %rdi
callq 0x4420
movzbl 0x1075d(%rip), %edi     # 0x16990
xorl $0x1, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x62da
// File: /workspace/github_cpp_makefile_star2_O2/lotuskip[P]yuxtapa/client/base.cpp
// Function: (anonymous namespace)::change_colour(_win_st*, unsigned char)
void change_colour(WINDOW* const w, unsigned char cpair)
{
	if(colmode != CM_FEW)
	{
		if(cpair >= 8 && cpair <= 15) // make second 8 base colours "light"
			wattrset(w, A_BOLD|COLOR_PAIR(cpair));
		else
			wattrset(w, COLOR_PAIR(cpair));
	}
	else
	{
		// Reduce the colours to the base 16:
		if(cpair >= BASE_COLOURS)
		{
			if(cpair < C_BG_HEAL)
				cpair = col_remap[cpair - BASE_COLOURS]; // (and goto set_colour)
			else // background is not black
			{
				// check the cases that require light foreground:
				if(cpair == C_BROWN_ON_TRAP || cpair == C_YELLOW_ON_TRAP
					|| cpair == C_GREEN_ON_POIS || cpair == C_RED_ON_HIT
					|| cpair == C_BLUE_ON_HEAL)
					wattrset(w, (A_BOLD
						| (COLOR_PAIR(cpair - C_BG_HEAL + BASE_COLOURS))));
				else
					wattrset(w, COLOR_PAIR(cpair - C_BG_HEAL + BASE_COLOURS));
				return;
			}
		}
		// set_colour:
		if(cpair >= BASE_COLOURS/2)
			wattrset(w, (A_BOLD | (COLOR_PAIR(cpair))));
		else
			wattrset(w, COLOR_PAIR(cpair));
	} // only few colours
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x2, 0x10708(%rip)     # 0x1695c
jne 0x6274
cmpb $0x10, %sil
jb 0x628a
cmpb $0x42, %sil
ja 0x629d
addl $-0x10, %esi
leaq 0x8084(%rip), %rax      # 0xe2f0
movb (%rsi,%rax), %cl
movzbl %cl, %esi
jmp 0x628c
movl %esi, %ecx
andb $-0x8, %cl
shll $0x8, %esi
leal 0x200000(%rsi), %eax
cmpb $0x8, %cl
cmovnel %esi, %eax
jmp 0x62c4
movl %esi, %ecx
shll $0x8, %esi
leal 0x200000(%rsi), %eax
cmpb $0x8, %cl
cmovbl %esi, %eax
jmp 0x62c4
movzbl %sil, %eax
addl $-0x47, %eax
cmpl $0x1d, %eax
ja 0x62cc
movl $0x20000621, %ecx       # imm = 0x20000621
btl %eax, %ecx
jae 0x62cc
shll $0x8, %esi
addl $0xcd00, %esi           # imm = 0xCD00
movzwl %si, %eax
orl $0x200000, %eax         # imm = 0x200000
movl %eax, %esi
popq %rbp
jmp 0x41e0
shll $0x8, %esi
addl $0xcd00, %esi           # imm = 0xCD00
movzwl %si, %eax
jmp 0x62c4
// File: /workspace/github_cpp_makefile_star2_O2/lotuskip[P]yuxtapa/client/base.cpp
// Function: (anonymous namespace)::return_cursor(bool)
void return_cursor(const bool def)
{
	if(def) // cursor in the view
	{
		wmove(windows[VIEW_WIN], VIEWSIZE/2, VIEWSIZE/2);
		wrefresh(windows[VIEW_WIN]);
	}
	else
	{
		wmove(windows[MSG_WIN], MSG_WIN_Y-1, cursor_x);
		wrefresh(windows[MSG_WIN]);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testl %edi, %edi
je 0x62f9
leaq 0x1069d(%rip), %rbx     # 0x16988
movq 0x10696(%rip), %rdi     # 0x16988
pushq $0xb
popq %rdx
movl %edx, %esi
jmp 0x6311
leaq 0x10680(%rip), %rbx     # 0x16980
movq 0x10679(%rip), %rdi     # 0x16980
movsbl 0x10683(%rip), %edx     # 0x16991
pushq $0xe
popq %rsi
callq 0x4250
movq (%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4420
// File: /workspace/github_cpp_makefile_star2_O2/lotuskip[P]yuxtapa/client/base.cpp
// Function: Base::incr_print_end(e_Win, bool)
void Base::incr_print_end(const e_Win targetwin, const bool cteol)
{
	if(cteol)
		wclrtoeol(windows[targetwin]);
	wrefresh(windows[targetwin]);
	return_cursor(cursor_in_view);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
leaq 0x105e8(%rip), %r14     # 0x16970
testl %esi, %esi
je 0x6395
movq (%r14,%rbx,8), %rdi
callq 0x4510
movq (%r14,%rbx,8), %rdi
callq 0x4420
movzbl 0x105eb(%rip), %edi     # 0x16990
xorl $0x1, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x62da
// File: /workspace/github_cpp_makefile_star2_O2/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 0x105bc(%rip), %rdi     # 0x16978
movzwl 0x10595(%rip), %esi     # 0x16958
addl $-0x18, %esi
movzwl 0x1058d(%rip), %edx     # 0x1695a
addl $-0x4, %edx
callq 0x4250
movq 0x1059c(%rip), %rdi     # 0x16978
pushq $0x4
popq %rsi
callq 0x6249
movq 0x1058d(%rip), %rdi     # 0x16978
leaq 0x7c74(%rip), %rsi      # 0xe066
pushq $-0x1
popq %rdx
callq 0x4670
movq 0x10577(%rip), %rdi     # 0x16978
callq 0x4420
movzbl 0x10583(%rip), %edi     # 0x16990
xorl $0x1, %edi
popq %rbp
jmp 0x62da
// File: /workspace/github_cpp_makefile_star2_O2/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 0x10557(%rip), %rdi     # 0x16978
movzwl 0x10532(%rip), %edx     # 0x1695a
addl $-0x4, %edx
xorl %esi, %esi
callq 0x4250
movq 0x1053f(%rip), %rdi     # 0x16978
pushq $0x4
popq %rsi
callq 0x6249
movq 0x10530(%rip), %rdi     # 0x16978
leaq 0x7c1b(%rip), %rsi      # 0xe06a
pushq $-0x1
popq %rdx
callq 0x4670
movq 0x1051a(%rip), %rdi     # 0x16978
callq 0x4420
movzbl 0x10526(%rip), %edi     # 0x16990
xorl $0x1, %edi
popq %rbp
jmp 0x62da
// File: /workspace/github_cpp_makefile_star2_O2/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 0x104e3(%rip), %rdi     # 0x16988
cmpl $0x17, %r14d
je 0x64ef
movl %r14d, %esi
xorl %edx, %edx
callq 0x4250
xorl %r15d, %r15d
cmpb $0x2e, %r15b
je 0x64e7
movq 0x104c3(%rip), %rdi     # 0x16988
movzbl (%rbx,%r15), %esi
callq 0x6249
movq 0x104b2(%rip), %rdi     # 0x16988
movsbl 0x1(%rbx,%r15), %esi
callq 0x45b0
addq $0x2, %r15
jmp 0x64b8
incl %r14d
addq %r15, %rbx
jmp 0x649e
callq 0x4420
movzbl 0x10495(%rip), %edi     # 0x16990
xorl $0x1, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x62da
// File: /workspace/github_cpp_makefile_star2_O2/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 0x10428(%rip), %rdi     # 0x16970
pushq $0x4
popq %rsi
pushq $0x35
popq %rdx
callq 0x4250
movq 0x10416(%rip), %rdi     # 0x16970
pushq $0x2e
popq %rsi
callq 0x6249
movq 0x10407(%rip), %rdi     # 0x16970
movzbl 0x10422(%rip), %eax     # 0x16992
movq 0x103c9(%rip), %rcx     # 0x16940
shll $0x5, %eax
movq (%rcx,%rax), %rsi
pushq $-0x1
popq %rdx
callq 0x4670
movq 0x103e3(%rip), %rdi     # 0x16970
callq 0x4420
movb 0x103fa(%rip), %al      # 0x16992
incb %al
movb %al, 0x103f2(%rip)      # 0x16992
movzbl %al, %eax
movq 0x1039e(%rip), %rcx     # 0x16948
subq 0x1038f(%rip), %rcx     # 0x16940
sarq $0x5, %rcx
cmpq %rax, %rcx
jne 0x65c1
movb $0x0, 0x103d1(%rip)     # 0x16992
movzbl 0x103c8(%rip), %edi     # 0x16990
xorl $0x1, %edi
popq %rbp
jmp 0x62da
// File: /workspace/github_cpp_makefile_star2_O2/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 0x10390(%rip), %rdi     # 0x16970
pushq $0x4
popq %rsi
pushq $0x37
popq %rdx
callq 0x4250
movq 0x1037e(%rip), %rdi     # 0x16970
pushq $0x2e
popq %rsi
callq 0x6249
movq 0x1036f(%rip), %rdi     # 0x16970
movl %ebx, %eax
leaq 0x7cc3(%rip), %rcx      # 0xe2cd
movsbl (%rax,%rcx), %esi
callq 0x45b0
movq 0x10356(%rip), %rdi     # 0x16970
callq 0x4420
movzbl 0x1036a(%rip), %edi     # 0x16990
xorl $0x1, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x62da
// File: /workspace/github_cpp_makefile_star2_O2/lotuskip[P]yuxtapa/client/base.cpp
// Function: Base::print_teams_upd(unsigned char, unsigned char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Base::print_teams_upd(const unsigned char greens,
	const unsigned char purples, const std::string &obj_state_str)
{
	wmove(windows[STAT_WIN], 0, 0);
	change_colour(windows[STAT_WIN], BASE_LIGHT_GRAY);
	waddstr(windows[STAT_WIN], obj_state_str.c_str());
	wclrtoeol(windows[STAT_WIN]);

	wmove(windows[STAT_WIN], 1, 0);
	change_colour(windows[STAT_WIN], C_GREEN_PC);
	string str = "Green team: "
		+ lex_cast(greens)
		+ " players ";
	waddstr(windows[STAT_WIN], str.c_str());
	change_colour(windows[STAT_WIN], C_PURPLE_PC);
	str = " Purple team: "
		+ lex_cast(purples)
		+ " players";
	waddstr(windows[STAT_WIN], str.c_str());
	wclrtoeol(windows[STAT_WIN]);
	wrefresh(windows[STAT_WIN]);
	return_cursor(cursor_in_view);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r15
movl %esi, %ebx
movl %edi, %r14d
movq 0x1031d(%rip), %rdi     # 0x16970
xorl %esi, %esi
xorl %edx, %edx
callq 0x4250
movq 0x1030d(%rip), %rdi     # 0x16970
pushq $0x7
popq %rsi
callq 0x6249
movq 0x102fe(%rip), %rdi     # 0x16970
movq (%r15), %rsi
pushq $-0x1
popq %rdx
callq 0x4670
movq 0x102ec(%rip), %rdi     # 0x16970
callq 0x4510
movq 0x102e0(%rip), %rdi     # 0x16970
pushq $0x1
popq %rsi
xorl %edx, %edx
callq 0x4250
movq 0x102cf(%rip), %rdi     # 0x16970
pushq $0x1e
popq %rsi
callq 0x6249
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movl %r14d, %esi
callq 0xd516
leaq 0x79af(%rip), %rsi      # 0xe06e
leaq -0x58(%rbp), %rdi
movq %r15, %rdx
callq 0x6a4c
leaq 0x79a9(%rip), %rdx      # 0xe07b
leaq -0x78(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x6a23
leaq -0x58(%rbp), %rdi
callq 0x4748
leaq -0x38(%rbp), %rdi
callq 0x4748
movq 0x10278(%rip), %rdi     # 0x16970
movq -0x78(%rbp), %rsi
pushq $-0x1
popq %rdx
callq 0x4670
movq 0x10265(%rip), %rdi     # 0x16970
pushq $0x1f
popq %rsi
callq 0x6249
movzbl %bl, %esi
leaq -0x98(%rbp), %rdi
callq 0xd516
leaq 0x795c(%rip), %rsi      # 0xe085
leaq -0x38(%rbp), %rdi
leaq -0x98(%rbp), %rdx
callq 0x6a4c
leaq 0x7954(%rip), %rdx      # 0xe094
leaq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x6a23
leaq -0x78(%rbp), %rbx
leaq -0x58(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4480
movq %r14, %rdi
callq 0x4748
leaq -0x38(%rbp), %rdi
callq 0x4748
leaq -0x98(%rbp), %rdi
callq 0x4748
movq 0x101ec(%rip), %rdi     # 0x16970
movq (%rbx), %rsi
pushq $-0x1
popq %rdx
callq 0x4670
movq 0x101da(%rip), %rdi     # 0x16970
callq 0x4510
movq 0x101ce(%rip), %rdi     # 0x16970
callq 0x4420
movzbl 0x101e2(%rip), %edi     # 0x16990
xorl $0x1, %edi
callq 0x62da
leaq -0x78(%rbp), %rdi
callq 0x4748
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x4748
jmp 0x67de
movq %rax, %rbx
leaq -0x98(%rbp), %rdi
callq 0x4748
jmp 0x6808
jmp 0x6805
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x4748
jmp 0x67ff
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
jmp 0x680c
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x4748
movq %rbx, %rdi
callq 0x4650
// File: /workspace/github_cpp_makefile_star2_O2/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 0x100f5(%rip), %rbx     # 0x16e80
movl (%rbx), %eax
cmpl $0x7, %eax
je 0x6e2e
cmpl $0x6, %eax
je 0x6db6
testl %eax, %eax
jne 0x6e69
movzbl %dl, %esi
pushq $0x4
popq %rdi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xa8ef
leaq 0xff83(%rip), %rsi      # 0x16d40
leaq -0xc(%rbp), %rbx
movq %rbx, %rdi
callq 0xd344
movl (%rbx), %eax
movl %eax, 0xff6f(%rip)      # 0x16d40
movq %rbx, %rdi
callq 0xd2d6
movzwl 0xff60(%rip), %eax      # 0x16d40
movw $0xffff, %cx            # imm = 0xFFFF
cmpw $0xb, %ax
jg 0x6df4
movw $0x1, %cx
cmpw $-0xc, %ax
jg 0x6e00
movswl %cx, %ecx
addl %eax, %ecx
movw %cx, 0xff40(%rip)       # 0x16d40
movzwl 0xff3b(%rip), %eax      # 0x16d42
movw $0xffff, %cx            # imm = 0xFFFF
cmpw $0xb, %ax
jg 0x6e1b
movw $0x1, %cx
cmpw $-0xc, %ax
jg 0x6e27
movswl %cx, %ecx
addl %eax, %ecx
movw %cx, 0xff1b(%rip)       # 0x16d42
callq 0xc5e5
jmp 0x6e69
movl 0xf584(%rip), %ecx      # 0x163b8
addl $-0x2, %ecx
cmpl $0x5, %ecx
ja 0x6e66
pushq $0x39
popq %rax
btl %ecx, %eax
jae 0x6e66
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 0xa8ef
andl $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x10003(%rip), %rbx     # 0x16e80
movl (%rbx), %eax
cmpl $0x6, %eax
jne 0x6ea6
movzwl 0xfeb7(%rip), %eax      # 0x16d42
orw 0xfeae(%rip), %ax       # 0x16d40
je 0x6ec4
andl $0x0, 0xfea5(%rip)      # 0x16d40
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xc5e5
cmpl $0x7, %eax
jne 0x6ec4
cmpl $0x7, 0xf506(%rip)      # 0x163b8
jne 0x6ec4
pushq $0xc
popq %rdi
pushq $0x8
popq %rsi
xorl %edx, %edx
callq 0xa8ef
andl $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, 0xf3bd(%rip)      # 0x163bc
movb $0x0, 0xfd3e(%rip)      # 0x16d44
movl %edi, 0xf3ac(%rip)      # 0x163b8
cmpl $0xb, %edi
jne 0x702e
leaq 0x745b(%rip), %rdi      # 0xe473
pushq $0x27
popq %rsi
pushq $0x25
popq %rdx
pushq $0x3
popq %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x61ca
jmp 0x7091
movzbl %dil, %eax
shll $0x5, %eax
leaq 0xfba4(%rip), %rcx      # 0x16be0
movq (%rax,%rcx), %rdi
movzbl %sil, %eax
leaq 0x7311(%rip), %rcx      # 0xe35c
movzbl (%rax,%rcx), %esi
pushq $0x25
popq %rdx
pushq $0x3
popq %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x61ca
movl 0xf352(%rip), %eax      # 0x163b8
imulq $0xd, %rax, %rax
leaq 0x72ef(%rip), %rcx      # 0xe360
movb 0x6(%rax,%rcx), %dl
movb 0x8(%rax,%rcx), %sil
movb %dl, 0xfcc5(%rip)       # 0x16d45
movb %sil, 0xfcbf(%rip)      # 0x16d46
movb 0x9(%rax,%rcx), %al
movb %al, 0xfcb6(%rip)       # 0x16d47
movb $0x4, %r12b
leaq 0x73e4(%rip), %rbx      # 0xe47f
pushq $0x27
popq %r14
pushq $0x25
popq %r15
cmpb $0x7, %r12b
je 0x70c6
movsbl %r12b, %ecx
movq %rbx, %rdi
movl %r14d, %esi
movl %r15d, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x61ca
incb %r12b
jmp 0x70a3
leaq 0x73b8(%rip), %rdi      # 0xe485
pushq $0x27
popq %rsi
pushq $0x34
popq %rdx
pushq $0x3
popq %rcx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x61ca
leaq 0xfd98(%rip), %rax      # 0x16e80
cmpl $0x5, (%rax)
jle 0x70fd
andl $0x0, (%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xc5e5
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
andq $0x0, 0xecf1(%rip)      # 0x16ea8
movq 0xece2(%rip), %rax      # 0x16ea0
xorl %ecx, %ecx
movb %cl, (%rax)
andq $0x0, 0xecfe(%rip)      # 0x16ec8
movq 0xecef(%rip), %rax      # 0x16ec0
movb %cl, (%rax)
andw $0x0, 0xed17(%rip)      # 0x16ef2
andw $0x0, 0xecfd(%rip)      # 0x16ee0
xorl %edi, %edi
callq 0x6523
andw $0x0, 0xecfe(%rip)      # 0x16ef0
movq 0xec97(%rip), %rax      # 0x16e90
movq %rax, 0xece8(%rip)      # 0x16ee8
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
cmpq $0x0, 0xecb8(%rip)      # 0x16ec8
je 0x8296
movq 0xec73(%rip), %rsi      # 0x16e90
cmpq %rsi, 0xec64(%rip)      # 0x16e88
je 0x823a
addq $-0x20, %rsi
leaq 0xec8f(%rip), %rdi      # 0x16ec0
callq 0x8305
testb %al, %al
je 0x8272
leaq 0xec47(%rip), %rdi      # 0x16e88
leaq 0xec78(%rip), %rsi      # 0x16ec0
callq 0x8312
movq 0xec3c(%rip), %rax      # 0x16e90
movq 0xec2d(%rip), %rsi      # 0x16e88
subq %rsi, %rax
cmpq $0x7d01, %rax           # imm = 0x7D01
jb 0x8272
leaq 0xec1b(%rip), %rdi      # 0x16e88
callq 0x834e
leaq 0xec47(%rip), %rbx      # 0x16ec0
movq %rbx, %rdi
callq 0xba34
xorl %esi, %esi
cmpl $0x1, 0xebf6(%rip)      # 0x16e80
sete %sil
movq %rbx, %rdi
callq 0xa9f7
leaq 0x61ec(%rip), %rdi      # 0xe489
pushq $0xe
popq %rcx
pushq $0x2
popq %r8
pushq $0x1
popq %r9
xorl %esi, %esi
xorl %edx, %edx
callq 0x61ca
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x650d
// File: /workspace/github_cpp_makefile_star2_O2/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
callq 0x879d
testb %al, %al
je 0x86d0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movb 0xe942(%rip), %al       # 0x17018
cmpb $0xe, %al
jne 0x8733
leaq 0xe93f(%rip), %rdi      # 0x17020
callq 0xcbf8
leaq 0xe90b(%rip), %rsi      # 0x16ff8
movq %rax, %rdi
callq 0xcc12
cmpl $0x2ed, %eax            # imm = 0x2ED
ja 0x8728
movzbl %bl, %edx
leaq -0x38(%rbp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8a10
leaq 0xe833(%rip), %rdi      # 0x16f48
movq %rbx, %rsi
callq 0x8820
leaq -0x38(%rbp), %rdi
callq 0x4748
jmp 0x86c7
callq 0x8a3d
movb 0xe8e5(%rip), %al       # 0x17018
movsbq %al, %rdi
callq 0x8b42
movq %rax, %rdi
movq %r14, %rsi
callq 0x4220
movsbq 0xe8c9(%rip), %r14      # 0x17018
movq %r14, %rdi
callq 0x8b42
movb %bl, 0x20(%rax)
leal 0x1(%r14), %eax
movb %al, 0xe8b4(%rip)       # 0x17018
callq 0x8bc7
leaq 0xe888(%rip), %rdi      # 0x16ff8
callq 0xcbf8
leaq 0xe86c(%rip), %rdi      # 0x16fe8
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0xcbf8
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x4748
movq %rbx, %rdi
callq 0x4650
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
movq %rdi, %r14
movsbq 0xe869(%rip), %rdi      # 0x17018
testq %rdi, %rdi
je 0x8818
movl %esi, %ebx
decq %rdi
callq 0x8b42
movq %r14, %rdi
movq %rax, %rsi
callq 0x84f3
testb %al, %al
je 0x8818
movsbq 0xe843(%rip), %r14      # 0x17018
decq %r14
movq %r14, %rdi
callq 0x8b42
cmpb %bl, 0x20(%rax)
jne 0x8818
movb 0x21(%rax), %cl
cmpb $-0x6, %cl
je 0x8803
incb %cl
movb %cl, 0x21(%rax)
cmpb $0x9, %cl
jl 0x8803
movq %r14, %rdi
callq 0x8b42
movb $-0x6, 0x21(%rax)
callq 0x8bc7
leaq 0xe7d9(%rip), %rdi      # 0x16fe8
callq 0xcbf8
movb $0x1, %al
jmp 0x881a
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x58, %rsp
cmpb $0x0, 0xe5c7(%rip)      # 0x17018
je 0x8b15
leaq 0xe49a(%rip), %rdi      # 0x16ef8
callq 0x8e14
leaq 0x5a1f(%rip), %rsi      # 0xe489
leaq -0x68(%rbp), %rbx
leaq -0x19(%rbp), %rdx
movq %rbx, %rdi
callq 0x69bc
leaq -0x48(%rbp), %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x8a10
leaq 0xe469(%rip), %rdi      # 0x16ef8
leaq -0x48(%rbp), %rsi
callq 0x8820
leaq -0x48(%rbp), %rdi
callq 0x4748
leaq -0x68(%rbp), %rdi
callq 0x4748
decb 0xe568(%rip)            # 0x17018
leaq 0xe531(%rip), %rdi      # 0x16fe8
callq 0xcbf8
movsbl 0xe555(%rip), %eax      # 0x17018
movb $0x2, %cl
idivb %cl
movzbl %al, %eax
xorl %ebx, %ebx
testb %al, %al
cmovlel %ebx, %eax
movzbl %al, %r14d
pushq $0x8
popq %r15
cmpq %rbx, %r14
je 0x8b15
movq %rbx, %rdi
callq 0x8b42
movzbl 0x20(%rax), %ecx
testb $-0x9, %cl
je 0x8b10
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
jmp 0x8ad9
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x4748
jmp 0x8b31
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x4748
movq %rbx, %rdi
callq 0x4650
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
xorl %ebx, %ebx
pushq $0x2
popq %r14
pushq $0x1
popq %r15
leaq -0x48(%rbp), %r12
pushq $0x5d
popq %r13
cmpq $0xe, %rbx
je 0x8c97
movq %rbx, %rdi
callq 0x8b42
cmpb $0x0, 0x21(%rax)
je 0x8c75
movq %r12, %rdi
movq %rax, %rsi
callq 0x4220
movq %r12, %rdi
callq 0xd028
cmpw $0x36, %ax
jl 0x8c36
movq %r12, %rdi
pushq $0x35
popq %rsi
callq 0xd0da
movq %r12, %rdi
leaq 0x5a14(%rip), %rsi      # 0xe654
callq 0x46c0
movq %rbx, %rdi
callq 0x8b42
movb 0x21(%rax), %al
addb $0x31, %al
movsbl %al, %esi
movq %r12, %rdi
callq 0x4310
movq %r12, %rdi
movl %r13d, %esi
callq 0x4310
movq %rbx, %rdi
callq 0x8b42
movq %r12, %rcx
jmp 0x8c78
movq %rax, %rcx
movq (%rcx), %rdi
movzbl 0x20(%rax), %esi
movsbl %bl, %ecx
xorl %edx, %edx
movl %r14d, %r8d
movl %r15d, %r9d
callq 0x61ca
incq %rbx
jmp 0x8bfa
leaq -0x48(%rbp), %rdi
callq 0x4748
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x4748
movq %rbx, %rdi
callq 0x4650
// File: /workspace/github_cpp_makefile_star2_O2/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 0xe2a4(%rip), %rax      # 0x16f78
cmpq 0xe27d(%rip), %rax      # 0x16f58
je 0x8d24
leaq 0xe33c(%rip), %rdi      # 0x17020
callq 0xcbf8
leaq 0xe308(%rip), %rsi      # 0x16ff8
movq %rax, %rdi
callq 0xcc12
cmpl $0x2ee, %eax            # imm = 0x2EE
jb 0x8d24
movq 0xe252(%rip), %rdi      # 0x16f58
movzbl 0x20(%rdi), %esi
callq 0x879d
testb %al, %al
je 0x8d4d
leaq 0xe22e(%rip), %rdi      # 0x16f48
callq 0x8e14
jmp 0x8da4
leaq 0xe2f5(%rip), %rdi      # 0x17020
callq 0xcbf8
leaq 0xe2b1(%rip), %rsi      # 0x16fe8
movq %rax, %rdi
callq 0xcc12
cmpl $0xdac, %eax            # imm = 0xDAC
jb 0x8da4
callq 0x8a3d
jmp 0x8d9f
callq 0x8a3d
leaq 0xe1ef(%rip), %rbx      # 0x16f48
movq 0xe1f8(%rip), %r14      # 0x16f58
movsbq 0xe2b0(%rip), %rdi      # 0x17018
callq 0x8b42
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x4220
movzwl 0x20(%r14), %eax
movw %ax, 0x20(%r15)
movq %rbx, %rdi
callq 0x8e14
incb 0xe285(%rip)            # 0x17018
leaq 0xe25e(%rip), %rdi      # 0x16ff8
callq 0xcbf8
callq 0x8bc7
leaq 0xe275(%rip), %rdi      # 0x17020
callq 0xcbf8
leaq 0xe251(%rip), %rsi      # 0x17008
movq %rax, %rdi
callq 0xcc12
cmpl $0x3e8, %eax            # imm = 0x3E8
jb 0x8e08
movzwl 0xe263(%rip), %eax      # 0x17030
testw %ax, %ax
je 0x8ddb
decl %eax
movw %ax, 0xe255(%rip)       # 0x17030
movb 0xe251(%rip), %al       # 0x17032
testb %al, %al
je 0x8ded
decb %al
movb %al, 0xe245(%rip)       # 0x17032
callq 0x8e80
leaq 0xe20f(%rip), %rdi      # 0x17008
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xcbf8
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x48, %rsp
movzwl 0xe19b(%rip), %r15d     # 0x17030
movw $0x3c, %cx
movl %r15d, %eax
xorl %edx, %edx
divw %cx
movl %edx, %ebx
movl %eax, %r14d
leaq 0x55dc(%rip), %rsi      # 0xe489
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rdx
callq 0x69bc
cmpw $0x257, %r15w           # imm = 0x257
ja 0x8ece
leaq -0x38(%rbp), %rdi
pushq $0x20
popq %rsi
callq 0x4310
movzwl %r14w, %esi
leaq -0x58(%rbp), %rdi
callq 0xd516
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x46f0
leaq -0x58(%rbp), %rdi
callq 0x4748
leaq -0x38(%rbp), %rdi
pushq $0x3a
popq %rsi
callq 0x4310
cmpw $0x9, %bx
ja 0x8f0f
leaq -0x38(%rbp), %rdi
pushq $0x30
popq %rsi
callq 0x4310
movzwl %bx, %esi
leaq -0x58(%rbp), %rdi
callq 0xd516
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x46f0
leaq -0x58(%rbp), %rdi
callq 0x4748
movq -0x38(%rbp), %rdi
pushq $0x7
popq %rsi
pushq $0x33
popq %rdx
pushq $0x6
popq %rcx
pushq $0x1
popq %r9
xorl %r8d, %r8d
callq 0x61ca
andq $0x0, -0x30(%rbp)
movq -0x38(%rbp), %rax
movb $0x0, (%rax)
movb 0xe0d6(%rip), %al       # 0x17032
cmpb $0x9, %al
ja 0x8f72
leaq -0x38(%rbp), %rdi
pushq $0x20
popq %rsi
callq 0x4310
movb 0xe0c0(%rip), %al       # 0x17032
movzbl %al, %esi
leaq -0x58(%rbp), %rdi
callq 0xd516
leaq -0x38(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x46f0
leaq -0x58(%rbp), %rdi
callq 0x4748
movq -0x38(%rbp), %rdi
pushq $0x36
popq %rdx
pushq $0x7
popq %rcx
pushq $0x1
popq %r9
movl %ecx, %esi
xorl %r8d, %r8d
callq 0x61ca
leaq -0x38(%rbp), %rdi
callq 0x4748
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8fc8
jmp 0x8fd8
jmp 0x8fc8
jmp 0x8fd8
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x4748
jmp 0x8fdb
jmp 0x8fd8
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x4748
movq %rbx, %rdi
callq 0x4650
// File: /workspace/github_cpp_makefile_star2_O2/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 0x6473
movzbl %al, %eax
movswl 0xd9dd(%rip), %ecx      # 0x17034
movswl 0xd9d8(%rip), %edx      # 0x17036
subl %edx, %ecx
cmpl %eax, %ecx
cmovgel %eax, %ecx
movsbl %cl, %r12d
xorl %r13d, %r13d
pushq $0x1
popq %rbx
leaq 0x5016(%rip), %r14      # 0xe68c
pushq $0x7
popq %r15
cmpl %r13d, %r12d
jle 0x9707
movsbl %r13b, %esi
xorl %edi, %edi
movl %ebx, %edx
callq 0x6324
movswq 0xd99e(%rip), %rdi      # 0x17036
addq %r13, %rdi
callq 0x9990
movq 0x20(%rax), %rdi
pushq $0x3
popq %rsi
movl %ebx, %edx
callq 0x633f
movswq 0xd980(%rip), %rdi      # 0x17036
addq %r13, %rdi
callq 0x9990
movzbl 0x40(%rax), %eax
leaq 0xc677(%rip), %rcx      # 0x15d40
movq (%rcx,%rax,8), %rdi
movzbl (%rax,%r14), %esi
movl %ebx, %edx
callq 0x633f
movswq 0xd955(%rip), %rdi      # 0x17036
addq %r13, %rdi
callq 0x9990
movq (%rax), %rdi
movl %r15d, %esi
movl %ebx, %edx
callq 0x633f
movl %ebx, %edi
movl %ebx, %esi
callq 0x6378
incq %r13
jmp 0x967a
cmpw $0x0, 0xd927(%rip)      # 0x17036
je 0x971f
callq 0x6416
movswl 0xd919(%rip), %eax      # 0x17036
jmp 0x9721
xorl %eax, %eax
addl %eax, %r12d
movswl 0xd909(%rip), %eax      # 0x17034
addq $0x8, %rsp
cmpl %eax, %r12d
jge 0x9743
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x63b1
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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, 0xd87b(%rip)       # 0x17030
movb %sil, 0xd876(%rip)      # 0x17032
callq 0x8e80
leaq 0xd840(%rip), %rdi      # 0x17008
popq %rbp
jmp 0xcbf8
// File: /workspace/github_cpp_makefile_star2_O2/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 0xd3eb(%rip), %rbx      # 0x17978
movq %rbx, %rdi
callq 0xcc4a
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0xcc5c
movzwl 0xdcb1(%rip), %esi      # 0x18258
movq %rbx, %rdi
callq 0xcc70
callq 0xa4fc
movq 0xdc75(%rip), %rdi      # 0x18230
callq 0x44f0
movl 0xdc7a(%rip), %edi      # 0x18240
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x4700
// File: /workspace/github_cpp_makefile_star2_O2/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 0xb9fc
testb %al, %al
je 0xa926
cmpb $0x0, 0xd947(%rip)      # 0x1825c
je 0xa946
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xd933(%rip), %rdi      # 0x18260
callq 0xcbf8
leaq 0xd90f(%rip), %rsi      # 0x18248
movq %rax, %rdi
callq 0xcc12
cmpl $0x32, %eax
jb 0xa917
leaq 0xd02b(%rip), %r12      # 0x17978
movq %r12, %rdi
callq 0xcc4a
pushq $0x7
popq %rsi
movq %r12, %rdi
callq 0xcc5c
movzwl 0xd8f1(%rip), %esi      # 0x18258
movq %r12, %rdi
callq 0xcc70
movzwl 0xd8e4(%rip), %esi      # 0x1825a
movq %r12, %rdi
callq 0xcc70
movzbl 0xd8d7(%rip), %esi      # 0x1825c
movq %r12, %rdi
callq 0xcc5c
movzbl %r14b, %r13d
movq %r12, %rdi
movl %r13d, %esi
callq 0xcc5c
cmpb $0xc, %r13b
ja 0xa9d2
movl $0x1cb0, %eax           # imm = 0x1CB0
btl %r13d, %eax
jae 0xa9d2
movzbl %r15b, %esi
leaq 0xcfc0(%rip), %rdi      # 0x17978
callq 0xcc5c
cmpb $0x5, %r14b
jne 0xa9d2
movzbl %bl, %esi
leaq 0xcfab(%rip), %rdi      # 0x17978
callq 0xcc5c
callq 0xa4fc
incb 0xd87f(%rip)            # 0x1825c
leaq 0xd864(%rip), %rdi      # 0x18248
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xcbf8
// File: /workspace/github_cpp_makefile_star2_O2/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 0xcf67(%rip), %r15      # 0x17978
movq %r15, %rdi
callq 0xcc4a
xorb $0x1, %r14b
movzbl %r14b, %eax
leal 0x4(,%rax,2), %esi
movq %r15, %rdi
callq 0xcc5c
movzwl 0xd821(%rip), %esi      # 0x18258
movq %r15, %rdi
callq 0xcc70
cmpq $0x15e, 0x8(%rbx)       # imm = 0x15E
ja 0xaa5a
leaq 0xcf28(%rip), %rdi      # 0x17978
movq %rbx, %rsi
callq 0xcc9a
jmp 0xaa94
movq %rbx, %rdi
movl $0x15e, %esi            # imm = 0x15E
callq 0xd189
movswq %ax, %rcx
leaq -0x38(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x43c0
leaq 0xcef5(%rip), %rdi      # 0x17978
movq %r14, %rsi
callq 0xcc9a
leaq -0x38(%rbp), %rdi
callq 0x4748
callq 0xa4fc
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x4748
movq %rbx, %rdi
callq 0x4650
// File: /workspace/github_cpp_makefile_star2_O2/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 0xceb0(%rip), %r14      # 0x17978
movq %r14, %rdi
callq 0xcc4a
pushq $0x8
popq %rsi
movq %r14, %rdi
callq 0xcc5c
movzwl 0xd776(%rip), %esi      # 0x18258
movq %r14, %rdi
callq 0xcc70
movq %r14, %rdi
movl %ebx, %esi
callq 0xcc5c
popq %rbx
popq %r14
popq %rbp
jmp 0xa4fc
// File: /workspace/github_cpp_makefile_star2_O2/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 0xce6e(%rip), %rbx      # 0x17978
movq %rbx, %rdi
callq 0xcc4a
pushq $0x9
popq %rsi
movq %rbx, %rdi
callq 0xcc5c
movzwl 0xd734(%rip), %esi      # 0x18258
movq %rbx, %rdi
callq 0xcc70
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xa4fc
// File: /workspace/github_cpp_makefile_star2_O2/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 0xce34(%rip), %rbx      # 0x17978
movq %rbx, %rdi
callq 0xcc4a
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0xcc5c
movzwl 0xd6fa(%rip), %esi      # 0x18258
movq %rbx, %rdi
callq 0xcc70
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xa4fc
// File: /workspace/github_cpp_makefile_star2_O2/lotuskip[P]yuxtapa/client/settings.cpp
// Function: (anonymous namespace)::fill_kph(char)
void fill_kph(const char k)
{
	if(k == '\t') // special
	{
		keyplaceholder[0] = '\\';
		keyplaceholder[1] = 't';
	}
	else if(k < 27) // means it's a ctrl key
	{
		keyplaceholder[0] = '^';
		keyplaceholder[1] = k + CTRL_ADD;
	}
	else if(k == ' ') // also special
	{
		keyplaceholder[0] = 'S';
		keyplaceholder[1] = 'P';
	}
	else
	{
		keyplaceholder[0] = k;
		keyplaceholder[1] = '\0';
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpb $0x9, %dil
jne 0xb853
movb $0x5c, 0xab7a(%rip)     # 0x163c8
movb $0x74, %dil
jmp 0xb881
cmpb $0x1a, %dil
jg 0xb866
movb $0x5e, 0xab68(%rip)     # 0x163c8
addb $0x40, %dil
jmp 0xb881
cmpb $0x20, %dil
jne 0xb878
movb $0x53, 0xab55(%rip)     # 0x163c8
movb $0x50, %dil
jmp 0xb881
movb %dil, 0xab49(%rip)      # 0x163c8
xorl %edi, %edi
movb %dil, 0xab41(%rip)      # 0x163c9
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x220, %rsp            # imm = 0x220
leaq 0xcca1(%rip), %rsi      # 0x18540
leaq 0x32e1(%rip), %rdx      # 0xeb87
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0xbb49
movq (%rbx), %rsi
leaq -0x230(%rbp), %rdi
pushq $0x10
popq %rdx
callq 0x4400
leaq -0x30(%rbp), %rdi
callq 0x4748
cmpw $0x0, 0xaaf7(%rip)      # 0x163cc
je 0xb907
movq -0x230(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x210(%rbp,%rax)
je 0xb91f
movq 0xa6fd(%rip), %rdi      # 0x15ff0
leaq 0x3298(%rip), %rsi      # 0xeb92
callq 0x4390
movq %rax, %rdi
callq 0x41f0
leaq -0x230(%rbp), %rdi
callq 0x4560
addq $0x220, %rsp            # imm = 0x220
popq %rbx
popq %r14
popq %rbp
retq
leaq 0xb562(%rip), %rbx      # 0x16e88
movq (%rbx), %rsi
movq 0x8(%rbx), %rax
subq %rsi, %rax
sarq $0x5, %rax
movswq 0xaa90(%rip), %rcx      # 0x163cc
movl %ecx, %ecx
cmpq %rcx, %rax
jbe 0xb94d
movq %rbx, %rdi
callq 0x834e
jmp 0xb926
leaq -0x230(%rbp), %r14
movq (%rbx), %rsi
cmpq 0x8(%rbx), %rsi
je 0xb907
movq %r14, %rdi
callq 0x4340
movq %rax, %rdi
callq 0x41f0
movq (%rbx), %rsi
movq %rbx, %rdi
callq 0x834e
jmp 0xb954
jmp 0xb98e
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x4748
jmp 0xb99d
jmp 0xb98e
jmp 0xb98e
movq %rax, %rbx
leaq -0x230(%rbp), %rdi
callq 0x4560
movq %rbx, %rdi
callq 0x4650
// File: /workspace/github_cpp_makefile_star2_O2/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 %rdi, %rbx
movq 0xcb30(%rip), %r14      # 0x18578
leaq 0xcb19(%rip), %r15      # 0x18568
cmpq %r15, %r14
je 0xba75
leaq 0x20(%r14), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x4720
cmpq $-0x1, %rax
jne 0xba80
movq %r14, %rdi
callq 0x4280
movq %rax, %r14
jmp 0xba4f
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x28(%r14), %rdx
addq $0x40, %r14
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4160