LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/AngelPn[P]L5R-card_game/src/DeckBuilder.cpp
// Function: DeckBuilder::deckShuffler(std::__cxx11::list<GreenCard*, std::allocator<GreenCard*>>*)
void DeckBuilder::deckShuffler(list<GreenCard *> *green)
{
	vector<GreenCard *> vect;
	list<GreenCard *>::iterator it;
	for (it = green->begin(); it != green->end(); it++)
		vect.push_back((*it));

	random_shuffle(vect.begin(), vect.end());

	green->clear();

	vector<GreenCard *>::iterator it2;
	for (it2 = vect.begin(); it2 != vect.end(); it2++)
		green->push_back((*it2));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq (%rsi), %r15
cmpq %rsi, %r15
je 0x4b6e
movq %rsp, %r14
leaq 0x10(%r15), %rdx
movq 0x8(%rsp), %rsi
cmpq 0x10(%rsp), %rsi
je 0x4af9
movq (%rdx), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rsp)
jmp 0x4b01
movq %r14, %rdi
callq 0x6b62
movq (%r15), %r15
cmpq %rbx, %r15
jne 0x4adb
movq (%rsp), %r14
movq 0x8(%rsp), %r15
cmpq %r15, %r14
je 0x4b6e
leaq 0x8(%r14), %rax
cmpq %r15, %rax
je 0x4b6e
movl $0x8, %r12d
callq 0x3070
cltq
movq %r12, %rcx
sarq $0x3, %rcx
incq %rcx
cqto
idivq %rcx
leaq (,%rdx,8), %rax
cmpq %rax, %r12
je 0x4b5d
leaq (%r14,%r12), %rax
leaq (%r14,%rdx,8), %rcx
movq (%rax), %rdx
movq (%rcx), %rsi
movq %rsi, (%rax)
movq %rdx, (%rcx)
leaq (%r14,%r12), %rax
addq $0x8, %rax
addq $0x8, %r12
cmpq %r15, %rax
jne 0x4b26
movq %rbx, %rdi
callq 0x5988
movq (%rsp), %r14
cmpq 0x8(%rsp), %r14
je 0x4bb0
movl $0x18, %edi
callq 0x3170
movq (%r14), %rcx
movq %rcx, 0x10(%rax)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3040
incq 0x10(%rbx)
addq $0x8, %r14
cmpq 0x8(%rsp), %r14
jne 0x4b81
movq (%rsp), %r14
testq %r14, %r14
je 0x4bc5
movq 0x10(%rsp), %rsi
subq %r14, %rsi
movq %r14, %rdi
callq 0x3180
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x4bd3
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x4bec
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x3180
movq %rbx, %rdi
callq 0x3220
// File: /workspace/github_cpp_makefile_star2_O3/AngelPn[P]L5R-card_game/./include/Follower.hpp
// Function: Follower::Follower(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
Follower(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 FOOTSOLDIER : cost= 0; attackBonus = 2; defenseBonus = 0; minimumHonor = 1; effectBonus = 1; effectCost = 2; break;
			case ARCHER      : cost= 0; attackBonus = 0; defenseBonus = 2; minimumHonor = 1; effectBonus = 1; effectCost = 2; break;
			case SIEGER      : cost= 5; attackBonus = 3; defenseBonus = 3; minimumHonor = 2; effectBonus = 2; effectCost = 3; break;
			case CAVALRY     : cost= 3; attackBonus = 4; defenseBonus = 2; minimumHonor = 3; effectBonus = 3; effectCost = 4; break;
			case NAVAL       : cost= 3; attackBonus = 2; defenseBonus = 4; minimumHonor = 3; effectBonus = 3; effectCost = 4; break;
			case BUSHIDO     : cost= 8; attackBonus = 8; defenseBonus = 8; minimumHonor = 6; effectBonus = 3; effectCost = 8; break;
		}

	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebp
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x5b00
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x5ca8
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x5bec
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3180
leaq 0xba4d(%rip), %rax      # 0x11640
movq %rax, (%rbx)
cmpl $0x6, %ebp
jae 0x5c4e
movl %ebp, %eax
leaq 0x6a94(%rip), %rcx      # 0xc698
movl (%rcx,%rax,4), %ecx
leaq 0x6aa2(%rip), %rdx      # 0xc6b0
movl (%rdx,%rax,4), %edx
leaq 0x6ab0(%rip), %rsi      # 0xc6c8
movl (%rsi,%rax,4), %esi
leaq 0x6abe(%rip), %rdi      # 0xc6e0
movl (%rdi,%rax,4), %edi
leaq 0x6acc(%rip), %r8       # 0xc6f8
movl (%r8,%rax,4), %r8d
leaq 0x6ad9(%rip), %r9       # 0xc710
movl (%r9,%rax,4), %eax
movl %ecx, 0x28(%rbx)
movl %edx, 0x50(%rbx)
movl %esi, 0x54(%rbx)
movl %edi, 0x58(%rbx)
movl %r8d, 0x5c(%rbx)
movl %eax, 0x60(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x5c73
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3180
movq %rbx, %rdi
callq 0x3220
nop
// File: /workspace/github_cpp_makefile_star2_O3/AngelPn[P]L5R-card_game/./include/Card.hpp
// Function: GreenCard::GreenCard(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
GreenCard(std::string name, int type): Card(name){
  		std::ifstream file("CardTextes.txt"); //Open file and read it

  		if(!no_cardTextes){ //In case all card textes are used
  			no_cardTextes= 12; //Reset the number of card textes
  		}
  		int i= no_cardTextes;
  		while(i){ //Get a unique card text each time a GreenCard is created
  			getline(file, this->cardText);
  			i--;
  		}
  		no_cardTextes--;
  		file.close(); //Close the file
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rdi, %rbx
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rsp, %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x5b00
leaq 0xb8ec(%rip), %rax      # 0x115d0
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %r12
movq %r12, 0x8(%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
callq 0x5b00
movb $0x0, 0x2c(%rbx)
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x5d1c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3180
leaq 0xb865(%rip), %rax      # 0x11588
movq %rax, (%rbx)
leaq 0x30(%rbx), %r14
leaq 0x40(%rbx), %rbp
movq %rbp, 0x30(%rbx)
movq $0x0, 0x38(%rbx)
movb $0x0, 0x40(%rbx)
leaq 0x6473(%rip), %rsi      # 0xc1b8
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movl $0x8, %edx
callq 0x3240
movl 0xc3ea(%rip), %r13d     # 0x12148
testl %r13d, %r13d
jne 0x5d73
movl $0xc, 0xc3db(%rip)      # 0x12148
movl $0xc, %r13d
movq 0x20(%rsp), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0x3250
decl %r13d
jne 0x5d73
decl 0xc3a6(%rip)            # 0x12148
leaq 0x20(%rsp), %rdi
callq 0x3050
leaq 0x20(%rsp), %rdi
callq 0x3060
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5de0
movq %rax, %r15
jmp 0x5ded
movq %rax, %r15
movq (%rsp), %rdi
movq %r13, %r12
cmpq %r13, %rdi
jne 0x5e14
jmp 0x5e20
movq %rax, %r15
leaq 0x20(%rsp), %rdi
callq 0x3060
movq (%r14), %rdi
cmpq %rbp, %rdi
je 0x5e01
movq (%rbp), %rsi
incq %rsi
callq 0x3180
leaq 0xb7c8(%rip), %rax      # 0x115d0
movq %rax, (%rbx)
movq 0x8(%rbx), %rdi
cmpq %r12, %rdi
je 0x5e20
movq (%r12), %rsi
incq %rsi
callq 0x3180
movq %r15, %rdi
callq 0x3220
// File: /workspace/github_cpp_makefile_star2_O3/AngelPn[P]L5R-card_game/./include/Follower.hpp
// Function: Follower::print() const
virtual void print() const{
		std::cout<< "\033[1;32mCost: \033[0m"<< cost<< "\033[1;32m\nAttack Bonus: \033[0m"<< attackBonus<<
		"\033[1;32m\nDefense Bonus: \033[0m"<< defenseBonus<< "\033[1;32m\nMinimum Honor: \033[0m"<< minimumHonor
			<< "\033[1;32m\nEffect Bonus: \033[0m"<< effectBonus<< "\033[1;32m\nEffect Cost: \033[0m"<< effectCost<< "\n";
		GreenCard::print();
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xc19a(%rip), %r14      # 0x11fd0
leaq 0x638a(%rip), %rsi      # 0xc1c7
movl $0x11, %edx
movq %r14, %rdi
callq 0x31a0
movl 0x28(%rbx), %esi
movq %r14, %rdi
callq 0x30e0
movq %rax, %r14
leaq 0x637a(%rip), %rsi      # 0xc1d9
movl $0x1a, %edx
movq %rax, %rdi
callq 0x31a0
movl 0x50(%rbx), %esi
movq %r14, %rdi
callq 0x30e0
movq %rax, %r14
leaq 0x6373(%rip), %rsi      # 0xc1f4
movl $0x1b, %edx
movq %rax, %rdi
callq 0x31a0
movl 0x54(%rbx), %esi
movq %r14, %rdi
callq 0x30e0
movq %rax, %r14
leaq 0x636d(%rip), %rsi      # 0xc210
movl $0x1b, %edx
movq %rax, %rdi
callq 0x31a0
movl 0x58(%rbx), %esi
movq %r14, %rdi
callq 0x30e0
movq %rax, %r14
leaq 0x6367(%rip), %rsi      # 0xc22c
movl $0x1a, %edx
movq %rax, %rdi
callq 0x31a0
movl 0x5c(%rbx), %esi
movq %r14, %rdi
callq 0x30e0
movq %rax, %r14
leaq 0x6360(%rip), %rsi      # 0xc247
movl $0x19, %edx
movq %rax, %rdi
callq 0x31a0
movl 0x60(%rbx), %esi
movq %r14, %rdi
callq 0x30e0
leaq 0x635b(%rip), %rsi      # 0xc261
movl $0x1, %edx
movq %rax, %rdi
callq 0x31a0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x59c4
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebp
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x5b00
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x5ca8
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x6036
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3180
leaq 0xb78b(%rip), %rax      # 0x117c8
movq %rax, (%rbx)
cmpl $0x5, %ebp
jae 0x60a7
movl %ebp, %eax
leaq 0x66da(%rip), %rcx      # 0xc728
movl (%rcx,%rax,4), %ecx
leaq 0x66e4(%rip), %rdx      # 0xc73c
movl (%rdx,%rax,4), %edx
leaq 0x66ee(%rip), %rsi      # 0xc750
movl (%rsi,%rax,4), %esi
leaq 0x66f8(%rip), %rdi      # 0xc764
movl (%rdi,%rax,4), %edi
leaq 0x6702(%rip), %r8       # 0xc778
movl (%r8,%rax,4), %r8d
leaq 0x670b(%rip), %r9       # 0xc78c
movl (%r9,%rax,4), %r9d
leaq 0x6714(%rip), %r10      # 0xc7a0
movl (%r10,%rax,4), %eax
movl %ecx, 0x28(%rbx)
movl %edx, 0x50(%rbx)
movl %esi, 0x54(%rbx)
movl %edi, 0x58(%rbx)
movl %r8d, 0x5c(%rbx)
movl %r9d, 0x60(%rbx)
movl %eax, 0x64(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x60cc
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3180
movq %rbx, %rdi
callq 0x3220
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebp
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x5b00
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x6504
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x6440
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3180
leaq 0xb679(%rip), %rax      # 0x11ac0
movq %rax, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
cmpl $0x7, %ebp
jae 0x6472
movl %ebp, %eax
leaq 0x6371(%rip), %rcx      # 0xc7d0
movl (%rcx,%rax,4), %ecx
leaq 0x634b(%rip), %rdx      # 0xc7b4
movl (%rdx,%rax,4), %eax
movl %ecx, 0x28(%rbx)
movl %eax, 0x40(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x6497
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3180
movq %rbx, %rdi
callq 0x3220
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
testl %esi, %esi
jle 0x6db8
movl %esi, %ebp
movq 0xb296(%rip), %r14      # 0x11fd0
movq %rsp, %r13
leaq 0x20(%rsp), %r15
movl $0x14, %edx
movq %r14, %rdi
leaq 0x5a9b(%rip), %rsi      # 0xc7ec
callq 0x31a0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x30f0
movq 0xb25c(%rip), %rdi      # 0x11fe0
movq %r13, %rsi
callq 0x31b0
movl $0xc8, %edi
callq 0x3170
movq %rax, %r12
movq %rax, %rdi
movq %r13, %rsi
callq 0x7ec8
movq %r12, 0x20(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x7636
decl %ebp
jne 0x6d42
movq %rbx, %rdi
callq 0x6e26
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x6ddb
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3180
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6e00
movq %rax, %rbx
movl $0xc8, %esi
movq %r12, %rdi
callq 0x3180
jmp 0x6e03
jmp 0x6e00
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq (%rsp), %rdi
cmpq %rax, %rdi
je 0x6e1e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3180
movq %rbx, %rdi
callq 0x3220
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xb195(%rip), %r14      # 0x11fd0
leaq 0x59bf(%rip), %rsi      # 0xc801
movl $0x16, %edx
movq %r14, %rdi
callq 0x31a0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x30f0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %r15, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x30f0
movq 0x8(%rbx), %rax
cmpq (%rbx), %rax
je 0x6f7e
xorl %r13d, %r13d
leaq 0x5969(%rip), %r12      # 0xc820
movl $0x7, %edx
movq %r14, %rdi
leaq 0x5952(%rip), %rsi      # 0xc818
callq 0x31a0
movq (%rbx), %rax
movq (%rax,%r13,8), %rax
movq 0xa8(%rax), %rsi
movq 0xb0(%rax), %rdx
movq %r14, %rdi
callq 0x31a0
movq %rax, %rbp
movl $0x5, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x31a0
leaq 0x1(%r13), %r15
movq %rbp, %rdi
movl %r15d, %esi
callq 0x3200
movq %rax, %rbp
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbp, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %rbp, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x30f0
movq (%rbx), %rax
movq (%rax,%r13,8), %rdi
callq 0x82b2
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x30f0
movq 0x8(%rbx), %rax
subq (%rbx), %rax
sarq $0x3, %rax
movq %r15, %r13
cmpq %r15, %rax
ja 0x6eb7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq (%rsi), %rax
movq %rsi, %rdi
callq *(%rax)
movl %eax, %ebp
movq (%r15), %rax
movq %r15, %rdi
callq *(%rax)
cmpl $0x1, %ebp
jne 0x77f4
cmpl $0x1, %eax
jne 0x7813
leaq 0xa287(%rip), %rsi      # 0x11a68
leaq 0xa550(%rip), %rdx      # 0x11d38
movq %r15, %rdi
xorl %ecx, %ecx
callq 0x3190
jmp 0x7815
cmpl $0x2, %eax
jne 0x781a
leaq 0xa268(%rip), %rsi      # 0x11a68
leaq 0xa279(%rip), %rdx      # 0x11a80
movq %r15, %rdi
xorl %ecx, %ecx
callq 0x3190
jmp 0x781c
xorl %eax, %eax
movq %rax, (%r14)
jmp 0x7822
xorl %eax, %eax
movq %rax, (%rbx)
movq %r14, %rbx
movq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq (%rsi), %rax
movq %rsi, %rdi
callq *(%rax)
movl %eax, %ebp
movq (%r15), %rax
movq %r15, %rdi
callq *(%rax)
cmpl $0x3, %ebp
jne 0x78d6
cmpl $0x3, %eax
jne 0x78f5
leaq 0x9ce5(%rip), %rsi      # 0x115a8
leaq 0x9d36(%rip), %rdx      # 0x11600
movq %r15, %rdi
xorl %ecx, %ecx
callq 0x3190
jmp 0x78f7
cmpl $0x4, %eax
jne 0x78fc
leaq 0x9cc6(%rip), %rsi      # 0x115a8
leaq 0x9e9f(%rip), %rdx      # 0x11788
movq %r15, %rdi
xorl %ecx, %ecx
callq 0x3190
jmp 0x78fe
xorl %eax, %eax
movq %rax, (%r14)
jmp 0x7904
xorl %eax, %eax
movq %rax, (%rbx)
movq %r14, %rbx
movq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebp
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x5b00
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x6504
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x79ca
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3180
leaq 0xa347(%rip), %rax      # 0x11d18
movq %rax, (%rbx)
movb $0x0, 0x2e(%rbx)
cmpl $0x5, %ebp
jae 0x7a21
movl %ebp, %eax
leaq 0x5046(%rip), %rcx      # 0xca2c
movl (%rcx,%rax,4), %ecx
leaq 0x5050(%rip), %rdx      # 0xca40
movl (%rdx,%rax,4), %edx
leaq 0x505a(%rip), %rsi      # 0xca54
movl (%rsi,%rax,4), %esi
leaq 0x5064(%rip), %rdi      # 0xca68
movl (%rdi,%rax,4), %edi
leaq 0x506e(%rip), %r8       # 0xca7c
movl (%r8,%rax,4), %eax
movl %ecx, 0x28(%rbx)
movl %edx, 0x30(%rbx)
movl %esi, 0x34(%rbx)
movl %edi, 0x38(%rbx)
movl %eax, 0x50(%rbx)
movl $0x18, %edi
callq 0x3170
movq %rax, 0x8(%rax)
movq %rax, (%rax)
movq $0x0, 0x10(%rax)
movq %rax, 0x40(%rbx)
movl $0x18, %edi
callq 0x3170
movq %rax, 0x8(%rax)
movq %rax, (%rax)
movq $0x0, 0x10(%rax)
movq %rax, 0x48(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
jne 0x7a92
jmp 0x7a9d
movq %rax, %r14
leaq 0x9b51(%rip), %rax      # 0x115d0
movq %rax, (%rbx)
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
movq %rbx, %r15
cmpq %rbx, %rdi
je 0x7a9d
movq (%r15), %rsi
incq %rsi
callq 0x3180
movq %r14, %rdi
callq 0x3220
nop
// File: /workspace/github_cpp_makefile_star2_O3/AngelPn[P]L5R-card_game/src/Personality.cpp
// Function: Personality::~Personality()
Personality::~Personality()
{
	items->clear();
	delete items;
	followers->clear();
	delete followers;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0xa263(%rip), %rax      # 0x11d18
movq %rax, (%rdi)
movq 0x48(%rdi), %rdi
callq 0x7e50
movq 0x48(%rbx), %r14
testq %r14, %r14
je 0x7ae7
movq (%r14), %rdi
cmpq %r14, %rdi
je 0x7ae7
movq (%rdi), %r15
movl $0x18, %esi
callq 0x3180
movq %r15, %rdi
cmpq %r14, %r15
jne 0x7ad2
movl $0x18, %esi
movq %r14, %rdi
callq 0x3180
movq 0x40(%rbx), %rdi
callq 0x7e8c
movq 0x40(%rbx), %r14
testq %r14, %r14
je 0x7b23
movq (%r14), %rdi
cmpq %r14, %rdi
je 0x7b23
movq (%rdi), %r15
movl $0x18, %esi
callq 0x3180
movq %r15, %rdi
cmpq %r14, %r15
jne 0x7b0e
movl $0x18, %esi
movq %r14, %rdi
callq 0x3180
leaq 0x9a99(%rip), %rax      # 0x115d0
movq %rax, (%rbx)
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0x7b57
movq (%rbx), %rsi
incq %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x3180
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq 0x48(%rdi), %rax
movq (%rax), %r14
cmpq %rax, %r14
je 0x7c1f
movq %rdi, %rbx
movq 0x10(%r14), %rcx
decl 0x64(%rcx)
jne 0x7c17
decq 0x10(%rax)
movq %r14, %rdi
callq 0x31f0
movl $0x18, %esi
movq %r14, %rdi
callq 0x3180
movq 0x48(%rbx), %rax
movq (%r14), %r14
cmpq %rax, %r14
jne 0x7bf1
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xa338(%rip), %r14      # 0x11fd0
leaq 0x47ce(%rip), %rsi      # 0xc46d
movl $0x11, %edx
movq %r14, %rdi
callq 0x31a0
movl 0x28(%rbx), %esi
movq %r14, %rdi
callq 0x30e0
movq %rax, %r14
leaq 0x4cd6(%rip), %rsi      # 0xc997
movl $0x14, %edx
movq %rax, %rdi
callq 0x31a0
movl 0x30(%rbx), %esi
movq %r14, %rdi
callq 0x30e0
movq %rax, %r14
leaq 0x4cc9(%rip), %rsi      # 0xc9ac
movl $0x15, %edx
movq %rax, %rdi
callq 0x31a0
movl 0x34(%rbx), %esi
movq %r14, %rdi
callq 0x30e0
movq %rax, %r14
leaq 0x4cbd(%rip), %rsi      # 0xc9c2
movl $0x14, %edx
movq %rax, %rdi
callq 0x31a0
movl 0x38(%rbx), %esi
movq %r14, %rdi
callq 0x30e0
movq %rax, %r14
leaq 0x4cb0(%rip), %rsi      # 0xc9d7
movl $0x23, %edx
movq %rax, %rdi
callq 0x31a0
movq 0x40(%rbx), %rax
movq 0x48(%rbx), %rcx
movq 0x10(%rcx), %rsi
addq 0x10(%rax), %rsi
movq %r14, %rdi
callq 0x30e0
movq %rax, %r14
leaq 0x4ca5(%rip), %rsi      # 0xc9fb
movl $0x1e, %edx
movq %rax, %rdi
callq 0x31a0
movl 0x50(%rbx), %esi
movq %r14, %rdi
callq 0x30e0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x30f0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x66a0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorl %ebp, %ebp
leaq 0x10(%rsp), %r15
movq %rbp, (%r15)
leaq 0x8(%rsp), %r12
movq %rbp, (%r12)
leaq 0x7(%rsp), %r13
movq %r13, %rdi
callq 0x77ac
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x7890
cmpq %rbp, (%r15)
je 0x7e1b
movq 0x40(%rbx), %rbx
movl $0x18, %edi
callq 0x3170
movq 0x10(%rsp), %rcx
jmp 0x7e2e
movq 0x48(%rbx), %rbx
movl $0x18, %edi
callq 0x3170
movq 0x8(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3040
incq 0x10(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x594c
movq 0x18(%rbx), %r14
testq %r14, %r14
je 0x81b5
movq (%r14), %rdi
cmpq %r14, %rdi
je 0x81b5
movq (%rdi), %r15
movl $0x18, %esi
callq 0x3180
movq %r15, %rdi
cmpq %r14, %r15
jne 0x81a0
movl $0x18, %esi
movq %r14, %rdi
callq 0x3180
movq 0x10(%rbx), %rdi
callq 0x5988
movq 0x10(%rbx), %r14
testq %r14, %r14
je 0x81f1
movq (%r14), %rdi
cmpq %r14, %rdi
je 0x81f1
movq (%rdi), %r15
movl $0x18, %esi
callq 0x3180
movq %r15, %rdi
cmpq %r14, %r15
jne 0x81dc
movl $0x18, %esi
movq %r14, %rdi
callq 0x3180
movq 0x38(%rbx), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x8210
movq (%rdi), %rax
callq *0x18(%rax)
movq 0xa8(%rbx), %rdi
leaq 0xb8(%rbx), %rax
cmpq %rax, %rdi
je 0x822e
movq (%rax), %rsi
incq %rsi
callq 0x3180
movq 0x88(%rbx), %rdi
testq %rdi, %rdi
je 0x8249
movq 0x98(%rbx), %rsi
subq %rdi, %rsi
callq 0x3180
movq 0x68(%rbx), %rdi
testq %rdi, %rdi
je 0x825e
movq 0x78(%rbx), %rsi
subq %rdi, %rsi
callq 0x3180
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x8273
movq 0x60(%rbx), %rsi
subq %rdi, %rsi
callq 0x3180
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x8288
movq 0x48(%rbx), %rsi
subq %rdi, %rsi
callq 0x3180
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x829d
movq 0x30(%rbx), %rsi
subq %rdi, %rsi
callq 0x3180
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x35f8
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x9bff(%rip), %r14      # 0x11fd0
leaq 0x449b(%rip), %rsi      # 0xc873
movl $0x8, %edx
movq %r14, %rdi
callq 0x31a0
movq 0xa8(%rbx), %rsi
movq 0xb0(%rbx), %rdx
movq %r14, %rdi
callq 0x31a0
movq %rax, %r15
leaq 0x4477(%rip), %rsi      # 0xc87c
movl $0xc, %edx
movq %rax, %rdi
callq 0x31a0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %r15, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x30f0
leaq 0x469d(%rip), %rsi      # 0xcadd
movl $0x12, %edx
movq %r14, %rdi
callq 0x31a0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x30f0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x30f0
movq %rbx, %rdi
callq 0x84cc
movq %rbx, %rdi
callq 0x85a8
movq %rbx, %rdi
callq 0x8664
movq %rbx, %rdi
callq 0x86f2
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x87f4
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x98c9(%rip), %r14      # 0x11fd0
leaq 0x441a(%rip), %rsi      # 0xcb28
movl $0x19, %edx
movq %r14, %rdi
callq 0x31a0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x30f0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x30f0
movq 0x20(%rbx), %r13
cmpq 0x28(%rbx), %r13
je 0x87e5
movl $0x1, %esi
movq 0x984e(%rip), %r14      # 0x11fd0
leaq 0x4ee5(%rip), %r15      # 0xd66e
leal 0x1(%rsi), %ebp
movq %r14, %rdi
callq 0x3200
movq %rax, %r12
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x31a0
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %r12, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x30f0
movq (%r13), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r13
movl %ebp, %esi
cmpq 0x28(%rbx), %r13
jne 0x8789
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x97c7(%rip), %r14      # 0x11fd0
leaq 0x4332(%rip), %rsi      # 0xcb42
movl $0x15, %edx
movq %r14, %rdi
callq 0x31a0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x30f0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %r15, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x30f0
movq 0x88(%rbx), %r12
cmpq 0x90(%rbx), %r12
je 0x895d
movl $0x1, %ebp
leaq 0x4de0(%rip), %r15      # 0xd66e
movq %r14, %rdi
movl %ebp, %esi
callq 0x3200
movq %rax, %r13
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x31a0
movq (%r13), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %r13, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x30f0
movq (%r12), %rdi
cmpb $0x1, 0x2d(%rdi)
jne 0x88e5
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x894a
movl $0xd, %edx
movq %r14, %rdi
leaq 0x4264(%rip), %rsi      # 0xcb58
callq 0x31a0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x30f0
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %r13, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x30f0
addq $0x8, %r12
incl %ebp
cmpq 0x90(%rbx), %r12
jne 0x888e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8de7(%rip), %r14      # 0x11fd0
leaq 0x3c94(%rip), %rsi      # 0xce84
movl $0x10, %edx
movq %r14, %rdi
callq 0x31a0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x30f0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x30f0
movq 0x50(%rbx), %r13
cmpq 0x58(%rbx), %r13
je 0x92c7
movl $0x1, %esi
movq 0x8d6c(%rip), %r14      # 0x11fd0
leaq 0x4403(%rip), %r15      # 0xd66e
leal 0x1(%rsi), %ebp
movq %r14, %rdi
callq 0x3200
movq %rax, %r12
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x31a0
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %r12, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x30f0
movq (%r13), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r13
movl %ebp, %esi
cmpq 0x58(%rbx), %r13
jne 0x926b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x7711(%rip), %r14      # 0x11fd0
leaq 0x2afa(%rip), %rsi      # 0xd3c0
movl $0x14, %edx
movq %r14, %rdi
callq 0x31a0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x30f0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x30f0
movq 0x38(%rbx), %r13
cmpq 0x40(%rbx), %r13
je 0xa99d
movl $0x1, %esi
movq 0x7696(%rip), %r14      # 0x11fd0
leaq 0x2d2d(%rip), %r15      # 0xd66e
leal 0x1(%rsi), %ebp
movq %r14, %rdi
callq 0x3200
movq %rax, %r12
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x31a0
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %r12, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x30f0
movq (%r13), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r13
movl %ebp, %esi
cmpq 0x40(%rbx), %r13
jne 0xa941
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorl %eax, %eax
leaq 0x18(%rsp), %r15
movq %rax, (%r15)
leaq 0x10(%rsp), %r12
movq %rax, (%r12)
leaq 0xf(%rsp), %r13
movq %r13, %rdi
callq 0x77ac
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x77ae
movq (%r15), %rax
testq %rax, %rax
je 0xaf4e
movq 0x58(%rbx), %rsi
cmpq 0x60(%rbx), %rsi
je 0xaf74
movq %rax, (%rsi)
addq $0x8, 0x58(%rbx)
jmp 0xaf98
movq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0xafa6
movq 0x40(%rbx), %rsi
cmpq 0x48(%rbx), %rsi
je 0xaf87
movq 0x10(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x40(%rbx)
jmp 0xaf98
addq $0x50, %rbx
leaq 0x18(%rsp), %rdx
movq %rbx, %rdi
callq 0xbde0
jmp 0xaf98
addq $0x38, %rbx
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0xbd04
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x6c4b(%rip), %r14      # 0x11fd0
leaq 0x14e7(%rip), %rsi      # 0xc873
movl $0x8, %edx
movq %r14, %rdi
callq 0x31a0
movq 0xa8(%rbx), %rsi
movq 0xb0(%rbx), %rdx
movq %r14, %rdi
callq 0x31a0
movq %rax, %r15
leaq 0x14c3(%rip), %rsi      # 0xc87c
movl $0xc, %edx
movq %rax, %rdi
callq 0x31a0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %r15, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x30f0
leaq 0x222a(%rip), %rsi      # 0xd61e
movl $0x10, %edx
movq %r14, %rdi
callq 0x31a0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x30f0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x3160
movsbl %al, %esi
movq %r14, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x30f0
movq %rbx, %rdi
callq 0xb488
movq %rbx, %rdi
callq 0x82b2
movq %rbx, %rdi
callq 0x86f2
movq %rbx, %rdi
callq 0x87f4
movq %rbx, %rdi
callq 0xa8aa
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0xa7f8
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x1, %eax
jne 0xb8b9
cmpq $0x0, 0x30(%rbx)
je 0xb8b9
addl $0x2, 0x40(%rbx)
jmp 0xb966
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
cmpl $0x2, %eax
jne 0xb8de
cmpq $0x0, 0x38(%rbx)
je 0xb8de
cmpq $0x0, 0x30(%rbx)
jne 0xb8de
addl $0x4, 0x40(%rbx)
jmp 0xb966
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
cmpl $0x2, %eax
jne 0xb900
cmpq $0x0, 0x38(%rbx)
jne 0xb900
cmpq $0x0, 0x30(%rbx)
je 0xb900
addl $0x5, 0x40(%rbx)
jmp 0xb966
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
cmpl $0x2, %eax
jne 0xb921
cmpq $0x0, 0x38(%rbx)
je 0xb921
cmpq $0x0, 0x30(%rbx)
je 0xb921
shll 0x40(%rbx)
jmp 0xb966
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
cmpl $0x3, %eax
jne 0xb93f
movq 0x38(%rbx), %rax
testq %rax, %rax
je 0xb93f
cmpq $0x0, 0x38(%rax)
je 0xb91c
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
cmpl $0x3, %eax
jne 0xb966
movq 0x38(%rbx), %rax
testq %rax, %rax
je 0xb966
cmpq $0x0, 0x38(%rax)
je 0xb966
movl 0x40(%rbx), %eax
leal (%rax,%rax,2), %eax
movl %eax, 0x40(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/romkatv[P]action-chain/src/action_chain_test.cc
// Function: ZZN7romkatv12_GLOBAL__N_110ParseFlagsEPKPKcS4_ENK3$_0clImEEbS2_PT_
Flags ParseFlags(const char* const* begin, const char* const* end) {
  auto Match = [&](const char* name, auto* flag) -> bool {
    if (std::strncmp(*begin + 2, name, std::strlen(name))) return false;
    const char* val = *begin + 2 + std::strlen(name);
    if (*val == '\0') {
      ++begin;
      CHECK(begin != end);
      val = *begin;
    } else if (*val == '=') {
      ++val;
    } else {
      return false;
    }
    ParseFlag(flag, val);
    return true;
  };
  Flags res;
  for (; begin != end; ++begin) {
    CHECK(!std::strncmp(*begin, "--", 2));
    CHECK(Match("sync", &res.sync) || Match("actions", &res.actions) ||
          Match("threads", &res.threads) || Match("ops-per-action", &res.ops_per_action));
  }
  if (!res.actions) {
    res.actions = (128 / (res.ops_per_action / 32 + 1)) << 20;
  }

  return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, (%rsp)
movq %rsi, %r13
movq %rdi, %r15
movq (%rdi), %rbp
movq (%rbp), %rbx
movq (%rbx), %r14
addq $0x2, %r14
movq %rsi, %rdi
callq 0x2090
movq %rax, %r12
movq %r14, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x20b0
testl %eax, %eax
je 0x4525
xorl %eax, %eax
jmp 0x45e2
movq (%rsp), %r13
movzbl (%r14,%r12), %eax
cmpl $0x3d, %eax
je 0x4557
testl %eax, %eax
jne 0x451e
addq $0x8, %rbx
movq %rbx, (%rbp)
movq (%r15), %rax
movq 0x8(%r15), %rcx
movq (%rax), %rax
cmpq (%rcx), %rax
je 0x4600
movq (%rax), %r14
jmp 0x455d
addq %r12, %r14
incq %r14
movq %r14, %rdi
callq 0x2090
testq %rax, %rax
je 0x45f1
movq %rax, %r15
movsbl -0x1(%r14,%rax), %edi
callq 0x2230
cmpl $0x67, %eax
je 0x459b
cmpl $0x6b, %eax
je 0x4593
cmpl $0x6d, %eax
jne 0x45a6
movl $0x14, %r12d
jmp 0x45a1
movl $0xa, %r12d
jmp 0x45a1
movl $0x1e, %r12d
decq %r15
jmp 0x45a9
xorl %r12d, %r12d
addq %r14, %r15
movq %r14, %rdi
movq %r15, %rsi
movq %r13, %rbx
movq %r13, %rdx
movl $0xa, %ecx
callq 0x4e9e
testl %edx, %edx
jne 0x45f6
movq (%rbx), %rdx
movq %rdx, %rax
movl %r12d, %ecx
shlq %cl, %rax
movq %rax, %rsi
shrq %cl, %rsi
cmpq %rdx, %rsi
jne 0x45fb
movq %rax, (%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x24c0
callq 0x2462
callq 0x2491
callq 0x24ef
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
subq $0x90, %rsp
movq %rsp, %rbx
movl $0x90, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x20d0
xorl %edi, %edi
movq %rbx, %rsi
callq 0x20f0
testl %eax, %eax
jne 0x4670
cvtsi2sdq (%rsp), %xmm0
cvtsi2sdq 0x8(%rsp), %xmm1
movsd 0x19ce(%rip), %xmm2     # 0x6010
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
cvtsi2sdq 0x10(%rsp), %xmm3
xorps %xmm0, %xmm0
cvtsi2sdq 0x18(%rsp), %xmm0
mulsd %xmm2, %xmm0
addsd %xmm3, %xmm0
addsd %xmm1, %xmm0
addq $0x90, %rsp
popq %rbx
retq
callq 0x251e
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rax
testq $-0x9, %rdi
je 0x47dd
movq 0x10(%rdi), %rax
cmpq $0x0, 0x28(%rax)
je 0x47db
movq 0x18(%rdi), %rcx
xorl %edx, %edx
incq (%rcx)
incq %rdx
cmpq 0x28(%rax), %rdx
jne 0x47cf
popq %rax
retq
leaq 0x1aef(%rip), %rdi      # 0x62d3
leaq 0x1b06(%rip), %rsi      # 0x62f1
leaq 0x1bc2(%rip), %rcx      # 0x63b4
movl $0x94, %edx
callq 0x2100
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
testq $-0x9, %rdi
je 0x5166
movq %rdi, %rbx
callq *0x8(%rdi)
movl $0x8, %esi
xchgq %rsi, (%rbx)
testq %rsi, %rsi
je 0x5164
cmpq $0x8, %rsi
je 0x5185
movq %rbx, %rdi
popq %rbx
jmp 0x5354
popq %rbx
retq
leaq 0x1166(%rip), %rdi      # 0x62d3
leaq 0x117d(%rip), %rsi      # 0x62f1
leaq 0x1202(%rip), %rcx      # 0x637d
movl $0x82, %edx
callq 0x2100
leaq 0x12a4(%rip), %rdi      # 0x6430
leaq 0x115e(%rip), %rsi      # 0x62f1
leaq 0x11e3(%rip), %rcx      # 0x637d
movl $0x85, %edx
callq 0x2100
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
testq $-0x9, %rsi
je 0x520d
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
jne 0x51ee
movq %rsi, %rax
xchgq %rax, (%rbx)
testq %rax, %rax
je 0x5209
cmpq $0x8, %rax
jne 0x522c
movq (%rbx), %rax
testq %rax, %rax
je 0x524b
movq %rsi, %rdi
callq 0x5138
movq %rbx, %rax
popq %rbx
retq
xorl %ebx, %ebx
jmp 0x5204
leaq 0x1209(%rip), %rdi      # 0x641d
leaq 0x10d6(%rip), %rsi      # 0x62f1
leaq 0x121f(%rip), %rcx      # 0x6441
movl $0x75, %edx
callq 0x2100
leaq 0x1245(%rip), %rdi      # 0x6478
leaq 0x10b7(%rip), %rsi      # 0x62f1
leaq 0x1200(%rip), %rcx      # 0x6441
movl $0x79, %edx
callq 0x2100
leaq 0x1234(%rip), %rdi      # 0x6486
leaq 0x1098(%rip), %rsi      # 0x62f1
leaq 0x1257(%rip), %rcx      # 0x64b7
movl $0x6e, %edx
callq 0x2100