LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/wangyu-[P]pwdgen/lib/pbkdf2-sha256.cpp
// Function: sha2_hmac_starts(sha2_context*, unsigned char const*, unsigned long, int)
void sha2_hmac_starts( sha2_context *ctx, const unsigned char *key, size_t keylen,
                       int is224 )
{
    size_t i;
    unsigned char sum[32];

    if( keylen > 64 )
    {
        sha2( key, keylen, sum, is224 );
        keylen = ( is224 ) ? 28 : 32;
        key = sum;
    }

    memset( ctx->ipad, 0x36, 64 );
    memset( ctx->opad, 0x5C, 64 );

    for( i = 0; i < keylen; i++ )
    {
        ctx->ipad[i] = (unsigned char)( ctx->ipad[i] ^ key[i] );
        ctx->opad[i] = (unsigned char)( ctx->opad[i] ^ key[i] );
    }

    sha2_starts( ctx, is224 );
    sha2_update( ctx, ctx->ipad, 64 );

    memset( sum, 0, sizeof( sum ) );
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %ecx, %ebp
movq %rdi, %rbx
cmpq $0x41, %rdx
jb 0x409de7
movq %rsp, %r14
movq %rsi, %rdi
movq %rdx, %rsi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x409d1b
xorl %eax, %eax
testl %ebp, %ebp
sete %al
leaq 0x1c(,%rax,4), %rdx
movq %r14, %rsi
leaq 0x90(%rbx), %r14
movaps 0xca78b(%rip), %xmm0    # 0x4d4580
movups %xmm0, 0xc0(%rbx)
movups %xmm0, 0xb0(%rbx)
movups %xmm0, 0xa0(%rbx)
movups %xmm0, 0x90(%rbx)
movaps 0xca778(%rip), %xmm0    # 0x4d4590
movups %xmm0, 0xd0(%rbx)
movups %xmm0, 0xe0(%rbx)
movups %xmm0, 0xf0(%rbx)
movups %xmm0, 0x100(%rbx)
xorl %eax, %eax
cmpq %rax, %rdx
je 0x409e54
movb (%rsi,%rax), %cl
xorb %cl, 0x90(%rbx,%rax)
movb (%rsi,%rax), %cl
xorb %cl, 0xd0(%rbx,%rax)
incq %rax
jmp 0x409e36
movq %rbx, %rdi
movl %ebp, %esi
callq 0x405474
pushq $0x40
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x4054cf
// File: /workspace/github_cpp_makefile_star2_O2/wangyu-[P]pwdgen/lib/pbkdf2-sha256.cpp
// Function: sha2_hmac_finish(sha2_context*, unsigned char*)
void sha2_hmac_finish( sha2_context *ctx, unsigned char output[32] )
{
    int is224, hlen;
    unsigned char tmpbuf[32];

    is224 = ctx->is224;
    hlen = ( is224 == 0 ) ? 32 : 28;

    sha2_finish( ctx, tmpbuf );
    sha2_starts( ctx, is224 );
    sha2_update( ctx, ctx->opad, 64 );
    sha2_update( ctx, tmpbuf, hlen );
    sha2_finish( ctx, output );

    memset( tmpbuf, 0, sizeof( tmpbuf ) );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl 0x110(%rdi), %ebp
xorl %eax, %eax
testl %ebp, %ebp
sete %al
leaq 0x1c(,%rax,4), %r15
movq %rsp, %r12
movq %r12, %rsi
callq 0x409b90
movq %r14, %rdi
movl %ebp, %esi
callq 0x405474
leaq 0xd0(%r14), %rsi
pushq $0x40
popq %rdx
movq %r14, %rdi
callq 0x4054cf
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x4054cf
movq %r14, %rdi
movq %rbx, %rsi
callq 0x409b90
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/wangyu-[P]pwdgen/lib/pbkdf2-sha256.cpp
// Function: hkdf_sha256(unsigned char const*, unsigned long, unsigned char const*, unsigned long, unsigned char const*, unsigned long, unsigned char*, unsigned long)
int hkdf_sha256( const unsigned char *salt,
                  size_t salt_len, const unsigned char *ikm, size_t ikm_len,
                  const unsigned char *info, size_t info_len,
                  unsigned char *okm, size_t okm_len )
{
    int ret;
    unsigned char prk[MBEDTLS_MD_MAX_SIZE];

    ret = hkdf_sha256_extract( salt, salt_len, ikm, ikm_len, prk );

    if( ret == 0 )
    {
        ret = hkdf_sha256_expand( prk, sha256_len,
                                   info, info_len, okm, okm_len );
    }

    mbedtls_platform_zeroize( prk, sizeof( prk ) );

    return( ret );
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %r9, %rbx
movq %r8, %r14
movq 0x70(%rsp), %r15
movq 0x78(%rsp), %r12
movq %rsp, %r13
movq %r13, %r8
callq 0x40a115
pushq $0x20
popq %rsi
movq %r13, %rdi
movq %r14, %rdx
movq %rbx, %rcx
movq %r15, %r8
movq %r12, %r9
callq 0x40a14c
movl %eax, %ebx
movq 0x1040e8(%rip), %rax    # 0x50e418
pushq $0x40
popq %rdx
movq %r13, %rdi
xorl %esi, %esi
callq *%rax
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nopw (%rax,%rax)
// File: /workspace/github_cpp_makefile_star2_O2/fredericmarchand[P]TexasHoldem/Card.cpp
// Function: Card::getSuitSymbol[abi:cxx11]()
string Card::getSuitSymbol()
{
    switch (suit)
    {
    case HEARTS:
        return "♥";
    case SPADES:
        return "♠";
    case CLUBS:
        return "♣";
    case DIAMONDS:
        return "♦";
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rsi), %eax
leaq 0x3b72(%rip), %rcx      # 0x6004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x3ba6(%rip), %rsi      # 0x6048
leaq -0xc(%rbp), %rdx
jmp 0x24cd
leaq 0x3ba1(%rip), %rsi      # 0x6050
leaq -0xa(%rbp), %rdx
jmp 0x24cd
leaq 0x3b98(%rip), %rsi      # 0x6054
leaq -0x9(%rbp), %rdx
jmp 0x24cd
leaq 0x3b83(%rip), %rsi      # 0x604c
leaq -0xb(%rbp), %rdx
movq %rbx, %rdi
callq 0x270a
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/fredericmarchand[P]TexasHoldem/Card.cpp
// Function: Card::getValueSymbol[abi:cxx11]()
string Card::getValueSymbol()
{
    switch (value)
    {
    case TWO:
        return " 2";
    case THREE:
        return " 3";
    case FOUR:
        return " 4";
    case FIVE:
        return " 5";
    case SIX:
        return " 6";
    case SEVEN:
        return " 7";
    case EIGHT:
        return " 8";
    case NINE:
        return " 9";
    case TEN:
        return "10";
    case JACK:
        return " J";
    case QUEEN:
        return " Q";
    case KING:
        return " K";
    case ACE:
        return " A";
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl 0x4(%rsi), %eax
addl $-0x2, %eax
leaq 0x3b1b(%rip), %rcx      # 0x6014
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x3b4f(%rip), %rsi      # 0x6058
leaq -0x15(%rbp), %rdx
jmp 0x25b2
leaq 0x3b60(%rip), %rsi      # 0x6079
leaq -0xa(%rbp), %rdx
jmp 0x25b2
leaq 0x3b3b(%rip), %rsi      # 0x6064
leaq -0x11(%rbp), %rdx
jmp 0x25b2
leaq 0x3b43(%rip), %rsi      # 0x607c
leaq -0x9(%rbp), %rdx
jmp 0x25b2
leaq 0x3b2d(%rip), %rsi      # 0x6073
leaq -0xc(%rbp), %rdx
jmp 0x25b2
leaq 0x3b0b(%rip), %rsi      # 0x605e
leaq -0x13(%rbp), %rdx
jmp 0x25b2
leaq 0x3b01(%rip), %rsi      # 0x6061
leaq -0x12(%rbp), %rdx
jmp 0x25b2
leaq 0x3b00(%rip), %rsi      # 0x606d
leaq -0xe(%rbp), %rdx
jmp 0x25b2
leaq 0x3ae1(%rip), %rsi      # 0x605b
leaq -0x14(%rbp), %rdx
jmp 0x25b2
leaq 0x3ae0(%rip), %rsi      # 0x6067
leaq -0x10(%rbp), %rdx
jmp 0x25b2
leaq 0x3ad6(%rip), %rsi      # 0x606a
leaq -0xf(%rbp), %rdx
jmp 0x25b2
leaq 0x3ad5(%rip), %rsi      # 0x6076
leaq -0xb(%rbp), %rdx
jmp 0x25b2
leaq 0x3ac2(%rip), %rsi      # 0x6070
leaq -0xd(%rbp), %rdx
movq %rbx, %rdi
callq 0x270a
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/fredericmarchand[P]TexasHoldem/Card.cpp
// Function: Card::printCard()
void Card::printCard()
{
    cout << "|----------|" << endl;
    cout << "|          |" << endl;
    cout << "|          |" << endl;
    cout << "|   " << getValueSymbol() << getSuitSymbol() << "    |" << endl;
    cout << "|          |" << endl;
    cout << "|          |" << endl;
    cout << "|----------|" << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0x69f5(%rip), %r14      # 0x8fd0
leaq 0x3a9d(%rip), %rsi      # 0x607f
movq %r14, %rdi
callq 0x2160
movq %rax, %rdi
callq 0x20b0
leaq 0x3a93(%rip), %r15      # 0x608c
movq %r14, %rdi
movq %r15, %rsi
callq 0x2160
movq %rax, %rdi
callq 0x20b0
movq %r14, %rdi
movq %r15, %rsi
callq 0x2160
movq %rax, %rdi
callq 0x20b0
leaq 0x3a73(%rip), %rsi      # 0x6099
movq %r14, %rdi
callq 0x2160
movq %rax, %r14
leaq -0x58(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x24e0
movq %r14, %rdi
movq %r15, %rsi
callq 0x2130
movq %rax, %r14
leaq -0x38(%rbp), %rdi
movq %rbx, %rsi
callq 0x2480
leaq -0x38(%rbp), %rsi
movq %r14, %rdi
callq 0x2130
leaq 0x3a26(%rip), %rsi      # 0x6093
movq %rax, %rdi
callq 0x2160
movq %rax, %rdi
callq 0x20b0
leaq -0x38(%rbp), %rdi
callq 0x20a0
leaq -0x58(%rbp), %rdi
callq 0x20a0
movq 0x693a(%rip), %rbx      # 0x8fd0
leaq 0x39ef(%rip), %r14      # 0x608c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2160
movq %rax, %rdi
callq 0x20b0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2160
movq %rax, %rdi
callq 0x20b0
leaq 0x39b5(%rip), %rsi      # 0x607f
movq %rbx, %rdi
callq 0x2160
movq %rax, %rdi
callq 0x20b0
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x26e7
movq %rax, %rbx
jmp 0x26f8
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x20a0
leaq -0x58(%rbp), %rdi
callq 0x20a0
movq %rbx, %rdi
callq 0x21f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/fredericmarchand[P]TexasHoldem/Player.cpp
// Function: Player::Player()
Player::Player()
{
    hand[0] = NULL;
    hand[1] = NULL;
    dealer = false;
    this->chips = 1000;
    state.move = CHECK;
    state.bet = 0;
    ai = true;
    handsWon = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb $0x0, 0x14(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movl $0x3e8, 0x10(%rdi)      # imm = 0x3E8
movq $0x1, 0x18(%rdi)
movb $0x1, 0x20(%rdi)
andl $0x0, 0x24(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/fredericmarchand[P]TexasHoldem/Player.cpp
// Function: Player::Player(int, bool)
Player::Player(int chips, bool ai)
{
    hand[0] = NULL;
    hand[1] = NULL;
    dealer = false;
    this->chips = chips;
    state.move = CHECK;
    state.bet = 0;
    this->ai = ai;
    handsWon = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb $0x0, 0x14(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movl %esi, 0x10(%rdi)
movq $0x1, 0x18(%rdi)
movb %dl, 0x20(%rdi)
andl $0x0, 0x24(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/fredericmarchand[P]TexasHoldem/Player.cpp
// Function: Player::printHand()
void Player::printHand()
{
    if (hand[0] == NULL || hand[1] == NULL)
    {
        cout << "Something is null" << endl;
        return;
    }
    printCardArray(hand, 2);
    cout << "chips: " << chips << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
cmpq $0x0, (%rdi)
je 0x2911
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0x2911
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x2932
movq 0x66d8(%rip), %rdi      # 0x8fd0
leaq 0x37db(%rip), %rsi      # 0x60da
callq 0x2160
movl 0x10(%rbx), %esi
movq %rax, %rdi
callq 0x21e0
jmp 0x2924
movq 0x66b8(%rip), %rdi      # 0x8fd0
leaq 0x37a9(%rip), %rsi      # 0x60c8
callq 0x2160
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x20b0
// File: /workspace/github_cpp_makefile_star2_O2/fredericmarchand[P]TexasHoldem/Player.cpp
// Function: Player::bet(int)
bool Player::bet(int value)
{
    bool allIn = false;

    if ((chips - value) <= 0) {
        allIn =  true;
        chips = 0;
        setState(BET, state.bet + chips);
    }
    else
    {
        chips -= value;
        setState(BET, state.bet + value);
    }

    return allIn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x10(%rdi), %eax
subl %esi, %eax
jle 0x2b52
addl %esi, 0x1c(%rdi)
movl %eax, %ecx
jmp 0x2b54
xorl %ecx, %ecx
testl %eax, %eax
setle %al
movl %ecx, 0x10(%rdi)
movl $0x2, 0x18(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/fredericmarchand[P]TexasHoldem/./CardUtil.h
// Function: sortCardArray(Card**, int, int)
static void sortCardArray(Card *cards[], int left, int right)
{
    int i = left, j = right;
    Card *tmp;
    Card *pivot = cards[(left + right) / 2];

    while (i <= j) 
    {
        while (cards[i]->getCardValue() < pivot->getCardValue())
        {
            i++;
        }
        while (cards[j]->getCardValue() > pivot->getCardValue())
        {
            j--;
        }
        if (i <= j) 
        {
            tmp = cards[i];
            cards[i] = cards[j];
            cards[j] = tmp;
            i++;
            j--;
        }
    }

    if (left < j)
    {
        sortCardArray(cards, left, j);
    }
    if (i < right)
    {
        sortCardArray(cards, i, right);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ecx
movl %esi, %r8d
movq %rdi, %r14
movq %rcx, -0x48(%rbp)
movq %rdi, -0x30(%rbp)
movl %r8d, %eax
movq %rax, -0x50(%rbp)
addl %ecx, %eax
cltd
pushq $0x2
popq %rsi
idivl %esi
cltq
movq (%r14,%rax,8), %rsi
movl %ecx, %ebx
movq %rsi, -0x40(%rbp)
cmpl %ebx, %r8d
jg 0x30ae
movslq %r8d, %r15
decq %r15
movl %r8d, %r14d
movq -0x30(%rbp), %r12
movq 0x8(%r12,%r15,8), %rdi
callq 0x2476
movl %eax, %r13d
movq -0x40(%rbp), %rdi
callq 0x2476
incq %r15
incl %r14d
cmpl %eax, %r13d
jl 0x302d
leal -0x1(%r14), %eax
movl %eax, -0x34(%rbp)
movslq %ebx, %r13
incq %r13
movl %ebx, %r12d
movq -0x30(%rbp), %rax
movq -0x8(%rax,%r13,8), %rdi
callq 0x2476
movl %eax, %ebx
movq -0x40(%rbp), %rdi
callq 0x2476
decq %r13
decl %r12d
cmpl %eax, %ebx
jg 0x305e
leal 0x1(%r12), %ebx
cmpq %r13, %r15
movl -0x34(%rbp), %r8d
jg 0x3017
movq -0x30(%rbp), %rdx
movq (%rdx,%r15,8), %rax
movq (%rdx,%r13,8), %rcx
movq %rcx, (%rdx,%r15,8)
movq %rax, (%rdx,%r13,8)
movl %r12d, %ebx
movl %r14d, %r8d
jmp 0x3017
movq -0x50(%rbp), %rsi
cmpl %esi, %ebx
movq -0x30(%rbp), %r14
jle 0x30ca
movq %r14, %rdi
movl %ebx, %edx
movl %r8d, %ebx
callq 0x2fdb
movl %ebx, %r8d
movq -0x48(%rbp), %rcx
cmpl %ecx, %r8d
jl 0x2ffc
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/fredericmarchand[P]TexasHoldem/Game.cpp
// Function: Game::Game(int)
Game::Game(int numPlayers)
{
    this->numPlayers = numPlayers;
    players = new Player*[numPlayers];
    for (int i = 0; i < numPlayers; ++i)
    {
        players[i] = new Player(100000, true);
    }

    deckPointer = 0;

    int index = 0;
    int suit = HEARTS;
    for (; suit <= DIAMONDS; ++suit)
    {
        int value = TWO;
        for (; value <= ACE; ++value)
        {
            deck[index++] = new Card((Suit)suit, (CardValue)value);
        }
    }
    resetDeck();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %r15
movl %esi, 0x8(%rdi)
movl %esi, %eax
shlq $0x3, %rax
xorl %ebx, %ebx
testl %esi, %esi
pushq $-0x1
popq %rdi
cmovnsq %rax, %rdi
cmovlel %ebx, %r14d
callq 0x2030
movq %r15, -0x30(%rbp)
movq %rax, (%r15)
pushq $0x28
popq %r15
pushq $0x1
popq %r12
cmpq %rbx, %r14
je 0x357c
movq %r15, %rdi
callq 0x2170
movq %rax, %r13
movq %rax, %rdi
movl $0x186a0, %esi          # imm = 0x186A0
movl %r12d, %edx
callq 0x280c
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %r13, (%rax,%rbx,8)
incq %rbx
jmp 0x354c
movq -0x30(%rbp), %rax
andl $0x0, 0x38(%rax)
leaq 0x40(%rax), %rbx
xorl %r14d, %r14d
cmpl $0x4, %r14d
je 0x35c9
xorl %r15d, %r15d
cmpq $0xd, %r15
je 0x35c0
leaq 0x2(%r15), %r13
pushq $0x8
popq %rdi
callq 0x2170
movq %rax, %r12
movq %rax, %rdi
movl %r14d, %esi
movl %r13d, %edx
callq 0x244c
movq %r12, (%rbx,%r15,8)
incq %r15
jmp 0x3594
incl %r14d
addq $0x68, %rbx
jmp 0x358b
xorps %xmm0, %xmm0
movq -0x30(%rbp), %rax
movups %xmm0, 0x2c(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x28
popq %rsi
movq %r13, %rdi
jmp 0x35ff
movq %rax, %rbx
pushq $0x8
popq %rsi
movq %r12, %rdi
callq 0x2180
movq %rbx, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O2/fredericmarchand[P]TexasHoldem/Game.cpp
// Function: Game::Game(Game*)
Game::Game(Game *game)
{
    numPlayers = game->getPlayerCount();
    players = new Player*[numPlayers];
    for (int i = 0; i < numPlayers; ++i)
    {
        players[i] = new Player(game->getPlayers()[i]);
    }
    
    deckPointer = 0;

    for (int i = 0; i < TOTAL_CARDS; ++i)
    {
        deck[i] = new Card(game->deck[i]);
    }

    flop[0] = getCard(game->flop[0]);
    flop[1] = getCard(game->flop[1]);
    flop[2] = getCard(game->flop[2]);
    turn = getCard(game->turn);
    river = getCard(game->river);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movslq 0x8(%rsi), %r12
leaq (,%r12,8), %rax
testq %r12, %r12
movl %r12d, 0x8(%rdi)
pushq $-0x1
popq %rdi
cmovnsq %rax, %rdi
callq 0x2030
movq %rax, (%rbx)
xorl %r13d, %r13d
pushq $0x28
popq %r15
movslq %r12d, %rax
cmpq %rax, %r13
jge 0x3691
movq %r15, %rdi
callq 0x2170
movq %rax, %r12
movq (%r14), %rax
movq (%rax,%r13,8), %rsi
movq %r12, %rdi
callq 0x282e
movq (%rbx), %rax
movq %r12, (%rax,%r13,8)
incq %r13
movl 0x8(%rbx), %r12d
jmp 0x365f
andl $0x0, 0x38(%rbx)
pushq $0x8
popq %r15
movq %r15, %r13
cmpq $0x3c, %r13
je 0x36c2
movq %r15, %rdi
callq 0x2170
movq %rax, %r12
movq (%r14,%r13,8), %rsi
movq %rax, %rdi
callq 0x2458
movq %r12, (%rbx,%r13,8)
incq %r13
jmp 0x369c
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0x3752
movq %rax, 0x10(%rbx)
movq 0x18(%r14), %rsi
movq %rbx, %rdi
callq 0x3752
movq %rax, 0x18(%rbx)
movq 0x20(%r14), %rsi
movq %rbx, %rdi
callq 0x3752
movq %rax, 0x20(%rbx)
movq 0x28(%r14), %rsi
movq %rbx, %rdi
callq 0x3752
movq %rax, 0x28(%rbx)
movq 0x30(%r14), %rsi
movq %rbx, %rdi
callq 0x3752
movq %rax, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x8
jmp 0x372d
movq %rax, %rbx
pushq $0x28
popq %rsi
movq %r12, %rdi
callq 0x2180
movq %rbx, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O2/fredericmarchand[P]TexasHoldem/Game.cpp
// Function: Game::getCard(Card*)
Card* Game::getCard(Card *card)
{
    if (card == NULL)
    {
        return NULL;
    }

    for (int i = 0; i < TOTAL_CARDS; ++i)
    {
        if (deck[i] == NULL)
            cout << "FUCK" << endl;
        if (card->getSuit() == deck[i]->getSuit() && card->getCardValue() == deck[i]->getCardValue())
        {
            return deck[i];
        }
    }
    //never happens
    return NULL;
}

// Assembly:
testq %rsi, %rsi
je 0x37d1
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
pushq $0x8
popq %r12
leaq 0x29dc(%rip), %r13      # 0x6152
cmpq $0x3c, %r12
je 0x37cd
cmpq $0x0, (%r14,%r12,8)
jne 0x379a
movq 0x5846(%rip), %rdi      # 0x8fd0
movq %r13, %rsi
callq 0x2160
movq %rax, %rdi
callq 0x20b0
movq %r15, %rdi
callq 0x246e
movl %eax, %ebx
movq (%r14,%r12,8), %rdi
callq 0x246e
cmpl %eax, %ebx
jne 0x37c8
movq %r15, %rdi
callq 0x2476
movl %eax, %ebx
movq (%r14,%r12,8), %rdi
callq 0x2476
cmpl %eax, %ebx
je 0x37d4
incq %r12
jmp 0x3776
xorl %eax, %eax
jmp 0x37d8
xorl %eax, %eax
retq
movq (%r14,%r12,8), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/fredericmarchand[P]TexasHoldem/Game.cpp
// Function: Game::~Game()
Game::~Game()
{
    for (int i = 0; i < numPlayers; ++i)
    {
        delete players[i];
    }
    delete [] players;

    for (int i = 0; i < TOTAL_CARDS; ++i)
    {
        delete deck[i];
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorl %r12d, %r12d
pushq $0x28
popq %r14
movslq 0x8(%rbx), %rax
movq (%rbx), %rdi
cmpq %rax, %r12
jge 0x382a
movq (%rdi,%r12,8), %r15
testq %r15, %r15
je 0x381a
movq %r15, %rdi
callq 0x2866
movq %r15, %rdi
movq %r14, %rsi
callq 0x2180
incq %r12
jmp 0x37fd
testq %rdi, %rdi
je 0x3834
callq 0x21a0
pushq $0x8
popq %r14
movq %r14, %r12
cmpq $0x3c, %r12
je 0x3862
movq (%rbx,%r12,8), %r15
testq %r15, %r15
je 0x3852
movq %r15, %rdi
callq 0x2468
movq %r15, %rdi
movq %r14, %rsi
callq 0x2180
incq %r12
jmp 0x383b
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/fredericmarchand[P]TexasHoldem/Game.cpp
// Function: Game::rotateDealerChip()
void Game::rotateDealerChip()
{
    int dealer;
    for (int i = 0; i < numPlayers; ++i)
    {
        if (players[i]->isDealer())
        {
           dealer = i;
           break;
        }
    }
    players[dealer]->setDealer(false);
    if (dealer == 0)
    {
        players[numPlayers-1]->setDealer(true);
    }
    else
    {
        players[dealer-1]->setDealer(true);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
movslq 0x8(%rbx), %rax
cmpq %rax, %r14
jge 0x38a1
movq (%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x28a8
testb %al, %al
jne 0x38a1
incq %r14
jmp 0x3883
movq (%rbx), %rax
movq (%rax,%r14,8), %rdi
xorl %esi, %esi
callq 0x28c6
testq %r14, %r14
movq (%rbx), %rax
movslq 0x8(%rbx), %rcx
cmovneq %r14, %rcx
movq -0x8(%rax,%rcx,8), %rdi
pushq $0x1
popq %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x28c6
// File: /workspace/github_cpp_makefile_star2_O2/fredericmarchand[P]TexasHoldem/Game.cpp
// Function: Game::getDealer()
Player* Game::getDealer()
{
    for (int i = 0; i < numPlayers; ++i)
    {
        if (players[i]->isDealer())
        {
           return players[i];
        }
    }
    //never happens
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
xorl %ebx, %ebx
xorl %r15d, %r15d
movslq 0x8(%r14), %rax
cmpq %rax, %r15
jge 0x3904
movq (%r14), %rax
movq (%rax,%r15,8), %rdi
callq 0x28a8
incq %r15
testb %al, %al
je 0x38e0
movq (%r14), %rax
movq -0x8(%rax,%r15,8), %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/fredericmarchand[P]TexasHoldem/Game.cpp
// Function: Game::getBigBlindPlayer()
Player* Game::getBigBlindPlayer()
{
    int dealer;
    for (int i = 0; i < numPlayers; ++i)
    {
        if (players[i]->isDealer())
        {
           dealer = i;
           break;
        }
    }
    if (dealer == 0) 
    {
        return players[numPlayers-2];
    }
    
    if (numPlayers == 2)
    {
        return players[dealer];
    }
    return players[dealer-2];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
xorl %r15d, %r15d
movslq 0x8(%rbx), %rax
cmpq %rax, %r15
jge 0x3947
movq (%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x28a8
testb %al, %al
jne 0x3947
incq %r15
addq $-0x8, %r14
jmp 0x3925
testq %r14, %r14
je 0x3964
xorl %eax, %eax
cmpl $0x2, 0x8(%rbx)
sete %al
shll $0x4, %eax
addq (%rbx), %rax
subq %r14, %rax
addq $-0x10, %rax
jmp 0x3973
movq (%rbx), %rax
movslq 0x8(%rbx), %rcx
leaq (%rax,%rcx,8), %rax
addq $-0x10, %rax
movq (%rax), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/fredericmarchand[P]TexasHoldem/Game.cpp
// Function: Game::getSmallBlindPlayer()
Player* Game::getSmallBlindPlayer()
{
    int dealer;
    for (int i = 0; i < numPlayers; ++i)
    {
        if (players[i]->isDealer())
        {
           dealer = i;
           break;
        }
    }
    if (dealer == 0) 
    {
        return players[numPlayers-1];
    }
    return players[dealer-1];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
movslq 0x8(%rbx), %rax
cmpq %rax, %r14
jge 0x39b1
movq (%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x28a8
testb %al, %al
jne 0x39ad
incq %r14
jmp 0x398f
movslq 0x8(%rbx), %rax
testq %r14, %r14
movq (%rbx), %rcx
cmovneq %r14, %rax
movq -0x8(%rcx,%rax,8), %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/fredericmarchand[P]TexasHoldem/Game.cpp
// Function: Game::getNextPlayer(Player*)
Player* Game::getNextPlayer(Player *player)
{
    int index = 0;
    for (int i = 0; i < numPlayers; ++i)
    {
        if (player == players[i])
        {
            index = i;
            break;
        }
    }
    if (index == 0)
    {
        return players[numPlayers-1];
    }
    return players[index-1];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq 0x8(%rdi), %rax
movq (%rdi), %rcx
xorl %edx, %edx
testl %eax, %eax
movl $0x0, %edi
cmovgl %eax, %edi
cmpl %edx, %edi
je 0x39f2
cmpq %rsi, (%rcx,%rdx,8)
je 0x39ec
incq %rdx
jmp 0x39dd
testl %edx, %edx
cmovneq %rdx, %rax
movq -0x8(%rcx,%rax,8), %rax
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/fredericmarchand[P]TexasHoldem/Game.cpp
// Function: Game::getPreviousPlayer(Player*)
Player* Game::getPreviousPlayer(Player *player)
{
    int index = 0;
    for (int i = 0; i < numPlayers; ++i)
    {
        if (player == players[i])
        {
            index = i;
            break;
        }
    }
    do {
        index++;
        if (index == numPlayers)
        {
            index = 0;
        }
    }
    while (players[index]->getState().move == FOLD);
    return players[index];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x8(%rdi), %eax
movq (%rdi), %rdx
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
xorl %edi, %edi
cmpq %rdi, %rax
je 0x3a28
cmpq %rsi, (%rdx,%rdi,8)
je 0x3a26
incq %rdi
jmp 0x3a16
movl %edi, %ecx
incl %ecx
xorl %r14d, %r14d
cmpl 0x8(%rbx), %ecx
je 0x3a35
movl %ecx, %r14d
movq (%rbx), %rax
movslq %r14d, %r15
movq (%rax,%r15,8), %rdi
callq 0x2b2a
movl %r14d, %ecx
testl %eax, %eax
je 0x3a28
movq (%rbx), %rax
movq (%rax,%r15,8), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/fredericmarchand[P]TexasHoldem/Game.cpp
// Function: Game::flipFlop(bool)
void Game::flipFlop(bool verbose)
{
    discardNextCard();
    flop[0] = flipNextCard();
    flop[1] = flipNextCard();
    flop[2] = flipNextCard();
    if (verbose)
        printCardArray(flop, 3);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movslq 0x38(%rdi), %rax
movq 0x48(%rdi,%rax,8), %rcx
movq %rcx, 0x10(%rdi)
movq 0x50(%rdi,%rax,8), %rcx
movq %rcx, 0x18(%rdi)
movq 0x58(%rdi,%rax,8), %rcx
addl $0x4, %eax
movl %eax, 0x38(%rdi)
movq %rcx, 0x20(%rdi)
testl %esi, %esi
je 0x3c61
movq %rdi, %rbx
pushq $0x3
popq %r12
movq 0x5500(%rip), %r14      # 0x8fd0
leaq 0x25a8(%rip), %r15      # 0x607f
subl $0x1, %r12d
jb 0x3aea
movq %r14, %rdi
movq %r15, %rsi
callq 0x2160
jmp 0x3ad7
movq 0x54df(%rip), %r14      # 0x8fd0
movq %r14, %rdi
callq 0x20b0
pushq $0x3
popq %r12
leaq 0x2588(%rip), %r15      # 0x608c
subl $0x1, %r12d
jb 0x3b17
movq %r14, %rdi
movq %r15, %rsi
callq 0x2160
jmp 0x3b04
movq 0x54b2(%rip), %r14      # 0x8fd0
movq %r14, %rdi
callq 0x20b0
pushq $0x3
popq %r12
leaq 0x255b(%rip), %r15      # 0x608c
subl $0x1, %r12d
jb 0x3b44
movq %r14, %rdi
movq %r15, %rsi
callq 0x2160
jmp 0x3b31
movq 0x5485(%rip), %rdi      # 0x8fd0
callq 0x20b0
xorl %r14d, %r14d
leaq -0x68(%rbp), %r12
leaq -0x48(%rbp), %r13
cmpq $0x3, %r14
je 0x3bce
movq 0x5468(%rip), %rdi      # 0x8fd0
leaq 0x252a(%rip), %rsi      # 0x6099
callq 0x2160
movq %rax, %r15
movq 0x10(%rbx,%r14,8), %rsi
movq %r12, %rdi
callq 0x24e0
movq %r15, %rdi
movq %r12, %rsi
callq 0x2130
movq %rax, %r15
movq 0x10(%rbx,%r14,8), %rsi
movq %r13, %rdi
callq 0x2480
movq %r15, %rdi
movq %r13, %rsi
callq 0x2130
movq %rax, %rdi
leaq 0x24df(%rip), %rsi      # 0x6093
callq 0x2160
movq %r13, %rdi
callq 0x20a0
movq %r12, %rdi
callq 0x20a0
incq %r14
jmp 0x3b5b
movq 0x53fb(%rip), %rbx      # 0x8fd0
movq %rbx, %rdi
callq 0x20b0
pushq $0x3
popq %r15
leaq 0x24a4(%rip), %r14      # 0x608c
subl $0x1, %r15d
jb 0x3bfb
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2160
jmp 0x3be8
movq 0x53ce(%rip), %rbx      # 0x8fd0
movq %rbx, %rdi
callq 0x20b0
pushq $0x3
popq %r15
leaq 0x2477(%rip), %r14      # 0x608c
subl $0x1, %r15d
jb 0x3c28
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2160
jmp 0x3c15
movq 0x53a1(%rip), %rbx      # 0x8fd0
movq %rbx, %rdi
callq 0x20b0
pushq $0x3
popq %r15
leaq 0x243d(%rip), %r14      # 0x607f
subl $0x1, %r15d
jb 0x3c55
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2160
jmp 0x3c42
movq 0x5374(%rip), %rdi      # 0x8fd0
callq 0x20b0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3c72
movq %rax, %rbx
jmp 0x3c83
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x20a0
leaq -0x68(%rbp), %rdi
callq 0x20a0
movq %rbx, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O2/fredericmarchand[P]TexasHoldem/Game.cpp
// Function: Game::flipTurn(bool)
void Game::flipTurn(bool verbose)
{
    discardNextCard();
    turn = flipNextCard();
    if (verbose)
        turn->printCard();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movslq 0x38(%rdi), %rcx
movq 0x48(%rdi,%rcx,8), %rdi
addl $0x2, %ecx
movl %ecx, 0x38(%rax)
movq %rdi, 0x28(%rax)
testl %esi, %esi
je 0x3cd6
popq %rbp
jmp 0x25c4
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/fredericmarchand[P]TexasHoldem/Game.cpp
// Function: Game::flipRiver(bool)
void Game::flipRiver(bool verbose)
{
    discardNextCard();
    river = flipNextCard();
    if (verbose)
        river->printCard();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movslq 0x38(%rdi), %rcx
movq 0x48(%rdi,%rcx,8), %rdi
addl $0x2, %ecx
movl %ecx, 0x38(%rax)
movq %rdi, 0x30(%rax)
testl %esi, %esi
je 0x3cfc
popq %rbp
jmp 0x25c4
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/fredericmarchand[P]TexasHoldem/Game.cpp
// Function: Game::shuffleDeck(int)
void Game::shuffleDeck(int start)
{
    // Use a different seed value so that we don't get same
    // result each time we run this program
    srand (time(NULL));
 
    // Start from the last element and swap one by one. We don't
    // need to run for the first element that's why i > 0
    for (int i = TOTAL_CARDS-1; i >= start; i--)
    {
        // Pick a random index from 0 to i
        int j = rand() % (i+1);
 
        // Swap arr[i] with the element at random index
        swap(&deck[i], &deck[j]);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
xorl %edi, %edi
callq 0x2140
movl %eax, %edi
callq 0x2150
movslq %r14d, %r14
pushq $0x33
popq %r15
cmpq %r14, %r15
jl 0x3db8
callq 0x2040
leal 0x1(%r15), %ecx
cltd
idivl %ecx
movslq %edx, %rax
movq 0x40(%rbx,%r15,8), %rcx
movq 0x40(%rbx,%rax,8), %rdx
movq %rdx, 0x40(%rbx,%r15,8)
movq %rcx, 0x40(%rbx,%rax,8)
decq %r15
jmp 0x3d8b
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/fredericmarchand[P]TexasHoldem/Game.cpp
// Function: Game::determineWinner()
int Game::determineWinner()
{
    //Check if everyone folded but one person
    for (int i = 0; i < numPlayers; ++i)
    {
        if (checkLastPlayerRemaining(players[i]) == true)
        {
            givePotToWinner(players[i]);
            return i;
        }
    }
    
    int equalHands = 0;
    Hand hands[numPlayers];
    Hand best = NOTHING;
    int playerIndex = 0;
    for (int i = 0; i < numPlayers; ++i) 
    {
        hands[i] = players[i]->bestHand(flop, turn, river, true);
        if (hands[i] > best)
        {
            best = hands[i];
            playerIndex = i;
            equalHands = 0;
        }
        else if (hands[i] == best)
        {
            equalHands = 1;
        }        
    }

    if (equalHands == 1)
    {
        splitPot();
        return SPLIT;
    }
    else
    {
        givePotToWinner(players[playerIndex]);
    }

    return playerIndex;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
xorl %ebx, %ebx
movslq 0x8(%r14), %rax
cmpq %rax, %rbx
jge 0x3dfb
movq (%r14), %rax
movq (%rax,%rbx,8), %rsi
movq %r14, %rdi
callq 0x3ea6
testb %al, %al
jne 0x3e6d
incq %rbx
jmp 0x3dda
movq %rsp, -0x38(%rbp)
leaq 0x10(%r14), %rax
movq %rax, -0x40(%rbp)
xorl %r15d, %r15d
xorl %r13d, %r13d
xorl %edx, %edx
xorl %ebx, %ebx
pushq $0x1
popq %r12
movslq 0x8(%r14), %rax
cmpq %rax, %r15
jge 0x3e5a
movq (%r14), %rax
movl %edx, -0x2c(%rbp)
movq 0x28(%r14), %rdx
movq (%rax,%r15,8), %rdi
movq 0x30(%r14), %rcx
movq -0x40(%rbp), %rsi
movl %r12d, %r8d
callq 0x30e6
movl -0x2c(%rbp), %edx
cmpl %edx, %eax
cmovel %r12d, %r13d
movl $0x0, %ecx
cmovgl %ecx, %r13d
cmovgl %eax, %edx
cmovgl %r15d, %ebx
incq %r15
jmp 0x3e15
cmpl $0x1, %r13d
jne 0x3e7e
movq %r14, %rdi
callq 0x3fc8
pushq $-0x1
popq %rbx
jmp 0x3e90
movq (%r14), %rax
movq (%rax,%rbx,8), %rsi
movq %r14, %rdi
callq 0x3efe
jmp 0x3e94
movq (%r14), %rax
movslq %ebx, %rcx
movq (%rax,%rcx,8), %rsi
movq %r14, %rdi
callq 0x3efe
movq -0x38(%rbp), %rsp
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/fredericmarchand[P]TexasHoldem/Game.cpp
// Function: Game::checkLastPlayerRemaining(Player*)
bool Game::checkLastPlayerRemaining(Player *player)
{
    bool ret = true;
    if (player->getState().move == FOLD)
        return false;

    for (int i = 0; i < numPlayers; ++i)
    {
        if (players[i] != player)
        {
            ret &= (players[i]->getState().move == FOLD);
        }
    }
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0x2b2a
testl %eax, %eax
je 0x3eee
movb $0x1, %bl
xorl %r12d, %r12d
movslq 0x8(%r15), %rax
cmpq %rax, %r12
jge 0x3ef0
movq (%r15), %rax
movq (%rax,%r12,8), %rdi
cmpq %r14, %rdi
je 0x3ee9
callq 0x2b2a
testl %eax, %eax
sete %al
andb %al, %bl
incq %r12
jmp 0x3ec8
xorl %ebx, %ebx
andb $0x1, %bl
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/fredericmarchand[P]TexasHoldem/Game.cpp
// Function: Game::givePotToWinner(Player*)
void Game::givePotToWinner(Player *winner)
{
    winner->addChips(pot);
    cout << "Winner: Player " << getPlayerIndex(winner) << endl;
    for (int i = 0; i < numPlayers; ++i)
    {
        cout << "Player " << i << ": $" << players[i]->getChipCount() << endl;
    }
    pot = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movl 0xc(%rdi), %esi
movq %r15, %rdi
callq 0x2894
movq 0x50ac(%rip), %rdi      # 0x8fd0
leaq 0x21e2(%rip), %rsi      # 0x610d
callq 0x2160
movq %rax, %r12
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3a5e
movq %r12, %rdi
movl %eax, %esi
callq 0x21e0
movq %rax, %rdi
callq 0x20b0
xorl %r15d, %r15d
leaq 0x22b0(%rip), %r12      # 0x620a
leaq 0x228e(%rip), %r13      # 0x61ef
movslq 0x8(%rbx), %rax
cmpq %rax, %r15
jge 0x3fb5
movq 0x505f(%rip), %rdi      # 0x8fd0
movq %r12, %rsi
callq 0x2160
movq %rax, %rdi
movl %r15d, %esi
callq 0x21e0
movq %rax, %rdi
movq %r13, %rsi
callq 0x2160
movq %rax, %r14
movq (%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x2880
movq %r14, %rdi
movl %eax, %esi
callq 0x21e0
movq %rax, %rdi
callq 0x20b0
incq %r15
jmp 0x3f61
andl $0x0, 0xc(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/fredericmarchand[P]TexasHoldem/Game.cpp
// Function: Game::splitPot()
void Game::splitPot()
{
    cout << "Split pot" << endl;
    for (int i = 0; i < numPlayers; ++i)
    {
        players[i]->addChips((int)(pot/numPlayers));
        cout << "Player " << i << ": $" << players[i]->getChipCount() << endl;
    }
    pot = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x4ff0(%rip), %rdi      # 0x8fd0
leaq 0x211c(%rip), %rsi      # 0x6103
callq 0x2160
movq %rax, %rdi
callq 0x20b0
xorl %r15d, %r15d
leaq 0x220c(%rip), %r12      # 0x620a
leaq 0x21ea(%rip), %r13      # 0x61ef
movslq 0x8(%rbx), %rcx
cmpq %rcx, %r15
jge 0x406d
movq (%rbx), %rax
movq (%rax,%r15,8), %rdi
movl 0xc(%rbx), %eax
cltd
idivl %ecx
movl %eax, %esi
callq 0x2894
movq 0x4fa7(%rip), %rdi      # 0x8fd0
movq %r12, %rsi
callq 0x2160
movq %rax, %rdi
movl %r15d, %esi
callq 0x21e0
movq %rax, %rdi
movq %r13, %rsi
callq 0x2160
movq %rax, %r14
movq (%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x2880
movq %r14, %rdi
movl %eax, %esi
callq 0x21e0
movq %rax, %rdi
callq 0x20b0
incq %r15
jmp 0x4005
andl $0x0, 0xc(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/fredericmarchand[P]TexasHoldem/Game.cpp
// Function: Game::printPot()
void Game::printPot()
{
    cout << endl;
    for (int i = 0; i < numPlayers; ++i)
    {
        cout << "Player " << i << ": $" << players[i]->getChipCount() << endl;
    }
    cout << "Pot: $" << pot << endl;
    cin.ignore();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x4f38(%rip), %rdi      # 0x8fd0
callq 0x20b0
xorl %r15d, %r15d
leaq 0x2163(%rip), %r12      # 0x620a
leaq 0x2141(%rip), %r13      # 0x61ef
movslq 0x8(%rbx), %rax
movq 0x4f17(%rip), %rdi      # 0x8fd0
cmpq %rax, %r15
jge 0x4102
movq %r12, %rsi
callq 0x2160
movq %rax, %rdi
movl %r15d, %esi
callq 0x21e0
movq %rax, %rdi
movq %r13, %rsi
callq 0x2160
movq %rax, %r14
movq (%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x2880
movq %r14, %rdi
movl %eax, %esi
callq 0x21e0
movq %rax, %rdi
callq 0x20b0
incq %r15
jmp 0x40ae
leaq 0x2014(%rip), %rsi      # 0x611d
callq 0x2160
movl 0xc(%rbx), %esi
movq %rax, %rdi
callq 0x21e0
movq %rax, %rdi
callq 0x20b0
movq 0x4eb8(%rip), %rdi      # 0x8fe0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2210
nop
// File: /workspace/github_cpp_makefile_star2_O2/fredericmarchand[P]TexasHoldem/Game.cpp
// Function: Game::getMove()
Move Game::getMove()
{
    Move move;
    string moveStr = "";

    while (moveStr.compare("c") != 0 && moveStr.compare("b") != 0 && moveStr.compare("f") != 0)
    {
        cout << "Check/Call (c), Bet/Raise (b), Fold (f)" << endl;
        cin >> moveStr;
    }
    if (moveStr.compare("c") == 0)
    {
        move = CHECK;
    }
    if (moveStr.compare("b") == 0)
    {
        move = BET;
    }
    if (moveStr.compare("f") == 0)
    {
        move = FOLD;
    }

    return move;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
leaq 0x1b4f(%rip), %rsi      # 0x609d
leaq -0x50(%rbp), %rbx
leaq -0x29(%rbp), %rdx
movq %rbx, %rdi
callq 0x270a
leaq 0x1bbf(%rip), %r14      # 0x6124
leaq 0x1bba(%rip), %r15      # 0x6126
leaq 0x1bb5(%rip), %r12      # 0x6128
movq 0x4a66(%rip), %r13      # 0x8fe0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2060
testl %eax, %eax
je 0x45cf
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2060
testl %eax, %eax
je 0x45cf
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2060
testl %eax, %eax
je 0x45cf
movq 0x4a22(%rip), %rdi      # 0x8fd0
leaq 0x1b75(%rip), %rsi      # 0x612a
callq 0x2160
movq %rax, %rdi
callq 0x20b0
movq %r13, %rdi
movq %rbx, %rsi
callq 0x2190
jmp 0x457a
leaq 0x1b4e(%rip), %rsi      # 0x6124
leaq -0x50(%rbp), %rbx
movq %rbx, %rdi
callq 0x2060
leaq 0x1b3d(%rip), %rsi      # 0x6126
movq %rbx, %rdi
callq 0x2060
xorl %r15d, %r15d
cmpl $0x1, %eax
adcl $0x1, %r15d
leaq 0x1b26(%rip), %rsi      # 0x6128
movq %rbx, %rdi
callq 0x2060
movl %eax, %r14d
testl %eax, %eax
cmovnel %r15d, %r14d
movq %rbx, %rdi
callq 0x20a0
movl %r14d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x20a0
movq %rbx, %rdi
callq 0x21f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/fredericmarchand[P]TexasHoldem/Game.cpp
// Function: Game::setupAIGame(Player*)
void Game::setupAIGame(Player *player)
{
    shuffleDeck(0);
    Card *c1 = getCard(player->getHand()[0]);
    Card *c2 = getCard(player->getHand()[1]);
    if (player == players[0])
    {
        swap(&c1, &deck[0]);
        swap(&c2, &deck[2]);
    }
    else if (player == players[1])
    {
        swap(&c1, &deck[1]);
        swap(&c2, &deck[3]);
    }
    distributeCards();

    if (flop[0] == NULL || flop[1] == NULL || flop[2] == NULL)
    {
        flipFlop(false);
    }
    else
    {
        swap(&flop[0], &deck[5]);
        swap(&flop[1], &deck[6]);
        swap(&flop[2], &deck[7]);
        deckPointer+=4;
    }
    if (turn == NULL)
    {
        flipTurn(false);
    }
    else
    {
        swap(&turn, &deck[9]);
        deckPointer+=2;
    }
    if (river == NULL)
    {
        flipRiver(false);
    }
    else
    {
        swap(&river, &deck[11]);
        deckPointer+=2;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
xorl %esi, %esi
callq 0x3d66
movq %r15, %rdi
callq 0x288a
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x3752
movq %rax, %r14
movq %r15, %rdi
callq 0x288a
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0x3752
movq (%rbx), %rcx
cmpq %r15, (%rcx)
je 0x4776
cmpq %r15, 0x8(%rcx)
jne 0x4784
pushq $0x58
popq %rcx
pushq $0x48
jmp 0x477b
pushq $0x50
popq %rcx
pushq $0x40
popq %rdx
movq %r14, (%rbx,%rdx)
movq %rax, (%rbx,%rcx)
movq %rbx, %rdi
callq 0x3cfe
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x47c9
movq 0x18(%rbx), %rcx
testq %rcx, %rcx
je 0x47c9
movq 0x20(%rbx), %rdx
testq %rdx, %rdx
je 0x47c9
movq 0x68(%rbx), %rsi
movq %rsi, 0x10(%rbx)
movq %rax, 0x68(%rbx)
movups 0x70(%rbx), %xmm0
movups %xmm0, 0x18(%rbx)
movq %rcx, 0x70(%rbx)
movq %rdx, 0x78(%rbx)
addl $0x4, 0x38(%rbx)
jmp 0x47d3
movq %rbx, %rdi
xorl %esi, %esi
callq 0x3a84
movq 0x28(%rbx), %rax
testq %rax, %rax
je 0x47ef
movq 0x88(%rbx), %rcx
movq %rax, 0x88(%rbx)
movl 0x38(%rbx), %eax
jmp 0x47f8
movslq 0x38(%rbx), %rax
movq 0x48(%rbx,%rax,8), %rcx
movq %rcx, 0x28(%rbx)
movq 0x30(%rbx), %rdx
testq %rdx, %rdx
je 0x4815
movq 0x98(%rbx), %rcx
movq %rdx, 0x98(%rbx)
jmp 0x481d
movslq %eax, %rcx
movq 0x58(%rbx,%rcx,8), %rcx
addl $0x4, %eax
movl %eax, 0x38(%rbx)
movq %rcx, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/fredericmarchand[P]TexasHoldem/Game.cpp
// Function: Game::aiSwap(Player*, bool, bool, bool)
void Game::aiSwap(Player *player, bool fl, bool tu, bool ri)
{
    shuffleDeck(3);
    player->getHand()[0] = deck[4];
    player->getHand()[1] = deck[5];
    if (fl)
    {
        flop[0] = deck[6];
        flop[1] = deck[7];
        flop[2] = deck[8];
        swap(&flop[0], &deck[5]);
        swap(&flop[1], &deck[6]);
        swap(&flop[2], &deck[7]);
    }
    if (tu)
    {
        turn = deck[9];
        swap(&turn, &deck[9]);
    }
    if (ri)
    {
        river = deck[10];
        swap(&river, &deck[11]);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, -0x2c(%rbp)
movl %ecx, %r15d
movl %edx, %r12d
movq %rsi, %r13
movq %rdi, %rbx
pushq $0x3
popq %rsi
callq 0x3d66
movq 0x60(%rbx), %r14
movq %r13, %rdi
callq 0x288a
movq %r14, (%rax)
movq 0x68(%rbx), %r14
movq %r13, %rdi
callq 0x288a
movq %r14, 0x8(%rax)
testl %r12d, %r12d
je 0x48a7
movq 0x68(%rbx), %rax
movq 0x70(%rbx), %rcx
movq 0x78(%rbx), %rdx
movq 0x80(%rbx), %rsi
movq %rax, 0x10(%rbx)
movq %rcx, 0x68(%rbx)
movq %rcx, 0x18(%rbx)
movq %rdx, 0x70(%rbx)
movq %rdx, 0x20(%rbx)
movq %rsi, 0x78(%rbx)
testb %r15b, %r15b
je 0x48b7
movq 0x88(%rbx), %rax
movq %rax, 0x28(%rbx)
cmpb $0x0, -0x2c(%rbp)
je 0x48d6
movq 0x90(%rbx), %rax
movq 0x98(%rbx), %rcx
movq %rcx, 0x30(%rbx)
movq %rax, 0x98(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/fredericmarchand[P]TexasHoldem/Node.cpp
// Function: Node::Node(NodeState*)
Node::Node(NodeState *state)
{
    parent = NULL;
    visits = 0;
    this->state = state;
    untriedMoves = *(state->getMoves());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x18(%rdi), %rbx
leaq 0x30(%rdi), %r14
andq $0x0, 0x8(%rdi)
andl $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x38(%rdi)
movq %rsi, 0x48(%rdi)
movq %rsi, %rdi
callq 0x53ee
movq %r14, %rdi
movq %rax, %rsi
callq 0x4cc2
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq %r14, %rdi
callq 0x4e4e
movq %rbx, %rdi
callq 0x4e10
movq %r15, %rdi
callq 0x21f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/fredericmarchand[P]TexasHoldem/Node.cpp
// Function: Node::Node(moves, Node*, NodeState*)
Node::Node(Move move, Node *parent, NodeState *state)
{
    this->parent = parent;
    visits = 0;
    this->move = move;
    this->state = state;
    untriedMoves = *(state->getMoves());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rdi)
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x18(%rdi)
movq %rdx, 0x8(%rdi)
andl $0x0, 0x10(%rdi)
leaq 0x18(%rdi), %rbx
leaq 0x30(%rdi), %r14
movl %esi, 0x14(%rdi)
movq %rcx, 0x48(%rdi)
movq %rcx, %rdi
callq 0x53ee
movq %r14, %rdi
movq %rax, %rsi
callq 0x4cc2
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq %r14, %rdi
callq 0x4e4e
movq %rbx, %rdi
callq 0x4e10
movq %r15, %rdi
callq 0x21f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/fredericmarchand[P]TexasHoldem/Node.cpp
// Function: Node::getUCB()
Node* Node::getUCB()
{
	if (children.size() == 0)
	{
		return NULL;
	}

	Node *child = NULL;
	float UCB = 0.0;
	for (int i = 1; i < children.size(); ++i)
	{
		Node *c = children.at(i);
		float temp = (c->getWins()/c->getVisits() + sqrt(2*log(this->getVisits()/c->getVisits())));
		if (UCB > temp)
		{
			UCB = temp;
			child = c;
		}

	}
    return child;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x18(%rdi), %rcx
movq 0x20(%rdi), %rax
cmpq %rcx, %rax
je 0x4ba1
movq %rdi, %rbx
leaq 0x18(%rdi), %rdx
movq %rdx, -0x38(%rbp)
xorpd %xmm0, %xmm0
pushq $0x1
popq %r12
xorl %r14d, %r14d
subq %rcx, %rax
sarq $0x3, %rax
cmpq %r12, %rax
jbe 0x4ba4
movss %xmm0, -0x2c(%rbp)
movq -0x38(%rbp), %rdi
movq %r12, %rsi
callq 0x4908
movq (%rax), %r15
movl (%r15), %eax
movl 0x10(%r15), %ecx
cltd
idivl %ecx
movl %eax, %r13d
movl 0x10(%rbx), %eax
cltd
idivl %ecx
movl %eax, %edi
callq 0x4da4
addsd %xmm0, %xmm0
ucomisd 0x163e(%rip), %xmm0     # 0x61a8
jb 0x4b72
sqrtsd %xmm0, %xmm0
jmp 0x4b77
callq 0x20f0
cvtsi2sd %r13d, %xmm1
addsd %xmm0, %xmm1
cvtsd2ss %xmm1, %xmm0
movss -0x2c(%rbp), %xmm1
ucomiss %xmm0, %xmm1
minss %xmm1, %xmm0
cmovaq %r15, %r14
incq %r12
movq 0x18(%rbx), %rcx
movq 0x20(%rbx), %rax
jmp 0x4b24
xorl %r14d, %r14d
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/fredericmarchand[P]TexasHoldem/Node.cpp
// Function: Node::addChild(moves, NodeState*)
Node* Node::addChild(Move move, NodeState *state)
{
	Node *child = new Node(move, this, state);
	for (int i = 0; i < untriedMoves.size(); i++)
	{
    	if (untriedMoves.at(i) == move)
    	{
    		untriedMoves.erase(untriedMoves.begin()+i);
    	}
	}
	children.push_back(child);

	return child;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movl %esi, %r14d
movq %rdi, %rbx
pushq $0x50
popq %rdi
callq 0x2170
movq %rax, %r15
movq %rax, %rdi
movl %r14d, %esi
movq %rbx, %rdx
movq %r12, %rcx
callq 0x4a00
movq %r15, -0x30(%rbp)
leaq 0x30(%rbx), %r15
xorl %r13d, %r13d
xorl %r12d, %r12d
movq 0x38(%rbx), %rax
subq 0x30(%rbx), %rax
sarq $0x2, %rax
cmpq %r12, %rax
jbe 0x4c87
movq %r15, %rdi
movq %r12, %rsi
callq 0x48e6
cmpl %r14d, (%rax)
jne 0x4c7e
movq (%r15), %rsi
addq %r13, %rsi
movq %r15, %rdi
callq 0x4db2
incq %r12
addq $0x4, %r13
jmp 0x4c4f
addq $0x18, %rbx
leaq -0x30(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4dec
movq (%r14), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x50
popq %rsi
movq %r15, %rdi
callq 0x2180
movq %rbx, %rdi
callq 0x21f0