LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: lotuskip[P]yuxtapa/server/viewpoint.cpp
// Function: ViewPoint::newmap()
void ViewPoint::newmap()
{
	Game::curmap->make_right_size(ownview);
	// Fill empty; the tiles will be updated with the actual map data as they
	// become visible. The only thing we need from the actual map already at
	// this point are the lit statuses:
	Coords c;
	for(c.y = ownview.size()-1; c.y >= 0; --c.y)
	{
		for(c.x = ownview.size()-1; c.x >= 0; --c.x)
		{
			ownview[c.y][c.x] = EMPTY_TILE;
			if(Game::curmap->get_tile(c).flags & TF_LIT)
				ownview[c.y][c.x].flags |= TF_LIT;
		}
	}
	pos.x = pos.y = ownview.size()/2;
	poschanged = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x28(%rbp)
leaq 0x5100d(%rip), %rax     # 0x91dd8
movq (%rax), %rdi
addq $0x8, %rsi
callq 0x2a3c0
leaq -0xc(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x60430
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
callq 0x2e900
subq $0x1, %rax
movw %ax, -0xa(%rbp)
movswl -0xa(%rbp), %eax
cmpl $0x0, %eax
jl 0x40ede
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
callq 0x2e900
subq $0x1, %rax
movw %ax, -0xc(%rbp)
movswl -0xc(%rbp), %eax
cmpl $0x0, %eax
jl 0x40ecb
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
movswq -0xa(%rbp), %rsi
callq 0x2e6a0
movq %rax, %rdi
movswq -0xc(%rbp), %rsi
callq 0x2e6c0
movl $0x6d3f0004, (%rax)     # imm = 0x6D3F0004
leaq 0x50f84(%rip), %rax     # 0x91dd8
movq (%rax), %rdi
leaq -0xc(%rbp), %rsi
callq 0x3dcd0
movl %eax, -0x2c(%rbp)
jmp 0x40e65
movl -0x2c(%rbp), %eax
movl %eax, -0x10(%rbp)
movzwl -0x10(%rbp), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x40eb8
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
movswq -0xa(%rbp), %rsi
callq 0x2e6a0
movq %rax, %rdi
movswq -0xc(%rbp), %rsi
callq 0x2e6c0
movzwl (%rax), %ecx
orl $0x10, %ecx
movw %cx, (%rax)
jmp 0x40eb8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0xc(%rbp), %rdi
callq 0x60460
jmp 0x40f10
jmp 0x40eba
movw -0xc(%rbp), %ax
addw $-0x1, %ax
movw %ax, -0xc(%rbp)
jmp 0x40e1b
jmp 0x40ecd
movw -0xa(%rbp), %ax
addw $-0x1, %ax
movw %ax, -0xa(%rbp)
jmp 0x40df9
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
callq 0x2e900
movq %rax, %rcx
movq -0x28(%rbp), %rax
shrq %rcx
movw %cx, 0x4(%rax)
movw %cx, 0x2(%rax)
movb $0x1, 0x6(%rax)
leaq -0xc(%rbp), %rdi
callq 0x60460
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x5920
nopl (%rax)
// File: lotuskip[P]yuxtapa/server/viewpoint.cpp
// Function: ViewPoint::clear_memory()
void ViewPoint::clear_memory()
{
	// Don't touch flags, so as to retain the lit statuses
	vector<Tile>::iterator ti;
	for(vector< vector<Tile> >::iterator i = ownview.begin(); i != ownview.end(); ++i)
	{
		for(ti = i->begin(); ti != i->end(); ++ti)
		{
			ti->cpair = EMPTY_TILE.cpair;
			ti->symbol = EMPTY_TILE.symbol;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x2ebe0
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
callq 0x2ebb0
movq %rax, -0x18(%rbp)
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
callq 0x2ede0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x2eda0
testb $0x1, %al
jne 0x40f72
jmp 0x40fec
leaq -0x18(%rbp), %rdi
callq 0x2ec00
movq %rax, %rdi
callq 0x2ec20
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x2ec00
movq %rax, %rdi
callq 0x2ec90
movq %rax, -0x30(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2ec50
testb $0x1, %al
jne 0x40fb7
jmp 0x40fdc
leaq -0x10(%rbp), %rdi
callq 0x2ece0
movb $0x6d, 0x3(%rax)
leaq -0x10(%rbp), %rdi
callq 0x2ece0
movb $0x3f, 0x2(%rax)
leaq -0x10(%rbp), %rdi
callq 0x2ed00
jmp 0x40f8f
jmp 0x40fde
leaq -0x18(%rbp), %rdi
callq 0x2ee30
jmp 0x40f4e
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lotuskip[P]yuxtapa/server/viewpoint.cpp
// Function: ViewPoint::fill_loslittbl_xy(Coords const&, char, char, bool)
bool ViewPoint::fill_loslittbl_xy(const Coords &c, const char x, const char y,
	const bool vis_in_dark)
{
	// We might be outside of the map, in which case the next point in
	// this line will *also* be outside of the map; check:
	if(Game::curmap->point_out_of_map(c))
		return true;
	// else safe to fetch the tile:
	Tile *tp = &(ownview[c.y][c.x]);
	if(!loslittbl[x][y]) // not already considered
	{
		/* Determine lit status. Note that if the static lit status
		 * of the tile has changed (by a wall being dug out), the
		 * view won't notice this until the tile is within the
		 * "visible-even-if-not-lit" radius. This could be a bug,
		 * but we shall call it a feature. */
		if(tp->flags & TF_LIT // statically lit
			|| is_dynlit(c))
		{
			loslittbl[x][y] = IS_LIT|IN_LOS;
			// update our view of this tile:
			*tp = Game::curmap->get_tile(c);
		}
		else if(vis_in_dark) // not lit, still in LOS if in smaller radius
		{
			loslittbl[x][y] = IN_LOS;
			// upd our view of this tile:
			*tp = Game::curmap->get_tile(c);
		}
	}
	// see if need to continue on this ray:
	return !(tp->flags & TF_SEETHRU);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %r8b, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb %dl, -0x19(%rbp)
movb %cl, -0x1a(%rbp)
andb $0x1, %al
movb %al, -0x1b(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq 0x50dab(%rip), %rax     # 0x91dd8
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x2ba40
testb $0x1, %al
jne 0x4103f
jmp 0x41048
movb $0x1, -0x1(%rbp)
jmp 0x4114b
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rax
movswq 0x2(%rax), %rsi
callq 0x2e6a0
movq %rax, %rdi
movq -0x18(%rbp), %rax
movswq (%rax), %rsi
callq 0x2e6c0
movq %rax, -0x28(%rbp)
movsbq -0x19(%rbp), %rcx
leaq 0x518e2(%rip), %rax     # 0x92960
imulq $0x17, %rcx, %rcx
addq %rcx, %rax
movsbq -0x1a(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
jne 0x41134
movq -0x28(%rbp), %rax
movzwl (%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
jne 0x410b2
movq -0x18(%rbp), %rdi
callq 0x48d60
testb $0x1, %al
jne 0x410b2
jmp 0x410ef
movsbq -0x19(%rbp), %rcx
leaq 0x518a2(%rip), %rax     # 0x92960
imulq $0x17, %rcx, %rcx
addq %rcx, %rax
movsbq -0x1a(%rbp), %rcx
movb $0x3, (%rax,%rcx)
leaq 0x50d03(%rip), %rax     # 0x91dd8
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x3dcd0
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movl -0x2c(%rbp), %ecx
movl %ecx, (%rax)
jmp 0x41132
testb $0x1, -0x1b(%rbp)
je 0x41130
movsbq -0x19(%rbp), %rcx
leaq 0x5185f(%rip), %rax     # 0x92960
imulq $0x17, %rcx, %rcx
addq %rcx, %rax
movsbq -0x1a(%rbp), %rcx
movb $0x1, (%rax,%rcx)
leaq 0x50cc0(%rip), %rax     # 0x91dd8
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x3dcd0
movl %eax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl -0x30(%rbp), %ecx
movl %ecx, (%rax)
jmp 0x41132
jmp 0x41134
movq -0x28(%rbp), %rax
movzwl (%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lotuskip[P]yuxtapa/server/viewpoint.cpp
// Function: ViewPoint::render_pc_indir(Coords const&, char*) const
bool ViewPoint::render_pc_indir(const Coords &c, char* const target) const
{
	list<PCEnt>::iterator it = any_pc_at(c);
	if(it != PCs.end() && it->is_seen_by_team(owner->team) && !it->isvoid())
	{
		it->draw(target, false);
		return true;
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x49290
movq %rax, -0x28(%rbp)
leaq 0x50fb0(%rip), %rdi     # 0x93050
callq 0x3d010
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3cfe0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x31(%rbp)
jne 0x420c4
jmp 0x42111
leaq -0x28(%rbp), %rdi
callq 0x3d040
movq -0x40(%rbp), %rdi
movq %rax, -0x48(%rbp)
addq $0x28, %rdi
callq 0x24f40
movq -0x48(%rbp), %rdi
movl 0xac(%rax), %esi
callq 0x430d0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x31(%rbp)
jne 0x420fb
jmp 0x42111
leaq -0x28(%rbp), %rdi
callq 0x3d040
movq %rax, %rdi
callq 0x3ce40
xorb $-0x1, %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x4211a
jmp 0x42137
leaq -0x28(%rbp), %rdi
callq 0x3d040
movq %rax, %rdi
movq -0x20(%rbp), %rsi
xorl %edx, %edx
callq 0x4d6c0
movb $0x1, -0x1(%rbp)
jmp 0x4213b
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lotuskip[P]yuxtapa/server/viewpoint.cpp
// Function: ViewPoint::render_trap_at(Coords const&, char*, bool) const
bool ViewPoint::render_trap_at(const Coords &c, char* const target, const bool lit) const
{
	list<Trap>::iterator tr_it = any_trap_at(c);
	if(tr_it->is_seen_by(owner->team))
	{
		tr_it->draw(target, lit);
		return true;
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x494b0
movq %rax, -0x30(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3daa0
movq -0x40(%rbp), %rdi
movq %rax, -0x38(%rbp)
addq $0x28, %rdi
callq 0x24f40
movq -0x38(%rbp), %rdi
movl 0xac(%rax), %eax
movzbl %al, %esi
callq 0x4d890
testb $0x1, %al
jne 0x42602
jmp 0x42625
leaq -0x30(%rbp), %rdi
callq 0x3daa0
movq %rax, %rdi
movq -0x20(%rbp), %rsi
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x4d6c0
movb $0x1, -0x1(%rbp)
jmp 0x42629
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lotuskip[P]yuxtapa/server/viewpoint.cpp
// Function: ViewPoint::drop_watcher(unsigned short)
void ViewPoint::drop_watcher(const unsigned short ID)
{
	for(vector< list<Player>::iterator >::iterator it = followers.begin();
		it != followers.end(); ++it)
	{
		if((*it)->stats_i->ID == ID)
		{
			followers.erase(it);
			break;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x30, %rdi
callq 0x42ec0
movq %rax, -0x18(%rbp)
movq -0x38(%rbp), %rdi
addq $0x30, %rdi
callq 0x42f30
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x42ef0
testb $0x1, %al
jne 0x427fc
jmp 0x42863
leaq -0x18(%rbp), %rdi
callq 0x42f60
movq %rax, %rdi
callq 0x1b050
movq %rax, %rdi
addq $0x80, %rdi
callq 0x1b390
movzwl (%rax), %eax
movzwl -0xa(%rbp), %ecx
cmpl %ecx, %eax
jne 0x42853
movq -0x38(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x40(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x42ff0
movq -0x40(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x42f80
movq %rax, -0x30(%rbp)
jmp 0x42863
jmp 0x42855
leaq -0x18(%rbp), %rdi
callq 0x43030
jmp 0x427d8
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: lotuskip[P]yuxtapa/server/viewpoint.cpp
// Function: ViewPoint::move_watchers()
void ViewPoint::move_watchers()
{
	vector< list<Player>::iterator >::iterator it = followers.begin();
	while(it != followers.end())
	{
		if(*it != owner)
		{
			(*it)->own_vp->set_pos(pos);
			((*it)->viewn_vp = (*it)->own_vp)->add_watcher((*it));
			it = followers.erase(it);
		}
		else
			++it;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x30, %rdi
callq 0x42ec0
movq %rax, -0x10(%rbp)
movq -0x40(%rbp), %rdi
addq $0x30, %rdi
callq 0x42f30
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x42ef0
testb $0x1, %al
jne 0x428b8
jmp 0x429a3
leaq -0x10(%rbp), %rdi
callq 0x42f60
movq %rax, %rsi
leaq -0x20(%rbp), %rdi
callq 0x18a20
movq -0x40(%rbp), %rsi
addq $0x28, %rsi
leaq -0x20(%rbp), %rdi
callq 0x24f10
testb $0x1, %al
jne 0x428e7
jmp 0x42995
leaq -0x10(%rbp), %rdi
callq 0x42f60
movq %rax, %rdi
callq 0x1b050
movq -0x40(%rbp), %rsi
movq 0xc0(%rax), %rdi
addq $0x2, %rsi
callq 0x426b0
leaq -0x10(%rbp), %rdi
callq 0x42f60
movq %rax, %rdi
callq 0x1b050
movq 0xc0(%rax), %rax
movq %rax, -0x50(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x42f60
movq %rax, %rdi
callq 0x1b050
movq -0x50(%rbp), %rcx
movq %rcx, 0xc8(%rax)
leaq -0x10(%rbp), %rdi
callq 0x42f60
movq -0x50(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
callq 0x42770
movq -0x40(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x48(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x42ff0
movq -0x48(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x42f80
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x4299e
leaq -0x10(%rbp), %rdi
callq 0x43030
jmp 0x42891
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: lotuskip[P]yuxtapa/server/actives.cpp
// Function: events_around(Coords const&)
bool events_around(const Coords &pos)
{
	for(set<Coords>::const_iterator it = event_set.begin();
		it != event_set.end(); ++it)
	{
		if(it->dist_walk(pos) <= VIEWSIZE/2)
			return true;
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x4cc15(%rip), %rdi     # 0x93148
callq 0x49cf0
movq %rax, -0x18(%rbp)
leaq 0x4cc05(%rip), %rdi     # 0x93148
callq 0x49d50
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x49d20
testb $0x1, %al
jne 0x4655f
jmp 0x4658d
leaq -0x18(%rbp), %rdi
callq 0x49d80
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x604f0
cwtl
cmpl $0xb, %eax
jg 0x46580
movb $0x1, -0x1(%rbp)
jmp 0x46591
jmp 0x46582
leaq -0x18(%rbp), %rdi
callq 0x49db0
jmp 0x4653c
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: lotuskip[P]yuxtapa/server/actives.cpp
// Function: (anonymous namespace)::next_unused_tile(Coords&, std::vector<Coords, std::allocator<Coords>>&, bool)
void next_unused_tile(Coords &c, vector<Coords> &useds, const bool force = false)
{
	init_nearby(c);
	if(force)
	{
		// find first not yet used:
		while(find(useds.begin(), useds.end(), c) != useds.end())
			c = next_nearby();
		if(all_placem_syms.find(Game::curmap->get_tile(c).symbol) == string::npos)
			*(Game::curmap->mod_tile(c)) = T_FLOOR; // change the map to force placement
	}
	else
	{
		// Find next (A) unused and (B) free spot
		while(find(useds.begin(), useds.end(), c) != useds.end()
			|| all_placem_syms.find(Game::curmap->get_tile(c).symbol) == string::npos)
			c = next_nearby();
	}
	// Found it:
	useds.push_back(c);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4ebf0
testb $0x1, -0x11(%rbp)
je 0x47a38
jmp 0x4797c
movq -0x10(%rbp), %rdi
callq 0x2e590
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2e5c0
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdx
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x2e540
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2e5c0
movq %rax, -0x38(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x31bc0
testb $0x1, %al
jne 0x479cb
jmp 0x479e8
leaq -0x3c(%rbp), %rdi
callq 0x4ec30
movq -0x8(%rbp), %rax
movl -0x3c(%rbp), %ecx
movl %ecx, (%rax)
leaq -0x3c(%rbp), %rdi
callq 0x60460
jmp 0x4797c
leaq 0x4a3e9(%rip), %rax     # 0x91dd8
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x3dcd0
movl %eax, -0x40(%rbp)
leaq 0x4b503(%rip), %rdi     # 0x92f08
xorl %eax, %eax
movl %eax, %edx
movsbl -0x3e(%rbp), %esi
callq 0x5720
cmpq $-0x1, %rax
jne 0x47a33
leaq 0x4a3b9(%rip), %rax     # 0x91dd8
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x3d2d0
movl 0x1e8a3(%rip), %ecx     # 0x662d4
movl %ecx, (%rax)
jmp 0x47aee
jmp 0x47a3a
movq -0x10(%rbp), %rdi
callq 0x2e590
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2e5c0
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rdx
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x2e540
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2e5c0
movq %rax, -0x60(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x31bc0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x69(%rbp)
jne 0x47ac3
leaq 0x4a342(%rip), %rax     # 0x91dd8
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x3dcd0
movl %eax, -0x64(%rbp)
leaq 0x4b45c(%rip), %rdi     # 0x92f08
xorl %eax, %eax
movl %eax, %edx
movsbl -0x62(%rbp), %esi
callq 0x5720
cmpq $-0x1, %rax
sete %al
movb %al, -0x69(%rbp)
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0x47acc
jmp 0x47aec
leaq -0x68(%rbp), %rdi
callq 0x4ec30
movq -0x8(%rbp), %rax
movl -0x68(%rbp), %ecx
movl %ecx, (%rax)
leaq -0x68(%rbp), %rdi
callq 0x60460
jmp 0x47a3a
jmp 0x47aee
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x2e630
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: lotuskip[P]yuxtapa/server/actives.cpp
// Function: clear_action_inds()
void clear_action_inds()
{
	map<Coords, unsigned char>::iterator it = axn_indicators.begin();
	while(it != axn_indicators.end())
	{
		if(it->second < NUM_ACTIONS)
		{
			Game::curmap->mod_tile(it->first)->flags &= ~(TF_ACTION);
			event_set.insert(it->first);
			axn_indicators.erase(it++);
		}
		else
		{
			it->second -= NUM_ACTIONS;
			++it;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq 0x4b101(%rip), %rdi     # 0x930a0
callq 0x4a060
movq %rax, -0x8(%rbp)
leaq 0x4b0f1(%rip), %rdi     # 0x930a0
callq 0x447c0
movq %rax, -0x10(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x4a090
testb $0x1, %al
jne 0x47fce
jmp 0x48074
leaq -0x8(%rbp), %rdi
callq 0x4a0c0
movzbl 0x4(%rax), %eax
cmpl $0x6, %eax
jge 0x48053
leaq 0x49df1(%rip), %rax     # 0x91dd8
movq (%rax), %rax
movq %rax, -0x38(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x4a0c0
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x3d2d0
movzwl (%rax), %ecx
andl $0xffffff7f, %ecx       # imm = 0xFFFFFF7F
movw %cx, (%rax)
leaq -0x8(%rbp), %rdi
callq 0x4a0c0
movq %rax, %rsi
leaq 0x4b126(%rip), %rdi     # 0x93148
callq 0x4a010
movq %rax, -0x20(%rbp)
movb %dl, -0x18(%rbp)
leaq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x4a120
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
leaq 0x4b058(%rip), %rdi     # 0x930a0
callq 0x4a0e0
movq %rax, -0x30(%rbp)
jmp 0x4806f
leaq -0x8(%rbp), %rdi
callq 0x4a0c0
movzbl 0x4(%rax), %ecx
subl $0x6, %ecx
movb %cl, 0x4(%rax)
leaq -0x8(%rbp), %rdi
callq 0x45450
jmp 0x47fa8
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: lotuskip[P]yuxtapa/server/actives.cpp
// Function: clear_sounds()
void clear_sounds()
{
	for(map<Coords, e_Sound>::const_iterator sit = reg_sounds.begin();
		sit != reg_sounds.end(); ++sit)
	{
		Game::curmap->mod_tile(sit->first)->flags &= ~(TF_SOUND);
		event_set.insert(sit->first);
	}
	reg_sounds.clear();
	for(map<Coords, string>::const_iterator vit = voices.begin();
		vit != voices.end(); ++vit)
	{
		Game::curmap->mod_tile(vit->first)->flags &= ~(TF_SOUND);
		event_set.insert(vit->first);
	}
	voices.clear();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
leaq 0x4af61(%rip), %rdi     # 0x930d0
callq 0x4a240
movq %rax, -0x10(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x43790
leaq 0x4af44(%rip), %rdi     # 0x930d0
callq 0x435e0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x43790
leaq -0x8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x4a270
testb $0x1, %al
jne 0x481b5
jmp 0x48211
leaq 0x49c1c(%rip), %rax     # 0x91dd8
movq (%rax), %rax
movq %rax, -0x68(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x4a2a0
movq -0x68(%rbp), %rdi
movq %rax, %rsi
callq 0x3d2d0
movzwl (%rax), %ecx
andl $0xfffffeff, %ecx       # imm = 0xFFFFFEFF
movw %cx, (%rax)
leaq -0x8(%rbp), %rdi
callq 0x4a2a0
movq %rax, %rsi
leaq 0x4af51(%rip), %rdi     # 0x93148
callq 0x4a010
movq %rax, -0x30(%rbp)
movb %dl, -0x28(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x4a2c0
jmp 0x48185
leaq 0x4aeb8(%rip), %rdi     # 0x930d0
callq 0x3c8c0
leaq 0x4aedc(%rip), %rdi     # 0x93100
callq 0x4a2f0
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x42a50
leaq 0x4aebf(%rip), %rdi     # 0x93100
callq 0x1b1b0
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x42a50
leaq -0x38(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x42a70
testb $0x1, %al
jne 0x4826a
jmp 0x482c6
leaq 0x49b67(%rip), %rax     # 0x91dd8
movq (%rax), %rax
movq %rax, -0x70(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x42aa0
movq -0x70(%rbp), %rdi
movq %rax, %rsi
callq 0x3d2d0
movzwl (%rax), %ecx
andl $0xfffffeff, %ecx       # imm = 0xFFFFFEFF
movw %cx, (%rax)
leaq -0x38(%rbp), %rdi
callq 0x42aa0
movq %rax, %rsi
leaq 0x4ae9c(%rip), %rdi     # 0x93148
callq 0x4a010
movq %rax, -0x60(%rbp)
movb %dl, -0x58(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4a320
jmp 0x4823a
leaq 0x4ae33(%rip), %rdi     # 0x93100
callq 0x3c8e0
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: lotuskip[P]yuxtapa/server/actives.cpp
// Function: update_static_light(Coords const&)
void update_static_light(const Coords &c)
{
	// Run the algorithm on two base radii to cover all spots.
	/* NOTE: this works for TORCH_LIGHT_RADIUS 7-9; if it is <=6 or >=10,
	 * adjustments are called for! */
	update_static_light_r(c, TORCH_LIGHT_RADIUS);
	update_static_light_r(c, TORCH_LIGHT_RADIUS-1);
	update_static_light_r(c, TORCH_LIGHT_RADIUS-2);
	// the LOS-algorithm doesn't consider the position itself:
	Game::curmap->mod_tile(c)->flags |= TF_LIT;	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x8, %esi
callq 0x48340
movq -0x8(%rbp), %rdi
movl $0x7, %esi
callq 0x48340
movq -0x8(%rbp), %rdi
movl $0x6, %esi
callq 0x48340
leaq 0x49abb(%rip), %rax     # 0x91dd8
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x3d2d0
movzwl (%rax), %ecx
orl $0x10, %ecx
movw %cx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: lotuskip[P]yuxtapa/server/actives.cpp
// Function: any_pc_at(Coords const&)
list<PCEnt>::iterator any_pc_at(const Coords &c)
{
	list<PCEnt>::iterator it;
	for(it = PCs.begin(); it != PCs.end(); ++it)
	{
		if(it->getpos() == c && !it->isvoid())
			break;
	}
	return it;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x4a640
leaq 0x49da4(%rip), %rdi     # 0x93050
callq 0x3cfb0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq 0x49d8c(%rip), %rdi     # 0x93050
callq 0x3d010
movq %rax, -0x20(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x3cfe0
testb $0x1, %al
jne 0x492e3
jmp 0x4937c
leaq -0x8(%rbp), %rdi
callq 0x3d040
movq %rax, %rsi
leaq -0x24(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x1b190
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x60860
movb %al, -0x35(%rbp)
jmp 0x4930e
movb -0x35(%rbp), %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x41(%rbp)
jne 0x4931d
jmp 0x4933b
leaq -0x8(%rbp), %rdi
callq 0x3d040
movq %rax, %rdi
callq 0x3ce40
movb %al, -0x42(%rbp)
jmp 0x49333
movb -0x42(%rbp), %al
xorb $-0x1, %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
movb %al, -0x43(%rbp)
leaq -0x24(%rbp), %rdi
callq 0x60460
movb -0x43(%rbp), %al
testb $0x1, %al
jne 0x49353
jmp 0x4936c
jmp 0x4937c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x24(%rbp), %rdi
callq 0x60460
jmp 0x49386
jmp 0x4936e
leaq -0x8(%rbp), %rdi
callq 0x3d110
jmp 0x492bd
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x5920
nop
// File: lotuskip[P]yuxtapa/server/actives.cpp
// Function: any_noccent_at(Coords const&, e_Noccent)
list<NOccEnt>::iterator any_noccent_at(const Coords &c, const e_Noccent type)
{
	list<NOccEnt>::iterator it;
	for(it = noccents[type].begin(); it != noccents[type].end(); ++it)
	{
		// actually, most noccents are never voided, but we make the check for all
		if(it->getpos() == c && !it->isvoid())
			break;
	}
	return it;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x3cda0
movl -0x14(%rbp), %eax
leaq 0x49b7e(%rip), %rdi     # 0x92f30
imulq $0x18, %rax, %rax
addq %rax, %rdi
callq 0x3c950
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movl -0x14(%rbp), %eax
leaq 0x49b5c(%rip), %rdi     # 0x92f30
imulq $0x18, %rax, %rax
addq %rax, %rdi
callq 0x3c9d0
movq %rax, -0x28(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x3cdc0
testb $0x1, %al
jne 0x493fa
jmp 0x49493
leaq -0x8(%rbp), %rdi
callq 0x3cdf0
movq %rax, %rsi
leaq -0x2c(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x1b190
movq -0x48(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x60860
movb %al, -0x3d(%rbp)
jmp 0x49425
movb -0x3d(%rbp), %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x49(%rbp)
jne 0x49434
jmp 0x49452
leaq -0x8(%rbp), %rdi
callq 0x3cdf0
movq %rax, %rdi
callq 0x3ce40
movb %al, -0x4a(%rbp)
jmp 0x4944a
movb -0x4a(%rbp), %al
xorb $-0x1, %al
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
movb %al, -0x4b(%rbp)
leaq -0x2c(%rbp), %rdi
callq 0x60460
movb -0x4b(%rbp), %al
testb $0x1, %al
jne 0x4946a
jmp 0x49483
jmp 0x49493
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x2c(%rbp), %rdi
callq 0x60460
jmp 0x4949d
jmp 0x49485
leaq -0x8(%rbp), %rdi
callq 0x3ce20
jmp 0x493ca
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x5920
nopw %cs:(%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x4a660
leaq 0x49b0c(%rip), %rdi     # 0x92fd8
callq 0x3da10
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq 0x49af4(%rip), %rdi     # 0x92fd8
callq 0x3da70
movq %rax, -0x20(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x3da40
testb $0x1, %al
jne 0x49503
jmp 0x4959c
leaq -0x8(%rbp), %rdi
callq 0x3daa0
movq %rax, %rsi
leaq -0x24(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x1b190
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x60860
movb %al, -0x35(%rbp)
jmp 0x4952e
movb -0x35(%rbp), %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x41(%rbp)
jne 0x4953d
jmp 0x4955b
leaq -0x8(%rbp), %rdi
callq 0x3daa0
movq %rax, %rdi
callq 0x3ce40
movb %al, -0x42(%rbp)
jmp 0x49553
movb -0x42(%rbp), %al
xorb $-0x1, %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
movb %al, -0x43(%rbp)
leaq -0x24(%rbp), %rdi
callq 0x60460
movb -0x43(%rbp), %al
testb $0x1, %al
jne 0x49573
jmp 0x4958c
jmp 0x4959c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x24(%rbp), %rdi
callq 0x60460
jmp 0x495a6
jmp 0x4958e
leaq -0x8(%rbp), %rdi
callq 0x3db60
jmp 0x494dd
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x5920
nop
// File: 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
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x4a680
leaq 0x49a24(%rip), %rdi     # 0x92ff0
callq 0x3d130
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq 0x49a0c(%rip), %rdi     # 0x92ff0
callq 0x3d190
movq %rax, -0x20(%rbp)
leaq -0x8(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x3d160
testb $0x1, %al
jne 0x49603
jmp 0x4969c
leaq -0x8(%rbp), %rdi
callq 0x3d1c0
movq %rax, %rsi
leaq -0x24(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x1b190
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x60860
movb %al, -0x35(%rbp)
jmp 0x4962e
movb -0x35(%rbp), %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x41(%rbp)
jne 0x4963d
jmp 0x4965b
leaq -0x8(%rbp), %rdi
callq 0x3d1c0
movq %rax, %rdi
callq 0x3ce40
movb %al, -0x42(%rbp)
jmp 0x49653
movb -0x42(%rbp), %al
xorb $-0x1, %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
movb %al, -0x43(%rbp)
leaq -0x24(%rbp), %rdi
callq 0x60460
movb -0x43(%rbp), %al
testb $0x1, %al
jne 0x49673
jmp 0x4968c
jmp 0x4969c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x24(%rbp), %rdi
callq 0x60460
jmp 0x496a6
jmp 0x4968e
leaq -0x8(%rbp), %rdi
callq 0x3d260
jmp 0x495dd
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x5920
nop
// File: 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
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movb 0xd(%rax), %al
movb %al, -0x12(%rbp)
testb $0x1, -0x11(%rbp)
je 0x4d6f1
movsbl -0x12(%rbp), %eax
addl $0x14, %eax
movb %al, -0x12(%rbp)
movq -0x20(%rbp), %rax
movb -0x12(%rbp), %dl
movq -0x10(%rbp), %rcx
movb %dl, (%rcx)
movb 0xc(%rax), %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, 0x1(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
testb $0x1, 0xe(%rax)
je 0x4ddff
jmp 0x4df4c
movq -0x50(%rbp), %rsi
addq $0x8, %rsi
leaq 0x4533a(%rip), %rdi     # 0x93148
callq 0x4a010
movq -0x50(%rbp), %rsi
movq %rax, -0x18(%rbp)
movb %dl, -0x10(%rbp)
leaq 0x43fb3(%rip), %rax     # 0x91dd8
movq (%rax), %rdi
addq $0x8, %rsi
callq 0x3d2d0
movzwl (%rax), %ecx
andl $-0x41, %ecx
movw %cx, (%rax)
movb $0x0, -0x19(%rbp)
movsbl -0x19(%rbp), %eax
cmpl $0x3, %eax
jge 0x4dece
movq -0x50(%rbp), %rdi
addq $0x18, %rdi
callq 0x4e9d0
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x563c0
testb $0x1, %al
jne 0x4de6a
jmp 0x4de6f
jmp 0x4df4c
movq -0x50(%rbp), %rdi
addq $0x18, %rdi
callq 0x4e9d0
movq -0x50(%rbp), %rdi
movl (%rax), %eax
movl %eax, 0x8(%rdi)
addq $0x18, %rdi
callq 0x4ea00
movq -0x50(%rbp), %rdi
addq $0x18, %rdi
callq 0x4ea30
testb $0x1, %al
jne 0x4dea1
jmp 0x4debf
movq -0x50(%rbp), %rdi
movq %rdi, %rsi
addq $0x8, %rsi
callq 0x576c0
movq -0x50(%rbp), %rdi
callq 0x4d8d0
jmp 0x4df4c
jmp 0x4dec1
movb -0x19(%rbp), %al
addb $0x1, %al
movb %al, -0x19(%rbp)
jmp 0x4de3e
movq -0x50(%rbp), %rsi
leaq 0x43eff(%rip), %rax     # 0x91dd8
movq (%rax), %rdi
addq $0x8, %rsi
movq %rsi, -0x60(%rbp)
callq 0x3d2d0
movq -0x60(%rbp), %rsi
movb (%rax), %cl
orb $0x40, %cl
movb %cl, (%rax)
leaq 0x4524d(%rip), %rdi     # 0x93148
callq 0x4a010
movq -0x50(%rbp), %rdi
movq %rax, -0x30(%rbp)
movb %dl, -0x28(%rbp)
addq $0x18, %rdi
callq 0x4e9d0
movq -0x60(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x34(%rbp)
leaq -0x34(%rbp), %rsi
callq 0x60710
movl %eax, -0x54(%rbp)
jmp 0x4df2b
movq -0x50(%rbp), %rax
movl -0x54(%rbp), %ecx
movl %ecx, %ecx
movl %ecx, %edx
leaq 0x1a363(%rip), %rcx     # 0x682a0
movb (%rcx,%rdx), %cl
movb %cl, 0xc(%rax)
leaq -0x34(%rbp), %rdi
callq 0x60460
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x34(%rbp), %rdi
callq 0x60460
movq -0x40(%rbp), %rdi
callq 0x5920
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movsbl 0x1c(%rax), %eax
cmpl $0x0, %eax
jle 0x4e8f3
movb $0x46, -0x9(%rbp)
jmp 0x4e91d
movq -0x18(%rbp), %rax
movb $0xa, -0x9(%rbp)
movsbl 0x1d(%rax), %eax
cmpl $0x2, %eax
jle 0x4e91b
movq -0x18(%rbp), %rax
movsbl 0x1d(%rax), %eax
subl $0x2, %eax
imull $0x14, %eax, %ecx
movsbl -0x9(%rbp), %eax
addl %ecx, %eax
movb %al, -0x9(%rbp)
jmp 0x4e91d
callq 0x5270
movl $0x64, %ecx
cqto
idivq %rcx
movsbq -0x9(%rbp), %rax
cmpq %rax, %rdx
setl %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movb 0x1c(%rcx), %al
addb $0x1, %al
movb %al, 0x1c(%rcx)
movsbl %al, %eax
cmpl $0x7, %eax
jne 0x4e976
movq -0x20(%rbp), %rdi
callq 0x4d8d0
movb $0x1, -0x1(%rbp)
jmp 0x4e988
movq -0x20(%rbp), %rax
movb $0x0, 0x1d(%rax)
movl -0x14(%rbp), %ecx
movl %ecx, 0x18(%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
movq %rdi, -0x18(%rbp)
movq %rdi, %rax
movq %rax, -0x10(%rbp)
movq %rdi, -0x8(%rbp)
movswl 0x44e2c(%rip), %eax     # 0x93a76
movl $0x4, %ecx
cltd
idivl %ecx
movslq %edx, %rcx
leaq 0x1b604(%rip), %rax     # 0x6a260
movsbl (%rax,%rcx), %ecx
movswl 0x44e09(%rip), %eax     # 0x93a70
addl %ecx, %eax
movw %ax, 0x44e00(%rip)      # 0x93a70
movswl 0x44dff(%rip), %eax     # 0x93a76
subl $0x1, %eax
movl $0x4, %ecx
cltd
idivl %ecx
movslq %edx, %rcx
leaq 0x1b5d4(%rip), %rax     # 0x6a260
movsbl (%rax,%rcx), %ecx
movswl 0x44ddb(%rip), %eax     # 0x93a72
addl %ecx, %eax
movw %ax, 0x44dd2(%rip)      # 0x93a72
movw 0x44dd3(%rip), %ax      # 0x93a7a
addw $0x1, %ax
movw %ax, 0x44dc8(%rip)      # 0x93a7a
cwtl
movswl 0x44dbe(%rip), %ecx     # 0x93a78
cmpl %ecx, %eax
jne 0x4ecf9
movw 0x44db1(%rip), %ax      # 0x93a76
addw $0x1, %ax
movw %ax, 0x44da6(%rip)      # 0x93a76
cwtl
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
je 0x4ecf0
movw 0x44d93(%rip), %ax      # 0x93a78
addw $0x1, %ax
movw %ax, 0x44d88(%rip)      # 0x93a78
movw $0x0, 0x44d81(%rip)     # 0x93a7a
jmp 0x4ecfb
movswl 0x44d6e(%rip), %ecx     # 0x93a70
movb $0x1, %al
cmpl $0x1, %ecx
movb %al, -0x19(%rbp)
jl 0x4ed4a
movswl 0x44d5f(%rip), %ecx     # 0x93a72
movb $0x1, %al
cmpl $0x1, %ecx
movb %al, -0x19(%rbp)
jl 0x4ed4a
movswl 0x44d4c(%rip), %ecx     # 0x93a70
movswl 0x44d49(%rip), %edx     # 0x93a74
movb $0x1, %al
cmpl %edx, %ecx
movb %al, -0x19(%rbp)
jge 0x4ed4a
movswl 0x44d37(%rip), %eax     # 0x93a72
movswl 0x44d32(%rip), %ecx     # 0x93a74
cmpl %ecx, %eax
setge %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x4ec43
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movl 0x44d0d(%rip), %edx     # 0x93a70
movl %edx, (%rcx)
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x422dd(%rip), %rdi     # 0x92f30
addq $0x90, %rdi
callq 0x3c950
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x3c980
leaq 0x422b9(%rip), %rdi     # 0x92f30
addq $0x90, %rdi
callq 0x3c9d0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x3c980
leaq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x3c9a0
testb $0x1, %al
jne 0x50caa
jmp 0x50d64
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x3ca00
movq %rax, %rsi
leaq -0x2c(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x1b190
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x604f0
movw %ax, -0x42(%rbp)
jmp 0x50cde
movw -0x42(%rbp), %ax
cwtl
movl %eax, -0x5c(%rbp)
leaq -0x2c(%rbp), %rdi
callq 0x60460
movl -0x5c(%rbp), %eax
cmpl $0x8, %eax
jg 0x50d54
leaq -0x10(%rbp), %rdi
callq 0x3ca00
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x1b190
movq -0x68(%rbp), %rdi
callq 0x482e0
jmp 0x50d1b
leaq -0x40(%rbp), %rdi
callq 0x60460
jmp 0x50d54
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x2c(%rbp), %rdi
callq 0x60460
jmp 0x50d6a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x60460
jmp 0x50d6a
jmp 0x50d56
leaq -0x10(%rbp), %rdi
callq 0x3ca30
jmp 0x50c70
addq $0x70, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x5920
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x1b050
movq %rax, %rdi
addq $0x80, %rdi
callq 0x1b390
movsbq -0x9(%rbp), %rcx
movq 0x38(%rax,%rcx,8), %rdx
addq $0x1, %rdx
movq %rdx, 0x38(%rax,%rcx,8)
leaq 0x3f810(%rip), %rax     # 0x91394
cmpl $0x4, (%rax)
jne 0x51c1a
leaq 0x3f804(%rip), %rax     # 0x91398
movzwl (%rax), %eax
leaq 0x3f7fa(%rip), %rcx     # 0x91398
movzwl 0x2(%rcx), %ecx
subl %ecx, %eax
movl %eax, -0x10(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x1b050
movl 0xac(%rax), %eax
movl %eax, %ecx
leaq 0x3f7d9(%rip), %rax     # 0x91398
movw (%rax,%rcx,2), %dx
addw $0x1, %dx
leaq 0x3f7ca(%rip), %rax     # 0x91398
movw %dx, (%rax,%rcx,2)
leaq 0x3f7bf(%rip), %rax     # 0x91398
movzwl (%rax), %eax
leaq 0x3f7b5(%rip), %rcx     # 0x91398
movzwl 0x2(%rcx), %ecx
subl %ecx, %eax
imull -0x10(%rbp), %eax
cmpl $0x0, %eax
jne 0x51c18
leaq 0x3e637(%rip), %rdi     # 0x90230
callq 0x189f0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x18a20
movq -0x18(%rbp), %rdi
callq 0x36ce0
jmp 0x51c1a
addq $0x20, %rsp
popq %rbp
retq
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
leaq -0xe(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x60430
leaq -0x18(%rbp), %rdi
callq 0x4a640
movb $0x0, -0x9(%rbp)
movsbl -0x9(%rbp), %eax
cmpl $0x18, %eax
jge 0x53649
movb $0x0, -0xa(%rbp)
movsbl -0xa(%rbp), %eax
cmpl $0x6, %eax
jge 0x5363a
movq 0x397bd(%rip), %rax     # 0x8cd38
movsbl -0x9(%rbp), %ecx
shll %ecx
imull $0x3, %ecx, %ecx
movsbl -0xa(%rbp), %edx
addl %edx, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
movq -0x8(%rbp), %rcx
movswl (%rcx), %ecx
addl %ecx, %eax
movw %ax, -0xe(%rbp)
movq 0x39793(%rip), %rax     # 0x8cd38
movsbl -0x9(%rbp), %ecx
shll %ecx
imull $0x3, %ecx, %ecx
movsbl -0xa(%rbp), %edx
addl %edx, %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
movq -0x8(%rbp), %rcx
movswl 0x2(%rcx), %ecx
addl %ecx, %eax
movw %ax, -0xc(%rbp)
leaq 0x3e805(%rip), %rax     # 0x91dd8
movq (%rax), %rdi
leaq -0xe(%rbp), %rsi
callq 0x3dcd0
movl %eax, -0x1c(%rbp)
movw -0x1c(%rbp), %ax
movw %ax, -0x10(%rbp)
movzwl %ax, %eax
andl $0x40, %eax
cmpl $0x0, %eax
je 0x53619
leaq -0xe(%rbp), %rdi
callq 0x58180
jmp 0x53600
jmp 0x53629
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0xe(%rbp), %rdi
callq 0x60460
jmp 0x53673
movzwl -0x10(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
jne 0x53627
jmp 0x5363a
jmp 0x53629
jmp 0x5362b
movsbl -0xa(%rbp), %eax
addl $0x2, %eax
movb %al, -0xa(%rbp)
jmp 0x53567
jmp 0x5363c
movb -0x9(%rbp), %al
addb $0x1, %al
movb %al, -0x9(%rbp)
jmp 0x53556
movq -0x8(%rbp), %rdi
callq 0x58180
jmp 0x53654
movq -0x8(%rbp), %rdi
movl $0x3, %esi
callq 0x48080
jmp 0x53664
leaq -0xe(%rbp), %rdi
callq 0x60460
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x5920
nopl (%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x1b050
movsbl 0x143(%rax), %eax
movl %eax, -0x28(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x1b050
movq %rax, %rcx
movl -0x28(%rbp), %eax
movl 0xb0(%rcx), %ecx
movl %ecx, %edx
leaq 0x16bd3(%rip), %rcx     # 0x6a300
imulq $0xd, %rdx, %rdx
addq %rdx, %rcx
movsbl 0x3(%rcx), %ecx
cmpl %ecx, %eax
jge 0x53873
jmp 0x53742
leaq -0x8(%rbp), %rdi
callq 0x1b050
movq %rax, %rdi
addq $0x80, %rdi
callq 0x1b390
movq 0x98(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x98(%rax)
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x29(%rbp)
je 0x537e1
leaq -0x8(%rbp), %rdi
callq 0x1b050
movq %rax, %rcx
movb 0x143(%rcx), %al
addb $0x1, %al
movb %al, 0x143(%rcx)
movsbl %al, %eax
movl %eax, -0x30(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x1b050
movl -0x30(%rbp), %ecx
movl 0xb0(%rax), %eax
movl %eax, %edx
leaq 0x16b4e(%rip), %rax     # 0x6a300
imulq $0xd, %rdx, %rdx
addq %rdx, %rax
movsbl 0x3(%rax), %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x29(%rbp)
jge 0x537e1
callq 0x5270
movl $0x4, %ecx
cqto
idivq %rcx
cmpq $0x0, %rdx
setne %al
xorb $-0x1, %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x537ea
jmp 0x537ef
jmp 0x53742
leaq 0x3ca3a(%rip), %rdi     # 0x90230
callq 0x189f0
movq %rax, -0x10(%rbp)
leaq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x1b050
movq -0x40(%rbp), %rdi
movq -0x10(%rbp), %rcx
movq %rcx, 0x150(%rax)
callq 0x1b050
movq -0x40(%rbp), %rdi
movb $0x1, 0x14d(%rax)
callq 0x1b050
movq 0x138(%rax), %rsi
leaq -0x14(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x1b190
movq -0x38(%rbp), %rdi
xorl %esi, %esi
callq 0x47f20
jmp 0x53851
leaq -0x14(%rbp), %rdi
callq 0x60460
jmp 0x53873
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x14(%rbp), %rdi
callq 0x60460
jmp 0x53879
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x5920
nopw %cs:(%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x8(%rbp), %rdi
callq 0x1b050
movq 0x138(%rax), %rsi
leaq -0x14(%rbp), %rdi
callq 0x1b190
leaq -0x10(%rbp), %rdi
callq 0x1b050
movq 0x138(%rax), %rsi
leaq -0x18(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x1b190
movq -0x40(%rbp), %rsi
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
xorl %edx, %edx
callq 0x53890
jmp 0x54f3f
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
leaq -0x14(%rbp), %rsi
xorl %edx, %edx
callq 0x53890
jmp 0x54f58
leaq -0x10(%rbp), %rdi
callq 0x1b050
movl $0x8, 0x12c(%rax)
leaq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x1b050
movq -0x50(%rbp), %rdi
movl $0x8, 0x12c(%rax)
callq 0x1b050
movq %rax, %rdi
callq 0x21cd0
movb %al, -0x41(%rbp)
jmp 0x54f98
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x54fdf
jmp 0x54fa1
leaq 0x3ce30(%rip), %rax     # 0x91dd8
movq (%rax), %rdi
leaq -0x14(%rbp), %rsi
callq 0x3d2d0
movzwl (%rax), %ecx
andl $-0x41, %ecx
movw %cx, (%rax)
jmp 0x54fdf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x60460
leaq -0x14(%rbp), %rdi
callq 0x60460
jmp 0x55032
leaq -0x10(%rbp), %rdi
callq 0x1b050
movq %rax, %rdi
callq 0x21cd0
movb %al, -0x51(%rbp)
jmp 0x54ff5
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x5501a
jmp 0x54ffe
leaq 0x3cdd3(%rip), %rax     # 0x91dd8
movq (%rax), %rdi
leaq -0x18(%rbp), %rsi
callq 0x3d2d0
movzwl (%rax), %ecx
andl $-0x41, %ecx
movw %cx, (%rax)
leaq -0x18(%rbp), %rdi
callq 0x60460
leaq -0x14(%rbp), %rdi
callq 0x60460
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x5920
nopl (%rax,%rax)