LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/Rjerk[P]ratabase/Parser.cpp
// Function: ratabase::Parser::check1(cmd_v const&)
bool Parser::check1(const cmd_v& cmd)
{
    if (cmd.obj_name.size() != 0 && cmd.params.size() == 0)
        return true;
    else {
        string reply = "Command \"" + cmd.cmd_name
             + "\" should have 1 parameter.\n";
        writeReplyBuf(reply);
        LOG_ERROR << reply;
        return false;
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rsi, %rdx
movq %rdi, %rbx
cmpq $0x0, 0x30(%rsi)
je 0x6953
movq 0x50(%rdx), %rax
cmpq 0x48(%rdx), %rax
je 0x69e0
addq $0x8, %rdx
leaq 0x49fd(%rip), %rsi      # 0xb35b
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x6c49
leaq 0x4a15(%rip), %rdx      # 0xb387
movq %rsp, %rdi
movq %r14, %rsi
callq 0x6c2a
leaq 0x20(%rsp), %rdi
callq 0x3170
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x651c
leaq 0x4999(%rip), %rsi      # 0xb332
leaq 0x4a03(%rip), %rcx      # 0xb3a3
leaq 0x20(%rsp), %rdi
pushq $0x77
popq %rdx
pushq $0x4
popq %r8
callq 0x9cd8
leaq 0x20(%rsp), %rdi
callq 0x9f26
addq $0x10, %rax
movq %rsp, %rsi
movq %rax, %rdi
callq 0x32b0
leaq 0x20(%rsp), %rdi
callq 0x9e18
movq %rsp, %rdi
callq 0x3170
xorl %eax, %eax
jmp 0x69e2
movb $0x1, %al
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
retq
movq %rax, %rbx
jmp 0x6a09
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
jmp 0x6a0c
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x9e18
movq %rsp, %rdi
callq 0x3170
movq %rbx, %rdi
callq 0x34b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Rjerk[P]ratabase/Parser.cpp
// Function: ratabase::Parser::check2(cmd_v const&)
bool Parser::check2(const cmd_v& cmd)
{
    if (cmd.obj_name.size() != 0 && cmd.params.size() == 1)
        return true;
    else {
        string reply = "Command \"" + cmd.cmd_name
             + "\" should have 2 parameters.\n";
        writeReplyBuf(reply);
        LOG_ERROR << reply;
        return false;
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rsi, %rdx
movq %rdi, %rbx
cmpq $0x0, 0x30(%rsi)
je 0x6a45
movq 0x50(%rdx), %rcx
subq 0x48(%rdx), %rcx
movb $0x1, %al
cmpq $0x20, %rcx
je 0x6ad2
addq $0x8, %rdx
leaq 0x490b(%rip), %rsi      # 0xb35b
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x6c49
leaq 0x4946(%rip), %rdx      # 0xb3aa
movq %rsp, %rdi
movq %r14, %rsi
callq 0x6c2a
leaq 0x20(%rsp), %rdi
callq 0x3170
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x651c
leaq 0x48a7(%rip), %rsi      # 0xb332
leaq 0x4935(%rip), %rcx      # 0xb3c7
leaq 0x20(%rsp), %rdi
pushq $0x4
popq %r8
movl $0x84, %edx
callq 0x9cd8
leaq 0x20(%rsp), %rdi
callq 0x9f26
addq $0x10, %rax
movq %rsp, %rsi
movq %rax, %rdi
callq 0x32b0
leaq 0x20(%rsp), %rdi
callq 0x9e18
movq %rsp, %rdi
callq 0x3170
xorl %eax, %eax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
retq
movq %rax, %rbx
jmp 0x6af9
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
jmp 0x6afc
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x9e18
movq %rsp, %rdi
callq 0x3170
movq %rbx, %rdi
callq 0x34b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Rjerk[P]ratabase/Parser.cpp
// Function: ratabase::Parser::checkMore(cmd_v const&)
bool Parser::checkMore(const cmd_v& cmd)
{
    if (cmd.obj_name.size() != 0 && cmd.params.size() > 0 &&
        cmd.params.size() % 2 == 0)
        return true;
    else {
        string reply = "Command \"" + cmd.cmd_name
             + "\" should have 4 or more parameters.\n";
        LOG_ERROR << reply;
        return false;
    }
}

// Assembly:
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rsi, %rdx
cmpq $0x0, 0x30(%rsi)
je 0x6b36
movq 0x48(%rdx), %rax
movq 0x50(%rdx), %rcx
cmpq %rax, %rcx
je 0x6b36
subl %eax, %ecx
movb $0x1, %al
andl $0x20, %ecx
je 0x6bbe
addq $0x8, %rdx
leaq 0x481a(%rip), %rsi      # 0xb35b
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x6c49
leaq 0x4879(%rip), %rdx      # 0xb3ce
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x6c2a
leaq 0x28(%rsp), %rdi
callq 0x3170
leaq 0x47bf(%rip), %rsi      # 0xb332
leaq 0x4879(%rip), %rcx      # 0xb3f3
leaq 0x28(%rsp), %rdi
pushq $0x4
popq %r8
movl $0x91, %edx
callq 0x9cd8
leaq 0x28(%rsp), %rdi
callq 0x9f26
addq $0x10, %rax
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x32b0
leaq 0x28(%rsp), %rdi
callq 0x9e18
leaq 0x8(%rsp), %rdi
callq 0x3170
xorl %eax, %eax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
retq
movq %rax, %rbx
jmp 0x6be3
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
jmp 0x6be8
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x9e18
leaq 0x8(%rsp), %rdi
callq 0x3170
movq %rbx, %rdi
callq 0x34b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Rjerk[P]ratabase/RatabaseManager.cpp
// Function: ratabase::RatabaseManager::RatabaseManager()
RatabaseManager::RatabaseManager()
{
    dbtable = new Ratabase*[DB_NUM_MAX];
    for (size_t i = 0; i < DB_NUM_MAX; ++i)
        dbtable[i] = nullptr;
    dbtable[0] = new Ratabase("default_db");
    dbcount = 1;
    current_db = dbtable[0];
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
leaq 0x18(%rdi), %rbx
movq %rbx, %rdi
callq 0x33a0
pushq $0x50
popq %rdi
callq 0x3030
movq %rax, (%r14)
xorl %eax, %eax
cmpq $0xa, %rax
je 0x7054
movq (%r14), %rcx
andq $0x0, (%rcx,%rax,8)
incq %rax
jmp 0x7041
pushq $0x48
popq %rdi
callq 0x3310
movq %rax, %r15
leaq 0x43c2(%rip), %rsi      # 0xb428
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x3130
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
callq 0x7eb8
movq (%r14), %rax
movq %r15, (%rax)
leaq 0x10(%rsp), %rdi
callq 0x3170
movq $0x1, 0x10(%r14)
movq (%r14), %rax
movq (%rax), %rax
movq %rax, 0x8(%r14)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x3170
jmp 0x70c0
movq %rax, %r14
movq %r15, %rdi
callq 0x32e0
jmp 0x70cd
movq %rax, %r14
movq %rbx, %rdi
callq 0x3090
movq %r14, %rdi
callq 0x34b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Rjerk[P]ratabase/RatabaseManager.cpp
// Function: ratabase::RatabaseManager::~RatabaseManager()
RatabaseManager::~RatabaseManager()
{
    for (size_t i = 0; i < DB_NUM_MAX; ++i) {
        if (dbtable[i] != nullptr)
            delete dbtable[i];
    }
    delete [] dbtable;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r15d, %r15d
movq (%rbx), %rdi
cmpq $0xa, %r15
je 0x7110
movq (%rdi,%r15,8), %r14
testq %r14, %r14
je 0x710b
movq %r14, %rdi
callq 0x7f20
movq %r14, %rdi
callq 0x32e0
incq %r15
jmp 0x70e9
testq %rdi, %rdi
je 0x711a
callq 0x3370
addq $0x18, %rbx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x3090
nop
// File: /workspace/github_cpp_makefile_star2_O2/Rjerk[P]ratabase/RatabaseManager.cpp
// Function: ratabase::RatabaseManager::manageDB(cmd_v const&)
bool RatabaseManager::manageDB(const cmd_v& cmd)
{
    string dbname = cmd.obj_name;
    switch (cmd.type) {
        case cmd_type::CREATE:
            return createDB(dbname);
        case cmd_type::SELECT:
            return selectDB(dbname);
        case cmd_type::DELETE:
            return deleteDB(dbname);
        case cmd_type::DISPLAY:
            return displayDB();
        default:
            return otherOperation(cmd);
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x28, %rsi
leaq 0x8(%rsp), %rdi
callq 0x33b0
movl (%r14), %eax
cmpq $0x3, %rax
ja 0x7197
leaq 0x42c1(%rip), %rcx      # 0xb418
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x71ce
jmp 0x71a2
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x76f4
jmp 0x71a2
movq %rbx, %rdi
callq 0x7914
jmp 0x71a2
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x7502
jmp 0x71a2
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7b64
movl %eax, %ebx
leaq 0x8(%rsp), %rdi
callq 0x3170
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3170
movq %rbx, %rdi
callq 0x34b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Rjerk[P]ratabase/RatabaseManager.cpp
// Function: ratabase::RatabaseManager::selectDB(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool RatabaseManager::selectDB(const string& dbname)
{
    resetMsg();
    size_t id;
    if (searchDB(dbname, id)) {
        current_db = dbtable[id];
        msg << "select " << dbname << " [" << std::to_string(id) << "] ok." << endl;
        LOG_INFO << msg.str();
        return true;
    } else {
        msg << "\"" << dbname << "\" doesn't exist." << endl;
        LOG_INFO << msg.str();
        return false;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rsi, %r15
movq %rdi, %r14
callq 0x7d72
leaq 0x20(%rsp), %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x7cf2
movl %eax, %ebx
testb %al, %al
je 0x760e
movq (%r14), %rax
movq 0x20(%rsp), %r12
movq (%rax,%r12,8), %rax
movq %rax, 0x8(%r14)
leaq 0x18(%r14), %rdi
leaq 0x3f45(%rip), %rsi      # 0xb497
callq 0x3300
movq %rax, %rdi
movq %r15, %rsi
callq 0x32b0
leaq 0x3f25(%rip), %rsi      # 0xb48e
movq %rax, %rdi
callq 0x3300
movq %rax, %r15
leaq 0x28(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x7dd8
movq %r15, %rdi
movq %r13, %rsi
callq 0x32b0
leaq 0x3efb(%rip), %rsi      # 0xb491
movq %rax, %rdi
callq 0x3300
movq %rax, %rdi
callq 0x3190
leaq 0x28(%rsp), %rdi
callq 0x3170
callq 0x9f0e
cmpl $0x2, %eax
jg 0x76a7
leaq 0x3e80(%rip), %rsi      # 0xb445
leaq 0x3ed3(%rip), %rcx      # 0xb49f
leaq 0x28(%rsp), %r15
pushq $0x51
popq %rdx
pushq $0x2
popq %r8
movq %r15, %rdi
callq 0x9cd8
movq %r15, %rdi
callq 0x9f26
movq %rax, %r15
addq $0x20, %r14
movq %rsp, %rdi
movq %r14, %rsi
callq 0x3440
addq $0x10, %r15
movq %rsp, %rsi
movq %r15, %rdi
callq 0x32b0
jmp 0x7695
leaq 0x18(%r14), %rdi
leaq 0x3d4a(%rip), %rsi      # 0xb363
callq 0x3300
movq %rax, %rdi
movq %r15, %rsi
callq 0x32b0
leaq 0x3e78(%rip), %rsi      # 0xb4a8
movq %rax, %rdi
callq 0x3300
movq %rax, %rdi
callq 0x3190
callq 0x9f0e
cmpl $0x2, %eax
jg 0x76a7
leaq 0x3df4(%rip), %rsi      # 0xb445
leaq 0x3e47(%rip), %rcx      # 0xb49f
leaq 0x28(%rsp), %r15
pushq $0x55
popq %rdx
pushq $0x2
popq %r8
movq %r15, %rdi
callq 0x9cd8
movq %r15, %rdi
callq 0x9f26
movq %rax, %r15
addq $0x20, %r14
movq %rsp, %rdi
movq %r14, %rsi
callq 0x3440
addq $0x10, %r15
movq %rsp, %rsi
movq %r15, %rdi
callq 0x32b0
movq %rsp, %rdi
callq 0x3170
leaq 0x28(%rsp), %rdi
callq 0x9e18
movl %ebx, %eax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x76c0
jmp 0x76cf
jmp 0x76cf
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3170
jmp 0x76d2
jmp 0x76cf
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x9e18
jmp 0x76eb
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x3170
movq %rbx, %rdi
callq 0x34b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Rjerk[P]ratabase/RatabaseManager.cpp
// Function: ratabase::RatabaseManager::deleteDB(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool RatabaseManager::deleteDB(const string& dbname)
{
    resetMsg();
    size_t id;
    if (searchDB(dbname, id)) {
        if (current_db == dbtable[id])
            current_db = dbtable[0];
        delete dbtable[id];
        dbtable[id] = nullptr;
        --dbcount;
        msg << "delete " << dbname << " [" << std::to_string(id) << "] ok." << endl;
        LOG_INFO << msg.str();
        return true;
    } else {
        msg << "\"" << dbname << "\" doesn't exist." << endl;
        LOG_INFO << msg.str();
        return false;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rsi, %r15
movq %rdi, %r14
callq 0x7d72
leaq 0x20(%rsp), %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x7cf2
movl %eax, %ebx
testb %al, %al
je 0x782e
movq (%r14), %rax
movq 0x20(%rsp), %r12
movq (%rax,%r12,8), %r13
cmpq %r13, 0x8(%r14)
jne 0x7746
movq (%rax), %rcx
movq %rcx, 0x8(%r14)
movq (%rax,%r12,8), %r13
testq %r13, %r13
je 0x7753
movq %r13, %rdi
callq 0x7f20
movq %r13, %rdi
callq 0x32e0
movq (%r14), %rax
andq $0x0, (%rax,%r12,8)
decq 0x10(%r14)
leaq 0x18(%r14), %rdi
leaq 0x3d47(%rip), %rsi      # 0xb4b9
callq 0x3300
movq %rax, %rdi
movq %r15, %rsi
callq 0x32b0
leaq 0x3d05(%rip), %rsi      # 0xb48e
movq %rax, %rdi
callq 0x3300
movq %rax, %r15
leaq 0x28(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x7dd8
movq %r15, %rdi
movq %r13, %rsi
callq 0x32b0
leaq 0x3cdb(%rip), %rsi      # 0xb491
movq %rax, %rdi
callq 0x3300
movq %rax, %rdi
callq 0x3190
leaq 0x28(%rsp), %rdi
callq 0x3170
callq 0x9f0e
cmpl $0x2, %eax
jg 0x78c7
leaq 0x3c60(%rip), %rsi      # 0xb445
leaq 0x3cd5(%rip), %rcx      # 0xb4c1
leaq 0x28(%rsp), %r15
pushq $0x65
popq %rdx
pushq $0x2
popq %r8
movq %r15, %rdi
callq 0x9cd8
movq %r15, %rdi
callq 0x9f26
movq %rax, %r15
addq $0x20, %r14
movq %rsp, %rdi
movq %r14, %rsi
callq 0x3440
addq $0x10, %r15
movq %rsp, %rsi
movq %r15, %rdi
callq 0x32b0
jmp 0x78b5
leaq 0x18(%r14), %rdi
leaq 0x3b2a(%rip), %rsi      # 0xb363
callq 0x3300
movq %rax, %rdi
movq %r15, %rsi
callq 0x32b0
leaq 0x3c58(%rip), %rsi      # 0xb4a8
movq %rax, %rdi
callq 0x3300
movq %rax, %rdi
callq 0x3190
callq 0x9f0e
cmpl $0x2, %eax
jg 0x78c7
leaq 0x3bd4(%rip), %rsi      # 0xb445
leaq 0x3c49(%rip), %rcx      # 0xb4c1
leaq 0x28(%rsp), %r15
pushq $0x69
popq %rdx
pushq $0x2
popq %r8
movq %r15, %rdi
callq 0x9cd8
movq %r15, %rdi
callq 0x9f26
movq %rax, %r15
addq $0x20, %r14
movq %rsp, %rdi
movq %r14, %rsi
callq 0x3440
addq $0x10, %r15
movq %rsp, %rsi
movq %r15, %rdi
callq 0x32b0
movq %rsp, %rdi
callq 0x3170
leaq 0x28(%rsp), %rdi
callq 0x9e18
movl %ebx, %eax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x78e0
jmp 0x78ef
jmp 0x78ef
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3170
jmp 0x78f2
jmp 0x78ef
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x9e18
jmp 0x790b
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x3170
movq %rbx, %rdi
callq 0x34b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Rjerk[P]ratabase/RatabaseManager.cpp
// Function: ratabase::RatabaseManager::otherOperation(cmd_v const&)
bool RatabaseManager::otherOperation(const cmd_v& cmd)
{
    resetMsg();
    if (current_db == nullptr) {
        msg << "Select or create a database to use." << endl;
        LOG_INFO << msg.str();
        return false;
    }
    msg << current_db->operate(cmd);
    LOG_INFO << msg.str();
    return true;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rsi, %r12
movq %rdi, %r14
callq 0x7d72
movq 0x8(%r14), %rbx
leaq 0x18(%r14), %r15
testq %rbx, %rbx
je 0x7c19
leaq 0x28(%rsp), %r13
movq %r13, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x7f58
movq %r15, %rdi
movq %r13, %rsi
callq 0x32b0
leaq 0x28(%rsp), %rdi
callq 0x3170
callq 0x9f0e
cmpl $0x2, %eax
jg 0x7c9f
leaq 0x3878(%rip), %rsi      # 0xb445
leaq 0x3982(%rip), %rcx      # 0xb556
leaq 0x28(%rsp), %r15
pushq $0x2
popq %r8
movq %r15, %rdi
movl $0x8a, %edx
callq 0x9cd8
movq %r15, %rdi
callq 0x9f26
movq %rax, %r15
addq $0x20, %r14
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x3440
addq $0x10, %r15
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x32b0
jmp 0x7c8b
leaq 0x3912(%rip), %rsi      # 0xb532
movq %r15, %rdi
callq 0x3300
movq %rax, %rdi
callq 0x3190
callq 0x9f0e
cmpl $0x2, %eax
jg 0x7c9f
leaq 0x3804(%rip), %rsi      # 0xb445
leaq 0x390e(%rip), %rcx      # 0xb556
leaq 0x28(%rsp), %r15
pushq $0x2
popq %r8
movq %r15, %rdi
movl $0x86, %edx
callq 0x9cd8
movq %r15, %rdi
callq 0x9f26
movq %rax, %r15
addq $0x20, %r14
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x3440
addq $0x10, %r15
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x32b0
leaq 0x8(%rsp), %rdi
callq 0x3170
leaq 0x28(%rsp), %rdi
callq 0x9e18
testq %rbx, %rbx
setne %al
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x7cbc
jmp 0x7ccd
jmp 0x7ccd
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3170
jmp 0x7cd0
jmp 0x7ccd
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x9e18
jmp 0x7ce9
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x3170
movq %rbx, %rdi
callq 0x34b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Rjerk[P]ratabase/RatabaseManager.cpp
// Function: ratabase::RatabaseManager::searchDB(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long&)
bool RatabaseManager::searchDB(const string& dbname, size_t& id)
{
    for (size_t i = 0; i < dbcount; ++i) {
        if (dbtable[i] != nullptr && dbtable[i]->getName() == dbname) {
            id = i;
            return true;
        }
    }
    id = -1;
    return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, (%rsp)
movq %rsi, %r14
movq %rdi, %r15
xorl %r13d, %r13d
leaq 0x8(%rsp), %r12
movq 0x10(%r15), %rbx
cmpq %rbx, %r13
jae 0x7d4e
movq (%r15), %rax
movq (%rax,%r13,8), %rsi
testq %rsi, %rsi
je 0x7d49
movq %r12, %rdi
callq 0x33b0
movq %r12, %rdi
movq %r14, %rsi
callq 0x5682
movl %eax, %ebp
movq %r12, %rdi
callq 0x3170
testb %bpl, %bpl
jne 0x7d53
incq %r13
jmp 0x7d12
pushq $-0x1
popq %rdx
jmp 0x7d56
movq %r13, %rdx
cmpq %rbx, %r13
setb %al
movq (%rsp), %rcx
movq %rdx, (%rcx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/Rjerk[P]ratabase/Ratabase.cpp
// Function: Ratabase::operate[abi:cxx11](cmd_v const&)
string Ratabase::operate(const cmd_v& cmd)
{
	switch (cmd.type) {
		case cmd_type::SSET:
			sset(cmd); break;
		case cmd_type::SAPP:
			sapp(cmd); break;
		case cmd_type::SLEN:
			slen(cmd); break;
		case cmd_type::SCLR:
			sclr(cmd); break;
		case cmd_type::LSET:
			lset(cmd); break;
		default:
			listOperate(cmd); break;
		case cmd_type::DSET:
			dset(cmd); break;
		case cmd_type::DADD:
		case cmd_type::DDEL:
		case cmd_type::DSIZE:
		case cmd_type::DGET:
			dictOperate(cmd); break;
	}
	return msg;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl (%rdx), %eax
addl $-0x4, %eax
cmpl $0x10, %eax
ja 0x7fc8
leaq 0x36c9(%rip), %rcx      # 0xb63c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %r14, %rdi
movq %rdx, %rsi
callq 0x84ba
addq $0x28, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x33b0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
movq %rdx, %rsi
callq 0x8130
jmp 0x7f87
movq %r14, %rdi
movq %rdx, %rsi
callq 0x8418
jmp 0x7f87
movq %r14, %rdi
movq %rdx, %rsi
callq 0x7ffc
jmp 0x7f87
movq %r14, %rdi
movq %rdx, %rsi
callq 0x831c
jmp 0x7f87
movq %r14, %rdi
movq %rdx, %rsi
callq 0x809e
jmp 0x7f87
movq %r14, %rdi
movq %rdx, %rsi
callq 0x81de
jmp 0x7f87
movq %r14, %rdi
movq %rdx, %rsi
callq 0x827a
jmp 0x7f87
// File: /workspace/github_cpp_makefile_star2_O2/Rjerk[P]ratabase/Ratabase.cpp
// Function: Ratabase::sset(cmd_v const&)
void Ratabase::sset(const cmd_v& cmd)
{
	Value v;
	v.set(STRING, cmd);
	addVal(cmd.obj_name.c_str(), v);
	setMsg("sset ok.");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x8dc4
pushq $0x1
popq %rsi
movq %r15, %rdi
movq %r14, %rdx
callq 0x8e14
movq 0x28(%r14), %rsi
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x8af4
leaq 0x366e(%rip), %rsi      # 0xb6ac
leaq 0x20(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x3130
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x8afe
leaq 0x20(%rsp), %rdi
callq 0x3170
leaq 0x10(%rsp), %rdi
callq 0x8dce
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x3170
jmp 0x808c
jmp 0x8089
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x8dce
movq %rbx, %rdi
callq 0x34b0
// File: /workspace/github_cpp_makefile_star2_O2/Rjerk[P]ratabase/Ratabase.cpp
// Function: Ratabase::sapp(cmd_v const&)
void Ratabase::sapp(const cmd_v& cmd)
{
	Value v;
	getVal(cmd.obj_name.c_str(), v);
	v.appString(cmd.params.front());
	setMsg(v.getString());
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
movq %r15, %rdi
callq 0x8dc4
movq 0x28(%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x8b3c
movq 0x48(%r14), %rsi
movq %rsp, %rdi
callq 0x8fc8
movq 0x8(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x33b0
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x8afe
leaq 0x10(%rsp), %rdi
callq 0x3170
movq %rsp, %rdi
callq 0x8dce
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x3170
jmp 0x811f
jmp 0x811c
movq %rax, %rbx
movq %rsp, %rdi
callq 0x8dce
movq %rbx, %rdi
callq 0x34b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Rjerk[P]ratabase/Ratabase.cpp
// Function: Ratabase::sclr(cmd_v const&)
void Ratabase::sclr(const cmd_v& cmd)
{
	Value v;
	getVal(cmd.obj_name.c_str(), v);
	v.clearString();
	setMsg("\"\"");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x8dc4
movq 0x28(%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x8b3c
leaq 0x10(%rsp), %rdi
callq 0x9096
leaq 0x349b(%rip), %rsi      # 0xb6b5
leaq 0x20(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x3130
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x8afe
leaq 0x20(%rsp), %rdi
callq 0x3170
leaq 0x10(%rsp), %rdi
callq 0x8dce
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x3170
jmp 0x8268
jmp 0x8265
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x8dce
movq %rbx, %rdi
callq 0x34b0
// File: /workspace/github_cpp_makefile_star2_O2/Rjerk[P]ratabase/Ratabase.cpp
// Function: Ratabase::lset(cmd_v const&)
void Ratabase::lset(const cmd_v& cmd)
{
	Value v;
	v.set(LIST, cmd);
	addVal(cmd.obj_name.c_str(), v);
	setMsg("lset ok.");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x8dc4
pushq $0x2
popq %rsi
movq %r15, %rdi
movq %r14, %rdx
callq 0x8e14
movq 0x28(%r14), %rsi
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x8af4
leaq 0x33fc(%rip), %rsi      # 0xb6b8
leaq 0x20(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x3130
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x8afe
leaq 0x20(%rsp), %rdi
callq 0x3170
leaq 0x10(%rsp), %rdi
callq 0x8dce
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x3170
jmp 0x830a
jmp 0x8307
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x8dce
movq %rbx, %rdi
callq 0x34b0
// File: /workspace/github_cpp_makefile_star2_O2/Rjerk[P]ratabase/Ratabase.cpp
// Function: Ratabase::listOperate(cmd_v const&)
void Ratabase::listOperate(const cmd_v& cmd)
{
	Value v;
	getVal(cmd.obj_name.c_str(), v);
	switch (cmd.type) {
		case cmd_type::LPUSH:
			lpush(v, cmd.params.front()); break;
		case cmd_type::LPOP:
			lpop(v); break;
		case cmd_type::LSIZE:
			lsize(v); break;
		case cmd_type::LIDX:
			lidx(v, cmd.params.front()); break;
		case cmd_type::LPUT:
			lput(v, (size_t)std::stoi(cmd.params.front()), cmd.params[1]); break;
		case cmd_type::LGET:
			lget(v, (size_t)std::stoi(cmd.params.front())); break;
		case cmd_type::LDEL:
			ldel(v, cmd.params.front()); break;
		default:
			break;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
movq %r15, %rdi
callq 0x8dc4
movq 0x28(%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x8b3c
movl (%r14), %eax
addl $-0x9, %eax
cmpl $0x6, %eax
ja 0x83f3
leaq 0x3325(%rip), %rcx      # 0xb680
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x48(%r14), %rdx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x8564
jmp 0x83f3
movq 0x48(%r14), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x8b45
movslq %eax, %rdx
movq 0x48(%r14), %rcx
addq $0x20, %rcx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x8702
jmp 0x83f3
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x862e
jmp 0x83f3
movq 0x48(%r14), %rdx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x8682
jmp 0x83f3
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x85bc
jmp 0x83f3
movq 0x48(%r14), %rdi
pushq $0xa
popq %rdx
xorl %esi, %esi
callq 0x8b45
movslq %eax, %rdx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x875e
jmp 0x83f3
movq 0x48(%r14), %rdx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x87a8
movq %rsp, %rdi
callq 0x8dce
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x8dce
movq %rbx, %rdi
callq 0x34b0
// File: /workspace/github_cpp_makefile_star2_O2/Rjerk[P]ratabase/Ratabase.cpp
// Function: Ratabase::dset(cmd_v const&)
void Ratabase::dset(const cmd_v& cmd)
{
	Value v;
	v.set(DICT, cmd);
	addVal(cmd.obj_name.c_str(), v);
	setMsg("dset ok.");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x8dc4
pushq $0x3
popq %rsi
movq %r15, %rdi
movq %r14, %rdx
callq 0x8e14
movq 0x28(%r14), %rsi
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x8af4
leaq 0x3267(%rip), %rsi      # 0xb6c1
leaq 0x20(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x3130
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x8afe
leaq 0x20(%rsp), %rdi
callq 0x3170
leaq 0x10(%rsp), %rdi
callq 0x8dce
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x3170
jmp 0x84a8
jmp 0x84a5
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x8dce
movq %rbx, %rdi
callq 0x34b0
// File: /workspace/github_cpp_makefile_star2_O2/Rjerk[P]ratabase/Ratabase.cpp
// Function: Ratabase::dictOperate(cmd_v const&)
void Ratabase::dictOperate(const cmd_v& cmd)
{
	Value v;
	getVal(cmd.obj_name.c_str(), v);
	switch (cmd.type) {
		case cmd_type::DADD:
			dadd(v, cmd.params); break;
		case cmd_type::DDEL:
			ddel(v, cmd.params.front()); break;
		case cmd_type::DSIZE:
			dsize(v); break;
		case cmd_type::DGET:
			dget(v, cmd.params.front()); break;
		default:
			return ;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
movq %r15, %rdi
callq 0x8dc4
movq 0x28(%r14), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x8b3c
movl (%r14), %eax
addl $-0x11, %eax
cmpl $0x3, %eax
ja 0x853f
leaq 0x31a7(%rip), %rcx      # 0xb69c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
addq $0x48, %r14
movq %rsp, %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x882c
jmp 0x853f
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x8908
jmp 0x853f
movq 0x48(%r14), %rdx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x895c
jmp 0x853f
movq 0x48(%r14), %rdx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x8884
movq %rsp, %rdi
callq 0x8dce
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x8dce
movq %rbx, %rdi
callq 0x34b0
// File: /workspace/github_cpp_makefile_star2_O2/Rjerk[P]ratabase/Ratabase.cpp
// Function: Ratabase::lidx(Value const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Ratabase::lidx(const Value& v, const string& elem)
{
	int idx = v.indexList(elem);
	if (idx != -1)
		setMsg(std::to_string(idx));
	else
		setMsg(elem+" doesn't exist.");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0x9128
cmpl $-0x1, %eax
je 0x86bb
movq %rsp, %r14
movq %r14, %rdi
movl %eax, %esi
callq 0x8b6e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8afe
jmp 0x86db
leaq 0x2de7(%rip), %rdx      # 0xb4a9
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x8bc7
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8afe
movq %rsp, %rdi
callq 0x3170
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x86ef
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3170
movq %rbx, %rdi
callq 0x34b0
// File: /workspace/github_cpp_makefile_star2_O2/Rjerk[P]ratabase/Ratabase.cpp
// Function: Ratabase::dget(Value&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Ratabase::dget(Value& v, const string& key)
{
	Value elem;
	if (v.getDict(key, elem)) {
		setMsg("(" + key + ", " + elem.getString() + ")");
	} else {
		setMsg(key+" doesn't exist.");
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x28(%rsp), %r12
movq %r12, %rdi
callq 0x8dc4
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x925e
testb %al, %al
je 0x8a3e
leaq 0x2d2d(%rip), %rsi      # 0xb6ca
leaq 0x58(%rsp), %rdi
movq %r14, %rdx
callq 0x6c49
leaq 0x2d1b(%rip), %rdx      # 0xb6cc
leaq 0x78(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x6c2a
movq 0x30(%rsp), %rsi
leaq 0x38(%rsp), %rdi
callq 0x33b0
leaq 0x98(%rsp), %rdi
leaq 0x78(%rsp), %rsi
leaq 0x38(%rsp), %rdx
callq 0x8bff
leaq 0x2ce2(%rip), %rdx      # 0xb6cf
leaq 0x8(%rsp), %rdi
leaq 0x98(%rsp), %rsi
callq 0x6c2a
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x8afe
leaq 0x8(%rsp), %rdi
callq 0x3170
leaq 0x98(%rsp), %rdi
callq 0x3170
leaq 0x38(%rsp), %rdi
callq 0x3170
leaq 0x78(%rsp), %rdi
callq 0x3170
leaq 0x58(%rsp), %rdi
jmp 0x8a64
leaq 0x2a64(%rip), %rdx      # 0xb4a9
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x8bc7
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x8afe
leaq 0x8(%rsp), %rdi
callq 0x3170
leaq 0x28(%rsp), %rdi
callq 0x8dce
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3170
jmp 0x8a94
movq %rax, %rbx
leaq 0x98(%rsp), %rdi
callq 0x3170
jmp 0x8aa6
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x3170
jmp 0x8ab5
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0x3170
jmp 0x8ace
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x8ad3
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x3170
jmp 0x8ae1
jmp 0x8ade
jmp 0x8ade
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x8dce
movq %rbx, %rdi
callq 0x34b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Rjerk[P]ratabase/Value.cpp
// Function: Value::set(int, cmd_v const&)
void Value::set(int type_, const cmd_v& cmd)
{
    type = type_;
    switch (type) {
        case STRING:
            setString(cmd.params.front()); break;
        case LIST:
            setList(cmd.obj_name.c_str(), cmd.params); break;
        case DICT:
            setDict(cmd.params); break;
        default:
            return ;
    }
}

// Assembly:
movl %esi, (%rdi)
cmpl $0x3, %esi
je 0x8e3b
cmpl $0x2, %esi
je 0x8e2e
cmpl $0x1, %esi
jne 0x8e47
movq 0x48(%rdx), %rsi
jmp 0x8e48
movq 0x28(%rdx), %rsi
addq $0x48, %rdx
jmp 0x8e86
addq $0x48, %rdx
movq %rdx, %rsi
jmp 0x8f46
retq
// File: /workspace/github_cpp_makefile_star2_O2/Rjerk[P]ratabase/Value.cpp
// Function: Value::setList(char const*, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
void Value::setList(const char* key, const vector<string>& params)
{
    List* lst = new List(string(key));
    for (auto s : params) {
        lst->push(s);
    }
    val = static_cast<void*> (lst);
    lst = nullptr;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
pushq $0x38
popq %rdi
callq 0x3310
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %r12, %rsi
callq 0x3130
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x97cc
leaq 0x10(%rsp), %r12
movq %r12, %rdi
callq 0x3170
movq (%r15), %r13
movq 0x8(%r15), %r15
cmpq %r15, %r13
je 0x8f03
movq %r12, %rdi
movq %r13, %rsi
callq 0x33b0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x9840
movq %r12, %rdi
callq 0x3170
addq $0x20, %r13
jmp 0x8eda
movq %rbx, 0x8(%r14)
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x3170
jmp 0x8f27
movq %rax, %r14
movq %rbx, %rdi
callq 0x32e0
jmp 0x8f3e
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x3170
movq %r14, %rdi
callq 0x34b0
// File: /workspace/github_cpp_makefile_star2_O2/Rjerk[P]ratabase/Value.cpp
// Function: Value::setDict(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
void Value::setDict(const vector<string>& params)
{
    Hashtable* dict = new Hashtable();

    for (vector<string>::const_iterator p = params.cbegin(), q = p+1;
                        p != params.cend();
                        p += 2, q += 2) {
        Value v;
        v.setString(*q);
        dict->put(p->c_str(), v);
    }

    val = static_cast<void*>(dict);
    dict = nullptr;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x18
popq %rdi
callq 0x3310
movq %rax, %r15
movq %rax, %rdi
callq 0x9306
movq (%r14), %r13
movq %rsp, %r12
cmpq 0x8(%r14), %r13
je 0x8fa3
andl $0x0, (%rsp)
leaq 0x20(%r13), %rsi
andq $0x0, 0x8(%rsp)
movq %r12, %rdi
callq 0x8e48
movq (%r13), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0x9418
addq $0x40, %r13
jmp 0x8f72
movq %r15, 0x8(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0x32e0
movq %rbx, %rdi
callq 0x34b0
// File: /workspace/github_cpp_makefile_star2_O2/Rjerk[P]ratabase/Value.cpp
// Function: Value::freeValue()
void Value::freeValue()
{
    switch (type) {
        case STRING:
            delete (string*)val;
            break;
        case LIST:
            delete (List*)val;
            break;
        case DICT:
            delete (Hashtable*)val;
            break;
        default:
            break;
    }
}

// Assembly:
pushq %rbx
movl (%rdi), %eax
cmpl $0x3, %eax
je 0x907a
cmpl $0x2, %eax
je 0x9067
cmpl $0x1, %eax
jne 0x9094
movq 0x8(%rdi), %rbx
testq %rbx, %rbx
je 0x908b
movq %rbx, %rdi
callq 0x3170
jmp 0x908b
movq 0x8(%rdi), %rbx
testq %rbx, %rbx
je 0x908b
movq %rbx, %rdi
callq 0x97e4
jmp 0x908b
movq 0x8(%rdi), %rbx
testq %rbx, %rbx
je 0x908b
movq %rbx, %rdi
callq 0x930e
movq %rbx, %rdi
popq %rbx
jmp 0x32e0
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/Rjerk[P]ratabase/Value.cpp
// Function: Value::getList[abi:cxx11](unsigned long) const
string Value::getList(size_t pos) const
{
    List* lst = static_cast<List*>(val);
    string s;
    if (lst->get(pos, s)) {
        return s;
    } else {
        return string();
    }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x8(%rsi), %rdi
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
andq $0x0, -0x8(%r14)
movb $0x0, (%r14)
leaq 0x8(%rsp), %rax
movq %rdx, %rsi
movq %rax, %rdx
callq 0x9a0a
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
testb %al, %al
je 0x918f
movq 0x8(%rsp), %rax
cmpq %r14, %rax
je 0x919b
movq %rax, (%rbx)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rbx)
jmp 0x91a2
movq %rbx, %rax
addq $0x8, %rax
movq %rcx, %r14
jmp 0x91b2
movups (%r14), %xmm0
movups %xmm0, (%rcx)
leaq 0x10(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x8(%rbx)
movq %r14, -0x8(%rax)
andq $0x0, (%rax)
movb $0x0, (%r14)
leaq 0x8(%rsp), %rdi
callq 0x3170
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3170
movq %rbx, %rdi
callq 0x34b0
// File: /workspace/github_cpp_makefile_star2_O2/Rjerk[P]ratabase/Value.cpp
// Function: Value::addDict(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
void Value::addDict(const vector<string>& params)
{
    Hashtable* dict = static_cast<Hashtable*>(val);
    for (vector<string>::const_iterator p = params.cbegin(), q = p+1;
                        p != params.cend();
                        p += 2, q += 2) {
        Value v;
        v.setString(*q);
        dict->put(p->c_str(), v);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq 0x8(%rdi), %r14
movq (%rsi), %r12
leaq 0x8(%rsp), %r15
cmpq 0x8(%rbx), %r12
je 0x923b
andl $0x0, 0x8(%rsp)
leaq 0x20(%r12), %rsi
andq $0x0, 0x10(%rsp)
movq %r15, %rdi
callq 0x8e48
movq (%r12), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x9418
addq $0x40, %r12
jmp 0x9208
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Rjerk[P]ratabase/Hash.cpp
// Function: Hashtable::~Hashtable()
Hashtable::~Hashtable()
{
	for (size_t i = 0; i < tablesz; ++i) {
    	Hashnode* entry = table[i];
        while (entry != nullptr) {
            Hashnode* prev = entry->getNext();
            entry = entry->getNext();
            delete prev;
        }
        table[i] = nullptr;
    }
    delete [] table;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r15d, %r15d
movq 0x10(%rbx), %rdi
cmpq (%rbx), %r15
jae 0x9354
movq (%rdi,%r15,8), %r14
testq %r14, %r14
je 0x9346
movq 0x18(%r14), %r14
testq %r14, %r14
je 0x933c
movq %r14, %rdi
callq 0x96ee
movq %r14, %rdi
callq 0x32e0
jmp 0x9326
movq 0x10(%rbx), %rax
andq $0x0, (%rax,%r15,8)
incq %r15
jmp 0x9319
testq %rdi, %rdi
je 0x9363
popq %rbx
popq %r14
popq %r15
jmp 0x3370
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Rjerk[P]ratabase/Hash.cpp
// Function: Hashtable::hashFunc(char const*)
unsigned Hashtable::hashFunc(const char* s) // fnv1a hash.
{
    unsigned hashvalue = 0x811C9DC5; // 2166136261 as seed.
    const unsigned fnv_prime = 0x01000193; // 16777619
    while (*s) {
        hashvalue = (*s++ ^ hashvalue) * fnv_prime;
    }
    return hashvalue;
}

// Assembly:
movl $0x811c9dc5, %eax       # imm = 0x811C9DC5
movsbl (%rsi), %ecx
testl %ecx, %ecx
je 0x9383
incq %rsi
xorl %ecx, %eax
imull $0x1000193, %eax, %eax  # imm = 0x1000193
jmp 0x936f
retq
// File: /workspace/github_cpp_makefile_star2_O2/Rjerk[P]ratabase/Hash.cpp
// Function: Hashtable::get(char const*, Value&)
bool Hashtable::get(const char* key, Value& value)
{
    Hashnode* entry = table[getSlot(key)];

    while (entry != nullptr) {
        if (strcmp(entry->getKey(), key) == 0) {
            value = entry->getValue();
            return true;
        }
        entry = entry->getNext();
    }
    return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq 0x10(%rdi), %r15
callq 0x9384
leaq (%r15,%rax,8), %r15
movq (%r15), %r15
testq %r15, %r15
je 0x93f5
movq (%r15), %rdi
movq %r14, %rsi
callq 0x33c0
testl %eax, %eax
je 0x93d3
addq $0x18, %r15
jmp 0x93b6
leaq 0x8(%r15), %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x8dd0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8dde
movq %rsp, %rdi
callq 0x8dce
testq %r15, %r15
setne %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x8dce
movq %rbx, %rdi
callq 0x34b0
// File: /workspace/github_cpp_makefile_star2_O2/Rjerk[P]ratabase/Hash.cpp
// Function: Hashtable::put(char const*, Value const&)
void Hashtable::put(const char* key, const Value& value)
{
	size_t index = getSlot(key);
    ++elemsz;
    Hashnode* entry = table[index];
    Hashnode* prev = nullptr;

    while (entry != nullptr && strcmp(entry->getKey(), key) != 0) {
        prev = entry;
        entry = entry->getNext();
    }

    if (entry != nullptr) {
        entry->setValue(value);
    } else {
        entry = new Hashnode(key, value);
        if (prev == nullptr) { // empty slot
            table[index] = entry;
        } else {
            prev->setNext(entry); // end of linklist.
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
callq 0x9384
movq %rax, %r14
incq 0x8(%rbx)
shlq $0x3, %rax
addq 0x10(%rbx), %rax
xorl %ebp, %ebp
movq (%rax), %r13
testq %r13, %r13
je 0x9463
movq (%r13), %rdi
movq %r12, %rsi
callq 0x33c0
testl %eax, %eax
je 0x9487
leaq 0x18(%r13), %rax
movq %r13, %rbp
jmp 0x9442
pushq $0x20
popq %rdi
callq 0x3310
movq %rax, %r13
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x976a
testq %rbp, %rbp
je 0x94a0
movq %r13, 0x18(%rbp)
jmp 0x94a8
movq %r13, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x971c
movq 0x10(%rbx), %rax
movq %r13, (%rax,%r14,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r13, %rdi
callq 0x32e0
movq %rbx, %rdi
callq 0x34b0
// File: /workspace/github_cpp_makefile_star2_O2/Rjerk[P]ratabase/Hash.cpp
// Function: Hashtable::remove(char const*)
bool Hashtable::remove(const char* key)
{
	size_t index = getSlot(key);
    Hashnode* prev = nullptr;
    Hashnode* entry = table[index];

    while (entry != nullptr && strcmp(entry->getKey(), key) != 0) {
   		prev = entry;
        entry = entry->getNext();
    }

    if (entry == nullptr) { // not found
        return false;
    } else {
        if (prev == nullptr) {// remove the element in slot
            table[index] = entry->getNext();
        } else {
            prev->setNext(entry->getNext());
        }
        delete entry;
        --elemsz;
        return true;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x9384
movq %rax, %r15
shlq $0x3, %r15
addq 0x10(%rbx), %r15
xorl %r13d, %r13d
movq %r15, %rax
movq (%rax), %r12
testq %r12, %r12
je 0x9538
movq (%r12), %rdi
movq %r14, %rsi
callq 0x33c0
testl %eax, %eax
je 0x9511
leaq 0x18(%r12), %rax
movq %r12, %r13
jmp 0x94ef
leaq 0x18(%r13), %rax
testq %r13, %r13
movq 0x18(%r12), %rcx
cmoveq %r15, %rax
movq %rcx, (%rax)
movq %r12, %rdi
callq 0x96ee
movq %r12, %rdi
callq 0x32e0
decq 0x8(%rbx)
testq %r12, %r12
setne %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/Rjerk[P]ratabase/Hash.cpp
// Function: Hashtable::print[abi:cxx11]() const
string Hashtable::print() const
{
    std::ostringstream os;
    os << "{\n";
    for (size_t i = 0; i < tablesz; ++i) {
        const Hashnode* entry = table[i];
        while (entry != nullptr) {
            os << "(" << string(entry->getKey())
               << ": " << entry->getValue().getString() << ")\n";
            entry = entry->getNext();
        }
    }
    os << "}";
    return os.str();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1e8, %rsp            # imm = 0x1E8
movq %rsi, 0x10(%rsp)
movq %rdi, %r14
leaq 0x70(%rsp), %rbx
movq %rbx, %rdi
callq 0x33a0
leaq 0x2234(%rip), %rsi      # 0xb7a9
movq %rbx, %rdi
callq 0x3300
movq %r14, 0x8(%rsp)
xorl %ecx, %ecx
leaq 0x50(%rsp), %r13
leaq 0x20(%rsp), %r14
leaq 0x30(%rsp), %r15
leaq 0x2212(%rip), %r12      # 0xb7ac
movq 0x10(%rsp), %rax
cmpq (%rax), %rcx
jae 0x9663
movq %rcx, 0x18(%rsp)
leaq (,%rcx,8), %rbx
addq 0x10(%rax), %rbx
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x9656
leaq 0x70(%rsp), %rdi
leaq 0x20f9(%rip), %rsi      # 0xb6ca
callq 0x3300
movq %rax, %rbp
movq (%rbx), %rsi
movq %r13, %rdi
leaq 0x7(%rsp), %rdx
callq 0x3130
movq %rbp, %rdi
movq %r13, %rsi
callq 0x32b0
movq %rax, %rdi
leaq 0x1c2d(%rip), %rsi      # 0xb22b
callq 0x3300
movq %rax, %rbp
leaq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x8dd0
movq 0x28(%rsp), %rsi
movq %r15, %rdi
callq 0x33b0
movq %rbp, %rdi
movq %r15, %rsi
callq 0x32b0
movq %rax, %rdi
movq %r12, %rsi
callq 0x3300
movq %r15, %rdi
callq 0x3170
movq %r14, %rdi
callq 0x8dce
movq %r13, %rdi
callq 0x3170
addq $0x18, %rbx
jmp 0x95b9
movq 0x18(%rsp), %rcx
incq %rcx
jmp 0x959a
leaq 0x2145(%rip), %rsi      # 0xb7af
leaq 0x70(%rsp), %rdi
callq 0x3300
movq 0x8(%rsp), %rbx
leaq 0x78(%rsp), %rsi
movq %rbx, %rdi
callq 0x3440
leaq 0x70(%rsp), %rdi
callq 0x3090
movq %rbx, %rax
addq $0x1e8, %rsp            # imm = 0x1E8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x96b0
jmp 0x96b5
movq %rax, %rbx
jmp 0x96c7
jmp 0x96b0
movq %rax, %rbx
jmp 0x96db
movq %rax, %rbx
jmp 0x96d1
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x3170
leaq 0x20(%rsp), %rdi
callq 0x8dce
leaq 0x50(%rsp), %rdi
callq 0x3170
leaq 0x70(%rsp), %rdi
callq 0x3090
movq %rbx, %rdi
callq 0x34b0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Rjerk[P]ratabase/List.cpp
// Function: List::~List()
List::~List()
{
    while (head != tail) {
        head = head->next;
        delete head->prev;
    }
    delete tail;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x28(%rbx), %rax
movq 0x30(%rbx), %r14
cmpq %r14, %rax
je 0x981b
movq 0x28(%rax), %rax
movq %rax, 0x28(%rbx)
movq 0x20(%rax), %r14
testq %r14, %r14
je 0x9811
movq %r14, %rdi
callq 0x8b62
movq %r14, %rdi
callq 0x32e0
jmp 0x97eb
testq %rax, %rax
je 0x9828
movq %r14, %rdi
callq 0x8b62
movq %r14, %rdi
callq 0x32e0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3170
nop
// File: /workspace/github_cpp_makefile_star2_O2/Rjerk[P]ratabase/List.cpp
// Function: List::push(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void List::push(const string& s)
{
    ListNode* node = new ListNode();
    node->s = s;
    if (sz == 0) {
        head = tail = node;
    } else {
        tail->next = node;
        node->prev = tail;
        tail = node;
        node = nullptr;
    }
    ++sz;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
pushq $0x30
popq %rdi
callq 0x3310
movq %rax, %r14
movq %rax, %rdi
callq 0x9c32
movq %r14, %rdi
movq %r15, %rsi
callq 0x31c0
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0x9883
leaq 0x30(%rbx), %rcx
movq (%rcx), %rdx
movq %r14, 0x28(%rdx)
movq %rdx, 0x20(%r14)
jmp 0x988b
movq %r14, 0x30(%rbx)
leaq 0x28(%rbx), %rcx
movq %r14, (%rcx)
incq %rax
movq %rax, 0x20(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x32e0
movq %rbx, %rdi
callq 0x34b0
// File: /workspace/github_cpp_makefile_star2_O2/Rjerk[P]ratabase/List.cpp
// Function: List::pop()
ListNode List::pop()
{
    ListNode* node = head;
    if (sz == 0) {
        return ListNode();
    } else if (sz == 1){
        head = tail = nullptr;
        --sz;
        return *node;
    } else {
        head = head->next;
        node->next = nullptr;
        head->prev = nullptr;
        --sz;
        return *node;
    }
}

// Assembly:
pushq %rbx
movq %rsi, %rax
movq %rdi, %rbx
movq 0x20(%rsi), %rcx
movq 0x28(%rsi), %rsi
cmpq $0x1, %rcx
je 0x98d2
testq %rcx, %rcx
jne 0x98e3
movq %rbx, %rdi
callq 0x9c32
jmp 0x9904
addq $0x20, %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
andq $0x0, 0x10(%rax)
jmp 0x98fc
movq 0x28(%rsi), %rdx
movq %rdx, 0x28(%rax)
andq $0x0, 0x28(%rsi)
andq $0x0, 0x20(%rdx)
decq %rcx
movq %rcx, 0x20(%rax)
movq %rbx, %rdi
callq 0x9c58
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Rjerk[P]ratabase/List.cpp
// Function: List::index(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
int List::index(const string& s) const
{
    ListNode* p = head;
    size_t i = 0;
    while (p->next != nullptr) {
        if (p->s == s) {
            return (int)i;
        }
        ++i;
        p = p->next;
    }
    return -1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
addq $0x28, %r15
xorl %ebp, %ebp
pushq $-0x1
popq %rbx
movq (%r15), %r15
cmpq $0x0, 0x28(%r15)
je 0x9943
movq %r15, %rdi
movq %r14, %rsi
callq 0x5682
testb %al, %al
jne 0x9941
addq $0x28, %r15
incl %ebp
jmp 0x9920
movl %ebp, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq