LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x20, %rsp
movl %edx, %ebp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x3200
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x4f14
movq %rsp, %rdi
callq 0x30c0
leaq 0xb7c8(%rip), %rax      # 0x10640
movq %rax, (%rbx)
cmpl $0x6, %ebp
jae 0x4ed3
movl %ebp, %eax
leaq 0x580f(%rip), %rcx      # 0xa698
movl (%rcx,%rax,4), %ecx
leaq 0x581d(%rip), %rdx      # 0xa6b0
movl (%rdx,%rax,4), %edx
leaq 0x582b(%rip), %rsi      # 0xa6c8
movl (%rsi,%rax,4), %esi
leaq 0x5839(%rip), %rdi      # 0xa6e0
movl (%rdi,%rax,4), %edi
leaq 0x5847(%rip), %r8       # 0xa6f8
movl (%r8,%rax,4), %r8d
leaq 0x5854(%rip), %r9       # 0xa710
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 $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x30c0
movq %rbx, %rdi
callq 0x3260
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x3200
movq %rbx, %rdi
movq %r14, %rsi
callq 0x50c0
movq %rsp, %rdi
callq 0x30c0
leaq 0xb63f(%rip), %rax      # 0x10588
movq %rax, (%rbx)
leaq 0x30(%rbx), %r14
leaq 0x40(%rbx), %rax
movq %rax, 0x30(%rbx)
andq $0x0, 0x38(%rbx)
movb $0x0, 0x40(%rbx)
leaq 0x5250(%rip), %rsi      # 0xa1b8
leaq 0x20(%rsp), %rdi
pushq $0x8
popq %rdx
callq 0x3280
movl 0xc1e5(%rip), %ebp      # 0x11160
testl %ebp, %ebp
jne 0x4f8c
movl $0xc, 0xc1d7(%rip)      # 0x11160
pushq $0xc
popq %rbp
leaq 0x20(%rsp), %r15
subl $0x1, %ebp
jb 0x4fa3
movq %r15, %rdi
movq %r14, %rsi
callq 0x3040
jmp 0x4f91
decl 0xc1b7(%rip)            # 0x11160
leaq 0x20(%rsp), %rdi
callq 0x3050
leaq 0x20(%rsp), %rdi
callq 0x3060
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4fdf
movq %rax, %r15
jmp 0x4fec
movq %rax, %r15
movq %rsp, %rdi
callq 0x30c0
jmp 0x4ffc
movq %rax, %r15
leaq 0x20(%rsp), %rdi
callq 0x3060
movq %r14, %rdi
callq 0x30c0
movq %rbx, %rdi
callq 0x57e0
movq %r15, %rdi
callq 0x3260
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
movq 0xbfc1(%rip), %rdi      # 0x10fd0
leaq 0x51b1(%rip), %rsi      # 0xa1c7
callq 0x31a0
movl 0x28(%rbx), %esi
movq %rax, %rdi
callq 0x3120
leaq 0x51ac(%rip), %rsi      # 0xa1d9
movq %rax, %rdi
callq 0x31a0
movl 0x50(%rbx), %esi
movq %rax, %rdi
callq 0x3120
leaq 0x51ad(%rip), %rsi      # 0xa1f4
movq %rax, %rdi
callq 0x31a0
movl 0x54(%rbx), %esi
movq %rax, %rdi
callq 0x3120
leaq 0x51af(%rip), %rsi      # 0xa210
movq %rax, %rdi
callq 0x31a0
movl 0x58(%rbx), %esi
movq %rax, %rdi
callq 0x3120
leaq 0x51b1(%rip), %rsi      # 0xa22c
movq %rax, %rdi
callq 0x31a0
movl 0x5c(%rbx), %esi
movq %rax, %rdi
callq 0x3120
leaq 0x51b2(%rip), %rsi      # 0xa247
movq %rax, %rdi
callq 0x31a0
movl 0x60(%rbx), %esi
movq %rax, %rdi
callq 0x3120
leaq 0x51b2(%rip), %rsi      # 0xa261
movq %rax, %rdi
callq 0x31a0
movq %rbx, %rdi
popq %rbx
jmp 0x4d58
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x20, %rsp
movl %edx, %ebp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x3200
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x4f14
movq %rsp, %rdi
callq 0x30c0
leaq 0xb616(%rip), %rax      # 0x107c8
movq %rax, (%rbx)
cmpl $0x5, %ebp
jae 0x521c
movl %ebp, %eax
leaq 0x5565(%rip), %rcx      # 0xa728
movl (%rcx,%rax,4), %ecx
leaq 0x556f(%rip), %rdx      # 0xa73c
movl (%rdx,%rax,4), %edx
leaq 0x5579(%rip), %rsi      # 0xa750
movl (%rsi,%rax,4), %esi
leaq 0x5583(%rip), %rdi      # 0xa764
movl (%rdi,%rax,4), %edi
leaq 0x558d(%rip), %r8       # 0xa778
movl (%r8,%rax,4), %r8d
leaq 0x5596(%rip), %r9       # 0xa78c
movl (%r9,%rax,4), %r9d
leaq 0x559f(%rip), %r10      # 0xa7a0
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 $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x30c0
movq %rbx, %rdi
callq 0x3260
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x20, %rsp
movl %edx, %ebp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x3200
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x557a
movq %rsp, %rdi
callq 0x30c0
leaq 0xb5cc(%rip), %rax      # 0x10ac0
movq %rax, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
cmpl $0x7, %ebp
jae 0x551f
movl %ebp, %eax
leaq 0x52c4(%rip), %rcx      # 0xa7d0
movl (%rcx,%rax,4), %ecx
leaq 0x529e(%rip), %rdx      # 0xa7b4
movl (%rdx,%rax,4), %eax
movl %ecx, 0x28(%rbx)
movl %eax, 0x40(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x30c0
movq %rbx, %rdi
callq 0x3260
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xb045(%rip), %r14      # 0x10fd0
leaq 0x486f(%rip), %rsi      # 0xa801
movq %r14, %rdi
callq 0x31a0
movq %rax, %rdi
callq 0x30d0
movq %rax, %rdi
callq 0x30d0
xorl %r13d, %r13d
movl $0xa8, %ebp
leaq 0x4867(%rip), %r12      # 0xa820
movq 0x8(%rbx), %rax
subq (%rbx), %rax
sarq $0x3, %rax
cmpq %r13, %rax
jbe 0x6025
movq %r14, %rdi
leaq 0x4845(%rip), %rsi      # 0xa818
callq 0x31a0
movq (%rbx), %rcx
movq (%rcx,%r13,8), %rsi
addq %rbp, %rsi
movq %rax, %rdi
callq 0x3170
movq %rax, %rdi
movq %r12, %rsi
callq 0x31a0
leaq 0x1(%r13), %r15
movq %rax, %rdi
movl %r15d, %esi
callq 0x3240
movq %rax, %rdi
callq 0x30d0
movq (%rbx), %rax
movq (%rax,%r13,8), %rdi
callq 0x6fa6
movq %r14, %rdi
callq 0x30d0
movq %r15, %r13
jmp 0x5fb9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
xorl %r15d, %r15d
xorl %ebp, %ebp
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r14, %rcx
jbe 0x6075
movq (%rax,%r14,8), %rdi
callq 0x6f9e
xorl %ecx, %ecx
testl %eax, %eax
setne %cl
cmovnel %r14d, %ebp
addl %ecx, %r15d
incq %r14
jmp 0x6046
cmpl $0x1, %r15d
pushq $-0x1
popq %rax
cmovel %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq (%rsi), %rax
movq %rsi, %rdi
callq *(%rax)
movq %r15, %rsi
cmpl $0x1, %eax
jne 0x660e
callq 0x6624
movq %rax, (%r14)
jmp 0x6619
callq 0x6652
movq %rax, (%rbx)
movq %r14, %rbx
andq $0x0, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq (%rsi), %rax
movq %rsi, %rdi
callq *(%rax)
movq %r15, %rsi
cmpl $0x3, %eax
jne 0x66a8
callq 0x66be
movq %rax, (%r14)
jmp 0x66b3
callq 0x66ec
movq %rax, (%rbx)
movq %r14, %rbx
andq $0x0, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x20, %rsp
movl %edx, %ebp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x3200
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x557a
movq %rsp, %rdi
callq 0x30c0
leaq 0xa5c8(%rip), %rax      # 0x10d18
movq %rax, (%rbx)
movb $0x0, 0x2e(%rbx)
cmpl $0x5, %ebp
jae 0x67a0
movl %ebp, %eax
leaq 0x42c7(%rip), %rcx      # 0xaa2c
movl (%rcx,%rax,4), %ecx
leaq 0x42d1(%rip), %rdx      # 0xaa40
movl (%rdx,%rax,4), %edx
leaq 0x42db(%rip), %rsi      # 0xaa54
movl (%rsi,%rax,4), %esi
leaq 0x42e5(%rip), %rdi      # 0xaa68
movl (%rdi,%rax,4), %edi
leaq 0x42ef(%rip), %r8       # 0xaa7c
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)
pushq $0x18
popq %rdi
callq 0x31b0
movq %rax, 0x8(%rax)
movq %rax, (%rax)
andq $0x0, 0x10(%rax)
movq %rax, 0x40(%rbx)
pushq $0x18
popq %rdi
callq 0x31b0
movq %rax, 0x8(%rax)
movq %rax, (%rax)
andq $0x0, 0x10(%rax)
movq %rax, 0x48(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rsp, %rdi
callq 0x30c0
jmp 0x67f1
movq %rax, %r14
movq %rbx, %rdi
callq 0x57e0
movq %r14, %rdi
callq 0x3260
nop
// File: /workspace/github_cpp_makefile_star2_O2/AngelPn[P]L5R-card_game/src/Personality.cpp
// Function: Personality::~Personality()
Personality::~Personality()
{
	items->clear();
	delete items;
	followers->clear();
	delete followers;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xa510(%rip), %rax      # 0x10d18
movq %rax, (%rdi)
movq 0x48(%rdi), %rdi
callq 0x6a8a
movq 0x48(%rbx), %r14
testq %r14, %r14
je 0x6825
movq %r14, %rdi
callq 0x6ae8
pushq $0x18
popq %rsi
movq %r14, %rdi
callq 0x31c0
movq 0x40(%rbx), %rdi
callq 0x6aa2
movq 0x40(%rbx), %r14
testq %r14, %r14
je 0x684a
movq %r14, %rdi
callq 0x6b12
pushq $0x18
popq %rsi
movq %r14, %rdi
callq 0x31c0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x57e0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rdi, %rbx
movq 0x48(%rdi), %rdi
movq %rdi, %r14
movq (%r14), %r14
cmpq %rdi, %r14
je 0x68f7
movq 0x10(%r14), %rax
decl 0x64(%rax)
jne 0x68d8
movq %r14, %rsi
callq 0x6ac2
movq 0x48(%rbx), %rdi
jmp 0x68d8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
movq 0xa689(%rip), %rdi      # 0x10fd0
leaq 0x3b1f(%rip), %rsi      # 0xa46d
callq 0x31a0
movl 0x28(%rbx), %esi
movq %rax, %rdi
callq 0x3120
leaq 0x4032(%rip), %rsi      # 0xa997
movq %rax, %rdi
callq 0x31a0
movl 0x30(%rbx), %esi
movq %rax, %rdi
callq 0x3120
leaq 0x402d(%rip), %rsi      # 0xa9ac
movq %rax, %rdi
callq 0x31a0
movl 0x34(%rbx), %esi
movq %rax, %rdi
callq 0x3120
leaq 0x4029(%rip), %rsi      # 0xa9c2
movq %rax, %rdi
callq 0x31a0
movl 0x38(%rbx), %esi
movq %rax, %rdi
callq 0x3120
leaq 0x4024(%rip), %rsi      # 0xa9d7
movq %rax, %rdi
callq 0x31a0
movq 0x40(%rbx), %rcx
movq 0x48(%rbx), %rdx
movq 0x10(%rdx), %rsi
addq 0x10(%rcx), %rsi
movq %rax, %rdi
callq 0x3120
leaq 0x4021(%rip), %rsi      # 0xa9fb
movq %rax, %rdi
callq 0x31a0
movl 0x50(%rbx), %esi
movq %rax, %rdi
callq 0x3120
movq %rax, %rdi
callq 0x30d0
movq %rbx, %rdi
popq %rbx
jmp 0x5662
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
andq $0x0, (%r15)
leaq 0x10(%rsp), %r12
andq $0x0, (%r12)
leaq 0xf(%rsp), %r13
movq %r13, %rdi
callq 0x65e4
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x6680
xorl %eax, %eax
cmpq %rax, (%r15)
je 0x6a6d
movq 0x40(%rbx), %rdi
leaq 0x18(%rsp), %rsi
callq 0x6adc
jmp 0x6a7b
movq 0x48(%rbx), %rdi
leaq 0x10(%rsp), %rsi
callq 0x6ad0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x4c94
movq 0x18(%rbx), %r14
testq %r14, %r14
je 0x6f0d
movq %r14, %rdi
callq 0x4df0
pushq $0x18
popq %rsi
movq %r14, %rdi
callq 0x31c0
movq 0x10(%rbx), %rdi
callq 0x4d34
movq 0x10(%rbx), %r14
testq %r14, %r14
je 0x6f32
movq %r14, %rdi
callq 0x4e1a
pushq $0x18
popq %rsi
movq %r14, %rdi
callq 0x31c0
leaq 0x38(%rbx), %r14
movq 0x38(%rbx), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x6f53
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0xa8(%rbx), %rdi
callq 0x30c0
leaq 0x88(%rbx), %rdi
callq 0x5a90
leaq 0x68(%rbx), %rdi
callq 0x9228
leaq 0x50(%rbx), %rdi
callq 0x91f4
movq %r14, %rdi
callq 0x91c0
leaq 0x20(%rbx), %rdi
callq 0x5c6e
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3570
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x9f80(%rip), %r14      # 0x10fd0
leaq 0x381c(%rip), %rsi      # 0xa873
movq %r14, %rdi
callq 0x31a0
leaq 0xa8(%rbx), %rsi
movq %rax, %rdi
callq 0x3170
leaq 0x3807(%rip), %rsi      # 0xa87c
movq %rax, %rdi
callq 0x31a0
movq %rax, %rdi
callq 0x30d0
leaq 0x3a51(%rip), %rsi      # 0xaadd
movq %r14, %rdi
callq 0x31a0
movq %rax, %rdi
callq 0x30d0
movq %rax, %rdi
callq 0x30d0
movq %rbx, %rdi
callq 0x70d4
movq %rbx, %rdi
callq 0x7168
movq %rbx, %rdi
callq 0x71ae
movq %rbx, %rdi
callq 0x71f4
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7272
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rax
movq 0x20(%rdi), %rax
movq 0x28(%rdi), %rcx
cmpq %rcx, %rax
je 0x70ef
movq (%rax), %rdx
movb $0x0, 0x2c(%rdx)
addq $0x8, %rax
jmp 0x70dd
movq 0x38(%rdi), %rax
movq 0x40(%rdi), %rcx
cmpq %rcx, %rax
je 0x7109
movq (%rax), %rdx
movb $0x0, 0x2c(%rdx)
addq $0x8, %rax
jmp 0x70f7
movq 0x50(%rdi), %rax
movq 0x58(%rdi), %rcx
cmpq %rcx, %rax
je 0x7123
movq (%rax), %rdx
movb $0x0, 0x2c(%rdx)
addq $0x8, %rax
jmp 0x7111
movq 0x88(%rdi), %rax
movq 0x90(%rdi), %rcx
cmpq %rcx, %rax
je 0x7143
movq (%rax), %rdx
movb $0x0, 0x2c(%rdx)
addq $0x8, %rax
jmp 0x7131
movq 0x9e86(%rip), %rdi      # 0x10fd0
leaq 0x399f(%rip), %rsi      # 0xaaf0
callq 0x31a0
movq %rax, %rdi
callq 0x30d0
movq %rax, %rdi
popq %rax
jmp 0x30d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
movq %rdi, %rbx
movq 0x9dca(%rip), %r14      # 0x10fd0
leaq 0x391b(%rip), %rsi      # 0xab28
movq %r14, %rdi
callq 0x31a0
movq %rax, %rdi
callq 0x30d0
movq %rax, %rdi
callq 0x30d0
movq 0x20(%rbx), %r12
pushq $0x1
popq %rsi
leaq 0x443b(%rip), %r15      # 0xb66e
cmpq 0x28(%rbx), %r12
je 0x7269
leal 0x1(%rsi), %ebp
movq %r14, %rdi
callq 0x3240
movq %rax, %rdi
movq %r15, %rsi
callq 0x31a0
movq %rax, %rdi
callq 0x30d0
movq (%r12), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r12
movl %ebp, %esi
jmp 0x7233
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x9d49(%rip), %r14      # 0x10fd0
leaq 0x38b4(%rip), %rsi      # 0xab42
movq %r14, %rdi
callq 0x31a0
movq %rax, %rdi
callq 0x30d0
movq %rax, %rdi
callq 0x30d0
movq 0x88(%rbx), %r13
pushq $0x1
popq %rbp
leaq 0x43b7(%rip), %r15      # 0xb66e
leaq 0x389a(%rip), %r12      # 0xab58
cmpq 0x90(%rbx), %r13
je 0x7319
movq %r14, %rdi
movl %ebp, %esi
callq 0x3240
movq %rax, %rdi
movq %r15, %rsi
callq 0x31a0
movq %rax, %rdi
callq 0x30d0
movq (%r13), %rdi
cmpb $0x1, 0x2d(%rdi)
jne 0x72f6
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x7311
movq %r14, %rdi
movq %r12, %rsi
callq 0x31a0
movq %rax, %rdi
callq 0x30d0
movq %rax, %rdi
callq 0x30d0
addq $0x8, %r13
incl %ebp
jmp 0x72be
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
movq %rdi, %rbx
movq 0x9790(%rip), %r14      # 0x10fd0
leaq 0x363d(%rip), %rsi      # 0xae84
movq %r14, %rdi
callq 0x31a0
movq %rax, %rdi
callq 0x30d0
movq %rax, %rdi
callq 0x30d0
movq 0x50(%rbx), %r12
pushq $0x1
popq %rsi
leaq 0x3e01(%rip), %r15      # 0xb66e
cmpq 0x58(%rbx), %r12
je 0x78a3
leal 0x1(%rsi), %ebp
movq %r14, %rdi
callq 0x3240
movq %rax, %rdi
movq %r15, %rsi
callq 0x31a0
movq %rax, %rdi
callq 0x30d0
movq (%r12), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r12
movl %ebp, %esi
jmp 0x786d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/AngelPn[P]L5R-card_game/src/Player.cpp
// Function: Player::tapHoldings()
void Player::tapHoldings()
{
	char input;
	unsigned int i, count = 0;

	while (holdings.size() - count > 0) //while player possesses untapped holdings (other than stronghold)
	{
		input = '0';
		i=0;
		this->printHoldings(); //print players holdings so they can decide whether to tap a holding for extra money or not

		while (input != 'y' && input != 'n')
		{
			cout << this->name<< ", do you want to tap any of your holdings for extra money (y:yes / n:no) ?" << endl;
			cin >> input;
		}

		if (input == 'y')
		{
			while ( i < 1 || i > (holdings.size()))
			{
				this->printHoldings();
				cout << "Choose a holding to tap : (1-" << holdings.size() << ")" << endl;
				cin >> i;
			}

			if (holdings[i-1]->is_tapped() == true)
			{
				cout << "Card already tapped can't be used for the remainder of the round " << endl;
				continue;
			}

			holdings[i-1]->tap(); //card is tapped
			money += holdings[i-1]->get_harvestValue();
			count++;
			cout << "Holding tapped and its harvest value was added to your money " << endl << endl;
		}

		else
			return;

	}

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0xa8(%rdi), %r14
xorl %ecx, %ecx
movq 0x9703(%rip), %r15      # 0x10fd0
leaq 0x3d9a(%rip), %r13      # 0xb66e
movq 0x9705(%rip), %rbp      # 0x10fe0
leaq 0xc(%rsp), %r12
movl %ecx, %ecx
movq %rcx, 0x10(%rsp)
movq 0x40(%rbx), %rax
subq 0x38(%rbx), %rax
sarq $0x3, %rax
cmpq %rcx, %rax
je 0x7a27
movb $0x30, 0xb(%rsp)
andl $0x0, 0xc(%rsp)
movq %rbx, %rdi
callq 0x854c
movzbl 0xb(%rsp), %eax
cmpl $0x6e, %eax
je 0x7a27
cmpl $0x79, %eax
je 0x799b
movq %r15, %rdi
movq %r14, %rsi
callq 0x3170
movq %rax, %rdi
leaq 0x3b96(%rip), %rsi      # 0xb4cc
callq 0x31a0
movq %rax, %rdi
callq 0x30d0
movq %rbp, %rdi
leaq 0xb(%rsp), %rsi
callq 0x31f0
jmp 0x790e
movq %rbx, %rdi
callq 0x854c
movq %r15, %rdi
leaq 0x3bb3(%rip), %rsi      # 0xb517
callq 0x31a0
movq 0x40(%rbx), %rsi
subq 0x38(%rbx), %rsi
sarq $0x3, %rsi
movq %rax, %rdi
callq 0x3120
movq %rax, %rdi
movq %r13, %rsi
callq 0x31a0
movq %rax, %rdi
callq 0x30d0
movq %rbp, %rdi
movq %r12, %rsi
callq 0x3250
movl 0xc(%rsp), %eax
testq %rax, %rax
je 0x7952
movq 0x38(%rbx), %rcx
movq 0x40(%rbx), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rax, %rdx
jb 0x7952
decl %eax
movq (%rcx,%rax,8), %rax
cmpb $0x1, 0x2c(%rax)
jne 0x79e5
movq %r15, %rdi
leaq 0x3b67(%rip), %rsi      # 0xb535
callq 0x31a0
movq %rax, %rdi
callq 0x30d0
movq 0x10(%rsp), %rcx
jmp 0x78e7
movb $0x1, 0x2c(%rax)
movl 0x40(%rax), %eax
addl %eax, 0xa0(%rbx)
movq 0x10(%rsp), %rax
incl %eax
movq %rax, 0x10(%rsp)
movq %r15, %rdi
leaq 0x3b6f(%rip), %rsi      # 0xb577
callq 0x31a0
movq %rax, %rdi
callq 0x30d0
movq %rax, %rdi
callq 0x30d0
movq 0x10(%rsp), %rcx
jmp 0x78e0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
movq %rdi, %rbx
movq 0x8a72(%rip), %r14      # 0x10fd0
leaq 0x2e5b(%rip), %rsi      # 0xb3c0
movq %r14, %rdi
callq 0x31a0
movq %rax, %rdi
callq 0x30d0
movq %rax, %rdi
callq 0x30d0
movq 0x38(%rbx), %r12
pushq $0x1
popq %rsi
leaq 0x30e3(%rip), %r15      # 0xb66e
cmpq 0x40(%rbx), %r12
je 0x85c1
leal 0x1(%rsi), %ebp
movq %r14, %rdi
callq 0x3240
movq %rax, %rdi
movq %r15, %rsi
callq 0x31a0
movq %rax, %rdi
callq 0x30d0
movq (%r12), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r12
movl %ebp, %esi
jmp 0x858b
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq 0x18(%rsp), %r15
andq $0x0, (%r15)
leaq 0x10(%rsp), %r12
andq $0x0, (%r12)
leaq 0xf(%rsp), %r13
movq %r13, %rdi
callq 0x65e4
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x65e6
xorl %eax, %eax
cmpq %rax, (%r15)
je 0x890c
addq $0x50, %rbx
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x9094
jmp 0x892b
leaq 0x10(%rsp), %r14
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x893a
addq $0x38, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9076
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x839a(%rip), %r14      # 0x10fd0
leaq 0x1c36(%rip), %rsi      # 0xa873
movq %r14, %rdi
callq 0x31a0
leaq 0xa8(%rbx), %rsi
movq %rax, %rdi
callq 0x3170
leaq 0x1c21(%rip), %rsi      # 0xa87c
movq %rax, %rdi
callq 0x31a0
movq %rax, %rdi
callq 0x30d0
leaq 0x29ac(%rip), %rsi      # 0xb61e
movq %r14, %rdi
callq 0x31a0
movq %rax, %rdi
callq 0x30d0
movq %rax, %rdi
callq 0x30d0
movq %rbx, %rdi
callq 0x8cc2
movq %rbx, %rdi
callq 0x6fa6
movq %rbx, %rdi
callq 0x71f4
movq %rbx, %rdi
callq 0x7272
movq %rbx, %rdi
callq 0x854c
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x84ec
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x90d1
cmpq $0x0, 0x30(%rbx)
je 0x90d1
addl $0x2, 0x40(%rbx)
jmp 0x917c
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
cmpl $0x2, %eax
jne 0x90f6
cmpq $0x0, 0x38(%rbx)
je 0x90f6
cmpq $0x0, 0x30(%rbx)
jne 0x90f6
addl $0x4, 0x40(%rbx)
jmp 0x917c
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
cmpl $0x2, %eax
jne 0x9118
cmpq $0x0, 0x38(%rbx)
jne 0x9118
cmpq $0x0, 0x30(%rbx)
je 0x9118
addl $0x5, 0x40(%rbx)
jmp 0x917c
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
cmpl $0x2, %eax
jne 0x9139
cmpq $0x0, 0x38(%rbx)
je 0x9139
cmpq $0x0, 0x30(%rbx)
je 0x9139
shll 0x40(%rbx)
jmp 0x917c
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
cmpl $0x3, %eax
jne 0x9157
movq 0x38(%rbx), %rax
testq %rax, %rax
je 0x9157
cmpq $0x0, 0x38(%rax)
je 0x9134
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
cmpl $0x3, %eax
jne 0x917c
movq 0x38(%rbx), %rax
testq %rax, %rax
je 0x917c
cmpq $0x0, 0x38(%rax)
je 0x917c
imull $0x3, 0x40(%rbx), %eax
movl %eax, 0x40(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2080
movq %rax, %r12
movq %r14, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x20c0
testl %eax, %eax
je 0x3aaf
xorl %eax, %eax
jmp 0x3b5c
movq (%rsp), %r13
movzbl (%r14,%r12), %eax
cmpl $0x3d, %eax
je 0x3ae1
testl %eax, %eax
jne 0x3aa8
addq $0x8, %rbx
movq %rbx, (%rbp)
movq (%r15), %rax
movq 0x8(%r15), %rcx
movq (%rax), %rax
cmpq (%rcx), %rax
je 0x3bd4
movq (%rax), %r14
jmp 0x3ae7
addq %r12, %r14
incq %r14
movq %r14, %rdi
callq 0x2080
testq %rax, %rax
je 0x3b6b
movq %rax, %r15
movsbl -0x1(%r14,%rax), %edi
callq 0x2260
cmpl $0x67, %eax
je 0x3b19
cmpl $0x6b, %eax
je 0x3b15
cmpl $0x6d, %eax
jne 0x3b22
pushq $0x14
jmp 0x3b1b
pushq $0xa
jmp 0x3b1b
pushq $0x1e
popq %r12
decq %r15
jmp 0x3b25
xorl %r12d, %r12d
addq %r14, %r15
pushq $0xa
popq %rcx
movq %r14, %rdi
movq %r15, %rsi
movq %r13, %rbx
movq %r13, %rdx
callq 0x4783
testl %edx, %edx
jne 0x3b8e
movq (%rbx), %rdx
movq %rdx, %rax
movl %r12d, %ecx
shlq %cl, %rax
movq %rax, %rsi
shrq %cl, %rsi
cmpq %rdx, %rsi
jne 0x3bb1
movq %rax, (%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x4456(%rip), %rax      # 0x7fc8
movq (%rax), %rdi
leaq 0x14fe(%rip), %rsi      # 0x507a
leaq 0x1508(%rip), %rdx      # 0x508b
leaq 0x1628(%rip), %r8       # 0x51b2
pushq $0x45
jmp 0x3bf5
movq 0x4433(%rip), %rax      # 0x7fc8
movq (%rax), %rdi
leaq 0x14db(%rip), %rsi      # 0x507a
leaq 0x14e5(%rip), %rdx      # 0x508b
leaq 0x1610(%rip), %r8       # 0x51bd
pushq $0x53
jmp 0x3bf5
movq 0x4410(%rip), %rax      # 0x7fc8
movq (%rax), %rdi
leaq 0x14b8(%rip), %rsi      # 0x507a
leaq 0x14c2(%rip), %rdx      # 0x508b
leaq 0x1635(%rip), %r8       # 0x5205
pushq $0x54
jmp 0x3bf5
movq 0x43ed(%rip), %rax      # 0x7fc8
movq (%rax), %rdi
leaq 0x1495(%rip), %rsi      # 0x507a
leaq 0x149f(%rip), %rdx      # 0x508b
leaq 0x15b2(%rip), %r8       # 0x51a5
pushq $0x60
popq %rcx
xorl %eax, %eax
callq 0x2250
callq 0x2100
// File: /workspace/github_cpp_makefile_star2_O2/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 0x20f0
xorl %edi, %edi
movq %rbx, %rsi
callq 0x2110
testl %eax, %eax
jne 0x3cc5
cvtsi2sdq (%rsp), %xmm0
cvtsi2sdq 0x8(%rsp), %xmm1
movsd 0x1376(%rip), %xmm2     # 0x5010
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
cvtsi2sdq 0x10(%rsp), %xmm3
cvtsi2sdq 0x18(%rsp), %xmm0
mulsd %xmm2, %xmm0
addsd %xmm3, %xmm0
addsd %xmm1, %xmm0
addq $0x90, %rsp
popq %rbx
retq
movq 0x42fc(%rip), %rax      # 0x7fc8
movq (%rax), %rdi
leaq 0x13a4(%rip), %rsi      # 0x507a
leaq 0x13ae(%rip), %rdx      # 0x508b
leaq 0x15cb(%rip), %r8       # 0x52af
movl $0x9f, %ecx
xorl %eax, %eax
callq 0x2250
callq 0x2100
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3ea2
movq 0x10(%rdi), %rax
movq 0x18(%rdi), %rcx
xorl %edx, %edx
cmpq 0x28(%rax), %rdx
je 0x3ea0
incq (%rcx)
incq %rdx
jmp 0x3e92
popq %rax
retq
leaq 0x142a(%rip), %rdi      # 0x52d3
leaq 0x1441(%rip), %rsi      # 0x52f1
leaq 0x155f(%rip), %rcx      # 0x5416
movl $0x94, %edx
callq 0x2120
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4a1e
movq %rdi, %rbx
callq *0x8(%rdi)
pushq $0x8
popq %rsi
xchgq %rsi, (%rbx)
testq %rsi, %rsi
je 0x4a1c
cmpq $0x8, %rsi
je 0x4a3d
movq %rbx, %rdi
popq %rbx
jmp 0x4d30
popq %rbx
retq
leaq 0x8ae(%rip), %rdi       # 0x52d3
leaq 0x8c5(%rip), %rsi       # 0x52f1
leaq 0x94a(%rip), %rcx       # 0x537d
movl $0x82, %edx
callq 0x2120
leaq 0xa4e(%rip), %rdi       # 0x5492
leaq 0x8a6(%rip), %rsi       # 0x52f1
leaq 0x92b(%rip), %rcx       # 0x537d
movl $0x85, %edx
callq 0x2120
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
testq $-0x9, %rsi
je 0x4add
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
jne 0x4ab8
movq %r14, %rax
xchgq %rax, (%rbx)
testq %rax, %rax
je 0x4ad9
cmpq $0x8, %rax
jne 0x4af6
movq %rbx, %rdi
callq 0x4b14
movq %r14, %rdi
callq 0x49f2
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %ebx, %ebx
jmp 0x4ace
leaq 0x99b(%rip), %rdi       # 0x547f
leaq 0x806(%rip), %rsi       # 0x52f1
leaq 0x9b1(%rip), %rcx       # 0x54a3
pushq $0x75
jmp 0x4b0d
leaq 0x9dd(%rip), %rdi       # 0x54da
leaq 0x7ed(%rip), %rsi       # 0x52f1
leaq 0x998(%rip), %rcx       # 0x54a3
pushq $0x79
popq %rdx
callq 0x2120
nop
// File: /workspace/github_cpp_makefile_star2_O2/romkatv[P]action-chain/src/action_chain.cc
// Function: romkatv::ActionChain::Work::RunAllSlow(romkatv::ActionChain::Work*, romkatv::ActionChain::Work*)
void ActionChain::Work::RunAllSlow(Work* w, Work* next) {
  do {
    do {
      assert(w != nullptr && w != Sealed());
      assert(next != nullptr && next != Sealed());
      w->Destroy();
      ::operator delete(w, kAllocSize);
      w = next;
      w->invoke_(w);
      next = w->next_.load(std::memory_order_acquire);
    } while (next);
    next = w->next_.exchange(Sealed(), std::memory_order_acq_rel);
  } while (next);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
pushq $0x20
popq %r14
pushq $0x8
popq %r12
testq $-0x9, %r15
je 0x4d98
testq $-0x9, %rbx
je 0x4db1
movq %r15, %rdi
callq 0x4b14
movq %r15, %rdi
movq %r14, %rsi
callq 0x2200
movq %rbx, %rdi
callq *0x8(%rbx)
movq (%rbx), %rax
testq %rax, %rax
jne 0x4d84
movq %r12, %rax
xchgq %rax, (%rbx)
testq %rax, %rax
je 0x4d8c
movq %rbx, %r15
movq %rax, %rbx
jmp 0x4d46
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x534(%rip), %rdi       # 0x52d3
leaq 0xa00(%rip), %rsi       # 0x57a6
leaq 0xa0d(%rip), %rcx       # 0x57ba
pushq $0xa
jmp 0x4dc8
leaq 0x6c7(%rip), %rdi       # 0x547f
leaq 0x9e7(%rip), %rsi       # 0x57a6
leaq 0x9f4(%rip), %rcx       # 0x57ba
pushq $0xb
popq %rdx
callq 0x2120
// File: /workspace/github_cpp_makefile_star2_O2/dianejdan[P]Eclat/./DbReader.hpp
// Function: DbReader::template_type(char*)
int template_type(char* filename){

        ifstream in_(filename); // open input file
        char buffer[4096]; // store each line/transaction
        string line;

        int typ = 3;
        // parse the input file, add item and tid into the tid list
        in_.getline(buffer, 4096);
        line = buffer;
        size_t pos1 = line.find_first_not_of(" ");
        if (buffer[pos1+1] == ' '){
            if (buffer[pos1] == '0' || buffer[pos1] == '1' || buffer[pos1] == '2' ||
                buffer[pos1] == '3' || buffer[pos1] == '4' || buffer[pos1] == '5' ||
                buffer[pos1] == '6' || buffer[pos1] == '7' || buffer[pos1] == '8' ||
                buffer[pos1] == '9')
                typ = 1;
            else
                typ = 2;
        }

        in_.close();
        return typ;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x1228, %rsp           # imm = 0x1228
leaq -0x230(%rbp), %rbx
pushq $0x8
popq %rdx
movq %rbx, %rdi
callq 0x2300
leaq -0x18(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x1230(%rbp), %rsi
movl $0x1000, %edx           # imm = 0x1000
movq %rbx, %rdi
callq 0x2090
leaq -0x28(%rbp), %rdi
leaq -0x1230(%rbp), %rbx
movq %rbx, %rsi
callq 0x2310
leaq 0x4a23(%rip), %rsi      # 0x7149
leaq -0x28(%rbp), %rdi
xorl %edx, %edx
callq 0x2120
cmpb $0x20, 0x1(%rax,%rbx)
jne 0x274b
movb -0x1230(%rbp,%rax), %al
addb $-0x30, %al
cmpb $0xa, %al
pushq $0x2
popq %rbx
sbbl $0x0, %ebx
jmp 0x274e
pushq $0x3
popq %rbx
leaq -0x230(%rbp), %rdi
callq 0x2050
leaq -0x28(%rbp), %rdi
callq 0x20d0
leaq -0x230(%rbp), %rdi
callq 0x2070
movl %ebx, %eax
addq $0x1228, %rsp           # imm = 0x1228
popq %rbx
popq %rbp
retq
jmp 0x277d
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0x20d0
leaq -0x230(%rbp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/dianejdan[P]Eclat/./PatternStore.hpp
// Function: PatternStore<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::eclat(Pattern<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>*)
void eclat(Pattern<Typ> *parent){
        vector<Pattern<Typ> * > myChildren = parent->get_children(); // get children list

        for (int i = 0; i < myChildren.size(); ++i){ // loop through child in children list
            int newPats = 0; // a count to see if there are new Patterns

            for (int j = (i+1); j < myChildren.size(); ++j){ // find the "larger" child
                // perform the join of tid lists of two children
                vector<int> joinTidList = myChildren[i]->join_tid_list(myChildren[j]);
                if (joinTidList.size() >= minsup){ // check if the join tid list is larger than minsup
                    // add this new pattern as a new child of the smaller child for joining
                    add_pattern(myChildren[i], myChildren[j]->get_item(), joinTidList);
                    ++newPats; // new pattern count increases by 1
                }
            }
            if (newPats > 0)
                eclat(myChildren[i]); // if more than one new patterns, eclat the smaller child for joining
                                      // it is like a DFS of tree structure
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, -0x38(%rbp)
addq $0x38, %rsi
leaq -0x50(%rbp), %rdi
callq 0x5dfe
pushq $0x1
popq %r14
xorl %r15d, %r15d
leaq -0xb0(%rbp), %r13
leaq -0x90(%rbp), %r12
movq -0x50(%rbp), %rax
movq -0x48(%rbp), %rcx
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %r15, %rdx
jbe 0x3605
leaq 0x1(%r15), %rdx
movq %rdx, -0x58(%rbp)
movl $0x0, -0x2c(%rbp)
movq %r14, -0x60(%rbp)
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r14, %rcx
jbe 0x35e2
movq (%rax,%r15,8), %rsi
movq (%rax,%r14,8), %rdx
leaq -0x78(%rbp), %rdi
callq 0x5d36
movq -0x70(%rbp), %rax
subq -0x78(%rbp), %rax
sarq $0x2, %rax
movq -0x38(%rbp), %rcx
movslq 0xc(%rcx), %rcx
cmpq %rcx, %rax
jb 0x35c9
movq -0x50(%rbp), %rax
movq %r13, %rdi
movq (%rax,%r15,8), %rbx
movq (%rax,%r14,8), %rsi
callq 0x2260
movq %r12, %rdi
leaq -0x78(%rbp), %rsi
callq 0x3818
movq -0x38(%rbp), %rdi
movq %rbx, %rsi
movq %r13, %rdx
movq %r12, %rcx
callq 0x549c
movq %r12, %rdi
callq 0x3c38
movq %r13, %rdi
callq 0x20d0
incl -0x2c(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x3c38
incq %r14
movq -0x50(%rbp), %rax
movq -0x48(%rbp), %rcx
jmp 0x354a
cmpl $0x0, -0x2c(%rbp)
jle 0x35f5
movq (%rax,%r15,8), %rsi
movq -0x38(%rbp), %rdi
callq 0x34e2
movq -0x60(%rbp), %r14
incq %r14
movq -0x58(%rbp), %r15
jmp 0x351c
leaq -0x50(%rbp), %rdi
callq 0x5e56
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3652
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
callq 0x3c38
jmp 0x3636
movq %rax, %rbx
leaq -0xb0(%rbp), %rdi
callq 0x20d0
jmp 0x3647
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x3c38
jmp 0x3655
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x5e56
movq %rbx, %rdi
callq 0x22e0