LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/lotuskip[P]yuxtapa/server/game.cpp
// Function: (anonymous namespace)::upd_num_boulders()
void upd_num_boulders()
{
	boulders_left = 0;
	for(list<OccEnt>::const_iterator b_it = boulders.begin();
		b_it != boulders.end(); ++b_it)
	{
		if(!b_it->isvoid() &&
			Game::curmap->coords_in_sector(b_it->getpos()) == obj_sector)
			++boulders_left; // a boulder is in the target sector
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x2d121(%rip), %r15     # 0x42e70
xorl %eax, %eax
leaq -0x2c(%rbp), %rbx
movq %r15, %r12
movw %ax, 0x2c721(%rip)      # 0x42480
movq (%r12), %r12
cmpq %r15, %r12
je 0x15da9
cmpb $0x0, 0x1e(%r12)
jne 0x15d5f
movq 0x2bee1(%rip), %rdi     # 0x41c58
movl 0x18(%r12), %eax
movl %eax, -0x2c(%rbp)
movq %rbx, %rsi
callq 0x128ac
movl %eax, %r14d
movl 0x27683(%rip), %r13d    # 0x3d414
movq %rbx, %rdi
callq 0x24d9e
cmpl %r13d, %r14d
jne 0x15d5f
movzwl 0x2c6db(%rip), %eax     # 0x42480
incl %eax
jmp 0x15d58
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x2c(%rbp), %rdi
callq 0x24d9e
movq %rbx, %rdi
callq 0x4710
// File: /workspace/github_cpp_makefile_star2_O2/lotuskip[P]yuxtapa/server/game.cpp
// Function: Game::start()
void Game::start()
{
	// It is possible that !nextmap is forced by a player before
	// the map is ready. Hence this check:
	while(init_phase != IPH_DONE)
		init_game();

	// Base maptime is [n] minutes where n depends on gamemode:
	map_over_turn = game_mode_mins[gamemode]
		*60*1000/Config::int_settings[Config::IS_TURNMS];
	// But we enforce a lower/upper limit dependent on map size:
	if(map_over_turn < 14*curmap->get_size())
		map_over_turn = 14*curmap->get_size();
	// (The range here is roughly 2--30 minutes on normal settings.)
	else if(map_over_turn > 15*curmap->get_size() + 2900)
		map_over_turn = 15*curmap->get_size() + 2900;
	// (And here roughly 14--44 minutes)
	
	if(gamemode == GM_STEAL)
		objective_str.erase(5); /* leaving just "Steal"; from now on the
		sector is given in the status string */

	send_times(cur_players.end());
	send_team_upds(cur_players.end());
	send_flag_upds(cur_players.end());
	for(list<Player>::iterator it = cur_players.begin();
		it != cur_players.end(); ++it)
	{
		// reduce intermission time from total time spent on server:
		it->stats_i->last_seen += time(NULL) - it->last_switched_cl;
		time(&(it->last_switched_cl));
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
cmpl $0x6, 0x2be86(%rip)     # 0x41c60
je 0x15de3
callq 0x158f6
jmp 0x15dd3
movl 0x2b42b(%rip), %ecx     # 0x41214
leaq 0x13014(%rip), %rax     # 0x28e04
movsbl (%rcx,%rax), %eax
imull $0xea60, %eax, %eax     # imm = 0xEA60
leaq 0x29a8f(%rip), %rsi     # 0x3f890
xorl %edx, %edx
divl 0x14(%rsi)
movw %ax, 0x2760b(%rip)      # 0x3d418
movzwl %ax, %edx
movq 0x2be41(%rip), %rax     # 0x41c58
movswl (%rax), %esi
imull $0xe, %esi, %eax
cmpl %eax, %edx
jl 0x15e2d
imull $0xf, %esi, %eax
addl $0xb54, %eax            # imm = 0xB54
cmpl %edx, %eax
jge 0x15e34
movw %ax, 0x275e4(%rip)      # 0x3d418
cmpl $0x2, %ecx
jne 0x15e4b
leaq 0x2bdf0(%rip), %rdi     # 0x41c30
pushq $0x5
popq %rsi
pushq $-0x1
popq %rdx
callq 0x40d0
leaq 0x2a25e(%rip), %rbx     # 0x400b0
movq %rbx, %rdi
callq 0x15ea4
movq %rbx, %rdi
callq 0x152e9
movq %rbx, %rdi
callq 0x15ff0
movq %rbx, %r14
movq (%r14), %r14
cmpq %rbx, %r14
je 0x15e9f
xorl %edi, %edi
callq 0x43c0
leaq 0xc8(%r14), %rdi
subq 0xc8(%r14), %rax
movq 0x90(%r14), %rcx
addq %rax, 0x138(%rcx)
callq 0x43c0
jmp 0x15e6d
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/lotuskip[P]yuxtapa/server/game.cpp
// Function: Game::send_times(std::_List_const_iterator<Player>)
void Game::send_times(const list<Player>::const_iterator to)
{
	// A convenient place as any to do a periodic check on what bots have
	// finished (or crashed or been killed or ...):
	num_bots();

	Network::send_buffer.clear();
	// mid and maptime are the same for all clients:
	Network::send_buffer.add((unsigned char)MID_TIME_UPD);
	Network::send_buffer.add((unsigned short)(
		(map_over_turn - curturn)*int_settings[IS_TURNMS]/1000));
	// but the spawn time is team-specific!
	unsigned char sts[3] = {
		// green spawn time:
		(unsigned char)((spawn_cycle - ((curturn + spawn_cycle/2) % spawn_cycle))
			*int_settings[IS_TURNMS]/1000),
		// purple spawn time:
		(unsigned char)((spawn_cycle - (curturn % spawn_cycle))*int_settings[IS_TURNMS]/1000),
		0 }; // specs don't spawn

	if(to == cur_players.end()) // need to send to all
	{
		for(list<Player>::const_iterator i = cur_players.begin();
			i != cur_players.end(); ++i)
		{
			Network::send_buffer.set_amount(3); // reset to overwrite
			Network::send_buffer.add(sts[i->team]);
			Network::send_to_player(*i);
		}
	}
	else
	{
		Network::send_buffer.add(sts[to->team]);
		Network::send_to_player(*to);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xf89e
leaq 0x28257(%rip), %r14     # 0x3e118
movq %r14, %rdi
callq 0x24712
pushq $0xe
popq %rsi
movq %r14, %rdi
callq 0x24724
movzwl 0x2753d(%rip), %eax     # 0x3d418
movzwl 0x2bd6e(%rip), %ecx     # 0x41c50
subl %ecx, %eax
leaq 0x299a5(%rip), %r12     # 0x3f890
imull 0x14(%r12), %eax
movl $0x3e8, %r15d           # imm = 0x3E8
xorl %edx, %edx
divl %r15d
movzwl %ax, %esi
movq %r14, %rdi
callq 0x24738
movzbl 0x2bd56(%rip), %eax     # 0x41c64
movzwl %ax, %ecx
movzwl 0x2bd38(%rip), %esi     # 0x41c50
movl %ecx, %eax
shrl %eax
addl %esi, %eax
xorl %edx, %edx
divl %ecx
movl %ecx, %eax
subl %edx, %eax
movl 0x14(%r12), %edi
imull %edi, %eax
xorl %edx, %edx
divl %r15d
movb %al, -0x2b(%rbp)
movl %esi, %eax
xorl %edx, %edx
divw %cx
movzwl %dx, %eax
subl %eax, %ecx
imull %edi, %ecx
movl %ecx, %eax
xorl %edx, %edx
divl %r15d
movb %al, -0x2a(%rbp)
movb $0x0, -0x29(%rbp)
cmpq 0x27056(%rip), %rbx     # 0x3cfb0
je 0x15f93
movl 0xbc(%rbx), %eax
addq $0x10, %rbx
movzbl -0x2b(%rbp,%rax), %esi
leaq 0x281a6(%rip), %r14     # 0x3e118
movq %r14, %rdi
callq 0x24724
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xc3a6
leaq 0x2a116(%rip), %r12     # 0x400b0
leaq 0x28177(%rip), %rbx     # 0x3e118
pushq $0x3
popq %r14
movq %r12, %r13
movq (%r13), %r13
cmpq %r12, %r13
je 0x15fe1
movq %rbx, %rdi
movl %r14d, %esi
callq 0x248ee
leaq 0x10(%r13), %r15
movl 0xbc(%r13), %eax
movzbl -0x2b(%rbp,%rax), %esi
movq %rbx, %rdi
callq 0x24724
movq %r15, %rdi
movq %rbx, %rsi
callq 0xc3a6
jmp 0x15fa8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/lotuskip[P]yuxtapa/server/game.cpp
// Function: Game::send_flag_upds(std::_List_const_iterator<Player>)
void Game::send_flag_upds(const list<Player>::const_iterator to)
{
	unsigned char flagbuf[MAX_D+1] = { MAX_PREDEF_CPAIR, MAX_PREDEF_CPAIR,
		MAX_PREDEF_CPAIR, MAX_PREDEF_CPAIR, MAX_PREDEF_CPAIR, MAX_PREDEF_CPAIR,
		MAX_PREDEF_CPAIR, MAX_PREDEF_CPAIR, MAX_PREDEF_CPAIR };
	char ch, bp;
	for(list<NOccEnt>::const_iterator it = noccents[NOE_FLAG].begin();
		it != noccents[NOE_FLAG].end(); ++it)
	{
		ch = Game::curmap->coords_in_sector(it->getpos());
		if(it->get_m() == T_NO_TEAM) // neutral flag
			flagbuf[ch] = C_NEUT_FLAG;
		else
		{
			bp = it->get_m();
			flagbuf[ch] = C_GREEN_PC
				+ bp // +1 if purple
				+ NUM_NORM_COLS*(it == *(--(team_flags[bp].end()))); // make lit if spawn flag
		}
	}

	Network::send_buffer.clear();
	Network::send_buffer.add((unsigned char)MID_FLAG_UPD);
	for(ch = 0; ch <= MAX_D; ++ch)
		Network::send_buffer.add(flagbuf[ch]);

	if(to == cur_players.end()) // send to all
		Network::broadcast();
	else // only send to 'to'
		Network::send_to_player(*to);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, -0x40(%rbp)
movabsq $0x6e6e6e6e6e6e6e6e, %rax # imm = 0x6E6E6E6E6E6E6E6E
movq %rax, -0x38(%rbp)
movb $0x6e, -0x30(%rbp)
leaq 0x2cd92(%rip), %r13     # 0x42db0
addq $0x78, %r13
leaq -0x2c(%rbp), %r14
pushq $0x14
popq %rbx
movq %r13, %r12
movq (%r12), %r12
cmpq %r13, %r12
je 0x16090
movq 0x2bc1c(%rip), %rdi     # 0x41c58
movl 0x18(%r12), %eax
movl %eax, -0x2c(%rbp)
movq %r14, %rsi
callq 0x128ac
movl %eax, %r15d
movq %r14, %rdi
callq 0x24d9e
movsbq 0x1f(%r12), %rcx
movb $0x27, %al
cmpq $0x3, %rcx
je 0x16083
imulq $0x18, %rcx, %rax
leaq 0x2ce80(%rip), %rdx     # 0x42ef0
movq 0x8(%rdx,%rax), %rdx
movl %ebx, %eax
cmpq 0x10(%rdx), %r12
je 0x1607f
xorl %eax, %eax
addb %cl, %al
addb $0x1e, %al
movl %r15d, %ecx
movsbq %cl, %rcx
movb %al, -0x38(%rbp,%rcx)
jmp 0x1602c
leaq 0x28081(%rip), %r14     # 0x3e118
movq %r14, %rdi
callq 0x24712
pushq $0xf
popq %rsi
movq %r14, %rdi
callq 0x24724
xorl %ebx, %ebx
cmpq $0x9, %rbx
je 0x160c4
movzbl -0x38(%rbp,%rbx), %esi
movq %r14, %rdi
callq 0x24724
incq %rbx
jmp 0x160ac
movq -0x40(%rbp), %rdi
cmpq 0x26ee1(%rip), %rdi     # 0x3cfb0
je 0x160e3
addq $0x10, %rdi
leaq 0x2803c(%rip), %rsi     # 0x3e118
callq 0xc3a6
jmp 0x160f4
leaq 0x2802e(%rip), %rsi     # 0x3e118
movl $0xffff, %edi           # imm = 0xFFFF
callq 0xb61b
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x2c(%rbp), %rdi
callq 0x24d9e
movq %rbx, %rdi
callq 0x4710
// File: /workspace/github_cpp_makefile_star2_O2/lotuskip[P]yuxtapa/server/game.cpp
// Function: (anonymous namespace)::validate_and_process(Axn const&, std::_List_iterator<Player>)
void validate_and_process(const Axn &axn, const list<Player>::iterator pit)
{
	if(axn.xncode <= XN_MOVE // these are always "sensible"
		|| short(axn.xncode - XN_SHOOT) == short(pit->cl))
		process_action(axn, pit);
	else
	{
		// Resend class info; ("client plays a healer but is sending a
		// shoot action; it must think it is still playing an archer!")
		send_full_state_refresh(pit);
		pit->action_queue.clear(); // discard rest of so-far-received actions, too
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movzbl (%rdi), %eax
cmpl $0x5, %eax
jb 0x16e11
addl $0xfffb, %eax           # imm = 0xFFFB
movzwl %ax, %eax
movswl 0xc0(%rbx), %ecx
cmpl %ecx, %eax
jne 0x16e1f
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1d614
movq %rbx, %rdi
callq 0x15092
addq $0xe8, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x17e6e
// File: /workspace/github_cpp_makefile_star2_O2/lotuskip[P]yuxtapa/server/game.cpp
// Function: (anonymous namespace)::send_state_upd(std::_List_iterator<Player>)
void send_state_upd(const list<Player>::iterator it)
{
	Network::send_buffer.clear();
	Network::send_buffer.add((unsigned char)MID_STATE_UPD);
	Network::send_buffer.add(
		static_cast<unsigned char>(it->cl_props.hp));
	Network::send_buffer.add(
		static_cast<unsigned char>(it->cl_props.tohit));
	Network::send_buffer.add(
		static_cast<unsigned char>(it->cl_props.dam_add));
	Network::send_buffer.add((unsigned char)it->cl_props.dv);
	Network::send_buffer.add((unsigned char)(it->poisoner != cur_players.end()));
	Network::send_buffer.add((unsigned char)it->sector);
	Network::send_buffer.add(it->torch_symbol(it->is_alive() && it->own_pc->torch_is_lit()));
	Network::send_to_player(*it);
	it->needs_state_upd = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x272c8(%rip), %r15     # 0x3e118
movq %r15, %rdi
callq 0x24712
pushq $0xb
popq %rsi
movq %r15, %rdi
callq 0x24724
leaq 0x10(%rbx), %r14
movzbl 0x153(%rbx), %esi
movq %r15, %rdi
callq 0x24724
movzbl 0x154(%rbx), %esi
movq %r15, %rdi
callq 0x24724
movzbl 0x157(%rbx), %esi
movq %r15, %rdi
callq 0x24724
movzbl 0x158(%rbx), %esi
movq %r15, %rdi
callq 0x24724
movq 0x160(%rbx), %rax
xorl %esi, %esi
cmpq 0x260fd(%rip), %rax     # 0x3cfb0
setne %sil
movq %r15, %rdi
callq 0x24724
movzbl 0x16c(%rbx), %esi
movq %r15, %rdi
callq 0x24724
movq %r14, %rdi
callq 0xe68e
testb %al, %al
je 0x16ee6
movq 0x148(%rbx), %rax
movb 0x20(%rax), %al
jmp 0x16ee8
xorl %eax, %eax
movzbl %al, %esi
movq %r14, %rdi
callq 0xe772
movzbl %al, %esi
leaq 0x2721b(%rip), %r15     # 0x3e118
movq %r15, %rdi
callq 0x24724
movq %r14, %rdi
movq %r15, %rsi
callq 0xc3a6
movb $0x0, 0x15d(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/lotuskip[P]yuxtapa/server/game.cpp
// Function: (anonymous namespace)::follow_change(std::_List_iterator<Player>, std::_List_const_iterator<Player>)
void follow_change(const list<Player>::iterator pit,
	const list<Player>::const_iterator fit)
{
	pit->viewn_vp->drop_watcher(pit->stats_i->ID);
	(pit->viewn_vp = fit->own_vp)->add_watcher(pit);
	if(pit->viewn_vp != pit->own_vp)
	{
		string s = "Now following " + fit->nick + ", a "
			+ team_name[fit->team]
			+ ' ' + classnames[fit->cl] + '.';
		Network::construct_msg(s, C_FIREB_TRAP_LIT);
		Network::send_to_player(*pit);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xc8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x90(%rdi), %rax
movq 0xd8(%rdi), %rdi
movzwl 0x10(%rax), %esi
callq 0x1954a
movq 0xd0(%r14), %rdi
movq %rdi, 0xd8(%rbx)
movq %rbx, %rsi
callq 0x19522
movq 0xd8(%rbx), %rax
cmpq 0xd0(%rbx), %rax
je 0x172c1
leaq 0x98(%r14), %rdx
leaq 0x11f2d(%rip), %rsi     # 0x290fe
leaq -0xd8(%rbp), %r15
movq %r15, %rdi
callq 0xde6a
leaq 0x11f26(%rip), %rdx     # 0x2910d
leaq -0x38(%rbp), %rdi
movq %r15, %rsi
callq 0xb309
movl 0xbc(%r14), %eax
shlq $0x5, %rax
leaq 0x2a01b(%rip), %rdx     # 0x41220
addq %rax, %rdx
leaq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0xe08e
leaq -0x78(%rbp), %rdi
leaq -0x58(%rbp), %rsi
pushq $0x20
popq %rdx
callq 0x17d8b
movl 0xc0(%r14), %eax
shlq $0x5, %rax
leaq 0x2a089(%rip), %rdx     # 0x412c0
addq %rax, %rdx
leaq -0x98(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0xe08e
leaq -0xb8(%rbp), %rdi
leaq -0x98(%rbp), %rsi
pushq $0x2e
popq %rdx
callq 0x17d8b
leaq -0x98(%rbp), %rdi
callq 0x47e8
leaq -0x78(%rbp), %rdi
callq 0x47e8
leaq -0x58(%rbp), %rdi
callq 0x47e8
leaq -0x38(%rbp), %rdi
callq 0x47e8
leaq -0xd8(%rbp), %rdi
callq 0x47e8
leaq -0xb8(%rbp), %rdi
pushq $0x39
popq %rsi
callq 0xc0f2
addq $0x10, %rbx
leaq 0x26e6b(%rip), %rsi     # 0x3e118
movq %rbx, %rdi
callq 0xc3a6
leaq -0xb8(%rbp), %rdi
callq 0x47e8
addq $0xc8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x98(%rbp), %rdi
callq 0x47e8
jmp 0x172e3
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x47e8
jmp 0x172f1
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x47e8
jmp 0x172ff
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x47e8
jmp 0x1730d
movq %rax, %rbx
leaq -0xd8(%rbp), %rdi
jmp 0x17320
movq %rax, %rbx
leaq -0xb8(%rbp), %rdi
callq 0x47e8
movq %rbx, %rdi
callq 0x4710
// File: /workspace/github_cpp_makefile_star2_O2/lotuskip[P]yuxtapa/server/game.cpp
// Function: Game::send_state_change(std::_List_const_iterator<Player>)
void Game::send_state_change(const list<Player>::const_iterator to)
{
	Network::send_buffer.clear();
	Network::send_buffer.add((unsigned char)MID_STATE_CHANGE);
	Network::send_buffer.add((unsigned char)to->next_cl);
	Network::send_buffer.add((unsigned char)to->team);
	Network::send_to_player(*to);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x26dd7(%rip), %r14     # 0x3e118
movq %r14, %rdi
callq 0x24712
pushq $0xc
popq %rsi
movq %r14, %rdi
callq 0x24724
leaq 0x10(%rbx), %r15
movzbl 0xc4(%rbx), %esi
movq %r14, %rdi
callq 0x24724
movzbl 0xbc(%rbx), %esi
movq %r14, %rdi
callq 0x24724
movq %r15, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xc3a6
// File: /workspace/github_cpp_makefile_star2_O2/lotuskip[P]yuxtapa/server/game.cpp
// Function: Game::send_team_info(std::_List_const_iterator<Player>)
void Game::send_team_info(const std::list<Player>::const_iterator to)
{
	// We will reuse renderbuffer for sending (it is vacant space when not
	// rendering).
	char *p = &(renderbuffer[1]);
	if(to->team == T_SPEC)
		renderbuffer[0] = cur_players.size() - num_players[0] - num_players[1];
	else
		renderbuffer[0] = num_players[to->team];
	if(renderbuffer[0] > VIEWSIZE) // can't print more than this
		renderbuffer[0] = VIEWSIZE;
	int count = renderbuffer[0];
	for(list<Player>::const_iterator it = cur_players.begin();
		it != cur_players.end(); ++it)
		if(it->team == to->team)
		{
			strcpy(p, it->nick.c_str());
			p += it->nick.length(); // skip '\0'
			if(it->botpid != -1)
			{
				strcpy(p, " (B)");
				p += 5; // include '\0'
			}
			else
			{
				strcpy(p, admin_lvl_str[it->stats_i->ad_lvl].c_str());
				p += admin_lvl_str[it->stats_i->ad_lvl].length()+1;
			}
			*(p++) = it->cl; // class
			if(it->is_alive()) // sector
				*(p++) = it->sector;
			else
				*(p++) = -1; // signifies dead
			if(!(--count))
				break;
		}
	Network::send_buffer.clear();
	Network::send_buffer.add((unsigned char)MID_TEAM_INFO);
	Network::send_buffer.write_compressed(renderbuffer, p - renderbuffer);
	Network::send_to_player(*to);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0xbc(%rdi), %eax
cmpq $0x2, %rax
jne 0x173c6
leaq 0x28d01(%rip), %rax     # 0x400b0
movl 0x10(%rax), %eax
movzbl 0x29e58(%rip), %ecx     # 0x41211
movzbl 0x29e52(%rip), %edx     # 0x41212
addl %ecx, %edx
subl %edx, %eax
jmp 0x173d0
leaq 0x29e44(%rip), %rcx     # 0x41211
movb (%rax,%rcx), %al
movzbl %al, %eax
cmpb $0x17, %al
pushq $0x17
popq %rcx
cmovll %eax, %ecx
movb %cl, 0x2a88f(%rip)      # 0x41c70
movsbl %cl, %r15d
leaq 0x2a885(%rip), %r14     # 0x41c71
leaq 0x28cbd(%rip), %r13     # 0x400b0
movq %r13, %r12
movq (%r12), %r12
cmpq %r13, %r12
je 0x174c5
movl 0xbc(%r12), %eax
cmpl 0xbc(%rbx), %eax
jne 0x173f6
movq 0x98(%r12), %rsi
movq %r14, %rdi
callq 0x43d0
addq 0xa0(%r12), %r14
cmpl $-0x1, 0x174(%r12)
je 0x17448
movb $0x0, 0x4(%r14)
movl $0x29422820, (%r14)     # imm = 0x29422820
addq $0x5, %r14
jmp 0x17491
movq 0x90(%r12), %rax
movl 0x140(%rax), %eax
shlq $0x5, %rax
leaq 0x2988f(%rip), %rcx     # 0x40cf0
movq (%rax,%rcx), %rsi
movq %r14, %rdi
callq 0x43d0
movq 0x90(%r12), %rax
movl 0x140(%rax), %eax
shlq $0x5, %rax
leaq 0x2986a(%rip), %rcx     # 0x40cf0
movq 0x8(%rax,%rcx), %rax
addq %rax, %r14
incq %r14
leaq 0x10(%r12), %rdi
movb 0xc0(%r12), %al
movb %al, (%r14)
callq 0xe68e
movb $-0x1, %cl
testb %al, %al
je 0x174b4
movb 0x16c(%r12), %cl
movb %cl, 0x1(%r14)
addq $0x2, %r14
decl %r15d
jne 0x173f6
addq $0x10, %rbx
leaq 0x26c48(%rip), %r15     # 0x3e118
movq %r15, %rdi
callq 0x24712
pushq $0x5
popq %rsi
movq %r15, %rdi
callq 0x24724
leaq 0x2a786(%rip), %rsi     # 0x41c70
subl %esi, %r14d
movzwl %r14w, %edx
movq %r15, %rdi
callq 0x247b0
movq %rbx, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xc3a6
// File: /workspace/github_cpp_makefile_star2_O2/lotuskip[P]yuxtapa/server/game.cpp
// Function: (anonymous namespace)::player_left_team(std::_List_iterator<Player>)
void player_left_team(const list<Player>::iterator pit)
{
	pit->own_vp->move_watchers();
	if(!intermission)
	{
		if(pit->is_alive())
			kill_player(pit);
		Game::del_owneds(pit);
		Game::send_times(pit);
	}
	post_join_msg(pit);
	Game::send_team_upds(cur_players.end());
	active_teambal_check();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xd0(%rdi), %rdi
callq 0x19584
leaq 0x25c0b(%rip), %rax     # 0x3d400
cmpb $0x0, (%rax)
jne 0x1781f
leaq 0x10(%rbx), %rdi
callq 0xe68e
testb %al, %al
je 0x1780f
movq %rbx, %rdi
callq 0x1fe5c
movq %rbx, %rdi
callq 0x17b0c
movq %rbx, %rdi
callq 0x15ea4
movq %rbx, %rdi
callq 0x1789e
leaq 0x28882(%rip), %rdi     # 0x400b0
callq 0x152e9
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x17cd0
// File: /workspace/github_cpp_makefile_star2_O2/lotuskip[P]yuxtapa/server/game.cpp
// Function: (anonymous namespace)::check_class_limit(e_Team, e_Class)
bool check_class_limit(const e_Team t, const e_Class c)
{
	if(int_settings[IS_CLASSLIMIT])
	{
		unsigned char num = 0;
		for(list<Player>::const_iterator it = cur_players.begin();
			it != cur_players.end(); ++it)
		{
			// Note: checking next_cl, not current class!
			if((it->team == t || it->team == T_SPEC) && it->next_cl == c
				&& ++num == int_settings[IS_CLASSLIMIT])
				return true;
		}
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x28047(%rip), %rax     # 0x3f890
movl 0x10(%rax), %ecx
testl %ecx, %ecx
je 0x1789a
leaq 0x28859(%rip), %rdx     # 0x400b0
xorl %r8d, %r8d
movq %rdx, %r9
movq (%r9), %r9
cmpq %rdx, %r9
setne %al
je 0x1789c
movl 0xbc(%r9), %r10d
cmpl %edi, %r10d
setne %r11b
cmpl $0x2, %r10d
setne %r10b
testb %r10b, %r11b
jne 0x1785d
cmpl %esi, 0xc4(%r9)
jne 0x1785d
incb %r8b
movzbl %r8b, %r10d
cmpl %r10d, %ecx
jne 0x1785d
jmp 0x1789c
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/lotuskip[P]yuxtapa/server/game.cpp
// Function: (anonymous namespace)::post_spawn_msg(std::_List_const_iterator<Player>)
void post_spawn_msg(const list<Player>::const_iterator pit)
{
	string s = "You will spawn as a " + team_name[pit->team];
	s += ' ';
	s += classnames[pit->next_cl];
	s += '.';
	Network::construct_msg(s, team_colour[pit->team]);
	Network::send_to_player(*pit);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movl 0xbc(%rdi), %eax
shlq $0x5, %rax
leaq 0x298d5(%rip), %rdx     # 0x41220
addq %rax, %rdx
leaq 0x117ce(%rip), %rsi     # 0x29123
leaq -0x30(%rbp), %r14
movq %r14, %rdi
callq 0xde6a
pushq $0x20
popq %rsi
movq %r14, %rdi
callq 0x4340
movl 0xc4(%rbx), %eax
shlq $0x5, %rax
leaq 0x29943(%rip), %rsi     # 0x412c0
addq %rax, %rsi
leaq -0x30(%rbp), %rdi
callq 0x4790
leaq -0x30(%rbp), %rdi
pushq $0x2e
popq %rsi
callq 0x4340
movl 0xbc(%rbx), %eax
leaq 0x114fd(%rip), %rcx     # 0x28e9f
movzbl (%rax,%rcx), %esi
leaq -0x30(%rbp), %rdi
callq 0xc0f2
addq $0x10, %rbx
leaq 0x2675e(%rip), %rsi     # 0x3e118
movq %rbx, %rdi
callq 0xc3a6
leaq -0x30(%rbp), %rdi
callq 0x47e8
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x47e8
movq %rbx, %rdi
callq 0x4710
// File: /workspace/github_cpp_makefile_star2_O2/lotuskip[P]yuxtapa/server/game.cpp
// Function: Game::team_switch(std::_List_iterator<Player>)
void Game::team_switch(const list<Player>::iterator pit)
{
	if(pit->team != T_SPEC)
	{
		if(int_settings[IS_TEAMBALANCE] != TB_OFF
			&& num_players[pit->team] <= num_players[opp_team[pit->team]])
		{
			string s = "You cannot switch team at this time.";
		 	Network::construct_msg(s, team_colour[pit->team]);
		 	Network::send_to_player(*pit);
		}
		else // ok w.r.t. team balance
		{
			// do the change:
			--num_players[pit->team];
			++num_players[(pit->team = opp_team[pit->team])];

			// Switch class until find one not limited by classlimit (ALL of
			// them cannot be limited due to check in settings.cpp!)
			e_Class newcl = pit->next_cl;
			while(check_class_limit(pit->team, newcl))
			{
				if((newcl = e_Class(newcl + 1)) == NO_CLASS)
					newcl = e_Class(0);
			}
			pit->next_cl = newcl;

			player_left_team(pit);
			post_spawn_msg(pit);
			send_state_change(pit);
			pit->own_vp->clear_memory();
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl 0xbc(%rdi), %eax
cmpq $0x2, %rax
je 0x17aeb
movq %rdi, %rbx
leaq 0x27e7f(%rip), %rcx     # 0x3f890
cmpl $0x0, 0x4(%rcx)
leaq 0x297f5(%rip), %rcx     # 0x41211
movb (%rax,%rcx), %dl
leaq 0x1147e(%rip), %rsi     # 0x28ea4
movl (%rsi,%rax,4), %r14d
je 0x17a32
cmpb (%r14,%rcx), %dl
jbe 0x17a9f
decb %dl
movb %dl, (%rax,%rcx)
movl %r14d, 0xbc(%rbx)
incb (%r14,%rcx)
movl 0xc4(%rbx), %r15d
xorl %r12d, %r12d
movl %r14d, %edi
movl %r15d, %esi
callq 0x1783e
testb %al, %al
je 0x17a68
incl %r15d
cmpl $0xb, %r15d
cmovel %r12d, %r15d
jmp 0x17a4c
movl %r15d, 0xc4(%rbx)
movq %rbx, %rdi
callq 0x177d9
movq %rbx, %rdi
callq 0x1792c
movq %rbx, %rdi
callq 0x1732d
movq 0xd0(%rbx), %rdi
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x188f6
leaq 0x1160c(%rip), %rsi     # 0x290b2
leaq -0x48(%rbp), %r14
leaq -0x21(%rbp), %rdx
movq %r14, %rdi
callq 0xb292
movl 0xbc(%rbx), %eax
leaq 0x113dc(%rip), %rcx     # 0x28e9f
movzbl (%rax,%rcx), %esi
movq %r14, %rdi
callq 0xc0f2
addq $0x10, %rbx
leaq 0x2663e(%rip), %rsi     # 0x3e118
movq %rbx, %rdi
callq 0xc3a6
leaq -0x48(%rbp), %rdi
callq 0x47e8
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x47e8
movq %rbx, %rdi
callq 0x4710
// File: /workspace/github_cpp_makefile_star2_O2/lotuskip[P]yuxtapa/server/game.cpp
// Function: (anonymous namespace)::active_teambal_check()
void active_teambal_check()
{
	if(Config::int_settings[IS_TEAMBALANCE] == TB_ACTIVE)
	{
		if(abs(num_players[T_GREEN] - num_players[T_PURPLE]) >= 2)
		{
			// teams are unbalanced; were they already?
			if(!team_unbalance)
			{
				team_unbalance = true;
				time(&teams_unbal_since);
			}
			// in any case, give the request:
			Network::to_chat("The teams are unbalanced, please fix them!");
		}
		else // teams are balanced (once more)
			team_unbalance = false;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x28, %rsp
leaq 0x27bb0(%rip), %rax     # 0x3f890
cmpl $0x2, 0x4(%rax)
jne 0x17d4f
movzbl 0x29524(%rip), %eax     # 0x41211
movzbl 0x2951e(%rip), %ecx     # 0x41212
subl %ecx, %eax
movl %eax, %ecx
negl %ecx
cmovsl %eax, %ecx
cmpb $0x2, %cl
jb 0x17d48
cmpb $0x0, 0x2a767(%rip)     # 0x42470
jne 0x17d1e
movb $0x1, 0x2a75e(%rip)     # 0x42470
leaq 0x2a75f(%rip), %rdi     # 0x42478
callq 0x43c0
leaq 0x11413(%rip), %rsi     # 0x29138
leaq -0x30(%rbp), %rbx
leaq -0x9(%rbp), %rdx
movq %rbx, %rdi
callq 0xb292
movq %rbx, %rdi
callq 0xc248
leaq -0x30(%rbp), %rdi
callq 0x47e8
jmp 0x17d4f
movb $0x0, 0x2a721(%rip)     # 0x42470
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x47e8
movq %rbx, %rdi
callq 0x4710
// File: /workspace/github_cpp_makefile_star2_O2/lotuskip[P]yuxtapa/server/viewpoint.cpp
// Function: ViewPoint::newmap()
void ViewPoint::newmap()
{
	Game::curmap->make_right_size(ownview);
	// Fill empty; the tiles will be updated with the actual map data as they
	// become visible. The only thing we need from the actual map already at
	// this point are the lit statuses:
	Coords c;
	for(c.y = ownview.size()-1; c.y >= 0; --c.y)
	{
		for(c.x = ownview.size()-1; c.x >= 0; --c.x)
		{
			ownview[c.y][c.x] = EMPTY_TILE;
			if(Game::curmap->get_tile(c).flags & TF_LIT)
				ownview[c.y][c.x].flags |= TF_LIT;
		}
	}
	pos.x = pos.y = ownview.size()/2;
	poschanged = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x29424(%rip), %r15     # 0x41c58
movq (%r15), %rdi
leaq 0x8(%rbx), %r14
movq %r14, %rsi
callq 0x11cc0
leaq -0x1c(%rbp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x24d90
movq 0x10(%rbx), %rax
subq 0x8(%rbx), %rax
pushq $0x18
popq %rsi
cqto
idivq %rsi
movq %rax, %rcx
leal -0x1(%rcx), %eax
movw %ax, -0x1a(%rbp)
movq 0x10(%rbx), %rax
subq 0x8(%rbx), %rax
cqto
idivq %rsi
decw %cx
jns 0x188c9
jmp 0x188d4
movswq %cx, %rcx
movq (%r14), %rdx
imulq $0x18, %rcx, %rcx
movq (%rdx,%rcx), %rcx
movzwl %ax, %eax
movl $0x6d3f0004, (%rcx,%rax,4) # imm = 0x6D3F0004
movq (%r15), %rdx
movzwl -0x1c(%rbp), %eax
movzwl -0x1a(%rbp), %ecx
movswq %cx, %rdi
movq 0x8(%rdx), %r8
imulq $0x18, %rdi, %rdi
movswq %ax, %rdx
movq (%r8,%rdi), %r8
testb $0x10, (%r8,%rdx,4)
je 0x188c9
movq (%r14), %r8
movq (%r8,%rdi), %rdi
orw $0x10, (%rdi,%rdx,4)
decw %ax
movw %ax, -0x1c(%rbp)
jns 0x1887e
jmp 0x18863
shrl %eax
movw %ax, 0x4(%rbx)
movw %ax, 0x2(%rbx)
movb $0x1, 0x6(%rbx)
leaq -0x1c(%rbp), %rdi
callq 0x24d9e
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/lotuskip[P]yuxtapa/server/viewpoint.cpp
// Function: ViewPoint::clear_memory()
void ViewPoint::clear_memory()
{
	// Don't touch flags, so as to retain the lit statuses
	vector<Tile>::iterator ti;
	for(vector< vector<Tile> >::iterator i = ownview.begin(); i != ownview.end(); ++i)
	{
		for(ti = i->begin(); ti != i->end(); ++ti)
		{
			ti->cpair = EMPTY_TILE.cpair;
			ti->symbol = EMPTY_TILE.symbol;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rcx
cmpq %rcx, %rax
je 0x18925
movq (%rax), %rdx
movq 0x8(%rax), %rsi
cmpq %rsi, %rdx
je 0x1891f
movw $0x6d3f, 0x2(%rdx)      # imm = 0x6D3F
addq $0x4, %rdx
jmp 0x1890e
addq $0x18, %rax
jmp 0x18902
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/lotuskip[P]yuxtapa/server/viewpoint.cpp
// Function: ViewPoint::fill_loslittbl_xy(Coords const&, char, char, bool)
bool ViewPoint::fill_loslittbl_xy(const Coords &c, const char x, const char y,
	const bool vis_in_dark)
{
	// We might be outside of the map, in which case the next point in
	// this line will *also* be outside of the map; check:
	if(Game::curmap->point_out_of_map(c))
		return true;
	// else safe to fetch the tile:
	Tile *tp = &(ownview[c.y][c.x]);
	if(!loslittbl[x][y]) // not already considered
	{
		/* Determine lit status. Note that if the static lit status
		 * of the tile has changed (by a wall being dug out), the
		 * view won't notice this until the tile is within the
		 * "visible-even-if-not-lit" radius. This could be a bug,
		 * but we shall call it a feature. */
		if(tp->flags & TF_LIT // statically lit
			|| is_dynlit(c))
		{
			loslittbl[x][y] = IS_LIT|IN_LOS;
			// update our view of this tile:
			*tp = Game::curmap->get_tile(c);
		}
		else if(vis_in_dark) // not lit, still in LOS if in smaller radius
		{
			loslittbl[x][y] = IN_LOS;
			// upd our view of this tile:
			*tp = Game::curmap->get_tile(c);
		}
	}
	// see if need to continue on this ray:
	return !(tp->flags & TF_SEETHRU);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %r14d
movl %ecx, %r15d
movl %edx, %r12d
movq %rsi, %rbx
movq %rdi, %r13
leaq 0x2930c(%rip), %rax     # 0x41c58
movq (%rax), %rdi
callq 0x1256c
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x189d9
movl %r14d, -0x2c(%rbp)
movswq 0x2(%rbx), %rax
movq 0x8(%r13), %rcx
imulq $0x18, %rax, %rax
movswq (%rbx), %r13
movq (%rcx,%rax), %r14
movsbq %r12b, %rax
movsbq %r15b, %rcx
imulq $0x17, %rax, %rax
leaq 0x29e58(%rip), %r15     # 0x427e0
addq %rax, %r15
cmpb $0x0, (%rcx,%r15)
movzwl (%r14,%r13,4), %eax
jne 0x189d4
addq %rcx, %r15
testb $0x10, %al
jne 0x189aa
movq %rbx, %rdi
callq 0x1b84e
testb %al, %al
je 0x189e8
movb $0x3, (%r15)
leaq 0x292a3(%rip), %rax     # 0x41c58
movq (%rax), %rax
movswq 0x2(%rbx), %rcx
movq 0x8(%rax), %rax
imulq $0x18, %rcx, %rcx
movswq (%rbx), %rdx
movq (%rax,%rcx), %rax
movl (%rax,%rdx,4), %eax
movl %eax, (%r14,%r13,4)
testb $0x4, %al
sete %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpb $0x0, -0x2c(%rbp)
je 0x189f4
movb $0x1, (%r15)
jmp 0x189ae
movzwl (%r14,%r13,4), %eax
jmp 0x189d4
nop
// File: /workspace/github_cpp_makefile_star2_O2/lotuskip[P]yuxtapa/server/viewpoint.cpp
// Function: ViewPoint::render_pc_indir(Coords const&, char*) const
bool ViewPoint::render_pc_indir(const Coords &c, char* const target) const
{
	list<PCEnt>::iterator it = any_pc_at(c);
	if(it != PCs.end() && it->is_seen_by_team(owner->team) && !it->isvoid())
	{
		it->draw(target, false);
		return true;
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x1b9db
cmpq 0x23d9e(%rip), %rax     # 0x3cfa8
je 0x19221
movq 0x28(%r14), %rcx
movl 0x2c(%rax), %edx
cmpl 0xbc(%rcx), %edx
jne 0x19221
cmpb $0x0, 0x1e(%rax)
je 0x19228
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
addq $0x10, %rax
movq %rax, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x1c9e6
movb $0x1, %al
jmp 0x19223
nop
// File: /workspace/github_cpp_makefile_star2_O2/lotuskip[P]yuxtapa/server/viewpoint.cpp
// Function: ViewPoint::render_trap_at(Coords const&, char*, bool) const
bool ViewPoint::render_trap_at(const Coords &c, char* const target, const bool lit) const
{
	list<Trap>::iterator tr_it = any_trap_at(c);
	if(tr_it->is_seen_by(owner->team))
	{
		tr_it->draw(target, lit);
		return true;
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %r14d
movq %rdx, %rbx
movq %rdi, %r12
movq %rsi, %rdi
callq 0x1bae4
movq %rax, %r15
addq $0x10, %r15
movq 0x28(%r12), %rax
movzbl 0xbc(%rax), %esi
movq %r15, %rdi
callq 0x1cab8
movl %eax, %r12d
testb %al, %al
je 0x19453
movzbl %r14b, %edx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1c9e6
movl %r12d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/lotuskip[P]yuxtapa/server/viewpoint.cpp
// Function: ViewPoint::drop_watcher(unsigned short)
void ViewPoint::drop_watcher(const unsigned short ID)
{
	for(vector< list<Player>::iterator >::iterator it = followers.begin();
		it != followers.end(); ++it)
	{
		if((*it)->stats_i->ID == ID)
		{
			followers.erase(it);
			break;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rcx
addq $0x30, %rdi
movq 0x30(%rcx), %rax
movq 0x38(%rcx), %rcx
cmpq %rcx, %rax
je 0x19578
movq (%rax), %rdx
movq 0x90(%rdx), %rdx
cmpw %si, 0x10(%rdx)
je 0x1957a
addq $0x8, %rax
jmp 0x1955d
popq %rbp
retq
movq %rax, %rsi
popq %rbp
jmp 0x1971c
nop
// File: /workspace/github_cpp_makefile_star2_O2/lotuskip[P]yuxtapa/server/viewpoint.cpp
// Function: ViewPoint::move_watchers()
void ViewPoint::move_watchers()
{
	vector< list<Player>::iterator >::iterator it = followers.begin();
	while(it != followers.end())
	{
		if(*it != owner)
		{
			(*it)->own_vp->set_pos(pos);
			((*it)->viewn_vp = (*it)->own_vp)->add_watcher((*it));
			it = followers.erase(it);
		}
		else
			++it;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x30(%rdi), %r14
movq 0x30(%rdi), %r12
leaq 0x2(%rdi), %r15
cmpq 0x38(%rbx), %r12
je 0x195ee
movq (%r12), %rax
cmpq 0x28(%rbx), %rax
je 0x195e8
movq 0xd0(%rax), %rdi
movq %r15, %rsi
callq 0x194b2
movq (%r12), %rax
movq 0xd0(%rax), %rdi
movq %rdi, 0xd8(%rax)
movq (%r12), %rsi
callq 0x19522
movq %r14, %rdi
movq %r12, %rsi
callq 0x1971c
movq %rax, %r12
jmp 0x1959e
addq $0x8, %r12
jmp 0x1959e
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/lotuskip[P]yuxtapa/server/actives.cpp
// Function: events_around(Coords const&)
bool events_around(const Coords &pos)
{
	for(set<Coords>::const_iterator it = event_set.begin();
		it != event_set.end(); ++it)
	{
		if(it->dist_walk(pos) <= VIEWSIZE/2)
			return true;
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28e0c(%rip), %r14     # 0x42fe0
leaq 0x28df5(%rip), %r15     # 0x42fd0
cmpq %r15, %r14
je 0x1a1ff
leaq 0x20(%r14), %rdi
movq %rbx, %rsi
callq 0x24dd8
cmpw $0xc, %ax
jl 0x1a1ff
movq %r14, %rdi
callq 0x4460
movq %rax, %r14
jmp 0x1a1db
cmpq %r15, %r14
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/lotuskip[P]yuxtapa/server/actives.cpp
// Function: (anonymous namespace)::next_unused_tile(Coords&, std::vector<Coords, std::allocator<Coords>>&, bool)
void next_unused_tile(Coords &c, vector<Coords> &useds, const bool force = false)
{
	init_nearby(c);
	if(force)
	{
		// find first not yet used:
		while(find(useds.begin(), useds.end(), c) != useds.end())
			c = next_nearby();
		if(all_placem_syms.find(Game::curmap->get_tile(c).symbol) == string::npos)
			*(Game::curmap->mod_tile(c)) = T_FLOOR; // change the map to force placement
	}
	else
	{
		// Find next (A) unused and (B) free spot
		while(find(useds.begin(), useds.end(), c) != useds.end()
			|| all_placem_syms.find(Game::curmap->get_tile(c).symbol) == string::npos)
			c = next_nearby();
	}
	// Found it:
	useds.push_back(c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
callq 0x1d501
testl %r15d, %r15d
je 0x1ad61
leaq -0x30(%rbp), %r15
movq (%r14), %rdi
movq 0x8(%r14), %rsi
movq %rbx, %rdx
callq 0x13f33
cmpq 0x8(%r14), %rax
je 0x1adcd
movq %r15, %rdi
callq 0x1d529
movl -0x30(%rbp), %eax
movl %eax, (%rbx)
movq %r15, %rdi
callq 0x24d9e
jmp 0x1ad31
leaq 0x26ef0(%rip), %r13     # 0x41c58
leaq 0x28019(%rip), %r15     # 0x42d88
leaq -0x2c(%rbp), %r12
movq (%r14), %rdi
movq 0x8(%r14), %rsi
movq %rbx, %rdx
callq 0x13f33
cmpq 0x8(%r14), %rax
jne 0x1adb6
movq (%r13), %rax
movswq 0x2(%rbx), %rcx
movq 0x8(%rax), %rax
imulq $0x18, %rcx, %rcx
movswq (%rbx), %rdx
movq (%rax,%rcx), %rax
movsbl 0x2(%rax,%rdx,4), %esi
movq %r15, %rdi
xorl %edx, %edx
callq 0x4560
cmpq $-0x1, %rax
jne 0x1ae24
movq %r12, %rdi
callq 0x1d529
movl -0x2c(%rbp), %eax
movl %eax, (%rbx)
movq %r12, %rdi
callq 0x24d9e
jmp 0x1ad73
leaq 0x26e84(%rip), %r15     # 0x41c58
movq (%r15), %rax
movswq 0x2(%rbx), %rcx
movq 0x8(%rax), %rax
imulq $0x18, %rcx, %rcx
movswq (%rbx), %rdx
movq (%rax,%rcx), %rax
movsbl 0x2(%rax,%rdx,4), %esi
leaq 0x27f90(%rip), %rdi     # 0x42d88
xorl %edx, %edx
callq 0x4560
cmpq $-0x1, %rax
jne 0x1ae24
movq (%r15), %rax
movswq 0x2(%rbx), %rcx
movq 0x8(%rax), %rax
imulq $0x18, %rcx, %rcx
movswq (%rbx), %rdx
movq (%rax,%rcx), %rax
movl $0x1c2e0005, (%rax,%rdx,4) # imm = 0x1C2E0005
movq %r14, %rdi
movq %rbx, %rsi
callq 0x139a6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/lotuskip[P]yuxtapa/server/actives.cpp
// Function: clear_action_inds()
void clear_action_inds()
{
	map<Coords, unsigned char>::iterator it = axn_indicators.begin();
	while(it != axn_indicators.end())
	{
		if(it->second < NUM_ACTIONS)
		{
			Game::curmap->mod_tile(it->first)->flags &= ~(TF_ACTION);
			event_set.insert(it->first);
			axn_indicators.erase(it++);
		}
		else
		{
			it->second -= NUM_ACTIONS;
			++it;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x27dc7(%rip), %r15     # 0x42f38
leaq 0x27db0(%rip), %r13     # 0x42f28
leaq 0x27e49(%rip), %rbx     # 0x42fc8
leaq 0x27d9a(%rip), %r14     # 0x42f20
cmpq %r13, %r15
je 0x1b1f3
movb 0x24(%r15), %al
cmpb $0x5, %al
ja 0x1b1e0
leaq 0x20(%r15), %rsi
leaq 0x26aba(%rip), %rax     # 0x41c58
movq (%rax), %rax
movswq 0x22(%r15), %rcx
movq 0x8(%rax), %rax
imulq $0x18, %rcx, %rcx
movswq 0x20(%r15), %rdx
movq (%rax,%rcx), %rax
andw $0xff7f, (%rax,%rdx,4)  # imm = 0xFF7F
movq %rbx, %rdi
callq 0x1c558
movq %r15, %rdi
callq 0x4260
movq %rax, %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x1c63a
movq %r12, %r15
jmp 0x1b186
addb $-0x6, %al
movb %al, 0x24(%r15)
movq %r15, %rdi
callq 0x4260
movq %rax, %r15
jmp 0x1b186
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/lotuskip[P]yuxtapa/server/actives.cpp
// Function: clear_sounds()
void clear_sounds()
{
	for(map<Coords, e_Sound>::const_iterator sit = reg_sounds.begin();
		sit != reg_sounds.end(); ++sit)
	{
		Game::curmap->mod_tile(sit->first)->flags &= ~(TF_SOUND);
		event_set.insert(sit->first);
	}
	reg_sounds.clear();
	for(map<Coords, string>::const_iterator vit = voices.begin();
		vit != voices.end(); ++vit)
	{
		Game::curmap->mod_tile(vit->first)->flags &= ~(TF_SOUND);
		event_set.insert(vit->first);
	}
	voices.clear();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x27c9e(%rip), %r14     # 0x42f68
leaq 0x27c87(%rip), %r12     # 0x42f58
leaq 0x26980(%rip), %r15     # 0x41c58
leaq 0x27ce9(%rip), %rbx     # 0x42fc8
cmpq %r12, %r14
je 0x1b31c
movq (%r15), %rax
leaq 0x20(%r14), %rsi
movswq 0x22(%r14), %rcx
movq 0x8(%rax), %rax
imulq $0x18, %rcx, %rcx
movswq 0x20(%r14), %rdx
movq (%rax,%rcx), %rax
andw $0xfeff, (%rax,%rdx,4)  # imm = 0xFEFF
movq %rbx, %rdi
callq 0x1c558
movq %r14, %rdi
callq 0x4460
movq %rax, %r14
jmp 0x1b2df
leaq 0x27c2d(%rip), %rdi     # 0x42f50
callq 0x1826a
movq 0x27c69(%rip), %r14     # 0x42f98
leaq 0x27c52(%rip), %r12     # 0x42f88
leaq 0x27c8b(%rip), %rbx     # 0x42fc8
cmpq %r12, %r14
je 0x1b37a
movq (%r15), %rax
leaq 0x20(%r14), %rsi
movswq 0x22(%r14), %rcx
movq 0x8(%rax), %rax
imulq $0x18, %rcx, %rcx
movswq 0x20(%r14), %rdx
movq (%rax,%rcx), %rax
andw $0xfeff, (%rax,%rdx,4)  # imm = 0xFEFF
movq %rbx, %rdi
callq 0x1c558
movq %r14, %rdi
callq 0x4460
movq %rax, %r14
jmp 0x1b33d
leaq 0x27bff(%rip), %rdi     # 0x42f80
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x18306
// File: /workspace/github_cpp_makefile_star2_O2/lotuskip[P]yuxtapa/server/actives.cpp
// Function: update_static_light(Coords const&)
void update_static_light(const Coords &c)
{
	// Run the algorithm on two base radii to cover all spots.
	/* NOTE: this works for TORCH_LIGHT_RADIUS 7-9; if it is <=6 or >=10,
	 * adjustments are called for! */
	update_static_light_r(c, TORCH_LIGHT_RADIUS);
	update_static_light_r(c, TORCH_LIGHT_RADIUS-1);
	update_static_light_r(c, TORCH_LIGHT_RADIUS-2);
	// the LOS-algorithm doesn't consider the position itself:
	Game::curmap->mod_tile(c)->flags |= TF_LIT;	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x8
popq %rsi
callq 0x1b3e0
pushq $0x7
popq %rsi
movq %rbx, %rdi
callq 0x1b3e0
pushq $0x6
popq %rsi
movq %rbx, %rdi
callq 0x1b3e0
leaq 0x2689c(%rip), %rax     # 0x41c58
movq (%rax), %rax
movswq 0x2(%rbx), %rcx
movq 0x8(%rax), %rax
imulq $0x18, %rcx, %rcx
movswq (%rbx), %rdx
movq (%rax,%rcx), %rax
orw $0x10, (%rax,%rdx,4)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/lotuskip[P]yuxtapa/server/actives.cpp
// Function: render_occent_at(Coords const&, char*, bool)
bool render_occent_at(const Coords &c, char *target, const bool lit)
{
	for(list<OccEnt>::const_iterator b_it = boulders.begin();
		b_it != boulders.end(); ++b_it)
	{
		if(b_it->getpos() == c)
		{
			b_it->draw(target, lit);
			return true;
		}
	}
	for(list<Arrow>::const_iterator a_it = arrows.begin();
		a_it != arrows.end(); ++a_it)
	{
		if(a_it->getpos() == c)
		{
			a_it->draw(target, lit);
			return true;
		}
	}
	// NOTE: passing false to mms and zaps since they are self-lighting and
	// thus have no separate "lit colour"
	for(list<MM>::const_iterator m_it = MMs.begin(); m_it != MMs.end(); ++m_it)
	{
		if(m_it->getpos() == c)
		{
			m_it->draw(target, false);
			return true;
		}
	}
	for(list<Zap>::const_iterator z_it = zaps.begin(); z_it != zaps.end(); ++z_it)
	{
		if(z_it->getpos() == c)
		{
			z_it->draw(target, false);
			return true;
		}
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, -0x30(%rbp)
movq %rsi, -0x38(%rbp)
movq %rdi, %r15
leaq 0x27832(%rip), %r12     # 0x42e70
leaq -0x2c(%rbp), %r13
movq %r12, %r14
movq (%r14), %r14
cmpq %r12, %r14
je 0x1b66f
movl 0x18(%r14), %eax
movl %eax, -0x2c(%rbp)
movq %r13, %rdi
movq %r15, %rsi
callq 0x24f42
movl %eax, %ebx
movq %r13, %rdi
callq 0x24d9e
testb %bl, %bl
je 0x1b645
jmp 0x1b6a5
leaq 0x27812(%rip), %r12     # 0x42e88
leaq -0x2c(%rbp), %r13
movq %r12, %r14
movq (%r14), %r14
cmpq %r12, %r14
je 0x1b6aa
movl 0x18(%r14), %eax
movl %eax, -0x2c(%rbp)
movq %r13, %rdi
movq %r15, %rsi
callq 0x24f42
movl %eax, %ebx
movq %r13, %rdi
callq 0x24d9e
testb %bl, %bl
je 0x1b67d
movl -0x30(%rbp), %eax
jmp 0x1b71a
leaq 0x277ef(%rip), %r13     # 0x42ea0
leaq -0x2c(%rbp), %r12
movq %r13, %r14
movq (%r14), %r14
cmpq %r13, %r14
je 0x1b6e2
movl 0x18(%r14), %eax
movl %eax, -0x2c(%rbp)
movq %r12, %rdi
movq %r15, %rsi
callq 0x24f42
movl %eax, %ebx
movq %r12, %rdi
callq 0x24d9e
testb %bl, %bl
je 0x1b6b8
jmp 0x1b718
leaq 0x277cf(%rip), %r13     # 0x42eb8
leaq -0x2c(%rbp), %r12
movq %r13, %r14
movq (%r14), %r14
cmpq %r13, %r14
je 0x1b73e
movl 0x18(%r14), %eax
movl %eax, -0x2c(%rbp)
movq %r12, %rdi
movq %r15, %rsi
callq 0x24f42
movl %eax, %ebx
movq %r12, %rdi
callq 0x24d9e
testb %bl, %bl
je 0x1b6f0
xorl %eax, %eax
addq $0x10, %r14
movzbl %al, %edx
movq %r14, %rdi
movq -0x38(%rbp), %rsi
callq 0x1c9e6
movb $0x1, %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0x1b72f
jmp 0x1b748
jmp 0x1b748
jmp 0x1b748
movq %rax, %rbx
leaq -0x2c(%rbp), %rdi
callq 0x24d9e
movq %rbx, %rdi
callq 0x4710
// File: /workspace/github_cpp_makefile_star2_O2/lotuskip[P]yuxtapa/server/actives.cpp
// Function: render_noccent_at(Coords const&, char*, bool)
void render_noccent_at(const Coords &c, char *target, const bool lit)
{
	list<NOccEnt>::const_iterator it;
	// NOTE: do not draw traps here.
	for(char i = NOE_CORPSE; i < NOE_TORCH; ++i)
	{
		for(it = noccents[i].begin(); it != noccents[i].end(); ++it)
		{
			if(it->getpos() == c)
			{
				it->draw(target, lit);
				return;
			}
		}
	}
	// NOTE: passing false to torches always since they are self-lighting and
	// thus have no separate "lit colour"
	for(it = noccents[NOE_TORCH].begin(); it != noccents[NOE_TORCH].end(); ++it)
	{
		if(it->getpos() == c)
		{
			it->draw(target, false);
			return;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, -0x34(%rbp)
movq %rsi, -0x40(%rbp)
movq %rdi, %r14
xorl %eax, %eax
leaq 0x27630(%rip), %rcx     # 0x42db0
leaq -0x30(%rbp), %r13
cmpq $0x6, %rax
je 0x1b7f7
movq %rax, -0x48(%rbp)
imulq $0x18, %rax, %r12
addq %rcx, %r12
movq %r12, %r15
movq (%r15), %r15
cmpq %r12, %r15
je 0x1b7c2
movl 0x18(%r15), %eax
movl %eax, -0x30(%rbp)
movq %r13, %rdi
movq %r14, %rsi
callq 0x24f42
movl %eax, %ebx
movq %r13, %rdi
callq 0x24d9e
testb %bl, %bl
je 0x1b798
jmp 0x1b7d2
movq -0x48(%rbp), %rax
incq %rax
leaq 0x275e0(%rip), %rcx     # 0x42db0
jmp 0x1b784
movl -0x34(%rbp), %eax
addq $0x10, %r15
movzbl %al, %edx
movq %r15, %rdi
movq -0x40(%rbp), %rsi
callq 0x1c9e6
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x27642(%rip), %r13     # 0x42e40
leaq -0x2c(%rbp), %r12
movq %r13, %r15
movq (%r15), %r15
cmpq %r13, %r15
je 0x1b7e8
movl 0x18(%r15), %eax
movl %eax, -0x2c(%rbp)
movq %r12, %rdi
movq %r14, %rsi
callq 0x24f42
movl %eax, %ebx
movq %r12, %rdi
callq 0x24d9e
testb %bl, %bl
je 0x1b805
xorl %eax, %eax
jmp 0x1b7d5
movq %rax, %rbx
leaq -0x2c(%rbp), %rdi
jmp 0x1b841
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x24d9e
movq %rbx, %rdi
callq 0x4710
// File: /workspace/github_cpp_makefile_star2_O2/lotuskip[P]yuxtapa/server/actives.cpp
// Function: any_pc_at(Coords const&)
list<PCEnt>::iterator any_pc_at(const Coords &c)
{
	list<PCEnt>::iterator it;
	for(it = PCs.begin(); it != PCs.end(); ++it)
	{
		if(it->getpos() == c && !it->isvoid())
			break;
	}
	return it;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x274dd(%rip), %r12     # 0x42ed0
leaq -0x2c(%rbp), %r15
movq %r12, %r14
movq (%r14), %r14
cmpq %r12, %r14
je 0x1ba35
movl 0x18(%r14), %eax
movl %eax, -0x2c(%rbp)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x24f42
testb %al, %al
je 0x1ba2b
movb 0x1e(%r14), %r13b
movq %r15, %rdi
callq 0x24d9e
testb %r13b, %r13b
jne 0x1b9fa
jmp 0x1ba35
movq %r15, %rdi
callq 0x24d9e
jmp 0x1b9fa
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x2c(%rbp), %rdi
callq 0x24d9e
movq %rbx, %rdi
callq 0x4710
// File: /workspace/github_cpp_makefile_star2_O2/lotuskip[P]yuxtapa/server/actives.cpp
// Function: any_noccent_at(Coords const&, e_Noccent)
list<NOccEnt>::iterator any_noccent_at(const Coords &c, const e_Noccent type)
{
	list<NOccEnt>::iterator it;
	for(it = noccents[type].begin(); it != noccents[type].end(); ++it)
	{
		// actually, most noccents are never voided, but we make the check for all
		if(it->getpos() == c && !it->isvoid())
			break;
	}
	return it;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, %eax
imulq $0x18, %rax, %rax
leaq 0x27337(%rip), %r12     # 0x42db0
addq %rax, %r12
leaq -0x2c(%rbp), %r15
movq %r12, %r14
movq (%r14), %r14
cmpq %r12, %r14
je 0x1babe
movl 0x18(%r14), %eax
movl %eax, -0x2c(%rbp)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x24f42
testb %al, %al
je 0x1bab4
movb 0x1e(%r14), %r13b
movq %r15, %rdi
callq 0x24d9e
testb %r13b, %r13b
jne 0x1ba83
jmp 0x1babe
movq %r15, %rdi
callq 0x24d9e
jmp 0x1ba83
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x2c(%rbp), %rdi
callq 0x24d9e
movq %rbx, %rdi
callq 0x4710