LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x28, %rsp
movq %rdi, -0x48(%rbp)
leaq 0x24848(%rip), %r13     # 0x45e98
leaq -0x34(%rbp), %r15
movq %r13, %r12
movq (%r12), %r12
cmpq %r13, %r12
je 0x2169f
movb 0x1e(%r12), %bl
testb %bl, %bl
je 0x2166e
xorl %r14d, %r14d
jmp 0x21685
movl 0x18(%r12), %eax
movl %eax, -0x34(%rbp)
movq %r15, %rdi
movq -0x48(%rbp), %rsi
callq 0x2bddc
movl %eax, %r14d
testb %bl, %bl
jne 0x21691
movq %r15, %rdi
callq 0x2bbf6
testb %r14b, %r14b
je 0x21657
leaq 0x10(%r12), %rax
movq %rax, -0x40(%rbp)
leaq 0x247f2(%rip), %rax     # 0x45e98
cmpq %rax, %r12
je 0x216b4
movq -0x40(%rbp), %rax
jmp 0x2176f
leaq 0x247f5(%rip), %r14     # 0x45eb0
leaq -0x30(%rbp), %r15
movq %r14, %r13
movq (%r13), %r13
cmpq %r14, %r13
je 0x21707
movb 0x1e(%r13), %bl
testb %bl, %bl
je 0x216d8
xorl %r12d, %r12d
jmp 0x216ee
movl 0x18(%r13), %eax
movl %eax, -0x30(%rbp)
movq %r15, %rdi
movq -0x48(%rbp), %rsi
callq 0x2bddc
movl %eax, %r12d
testb %bl, %bl
jne 0x216fa
movq %r15, %rdi
callq 0x2bbf6
testb %r12b, %r12b
je 0x216c2
leaq 0x10(%r13), %rax
movq %rax, -0x40(%rbp)
leaq 0x247a2(%rip), %rax     # 0x45eb0
cmpq %rax, %r13
movq -0x40(%rbp), %rax
jne 0x2176f
leaq 0x247aa(%rip), %r14     # 0x45ec8
xorl %eax, %eax
leaq -0x2c(%rbp), %r15
movq %r14, %r13
movq (%r13), %r13
cmpq %r14, %r13
je 0x2176f
movb 0x1e(%r13), %bl
testb %bl, %bl
je 0x2173d
xorl %r12d, %r12d
jmp 0x21755
movl 0x18(%r13), %eax
movl %eax, -0x2c(%rbp)
movq %r15, %rdi
movq -0x48(%rbp), %rsi
callq 0x2bddc
movl %eax, %r12d
xorl %eax, %eax
testb %bl, %bl
jne 0x21763
movq %r15, %rdi
callq 0x2bbf6
xorl %eax, %eax
testb %r12b, %r12b
je 0x21727
addq $0x10, %r13
movq %r13, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x2c(%rbp), %rdi
jmp 0x21797
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
jmp 0x21797
movq %rax, %rbx
leaq -0x34(%rbp), %rdi
callq 0x2bbf6
movq %rbx, %rdi
callq 0x4750
// File: /workspace/github_cpp_makefile_star2_O1/lotuskip[P]yuxtapa/server/ent.cpp
// Function: Ent::draw(char*, bool) const
void Ent::draw(char *target, const bool lit) const
{
	char cp = cpair;
	if(lit)
		cp += NUM_NORM_COLS;
	*target = cp;
	*(++target) = symbol;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movzbl 0xd(%rdi), %eax
leal 0x14(%rax), %ecx
movzbl %cl, %ecx
testl %edx, %edx
cmovel %eax, %ecx
movb %cl, (%rsi)
movb 0xc(%rdi), %al
movb %al, 0x1(%rsi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x21fd4
retq
pushq %rbp
movq %rsp, %rbp
movb $0x1, 0xe(%rdi)
leaq 0x22c85(%rip), %rax     # 0x44c68
movq (%rax), %rax
movswq 0xa(%rdi), %rcx
movq 0x8(%rax), %rax
leaq (%rcx,%rcx,2), %rcx
movswq 0x8(%rdi), %rdx
movq (%rax,%rcx,8), %rax
andw $-0x21, (%rax,%rdx,4)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x224b1
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
leaq 0x23c14(%rip), %rdi     # 0x45fd8
movq %r14, %rsi
callq 0x21b9c
leaq 0x22895(%rip), %rax     # 0x44c68
movq (%rax), %rax
movswq 0xa(%rbx), %rcx
movq 0x8(%rax), %rax
leaq (%rcx,%rcx,2), %rcx
movswq 0x8(%rbx), %rdx
movq (%rax,%rcx,8), %rax
andw $-0x41, (%rax,%rdx,4)
leaq 0x18(%rbx), %r15
xorl %r13d, %r13d
xorl %r12d, %r12d
movq 0x18(%rbx), %rsi
addq $0x10, %rsi
movq %rbx, %rdi
callq 0x26926
testb %al, %al
jne 0x2244a
movq (%r15), %rsi
movl 0x10(%rsi), %eax
movl %eax, (%r14)
movq %r15, %rdi
callq 0x1f57e
cmpq %r15, (%r15)
je 0x2243b
cmpb $0x2, %r12b
leal 0x1(%r12), %eax
setae %r13b
movl %eax, %r12d
cmpb $0x3, %al
jne 0x223fb
jmp 0x22450
movq %rbx, %rdi
movq %r14, %rsi
callq 0x27462
movb $0x1, 0xe(%rbx)
testb $0x1, %r13b
je 0x224b1
leaq 0x22811(%rip), %rax     # 0x44c68
movq (%rax), %rax
movswq 0xa(%rbx), %rcx
movq 0x8(%rax), %rax
leaq (%rcx,%rcx,2), %rcx
movswq 0x8(%rbx), %rdx
movq (%rax,%rcx,8), %rax
orw $0x40, (%rax,%rdx,4)
leaq 0x23b5c(%rip), %rdi     # 0x45fd8
movq %r14, %rsi
callq 0x21b9c
movq 0x18(%rbx), %rax
movl 0x10(%rax), %eax
leaq -0x2c(%rbp), %rsi
movl %eax, (%rsi)
movq %r14, %rdi
callq 0x2bd30
movl %eax, %eax
leaq 0x10c72(%rip), %rcx     # 0x33114
movb (%rax,%rcx), %al
movb %al, 0xc(%rbx)
leaq -0x2c(%rbp), %rdi
callq 0x2bbf6
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/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 0x22a45
movq %rdi, %r13
movb 0x1c(%rdi), %al
cmpb $-0x1, %al
je 0x22952
leaq 0x8(%r13), %rsi
leaq 0x236b2(%rip), %rdi     # 0x45fd8
callq 0x21b9c
leaq 0x22336(%rip), %rax     # 0x44c68
movq (%rax), %rax
movswq 0xa(%r13), %rcx
movq 0x8(%rax), %rax
leaq (%rcx,%rcx,2), %rcx
movswq 0x8(%r13), %rdx
movq (%rax,%rcx,8), %rax
andw $-0x41, (%rax,%rdx,4)
jmp 0x22958
incb %al
movb %al, 0x1c(%r13)
leaq 0x8(%r13), %r14
xorl %ecx, %ecx
leaq -0x2c(%rbp), %rbx
xorl %r12d, %r12d
movl %ecx, -0x30(%rbp)
movl 0x18(%r13), %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2bc76
movq %r13, %r15
movq %r13, %rdi
movq %rbx, %rsi
callq 0x26926
movl %eax, %r13d
movq %rbx, %rdi
callq 0x2bbf6
testb %r13b, %r13b
movq %r15, %r13
je 0x229a5
cmpb $0x0, 0xe(%r13)
jne 0x229e4
cmpb $0x1, %r12b
je 0x229df
movl 0x18(%r13), %edx
leaq -0x34(%rbp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2bc76
movl -0x34(%rbp), %eax
movl %eax, 0x8(%r13)
movq %rbx, %rdi
callq 0x2bbf6
testb %r12b, %r12b
leal 0x1(%r12), %eax
setne %cl
movl %eax, %r12d
cmpb $0x2, %al
leaq -0x2c(%rbp), %rbx
jne 0x22965
jmp 0x229ea
movb $0x1, 0xe(%r13)
testb $0x1, -0x30(%rbp)
je 0x22a45
movb 0x1d(%r13), %al
incb %al
movb %al, 0x1d(%r13)
cmpb $0x7, %al
jl 0x229ff
movb $0x1, 0xe(%r13)
jmp 0x22a45
leaq 0x22262(%rip), %rax     # 0x44c68
movq (%rax), %rax
movswq 0xa(%r13), %rcx
movq 0x8(%rax), %rax
leaq (%rcx,%rcx,2), %rcx
movswq 0x8(%r13), %rdx
movq (%rax,%rcx,8), %rax
orw $0x40, (%rax,%rdx,4)
leaq 0x235ad(%rip), %rdi     # 0x45fd8
movq %r14, %rsi
callq 0x21b9c
movl 0x18(%r13), %eax
leaq 0x106df(%rip), %rcx     # 0x3311d
movb (%rax,%rcx), %al
movb %al, 0xc(%r13)
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/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
movl $0x46, %ebx
cmpb $0x0, 0x1c(%rdi)
jg 0x22a94
movb 0x1d(%rdi), %al
movl $0xa, %ebx
cmpb $0x3, %al
jl 0x22a94
movzbl %al, %eax
shll $0x2, %eax
leal (%rax,%rax,4), %eax
addb $-0x1e, %al
movsbq %al, %rbx
callq 0x41d0
movq %rax, %rcx
movabsq $-0x5c28f5c28f5c28f5, %rdx # imm = 0xA3D70A3D70A3D70B
imulq %rdx
addq %rcx, %rdx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x6, %rdx
addq %rax, %rdx
imulq $0x64, %rdx, %rax
subq %rax, %rcx
cmpq %rbx, %rcx
setl %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x22ae4
movb $0x1, 0xe(%rdi)
jmp 0x22aeb
movb $0x0, 0x1d(%rdi)
movl %esi, 0x18(%rdi)
cmpb $0x7, %al
sete %al
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movq %rdi, %rax
movzwl 0x23d00(%rip), %r10d    # 0x46906
movzwl 0x23cf3(%rip), %ecx     # 0x46900
movzwl 0x23cee(%rip), %edx     # 0x46902
movzwl 0x23cee(%rip), %r9d     # 0x4690a
movzwl 0x23ce5(%rip), %esi     # 0x46908
movzwl 0x23cda(%rip), %edi     # 0x46904
leaq 0x124cf(%rip), %r8      # 0x35100
movswl %r10w, %r11d
leal 0x3(%r11), %r14d
testl %r11d, %r11d
cmovnsl %r11d, %r14d
leal -0x1(%r11), %r15d
leal 0x2(%r11), %ebx
testl %r15d, %r15d
cmovnsl %r15d, %ebx
incl %r9d
cmpw %si, %r9w
jne 0x22c79
leal 0x1(%r10), %r15d
movw %r15w, 0x23ca2(%rip)    # 0x46906
testb $0x1, %r10b
jne 0x22c73
incl %esi
movw %si, 0x23c95(%rip)      # 0x46908
xorl %r9d, %r9d
movl %r15d, %r10d
andl $-0x4, %r14d
movl %r11d, %r15d
subl %r14d, %r15d
movslq %r15d, %r14
movsbl (%r14,%r8), %r14d
addl %r14d, %ecx
andl $-0x4, %ebx
negl %ebx
addl %ebx, %r11d
decl %r11d
movslq %r11d, %r11
movsbl (%r11,%r8), %r11d
addl %r11d, %edx
testw %cx, %cx
jle 0x22c31
testw %dx, %dx
jle 0x22c31
cmpw %di, %cx
jge 0x22c31
cmpw %di, %dx
jge 0x22c31
movw %cx, 0x23c39(%rip)      # 0x46900
movw %dx, 0x23c34(%rip)      # 0x46902
movw %r9w, 0x23c34(%rip)     # 0x4690a
movl 0x23c24(%rip), %ecx     # 0x46900
movl %ecx, (%rax)
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rdi, -0x38(%rbp)
leaq 0x21761(%rip), %rax     # 0x45dc0
movq 0x90(%rax), %r13
addq $0x90, %rax
cmpq %rax, %r13
je 0x246cb
leaq -0x30(%rbp), %r14
leaq -0x2c(%rbp), %rbx
movl $0x90, %r15d
addq 0x1b942(%rip), %r15     # 0x3ffc8
movl 0x18(%r13), %eax
movl %eax, -0x30(%rbp)
movq -0x38(%rbp), %rdi
movq %r14, %rsi
callq 0x2bc42
movl %eax, %r12d
movq %r14, %rdi
callq 0x2bbf6
cmpw $0x8, %r12w
jg 0x246c2
movl 0x18(%r13), %eax
movl %eax, -0x2c(%rbp)
movq %rbx, %rdi
callq 0x20cea
movq %rbx, %rdi
callq 0x2bbf6
movq (%r13), %r13
cmpq %r15, %r13
jne 0x24686
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x2c(%rbp), %rdi
jmp 0x246ea
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/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 0x1f38c(%rip), %rax     # 0x44224
cmpl $0x4, (%rax)
jne 0x24eca
leaq 0x1f384(%rip), %rax     # 0x44228
movzwl (%rax), %ecx
movzwl 0x2(%rax), %edx
movl 0xbc(%rdi), %esi
incw (%rax,%rsi,2)
movzwl (%rax), %esi
movzwl 0x2(%rax), %eax
cmpl %edx, %ecx
setne %cl
cmpl %eax, %esi
setne %al
testb %cl, %al
je 0x24ecc
popq %rbp
retq
leaq 0x1e1ed(%rip), %rdi     # 0x430c0
popq %rbp
jmp 0x19f7b
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2bbe8
leaq 0x10221(%rip), %r12     # 0x35240
leaq 0x1fc42(%rip), %r13     # 0x44c68
movl %r14d, -0x30(%rbp)
movslq %r14d, %rax
addq %rax, %rax
leaq (%rax,%rax,2), %r14
xorl %r15d, %r15d
movslq %r15d, %rax
addq %r14, %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
leaq (%rax,%rax,2), %rax
movswq %cx, %rcx
movq (%rdx,%rax,8), %rax
movl (%rax,%rcx,4), %eax
testb $0x40, %al
jne 0x2507c
testb $0x4, %al
jne 0x25085
jmp 0x25093
leaq -0x2c(%rbp), %rdi
callq 0x27c83
addb $0x2, %r15b
movsbl %r15b, %r15d
cmpl $0x6, %r15d
jl 0x25037
movl -0x30(%rbp), %r14d
incl %r14d
cmpl $0x18, %r14d
jne 0x25026
movq %rbx, %rdi
callq 0x27c83
movq %rbx, %rdi
movl $0x3, %esi
callq 0x20b4f
leaq -0x2c(%rbp), %rdi
callq 0x2bbf6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x250cf
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/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
leaq (%rcx,%rcx,2), %rdx
leaq (%rcx,%rdx,4), %rcx
leaq 0x10097(%rip), %r14     # 0x351a0
cmpb 0x3(%r14,%rcx), %al
jge 0x25184
movq %rdi, %rbx
movq 0x90(%rbx), %rax
incq 0xa8(%rax)
je 0x2514f
movb 0x153(%rbx), %al
incb %al
movb %al, 0x153(%rbx)
movl 0xc0(%rbx), %ecx
leaq (%rcx,%rcx,2), %rdx
leaq (%rcx,%rdx,4), %rcx
cmpb 0x3(%r14,%rcx), %al
jge 0x2514f
callq 0x41d0
testb $0x3, %al
je 0x25113
leaq 0x1df6a(%rip), %rax     # 0x430c0
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 0x20a4f
leaq -0x14(%rbp), %rdi
callq 0x2bbf6
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x14(%rbp), %rdi
callq 0x2bbf6
movq %rbx, %rdi
callq 0x4750
// File: /workspace/github_cpp_makefile_star2_O1/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
movl %esi, %r14d
movq %rdi, %r15
leaq 0x1f515(%rip), %rax     # 0x44c68
movq (%rax), %rax
movswq 0x2(%rdi), %rcx
movq 0x8(%rax), %rax
leaq (%rcx,%rcx,2), %rcx
movswq (%rdi), %r13
movq (%rax,%rcx,8), %r12
movzbl 0x2(%r12,%r13,4), %eax
xorl %ebx, %ebx
cmpl $0x2c, %eax
jg 0x2578c
cmpl $0x23, %eax
je 0x25862
cmpl $0x2b, %eax
je 0x2586b
jmp 0x2579e
cmpl $0x2d, %eax
je 0x2586b
cmpl $0x7c, %eax
je 0x2586b
testb $0x20, (%r12,%r13,4)
je 0x257c6
movq %r15, %rdi
movl $0x1, %esi
callq 0x2149b
leaq 0x20607(%rip), %rcx     # 0x45dc0
addq $0x18, %rcx
cmpq %rcx, %rax
jne 0x2585e
movb $0x1, %bl
testb $0x40, (%r12,%r13,4)
je 0x2586b
movq %r15, %rdi
callq 0x215ae
cmpq 0x1a7f6(%rip), %rax     # 0x3ffd8
je 0x2586b
leaq -0x2c(%rbp), %rdi
movq %r15, %rsi
movl %r14d, %edx
callq 0x2bc76
testb $0x2, (%r12,%r13,4)
jne 0x25855
leaq 0x1f463(%rip), %rax     # 0x44c68
movq (%rax), %rax
movswq -0x2a(%rbp), %rcx
movq 0x8(%rax), %rax
leaq (%rcx,%rcx,2), %rdx
movswq -0x2c(%rbp), %rcx
movq (%rax,%rdx,8), %rdx
movzwl (%rdx,%rcx,4), %eax
movl %eax, %esi
andl $0x41, %esi
cmpl $0x1, %esi
jne 0x25855
cmpb $0x5c, 0x2(%rdx,%rcx,4)
je 0x25855
testb $0x20, %al
je 0x2587c
leaq -0x2c(%rbp), %rdi
movl $0x5, %esi
callq 0x2149b
leaq 0x20574(%rip), %rcx     # 0x45dc0
addq $0x78, %rcx
cmpq %rcx, %rax
je 0x2587c
leaq -0x2c(%rbp), %rdi
callq 0x2bbf6
xorl %ebx, %ebx
jmp 0x2586b
movb (%r12,%r13,4), %bl
andb $0x1, %bl
negb %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq -0x2c(%rbp), %rdi
callq 0x2bbf6
jmp 0x2586b
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/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 0x1d5a6(%rip), %r13     # 0x430c0
movq (%r13), %rbx
cmpq %r13, %rbx
je 0x25c1d
leaq -0x30(%rbp), %r14
leaq -0x2c(%rbp), %r15
leaq 0x10(%rbx), %rdi
callq 0x125e6
testb %al, %al
je 0x25c11
movl 0x13c(%rbx), %edx
cmpl $0x8, %edx
je 0x25c11
movq 0x148(%rbx), %rax
movl 0x8(%rax), %eax
movl %eax, -0x2c(%rbp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x2bc76
movq %r15, %rdi
callq 0x2bbf6
leaq 0x1f0f2(%rip), %rax     # 0x44c68
movq (%rax), %rax
movswq -0x2e(%rbp), %rcx
movq 0x8(%rax), %rax
leaq (%rcx,%rcx,2), %rcx
movswq -0x30(%rbp), %rdx
movq (%rax,%rcx,8), %rax
testb $0x40, (%rax,%rdx,4)
jne 0x25bb1
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x251a1
movl $0x8, 0x13c(%rbx)
jmp 0x25c05
movq %r14, %rdi
callq 0x21415
cmpq 0x1a3f0(%rip), %rax     # 0x3ffb0
je 0x25c05
movq 0x20(%rax), %r12
movl 0xbc(%r12), %eax
cmpl 0xbc(%rbx), %eax
jne 0x25c05
movl 0x13c(%r12), %r15d
movl 0x13c(%rbx), %edi
callq 0x2bbcc
cmpl %eax, %r15d
je 0x25bfa
cmpw $0x8, 0x13a(%r12)
jb 0x25c05
movq %r12, %rdi
movq %rbx, %rsi
callq 0x25c4d
movq %r14, %rdi
callq 0x2bbf6
leaq -0x2c(%rbp), %r15
movq (%rbx), %rbx
cmpq %r13, %rbx
jne 0x25b2f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x25c30
jmp 0x25c30
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
jmp 0x25c40
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/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 0x251a1
leaq -0x14(%rbp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x251a1
movl $0x8, %eax
movl %eax, 0x13c(%rbx)
movl %eax, 0x13c(%r14)
addq $0x10, %r14
movq %r14, %rdi
callq 0x125e6
addq $0x10, %rbx
testb %al, %al
jne 0x25cdb
leaq 0x1efab(%rip), %rax     # 0x44c68
movq (%rax), %rax
movswq -0x12(%rbp), %rcx
movq 0x8(%rax), %rax
leaq (%rcx,%rcx,2), %rcx
movswq -0x14(%rbp), %rdx
movq (%rax,%rcx,8), %rax
andw $-0x41, (%rax,%rdx,4)
movq %rbx, %rdi
callq 0x125e6
testb %al, %al
jne 0x25d0c
leaq 0x1ef7a(%rip), %rax     # 0x44c68
movq (%rax), %rax
movswq -0x16(%rbp), %rcx
movq 0x8(%rax), %rax
leaq (%rcx,%rcx,2), %rcx
movswq -0x18(%rbp), %rdx
movq (%rax,%rcx,8), %rax
andw $-0x41, (%rax,%rdx,4)
leaq -0x18(%rbp), %rdi
callq 0x2bbf6
leaq -0x14(%rbp), %rdi
callq 0x2bbf6
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x18(%rbp), %rdi
callq 0x2bbf6
leaq -0x14(%rbp), %rdi
callq 0x2bbf6
movq %rbx, %rdi
callq 0x4750
// File: /workspace/github_cpp_makefile_star2_O1/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, %r12d
movl %ecx, -0x40(%rbp)
movl %edx, %r15d
movq 0x148(%rdi), %rax
movl 0x8(%rax), %eax
movl %eax, -0x2c(%rbp)
movq %rdi, -0x38(%rbp)
movb 0x158(%rdi), %bl
subb %sil, %bl
callq 0x41d0
movq %rax, %r13
movabsq $0x6666666666666667, %rcx # imm = 0x6666666666666667
imulq %rcx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x3, %rdx
addq %rax, %rdx
shlq $0x2, %rdx
leaq (%rdx,%rdx,4), %rax
subq %rax, %r13
movsbl %bl, %ecx
cmpl %ecx, %r13d
setge %al
cmpq $0x13, %r13
sete %r14b
orb %al, %r14b
cmpb $0x1, %r14b
jne 0x267e8
movl %ecx, -0x3c(%rbp)
testb %r15b, %r15b
je 0x267f8
movsbq -0x40(%rbp), %rbx
callq 0x41d0
cqto
idivq %rbx
movq %rdx, %rcx
addb %r12b, %cl
incb %cl
movl %ecx, %r12d
decb %r15b
jne 0x267cc
jmp 0x267fb
leaq -0x2c(%rbp), %rdi
movl $0x5, %esi
callq 0x20a4f
jmp 0x26842
movl %r12d, %ecx
cmpq $0x13, %r13
je 0x26819
movl %r13d, %eax
cltd
idivl -0x3c(%rbp)
cmpl $0x1, %eax
jg 0x26819
movq -0x38(%rbp), %rdx
subb 0x159(%rdx), %cl
jmp 0x2681d
movq -0x38(%rbp), %rdx
movzbl %cl, %eax
xorl %ecx, %ecx
testb %al, %al
cmovgl %eax, %ecx
subb %cl, 0x153(%rdx)
movb $0x1, 0x15d(%rdx)
leaq -0x2c(%rbp), %rdi
movl $0x4, %esi
callq 0x20a4f
leaq -0x2c(%rbp), %rdi
callq 0x2bbf6
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2685f
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/chores.cpp
// Function: (anonymous namespace)::finish_wall_dig(Coords const&)
void finish_wall_dig(const Coords &c)
{
	update_lights_around(c);
	// Need to update BYWALL for neighbours:
	e_Dir dir = D_N;
	Coords cn;
	do {
		cn = c.in(dir);
		Game::curmap->upd_by_wall_flag(cn);
	} while(++dir != D_N);
	event_set.insert(c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0x24643
leaq -0x34(%rbp), %r14
movl $0x0, (%r14)
leaq -0x2c(%rbp), %r15
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2bbe8
leaq -0x30(%rbp), %r12
leaq 0x1e3b6(%rip), %r13     # 0x44c68
movl -0x34(%rbp), %edx
movq %r12, %rdi
movq %rbx, %rsi
callq 0x2bc76
movl -0x30(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq %r12, %rdi
callq 0x2bbf6
movq (%r13), %rdi
movq %r15, %rsi
callq 0x16f22
movq %r14, %rdi
callq 0x2bb9c
cmpl $0x0, (%rax)
jne 0x268b2
leaq 0x1f6ea(%rip), %rdi     # 0x45fd8
movq %rbx, %rsi
callq 0x21b9c
leaq -0x2c(%rbp), %rdi
callq 0x2bbf6
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x26912
jmp 0x26912
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/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 0x1d7ee(%rip), %rax     # 0x44c68
movq (%rax), %rax
movswq 0x2(%rsi), %rcx
movq 0x8(%rax), %rax
leaq (%rcx,%rcx,2), %rcx
movswq (%rsi), %r12
movq (%rax,%rcx,8), %r13
testb $0x8, 0x1(%r13,%r12,4)
je 0x2750d
movq %rdi, %r14
callq 0x41d0
movq %rax, %rcx
movabsq $-0x5c28f5c28f5c28f5, %rdx # imm = 0xA3D70A3D70A3D70B
imulq %rdx
addq %rcx, %rdx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x6, %rdx
addq %rax, %rdx
imulq $0x64, %rdx, %rax
subq %rax, %rcx
cmpq $0x3b, %rcx
jg 0x2750d
movq %rbx, %rdi
callq 0x21528
movq %rax, %r15
movzbl 0x1f(%rax), %eax
cmpq $0x5, %rax
ja 0x27560
leaq 0xdc94(%rip), %rcx      # 0x35180
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 0x20b4f
movq %rbx, %rdi
movl $0x5, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20a4f
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x24ff7
movq %rbx, %rdi
movl $0x1, %esi
callq 0x20b4f
leaq 0x1e916(%rip), %rdi     # 0x45e68
movq %r15, %rsi
callq 0x1d882
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 0x22060
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 0x275a0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x21415
cmpq 0x1831d(%rip), %rax     # 0x3ffb0
je 0x27cb2
movq 0x20(%rax), %rax
movl 0xc0(%rax), %ecx
cmpl $0x1, %ecx
je 0x27cb2
cmpl $0xa, %ecx
jne 0x27cb4
cmpb $0x0, 0x140(%rax)
je 0x27cb4
popq %rbp
retq
movw $0x0, 0x13a(%rax)
movq 0xd0(%rax), %rdi
popq %rbp
jmp 0x1ed2c
// File: /workspace/github_cpp_makefile_star2_O1/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
leaq 0x189c7(%rip), %rbx     # 0x430c0
movq (%rbx), %r13
cmpq %rbx, %r13
je 0x2a796
leaq 0x189b4(%rip), %rbx     # 0x430c0
xorl %r14d, %r14d
movq %rdi, -0x30(%rbp)
leaq 0x98(%r13), %r12
movq 0xa0(%r13), %rdx
movq 0x8(%rdi), %r15
cmpq %r15, %rdx
jne 0x2a743
testq %rdx, %rdx
je 0x2a793
movq (%rdi), %rsi
movq (%r12), %rdi
callq 0x4400
movq -0x30(%rbp), %rdi
testl %eax, %eax
je 0x2a793
movq (%rdi), %rsi
movq %r12, %rdi
xorl %edx, %edx
movq %r15, %rcx
callq 0x4730
movq -0x30(%rbp), %rdi
leaq 0x18962(%rip), %rdx     # 0x430c0
cmpq %rdx, %rbx
movzbl %r14b, %ecx
movl $0x1, %r14d
cmovel %ecx, %r14d
cmpq $-0x1, %rax
cmovneq %r13, %rbx
cmovel %ecx, %r14d
movq (%r13), %r13
cmpq %rdx, %r13
jne 0x2a713
testb $0x1, %r14b
je 0x2a796
leaq 0x1892f(%rip), %rbx     # 0x430c0
jmp 0x2a796
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_O1/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 0x45a0
testl %eax, %eax
js 0x2aae8
je 0x2ab92
movl %eax, %ebx
movl %eax, %edi
leaq -0x34(%rbp), %rsi
movl $0x1, %edx
callq 0x42f0
cmpl %ebx, %eax
jne 0x2aae1
testb $0x7f, -0x34(%rbp)
je 0x2ab12
xorl %eax, %eax
jmp 0x2ab89
leaq -0x20(%rbp), %rbx
movq %rbx, -0x10(%rbx)
leaq 0xafc8(%rip), %rsi      # 0x35abf
leaq 0xafdc(%rip), %rdx      # 0x35ada
leaq -0x30(%rbp), %rdi
callq 0xdfec
leaq -0x30(%rbp), %rdi
callq 0x15254
jmp 0x2ab72
leaq -0x20(%rbp), %rbx
movq %rbx, -0x10(%rbx)
leaq 0xafba(%rip), %rsi      # 0x35adb
leaq 0xafe8(%rip), %rdx      # 0x35b10
leaq -0x30(%rbp), %rdi
callq 0xdfec
leaq -0x30(%rbp), %rdi
callq 0x15254
movq -0x30(%rbp), %rdi
cmpq %rbx, %rdi
je 0x2ab4f
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x43f0
leaq -0x30(%rbp), %rdi
movq %rbx, (%rdi)
leaq 0xafb4(%rip), %rsi      # 0x35b11
leaq 0xafd4(%rip), %rdx      # 0x35b38
callq 0xdfec
leaq -0x30(%rbp), %rdi
callq 0xf676
movq -0x30(%rbp), %rdi
cmpq %rbx, %rdi
je 0x2ab87
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x43f0
movb $0x1, %al
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x11b3b
movq (%rax), %rbx
callq 0x11b3b
movq (%rax), %rsi
xorl %r14d, %r14d
movl %r14d, %edx
movl %r14d, %eax
movq %rbx, %rdi
callq 0x44d0
movl %r14d, %edi
callq 0x46c0
jmp 0x2abc3
jmp 0x2abdd
jmp 0x2abc3
jmp 0x2abdd
movq %rax, %r14
movq -0x30(%rbp), %rdi
cmpq %rbx, %rdi
je 0x2abe0
movq -0x20(%rbp), %rsi
incq %rsi
callq 0x43f0
jmp 0x2abe0
movq %rax, %r14
movq %r14, %rdi
callq 0x4750
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x30, %rsp
leaq 0x184c2(%rip), %rax     # 0x430c0
movq (%rax), %rax
leaq -0x28(%rbp), %rdi
movq %rax, (%rdi)
callq 0x1476c
movl %eax, %ebx
testb %al, %al
je 0x2ac5a
movq -0x28(%rbp), %r14
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x4375(%rip), %rsi      # 0x2ef9c
leaq 0x4377(%rip), %rdx      # 0x2efa5
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0xdfec
movq %r14, %rdi
movq %r15, %rsi
callq 0x1bff2
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x2ac5a
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x43f0
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x2ac81
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x43f0
movq %rbx, %rdi
callq 0x4750
// File: /workspace/github_cpp_makefile_star2_O1/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
movq 0x90(%rdi), %rcx
movq 0x90(%rsi), %rdx
xorl %r9d, %r9d
xorl %eax, %eax
xorl %r8d, %r8d
addq 0xc0(%rcx,%r9,8), %rax
addq 0xc0(%rdx,%r9,8), %r8
incq %r9
cmpq $0xb, %r9
jne 0x2aca3
movabsq $0x2e8ba2e8ba2e8ba3, %r9 # imm = 0x2E8BA2E8BA2E8BA3
mulq %r9
movq %rdx, %rcx
shrq %rcx
movq %r8, %rax
mulq %r9
movq 0x90(%rdi), %rax
movq 0x40(%rax), %rdi
cmpq $0x13, %rdi
jbe 0x2ad7e
xorl %r9d, %r9d
xorl %r8d, %r8d
addq 0x48(%rax,%r9,8), %r8
incq %r9
cmpq $0xb, %r9
jne 0x2acf0
movq 0xa0(%rax), %r9
xorl %r10d, %r10d
cmpq %r9, %r8
cmovaq %r9, %r10
subq %r10, %r8
js 0x2ad1b
cvtsi2ss %r8, %xmm0
jmp 0x2ad31
movq %r8, %r9
shrq %r9
andl $0x1, %r8d
orq %r9, %r8
cvtsi2ss %r8, %xmm0
addss %xmm0, %xmm0
testq %rdi, %rdi
js 0x2ad3d
cvtsi2ss %rdi, %xmm1
jmp 0x2ad52
movq %rdi, %r8
shrq %r8
andl $0x1, %edi
orq %r8, %rdi
cvtsi2ss %rdi, %xmm1
addss %xmm1, %xmm1
cvtsi2ss %rcx, %xmm2
divss %xmm1, %xmm0
mulss %xmm0, %xmm2
cvttss2si %xmm2, %rdi
movq %rdi, %r8
sarq $0x3f, %r8
subss 0xaa4d(%rip), %xmm2     # 0x357c0
cvttss2si %xmm2, %rcx
andq %r8, %rcx
orq %rdi, %rcx
shrq %rdx
movq 0x90(%rsi), %rsi
movq 0x40(%rsi), %rdi
cmpq $0x14, %rdi
jb 0x2ae39
xorl %r9d, %r9d
xorl %r8d, %r8d
addq 0x48(%rsi,%r9,8), %r8
incq %r9
cmpq $0xb, %r9
jne 0x2ad9c
movq 0xa0(%rsi), %r9
xorl %r10d, %r10d
cmpq %r9, %r8
cmovaq %r9, %r10
subq %r10, %r8
js 0x2adca
xorps %xmm0, %xmm0
cvtsi2ss %r8, %xmm0
jmp 0x2ade3
movq %r8, %r9
shrq %r9
andl $0x1, %r8d
orq %r9, %r8
xorps %xmm0, %xmm0
cvtsi2ss %r8, %xmm0
addss %xmm0, %xmm0
testq %rdi, %rdi
js 0x2adf2
xorps %xmm1, %xmm1
cvtsi2ss %rdi, %xmm1
jmp 0x2ae0a
movq %rdi, %r8
shrq %r8
andl $0x1, %edi
orq %r8, %rdi
xorps %xmm1, %xmm1
cvtsi2ss %rdi, %xmm1
addss %xmm1, %xmm1
xorps %xmm2, %xmm2
cvtsi2ss %rdx, %xmm2
divss %xmm1, %xmm0
mulss %xmm0, %xmm2
cvttss2si %xmm2, %rdi
movq %rdi, %r8
sarq $0x3f, %r8
subss 0xa992(%rip), %xmm2     # 0x357c0
cvttss2si %xmm2, %rdx
andq %r8, %rdx
orq %rdi, %rdx
cmpq %rdx, %rcx
jne 0x2ae4c
movq 0xa8(%rax), %rax
cmpq 0xa8(%rsi), %rax
seta %al
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/karel-brinda[P]ococo/src/misc.cpp
// Function: ococo::fatal_error(char const*, ...)
void ococo::fatal_error(const char *format, ...) {
    va_list args;
    va_start(args, format);
    fprintf(stderr, "[ococo:fatal-error]: ");
    vfprintf(stderr, format, args);
    va_end(args);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x4ae3
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %r14
movq %rdi, 0x10(%r14)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%r14)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%r14)
movq 0x5f4be(%rip), %r15     # 0x63fc8
movq (%r15), %rcx
leaq 0x4d10f(%rip), %rdi     # 0x51c23
pushq $0x15
popq %rsi
pushq $0x1
popq %rdx
callq 0x4a30
movq (%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x4710
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/karel-brinda[P]ococo/src/misc.cpp
// Function: ococo::error(char const*, ...)
void ococo::error(const char *format, ...) {
    va_list args;
    va_start(args, format);
    fprintf(stderr, "[ococo:error]: ");
    vfprintf(stderr, format, args);
    va_end(args);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x4b9d
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %r14
movq %rdi, 0x10(%r14)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%r14)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%r14)
movq 0x5f404(%rip), %r15     # 0x63fc8
movq (%r15), %rcx
leaq 0x4d06b(%rip), %rdi     # 0x51c39
pushq $0xf
popq %rsi
pushq $0x1
popq %rdx
callq 0x4a30
movq (%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x4710
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/karel-brinda[P]ococo/src/misc.cpp
// Function: ococo::warning(char const*, ...)
void ococo::warning(const char *format, ...) {
    va_list args;
    va_start(args, format);
    fprintf(stderr, "[ococo:warning]: ");
    vfprintf(stderr, format, args);
    va_end(args);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x4c57
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %r14
movq %rdi, 0x10(%r14)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%r14)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%r14)
movq 0x5f34a(%rip), %r15     # 0x63fc8
movq (%r15), %rcx
leaq 0x4cfc1(%rip), %rdi     # 0x51c49
pushq $0x11
popq %rsi
pushq $0x1
popq %rdx
callq 0x4a30
movq (%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x4710
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/karel-brinda[P]ococo/src/misc.cpp
// Function: ococo::info(char const*, ...)
void ococo::info(const char *format, ...) {
    va_list args;
    va_start(args, format);
    fprintf(stderr, "[ococo]: ");
    vfprintf(stderr, format, args);
    va_end(args);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x4d11
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %r14
movq %rdi, 0x10(%r14)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%r14)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%r14)
movq 0x5f290(%rip), %r15     # 0x63fc8
movq (%r15), %rcx
leaq 0x4cf19(%rip), %rdi     # 0x51c5b
pushq $0x9
popq %rsi
pushq $0x1
popq %rdx
callq 0x4a30
movq (%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x4710
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/karel-brinda[P]ococo/ext/htslib/cram/cram_stats.c
// Function: cram_stats_dump
void cram_stats_dump(cram_stats *st) {
    int i;
    fprintf(stderr, "cram_stats:\n");
    for (i = 0; i < MAX_STAT_VAL; i++) {
	if (!st->freqs[i])
	    continue;
	fprintf(stderr, "\t%d\t%d\n", i, st->freqs[i]);
    }
    if (st->h) {
	khint_t k;
	for (k = kh_begin(st->h); k != kh_end(st->h); k++) {
	    if (!kh_exist(st->h, k))
		continue;

	    fprintf(stderr, "\t%d\t%d\n", kh_key(st->h, k), kh_val(st->h, k));
	}
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x5e6c2(%rip), %r12     # 0x63fc8
movq (%r12), %rcx
leaq 0x4f939(%rip), %rdi     # 0x5524a
pushq $0xc
popq %rsi
pushq $0x1
popq %rdx
callq 0x4a30
leaq 0x4eca4(%rip), %r14     # 0x545c7
xorl %r15d, %r15d
movl (%rbx,%r15,4), %ecx
testl %ecx, %ecx
jne 0x593c
incq %r15
cmpq $0x400, %r15            # imm = 0x400
jne 0x5926
jmp 0x594f
movq (%r12), %rdi
movq %r14, %rsi
movl %r15d, %edx
xorl %eax, %eax
callq 0x4770
jmp 0x592e
cmpq $0x0, 0x1000(%rbx)
je 0x59bf
movq 0x1000(%rbx), %rax
cmpl $0x0, (%rax)
je 0x59bf
leaq 0x4ec5b(%rip), %r14     # 0x545c7
xorl %ebp, %ebp
xorl %r15d, %r15d
movq 0x10(%rax), %rcx
movl %r15d, %edx
shrl $0x4, %edx
movl (%rcx,%rdx,4), %edx
movl %ebp, %ecx
andb $0x1e, %cl
shrl %cl, %edx
testb $0x3, %dl
je 0x599e
incl %r15d
movq 0x1000(%rbx), %rax
addl $0x2, %ebp
cmpl (%rax), %r15d
jne 0x5971
jmp 0x59bf
movq (%r12), %rdi
movl %r15d, %ecx
movq 0x18(%rax), %rdx
movq 0x20(%rax), %rax
movl (%rdx,%rcx,4), %edx
movl (%rax,%rcx,4), %ecx
movq %r14, %rsi
xorl %eax, %eax
callq 0x4770
jmp 0x598a
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq