LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/sangwoojun[P]rv32emulator/./linenoise.hpp
// Function: linenoise::unicodeColumnPos(char const*, int)
inline int unicodeColumnPos(const char* buf, int buf_len)
{
    int ret = 0;

    int off = 0;
    while (off < buf_len) {
        int len;
        if (isAnsiEscape(buf + off, buf_len - off, &len)) {
            off += len;
            continue;
        }

        int cp = 0;
        len = unicodeUTF8CharToCodePoint(buf + off, buf_len - off, &cp);

        if (!unicodeIsCombiningChar(cp)) {
            ret += unicodeIsWideChar(cp) ? 2 : 1;
        }

        off += len;
    }

    return ret;
}

// Assembly:
testl %esi, %esi
jle 0x712c
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
xorl %ecx, %ecx
movabsq $0x1020000c06ff, %rdx   # imm = 0x1020000C06FF
leaq 0x11e5(%rip), %r8       # 0x8180
leaq 0x42de(%rip), %r9       # 0xb280
xorl %eax, %eax
movslq %ecx, %r11
leaq (%rdi,%r11), %r10
movl %esi, %r14d
subl %r11d, %r14d
cmpl $0x3, %r14d
jl 0x6fea
cmpw $0x5b1b, (%r10)         # imm = 0x5B1B
jne 0x6ff9
movl %r14d, %ebx
movl $0x2, %r11d
cmpq %r11, %rbx
je 0x6fea
movzbl (%r10,%r11), %r15d
incq %r11
addl $-0x41, %r15d
cmpl $0x2c, %r15d
ja 0x6fc8
btq %r15, %rdx
jae 0x6fc8
jmp 0x711a
cmpl %ecx, %esi
jne 0x6ff9
xorl %r15d, %r15d
xorl %r11d, %r11d
jmp 0x70d5
movzbl (%r10), %ebx
testb %bl, %bl
js 0x700f
movl $0x1, %r11d
movl %ebx, %r15d
jmp 0x70d5
movl %ebx, %r11d
andl $-0x20, %r11d
cmpl $0xc0, %r11d
jne 0x703c
cmpl $0x2, %r14d
jl 0x6fee
andl $0x1f, %ebx
shll $0x6, %ebx
movl $0x2, %r11d
movl $0x1, %r14d
jmp 0x70c9
movl %ebx, %r11d
andl $-0x10, %r11d
cmpl $0xe0, %r11d
jne 0x7076
cmpl $0x3, %r14d
jl 0x6fee
andl $0xf, %ebx
shll $0xc, %ebx
movzbl 0x1(%r10), %r11d
andl $0x3f, %r11d
shll $0x6, %r11d
orl %r11d, %ebx
movl $0x3, %r11d
movl $0x2, %r14d
jmp 0x70c9
xorl %r15d, %r15d
cmpl $0x4, %r14d
jl 0x6ff1
movl %ebx, %r14d
andl $-0x8, %r14d
movl $0x0, %r11d
cmpl $0xf0, %r14d
jne 0x70d5
andl $0x7, %ebx
shll $0x12, %ebx
movzbl 0x1(%r10), %r11d
andl $0x3f, %r11d
shll $0xc, %r11d
orl %ebx, %r11d
movzbl 0x2(%r10), %ebx
andl $0x3f, %ebx
shll $0x6, %ebx
orl %r11d, %ebx
movl $0x4, %r11d
movl $0x3, %r14d
movzbl (%r10,%r14), %r15d
andl $0x3f, %r15d
orl %ebx, %r15d
movl %r15d, %r10d
xorl %ebx, %ebx
cmpq %r10, (%rbx,%r8)
je 0x711a
addq $0x8, %rbx
cmpq $0x30f8, %rbx           # imm = 0x30F8
jne 0x70da
xorl %ebx, %ebx
cmpq %r10, (%rbx,%r9)
ja 0x70fc
cmpq %r10, 0x8(%rbx,%r9)
jae 0x7111
addq $0x10, %rbx
cmpq $0x200, %rbx            # imm = 0x200
jne 0x70ef
movl $0x1, %r10d
jmp 0x7117
movl $0x2, %r10d
addl %r10d, %eax
addl %r11d, %ecx
cmpl %esi, %ecx
jl 0x6fa4
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x648e
movq %r12, %rdi
movq %r14, %rsi
callq 0x5a64
leaq 0xf8(%rsp), %rdi
callq 0x455c
leaq 0xa8(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x648e
movq %r12, %rdi
movq %r14, %rsi
callq 0x5a64
leaq 0xa8(%rsp), %rdi
callq 0x455c
leaq 0x58(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x648e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5a64
leaq 0x58(%rsp), %rdi
callq 0x455c
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x648e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5a64
leaq 0x8(%rsp), %rdi
callq 0x455c
movq %rbx, %rdi
callq 0x5a2c
addq $0x148, %rsp            # imm = 0x148
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x39d4
jmp 0x39d4
jmp 0x39d4
movq %rax, %rbx
movq %r14, %rdi
callq 0x455c
movq %rbx, %rdi
callq 0x2230
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x160, %rsp            # imm = 0x160
movq %rdi, %rbx
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x31ff(%rip), %rsi      # 0x7282
leaq 0x3200(%rip), %rdx      # 0x728a
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x3700
leaq 0xd0(%rsp), %rdi
movq %r14, %rsi
callq 0x4690
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x40be
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x2180
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x31bd(%rip), %rsi      # 0x728b
leaq 0x31c0(%rip), %rdx      # 0x7295
movq %rsp, %rdi
callq 0x3700
leaq 0x40(%rsp), %rdi
movq %rsp, %rsi
callq 0x5770
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x4100
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2180
leaq 0x40(%rsp), %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x5efc
leaq 0x40(%rsp), %r14
leaq 0xd0(%rsp), %r15
movq %r14, %rdi
callq 0x5ef8
testl %eax, %eax
jle 0x4138
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x3cdc
jmp 0x411c
movq 0x6e91(%rip), %rbx      # 0xafd0
leaq 0x3150(%rip), %rsi      # 0x7296
movl $0x23, %edx
movq %rbx, %rdi
callq 0x2190
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq 0x6e5f(%rip), %rdi      # 0xafd0
callq 0x2030
movq %rax, %rdi
callq 0x20f0
leaq 0x40(%rsp), %rdi
callq 0x5980
leaq 0xd0(%rsp), %rdi
callq 0x4722
addq $0x160, %rsp            # imm = 0x160
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x41ed
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2180
jmp 0x41ed
movq %rax, %rbx
jmp 0x41ed
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x41fa
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x2180
jmp 0x41fa
jmp 0x41e0
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x5980
leaq 0xd0(%rsp), %rdi
callq 0x4722
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r12
movq %rdi, %r15
leaq 0x69f1(%rip), %rax      # 0xacc0
movq %rax, (%rdi)
leaq 0x10(%rdi), %rbx
leaq 0x20(%rdi), %rax
movq %rax, (%rsp)
movq %rax, 0x10(%rdi)
xorl %eax, %eax
movq %rax, 0x18(%rdi)
movb %al, 0x20(%rdi)
leaq 0x30(%rdi), %r14
leaq 0x40(%rdi), %rbp
movq %rbp, 0x30(%rdi)
movq %rax, 0x38(%rdi)
movb %al, 0x40(%rdi)
movl %edx, 0x8(%rdi)
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x28(%rsp), %rdi
movq %rax, %rsi
callq 0x33fa
leaq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0x20c0
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x4345
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2180
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x33fa
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x20c0
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x4388
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2180
movb $0x0, 0xc(%r15)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x43cf
movq 0x18(%rsp), %rsi
jmp 0x43c2
movq %rax, %r15
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x43cf
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2180
jmp 0x43cf
movq %rax, %r15
movq (%r14), %rdi
cmpq %rbp, %rdi
je 0x43e3
movq (%rbp), %rsi
incq %rsi
callq 0x2180
movq (%rbx), %rdi
cmpq (%rsp), %rdi
je 0x43fb
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x2180
movq %r15, %rdi
callq 0x2230
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebp
movq %rdi, %rbx
leaq 0x688a(%rip), %rax      # 0xacc0
movq %rax, (%rdi)
leaq 0x20(%rdi), %r12
movq %r12, 0x10(%rdi)
xorl %eax, %eax
movq %rax, 0x18(%rdi)
movb %al, 0x20(%rdi)
leaq 0x30(%rdi), %r14
leaq 0x40(%rdi), %r13
movq %r13, 0x30(%rdi)
movq %rax, 0x38(%rdi)
movb %al, 0x40(%rdi)
movl %edx, 0x8(%rdi)
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x33fa
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x20c0
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x44a4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2180
movq %rbx, %rdi
movl %ebp, %esi
callq 0x4512
movb $0x0, 0xc(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbp
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x44e0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2180
jmp 0x44e0
movq %rax, %rbp
movq (%r14), %rdi
cmpq %r13, %rdi
je 0x44f4
movq (%r13), %rsi
incq %rsi
callq 0x2180
movq 0x10(%rbx), %rdi
cmpq %r12, %rdi
je 0x4509
movq (%r12), %rsi
incq %rsi
callq 0x2180
movq %rbp, %rdi
callq 0x2230
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x0, 0x8(%rdi)
movq 0x18(%rdi), %rdi
cmpq %rdi, 0x20(%rbx)
je 0x4870
movl $0x1, %ebp
xorl %eax, %eax
movabsq $-0x3333333333333333, %r15 # imm = 0xCCCCCCCCCCCCCCCD
leaq (%rax,%rax,4), %r14
shlq $0x4, %r14
addq %r14, %rdi
callq 0x4686
testb %al, %al
jne 0x484f
addq 0x18(%rbx), %r14
movq %r14, %rdi
callq 0x45b6
addl %eax, 0x8(%rbx)
movl %ebp, %eax
movq 0x18(%rbx), %rdi
movq 0x20(%rbx), %rcx
subq %rdi, %rcx
sarq $0x4, %rcx
imulq %r15, %rcx
incl %ebp
cmpq %rax, %rcx
ja 0x482c
movl 0x8(%rbx), %eax
jmp 0x4872
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x248c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4a10
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4b32
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4d80
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4ff0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x523e
movq 0x663c(%rip), %rdi      # 0xafd0
leaq 0x2938(%rip), %rsi      # 0x72d3
movl $0xd, %edx
callq 0x2190
movq %rbx, %rdi
callq 0x4800
movq 0x661c(%rip), %rdi      # 0xafd0
movl %eax, %esi
callq 0x2220
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
leaq 0x8(%rsp), %rdi
callq 0x2d3e
addq $0xf8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2d3e
movq %rbx, %rdi
callq 0x2230
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movq %rsi, %rdi
callq 0x3284
testl %eax, %eax
je 0x4afc
xorl %ebp, %ebp
movq 0x6593(%rip), %r15      # 0xafd0
movabsq $-0x3333333333333333, %r12 # imm = 0xCCCCCCCCCCCCCCCD
movq 0x20(%r14), %rax
cmpq 0x18(%r14), %rax
je 0x4ac3
movl $0x1, %r13d
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x2de2
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r15, %rdi
callq 0x2190
movl $0x1, %edx
movq %rax, %rdi
leaq 0x2915(%rip), %rsi      # 0x739c
callq 0x2190
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x4aa8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2180
movl %r13d, %eax
movq 0x20(%r14), %rcx
subq 0x18(%r14), %rcx
sarq $0x4, %rcx
imulq %r12, %rcx
incl %r13d
cmpq %rax, %rcx
ja 0x4a57
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
incl %ebp
movq %rbx, %rdi
callq 0x3284
cmpl %eax, %ebp
jb 0x4a47
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x4b2a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2180
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O3/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 %rdi, %r14
movq 0x18(%rdi), %rdi
cmpq %rdi, 0x20(%r14)
je 0x4cbb
movq %rsi, %rbx
movl $0x1, %r15d
xorl %eax, %eax
leaq 0x28(%rsp), %r12
leaq 0x48(%rsp), %r13
leaq (%rax,%rax,4), %rbp
shlq $0x4, %rbp
addq %rbp, %rdi
callq 0x4686
testb %al, %al
je 0x4c0e
leaq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
movq %r12, %rdi
leaq 0x274f(%rip), %rsi      # 0x72e1
leaq 0x2749(%rip), %rdx      # 0x72e2
callq 0x3700
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x2e82
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x6411(%rip), %rdi      # 0xafd0
callq 0x2190
movl $0x1, %edx
movq %rax, %rdi
leaq 0x27c9(%rip), %rsi      # 0x739c
callq 0x2190
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x4bf4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2180
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x4c8f
movq 0x38(%rsp), %rsi
jmp 0x4c87
addq 0x18(%r14), %rbp
movq %r13, %rdi
movq %rbp, %rsi
callq 0x4662
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x2e82
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x6392(%rip), %rdi      # 0xafd0
callq 0x2190
movl $0x1, %edx
movq %rax, %rdi
leaq 0x274a(%rip), %rsi      # 0x739c
callq 0x2190
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x4c73
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2180
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x4c8f
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x2180
movl %r15d, %eax
movq 0x18(%r14), %rdi
movq 0x20(%r14), %rcx
subq %rdi, %rcx
sarq $0x4, %rcx
movabsq $-0x3333333333333333, %rdx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rdx, %rcx
incl %r15d
cmpq %rax, %rcx
ja 0x4b66
movq 0x630e(%rip), %rbx      # 0xafd0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x4d77
movq %rax, %rbx
jmp 0x4d26
movq %rax, %rbx
jmp 0x4d5b
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x4d26
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2180
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x4d77
movq 0x58(%rsp), %rsi
jmp 0x4d6f
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x4d5b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2180
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x4d77
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2180
movq %rbx, %rdi
callq 0x2230
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rdi, %r14
movq 0x18(%rdi), %rdi
cmpq %rdi, 0x20(%r14)
je 0x5179
movq %rsi, %rbx
movl $0x1, %r15d
xorl %eax, %eax
leaq 0x28(%rsp), %r12
leaq 0x48(%rsp), %r13
leaq (%rax,%rax,4), %rbp
shlq $0x4, %rbp
addq %rbp, %rdi
callq 0x4686
testb %al, %al
je 0x50cc
leaq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
movq %r12, %rdi
leaq 0x2291(%rip), %rsi      # 0x72e1
leaq 0x228b(%rip), %rdx      # 0x72e2
callq 0x3700
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x2fac
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x5f53(%rip), %rdi      # 0xafd0
callq 0x2190
movl $0x1, %edx
movq %rax, %rdi
leaq 0x230b(%rip), %rsi      # 0x739c
callq 0x2190
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x50b2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2180
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x514d
movq 0x38(%rsp), %rsi
jmp 0x5145
addq 0x18(%r14), %rbp
movq %r13, %rdi
movq %rbp, %rsi
callq 0x4662
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x2fac
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x5ed4(%rip), %rdi      # 0xafd0
callq 0x2190
movl $0x1, %edx
movq %rax, %rdi
leaq 0x228c(%rip), %rsi      # 0x739c
callq 0x2190
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x5131
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2180
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x514d
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x2180
movl %r15d, %eax
movq 0x18(%r14), %rdi
movq 0x20(%r14), %rcx
subq %rdi, %rcx
sarq $0x4, %rcx
movabsq $-0x3333333333333333, %rdx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rdx, %rcx
incl %r15d
cmpq %rax, %rcx
ja 0x5024
movq 0x5e50(%rip), %rbx      # 0xafd0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x5235
movq %rax, %rbx
jmp 0x51e4
movq %rax, %rbx
jmp 0x5219
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x51e4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2180
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x5235
movq 0x58(%rsp), %rsi
jmp 0x522d
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x5219
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2180
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x5235
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2180
movq %rbx, %rdi
callq 0x2230
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movq %rsi, %rdi
callq 0x32a6
testl %eax, %eax
je 0x532a
xorl %ebp, %ebp
movq 0x5d65(%rip), %r15      # 0xafd0
movabsq $-0x3333333333333333, %r12 # imm = 0xCCCCCCCCCCCCCCCD
movq 0x20(%r14), %rax
cmpq 0x18(%r14), %rax
je 0x52f1
movl $0x1, %r13d
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x2e32
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r15, %rdi
callq 0x2190
movl $0x1, %edx
movq %rax, %rdi
leaq 0x20e7(%rip), %rsi      # 0x739c
callq 0x2190
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x52d6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2180
movl %r13d, %eax
movq 0x20(%r14), %rcx
subq 0x18(%r14), %rcx
sarq $0x4, %rcx
imulq %r12, %rcx
incl %r13d
cmpq %rax, %rcx
ja 0x5285
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
incl %ebp
movq %rbx, %rdi
callq 0x32a6
cmpl %eax, %ebp
jb 0x5275
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x5358
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2180
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O3/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, %r14
movq %rdi, %rbx
movb $0x1, 0x8(%rdi)
leaq 0x60(%rdi), %r15
leaq 0x20(%rdi), %r12
movq 0x52fd(%rip), %r13      # 0xafe0
leaq 0x8(%rsp), %rbp
movq %r15, %rdi
callq 0x4934
movl $0x1c, %edx
movq 0x52d4(%rip), %rdi      # 0xafd0
leaq 0x15f0(%rip), %rsi      # 0x72f3
callq 0x2190
movq (%r13), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %edx
movq %r13, %rdi
movq %r12, %rsi
callq 0x2260
movq %r12, %rdi
leaq 0x15db(%rip), %rsi      # 0x7310
callq 0x2060
testl %eax, %eax
je 0x5d64
movq %r12, %rdi
leaq 0x15ca(%rip), %rsi      # 0x7312
callq 0x2060
testl %eax, %eax
je 0x5d64
movq %r12, %rdi
leaq 0x15bb(%rip), %rsi      # 0x7316
callq 0x2060
testl %eax, %eax
jne 0x5d99
movq %rbp, %rdi
movq %r14, %rsi
callq 0x648e
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x5a64
movq %rbp, %rdi
callq 0x455c
movq %r15, %rdi
callq 0x4800
cmpl $0x16, %eax
setl 0x8(%rbx)
jl 0x5ce8
jmp 0x5d9d
movb $0x0, 0x8(%rbx)
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x455c
movq %rbx, %rdi
callq 0x2230
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5e93
movl $0x0, (%r14)
movq 0x51e2(%rip), %r15      # 0xafd0
leaq 0x1553(%rip), %r13      # 0x7348
leaq 0x159f(%rip), %rbp      # 0x739b
movq 0x51dd(%rip), %r12      # 0xafe0
movl $0x2d, %edx
movq %r15, %rdi
leaq 0x1508(%rip), %rsi      # 0x731a
callq 0x2190
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
movl $0xa, %edx
movq %r15, %rdi
movq %r13, %rsi
callq 0x2190
movl 0x10(%rbx), %esi
movq %r15, %rdi
callq 0x2220
movl $0x2, %edx
movq %rax, %rdi
movq %rbp, %rsi
callq 0x2190
movq %r12, %rdi
movq %r14, %rsi
callq 0x20e0
movq %r12, %rdi
callq 0x2250
movl 0x14(%rbx), %eax
cmpl $0x32, %eax
jl 0x5e03
cmpl %eax, 0x10(%rbx)
jl 0x5e03
jmp 0x5e96
movl %eax, (%r14)
movq 0x5133(%rip), %r14      # 0xafd0
leaq 0x14af(%rip), %rsi      # 0x7353
movl $0x10, %edx
movq %r14, %rdi
callq 0x2190
movl 0x14(%rbx), %esi
movq %r14, %rdi
callq 0x2220
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
movl 0x14(%rbx), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x28(%rsp), %rdi
callq 0x3798
leaq 0x28(%rsp), %rbx
movq 0x487d(%rip), %r14      # 0xafd0
leaq 0xc1e(%rip), %r15       # 0x7378
movq 0x487f(%rip), %r12      # 0xafe0
leaq 0x8(%rsp), %r13
leaq 0xc31(%rip), %rbp       # 0x739e
movq %rbx, %rdi
callq 0x4064
movl $0x25, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2190
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %edx
movq %r12, %rdi
movq %r13, %rsi
callq 0x2260
movq %r13, %rdi
movq %rbp, %rsi
callq 0x2060
testl %eax, %eax
je 0x676d
movq %r13, %rdi
leaq 0xbdf(%rip), %rsi       # 0x73a0
callq 0x2060
testl %eax, %eax
je 0x676d
leaq 0x28(%rsp), %rdi
callq 0x3856
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x67f0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2180
xorl %eax, %eax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x6816
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x3856
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x6832
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2180
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O3/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
movl $0x60, %edi
callq 0x2220
movq %rax, %rbx
movq %rax, %rdi
movl %ebp, %esi
movq %r14, %rdx
callq 0x35e4
movl (%rbx), %eax
cmpl $0x1, %eax
je 0x2642
cmpl $0x2, %eax
je 0x2628
testl %eax, %eax
jne 0x2616
jmp 0x264c
movq %rbx, %rdi
callq 0x3eaa
movq %rbx, %rdi
callq 0x3884
movq %rbx, %rdi
callq 0x3ecc
jmp 0x2616
movq %rbx, %rdi
callq 0x3972
jmp 0x2616
movq %rbx, %r12
movq %rbx, %rdi
callq 0x3860
movq %rbx, %rdi
callq 0x37a4
movl $0x60, %esi
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
movl $0x60, %esi
movq %rbx, %rdi
callq 0x2230
xorl %ebx, %ebx
jmp 0x269f
movq %rdx, %r15
movq %rax, %r14
movq %r12, %rbx
jmp 0x269f
movq %rdx, %r15
movq %rax, %r14
cmpl $0x1, %r15d
jne 0x2719
movq %r14, %rdi
callq 0x2100
movq %rax, %r14
testq %rbx, %rbx
je 0x26bd
movq %rbx, %rdi
callq 0x37a4
movl $0x60, %esi
movq %rbx, %rdi
callq 0x2230
movq 0x691f(%rip), %rdi      # 0x8ff0
leaq 0x292c(%rip), %rsi      # 0x5004
movl $0xb, %edx
callq 0x2260
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq 0x68fe(%rip), %rdi      # 0x8ff0
movq %rax, %rsi
callq 0x2210
movq %rax, %rdi
callq 0x2130
callq 0x2310
movl $0x1, %eax
jmp 0x266e
movq %rax, %r14
callq 0x2310
movq %r14, %rdi
callq 0x2340
movq %rax, %rdi
callq 0x2729
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbx
movq %rdi, %rbx
addq $0x38, %rdi
movl $0xe1, %edx
movl $0x5f, %esi
callq 0x2160
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movups %xmm0, 0x10(%rbx)
movb $0x0, 0x20(%rbx)
movaps 0x28da(%rip), %xmm0     # 0x53d0
movups %xmm0, 0x24(%rbx)
movl $0xa, 0x34(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x2679(%rip), %rdx      # 0x5880
movl $0x16, %edi
movl $0x4, %esi
xorl %eax, %eax
callq 0x22b0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x21f0
leaq 0x2159(%rip), %rdx      # 0x5383
movl $0x16, %edi
movl $0x4, %esi
movq %r14, %rcx
xorl %eax, %eax
callq 0x22b0
movl 0x30(%r14), %eax
movl 0x34(%r14), %edi
leal -0x1(,%rax,2), %esi
callq 0x2170
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2320
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4398
leaq 0x18(%rbx), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x422c
leaq 0x597b(%rip), %rax      # 0x8c08
movq %rax, (%rbx)
movq 0x20(%rbx), %rax
cmpb $0x0, 0x10(%rax)
jne 0x330c
movb $0x1, 0x10(%rax)
movq 0x18(%rax), %rdi
callq 0x2250
movq %rax, %r15
testq %rax, %rax
je 0x3319
movl $0x2, %edi
movl $0x1, %esi
movl $0x6, %edx
callq 0x2080
movl %eax, %ebp
movq 0x20(%rbx), %rax
movl %ebp, 0xc(%rax)
cmpl $-0x1, %ebp
je 0x3337
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
movl %ebp, %edi
movl $0x10, %edx
callq 0x21c0
cmpl $-0x1, %eax
je 0x3369
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x28, %edi
callq 0x2140
movq %rax, %r12
leaq 0x2573(%rip), %rsi      # 0x58a0
movq %rax, %rdi
callq 0x423c
jmp 0x3353
movl $0x28, %edi
callq 0x2140
movq %rax, %r12
leaq 0x2582(%rip), %rsi      # 0x58cd
movq %rax, %rdi
callq 0x423c
leaq 0x5976(%rip), %rsi      # 0x8cd0
leaq 0xf15(%rip), %rdx       # 0x4276
movq %r12, %rdi
callq 0x2330
movl $0x28, %edi
callq 0x2140
movq %rax, %r12
leaq 0x257a(%rip), %rsi      # 0x58f7
movq %rax, %rdi
callq 0x423c
leaq 0x5944(%rip), %rsi      # 0x8cd0
leaq 0xee3(%rip), %rdx       # 0x4276
movq %r12, %rdi
callq 0x2330
jmp 0x339f
jmp 0x339f
movq %rax, %r15
movq %r12, %rdi
callq 0x2190
jmp 0x33b1
jmp 0x33ae
movq %rax, %r15
movq %r14, %rdi
callq 0x4238
jmp 0x33be
movq %rax, %r15
movq %rbx, %rdi
callq 0x43b2
movq %r15, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/nesro[P]NCursesGomoku/src/game.cpp
// Function: CGame::CGame(int, char**)
CGame::CGame(int argc, char ** argv) {

	this->m_PlayerOnTurn = 0;
	this->m_ServerSocket = 0;
	this->m_ConnectionSocket = 0;

	if (argc > 1) {
		m_Port = atoi(argv[1]);
	} else {
		m_Port = CNetwork::DEFAULT_PORT;
	}

	if (argc > 2) {
		m_Host = argv[2];
	} else {
		m_Host = "localhost";
	}

	m_IsConnectionUp = false;
	m_IsServerUp = false;

	m_Players[0] = NULL;
	m_Players[1] = NULL;

	srand((unsigned) (time(NULL)));

	m_Status = STATUS_MENU;

	initscr();
	raw();
	keypad(stdscr, TRUE);
	noecho();

	/* turn off cursor */
	curs_set(0);

	start_color();
	init_pair(1, COLOR_CYAN, COLOR_BLACK);
	init_pair(6, COLOR_MAGENTA, COLOR_BLACK);

	/* color of old stones*/
	init_pair(2, COLOR_WHITE, COLOR_RED);
	init_pair(3, COLOR_WHITE, COLOR_GREEN);

	/* color of newest stone*/
	init_pair(4, COLOR_BLACK, COLOR_RED);
	init_pair(5, COLOR_BLACK, COLOR_GREEN);

	init_pair(BACKROUND_COLOR_X_PAIR, BACKROUND_COLOR_X, COLOR_BLACK);
	init_pair(BACKROUND_COLOR_O_PAIR, BACKROUND_COLOR_O, COLOR_BLACK);

	m_Board = new CBoard();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
leaq 0x18(%rdi), %rbx
leaq 0x28(%rdi), %r12
movq %r12, 0x18(%rdi)
xorl %eax, %eax
movq %rax, 0x20(%rdi)
movb $0x0, 0x28(%rdi)
movl $0x0, 0x58(%rdi)
movq %rax, 0x8(%rdi)
cmpl $0x1, %esi
jle 0x364c
movq %rdx, %r15
movl %esi, %ebp
movq 0x8(%rdx), %rdi
callq 0x2300
movl %eax, 0x38(%r14)
cmpl $0x2, %ebp
je 0x3654
movq 0x10(%r15), %r15
movq %r15, %rdi
callq 0x2110
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
movq %r15, %rcx
movq %rax, %r8
callq 0x22f0
jmp 0x366d
movl $0x44d, 0x38(%r14)      # imm = 0x44D
leaq 0x2405(%rip), %rcx      # 0x5a60
movl $0x9, %r8d
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x22f0
xorl %eax, %eax
movb %al, 0x10(%r14)
movb %al, 0x4(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%r14)
xorl %edi, %edi
callq 0x21e0
movl %eax, %edi
callq 0x2200
movl $0x1, (%r14)
callq 0x22d0
callq 0x20c0
movq 0x592b(%rip), %rax      # 0x8fd0
movq (%rax), %rdi
movl $0x1, %esi
callq 0x20f0
callq 0x2270
xorl %edi, %edi
callq 0x21a0
callq 0x2070
movl $0x1, %edi
movl $0x6, %esi
xorl %edx, %edx
callq 0x2050
movl $0x6, %edi
movl $0x5, %esi
xorl %edx, %edx
callq 0x2050
movl $0x2, %edi
movl $0x7, %esi
movl $0x1, %edx
callq 0x2050
movl $0x3, %edi
movl $0x7, %esi
movl $0x2, %edx
callq 0x2050
movl $0x4, %edi
xorl %esi, %esi
movl $0x1, %edx
callq 0x2050
movl $0x5, %edi
xorl %esi, %esi
movl $0x2, %edx
callq 0x2050
movl $0xc, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x2050
movl $0xd, %edi
movl $0x5, %esi
xorl %edx, %edx
callq 0x2050
movl $0x11c, %edi            # imm = 0x11C
callq 0x2220
movq %rax, %r15
movq %rax, %rdi
callq 0x2a90
movq %r15, 0x50(%r14)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movl $0x11c, %esi            # imm = 0x11C
movq %r15, %rdi
callq 0x2230
jmp 0x3788
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x379c
movq (%r12), %rsi
incq %rsi
callq 0x2230
movq %r14, %rdi
callq 0x2340
// File: /workspace/github_cpp_makefile_star2_O3/nesro[P]NCursesGomoku/src/game.cpp
// Function: CGame::playerCleanup()
void CGame::playerCleanup(void) {
	delete m_Players[0];
	m_Players[0] = NULL;

	delete m_Players[1];
	m_Players[1] = NULL;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x40(%rdi), %rdi
testq %rdi, %rdi
je 0x383f
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x40(%rbx)
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x3856
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x48(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/nesro[P]NCursesGomoku/src/game.cpp
// Function: CGame::networkCleanup()
void CGame::networkCleanup(void) {
	if (m_IsConnectionUp) {
		close(m_ConnectionSocket);
	}

	if (m_IsServerUp) {
		close(m_ServerSocket);
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x10(%rdi)
jne 0x3872
movl 0xc(%rbx), %edi
callq 0x2380
cmpb $0x1, 0x4(%rbx)
jne 0x3881
movl 0x8(%rbx), %edi
popq %rbx
jmp 0x2380
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/nesro[P]NCursesGomoku/src/game.cpp
// Function: CGame::clearScreen() const
void CGame::clearScreen(void) const {
	for (int i = 0; i < LINES; i++) {
		for (int j = 0; j < COLS; j++) {
			if (rand() % 2 == 0) {
				attron(COLOR_PAIR(BACKROUND_COLOR_X_PAIR));
				mvprintw(i, j, ".");
				attroff(COLOR_PAIR(BACKROUND_COLOR_X_PAIR));
			} else {
				attron(COLOR_PAIR(BACKROUND_COLOR_O_PAIR));
				mvprintw(i, j, "o");
				attroff(COLOR_PAIR(BACKROUND_COLOR_O_PAIR));
			}
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x5706(%rip), %rax      # 0x8fb0
movl (%rax), %eax
testl %eax, %eax
jle 0x393d
movq 0x56fd(%rip), %r13      # 0x8fb8
movl (%r13), %ecx
movq 0x570a(%rip), %rbx      # 0x8fd0
leaq 0x2415(%rip), %r12      # 0x5ce2
xorl %edi, %edi
testl %ecx, %ecx
jle 0x3937
xorl %ebp, %ebp
movl %edi, 0x4(%rsp)
callq 0x2090
andl $0x1, %eax
leal 0xc(%rax), %r14d
shll $0x8, %r14d
testl %eax, %eax
movq (%rbx), %rdi
leaq 0x23ef(%rip), %r15      # 0x5ce4
cmoveq %r12, %r15
movl %r14d, %esi
xorl %edx, %edx
callq 0x2120
movl 0x4(%rsp), %edi
movl %ebp, %esi
movq %r15, %rdx
xorl %eax, %eax
callq 0x22b0
movq (%rbx), %rdi
movl %r14d, %esi
xorl %edx, %edx
callq 0x2290
incl %ebp
movl (%r13), %ecx
cmpl %ecx, %ebp
jl 0x38d9
movq 0x567f(%rip), %rax      # 0x8fb0
movl (%rax), %eax
movl 0x4(%rsp), %edi
incl %edi
cmpl %eax, %edi
jl 0x38cf
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/nesro[P]NCursesGomoku/src/game.cpp
// Function: CGame::startGame(int)
void CGame::startGame(int playerToStart) {
	m_Status = STATUS_TURN;

	m_PlayerOnTurn = playerToStart;

	clearScreen();
	m_Board->reset();
	m_Board->show();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x2, (%rdi)
movl %esi, 0x58(%rdi)
callq 0x3898
movq 0x50(%rbx), %rdi
callq 0x2aca
movq 0x50(%rbx), %rdi
popq %rbx
jmp 0x2b06
nop
// File: /workspace/github_cpp_makefile_star2_O3/nesro[P]NCursesGomoku/src/local.cpp
// Function: CLocal::nextMove()
void CLocal::nextMove(void) {

    /* nothing to do here */
    if (m_IsWinner == true) {
        return;
    }

    int key;

    char message[CBoard::MESSAGE_LENGTH];
    memset(message, '\0', CBoard::MESSAGE_LENGTH);
    sprintf(message, " Your (%c) turn!", m_Mark);
    m_Board->printMessage(message);

    /* make cursor visible */
    curs_set(2);

    for (;;) {
        key = getch();

        switch (key) {
            case KEY_UP:
                m_Board->moveCursor(CBoard::DIRECTION_UP);
                break;
                
            case KEY_DOWN:
                m_Board->moveCursor(CBoard::DIRECTION_DOWN);
                break;
                
            case KEY_LEFT:
                m_Board->moveCursor(CBoard::DIRECTION_LEFT);
                break;
                
            case KEY_RIGHT:
                m_Board->moveCursor(CBoard::DIRECTION_RIGHT);
                break;
                
            case 'w':
            case 'W':
            case ' ':
                if (m_Board->addStone(m_Mark, -1, -1)) {
                    curs_set(0);
                    return;
                }
                
                break;
                
            case 'q':
            case 'Q':
                m_Surrender = true;

                curs_set(0);
                return;

                break;
                
            default:
                break;
        }
    }
}

// Assembly:
cmpb $0x0, 0xa(%rdi)
jne 0x4213
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, 0x10(%r14)
movaps %xmm0, (%r14)
movsbl 0x9(%rdi), %edx
leaq 0x1ba8(%rip), %rsi      # 0x5d00
movq %r14, %rdi
xorl %eax, %eax
callq 0x2060
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x31f6
movl $0x2, %edi
callq 0x21a0
movq 0x4e51(%rip), %r14      # 0x8fd0
leaq 0x1b62(%rip), %r15      # 0x5ce8
movq (%r14), %rdi
callq 0x20e0
cmpl $0x70, %eax
jle 0x41b0
leal -0x102(%rax), %ecx
cmpl $0x3, %ecx
ja 0x41c1
movslq (%r15,%rcx,4), %rax
addq %r15, %rax
xorl %esi, %esi
jmpq *%rax
movl $0x2, %esi
jmp 0x41ef
cmpl $0x20, %eax
je 0x41c6
cmpl $0x57, %eax
je 0x41c6
cmpl $0x51, %eax
jne 0x4186
jmp 0x41ff
cmpl $0x77, %eax
jne 0x41fa
movq 0x10(%rbx), %rdi
movsbl 0x9(%rbx), %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
callq 0x2e6c
testb %al, %al
je 0x4186
jmp 0x4203
movl $0x1, %esi
jmp 0x41ef
movl $0x3, %esi
movq 0x10(%rbx), %rdi
callq 0x2ebe
jmp 0x4186
cmpl $0x71, %eax
jne 0x4186
movb $0x1, 0x8(%rbx)
xorl %edi, %edi
callq 0x21a0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/nesro[P]NCursesGomoku/src/player.cpp
// Function: CPlayer::goRandom() const
void CPlayer::goRandom(void) const {
    int middle = 15 / 2;
    int randomRange = 1;

    /* search for first empty stone in from middle of board */
    while (m_Board->addStone(m_Mark, middle - randomRange + rand() %
            (randomRange * 2), middle - randomRange + rand() % (randomRange * 2)
            ) == false) {
        if (randomRange < 8) {
            randomRange++;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, (%rsp)
movl $0x1, %r13d
movq (%rsp), %rax
movq 0x10(%rax), %r14
movsbl 0x9(%rax), %ebp
movl $0x7, %r15d
subl %r13d, %r15d
callq 0x2090
leal (,%r13,2), %ebx
cltd
idivl %ebx
movl %edx, %r12d
addl %r15d, %r12d
callq 0x2090
cltd
idivl %ebx
addl %edx, %r15d
movq %r14, %rdi
movl %ebp, %esi
movl %r12d, %edx
movl %r15d, %ecx
callq 0x2e6c
testb %al, %al
jne 0x441f
cmpl $0x8, %r13d
adcl $0x0, %r13d
jmp 0x43cb
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/akw0088[P]openssl/aes_upload_reverse.cpp
// Function: main
int main(int argc, char *argv[])
{

	if (argc < 6)
	{
		printf("Usage: aes_upload_reverse filename ip port key iv public_key\r\n");
		printf("Example: ./aes_upload_reverse file.tgz 127.0.0.1 65535 01234567890123456789012345678901 0123456789012345 id_rsa.openssl.pub\r\n");
		return 0;
	}

	char *filename = argv[1];
	char *ip_str = argv[2];
	unsigned short port = atoi(argv[3]);
	unsigned char *key = (unsigned char *)argv[4];
	unsigned char *iv = (unsigned char *)argv[5];
	unsigned char *pubkey = (unsigned char *)argv[6];

	printf("Attempting to upload %s to ip %s port %d\r\n", filename, ip_str, (int)port);
	aes_file_upload_reverse(filename, ip_str, port, key, iv, pubkey);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x5, %edi
jg 0x2b9c
leaq 0x753(%rip), %rdi       # 0x32dc
callq 0x2270
leaq 0x785(%rip), %rdi       # 0x331a
callq 0x2270
jmp 0x2bf0
movq %rsi, %rbx
movq 0x8(%rsi), %r14
movq 0x10(%rsi), %r15
movq 0x18(%rsi), %rdi
callq 0x2280
movq 0x20(%rbx), %r12
movq 0x28(%rbx), %r13
movq 0x30(%rbx), %rcx
movq %rcx, -0x30(%rbp)
movzwl %ax, %ebx
leaq 0x53f(%rip), %rdi       # 0x3109
movq %r14, %rsi
movq %r15, %rdx
movl %ebx, %ecx
xorl %eax, %eax
callq 0x2060
movq %r14, %rdi
movq %r15, %rsi
movl %ebx, %edx
movq %r12, %rcx
movq %r13, %r8
movq -0x30(%rbp), %r9
callq 0x2804
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/smallsimple[P]CoreInterpreter-CSE5341/main.cpp
// Function: main
int main(int argc, char* argv[]){    
  //cout << "argc = " << argc << endl;
  ifstream *inputfile;
  inputfile = NULL;
  if (argc >= 3){
    inputfile = new ifstream(argv[2]);
  }
  else {
    cout << "Warning: input file not assigned! Might be a problem." << endl;
  }
  Tokenizer *firstTokens;
  firstTokens = Tokenizer::initialize(argv[1]);
  //firstTokens->printTokensNum();
  //firstTokens->printTokensName();
  
  Prog prog(inputfile);
  prog.ParseProg();  
  cout << "==========Pretty Printed Core Program==========" << endl;
  prog.PrintProg();
  cout << "====================OUTPUT=====================" << endl;
  //cout << "finish PrintProg()." << endl;
  prog.ExecProg();
  if (inputfile != NULL && inputfile->is_open()){
    inputfile->close();
    free(inputfile);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
cmpl $0x3, %edi
jl 0x2d21
movl $0x208, %edi            # imm = 0x208
callq 0x2190
movq %rax, %rbx
movq 0x10(%r14), %rsi
movq %rax, %rdi
movl $0x8, %edx
callq 0x22c0
jmp 0x2d65
movq 0x92b0(%rip), %rbx      # 0xbfd8
leaq 0x52d5(%rip), %rsi      # 0x8004
movl $0x35, %edx
movq %rbx, %rdi
callq 0x21d0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
xorl %ebx, %ebx
movq 0x8(%r14), %rdi
callq 0x3bda
leaq -0x30(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x44f4
movq %r14, %rdi
callq 0x4606
movq 0x924c(%rip), %r15      # 0xbfd8
leaq 0x52a7(%rip), %rsi      # 0x803a
movl $0x2f, %edx
movq %r15, %rdi
callq 0x21d0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq %r14, %rdi
callq 0x4504
leaq 0x5294(%rip), %rsi      # 0x806a
movl $0x2f, %edx
movq %r15, %rdi
callq 0x21d0
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movq %r14, %rdi
callq 0x45e6
testq %rbx, %rbx
je 0x2e34
leaq 0x78(%rbx), %rdi
callq 0x2060
testb %al, %al
je 0x2e34
movq %rbx, %rdi
callq 0x2050
movq %rbx, %rdi
callq 0x21e0
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movl $0x208, %esi            # imm = 0x208
movq %rbx, %rdi
callq 0x21a0
movq %r14, %rdi
callq 0x22a0
nopl (%rax)