LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x40a017
movq %rsp, %r14
movq %rsi, %rdi
movq %rdx, %rsi
movq %r14, %rdx
movl %ebp, %ecx
callq 0x409eda
xorl %eax, %eax
testl %ebp, %ebp
sete %al
leaq 0x1c(,%rax,4), %rdx
movq %r14, %rsi
leaq 0x90(%rbx), %r14
movaps 0xca58b(%rip), %xmm0    # 0x4d45b0
movups %xmm0, 0xc0(%rbx)
movups %xmm0, 0xb0(%rbx)
movups %xmm0, 0xa0(%rbx)
movups %xmm0, 0x90(%rbx)
movaps 0xca578(%rip), %xmm0    # 0x4d45c0
movups %xmm0, 0xd0(%rbx)
movups %xmm0, 0xe0(%rbx)
movups %xmm0, 0xf0(%rbx)
movups %xmm0, 0x100(%rbx)
testq %rdx, %rdx
je 0x40a08b
leaq 0xd0(%rbx), %rax
xorl %ecx, %ecx
movb (%rsi,%rcx), %dil
xorb %dil, -0x40(%rax,%rcx)
movb (%rsi,%rcx), %dil
xorb %dil, (%rax,%rcx)
incq %rcx
cmpq %rcx, %rdx
jne 0x40a072
movq %rbx, %rdi
movl %ebp, %esi
callq 0x4055d0
movl $0x40, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x405686
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x409d4d
movq %r14, %rdi
movl %ebp, %esi
callq 0x4055d0
leaq 0xd0(%r14), %rsi
movl $0x40, %edx
movq %r14, %rdi
callq 0x405686
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x405686
movq %r14, %rdi
movq %rbx, %rsi
callq 0x409d4d
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/wangyu-[P]pwdgen/lib/pbkdf2-sha256.cpp
// Function: sha2_hmac(unsigned char const*, unsigned long, unsigned char const*, unsigned long, unsigned char*, int)
void sha2_hmac( const unsigned char *key, size_t keylen,
                const unsigned char *input, size_t ilen,
                unsigned char output[32], int is224 )
{
    sha2_context ctx;

    sha2_hmac_starts( &ctx, key, keylen, is224 );
    sha2_hmac_update( &ctx, input, ilen );
    sha2_hmac_finish( &ctx, output );

    memset( &ctx, 0, sizeof( sha2_context ) );
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rdx
movq %rdi, %rsi
movq %rsp, %r12
movq %r12, %rdi
movl %r9d, %ecx
callq 0x409fdf
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x405686
movq %r12, %rdi
movq %rbx, %rsi
callq 0x40a0b3
movl $0x118, %edx            # imm = 0x118
movq %r12, %rdi
xorl %esi, %esi
callq 0x401098
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x80, %rsp
movq %r9, %rbx
movq %r8, %r14
movq 0xb0(%rsp), %r15
movq 0xb8(%rsp), %r12
xorps %xmm0, %xmm0
leaq 0x40(%rsp), %rax
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
testq %rdi, %rdi
movl $0x20, %r8d
cmoveq %r8, %rsi
cmoveq %rax, %rdi
movq %rsp, %r13
movq %r13, %r8
xorl %r9d, %r9d
callq 0x40a14d
movl $0x20, %esi
movq %r13, %rdi
movq %r14, %rdx
movq %rbx, %rcx
movq %r15, %r8
movq %r12, %r9
callq 0x40a3e1
movl %eax, %ebx
movq 0x103e23(%rip), %rax    # 0x50e418
movl $0x40, %edx
movq %r13, %rdi
xorl %esi, %esi
callq *%rax
movl %ebx, %eax
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x10(%rdi), %rcx
movq %rcx, (%rdi)
leaq 0x4b2b(%rip), %rcx      # 0x7004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x4b5f(%rip), %rsi      # 0x7048
leaq 0x4b5b(%rip), %rdx      # 0x704b
jmp 0x2520
leaq 0x4b57(%rip), %rsi      # 0x7050
leaq 0x4b53(%rip), %rdx      # 0x7053
jmp 0x2520
leaq 0x4b4b(%rip), %rsi      # 0x7054
leaq 0x4b47(%rip), %rdx      # 0x7057
jmp 0x2520
leaq 0x4b33(%rip), %rsi      # 0x704c
leaq 0x4b2f(%rip), %rdx      # 0x704f
movq %rbx, %rdi
callq 0x28cc
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rax
movq %rdi, %rbx
movl 0x4(%rsi), %eax
leaq 0x10(%rdi), %rcx
movq %rcx, (%rdi)
addl $-0x2, %eax
leaq 0x4ac5(%rip), %rcx      # 0x7014
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x4af9(%rip), %rsi      # 0x7058
leaq 0x4af4(%rip), %rdx      # 0x705a
jmp 0x2632
leaq 0x4b07(%rip), %rsi      # 0x7079
leaq 0x4b02(%rip), %rdx      # 0x707b
jmp 0x2632
leaq 0x4adf(%rip), %rsi      # 0x7064
leaq 0x4ada(%rip), %rdx      # 0x7066
jmp 0x2632
leaq 0x4ae4(%rip), %rsi      # 0x707c
leaq 0x4adf(%rip), %rdx      # 0x707e
jmp 0x2632
leaq 0x4ac8(%rip), %rsi      # 0x7073
leaq 0x4ac3(%rip), %rdx      # 0x7075
jmp 0x2632
leaq 0x4aa3(%rip), %rsi      # 0x705e
leaq 0x4a9e(%rip), %rdx      # 0x7060
jmp 0x2632
leaq 0x4a96(%rip), %rsi      # 0x7061
leaq 0x4a91(%rip), %rdx      # 0x7063
jmp 0x2632
leaq 0x4a92(%rip), %rsi      # 0x706d
leaq 0x4a8d(%rip), %rdx      # 0x706f
jmp 0x2632
leaq 0x4a70(%rip), %rsi      # 0x705b
leaq 0x4a6b(%rip), %rdx      # 0x705d
jmp 0x2632
leaq 0x4a6c(%rip), %rsi      # 0x7067
leaq 0x4a67(%rip), %rdx      # 0x7069
jmp 0x2632
leaq 0x4a5f(%rip), %rsi      # 0x706a
leaq 0x4a5a(%rip), %rdx      # 0x706c
jmp 0x2632
leaq 0x4a5b(%rip), %rsi      # 0x7076
leaq 0x4a56(%rip), %rdx      # 0x7078
jmp 0x2632
leaq 0x4a45(%rip), %rsi      # 0x7070
leaq 0x4a40(%rip), %rdx      # 0x7072
movq %rbx, %rdi
callq 0x28cc
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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)
movl $0x0, 0x24(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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)
movl $0x0, 0x24(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/fredericmarchand[P]TexasHoldem/Player.cpp
// Function: Player::Player(Player*)
Player::Player(Player *player)
{
    hand[0] = player->hand[0];
    hand[1] = player->hand[1];
    dealer = player->dealer;
    chips = player->chips;
    state.move = player->state.move;
    state.bet = player->state.bet;
    ai = player->ai;
    handsWon = player->handsWon;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq (%rsi), %rax
movq %rax, (%rdi)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rdi)
movb 0x14(%rsi), %al
movb %al, 0x14(%rdi)
movl 0x10(%rsi), %eax
movl %eax, 0x10(%rdi)
movl 0x18(%rsi), %eax
movl %eax, 0x18(%rdi)
movl 0x1c(%rsi), %eax
movl %eax, 0x1c(%rdi)
movb 0x20(%rsi), %al
movb %al, 0x20(%rdi)
movl 0x24(%rsi), %eax
movl %eax, 0x24(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
cmpq $0x0, (%rdi)
je 0x2aa9
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0x2aa9
movq %rbx, %rdi
movl $0x2, %esi
callq 0x2aef
movq 0x754b(%rip), %r14      # 0x9fd0
leaq 0x464e(%rip), %rsi      # 0x70da
movl $0x7, %edx
movq %r14, %rdi
callq 0x2150
movl 0x10(%rbx), %esi
movq %r14, %rdi
callq 0x21b0
movq %rax, %rbx
jmp 0x2ac4
movq 0x7520(%rip), %rbx      # 0x9fd0
leaq 0x4611(%rip), %rsi      # 0x70c8
movl $0x11, %edx
movq %rbx, %rdi
callq 0x2150
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2090
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2e88
movl %eax, 0x10(%rdi)
movl $0x2, 0x18(%rdi)
addl %esi, 0x1c(%rdi)
jmp 0x2e96
movl $0x0, 0x10(%rdi)
movl $0x2, 0x18(%rdi)
testl %eax, %eax
setle %al
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rdi, %r13
movq %rdx, -0x38(%rbp)
movq %rdi, -0x48(%rbp)
movl %edx, %r12d
movl %esi, %ebx
movq %rsi, -0x40(%rbp)
cmpl %edx, %esi
jg 0x34df
movq -0x38(%rbp), %rdx
movq -0x40(%rbp), %rsi
leal (%rdx,%rsi), %eax
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
movslq %ecx, %rax
movq (%r13,%rax,8), %rax
movl %esi, %ebx
movl %edx, %r12d
movq %rax, -0x50(%rbp)
movslq %ebx, %r15
decq %r15
movl %ebx, %r14d
movq 0x8(%r13,%r15,8), %rdi
callq 0x24b6
movl %eax, %ebx
movq -0x50(%rbp), %rdi
callq 0x24b6
incq %r15
incl %r14d
cmpl %eax, %ebx
jl 0x345a
leal -0x1(%r14), %eax
movl %eax, -0x2c(%rbp)
movslq %r12d, %r13
incq %r13
movq -0x48(%rbp), %rax
movq -0x8(%rax,%r13,8), %rdi
callq 0x24b6
movl %eax, %ebx
movq -0x50(%rbp), %rdi
callq 0x24b6
decq %r13
decl %r12d
cmpl %eax, %ebx
jg 0x3486
movq -0x48(%rbp), %rax
cmpq %r13, %r15
jle 0x34bd
incl %r12d
movq %rax, %r13
movl -0x2c(%rbp), %ebx
jmp 0x34d6
movq %rax, %rdx
movq (%rax,%r15,8), %rax
movq (%rdx,%r13,8), %rcx
movq %rcx, (%rdx,%r15,8)
movq %rax, (%rdx,%r13,8)
movq %rdx, %r13
movl %r14d, %ebx
cmpl %r12d, %ebx
jle 0x3451
movq -0x40(%rbp), %rsi
cmpl %esi, %r12d
jle 0x34f3
movq %r13, %rdi
movl %r12d, %edx
callq 0x33ff
movl %ebx, %esi
movq -0x38(%rbp), %rdx
cmpl %edx, %ebx
jl 0x341b
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
subq $0x18, %rsp
movl %esi, %r14d
movq %rdi, %r12
movl %esi, 0x8(%rdi)
movslq %esi, %rbx
leaq (,%rbx,8), %rax
testl %ebx, %ebx
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x2030
movq %rax, (%r12)
testl %ebx, %ebx
jle 0x39c4
movl %r14d, %ebx
xorl %r15d, %r15d
movl $0x28, %edi
callq 0x2130
movq %rax, %r14
movq %rax, %rdi
movl $0x186a0, %esi          # imm = 0x186A0
movl $0x1, %edx
callq 0x2992
movq (%r12), %rax
movq %r14, (%rax,%r15,8)
incq %r15
cmpq %r15, %rbx
jne 0x3995
movl $0x0, 0x38(%r12)
movq %r12, -0x38(%rbp)
leaq 0x40(%r12), %rax
movq %rax, -0x40(%rbp)
xorl %r14d, %r14d
xorl %eax, %eax
movl %eax, -0x2c(%rbp)
cltq
movq -0x40(%rbp), %rcx
leaq (%rcx,%rax,8), %rbx
xorl %r13d, %r13d
leal 0x2(%r13), %r12d
movl $0x8, %edi
callq 0x2130
movq %rax, %r15
movq %rax, %rdi
movl %r14d, %esi
movl %r12d, %edx
callq 0x248c
movq %r15, (%rbx,%r13,8)
incq %r13
cmpl $0xd, %r13d
jne 0x39ef
movl -0x2c(%rbp), %eax
addl %r13d, %eax
incl %r14d
cmpl $0x4, %r14d
jne 0x39df
xorps %xmm0, %xmm0
movq -0x38(%rbp), %rax
movups %xmm0, 0x2c(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x10(%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x28, %esi
movq %r14, %rdi
jmp 0x3a64
movq %rax, %rbx
movl $0x8, %esi
movq %r15, %rdi
callq 0x2140
movq %rbx, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movslq 0x8(%rsi), %rax
leaq (,%rax,8), %rcx
testq %rax, %rax
movl %eax, 0x8(%rdi)
movq $-0x1, %rdi
cmovnsq %rcx, %rdi
callq 0x2030
movq %rax, (%rbx)
cmpl $0x0, 0x8(%rbx)
jle 0x3af6
xorl %r12d, %r12d
movl $0x28, %edi
callq 0x2130
movq %rax, %r15
movq (%r14), %rax
movq (%rax,%r12,8), %rsi
movq %r15, %rdi
callq 0x29b8
movq (%rbx), %rax
movq %r15, (%rax,%r12,8)
incq %r12
movslq 0x8(%rbx), %rax
cmpq %rax, %r12
jl 0x3ac7
movl $0x0, 0x38(%rbx)
movl $0x8, %r12d
movl $0x8, %edi
callq 0x2130
movq %rax, %r15
movq (%r14,%r12,8), %rsi
movq %rax, %rdi
callq 0x2498
movq %r15, (%rbx,%r12,8)
incq %r12
cmpq $0x3c, %r12
jne 0x3b03
movq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0x3bb8
movq %rax, 0x10(%rbx)
movq 0x18(%r14), %rsi
movq %rbx, %rdi
callq 0x3bb8
movq %rax, 0x18(%rbx)
movq 0x20(%r14), %rsi
movq %rbx, %rdi
callq 0x3bb8
movq %rax, 0x20(%rbx)
movq 0x28(%r14), %rsi
movq %rbx, %rdi
callq 0x3bb8
movq %rax, 0x28(%rbx)
movq 0x30(%r14), %rsi
movq %rbx, %rdi
callq 0x3bb8
movq %rax, 0x30(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x28, %esi
jmp 0x3b94
movq %rax, %rbx
movl $0x8, %esi
movq %r15, %rdi
callq 0x2140
movq %rbx, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3c60
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
movl $0x8, %r13d
movq 0x63ee(%rip), %r12      # 0x9fd0
cmpq $0x0, (%r14,%r13,8)
jne 0x3c25
movl $0x4, %edx
movq %r12, %rdi
leaq 0x355a(%rip), %rsi      # 0x7152
callq 0x2150
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %r12, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2090
movq %r15, %rdi
callq 0x24ae
movl %eax, %ebx
movq (%r14,%r13,8), %rdi
callq 0x24ae
cmpl %eax, %ebx
jne 0x3c53
movq %r15, %rdi
callq 0x24b6
movl %eax, %ebx
movq (%r14,%r13,8), %rdi
callq 0x24b6
cmpl %eax, %ebx
je 0x3c63
incq %r13
cmpq $0x3c, %r13
jne 0x3be2
xorl %eax, %eax
jmp 0x3c67
xorl %eax, %eax
retq
movq (%r14,%r13,8), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x8(%rdi)
jle 0x3cb9
xorl %r15d, %r15d
movq (%rbx), %rax
movq (%rax,%r15,8), %r14
testq %r14, %r14
je 0x3cad
movq %r14, %rdi
callq 0x29f0
movl $0x28, %esi
movq %r14, %rdi
callq 0x2140
incq %r15
movslq 0x8(%rbx), %rax
cmpq %rax, %r15
jl 0x3c8c
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x3cc6
callq 0x2170
movl $0x8, %r15d
movq (%rbx,%r15,8), %r14
testq %r14, %r14
je 0x3cea
movq %r14, %rdi
callq 0x24a8
movl $0x8, %esi
movq %r14, %rdi
callq 0x2140
incq %r15
cmpq $0x3c, %r15
jne 0x3ccc
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x8(%rdi)
jle 0x3d3c
xorl %r14d, %r14d
movq (%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x2a32
testb %al, %al
jne 0x3d3f
incq %r14
movslq 0x8(%rbx), %rax
cmpq %rax, %r14
jl 0x3d1e
jmp 0x3d3f
xorl %r14d, %r14d
movq (%rbx), %rax
movl %r14d, %r15d
movq (%rax,%r15,8), %rdi
xorl %esi, %esi
callq 0x2a50
testl %r14d, %r14d
movslq 0x8(%rbx), %rax
cmovneq %r15, %rax
movq (%rbx), %rcx
movq -0x8(%rcx,%rax,8), %rdi
movl $0x1, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2a50
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
cmpl $0x0, 0x8(%rdi)
jle 0x3dae
movq %rdi, %r14
xorl %ebx, %ebx
xorl %r15d, %r15d
movq (%r14), %rax
movq (%rax,%r15,8), %rdi
callq 0x2a32
testb %al, %al
jne 0x3db2
incq %r15
movslq 0x8(%r14), %rax
cmpq %rax, %r15
jl 0x3d90
jmp 0x3db9
xorl %ebx, %ebx
jmp 0x3db9
movq (%r14), %rax
movq (%rax,%r15,8), %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0x8(%rdi)
jle 0x3df9
xorl %r14d, %r14d
movq (%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x2a32
testb %al, %al
jne 0x3dfc
incq %r14
movslq 0x8(%rbx), %rax
cmpq %rax, %r14
jl 0x3ddb
jmp 0x3dfc
xorl %r14d, %r14d
testl %r14d, %r14d
je 0x3e20
xorl %eax, %eax
cmpl $0x2, 0x8(%rbx)
sete %al
movl %r14d, %ecx
shlq $0x3, %rcx
addq (%rbx), %rcx
shll $0x4, %eax
addq %rcx, %rax
addq $-0x10, %rax
jmp 0x3e2f
movq (%rbx), %rax
movslq 0x8(%rbx), %rcx
leaq (%rax,%rcx,8), %rax
addq $-0x10, %rax
movq (%rax), %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
cmpl $0x0, 0x8(%rdi)
jle 0x3e69
xorl %r14d, %r14d
movq (%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x2a32
testb %al, %al
jne 0x3e6c
incq %r14
movslq 0x8(%rbx), %rax
cmpq %rax, %r14
jl 0x3e4b
jmp 0x3e6c
xorl %r14d, %r14d
testl %r14d, %r14d
movq (%rbx), %rax
movslq 0x8(%rbx), %rcx
movl %r14d, %edx
cmoveq %rcx, %rdx
movq -0x8(%rax,%rdx,8), %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
testq %rax, %rax
jle 0x3ea8
movq (%rdi), %rdx
xorl %ecx, %ecx
cmpq %rsi, (%rdx,%rcx,8)
je 0x3eaa
incq %rcx
cmpq %rcx, %rax
jne 0x3e9a
xorl %ecx, %ecx
testl %ecx, %ecx
movq (%rdi), %rdx
movl %ecx, %ecx
cmoveq %rax, %rcx
movq -0x8(%rdx,%rcx,8), %rax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movslq 0x8(%rdi), %rax
testq %rax, %rax
jle 0x3ee5
movq (%rbx), %rdx
xorl %ecx, %ecx
cmpq %rsi, (%rdx,%rcx,8)
je 0x3ee7
incq %rcx
cmpq %rcx, %rax
jne 0x3ed7
xorl %ecx, %ecx
incl %ecx
xorl %r14d, %r14d
cmpl 0x8(%rbx), %ecx
je 0x3ef4
movl %ecx, %r14d
movq (%rbx), %rax
movslq %r14d, %r15
movq (%rax,%r15,8), %rdi
callq 0x2e58
movl %r14d, %ecx
testl %eax, %eax
je 0x3ee7
movq (%rbx), %rax
movq (%rax,%r15,8), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
leaq 0x1(%rcx), %rdx
movl %edx, 0x38(%rdi)
movq 0x48(%rdi,%rcx,8), %rdi
addl $0x2, %ecx
movl %ecx, 0x38(%rax)
movq %rdi, 0x28(%rax)
testl %esi, %esi
je 0x42cb
popq %rbp
jmp 0x2644
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
leaq 0x1(%rcx), %rdx
movl %edx, 0x38(%rdi)
movq 0x48(%rdi,%rcx,8), %rdi
addl $0x2, %ecx
movl %ecx, 0x38(%rax)
movq %rdi, 0x30(%rax)
testl %esi, %esi
je 0x42f9
popq %rbp
jmp 0x2644
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2100
movl %eax, %edi
callq 0x2110
cmpl $0x33, %r14d
jg 0x43bd
movslq %r14d, %r14
movl $0x34, %r15d
callq 0x2050
cltd
idivl %r15d
movslq %edx, %rax
movq 0x38(%rbx,%r15,8), %rcx
movq 0x40(%rbx,%rax,8), %rdx
movq %rdx, 0x38(%rbx,%r15,8)
movq %rcx, 0x40(%rbx,%rax,8)
decq %r15
cmpq %r14, %r15
jg 0x4395
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, %rbx
cmpl $0x0, 0x8(%rdi)
setg %r15b
jle 0x4441
movq (%rbx), %rax
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x44f6
testb %al, %al
je 0x43fd
xorl %r14d, %r14d
jmp 0x4429
movl $0x1, %r14d
movslq 0x8(%rbx), %rax
cmpq %rax, %r14
setl %r15b
jge 0x4441
movq (%rbx), %rax
movq (%rax,%r14,8), %rsi
movq %rbx, %rdi
callq 0x44f6
incq %r14
testb %al, %al
je 0x4403
decq %r14
movq (%rbx), %rax
movq (%rax,%r14,8), %rsi
movq %rbx, %rdi
callq 0x455a
testb %r15b, %r15b
jne 0x44e4
movq %rsp, %r15
cmpl $0x0, 0x8(%rbx)
jle 0x44b6
movq %r15, -0x30(%rbp)
leaq 0x10(%rbx), %rax
movq %rax, -0x38(%rbp)
xorl %r13d, %r13d
xorl %r14d, %r14d
xorl %r15d, %r15d
xorl %r12d, %r12d
movq (%rbx), %rax
movq 0x28(%rbx), %rdx
movq (%rax,%r13,8), %rdi
movq 0x30(%rbx), %rcx
movq -0x38(%rbp), %rsi
movl $0x1, %r8d
callq 0x3510
cmpl %r15d, %eax
movl $0x1, %ecx
cmovel %ecx, %r12d
movl $0x0, %ecx
cmovgl %ecx, %r12d
cmovgl %eax, %r15d
cmovgl %r13d, %r14d
incq %r13
movslq 0x8(%rbx), %rax
cmpq %rax, %r13
jl 0x4462
cmpl $0x1, %r12d
sete %al
movq -0x30(%rbp), %r15
jmp 0x44bb
xorl %eax, %eax
xorl %r14d, %r14d
testb %al, %al
je 0x44cf
movq %rbx, %rdi
callq 0x469c
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
jmp 0x44e1
movq (%rbx), %rax
movslq %r14d, %rcx
movq (%rax,%rcx,8), %rsi
movq %rbx, %rdi
callq 0x455a
movq %r15, %rsp
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2e58
testl %eax, %eax
je 0x4545
cmpl $0x0, 0x8(%r15)
jle 0x4549
movb $0x1, %bl
xorl %r12d, %r12d
movq (%r15), %rax
movq (%rax,%r12,8), %rdi
cmpq %r14, %rdi
je 0x4537
callq 0x2e58
testl %eax, %eax
sete %al
andb %al, %bl
incq %r12
movslq 0x8(%r15), %rax
cmpq %rax, %r12
jl 0x451f
jmp 0x454b
xorl %ebx, %ebx
jmp 0x454b
movb $0x1, %bl
andb $0x1, %bl
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, %r14
movq %rdi, %rbx
movl 0xc(%rdi), %esi
movq %r14, %rdi
callq 0x2a1e
movq 0x5a50(%rip), %rdi      # 0x9fd0
leaq 0x2b86(%rip), %rsi      # 0x710d
movl $0xf, %edx
callq 0x2150
movslq 0x8(%rbx), %rax
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
testq %rax, %rax
jle 0x45b6
movq (%rbx), %rdx
xorl %ecx, %ecx
cmpq %r14, (%rdx,%rcx,8)
je 0x45b4
incq %rcx
cmpq %rcx, %rax
jne 0x45a4
jmp 0x45b6
movl %ecx, %esi
movq 0x5a13(%rip), %rdi      # 0x9fd0
callq 0x21b0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2090
cmpl $0x0, 0x8(%rbx)
jle 0x4685
xorl %r14d, %r14d
movq 0x59d0(%rip), %r15      # 0x9fd0
leaq 0x2be8(%rip), %r13      # 0x71ef
movl $0x7, %edx
movq %r15, %rdi
leaq 0x2bf4(%rip), %rsi      # 0x720a
callq 0x2150
movq %r15, %rdi
movl %r14d, %esi
callq 0x21b0
movq %rax, %r12
movl $0x3, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x2150
movq (%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x2a0a
movq %r12, %rdi
movl %eax, %esi
callq 0x21b0
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %r12, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2090
incq %r14
movslq 0x8(%rbx), %rax
cmpq %rax, %r14
jl 0x4607
movl $0x0, 0xc(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x591c(%rip), %r14      # 0x9fd0
leaq 0x2a48(%rip), %rsi      # 0x7103
movl $0x9, %edx
movq %r14, %rdi
callq 0x2150
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2090
movl 0x8(%rbx), %ecx
testl %ecx, %ecx
jle 0x47a1
xorl %r14d, %r14d
movq 0x58cc(%rip), %r15      # 0x9fd0
leaq 0x2ae4(%rip), %r13      # 0x71ef
movq (%rbx), %rax
movq (%rax,%r14,8), %rdi
movl 0xc(%rbx), %eax
cltd
idivl %ecx
movl %eax, %esi
callq 0x2a1e
movl $0x7, %edx
movq %r15, %rdi
leaq 0x2adc(%rip), %rsi      # 0x720a
callq 0x2150
movq %r15, %rdi
movl %r14d, %esi
callq 0x21b0
movq %rax, %r12
movl $0x3, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x2150
movq (%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x2a0a
movq %r12, %rdi
movl %eax, %esi
callq 0x21b0
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %r12, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2090
incq %r14
movslq 0x8(%rbx), %rcx
cmpq %rcx, %r14
jl 0x470b
movl $0x0, 0xc(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5800(%rip), %r14      # 0x9fd0
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2090
cmpl $0x0, 0x8(%rbx)
jle 0x4890
xorl %r14d, %r14d
movq 0x57c5(%rip), %r15      # 0x9fd0
leaq 0x29dd(%rip), %r13      # 0x71ef
movl $0x7, %edx
movq %r15, %rdi
leaq 0x29e9(%rip), %rsi      # 0x720a
callq 0x2150
movq %r15, %rdi
movl %r14d, %esi
callq 0x21b0
movq %rax, %r12
movl $0x3, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x2150
movq (%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x2a0a
movq %r12, %rdi
movl %eax, %esi
callq 0x21b0
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %r12, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2090
incq %r14
movslq 0x8(%rbx), %rax
cmpq %rax, %r14
jl 0x4812
movq 0x5739(%rip), %r14      # 0x9fd0
leaq 0x287f(%rip), %rsi      # 0x711d
movl $0x6, %edx
movq %r14, %rdi
callq 0x2150
movl 0xc(%rbx), %esi
movq %r14, %rdi
callq 0x21b0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2090
movq 0x56f9(%rip), %rdi      # 0x9fe0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x21e0
// File: /workspace/github_cpp_makefile_star2_O1/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 -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0x2231(%rip), %rdx      # 0x709d
leaq -0x48(%rbp), %rbx
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x28cc
leaq 0x22a2(%rip), %r14      # 0x7124
leaq 0x229d(%rip), %r15      # 0x7126
movq 0x5140(%rip), %r13      # 0x9fd0
movq 0x5149(%rip), %r12      # 0x9fe0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2060
testl %eax, %eax
je 0x4f11
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2060
testl %eax, %eax
je 0x4f11
movq %rbx, %rdi
leaq 0x2269(%rip), %rsi      # 0x7128
callq 0x2060
testl %eax, %eax
je 0x4f11
movl $0x27, %edx
movq %r13, %rdi
leaq 0x2253(%rip), %rsi      # 0x712a
callq 0x2150
movq (%r13), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x2120
movsbl %al, %esi
movq %r13, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2090
movq %r12, %rdi
movq %rbx, %rsi
callq 0x2160
jmp 0x4e97
leaq 0x220c(%rip), %rsi      # 0x7124
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x2060
leaq 0x21fb(%rip), %rsi      # 0x7126
movq %r15, %rdi
callq 0x2060
movl %eax, %ebx
leaq 0x21ec(%rip), %rsi      # 0x7128
movq %r15, %rdi
callq 0x2060
movl %eax, %r14d
movq (%r15), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x4f5f
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2140
xorl %eax, %eax
cmpl $0x1, %ebx
adcl $0x1, %eax
testl %r14d, %r14d
cmovel %r14d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x4f99
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2140
movq %rbx, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4368
movq %r15, %rdi
callq 0x2a14
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x3bb8
movq %rax, %r14
movq %r15, %rdi
callq 0x2a14
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0x3bb8
movq (%rbx), %rcx
cmpq %r15, (%rcx)
je 0x50d3
cmpq %r15, 0x8(%rcx)
jne 0x50e5
movl $0x58, %ecx
movl $0x48, %edx
jmp 0x50dd
movl $0x50, %ecx
movl $0x40, %edx
movq %r14, (%rbx,%rdx)
movq %rax, (%rbx,%rcx)
movq %rbx, %rdi
callq 0x42fc
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x512a
movq 0x18(%rbx), %rcx
testq %rcx, %rcx
je 0x512a
movq 0x20(%rbx), %rdx
testq %rdx, %rdx
je 0x512a
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 0x5164
movslq 0x38(%rbx), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x38(%rbx)
movq 0x48(%rbx,%rax,8), %rcx
leaq 0x2(%rax), %rdx
movl %edx, 0x38(%rbx)
movq %rcx, 0x10(%rbx)
movq 0x50(%rbx,%rax,8), %rcx
leaq 0x3(%rax), %rdx
movl %edx, 0x38(%rbx)
movq %rcx, 0x18(%rbx)
movq 0x58(%rbx,%rax,8), %rcx
addl $0x4, %eax
movl %eax, 0x38(%rbx)
movq %rcx, 0x20(%rbx)
movq 0x28(%rbx), %rax
testq %rax, %rax
je 0x5185
movq 0x88(%rbx), %rcx
movq %rcx, 0x28(%rbx)
movq %rax, 0x88(%rbx)
addl $0x2, 0x38(%rbx)
jmp 0x519f
movslq 0x38(%rbx), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x38(%rbx)
movq 0x48(%rbx,%rax,8), %rcx
addl $0x2, %eax
movl %eax, 0x38(%rbx)
movq %rcx, 0x28(%rbx)
movq 0x30(%rbx), %rax
testq %rax, %rax
je 0x51c0
movq 0x98(%rbx), %rcx
movq %rcx, 0x30(%rbx)
movq %rax, 0x98(%rbx)
addl $0x2, 0x38(%rbx)
jmp 0x51da
movslq 0x38(%rbx), %rax
leaq 0x1(%rax), %rcx
movl %ecx, 0x38(%rbx)
movq 0x48(%rbx,%rax,8), %rcx
addl $0x2, %eax
movl %eax, 0x38(%rbx)
movq %rcx, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x3, %esi
callq 0x4368
movq 0x60(%rbx), %r14
movq %r13, %rdi
callq 0x2a14
movq %r14, (%rax)
movq 0x68(%rbx), %r14
movq %r13, %rdi
callq 0x2a14
movq %r14, 0x8(%rax)
testl %r12d, %r12d
je 0x525d
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 0x526d
movq 0x88(%rbx), %rax
movq %rax, 0x28(%rbx)
cmpb $0x0, -0x2c(%rbp)
je 0x528c
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_O1/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 %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
leaq 0x30(%rdi), %r15
movq $0x0, 0x8(%rdi)
movl $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 0x5d20
movq %r15, %rdi
movq %rax, %rsi
callq 0x566e
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
movq (%r15), %rdi
testq %rdi, %rdi
je 0x532d
movq 0x40(%rbx), %rsi
subq %rdi, %rsi
callq 0x2140
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2200
movq %r12, %rdi
callq 0x21c0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
leaq 0x30(%rdi), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rdi)
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x18(%rdi)
movq %rdx, 0x8(%rdi)
movl $0x0, 0x10(%rdi)
movl %esi, 0x14(%rdi)
movq %rcx, 0x48(%rdi)
movq %rcx, %rdi
callq 0x5d20
movq %r15, %rdi
movq %rax, %rsi
callq 0x566e
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
movq (%r15), %rdi
testq %rdi, %rdi
je 0x53aa
movq 0x40(%rbx), %rsi
subq %rdi, %rsi
callq 0x2140
movq %r14, %rdi
movq %rbx, %rsi
callq 0x221b
movq %r12, %rdi
callq 0x21c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rax
movq 0x20(%rdi), %rax
cmpq 0x18(%rdi), %rax
je 0x550a
movq %rdi, %rbx
movq 0x18(%rdi), %rax
movq 0x20(%rdi), %rcx
subq %rax, %rcx
cmpq $0x9, %rcx
jb 0x550a
xorps %xmm0, %xmm0
movl $0x1, %r12d
xorl %r14d, %r14d
movss %xmm0, -0x2c(%rbp)
movq (%rax,%r12,8), %r13
movl (%r13), %eax
movl 0x10(%r13), %ecx
cltd
idivl %ecx
movl %eax, %r15d
movl 0x10(%rbx), %eax
cltd
idivl %ecx
xorps %xmm0, %xmm0
cvtsi2sd %eax, %xmm0
callq 0x20d0
addsd %xmm0, %xmm0
ucomisd 0x1ce7(%rip), %xmm0     # 0x71a8
jb 0x54c9
sqrtsd %xmm0, %xmm0
jmp 0x54ce
callq 0x20c0
xorps %xmm1, %xmm1
cvtsi2sd %r15d, %xmm1
addsd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtsd2ss %xmm1, %xmm0
movss -0x2c(%rbp), %xmm1
ucomiss %xmm0, %xmm1
cmovaq %r13, %r14
minss %xmm1, %xmm0
incq %r12
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r12, %rcx
ja 0x548c
jmp 0x550d
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop