LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: wangyu-[P]pwdgen/lib/pbkdf2-sha1.cpp
// Function: sha1_hmac_starts(sha1_context*, unsigned char const*, int)
void sha1_hmac_starts(sha1_context * ctx, const unsigned char *key, int keylen)
{
	int i;
	unsigned char sum[20];

	if (keylen > 64) {
		sha1(key, keylen, sum);
		keylen = 20;
		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]);
	}

	sha1_starts(ctx);
	sha1_update(ctx, ctx->ipad, 64);

}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
cmpl $0x40, 0x24(%rsp)
jle 0x40802a
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movq %rsp, %rdx
callq 0x407f90
movl $0x14, 0x24(%rsp)
movq %rsp, %rax
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
addq $0x78, %rdi
movl $0x36, %esi
movl $0x40, %edx
callq 0x401098
movq 0x30(%rsp), %rdi
addq $0xb8, %rdi
movl $0x5c, %esi
movl $0x40, %edx
callq 0x401098
movl $0x0, 0x20(%rsp)
movl 0x20(%rsp), %eax
cmpl 0x24(%rsp), %eax
jge 0x4080e0
movq 0x30(%rsp), %rax
movslq 0x20(%rsp), %rcx
movzbl 0x78(%rax,%rcx), %eax
movq 0x28(%rsp), %rcx
movslq 0x20(%rsp), %rdx
movzbl (%rcx,%rdx), %ecx
xorl %ecx, %eax
movb %al, %dl
movq 0x30(%rsp), %rax
movslq 0x20(%rsp), %rcx
movb %dl, 0x78(%rax,%rcx)
movq 0x30(%rsp), %rax
movslq 0x20(%rsp), %rcx
movzbl 0xb8(%rax,%rcx), %eax
movq 0x28(%rsp), %rcx
movslq 0x20(%rsp), %rdx
movzbl (%rcx,%rdx), %ecx
xorl %ecx, %eax
movb %al, %dl
movq 0x30(%rsp), %rax
movslq 0x20(%rsp), %rcx
movb %dl, 0xb8(%rax,%rcx)
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x408065
movq 0x30(%rsp), %rdi
callq 0x4043b0
movq 0x30(%rsp), %rdi
movq 0x30(%rsp), %rsi
addq $0x78, %rsi
movl $0x40, %edx
callq 0x404420
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: wangyu-[P]pwdgen/lib/pbkdf2-sha1.cpp
// Function: sha1_hmac_finish(sha1_context*, unsigned char*)
void sha1_hmac_finish(sha1_context * ctx, unsigned char output[20])
{
	unsigned char tmpbuf[20];

	sha1_finish(ctx, tmpbuf);
	sha1_starts(ctx);
	sha1_update(ctx, ctx->opad, 64);
	sha1_update(ctx, tmpbuf, 20);
	sha1_finish(ctx, output);

}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x407cc0
movq 0x20(%rsp), %rdi
callq 0x4043b0
movq 0x20(%rsp), %rdi
movq 0x20(%rsp), %rsi
addq $0xb8, %rsi
movl $0x40, %edx
callq 0x404420
movq 0x20(%rsp), %rdi
movq %rsp, %rsi
movl $0x14, %edx
callq 0x404420
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x407cc0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: wangyu-[P]pwdgen/lib/pbkdf2-sha256.cpp
// Function: sha2_starts(sha2_context*, int)
void sha2_starts( sha2_context *ctx, int is224 )
{
    ctx->total[0] = 0;
    ctx->total[1] = 0;

    if( is224 == 0 )
    {
        /* SHA-256 */
        ctx->state[0] = 0x6A09E667;
        ctx->state[1] = 0xBB67AE85;
        ctx->state[2] = 0x3C6EF372;
        ctx->state[3] = 0xA54FF53A;
        ctx->state[4] = 0x510E527F;
        ctx->state[5] = 0x9B05688C;
        ctx->state[6] = 0x1F83D9AB;
        ctx->state[7] = 0x5BE0CD19;
    }
    else
    {
        /* SHA-224 */
        ctx->state[0] = 0xC1059ED8;
        ctx->state[1] = 0x367CD507;
        ctx->state[2] = 0x3070DD17;
        ctx->state[3] = 0xF70E5939;
        ctx->state[4] = 0xFFC00B31;
        ctx->state[5] = 0x68581511;
        ctx->state[6] = 0x64F98FA7;
        ctx->state[7] = 0xBEFA4FA4;
    }

    ctx->is224 = is224;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq -0x8(%rsp), %rax
movq $0x0, (%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x8(%rax)
cmpl $0x0, -0xc(%rsp)
jne 0x408596
movq -0x8(%rsp), %rax
movq $0x6a09e667, 0x10(%rax) # imm = 0x6A09E667
movq -0x8(%rsp), %rax
movl $0xbb67ae85, %ecx       # imm = 0xBB67AE85
movq %rcx, 0x18(%rax)
movq -0x8(%rsp), %rax
movq $0x3c6ef372, 0x20(%rax) # imm = 0x3C6EF372
movq -0x8(%rsp), %rax
movl $0xa54ff53a, %ecx       # imm = 0xA54FF53A
movq %rcx, 0x28(%rax)
movq -0x8(%rsp), %rax
movq $0x510e527f, 0x30(%rax) # imm = 0x510E527F
movq -0x8(%rsp), %rax
movl $0x9b05688c, %ecx       # imm = 0x9B05688C
movq %rcx, 0x38(%rax)
movq -0x8(%rsp), %rax
movq $0x1f83d9ab, 0x40(%rax) # imm = 0x1F83D9AB
movq -0x8(%rsp), %rax
movq $0x5be0cd19, 0x48(%rax) # imm = 0x5BE0CD19
jmp 0x408602
movq -0x8(%rsp), %rax
movl $0xc1059ed8, %ecx       # imm = 0xC1059ED8
movq %rcx, 0x10(%rax)
movq -0x8(%rsp), %rax
movq $0x367cd507, 0x18(%rax) # imm = 0x367CD507
movq -0x8(%rsp), %rax
movq $0x3070dd17, 0x20(%rax) # imm = 0x3070DD17
movq -0x8(%rsp), %rax
movl $0xf70e5939, %ecx       # imm = 0xF70E5939
movq %rcx, 0x28(%rax)
movq -0x8(%rsp), %rax
movl $0xffc00b31, %ecx       # imm = 0xFFC00B31
movq %rcx, 0x30(%rax)
movq -0x8(%rsp), %rax
movq $0x68581511, 0x38(%rax) # imm = 0x68581511
movq -0x8(%rsp), %rax
movq $0x64f98fa7, 0x40(%rax) # imm = 0x64F98FA7
movq -0x8(%rsp), %rax
movl $0xbefa4fa4, %ecx       # imm = 0xBEFA4FA4
movq %rcx, 0x48(%rax)
movl -0xc(%rsp), %ecx
movq -0x8(%rsp), %rax
movl %ecx, 0x110(%rax)
retq
nopw %cs:(%rax,%rax)
// File: wangyu-[P]pwdgen/lib/pbkdf2-sha256.cpp
// Function: sha2_update(sha2_context*, unsigned char const*, unsigned long)
void sha2_update( sha2_context *ctx, const unsigned char *input, size_t ilen )
{
    size_t fill;
    unsigned long left;

    if( ilen <= 0 )
        return;

    left = ctx->total[0] & 0x3F;
    fill = 64 - left;

    ctx->total[0] += (unsigned long) ilen;
    ctx->total[0] &= 0xFFFFFFFF;

    if( ctx->total[0] < (unsigned long) ilen )
        ctx->total[1]++;

    if( left && ilen >= fill )
    {
        memcpy( (void *) (ctx->buffer + left),
                (void *) input, fill );
        sha2_process( ctx, ctx->buffer );
        input += fill;
        ilen  -= fill;
        left = 0;
    }

    while( ilen >= 64 )
    {
        sha2_process( ctx, input );
        input += 64;
        ilen  -= 64;
    }

    if( ilen > 0 )
    {
        memcpy( (void *) (ctx->buffer + left),
                (void *) input, ilen );
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
ja 0x408640
jmp 0x408769
movq 0x20(%rsp), %rax
movq (%rax), %rax
andq $0x3f, %rax
movq %rax, (%rsp)
movl $0x40, %eax
subq (%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rcx
movq 0x20(%rsp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq 0x20(%rsp), %rax
movabsq $0xffffffff, %rcx       # imm = 0xFFFFFFFF
andq (%rax), %rcx
movq %rcx, (%rax)
movq 0x20(%rsp), %rax
movq (%rax), %rax
cmpq 0x10(%rsp), %rax
jae 0x4086a3
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
cmpq $0x0, (%rsp)
je 0x40870e
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
jb 0x40870e
movq 0x20(%rsp), %rdi
addq $0x50, %rdi
addq (%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x401040
movq 0x20(%rsp), %rdi
movq 0x20(%rsp), %rsi
addq $0x50, %rsi
callq 0x408770
movq 0x8(%rsp), %rax
addq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
subq %rcx, %rax
movq %rax, 0x10(%rsp)
movq $0x0, (%rsp)
jmp 0x408710
cmpq $0x40, 0x10(%rsp)
jb 0x408745
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x408770
movq 0x18(%rsp), %rax
addq $0x40, %rax
movq %rax, 0x18(%rsp)
movq 0x10(%rsp), %rax
subq $0x40, %rax
movq %rax, 0x10(%rsp)
jmp 0x408710
cmpq $0x0, 0x10(%rsp)
jbe 0x408769
movq 0x20(%rsp), %rdi
addq $0x50, %rdi
addq (%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x401040
addq $0x28, %rsp
retq
nop
// File: wangyu-[P]pwdgen/lib/pbkdf2-sha256.cpp
// Function: sha2(unsigned char const*, unsigned long, unsigned char*, int)
void sha2( const unsigned char *input, size_t ilen,
           unsigned char output[32], int is224 )
{
    sha2_context ctx;

    sha2_starts( &ctx, is224 );
    sha2_update( &ctx, input, ilen );
    sha2_finish( &ctx, output );

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

// Assembly:
subq $0x138, %rsp            # imm = 0x138
movq %rdi, 0x130(%rsp)
movq %rsi, 0x128(%rsp)
movq %rdx, 0x120(%rsp)
movl %ecx, 0x11c(%rsp)
movl 0x11c(%rsp), %esi
movq %rsp, %rdi
callq 0x408500
movq 0x130(%rsp), %rsi
movq 0x128(%rsp), %rdx
movq %rsp, %rdi
callq 0x408620
movq 0x120(%rsp), %rsi
movq %rsp, %rdi
callq 0x410a70
movq %rsp, %rdi
xorl %esi, %esi
movl $0x118, %edx            # imm = 0x118
callq 0x401098
addq $0x138, %rsp            # imm = 0x138
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movl %ecx, 0x2c(%rsp)
cmpq $0x40, 0x30(%rsp)
jbe 0x410f28
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq %rsp, %rdx
movl 0x2c(%rsp), %ecx
callq 0x410e50
movl 0x2c(%rsp), %edx
movl $0x20, %eax
movl $0x1c, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
cltq
movq %rax, 0x30(%rsp)
movq %rsp, %rax
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rdi
addq $0x90, %rdi
movl $0x36, %esi
movl $0x40, %edx
callq 0x401098
movq 0x40(%rsp), %rdi
addq $0xd0, %rdi
movl $0x5c, %esi
movl $0x40, %edx
callq 0x401098
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x30(%rsp), %rax
jae 0x410ff0
movq 0x40(%rsp), %rax
movq 0x20(%rsp), %rcx
movzbl 0x90(%rax,%rcx), %eax
movq 0x38(%rsp), %rcx
movq 0x20(%rsp), %rdx
movzbl (%rcx,%rdx), %ecx
xorl %ecx, %eax
movb %al, %dl
movq 0x40(%rsp), %rax
movq 0x20(%rsp), %rcx
movb %dl, 0x90(%rax,%rcx)
movq 0x40(%rsp), %rax
movq 0x20(%rsp), %rcx
movzbl 0xd0(%rax,%rcx), %eax
movq 0x38(%rsp), %rcx
movq 0x20(%rsp), %rdx
movzbl (%rcx,%rdx), %ecx
xorl %ecx, %eax
movb %al, %dl
movq 0x40(%rsp), %rax
movq 0x20(%rsp), %rcx
movb %dl, 0xd0(%rax,%rcx)
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x410f67
movq 0x40(%rsp), %rdi
movl 0x2c(%rsp), %esi
callq 0x408500
movq 0x40(%rsp), %rdi
movq 0x40(%rsp), %rsi
addq $0x90, %rsi
movl $0x40, %edx
callq 0x408620
movq %rsp, %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x401098
addq $0x48, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movl 0x110(%rax), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %edx
movl $0x1c, %eax
movl $0x20, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
movl %eax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movq %rsp, %rsi
callq 0x410a70
movq 0x30(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x408500
movq 0x30(%rsp), %rdi
movq 0x30(%rsp), %rsi
addq $0xd0, %rsi
movl $0x40, %edx
callq 0x408620
movq 0x30(%rsp), %rdi
movq %rsp, %rsi
movslq 0x20(%rsp), %rdx
callq 0x408620
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x410a70
movq %rsp, %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x401098
addq $0x38, %rsp
retq
// File: 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:
subq $0x148, %rsp            # imm = 0x148
movq %rdi, 0x140(%rsp)
movq %rsi, 0x138(%rsp)
movq %rdx, 0x130(%rsp)
movq %rcx, 0x128(%rsp)
movq %r8, 0x120(%rsp)
movl %r9d, 0x11c(%rsp)
movq 0x140(%rsp), %rsi
movq 0x138(%rsp), %rdx
movl 0x11c(%rsp), %ecx
movq %rsp, %rdi
callq 0x410ed0
movq 0x130(%rsp), %rsi
movq 0x128(%rsp), %rdx
movq %rsp, %rdi
callq 0x411030
movq 0x120(%rsp), %rsi
movq %rsp, %rdi
callq 0x411060
movq %rsp, %rdi
xorl %esi, %esi
movl $0x118, %edx            # imm = 0x118
callq 0x401098
addq $0x148, %rsp            # imm = 0x148
retq
nopw %cs:(%rax,%rax)
// File: wangyu-[P]pwdgen/lib/pbkdf2-sha256.cpp
// Function: hkdf_sha256_extract(unsigned char const*, unsigned long, unsigned char const*, unsigned long, unsigned char*)
int hkdf_sha256_extract(
                          const unsigned char *salt, size_t salt_len,
                          const unsigned char *ikm, size_t ikm_len,
                          unsigned char *prk )
{
    unsigned char null_salt[MBEDTLS_MD_MAX_SIZE] = { '\0' };

    if( salt == NULL )
    {
        size_t hash_len;

        hash_len = sha256_len;

        if( hash_len == 0 )
        {
            return MBEDTLS_ERR_HKDF_BAD_INPUT_DATA;
        }

        salt = null_salt;
        salt_len = hash_len;
    }

    sha2_hmac (salt, salt_len, ikm, ikm_len, prk ,0);
    return 0;
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movq %rdx, 0x68(%rsp)
movq %rcx, 0x60(%rsp)
movq %r8, 0x58(%rsp)
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x401098
cmpq $0x0, 0x78(%rsp)
jne 0x41152b
movq $0x20, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x411517
movl $0xffffa080, 0x84(%rsp) # imm = 0xFFFFA080
jmp 0x411557
leaq 0x10(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x78(%rsp), %rdi
movq 0x70(%rsp), %rsi
movq 0x68(%rsp), %rdx
movq 0x60(%rsp), %rcx
movq 0x58(%rsp), %r8
xorl %r9d, %r9d
callq 0x411140
movl $0x0, 0x84(%rsp)
movl 0x84(%rsp), %eax
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x78, %rsp
movq 0x88(%rsp), %rax
movq 0x80(%rsp), %rax
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movq %r8, 0x50(%rsp)
movq %r9, 0x48(%rsp)
movq 0x70(%rsp), %rdi
movq 0x68(%rsp), %rsi
movq 0x60(%rsp), %rdx
movq 0x58(%rsp), %rcx
movq %rsp, %r8
callq 0x4114c0
movl %eax, 0x44(%rsp)
cmpl $0x0, 0x44(%rsp)
jne 0x4118c4
movq %rsp, %rdi
movq 0x50(%rsp), %rdx
movq 0x48(%rsp), %rcx
movq 0x80(%rsp), %r8
movq 0x88(%rsp), %r9
movl $0x20, %esi
callq 0x411570
movl %eax, 0x44(%rsp)
movq %rsp, %rdi
movl $0x40, %esi
callq 0x411490
movl 0x44(%rsp), %eax
addq $0x78, %rsp
retq
nopw (%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x30(%rbp)
subq $0x3, %rax
ja 0x2763
movq -0x30(%rbp), %rax
leaq 0x89ca(%rip), %rcx      # 0xb004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq -0x11(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x22b0
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rdx
leaq 0x89e9(%rip), %rsi      # 0xb048
callq 0x2da0
jmp 0x2666
leaq -0x11(%rbp), %rdi
callq 0x21d0
jmp 0x2765
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x11(%rbp), %rdi
callq 0x21d0
jmp 0x276f
leaq -0x25(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x22b0
movq -0x40(%rbp), %rdi
movq -0x50(%rbp), %rdx
leaq 0x89a2(%rip), %rsi      # 0xb04c
callq 0x2da0
jmp 0x26b1
leaq -0x25(%rbp), %rdi
callq 0x21d0
jmp 0x2765
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x25(%rbp), %rdi
callq 0x21d0
jmp 0x276f
leaq -0x26(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x22b0
movq -0x40(%rbp), %rdi
movq -0x58(%rbp), %rdx
leaq 0x895b(%rip), %rsi      # 0xb050
callq 0x2da0
jmp 0x26fc
leaq -0x26(%rbp), %rdi
callq 0x21d0
jmp 0x2765
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x26(%rbp), %rdi
callq 0x21d0
jmp 0x276f
leaq -0x27(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x22b0
movq -0x40(%rbp), %rdi
movq -0x60(%rbp), %rdx
leaq 0x891a(%rip), %rsi      # 0xb054
callq 0x2da0
jmp 0x2741
leaq -0x27(%rbp), %rdi
callq 0x21d0
jmp 0x2765
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x27(%rbp), %rdi
callq 0x21d0
jmp 0x276f
ud2
movq -0x38(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x22a0
nopl (%rax,%rax)
// File: 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
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
movq 0xd3e2(%rip), %rdi      # 0xffd0
movq %rdi, -0x80(%rbp)
leaq 0x8486(%rip), %rsi      # 0xb07f
callq 0x2180
movq %rax, %rdi
movq 0xd3b8(%rip), %rsi      # 0xffc0
movq %rsi, -0x88(%rbp)
callq 0x21b0
movq -0x80(%rbp), %rdi
leaq 0x846d(%rip), %rsi      # 0xb08c
movq %rsi, -0x90(%rbp)
callq 0x2180
movq -0x88(%rbp), %rsi
movq %rax, %rdi
callq 0x21b0
movq -0x90(%rbp), %rsi
movq -0x80(%rbp), %rdi
callq 0x2180
movq -0x88(%rbp), %rsi
movq %rax, %rdi
callq 0x21b0
movq -0x80(%rbp), %rdi
leaq 0x8435(%rip), %rsi      # 0xb099
callq 0x2180
movq -0x78(%rbp), %rsi
movq %rax, -0x70(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x2780
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x2150
movq %rax, -0x60(%rbp)
jmp 0x2c91
movq -0x78(%rbp), %rsi
leaq -0x58(%rbp), %rdi
callq 0x2600
jmp 0x2ca0
movq -0x60(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x2150
movq %rax, -0x98(%rbp)
jmp 0x2cb6
movq -0x98(%rbp), %rdi
leaq 0x83cf(%rip), %rsi      # 0xb093
callq 0x2180
movq %rax, -0xa0(%rbp)
jmp 0x2cd2
movq -0xa0(%rbp), %rdi
movq 0xd2e0(%rip), %rsi      # 0xffc0
callq 0x21b0
jmp 0x2ce7
leaq -0x58(%rbp), %rdi
callq 0x20c0
leaq -0x28(%rbp), %rdi
callq 0x20c0
movq 0xd2d0(%rip), %rdi      # 0xffd0
leaq 0x8385(%rip), %rsi      # 0xb08c
callq 0x2180
movq %rax, %rdi
movq 0xd2aa(%rip), %rsi      # 0xffc0
callq 0x21b0
movq 0xd2ae(%rip), %rdi      # 0xffd0
leaq 0x8363(%rip), %rsi      # 0xb08c
callq 0x2180
movq %rax, %rdi
movq 0xd288(%rip), %rsi      # 0xffc0
callq 0x21b0
movq 0xd28c(%rip), %rdi      # 0xffd0
leaq 0x8334(%rip), %rsi      # 0xb07f
callq 0x2180
movq %rax, %rdi
movq 0xd266(%rip), %rsi      # 0xffc0
callq 0x21b0
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2d8b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x20c0
leaq -0x28(%rbp), %rdi
callq 0x20c0
movq -0x30(%rbp), %rdi
callq 0x22a0
nopl (%rax)
// File: 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
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x14(%rax)
movl $0x3e8, 0x10(%rax)      # imm = 0x3E8
movl $0x1, 0x18(%rax)
movl $0x0, 0x1c(%rax)
movb $0x1, 0x20(%rax)
movl $0x0, 0x24(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %dl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
andb $0x1, %al
movb %al, -0xd(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x14(%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0x10(%rax)
movl $0x1, 0x18(%rax)
movl $0x0, 0x1c(%rax)
movb -0xd(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x20(%rax)
movl $0x0, 0x24(%rax)
popq %rbp
retq
nop
// File: 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 %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movb 0x14(%rcx), %cl
andb $0x1, %cl
movb %cl, 0x14(%rax)
movq -0x10(%rbp), %rcx
movl 0x10(%rcx), %ecx
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movl 0x18(%rcx), %ecx
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rcx
movl 0x1c(%rcx), %ecx
movl %ecx, 0x1c(%rax)
movq -0x10(%rbp), %rcx
movb 0x20(%rcx), %cl
andb $0x1, %cl
movb %cl, 0x20(%rax)
movq -0x10(%rbp), %rcx
movl 0x24(%rcx), %ecx
movl %ecx, 0x24(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, (%rax)
je 0x3365
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x3389
movq 0xcc64(%rip), %rdi      # 0xffd0
leaq 0x7d55(%rip), %rsi      # 0xb0c8
callq 0x2180
movq %rax, %rdi
movq 0xcc3e(%rip), %rsi      # 0xffc0
callq 0x21b0
jmp 0x33c8
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x33d0
movq 0xcc32(%rip), %rdi      # 0xffd0
leaq 0x7d35(%rip), %rsi      # 0xb0da
callq 0x2180
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x10(%rax), %esi
callq 0x2290
movq %rax, %rdi
movq 0xcbfd(%rip), %rsi      # 0xffc0
callq 0x21b0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movb $0x0, -0xd(%rbp)
movl 0x10(%rax), %eax
subl -0xc(%rbp), %eax
cmpl $0x0, %eax
jg 0x3717
movq -0x18(%rbp), %rdi
movb $0x1, -0xd(%rbp)
movl $0x0, 0x10(%rdi)
movl 0x1c(%rdi), %edx
addl 0x10(%rdi), %edx
movl $0x2, %esi
callq 0x36b0
jmp 0x3736
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %ecx
movl 0x10(%rdi), %eax
subl %ecx, %eax
movl %eax, 0x10(%rdi)
movl 0x1c(%rdi), %edx
addl -0xc(%rbp), %edx
movl $0x2, %esi
callq 0x36b0
movb -0xd(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: fredericmarchand[P]TexasHoldem/Player.cpp
// Function: checkHand(Card**, Card**, hands*)
void checkHand(Card **combo, Card **retCombo, Hand *maxValue)
{
    sortCardArray(combo, 0, 4);
    Hand value = NOTHING;
    value = evaluateHand(combo);
    if (value > *maxValue) 
    {
        *maxValue = value;
        for (int i = 0; i < 5; ++i)
        {
            retCombo[i] = combo[i];
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0x3ae0
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3c30
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jle 0x3acd
movl -0x1c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x20(%rbp)
cmpl $0x5, -0x20(%rbp)
jge 0x3acb
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x10(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x3aa2
jmp 0x3acd
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0xc(%rbp), %eax
addl -0x10(%rbp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x30(%rbp), %rax
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jg 0x3bee
jmp 0x3b33
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x25e0
movl %eax, -0x34(%rbp)
movq -0x28(%rbp), %rdi
callq 0x25e0
movl %eax, %ecx
movl -0x34(%rbp), %eax
cmpl %ecx, %eax
jge 0x3b64
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x3b33
jmp 0x3b66
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x25e0
movl %eax, -0x38(%rbp)
movq -0x28(%rbp), %rdi
callq 0x25e0
movl %eax, %ecx
movl -0x38(%rbp), %eax
cmpl %ecx, %eax
jle 0x3b97
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x3b66
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jg 0x3be9
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rbp), %rdx
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x3b25
movl -0xc(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x3c05
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x3ae0
movl -0x14(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x3c1c
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x3ae0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, 0x8(%rax)
movslq -0xc(%rbp), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x46fd
movl $0x28, %edi
callq 0x2190
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movl $0x186a0, %esi          # imm = 0x186A0
movl $0x1, %edx
callq 0x3140
jmp 0x46c0
movq -0x38(%rbp), %rdx
movq -0x30(%rbp), %rax
movq (%rax), %rax
movslq -0x10(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x4693
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x28, %esi
callq 0x21a0
jmp 0x47af
movq -0x30(%rbp), %rax
movl $0x0, 0x38(%rax)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x3, -0x24(%rbp)
jg 0x47a0
movl $0x2, -0x28(%rbp)
cmpl $0xe, -0x28(%rbp)
jg 0x4790
movl $0x8, %edi
callq 0x2190
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movl -0x24(%rbp), %esi
movl -0x28(%rbp), %edx
callq 0x2570
jmp 0x474e
movq -0x30(%rbp), %rax
movq -0x40(%rbp), %rdx
movl -0x20(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x20(%rbp)
movslq %ecx, %rcx
movq %rdx, 0x40(%rax,%rcx,8)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x4727
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x8, %esi
callq 0x21a0
jmp 0x47af
jmp 0x4792
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x4716
movq -0x30(%rbp), %rdi
callq 0x47c0
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x22a0
nopl (%rax,%rax)
// File: fredericmarchand[P]TexasHoldem/Game.cpp
// Function: Game::resetDeck()
void Game::resetDeck()
{
    deckPointer = 0;
    flop[0] = NULL;
    flop[1] = NULL;
    flop[2] = NULL;
    turn = NULL;
    river = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x38(%rax)
movq $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
movq $0x0, 0x20(%rax)
movq $0x0, 0x28(%rax)
movq $0x0, 0x30(%rax)
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x49e0
movl %eax, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x8(%rax)
movslq 0x8(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x14(%rbp)
movq -0x30(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x48dd
movl $0x28, %edi
callq 0x2190
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4a00
movq %rax, -0x38(%rbp)
jmp 0x4889
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x3190
jmp 0x48a0
movq -0x40(%rbp), %rdx
movq -0x30(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4860
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x28, %esi
callq 0x21a0
jmp 0x49cb
movq -0x30(%rbp), %rax
movl $0x0, 0x38(%rax)
movl $0x0, -0x28(%rbp)
cmpl $0x34, -0x28(%rbp)
jge 0x4955
movl $0x8, %edi
callq 0x2190
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq 0x40(%rax,%rcx,8), %rsi
callq 0x2590
jmp 0x491d
movq -0x30(%rbp), %rax
movq -0x48(%rbp), %rdx
movslq -0x28(%rbp), %rcx
movq %rdx, 0x40(%rax,%rcx,8)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x48ef
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x8, %esi
callq 0x21a0
jmp 0x49cb
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x4a20
movq -0x30(%rbp), %rdi
movq %rax, 0x10(%rdi)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x4a20
movq -0x30(%rbp), %rdi
movq %rax, 0x18(%rdi)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x4a20
movq -0x30(%rbp), %rdi
movq %rax, 0x20(%rdi)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x4a20
movq -0x30(%rbp), %rdi
movq %rax, 0x28(%rdi)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rsi
callq 0x4a20
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x30(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x22a0
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x4a4c
movq $0x0, -0x8(%rbp)
jmp 0x4b0c
movl $0x0, -0x1c(%rbp)
cmpl $0x34, -0x1c(%rbp)
jge 0x4b04
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
cmpq $0x0, 0x40(%rax,%rcx,8)
jne 0x4a8f
movq 0xb55c(%rip), %rdi      # 0xffd0
leaq 0x66d7(%rip), %rsi      # 0xb152
callq 0x2180
movq %rax, %rdi
movq 0xb536(%rip), %rsi      # 0xffc0
callq 0x21b0
movq -0x18(%rbp), %rdi
callq 0x25d0
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, -0x2c(%rbp)
movslq -0x1c(%rbp), %rcx
movq 0x40(%rax,%rcx,8), %rdi
callq 0x25d0
movl %eax, %ecx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
jne 0x4af4
movq -0x18(%rbp), %rdi
callq 0x25e0
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, -0x30(%rbp)
movslq -0x1c(%rbp), %rcx
movq 0x40(%rax,%rcx,8), %rdi
callq 0x25e0
movl %eax, %ecx
movl -0x30(%rbp), %eax
cmpl %ecx, %eax
jne 0x4af4
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq 0x40(%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x4b0c
jmp 0x4af6
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x4a53
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x4b84
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x4b77
movq -0x20(%rbp), %rdi
callq 0x3200
movq -0x20(%rbp), %rdi
movl $0x28, %esi
callq 0x21a0
jmp 0x4b79
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4b3b
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x4b9e
movq -0x28(%rbp), %rdi
callq 0x2220
movl $0x0, -0x10(%rbp)
cmpl $0x34, -0x10(%rbp)
jge 0x4be6
movq -0x18(%rbp), %rax
movslq -0x10(%rbp), %rcx
movq 0x40(%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x4bd9
movq -0x30(%rbp), %rdi
callq 0x25c0
movq -0x30(%rbp), %rdi
movl $0x8, %esi
callq 0x21a0
jmp 0x4bdb
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x4ba5
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x4c66
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x32c0
testb $0x1, %al
jne 0x4c51
jmp 0x4c59
movl -0x10(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x4c66
jmp 0x4c5b
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x4c2b
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
xorl %esi, %esi
callq 0x3320
cmpl $0x0, -0xc(%rbp)
jne 0x4ca2
movq -0x18(%rbp), %rcx
movq (%rcx), %rax
movl 0x8(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
movl $0x1, %esi
callq 0x3320
jmp 0x4cc0
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
movl $0x1, %esi
callq 0x3320
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x4d33
movq -0x20(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x32c0
testb $0x1, %al
jne 0x4d11
jmp 0x4d26
movq -0x20(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x4d3b
jmp 0x4d28
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4ceb
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x4da6
movq -0x20(%rbp), %rax
movq (%rax), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x32c0
testb $0x1, %al
jne 0x4d91
jmp 0x4d99
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x4da6
jmp 0x4d9b
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4d6b
cmpl $0x0, -0x14(%rbp)
jne 0x4dc6
movq -0x20(%rbp), %rcx
movq (%rcx), %rax
movl 0x8(%rcx), %ecx
subl $0x2, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x4dfd
movq -0x20(%rbp), %rax
cmpl $0x2, 0x8(%rax)
jne 0x4de5
movq -0x20(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x4dfd
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl -0x14(%rbp), %ecx
subl $0x2, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x4e66
movq -0x20(%rbp), %rax
movq (%rax), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x32c0
testb $0x1, %al
jne 0x4e51
jmp 0x4e59
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x4e66
jmp 0x4e5b
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4e2b
cmpl $0x0, -0x14(%rbp)
jne 0x4e86
movq -0x20(%rbp), %rcx
movq (%rcx), %rax
movl 0x8(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x4e9e
movq -0x20(%rbp), %rax
movq (%rax), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movl -0x20(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x4f08
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq (%rcx), %rcx
movslq -0x20(%rbp), %rdx
cmpq (%rcx,%rdx,8), %rax
jne 0x4efb
movl -0x20(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x4f08
jmp 0x4efd
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x4ed2
cmpl $0x0, -0x1c(%rbp)
jne 0x4f28
movq -0x28(%rbp), %rcx
movq (%rcx), %rax
movl 0x8(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
jmp 0x4f40
movq -0x28(%rbp), %rax
movq (%rax), %rax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x28(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x4fac
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq (%rcx), %rcx
movslq -0x18(%rbp), %rdx
cmpq (%rcx,%rdx,8), %rax
jne 0x4f9f
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x4fac
jmp 0x4fa1
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4f76
jmp 0x4fae
movq -0x28(%rbp), %rcx
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl 0x8(%rcx), %eax
jne 0x4fca
movl $0x0, -0x14(%rbp)
jmp 0x4fcc
movq -0x28(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x3690
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x20(%rbp)
je 0x4fae
movq -0x28(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: fredericmarchand[P]TexasHoldem/Game.cpp
// Function: Game::getPlayerIndex(Player*)
int Game::getPlayerIndex(Player *player)
{
    for (int i = 0; i < numPlayers; ++i)
    {
        if (player == players[i])
        {
            return i;
        }
    }
    //never happens
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x5051
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq (%rcx), %rcx
movslq -0x1c(%rbp), %rdx
cmpq (%rcx,%rdx,8), %rax
jne 0x5044
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x5058
jmp 0x5046
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x501b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x50d0
movq -0x18(%rbp), %rdi
callq 0x50f0
movq -0x18(%rbp), %rdi
movq %rax, 0x10(%rdi)
callq 0x50f0
movq -0x18(%rbp), %rdi
movq %rax, 0x18(%rdi)
callq 0x50f0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
testb $0x1, -0x9(%rbp)
je 0x50c7
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
movl $0x3, %esi
callq 0x5120
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x50d0
movq -0x18(%rbp), %rdi
callq 0x50f0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
testb $0x1, -0x9(%rbp)
je 0x5428
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x2bd0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x50d0
movq -0x18(%rbp), %rdi
callq 0x50f0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x30(%rax)
testb $0x1, -0x9(%rbp)
je 0x5478
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x2bd0
addq $0x20, %rsp
popq %rbp
retq
nop