LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: AngelPn[P]L5R-card_game/./include/Item.hpp
// Function: Item::Item(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
Item(const std::string name, int type) : GreenCard(name, type)
	//constructors of GreenCard and Card will initialize the data members which are not in the .txt files
	//data members with values from the .txt file, are initialized here
	{
		switch (type)
		{
			case KATANA    : cost= 0; attackBonus = 2; defenseBonus = 0; minimumHonor = 1; effectBonus= 1; effectCost= 2; durability = 3; break;
			case SPEAR     : cost= 0; attackBonus = 0; defenseBonus = 2; minimumHonor = 1; effectBonus= 1; effectCost= 2; durability = 3; break;
			case BOW       : cost= 2; attackBonus = 2; defenseBonus = 2; minimumHonor = 2; effectBonus= 3; effectCost= 4; durability = 5; break;
			case NINJATO   : cost= 4; attackBonus = 3; defenseBonus = 3; minimumHonor = 3; effectBonus= 2; effectCost= 2; durability = 4; break;
			case WAKIZASHI : cost= 8; attackBonus = 5; defenseBonus = 5; minimumHonor = 3; effectBonus= 3; effectCost= 3; durability = 8; break;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x40f0
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x8840
jmp 0x8c6a
leaq -0x38(%rbp), %rdi
callq 0x4160
movq -0x58(%rbp), %rax
leaq 0x1bb42(%rip), %rcx     # 0x247c0
movq %rcx, (%rax)
movl -0x14(%rbp), %eax
movq %rax, -0x60(%rbp)
subq $0x4, %rax
ja 0x8dd7
movq -0x60(%rbp), %rax
leaq 0xf3ab(%rip), %rcx      # 0x18048
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4160
jmp 0x8ddd
movq -0x58(%rbp), %rax
movl $0x0, 0x28(%rax)
movl $0x2, 0x50(%rax)
movl $0x0, 0x54(%rax)
movl $0x1, 0x58(%rax)
movl $0x1, 0x5c(%rax)
movl $0x2, 0x60(%rax)
movl $0x3, 0x64(%rax)
jmp 0x8dd7
movq -0x58(%rbp), %rax
movl $0x0, 0x28(%rax)
movl $0x0, 0x50(%rax)
movl $0x2, 0x54(%rax)
movl $0x1, 0x58(%rax)
movl $0x1, 0x5c(%rax)
movl $0x2, 0x60(%rax)
movl $0x3, 0x64(%rax)
jmp 0x8dd7
movq -0x58(%rbp), %rax
movl $0x2, 0x28(%rax)
movl $0x2, 0x50(%rax)
movl $0x2, 0x54(%rax)
movl $0x2, 0x58(%rax)
movl $0x3, 0x5c(%rax)
movl $0x4, 0x60(%rax)
movl $0x5, 0x64(%rax)
jmp 0x8dd7
movq -0x58(%rbp), %rax
movl $0x4, 0x28(%rax)
movl $0x3, 0x50(%rax)
movl $0x3, 0x54(%rax)
movl $0x3, 0x58(%rax)
movl $0x2, 0x5c(%rax)
movl $0x2, 0x60(%rax)
movl $0x4, 0x64(%rax)
jmp 0x8dd7
movq -0x58(%rbp), %rax
movl $0x8, 0x28(%rax)
movl $0x5, 0x50(%rax)
movl $0x5, 0x54(%rax)
movl $0x3, 0x58(%rax)
movl $0x3, 0x5c(%rax)
movl $0x3, 0x60(%rax)
movl $0x8, 0x64(%rax)
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x4340
nopw %cs:(%rax,%rax)
// File: AngelPn[P]L5R-card_game/./include/Holding.hpp
// Function: Holding::Holding(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
Holding(const std::string name, int type) : BlackCard(name, type), upperHolding(NULL), subHolding(NULL)
	//constructors of BlackCard and Card will initialize the data members which are not in the .txt files
	//data members with values from the .txt file, are initialized here
	{
		switch (type)
		{
			case PLAIN        : cost= 2; harvestValue = 2; break;
			case SOLO         : cost= 2; harvestValue = 2; break;
			case MINE         : cost= 5; harvestValue = 3; break;
			case FARMS        : cost= 3; harvestValue = 4; break;
			case GOLD_MINE    : cost= 7; harvestValue = 5; break;
			case STRONGHOLD   : cost= 0; harvestValue = 5; break;
			case CRYSTAL_MINE : cost= 12; harvestValue = 6; break;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x40f0
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x9530
jmp 0x935a
leaq -0x38(%rbp), %rdi
callq 0x4160
movq -0x58(%rbp), %rax
leaq 0x1b74a(%rip), %rcx     # 0x24ab8
movq %rcx, (%rax)
movq $0x0, 0x30(%rax)
movq $0x0, 0x38(%rax)
movl -0x14(%rbp), %eax
movq %rax, -0x60(%rbp)
subq $0x6, %rax
ja 0x944a
movq -0x60(%rbp), %rax
leaq 0xecbf(%rip), %rcx      # 0x1805c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4160
jmp 0x9450
movq -0x58(%rbp), %rax
movl $0x2, 0x28(%rax)
movl $0x2, 0x40(%rax)
jmp 0x944a
movq -0x58(%rbp), %rax
movl $0x2, 0x28(%rax)
movl $0x2, 0x40(%rax)
jmp 0x944a
movq -0x58(%rbp), %rax
movl $0x5, 0x28(%rax)
movl $0x3, 0x40(%rax)
jmp 0x944a
movq -0x58(%rbp), %rax
movl $0x3, 0x28(%rax)
movl $0x4, 0x40(%rax)
jmp 0x944a
movq -0x58(%rbp), %rax
movl $0x7, 0x28(%rax)
movl $0x5, 0x40(%rax)
jmp 0x944a
movq -0x58(%rbp), %rax
movl $0x0, 0x28(%rax)
movl $0x5, 0x40(%rax)
jmp 0x944a
movq -0x58(%rbp), %rax
movl $0xc, 0x28(%rax)
movl $0x6, 0x40(%rax)
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x4340
nopl (%rax)
// File: AngelPn[P]L5R-card_game/src/GameBoard.cpp
// Function: GameBoard::initializeGameBoard(int)
void GameBoard::initializeGameBoard(int no_players){
	std::string name;
	for(int i=0; i< no_players; i++){
		std::cout << "Give player's name: " << std::endl;
		std::cin >> name;
		players.push_back(new Player(name));
	}

		printGameStatistics();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x42d0
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xc3b8
movq 0x18cc6(%rip), %rdi     # 0x24fd0
leaq 0xc3d0(%rip), %rsi      # 0x186e1
callq 0x4200
movq %rax, -0x60(%rbp)
jmp 0xc31c
movq -0x60(%rbp), %rdi
movq 0x18c99(%rip), %rsi     # 0x24fc0
callq 0x4230
jmp 0xc32e
movq 0x18cab(%rip), %rdi     # 0x24fe0
leaq -0x30(%rbp), %rsi
callq 0x42a0
jmp 0xc340
movq -0x58(%rbp), %rax
movq %rax, -0x70(%rbp)
movl $0xc8, %edi
callq 0x4210
movq %rax, -0x68(%rbp)
jmp 0xc358
movq -0x68(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xf3b0
jmp 0xc367
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x50(%rbp), %rsi
callq 0xcc10
jmp 0xc37e
jmp 0xc380
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xc2f7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0xc3d2
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
movl $0xc8, %esi
callq 0x4220
jmp 0xc3d2
movq -0x58(%rbp), %rdi
callq 0xc3f0
jmp 0xc3c3
leaq -0x30(%rbp), %rdi
callq 0x4160
addq $0x70, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x4160
movq -0x40(%rbp), %rdi
callq 0x4340
nopw %cs:(%rax,%rax)
// File: AngelPn[P]L5R-card_game/src/GameBoard.cpp
// Function: GameBoard::printGameStatistics()
void GameBoard::printGameStatistics(){
	std::cout << "\nPrinting Statistics: " << std::endl << std::endl;
	for(int i=0; i< players.size(); i++){
		std::cout<< "PLAYER "<< players[i]->name << " is #"<< i+1 << std::endl;
		players[i]->printGameStatistics();
		std::cout<< std::endl;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x18bc5(%rip), %rdi     # 0x24fd0
leaq 0xc2e4(%rip), %rsi      # 0x186f6
callq 0x4200
movq %rax, %rdi
movq 0x18b9f(%rip), %rsi     # 0x24fc0
callq 0x4230
movq %rax, %rdi
movq 0x18b90(%rip), %rsi     # 0x24fc0
callq 0x4230
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rdi
movslq -0xc(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0xcb70
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0xc4f6
movq 0x18b6c(%rip), %rdi     # 0x24fd0
leaq 0xc2a2(%rip), %rsi      # 0x1870d
callq 0x4200
movq -0x18(%rbp), %rdi
movq %rax, -0x28(%rbp)
movslq -0xc(%rbp), %rsi
callq 0xcb90
movq -0x28(%rbp), %rdi
movq (%rax), %rsi
addq $0xa8, %rsi
callq 0x41d0
movq %rax, %rdi
leaq 0xc277(%rip), %rsi      # 0x18715
callq 0x4200
movq %rax, %rdi
movl -0xc(%rbp), %esi
addl $0x1, %esi
callq 0x4330
movq %rax, %rdi
movq 0x18b05(%rip), %rsi     # 0x24fc0
callq 0x4230
movq -0x18(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0xcb90
movq (%rax), %rdi
callq 0xf870
movq 0x18af4(%rip), %rdi     # 0x24fd0
movq 0x18add(%rip), %rsi     # 0x24fc0
callq 0x4230
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xc43c
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: AngelPn[P]L5R-card_game/src/GameBoard.cpp
// Function: GameBoard::checkWinningCondition()
int GameBoard::checkWinningCondition(){
	int flag= 0, winner= 0;
	for(int i=0; i< players.size(); i++){
		if(players[i]->give_no_provinces()== 0)
			continue;
		else{
			flag++;
			winner= i;
		}
	}
	if(flag== 1) return winner;
	else return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rdi
movslq -0x1c(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0xcb70
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0xc57e
movq -0x28(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0xcb90
movq (%rax), %rdi
callq 0xf850
cmpl $0x0, %eax
jne 0xc562
jmp 0xc573
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0xc573
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xc529
cmpl $0x1, -0x14(%rbp)
jne 0xc58c
movl -0x18(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xc593
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: AngelPn[P]L5R-card_game/src/TypeConverter.cpp
// Function: TypeConverter::getCorrectType(BlackCard*, Personality**, Holding**)
void TypeConverter::getCorrectType(BlackCard *card, Personality **person, Holding **hold)
{
	if (card->getType() == PERSONALITY) {
		(*person) = getPersonality(card);
		(*hold) = NULL;
	}
	else {
		(*hold) = getHolding(card);
		(*person) = NULL;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x1, %eax
jne 0xd612
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xd640
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
jmp 0xd634
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xd6c0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: AngelPn[P]L5R-card_game/src/TypeConverter.cpp
// Function: TypeConverter::getCorrectType(GreenCard*, Follower**, Item**)
void TypeConverter::getCorrectType(GreenCard *card, Follower **follow, Item **item)
{
	if (card->getType() == FOLLOWER) {
		(*follow) = getFollower(card);
		(*item) = NULL;
	}
	else {
		(*item) = getItem(card);
		(*follow) = NULL;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *(%rax)
cmpl $0x3, %eax
jne 0xd792
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xd7c0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq $0x0, (%rax)
jmp 0xd7b4
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xd840
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: AngelPn[P]L5R-card_game/src/Personality.cpp
// Function: Personality::Personality(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
Personality::Personality(const std::string name, int type) : BlackCard(name, type), isDead(0)
//constructors of BlackCard and Card will initialize the data members which are not in the .txt files
//data members with values from the .txt file, are initialized here
{
	switch (type)
	{
		case ATTACKER   : cost= 5; attack = 3; defense = 2; honour = 2; greenCardBound = 3; break;
		case DEFENDER   : cost= 5; attack = 2; defense = 3; honour = 2; greenCardBound = 3; break;
		case SHOGUN     : cost= 15; attack = 10; defense = 5; honour = 8; greenCardBound = 4; break;
		case CHANCELLOR : cost= 15; attack = 5; defense = 10; honour = 8; greenCardBound = 4; break;
		case CHAMPION   : cost= 30; attack = 20; defense = 20; honour = 12; greenCardBound = 5; break;
	}

	followers = new std::list<Follower*>();
	items = new std::list<Item*>();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x40f0
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x9530
jmp 0xd8fa
leaq -0x38(%rbp), %rdi
callq 0x4160
movq -0x58(%rbp), %rax
leaq 0x17402(%rip), %rcx     # 0x24d10
movq %rcx, (%rax)
movb $0x0, 0x2e(%rax)
movl -0x14(%rbp), %eax
movq %rax, -0x60(%rbp)
subq $0x4, %rax
ja 0xda22
movq -0x60(%rbp), %rax
leaq 0xaf3f(%rip), %rcx      # 0x18870
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x4160
jmp 0xdaa5
movq -0x58(%rbp), %rax
movl $0x5, 0x28(%rax)
movl $0x3, 0x30(%rax)
movl $0x2, 0x34(%rax)
movl $0x2, 0x38(%rax)
movl $0x3, 0x50(%rax)
jmp 0xda22
movq -0x58(%rbp), %rax
movl $0x5, 0x28(%rax)
movl $0x2, 0x30(%rax)
movl $0x3, 0x34(%rax)
movl $0x2, 0x38(%rax)
movl $0x3, 0x50(%rax)
jmp 0xda22
movq -0x58(%rbp), %rax
movl $0xf, 0x28(%rax)
movl $0xa, 0x30(%rax)
movl $0x5, 0x34(%rax)
movl $0x8, 0x38(%rax)
movl $0x4, 0x50(%rax)
jmp 0xda22
movq -0x58(%rbp), %rax
movl $0xf, 0x28(%rax)
movl $0x5, 0x30(%rax)
movl $0xa, 0x34(%rax)
movl $0x8, 0x38(%rax)
movl $0x4, 0x50(%rax)
jmp 0xda22
movq -0x58(%rbp), %rax
movl $0x1e, 0x28(%rax)
movl $0x14, 0x30(%rax)
movl $0x14, 0x34(%rax)
movl $0xc, 0x38(%rax)
movl $0x5, 0x50(%rax)
movl $0x18, %edi
callq 0x4210
movq %rax, -0x68(%rbp)
jmp 0xda32
movq -0x68(%rbp), %rdi
xorps %xmm0, %xmm0
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
callq 0xe0b0
movq -0x68(%rbp), %rcx
movq -0x58(%rbp), %rax
movq %rcx, 0x40(%rax)
movl $0x18, %edi
callq 0x4210
movq %rax, -0x70(%rbp)
jmp 0xda65
movq -0x70(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x4130
movq -0x70(%rbp), %rdi
callq 0xe0d0
movq -0x70(%rbp), %rcx
movq -0x58(%rbp), %rax
movq %rcx, 0x48(%rax)
addq $0x70, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x9770
movq -0x40(%rbp), %rdi
callq 0x4340
nop
// File: AngelPn[P]L5R-card_game/src/Personality.cpp
// Function: Personality::~Personality()
Personality::~Personality()
{
	items->clear();
	delete items;
	followers->clear();
	delete followers;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x17235(%rip), %rcx     # 0x24d00
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x48(%rax), %rdi
callq 0xe0f0
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0xdb04
movq -0x10(%rbp), %rdi
callq 0xe120
movq -0x10(%rbp), %rdi
movl $0x18, %esi
callq 0x4220
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0xe140
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0xdb3a
movq -0x20(%rbp), %rdi
callq 0xe170
movq -0x20(%rbp), %rdi
movl $0x18, %esi
callq 0x4220
movq -0x18(%rbp), %rdi
callq 0x9770
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: AngelPn[P]L5R-card_game/src/Personality.cpp
// Function: Personality::decrement_durability()
void Personality::decrement_durability(){
	std::list<Item *>::iterator it;
	for (it = items->begin(); it != items->end(); it++){
		(*it)->decrement_durability();
		if((*it)->get_durability() == 0)
			items->erase(it);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x10(%rbp), %rdi
callq 0xe350
movq -0x40(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0xe370
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x40(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0xe3d0
movq %rax, -0x20(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xe3a0
testb $0x1, %al
jne 0xdd8a
jmp 0xddf1
leaq -0x10(%rbp), %rdi
callq 0xe400
movq (%rax), %rdi
callq 0xe420
leaq -0x10(%rbp), %rdi
callq 0xe400
movq (%rax), %rdi
callq 0xe440
cmpl $0x0, %eax
jne 0xdddb
movq -0x40(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x48(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0xe4b0
movq -0x48(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xe460
movq %rax, -0x30(%rbp)
jmp 0xdddd
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0xe4d0
movq %rax, -0x38(%rbp)
jmp 0xdd66
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: AngelPn[P]L5R-card_game/src/Personality.cpp
// Function: Personality::print() const
void Personality::print() const{
	std::cout<< "\033[1;31mCost: \033[0m"<< cost<< "\033[1;31m\nAttack: \033[0m"<< attack<< "\033[1;31m\nDefense: \033[0m"<< defense<<
	"\033[1;31m\nHonour: \033[0m"<< honour<< "\033[1;31m\nGreen cards attached : \033[0m"
	<< followers->size() + items->size() << "\033[1;31m\nMax green cards : \033[0m" << greenCardBound << std::endl;
	BlackCard::print();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x170f5(%rip), %rdi     # 0x24fd0
leaq 0xa5ac(%rip), %rsi      # 0x1848e
callq 0x4200
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x28(%rax), %esi
callq 0x42c0
movq %rax, %rdi
leaq 0xa9b0(%rip), %rsi      # 0x188b0
callq 0x4200
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x30(%rax), %esi
callq 0x42c0
movq %rax, %rdi
leaq 0xa9a7(%rip), %rsi      # 0x188c5
callq 0x4200
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x34(%rax), %esi
callq 0x42c0
movq %rax, %rdi
leaq 0xa99f(%rip), %rsi      # 0x188db
callq 0x4200
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x38(%rax), %esi
callq 0x42c0
movq %rax, %rdi
leaq 0xa996(%rip), %rsi      # 0x188f0
callq 0x4200
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq 0x40(%rax), %rdi
callq 0xe500
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq 0x48(%rax), %rdi
callq 0xe530
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdi
addq %rax, %rsi
callq 0x4090
movq %rax, %rdi
leaq 0xa973(%rip), %rsi      # 0x18914
callq 0x4200
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x50(%rax), %esi
callq 0x42c0
movq %rax, %rdi
movq 0x17001(%rip), %rsi     # 0x24fc0
callq 0x4230
movq -0x10(%rbp), %rdi
callq 0x96c0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: AngelPn[P]L5R-card_game/src/Personality.cpp
// Function: Personality::equip(GreenCard*)
void Personality::equip(GreenCard *card)
{
	Follower *follow = NULL;
	Item *item = NULL;
	TypeConverter t;
	t.getCorrectType(card,&follow,&item);
	if (follow == NULL) //if given green card is item
		items->push_back(item); //push it to the vector of items of personality
	else
		followers->push_back(follow); //else push it to the vector of followers of personality
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
leaq -0x21(%rbp), %rdi
callq 0xd5b0
movq -0x10(%rbp), %rsi
leaq -0x21(%rbp), %rdi
leaq -0x18(%rbp), %rdx
leaq -0x20(%rbp), %rcx
callq 0xd740
cmpq $0x0, -0x18(%rbp)
jne 0xe090
movq -0x30(%rbp), %rax
movq 0x48(%rax), %rdi
leaq -0x20(%rbp), %rsi
callq 0xe580
jmp 0xe0a1
movq -0x30(%rbp), %rax
movq 0x40(%rax), %rdi
leaq -0x18(%rbp), %rsi
callq 0xe5c0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: AngelPn[P]L5R-card_game/src/Player.cpp
// Function: Player::~Player()
Player::~Player(){
	dynastyDeck->clear();
	delete dynastyDeck;
	fateDeck->clear();
	delete fateDeck;
	delete holdings[0]; //deletes stronghold
	//deck and the cards get  deleted by destructor of class DeckBuilder
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x18(%rax), %rdi
callq 0x7a60
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0xf786
movq -0x10(%rbp), %rdi
callq 0x6c30
movq -0x10(%rbp), %rdi
movl $0x18, %esi
callq 0x4220
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x7db0
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0xf7bc
movq -0x20(%rbp), %rdi
callq 0x6c50
movq -0x20(%rbp), %rdi
movl $0x18, %esi
callq 0x4220
movq -0x18(%rbp), %rdi
addq $0x38, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x13770
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0xf7e4
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq -0x18(%rbp), %rdi
addq $0xa8, %rdi
callq 0x4160
movq -0x18(%rbp), %rdi
addq $0x88, %rdi
callq 0x7b90
movq -0x18(%rbp), %rdi
addq $0x68, %rdi
callq 0x137f0
movq -0x18(%rbp), %rdi
addq $0x50, %rdi
callq 0x13850
movq -0x18(%rbp), %rdi
addq $0x38, %rdi
callq 0x138b0
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
callq 0x7ee0
movq -0x18(%rbp), %rdi
callq 0x4860
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: AngelPn[P]L5R-card_game/src/Player.cpp
// Function: Player::startingPhase()
void Player::startingPhase()
{
	cout << "Player: " << this->name << " is playing " << endl;
	cout << "Starting Phase ..." << endl << endl;
	this->untapEverything(); //untap all cards
	this->drawFateCard(); //draw top card of fateDeck
	this->revealProvinces(); //reveal not-destroyed provinces
	this->printHand(); //print cards in your hand
	this->printProvinces(); //prints not-destroyed provinces
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x15665(%rip), %rdi     # 0x24fd0
leaq 0x8df6(%rip), %rsi      # 0x18768
callq 0x4200
movq -0x10(%rbp), %rsi
movq %rax, %rdi
addq $0xa8, %rsi
callq 0x41d0
movq %rax, %rdi
leaq 0x8ddd(%rip), %rsi      # 0x18771
callq 0x4200
movq %rax, %rdi
movq 0x1561d(%rip), %rsi     # 0x24fc0
callq 0x4230
movq 0x15621(%rip), %rdi     # 0x24fd0
leaq 0x8fca(%rip), %rsi      # 0x18980
callq 0x4200
movq %rax, %rdi
movq 0x155fb(%rip), %rsi     # 0x24fc0
callq 0x4230
movq %rax, %rdi
movq 0x155ec(%rip), %rsi     # 0x24fc0
callq 0x4230
movq -0x10(%rbp), %rdi
callq 0xfa10
movq -0x10(%rbp), %rdi
callq 0xfbb0
movq -0x10(%rbp), %rdi
callq 0xfc30
movq -0x10(%rbp), %rdi
callq 0xfcd0
movq -0x10(%rbp), %rdi
callq 0xfdb0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: AngelPn[P]L5R-card_game/src/Player.cpp
// Function: Player::untapEverything()
void Player::untapEverything()
{
	for (vector<GreenCard *>::iterator it = hand.begin(); it != hand.end(); ++it)
	{
		(*it)->untap();
	}

	for (vector<Holding*>::iterator it = holdings.begin(); it != holdings.end(); ++it)
	{
		(*it)->untap();
	}

	for (vector<Personality*>::iterator it = army.begin(); it != army.end(); ++it)
	{
		(*it)->untap();
	}

	for (vector<BlackCard*>::iterator it = provinces.begin(); it != provinces.end(); ++it)
	{
		(*it)->untap();
	}

	cout << "All cards untapped " << endl << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
addq $0x20, %rdi
callq 0x7d50
movq %rax, -0x10(%rbp)
movq -0x50(%rbp), %rdi
addq $0x20, %rdi
callq 0x7d80
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x7e00
testb $0x1, %al
jne 0xfa55
jmp 0xfa71
leaq -0x10(%rbp), %rdi
callq 0x7e80
movq (%rax), %rdi
callq 0x13950
leaq -0x10(%rbp), %rdi
callq 0xc090
jmp 0xfa31
movq -0x50(%rbp), %rdi
addq $0x38, %rdi
callq 0x13970
movq %rax, -0x20(%rbp)
movq -0x50(%rbp), %rdi
addq $0x38, %rdi
callq 0x139e0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x139a0
testb $0x1, %al
jne 0xfaa6
jmp 0xfac2
leaq -0x20(%rbp), %rdi
callq 0x13a10
movq (%rax), %rdi
callq 0x13950
leaq -0x20(%rbp), %rdi
callq 0x13a30
jmp 0xfa82
movq -0x50(%rbp), %rdi
addq $0x50, %rdi
callq 0x13a50
movq %rax, -0x30(%rbp)
movq -0x50(%rbp), %rdi
addq $0x50, %rdi
callq 0x13ac0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x13a80
testb $0x1, %al
jne 0xfaf7
jmp 0xfb13
leaq -0x30(%rbp), %rdi
callq 0x13af0
movq (%rax), %rdi
callq 0x13950
leaq -0x30(%rbp), %rdi
callq 0x13b10
jmp 0xfad3
movq -0x50(%rbp), %rdi
addq $0x88, %rdi
callq 0x7a00
movq %rax, -0x40(%rbp)
movq -0x50(%rbp), %rdi
addq $0x88, %rdi
callq 0x7a30
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x7ab0
testb $0x1, %al
jne 0xfb4e
jmp 0xfb6a
leaq -0x40(%rbp), %rdi
callq 0x7b30
movq (%rax), %rdi
callq 0x13950
leaq -0x40(%rbp), %rdi
callq 0xb690
jmp 0xfb27
movq 0x1545f(%rip), %rdi     # 0x24fd0
leaq 0x8e1b(%rip), %rsi      # 0x18993
callq 0x4200
movq %rax, %rdi
movq 0x15439(%rip), %rsi     # 0x24fc0
callq 0x4230
movq %rax, %rdi
movq 0x1542a(%rip), %rsi     # 0x24fc0
callq 0x4230
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: AngelPn[P]L5R-card_game/src/Player.cpp
// Function: Player::printHand() const
void Player::printHand() const
{
	int flag = 1;
	cout << "Printing cards in hand : " << endl << endl;
	for (vector<GreenCard *>::const_iterator it = hand.begin(); it != hand.end(); ++it)
	{
		cout<< flag++ << ")"<< endl;
		(*it)->print();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x1, -0xc(%rbp)
movq 0x152de(%rip), %rdi     # 0x24fd0
leaq 0x8cd2(%rip), %rsi      # 0x189cb
callq 0x4200
movq %rax, %rdi
movq 0x152b8(%rip), %rsi     # 0x24fc0
callq 0x4230
movq %rax, %rdi
movq 0x152a9(%rip), %rsi     # 0x24fc0
callq 0x4230
movq -0x28(%rbp), %rdi
addq $0x20, %rdi
callq 0x13b50
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rdi
addq $0x20, %rdi
callq 0x13bc0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x13b80
testb $0x1, %al
jne 0xfd51
jmp 0xfda3
movl -0xc(%rbp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq 0x1526d(%rip), %rdi     # 0x24fd0
callq 0x4330
movq %rax, %rdi
leaq 0x979f(%rip), %rsi      # 0x19511
callq 0x4200
movq %rax, %rdi
movq 0x1523f(%rip), %rsi     # 0x24fc0
callq 0x4230
leaq -0x18(%rbp), %rdi
callq 0x13bf0
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
leaq -0x18(%rbp), %rdi
callq 0x13c10
jmp 0xfd2d
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: AngelPn[P]L5R-card_game/src/Player.cpp
// Function: Player::printProvinces() const
void Player::printProvinces() const
{
	int flag= 1;
	cout << "Printing provinces : " << endl << endl;
	for (vector<BlackCard*>::const_iterator it = provinces.begin(); it != provinces.end(); ++it)
	{
		cout<< flag++ << ")"<< endl;
		if ((*it)->is_revealed() == true)
			(*it)->print();
		else cout<< "Not revealed!"<< endl<< endl;
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x1, -0xc(%rbp)
movq 0x151fe(%rip), %rdi     # 0x24fd0
leaq 0x8c0c(%rip), %rsi      # 0x189e5
callq 0x4200
movq %rax, %rdi
movq 0x151d8(%rip), %rsi     # 0x24fc0
callq 0x4230
movq %rax, %rdi
movq 0x151c9(%rip), %rsi     # 0x24fc0
callq 0x4230
movq -0x28(%rbp), %rdi
addq $0x88, %rdi
callq 0x13c30
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rdi
addq $0x88, %rdi
callq 0x13ca0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x13c60
testb $0x1, %al
jne 0xfe3a
jmp 0xfedf
movl -0xc(%rbp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq 0x15184(%rip), %rdi     # 0x24fd0
callq 0x4330
movq %rax, %rdi
leaq 0x96b6(%rip), %rsi      # 0x19511
callq 0x4200
movq %rax, %rdi
movq 0x15156(%rip), %rsi     # 0x24fc0
callq 0x4230
leaq -0x18(%rbp), %rdi
callq 0x13cd0
movq (%rax), %rdi
callq 0x13cf0
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0xfe9e
leaq -0x18(%rbp), %rdi
callq 0x13cd0
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0xfecf
movq 0x1512b(%rip), %rdi     # 0x24fd0
leaq 0x8b4f(%rip), %rsi      # 0x189fb
callq 0x4200
movq %rax, %rdi
movq 0x15105(%rip), %rsi     # 0x24fc0
callq 0x4230
movq %rax, %rdi
movq 0x150f6(%rip), %rsi     # 0x24fc0
callq 0x4230
jmp 0xfed1
leaq -0x18(%rbp), %rdi
callq 0x13d10
jmp 0xfe10
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: AngelPn[P]L5R-card_game/src/Player.cpp
// Function: Player::printArmy() const
void Player::printArmy() const
{
	int flag = 1;
	cout << "Printing army : " << endl << endl;
	for (vector<Personality*>::const_iterator it = army.begin(); it != army.end(); ++it)
	{
		cout<< flag++ << ")"<< endl;
		(*it)->print();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x1, -0xc(%rbp)
movq 0x1485e(%rip), %rdi     # 0x24fd0
leaq 0x85ae(%rip), %rsi      # 0x18d27
callq 0x4200
movq %rax, %rdi
movq 0x14838(%rip), %rsi     # 0x24fc0
callq 0x4230
movq %rax, %rdi
movq 0x14829(%rip), %rsi     # 0x24fc0
callq 0x4230
movq -0x28(%rbp), %rdi
addq $0x50, %rdi
callq 0x13ea0
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rdi
addq $0x50, %rdi
callq 0x13f10
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x13ed0
testb $0x1, %al
jne 0x107d1
jmp 0x10823
movl -0xc(%rbp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq 0x147ed(%rip), %rdi     # 0x24fd0
callq 0x4330
movq %rax, %rdi
leaq 0x8d1f(%rip), %rsi      # 0x19511
callq 0x4200
movq %rax, %rdi
movq 0x147bf(%rip), %rsi     # 0x24fc0
callq 0x4230
leaq -0x18(%rbp), %rdi
callq 0x13f40
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
leaq -0x18(%rbp), %rdi
callq 0x13f60
jmp 0x107ad
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: AngelPn[P]L5R-card_game/src/Player.cpp
// Function: Player::printHoldings() const
void Player::printHoldings() const
{
	int flag = 1;
	cout << "Printing holdings : " << endl << endl;
	for (vector<Holding*>::const_iterator it = holdings.begin(); it != holdings.end(); ++it)
	{
		cout<< flag++ << ")"<< endl;
		(*it)->print();
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x1, -0xc(%rbp)
movq 0x12a7e(%rip), %rdi     # 0x24fd0
leaq 0x6d0a(%rip), %rsi      # 0x19263
callq 0x4200
movq %rax, %rdi
movq 0x12a58(%rip), %rsi     # 0x24fc0
callq 0x4230
movq %rax, %rdi
movq 0x12a49(%rip), %rsi     # 0x24fc0
callq 0x4230
movq -0x28(%rbp), %rdi
addq $0x38, %rdi
callq 0x14310
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rdi
addq $0x38, %rdi
callq 0x14380
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x14340
testb $0x1, %al
jne 0x125b1
jmp 0x12603
movl -0xc(%rbp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq 0x12a0d(%rip), %rdi     # 0x24fd0
callq 0x4330
movq %rax, %rdi
leaq 0x6f3f(%rip), %rsi      # 0x19511
callq 0x4200
movq %rax, %rdi
movq 0x129df(%rip), %rsi     # 0x24fc0
callq 0x4230
leaq -0x18(%rbp), %rdi
callq 0x143b0
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
leaq -0x18(%rbp), %rdi
callq 0x143d0
jmp 0x1258d
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: AngelPn[P]L5R-card_game/src/Player.cpp
// Function: Player::equipProvince(BlackCard*)
void Player::equipProvince(BlackCard* card)
{
	Personality *person = NULL;
	Holding *hold = NULL;
	TypeConverter t;
	t.getCorrectType(card,&person,&hold);
	if (person == NULL) //if given black card is holding
	{
		this->checkChains(hold); //check for upper-sub holding connections
		holdings.push_back(hold); //push it to the vector of holdings of player
	}
	else
		army.push_back(person); //else push it to the army of player

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
leaq -0x21(%rbp), %rdi
callq 0xd5b0
movq -0x10(%rbp), %rsi
leaq -0x21(%rbp), %rdi
leaq -0x18(%rbp), %rdx
leaq -0x20(%rbp), %rcx
callq 0xd5c0
cmpq $0x0, -0x18(%rbp)
jne 0x12b2d
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x12b50
movq -0x30(%rbp), %rdi
addq $0x38, %rdi
leaq -0x20(%rbp), %rsi
callq 0x14450
jmp 0x12b3e
movq -0x30(%rbp), %rdi
addq $0x50, %rdi
leaq -0x18(%rbp), %rsi
callq 0x144c0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: AngelPn[P]L5R-card_game/src/Player.cpp
// Function: Player::endingPhase()
void Player::endingPhase()
{
	cout << "Player: " << this->name << " is playing " << endl;
	cout << "Ending Phase ..." << endl << endl;
	this->discardSurplusFateCards();
	this->printGameStatistics();
	this->printHand();
	this->printProvinces();
	this->printHoldings();
	this->printArena();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x11eb5(%rip), %rdi     # 0x24fd0
leaq 0x5646(%rip), %rsi      # 0x18768
callq 0x4200
movq -0x10(%rbp), %rsi
movq %rax, %rdi
addq $0xa8, %rsi
callq 0x41d0
movq %rax, %rdi
leaq 0x562d(%rip), %rsi      # 0x18771
callq 0x4200
movq %rax, %rdi
movq 0x11e6d(%rip), %rsi     # 0x24fc0
callq 0x4230
movq 0x11e71(%rip), %rdi     # 0x24fd0
leaq 0x635b(%rip), %rsi      # 0x194c1
callq 0x4200
movq %rax, %rdi
movq 0x11e4b(%rip), %rsi     # 0x24fc0
callq 0x4230
movq %rax, %rdi
movq 0x11e3c(%rip), %rsi     # 0x24fc0
callq 0x4230
movq -0x10(%rbp), %rdi
callq 0x131d0
movq -0x10(%rbp), %rdi
callq 0xf870
movq -0x10(%rbp), %rdi
callq 0xfcd0
movq -0x10(%rbp), %rdi
callq 0xfdb0
movq -0x10(%rbp), %rdi
callq 0x12530
movq -0x10(%rbp), %rdi
callq 0x12480
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: AngelPn[P]L5R-card_game/./include/Holding.hpp
// Function: Holding::equipBonus()
void equipBonus() //updates harvest value with bonus from upper,sub connections
	{
		if (this->getHoldingType() == MINE && upperHolding != NULL)
			this->harvestValue += 2;
		else if (this->getHoldingType() == GOLD_MINE && subHolding != NULL && upperHolding == NULL)
			this->harvestValue += 4;
		else if (this->getHoldingType() == GOLD_MINE && subHolding == NULL && upperHolding != NULL)
			this->harvestValue += 5;
		else if (this->getHoldingType() == GOLD_MINE && subHolding != NULL && upperHolding != NULL)
			this->harvestValue *= 2;
		else if (this->getHoldingType() == CRYSTAL_MINE && subHolding != NULL && subHolding->subHolding == NULL)
			this->harvestValue *= 2;
		else if (this->getHoldingType() == CRYSTAL_MINE && subHolding != NULL && subHolding->subHolding != NULL)
			this->harvestValue *= 3;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x1, %eax
jne 0x145ec
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x145ec
movq -0x10(%rbp), %rax
movl 0x40(%rax), %ecx
addl $0x2, %ecx
movl %ecx, 0x40(%rax)
jmp 0x14702
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x2, %eax
jne 0x14623
movq -0x10(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x14623
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
jne 0x14623
movq -0x10(%rbp), %rax
movl 0x40(%rax), %ecx
addl $0x4, %ecx
movl %ecx, 0x40(%rax)
jmp 0x14700
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x2, %eax
jne 0x1465a
movq -0x10(%rbp), %rax
cmpq $0x0, 0x38(%rax)
jne 0x1465a
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x1465a
movq -0x10(%rbp), %rax
movl 0x40(%rax), %ecx
addl $0x5, %ecx
movl %ecx, 0x40(%rax)
jmp 0x146fe
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x2, %eax
jne 0x1468d
movq -0x10(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x1468d
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x1468d
movq -0x10(%rbp), %rax
movl 0x40(%rax), %ecx
shll %ecx
movl %ecx, 0x40(%rax)
jmp 0x146fc
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x3, %eax
jne 0x146c4
movq -0x10(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x146c4
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
cmpq $0x0, 0x38(%rax)
jne 0x146c4
movq -0x10(%rbp), %rax
movl 0x40(%rax), %ecx
shll %ecx
movl %ecx, 0x40(%rax)
jmp 0x146fa
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x3, %eax
jne 0x146f8
movq -0x10(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x146f8
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
cmpq $0x0, 0x38(%rax)
je 0x146f8
movq -0x10(%rbp), %rax
imull $0x3, 0x40(%rax), %ecx
movl %ecx, 0x40(%rax)
jmp 0x146fa
jmp 0x146fc
jmp 0x146fe
jmp 0x14700
jmp 0x14702
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: romkatv[P]action-chain/src/action_chain_test.cc
// Function: romkatv::(anonymous namespace)::ParseFlag(unsigned long*, std::basic_string_view<char, std::char_traits<char>>)
void ParseFlag(std::uint64_t* flag, std::string_view s) {
  CHECK(!s.empty());
  int shift = 0;
  switch (std::tolower(s.back())) {
    case 'k':
      shift = 10;
      break;
    case 'm':
      shift = 20;
      break;
    case 'g':
      shift = 30;
      break;
  }
  if (shift) s.remove_suffix(1);
  CHECK(std::from_chars(s.data(), s.data() + s.size(), *flag).ec == std::errc());
  CHECK(((*flag) << shift >> shift) == *flag);
  *flag <<= shift;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x9cd0
testb $0x1, %al
jne 0x51c3
jmp 0x51f3
movq 0xee06(%rip), %rax      # 0x13fd0
movq (%rax), %rdi
leaq 0x7fa6(%rip), %rsi      # 0xd17a
leaq 0x7fb0(%rip), %rdx      # 0xd18b
movl $0x45, %ecx
leaq 0x80ce(%rip), %r8       # 0xd2b5
movb $0x0, %al
callq 0x3320
callq 0x3140
jmp 0x51f5
movl $0x0, -0x1c(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x9cf0
movsbl (%rax), %edi
callq 0x3330
movl %eax, %ecx
movl %ecx, -0x34(%rbp)
subl $0x67, %eax
je 0x523f
jmp 0x5219
movl -0x34(%rbp), %eax
subl $0x6b, %eax
je 0x522d
jmp 0x5223
movl -0x34(%rbp), %eax
subl $0x6d, %eax
je 0x5236
jmp 0x5246
movl $0xa, -0x1c(%rbp)
jmp 0x5246
movl $0x14, -0x1c(%rbp)
jmp 0x5246
movl $0x1e, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x525a
leaq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x9d20
leaq -0x10(%rbp), %rdi
callq 0x9e20
movq %rax, -0x40(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x9e20
movq %rax, -0x48(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x9e40
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdi
addq %rax, %rsi
movq -0x18(%rbp), %rdx
movl $0xa, %ecx
callq 0x9d40
movq %rax, -0x30(%rbp)
movl %edx, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
sete %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x52ac
jmp 0x52dc
movq 0xed1d(%rip), %rax      # 0x13fd0
movq (%rax), %rdi
leaq 0x7ebd(%rip), %rsi      # 0xd17a
leaq 0x7ec7(%rip), %rdx      # 0xd18b
movl $0x53, %ecx
leaq 0x7ff0(%rip), %r8       # 0xd2c0
movb $0x0, %al
callq 0x3320
callq 0x3140
jmp 0x52de
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl -0x1c(%rbp), %ecx
shlq %cl, %rax
movl -0x1c(%rbp), %ecx
shrq %cl, %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
je 0x532a
movq 0xeccf(%rip), %rax      # 0x13fd0
movq (%rax), %rdi
leaq 0x7e6f(%rip), %rsi      # 0xd17a
leaq 0x7e79(%rip), %rdx      # 0xd18b
movl $0x54, %ecx
leaq 0x7fea(%rip), %r8       # 0xd308
movb $0x0, %al
callq 0x3320
callq 0x3140
jmp 0x532c
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
movq (%rax), %rdx
movl %ecx, %ecx
shlq %cl, %rdx
movq %rdx, %rcx
movq %rcx, (%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: romkatv[P]action-chain/src/action_chain_test.cc
// Function: romkatv::(anonymous namespace)::CpuTimeSec()
double CpuTimeSec() {
  auto ToSec = [](const timeval& tv) { return tv.tv_sec + 1e-6 * tv.tv_usec; };
  rusage usage = {};
  CHECK(getrusage(RUSAGE_SELF, &usage) == 0);
  return ToSec(usage.ru_utime) + ToSec(usage.ru_stime);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
leaq -0x98(%rbp), %rdi
xorl %esi, %esi
movl $0x90, %edx
callq 0x3130
xorl %edi, %edi
leaq -0x98(%rbp), %rsi
callq 0x3150
cmpl $0x0, %eax
je 0x54d1
movq 0xeb28(%rip), %rax      # 0x13fd0
movq (%rax), %rdi
leaq 0x7cc8(%rip), %rsi      # 0xd17a
leaq 0x7cd2(%rip), %rdx      # 0xd18b
movl $0x9f, %ecx
leaq 0x7eed(%rip), %r8       # 0xd3b2
movb $0x0, %al
callq 0x3320
callq 0x3140
jmp 0x54d3
leaq -0x98(%rbp), %rsi
leaq -0x1(%rbp), %rdi
callq 0x5630
movsd %xmm0, -0xa0(%rbp)
leaq -0x98(%rbp), %rsi
addq $0x10, %rsi
leaq -0x1(%rbp), %rdi
callq 0x5630
movaps %xmm0, %xmm1
movsd -0xa0(%rbp), %xmm0
addsd %xmm1, %xmm0
addq $0xa0, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: romkatv[P]action-chain/src/action_chain.h
// Function: void romkatv::ActionChain::Run<int romkatv::(anonymous namespace)::Benchmark<romkatv::ActionChain>(romkatv::(anonymous namespace)::Flags const&)::'lambda'()::operator()() const::'lambda'()>(romkatv::ActionChain::Mem*, int romkatv::(anonymous namespace)::Benchmark<romkatv::ActionChain>(romkatv::(anonymous namespace)::Flags const&)::'lambda'()::operator()() const::'lambda'()&&)
void Run(Mem* mem, F&& action) {
    assert(mem);
    if (!mem->p_) mem->p_ = ::operator new(kAllocSize);
    Work* work = Work::New(mem->p_, std::forward<F>(action));
    mem->p_ = tail_.exchange(work, std::memory_order_acq_rel)->ContinueWith(work);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5ce5
jmp 0x5d04
leaq 0x77cb(%rip), %rdi      # 0xd4b7
leaq 0x7701(%rip), %rsi      # 0xd3f4
movl $0x4f, %edx
leaq 0x77bc(%rip), %rcx      # 0xd4bb
callq 0x3170
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x5d22
movl $0x20, %edi
callq 0x3250
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x5d70
movq -0x28(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
movl $0x4, %edx
callq 0xaa10
movq %rax, %rdi
movq -0x20(%rbp), %rsi
callq 0xad00
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: romkatv[P]action-chain/src/action_chain.h
// Function: romkatv::ActionChain::Work* romkatv::ActionChain::Work::New<int romkatv::(anonymous namespace)::Benchmark<romkatv::ActionChain>(romkatv::(anonymous namespace)::Flags const&)::'lambda'()::operator()() const::'lambda'()>(void*, int romkatv::(anonymous namespace)::Benchmark<romkatv::ActionChain>(romkatv::(anonymous namespace)::Flags const&)::'lambda'()::operator()() const::'lambda'()&&)
static Work* New(void* p, F&& f) {
      // This is easy to fix with no adverse effects for the code that currently
      // compiles.
      static_assert(alignof(F) <= alignof(Work), "Sorry, not implemented");
      // This might be a bit trickier to fix without slowing down existing code.
      static_assert(sizeof(Work) + sizeof(F) <= kAllocSize);
      Work* w = new (p) Work;
      w->invoke_ = &Work::Invoke<std::decay_t<F>>;
      new (w + 1) std::decay_t<F>(std::forward<F>(f));
      return w;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0xa930
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
leaq 0x30(%rip), %rcx        # 0x5dd0
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, 0x10(%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: romkatv[P]action-chain/src/action_chain.h
// Function: void romkatv::ActionChain::Work::Invoke<int romkatv::(anonymous namespace)::Benchmark<romkatv::ActionChain>(romkatv::(anonymous namespace)::Flags const&)::'lambda'()::operator()() const::'lambda'()>(romkatv::ActionChain::Work*)
static void Invoke(Work* w) {
      assert(w != nullptr && w != Sealed());
      F& f = *reinterpret_cast<F*>(w + 1);
      std::move(f)();
      f.~F();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x8(%rbp)
movb %al, -0x11(%rbp)
je 0x5e05
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0xa9d0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x5e0e
jmp 0x5e10
jmp 0x5e2f
leaq 0x75bf(%rip), %rdi      # 0xd3d6
leaq 0x75d6(%rip), %rsi      # 0xd3f4
movl $0x94, %edx
leaq 0x76ef(%rip), %rcx      # 0xd519
callq 0x3170
movq -0x8(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5e50
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: romkatv[P]action-chain/src/action_chain.h
// Function: romkatv::ActionChain::Work::RunAll(romkatv::ActionChain::Work*)
static void RunAll(Work* w) {
      assert(w != nullptr && w != Sealed());
      w->invoke_(w);
      if (Work* next = w->next_.exchange(Sealed(), std::memory_order_acq_rel)) {
        assert(next != Sealed());
        RunAllSlow(w, next);
      }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x8(%rbp)
movb %al, -0x11(%rbp)
je 0xa7e5
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0xa9d0
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
setne %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0xa7ee
jmp 0xa7f0
jmp 0xa80f
leaq 0x2bdf(%rip), %rdi      # 0xd3d6
leaq 0x2bf6(%rip), %rsi      # 0xd3f4
movl $0x82, %edx
leaq 0x2c76(%rip), %rcx      # 0xd480
callq 0x3170
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0xa9d0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
movl $0x4, %edx
callq 0xaa10
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xa88d
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0xa9d0
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
je 0xa861
jmp 0xa880
leaq 0x2d2d(%rip), %rdi      # 0xd595
leaq 0x2b85(%rip), %rsi      # 0xd3f4
movl $0x85, %edx
leaq 0x2c05(%rip), %rcx      # 0xd480
callq 0x3170
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xc260
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: romkatv[P]action-chain/src/action_chain.h
// Function: romkatv::ActionChain::Work::ContinueWith(romkatv::ActionChain::Work*)
void* ContinueWith(Work* next) {
      assert(next != nullptr && next != Sealed());
      if (Work* w = next_.load(std::memory_order_acquire)
                        ?: next_.exchange(next, std::memory_order_acq_rel)) {
        static_cast<void>(w);
        assert(w == Sealed());
        Destroy();
        RunAll(next);
        return this;
      }
      return nullptr;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x21(%rbp)
je 0xad41
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0xa9d0
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0xad4a
jmp 0xad4c
jmp 0xad6b
leaq 0x282f(%rip), %rdi      # 0xd582
leaq 0x269a(%rip), %rsi      # 0xd3f4
movl $0x75, %edx
leaq 0x2840(%rip), %rcx      # 0xd5a6
callq 0x3170
movq -0x30(%rbp), %rdi
movl $0x2, %esi
callq 0xa8a0
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0xad8d
movq -0x40(%rbp), %rax
movq %rax, -0x48(%rbp)
jmp 0xada3
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x4, %edx
callq 0xaa10
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xae08
movq -0x20(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0xa9d0
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jne 0xadcd
jmp 0xadec
leaq 0x2809(%rip), %rdi      # 0xd5dd
leaq 0x2619(%rip), %rsi      # 0xd3f4
movl $0x79, %edx
leaq 0x27bf(%rip), %rcx      # 0xd5a6
callq 0x3170
movq -0x30(%rbp), %rdi
callq 0xae20
movq -0x18(%rbp), %rdi
callq 0xa7b0
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xae10
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)