LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: sangwoojun[P]rv32emulator/./linenoise.hpp
// Function: linenoise::getCursorPosition(int, int)
inline int getCursorPosition(int ifd, int ofd) {
    char buf[32];
    int cols, rows;
    unsigned int i = 0;

    /* Report cursor location */
    if (write(ofd, "\x1b[6n", 4) != 4) return -1;

    /* Read the response: ESC [ rows ; cols R */
    while (i < sizeof(buf)-1) {
        if (read(ifd,buf+i,1) != 1) break;
        if (buf[i] == 'R') break;
        i++;
    }
    buf[i] = '\0';

    /* Parse it. */
    if (buf[0] != ESC || buf[1] != '[') return -1;
    if (sscanf(buf+2,"%d;%d",&rows,&cols) != 2) return -1;
    return cols;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x3c(%rbp)
movl -0xc(%rbp), %edi
leaq 0x315c(%rip), %rsi      # 0xb9ab
movl $0x4, %edx
callq 0x20a0
cmpq $0x4, %rax
je 0x886b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x8904
jmp 0x886d
movl -0x3c(%rbp), %eax
cmpq $0x1f, %rax
jae 0x88af
movl -0x8(%rbp), %edi
leaq -0x30(%rbp), %rsi
movl -0x3c(%rbp), %eax
addq %rax, %rsi
movl $0x1, %edx
callq 0x2330
cmpq $0x1, %rax
je 0x8895
jmp 0x88af
movl -0x3c(%rbp), %eax
movsbl -0x30(%rbp,%rax), %eax
cmpl $0x52, %eax
jne 0x88a4
jmp 0x88af
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x886d
movl -0x3c(%rbp), %eax
movb $0x0, -0x30(%rbp,%rax)
movsbl -0x30(%rbp), %eax
cmpl $0x1b, %eax
jne 0x88c9
movsbl -0x2f(%rbp), %eax
cmpl $0x5b, %eax
je 0x88d2
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x8904
leaq -0x30(%rbp), %rdi
addq $0x2, %rdi
leaq 0x30cf(%rip), %rsi      # 0xb9b0
leaq -0x38(%rbp), %rdx
leaq -0x34(%rbp), %rcx
movb $0x0, %al
callq 0x21e0
cmpl $0x2, %eax
je 0x88fe
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x8904
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: sangwoojun[P]rv32emulator/./linenoise.hpp
// Function: linenoise::unicodePrevGraphemeLen(char*, int)
inline int unicodePrevGraphemeLen(char* buf, int pos)
{
    if (pos == 0) {
        return 0;
    }
    int end = pos;
    while (pos > 0) {
        int len = unicodePrevUTF8CharLen(buf, pos);
        pos -= len;
        int cp = 0;
        unicodeUTF8CharToCodePoint(buf + pos, len, &cp);
        if (!unicodeIsCombiningChar(cp)) {
            return end - pos;
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x8d4e
movl $0x0, -0x4(%rbp)
jmp 0x8db4
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x14(%rbp)
jle 0x8dad
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x8dc0
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %ecx
movl -0x14(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x14(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rax
addq %rax, %rdi
movl -0x1c(%rbp), %esi
leaq -0x20(%rbp), %rdx
callq 0x8910
movslq -0x20(%rbp), %rdi
callq 0x8e20
cmpl $0x0, %eax
jne 0x8dab
movl -0x18(%rbp), %eax
subl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x8db4
jmp 0x8d54
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: sangwoojun[P]rv32emulator/./linenoise.hpp
// Function: linenoise::unicodePrevUTF8CharLen(char*, int)
inline int unicodePrevUTF8CharLen(char* buf, int pos)
{
    int end = pos--;
    while (pos >= 0 && ((unsigned char)buf[pos] & 0xC0) == 0x80) {
        pos--;
    }
    return end - pos;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0xc(%rbp)
movl %eax, -0x10(%rbp)
xorl %eax, %eax
cmpl $0x0, -0xc(%rbp)
movb %al, -0x11(%rbp)
jl 0x8e00
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movzbl (%rax,%rcx), %eax
andl $0xc0, %eax
cmpl $0x80, %eax
sete %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x8e09
jmp 0x8e14
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x8dd9
movl -0x10(%rbp), %eax
subl -0xc(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: sangwoojun[P]rv32emulator/./linenoise.hpp
// Function: linenoise::unicodeIsCombiningChar(unsigned long)
inline int unicodeIsCombiningChar(unsigned long cp)
{
    int i;
    for (i = 0; i < unicodeCombiningCharTableSize; i++) {
        if (unicodeCombiningCharTable[i] == cp) {
            return 1;
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl 0x6408(%rip), %eax      # 0xf240
jge 0x8e65
movslq -0x14(%rbp), %rcx
leaq 0x640b(%rip), %rax      # 0xf250
movq (%rax,%rcx,8), %rax
cmpq -0x10(%rbp), %rax
jne 0x8e58
movl $0x1, -0x4(%rbp)
jmp 0x8e6c
jmp 0x8e5a
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x8e2f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: sangwoojun[P]rv32emulator/./linenoise.hpp
// Function: linenoise::unicodeGraphemeLen(char*, int, int)
inline int unicodeGraphemeLen(char* buf, int buf_len, int pos)
{
    if (pos == buf_len) {
        return 0;
    }
    int beg = pos;
    pos += unicodeUTF8CharLen(buf, buf_len, pos);
    while (pos < buf_len) {
        int len = unicodeUTF8CharLen(buf, buf_len, pos);
        int cp = 0;
        unicodeUTF8CharToCodePoint(buf + pos, len, &cp);
        if (!unicodeIsCombiningChar(cp)) {
            return pos - beg;
        }
        pos += len;
    }
    return pos - beg;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jne 0x8ea6
movl $0x0, -0x4(%rbp)
jmp 0x8f26
movl -0x18(%rbp), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x8f30
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x8f1d
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x8f30
movl %eax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x18(%rbp), %rax
addq %rax, %rdi
movl -0x20(%rbp), %esi
leaq -0x24(%rbp), %rdx
callq 0x8910
movslq -0x24(%rbp), %rdi
callq 0x8e20
cmpl $0x0, %eax
jne 0x8f12
movl -0x18(%rbp), %eax
subl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x8f26
movl -0x20(%rbp), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x8ec1
movl -0x18(%rbp), %eax
subl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: sangwoojun[P]rv32emulator/./linenoise.hpp
// Function: linenoise::unicodeUTF8CharLen(char*, int, int)
inline int unicodeUTF8CharLen(char* buf, int buf_len, int pos)
{
    if (pos == buf_len) { return 0; }
    unsigned char ch = buf[pos];
    if (ch < 0x80) { return 1; }
    else if (ch < 0xE0) { return 2; }
    else if (ch < 0xF0) { return 3; }
    else { return 4; }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jne 0x8f4f
movl $0x0, -0x4(%rbp)
jmp 0x8fa0
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x19(%rbp)
movzbl -0x19(%rbp), %eax
cmpl $0x80, %eax
jge 0x8f71
movl $0x1, -0x4(%rbp)
jmp 0x8fa0
movzbl -0x19(%rbp), %eax
cmpl $0xe0, %eax
jge 0x8f85
movl $0x2, -0x4(%rbp)
jmp 0x8fa0
movzbl -0x19(%rbp), %eax
cmpl $0xf0, %eax
jge 0x8f99
movl $0x3, -0x4(%rbp)
jmp 0x8fa0
movl $0x4, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: sangwoojun[P]rv32emulator/./linenoise.hpp
// Function: linenoise::unicodeColumnPos(char const*, int)
inline int unicodeColumnPos(const char* buf, int buf_len)
{
    int ret = 0;

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

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

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

        off += len;
    }

    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x9764
movq -0x8(%rbp), %rdi
movslq -0x14(%rbp), %rax
addq %rax, %rdi
movl -0xc(%rbp), %esi
subl -0x14(%rbp), %esi
leaq -0x18(%rbp), %rdx
callq 0x9870
cmpl $0x0, %eax
je 0x9703
movl -0x18(%rbp), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x96cd
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x14(%rbp), %rax
addq %rax, %rdi
movl -0xc(%rbp), %esi
subl -0x14(%rbp), %esi
leaq -0x1c(%rbp), %rdx
callq 0x8910
movl %eax, -0x18(%rbp)
movslq -0x1c(%rbp), %rdi
callq 0x8e20
cmpl $0x0, %eax
jne 0x9756
movslq -0x1c(%rbp), %rdi
callq 0x6d90
movl %eax, %edx
movl $0x1, %eax
movl $0x2, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x18(%rbp), %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x96cd
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: sangwoojun[P]rv32emulator/./linenoise.hpp
// Function: linenoise::unicodeColumnPosForMultiLine(char*, int, int, int, int)
inline int unicodeColumnPosForMultiLine(char* buf, int buf_len, int pos, int cols, int ini_pos)
{
    int ret = 0;
    int colwid = ini_pos;

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

        int wid = 0;
        if (!unicodeIsCombiningChar(cp)) {
            wid = unicodeIsWideChar(cp) ? 2 : 1;
        }

        int dif = (int)(colwid + wid) - (int)cols;
        if (dif > 0) {
            ret += dif;
            colwid = wid;
        } else if (dif == 0) {
            colwid = 0;
        } else {
            colwid += wid;
        }

        if (off >= pos) {
            break;
        }

        off += len;
        ret += wid;
    }

    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x985e
movl $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movslq -0x24(%rbp), %rax
addq %rax, %rdi
movl -0xc(%rbp), %esi
subl -0x24(%rbp), %esi
leaq -0x28(%rbp), %rdx
callq 0x8910
movl %eax, -0x2c(%rbp)
movl $0x0, -0x30(%rbp)
movslq -0x28(%rbp), %rdi
callq 0x8e20
cmpl $0x0, %eax
jne 0x9800
movslq -0x28(%rbp), %rdi
callq 0x6d90
movl %eax, %edx
movl $0x1, %eax
movl $0x2, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x30(%rbp)
movl -0x20(%rbp), %eax
addl -0x30(%rbp), %eax
subl -0x14(%rbp), %eax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jle 0x9823
movl -0x34(%rbp), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x983d
cmpl $0x0, -0x34(%rbp)
jne 0x9832
movl $0x0, -0x20(%rbp)
jmp 0x983b
movl -0x30(%rbp), %eax
addl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x983d
movl -0x24(%rbp), %eax
cmpl -0x10(%rbp), %eax
jl 0x9847
jmp 0x985e
movl -0x2c(%rbp), %eax
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x30(%rbp), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x979d
movl -0x1c(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: sangwoojun[P]rv32emulator/./linenoise.hpp
// Function: linenoise::isAnsiEscape(char const*, int, int*)
inline int isAnsiEscape(const char* buf, int buf_len, int* len)
{
    if (buf_len > 2 && !memcmp("\033[", buf, 2)) {
        int off = 2;
        while (off < buf_len) {
            switch (buf[off++]) {
            case 'A': case 'B': case 'C': case 'D':
            case 'E': case 'F': case 'G': case 'H':
            case 'J': case 'K': case 'S': case 'T':
            case 'f': case 'm':
                *len = off;
                return 1;
            }
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
cmpl $0x2, -0x14(%rbp)
jle 0x9912
movq -0x10(%rbp), %rax
movw (%rax), %ax
subw $0x5b1b, %ax            # imm = 0x5B1B
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x9912
movl $0x2, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x9910
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl %ecx, %edx
incl %edx
movl %edx, -0x24(%rbp)
movsbl (%rax,%rcx), %eax
movl %eax, -0x28(%rbp)
addl $-0x41, %eax
subl $0x8, %eax
jb 0x98fc
jmp 0x98ce
movl -0x28(%rbp), %eax
addl $-0x4a, %eax
subl $0x2, %eax
jb 0x98fc
jmp 0x98db
movl -0x28(%rbp), %eax
addl $-0x53, %eax
subl $0x2, %eax
jb 0x98fc
jmp 0x98e8
movl -0x28(%rbp), %eax
subl $0x66, %eax
je 0x98fc
jmp 0x98f2
movl -0x28(%rbp), %eax
subl $0x6d, %eax
jne 0x990e
jmp 0x98fc
movl -0x24(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, -0x4(%rbp)
jmp 0x9919
jmp 0x98a6
jmp 0x9912
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: smuething[P]dune-cxx11/26-unordered_map.cc
// Function: main
int main()
{
  std::unordered_map<double,int> m;
  m[3.7] = 4;
  assert(m[3.7] == 4);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x12e0
movq -0x70(%rbp), %rdi
movabsq $0x400d99999999999a, %rax # imm = 0x400D99999999999A
movq %rax, -0x48(%rbp)
leaq -0x48(%rbp), %rsi
callq 0x1300
movq %rax, -0x68(%rbp)
jmp 0x1240
movq -0x68(%rbp), %rax
movl $0x4, (%rax)
movabsq $0x400d99999999999a, %rax # imm = 0x400D99999999999A
movq %rax, -0x60(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x1300
movq %rax, -0x78(%rbp)
jmp 0x126b
movq -0x78(%rbp), %rax
cmpl $0x4, (%rax)
jne 0x1276
jmp 0x12ac
leaq 0x1d8b(%rip), %rdi      # 0x3008
leaq 0x1d90(%rip), %rsi      # 0x3014
movl $0x8, %edx
leaq 0x1d98(%rip), %rcx      # 0x3028
callq 0x1080
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1330
jmp 0x12c8
movl $0x0, -0x4(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1330
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x10f0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/exercises/ex16_51_52.cc
// Function: main
int main(int argc, char const *argv[])
{
	int i = 0;
	double d = 3.14;
	std::string s = "how now brown cow?";
	foo(i, s, 42, d);
	foo(s, 42, "hi");
	foo(d, s);
	foo("hi");

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movabsq $0x40091eb851eb851f, %rax # imm = 0x40091EB851EB851F
movq %rax, -0x20(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x10b0
movq -0x68(%rbp), %rdx
leaq 0xdc1(%rip), %rsi       # 0x2004
leaq -0x40(%rbp), %rdi
callq 0x1080
jmp 0x124e
leaq -0x41(%rbp), %rdi
callq 0x1070
movl $0x2a, -0x58(%rbp)
leaq -0x14(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x58(%rbp), %rdx
leaq -0x20(%rbp), %rcx
callq 0x1300
jmp 0x1275
movl $0x2a, -0x5c(%rbp)
leaq 0xd94(%rip), %rdx       # 0x2017
leaq -0x40(%rbp), %rdi
leaq -0x5c(%rbp), %rsi
callq 0x1360
jmp 0x1292
leaq -0x20(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x13c0
jmp 0x12a1
leaq 0xd6f(%rip), %rdi       # 0x2017
callq 0x1420
jmp 0x12af
movl $0x0, -0x4(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1040
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x41(%rbp), %rdi
callq 0x1070
jmp 0x12f4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x1040
movq -0x50(%rbp), %rdi
callq 0x10a0
nopl (%rax)
// File: moloch--[P]cli-Blackjack/./Blackjack/AsciiArt.cpp
// Function: AsciiArt::getTopRank(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string AsciiArt::getTopRank(string rank)
{
	ostringstream result; // Create string stream
	result << "|" << rank;
	while (result.str().length() < 10) // Length of rank is not fixed
	{
		result << " ";
	}
	result << "|";
	return result.str();
}

// Assembly:
subq $0x1f8, %rsp            # imm = 0x1F8
movq %rdx, 0x10(%rsp)
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x1f0(%rsp)
movq %rsi, 0x1e8(%rsp)
movq %rdx, 0x1e0(%rsp)
leaq 0x68(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x2270
movq 0x28(%rsp), %rdi
leaq 0x62a6(%rip), %rsi      # 0xa062
callq 0x21b0
movq %rax, 0x30(%rsp)
jmp 0x3dc8
movq 0x10(%rsp), %rsi
movq 0x30(%rsp), %rdi
callq 0x2180
jmp 0x3dd9
jmp 0x3ddb
leaq 0x38(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x21e0
jmp 0x3dec
leaq 0x38(%rsp), %rdi
callq 0x22a0
movq %rax, 0x8(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x2110
movq 0x8(%rsp), %rax
cmpq $0xa, %rax
jae 0x3e3f
leaq 0x6585(%rip), %rsi      # 0xa39c
leaq 0x68(%rsp), %rdi
callq 0x21b0
jmp 0x3e23
jmp 0x3ddb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x2060
jmp 0x3e7a
leaq 0x621c(%rip), %rsi      # 0xa062
leaq 0x68(%rsp), %rdi
callq 0x21b0
jmp 0x3e52
movq 0x18(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x21e0
jmp 0x3e63
leaq 0x68(%rsp), %rdi
callq 0x2060
movq 0x20(%rsp), %rax
addq $0x1f8, %rsp            # imm = 0x1F8
retq
movq 0x60(%rsp), %rdi
callq 0x22f0
nopw %cs:(%rax,%rax)
// File: moloch--[P]cli-Blackjack/./Blackjack/AsciiArt.cpp
// Function: AsciiArt::getBottomRank(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string AsciiArt::getBottomRank(string rank)
{
	ostringstream result; // Create string stream
	result << "|";
	while (result.str().length() + rank.length() < 10) // Length of rank is not fixed
	{
		result << " ";
	}
	result << rank << "|";
	return result.str();
}

// Assembly:
subq $0x1f8, %rsp            # imm = 0x1F8
movq %rdx, 0x18(%rsp)
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0x1f0(%rsp)
movq %rsi, 0x1e8(%rsp)
movq %rdx, 0x1e0(%rsp)
leaq 0x68(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x2270
movq 0x30(%rsp), %rdi
leaq 0x6186(%rip), %rsi      # 0xa062
callq 0x21b0
jmp 0x3ee3
jmp 0x3ee5
leaq 0x38(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x21e0
jmp 0x3ef6
leaq 0x38(%rsp), %rdi
callq 0x22a0
movq 0x18(%rsp), %rdi
movq %rax, 0x8(%rsp)
callq 0x22a0
movq %rax, %rcx
movq 0x8(%rsp), %rax
addq %rcx, %rax
movq %rax, 0x10(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x2110
movq 0x10(%rsp), %rax
cmpq $0xa, %rax
jae 0x3f63
leaq 0x6461(%rip), %rsi      # 0xa39c
leaq 0x68(%rsp), %rdi
callq 0x21b0
jmp 0x3f47
jmp 0x3ee5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x2060
jmp 0x3fb2
movq 0x18(%rsp), %rsi
leaq 0x68(%rsp), %rdi
callq 0x2180
movq %rax, (%rsp)
jmp 0x3f78
movq (%rsp), %rdi
leaq 0x60df(%rip), %rsi      # 0xa062
callq 0x21b0
jmp 0x3f8a
movq 0x20(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x21e0
jmp 0x3f9b
leaq 0x68(%rsp), %rdi
callq 0x2060
movq 0x28(%rsp), %rax
addq $0x1f8, %rsp            # imm = 0x1F8
retq
movq 0x60(%rsp), %rdi
callq 0x22f0
nopl (%rax)
// File: moloch--[P]cli-Blackjack/./Blackjack/AsciiArt.cpp
// Function: AsciiArt::printSymbol(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
string AsciiArt::printSymbol(string suit, int segment)
{
	/* Switch statements are evil */
	if (suit == "clubs")
	{
		return getClubsSymbol(segment);
	}
	else if (suit == "hearts")
	{
		return getHeartsSymbol(segment);
	}
	else if (suit == "diamonds")
	{
		return getDiamondsSymbol(segment);
	}
	else if (suit == "spades")
	{
		return getSpadesSymbol(segment);
	}
	else if (suit == "hidden")
	{
		return getHiddenSymbol(segment);
	}
	else
	{
		/* Just return something */
		return "Error: Not a valid suit";
	}
}

// Assembly:
subq $0x58, %rsp
movq %rdx, 0x8(%rsp)
movq %rdi, %rax
movq 0x8(%rsp), %rdi
movq %rax, 0x10(%rsp)
movq %rax, %rdx
movq %rdx, 0x18(%rsp)
movq %rax, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdi, 0x40(%rsp)
movl %ecx, 0x3c(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x5f02(%rip), %rsi      # 0xa0f4
callq 0x44f0
testb $0x1, %al
jne 0x41fd
jmp 0x4215
movq 0x20(%rsp), %rsi
movq 0x10(%rsp), %rdi
movl 0x3c(%rsp), %edx
callq 0x3fc0
jmp 0x4316
movq 0x8(%rsp), %rdi
leaq 0x5ed9(%rip), %rsi      # 0xa0fa
callq 0x44f0
testb $0x1, %al
jne 0x422c
jmp 0x4244
movq 0x20(%rsp), %rsi
movq 0x10(%rsp), %rdi
movl 0x3c(%rsp), %edx
callq 0x4010
jmp 0x4316
movq 0x8(%rsp), %rdi
leaq 0x5eb1(%rip), %rsi      # 0xa101
callq 0x44f0
testb $0x1, %al
jne 0x425b
jmp 0x4273
movq 0x20(%rsp), %rsi
movq 0x10(%rsp), %rdi
movl 0x3c(%rsp), %edx
callq 0x4060
jmp 0x4316
movq 0x8(%rsp), %rdi
leaq 0x5e8b(%rip), %rsi      # 0xa10a
callq 0x44f0
testb $0x1, %al
jne 0x428a
jmp 0x429f
movq 0x20(%rsp), %rsi
movq 0x10(%rsp), %rdi
movl 0x3c(%rsp), %edx
callq 0x40b0
jmp 0x4316
movq 0x8(%rsp), %rdi
leaq 0x5e66(%rip), %rsi      # 0xa111
callq 0x44f0
testb $0x1, %al
jne 0x42b6
jmp 0x42cb
movq 0x20(%rsp), %rsi
movq 0x10(%rsp), %rdi
movl 0x3c(%rsp), %edx
callq 0x4100
jmp 0x4316
leaq 0x3b(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x2300
movq 0x10(%rsp), %rdi
movq (%rsp), %rdx
leaq 0x5e2f(%rip), %rsi      # 0xa118
callq 0x4370
jmp 0x42f0
leaq 0x3b(%rsp), %rdi
callq 0x2210
jmp 0x4316
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x3b(%rsp), %rdi
callq 0x2210
jmp 0x4320
movq 0x18(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x22f0
nopw (%rax,%rax)
// File: moloch--[P]cli-Blackjack/./Blackjack/Blackjack.cpp
// Function: Blackjack::initialDeal(Player&, Dealer&)
void Blackjack::initialDeal(Player & player, Dealer & dealer)
{
    player.hit(deck.deal()); // Deal two cards to the player(s)
    player.hit(deck.deal());
    dealer.hit(deck.deal()); // Deal two cards to the dealer
    dealer.hit(deck.deal());
    dealer.hideCard();       // Hide dealer's card
}

// Assembly:
subq $0x1b8, %rsp            # imm = 0x1B8
movq %rdi, 0x1b0(%rsp)
movq %rsi, 0x1a8(%rsp)
movq %rdx, 0x1a0(%rsp)
movq 0x1b0(%rsp), %rsi
movq %rsi, 0x38(%rsp)
movq 0x1a8(%rsp), %rax
movq %rax, 0x40(%rsp)
addq $0x18, %rsi
leaq 0x150(%rsp), %rdi
movq %rdi, 0x48(%rsp)
callq 0x9740
movq 0x40(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x8760
jmp 0x5580
leaq 0x150(%rsp), %rdi
callq 0x64c0
movq 0x38(%rsp), %rsi
movq 0x1a8(%rsp), %rax
movq %rax, 0x28(%rsp)
addq $0x18, %rsi
leaq 0xf0(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x9740
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x8760
jmp 0x55c6
leaq 0xf0(%rsp), %rdi
callq 0x64c0
movq 0x38(%rsp), %rsi
movq 0x1a0(%rsp), %rax
movq %rax, 0x18(%rsp)
addq $0x18, %rsi
leaq 0xa0(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x9740
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x8760
jmp 0x560c
leaq 0xa0(%rsp), %rdi
callq 0x64c0
movq 0x38(%rsp), %rsi
movq 0x1a0(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x18, %rsi
leaq 0x50(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x9740
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x8760
jmp 0x564f
leaq 0x50(%rsp), %rdi
callq 0x64c0
movq 0x1a0(%rsp), %rdi
callq 0x86e0
addq $0x1b8, %rsp            # imm = 0x1B8
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x148(%rsp)
movl %eax, 0x144(%rsp)
leaq 0x150(%rsp), %rdi
callq 0x64c0
jmp 0x56f5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x148(%rsp)
movl %eax, 0x144(%rsp)
leaq 0xf0(%rsp), %rdi
callq 0x64c0
jmp 0x56f5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x148(%rsp)
movl %eax, 0x144(%rsp)
leaq 0xa0(%rsp), %rdi
callq 0x64c0
jmp 0x56f5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x148(%rsp)
movl %eax, 0x144(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x64c0
movq 0x148(%rsp), %rdi
callq 0x22f0
nopw %cs:(%rax,%rax)
// File: moloch--[P]cli-Blackjack/./Blackjack/Blackjack.cpp
// Function: Blackjack::playGame()
void Blackjack::playGame()
{
	Dealer dealer("HAL 9000"); // Create the dealer
	Player player1("Weak Human"); // Create the player(s)
	player1.setMoney(1000);
	while (player1.getMoney() > 0)
	{
		startTurn(player1, dealer);
	}
	cout << "\n [!] You have lost all your money!" << endl;
}

// Assembly:
subq $0x1b8, %rsp            # imm = 0x1B8
movq %rdi, 0x1b0(%rsp)
movq 0x1b0(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0xff(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x2300
movq 0x28(%rsp), %rdx
leaq 0x4368(%rip), %rsi      # 0xa282
leaq 0x100(%rsp), %rdi
callq 0x4370
jmp 0x5f29
leaq 0x120(%rsp), %rdi
leaq 0x100(%rsp), %rsi
callq 0x6670
jmp 0x5f40
leaq 0x100(%rsp), %rdi
callq 0x2110
leaq 0xff(%rsp), %rdi
callq 0x2210
leaq 0x37(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x2300
movq 0x18(%rsp), %rdx
leaq 0x4316(%rip), %rsi      # 0xa28b
leaq 0x38(%rsp), %rdi
callq 0x4370
jmp 0x5f81
leaq 0x58(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x83a0
jmp 0x5f92
leaq 0x38(%rsp), %rdi
callq 0x2110
leaq 0x37(%rsp), %rdi
callq 0x2210
leaq 0x58(%rsp), %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x8d00
jmp 0x5fb7
jmp 0x5fb9
leaq 0x58(%rsp), %rdi
callq 0x8cf0
movl %eax, 0x14(%rsp)
jmp 0x5fc9
movl 0x14(%rsp), %eax
cmpl $0x0, %eax
jle 0x609a
movq 0x20(%rsp), %rdi
leaq 0x58(%rsp), %rsi
leaq 0x120(%rsp), %rdx
callq 0x5ad0
jmp 0x5fef
jmp 0x5fb9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xf0(%rsp)
movl %eax, 0xec(%rsp)
jmp 0x6028
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xf0(%rsp)
movl %eax, 0xec(%rsp)
leaq 0x100(%rsp), %rdi
callq 0x2110
leaq 0xff(%rsp), %rdi
callq 0x2210
jmp 0x60f3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xf0(%rsp)
movl %eax, 0xec(%rsp)
jmp 0x606e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xf0(%rsp)
movl %eax, 0xec(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x2110
leaq 0x37(%rsp), %rdi
callq 0x2210
jmp 0x60e6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xf0(%rsp)
movl %eax, 0xec(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x85d0
jmp 0x60e6
movq 0x7f2f(%rip), %rdi      # 0xdfd0
leaq 0x41ee(%rip), %rsi      # 0xa296
callq 0x21b0
movq %rax, 0x8(%rsp)
jmp 0x60b4
movq 0x8(%rsp), %rdi
movq 0x7f00(%rip), %rsi      # 0xdfc0
callq 0x21f0
jmp 0x60c7
leaq 0x58(%rsp), %rdi
callq 0x85d0
leaq 0x120(%rsp), %rdi
callq 0x6710
addq $0x1b8, %rsp            # imm = 0x1B8
retq
leaq 0x120(%rsp), %rdi
callq 0x6710
movq 0xf0(%rsp), %rdi
callq 0x22f0
// File: moloch--[P]cli-Blackjack/./Blackjack/Blackjack.cpp
// Function: Blackjack::getStringFromUser(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string Blackjack::getStringFromUser(string prompt)
{   /* Prompts the user with the provided string, and returns their input */
	cout << prompt;
	getline(cin, userInput);
	return userInput;
}

// Assembly:
subq $0x38, %rsp
movq %rdx, (%rsp)
movq %rsi, %rax
movq (%rsp), %rsi
movq %rdi, 0x10(%rsp)
movq %rdi, %rcx
movq %rcx, 0x18(%rsp)
movq %rdi, 0x30(%rsp)
movq %rax, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x7e94(%rip), %rdi      # 0xdfd0
callq 0x2180
movq 0x8(%rsp), %rsi
addq $0x70, %rsi
movq 0x7e8f(%rip), %rdi      # 0xdfe0
callq 0x2050
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdi
addq $0x70, %rsi
callq 0x20c0
movq 0x18(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: moloch--[P]cli-Blackjack/./Blackjack/Card.cpp
// Function: Card::Card(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Card::Card(string cardSuit, int cardValue, string cardRank)
{
	setValue(cardValue);
	setSuit(cardSuit);
	setRank(cardRank);
	hidden = false;
}

// Assembly:
subq $0x98, %rsp
movq %rsi, (%rsp)
movq %rcx, 0x8(%rsp)
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movl %edx, 0x84(%rsp)
movq %rcx, 0x78(%rsp)
movq 0x90(%rsp), %rdi
movq %rdi, 0x20(%rsp)
leaq 0x7ac0(%rip), %rax      # 0xdcc0
movq %rax, (%rdi)
addq $0x10, %rdi
movq %rdi, 0x10(%rsp)
callq 0x2280
movq 0x20(%rsp), %rdi
addq $0x30, %rdi
movq %rdi, 0x18(%rsp)
callq 0x2280
movq 0x20(%rsp), %rdi
movl 0x84(%rsp), %esi
callq 0x6300
jmp 0x6237
movq (%rsp), %rsi
leaq 0x48(%rsp), %rdi
callq 0x20c0
jmp 0x6247
movq 0x20(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x6320
jmp 0x6258
leaq 0x48(%rsp), %rdi
callq 0x2110
movq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0x20c0
jmp 0x6273
movq 0x20(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x6350
jmp 0x6284
leaq 0x28(%rsp), %rdi
callq 0x2110
movq 0x20(%rsp), %rax
movb $0x0, 0xc(%rax)
addq $0x98, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
jmp 0x62e1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x2110
jmp 0x62e1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x2110
movq 0x18(%rsp), %rdi
callq 0x2110
movq 0x10(%rsp), %rdi
callq 0x2110
movq 0x70(%rsp), %rdi
callq 0x22f0
nop
// File: moloch--[P]cli-Blackjack/./Blackjack/Card.cpp
// Function: Card::Card(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int)
Card::Card(string cardSuit, int cardValue, int cardRank)
{
	setValue(cardValue);
	setSuit(cardSuit);
	setRank(cardRank);
	hidden = false;
}

// Assembly:
subq $0x68, %rsp
movq %rsi, (%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movl %edx, 0x54(%rsp)
movl %ecx, 0x50(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x18(%rsp)
leaq 0x7915(%rip), %rax      # 0xdcc0
movq %rax, (%rdi)
addq $0x10, %rdi
movq %rdi, 0x8(%rsp)
callq 0x2280
movq 0x18(%rsp), %rdi
addq $0x30, %rdi
movq %rdi, 0x10(%rsp)
callq 0x2280
movq 0x18(%rsp), %rdi
movl 0x54(%rsp), %esi
callq 0x6300
jmp 0x63df
movq (%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0x20c0
jmp 0x63ef
movq 0x18(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x6320
jmp 0x6400
leaq 0x20(%rsp), %rdi
callq 0x2110
movq 0x18(%rsp), %rdi
movl 0x50(%rsp), %esi
callq 0x6470
jmp 0x641a
movq 0x18(%rsp), %rax
movb $0x0, 0xc(%rax)
addq $0x68, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0x6450
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x2110
movq 0x10(%rsp), %rdi
callq 0x2110
movq 0x8(%rsp), %rdi
callq 0x2110
movq 0x48(%rsp), %rdi
callq 0x22f0
nop
// File: moloch--[P]cli-Blackjack/./Blackjack/Hand.cpp
// Function: Hand::getScore()
int Hand::getScore()
{
	score = 0; // Re-calculate score
	for (unsigned int index = 0; index < hand.size(); ++index)
	{
		if (!hand[index].isHidden()) // Do not include hidden values
		{
			score += hand[index].getValue();
		}
	}
	return score;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x8(%rax)
movl $0x0, 0x1c(%rsp)
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %eax
movq %rax, 0x8(%rsp)
addq $0x18, %rdi
callq 0x76c0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x690e
movq 0x10(%rsp), %rdi
addq $0x18, %rdi
movl 0x1c(%rsp), %eax
movl %eax, %esi
callq 0x76e0
movq %rax, %rdi
callq 0x6640
testb $0x1, %al
jne 0x68ff
movq 0x10(%rsp), %rdi
addq $0x18, %rdi
movl 0x1c(%rsp), %eax
movl %eax, %esi
callq 0x76e0
movq %rax, %rdi
callq 0x6530
movl %eax, %ecx
movq 0x10(%rsp), %rax
addl 0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
jmp 0x6901
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x6892
movq 0x10(%rsp), %rax
movl 0x8(%rax), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: moloch--[P]cli-Blackjack/./Blackjack/Hand.cpp
// Function: Hand::printAsciiHand()
void Hand::printAsciiHand()
{
    AsciiArt ascii;
    printAsciiHeader(ascii); // An entire line must be printed before another can start
    printAsciiTopRank(ascii);
    printAsciiSymbol(ascii);
    printAsciiBottomRank(ascii);
    printAsciiFooter(ascii);
    cout << "Total value: " << getScore() << endl;
}

// Assembly:
subq $0x138, %rsp            # imm = 0x138
movq %rdi, 0x130(%rsp)
movq 0x130(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x40(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x2580
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x6bd0
jmp 0x6afc
movq 0x20(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x6cf0
jmp 0x6b0d
movq 0x20(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x6f90
jmp 0x6b1e
movq 0x20(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x7290
jmp 0x6b2f
movq 0x20(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x7530
jmp 0x6b40
movq 0x7489(%rip), %rdi      # 0xdfd0
leaq 0x3785(%rip), %rsi      # 0xa2d3
callq 0x21b0
movq %rax, 0x18(%rsp)
jmp 0x6b5a
movq 0x20(%rsp), %rdi
callq 0x6870
movl %eax, 0x14(%rsp)
jmp 0x6b6a
movl 0x14(%rsp), %esi
movq 0x18(%rsp), %rdi
callq 0x22e0
movq %rax, 0x8(%rsp)
jmp 0x6b7f
movq 0x8(%rsp), %rdi
movq 0x7435(%rip), %rsi      # 0xdfc0
callq 0x21f0
jmp 0x6b92
leaq 0x40(%rsp), %rdi
callq 0x3bf0
addq $0x138, %rsp            # imm = 0x138
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x3bf0
movq 0x38(%rsp), %rdi
callq 0x22f0
nopw %cs:(%rax,%rax)
// File: moloch--[P]cli-Blackjack/./Blackjack/Hand.cpp
// Function: Hand::printAsciiHeader(AsciiArt&)
void Hand::printAsciiHeader(AsciiArt & ascii)
{
    for (unsigned int index = 0;index < ascii.getHeaderSize();++index)
    {
        for (unsigned int cardIndex = 0;cardIndex < hand.size();++cardIndex)
        {
            cout << ascii.getCardHeader(index) << " ";
        }
        cout << endl; // End line
    }
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x28(%rsp)
movl $0x0, 0x64(%rsp)
movl 0x64(%rsp), %eax
movl %eax, 0x24(%rsp)
movq 0x68(%rsp), %rdi
callq 0x4150
movl %eax, %ecx
movl 0x24(%rsp), %eax
cmpl %ecx, %eax
jae 0x6cd3
movl $0x0, 0x60(%rsp)
movq 0x28(%rsp), %rdi
movl 0x60(%rsp), %eax
movq %rax, 0x18(%rsp)
addq $0x18, %rdi
callq 0x76c0
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x6cb0
movq 0x68(%rsp), %rsi
movl 0x64(%rsp), %edx
leaq 0x40(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x3cd0
movq 0x8(%rsp), %rsi
movq 0x7370(%rip), %rdi      # 0xdfd0
callq 0x2180
movq %rax, 0x10(%rsp)
jmp 0x6c6c
movq 0x10(%rsp), %rdi
leaq 0x3724(%rip), %rsi      # 0xa39c
callq 0x21b0
jmp 0x6c7f
leaq 0x40(%rsp), %rdi
callq 0x2110
movl 0x60(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x60(%rsp)
jmp 0x6c18
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x2110
jmp 0x6cd8
movq 0x7319(%rip), %rdi      # 0xdfd0
movq 0x7302(%rip), %rsi      # 0xdfc0
callq 0x21f0
movl 0x64(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x64(%rsp)
jmp 0x6bf0
addq $0x78, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x22f0
nopw %cs:(%rax,%rax)
// File: moloch--[P]cli-Blackjack/./Blackjack/Hand.cpp
// Function: Hand::printAsciiTopRank(AsciiArt&)
void Hand::printAsciiTopRank(AsciiArt & ascii)
{
    for (unsigned int cardIndex = 0;cardIndex < hand.size();++cardIndex)
    {
        if (hand[cardIndex].isHidden())
        {
            cout << ascii.getTopRank("?") << " ";
        }
        else
        {
            cout << ascii.getTopRank(getCardRank(cardIndex)) << " ";
        }
    }
    cout << endl; // End line
}

// Assembly:
subq $0xf8, %rsp
movq %rdi, 0xf0(%rsp)
movq %rsi, 0xe8(%rsp)
movq 0xf0(%rsp), %rax
movq %rax, 0x40(%rsp)
movl $0x0, 0xe4(%rsp)
movq 0x40(%rsp), %rdi
movl 0xe4(%rsp), %eax
movq %rax, 0x38(%rsp)
addq $0x18, %rdi
callq 0x76c0
movq %rax, %rcx
movq 0x38(%rsp), %rax
cmpq %rcx, %rax
jae 0x6f65
movq 0x40(%rsp), %rdi
addq $0x18, %rdi
movl 0xe4(%rsp), %eax
movl %eax, %esi
callq 0x76e0
movq %rax, %rdi
callq 0x6640
testb $0x1, %al
jne 0x6d72
jmp 0x6e8e
movq 0xe8(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x9f(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x2300
movq 0x30(%rsp), %rdx
leaq 0x3544(%rip), %rsi      # 0xa2e1
leaq 0xa0(%rsp), %rdi
callq 0x4370
jmp 0x6dac
movq 0x28(%rsp), %rsi
leaq 0xc0(%rsp), %rdi
leaq 0xa0(%rsp), %rdx
callq 0x3d70
jmp 0x6dc8
movq 0x7201(%rip), %rdi      # 0xdfd0
leaq 0xc0(%rsp), %rsi
callq 0x2180
movq %rax, 0x20(%rsp)
jmp 0x6de3
movq 0x20(%rsp), %rdi
leaq 0x35ad(%rip), %rsi      # 0xa39c
callq 0x21b0
jmp 0x6df6
leaq 0xc0(%rsp), %rdi
callq 0x2110
leaq 0xa0(%rsp), %rdi
callq 0x2110
leaq 0x9f(%rsp), %rdi
callq 0x2210
jmp 0x6f4d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0x6e7c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0x6e6f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0xc0(%rsp), %rdi
callq 0x2110
leaq 0xa0(%rsp), %rdi
callq 0x2110
leaq 0x9f(%rsp), %rdi
callq 0x2210
jmp 0x6f80
movq 0x40(%rsp), %rsi
movq 0xe8(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0xe4(%rsp), %edx
leaq 0x48(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x69b0
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
leaq 0x68(%rsp), %rdi
callq 0x3d70
jmp 0x6ecc
movq 0x70fd(%rip), %rdi      # 0xdfd0
leaq 0x68(%rsp), %rsi
callq 0x2180
movq %rax, 0x8(%rsp)
jmp 0x6ee4
movq 0x8(%rsp), %rdi
leaq 0x34ac(%rip), %rsi      # 0xa39c
callq 0x21b0
jmp 0x6ef7
leaq 0x68(%rsp), %rdi
callq 0x2110
leaq 0x48(%rsp), %rdi
callq 0x2110
jmp 0x6f4d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0x6f41
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x2110
leaq 0x48(%rsp), %rdi
callq 0x2110
jmp 0x6f80
jmp 0x6f4f
movl 0xe4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xe4(%rsp)
jmp 0x6d1f
movq 0x7064(%rip), %rdi      # 0xdfd0
movq 0x704d(%rip), %rsi      # 0xdfc0
callq 0x21f0
addq $0xf8, %rsp
retq
movq 0x90(%rsp), %rdi
callq 0x22f0
nopl (%rax)
// File: moloch--[P]cli-Blackjack/./Blackjack/Hand.cpp
// Function: Hand::printAsciiBottomRank(AsciiArt&)
void Hand::printAsciiBottomRank(AsciiArt & ascii)
{
    for (unsigned int cardIndex = 0;cardIndex < hand.size();++cardIndex)
    {
        if (hand[cardIndex].isHidden())
        {
            cout << ascii.getBottomRank("?") << " ";
        }
        else
        {
            cout << ascii.getBottomRank(getCardRank(cardIndex)) << " ";
        }
    }
    cout << endl; // End line & flush buffer
}

// Assembly:
subq $0xf8, %rsp
movq %rdi, 0xf0(%rsp)
movq %rsi, 0xe8(%rsp)
movq 0xf0(%rsp), %rax
movq %rax, 0x40(%rsp)
movl $0x0, 0xe4(%rsp)
movq 0x40(%rsp), %rdi
movl 0xe4(%rsp), %eax
movq %rax, 0x38(%rsp)
addq $0x18, %rdi
callq 0x76c0
movq %rax, %rcx
movq 0x38(%rsp), %rax
cmpq %rcx, %rax
jae 0x7505
movq 0x40(%rsp), %rdi
addq $0x18, %rdi
movl 0xe4(%rsp), %eax
movl %eax, %esi
callq 0x76e0
movq %rax, %rdi
callq 0x6640
testb $0x1, %al
jne 0x7312
jmp 0x742e
movq 0xe8(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x9f(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0x2300
movq 0x30(%rsp), %rdx
leaq 0x2fa4(%rip), %rsi      # 0xa2e1
leaq 0xa0(%rsp), %rdi
callq 0x4370
jmp 0x734c
movq 0x28(%rsp), %rsi
leaq 0xc0(%rsp), %rdi
leaq 0xa0(%rsp), %rdx
callq 0x3e90
jmp 0x7368
movq 0x6c61(%rip), %rdi      # 0xdfd0
leaq 0xc0(%rsp), %rsi
callq 0x2180
movq %rax, 0x20(%rsp)
jmp 0x7383
movq 0x20(%rsp), %rdi
leaq 0x300d(%rip), %rsi      # 0xa39c
callq 0x21b0
jmp 0x7396
leaq 0xc0(%rsp), %rdi
callq 0x2110
leaq 0xa0(%rsp), %rdi
callq 0x2110
leaq 0x9f(%rsp), %rdi
callq 0x2210
jmp 0x74ed
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0x741c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0x740f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0xc0(%rsp), %rdi
callq 0x2110
leaq 0xa0(%rsp), %rdi
callq 0x2110
leaq 0x9f(%rsp), %rdi
callq 0x2210
jmp 0x7520
movq 0x40(%rsp), %rsi
movq 0xe8(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0xe4(%rsp), %edx
leaq 0x48(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x69b0
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
leaq 0x68(%rsp), %rdi
callq 0x3e90
jmp 0x746c
movq 0x6b5d(%rip), %rdi      # 0xdfd0
leaq 0x68(%rsp), %rsi
callq 0x2180
movq %rax, 0x8(%rsp)
jmp 0x7484
movq 0x8(%rsp), %rdi
leaq 0x2f0c(%rip), %rsi      # 0xa39c
callq 0x21b0
jmp 0x7497
leaq 0x68(%rsp), %rdi
callq 0x2110
leaq 0x48(%rsp), %rdi
callq 0x2110
jmp 0x74ed
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0x74e1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x2110
leaq 0x48(%rsp), %rdi
callq 0x2110
jmp 0x7520
jmp 0x74ef
movl 0xe4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xe4(%rsp)
jmp 0x72bf
movq 0x6ac4(%rip), %rdi      # 0xdfd0
movq 0x6aad(%rip), %rsi      # 0xdfc0
callq 0x21f0
addq $0xf8, %rsp
retq
movq 0x90(%rsp), %rdi
callq 0x22f0
nopl (%rax)
// File: moloch--[P]cli-Blackjack/./Blackjack/Hand.cpp
// Function: Hand::printAsciiFooter(AsciiArt&)
void Hand::printAsciiFooter(AsciiArt & ascii)
{
    for (unsigned int index = 0;index < ascii.getFooterSize();++index)
    {
        for (unsigned int cardIndex = 0;cardIndex < hand.size();++cardIndex)
        {
            cout << ascii.getCardFooter(index) << " ";
        }
        cout << endl;
    }
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x28(%rsp)
movl $0x0, 0x64(%rsp)
movl 0x64(%rsp), %eax
movl %eax, 0x24(%rsp)
movq 0x68(%rsp), %rdi
callq 0x4190
movl %eax, %ecx
movl 0x24(%rsp), %eax
cmpl %ecx, %eax
jae 0x7633
movl $0x0, 0x60(%rsp)
movq 0x28(%rsp), %rdi
movl 0x60(%rsp), %eax
movq %rax, 0x18(%rsp)
addq $0x18, %rdi
callq 0x76c0
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x7610
movq 0x68(%rsp), %rsi
movl 0x64(%rsp), %edx
leaq 0x40(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x3d20
movq 0x8(%rsp), %rsi
movq 0x6a10(%rip), %rdi      # 0xdfd0
callq 0x2180
movq %rax, 0x10(%rsp)
jmp 0x75cc
movq 0x10(%rsp), %rdi
leaq 0x2dc4(%rip), %rsi      # 0xa39c
callq 0x21b0
jmp 0x75df
leaq 0x40(%rsp), %rdi
callq 0x2110
movl 0x60(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x60(%rsp)
jmp 0x7578
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x2110
jmp 0x7638
movq 0x69b9(%rip), %rdi      # 0xdfd0
movq 0x69a2(%rip), %rsi      # 0xdfc0
callq 0x21f0
movl 0x64(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x64(%rsp)
jmp 0x7550
addq $0x78, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x22f0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: moloch--[P]cli-Blackjack/./Blackjack/Player.cpp
// Function: Player::turn(Deck&)
void Player::turn(Deck & deck)
{
	playTurn = true;
	while (playTurn)
	{
		printCurrentHand();
		cout << "Do you want to hit or stay? ";
		getline(cin, playerInput);
		if (playerInput == "h" || playerInput == "hit" || playerInput == "Hit")
		{
			hit(deck.deal());
			playTurn = !isBust(); // If the player busts, end their turn
		}
		else
		{
			playTurn = false; // User wants to stay, end their turn
		}
	}
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x10(%rsp)
movb $0x1, 0x8(%rax)
movq 0x10(%rsp), %rax
testb $0x1, 0x8(%rax)
je 0x8b96
movq 0x10(%rsp), %rdi
callq 0x86a0
movq 0x551b(%rip), %rdi      # 0xdfd0
leaq 0x1837(%rip), %rsi      # 0xa2f3
callq 0x21b0
movq 0x10(%rsp), %rsi
addq $0x20, %rsi
movq 0x550f(%rip), %rdi      # 0xdfe0
callq 0x2050
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
leaq 0x182a(%rip), %rsi      # 0xa310
callq 0x44f0
testb $0x1, %al
jne 0x8b23
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
leaq 0x1813(%rip), %rsi      # 0xa312
callq 0x44f0
testb $0x1, %al
jne 0x8b23
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
leaq 0x17fe(%rip), %rsi      # 0xa316
callq 0x44f0
testb $0x1, %al
jne 0x8b23
jmp 0x8b88
movq 0x78(%rsp), %rsi
leaq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x9740
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x8760
jmp 0x8b48
leaq 0x28(%rsp), %rdi
callq 0x64c0
movq 0x10(%rsp), %rdi
callq 0x86c0
movb %al, %cl
movq 0x10(%rsp), %rax
xorb $-0x1, %cl
andb $0x1, %cl
movb %cl, 0x8(%rax)
jmp 0x8b91
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x64c0
jmp 0x8b9e
movq 0x10(%rsp), %rax
movb $0x0, 0x8(%rax)
jmp 0x8a95
addq $0x88, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x22f0
nopl (%rax,%rax)
// File: moloch--[P]cli-Blackjack/./Blackjack/Player.cpp
// Function: Player::getWager()
int Player::getWager()
{
	if (getMoney() > 50)
	{
		wager = 0;
		while(wager < 50 || getMoney() < wager)
		{
			cout << "How much would you like to wager (min. $50)? " << endl;
			cout << "You have $" << getMoney() << ": ";
			cin >> wager;
			cin.ignore();  // Drop newline char
		}
	}
	else
	{
		wager = getMoney();
	}
	cout << "Your wager is: $" << wager << endl;
	return wager;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x8cf0
cmpl $0x32, %eax
jle 0x8c9b
movq 0x18(%rsp), %rax
movl $0x0, 0x14(%rax)
movq 0x18(%rsp), %rcx
movb $0x1, %al
cmpl $0x32, 0x14(%rcx)
movb %al, 0x17(%rsp)
jl 0x8c07
movq 0x18(%rsp), %rdi
callq 0x8cf0
movq 0x18(%rsp), %rcx
cmpl 0x14(%rcx), %eax
setl %al
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x8c14
jmp 0x8c99
movq 0x53b5(%rip), %rdi      # 0xdfd0
leaq 0x16f8(%rip), %rsi      # 0xa31a
callq 0x21b0
movq %rax, %rdi
movq 0x538f(%rip), %rsi      # 0xdfc0
callq 0x21f0
movq 0x5393(%rip), %rdi      # 0xdfd0
leaq 0x1704(%rip), %rsi      # 0xa348
callq 0x21b0
movq 0x18(%rsp), %rdi
movq %rax, 0x8(%rsp)
callq 0x8cf0
movq 0x8(%rsp), %rdi
movl %eax, %esi
callq 0x22e0
movq %rax, %rdi
leaq 0x172d(%rip), %rsi      # 0xa39b
callq 0x21b0
movq 0x18(%rsp), %rsi
addq $0x14, %rsi
movq 0x535d(%rip), %rdi      # 0xdfe0
callq 0x2100
movq 0x5351(%rip), %rdi      # 0xdfe0
callq 0x2320
jmp 0x8bdd
jmp 0x8caf
movq 0x18(%rsp), %rdi
callq 0x8cf0
movl %eax, %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x14(%rax)
movq 0x531a(%rip), %rdi      # 0xdfd0
leaq 0x1696(%rip), %rsi      # 0xa353
callq 0x21b0
movq %rax, %rdi
movq 0x18(%rsp), %rax
movl 0x14(%rax), %esi
callq 0x22e0
movq %rax, %rdi
movq 0x52e4(%rip), %rsi      # 0xdfc0
callq 0x21f0
movq 0x18(%rsp), %rax
movl 0x14(%rax), %eax
addq $0x28, %rsp
retq
nop
// File: moloch--[P]cli-Blackjack/./Blackjack/main.cpp
// Function: main
int main()
{
	string playAgain;
	bool playGame = true;
	Blackjack game;
	while (playGame)
	{
		game.playGame();
		cout << "Would you like to play again? [Y/n]: ";
		getline(cin, playAgain);
		if (playAgain != "y" && playAgain != "Y") // Only check affirmative
		{
			playGame = false; // Stop playing game
		}
	}
	return 0;
}

// Assembly:
subq $0xd8, %rsp
movl $0x0, 0xd4(%rsp)
leaq 0xb0(%rsp), %rdi
callq 0x2280
movb $0x1, 0xaf(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x53d0
jmp 0x9cb3
jmp 0x9cb5
testb $0x1, 0xaf(%rsp)
je 0x9d7b
leaq 0x18(%rsp), %rdi
callq 0x5ee0
jmp 0x9ccf
movq 0x42fa(%rip), %rdi      # 0xdfd0
leaq 0x69b(%rip), %rsi       # 0xa378
callq 0x21b0
jmp 0x9ce4
movq 0x42f5(%rip), %rdi      # 0xdfe0
leaq 0xb0(%rsp), %rsi
callq 0x2050
jmp 0x9cfa
leaq 0x69d(%rip), %rsi       # 0xa39e
leaq 0xb0(%rsp), %rdi
callq 0x9dd0
movb %al, 0xb(%rsp)
jmp 0x9d14
movb 0xb(%rsp), %al
testb $0x1, %al
jne 0x9d1e
jmp 0x9d76
leaq 0x67b(%rip), %rsi       # 0xa3a0
leaq 0xb0(%rsp), %rdi
callq 0x9dd0
movb %al, 0xa(%rsp)
jmp 0x9d38
movb 0xa(%rsp), %al
testb $0x1, %al
jne 0x9d42
jmp 0x9d76
movb $0x0, 0xaf(%rsp)
jmp 0x9d76
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
jmp 0x9dac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x5480
jmp 0x9dac
jmp 0x9cb5
movl $0x0, 0xd4(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x5480
leaq 0xb0(%rsp), %rdi
callq 0x2110
movl 0xd4(%rsp), %eax
addq $0xd8, %rsp
retq
leaq 0xb0(%rsp), %rdi
callq 0x2110
movq 0x10(%rsp), %rdi
callq 0x22f0
nopw %cs:(%rax,%rax)
nopl (%rax)