LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: sharmaeklavya2[P]ddos-on-anycast/src/simulate.cpp
// Function: ArgSpec::set_from_string(char const*)
void set_from_string(const char* s) {
        val_s = s;
        if(type == 'i') {
            val_i = coalesce(atoi(s), defval_i, zero_is_null);
        }
        else if(type == 'f') {
            val_f = coalesce(atof(s), defval_f, zero_is_null);
        }
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x8(%rsp), %rsi
addq $0x58, %rdi
callq 0x21f0
movq (%rsp), %rax
movsbl 0x20(%rax), %eax
cmpl $0x69, %eax
jne 0x2306d
movq 0x8(%rsp), %rdi
callq 0x2260
movl %eax, %edi
movq (%rsp), %rax
movl 0x48(%rax), %esi
movb 0x78(%rax), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x22b10
movl %eax, %ecx
movq (%rsp), %rax
movl %ecx, 0x50(%rax)
jmp 0x230a5
movq (%rsp), %rax
movsbl 0x20(%rax), %eax
cmpl $0x66, %eax
jne 0x230a3
movq 0x8(%rsp), %rdi
callq 0x21e0
movq (%rsp), %rax
movsd 0x48(%rax), %xmm1
movb 0x78(%rax), %al
andb $0x1, %al
movzbl %al, %edi
callq 0x22b70
movq (%rsp), %rax
movsd %xmm0, 0x50(%rax)
jmp 0x230a5
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: sharmaeklavya2[P]ddos-on-anycast/src/lib/graph_gen.hpp
// Function: NormalOrderGraphGen::operator()(std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>&, int)
virtual int operator()(ipvec& l, int seed) {
        rng_t rng(seed);
        rng_t rng2(rng());
        graph_gen.n = std::max(1, int(n * std::normal_distribution<double>(1.0, sigma)(rng2)));
        return graph_gen(l, rng());
    }

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movl %edx, 0x64(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
movslq 0x64(%rsp), %rsi
leaq 0x58(%rsp), %rdi
callq 0xa4a0
leaq 0x58(%rsp), %rdi
callq 0xa4d0
movq %rax, %rsi
leaq 0x50(%rsp), %rdi
callq 0xa4a0
movq 0x10(%rsp), %rax
movl $0x1, 0x4c(%rsp)
cvtsi2sdl 0x8(%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rax), %xmm1
leaq 0x28(%rsp), %rdi
movsd 0x57fc(%rip), %xmm0     # 0x29488
callq 0xb310
leaq 0x28(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0xb360
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, 0x48(%rsp)
leaq 0x4c(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0xb2d0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movl (%rcx), %edx
movq 0x18(%rax), %rcx
movl %edx, 0x8(%rcx)
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x58(%rsp), %rdi
callq 0xa4d0
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl %eax, %edx
movq (%rdi), %rax
callq *(%rax)
addq $0x78, %rsp
retq
nopl (%rax,%rax)
// File: Rjerk[P]ratabase/Server.cpp
// Function: ratabase::Server::Server(int)
Server::Server(int port):
    port_(port)
{
    serverInit();
    rm_ = std::unique_ptr<RatabaseManager>(new RatabaseManager());
    parser_ = std::unique_ptr<Parser>(new Parser());
    LOG_DEBUG << "ctor[" << this << "]";
}

// Assembly:
subq $0x218, %rsp            # imm = 0x218
movq %rdi, 0x210(%rsp)
movl %esi, 0x20c(%rsp)
movq 0x210(%rsp), %rdi
movq %rdi, 0x58(%rsp)
movl 0x20c(%rsp), %eax
movl %eax, (%rdi)
addq $0x10, %rdi
movq %rdi, 0x40(%rsp)
callq 0x92c0
movq 0x58(%rsp), %rdi
addq $0x18, %rdi
movq %rdi, 0x48(%rsp)
callq 0x92f0
movq 0x58(%rsp), %rdi
addq $0x20, %rdi
movq %rdi, 0x50(%rsp)
callq 0x9320
movq 0x58(%rsp), %rdi
callq 0x80e0
jmp 0x7eec
movl $0x190, %edi            # imm = 0x190
callq 0x33a0
movq %rax, 0x38(%rsp)
jmp 0x7efd
movq 0x38(%rsp), %rdi
callq 0xc110
jmp 0x7f09
movq 0x38(%rsp), %rsi
leaq 0x1f0(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x9360
movq 0x58(%rsp), %rdi
movq 0x28(%rsp), %rsi
addq $0x10, %rdi
callq 0x9390
movq 0x28(%rsp), %rdi
callq 0x93c0
movl $0xd0, %edi
callq 0x33a0
movq %rax, 0x30(%rsp)
jmp 0x7f4e
movq 0x30(%rsp), %rdi
callq 0xa050
jmp 0x7f5a
movq 0x30(%rsp), %rsi
leaq 0x1e8(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x9420
movq 0x58(%rsp), %rdi
movq 0x18(%rsp), %rsi
addq $0x18, %rdi
callq 0x9450
movq 0x18(%rsp), %rdi
callq 0x9480
callq 0x12170
movl %eax, 0x24(%rsp)
jmp 0x7f99
movl 0x24(%rsp), %eax
cmpl $0x1, %eax
jg 0x80a1
leaq 0xc0d0(%rip), %rsi      # 0x1407d
leaq 0xc0db(%rip), %rcx      # 0x1408f
leaq 0x60(%rsp), %rdi
movl $0x1b, %edx
movl $0x1, %r8d
callq 0x11e00
jmp 0x7fcb
leaq 0x60(%rsp), %rdi
callq 0x121a0
movq %rax, 0x10(%rsp)
jmp 0x7fdc
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
leaq 0xc09c(%rip), %rsi      # 0x14088
callq 0x3390
movq %rax, 0x8(%rsp)
jmp 0x7ff8
movq 0x58(%rsp), %rsi
movq 0x8(%rsp), %rdi
callq 0x3310
movq %rax, (%rsp)
jmp 0x800d
movq (%rsp), %rdi
leaq 0xc79a(%rip), %rsi      # 0x147b2
callq 0x3390
jmp 0x801f
leaq 0x60(%rsp), %rdi
callq 0x12060
jmp 0x80a1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x200(%rsp)
movl %eax, 0x1fc(%rsp)
jmp 0x80a9
movq 0x38(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x200(%rsp)
movl %eax, 0x1fc(%rsp)
callq 0x3370
jmp 0x80a9
movq 0x30(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x200(%rsp)
movl %eax, 0x1fc(%rsp)
callq 0x3370
jmp 0x80a9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x200(%rsp)
movl %eax, 0x1fc(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x12060
jmp 0x80a9
addq $0x218, %rsp            # imm = 0x218
retq
movq 0x50(%rsp), %rdi
callq 0x94e0
movq 0x48(%rsp), %rdi
callq 0x9480
movq 0x40(%rsp), %rdi
callq 0x93c0
movq 0x200(%rsp), %rdi
callq 0x3590
nopw %cs:(%rax,%rax)
// File: Rjerk[P]ratabase/Server.cpp
// Function: ratabase::Server::recvRequest()
bool Server::recvRequest()
{
    char buf[1024];
    ssize_t nread = sockets::read(connsock_, buf, sizeof(buf));
    if (nread > 0) {
        LOG_DEBUG << "read buffer: " << buf;
        parser_.get()->addData(buf, nread);
        return true;
    } else {
        return false;
    }
}

// Assembly:
subq $0x5d8, %rsp            # imm = 0x5D8
movq %rdi, 0x5c8(%rsp)
movq 0x5c8(%rsp), %rax
movq %rax, 0x18(%rsp)
movl 0x8(%rax), %edi
leaq 0x1c0(%rsp), %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x12fe0
movq %rax, 0x1b8(%rsp)
cmpq $0x0, 0x1b8(%rsp)
jle 0x8b43
callq 0x12170
cmpl $0x1, %eax
jg 0x8b13
leaq 0xb5f0(%rip), %rsi      # 0x1407d
leaq 0xb74d(%rip), %rcx      # 0x141e1
leaq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl $0x72, %edx
movl $0x1, %r8d
callq 0x11e00
movq 0x8(%rsp), %rdi
callq 0x121a0
movq %rax, 0x10(%rsp)
jmp 0x8abf
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
leaq 0xb71e(%rip), %rsi      # 0x141ed
callq 0x3390
movq %rax, (%rsp)
jmp 0x8ada
movq (%rsp), %rdi
leaq 0x1c0(%rsp), %rsi
callq 0x3390
jmp 0x8aed
leaq 0x30(%rsp), %rdi
callq 0x12060
jmp 0x8b13
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x12060
jmp 0x8b5c
movq 0x18(%rsp), %rdi
addq $0x18, %rdi
callq 0x9520
movq %rax, %rdi
leaq 0x1c0(%rsp), %rsi
movq 0x1b8(%rsp), %rdx
callq 0xa080
movb $0x1, 0x5d7(%rsp)
jmp 0x8b4b
movb $0x0, 0x5d7(%rsp)
movb 0x5d7(%rsp), %al
andb $0x1, %al
addq $0x5d8, %rsp            # imm = 0x5D8
retq
movq 0x28(%rsp), %rdi
callq 0x3590
nopw %cs:(%rax,%rax)
// File: Rjerk[P]ratabase/Server.cpp
// Function: ratabase::Server::parseRequest()
bool Server::parseRequest()
{
    if (parser_.get()->parse(cmd_) == false) {
        LOG_ERROR << "Failed in parsing request. Sending error message...";
        string reply = parser_.get()->getReplyFromParser();
        sockets::write(connsock_, reply.c_str(), reply.size());
        return false;
    }
    return true;
}

// Assembly:
subq $0x1f8, %rsp            # imm = 0x1F8
movq %rdi, 0x1e8(%rsp)
movq 0x1e8(%rsp), %rdi
movq %rdi, 0x28(%rsp)
addq $0x18, %rdi
callq 0x9520
movq 0x28(%rsp), %rsi
movq %rax, %rdi
addq $0x20, %rsi
callq 0xa1d0
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x8cab
leaq 0xb4c2(%rip), %rsi      # 0x1407d
leaq 0xb670(%rip), %rcx      # 0x14232
leaq 0x60(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movl $0x8c, %edx
movl $0x4, %r8d
callq 0x11e00
movq 0x18(%rsp), %rdi
callq 0x121a0
movq %rax, 0x20(%rsp)
jmp 0x8bed
movq 0x20(%rsp), %rdi
addq $0x10, %rdi
leaq 0xb642(%rip), %rsi      # 0x1423f
callq 0x3390
jmp 0x8c04
leaq 0x60(%rsp), %rdi
callq 0x12060
movq 0x28(%rsp), %rdi
addq $0x18, %rdi
callq 0x9520
movq %rax, %rsi
leaq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xa140
movq 0x28(%rsp), %rax
movq (%rsp), %rdi
movl 0x8(%rax), %eax
movl %eax, 0xc(%rsp)
callq 0x31a0
movq (%rsp), %rdi
movq %rax, 0x10(%rsp)
callq 0x32b0
movl 0xc(%rsp), %edi
movq 0x10(%rsp), %rsi
movq %rax, %rdx
callq 0x130c0
jmp 0x8c63
movb $0x0, 0x1f7(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x3280
jmp 0x8cb3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x12060
jmp 0x8cc4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x3280
jmp 0x8cc4
movb $0x1, 0x1f7(%rsp)
movb 0x1f7(%rsp), %al
andb $0x1, %al
addq $0x1f8, %rsp            # imm = 0x1F8
retq
movq 0x58(%rsp), %rdi
callq 0x3590
nop
// File: Rjerk[P]ratabase/Server.cpp
// Function: ratabase::Server::dbOperate()
void Server::dbOperate()
{
    if (rm_.get()->manageDB(cmd_) == false) {
        LOG_ERROR << "Failed in operating ratabase. Sending erorr message...";
    } else {
        LOG_ERROR << "Operating ratabase ok.";
    }
}

// Assembly:
subq $0x358, %rsp            # imm = 0x358
movq %rdi, 0x350(%rsp)
movq 0x350(%rsp), %rdi
movq %rdi, 0x28(%rsp)
addq $0x10, %rdi
callq 0x9590
movq 0x28(%rsp), %rsi
movq %rax, %rdi
addq $0x20, %rsi
callq 0xc340
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x8d9f
leaq 0xb362(%rip), %rsi      # 0x1407d
leaq 0xb551(%rip), %rcx      # 0x14273
leaq 0x1c8(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movl $0x97, %edx
movl $0x4, %r8d
callq 0x11e00
movq 0x18(%rsp), %rdi
callq 0x121a0
movq %rax, 0x20(%rsp)
jmp 0x8d50
movq 0x20(%rsp), %rdi
addq $0x10, %rdi
leaq 0xb51d(%rip), %rsi      # 0x1427d
callq 0x3390
jmp 0x8d67
leaq 0x1c8(%rsp), %rdi
callq 0x12060
jmp 0x8e1b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1c0(%rsp)
movl %eax, 0x1bc(%rsp)
leaq 0x1c8(%rsp), %rdi
callq 0x12060
jmp 0x8e23
leaq 0xb2d7(%rip), %rsi      # 0x1407d
leaq 0xb4c6(%rip), %rcx      # 0x14273
leaq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl $0x99, %edx
movl $0x4, %r8d
callq 0x11e00
movq 0x8(%rsp), %rdi
callq 0x121a0
movq %rax, 0x10(%rsp)
jmp 0x8dd8
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
leaq 0xb4cc(%rip), %rsi      # 0x142b4
callq 0x3390
jmp 0x8def
leaq 0x30(%rsp), %rdi
callq 0x12060
jmp 0x8e1b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1c0(%rsp)
movl %eax, 0x1bc(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x12060
jmp 0x8e23
addq $0x358, %rsp            # imm = 0x358
retq
movq 0x1c0(%rsp), %rdi
callq 0x3590
// File: Rjerk[P]ratabase/Parser.cpp
// Function: ratabase::Parser::check0(cmd_v const&)
bool Parser::check0(const cmd_v& cmd)
{
    if (cmd.obj_name.size() == 0)
        return true;
    else {
        string reply = "Command \"" + cmd.cmd_name
             + "\" should have 0 parameter\n";
        writeReplyBuf(reply);
        LOG_ERROR << reply;
        return false;
    }
}

// Assembly:
subq $0x208, %rsp            # imm = 0x208
movq %rdi, 0x1f8(%rsp)
movq %rsi, 0x1f0(%rsp)
movq 0x1f8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x1f0(%rsp), %rdi
addq $0x28, %rdi
callq 0x32b0
cmpq $0x0, %rax
jne 0xa7c8
movb $0x1, 0x207(%rsp)
jmp 0xa8fa
movq 0x1f0(%rsp), %rdx
addq $0x8, %rdx
leaq 0x9b87(%rip), %rsi      # 0x14362
leaq 0x1b0(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xaf90
movq 0x8(%rsp), %rsi
leaq 0x9b73(%rip), %rdx      # 0x1436c
leaq 0x1d0(%rsp), %rdi
callq 0xaf40
jmp 0xa808
leaq 0x1b0(%rsp), %rdi
callq 0x3280
movq 0x10(%rsp), %rdi
leaq 0x1d0(%rsp), %rsi
callq 0xa0e0
leaq 0x9b0b(%rip), %rsi      # 0x14339
leaq 0x9b52(%rip), %rcx      # 0x14387
leaq 0x18(%rsp), %rdi
movl $0x6a, %edx
movl $0x4, %r8d
callq 0x11e00
jmp 0xa84c
leaq 0x18(%rsp), %rdi
callq 0x121a0
movq %rax, (%rsp)
jmp 0xa85c
movq (%rsp), %rdi
addq $0x10, %rdi
leaq 0x1d0(%rsp), %rsi
callq 0x3350
jmp 0xa873
leaq 0x18(%rsp), %rdi
callq 0x12060
movb $0x0, 0x207(%rsp)
leaq 0x1d0(%rsp), %rdi
callq 0x3280
jmp 0xa8fa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1a8(%rsp)
movl %eax, 0x1a4(%rsp)
leaq 0x1b0(%rsp), %rdi
callq 0x3280
jmp 0xa90b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1a8(%rsp)
movl %eax, 0x1a4(%rsp)
jmp 0xa8eb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1a8(%rsp)
movl %eax, 0x1a4(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x12060
leaq 0x1d0(%rsp), %rdi
callq 0x3280
jmp 0xa90b
movb 0x207(%rsp), %al
andb $0x1, %al
addq $0x208, %rsp            # imm = 0x208
retq
movq 0x1a8(%rsp), %rdi
callq 0x3590
nopl (%rax,%rax)
// File: 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:
subq $0x208, %rsp            # imm = 0x208
movq %rdi, 0x1f8(%rsp)
movq %rsi, 0x1f0(%rsp)
movq 0x1f8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x1f0(%rsp), %rdi
addq $0x28, %rdi
callq 0x32b0
cmpq $0x0, %rax
je 0xa97f
movq 0x1f0(%rsp), %rdi
addq $0x48, %rdi
callq 0xb0f0
cmpq $0x0, %rax
jne 0xa97f
movb $0x1, 0x207(%rsp)
jmp 0xaab1
movq 0x1f0(%rsp), %rdx
addq $0x8, %rdx
leaq 0x99d0(%rip), %rsi      # 0x14362
leaq 0x1b0(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xaf90
movq 0x8(%rsp), %rsi
leaq 0x99de(%rip), %rdx      # 0x1438e
leaq 0x1d0(%rsp), %rdi
callq 0xaf40
jmp 0xa9bf
leaq 0x1b0(%rsp), %rdi
callq 0x3280
movq 0x10(%rsp), %rdi
leaq 0x1d0(%rsp), %rsi
callq 0xa0e0
leaq 0x9954(%rip), %rsi      # 0x14339
leaq 0x99be(%rip), %rcx      # 0x143aa
leaq 0x18(%rsp), %rdi
movl $0x77, %edx
movl $0x4, %r8d
callq 0x11e00
jmp 0xaa03
leaq 0x18(%rsp), %rdi
callq 0x121a0
movq %rax, (%rsp)
jmp 0xaa13
movq (%rsp), %rdi
addq $0x10, %rdi
leaq 0x1d0(%rsp), %rsi
callq 0x3350
jmp 0xaa2a
leaq 0x18(%rsp), %rdi
callq 0x12060
movb $0x0, 0x207(%rsp)
leaq 0x1d0(%rsp), %rdi
callq 0x3280
jmp 0xaab1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1a8(%rsp)
movl %eax, 0x1a4(%rsp)
leaq 0x1b0(%rsp), %rdi
callq 0x3280
jmp 0xaac2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1a8(%rsp)
movl %eax, 0x1a4(%rsp)
jmp 0xaaa2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1a8(%rsp)
movl %eax, 0x1a4(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x12060
leaq 0x1d0(%rsp), %rdi
callq 0x3280
jmp 0xaac2
movb 0x207(%rsp), %al
andb $0x1, %al
addq $0x208, %rsp            # imm = 0x208
retq
movq 0x1a8(%rsp), %rdi
callq 0x3590
nop
// File: 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:
subq $0x208, %rsp            # imm = 0x208
movq %rdi, 0x1f8(%rsp)
movq %rsi, 0x1f0(%rsp)
movq 0x1f8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x1f0(%rsp), %rdi
addq $0x28, %rdi
callq 0x32b0
cmpq $0x0, %rax
je 0xab2f
movq 0x1f0(%rsp), %rdi
addq $0x48, %rdi
callq 0xb0f0
cmpq $0x1, %rax
jne 0xab2f
movb $0x1, 0x207(%rsp)
jmp 0xac61
movq 0x1f0(%rsp), %rdx
addq $0x8, %rdx
leaq 0x9820(%rip), %rsi      # 0x14362
leaq 0x1b0(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xaf90
movq 0x8(%rsp), %rsi
leaq 0x9851(%rip), %rdx      # 0x143b1
leaq 0x1d0(%rsp), %rdi
callq 0xaf40
jmp 0xab6f
leaq 0x1b0(%rsp), %rdi
callq 0x3280
movq 0x10(%rsp), %rdi
leaq 0x1d0(%rsp), %rsi
callq 0xa0e0
leaq 0x97a4(%rip), %rsi      # 0x14339
leaq 0x9832(%rip), %rcx      # 0x143ce
leaq 0x18(%rsp), %rdi
movl $0x84, %edx
movl $0x4, %r8d
callq 0x11e00
jmp 0xabb3
leaq 0x18(%rsp), %rdi
callq 0x121a0
movq %rax, (%rsp)
jmp 0xabc3
movq (%rsp), %rdi
addq $0x10, %rdi
leaq 0x1d0(%rsp), %rsi
callq 0x3350
jmp 0xabda
leaq 0x18(%rsp), %rdi
callq 0x12060
movb $0x0, 0x207(%rsp)
leaq 0x1d0(%rsp), %rdi
callq 0x3280
jmp 0xac61
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1a8(%rsp)
movl %eax, 0x1a4(%rsp)
leaq 0x1b0(%rsp), %rdi
callq 0x3280
jmp 0xac72
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1a8(%rsp)
movl %eax, 0x1a4(%rsp)
jmp 0xac52
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1a8(%rsp)
movl %eax, 0x1a4(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x12060
leaq 0x1d0(%rsp), %rdi
callq 0x3280
jmp 0xac72
movb 0x207(%rsp), %al
andb $0x1, %al
addq $0x208, %rsp            # imm = 0x208
retq
movq 0x1a8(%rsp), %rdi
callq 0x3590
nop
// File: 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:
subq $0x208, %rsp            # imm = 0x208
movq %rdi, 0x1f8(%rsp)
movq %rsi, 0x1f0(%rsp)
movq 0x1f0(%rsp), %rdi
addq $0x28, %rdi
callq 0x32b0
cmpq $0x0, %rax
je 0xaced
movq 0x1f0(%rsp), %rdi
addq $0x48, %rdi
callq 0xb0f0
cmpq $0x0, %rax
jbe 0xaced
movq 0x1f0(%rsp), %rdi
addq $0x48, %rdi
callq 0xb0f0
andq $0x1, %rax
cmpq $0x0, %rax
jne 0xaced
movb $0x1, 0x207(%rsp)
jmp 0xae0f
movq 0x1f0(%rsp), %rdx
addq $0x8, %rdx
leaq 0x9662(%rip), %rsi      # 0x14362
leaq 0x1b0(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xaf90
movq 0x10(%rsp), %rsi
leaq 0x96b7(%rip), %rdx      # 0x143d5
leaq 0x1d0(%rsp), %rdi
callq 0xaf40
jmp 0xad2d
leaq 0x1b0(%rsp), %rdi
callq 0x3280
leaq 0x95f8(%rip), %rsi      # 0x14339
leaq 0x96b2(%rip), %rcx      # 0x143fa
leaq 0x18(%rsp), %rdi
movl $0x91, %edx
movl $0x4, %r8d
callq 0x11e00
jmp 0xad5f
leaq 0x18(%rsp), %rdi
callq 0x121a0
movq %rax, 0x8(%rsp)
jmp 0xad70
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
leaq 0x1d0(%rsp), %rsi
callq 0x3350
jmp 0xad88
leaq 0x18(%rsp), %rdi
callq 0x12060
movb $0x0, 0x207(%rsp)
leaq 0x1d0(%rsp), %rdi
callq 0x3280
jmp 0xae0f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1a8(%rsp)
movl %eax, 0x1a4(%rsp)
leaq 0x1b0(%rsp), %rdi
callq 0x3280
jmp 0xae20
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1a8(%rsp)
movl %eax, 0x1a4(%rsp)
jmp 0xae00
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x1a8(%rsp)
movl %eax, 0x1a4(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x12060
leaq 0x1d0(%rsp), %rdi
callq 0x3280
jmp 0xae20
movb 0x207(%rsp), %al
andb $0x1, %al
addq $0x208, %rsp            # imm = 0x208
retq
movq 0x1a8(%rsp), %rdi
callq 0x3590
nopl (%rax)
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x18(%rsp)
addq $0x18, %rdi
movq %rdi, 0x20(%rsp)
callq 0x3470
movl $0x50, %edi
callq 0x3030
movq %rax, 0x28(%rsp)
jmp 0xc142
movq 0x18(%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rcx, (%rax)
movq $0x0, 0x58(%rsp)
cmpq $0xa, 0x58(%rsp)
jae 0xc198
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq 0x58(%rsp), %rcx
movq $0x0, (%rax,%rcx,8)
movq 0x58(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x58(%rsp)
jmp 0xc158
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
jmp 0xc272
movl $0x48, %edi
callq 0x33a0
movq %rax, 0x10(%rsp)
jmp 0xc1a9
movb $0x1, 0x36(%rsp)
leaq 0x37(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x35a0
movq 0x8(%rsp), %rdx
leaq 0x8267(%rip), %rsi      # 0x14430
leaq 0x38(%rsp), %rdi
callq 0x3480
jmp 0xc1d5
movq 0x10(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0xdd90
jmp 0xc1e6
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
movb $0x0, 0x36(%rsp)
movq (%rax), %rax
movq %rcx, (%rax)
leaq 0x38(%rsp), %rdi
callq 0x3280
leaq 0x37(%rsp), %rdi
callq 0x33d0
movq 0x18(%rsp), %rax
movq $0x1, 0x10(%rax)
movq (%rax), %rcx
movq (%rcx), %rcx
movq %rcx, 0x8(%rax)
addq $0x78, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
jmp 0xc253
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x3280
leaq 0x37(%rsp), %rdi
callq 0x33d0
testb $0x1, 0x36(%rsp)
jne 0xc266
jmp 0xc270
movq 0x10(%rsp), %rdi
callq 0x3370
jmp 0xc272
movq 0x20(%rsp), %rdi
callq 0x30e0
movq 0x68(%rsp), %rdi
callq 0x3590
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
cmpq $0xa, 0x18(%rsp)
jae 0xc30c
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0xc2fa
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0xc2f8
movq 0x8(%rsp), %rdi
callq 0xde50
movq 0x8(%rsp), %rdi
callq 0x3370
jmp 0xc2fa
jmp 0xc2fc
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0xc2ac
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0xc327
movq (%rsp), %rdi
callq 0x3430
movq 0x10(%rsp), %rdi
addq $0x18, %rdi
callq 0x30e0
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x50(%rsp), %rsi
addq $0x28, %rsi
leaq 0x30(%rsp), %rdi
callq 0x31b0
movq 0x50(%rsp), %rax
movl (%rax), %eax
movq %rax, 0x18(%rsp)
subq $0x3, %rax
ja 0xc455
movq 0x18(%rsp), %rax
leaq 0x8093(%rip), %rcx      # 0x14420
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xc4a0
movb %al, 0xf(%rsp)
jmp 0xc3ab
movb 0xf(%rsp), %al
andb $0x1, %al
movb %al, 0x67(%rsp)
movl $0x1, 0x20(%rsp)
jmp 0xc47c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x3280
jmp 0xc491
movq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xcb10
movb %al, 0xe(%rsp)
jmp 0xc3f4
movb 0xe(%rsp), %al
andb $0x1, %al
movb %al, 0x67(%rsp)
movl $0x1, 0x20(%rsp)
jmp 0xc47c
movq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0xce70
movb %al, 0xd(%rsp)
jmp 0xc41d
movb 0xd(%rsp), %al
andb $0x1, %al
movb %al, 0x67(%rsp)
movl $0x1, 0x20(%rsp)
jmp 0xc47c
movq 0x10(%rsp), %rdi
callq 0xd240
movb %al, 0xc(%rsp)
jmp 0xc441
movb 0xc(%rsp), %al
andb $0x1, %al
movb %al, 0x67(%rsp)
movl $0x1, 0x20(%rsp)
jmp 0xc47c
movq 0x10(%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0xd650
movb %al, 0xb(%rsp)
jmp 0xc46a
movb 0xb(%rsp), %al
andb $0x1, %al
movb %al, 0x67(%rsp)
movl $0x1, 0x20(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x3280
movb 0x67(%rsp), %al
andb $0x1, %al
addq $0x68, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x3590
nopl (%rax,%rax)
// File: 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:
subq $0x3e8, %rsp            # imm = 0x3E8
movq %rdi, 0x3d8(%rsp)
movq %rsi, 0x3d0(%rsp)
movq 0x3d8(%rsp), %rdi
movq %rdi, 0x48(%rsp)
callq 0xda10
movq 0x48(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xd7a3
movq 0x48(%rsp), %rdi
addq $0x18, %rdi
leaq 0x6ea1(%rip), %rsi      # 0x1453a
callq 0x3390
movq %rax, %rdi
movq 0xd918(%rip), %rsi      # 0x1afc0
callq 0x33c0
callq 0x12170
cmpl $0x2, %eax
jg 0xd796
leaq 0x6d8b(%rip), %rsi      # 0x1444d
leaq 0x6e95(%rip), %rcx      # 0x1455e
leaq 0x248(%rsp), %rdi
movq %rdi, 0x38(%rsp)
movl $0x86, %edx
movl $0x2, %r8d
callq 0x11e00
movq 0x38(%rsp), %rdi
callq 0x121a0
movq %rax, 0x40(%rsp)
jmp 0xd6f7
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x30(%rsp)
addq $0x18, %rsi
leaq 0x218(%rsp), %rdi
callq 0x33b0
jmp 0xd71d
movq 0x30(%rsp), %rdi
leaq 0x218(%rsp), %rsi
callq 0x3350
jmp 0xd731
leaq 0x218(%rsp), %rdi
callq 0x3280
leaq 0x248(%rsp), %rdi
callq 0x12060
jmp 0xd796
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x240(%rsp)
movl %eax, 0x23c(%rsp)
jmp 0xd784
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x240(%rsp)
movl %eax, 0x23c(%rsp)
leaq 0x218(%rsp), %rdi
callq 0x3280
leaq 0x248(%rsp), %rdi
callq 0x12060
jmp 0xd8fd
movb $0x0, 0x3e7(%rsp)
jmp 0xd8ec
movq 0x48(%rsp), %rax
movq %rax, %rcx
addq $0x18, %rcx
movq %rcx, 0x20(%rsp)
movq 0x8(%rax), %rsi
movq 0x3d0(%rsp), %rdx
leaq 0x1f8(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0xdea0
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x3350
jmp 0xd7e3
leaq 0x1f8(%rsp), %rdi
callq 0x3280
callq 0x12170
cmpl $0x2, %eax
jg 0xd8e4
leaq 0x6c48(%rip), %rsi      # 0x1444d
leaq 0x6d52(%rip), %rcx      # 0x1455e
leaq 0x70(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movl $0x8a, %edx
movl $0x2, %r8d
callq 0x11e00
movq 0x10(%rsp), %rdi
callq 0x121a0
movq %rax, 0x18(%rsp)
jmp 0xd837
movq 0x48(%rsp), %rsi
movq 0x18(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x8(%rsp)
addq $0x18, %rsi
leaq 0x50(%rsp), %rdi
callq 0x33b0
jmp 0xd85a
movq 0x8(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x3350
jmp 0xd86b
leaq 0x50(%rsp), %rdi
callq 0x3280
leaq 0x70(%rsp), %rdi
callq 0x12060
jmp 0xd8e4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x240(%rsp)
movl %eax, 0x23c(%rsp)
leaq 0x1f8(%rsp), %rdi
callq 0x3280
jmp 0xd8fd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x240(%rsp)
movl %eax, 0x23c(%rsp)
jmp 0xd8d8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x240(%rsp)
movl %eax, 0x23c(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x3280
leaq 0x70(%rsp), %rdi
callq 0x12060
jmp 0xd8fd
movb $0x1, 0x3e7(%rsp)
movb 0x3e7(%rsp), %al
andb $0x1, %al
addq $0x3e8, %rsp            # imm = 0x3E8
retq
movq 0x240(%rsp), %rdi
callq 0x3590
nopw (%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
movq $0x0, 0x40(%rsp)
movq 0x10(%rsp), %rcx
movq 0x40(%rsp), %rax
cmpq 0x10(%rcx), %rax
jae 0xd9ed
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x40(%rsp), %rcx
movq (%rax,%rcx,8), %rcx
movb $0x0, 0x1f(%rsp)
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, 0xf(%rsp)
je 0xd99f
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x40(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x20(%rsp), %rdi
callq 0xdba0
movb $0x1, 0x1f(%rsp)
movq 0x50(%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0x7790
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
movb %al, 0xe(%rsp)
testb $0x1, 0x1f(%rsp)
jne 0xd9b0
jmp 0xd9ba
leaq 0x20(%rsp), %rdi
callq 0x3280
movb 0xe(%rsp), %al
testb $0x1, %al
jne 0xd9c4
jmp 0xd9d8
movq 0x40(%rsp), %rcx
movq 0x48(%rsp), %rax
movq %rcx, (%rax)
movb $0x1, 0x67(%rsp)
jmp 0xd9fe
jmp 0xd9da
movq 0x40(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x40(%rsp)
jmp 0xd936
movq 0x48(%rsp), %rax
movq $-0x1, (%rax)
movb $0x0, 0x67(%rsp)
movb 0x67(%rsp), %al
andb $0x1, %al
addq $0x68, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movl (%rax), %eax
addl $-0x4, %eax
movl %eax, %ecx
movq %rcx, 0x18(%rsp)
subl $0x10, %eax
ja 0xdf49
movq 0x18(%rsp), %rax
leaq 0x6751(%rip), %rcx      # 0x1463c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xdfa0
jmp 0xdf7a
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xe0b0
jmp 0xdf7a
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xe190
jmp 0xdf7a
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xe2a0
jmp 0xdf7a
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xe3b0
jmp 0xdf7a
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xe4c0
jmp 0xdf7a
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xe6b0
jmp 0xdf7a
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xe7c0
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
addq $0x28, %rsi
callq 0x31b0
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x58(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xfa50
movq 0x18(%rsp), %rdi
movq 0x68(%rsp), %rdx
movl $0x1, %esi
callq 0xfb20
jmp 0xdfdd
movq 0x68(%rsp), %rdi
addq $0x28, %rdi
callq 0x31a0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
leaq 0x58(%rsp), %rdx
callq 0xf210
jmp 0xdfff
leaq 0x27(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x35a0
movq 0x8(%rsp), %rdx
leaq 0x6692(%rip), %rsi      # 0x146ac
leaq 0x28(%rsp), %rdi
callq 0x3480
jmp 0xe026
movq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xf240
jmp 0xe037
leaq 0x28(%rsp), %rdi
callq 0x3280
leaq 0x27(%rsp), %rdi
callq 0x33d0
leaq 0x58(%rsp), %rdi
callq 0xfa70
addq $0x78, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0xe09c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0xe092
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x3280
leaq 0x27(%rsp), %rdi
callq 0x33d0
leaq 0x58(%rsp), %rdi
callq 0xfa70
movq 0x50(%rsp), %rdi
callq 0x3590
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x48(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xfa50
movq 0x58(%rsp), %rdi
addq $0x28, %rdi
callq 0x31a0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
movq %rax, %rsi
callq 0xf290
jmp 0xe0f9
movq 0x58(%rsp), %rdi
addq $0x48, %rdi
callq 0xf2c0
movq %rax, %rsi
leaq 0x48(%rsp), %rdi
callq 0xff60
jmp 0xe116
leaq 0x18(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0xf2f0
jmp 0xe127
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0xf240
jmp 0xe138
leaq 0x18(%rsp), %rdi
callq 0x3280
leaq 0x48(%rsp), %rdi
callq 0xfa70
addq $0x68, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0xe179
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x3280
leaq 0x48(%rsp), %rdi
callq 0xfa70
movq 0x40(%rsp), %rdi
callq 0x3590
nopl (%rax)
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x58(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xfa50
movq 0x68(%rsp), %rdi
addq $0x28, %rdi
callq 0x31a0
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rdx
movq %rax, %rsi
callq 0xf290
jmp 0xe2e9
leaq 0x58(%rsp), %rdi
callq 0x100d0
jmp 0xe2f5
leaq 0x27(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x35a0
movq 0x8(%rsp), %rdx
leaq 0x63a5(%rip), %rsi      # 0x146b5
leaq 0x28(%rsp), %rdi
callq 0x3480
jmp 0xe31c
movq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xf240
jmp 0xe32d
leaq 0x28(%rsp), %rdi
callq 0x3280
leaq 0x27(%rsp), %rdi
callq 0x33d0
leaq 0x58(%rsp), %rdi
callq 0xfa70
addq $0x78, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0xe392
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0xe388
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x3280
leaq 0x27(%rsp), %rdi
callq 0x33d0
leaq 0x58(%rsp), %rdi
callq 0xfa70
movq 0x50(%rsp), %rdi
callq 0x3590
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x58(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xfa50
movq 0x18(%rsp), %rdi
movq 0x68(%rsp), %rdx
movl $0x2, %esi
callq 0xfb20
jmp 0xe3ed
movq 0x68(%rsp), %rdi
addq $0x28, %rdi
callq 0x31a0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
leaq 0x58(%rsp), %rdx
callq 0xf210
jmp 0xe40f
leaq 0x27(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x35a0
movq 0x8(%rsp), %rdx
leaq 0x628e(%rip), %rsi      # 0x146b8
leaq 0x28(%rsp), %rdi
callq 0x3480
jmp 0xe436
movq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xf240
jmp 0xe447
leaq 0x28(%rsp), %rdi
callq 0x3280
leaq 0x27(%rsp), %rdi
callq 0x33d0
leaq 0x58(%rsp), %rdi
callq 0xfa70
addq $0x78, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0xe4ac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0xe4a2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x3280
leaq 0x27(%rsp), %rdi
callq 0x33d0
leaq 0x58(%rsp), %rdi
callq 0xfa70
movq 0x50(%rsp), %rdi
callq 0x3590
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x48(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0xfa50
movq 0x58(%rsp), %rdi
addq $0x28, %rdi
callq 0x31a0
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rdx
movq %rax, %rsi
callq 0xf290
jmp 0xe509
movq 0x58(%rsp), %rax
movl (%rax), %eax
addl $-0x9, %eax
movl %eax, %ecx
movq %rcx, 0x20(%rsp)
subl $0x6, %eax
ja 0xe690
movq 0x20(%rsp), %rax
leaq 0x6151(%rip), %rcx      # 0x14680
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0xfa70
jmp 0xe6a1
movq 0x58(%rsp), %rdi
addq $0x48, %rdi
callq 0xf2c0
movq 0x28(%rsp), %rdi
movq %rax, %rdx
leaq 0x48(%rsp), %rsi
callq 0xe900
jmp 0xe577
jmp 0xe692
movq 0x28(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0xe980
jmp 0xe58d
jmp 0xe692
movq 0x28(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0xea20
jmp 0xe5a3
jmp 0xe692
movq 0x58(%rsp), %rdi
addq $0x48, %rdi
callq 0xf2c0
movq 0x28(%rsp), %rdi
movq %rax, %rdx
leaq 0x48(%rsp), %rsi
callq 0xeaa0
jmp 0xe5ca
jmp 0xe692
movq 0x58(%rsp), %rdi
addq $0x48, %rdi
callq 0xf2c0
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0xf320
movl %eax, 0x1c(%rsp)
jmp 0xe5f4
movl 0x1c(%rsp), %eax
cltq
movq %rax, 0x10(%rsp)
movq 0x58(%rsp), %rdi
addq $0x48, %rdi
movl $0x1, %esi
callq 0xf370
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rdx
movq %rax, %rcx
leaq 0x48(%rsp), %rsi
callq 0xeb90
jmp 0xe62b
jmp 0xe692
movq 0x58(%rsp), %rdi
addq $0x48, %rdi
callq 0xf2c0
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0xf320
movl %eax, 0xc(%rsp)
jmp 0xe652
movq 0x28(%rsp), %rdi
movl 0xc(%rsp), %eax
movslq %eax, %rdx
leaq 0x48(%rsp), %rsi
callq 0xec20
jmp 0xe66a
jmp 0xe692
movq 0x58(%rsp), %rdi
addq $0x48, %rdi
callq 0xf2c0
movq 0x28(%rsp), %rdi
movq %rax, %rdx
leaq 0x48(%rsp), %rsi
callq 0xeca0
jmp 0xe68e
jmp 0xe692
jmp 0xe692
leaq 0x48(%rsp), %rdi
callq 0xfa70
addq $0x68, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x3590
nopl (%rax,%rax)
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x58(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0xfa50
movq 0x18(%rsp), %rdi
movq 0x68(%rsp), %rdx
movl $0x3, %esi
callq 0xfb20
jmp 0xe6ed
movq 0x68(%rsp), %rdi
addq $0x28, %rdi
callq 0x31a0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
leaq 0x58(%rsp), %rdx
callq 0xf210
jmp 0xe70f
leaq 0x27(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x35a0
movq 0x8(%rsp), %rdx
leaq 0x5f97(%rip), %rsi      # 0x146c1
leaq 0x28(%rsp), %rdi
callq 0x3480
jmp 0xe736
movq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xf240
jmp 0xe747
leaq 0x28(%rsp), %rdi
callq 0x3280
leaq 0x27(%rsp), %rdi
callq 0x33d0
leaq 0x58(%rsp), %rdi
callq 0xfa70
addq $0x78, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0xe7ac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0xe7a2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x3280
leaq 0x27(%rsp), %rdi
callq 0x33d0
leaq 0x58(%rsp), %rdi
callq 0xfa70
movq 0x50(%rsp), %rdi
callq 0x3590
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x28(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xfa50
movq 0x38(%rsp), %rdi
addq $0x28, %rdi
callq 0x31a0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
movq %rax, %rsi
callq 0xf290
jmp 0xe809
movq 0x38(%rsp), %rax
movl (%rax), %eax
addl $-0x11, %eax
movl %eax, %ecx
movq %rcx, (%rsp)
subl $0x3, %eax
ja 0xe8ca
movq (%rsp), %rax
leaq 0x5e6f(%rip), %rcx      # 0x1469c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xfa70
jmp 0xe8eb
movq 0x8(%rsp), %rdi
movq 0x38(%rsp), %rdx
addq $0x48, %rdx
leaq 0x28(%rsp), %rsi
callq 0xed90
jmp 0xe86d
jmp 0xe8d4
movq 0x38(%rsp), %rdi
addq $0x48, %rdi
callq 0xf2c0
movq 0x8(%rsp), %rdi
movq %rax, %rdx
leaq 0x28(%rsp), %rsi
callq 0xee10
jmp 0xe891
jmp 0xe8d4
movq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xef00
jmp 0xe8a4
jmp 0xe8d4
movq 0x38(%rsp), %rdi
addq $0x48, %rdi
callq 0xf2c0
movq 0x8(%rsp), %rdi
movq %rax, %rdx
leaq 0x28(%rsp), %rsi
callq 0xef80
jmp 0xe8c8
jmp 0xe8d4
movl $0x1, 0x18(%rsp)
jmp 0xe8dc
movl $0x0, 0x18(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xfa70
addq $0x48, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x3590
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x78(%rsp), %rdi
movq 0x70(%rsp), %rsi
callq 0x10260
movl %eax, 0x6c(%rsp)
cmpl $-0x1, 0x6c(%rsp)
je 0xeb2a
movl 0x6c(%rsp), %esi
leaq 0x48(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xf3b0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xf240
jmp 0xeb04
leaq 0x48(%rsp), %rdi
callq 0x3280
jmp 0xeb7a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x3280
jmp 0xeb82
movq 0x70(%rsp), %rsi
leaq 0x597b(%rip), %rdx      # 0x144b1
leaq 0x18(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xf4f0
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
callq 0xf240
jmp 0xeb54
leaq 0x18(%rsp), %rdi
callq 0x3280
jmp 0xeb7a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x3280
jmp 0xeb82
addq $0x88, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x3590
nopl (%rax)
// File: Rjerk[P]ratabase/Ratabase.cpp
// Function: Ratabase::ldel(Value&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Ratabase::ldel(Value& v, const string& elem)
{
	if (v.deleteList(elem))
		setMsg(v.printList());
	else
		setMsg(elem+" doesn't exist.");
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x78(%rsp), %rdi
movq 0x70(%rsp), %rsi
callq 0x103a0
testb $0x1, %al
jne 0xecdb
jmp 0xed26
movq 0x78(%rsp), %rsi
leaq 0x50(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x10180
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xf240
jmp 0xed00
leaq 0x50(%rsp), %rdi
callq 0x3280
jmp 0xed78
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x3280
jmp 0xed80
movq 0x70(%rsp), %rsi
leaq 0x577f(%rip), %rdx      # 0x144b1
leaq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xf4f0
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xf240
jmp 0xed52
leaq 0x20(%rsp), %rdi
callq 0x3280
jmp 0xed78
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x3280
jmp 0xed80
addq $0x88, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x3590
nopw (%rax,%rax)
// File: Rjerk[P]ratabase/Ratabase.cpp
// Function: Ratabase::ddel(Value&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Ratabase::ddel(Value& v, const string& key)
{
	if (v.deleteDict(key))
		setMsg(v.printDict());
	else
		setMsg(key+" doesn't exist.");
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x78(%rsp), %rdi
movq 0x70(%rsp), %rsi
callq 0x104f0
testb $0x1, %al
jne 0xee4b
jmp 0xee96
movq 0x78(%rsp), %rsi
leaq 0x50(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x105c0
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xf240
jmp 0xee70
leaq 0x50(%rsp), %rdi
callq 0x3280
jmp 0xeee8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x3280
jmp 0xeef0
movq 0x70(%rsp), %rsi
leaq 0x560f(%rip), %rdx      # 0x144b1
leaq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xf4f0
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xf240
jmp 0xeec2
leaq 0x20(%rsp), %rdi
callq 0x3280
jmp 0xeee8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x3280
jmp 0xeef0
addq $0x88, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x3590
nopw (%rax,%rax)
// File: 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:
subq $0x118, %rsp            # imm = 0x118
movq %rdi, 0x110(%rsp)
movq %rsi, 0x108(%rsp)
movq %rdx, 0x100(%rsp)
movq 0x110(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0xf0(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xfa50
movq 0x10(%rsp), %rdx
movq 0x108(%rsp), %rdi
movq 0x100(%rsp), %rsi
callq 0x10570
movb %al, 0x1f(%rsp)
jmp 0xefde
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0xefeb
jmp 0xf188
movq 0x100(%rsp), %rdx
leaq 0x56d0(%rip), %rsi      # 0x146ca
leaq 0x60(%rsp), %rdi
callq 0xaf90
jmp 0xf006
leaq 0x56bf(%rip), %rdx      # 0x146cc
leaq 0x80(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0xaf40
jmp 0xf021
leaq 0x40(%rsp), %rdi
leaq 0xf0(%rsp), %rsi
callq 0xf2f0
jmp 0xf035
leaq 0xa0(%rsp), %rdi
leaq 0x80(%rsp), %rsi
leaq 0x40(%rsp), %rdx
callq 0xf580
jmp 0xf051
leaq 0x5677(%rip), %rdx      # 0x146cf
leaq 0xc0(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
callq 0xaf40
jmp 0xf06f
movq 0x8(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
callq 0xf240
jmp 0xf083
leaq 0xc0(%rsp), %rdi
callq 0x3280
leaq 0xa0(%rsp), %rdi
callq 0x3280
leaq 0x40(%rsp), %rdi
callq 0x3280
leaq 0x80(%rsp), %rdi
callq 0x3280
leaq 0x60(%rsp), %rdi
callq 0x3280
jmp 0xf1e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xe8(%rsp)
movl %eax, 0xe4(%rsp)
jmp 0xf1f5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xe8(%rsp)
movl %eax, 0xe4(%rsp)
jmp 0xf17c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xe8(%rsp)
movl %eax, 0xe4(%rsp)
jmp 0xf16f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xe8(%rsp)
movl %eax, 0xe4(%rsp)
jmp 0xf165
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xe8(%rsp)
movl %eax, 0xe4(%rsp)
jmp 0xf158
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xe8(%rsp)
movl %eax, 0xe4(%rsp)
leaq 0xc0(%rsp), %rdi
callq 0x3280
leaq 0xa0(%rsp), %rdi
callq 0x3280
leaq 0x40(%rsp), %rdi
callq 0x3280
leaq 0x80(%rsp), %rdi
callq 0x3280
leaq 0x60(%rsp), %rdi
callq 0x3280
jmp 0xf1f5
movq 0x100(%rsp), %rsi
leaq 0x531a(%rip), %rdx      # 0x144b1
leaq 0x20(%rsp), %rdi
callq 0xf4f0
jmp 0xf1a3
movq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0xf240
jmp 0xf1b4
leaq 0x20(%rsp), %rdi
callq 0x3280
jmp 0xf1e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xe8(%rsp)
movl %eax, 0xe4(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x3280
jmp 0xf1f5
leaq 0xf0(%rsp), %rdi
callq 0xfa70
addq $0x118, %rsp            # imm = 0x118
retq
leaq 0xf0(%rsp), %rdi
callq 0xfa70
movq 0xe8(%rsp), %rdi
callq 0x3590
nop
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movl 0x1c(%rsp), %ecx
movl %ecx, (%rax)
movl (%rax), %eax
movl %eax, 0xc(%rsp)
subl $0x1, %eax
je 0xfb64
jmp 0xfb4e
movl 0xc(%rsp), %eax
subl $0x2, %eax
je 0xfb80
jmp 0xfb59
movl 0xc(%rsp), %eax
subl $0x3, %eax
je 0xfba5
jmp 0xfbb9
movq 0x10(%rsp), %rdi
addq $0x48, %rdi
callq 0xf2c0
movq (%rsp), %rdi
movq %rax, %rsi
callq 0xfbc0
jmp 0xfbbb
movq 0x10(%rsp), %rdi
addq $0x28, %rdi
callq 0x31a0
movq (%rsp), %rdi
movq %rax, %rsi
movq 0x10(%rsp), %rdx
addq $0x48, %rdx
callq 0xfc30
jmp 0xfbbb
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
addq $0x48, %rsi
callq 0xfdf0
jmp 0xfbbb
jmp 0xfbbb
addq $0x28, %rsp
retq