LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/sangwoojun[P]rv32emulator/./linenoise.hpp
// Function: linenoise::unicodeReadUTF8Char(int, char*, int*)
inline int unicodeReadUTF8Char(int fd, char* buf, int* cp)
{
    int nread = read(fd,&buf[0],1);

    if (nread <= 0) { return nread; }

    unsigned char byte = buf[0];

    if ((byte & 0x80) == 0) {
        ;
    } else if ((byte & 0xE0) == 0xC0) {
        nread = read(fd,&buf[1],1);
        if (nread <= 0) { return nread; }
    } else if ((byte & 0xF0) == 0xE0) {
        nread = read(fd,&buf[1],2);
        if (nread <= 0) { return nread; }
    } else if ((byte & 0xF8) == 0xF0) {
        nread = read(fd,&buf[1],3);
        if (nread <= 0) { return nread; }
    } else {
        return -1;
    }

    return unicodeUTF8CharToCodePoint(buf, 4, cp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %r15d
movl $0x1, %edx
callq 0x22b0
testl %eax, %eax
jle 0x62d4
movzbl (%r14), %ecx
testb %cl, %cl
jns 0x6232
movl %ecx, %eax
andl $-0x20, %eax
cmpl $0xc0, %eax
jne 0x61ee
leaq 0x1(%r14), %rsi
movl $0x1, %edx
jmp 0x6222
movl %ecx, %eax
andl $-0x10, %eax
cmpl $0xe0, %eax
jne 0x6205
leaq 0x1(%r14), %rsi
movl $0x2, %edx
jmp 0x6222
andl $-0x8, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0xf0, %ecx
jne 0x62d4
leaq 0x1(%r14), %rsi
movl $0x3, %edx
movl %r15d, %edi
callq 0x22b0
testl %eax, %eax
jle 0x62d4
movzbl (%r14), %ecx
testb %cl, %cl
js 0x6244
movl $0x1, %eax
jmp 0x62d2
movl %ecx, %eax
andl $-0x20, %eax
cmpl $0xc0, %eax
jne 0x6264
andl $0x1f, %ecx
shll $0x6, %ecx
movl $0x2, %eax
movl $0x1, %esi
movl %ecx, %edx
jmp 0x62c8
movl %ecx, %eax
andl $-0x10, %eax
cmpl $0xe0, %eax
jne 0x628f
andl $0xf, %ecx
shll $0xc, %ecx
movzbl 0x1(%r14), %edx
andl $0x3f, %edx
shll $0x6, %edx
orl %ecx, %edx
movl $0x3, %eax
movl $0x2, %esi
jmp 0x62c8
movl %ecx, %edx
andl $-0x8, %edx
xorl %eax, %eax
cmpl $0xf0, %edx
jne 0x62d4
andl $0x7, %ecx
shll $0x12, %ecx
movzbl 0x1(%r14), %eax
andl $0x3f, %eax
shll $0xc, %eax
orl %ecx, %eax
movzbl 0x2(%r14), %edx
andl $0x3f, %edx
shll $0x6, %edx
orl %eax, %edx
movl $0x4, %eax
movl $0x3, %esi
movzbl (%r14,%rsi), %ecx
andl $0x3f, %ecx
orl %edx, %ecx
movl %ecx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/sangwoojun[P]rv32emulator/./linenoise.hpp
// Function: linenoise::linenoiseEditHistoryNext(linenoise::linenoiseState*, int)
inline void linenoiseEditHistoryNext(struct linenoiseState *l, int dir) {
    if (history.size() > 1) {
        /* Update the current history entry before to
         * overwrite it with the next one. */
        history[history.size() - 1 - l->history_index] = l->buf;
        /* Show the new entry */
        l->history_index += (dir == LINENOISE_HISTORY_PREV) ? 1 : -1;
        if (l->history_index < 0) {
            l->history_index = 0;
            return;
        } else if (l->history_index >= (int)history.size()) {
            l->history_index = static_cast<int>(history.size())-1;
            return;
        }
        memset(l->buf, 0, l->buflen);
        strcpy(l->buf,history[history.size() - 1 - l->history_index].c_str());
        l->len = l->pos = static_cast<int>(strlen(l->buf));
        refreshLine(l);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x8535(%rip), %rcx      # 0xeb30
movq 0x8526(%rip), %rax      # 0xeb28
subq %rax, %rcx
cmpq $0x21, %rcx
jb 0x66da
movl %esi, %r14d
movq %rdi, %rbx
movq 0x8(%rdi), %r15
movslq 0x4c(%rdi), %rdx
notq %rdx
addq %rcx, %rax
shlq $0x5, %rdx
leaq (%rax,%rdx), %r12
movq 0x8(%rdx,%rax), %r13
movq %r15, %rdi
callq 0x20f0
movq %r12, %rdi
xorl %esi, %esi
movq %r13, %rdx
movq %r15, %rcx
movq %rax, %r8
callq 0x22f0
xorl %eax, %eax
cmpl $0x1, %r14d
sete %al
leal -0x1(,%rax,2), %eax
addl 0x4c(%rbx), %eax
movl %eax, 0x4c(%rbx)
js 0x66cc
movq 0x84c6(%rip), %rcx      # 0xeb30
subq 0x84b7(%rip), %rcx      # 0xeb28
shrq $0x5, %rcx
cmpl %ecx, %eax
jge 0x66d5
movq 0x8(%rbx), %rdi
movslq 0x10(%rbx), %rdx
xorl %esi, %esi
callq 0x2120
movq 0x8(%rbx), %rdi
movq 0x849d(%rip), %rax      # 0xeb30
movslq 0x4c(%rbx), %rcx
notq %rcx
shlq $0x5, %rcx
movq (%rax,%rcx), %rsi
callq 0x2170
movq 0x8(%rbx), %rdi
callq 0x20f0
movl %eax, 0x38(%rbx)
movl %eax, 0x40(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6b31
movl $0x0, 0x4c(%rbx)
jmp 0x66da
decl %ecx
movl %ecx, 0x4c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/sangwoojun[P]rv32emulator/./linenoise.hpp
// Function: linenoise::linenoiseEditInsert(linenoise::linenoiseState*, char const*, int)
inline int linenoiseEditInsert(struct linenoiseState *l, const char* cbuf, int clen) {
    if (l->len < l->buflen) {
        if (l->len == l->pos) {
            memcpy(&l->buf[l->pos],cbuf,clen);
            l->pos+=clen;
            l->len+=clen;;
            l->buf[l->len] = '\0';
            if ((!mlmode && unicodeColumnPos(l->prompt.c_str(), static_cast<int>(l->prompt.length()))+unicodeColumnPos(l->buf,l->len) < l->cols) /* || mlmode */) {
                /* Avoid a full update of the line in the
                 * trivial case. */
                if (write(l->ofd,cbuf,clen) == -1) return -1;
            } else {
                refreshLine(l);
            }
        } else {
            memmove(l->buf+l->pos+clen,l->buf+l->pos,l->len-l->pos);
            memcpy(&l->buf[l->pos],cbuf,clen);
            l->pos+=clen;
            l->len+=clen;
            l->buf[l->len] = '\0';
            refreshLine(l);
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl 0x40(%rdi), %eax
cmpl 0x10(%rdi), %eax
jge 0x67b7
movq %rsi, %r14
movq %rdi, %rbx
movslq 0x38(%rdi), %rcx
movq %rcx, %rsi
addq 0x8(%rdi), %rsi
movslq %edx, %r15
subl %ecx, %eax
jne 0x677a
movq %rsi, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2150
addl %r15d, 0x38(%rbx)
movslq 0x40(%rbx), %rax
addq %r15, %rax
movl %eax, 0x40(%rbx)
movq 0x8(%rbx), %rcx
movb $0x0, (%rcx,%rax)
movq 0x18(%rbx), %rdi
movl 0x20(%rbx), %esi
callq 0x6ca3
movl %eax, %r12d
movq 0x8(%rbx), %rdi
movl 0x40(%rbx), %esi
callq 0x6ca3
addl %r12d, %eax
cmpl 0x44(%rbx), %eax
jge 0x67af
movl 0x4(%rbx), %edi
movq %r14, %rsi
movq %r15, %rdx
callq 0x20a0
cmpq $-0x1, %rax
jne 0x67b7
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x67b9
leaq (%rsi,%r15), %rdi
movslq %eax, %rdx
callq 0x2350
movslq 0x38(%rbx), %rdi
addq 0x8(%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2150
addl %r15d, 0x38(%rbx)
movslq 0x40(%rbx), %rax
addq %r15, %rax
movl %eax, 0x40(%rbx)
movq 0x8(%rbx), %rcx
movb $0x0, (%rcx,%rax)
movq %rbx, %rdi
callq 0x6b31
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
testl %esi, %esi
je 0x69c6
leaq 0x1912(%rip), %rcx      # 0x8180
movl %esi, %r10d
testl %r10d, %r10d
jle 0x69c6
movl %r10d, %r8d
decq %r8
movl %r10d, %edx
testl %edx, %edx
jle 0x689e
movl %r8d, %r9d
movb (%rdi,%r9), %r9b
andb $-0x40, %r9b
decl %edx
decq %r8
negb %r9b
jo 0x6883
jmp 0x68a3
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
subl %edx, %r10d
jne 0x68b0
xorl %r11d, %r11d
jmp 0x698f
movslq %edx, %r8
addq %rdi, %r8
movzbl (%r8), %r9d
movl %r9d, %r11d
testb %r9b, %r9b
jns 0x698f
movl %r9d, %r11d
andl $-0x20, %r11d
cmpl $0xc0, %r11d
jne 0x68f9
movl $0x0, %r11d
cmpl $0x2, %r10d
jl 0x698f
andl $0x1f, %r9d
shll $0x6, %r9d
movl $0x1, %r10d
jmp 0x6983
movl %r9d, %r11d
andl $-0x10, %r11d
cmpl $0xe0, %r11d
jne 0x6935
movl $0x0, %r11d
cmpl $0x3, %r10d
jl 0x698f
andl $0xf, %r9d
shll $0xc, %r9d
movzbl 0x1(%r8), %r10d
andl $0x3f, %r10d
shll $0x6, %r10d
orl %r10d, %r9d
movl $0x2, %r10d
jmp 0x6983
cmpl $0x4, %r10d
jl 0x68a8
movl %r9d, %r10d
andl $-0x8, %r10d
movl $0x0, %r11d
cmpl $0xf0, %r10d
jne 0x698f
andl $0x7, %r9d
shll $0x12, %r9d
movzbl 0x1(%r8), %r10d
andl $0x3f, %r10d
shll $0xc, %r10d
orl %r9d, %r10d
movzbl 0x2(%r8), %r9d
andl $0x3f, %r9d
shll $0x6, %r9d
orl %r10d, %r9d
movl $0x3, %r10d
movzbl (%r8,%r10), %r11d
andl $0x3f, %r11d
orl %r9d, %r11d
movl %r11d, %r8d
xorl %r10d, %r10d
movq (%r10,%rcx), %r9
cmpq %r8, %r9
je 0x69ae
leaq 0x8(%r10), %r11
cmpq $0x30f0, %r10           # imm = 0x30F0
movq %r11, %r10
jne 0x6995
movl %esi, %r11d
subl %edx, %r11d
movl %edx, %r10d
cmpq %r8, %r9
cmovnel %r11d, %eax
je 0x6871
jmp 0x69c8
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
xorl %eax, %eax
cmpl %esi, %edx
je 0x6b30
movslq %edx, %rax
movb (%rdi,%rax), %al
movl $0x1, %ecx
testb %al, %al
jns 0x69f6
movl $0x2, %ecx
cmpb $-0x20, %al
jb 0x69f6
cmpb $-0x10, %al
movl $0x4, %ecx
sbbl $0x0, %ecx
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
addl %edx, %ecx
leaq 0x177a(%rip), %r8       # 0x8180
cmpl %esi, %ecx
jge 0x6b28
movslq %ecx, %r10
movb (%rdi,%r10), %r11b
movl $0x1, %r9d
testb %r11b, %r11b
jns 0x6a3a
movl $0x2, %r9d
cmpb $-0x20, %r11b
jb 0x6a3a
cmpb $-0x10, %r11b
movl $0x4, %r9d
sbbl $0x0, %r9d
movzbl (%rdi,%r10), %r11d
movl %r11d, %ebx
testb %r11b, %r11b
jns 0x6af4
addq %rdi, %r10
movl %r11d, %ebx
andl $-0x20, %ebx
cmpl $0xc0, %ebx
jne 0x6a71
cmpl $0x2, %r9d
jb 0x6aa2
andl $0x1f, %r11d
shll $0x6, %r11d
movl $0x1, %ebx
jmp 0x6ae9
movl %r11d, %ebx
andl $-0x10, %ebx
cmpl $0xe0, %ebx
jne 0x6aa6
cmpl $0x3, %r9d
jb 0x6aa2
andl $0xf, %r11d
shll $0xc, %r11d
movzbl 0x1(%r10), %ebx
andl $0x3f, %ebx
shll $0x6, %ebx
orl %ebx, %r11d
movl $0x2, %ebx
jmp 0x6ae9
xorl %ebx, %ebx
jmp 0x6af4
xorl %ebx, %ebx
cmpl $0x4, %r9d
jb 0x6af4
movl %r11d, %r14d
andl $-0x8, %r14d
cmpl $0xf0, %r14d
jne 0x6af4
andl $0x7, %r11d
shll $0x12, %r11d
movzbl 0x1(%r10), %ebx
andl $0x3f, %ebx
shll $0xc, %ebx
orl %r11d, %ebx
movzbl 0x2(%r10), %r11d
andl $0x3f, %r11d
shll $0x6, %r11d
orl %ebx, %r11d
movl $0x3, %ebx
movzbl (%r10,%rbx), %ebx
andl $0x3f, %ebx
orl %r11d, %ebx
movl %ebx, %r10d
xorl %ebx, %ebx
movq (%rbx,%r8), %r11
cmpq %r10, %r11
je 0x6b12
addq $0x8, %rbx
cmpq $0x30f8, %rbx           # imm = 0x30F8
jne 0x6af9
xorl %r9d, %r9d
addl %ecx, %r9d
subl %edx, %ecx
cmpq %r10, %r11
cmovnel %ecx, %eax
movl %r9d, %ecx
je 0x6a06
jmp 0x6b2c
subl %edx, %ecx
movl %ecx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/sangwoojun[P]rv32emulator/./linenoise.hpp
// Function: linenoise::refreshSingleLine(linenoise::linenoiseState*)
inline void refreshSingleLine(struct linenoiseState *l) {
    char seq[64];
    int pcolwid = unicodeColumnPos(l->prompt.c_str(), static_cast<int>(l->prompt.length()));
    int fd = l->ofd;
    char *buf = l->buf;
    int len = l->len;
    int pos = l->pos;
    std::string ab;

    while((pcolwid+unicodeColumnPos(buf, pos)) >= l->cols) {
        int glen = unicodeGraphemeLen(buf, len, 0);
        buf += glen;
        len -= glen;
        pos -= glen;
    }
    while (pcolwid+unicodeColumnPos(buf, len) > l->cols) {
        len -= unicodePrevGraphemeLen(buf, len);
    }

    /* Cursor to left edge */
    snprintf(seq,64,"\r");
    ab += seq;
    /* Write the prompt and the current buffer content */
    ab += l->prompt;
    ab.append(buf, len);
    /* Erase to right */
    snprintf(seq,64,"\x1b[0K");
    ab += seq;
    /* Move cursor to original position. */
    snprintf(seq,64,"\r\x1b[%dC", (int)(unicodeColumnPos(buf, pos)+pcolwid));
    ab += seq;
    if (write(fd,ab.c_str(), static_cast<int>(ab.length())) == -1) {} /* Can't recover from write error. */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movl 0x20(%rbx), %esi
callq 0x6ca3
movl %eax, %r14d
movl 0x4(%rbx), %eax
movl %eax, -0x2c(%rbp)
movq 0x8(%rbx), %r15
movl 0x40(%rbx), %r13d
movl 0x38(%rbx), %r12d
leaq -0x40(%rbp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq %r15, %rdi
movl %r12d, %esi
callq 0x6ca3
addl %r14d, %eax
cmpl 0x44(%rbx), %eax
jl 0x6bb4
movq %r15, %rdi
movl %r13d, %esi
xorl %edx, %edx
callq 0x69ca
cltq
addq %rax, %r15
subl %eax, %r13d
subl %eax, %r12d
jmp 0x6b79
movq %r15, %rdi
movl %r13d, %esi
callq 0x685b
subl %eax, %r13d
movq %r15, %rdi
movl %r13d, %esi
callq 0x6ca3
addl %r14d, %eax
cmpl 0x44(%rbx), %eax
jg 0x6ba6
leaq -0x90(%rbp), %rsi
movw $0xd, (%rsi)
leaq -0x50(%rbp), %rdi
callq 0x23a0
movq 0x18(%rbx), %rsi
movq 0x20(%rbx), %rdx
leaq -0x50(%rbp), %rdi
callq 0x2090
movslq %r13d, %rdx
leaq -0x50(%rbp), %rdi
movq %r15, %rsi
callq 0x2050
leaq -0x90(%rbp), %rsi
movb $0x0, 0x4(%rsi)
movl $0x4b305b1b, (%rsi)     # imm = 0x4B305B1B
leaq -0x50(%rbp), %rdi
callq 0x23a0
movq %r15, %rdi
movl %r12d, %esi
callq 0x6ca3
addl %r14d, %eax
leaq 0x4e13(%rip), %rdx      # 0xba3e
leaq -0x90(%rbp), %rbx
movl $0x40, %esi
movq %rbx, %rdi
movl %eax, %ecx
xorl %eax, %eax
callq 0x2340
leaq -0x50(%rbp), %rdi
movq %rbx, %rsi
callq 0x23a0
movq -0x50(%rbp), %rsi
movslq -0x48(%rbp), %rdx
movl -0x2c(%rbp), %edi
callq 0x20a0
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x6c71
callq 0x2180
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6c86
jmp 0x6c86
jmp 0x6c86
movq %rax, %rbx
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x6c9b
callq 0x2180
movq %rbx, %rdi
callq 0x2370
// File: /workspace/github_cpp_makefile_star2_O1/sangwoojun[P]rv32emulator/./linenoise.hpp
// Function: linenoise::unicodeColumnPos(char const*, int)
inline int unicodeColumnPos(const char* buf, int buf_len)
{
    int ret = 0;

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

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

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

        off += len;
    }

    return ret;
}

// Assembly:
testl %esi, %esi
jle 0x6e74
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
xorl %ecx, %ecx
leaq 0x14bf(%rip), %r8       # 0x8180
leaq 0x45b8(%rip), %r9       # 0xb280
xorl %r10d, %r10d
movq %rdi, -0x30(%rbp)
movslq %ecx, %rdx
leaq (%rdi,%rdx), %r11
movl %esi, %r14d
subl %edx, %r14d
movb $0x1, %bl
cmpl $0x3, %r14d
jl 0x6d30
cmpw $0x5b1b, (%r11)         # imm = 0x5B1B
jne 0x6d30
movl %r10d, %edi
movl %r14d, %r15d
movl $0x2, %r12d
cmpq %r12, %r15
je 0x6d29
movq %r12, %r13
incq %r12
movzbl (%r11,%r13), %edx
addl $-0x41, %edx
cmpl $0x2c, %edx
ja 0x6cf8
movabsq $0x1020000c06ff, %r10   # imm = 0x1020000C06FF
btq %rdx, %r10
jae 0x6cf8
cmpq %r15, %r13
setae %bl
movl %r12d, %eax
movl %edi, %r10d
movq -0x30(%rbp), %rdi
testb %bl, %bl
je 0x6e5e
cmpl %ecx, %esi
jne 0x6d46
xorl %r11d, %r11d
xorl %eax, %eax
jmp 0x6e13
movzbl (%r11), %ebx
testb %bl, %bl
js 0x6d5b
movl $0x1, %eax
movl %ebx, %r15d
jmp 0x6e10
movl %ebx, %edx
andl $-0x20, %edx
cmpl $0xc0, %edx
jne 0x6d84
cmpl $0x2, %r14d
jl 0x6db7
andl $0x1f, %ebx
shll $0x6, %ebx
movl $0x2, %eax
movl $0x1, %r14d
jmp 0x6e04
movl %ebx, %edx
andl $-0x10, %edx
cmpl $0xe0, %edx
jne 0x6dbe
cmpl $0x3, %r14d
jl 0x6db7
andl $0xf, %ebx
shll $0xc, %ebx
movzbl 0x1(%r11), %edx
andl $0x3f, %edx
shll $0x6, %edx
orl %edx, %ebx
movl $0x3, %eax
movl $0x2, %r14d
jmp 0x6e04
xorl %r15d, %r15d
xorl %eax, %eax
jmp 0x6e10
xorl %r15d, %r15d
cmpl $0x4, %r14d
jl 0x6dba
movl %ebx, %edx
andl $-0x8, %edx
movl $0x0, %eax
cmpl $0xf0, %edx
jne 0x6e10
andl $0x7, %ebx
shll $0x12, %ebx
movzbl 0x1(%r11), %edx
andl $0x3f, %edx
shll $0xc, %edx
orl %ebx, %edx
movzbl 0x2(%r11), %ebx
andl $0x3f, %ebx
shll $0x6, %ebx
orl %edx, %ebx
movl $0x4, %eax
movl $0x3, %r14d
movzbl (%r11,%r14), %r15d
andl $0x3f, %r15d
orl %ebx, %r15d
movl %r15d, %r11d
xorl %ebx, %ebx
movq (%rbx,%r8), %r14
cmpq %r11, %r14
je 0x6e2e
leaq 0x8(%rbx), %rdx
cmpq $0x30f0, %rbx           # imm = 0x30F0
movq %rdx, %rbx
jne 0x6e15
cmpq %r11, %r14
je 0x6e5e
xorl %ebx, %ebx
cmpq %r11, (%rbx,%r9)
ja 0x6e42
cmpq %r11, 0x8(%rbx,%r9)
jae 0x6e56
addq $0x10, %rbx
cmpq $0x200, %rbx            # imm = 0x200
jne 0x6e35
movl $0x1, %edx
jmp 0x6e5b
movl $0x2, %edx
addl %edx, %r10d
addl %eax, %ecx
cmpl %esi, %ecx
jl 0x6ccf
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x6e77
xorl %r10d, %r10d
movl %r10d, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
subq $0x40, %rsp
leaq 0x38(%rsp), %rax
movq %rax, -0x30(%rax)
movq $0x1, -0x28(%rax)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%rax)
movl $0x3f800000, -0x10(%rax) # imm = 0x3F800000
movups %xmm0, -0x8(%rax)
movabsq $0x400d99999999999a, %rbx # imm = 0x400D99999999999A
movq %rsp, %rsi
movq %rbx, (%rsi)
leaq 0x8(%rsp), %rdi
callq 0x133c
movl $0x4, (%rax)
movq %rsp, %rsi
movq %rbx, (%rsi)
leaq 0x8(%rsp), %rdi
callq 0x133c
cmpl $0x4, (%rax)
jne 0x128b
leaq 0x8(%rsp), %rdi
callq 0x12c2
xorl %eax, %eax
addq $0x40, %rsp
popq %rbx
retq
leaq 0xd72(%rip), %rdi       # 0x2004
leaq 0xd77(%rip), %rsi       # 0x2010
leaq 0xd84(%rip), %rcx       # 0x2024
movl $0x8, %edx
callq 0x1080
jmp 0x12ac
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x12c2
movq %rbx, %rdi
callq 0x10f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
leaq -0x54(%rbp), %rbx
movl $0x0, (%rbx)
movabsq $0x40091eb851eb851f, %rax # imm = 0x40091EB851EB851F
leaq -0x50(%rbp), %r14
movq %rax, (%r14)
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0xdae(%rip), %rsi       # 0x2004
leaq 0xdb9(%rip), %rdx       # 0x2016
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x14f6
leaq -0x24(%rbp), %rdx
movl $0x2a, (%rdx)
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rcx
callq 0x12fc
leaq -0x24(%rbp), %rsi
movl $0x2a, (%rsi)
leaq 0xd85(%rip), %rdx       # 0x2017
leaq -0x48(%rbp), %rdi
callq 0x137c
leaq -0x50(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x13fc
leaq 0xd68(%rip), %rdi       # 0x2017
callq 0x147c
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x12c9
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x10a0
xorl %eax, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x12dc
jmp 0x12dc
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x12f4
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x10a0
movq %rbx, %rdi
callq 0x10c0
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rdx, %r14
movq %rdi, 0x8(%rsp)
leaq 0x30(%rsp), %r15
movq %r15, %rdi
callq 0x21c0
leaq 0x41b3(%rip), %rsi      # 0x7062
movl $0x1, %edx
movq %r15, %rdi
callq 0x2190
movq (%r14), %rsi
movq 0x8(%r14), %rdx
leaq 0x30(%rsp), %rdi
callq 0x2190
leaq 0x38(%rsp), %r14
leaq 0x20(%rsp), %rbp
leaq 0x10(%rsp), %r15
leaq 0x44b9(%rip), %r12      # 0x739c
leaq 0x30(%rsp), %r13
movq %r15, %rdi
movq %r14, %rsi
callq 0x2200
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rbx
cmpq %rbp, %rdi
je 0x2f0f
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x2180
cmpq $0x9, %rbx
ja 0x2f27
movl $0x1, %edx
movq %r13, %rdi
movq %r12, %rsi
callq 0x2190
jmp 0x2ee8
leaq 0x4134(%rip), %rsi      # 0x7062
leaq 0x30(%rsp), %rdi
movl $0x1, %edx
callq 0x2190
movq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x2200
movq 0x8077(%rip), %rsi      # 0xafc8
leaq 0x30(%rsp), %rdi
callq 0x20b0
leaq 0xa0(%rsp), %rdi
callq 0x2070
movq 0x8(%rsp), %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2f83
jmp 0x2f83
movq %rax, %rbx
movq 0x803b(%rip), %rsi      # 0xafc8
leaq 0x30(%rsp), %rdi
callq 0x20b0
leaq 0xa0(%rsp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rdx, %r15
movq %rdi, 0x8(%rsp)
leaq 0x30(%rsp), %r14
movq %r14, %rdi
callq 0x21c0
leaq 0x4089(%rip), %rsi      # 0x7062
movl $0x1, %edx
movq %r14, %rdi
callq 0x2190
leaq 0x20(%rsp), %rbx
leaq 0x10(%rsp), %r12
leaq 0x43a5(%rip), %r13      # 0x739c
leaq 0x30(%rsp), %rbp
movq %r12, %rdi
leaq 0x38(%rsp), %rsi
callq 0x2200
movq 0x8(%r15), %r14
addq 0x18(%rsp), %r14
movq 0x10(%rsp), %rdi
cmpq %rbx, %rdi
je 0x3029
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x2180
cmpq $0x9, %r14
ja 0x3041
movl $0x1, %edx
movq %rbp, %rdi
movq %r13, %rsi
callq 0x2190
jmp 0x2ffc
movq (%r15), %rsi
movq 0x8(%r15), %rdx
leaq 0x30(%rsp), %rdi
callq 0x2190
leaq 0x4009(%rip), %rsi      # 0x7062
movl $0x1, %edx
movq %rax, %rdi
callq 0x2190
movq 0x8(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x2200
movq 0x7f4c(%rip), %rsi      # 0xafc8
leaq 0x30(%rsp), %rdi
callq 0x20b0
leaq 0xa0(%rsp), %rdi
callq 0x2070
movq 0x8(%rsp), %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x30ae
jmp 0x30ae
movq %rax, %rbx
movq 0x7f10(%rip), %rsi      # 0xafc8
leaq 0x30(%rsp), %rdi
callq 0x20b0
leaq 0xa0(%rsp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x2230
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x3e27(%rip), %rsi      # 0x70f4
movq %rdx, %rdi
callq 0x2060
testl %eax, %eax
je 0x3344
leaq 0x3e1a(%rip), %rsi      # 0x70fa
movq %r15, %rdi
callq 0x2060
testl %eax, %eax
je 0x3353
leaq 0x3e0e(%rip), %rsi      # 0x7101
movq %r15, %rdi
callq 0x2060
testl %eax, %eax
je 0x3362
leaq 0x3e04(%rip), %rsi      # 0x710a
movq %r15, %rdi
callq 0x2060
testl %eax, %eax
je 0x3371
leaq 0x3df8(%rip), %rsi      # 0x7111
movq %r15, %rdi
callq 0x2060
testl %eax, %eax
je 0x3380
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x3de5(%rip), %rsi      # 0x7118
leaq 0x3df5(%rip), %rdx      # 0x712f
movq %rbx, %rdi
callq 0x36f0
jmp 0x338d
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x30d8
jmp 0x338d
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x312c
jmp 0x338d
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x3182
jmp 0x338d
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x31d8
jmp 0x338d
movq %rbx, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x322e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/moloch--[P]cli-Blackjack/./Blackjack/Blackjack.cpp
// Function: Blackjack::initialDeal(Player&, Dealer&)
void Blackjack::initialDeal(Player & player, Dealer & dealer)
{
    player.hit(deck.deal()); // Deal two cards to the player(s)
    player.hit(deck.deal());
    dealer.hit(deck.deal()); // Deal two cards to the dealer
    dealer.hit(deck.deal());
    dealer.hideCard();       // Hide dealer's card
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x148, %rsp            # imm = 0x148
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
addq $0x18, %r15
leaq 0xf8(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x6456
movq %r12, %rdi
movq %r14, %rsi
callq 0x5a28
leaq 0xf8(%rsp), %rdi
callq 0x4544
leaq 0xa8(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x6456
movq %r12, %rdi
movq %r14, %rsi
callq 0x5a28
leaq 0xa8(%rsp), %rdi
callq 0x4544
leaq 0x58(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x6456
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5a28
leaq 0x58(%rsp), %rdi
callq 0x4544
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x6456
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5a28
leaq 0x8(%rsp), %rdi
callq 0x4544
movq %rbx, %rdi
callq 0x59f0
addq $0x148, %rsp            # imm = 0x148
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x39bc
jmp 0x39bc
jmp 0x39bc
movq %rax, %rbx
movq %r14, %rdi
callq 0x4544
movq %rbx, %rdi
callq 0x2230
nop
// File: /workspace/github_cpp_makefile_star2_O1/moloch--[P]cli-Blackjack/./Blackjack/Blackjack.cpp
// Function: Blackjack::playGame()
void Blackjack::playGame()
{
	Dealer dealer("HAL 9000"); // Create the dealer
	Player player1("Weak Human"); // Create the player(s)
	player1.setMoney(1000);
	while (player1.getMoney() > 0)
	{
		startTurn(player1, dealer);
	}
	cout << "\n [!] You have lost all your money!" << endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x160, %rsp            # imm = 0x160
movq %rdi, %rbx
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x3217(%rip), %rsi      # 0x7282
leaq 0x3218(%rip), %rdx      # 0x728a
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x36f0
leaq 0xd0(%rsp), %rdi
movq %r14, %rsi
callq 0x4678
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x40a6
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x2180
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x31d5(%rip), %rsi      # 0x728b
leaq 0x31d8(%rip), %rdx      # 0x7295
movq %rsp, %rdi
callq 0x36f0
leaq 0x40(%rsp), %rdi
movq %rsp, %rsi
callq 0x5734
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x40e8
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2180
leaq 0x40(%rsp), %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x5ec2
leaq 0x40(%rsp), %r14
leaq 0xd0(%rsp), %r15
movq %r14, %rdi
callq 0x5ebe
testl %eax, %eax
jle 0x4120
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x3cc4
jmp 0x4104
movq 0x6ea9(%rip), %rbx      # 0xafd0
leaq 0x3168(%rip), %rsi      # 0x7296
movl $0x23, %edx
movq %rbx, %rdi
callq 0x2190
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq 0x6e77(%rip), %rdi      # 0xafd0
callq 0x2030
movq %rax, %rdi
callq 0x20f0
leaq 0x40(%rsp), %rdi
callq 0x5944
leaq 0xd0(%rsp), %rdi
callq 0x470a
addq $0x160, %rsp            # imm = 0x160
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x41d5
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2180
jmp 0x41d5
movq %rax, %rbx
jmp 0x41d5
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x41e2
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x2180
jmp 0x41e2
jmp 0x41c8
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x5944
leaq 0xd0(%rsp), %rdi
callq 0x470a
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
movq 0x6dca(%rip), %rdi      # 0xafd0
callq 0x2190
leaq 0x70(%r14), %r15
movq 0x6dca(%rip), %r12      # 0xafe0
movq (%r12), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %edx
movq %r12, %rdi
movq %r15, %rsi
callq 0x2260
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x70(%r14), %rsi
movq 0x78(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x33f8
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/moloch--[P]cli-Blackjack/./Blackjack/Card.cpp
// Function: Card::Card(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Card::Card(string cardSuit, int cardValue, string cardRank)
{
	setValue(cardValue);
	setSuit(cardSuit);
	setRank(cardRank);
	hidden = false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r12
movq %rdi, %r15
leaq 0x6a09(%rip), %rax      # 0xacc0
movq %rax, (%rdi)
leaq 0x10(%rdi), %rbx
leaq 0x20(%rdi), %rax
movq %rax, (%rsp)
movq %rax, 0x10(%rdi)
xorl %eax, %eax
movq %rax, 0x18(%rdi)
movb %al, 0x20(%rdi)
leaq 0x30(%rdi), %r14
leaq 0x40(%rdi), %rbp
movq %rbp, 0x30(%rdi)
movq %rax, 0x38(%rdi)
movb %al, 0x40(%rdi)
movl %edx, 0x8(%rdi)
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x28(%rsp), %rdi
movq %rax, %rsi
callq 0x33f8
leaq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0x20c0
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x432d
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2180
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x33f8
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x20c0
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x4370
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2180
movb $0x0, 0xc(%r15)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x43b7
movq 0x18(%rsp), %rsi
jmp 0x43aa
movq %rax, %r15
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x43b7
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2180
jmp 0x43b7
movq %rax, %r15
movq (%r14), %rdi
cmpq %rbp, %rdi
je 0x43cb
movq (%rbp), %rsi
incq %rsi
callq 0x2180
movq (%rbx), %rdi
cmpq (%rsp), %rdi
je 0x43e3
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x2180
movq %r15, %rdi
callq 0x2230
nop
// File: /workspace/github_cpp_makefile_star2_O1/moloch--[P]cli-Blackjack/./Blackjack/Card.cpp
// Function: Card::Card(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int)
Card::Card(string cardSuit, int cardValue, int cardRank)
{
	setValue(cardValue);
	setSuit(cardSuit);
	setRank(cardRank);
	hidden = false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebp
movq %rdi, %rbx
leaq 0x68a2(%rip), %rax      # 0xacc0
movq %rax, (%rdi)
leaq 0x20(%rdi), %r12
movq %r12, 0x10(%rdi)
xorl %eax, %eax
movq %rax, 0x18(%rdi)
movb %al, 0x20(%rdi)
leaq 0x30(%rdi), %r14
leaq 0x40(%rdi), %r13
movq %r13, 0x30(%rdi)
movq %rax, 0x38(%rdi)
movb %al, 0x40(%rdi)
movl %edx, 0x8(%rdi)
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x33f8
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x20c0
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x448c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2180
movq %rbx, %rdi
movl %ebp, %esi
callq 0x44fa
movb $0x0, 0xc(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbp
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x44c8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2180
jmp 0x44c8
movq %rax, %rbp
movq (%r14), %rdi
cmpq %r13, %rdi
je 0x44dc
movq (%r13), %rsi
incq %rsi
callq 0x2180
movq 0x10(%rbx), %rdi
cmpq %r12, %rdi
je 0x44f1
movq (%r12), %rsi
incq %rsi
callq 0x2180
movq %rbp, %rdi
callq 0x2230
nop
// File: /workspace/github_cpp_makefile_star2_O1/moloch--[P]cli-Blackjack/./Blackjack/Hand.cpp
// Function: Hand::getScore()
int Hand::getScore()
{
	score = 0; // Re-calculate score
	for (unsigned int index = 0; index < hand.size(); ++index)
	{
		if (!hand[index].isHidden()) // Do not include hidden values
		{
			score += hand[index].getValue();
		}
	}
	return score;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x0, 0x8(%rdi)
movq 0x18(%rdi), %rdi
cmpq %rdi, 0x20(%rbx)
je 0x4853
movl $0x1, %ebp
xorl %eax, %eax
movabsq $-0x3333333333333333, %r15 # imm = 0xCCCCCCCCCCCCCCCD
leaq (%rax,%rax,4), %r14
shlq $0x4, %r14
addq %r14, %rdi
callq 0x466e
testb %al, %al
jne 0x4837
addq 0x18(%rbx), %r14
movq %r14, %rdi
callq 0x459e
addl %eax, 0x8(%rbx)
movl %ebp, %eax
movq 0x18(%rbx), %rdi
movq 0x20(%rbx), %rcx
subq %rdi, %rcx
sarq $0x4, %rcx
imulq %r15, %rcx
incl %ebp
cmpq %rax, %rcx
ja 0x4814
movl 0x8(%rbx), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/moloch--[P]cli-Blackjack/./Blackjack/Hand.cpp
// Function: Hand::printAsciiHand()
void Hand::printAsciiHand()
{
    AsciiArt ascii;
    printAsciiHeader(ascii); // An entire line must be printed before another can start
    printAsciiTopRank(ascii);
    printAsciiSymbol(ascii);
    printAsciiBottomRank(ascii);
    printAsciiFooter(ascii);
    cout << "Total value: " << getScore() << endl;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0xf8, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x248c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x49f4
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4b16
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4d64
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x4fd4
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5222
movq 0x6658(%rip), %rdi      # 0xafd0
leaq 0x2954(%rip), %rsi      # 0x72d3
movl $0xd, %edx
callq 0x2190
movq %rbx, %rdi
callq 0x47e8
movq 0x6638(%rip), %rdi      # 0xafd0
movl %eax, %esi
callq 0x2220
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
leaq 0x8(%rsp), %rdi
callq 0x2d3e
addq $0xf8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2d3e
movq %rbx, %rdi
callq 0x2230
nop
// File: /workspace/github_cpp_makefile_star2_O1/moloch--[P]cli-Blackjack/./Blackjack/Hand.cpp
// Function: Hand::printAsciiHeader(AsciiArt&)
void Hand::printAsciiHeader(AsciiArt & ascii)
{
    for (unsigned int index = 0;index < ascii.getHeaderSize();++index)
    {
        for (unsigned int cardIndex = 0;cardIndex < hand.size();++cardIndex)
        {
            cout << ascii.getCardHeader(index) << " ";
        }
        cout << endl; // End line
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x3284
testl %eax, %eax
je 0x4ae0
xorl %ebp, %ebp
movq 0x65af(%rip), %r15      # 0xafd0
movabsq $-0x3333333333333333, %r12 # imm = 0xCCCCCCCCCCCCCCCD
movq 0x20(%r14), %rax
cmpq 0x18(%r14), %rax
je 0x4aa7
movl $0x1, %r13d
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x2de2
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r15, %rdi
callq 0x2190
movl $0x1, %edx
movq %rax, %rdi
leaq 0x2931(%rip), %rsi      # 0x739c
callq 0x2190
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x4a8c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2180
movl %r13d, %eax
movq 0x20(%r14), %rcx
subq 0x18(%r14), %rcx
sarq $0x4, %rcx
imulq %r12, %rcx
incl %r13d
cmpq %rax, %rcx
ja 0x4a3b
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
incl %ebp
movq %rbx, %rdi
callq 0x3284
cmpl %eax, %ebp
jb 0x4a2b
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x4b0e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2180
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O1/moloch--[P]cli-Blackjack/./Blackjack/Hand.cpp
// Function: Hand::printAsciiTopRank(AsciiArt&)
void Hand::printAsciiTopRank(AsciiArt & ascii)
{
    for (unsigned int cardIndex = 0;cardIndex < hand.size();++cardIndex)
    {
        if (hand[cardIndex].isHidden())
        {
            cout << ascii.getTopRank("?") << " ";
        }
        else
        {
            cout << ascii.getTopRank(getCardRank(cardIndex)) << " ";
        }
    }
    cout << endl; // End line
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %r14
movq 0x18(%rdi), %rdi
cmpq %rdi, 0x20(%r14)
je 0x4c9f
movq %rsi, %rbx
movl $0x1, %r15d
xorl %eax, %eax
leaq 0x28(%rsp), %r12
leaq 0x48(%rsp), %r13
leaq (%rax,%rax,4), %rbp
shlq $0x4, %rbp
addq %rbp, %rdi
callq 0x466e
testb %al, %al
je 0x4bf2
leaq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
movq %r12, %rdi
leaq 0x276b(%rip), %rsi      # 0x72e1
leaq 0x2765(%rip), %rdx      # 0x72e2
callq 0x36f0
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x2e82
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x642d(%rip), %rdi      # 0xafd0
callq 0x2190
movl $0x1, %edx
movq %rax, %rdi
leaq 0x27e5(%rip), %rsi      # 0x739c
callq 0x2190
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x4bd8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2180
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x4c73
movq 0x38(%rsp), %rsi
jmp 0x4c6b
addq 0x18(%r14), %rbp
movq %r13, %rdi
movq %rbp, %rsi
callq 0x464a
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x2e82
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x63ae(%rip), %rdi      # 0xafd0
callq 0x2190
movl $0x1, %edx
movq %rax, %rdi
leaq 0x2766(%rip), %rsi      # 0x739c
callq 0x2190
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x4c57
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2180
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x4c73
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x2180
movl %r15d, %eax
movq 0x18(%r14), %rdi
movq 0x20(%r14), %rcx
subq %rdi, %rcx
sarq $0x4, %rcx
movabsq $-0x3333333333333333, %rdx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rdx, %rcx
incl %r15d
cmpq %rax, %rcx
ja 0x4b4a
movq 0x632a(%rip), %rbx      # 0xafd0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x4d5b
movq %rax, %rbx
jmp 0x4d0a
movq %rax, %rbx
jmp 0x4d3f
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x4d0a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2180
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x4d5b
movq 0x58(%rsp), %rsi
jmp 0x4d53
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x4d3f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2180
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x4d5b
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2180
movq %rbx, %rdi
callq 0x2230
nop
// File: /workspace/github_cpp_makefile_star2_O1/moloch--[P]cli-Blackjack/./Blackjack/Hand.cpp
// Function: Hand::printAsciiBottomRank(AsciiArt&)
void Hand::printAsciiBottomRank(AsciiArt & ascii)
{
    for (unsigned int cardIndex = 0;cardIndex < hand.size();++cardIndex)
    {
        if (hand[cardIndex].isHidden())
        {
            cout << ascii.getBottomRank("?") << " ";
        }
        else
        {
            cout << ascii.getBottomRank(getCardRank(cardIndex)) << " ";
        }
    }
    cout << endl; // End line & flush buffer
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %r14
movq 0x18(%rdi), %rdi
cmpq %rdi, 0x20(%r14)
je 0x515d
movq %rsi, %rbx
movl $0x1, %r15d
xorl %eax, %eax
leaq 0x28(%rsp), %r12
leaq 0x48(%rsp), %r13
leaq (%rax,%rax,4), %rbp
shlq $0x4, %rbp
addq %rbp, %rdi
callq 0x466e
testb %al, %al
je 0x50b0
leaq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
movq %r12, %rdi
leaq 0x22ad(%rip), %rsi      # 0x72e1
leaq 0x22a7(%rip), %rdx      # 0x72e2
callq 0x36f0
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x2fac
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x5f6f(%rip), %rdi      # 0xafd0
callq 0x2190
movl $0x1, %edx
movq %rax, %rdi
leaq 0x2327(%rip), %rsi      # 0x739c
callq 0x2190
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x5096
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2180
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x5131
movq 0x38(%rsp), %rsi
jmp 0x5129
addq 0x18(%r14), %rbp
movq %r13, %rdi
movq %rbp, %rsi
callq 0x464a
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
movq %r13, %rdx
callq 0x2fac
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x5ef0(%rip), %rdi      # 0xafd0
callq 0x2190
movl $0x1, %edx
movq %rax, %rdi
leaq 0x22a8(%rip), %rsi      # 0x739c
callq 0x2190
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x5115
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2180
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x5131
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x2180
movl %r15d, %eax
movq 0x18(%r14), %rdi
movq 0x20(%r14), %rcx
subq %rdi, %rcx
sarq $0x4, %rcx
movabsq $-0x3333333333333333, %rdx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rdx, %rcx
incl %r15d
cmpq %rax, %rcx
ja 0x5008
movq 0x5e6c(%rip), %rbx      # 0xafd0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x5219
movq %rax, %rbx
jmp 0x51c8
movq %rax, %rbx
jmp 0x51fd
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x51c8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2180
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x5219
movq 0x58(%rsp), %rsi
jmp 0x5211
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x51fd
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2180
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x5219
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2180
movq %rbx, %rdi
callq 0x2230
nop
// File: /workspace/github_cpp_makefile_star2_O1/moloch--[P]cli-Blackjack/./Blackjack/Hand.cpp
// Function: Hand::printAsciiFooter(AsciiArt&)
void Hand::printAsciiFooter(AsciiArt & ascii)
{
    for (unsigned int index = 0;index < ascii.getFooterSize();++index)
    {
        for (unsigned int cardIndex = 0;cardIndex < hand.size();++cardIndex)
        {
            cout << ascii.getCardFooter(index) << " ";
        }
        cout << endl;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x32a6
testl %eax, %eax
je 0x530e
xorl %ebp, %ebp
movq 0x5d81(%rip), %r15      # 0xafd0
movabsq $-0x3333333333333333, %r12 # imm = 0xCCCCCCCCCCCCCCCD
movq 0x20(%r14), %rax
cmpq 0x18(%r14), %rax
je 0x52d5
movl $0x1, %r13d
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x2e32
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r15, %rdi
callq 0x2190
movl $0x1, %edx
movq %rax, %rdi
leaq 0x2103(%rip), %rsi      # 0x739c
callq 0x2190
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x52ba
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2180
movl %r13d, %eax
movq 0x20(%r14), %rcx
subq 0x18(%r14), %rcx
sarq $0x4, %rcx
imulq %r12, %rcx
incl %r13d
cmpq %rax, %rcx
ja 0x5269
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20f0
incl %ebp
movq %rbx, %rdi
callq 0x32a6
cmpl %eax, %ebp
jb 0x5259
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x533c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2180
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O1/moloch--[P]cli-Blackjack/./Blackjack/Player.cpp
// Function: Player::turn(Deck&)
void Player::turn(Deck & deck)
{
	playTurn = true;
	while (playTurn)
	{
		printCurrentHand();
		cout << "Do you want to hit or stay? ";
		getline(cin, playerInput);
		if (playerInput == "h" || playerInput == "hit" || playerInput == "Hit")
		{
			hit(deck.deal());
			playTurn = !isBust(); // If the player busts, end their turn
		}
		else
		{
			playTurn = false; // User wants to stay, end their turn
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movb $0x1, 0x8(%rdi)
leaq 0x60(%rdi), %r15
leaq 0x20(%rdi), %r12
movq 0x5339(%rip), %r13      # 0xafe0
leaq 0x8(%rsp), %rbp
movq %r15, %rdi
callq 0x4918
movl $0x1c, %edx
movq 0x5310(%rip), %rdi      # 0xafd0
leaq 0x162c(%rip), %rsi      # 0x72f3
callq 0x2190
movq (%r13), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x2160
movsbl %al, %edx
movq %r13, %rdi
movq %r12, %rsi
callq 0x2260
movq %r12, %rdi
leaq 0x1617(%rip), %rsi      # 0x7310
callq 0x2060
testl %eax, %eax
je 0x5d2c
movq %r12, %rdi
leaq 0x1606(%rip), %rsi      # 0x7312
callq 0x2060
testl %eax, %eax
je 0x5d2c
movq %r12, %rdi
leaq 0x15f7(%rip), %rsi      # 0x7316
callq 0x2060
testl %eax, %eax
je 0x5d2c
xorl %eax, %eax
jmp 0x5d58
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x6456
movq %r14, %rdi
movq %rbp, %rsi
callq 0x5a28
movq %rbp, %rdi
callq 0x4544
movq %r15, %rdi
callq 0x47e8
cmpl $0x16, %eax
setl %al
movb %al, 0x8(%r14)
testb %al, %al
jne 0x5cac
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4544
movq %rbx, %rdi
callq 0x2230