LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/moloch--[P]cli-Blackjack/./Blackjack/AsciiArt.cpp
// Function: AsciiArt::getTopRank(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string AsciiArt::getTopRank(string rank)
{
	ostringstream result; // Create string stream
	result << "|" << rank;
	while (result.str().length() < 10) // Length of rank is not fixed
	{
		result << " ";
	}
	result << "|";
	return result.str();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x21e0
leaq 0x34a3(%rip), %rsi      # 0x6062
movq %r15, %rdi
callq 0x2180
movq %rax, %rdi
movq %r14, %rsi
callq 0x2150
leaq 0x28(%rsp), %r14
movq %rsp, %r15
leaq 0x37bb(%rip), %r12      # 0x639c
leaq 0x20(%rsp), %r13
movq %r15, %rdi
movq %r14, %rsi
callq 0x2230
movq 0x8(%rsp), %rbp
movq %r15, %rdi
callq 0x20b0
cmpq $0x9, %rbp
ja 0x2c11
movq %r13, %rdi
movq %r12, %rsi
callq 0x2180
jmp 0x2be6
leaq 0x344a(%rip), %rsi      # 0x6062
leaq 0x20(%rsp), %rdi
callq 0x2180
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2230
leaq 0x20(%rsp), %rdi
callq 0x2040
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2c50
jmp 0x2c50
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x2040
movq %rbx, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O2/moloch--[P]cli-Blackjack/./Blackjack/AsciiArt.cpp
// Function: AsciiArt::getBottomRank(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string AsciiArt::getBottomRank(string rank)
{
	ostringstream result; // Create string stream
	result << "|";
	while (result.str().length() + rank.length() < 10) // Length of rank is not fixed
	{
		result << " ";
	}
	result << rank << "|";
	return result.str();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rdx, %r15
movq %rdi, 0x8(%rsp)
leaq 0x30(%rsp), %r14
movq %r14, %rdi
callq 0x21e0
leaq 0x33cf(%rip), %rsi      # 0x6062
movq %r14, %rdi
callq 0x2180
leaq 0x38(%rsp), %r14
leaq 0x10(%rsp), %r12
leaq 0x36f0(%rip), %r13      # 0x639c
leaq 0x30(%rsp), %rbp
movq %r12, %rdi
movq %r14, %rsi
callq 0x2230
movq 0x8(%r15), %rbx
addq 0x18(%rsp), %rbx
movq %r12, %rdi
callq 0x20b0
cmpq $0x9, %rbx
ja 0x2ce0
movq %rbp, %rdi
movq %r13, %rsi
callq 0x2180
jmp 0x2cb1
leaq 0x30(%rsp), %rdi
movq %r15, %rsi
callq 0x2150
leaq 0x336e(%rip), %rsi      # 0x6062
movq %rax, %rdi
callq 0x2180
movq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x2230
leaq 0x30(%rsp), %rdi
callq 0x2040
movq 0x8(%rsp), %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2d2e
jmp 0x2d2e
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x2040
movq %rbx, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O2/moloch--[P]cli-Blackjack/./Blackjack/AsciiArt.cpp
// Function: AsciiArt::printSymbol(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
string AsciiArt::printSymbol(string suit, int segment)
{
	/* Switch statements are evil */
	if (suit == "clubs")
	{
		return getClubsSymbol(segment);
	}
	else if (suit == "hearts")
	{
		return getHeartsSymbol(segment);
	}
	else if (suit == "diamonds")
	{
		return getDiamondsSymbol(segment);
	}
	else if (suit == "spades")
	{
		return getSpadesSymbol(segment);
	}
	else if (suit == "hidden")
	{
		return getHiddenSymbol(segment);
	}
	else
	{
		/* Just return something */
		return "Error: Not a valid suit";
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x32b7(%rip), %rsi      # 0x60f4
movq %rdx, %rdi
callq 0x2f85
testb %al, %al
je 0x2e5b
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x2d44
jmp 0x2ef7
leaq 0x3298(%rip), %rsi      # 0x60fa
movq %r15, %rdi
callq 0x2f85
testb %al, %al
je 0x2e7d
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x2d64
jmp 0x2ef7
leaq 0x327d(%rip), %rsi      # 0x6101
movq %r15, %rdi
callq 0x2f85
testb %al, %al
je 0x2e9f
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x2d88
jmp 0x2ef7
leaq 0x3264(%rip), %rsi      # 0x610a
movq %r15, %rdi
callq 0x2f85
testb %al, %al
je 0x2ec1
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x2dac
jmp 0x2ef7
leaq 0x3249(%rip), %rsi      # 0x6111
movq %r15, %rdi
callq 0x2f85
testb %al, %al
je 0x2ee3
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x2dd0
jmp 0x2ef7
leaq 0x322e(%rip), %rsi      # 0x6118
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x2f06
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/moloch--[P]cli-Blackjack/./Blackjack/Blackjack.cpp
// Function: Blackjack::initialDeal(Player&, Dealer&)
void Blackjack::initialDeal(Player & player, Dealer & dealer)
{
    player.hit(deck.deal()); // Deal two cards to the player(s)
    player.hit(deck.deal());
    dealer.hit(deck.deal()); // Deal two cards to the dealer
    dealer.hit(deck.deal());
    dealer.hideCard();       // Hide dealer's card
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x148, %rsp            # imm = 0x148
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
addq $0x18, %r15
leaq 0xf8(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x51aa
movq %r12, %rdi
movq %r14, %rsi
callq 0x4a72
leaq 0xf8(%rsp), %rdi
callq 0x3bbe
leaq 0xa8(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x51aa
movq %r12, %rdi
movq %r14, %rsi
callq 0x4a72
leaq 0xa8(%rsp), %rdi
callq 0x3bbe
leaq 0x58(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x51aa
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4a72
leaq 0x58(%rsp), %rdi
callq 0x3bbe
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x51aa
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4a72
leaq 0x8(%rsp), %rdi
callq 0x3bbe
movq %rbx, %rdi
callq 0x4a3a
addq $0x148, %rsp            # imm = 0x148
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x342c
jmp 0x342c
jmp 0x342c
movq %rax, %rbx
movq %r14, %rdi
callq 0x3bbe
movq %rbx, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O2/moloch--[P]cli-Blackjack/./Blackjack/Blackjack.cpp
// Function: Blackjack::findWinner(Player&, Dealer&)
void Blackjack::findWinner(Player & player, Dealer & dealer)
{
    if(player.isBust()) // Check to see if player busted during their turn
    {
        cout << "\n***** [ " << player.getName() << " busted ] *****" << endl;
        player.printCurrentHand();
    }
    else
    {
        dealer.turn(deck, player.getCurrentScore());
    }
    cout << dealer.getName() << " has:" << endl;
    dealer.printCurrentHand();
    /* Find winner and print the results on stdout, remember house wins on a tie */
    if((player.getCurrentScore() > dealer.getCurrentScore() || dealer.isBust()) && !player.isBust())
    {
        cout << player.getName() << " has won the game!" << endl;
        player.giveMoney(wager);
        playerWins++;
    }
    else
    {
        cout << dealer.getName() << " has won the game!" << endl;
        player.takeMoney(wager);
        dealerWins++;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x4a28
testb %al, %al
je 0x34bf
movq 0x6b66(%rip), %rdi      # 0x9fd0
leaq 0x2da3(%rip), %rsi      # 0x6214
callq 0x2180
movq %rax, %r12
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x4a02
movq %r12, %rdi
movq %r13, %rsi
callq 0x2150
leaq 0x2d83(%rip), %rsi      # 0x621e
movq %rax, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0x8(%rsp), %rdi
callq 0x20b0
movq %r14, %rdi
callq 0x4a1e
jmp 0x34d8
leaq 0x18(%rbx), %r12
movq %r14, %rdi
callq 0x4a14
movq %r15, %rdi
movq %r12, %rsi
movl %eax, %edx
callq 0x3d14
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x4a02
movq 0x6ae1(%rip), %rdi      # 0x9fd0
movq %r12, %rsi
callq 0x2150
leaq 0x2d30(%rip), %rsi      # 0x622e
movq %rax, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0x8(%rsp), %rdi
callq 0x20b0
movq %r15, %rdi
callq 0x4a1e
movq %r14, %rdi
callq 0x4a14
movl %eax, %ebp
movq %r15, %rdi
callq 0x4a14
cmpl %eax, %ebp
jg 0x3542
movq %r15, %rdi
callq 0x4a28
testb %al, %al
je 0x354e
movq %r14, %rdi
callq 0x4a28
testb %al, %al
je 0x359e
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x4a02
movq 0x6a6b(%rip), %rdi      # 0x9fd0
movq %r12, %rsi
callq 0x2150
leaq 0x2cc0(%rip), %rsi      # 0x6234
movq %rax, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0x8(%rsp), %rdi
callq 0x20b0
movl 0x10(%rbx), %esi
movq %r14, %rdi
callq 0x4daa
incl 0x8(%rbx)
jmp 0x35ec
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x4a02
movq 0x6a1b(%rip), %rdi      # 0x9fd0
movq %r15, %rsi
callq 0x2150
leaq 0x2c70(%rip), %rsi      # 0x6234
movq %rax, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0x8(%rsp), %rdi
callq 0x20b0
movl 0x10(%rbx), %esi
movq %r14, %rdi
callq 0x4da6
incl 0xc(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3601
jmp 0x3601
jmp 0x3601
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20b0
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/moloch--[P]cli-Blackjack/./Blackjack/Blackjack.cpp
// Function: Blackjack::playGame()
void Blackjack::playGame()
{
	Dealer dealer("HAL 9000"); // Create the dealer
	Player player1("Weak Human"); // Create the player(s)
	player1.setMoney(1000);
	while (player1.getMoney() > 0)
	{
		startTurn(player1, dealer);
	}
	cout << "\n [!] You have lost all your money!" << endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x170, %rsp            # imm = 0x170
movq %rdi, %rbx
leaq 0x2a20(%rip), %rsi      # 0x6282
leaq 0x30(%rsp), %rdi
leaq 0x50(%rsp), %rdx
callq 0x2f06
leaq 0xe0(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x3c8c
leaq 0x30(%rsp), %rdi
callq 0x20b0
leaq 0x29f7(%rip), %rsi      # 0x628b
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x2f06
leaq 0x50(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x483c
leaq 0x10(%rsp), %rdi
callq 0x20b0
leaq 0x50(%rsp), %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x4da2
leaq 0x50(%rsp), %r14
leaq 0xe0(%rsp), %r15
movq %r14, %rdi
callq 0x4d9e
testl %eax, %eax
jle 0x38f4
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x3616
jmp 0x38d8
movq 0x66d5(%rip), %rdi      # 0x9fd0
leaq 0x2994(%rip), %rsi      # 0x6296
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0x50(%rsp), %rdi
callq 0x49bc
leaq 0xe0(%rsp), %rdi
callq 0x3cf6
addq $0x170, %rsp            # imm = 0x170
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x20b0
jmp 0x396a
movq %rax, %rbx
jmp 0x396a
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x20b0
jmp 0x3977
movq %rax, %rbx
jmp 0x3977
jmp 0x395d
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x49bc
leaq 0xe0(%rsp), %rdi
callq 0x3cf6
movq %rbx, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O2/moloch--[P]cli-Blackjack/./Blackjack/Blackjack.cpp
// Function: Blackjack::getStringFromUser(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string Blackjack::getStringFromUser(string prompt)
{   /* Prompts the user with the provided string, and returns their input */
	cout << prompt;
	getline(cin, userInput);
	return userInput;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x663f(%rip), %rdi      # 0x9fd0
movq %rdx, %rsi
callq 0x2150
addq $0x70, %rbx
movq 0x663c(%rip), %rdi      # 0x9fe0
movq %rbx, %rsi
callq 0x2030
movq %r14, %rdi
movq %rbx, %rsi
callq 0x21f0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/moloch--[P]cli-Blackjack/./Blackjack/Card.cpp
// Function: Card::Card(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Card::Card(string cardSuit, int cardValue, string cardRank)
{
	setValue(cardValue);
	setSuit(cardSuit);
	setRank(cardRank);
	hidden = false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r12
movq %rdi, %r15
leaq 0x62be(%rip), %rax      # 0x9cc8
movq %rax, (%rdi)
leaq 0x20(%rdi), %rax
movq %rax, 0x10(%rdi)
andq $0x0, 0x18(%rdi)
xorl %eax, %eax
movb %al, 0x20(%rdi)
leaq 0x40(%rdi), %rcx
movq %rcx, 0x30(%rdi)
andq $0x0, 0x38(%rdi)
leaq 0x10(%rdi), %rbx
leaq 0x30(%rdi), %r14
movb %al, 0x40(%rdi)
movl %edx, 0x8(%rdi)
leaq 0x28(%rsp), %rdi
callq 0x21f0
leaq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0x20e0
leaq 0x28(%rsp), %rdi
callq 0x20b0
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x21f0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x20e0
leaq 0x8(%rsp), %rdi
callq 0x20b0
movb $0x0, 0xc(%r15)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r15
leaq 0x8(%rsp), %rdi
jmp 0x3aa2
movq %rax, %r15
leaq 0x28(%rsp), %rdi
callq 0x20b0
jmp 0x3aac
movq %rax, %r15
movq %r14, %rdi
callq 0x20b0
movq %rbx, %rdi
callq 0x20b0
movq %r15, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/moloch--[P]cli-Blackjack/./Blackjack/Card.cpp
// Function: Card::Card(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int)
Card::Card(string cardSuit, int cardValue, int cardRank)
{
	setValue(cardValue);
	setSuit(cardSuit);
	setRank(cardRank);
	hidden = false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebp
movq %rdi, %rbx
leaq 0x61d6(%rip), %rax      # 0x9cc8
movq %rax, (%rdi)
leaq 0x20(%rdi), %rax
movq %rax, 0x10(%rdi)
andq $0x0, 0x18(%rdi)
xorl %eax, %eax
movb %al, 0x20(%rdi)
leaq 0x40(%rdi), %rcx
movq %rcx, 0x30(%rdi)
andq $0x0, 0x38(%rdi)
leaq 0x30(%rdi), %r14
movb %al, 0x40(%rdi)
movl %edx, 0x8(%rdi)
leaq 0x8(%rsp), %rdi
callq 0x21f0
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x20e0
leaq 0x8(%rsp), %rdi
callq 0x20b0
movq %rbx, %rdi
movl %ebp, %esi
callq 0x3b86
movb $0x0, 0xc(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
leaq 0x8(%rsp), %rdi
callq 0x20b0
jmp 0x3b6a
movq %rax, %r15
addq $0x10, %rbx
movq %r14, %rdi
callq 0x20b0
movq %rbx, %rdi
callq 0x20b0
movq %r15, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/moloch--[P]cli-Blackjack/./Blackjack/Hand.cpp
// Function: Hand::getScore()
int Hand::getScore()
{
	score = 0; // Re-calculate score
	for (unsigned int index = 0; index < hand.size(); ++index)
	{
		if (!hand[index].isHidden()) // Do not include hidden values
		{
			score += hand[index].getValue();
		}
	}
	return score;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
andl $0x0, 0x8(%rdi)
xorl %r15d, %r15d
pushq $0x50
popq %r12
movl %r15d, %r15d
movq 0x18(%rbx), %rdi
movq 0x20(%rbx), %rax
subq %rdi, %rax
cqto
idivq %r12
cmpq %r15, %rax
jbe 0x3e10
imulq $0x50, %r15, %r14
addq %r14, %rdi
callq 0x3c82
testb %al, %al
jne 0x3e0b
addq 0x18(%rbx), %r14
movq %r14, %rdi
callq 0x3bf8
addl %eax, 0x8(%rbx)
incl %r15d
jmp 0x3dd4
movl 0x8(%rbx), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/moloch--[P]cli-Blackjack/./Blackjack/Hand.cpp
// Function: Hand::printAsciiHand()
void Hand::printAsciiHand()
{
    AsciiArt ascii;
    printAsciiHeader(ascii); // An entire line must be printed before another can start
    printAsciiTopRank(ascii);
    printAsciiSymbol(ascii);
    printAsciiBottomRank(ascii);
    printAsciiFooter(ascii);
    cout << "Total value: " << getScore() << endl;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xf8, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x245c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3f72
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4020
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4172
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x42fe
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4450
movq 0x60b2(%rip), %rdi      # 0x9fd0
leaq 0x23ae(%rip), %rsi      # 0x62d3
callq 0x2180
movq %rax, %r14
movq %rbx, %rdi
callq 0x3dbe
movq %r14, %rdi
movl %eax, %esi
callq 0x2250
movq %rax, %rdi
callq 0x20c0
leaq 0x8(%rsp), %rdi
callq 0x2acc
addq $0xf8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2acc
movq %rbx, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O2/moloch--[P]cli-Blackjack/./Blackjack/Hand.cpp
// Function: Hand::printAsciiHeader(AsciiArt&)
void Hand::printAsciiHeader(AsciiArt & ascii)
{
    for (unsigned int index = 0;index < ascii.getHeaderSize();++index)
    {
        for (unsigned int cardIndex = 0;cardIndex < hand.size();++cardIndex)
        {
            cout << ascii.getCardHeader(index) << " ";
        }
        cout << endl; // End line
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorl %ebp, %ebp
leaq 0x8(%rsp), %r15
movq 0x603c(%rip), %r12      # 0x9fd0
movq %rbx, %rdi
callq 0x2df4
cmpl %eax, %ebp
jae 0x3ffb
xorl %r13d, %r13d
movl %r13d, %ecx
movq 0x20(%r14), %rax
subq 0x18(%r14), %rax
cqto
pushq $0x50
popq %rsi
idivq %rsi
cmpq %rcx, %rax
jbe 0x3fef
movq %r15, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x2b54
movq %r12, %rdi
movq %r15, %rsi
callq 0x2150
movq %rax, %rdi
leaq 0x23bf(%rip), %rsi      # 0x639c
callq 0x2180
movq %r15, %rdi
callq 0x20b0
incl %r13d
jmp 0x3fa3
movq %r12, %rdi
callq 0x20c0
incl %ebp
jmp 0x3f94
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20b0
movq %rbx, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O2/moloch--[P]cli-Blackjack/./Blackjack/Hand.cpp
// Function: Hand::printAsciiTopRank(AsciiArt&)
void Hand::printAsciiTopRank(AsciiArt & ascii)
{
    for (unsigned int cardIndex = 0;cardIndex < hand.size();++cardIndex)
    {
        if (hand[cardIndex].isHidden())
        {
            cout << ascii.getTopRank("?") << " ";
        }
        else
        {
            cout << ascii.getTopRank(getCardRank(cardIndex)) << " ";
        }
    }
    cout << endl; // End line
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
leaq 0x48(%rsp), %r13
leaq 0x8(%rsp), %r12
leaq 0x28(%rsp), %rbp
movl %r15d, %r15d
movq 0x18(%r14), %rdi
movq 0x20(%r14), %rax
subq %rdi, %rax
cqto
pushq $0x50
popq %rcx
idivq %rcx
cmpq %r15, %rax
jbe 0x4114
imulq $0x50, %r15, %rax
addq %rax, %rdi
callq 0x3c82
testb %al, %al
je 0x40c2
movq %r13, %rdi
leaq 0x2262(%rip), %rsi      # 0x62e1
leaq 0x7(%rsp), %rdx
callq 0x2f06
movq %r12, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x2b94
movq 0x5f32(%rip), %rdi      # 0x9fd0
movq %r12, %rsi
callq 0x2150
movq %rax, %rdi
leaq 0x22ec(%rip), %rsi      # 0x639c
callq 0x2180
movq %r12, %rdi
callq 0x20b0
movq %r13, %rdi
jmp 0x4107
movq %rbp, %rdi
movq %r14, %rsi
movl %r15d, %edx
callq 0x3e58
movq %r12, %rdi
movq %rbx, %rsi
movq %rbp, %rdx
callq 0x2b94
movq 0x5eeb(%rip), %rdi      # 0x9fd0
movq %r12, %rsi
callq 0x2150
movq %rax, %rdi
leaq 0x22a5(%rip), %rsi      # 0x639c
callq 0x2180
movq %r12, %rdi
callq 0x20b0
movq %rbp, %rdi
callq 0x20b0
incl %r15d
jmp 0x4046
movq 0x5eb5(%rip), %rdi      # 0x9fd0
callq 0x20c0
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x415f
movq %rax, %rbx
jmp 0x4169
movq %rax, %rbx
jmp 0x414b
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20b0
leaq 0x48(%rsp), %rdi
jmp 0x4164
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20b0
leaq 0x28(%rsp), %rdi
callq 0x20b0
movq %rbx, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O2/moloch--[P]cli-Blackjack/./Blackjack/Hand.cpp
// Function: Hand::printAsciiSymbol(AsciiArt&)
void Hand::printAsciiSymbol(AsciiArt & ascii)
{
    for (unsigned int index = 0;index < ascii.getSymbolSize();++index)
    {
        for (unsigned int cardIndex = 0;cardIndex < hand.size();++cardIndex)
        {
            if (hand[cardIndex].isHidden())  // Check to if card is hidden
            {
                cout << ascii.printSymbol("hidden", index) << " ";
            }
            else
            {
                cout << ascii.printSymbol(hand[cardIndex].getSuit(), index) << " ";
            }
        }
        cout << endl;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, 0x10(%rsp)
movq %rdi, %r14
xorl %ebp, %ebp
leaq 0x38(%rsp), %r15
movq 0x10(%rsp), %rdi
callq 0x2e02
cmpl %eax, %ebp
jae 0x42ac
xorl %r13d, %r13d
movl %r13d, %r13d
movq 0x18(%r14), %rdi
movq 0x20(%r14), %rax
subq %rdi, %rax
cqto
pushq $0x50
popq %rcx
idivq %rcx
cmpq %r13, %rax
jbe 0x4299
imulq $0x50, %r13, %r12
addq %r12, %rdi
callq 0x3c82
testb %al, %al
je 0x422e
leaq 0x58(%rsp), %rbx
movq %rbx, %rdi
leaq 0x1f2f(%rip), %rsi      # 0x6111
leaq 0xf(%rsp), %rdx
callq 0x2f06
movq %r15, %rdi
movq 0x10(%rsp), %rsi
movq %rbx, %rdx
movl %ebp, %ecx
callq 0x2e24
movq 0x5dcb(%rip), %rdi      # 0x9fd0
movq %r15, %rsi
callq 0x2150
movq %rax, %rdi
leaq 0x2185(%rip), %rsi      # 0x639c
callq 0x2180
movq %r15, %rdi
callq 0x20b0
movq %rbx, %rdi
callq 0x20b0
jmp 0x4291
movq %r14, %rbx
addq 0x18(%r14), %r12
movl %ebp, %r14d
leaq 0x18(%rsp), %rbp
movq %rbp, %rdi
movq %r12, %rsi
callq 0x3bfc
movq %r15, %rdi
movq 0x10(%rsp), %rsi
movq %rbp, %rdx
movl %r14d, %ebp
movl %r14d, %ecx
callq 0x2e24
movq 0x5d6b(%rip), %rdi      # 0x9fd0
movq %r15, %rsi
callq 0x2150
movq %rax, %rdi
leaq 0x2125(%rip), %rsi      # 0x639c
callq 0x2180
movq %r15, %rdi
callq 0x20b0
leaq 0x18(%rsp), %rdi
callq 0x20b0
movq %rbx, %r14
incl %r13d
jmp 0x41a4
movq 0x5d30(%rip), %rdi      # 0x9fd0
callq 0x20c0
incl %ebp
jmp 0x418f
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x42eb
movq %rax, %rbx
jmp 0x42f5
movq %rax, %rbx
jmp 0x42d7
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x20b0
leaq 0x58(%rsp), %rdi
jmp 0x42f0
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x20b0
leaq 0x18(%rsp), %rdi
callq 0x20b0
movq %rbx, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O2/moloch--[P]cli-Blackjack/./Blackjack/Hand.cpp
// Function: Hand::printAsciiBottomRank(AsciiArt&)
void Hand::printAsciiBottomRank(AsciiArt & ascii)
{
    for (unsigned int cardIndex = 0;cardIndex < hand.size();++cardIndex)
    {
        if (hand[cardIndex].isHidden())
        {
            cout << ascii.getBottomRank("?") << " ";
        }
        else
        {
            cout << ascii.getBottomRank(getCardRank(cardIndex)) << " ";
        }
    }
    cout << endl; // End line & flush buffer
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
leaq 0x48(%rsp), %r13
leaq 0x8(%rsp), %r12
leaq 0x28(%rsp), %rbp
movl %r15d, %r15d
movq 0x18(%r14), %rdi
movq 0x20(%r14), %rax
subq %rdi, %rax
cqto
pushq $0x50
popq %rcx
idivq %rcx
cmpq %r15, %rax
jbe 0x43f2
imulq $0x50, %r15, %rax
addq %rax, %rdi
callq 0x3c82
testb %al, %al
je 0x43a0
movq %r13, %rdi
leaq 0x1f84(%rip), %rsi      # 0x62e1
leaq 0x7(%rsp), %rdx
callq 0x2f06
movq %r12, %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x2c66
movq 0x5c54(%rip), %rdi      # 0x9fd0
movq %r12, %rsi
callq 0x2150
movq %rax, %rdi
leaq 0x200e(%rip), %rsi      # 0x639c
callq 0x2180
movq %r12, %rdi
callq 0x20b0
movq %r13, %rdi
jmp 0x43e5
movq %rbp, %rdi
movq %r14, %rsi
movl %r15d, %edx
callq 0x3e58
movq %r12, %rdi
movq %rbx, %rsi
movq %rbp, %rdx
callq 0x2c66
movq 0x5c0d(%rip), %rdi      # 0x9fd0
movq %r12, %rsi
callq 0x2150
movq %rax, %rdi
leaq 0x1fc7(%rip), %rsi      # 0x639c
callq 0x2180
movq %r12, %rdi
callq 0x20b0
movq %rbp, %rdi
callq 0x20b0
incl %r15d
jmp 0x4324
movq 0x5bd7(%rip), %rdi      # 0x9fd0
callq 0x20c0
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x443d
movq %rax, %rbx
jmp 0x4447
movq %rax, %rbx
jmp 0x4429
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20b0
leaq 0x48(%rsp), %rdi
jmp 0x4442
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20b0
leaq 0x28(%rsp), %rdi
callq 0x20b0
movq %rbx, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O2/moloch--[P]cli-Blackjack/./Blackjack/Hand.cpp
// Function: Hand::printAsciiFooter(AsciiArt&)
void Hand::printAsciiFooter(AsciiArt & ascii)
{
    for (unsigned int index = 0;index < ascii.getFooterSize();++index)
    {
        for (unsigned int cardIndex = 0;cardIndex < hand.size();++cardIndex)
        {
            cout << ascii.getCardFooter(index) << " ";
        }
        cout << endl;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorl %ebp, %ebp
leaq 0x8(%rsp), %r15
movq 0x5b5e(%rip), %r12      # 0x9fd0
movq %rbx, %rdi
callq 0x2e16
cmpl %eax, %ebp
jae 0x44d9
xorl %r13d, %r13d
movl %r13d, %ecx
movq 0x20(%r14), %rax
subq 0x18(%r14), %rax
cqto
pushq $0x50
popq %rsi
idivq %rsi
cmpq %rcx, %rax
jbe 0x44cd
movq %r15, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x2b74
movq %r12, %rdi
movq %r15, %rsi
callq 0x2150
movq %rax, %rdi
leaq 0x1ee1(%rip), %rsi      # 0x639c
callq 0x2180
movq %r15, %rdi
callq 0x20b0
incl %r13d
jmp 0x4481
movq %r12, %rdi
callq 0x20c0
incl %ebp
jmp 0x4472
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20b0
movq %rbx, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O2/moloch--[P]cli-Blackjack/./Blackjack/Player.cpp
// Function: Player::hit(Card)
void Player::hit(Card card)
{
	if (card.getRank() == "A" && (hand.getScore() + 11) > 21)
	{
		card.setValue(1);
	}
	else if (card.getRank() == "A")
	{
		card.setValue(11);
	}
	hand.putInHand(card);
	if(isBust()) // Look for aces if player went bust from new card
	{
		for (unsigned int index = 0; index < hand.getSize(); ++index)
		{
			if (hand.getCardRank(index) == "A" && hand.getCardValue(index) == 11)
			{
				hand.setCardValue(index, 1); // Change ace's value to 1
			}
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x3c70
leaq 0x1857(%rip), %rsi      # 0x62f1
movq %r14, %rdi
callq 0x2f85
testb %al, %al
je 0x4ac4
leaq 0x60(%rbx), %rdi
callq 0x3dbe
movl %eax, %ebp
leaq 0x8(%rsp), %rdi
callq 0x20b0
cmpl $0xa, %ebp
jle 0x4ace
pushq $0x1
jmp 0x4afe
leaq 0x8(%rsp), %rdi
callq 0x20b0
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x3c70
leaq 0x180c(%rip), %rsi      # 0x62f1
movq %r14, %rdi
callq 0x2f85
movl %eax, %ebp
movq %r14, %rdi
callq 0x20b0
testb %bpl, %bpl
je 0x4b07
pushq $0xb
popq %rsi
movq %r15, %rdi
callq 0x3ac4
leaq 0x60(%rbx), %r14
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x46d4
movq %r14, %rdi
movq %r12, %rsi
callq 0x3e74
leaq 0x28(%rsp), %rdi
callq 0x3bbe
movq %rbx, %rdi
callq 0x4a28
testb %al, %al
je 0x4baa
xorl %ebx, %ebx
leaq 0x8(%rsp), %r15
leaq 0x17a7(%rip), %r12      # 0x62f1
pushq $0x1
popq %rbp
movq %r14, %rdi
callq 0x3e20
cmpl %eax, %ebx
jae 0x4baa
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x3e58
movq %r15, %rdi
movq %r12, %rsi
callq 0x2f85
testb %al, %al
je 0x4b9e
movq %r14, %rdi
movl %ebx, %esi
callq 0x3e32
movl %eax, %r13d
movq %r15, %rdi
callq 0x20b0
cmpl $0xb, %r13d
jne 0x4ba6
movq %r14, %rdi
movl %ebx, %esi
movl %ebp, %edx
callq 0x3e44
jmp 0x4ba6
movq %r15, %rdi
callq 0x20b0
incl %ebx
jmp 0x4b4d
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4bca
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x3bbe
jmp 0x4bd7
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20b0
movq %rbx, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O2/moloch--[P]cli-Blackjack/./Blackjack/Player.cpp
// Function: Player::turn(Deck&)
void Player::turn(Deck & deck)
{
	playTurn = true;
	while (playTurn)
	{
		printCurrentHand();
		cout << "Do you want to hit or stay? ";
		getline(cin, playerInput);
		if (playerInput == "h" || playerInput == "hit" || playerInput == "Hit")
		{
			hit(deck.deal());
			playTurn = !isBust(); // If the player busts, end their turn
		}
		else
		{
			playTurn = false; // User wants to stay, end their turn
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x60(%rdi), %r15
leaq 0x20(%rdi), %r12
movb $0x1, %al
leaq 0x170b(%rip), %rbp      # 0x6310
leaq 0x8(%rsp), %r13
movb %al, 0x8(%r14)
testb $0x1, %al
je 0x4ca6
movq %r15, %rdi
callq 0x3ebe
movq 0x53ab(%rip), %rdi      # 0x9fd0
leaq 0x16c7(%rip), %rsi      # 0x62f3
callq 0x2180
movq 0x53a8(%rip), %rdi      # 0x9fe0
movq %r12, %rsi
callq 0x2030
movq %r12, %rdi
movq %rbp, %rsi
callq 0x2f85
testb %al, %al
jne 0x4c79
movq %r12, %rdi
leaq 0x16b9(%rip), %rsi      # 0x6312
callq 0x2f85
testb %al, %al
jne 0x4c79
movq %r12, %rdi
leaq 0x16aa(%rip), %rsi      # 0x6316
callq 0x2f85
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
je 0x4c0a
movq %r13, %rdi
movq %rbx, %rsi
callq 0x51aa
movq %r14, %rdi
movq %r13, %rsi
callq 0x4a72
movq %r13, %rdi
callq 0x3bbe
movq %r14, %rdi
callq 0x4a28
xorb $0x1, %al
jmp 0x4c0a
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3bbe
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/moloch--[P]cli-Blackjack/./Blackjack/Player.cpp
// Function: Player::getWager()
int Player::getWager()
{
	if (getMoney() > 50)
	{
		wager = 0;
		while(wager < 50 || getMoney() < wager)
		{
			cout << "How much would you like to wager (min. $50)? " << endl;
			cout << "You have $" << getMoney() << ": ";
			cin >> wager;
			cin.ignore();  // Drop newline char
		}
	}
	else
	{
		wager = getMoney();
	}
	cout << "Your wager is: $" << wager << endl;
	return wager;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x10(%rdi), %eax
leaq 0x14(%rdi), %r14
cmpl $0x33, %eax
jl 0x4d62
andl $0x0, (%r14)
xorl %ecx, %ecx
movq 0x52df(%rip), %r15      # 0x9fd0
leaq 0x1650(%rip), %r13      # 0x6348
leaq 0x169c(%rip), %rbp      # 0x639b
movq 0x52da(%rip), %r12      # 0x9fe0
cmpl $0x32, %ecx
jl 0x4d0f
cmpl %ecx, %eax
jge 0x4d65
movq %r15, %rdi
leaq 0x1601(%rip), %rsi      # 0x631a
callq 0x2180
movq %rax, %rdi
callq 0x20c0
movq %r15, %rdi
movq %r13, %rsi
callq 0x2180
movl 0x10(%rbx), %esi
movq %rax, %rdi
callq 0x2250
movq %rax, %rdi
movq %rbp, %rsi
callq 0x2180
movq %r12, %rdi
movq %r14, %rsi
callq 0x2100
movq %r12, %rdi
callq 0x2280
movl 0x10(%rbx), %eax
movl 0x14(%rbx), %ecx
jmp 0x4d06
movl %eax, (%r14)
movq 0x5264(%rip), %rdi      # 0x9fd0
leaq 0x15e0(%rip), %rsi      # 0x6353
callq 0x2180
movl 0x14(%rbx), %esi
movq %rax, %rdi
callq 0x2250
movq %rax, %rdi
callq 0x20c0
movl 0x14(%rbx), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/moloch--[P]cli-Blackjack/./Blackjack/Deck.cpp
// Function: Deck::Deck()
Deck::Deck()
{
	srand(time(NULL)); // Seed random number generator
    suits.push_back("hearts"); // Valid suits
    suits.push_back("clubs");
    suits.push_back("diamonds");
    suits.push_back("spades");
    faceCards.push_back("J"); // Valid non-numeric ranks
    faceCards.push_back("Q");
    faceCards.push_back("K");
    faceCards.push_back("A"); // The exact value of this card is dealt with in the hand
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r15
leaq 0x4fcb(%rip), %rax      # 0x9d90
movq %rax, (%rdi)
leaq 0x10(%rdi), %rbx
leaq 0x28(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x40(%rdi)
andq $0x0, 0x50(%rdi)
xorl %edi, %edi
callq 0x2160
movl %eax, %edi
callq 0x2170
leaq 0x12fd(%rip), %rsi      # 0x60fa
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x2f06
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x2ff8
leaq 0x8(%rsp), %rdi
callq 0x20b0
leaq 0x12ca(%rip), %rsi      # 0x60f4
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x2f06
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x2ff8
leaq 0x8(%rsp), %rdi
callq 0x20b0
leaq 0x12aa(%rip), %rsi      # 0x6101
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x2f06
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x2ff8
leaq 0x8(%rsp), %rdi
callq 0x20b0
leaq 0x1286(%rip), %rsi      # 0x610a
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x2f06
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x2ff8
leaq 0x8(%rsp), %rdi
callq 0x20b0
leaq 0x14bb(%rip), %rsi      # 0x636c
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x2f06
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x2ff8
leaq 0x8(%rsp), %rdi
callq 0x20b0
leaq 0x1490(%rip), %rsi      # 0x636e
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x2f06
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x2ff8
leaq 0x8(%rsp), %rdi
callq 0x20b0
leaq 0x1465(%rip), %rsi      # 0x6370
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x2f06
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x2ff8
leaq 0x8(%rsp), %rdi
callq 0x20b0
leaq 0x13b9(%rip), %rsi      # 0x62f1
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x2f06
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x2ff8
leaq 0x8(%rsp), %rdi
callq 0x20b0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x4f86
jmp 0x4f95
jmp 0x4f86
jmp 0x4f95
jmp 0x4f86
jmp 0x4f95
jmp 0x4f86
jmp 0x4f95
jmp 0x4f86
jmp 0x4f95
jmp 0x4f86
jmp 0x4f95
jmp 0x4f86
jmp 0x4f95
movq %rax, %r12
leaq 0x8(%rsp), %rdi
callq 0x20b0
jmp 0x4f98
movq %rax, %r12
addq $0x40, %r15
movq %r15, %rdi
callq 0x44fe
movq %r14, %rdi
callq 0x2f42
movq %rbx, %rdi
callq 0x2f42
movq %r12, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/moloch--[P]cli-Blackjack/./Blackjack/Deck.cpp
// Function: Deck::initialize()
void Deck::initialize()
{
	reset();
    deckCounter = 0; // Location in deck
    // Iterate through each suit, creating cards on the way
    for(unsigned int suitIndex = 0;suitIndex < suits.size();++suitIndex)
    {
        // Create number cards for the current suit
        for(int numberIndex = 2;numberIndex <= 10;++numberIndex)
        {
            Card card(suits[suitIndex], numberIndex, numberIndex);
            deckOfCards.push_back(card);
        }
        // Create face cards for the current suit
        for(unsigned int faceIndex = 0;faceIndex < faceCards.size();++faceIndex)
        {
            Card card(suits[suitIndex], 10, faceCards[faceIndex]);
            deckOfCards.push_back(card);
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %rbx
callq 0x5000
andl $0x0, 0x8(%rbx)
leaq 0x40(%rbx), %r14
xorl %r12d, %r12d
leaq 0x78(%rsp), %r13
movl %r12d, %r12d
movq 0x30(%rbx), %rax
subq 0x28(%rbx), %rax
sarq $0x5, %rax
cmpq %r12, %rax
jbe 0x5158
movq %r12, 0x8(%rsp)
movq %r12, %rbp
shlq $0x5, %rbp
pushq $0x2
popq %r15
leaq 0x58(%rsp), %r12
cmpl $0xb, %r15d
je 0x50bc
movq 0x28(%rbx), %rsi
addq %rbp, %rsi
movq %r12, %rdi
callq 0x21f0
movq %r13, %rdi
movq %r12, %rsi
movl %r15d, %edx
movl %r15d, %ecx
callq 0x3adc
movq %r12, %rdi
callq 0x20b0
movq %r14, %rdi
movq %r13, %rsi
callq 0x4520
movq %r13, %rdi
callq 0x3bbe
incl %r15d
jmp 0x5076
xorl %r15d, %r15d
movq %rbp, 0x10(%rsp)
movl %r15d, %r15d
movq 0x18(%rbx), %rax
subq 0x10(%rbx), %rax
sarq $0x5, %rax
cmpq %r15, %rax
jbe 0x514b
movq %r14, %r12
movq 0x28(%rbx), %rsi
addq %rbp, %rsi
leaq 0x38(%rsp), %rbp
movq %rbp, %rdi
callq 0x21f0
movq %r15, %rsi
shlq $0x5, %rsi
addq 0x10(%rbx), %rsi
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0x21f0
movq %r13, %rdi
movq %rbp, %rsi
pushq $0xa
popq %rdx
movq %r14, %rcx
callq 0x39f2
movq %r14, %rdi
callq 0x20b0
movq %rbp, %rdi
callq 0x20b0
movq %r12, %r14
movq %r12, %rdi
movq %r13, %rsi
callq 0x4520
movq %r13, %rdi
callq 0x3bbe
incl %r15d
movq 0x10(%rsp), %rbp
jmp 0x50c4
movq 0x8(%rsp), %r12
incl %r12d
jmp 0x5049
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5194
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x20b0
jmp 0x517e
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
jmp 0x518d
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x20b0
jmp 0x51a1
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0x3bbe
movq %rbx, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O2/moloch--[P]cli-Blackjack/./Blackjack/main.cpp
// Function: main
int main()
{
	string playAgain;
	bool playGame = true;
	Blackjack game;
	while (playGame)
	{
		game.playGame();
		cout << "Would you like to play again? [Y/n]: ";
		getline(cin, playAgain);
		if (playAgain != "y" && playAgain != "Y") // Only check affirmative
		{
			playGame = false; // Stop playing game
		}
	}
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x28(%rsp), %rdi
callq 0x3278
leaq 0x28(%rsp), %rbx
movq 0x4c60(%rip), %r14      # 0x9fd0
leaq 0x1001(%rip), %r15      # 0x6378
movq 0x4c62(%rip), %r12      # 0x9fe0
leaq 0x8(%rsp), %r13
leaq 0x1014(%rip), %rbp      # 0x639e
movq %rbx, %rdi
callq 0x384c
movq %r14, %rdi
movq %r15, %rsi
callq 0x2180
movq %r12, %rdi
movq %r13, %rsi
callq 0x2030
movq %r13, %rdi
movq %rbp, %rsi
callq 0x5416
testb %al, %al
je 0x538a
movq %r13, %rdi
leaq 0xfdf(%rip), %rsi       # 0x63a0
callq 0x5416
testb %al, %al
je 0x538a
leaq 0x28(%rsp), %rdi
callq 0x32f4
leaq 0x8(%rsp), %rdi
callq 0x20b0
xorl %eax, %eax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x5404
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x32f4
leaq 0x8(%rsp), %rdi
callq 0x20b0
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/nesro[P]NCursesGomoku/src/main.cpp
// Function: main
int main(int argc, char *argv[]) {
	CGame *game = NULL;
	try {
		game = new CGame(argc, argv);
		for (;;) {
			switch (game->m_Status) {
			case CGame::STATUS_TURN:
				game->playerMove();
				game->renderBoard();
				game->checkForWin();

				break;
			case CGame::STATUS_MENU:
				game->showMenu();

				break;
			case CGame::STATUS_EXIT:
				game->networkCleanup();
				delete game;
				return EXIT_SUCCESS;
			default:
				break;
			}
		}
	} catch (std::exception & e) {
		delete game;
		std::cerr << "Exception: " << e.what() << std::endl;
	}

	return EXIT_FAILURE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movl %edi, %ebp
xorl %r12d, %r12d
pushq $0x60
popq %rdi
callq 0x2220
movq %rax, %rbx
movq %rax, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x34c0
movl (%rbx), %eax
cmpl $0x1, %eax
je 0x2630
cmpl $0x2, %eax
je 0x2616
testl %eax, %eax
jne 0x2604
jmp 0x263a
movq %rbx, %rdi
callq 0x3bd0
movq %rbx, %rdi
callq 0x36cc
movq %rbx, %rdi
callq 0x3bf2
jmp 0x2604
movq %rbx, %rdi
callq 0x379a
jmp 0x2604
movq %rbx, %r12
movq %rbx, %rdi
callq 0x36a8
movq %rbx, %rdi
callq 0x3630
pushq $0x60
popq %rsi
movq %rbx, %rdi
callq 0x2230
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %r15
movq %rax, %r14
pushq $0x60
popq %rsi
movq %rbx, %rdi
callq 0x2230
xorl %ebx, %ebx
jmp 0x2689
movq %rdx, %r15
movq %rax, %r14
movq %r12, %rbx
jmp 0x2689
movq %rdx, %r15
movq %rax, %r14
cmpl $0x1, %r15d
jne 0x26f9
movq %r14, %rdi
callq 0x2100
movq %rax, %r14
testq %rbx, %rbx
je 0x26a7
movq %rbx, %rdi
callq 0x3630
pushq $0x60
popq %rsi
movq %rbx, %rdi
callq 0x2230
movq 0x6937(%rip), %rdi      # 0x8ff0
leaq 0x2944(%rip), %rsi      # 0x5004
callq 0x2210
movq %rax, %rbx
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2210
movq %rax, %rdi
callq 0x2140
callq 0x22f0
pushq $0x1
popq %rax
jmp 0x265a
movq %rax, %r14
callq 0x22f0
movq %r14, %rdi
callq 0x2320
movq %rax, %rdi
callq 0x2709
// File: /workspace/github_cpp_makefile_star2_O2/nesro[P]NCursesGomoku/src/ai.cpp
// Function: CAI::~CAI()
CAI::~CAI(void) {
	for (int i = 0; i < STRATEGIES; i++) {
		delete[] m_Patterns[i];
	}

	delete[] m_Patterns;
	delete[] m_Moves;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x63a2(%rip), %rax      # 0x8bc8
movq %rax, (%rdi)
xorl %r14d, %r14d
movq 0x18(%rbx), %rdi
cmpq $0x15, %r14
je 0x2849
movq (%rdi,%r14,8), %rdi
testq %rdi, %rdi
je 0x2844
callq 0x2290
incq %r14
jmp 0x282c
testq %rdi, %rdi
je 0x2853
callq 0x2290
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x2861
callq 0x2290
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x401e
// File: /workspace/github_cpp_makefile_star2_O2/nesro[P]NCursesGomoku/src/board.cpp
// Function: CBoard::reset()
void CBoard::reset(void) {
	for (int i = 0; i < BOARD_WIDTH; i++) {
		for (int j = 0; j < BOARD_HEIGHT; j++) {
			m_Stones[i][j] = EMPTY_CELL;
		}
	}

	memset(m_Message, 0, MESSAGE_LENGTH + 1);

	m_LastStone.m_X = -1;
	m_LastStone.m_Y = -1;

	m_StonesOnBoard = 0;

	m_Cursor.m_X = (int) ((CURSOR_MAX + CURSOR_MIN) / 2);
	m_Cursor.m_Y = (int) ((CURSOR_MAX + CURSOR_MIN) / 2);
}

// Assembly:
leaq 0x38(%rdi), %rax
xorl %ecx, %ecx
pushq $-0xf
popq %rdx
cmpq $0xf, %rcx
je 0x2a7c
movq %rdx, %rsi
testq %rsi, %rsi
je 0x2a73
movb $0x5f, 0xf(%rax,%rsi)
incq %rsi
jmp 0x2a64
incq %rcx
addq $0xf, %rax
jmp 0x2a5b
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movb $0x0, 0x20(%rdi)
movaps 0x293f(%rip), %xmm0     # 0x53d0
movups %xmm0, 0x24(%rdi)
movl $0xa, 0x34(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/nesro[P]NCursesGomoku/src/board.cpp
// Function: CBoard::addStone(char, int, int)
bool CBoard::addStone(char mark, int x, int y) {

	if (x == -1) {
		x = m_Cursor.m_X - CURSOR_MIN;
	}

	if (y == -1) {
		y = m_Cursor.m_Y - CURSOR_MIN;
	}

	if (m_Stones[y][x] == EMPTY_CELL) {
		m_StonesOnBoard++;

		m_LastStone.m_X = y;
		m_LastStone.m_Y = x;

		m_Stones[y][x] = mark;
	} else {
		return false;
	}

	return true;
}

// Assembly:
movl 0x30(%rdi), %r8d
movl 0x34(%rdi), %eax
addl $-0x3, %r8d
cmpl $-0x1, %edx
cmovnel %edx, %r8d
addl $-0x3, %eax
cmpl $-0x1, %ecx
cmovnel %ecx, %eax
movslq %eax, %rcx
imulq $0xf, %rcx, %rdx
addq %rdi, %rdx
movslq %r8d, %r8
movb 0x38(%r8,%rdx), %cl
cmpb $0x5f, %cl
jne 0x2e1a
incl 0x24(%rdi)
addq %r8, %rdx
addq $0x38, %rdx
movl %eax, 0x28(%rdi)
movl %r8d, 0x2c(%rdi)
movb %sil, (%rdx)
cmpb $0x5f, %cl
sete %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/nesro[P]NCursesGomoku/src/board.cpp
// Function: CBoard::moveCursor(int)
void CBoard::moveCursor(int direction) {
	switch (direction) {
	case DIRECTION_UP:
		m_Cursor.m_Y--;
		if (m_Cursor.m_Y < CURSOR_MIN) {
			m_Cursor.m_Y = CURSOR_MAX;
		}
		break;
	case DIRECTION_DOWN:
		m_Cursor.m_Y++;
		if (m_Cursor.m_Y > CURSOR_MAX) {
			m_Cursor.m_Y = CURSOR_MIN;
		}
		break;
	case DIRECTION_LEFT:
		m_Cursor.m_X--;
		if (m_Cursor.m_X < CURSOR_MIN) {
			m_Cursor.m_X = CURSOR_MAX;
		}
		break;
	case DIRECTION_RIGHT:
		m_Cursor.m_X++;
		if (m_Cursor.m_X > CURSOR_MAX) {
			m_Cursor.m_X = CURSOR_MIN;
		}
		break;
	default:
		break;
	}

	move(m_Cursor.m_Y, m_Cursor.m_X * 2 - 1);
}

// Assembly:
cmpl $0x3, %esi
ja 0x2e81
movl %esi, %eax
leaq 0x25b0(%rip), %rcx      # 0x53e0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl 0x34(%rdi), %eax
leal -0x1(%rax), %ecx
cmpl $0x4, %eax
pushq $0x11
popq %rax
cmovgel %ecx, %eax
jmp 0x2e59
movl 0x34(%rdi), %eax
leal 0x1(%rax), %ecx
cmpl $0x11, %eax
pushq $0x3
popq %rax
cmovll %ecx, %eax
movl %eax, 0x34(%rdi)
jmp 0x2e81
movl 0x30(%rdi), %eax
leal 0x1(%rax), %ecx
cmpl $0x11, %eax
pushq $0x3
popq %rax
cmovll %ecx, %eax
jmp 0x2e7e
movl 0x30(%rdi), %eax
leal -0x1(%rax), %ecx
cmpl $0x4, %eax
pushq $0x11
popq %rax
cmovgel %ecx, %eax
movl %eax, 0x30(%rdi)
movl 0x30(%rdi), %eax
movl 0x34(%rdi), %edi
leal -0x1(,%rax,2), %esi
jmp 0x2170
nop
// File: /workspace/github_cpp_makefile_star2_O2/nesro[P]NCursesGomoku/src/board.cpp
// Function: CBoard::printMessage(char const*)
void CBoard::printMessage(const char * message) {
	mvprintw(22, 4, "                               ");
	strcpy(m_Message, message);
	mvprintw(22, 4, "%s", m_Message);
	move(m_Cursor.m_Y, m_Cursor.m_X * 2 - 1);
	refresh();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x2778(%rip), %rdx      # 0x5880
pushq $0x16
popq %rbp
pushq $0x4
popq %r15
movl %ebp, %edi
movl %r15d, %esi
xorl %eax, %eax
callq 0x22a0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x21f0
leaq 0x2256(%rip), %rdx      # 0x5383
movl %ebp, %edi
movl %r15d, %esi
movq %r14, %rcx
xorl %eax, %eax
callq 0x22a0
movl 0x30(%r14), %eax
movl 0x34(%r14), %edi
leal -0x1(,%rax,2), %esi
callq 0x2170
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2300
nop
// File: /workspace/github_cpp_makefile_star2_O2/nesro[P]NCursesGomoku/src/client.cpp
// Function: CClient::CClient(CBoard*, char, CGame*)
CClient::CClient(CBoard * board, char mark, CGame * game) :
CPlayer(board, mark), CNetwork(game) {

    if (m_Game->m_IsConnectionUp == true) {
        return;
    } else {
        m_Game->m_IsConnectionUp = true;
    }

    hostent * host;

    if ((host = gethostbyname(m_Game->m_Host.c_str())) == NULL) {
        throw CNetworkException("Fatal network error: Client host is invalid.");
    }

    if ((m_Game->m_ConnectionSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP))
            == -1) {
        throw CNetworkException("Fatal network error: Client socket error.");
    }

    sockaddr_in serverSock;

    serverSock.sin_family = AF_INET;
    serverSock.sin_port = htons(m_Game->m_Port);
    memcpy(&(serverSock.sin_addr), host->h_addr, host->h_length);

    if (connect(m_Game->m_ConnectionSocket, (sockaddr *) & serverSock,
            sizeof (serverSock)) == -1) {
        throw CNetworkException("Fatal network error: Client connect failed.");
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r15
movq %rdi, %rbx
callq 0x4004
leaq 0x18(%rbx), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x3eb0
leaq 0x5a7b(%rip), %rax      # 0x8c08
movq %rax, (%rbx)
movq 0x20(%rbx), %rax
cmpb $0x0, 0x10(%rax)
jne 0x3204
movb $0x1, 0x10(%rax)
movq 0x18(%rax), %rdi
callq 0x2250
movq %rax, %r15
testq %rax, %rax
je 0x3211
pushq $0x2
popq %rdi
pushq $0x1
popq %rsi
pushq $0x6
popq %rdx
callq 0x2080
movl %eax, %ebp
movq 0x20(%rbx), %rax
movl %ebp, 0xc(%rax)
cmpl $-0x1, %ebp
je 0x322d
leaq 0x4(%rsp), %rdi
movw $0x2, -0x4(%rdi)
movzwl 0x38(%rax), %eax
rolw $0x8, %ax
movw %ax, -0x2(%rdi)
movq 0x18(%r15), %rax
movq (%rax), %rsi
movslq 0x14(%r15), %rdx
callq 0x21b0
movq %rsp, %rsi
pushq $0x10
popq %rdx
movl %ebp, %edi
callq 0x21c0
cmpl $-0x1, %eax
je 0x325d
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
pushq $0x28
popq %rdi
callq 0x2150
movq %rax, %r12
leaq 0x267d(%rip), %rsi      # 0x58a0
movq %rax, %rdi
callq 0x3ebc
jmp 0x3247
pushq $0x28
popq %rdi
callq 0x2150
movq %rax, %r12
leaq 0x268e(%rip), %rsi      # 0x58cd
movq %rax, %rdi
callq 0x3ebc
leaq 0x5a82(%rip), %rsi      # 0x8cd0
leaq 0xca1(%rip), %rdx       # 0x3ef6
movq %r12, %rdi
callq 0x2310
pushq $0x28
popq %rdi
callq 0x2150
movq %rax, %r12
leaq 0x2688(%rip), %rsi      # 0x58f7
movq %rax, %rdi
callq 0x3ebc
leaq 0x5a52(%rip), %rsi      # 0x8cd0
leaq 0xc71(%rip), %rdx       # 0x3ef6
movq %r12, %rdi
callq 0x2310
jmp 0x3291
jmp 0x3291
movq %rax, %r15
movq %r12, %rdi
callq 0x2190
jmp 0x32a3
jmp 0x32a0
movq %rax, %r15
movq %r14, %rdi
callq 0x3eb8
jmp 0x32b0
movq %rax, %r15
movq %rbx, %rdi
callq 0x401e
movq %r15, %rdi
callq 0x2320