LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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
movw $0x0, 0x2a475(%rip)     # 0x45490
leaq 0x2ae5e(%rip), %r14     # 0x45e80
movq (%r14), %r15
cmpq %r14, %r15
je 0x1b07d
leaq -0x2c(%rbp), %rbx
movb 0x1e(%r15), %r12b
testb %r12b, %r12b
je 0x1b03c
xorl %r13d, %r13d
jmp 0x1b05c
movq 0x29c25(%rip), %rdi     # 0x44c68
movl 0x18(%r15), %eax
movl %eax, -0x2c(%rbp)
movq %rbx, %rsi
callq 0x17406
cmpl 0x253cc(%rip), %eax     # 0x40424
sete %r13b
testb %r12b, %r12b
jne 0x1b069
movq %rbx, %rdi
callq 0x2bbf6
testb %r13b, %r13b
je 0x1b075
incw 0x2a41b(%rip)           # 0x45490
movq (%r15), %r15
cmpq %r14, %r15
jne 0x1b02e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x2c(%rbp), %rdi
callq 0x2bbf6
movq %rbx, %rdi
callq 0x4750
// File: /workspace/github_cpp_makefile_star2_O1/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, 0x29bc2(%rip)     # 0x44c70
je 0x1b0b7
callq 0x1aafc
jmp 0x1b0a7
movl 0x29167(%rip), %ecx     # 0x44224
leaq 0x13d10(%rip), %rax     # 0x2edd4
movsbl (%rcx,%rax), %eax
imull $0xea60, %eax, %eax     # imm = 0xEA60
leaq 0x277cb(%rip), %rsi     # 0x428a0
xorl %edx, %edx
divl 0x14(%rsi)
movw %ax, 0x25347(%rip)      # 0x40428
movzwl %ax, %edi
movq 0x29b7d(%rip), %rdx     # 0x44c68
movswl (%rdx), %edx
movl %edx, %esi
shll $0x4, %esi
subl %edx, %esi
subl %edx, %esi
cmpl %esi, %edi
jl 0x1b11a
movzwl %ax, %eax
leal (%rdx,%rdx,4), %esi
leal (%rsi,%rsi,2), %esi
addl $0xb54, %esi            # imm = 0xB54
cmpl %eax, %esi
jge 0x1b121
leal (%rdx,%rdx,4), %eax
leal (%rax,%rax,2), %esi
addl $0xb54, %esi            # imm = 0xB54
movw %si, 0x25307(%rip)      # 0x40428
cmpl $0x2, %ecx
jne 0x1b149
movq 0x29b1b(%rip), %rcx     # 0x44c48
cmpq $0x4, %rcx
jbe 0x1b1a2
movq $0x5, 0x29b0a(%rip) # 0x44c48
movq 0x29afb(%rip), %rax     # 0x44c40
movb $0x0, 0x5(%rax)
leaq 0x27f70(%rip), %rbx     # 0x430c0
movq %rbx, %rdi
callq 0x1b1bc
movq %rbx, %rdi
callq 0x19f7b
movq %rbx, %rdi
callq 0x1b30b
movq (%rbx), %r14
cmpq %rbx, %r14
je 0x1b19d
xorl %edi, %edi
callq 0x43b0
leaq 0xc8(%r14), %rdi
subq 0xc8(%r14), %rax
movq 0x90(%r14), %rcx
addq %rax, 0x138(%rcx)
callq 0x43b0
movq (%r14), %r14
jmp 0x1b16b
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x11560(%rip), %rdi     # 0x2c709
leaq 0x11545(%rip), %rsi     # 0x2c6f5
movl $0x5, %edx
xorl %eax, %eax
callq 0x4610
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x13ebc
leaq 0x25f4e(%rip), %r14     # 0x41128
movq %r14, %rdi
callq 0x2b340
movq %r14, %rdi
movl $0xe, %esi
callq 0x2b354
movzwl 0x25232(%rip), %eax     # 0x40428
movzwl 0x29a63(%rip), %ecx     # 0x44c60
subl %ecx, %eax
leaq 0x2769a(%rip), %r15     # 0x428a0
imull 0x14(%r15), %eax
imulq $0x10624dd3, %rax, %rax # imm = 0x10624DD3
shrq $0x26, %rax
movzwl %ax, %esi
movq %r14, %rdi
callq 0x2b368
movzbl 0x29a4c(%rip), %esi     # 0x44c74
movzwl 0x29a31(%rip), %ecx     # 0x44c60
movl %esi, %eax
shrl %eax
addl %ecx, %eax
xorl %edx, %edx
divl %esi
movl %esi, %eax
subl %edx, %eax
movl 0x14(%r15), %edi
imull %edi, %eax
imulq $0x10624dd3, %rax, %rax # imm = 0x10624DD3
shrq $0x26, %rax
movb %al, -0x23(%rbp)
movl %ecx, %eax
xorl %edx, %edx
divl %esi
subl %edx, %esi
imull %edi, %esi
imulq $0x10624dd3, %rsi, %rax # imm = 0x10624DD3
shrq $0x26, %rax
movb %al, -0x22(%rbp)
movb $0x0, -0x21(%rbp)
cmpq 0x24d42(%rip), %rbx     # 0x3ffb8
je 0x1b2ad
movl 0xbc(%rbx), %eax
addq $0x10, %rbx
movzbl -0x23(%rbp,%rax), %esi
leaq 0x25e9a(%rip), %r14     # 0x41128
movq %r14, %rdi
callq 0x2b354
movq %rbx, %rdi
movq %r14, %rsi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xf816
leaq 0x27e0c(%rip), %r15     # 0x430c0
movq (%r15), %r12
cmpq %r15, %r12
je 0x1b2fe
leaq 0x25e65(%rip), %rbx     # 0x41128
movq %rbx, %rdi
movl $0x3, %esi
callq 0x2b54e
leaq 0x10(%r12), %r14
movl 0xbc(%r12), %eax
movzbl -0x23(%rbp,%rax), %esi
movq %rbx, %rdi
callq 0x2b354
movq %r14, %rdi
movq %rbx, %rsi
callq 0xf816
movq (%r12), %r12
cmpq %r15, %r12
jne 0x1b2c3
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2aa87(%rip), %r12     # 0x45dc0
movq 0x78(%r12), %r13
addq $0x78, %r12
cmpq %r12, %r13
je 0x1b3ae
leaq -0x2c(%rbp), %r14
leaq 0x2abae(%rip), %rbx     # 0x45f00
movq 0x2990f(%rip), %rdi     # 0x44c68
movl 0x18(%r13), %eax
movl %eax, -0x2c(%rbp)
movq %r14, %rsi
callq 0x17406
movl %eax, %r15d
movq %r14, %rdi
callq 0x2bbf6
movsbq 0x1f(%r13), %rcx
movb $0x27, %al
cmpq $0x3, %rcx
je 0x1b39a
leaq (%rcx,%rcx,2), %rax
movq 0x8(%rbx,%rax,8), %rdx
movl $0x14, %eax
cmpq 0x10(%rdx), %r13
je 0x1b396
xorl %eax, %eax
addb %cl, %al
addb $0x1e, %al
movl %r15d, %ecx
movsbq %cl, %rcx
movb %al, -0x38(%rbp,%rcx)
movq (%r13), %r13
cmpq %r12, %r13
jne 0x1b352
leaq 0x25d73(%rip), %r14     # 0x41128
movq %r14, %rdi
callq 0x2b340
movq %r14, %rdi
movl $0xf, %esi
callq 0x2b354
xorl %ebx, %ebx
movzbl -0x38(%rbp,%rbx), %esi
movq %r14, %rdi
callq 0x2b354
incq %rbx
cmpq $0x9, %rbx
jne 0x1b3cc
movq -0x40(%rbp), %rdi
cmpq 0x24bcb(%rip), %rdi     # 0x3ffb8
je 0x1b401
addq $0x10, %rdi
leaq 0x25d2e(%rip), %rsi     # 0x41128
callq 0xf816
jmp 0x1b412
leaq 0x25d20(%rip), %rsi     # 0x41128
movl $0xffff, %edi           # imm = 0xFFFF
callq 0xe383
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x2c(%rbp), %rdi
callq 0x2bbf6
movq %rbx, %rdi
callq 0x4750
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1c2ac
addl $0xfffb, %eax           # imm = 0xFFFB
movzwl %ax, %eax
movswl 0xc0(%rbx), %ecx
cmpl %ecx, %eax
jne 0x1c2ba
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x22ce8
movq %rbx, %rdi
callq 0x19c91
addq $0xe8, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1d788
// File: /workspace/github_cpp_makefile_star2_O1/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 0x24e3d(%rip), %r15     # 0x41128
movq %r15, %rdi
callq 0x2b340
movq %r15, %rdi
movl $0xb, %esi
callq 0x2b354
leaq 0x10(%rbx), %r14
movzbl 0x153(%rbx), %esi
movq %r15, %rdi
callq 0x2b354
movzbl 0x154(%rbx), %esi
movq %r15, %rdi
callq 0x2b354
movzbl 0x157(%rbx), %esi
movq %r15, %rdi
callq 0x2b354
movzbl 0x158(%rbx), %esi
movq %r15, %rdi
callq 0x2b354
movq 0x160(%rbx), %rax
xorl %esi, %esi
cmpq 0x23c68(%rip), %rax     # 0x3ffb8
setne %sil
movq %r15, %rdi
callq 0x2b354
movzbl 0x16c(%rbx), %esi
movq %r15, %rdi
callq 0x2b354
movq %r14, %rdi
callq 0x125e6
testb %al, %al
je 0x1c383
movq 0x148(%rbx), %rax
movb 0x20(%rax), %al
jmp 0x1c385
xorl %eax, %eax
movzbl %al, %esi
movq %r14, %rdi
callq 0x126f0
movzbl %al, %esi
leaq 0x24d8e(%rip), %r15     # 0x41128
movq %r15, %rdi
callq 0x2b354
movq %r14, %rdi
movq %r15, %rsi
callq 0xf816
movb $0x0, 0x15d(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x246f1(%rip), %r14     # 0x41128
movq %r14, %rdi
callq 0x2b340
movq %r14, %rdi
movl $0xc, %esi
callq 0x2b354
leaq 0x10(%rbx), %r15
movzbl 0xc4(%rbx), %esi
movq %r14, %rdi
callq 0x2b354
movzbl 0xbc(%rbx), %esi
movq %r14, %rdi
callq 0x2b354
movq %r15, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xf816
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1ee1c
leaq 0x234dd(%rip), %rax     # 0x40410
cmpb $0x0, (%rax)
jne 0x1cf5d
leaq 0x10(%rbx), %rdi
callq 0x125e6
testb %al, %al
je 0x1cf4d
movq %rbx, %rdi
callq 0x2589b
movq %rbx, %rdi
callq 0x1d361
movq %rbx, %rdi
callq 0x1b1bc
movq %rbx, %rdi
callq 0x1cfed
leaq 0x26154(%rip), %rdi     # 0x430c0
callq 0x19f7b
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1d51a
// File: /workspace/github_cpp_makefile_star2_O1/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 0x25919(%rip), %rax     # 0x428a0
movl 0x10(%rax), %eax
testl %eax, %eax
je 0x1cfdf
leaq 0x2612b(%rip), %rcx     # 0x430c0
movq (%rcx), %rdx
cmpq %rcx, %rdx
sete %r9b
je 0x1cfdf
xorl %r8d, %r8d
movl 0xbc(%rdx), %r10d
cmpl %edi, %r10d
setne %r11b
cmpl $0x2, %r10d
setne %r10b
testb %r10b, %r11b
jne 0x1cfd3
cmpl %esi, 0xc4(%rdx)
jne 0x1cfd3
incb %r8b
movzbl %r8b, %r10d
cmpl %r10d, %eax
je 0x1cfe3
movq (%rdx), %rdx
cmpq %rcx, %rdx
sete %r9b
jne 0x1cfa4
xorl %eax, %eax
popq %rbp
retq
movb $0x1, %al
testb $0x1, %r9b
jne 0x1cfdf
jmp 0x1cfe1
// File: /workspace/github_cpp_makefile_star2_O1/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 0x27101(%rip), %rdx     # 0x44230
addq %rax, %rdx
leaq 0x11fb1(%rip), %rsi     # 0x2f0ea
leaq -0x30(%rbp), %r14
movq %r14, %rdi
callq 0x11dd6
movq %r14, %rdi
movl $0x20, %esi
callq 0x4340
movl 0xc4(%rbx), %eax
shlq $0x5, %rax
leaq 0x2716d(%rip), %rcx     # 0x442d0
movq (%rax,%rcx), %rsi
movq 0x8(%rax,%rcx), %rdx
leaq -0x30(%rbp), %rdi
callq 0x4130
leaq -0x30(%rbp), %rdi
movl $0x2e, %esi
callq 0x4340
movl 0xbc(%rbx), %eax
leaq 0x11cdf(%rip), %rcx     # 0x2ee6f
movzbl (%rax,%rcx), %esi
leaq -0x30(%rbp), %rdi
callq 0xf4ed
addq $0x10, %rbx
leaq 0x23f80(%rip), %rsi     # 0x41128
movq %rbx, %rdi
callq 0xf816
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1d1c9
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x43f0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1d1ee
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x43f0
movq %rbx, %rdi
callq 0x4750
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x20, %rsp
movl 0xbc(%rdi), %eax
cmpq $0x2, %rax
jne 0x1d21e
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %rbx
leaq 0x25678(%rip), %rcx     # 0x428a0
cmpl $0x0, 0x4(%rcx)
je 0x1d24b
leaq 0x26fec(%rip), %rcx     # 0x44221
movb (%rax,%rcx), %dl
leaq 0x11c35(%rip), %rsi     # 0x2ee74
movl (%rsi,%rax,4), %esi
cmpb (%rsi,%rcx), %dl
jbe 0x1d2d5
leaq 0x26fcf(%rip), %rcx     # 0x44221
decb (%rax,%rcx)
leaq 0x11c18(%rip), %rdx     # 0x2ee74
movl (%rdx,%rax,4), %r15d
movl %r15d, 0xbc(%rbx)
incb (%r15,%rcx)
movl 0xc4(%rbx), %r14d
movl %r15d, %edi
movl %r14d, %esi
callq 0x1cf7c
testb %al, %al
je 0x1d29e
xorl %r12d, %r12d
incl %r14d
cmpl $0xb, %r14d
cmovel %r12d, %r14d
movl %r15d, %edi
movl %r14d, %esi
callq 0x1cf7c
testb %al, %al
jne 0x1d284
movl %r14d, 0xc4(%rbx)
movq %rbx, %rdi
callq 0x1cf17
movq %rbx, %rdi
callq 0x1d110
movq %rbx, %rdi
callq 0x1ca23
movq 0xd0(%rbx), %rdi
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1dfda
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x11d95(%rip), %rsi     # 0x2f079
leaq 0x11db2(%rip), %rdx     # 0x2f09d
leaq -0x40(%rbp), %r14
movq %r14, %rdi
callq 0xdfec
movl 0xbc(%rbx), %eax
leaq 0x11b6b(%rip), %rcx     # 0x2ee6f
movzbl (%rax,%rcx), %esi
movq %r14, %rdi
callq 0xf4ed
addq $0x10, %rbx
leaq 0x23e0d(%rip), %rsi     # 0x41128
movq %rbx, %rdi
callq 0xf816
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x1d211
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x43f0
jmp 0x1d211
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0x1d359
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x43f0
movq %rbx, %rdi
callq 0x4750
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x20, %rsp
leaq 0x25374(%rip), %rax     # 0x428a0
cmpl $0x2, 0x4(%rax)
jne 0x1d5b6
movzbl 0x26ce4(%rip), %eax     # 0x44221
movzbl 0x26cde(%rip), %ecx     # 0x44222
subl %ecx, %eax
movl %eax, %ecx
negl %ecx
cmovsl %eax, %ecx
cmpb $0x2, %cl
jb 0x1d5af
cmpb $0x0, 0x27f27(%rip)     # 0x45480
jne 0x1d56e
movb $0x1, 0x27f1e(%rip)     # 0x45480
leaq 0x27f1f(%rip), %rdi     # 0x45488
callq 0x43b0
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x11b82(%rip), %rsi     # 0x2f0ff
leaq 0x11ba5(%rip), %rdx     # 0x2f129
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0xdfec
movq %rbx, %rdi
callq 0xf676
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x1d5b6
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x43f0
jmp 0x1d5b6
movb $0x0, 0x27eca(%rip)     # 0x45480
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x1d5d7
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x43f0
movq %rbx, %rdi
callq 0x4750
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x26d61(%rip), %r12     # 0x44c68
movq (%r12), %rdi
leaq 0x8(%rbx), %r14
movq %r14, %rsi
callq 0x16696
leaq -0x24(%rbp), %r15
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2bbe8
movl 0x10(%rbx), %eax
subl 0x8(%rbx), %eax
shrl $0x3, %eax
imull $0xffffaaab, %eax, %eax # imm = 0xFFFFAAAB
decw %ax
movw %ax, 0x2(%r15)
js 0x1dfa6
movl 0x10(%rbx), %eax
subl 0x8(%rbx), %eax
shrl $0x3, %eax
imull $0xffffaaab, %eax, %eax # imm = 0xFFFFAAAB
decw %ax
movw %ax, -0x24(%rbp)
js 0x1dfa0
movswq -0x22(%rbp), %rcx
movq (%r14), %rdx
leaq (%rcx,%rcx,2), %rcx
movq (%rdx,%rcx,8), %rcx
movzwl %ax, %eax
movl $0x6d3f0004, (%rcx,%rax,4) # imm = 0x6D3F0004
movq (%r12), %rax
movswq -0x22(%rbp), %rcx
movq 0x8(%rax), %rdx
leaq (%rcx,%rcx,2), %rcx
movswq -0x24(%rbp), %rax
movq (%rdx,%rcx,8), %rdx
testb $0x10, (%rdx,%rax,4)
je 0x1df4f
movq (%r14), %rdx
movq (%rdx,%rcx,8), %rcx
orw $0x10, (%rcx,%rax,4)
jmp 0x1df4f
decw -0x22(%rbp)
jns 0x1df40
movl 0x10(%rbx), %eax
subl 0x8(%rbx), %eax
shrl $0x3, %eax
imull $0xaaaaaaab, %eax, %eax # imm = 0xAAAAAAAB
shrl %eax
movw %ax, 0x4(%rbx)
movw %ax, 0x2(%rbx)
movb $0x1, 0x6(%rbx)
leaq -0x24(%rbp), %rdi
callq 0x2bbf6
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x26c36(%rip), %rax     # 0x44c68
movq (%rax), %rdi
callq 0x1704c
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x1e0d7
movl %r14d, -0x2c(%rbp)
movswq 0x2(%rbx), %rax
movq 0x8(%r13), %rcx
leaq (%rax,%rax,2), %rax
movswq (%rbx), %r13
movq (%rcx,%rax,8), %r14
movsbq %r12b, %rax
movsbq %r15b, %r15
leaq (%rax,%rax,2), %rcx
shlq $0x3, %rcx
subq %rax, %rcx
leaq 0x27777(%rip), %r12     # 0x457f0
addq %rcx, %r12
cmpb $0x0, (%r15,%r12)
jne 0x1e0cf
movb $0x3, %al
testb $0x10, (%r14,%r13,4)
jne 0x1e0a2
movq %rbx, %rdi
callq 0x21230
movl -0x2c(%rbp), %ecx
orb %al, %cl
cmpb $0x1, %cl
jne 0x1e0cf
addb %al, %al
incb %al
addq %r15, %r12
movb %al, (%r12)
leaq 0x26bb8(%rip), %rax     # 0x44c68
movq (%rax), %rax
movswq 0x2(%rbx), %rcx
movq 0x8(%rax), %rax
leaq (%rcx,%rcx,2), %rcx
movswq (%rbx), %rdx
movq (%rax,%rcx,8), %rax
movl (%rax,%rdx,4), %eax
movl %eax, (%r14,%r13,4)
testb $0x4, (%r14,%r13,4)
sete %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x21415
cmpq 0x215f2(%rip), %rax     # 0x3ffb0
je 0x1e9d5
movq 0x28(%r14), %rcx
movl 0x2c(%rax), %edx
cmpl 0xbc(%rcx), %edx
jne 0x1e9d5
cmpb $0x0, 0x1e(%rax)
je 0x1e9dc
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
addq $0x10, %rax
movq %rax, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x21f8a
movb $0x1, %al
jmp 0x1e9d7
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x21528
movq %rax, %r15
addq $0x10, %r15
movq 0x28(%r12), %rax
movzbl 0xbc(%rax), %esi
movq %r15, %rdi
callq 0x22060
movl %eax, %r12d
testb %al, %al
je 0x1ec89
movzbl %r14b, %edx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x21f8a
movl %r12d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
movq 0x38(%rbx), %rax
cmpq %rax, %rdi
je 0x1ee14
movq %rax, %rdx
subq %rdi, %rdx
addq $-0x8, %rdx
movq (%rdi), %rcx
movq 0x90(%rcx), %rcx
cmpw %si, 0x10(%rcx)
je 0x1ee01
addq $0x8, %rdi
addq $-0x8, %rdx
cmpq %rax, %rdi
jne 0x1ede2
jmp 0x1ee14
leaq 0x8(%rdi), %rsi
cmpq %rax, %rsi
je 0x1ee0f
callq 0x46b0
addq $-0x8, 0x38(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x30(%rdi), %r14
cmpq 0x38(%rdi), %r14
je 0x1eeb3
movq %rdi, %rbx
leaq 0x2(%rdi), %r15
leaq 0x25e26(%rip), %r12     # 0x44c68
movq (%r14), %rax
cmpq 0x28(%rbx), %rax
je 0x1eea9
movq 0xd0(%rax), %r13
movq (%r12), %rdi
movq %r15, %rsi
callq 0x1704c
testb %al, %al
jne 0x1ee6e
movl (%r15), %eax
movl %eax, 0x2(%r13)
movb $0x1, 0x6(%r13)
movq (%r14), %rax
movq 0xd0(%rax), %rdi
movq %rdi, 0xd8(%rax)
movq (%r14), %rsi
callq 0x1ed84
movq %r14, %rsi
addq $0x8, %rsi
movq 0x38(%rbx), %rdx
cmpq %rdx, %rsi
je 0x1eea2
subq %rsi, %rdx
movq %r14, %rdi
callq 0x46b0
addq $-0x8, 0x38(%rbx)
jmp 0x1eead
addq $0x8, %r14
cmpq 0x38(%rbx), %r14
jne 0x1ee42
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
movq 0x26856(%rip), %r14     # 0x45ff0
leaq 0x2683f(%rip), %r12     # 0x45fe0
cmpq %r12, %r14
setne %r15b
je 0x1f7dc
movq %rdi, %rbx
leaq 0x20(%r14), %rdi
movq %rbx, %rsi
callq 0x2bc42
cmpw $0xc, %ax
jl 0x1f7dc
movq %r14, %rdi
callq 0x4470
cmpq %r12, %rax
setne %r15b
je 0x1f7dc
movq %rax, %r14
movq %rax, %rdi
addq $0x20, %rdi
jmp 0x1f7b1
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, %rbx
movq %rdi, %r14
callq 0x22bc9
testl %r15d, %r15d
je 0x20691
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
movq %r14, %rdx
callq 0x18b9a
cmpq 0x8(%rbx), %rax
je 0x20624
leaq -0x30(%rbp), %r15
movq %r15, %rdi
callq 0x22bf2
movl -0x30(%rbp), %eax
movl %eax, (%r14)
movq %r15, %rdi
callq 0x2bbf6
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
movq %r14, %rdx
callq 0x18b9a
cmpq 0x8(%rbx), %rax
jne 0x205f9
leaq 0x2463d(%rip), %r15     # 0x44c68
movq (%r15), %rax
movswq 0x2(%r14), %rcx
movq 0x8(%rax), %rax
leaq (%rcx,%rcx,2), %rcx
movswq (%r14), %rdx
movq (%rax,%rcx,8), %rax
movsbl 0x2(%rax,%rdx,4), %esi
leaq 0x25749(%rip), %rdi     # 0x45d98
xorl %edx, %edx
callq 0x4550
cmpq $-0x1, %rax
jne 0x2067b
movq (%r15), %rax
movswq 0x2(%r14), %rcx
movq 0x8(%rax), %rax
leaq (%rcx,%rcx,2), %rcx
movswq (%r14), %rdx
movq (%rax,%rcx,8), %rax
movl $0x1c2e0005, (%rax,%rdx,4) # imm = 0x1C2E0005
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x206fe
movl (%r14), %eax
movl %eax, (%rsi)
addq $0x4, 0x8(%rbx)
jmp 0x20709
leaq 0x245d0(%rip), %r13     # 0x44c68
leaq 0x256f9(%rip), %r15     # 0x45d98
leaq -0x2c(%rbp), %r12
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
movq %r14, %rdx
callq 0x18b9a
cmpq 0x8(%rbx), %rax
jne 0x206e6
movq (%r13), %rax
movswq 0x2(%r14), %rcx
movq 0x8(%rax), %rax
leaq (%rcx,%rcx,2), %rcx
movswq (%r14), %rdx
movq (%rax,%rcx,8), %rax
movsbl 0x2(%rax,%rdx,4), %esi
movq %r15, %rdi
xorl %edx, %edx
callq 0x4550
cmpq $-0x1, %rax
jne 0x2067b
movq %r12, %rdi
callq 0x22bf2
movl -0x2c(%rbp), %eax
movl %eax, (%r14)
movq %r12, %rdi
callq 0x2bbf6
jmp 0x206a3
movq %rbx, %rdi
movq %r14, %rdx
callq 0x18c8e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2548b(%rip), %rbx     # 0x45f48
leaq 0x25474(%rip), %r13     # 0x45f38
cmpq %r13, %rbx
je 0x20b40
leaq 0x25508(%rip), %r14     # 0x45fd8
leaq 0x25459(%rip), %r15     # 0x45f30
movb 0x24(%rbx), %al
cmpb $0x5, %al
ja 0x20b2b
leaq 0x20(%rbx), %rsi
leaq 0x2417f(%rip), %rax     # 0x44c68
movq (%rax), %rax
movswq 0x22(%rbx), %rcx
movq 0x8(%rax), %rax
leaq (%rcx,%rcx,2), %rcx
movswq 0x20(%rbx), %rdx
movq (%rax,%rcx,8), %rax
andw $0xff7f, (%rax,%rdx,4)  # imm = 0xFF7F
movq %r14, %rdi
callq 0x21b9c
movq %rbx, %rdi
callq 0x4260
movq %rax, %r12
movq %r15, %rdi
movq %rbx, %rsi
callq 0x21c58
movq %r12, %rbx
jmp 0x20b3b
addb $-0x6, %al
movb %al, 0x24(%rbx)
movq %rbx, %rdi
callq 0x4260
movq %rax, %rbx
cmpq %r13, %rbx
jne 0x20ad7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x25361(%rip), %rbx     # 0x45f78
leaq 0x2534a(%rip), %r15     # 0x45f68
cmpq %r15, %rbx
je 0x20c6d
leaq 0x2403e(%rip), %r12     # 0x44c68
leaq 0x253a7(%rip), %r14     # 0x45fd8
movq (%r12), %rax
leaq 0x20(%rbx), %rsi
movswq 0x22(%rbx), %rcx
movq 0x8(%rax), %rax
leaq (%rcx,%rcx,2), %rcx
movswq 0x20(%rbx), %rdx
movq (%rax,%rcx,8), %rax
andw $0xfeff, (%rax,%rdx,4)  # imm = 0xFEFF
movq %r14, %rdi
callq 0x21b9c
movq %rbx, %rdi
callq 0x4470
movq %rax, %rbx
cmpq %r15, %rax
jne 0x20c31
leaq 0x252ec(%rip), %rdi     # 0x45f60
callq 0x1da92
movq 0x25328(%rip), %rbx     # 0x45fa8
leaq 0x25311(%rip), %r15     # 0x45f98
cmpq %r15, %rbx
je 0x20cd6
leaq 0x23fd5(%rip), %r12     # 0x44c68
leaq 0x2533e(%rip), %r14     # 0x45fd8
movq (%r12), %rax
leaq 0x20(%rbx), %rsi
movswq 0x22(%rbx), %rcx
movq 0x8(%rax), %rax
leaq (%rcx,%rcx,2), %rcx
movswq 0x20(%rbx), %rdx
movq (%rax,%rcx,8), %rax
andw $0xfeff, (%rax,%rdx,4)  # imm = 0xFEFF
movq %r14, %rdi
callq 0x21b9c
movq %rbx, %rdi
callq 0x4470
movq %rax, %rbx
cmpq %r15, %rax
jne 0x20c9a
leaq 0x252b3(%rip), %rdi     # 0x45f90
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1db18
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x8, %esi
callq 0x20d42
movq %rbx, %rdi
movl $0x7, %esi
callq 0x20d42
movq %rbx, %rdi
movl $0x6, %esi
callq 0x20d42
leaq 0x23f4a(%rip), %rax     # 0x44c68
movq (%rax), %rax
movswq 0x2(%rbx), %rcx
movq 0x8(%rax), %rax
leaq (%rcx,%rcx,2), %rcx
movswq (%rbx), %rdx
movq (%rax,%rcx,8), %rax
orw $0x10, (%rax,%rdx,4)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, %r14
leaq 0x24ec3(%rip), %r15     # 0x45e80
leaq -0x2c(%rbp), %r12
movq %r15, %rbx
movq (%rbx), %rbx
cmpq %r15, %rbx
je 0x21011
movl 0x18(%rbx), %eax
movl %eax, -0x2c(%rbp)
movq %r12, %rdi
movq %r14, %rsi
callq 0x2bddc
movl %eax, %r13d
movq %r12, %rdi
callq 0x2bbf6
testb %r13b, %r13b
je 0x20fc4
leaq 0x24e8c(%rip), %r15     # 0x45e80
leaq 0x10(%rbx), %rdi
movzbl -0x30(%rbp), %edx
movq -0x38(%rbp), %rsi
callq 0x21f8a
movb $0x1, %r12b
cmpq %r15, %rbx
jne 0x21111
leaq 0x24e80(%rip), %r15     # 0x45e98
leaq -0x2c(%rbp), %r12
movq %r15, %rbx
movq (%rbx), %rbx
cmpq %r15, %rbx
je 0x2106c
movl 0x18(%rbx), %eax
movl %eax, -0x2c(%rbp)
movq %r12, %rdi
movq %r14, %rsi
callq 0x2bddc
movl %eax, %r13d
movq %r12, %rdi
callq 0x2bbf6
testb %r13b, %r13b
je 0x2101f
leaq 0x24e49(%rip), %r15     # 0x45e98
leaq 0x10(%rbx), %rdi
movzbl -0x30(%rbp), %edx
movq -0x38(%rbp), %rsi
callq 0x21f8a
movb $0x1, %r12b
cmpq %r15, %rbx
jne 0x21111
leaq 0x24e3d(%rip), %r13     # 0x45eb0
leaq -0x2c(%rbp), %r15
movq %r13, %rbx
movq (%rbx), %rbx
cmpq %r13, %rbx
je 0x210c1
movl 0x18(%rbx), %eax
movl %eax, -0x2c(%rbp)
movq %r15, %rdi
movq %r14, %rsi
callq 0x2bddc
movl %eax, %r12d
movq %r15, %rdi
callq 0x2bbf6
testb %r12b, %r12b
je 0x2107a
leaq 0x24e06(%rip), %r15     # 0x45eb0
leaq 0x10(%rbx), %rdi
movq -0x38(%rbp), %rsi
xorl %edx, %edx
callq 0x21f8a
movb $0x1, %r12b
cmpq %r15, %rbx
jne 0x21111
leaq 0x24e00(%rip), %r15     # 0x45ec8
leaq -0x2c(%rbp), %r13
movq (%r15), %r15
leaq 0x24df2(%rip), %rax     # 0x45ec8
cmpq %rax, %r15
setne %r12b
je 0x21111
movl 0x18(%r15), %eax
movl %eax, -0x2c(%rbp)
movq %r13, %rdi
movq %r14, %rsi
callq 0x2bddc
movl %eax, %ebx
movq %r13, %rdi
callq 0x2bbf6
testb %bl, %bl
je 0x210cc
addq $0x10, %r15
movq %r15, %rdi
movq -0x38(%rbp), %rsi
xorl %edx, %edx
callq 0x21f8a
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x21129
jmp 0x21129
jmp 0x21129
movq %rax, %rbx
leaq -0x2c(%rbp), %rdi
callq 0x2bbf6
movq %rbx, %rdi
callq 0x4750
// File: /workspace/github_cpp_makefile_star2_O1/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 0x24c5f(%rip), %rcx     # 0x45dc0
leaq -0x30(%rbp), %r13
movq %rax, -0x48(%rbp)
leaq (%rax,%rax,2), %rax
leaq (%rcx,%rax,8), %r12
movq %r12, %r15
movq (%r15), %r15
cmpq %r12, %r15
je 0x2119e
movl 0x18(%r15), %eax
movl %eax, -0x30(%rbp)
movq %r13, %rdi
movq %r14, %rsi
callq 0x2bddc
movl %eax, %ebx
movq %r13, %rdi
callq 0x2bbf6
testb %bl, %bl
je 0x21174
jmp 0x211ee
movq -0x48(%rbp), %rax
incq %rax
cmpq $0x6, %rax
leaq 0x24c10(%rip), %rcx     # 0x45dc0
jne 0x21165
leaq 0x24c97(%rip), %rbx     # 0x45e50
leaq -0x2c(%rbp), %r12
movq %rbx, %r15
movq (%r15), %r15
cmpq %rbx, %r15
je 0x21204
movl 0x18(%r15), %eax
movl %eax, -0x2c(%rbp)
movq %r12, %rdi
movq %r14, %rsi
callq 0x2bddc
movl %eax, %r13d
movq %r12, %rdi
callq 0x2bbf6
xorl %eax, %eax
testb %r13b, %r13b
je 0x211c0
jmp 0x211f1
movl -0x34(%rbp), %eax
addq $0x10, %r15
movzbl %al, %edx
movq %r15, %rdi
movq -0x40(%rbp), %rsi
callq 0x21f8a
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x2c(%rbp), %rdi
jmp 0x21223
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x2bbf6
movq %rbx, %rdi
callq 0x4750
// File: /workspace/github_cpp_makefile_star2_O1/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 0x24ab6(%rip), %rbx     # 0x45ee0
leaq 0x24aaf(%rip), %r12     # 0x45ee0
cmpq %r12, %rbx
je 0x21475
movq %rdi, %r14
leaq -0x2c(%rbp), %r15
movl 0x18(%rbx), %eax
movl %eax, -0x2c(%rbp)
movq %r15, %rdi
movq %r14, %rsi
callq 0x2bddc
testb %al, %al
je 0x21465
movb 0x1e(%rbx), %r13b
movq %r15, %rdi
callq 0x2bbf6
testb %r13b, %r13b
jne 0x2146d
jmp 0x21475
movq %r15, %rdi
callq 0x2bbf6
movq (%rbx), %rbx
cmpq %r12, %rbx
jne 0x2143d
movq %rbx, %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 0x2bbf6
movq %rbx, %rdi
callq 0x4750
// File: /workspace/github_cpp_makefile_star2_O1/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
movl %esi, %eax
leaq (%rax,%rax,2), %rax
leaq 0x2490a(%rip), %rcx     # 0x45dc0
leaq (%rcx,%rax,8), %r12
movq (%r12), %rbx
cmpq %r12, %rbx
je 0x21502
movq %rdi, %r14
leaq -0x2c(%rbp), %r15
movl 0x18(%rbx), %eax
movl %eax, -0x2c(%rbp)
movq %r15, %rdi
movq %r14, %rsi
callq 0x2bddc
testb %al, %al
je 0x214f2
movb 0x1e(%rbx), %r13b
movq %r15, %rdi
callq 0x2bbf6
testb %r13b, %r13b
jne 0x214fa
jmp 0x21502
movq %r15, %rdi
callq 0x2bbf6
movq (%rbx), %rbx
cmpq %r12, %rbx
jne 0x214ca
movq %rbx, %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 0x2bbf6
movq %rbx, %rdi
callq 0x4750
// File: /workspace/github_cpp_makefile_star2_O1/lotuskip[P]yuxtapa/server/actives.cpp
// Function: any_trap_at(Coords const&)
list<Trap>::iterator any_trap_at(const Coords &c)
{
	list<Trap>::iterator it;
	for(it = traps.begin(); it != traps.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 0x2492b(%rip), %rbx     # 0x45e68
leaq 0x24924(%rip), %r12     # 0x45e68
cmpq %r12, %rbx
je 0x21588
movq %rdi, %r14
leaq -0x2c(%rbp), %r15
movl 0x18(%rbx), %eax
movl %eax, -0x2c(%rbp)
movq %r15, %rdi
movq %r14, %rsi
callq 0x2bddc
testb %al, %al
je 0x21578
movb 0x1e(%rbx), %r13b
movq %r15, %rdi
callq 0x2bbf6
testb %r13b, %r13b
jne 0x21580
jmp 0x21588
movq %r15, %rdi
callq 0x2bbf6
movq (%rbx), %rbx
cmpq %r12, %rbx
jne 0x21550
movq %rbx, %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 0x2bbf6
movq %rbx, %rdi
callq 0x4750
// File: /workspace/github_cpp_makefile_star2_O1/lotuskip[P]yuxtapa/server/actives.cpp
// Function: any_boulder_at(Coords const&)
list<OccEnt>::iterator any_boulder_at(const Coords &c)
{
	list<OccEnt>::iterator it;
	for(it = boulders.begin(); it != boulders.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 0x248bd(%rip), %rbx     # 0x45e80
leaq 0x248b6(%rip), %r12     # 0x45e80
cmpq %r12, %rbx
je 0x2160e
movq %rdi, %r14
leaq -0x2c(%rbp), %r15
movl 0x18(%rbx), %eax
movl %eax, -0x2c(%rbp)
movq %r15, %rdi
movq %r14, %rsi
callq 0x2bddc
testb %al, %al
je 0x215fe
movb 0x1e(%rbx), %r13b
movq %r15, %rdi
callq 0x2bbf6
testb %r13b, %r13b
jne 0x21606
jmp 0x2160e
movq %r15, %rdi
callq 0x2bbf6
movq (%rbx), %rbx
cmpq %r12, %rbx
jne 0x215d6
movq %rbx, %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 0x2bbf6
movq %rbx, %rdi
callq 0x4750