LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 %rdi, %rbx
leaq 0x2735c(%rip), %r12     # 0x42e58
leaq -0x2c(%rbp), %r15
movq %r12, %r14
movq (%r14), %r14
cmpq %r12, %r14
je 0x1bb3e
movl 0x18(%r14), %eax
movl %eax, -0x2c(%rbp)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x24f42
testb %al, %al
je 0x1bb34
movb 0x1e(%r14), %r13b
movq %r15, %rdi
callq 0x24d9e
testb %r13b, %r13b
jne 0x1bb03
jmp 0x1bb3e
movq %r15, %rdi
callq 0x24d9e
jmp 0x1bb03
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_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 %rdi, %rbx
leaq 0x272f4(%rip), %r12     # 0x42e70
leaq -0x2c(%rbp), %r15
movq %r12, %r14
movq (%r14), %r14
cmpq %r12, %r14
je 0x1bbbe
movl 0x18(%r14), %eax
movl %eax, -0x2c(%rbp)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x24f42
testb %al, %al
je 0x1bbb4
movb 0x1e(%r14), %r13b
movq %r15, %rdi
callq 0x24d9e
testb %r13b, %r13b
jne 0x1bb83
jmp 0x1bbbe
movq %r15, %rdi
callq 0x24d9e
jmp 0x1bb83
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_missile_at(Coords const&)
OwnedEnt* any_missile_at(const Coords &c)
{
	for(list<Arrow>::iterator a_it = arrows.begin(); a_it != arrows.end(); ++a_it)
	{
		if(!a_it->isvoid() && a_it->getpos() == c)
			return &(*a_it);
	}
	for(list<MM>::iterator m_it = MMs.begin(); m_it != MMs.end(); ++m_it)
	{
		if(!m_it->isvoid() && m_it->getpos() == c)
			return &(*m_it);
	}
	for(list<Zap>::iterator z_it = zaps.begin(); z_it != zaps.end(); ++z_it)
	{
		if(!z_it->isvoid() && z_it->getpos() == c)
			return &(*z_it);
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
leaq 0x27289(%rip), %r13     # 0x42e88
leaq -0x34(%rbp), %r15
movq %r13, %rbx
movq (%rbx), %rbx
cmpq %r13, %rbx
je 0x1bc37
cmpb $0x0, 0x1e(%rbx)
jne 0x1bc06
movl 0x18(%rbx), %eax
movl %eax, -0x34(%rbp)
movq %r15, %rdi
movq %r14, %rsi
callq 0x24f42
movl %eax, %r12d
movq %r15, %rdi
callq 0x24d9e
testb %r12b, %r12b
je 0x1bc06
jmp 0x1bc74
leaq 0x27262(%rip), %r13     # 0x42ea0
leaq -0x30(%rbp), %r15
movq %r13, %rbx
movq (%rbx), %rbx
cmpq %r13, %rbx
je 0x1bc7a
cmpb $0x0, 0x1e(%rbx)
jne 0x1bc45
movl 0x18(%rbx), %eax
movl %eax, -0x30(%rbp)
movq %r15, %rdi
movq %r14, %rsi
callq 0x24f42
movl %eax, %r12d
movq %r15, %rdi
callq 0x24d9e
testb %r12b, %r12b
je 0x1bc45
addq $0x10, %rbx
jmp 0x1bcc8
movq %r14, -0x40(%rbp)
leaq 0x27233(%rip), %r14     # 0x42eb8
xorl %ebx, %ebx
leaq -0x2c(%rbp), %r15
movq %r14, %r13
movq (%r13), %r13
cmpq %r14, %r13
je 0x1bcc8
cmpb $0x0, 0x1e(%r13)
jne 0x1bc8e
movl 0x18(%r13), %eax
movl %eax, -0x2c(%rbp)
movq %r15, %rdi
movq -0x40(%rbp), %rsi
callq 0x24f42
movl %eax, %r12d
movq %r15, %rdi
callq 0x24d9e
testb %r12b, %r12b
je 0x1bc8e
addq $0x10, %r13
movq %r13, %rbx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x2c(%rbp), %rdi
jmp 0x1bcf3
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
jmp 0x1bcf3
movq %rax, %rbx
leaq -0x34(%rbp), %rdi
callq 0x24d9e
movq %rbx, %rdi
callq 0x4710
// File: /workspace/github_cpp_makefile_star2_O2/lotuskip[P]yuxtapa/server/noccent.cpp
// Function: NOccEnt::update()
void NOccEnt::update()
{
	// At the moment this gets called only for corpses!
	if(!(--misc))
	{
		makevoid();
		Game::curmap->mod_tile(pos)->flags &= ~(TF_NOCCENT);
	}
}

// Assembly:
decb 0xf(%rdi)
je 0x1ca30
retq
pushq %rbp
movq %rsp, %rbp
movb $0x1, 0xe(%rdi)
leaq 0x25219(%rip), %rax     # 0x41c58
movq (%rax), %rax
movswq 0xa(%rdi), %rcx
movq 0x8(%rax), %rax
imulq $0x18, %rcx, %rcx
movswq 0x8(%rdi), %rdx
movq (%rax,%rcx), %rax
andw $-0x21, (%rax,%rdx,4)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/lotuskip[P]yuxtapa/server/occent.cpp
// Function: Arrow::update()
void Arrow::update()
{
	if(madevoid)
		return;
	event_set.insert(pos); // in any event, arrow moves away
	Game::curmap->mod_tile(pos)->flags &= ~(TF_OCCUPIED);

	for(char ch = 0; ch < ARROW_TILES_PER_TURN; ++ch)
	{
		if(missile_coll(this, path.front()))
			return; // missile_coll should have voided *this
		// else
		pos = path.front();
		path.pop_front();
		if(path.empty()) // this is where the arrow falls
		{
			arrow_fall(this, pos);
			makevoid(); // occupied flag has been unset
			return;
		}
	}
	// Flew all the way without hitting anything; update for drawing:
	Game::curmap->mod_tile(pos)->flags |= TF_OCCUPIED;
	event_set.insert(pos);
	symbol = arrowpath_sym[pos.dir_of(path.front())];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpb $0x0, 0xe(%rdi)
jne 0x1cea4
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
leaq 0x261f8(%rip), %rdi     # 0x42fc8
movq %r14, %rsi
callq 0x1c558
leaq 0x24e79(%rip), %r12     # 0x41c58
movq (%r12), %rax
movswq 0xa(%rbx), %rcx
movq 0x8(%rax), %rax
imulq $0x18, %rcx, %rcx
movswq 0x8(%rbx), %rdx
movq (%rax,%rcx), %rax
andw $-0x41, (%rax,%rdx,4)
leaq 0x18(%rbx), %r15
movb $0x4, %r13b
decb %r13b
je 0x1ce49
movq 0x18(%rbx), %rsi
addq $0x10, %rsi
movq %rbx, %rdi
callq 0x20c24
testb %al, %al
jne 0x1cea4
movq (%r15), %rax
movl 0x10(%rax), %eax
movl %eax, (%r14)
movq %r15, %rdi
callq 0x1d42c
cmpq %r15, (%r15)
jne 0x1ce05
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21600
movb $0x1, 0xe(%rbx)
jmp 0x1cea4
movq (%r12), %rax
movswq 0xa(%rbx), %rcx
movq 0x8(%rax), %rax
imulq $0x18, %rcx, %rcx
movswq 0x8(%rbx), %rdx
movq (%rax,%rcx), %rax
orw $0x40, (%rax,%rdx,4)
leaq 0x26159(%rip), %rdi     # 0x42fc8
movq %r14, %rsi
callq 0x1c558
movq 0x18(%rbx), %rax
movl 0x10(%rax), %eax
leaq -0x2c(%rbp), %rsi
movl %eax, (%rsi)
movq %r14, %rdi
callq 0x24e9e
movl %eax, %eax
leaq 0x102bc(%rip), %rcx     # 0x2d151
movb (%rax,%rcx), %al
movb %al, 0xc(%rbx)
leaq -0x2c(%rbp), %rdi
callq 0x24d9e
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
nop
// File: /workspace/github_cpp_makefile_star2_O2/lotuskip[P]yuxtapa/server/occent.cpp
// Function: Zap::update()
void Zap::update()
{
	if(madevoid)
		return;
	if(bounces == -1) // indicates the first call to update()
		++bounces;
	else // not the first move; should vacate position:
	{
		event_set.insert(pos);
		Game::curmap->mod_tile(pos)->flags &= ~(TF_OCCUPIED);
	}

	for(char ch = 0; ch < ZAP_TILES_PER_TURN; ++ch)
	{
		if(missile_coll(this, pos.in(dir)))
		{
			// For zaps, missile_coll returns true if we (A) have been voided
			// by hitting something, or (B) hit a PC and _should_ void ourselves
			// if that was the final tile for this round.
			if(isvoid())
				return; // *this voided, possibly via a returning bounce() call
			//else
			if(ch == ZAP_TILES_PER_TURN-1) // hit something and are at the last tile
			{
				makevoid(); // occupied flag has been unset
				return;
			}
			// else we hit a PC and will pass right through her
		}
		pos = pos.in(dir);
	}
	// Travelled all the way without hitting anything.
	if(++travelled > ZAP_TRAVEL_DIST)
		makevoid();
	else
	{
		// Update for drawing:
		Game::curmap->mod_tile(pos)->flags |= TF_OCCUPIED;
		event_set.insert(pos);
		symbol = zappath_sym[dir];
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpb $0x0, 0xe(%rdi)
jne 0x1d3a2
movq %rdi, %rbx
cmpb $-0x1, 0x1c(%rdi)
je 0x1d2cf
leaq 0x8(%rbx), %rsi
leaq 0x25d25(%rip), %rdi     # 0x42fc8
callq 0x1c558
leaq 0x249a9(%rip), %rax     # 0x41c58
movq (%rax), %rax
movswq 0xa(%rbx), %rcx
movq 0x8(%rax), %rax
imulq $0x18, %rcx, %rcx
movswq 0x8(%rbx), %rdx
movq (%rax,%rcx), %rax
andw $-0x41, (%rax,%rdx,4)
jmp 0x1d2d3
movb $0x0, 0x1c(%rbx)
leaq 0x8(%rbx), %rax
movq %rax, -0x30(%rbp)
movb $0x2, %r15b
leaq -0x38(%rbp), %r14
movb $0x2, %r12b
subb $0x1, %r12b
jb 0x1d34b
movl 0x18(%rbx), %edx
movq %r14, %rdi
movq -0x30(%rbp), %rsi
callq 0x24e0c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x20c24
movq %r14, %rdi
movl %eax, %r13d
callq 0x24d9e
testb %r13b, %r13b
je 0x1d325
cmpb $0x0, 0xe(%rbx)
jne 0x1d3a2
cmpb $0x1, %r15b
je 0x1d357
movl 0x18(%rbx), %edx
leaq -0x34(%rbp), %r15
movq %r15, %rdi
movq -0x30(%rbp), %rsi
callq 0x24e0c
movl -0x34(%rbp), %eax
movl %eax, 0x8(%rbx)
movq %r15, %rdi
callq 0x24d9e
movl %r12d, %r15d
jmp 0x1d2e5
movb 0x1d(%rbx), %al
incb %al
movb %al, 0x1d(%rbx)
cmpb $0x7, %al
jl 0x1d35d
movb $0x1, 0xe(%rbx)
jmp 0x1d3a2
leaq 0x248f4(%rip), %rax     # 0x41c58
movq (%rax), %rax
movswq 0xa(%rbx), %rcx
movq 0x8(%rax), %rax
imulq $0x18, %rcx, %rcx
movswq 0x8(%rbx), %rdx
movq (%rax,%rcx), %rax
orw $0x40, (%rax,%rdx,4)
leaq 0x25c3f(%rip), %rdi     # 0x42fc8
movq -0x30(%rbp), %rsi
callq 0x1c558
movl 0x18(%rbx), %eax
leaq 0xfdbe(%rip), %rcx      # 0x2d15a
movb (%rax,%rcx), %al
movb %al, 0xc(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x24d9e
movq %rbx, %rdi
callq 0x4710
nop
// File: /workspace/github_cpp_makefile_star2_O2/lotuskip[P]yuxtapa/server/occent.cpp
// Function: Zap::hit_tree()
bool Zap::hit_tree()
{
	/* Chance to hit trees depends on distance travelled and whether has
	 * bounced: */
	char chance;
	if(bounces > 0)
		chance = 70;
	else
	{
		chance = 10;
		if(travelled > 2)
			chance += (travelled - 2)*20;
	}
	/* Chance when hasn't bounced yet is 10% when travelled <= 2 tiles, 70% when
	 * has travelled >= 5 tiles, and linearly in between. */
	return random()%100 < chance;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
cmpb $0x0, 0x1c(%rdi)
jle 0x1d3d6
pushq $0x46
jmp 0x1d3ed
movb 0x1d(%rdi), %al
cmpb $0x3, %al
jl 0x1d3eb
movzbl %al, %eax
imull $0x14, %eax, %eax
addb $-0x1e, %al
movsbq %al, %rbx
jmp 0x1d3ee
pushq $0xa
popq %rbx
callq 0x41e0
pushq $0x64
popq %rcx
cqto
idivq %rcx
cmpq %rbx, %rdx
setl %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/lotuskip[P]yuxtapa/server/occent.cpp
// Function: Zap::bounce(e_Dir)
bool Zap::bounce(const e_Dir nd)
{
	if(++bounces == MAX_ZAP_BOUNCES)
	{
		makevoid();
		// This is called only via missile_coll, which is called only via this->update(),
		// occupied flag has been unset.
		return true;
	}
	travelled = 0;
	dir = nd;
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb 0x1c(%rdi), %al
incb %al
movb %al, 0x1c(%rdi)
cmpb $0x7, %al
jne 0x1d41e
movb $0x1, 0xe(%rdi)
jmp 0x1d425
movb $0x0, 0x1d(%rdi)
movl %esi, 0x18(%rdi)
cmpb $0x7, %al
sete %al
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/lotuskip[P]yuxtapa/server/spiral.cpp
// Function: next_nearby()
Coords next_nearby()
{
	do {
		pnt.x += coord_adds[eind % 4];
		pnt.y += coord_adds[(eind-1)%4];
		if(++lenidx == elen)
		{
			if((++eind)%2)
				++elen;
			lenidx = 0;
		}
	}
	while(pnt.x < 1 || pnt.y < 1 || pnt.x >= maxdim
		|| pnt.y >= maxdim);
	return pnt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movzwl 0x263b8(%rip), %r13d    # 0x438f6
movzwl 0x263aa(%rip), %r8d     # 0x438f0
movzwl 0x263a4(%rip), %r9d     # 0x438f2
movzwl 0x263a4(%rip), %r12d    # 0x438fa
movzwl 0x2639a(%rip), %r10d    # 0x438f8
movzwl 0x2638e(%rip), %r11d    # 0x438f4
movw $0x4, %bx
leaq 0x11bd9(%rip), %r14     # 0x2f14a
movl $0x4, %r15d
movswl %r13w, %esi
movl %esi, %eax
cwtd
idivw %bx
movl %edx, %ecx
decl %esi
movl %esi, %eax
cltd
idivl %r15d
incl %r12d
cmpw %r10w, %r12w
jne 0x1d5b7
leal 0x1(%r13), %eax
movw %ax, 0x26356(%rip)      # 0x438f6
testb $0x1, %r13b
jne 0x1d5b1
incl %r10d
movw %r10w, 0x26347(%rip)    # 0x438f8
xorl %r12d, %r12d
movl %eax, %r13d
movswq %cx, %rax
movsbl (%rax,%r14), %eax
addl %eax, %r8d
movslq %edx, %rax
movsbl (%rax,%r14), %eax
addl %eax, %r9d
testw %r8w, %r8w
jle 0x1d577
testw %r9w, %r9w
jle 0x1d577
cmpw %r11w, %r8w
jge 0x1d577
cmpw %r11w, %r9w
jae 0x1d577
movw %r8w, 0x26302(%rip)     # 0x438f0
movw %r9w, 0x262fc(%rip)     # 0x438f2
movw %r12w, 0x262fc(%rip)    # 0x438fa
movl 0x262ec(%rip), %eax     # 0x438f0
movl %eax, (%rdi)
movq %rdi, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/lotuskip[P]yuxtapa/server/chores.cpp
// Function: (anonymous namespace)::update_lights_around(Coords const&)
void update_lights_around(const Coords &c)
{
	for(list<NOccEnt>::const_iterator it = noccents[NOE_TORCH].begin();
		it != noccents[NOE_TORCH].end(); ++it)
	{
		if(c.dist_walk(it->getpos()) <= TORCH_LIGHT_RADIUS)
			update_static_light(it->getpos());
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl $0x90, %r15d
addq 0x1e12f(%rip), %r15     # 0x3cfc8
movq %rdi, -0x38(%rbp)
leaq -0x2c(%rbp), %r14
movq %r15, %r13
movq (%r13), %r13
cmpq %r15, %r13
je 0x1eeef
movl 0x18(%r13), %eax
movl %eax, -0x30(%rbp)
movq -0x38(%rbp), %rdi
leaq -0x30(%rbp), %rbx
movq %rbx, %rsi
callq 0x24dd8
movl %eax, %r12d
movq %rbx, %rdi
callq 0x24d9e
cmpw $0x8, %r12w
jg 0x1eea4
movl 0x18(%r13), %eax
movl %eax, -0x2c(%rbp)
movq %r14, %rdi
callq 0x1b38e
movq %r14, %rdi
callq 0x24d9e
jmp 0x1eea4
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x2c(%rbp), %rdi
jmp 0x1ef0e
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/chores.cpp
// Function: (anonymous namespace)::record_kill(std::_List_iterator<Player>, char)
void record_kill(const list<Player>::iterator pit, const char method)
{
	++(pit->stats_i->kills[method]);
	if(gamemode == GM_TDM)
	{
		int cmp = int(tdm_kills[T_GREEN]) - tdm_kills[T_PURPLE];
		++tdm_kills[pit->team];
		// First cmp = A-B, then either A or B is incremented by one, and
		// we want to know whether their relative order has changed. This
		// test suffices:
		if((int(tdm_kills[T_GREEN]) - tdm_kills[T_PURPLE])*cmp == 0)
			Game::send_team_upds(cur_players.end());
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x90(%rdi), %rax
movzbl %sil, %ecx
incq 0x48(%rax,%rcx,8)
leaq 0x21cb5(%rip), %rax     # 0x41214
cmpl $0x4, (%rax)
jne 0x1f58e
leaq 0x21cad(%rip), %rax     # 0x41218
movzwl (%rax), %ecx
movzwl 0x2(%rax), %edx
subl %edx, %ecx
movl 0xbc(%rdi), %edx
incw (%rax,%rdx,2)
movzwl (%rax), %edx
movzwl 0x2(%rax), %eax
subl %eax, %edx
imull %ecx, %edx
testl %edx, %edx
je 0x1f590
popq %rbp
retq
leaq 0x20b19(%rip), %rdi     # 0x400b0
popq %rbp
jmp 0x152e9
// File: /workspace/github_cpp_makefile_star2_O2/lotuskip[P]yuxtapa/server/chores.cpp
// Function: (anonymous namespace)::flash_at(Coords const&)
void flash_at(const Coords &pos)
{
	// Every non-assassin within LOS is blinded (note that
	// the radius is the same as for trap detection).
	char line, ind;
	Coords c;
	unsigned short f;
	list<PCEnt>::iterator pc_it;
	for(line = 0; line < DETECT_TRAPS_RAD*8; ++line)
	{
		for(ind = 0; ind < 2*DETECT_TRAPS_RAD; ind += 2)
		{
			c.x = loslookup[DETECT_TRAPS_RAD-2][line*2*DETECT_TRAPS_RAD+ind] + pos.x;
			c.y = loslookup[DETECT_TRAPS_RAD-2][line*2*DETECT_TRAPS_RAD+ind+1] + pos.y;
			if((f = Game::curmap->get_tile(c).flags) & TF_OCCUPIED)
				conditional_blind(c);
			else if(!(f & TF_SEETHRU))
				break;
		}
	}
	// At pos itself, too:
	conditional_blind(pos);
	add_sound(pos, S_ZAP);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq -0x2c(%rbp), %rdi
xorl %r14d, %r14d
xorl %esi, %esi
xorl %edx, %edx
callq 0x24d90
leaq 0xfc23(%rip), %r12      # 0x2f280
leaq 0x225f4(%rip), %r13     # 0x41c58
cmpl $0x18, %r14d
je 0x1f6df
movl %r14d, -0x30(%rbp)
movslq %r14d, %rax
imulq $0x6, %rax, %r15
xorl %r14d, %r14d
movsbl %r14b, %r14d
cmpl $0x5, %r14d
jg 0x1f6d6
movslq %r14d, %rax
addq %r15, %rax
movsbl (%r12,%rax), %ecx
addw (%rbx), %cx
movw %cx, -0x2c(%rbp)
movsbl 0x1(%r12,%rax), %eax
addw 0x2(%rbx), %ax
movw %ax, -0x2a(%rbp)
movq (%r13), %rdx
movswq %ax, %rax
movq 0x8(%rdx), %rdx
imulq $0x18, %rax, %rax
movswq %cx, %rcx
movq (%rdx,%rax), %rax
movl (%rax,%rcx,4), %eax
testb $0x40, %al
jne 0x1f6c7
testb $0x4, %al
jne 0x1f6d0
jmp 0x1f6d6
leaq -0x2c(%rbp), %rdi
callq 0x21a76
addl $0x2, %r14d
jmp 0x1f678
movl -0x30(%rbp), %r14d
incl %r14d
jmp 0x1f664
movq %rbx, %rdi
callq 0x21a76
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x1b202
leaq -0x2c(%rbp), %rdi
callq 0x24d9e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1f70c
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/chores.cpp
// Function: (anonymous namespace)::heal_PC(std::_List_iterator<Player>)
void heal_PC(const list<Player>::iterator pit)
{
	if(pit->cl_props.hp < classes[pit->cl].hp)
	{
		/* always heal at least once, but sometimes more */
		while(++(pit->stats_i->healing_recvd) && // this first one is of course always true
			++(pit->cl_props.hp) < classes[pit->cl].hp && !(random()%4));
		pit->poisoner = cur_players.end();
		pit->needs_state_upd = true;
		add_action_ind(pit->own_pc->getpos(), A_HEAL);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movb 0x153(%rdi), %al
movl 0xc0(%rdi), %ecx
imulq $0xd, %rcx, %rcx
leaq 0xfa7e(%rip), %r14      # 0x2f1e0
cmpb 0x3(%rcx,%r14), %al
jge 0x1f7d9
movq %rdi, %rbx
movq 0x90(%rbx), %rax
incq 0xa8(%rax)
je 0x1f7a4
movb 0x153(%rbx), %al
incb %al
movb %al, 0x153(%rbx)
movl 0xc0(%rbx), %ecx
imulq $0xd, %rcx, %rcx
cmpb 0x3(%rcx,%r14), %al
jge 0x1f7a4
callq 0x41e0
testb $0x3, %al
je 0x1f76c
leaq 0x20905(%rip), %rax     # 0x400b0
movq %rax, 0x160(%rbx)
movb $0x1, 0x15d(%rbx)
movq 0x148(%rbx), %rax
movl 0x8(%rax), %eax
leaq -0x14(%rbp), %rdi
movl %eax, (%rdi)
xorl %esi, %esi
callq 0x1b103
leaq -0x14(%rbp), %rdi
callq 0x24d9e
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x14(%rbp), %rdi
callq 0x24d9e
movq %rbx, %rdi
callq 0x4710
// File: /workspace/github_cpp_makefile_star2_O2/lotuskip[P]yuxtapa/server/chores.cpp
// Function: (anonymous namespace)::cant_dig_in(Coords const&, e_Dir)
char cant_dig_in(const Coords &c, const e_Dir d)
{
	// Mining requires one of: (A) there is a wall/window/door, (B) there is a blocked
	// boulder, (C) there is a boulder source.
	Tile* tp = Game::curmap->mod_tile(c);
	if(tp->symbol == '#' && tp->flags & TF_WALKTHRU)
		return -1;
	if(tp->symbol == '#' || tp->symbol == '|' || tp->symbol == '-' || tp->symbol == '+'
		|| ((tp->flags & TF_NOCCENT) && any_noccent_at(c, NOE_BLOCK_SOURCE)
			!= noccents[NOE_BLOCK_SOURCE].end()))
		return 0;
	// that was (A) and (C); (B) is more complicated:
	if(tp->flags & TF_OCCUPIED && any_boulder_at(c) != boulders.end())
	{
		Coords pushtarpos = c.in(d);
		Tile *pushtar = Game::curmap->mod_tile(pushtarpos);
		if((tp->flags & TF_SLOWWALK) || (pushtar->flags & TF_OCCUPIED)
			|| !(pushtar->flags & TF_WALKTHRU) || pushtar->symbol == '\\'
			|| ((pushtar->flags & TF_NOCCENT)
			&& any_noccent_at(pushtarpos, NOE_FLAG) != noccents[NOE_FLAG].end()))
			return 0; // cannot push; hence can dig
	}
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x21f3e(%rip), %rax     # 0x41c58
movq (%rax), %rax
movswq 0x2(%rdi), %rcx
movq 0x8(%rax), %rax
imulq $0x18, %rcx, %rcx
movswq (%rdi), %r13
movq (%rax,%rcx), %r12
movzbl 0x2(%r12,%r13,4), %eax
xorl %ebx, %ebx
cmpl $0x7c, %eax
je 0x1fe2c
cmpl $0x2b, %eax
je 0x1fe2c
cmpl $0x2d, %eax
je 0x1fe2c
cmpl $0x23, %eax
jne 0x1fd68
movb (%r12,%r13,4), %bl
andb $0x1, %bl
negb %bl
jmp 0x1fe2c
movl %esi, %r14d
movq %rdi, %r15
movzwl (%r12,%r13,4), %eax
testb $0x20, %al
je 0x1fd9b
pushq $0x1
popq %rsi
movq %r15, %rdi
callq 0x1ba5b
leaq 0x23027(%rip), %rcx     # 0x42db0
addq $0x18, %rcx
cmpq %rcx, %rax
jne 0x1fe2a
movzwl (%r12,%r13,4), %eax
movb $0x1, %bl
testb $0x40, %al
je 0x1fe2c
movq %r15, %rdi
callq 0x1bb64
cmpq 0x1d224(%rip), %rax     # 0x3cfd8
je 0x1fe2c
leaq -0x2c(%rbp), %rdi
movq %r15, %rsi
movl %r14d, %edx
callq 0x24e0c
testb $0x2, (%r12,%r13,4)
jne 0x1fe21
leaq 0x21e85(%rip), %rax     # 0x41c58
movq (%rax), %rax
movswq -0x2a(%rbp), %rcx
movq 0x8(%rax), %rax
imulq $0x18, %rcx, %rdx
movswq -0x2c(%rbp), %rcx
movq (%rax,%rdx), %rdx
movzwl (%rdx,%rcx,4), %eax
movl %eax, %esi
andl $0x41, %esi
cmpl $0x1, %esi
jne 0x1fe21
cmpb $0x5c, 0x2(%rdx,%rcx,4)
je 0x1fe21
testb $0x20, %al
je 0x1fe3d
leaq -0x2c(%rbp), %rdi
pushq $0x5
popq %rsi
callq 0x1ba5b
leaq 0x22f98(%rip), %rcx     # 0x42db0
addq $0x78, %rcx
cmpq %rcx, %rax
je 0x1fe3d
leaq -0x2c(%rbp), %rdi
callq 0x24d9e
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq -0x2c(%rbp), %rdi
callq 0x24d9e
jmp 0x1fe2c
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/chores.cpp
// Function: process_swaps()
void process_swaps()
{
	for(list<Player>::iterator it = cur_players.begin();
		it != cur_players.end(); ++it)
	{
		if(it->is_alive() && it->wants_to_move_to != MAX_D)
		{
			Coords tarpos = it->own_pc->getpos().in(it->wants_to_move_to);
			if(Game::curmap->get_tile(tarpos).flags & TF_OCCUPIED)
			{
				// Check if there is teammate willing to swap:
				list<PCEnt>::iterator pc_it = any_pc_at(tarpos);
				if(pc_it != PCs.end())
				{
					list<Player>::iterator pp = pc_it->get_owner();
					if(pp->team == it->team
						&& (pp->wants_to_move_to == !(it->wants_to_move_to)
						|| pp->turns_without_axn >= IDLE_TURNS_TO_AUTOSWAP))
						swap_places(pp, it);
				}
			}
			else // not occupied; can move there!
			{
				move_player_to(it, tarpos, true);
				it->wants_to_move_to = MAX_D;
			}
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x1fff6(%rip), %r15     # 0x400b0
leaq -0x30(%rbp), %rbx
leaq -0x2c(%rbp), %r14
movq %r15, %r12
movq (%r12), %r12
cmpq %r15, %r12
je 0x201b6
leaq 0x10(%r12), %rdi
callq 0xe68e
testb %al, %al
je 0x200c5
movl 0x13c(%r12), %edx
cmpl $0x8, %edx
je 0x200c5
movq 0x148(%r12), %rax
movl 0x8(%rax), %eax
movl %eax, -0x2c(%rbp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x24e0c
movq %r14, %rdi
callq 0x24d9e
leaq 0x21b43(%rip), %rax     # 0x41c58
movq (%rax), %rax
movswq -0x2e(%rbp), %rcx
movq 0x8(%rax), %rax
imulq $0x18, %rcx, %rcx
movswq -0x30(%rbp), %rdx
movq (%rax,%rcx), %rax
testb $0x40, (%rax,%rdx,4)
jne 0x20150
movq %r12, %rdi
movq %rbx, %rsi
pushq $0x1
popq %rdx
callq 0x1f7f6
movl $0x8, 0x13c(%r12)
jmp 0x201a5
movq %rbx, %rdi
callq 0x1b9db
cmpq 0x1ce49(%rip), %rax     # 0x3cfa8
je 0x201a5
movq 0x20(%rax), %r13
movl 0xbc(%r13), %eax
cmpl 0xbc(%r12), %eax
jne 0x201a5
movl 0x13c(%r13), %r14d
movl 0x13c(%r12), %edi
callq 0x24d7c
cmpl %eax, %r14d
je 0x2019a
cmpw $0x8, 0x13a(%r13)
jb 0x201a5
movq %r13, %rdi
movq %r12, %rsi
callq 0x201e6
movq %rbx, %rdi
callq 0x24d9e
leaq -0x2c(%rbp), %r14
jmp 0x200c5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x201c9
jmp 0x201c9
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
jmp 0x201d9
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/chores.cpp
// Function: (anonymous namespace)::swap_places(std::_List_iterator<Player>, std::_List_iterator<Player>)
void swap_places(const list<Player>::iterator pit1, const list<Player>::iterator pit2)
{
	Coords pos1 = pit1->own_pc->getpos();
	Coords pos2 = pit2->own_pc->getpos();
	move_player_to(pit1, pos2, false);
	move_player_to(pit2, pos1, false);
	pit1->wants_to_move_to = pit2->wants_to_move_to = MAX_D;
	// A very rare possibility is that one of the players dies due to a
	// trap; we must check this:
	if(!pit1->is_alive())
		Game::curmap->mod_tile(pos1)->flags &= ~(TF_OCCUPIED);
	if(!pit2->is_alive())
		Game::curmap->mod_tile(pos2)->flags &= ~(TF_OCCUPIED);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x148(%rdi), %rax
movl 0x8(%rax), %eax
movl %eax, -0x14(%rbp)
movq 0x148(%rsi), %rax
movl 0x8(%rax), %eax
leaq -0x18(%rbp), %rsi
movl %eax, (%rsi)
xorl %edx, %edx
callq 0x1f7f6
leaq -0x14(%rbp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1f7f6
pushq $0x8
popq %rax
movl %eax, 0x13c(%rbx)
movl %eax, 0x13c(%r14)
addq $0x10, %r14
movq %r14, %rdi
callq 0xe68e
addq $0x10, %rbx
testb %al, %al
jne 0x20272
leaq 0x21a04(%rip), %rax     # 0x41c58
movq (%rax), %rax
movswq -0x12(%rbp), %rcx
movq 0x8(%rax), %rax
imulq $0x18, %rcx, %rcx
movswq -0x14(%rbp), %rdx
movq (%rax,%rcx), %rax
andw $-0x41, (%rax,%rdx,4)
movq %rbx, %rdi
callq 0xe68e
testb %al, %al
jne 0x202a3
leaq 0x219d3(%rip), %rax     # 0x41c58
movq (%rax), %rax
movswq -0x16(%rbp), %rcx
movq 0x8(%rax), %rax
imulq $0x18, %rcx, %rcx
movswq -0x18(%rbp), %rdx
movq (%rax,%rcx), %rax
andw $-0x41, (%rax,%rdx,4)
leaq -0x18(%rbp), %rdi
callq 0x24d9e
leaq -0x14(%rbp), %rdi
callq 0x24d9e
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x18(%rbp), %rdi
callq 0x24d9e
leaq -0x14(%rbp), %rdi
callq 0x24d9e
movq %rbx, %rdi
callq 0x4710
// File: /workspace/github_cpp_makefile_star2_O2/lotuskip[P]yuxtapa/server/chores.cpp
// Function: (anonymous namespace)::test_hit(std::_List_iterator<Player>, char, char, char, char)
bool test_hit(const list<Player>::iterator def, const char tohit,
	char numdies, const char ddie, const char dadd)
{
	Coords loc = def->own_pc->getpos();
	char P = def->cl_props.dv - tohit;
	char R = random()%20;
	if(R >= P || R == 19) // hit
	{
		char dam = dadd;
		while(numdies--)
			dam += 1 + random()%ddie;
		if(R != 19 && R/P < 2) // not critical hit; apply PV
			dam -= def->cl_props.pv;
		def->cl_props.hp -= max(0, int(dam));
		def->needs_state_upd = true;
		add_action_ind(loc, A_HIT);
		return true;
	}
	add_action_ind(loc, A_MISS);
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r8d, %r15d
movl %ecx, -0x34(%rbp)
movl %edx, %r12d
movq %rdi, %r14
movq 0x148(%rdi), %rax
movl 0x8(%rax), %eax
movl %eax, -0x2c(%rbp)
movb 0x158(%rdi), %bl
subb %sil, %bl
callq 0x41e0
pushq $0x14
popq %rcx
cqto
idivq %rcx
movq %rdx, %r13
movsbl %bl, %ecx
cmpl %ecx, %r13d
setge %al
cmpq $0x13, %rdx
sete %bl
orb %al, %bl
cmpb $0x1, %bl
jne 0x20b9f
movl %ecx, -0x30(%rbp)
movq %r14, -0x40(%rbp)
movsbq -0x34(%rbp), %r14
subb $0x1, %r12b
jb 0x20bad
callq 0x41e0
cqto
idivq %r14
addb %dl, %r15b
incb %r15b
jmp 0x20b87
leaq -0x2c(%rbp), %rdi
pushq $0x5
popq %rsi
callq 0x1b103
jmp 0x20bf4
cmpq $0x13, %r13
jne 0x20bb9
movq -0x40(%rbp), %rdx
jmp 0x20bd0
movl %r13d, %eax
cltd
idivl -0x30(%rbp)
cmpl $0x1, %eax
movq -0x40(%rbp), %rdx
jg 0x20bd0
subb 0x159(%rdx), %r15b
movzbl %r15b, %eax
xorl %ecx, %ecx
testb %al, %al
cmovgl %eax, %ecx
subb %cl, 0x153(%rdx)
movb $0x1, 0x15d(%rdx)
leaq -0x2c(%rbp), %rdi
pushq $0x4
popq %rsi
callq 0x1b103
leaq -0x2c(%rbp), %rdi
callq 0x24d9e
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x20c10
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/chores.cpp
// Function: arrow_fall(OwnedEnt const*, Coords const&)
void arrow_fall(const OwnedEnt* arr, const Coords &c)
{
	Tile* tar = Game::curmap->mod_tile(c);
	// Arrow falling on a trap might trigger the trap:
	if((tar->flags & TF_TRAP) && random()%100 < CHANCE_ARROW_TRIG_TRAP)
	{
		list<Trap>::iterator tr_it = any_trap_at(c);
		// Functionality is somewhat different from trigger_trap(...), but we
		// also repeat some functionality here...
		switch(tr_it->get_m())
		{
		case TRAP_WATER:
		case TRAP_ACID:
			add_sound(c, S_SPLASH);
			break;
		case TRAP_LIGHT:
			flash_at(c);
			break;
		case TRAP_BOOBY:
			add_sound(c, S_CREAK);
			// Boobytraps are always destroyed:
			traps.erase(tr_it);
			tar->flags &= ~(TF_TRAP);
			break;
		//case TRAP_TELE: // (detected by nothing happening!)
		case TRAP_FIREB:
			fireball_trigger(c, arr->get_owner(), tr_it->is_seen_by(arr->get_owner()->team));
			break;
		}
	} // trap found there
	else
		add_action_ind(c, A_MISS);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0x20640(%rip), %rax     # 0x41c58
movq (%rax), %rax
movswq 0x2(%rsi), %rcx
movq 0x8(%rax), %rax
imulq $0x18, %rcx, %rcx
movswq (%rsi), %r12
movq (%rax,%rcx), %r13
testb $0x8, 0x1(%r13,%r12,4)
je 0x2168b
movq %rdi, %r14
callq 0x41e0
pushq $0x64
popq %rcx
cqto
idivq %rcx
cmpq $0x3b, %rdx
jg 0x2168b
movq %rbx, %rdi
callq 0x1bae4
movq %rax, %r15
movzbl 0x1f(%rax), %eax
cmpq $0x5, %rax
ja 0x216da
leaq 0xdb56(%rip), %rcx      # 0x2f1c0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1b202
pushq $0x5
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1b103
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1f635
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x1b202
leaq 0x2178c(%rip), %rdi     # 0x42e58
movq %r15, %rsi
callq 0x17f5c
andb $-0x9, 0x1(%r13,%r12,4)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addq $0x10, %r15
movq 0x10(%r14), %r14
movzbl 0xbc(%r14), %esi
movq %r15, %rdi
callq 0x1cab8
movzbl %al, %edx
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2171a
// File: /workspace/github_cpp_makefile_star2_O2/lotuskip[P]yuxtapa/server/chores.cpp
// Function: (anonymous namespace)::conditional_blind(Coords const&)
void conditional_blind(const Coords &c)
{
	list<PCEnt>::iterator pc_it = any_pc_at(c);
	// Must be valid PC, not assassin, and not a mind's eye using planewalker:
	if(pc_it != PCs.end() && pc_it->get_owner()->cl != C_ASSASSIN
		&& (pc_it->get_owner()->cl != C_PLANEWALKER || !pc_it->get_owner()->limiter))
	{
		pc_it->get_owner()->turns_without_axn = 0; // being blinded stops "idling"
		pc_it->get_owner()->own_vp->blind();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x1b9db
cmpq 0x1b522(%rip), %rax     # 0x3cfa8
je 0x21aa5
movq 0x20(%rax), %rax
movl 0xc0(%rax), %ecx
cmpl $0x1, %ecx
je 0x21aa5
cmpl $0xa, %ecx
jne 0x21aa7
cmpb $0x0, 0x140(%rax)
je 0x21aa7
popq %rbp
retq
andw $0x0, 0x13a(%rax)
movq 0xd0(%rax), %rdi
popq %rbp
jmp 0x194e2
// File: /workspace/github_cpp_makefile_star2_O2/lotuskip[P]yuxtapa/server/cmds.cpp
// Function: (anonymous namespace)::id_pl_by_nick_part(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
list<Player>::iterator id_pl_by_nick_part(const string &s)
{
	list<Player>::iterator foundit = cur_players.end();
	bool found_several = false;
	for(list<Player>::iterator pit = cur_players.begin();
		pit != cur_players.end(); ++pit)
	{
		if(pit->nick == s) // exact match overrules any partial
			return pit;
		// else check for a partial match:
		if(pit->nick.find(s) != string::npos)
		{
			if(foundit != cur_players.end()) // already found one!
				found_several = true;
			foundit = pit;
		}
	}
	if(found_several) // could not match uniquely
		return cur_players.end();
	return foundit;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
leaq 0x1c5a0(%rip), %r14     # 0x400b0
xorl %r8d, %r8d
movq %r14, %r13
movq %r14, %rbx
movq (%rbx), %rbx
cmpq %r14, %rbx
je 0x23b6a
movq %r8, -0x30(%rbp)
leaq 0x98(%rbx), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0xb2dd
testb %al, %al
jne 0x23b7a
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x47d0
cmpq %r14, %r13
setne %cl
movq -0x30(%rbp), %r8
orb %r8b, %cl
cmpq $-0x1, %rax
cmovneq %rbx, %r13
movzbl %cl, %eax
movzbl %r8b, %r8d
cmovnel %eax, %r8d
jmp 0x23b19
testb $0x1, %r8b
je 0x23b77
leaq 0x1c539(%rip), %r13     # 0x400b0
movq %r13, %rbx
movq %rbx, %rax
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/cmds.cpp
// Function: spawn_bot()
bool spawn_bot()
{
	using namespace Config;
	pid_t pid;
	int i;
	if((pid = vfork()) < 0)
	{
		timed_log("!spawnbot -- error in fork!");
		return true;
	}
	if(!pid)
	{
		// This is the forked bot.
		execl(get_botexe().c_str(), get_botexe().c_str(), NULL);
		_exit(0);
	}
	// Server code continues:
	// It might be that the bot executable doesn't exists, in which
	// case the forked child just exited; check:
	if(waitpid(pid, &i, WNOHANG) == pid && WIFEXITED(i))
	{
		timed_log("!spawnbot -- could not find/run \'mrbrown\' executable!");
		Network::to_chat("Cannot spawn bots! Check configuration.");
		return true;
	}
	// else bot is running and network will handle its connection attempt
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
callq 0x45b0
testl %eax, %eax
js 0x23e0a
je 0x23e80
movl %eax, %ebx
movl %eax, %edi
leaq -0x18(%rbp), %rsi
pushq $0x1
popq %rdx
callq 0x4300
cmpl %ebx, %eax
jne 0x23e06
testb $0x7f, -0x18(%rbp)
je 0x23e29
xorl %eax, %eax
jmp 0x23e77
leaq 0xbcf1(%rip), %rsi      # 0x2fb02
leaq -0x38(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0xb292
leaq -0x38(%rbp), %rdi
callq 0x10c94
jmp 0x23e6c
leaq 0xbcee(%rip), %rsi      # 0x2fb1e
leaq -0x38(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0xb292
leaq -0x38(%rbp), %rdi
callq 0x10c94
leaq -0x38(%rbp), %rdi
callq 0x47e8
leaq 0xbcfe(%rip), %rsi      # 0x2fb54
leaq -0x38(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0xb292
leaq -0x38(%rbp), %rdi
callq 0xc248
leaq -0x38(%rbp), %rdi
callq 0x47e8
movb $0x1, %al
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0xdc7e
movq (%rax), %rbx
callq 0xdc7e
movq (%rax), %rsi
xorl %r14d, %r14d
movl %r14d, %edx
movl %r14d, %eax
movq %rbx, %rdi
callq 0x44d0
movl %r14d, %edi
callq 0x46a0
jmp 0x23eb1
jmp 0x23ec5
jmp 0x23eb1
jmp 0x23ec5
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x47e8
movq %rbx, %rdi
callq 0x4710
movq %rax, %rdi
callq 0x4710
// File: /workspace/github_cpp_makefile_star2_O2/lotuskip[P]yuxtapa/server/cmds.cpp
// Function: drop_a_bot()
bool drop_a_bot()
{
	list<Player>::iterator bit = cur_players.begin();
	if(next_bot(bit))
	{
		Game::remove_player(bit, " dropped.");
		return true;
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
leaq 0x1c1cf(%rip), %rax     # 0x400b0
movq (%rax), %rax
leaq -0x28(%rbp), %rdi
movq %rax, (%rdi)
callq 0xfd9d
movl %eax, %ebx
testb %al, %al
je 0x23f25
movq -0x28(%rbp), %r14
leaq 0x50d4(%rip), %rsi      # 0x28fd5
leaq -0x48(%rbp), %r15
leaq -0x19(%rbp), %rdx
movq %r15, %rdi
callq 0xb292
movq %r14, %rdi
movq %r15, %rsi
callq 0x16b9c
leaq -0x48(%rbp), %rdi
callq 0x47e8
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
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/cmds.cpp
// Function: (anonymous namespace)::pl_level_cmp(std::_List_const_iterator<Player>, std::_List_const_iterator<Player>)
bool pl_level_cmp(const list<Player>::const_iterator i, const list<Player>::const_iterator j)
{
	// Ordering is based on a consideration of kills/deaths & playing time:
	unsigned long resi = 0, resj = 0;
	for(char ch = 0; ch < NO_CLASS; ++ch)
	{
		resi += i->stats_i->time_played[ch];
		resj += j->stats_i->time_played[ch];
	}
	resi /= NO_CLASS; // averages of times played as each class
	resj /= NO_CLASS;
	// only take kill/death ratio into account if have enough deaths:
	if(i->stats_i->deaths >= KILLS_DEATHS_REQ_FOR_COMP)
		resi *= float(total_kills(i->stats_i))/i->stats_i->deaths;
	if(j->stats_i->deaths >= KILLS_DEATHS_REQ_FOR_COMP)
		resj *= float(total_kills(j->stats_i))/j->stats_i->deaths;
	// It might be that resi == resj, although this is very unlikely.
	// In that case, less healing received wins (or arbitrarily j if equal):
	if(resi != resj)
		return (resi > resj);
	return (i->stats_i->healing_recvd > j->stats_i->healing_recvd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x90(%rdi), %rbx
movq 0x90(%rsi), %r14
pushq $0x18
popq %rdx
xorl %ecx, %ecx
xorl %eax, %eax
cmpq $0x23, %rdx
je 0x23f7c
addq (%rbx,%rdx,8), %rax
addq (%r14,%rdx,8), %rcx
incq %rdx
jmp 0x23f69
pushq $0xb
popq %rsi
xorl %edx, %edx
divq %rsi
movq %rax, %r15
movq %rcx, %rax
xorl %edx, %edx
divq %rsi
movq %rax, %r12
movq 0x40(%rbx), %r13
cmpq $0x13, %r13
jbe 0x24013
movq %rbx, %rdi
callq 0x240b9
testq %rax, %rax
js 0x23fb0
cvtsi2ss %rax, %xmm0
jmp 0x23fc5
movq %rax, %rcx
shrq %rcx
andl $0x1, %eax
orq %rcx, %rax
cvtsi2ss %rax, %xmm0
addss %xmm0, %xmm0
testq %r13, %r13
js 0x23fd1
cvtsi2ss %r13, %xmm1
jmp 0x23fe7
movq %r13, %rax
shrq %rax
andl $0x1, %r13d
orq %rax, %r13
cvtsi2ss %r13, %xmm1
addss %xmm1, %xmm1
cvtsi2ss %r15, %xmm2
divss %xmm1, %xmm0
mulss %xmm0, %xmm2
cvttss2si %xmm2, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subss 0xb7f8(%rip), %xmm2     # 0x2f800
cvttss2si %xmm2, %r15
andq %rcx, %r15
orq %rax, %r15
movq 0x40(%r14), %r13
cmpq $0x14, %r13
jb 0x24094
movq %r14, %rdi
callq 0x240b9
testq %rax, %rax
js 0x24031
cvtsi2ss %rax, %xmm0
jmp 0x24046
movq %rax, %rcx
shrq %rcx
andl $0x1, %eax
orq %rcx, %rax
cvtsi2ss %rax, %xmm0
addss %xmm0, %xmm0
testq %r13, %r13
js 0x24052
cvtsi2ss %r13, %xmm1
jmp 0x24068
movq %r13, %rax
shrq %rax
andl $0x1, %r13d
orq %rax, %r13
cvtsi2ss %r13, %xmm1
addss %xmm1, %xmm1
cvtsi2ss %r12, %xmm2
divss %xmm1, %xmm0
mulss %xmm0, %xmm2
cvttss2si %xmm2, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subss 0xb777(%rip), %xmm2     # 0x2f800
cvttss2si %xmm2, %r12
andq %rcx, %r12
orq %rax, %r12
cmpq %r12, %r15
jne 0x240a7
movq 0xa8(%rbx), %rax
cmpq 0xa8(%r14), %rax
seta %al
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/cmds.cpp
// Function: (anonymous namespace)::total_kills(std::_List_iterator<PlayerStats>)
unsigned long total_kills(const list<PlayerStats>::iterator st)
{
	unsigned long res = 0;
	for(char i = 0; i < MAX_WAY_TO_KILL; ++i)
		res += st->kills[i];
	if(res > st->tks)
		res -= st->tks;
	return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %ecx, %ecx
xorl %eax, %eax
cmpq $0xb, %rcx
je 0x240d1
addq 0x48(%rdi,%rcx,8), %rax
incq %rcx
jmp 0x240c1
movq 0xa0(%rdi), %rcx
xorl %edx, %edx
cmpq %rcx, %rax
cmovaq %rcx, %rdx
subq %rdx, %rax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/karel-brinda[P]ococo/src/main.cpp
// Function: main
int main(int argc, const char **argv) {
    /* Use default configuration */
    ococo::params_t params = ococo::params_t(argc, argv);
    if (!params.correctly_initialized) {
        return EXIT_FAILURE;
    }

    switch (params.counter_configuration) {
        case ococo::OCOCO16: {
            ococo::caller_t<uint16_t, 3, 4> caller(&params);
            if (!caller.correctly_initialized) {
                return EXIT_FAILURE;
            }
            caller.run();
            return caller.return_code;
        }

        case ococo::OCOCO32: {
            ococo::caller_t<uint32_t, 7, 4> caller(&params);
            if (!caller.correctly_initialized) {
                return EXIT_FAILURE;
            }
            caller.run();
            return caller.return_code;
        }

        case ococo::OCOCO64: {
            ococo::caller_t<uint64_t, 15, 4> caller(&params);
            if (!caller.correctly_initialized) {
                return EXIT_FAILURE;
            }
            caller.run();
            return caller.return_code;
        }
    }

    return EXIT_FAILURE;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x278, %rsp            # imm = 0x278
movq %rsi, %rdx
movl %edi, %esi
leaq 0x40(%rsp), %r14
movq %r14, %rdi
callq 0xaa38
pushq $0x1
popq %rbx
cmpb $0x1, (%r14)
jne 0x4cb8
movl 0x68(%rsp), %eax
cmpl $0x2, %eax
je 0x4c67
cmpl $0x1, %eax
je 0x4c41
testl %eax, %eax
jne 0x4cb8
leaq 0x8(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x529a
cmpb $0x0, 0x8(%rsp)
je 0x4cab
leaq 0x8(%rsp), %rdi
callq 0x57c8
movl 0xc(%rsp), %ebx
jmp 0x4cae
leaq 0x8(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x5c20
cmpb $0x0, 0x8(%rsp)
je 0x4c8d
leaq 0x8(%rsp), %rdi
callq 0x614e
movl 0xc(%rsp), %ebx
jmp 0x4c90
leaq 0x8(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x65a4
cmpb $0x0, 0x8(%rsp)
je 0x4c9c
leaq 0x8(%rsp), %rdi
callq 0x6ad2
movl 0xc(%rsp), %ebx
jmp 0x4c9f
pushq $0x1
popq %rbx
leaq 0x8(%rsp), %rdi
callq 0x6500
jmp 0x4cb8
pushq $0x1
popq %rbx
leaq 0x8(%rsp), %rdi
callq 0x6e84
jmp 0x4cb8
pushq $0x1
popq %rbx
leaq 0x8(%rsp), %rdi
callq 0x5b7c
leaq 0x40(%rsp), %rdi
callq 0xb200
movl %ebx, %eax
addq $0x278, %rsp            # imm = 0x278
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5b7c
jmp 0x4d03
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6e84
jmp 0x4d03
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x6500
jmp 0x4d03
jmp 0x4d00
jmp 0x4d00
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0xb200
movq %rbx, %rdi
callq 0x4950
// File: /workspace/github_cpp_makefile_star2_O2/karel-brinda[P]ococo/src/caller.h
// Function: ococo::caller_t<unsigned short, 3, 4>::~caller_t()
caller_t<T, counter_size, refbase_size>::~caller_t() {
    hts_itr_destroy(iter);
    bam_destroy1(b);
    bam_hdr_destroy(header);

    if (stats != nullptr) {
        delete stats;
    }

    if (return_code == EXIT_SUCCESS && correctly_initialized == true) {
        ococo::info("Ococo successfully finished. Bye.\n");
        ococo::info("%.3f sec; CPU: %.3f sec\n", realtime() - t_real, cputime());
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0xf866
movq 0x10(%rbx), %rdi
callq 0x11220
movq 0x18(%rbx), %rdi
callq 0x10b43
movq 0x20(%rbx), %r14
testq %r14, %r14
je 0x5bbd
movq %r14, %rdi
callq 0x782c
pushq $0x38
popq %rsi
movq %r14, %rdi
callq 0x4540
cmpl $0x0, 0x4(%rbx)
jne 0x5c0f
cmpb $0x1, (%rbx)
jne 0x5c0f
leaq 0x3be48(%rip), %rdi     # 0x41a17
xorl %eax, %eax
callq 0xa59c
callq 0xa67e
movsd %xmm0, 0x10(%rsp)
movsd 0x30(%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0xa6ad
movapd %xmm0, %xmm1
movsd 0x10(%rsp), %xmm0
subsd 0x8(%rsp), %xmm0
leaq 0x3be32(%rip), %rdi     # 0x41a3a
movb $0x2, %al
callq 0xa59c
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x775a
nop
// File: /workspace/github_cpp_makefile_star2_O2/karel-brinda[P]ococo/src/stats.h
// Function: ococo::stats_t<unsigned short, 3, 4>::check_allocation() const
bool stats_t<T, counter_size, refbase_size>::check_allocation() const {
    if (seq_active == nullptr || seq_len == nullptr || seq_stats == nullptr ||
        seq_name == nullptr || seq_comment == nullptr) {
        return false;
    }

    for (int i = 0; i < n_seqs; i++) {
        if (seq_stats[i] == nullptr) {
            return false;
        }
    }

    return true;
}

// Assembly:
xorl %eax, %eax
cmpq $0x0, 0x8(%rdi)
je 0x718e
cmpq $0x0, 0x10(%rdi)
je 0x718e
movq 0x28(%rdi), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x718e
cmpq $0x0, 0x18(%rdi)
je 0x718e
cmpq $0x0, 0x20(%rdi)
je 0x718e
movslq (%rdi), %rax
xorl %edx, %edx
testl %eax, %eax
movl $0x0, %esi
cmovgl %eax, %esi
cmpq %rdx, %rsi
je 0x718f
cmpq $0x0, (%rcx,%rdx,8)
leaq 0x1(%rdx), %rdx
jne 0x717c
xorl %eax, %eax
retq
cmpq %rax, %rdx
setge %al
retq
// File: /workspace/github_cpp_makefile_star2_O2/karel-brinda[P]ococo/src/stats.h
// Function: ococo::stats_t<unsigned int, 7, 4>::compress_position_stats(ococo::pos_stats_uncompr_t const&)
T stats_t<T, counter_size, refbase_size>::compress_position_stats(
    const pos_stats_uncompr_t &psu) {
    T psc = 0;

    for (int32_t i = 0; i < 4; i++) {
        psc <<= counter_size;
        psc |= psu.counters[i] & right_full_mask<T, counter_size>();
    }

    psc <<= refbase_size;
    psc |= psu.nt16;

    return psc;
}

// Assembly:
xorl %ecx, %ecx
pushq $0x1
popq %rax
cmpq $0x5, %rax
je 0x8923
shll $0x7, %ecx
movl (%rdi,%rax,4), %edx
andl $0x7f, %edx
orl %edx, %ecx
incq %rax
jmp 0x890d
shll $0x4, %ecx
movzbl (%rdi), %eax
orl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/karel-brinda[P]ococo/src/stats.h
// Function: ococo::stats_t<unsigned short, 3, 4>::~stats_t()
stats_t<T, counter_size, refbase_size>::~stats_t() {
    if (seq_stats != nullptr) {
        for (int32_t seqid = 0; seqid < n_seqs; seqid++) {
            delete[] seq_stats[seqid];
        }
    }
    delete[] seq_active;
    delete[] seq_len;
    delete[] seq_name;
    delete[] seq_comment;
    delete[] seq_stats;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x28(%rdi)
je 0x7861
xorl %r14d, %r14d
movslq (%rbx), %rax
cmpq %rax, %r14
jge 0x7861
movq 0x28(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x785c
callq 0x46b0
incq %r14
jmp 0x7842
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x786f
callq 0x46b0
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x787d
callq 0x46b0
movq 0x18(%rbx), %r12
testq %r12, %r12
je 0x78c2
leaq -0x8(%r12), %r14
movq -0x8(%r12), %r15
testq %r15, %r15
je 0x78af
addq $-0x20, %r12
movq %r15, %r13
shlq $0x5, %r13
leaq (%r12,%r13), %rdi
callq 0x4230
addq $-0x20, %r13
jne 0x78a0
shlq $0x5, %r15
orq $0x8, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x4a30
movq 0x20(%rbx), %r12
testq %r12, %r12
je 0x7907
leaq -0x8(%r12), %r14
movq -0x8(%r12), %r15
testq %r15, %r15
je 0x78f4
addq $-0x20, %r12
movq %r15, %r13
shlq $0x5, %r13
leaq (%r12,%r13), %rdi
callq 0x4230
addq $-0x20, %r13
jne 0x78e5
shlq $0x5, %r15
orq $0x8, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x4a30
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x791e
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x46b0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/karel-brinda[P]ococo/src/stats.h
// Function: ococo::stats_t<unsigned short, 3, 4>::increment(unsigned short, unsigned char)
T stats_t<T, counter_size, refbase_size>::increment(T psc, nt4_t nt4) {
    assert(0 <= nt4 && nt4 < 4);

    pos_stats_uncompr_t psu;
    decompress_position_stats(psc, psu);

    if (psu.counters[nt4] == right_full_mask<uint16_t, counter_size>()) {
        psu.counters[0] >>= 1;
        psu.counters[1] >>= 1;
        psu.counters[2] >>= 1;
        psu.counters[3] >>= 1;
    }

    psu.counters[nt4]++;

    return compress_position_stats(psu);
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movl %esi, %ebx
cmpb $0x4, %bl
jae 0x79a0
movzwl %di, %edi
leaq 0x8(%rsp), %rsi
callq 0x7e4c
movzbl %bl, %eax
movl 0xc(%rsp,%rax,4), %ecx
cmpl $0x7, %ecx
jne 0x798a
movdqu 0xc(%rsp), %xmm0
psrad $0x1, %xmm0
movdqu %xmm0, 0xc(%rsp)
movl 0xc(%rsp,%rax,4), %ecx
incl %ecx
movl %ecx, 0xc(%rsp,%rax,4)
leaq 0x8(%rsp), %rdi
callq 0x7766
addq $0x20, %rsp
popq %rbx
retq
leaq 0x3a133(%rip), %rdi     # 0x41ada
leaq 0x399fc(%rip), %rsi     # 0x413aa
leaq 0x3a139(%rip), %rcx     # 0x41aee
movl $0x273, %edx            # imm = 0x273
callq 0x4360
nop