LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/Rjerk[P]ratabase/Server.cpp
// Function: ratabase::Server::serverInit()
void Server::serverInit()
{
    if (port_ < 1024 || port_ > 65535) {
        LOG_FATAL << "Server::serverInit: Invalid port";
    }

    struct sockaddr_in servaddr;
    ::bzero(&servaddr, sizeof(servaddr));
    servaddr.sin_family = AF_INET;
    servaddr.sin_port = htons(port_);
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);

    if ((servsock_ = ::socket(PF_INET, SOCK_STREAM, 0)) < 0) {
        LOG_FATAL << "make socket error";
    }

    const int on = 1;
    ::setsockopt(servsock_, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on));
    if (::setsockopt(servsock_, SOL_SOCKET, SO_REUSEPORT, &on, sizeof(on)) == -1) {
        LOG_ERROR << "setsockopt REUSEPORT failed.";
    }

    sockets::bindOrDie(servsock_, (struct sockaddr* ) &servaddr);

    sockets::listenOrDie(servsock_);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rdi, %rbx
movl $0xffff0000, %eax       # imm = 0xFFFF0000
addl (%rdi), %eax
cmpl $0xffff03ff, %eax       # imm = 0xFFFF03FF
ja 0x5997
leaq 0x770f(%rip), %rsi      # 0xd05d
leaq 0x7727(%rip), %rcx      # 0xd07c
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movl $0x27, %edx
movl $0x5, %r8d
callq 0xb910
movq %r14, %rdi
callq 0xbc72
addq $0x10, %rax
leaq 0x7707(%rip), %rsi      # 0xd087
movl $0x20, %edx
movq %rax, %rdi
callq 0x3340
leaq 0x20(%rsp), %rdi
callq 0xbb24
leaq 0x10(%rsp), %r14
movl $0x10, %esi
movq %r14, %rdi
callq 0x34c0
movw $0x2, (%r14)
movzwl (%rbx), %eax
rolw $0x8, %ax
movw %ax, 0x2(%r14)
movl $0x0, 0x4(%r14)
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x3090
movl %eax, 0x4(%rbx)
testl %eax, %eax
jns 0x5a2b
leaq 0x767b(%rip), %rsi      # 0xd05d
leaq 0x7693(%rip), %rcx      # 0xd07c
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movl $0x31, %edx
movl $0x5, %r8d
callq 0xb910
movq %r14, %rdi
callq 0xbc72
addq $0x10, %rax
leaq 0x7694(%rip), %rsi      # 0xd0a8
movl $0x11, %edx
movq %rax, %rdi
callq 0x3340
leaq 0x20(%rsp), %rdi
callq 0xbb24
leaq 0xc(%rsp), %r14
movl $0x1, (%r14)
movl 0x4(%rbx), %edi
movl $0x1, %esi
movl $0x2, %edx
movq %r14, %rcx
movl $0x4, %r8d
callq 0x34e0
movl 0x4(%rbx), %edi
movl $0x1, %esi
movl $0xf, %edx
movq %r14, %rcx
movl $0x4, %r8d
callq 0x34e0
cmpl $-0x1, %eax
jne 0x5ac2
leaq 0x75e4(%rip), %rsi      # 0xd05d
leaq 0x75fc(%rip), %rcx      # 0xd07c
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movl $0x37, %edx
movl $0x4, %r8d
callq 0xb910
movq %r14, %rdi
callq 0xbc72
addq $0x10, %rax
leaq 0x760f(%rip), %rsi      # 0xd0ba
movl $0x1c, %edx
movq %rax, %rdi
callq 0x3340
leaq 0x20(%rsp), %rdi
callq 0xbb24
movl 0x4(%rbx), %edi
leaq 0x10(%rsp), %rsi
callq 0xbfd5
movl 0x4(%rbx), %edi
callq 0xc059
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
retq
jmp 0x5ae6
jmp 0x5ae6
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xbb24
movq %rbx, %rdi
callq 0x34d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/Rjerk[P]ratabase/Server.cpp
// Function: ratabase::Server::run()
void Server::run()
{
    for (int i = 1; ; ++i) {
        connsock_ = ::accept(servsock_, nullptr, nullptr);
        if (connsock_ < 0) {
            LOG_FATAL << "Server::run: accept error";
        }

        LOG_INFO << "Connect to client " << i << "";

        int ret;
        if ((ret = fork()) < 0) {
            continue;
        } else if (ret == 0) {
            while (this->processRequest())
                ;
            LOG_INFO << "Close connection to client " << i;
            sockets::close(connsock_);
        }
    }

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movq %rdi, %rbx
movl $0x1, %ebp
leaq 0x7461(%rip), %r14      # 0xd05d
leaq 0x74d4(%rip), %r15      # 0xd0d7
movq %rsp, %r12
movl 0x4(%rbx), %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x30d0
movl %eax, 0x8(%rbx)
testl %eax, %eax
jns 0x5c5a
movq %r12, %rdi
movq %r14, %rsi
movl $0x44, %edx
movq %r15, %rcx
movl $0x5, %r8d
callq 0xb910
movq %r12, %rdi
callq 0xbc72
addq $0x10, %rax
movl $0x19, %edx
movq %rax, %rdi
leaq 0x748e(%rip), %rsi      # 0xd0db
callq 0x3340
movq %r12, %rdi
callq 0xbb24
callq 0xbc5a
cmpl $0x2, %eax
jg 0x5cc3
movq %r12, %rdi
movq %r14, %rsi
movl $0x47, %edx
movq %r15, %rcx
movl $0x2, %r8d
callq 0xb910
movq %r12, %rdi
callq 0xbc72
movq %rax, %r13
addq $0x10, %r13
movl $0x12, %edx
movq %r13, %rdi
leaq 0x745a(%rip), %rsi      # 0xd0f5
callq 0x3340
movq %r13, %rdi
movl %ebp, %esi
callq 0x34b0
movq %rax, %rdi
leaq 0x7661(%rip), %rsi      # 0xd315
xorl %edx, %edx
callq 0x3340
movq %r12, %rdi
callq 0xbb24
callq 0x30a0
testl %eax, %eax
jne 0x5d38
movq %rbx, %rdi
callq 0x5d56
testb %al, %al
jne 0x5ccc
callq 0xbc5a
cmpl $0x2, %eax
jg 0x5d30
movq %r12, %rdi
movq %r14, %rsi
movl $0x4f, %edx
movq %r15, %rcx
movl $0x2, %r8d
callq 0xb910
movq %r12, %rdi
callq 0xbc72
movq %rax, %r13
addq $0x10, %r13
movl $0x1b, %edx
movq %r13, %rdi
leaq 0x73ef(%rip), %rsi      # 0xd108
callq 0x3340
movq %r13, %rdi
movl %ebp, %esi
callq 0x34b0
movq %r12, %rdi
callq 0xbb24
movl 0x8(%rbx), %edi
callq 0xc2e3
incl %ebp
jmp 0x5c06
jmp 0x5d43
jmp 0x5d43
movq %rax, %rbx
movq %rsp, %rdi
callq 0xbb24
movq %rbx, %rdi
callq 0x34d0
// File: /workspace/github_cpp_makefile_star2_O1/Rjerk[P]ratabase/Server.cpp
// Function: ratabase::Server::processRequest()
bool Server::processRequest()
{
    if (recvRequest() == false) {
        LOG_ERROR << "Failed in receiving request...";
        return false;
    }

    LOG_INFO << "Recevie request, parsing request...";
    if (parseRequest() == false) {
        return true;
    }

    LOG_INFO << "Parse command finished, operating database...";
    dbOperate();

    if (sendRespond() == false) {
        LOG_ERROR << "Failed in sending respond...";
        return false;
    }

    return true;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rdi, %rbx
callq 0x5f14
testb %al, %al
je 0x5e98
callq 0xbc5a
cmpl $0x2, %eax
jg 0x5dcb
leaq 0x72db(%rip), %rsi      # 0xd05d
leaq 0x739b(%rip), %rcx      # 0xd124
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x5d, %edx
movl $0x2, %r8d
callq 0xb910
movq %r14, %rdi
callq 0xbc72
addq $0x10, %rax
leaq 0x739e(%rip), %rsi      # 0xd152
movl $0x23, %edx
movq %rax, %rdi
callq 0x3340
leaq 0x8(%rsp), %rdi
callq 0xbb24
movq %rbx, %rdi
callq 0x6000
movb $0x1, %bpl
testb %al, %al
je 0x5eea
callq 0xbc5a
cmpl $0x2, %eax
jg 0x5e38
leaq 0x726e(%rip), %rsi      # 0xd05d
leaq 0x732e(%rip), %rcx      # 0xd124
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x62, %edx
movl $0x2, %r8d
callq 0xb910
movq %r14, %rdi
callq 0xbc72
addq $0x10, %rax
leaq 0x7355(%rip), %rsi      # 0xd176
movl $0x2d, %edx
movq %rax, %rdi
callq 0x3340
leaq 0x8(%rsp), %rdi
callq 0xbb24
movq %rbx, %rdi
callq 0x60e6
movq %rbx, %rdi
callq 0x61a4
testb %al, %al
jne 0x5eea
leaq 0x7206(%rip), %rsi      # 0xd05d
leaq 0x72c6(%rip), %rcx      # 0xd124
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movl $0x66, %edx
movl $0x4, %r8d
callq 0xb910
movq %rbx, %rdi
callq 0xbc72
addq $0x10, %rax
leaq 0x731b(%rip), %rsi      # 0xd1a4
movl $0x1c, %edx
movq %rax, %rdi
callq 0x3340
jmp 0x5ede
leaq 0x71be(%rip), %rsi      # 0xd05d
leaq 0x727e(%rip), %rcx      # 0xd124
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
movl $0x59, %edx
movl $0x4, %r8d
callq 0xb910
movq %rbx, %rdi
callq 0xbc72
addq $0x10, %rax
leaq 0x7262(%rip), %rsi      # 0xd133
movl $0x1e, %edx
movq %rax, %rdi
callq 0x3340
leaq 0x8(%rsp), %rdi
callq 0xbb24
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x5efe
jmp 0x5efe
jmp 0x5efe
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xbb24
movq %rbx, %rdi
callq 0x34d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x598, %rsp            # imm = 0x598
movq %rdi, %rbx
movl 0x8(%rdi), %edi
leaq 0x190(%rsp), %rsi
movl $0x400, %edx            # imm = 0x400
callq 0xc363
movq %rax, %r14
testq %rax, %rax
jle 0x5fd5
callq 0xbc5a
cmpl $0x1, %eax
jg 0x5fc1
leaq 0x7106(%rip), %rsi      # 0xd05d
leaq 0x7263(%rip), %rcx      # 0xd1c1
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movl $0x72, %edx
movl $0x1, %r8d
callq 0xb910
movq %r15, %rdi
callq 0xbc72
movq %rax, %r15
addq $0x10, %r15
leaq 0x7241(%rip), %rsi      # 0xd1cd
movl $0xd, %edx
movq %r15, %rdi
callq 0x3340
leaq 0x190(%rsp), %r12
movq %r12, %rdi
callq 0x3160
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x3340
leaq 0x8(%rsp), %rdi
callq 0xbb24
movq 0x18(%rbx), %rdi
leaq 0x190(%rsp), %rsi
movq %r14, %rdx
callq 0x6556
testq %r14, %r14
setg %al
addq $0x598, %rsp            # imm = 0x598
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xbb24
movq %rbx, %rdi
callq 0x34d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rdi, %r14
movq 0x18(%rdi), %rdi
leaq 0x20(%r14), %rsi
callq 0x6618
movl %eax, %ebx
testb %al, %al
jne 0x60aa
leaq 0x7030(%rip), %rsi      # 0xd05d
leaq 0x71de(%rip), %rcx      # 0xd212
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movl $0x8c, %edx
movl $0x4, %r8d
callq 0xb910
movq %r15, %rdi
callq 0xbc72
addq $0x10, %rax
leaq 0x71c0(%rip), %rsi      # 0xd21f
movl $0x33, %edx
movq %rax, %rdi
callq 0x3340
leaq 0x8(%rsp), %rdi
callq 0xbb24
movq 0x18(%r14), %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x65de
movl 0x8(%r14), %edi
movq (%r15), %rsi
movq 0x8(%r15), %rdx
callq 0xc3e8
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x60aa
callq 0x32d0
movl %ebx, %eax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x60de
callq 0x32d0
jmp 0x60de
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xbb24
movq %rbx, %rdi
callq 0x34d0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6ba3
movq 0x50(%rdx), %rax
cmpq 0x48(%rdx), %rax
je 0x6cbe
addq $0x8, %rdx
leaq 0x6791(%rip), %rsi      # 0xd33f
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x7063
leaq 0x67a9(%rip), %rsi      # 0xd36b
movq %r14, %rdi
callq 0x3500
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x6bf0
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x6bf7
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6c22
callq 0x32d0
leaq 0x6c(%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0xbc(%rbx)
movups %xmm0, 0xac(%rbx)
movups %xmm0, 0x9c(%rbx)
movups %xmm0, 0x8c(%rbx)
movups %xmm0, 0x7c(%rbx)
movups %xmm0, 0x6c(%rbx)
movl $0x0, 0xcc(%rbx)
movq (%rsp), %rsi
callq 0x32c0
leaq 0x66af(%rip), %rsi      # 0xd316
leaq 0x6719(%rip), %rcx      # 0xd387
leaq 0x20(%rsp), %rdi
movl $0x77, %edx
movl $0x4, %r8d
callq 0xb910
leaq 0x20(%rsp), %rdi
callq 0xbc72
addq $0x10, %rax
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rax, %rdi
callq 0x3340
leaq 0x20(%rsp), %rdi
callq 0xbb24
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x6cba
callq 0x32d0
xorl %eax, %eax
jmp 0x6cc0
movb $0x1, %al
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
retq
movq %rax, %rbx
jmp 0x6cf0
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0x6cf9
jmp 0x6cfe
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xbb24
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x6cfe
callq 0x32d0
movq %rbx, %rdi
callq 0x34d0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6d31
movq 0x50(%rdx), %rcx
subq 0x48(%rdx), %rcx
movb $0x1, %al
cmpq $0x20, %rcx
je 0x6e4a
addq $0x8, %rdx
leaq 0x6603(%rip), %rsi      # 0xd33f
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x7063
leaq 0x663e(%rip), %rsi      # 0xd38e
movq %r14, %rdi
callq 0x3500
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x6d7e
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x6d85
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6db0
callq 0x32d0
leaq 0x6c(%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0xbc(%rbx)
movups %xmm0, 0xac(%rbx)
movups %xmm0, 0x9c(%rbx)
movups %xmm0, 0x8c(%rbx)
movups %xmm0, 0x7c(%rbx)
movups %xmm0, 0x6c(%rbx)
movl $0x0, 0xcc(%rbx)
movq (%rsp), %rsi
callq 0x32c0
leaq 0x6521(%rip), %rsi      # 0xd316
leaq 0x65af(%rip), %rcx      # 0xd3ab
leaq 0x20(%rsp), %rdi
movl $0x84, %edx
movl $0x4, %r8d
callq 0xb910
leaq 0x20(%rsp), %rdi
callq 0xbc72
addq $0x10, %rax
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rax, %rdi
callq 0x3340
leaq 0x20(%rsp), %rdi
callq 0xbb24
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x6e48
callq 0x32d0
xorl %eax, %eax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
retq
movq %rax, %rbx
jmp 0x6e7a
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0x6e83
jmp 0x6e88
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xbb24
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x6e88
callq 0x32d0
movq %rbx, %rdi
callq 0x34d0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rsi, %rdx
cmpq $0x0, 0x30(%rsi)
je 0x6ebe
movq 0x48(%rdx), %rax
movq 0x50(%rdx), %rcx
cmpq %rax, %rcx
je 0x6ebe
subl %eax, %ecx
movb $0x1, %al
andl $0x20, %ecx
je 0x6f99
addq $0x8, %rdx
leaq 0x6476(%rip), %rsi      # 0xd33f
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x7063
leaq 0x64d5(%rip), %rsi      # 0xd3b2
movq %rbx, %rdi
callq 0x3500
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x6f0b
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x6f12
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6f3d
callq 0x32d0
leaq 0x63d2(%rip), %rsi      # 0xd316
leaq 0x648c(%rip), %rcx      # 0xd3d7
leaq 0x20(%rsp), %rdi
movl $0x91, %edx
movl $0x4, %r8d
callq 0xb910
leaq 0x20(%rsp), %rdi
callq 0xbc72
addq $0x10, %rax
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rax, %rdi
callq 0x3340
leaq 0x20(%rsp), %rdi
callq 0xbb24
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x6f97
callq 0x32d0
xorl %eax, %eax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
retq
movq %rax, %rbx
jmp 0x6fc9
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0x6fd2
jmp 0x6fd7
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xbb24
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x6fd7
callq 0x32d0
movq %rbx, %rdi
callq 0x34d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
movq %r14, %rdi
callq 0x33b0
movl $0x50, %edi
callq 0x3030
movq %rax, (%rbx)
xorl %eax, %eax
movq (%rbx), %rcx
movq $0x0, (%rcx,%rax,8)
incq %rax
cmpq $0xa, %rax
jne 0x7557
movl $0x48, %edi
callq 0x3300
movq %rax, %r15
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x5e84(%rip), %rsi      # 0xd40c
leaq 0x5e87(%rip), %rdx      # 0xd416
movq %rsp, %rdi
callq 0x70e4
movq %rsp, %rsi
movq %r15, %rdi
callq 0x8ac8
movq (%rbx), %rax
movq %r15, (%rax)
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x75b6
callq 0x32d0
movq $0x1, 0x10(%rbx)
movq (%rbx), %rax
movq (%rax), %rax
movq %rax, 0x8(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r12
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x75ec
callq 0x32d0
jmp 0x75ec
movq %rax, %r12
movq %r15, %rdi
callq 0x32d0
jmp 0x75f9
movq %rax, %r12
movq 0xa9d0(%rip), %rsi      # 0x11fd0
movq %r14, %rdi
callq 0x3190
addq $0x88, %rbx
movq %rbx, %rdi
callq 0x30e0
movq %r12, %rdi
callq 0x34d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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), %rax
movq (%rax,%r15,8), %r14
testq %r14, %r14
je 0x7647
movq %r14, %rdi
callq 0x8b5c
movq %r14, %rdi
callq 0x32d0
incq %r15
cmpq $0xa, %r15
jne 0x762b
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x765d
callq 0x3390
leaq 0x18(%rbx), %rdi
movq 0xa968(%rip), %rsi      # 0x11fd0
callq 0x3190
addq $0x88, %rbx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x30e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x28(%rsi), %rsi
movq 0x30(%r14), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x55d2
movl (%r14), %eax
cmpq $0x3, %rax
ja 0x76f7
leaq 0x5d3f(%rip), %rcx      # 0xd3fc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x7738
jmp 0x7702
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x7fd0
jmp 0x7702
movq %rbx, %rdi
callq 0x832a
jmp 0x7702
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x7ca8
jmp 0x7702
movq %rbx, %rdi
movq %r14, %rsi
callq 0x86f8
movl %eax, %ebx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x7712
callq 0x32d0
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x772f
callq 0x32d0
movq %rbx, %rdi
callq 0x34d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x89d8
movq 0x8(%r14), %rbx
leaq 0x18(%r14), %r15
testq %rbx, %rbx
je 0x87c5
leaq 0x28(%rsp), %r13
movq %r13, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x8baa
movq (%r13), %rsi
movq 0x8(%r13), %rdx
movq %r15, %rdi
callq 0x3340
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x875a
callq 0x32d0
callq 0xbc5a
cmpl $0x2, %eax
jg 0x887f
leaq 0x4cba(%rip), %rsi      # 0xd429
leaq 0x4dc4(%rip), %rcx      # 0xd53a
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movl $0x8a, %edx
movl $0x2, %r8d
callq 0xb910
movq %r15, %rdi
callq 0xbc72
movq %rax, %r15
addq $0x20, %r14
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x3470
addq $0x10, %r15
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r15, %rdi
callq 0x3340
jmp 0x8862
leaq 0x4d4a(%rip), %rsi      # 0xd516
movl $0x23, %edx
movq %r15, %rdi
callq 0x3340
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x32f0
movsbl %al, %esi
movq %r15, %rdi
callq 0x3040
movq %rax, %rdi
callq 0x3200
callq 0xbc5a
cmpl $0x2, %eax
jg 0x887f
leaq 0x4c18(%rip), %rsi      # 0xd429
leaq 0x4d22(%rip), %rcx      # 0xd53a
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movl $0x86, %edx
movl $0x2, %r8d
callq 0xb910
movq %r15, %rdi
callq 0xbc72
movq %rax, %r15
addq $0x20, %r14
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x3470
addq $0x10, %r15
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r15, %rdi
callq 0x3340
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8875
callq 0x32d0
leaq 0x28(%rsp), %rdi
callq 0xbb24
testq %rbx, %rbx
setne %al
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x889c
jmp 0x88b6
jmp 0x88b6
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x88b9
callq 0x32d0
jmp 0x88b9
jmp 0x88b6
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xbb24
movq %rbx, %rdi
callq 0x34d0
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x88c3
callq 0x32d0
jmp 0x88c3
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
cmpq $0x0, 0x10(%rdi)
setne %bpl
movq $-0x1, %rax
je 0x89c0
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, (%rsp)
xorl %ebx, %ebx
movq (%r15), %rax
movq (%rax,%rbx,8), %r12
testq %r12, %r12
je 0x8967
movq (%rax,%rbx,8), %rax
leaq 0x18(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x55d2
movq 0x10(%rsp), %rdx
cmpq 0x8(%r14), %rdx
jne 0x8967
testq %rdx, %rdx
je 0x899b
movq (%r14), %rsi
movq 0x8(%rsp), %rdi
callq 0x3310
testl %eax, %eax
sete %r13b
jmp 0x896a
xorl %r13d, %r13d
testq %r12, %r12
je 0x8983
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x8983
callq 0x32d0
testb %r13b, %r13b
jne 0x89a0
incq %rbx
cmpq 0x10(%r15), %rbx
setb %bpl
jb 0x8914
jmp 0x89b5
movb $0x1, %r13b
jmp 0x896a
testb $0x1, %bpl
movq $-0x1, %rax
cmovneq %rbx, %rax
movq (%rsp), %rdx
jmp 0x89c0
movq (%rsp), %rdx
movq $-0x1, %rax
movq %rax, (%rdx)
andb $0x1, %bpl
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8c25
leaq 0x4a57(%rip), %rcx      # 0xd61c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %r14, %rdi
movq %rdx, %rsi
callq 0x9556
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x28(%r14), %rsi
movq 0x30(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x55d2
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
movq %rdx, %rsi
callq 0x8e88
jmp 0x8bd9
movq %r14, %rdi
movq %rdx, %rsi
callq 0x943e
jmp 0x8bd9
movq %r14, %rdi
movq %rdx, %rsi
callq 0x8c5a
jmp 0x8bd9
movq %r14, %rdi
movq %rdx, %rsi
callq 0x9260
jmp 0x8bd9
movq %r14, %rdi
movq %rdx, %rsi
callq 0x8d72
jmp 0x8bd9
movq %r14, %rdi
movq %rdx, %rsi
callq 0x9038
jmp 0x8bd9
movq %r14, %rdi
movq %rdx, %rsi
callq 0x9148
jmp 0x8bd9
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xa638
movq %r15, %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0xa68e
movq 0x28(%r14), %rsi
movq 0x20(%rbx), %rdi
leaq 0x8(%rsp), %rdx
callq 0xae00
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x49e2(%rip), %rsi      # 0xd68c
leaq 0x49e3(%rip), %rdx      # 0xd694
leaq 0x18(%rsp), %rdi
callq 0x70e4
leaq 0x48(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
addq %rsi, %rdx
leaq 0x38(%rsp), %rdi
callq 0x55d2
leaq 0x4631(%rip), %rsi      # 0xd314
leaq 0x38(%rsp), %rdi
callq 0x3500
addq $0x28, %rbx
leaq 0x38(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3360
movq (%r14), %rdi
cmpq %r12, %rdi
je 0x8d0e
callq 0x32d0
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x8d1d
callq 0x32d0
leaq 0x8(%rsp), %rdi
callq 0xa648
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x38(%rsp), %rdi
cmpq %r12, %rdi
je 0x8d4a
callq 0x32d0
jmp 0x8d4a
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x8d60
callq 0x32d0
jmp 0x8d60
jmp 0x8d5d
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xa648
movq %rbx, %rdi
callq 0x34d0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xa638
movq 0x28(%r14), %rsi
movq 0x20(%rbx), %rdi
movq %r15, %rdx
callq 0xad4e
movq 0x48(%r14), %rsi
leaq 0x8(%rsp), %rdi
callq 0xa88e
movq 0x10(%rsp), %rax
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq 0x18(%rsp), %rdi
callq 0x55d2
leaq 0x48(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
addq %rsi, %rdx
leaq 0x38(%rsp), %rdi
callq 0x55d2
leaq 0x451c(%rip), %rsi      # 0xd314
leaq 0x38(%rsp), %rdi
callq 0x3500
addq $0x28, %rbx
leaq 0x38(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3360
movq (%r14), %rdi
cmpq %r12, %rdi
je 0x8e23
callq 0x32d0
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x8e32
callq 0x32d0
leaq 0x8(%rsp), %rdi
callq 0xa648
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x38(%rsp), %rdi
cmpq %r12, %rdi
je 0x8e5f
callq 0x32d0
jmp 0x8e5f
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x8e75
callq 0x32d0
jmp 0x8e75
jmp 0x8e72
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xa648
movq %rbx, %rdi
callq 0x34d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xa638
movq 0x28(%r14), %rsi
movq 0x20(%rbx), %rdi
movq %r15, %rdx
callq 0xad4e
leaq 0x8(%rsp), %rdi
callq 0xa9e0
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x4615(%rip), %rsi      # 0xd695
leaq 0x4610(%rip), %rdx      # 0xd697
leaq 0x18(%rsp), %rdi
callq 0x70e4
leaq 0x48(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
addq %rsi, %rdx
leaq 0x38(%rsp), %rdi
callq 0x55d2
leaq 0x425b(%rip), %rsi      # 0xd314
leaq 0x38(%rsp), %rdi
callq 0x3500
addq $0x28, %rbx
leaq 0x38(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3360
movq (%r14), %rdi
cmpq %r12, %rdi
je 0x90e4
callq 0x32d0
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x90f3
callq 0x32d0
leaq 0x8(%rsp), %rdi
callq 0xa648
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x38(%rsp), %rdi
cmpq %r12, %rdi
je 0x9120
callq 0x32d0
jmp 0x9120
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x9136
callq 0x32d0
jmp 0x9136
jmp 0x9133
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xa648
movq %rbx, %rdi
callq 0x34d0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xa638
movq %r15, %rdi
movl $0x2, %esi
movq %r14, %rdx
callq 0xa68e
movq 0x28(%r14), %rsi
movq 0x20(%rbx), %rdi
leaq 0x8(%rsp), %rdx
callq 0xae00
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x4500(%rip), %rsi      # 0xd698
leaq 0x4501(%rip), %rdx      # 0xd6a0
leaq 0x18(%rsp), %rdi
callq 0x70e4
leaq 0x48(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
addq %rsi, %rdx
leaq 0x38(%rsp), %rdi
callq 0x55d2
leaq 0x4143(%rip), %rsi      # 0xd314
leaq 0x38(%rsp), %rdi
callq 0x3500
addq $0x28, %rbx
leaq 0x38(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3360
movq (%r14), %rdi
cmpq %r12, %rdi
je 0x91fc
callq 0x32d0
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x920b
callq 0x32d0
leaq 0x8(%rsp), %rdi
callq 0xa648
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x38(%rsp), %rdi
cmpq %r12, %rdi
je 0x9238
callq 0x32d0
jmp 0x9238
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x924e
callq 0x32d0
jmp 0x924e
jmp 0x924b
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xa648
movq %rbx, %rdi
callq 0x34d0
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
movq %r15, %rdi
callq 0xa638
movq 0x28(%r14), %rsi
movq 0x20(%rbx), %rdi
movq %r15, %rdx
callq 0xad4e
movl (%r14), %eax
addl $-0x9, %eax
cmpl $0x6, %eax
ja 0x93c8
leaq 0x43bb(%rip), %rcx      # 0xd660
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x48(%r14), %rdx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x9602
jmp 0x93c8
movq 0x48(%r14), %rax
movq (%rax), %r12
callq 0x3050
movq %rax, %r15
movl (%rax), %ebp
movl $0x0, (%rax)
leaq 0x10(%rsp), %r13
movq %r12, %rdi
movq %r13, %rsi
movl $0xa, %edx
callq 0x33d0
cmpq %r12, (%r13)
je 0x93df
movslq %eax, %rcx
cmpq %rax, %rcx
jne 0x93f7
movl (%r15), %ecx
cmpl $0x22, %ecx
je 0x93f7
testl %ecx, %ecx
jne 0x9317
movl %ebp, (%r15)
movslq %eax, %rdx
movq 0x48(%r14), %rcx
addq $0x20, %rcx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x9b20
jmp 0x93c8
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x97ce
jmp 0x93c8
movq 0x48(%r14), %rdx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x9900
jmp 0x93c8
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x96d0
jmp 0x93c8
movq 0x48(%r14), %rax
movq (%rax), %r15
callq 0x3050
movq %rax, %r14
movl (%rax), %ebp
movl $0x0, (%rax)
leaq 0x10(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
movl $0xa, %edx
callq 0x33d0
cmpq %r15, (%r12)
je 0x93eb
movslq %eax, %rcx
cmpq %rax, %rcx
jne 0x9403
movl (%r14), %ecx
cmpl $0x22, %ecx
je 0x9403
testl %ecx, %ecx
jne 0x93a9
movl %ebp, (%r14)
movslq %eax, %rdx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x9bf0
jmp 0x93c8
movq 0x48(%r14), %rdx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x9ca0
movq %rsp, %rdi
callq 0xa648
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x42c9(%rip), %rdi      # 0xd6af
callq 0x31e0
leaq 0x42bd(%rip), %rdi      # 0xd6af
callq 0x31e0
leaq 0x42b1(%rip), %rdi      # 0xd6af
callq 0x3400
leaq 0x42a5(%rip), %rdi      # 0xd6af
callq 0x3400
movq %rax, %rbx
cmpl $0x0, (%r14)
jne 0x942e
movl %ebp, (%r14)
jmp 0x942e
movq %rax, %rbx
cmpl $0x0, (%r15)
jne 0x942e
movl %ebp, (%r15)
jmp 0x942e
movq %rax, %rbx
movq %rsp, %rdi
callq 0xa648
movq %rbx, %rdi
callq 0x34d0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xa638
movq %r15, %rdi
movl $0x3, %esi
movq %r14, %rdx
callq 0xa68e
movq 0x28(%r14), %rsi
movq 0x20(%rbx), %rdi
leaq 0x8(%rsp), %rdx
callq 0xae00
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x4213(%rip), %rsi      # 0xd6a1
leaq 0x4214(%rip), %rdx      # 0xd6a9
leaq 0x18(%rsp), %rdi
callq 0x70e4
leaq 0x48(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
addq %rsi, %rdx
leaq 0x38(%rsp), %rdi
callq 0x55d2
leaq 0x3e4d(%rip), %rsi      # 0xd314
leaq 0x38(%rsp), %rdi
callq 0x3500
addq $0x28, %rbx
leaq 0x38(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3360
movq (%r14), %rdi
cmpq %r12, %rdi
je 0x94f2
callq 0x32d0
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x9501
callq 0x32d0
leaq 0x8(%rsp), %rdi
callq 0xa648
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x38(%rsp), %rdi
cmpq %r12, %rdi
je 0x952e
callq 0x32d0
jmp 0x952e
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x9544
callq 0x32d0
jmp 0x9544
jmp 0x9541
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xa648
movq %rbx, %rdi
callq 0x34d0
// File: /workspace/github_cpp_makefile_star2_O1/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 0xa638
movq 0x28(%r14), %rsi
movq 0x20(%rbx), %rdi
movq %r15, %rdx
callq 0xad4e
movl (%r14), %eax
addl $-0x11, %eax
cmpl $0x3, %eax
ja 0x95dc
leaq 0x40ea(%rip), %rcx      # 0xd67c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
addq $0x48, %r14
movq %rsp, %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x9e2e
jmp 0x95dc
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xa08a
jmp 0x95dc
movq 0x48(%r14), %rdx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xa1bc
jmp 0x95dc
movq 0x48(%r14), %rdx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x9efc
movq %rsp, %rdi
callq 0xa648
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0xa648
movq %rbx, %rdi
callq 0x34d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r15
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0xaa84
cmpl $-0x1, %eax
je 0x998c
movl %eax, %r14d
movl %eax, %ebp
negl %ebp
cmovsl %eax, %ebp
movl $0x1, %r15d
cmpl $0xa, %ebp
jb 0x9a2a
movl $0x4, %r15d
movl $0xd1b71759, %eax       # imm = 0xD1B71759
movl %ebp, %ecx
cmpl $0x63, %ecx
jbe 0x9a21
cmpl $0x3e7, %ecx            # imm = 0x3E7
jbe 0x9a27
cmpl $0x2710, %ecx           # imm = 0x2710
jb 0x9a2a
movl %ecx, %edx
imulq %rax, %rdx
shrq $0x2d, %rdx
addl $0x4, %r15d
cmpl $0x1869f, %ecx          # imm = 0x1869F
movl %edx, %ecx
ja 0x994a
addl $-0x3, %r15d
jmp 0x9a2a
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x55d2
leaq 0x3ad9(%rip), %rsi      # 0xd48d
movq %r14, %rdi
callq 0x3500
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x55d2
leaq 0x3931(%rip), %rsi      # 0xd314
leaq 0x28(%rsp), %rdi
callq 0x3500
addq $0x28, %rbx
leaq 0x28(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3360
movq (%r14), %rdi
cmpq %r15, %rdi
je 0x9a0e
callq 0x32d0
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
jne 0x9ab9
jmp 0x9abe
addl $-0x2, %r15d
jmp 0x9a2a
decl %r15d
shrl $0x1f, %r14d
leal (%r15,%r14), %esi
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movl $0x2d, %edx
callq 0x3350
addq (%r12), %r14
movq %r14, %rdi
movl %r15d, %esi
movl %ebp, %edx
callq 0xa5cb
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x55d2
leaq 0x3890(%rip), %rsi      # 0xd314
leaq 0x28(%rsp), %rdi
callq 0x3500
addq $0x28, %rbx
leaq 0x28(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3360
movq (%r14), %rdi
cmpq %r15, %rdi
je 0x9aaf
callq 0x32d0
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x9abe
callq 0x32d0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x9ae6
callq 0x32d0
jmp 0x9ae6
jmp 0x9ae3
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
jne 0x9b13
jmp 0x9b18
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x9b09
callq 0x32d0
jmp 0x9b09
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x9b18
callq 0x32d0
movq %rbx, %rdi
callq 0x34d0
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0xab4c
testb %al, %al
je 0x9d41
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0xaa4c
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x55d2
leaq 0x361d(%rip), %rsi      # 0xd314
leaq 0x28(%rsp), %rdi
callq 0x3500
addq $0x28, %rbx
leaq 0x28(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3360
movq (%r14), %rdi
cmpq %r15, %rdi
je 0x9d22
callq 0x32d0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9d35
callq 0x32d0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x55d2
leaq 0x3725(%rip), %rsi      # 0xd48d
movq %r14, %rdi
callq 0x3500
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x55d2
leaq 0x357c(%rip), %rsi      # 0xd314
leaq 0x28(%rsp), %rdi
callq 0x3500
addq $0x28, %rbx
leaq 0x28(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3360
movq (%r14), %rdi
cmpq %r12, %rdi
je 0x9dc3
callq 0x32d0
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
jne 0x9d30
jmp 0x9d35
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x9e03
callq 0x32d0
jmp 0x9e03
jmp 0x9e00
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x9e1d
callq 0x32d0
jmp 0x9e1d
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x9e12
callq 0x32d0
movq %rbx, %rdi
callq 0x34d0
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0x9e0d
jmp 0x9e12
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0xabba
testb %al, %al
je 0x9f9d
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0xabdc
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x55d2
leaq 0x33c1(%rip), %rsi      # 0xd314
leaq 0x28(%rsp), %rdi
callq 0x3500
addq $0x28, %rbx
leaq 0x28(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3360
movq (%r14), %rdi
cmpq %r15, %rdi
je 0x9f7e
callq 0x32d0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9f91
callq 0x32d0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x55d2
leaq 0x34c9(%rip), %rsi      # 0xd48d
movq %r14, %rdi
callq 0x3500
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x55d2
leaq 0x3320(%rip), %rsi      # 0xd314
leaq 0x28(%rsp), %rdi
callq 0x3500
addq $0x28, %rbx
leaq 0x28(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3360
movq (%r14), %rdi
cmpq %r12, %rdi
je 0xa01f
callq 0x32d0
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
jne 0x9f8c
jmp 0x9f91
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0xa05f
callq 0x32d0
jmp 0xa05f
jmp 0xa05c
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0xa079
callq 0x32d0
jmp 0xa079
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xa06e
callq 0x32d0
movq %rbx, %rdi
callq 0x34d0
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0xa069
jmp 0xa06e
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xa6b5
cmpl $0x2, %esi
je 0xa6a8
cmpl $0x1, %esi
jne 0xa6c1
movq 0x48(%rdx), %rsi
jmp 0xa6c2
movq 0x28(%rdx), %rsi
addq $0x48, %rdx
jmp 0xa710
addq $0x48, %rdx
movq %rdx, %rsi
jmp 0xa800
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movl $0x38, %edi
callq 0x3300
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %r12, %rsi
callq 0x3140
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xb2a8
leaq 0x18(%rsp), %r12
movq -0x10(%r12), %rdi
cmpq %r12, %rdi
je 0xa767
callq 0x32d0
movq (%r15), %r13
movq 0x8(%r15), %rbp
cmpq %rbp, %r13
je 0xa7b3
leaq 0x8(%rsp), %r15
movq %r12, 0x8(%rsp)
movq (%r13), %rsi
movq 0x8(%r13), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x55d2
movq %rbx, %rdi
movq %r15, %rsi
callq 0xb368
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xa7aa
callq 0x32d0
addq $0x20, %r13
cmpq %rbp, %r13
jne 0xa778
movq %rbx, 0x8(%r14)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xa7e1
callq 0x32d0
jmp 0xa7e1
movq %rax, %r14
movq %rbx, %rdi
jmp 0xa7f3
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xa7f8
callq 0x32d0
movq %r14, %rdi
callq 0x34d0
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x18, %edi
callq 0x3300
movq %rax, %r15
movq %rax, %rdi
callq 0xac4c
movq (%r14), %r13
cmpq 0x8(%r14), %r13
je 0xa869
movq %rsp, %r12
leaq 0x20(%r13), %rsi
movl $0x0, (%rsp)
movq $0x0, 0x8(%rsp)
movq %r12, %rdi
callq 0xa6c2
movq (%r13), %rsi
movq %r15, %rdi
movq %r12, %rdx
callq 0xae00
addq $0x40, %r13
cmpq 0x8(%r14), %r13
jne 0xa834
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 0x32d0
movq %rbx, %rdi
callq 0x34d0