LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/Sherhang[P]redis-for-cpp/./credis.h
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> Redis::num2str<long>(long const&)
std::string num2str(const T& num)
    {
        std::stringstream ss;
        ss << num;
        std::string str;
        ss >> str;
        return str;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x32a0
leaq 0x18(%rsp), %rdi
movq (%r14), %rsi
callq 0x3360
leaq 0x10(%rbx), %r15
movq %r15, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x3460
movq 0xf89a(%rip), %rsi      # 0x19fb8
leaq 0x8(%rsp), %rdi
callq 0x32c0
leaq 0x88(%rsp), %rdi
callq 0x3130
movq %rbx, %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0xa75a
callq 0x3350
jmp 0xa75a
movq %rax, %r14
movq 0xf857(%rip), %rsi      # 0x19fb8
leaq 0x8(%rsp), %rdi
callq 0x32c0
leaq 0x88(%rsp), %rdi
callq 0x3130
movq %r14, %rdi
callq 0x35b0
// File: /workspace/github_cpp_makefile_star2_O3/Sherhang[P]redis-for-cpp/credis.cpp
// Function: Redis::~Redis()
Redis::~Redis() 
{
    if(_connected)
    {
        //DEBUG<<"free _context"<<std::endl;
        ::redisFree(_context);
        _connected = false;
    }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x159a9(%rip), %rax     # 0x19d88
movq %rax, (%rdi)
cmpb $0x1, 0x60(%rdi)
jne 0x43f5
movq 0x8(%rbx), %rdi
callq 0xd3f0
movb $0x0, 0x60(%rbx)
movq 0x40(%rbx), %rdi
leaq 0x50(%rbx), %rax
cmpq %rax, %rdi
je 0x4407
callq 0x3350
movq 0x18(%rbx), %rdi
addq $0x28, %rbx
cmpq %rbx, %rdi
je 0x441a
popq %rbx
jmp 0x3350
popq %rbx
retq
movq %rax, %rdi
callq 0xa641
// File: /workspace/github_cpp_makefile_star2_O3/Sherhang[P]redis-for-cpp/credis.cpp
// Function: Redis::connect()
void Redis::connect()
{
    if(_connected)
    {
        //DEBUG
        return;
    }
    _connected = true;
    _context = ::redisConnect(_ip.c_str(), _port);
    if (_context && _context->err)
    {
        exit(EXIT_FAILURE);
    }
    if(_pwd.empty())
    {
        std::vector<std::string> status;
        exec("PING",status);
        if((!status.empty()) && strcasecmp(status[0].c_str(),"PONG") == 0)
        {
            return ;
        }
        else
        {
            //debug
            exit(EXIT_FAILURE);
        }
    }

    if (auth(_pwd))
    {
        //debug
    }
    else
    {
        exit(EXIT_FAILURE);
    }

}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
cmpb $0x0, 0x60(%rdi)
jne 0x4527
movq %rdi, %rbx
movb $0x1, 0x60(%rdi)
movq 0x18(%rdi), %rdi
movl 0x38(%rbx), %esi
callq 0xd6b0
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x4498
cmpl $0x0, (%rax)
jne 0x452f
cmpq $0x0, 0x48(%rbx)
je 0x44b1
leaq 0x40(%rbx), %rsi
movq %rbx, %rdi
callq 0x471a
testb %al, %al
jne 0x4527
jmp 0x452f
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
leaq 0x28(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0xfbeb(%rip), %rsi      # 0x140bc
leaq 0xfbe8(%rip), %rdx      # 0x140c0
leaq 0x18(%rsp), %rdi
callq 0x42ba
leaq 0x18(%rsp), %rsi
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x4560
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
je 0x4501
callq 0x3350
movq (%rsp), %rax
cmpq 0x8(%rsp), %rax
je 0x452f
movq (%rax), %rdi
leaq 0xfbab(%rip), %rsi      # 0x140c1
callq 0x33c0
testl %eax, %eax
jne 0x452f
movq %rsp, %rdi
callq 0x4270
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movl $0x1, %edi
callq 0x3430
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r14, %rdi
je 0x4550
callq 0x3350
jmp 0x4550
movq %rax, %rbx
movq %rsp, %rdi
callq 0x4270
movq %rbx, %rdi
callq 0x35b0
// File: /workspace/github_cpp_makefile_star2_O3/Sherhang[P]redis-for-cpp/credis.cpp
// Function: Redis::del(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int64_t Redis::del(const std::string& key)
{
    int64_t ret=0;
    std::string cmd = "DEL " + key;
    if(execReplyInt(cmd, ret))
    {
        return ret;
    }
    DEBUG<<"execReplyInt error "<<std::endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq $0x0, (%r14)
leaq 0xf8d4(%rip), %rsi      # 0x140c6
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0xa64c
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x4928
testb %al, %al
je 0x4836
movq 0x8(%rsp), %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4829
callq 0x3350
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x1579b(%rip), %rdi     # 0x19fd8
leaq 0xf887(%rip), %rsi      # 0x140cb
movl $0x7, %edx
callq 0x33f0
movq 0x15783(%rip), %rdi     # 0x19fd8
leaq 0xf877(%rip), %rsi      # 0x140d3
movl $0xa, %edx
callq 0x33f0
movq 0x1576b(%rip), %rdi     # 0x19fd8
leaq 0xf86a(%rip), %rsi      # 0x140de
movl $0x1, %edx
callq 0x33f0
movq 0x15753(%rip), %rdi     # 0x19fd8
leaq 0xf854(%rip), %rsi      # 0x140e0
movl $0x3, %edx
callq 0x33f0
movq 0x1573b(%rip), %rdi     # 0x19fd8
leaq 0xf83a(%rip), %rsi      # 0x140de
movl $0x1, %edx
callq 0x33f0
movq 0x15723(%rip), %rdi     # 0x19fd8
leaq 0xf828(%rip), %rsi      # 0x140e4
movl $0x4, %edx
callq 0x33f0
movq 0x1570b(%rip), %rdi     # 0x19fd8
movl $0x75, %esi
callq 0x3590
movq %rax, %rbx
leaq 0x10311(%rip), %rsi     # 0x14bf2
movl $0x1, %edx
movq %rax, %rdi
callq 0x33f0
leaq 0xf7f4(%rip), %rsi      # 0x140e9
movl $0x13, %edx
movq %rbx, %rdi
callq 0x33f0
movq %rbx, %rdi
callq 0x31c0
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4920
callq 0x3350
movq %rbx, %rdi
callq 0x35b0
// File: /workspace/github_cpp_makefile_star2_O3/Sherhang[P]redis-for-cpp/credis.cpp
// Function: Redis::execReplyInt(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, long&)
bool Redis::execReplyInt(const std::string& cmd, int64_t& ret)
{
    if(_context==NULL)
    {
        return false;
    }

    redisReply* _reply = (redisReply*)::redisCommand(_context, cmd.c_str());
    if (!isError(_reply))
    {
        //DEBUG<<"_reply->type "<<_reply->type<<std::endl;
        if (_reply->type == REDIS_REPLY_INTEGER)
        {
            ret = _reply->integer;
            freeReply(_reply);
            return true;
        }
        if (_reply->type == REDIS_REPLY_ERROR)
        {
            std::string reason = _reply->str;
            reason.resize(_reply->len);
            freeReply(_reply);
            return false;
        }
    }
    freeReply(_reply);
    return false;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x49bd
movq %rdx, %r14
movq (%rsi), %rsi
xorl %ebp, %ebp
xorl %eax, %eax
callq 0xe1b0
testq %rax, %rax
je 0x49bf
movq %rax, %rbx
movl (%rax), %eax
cmpl $0x6, %eax
je 0x4974
cmpl $0x3, %eax
jne 0x49b5
movq 0x8(%rbx), %rax
movq %rax, (%r14)
movq %rbx, %rdi
callq 0xbb00
movb $0x1, %bpl
jmp 0x49bf
movq 0x18(%rbx), %rsi
leaq 0x10(%rsp), %r14
leaq 0xf(%rsp), %rdx
movq %r14, %rdi
callq 0x3170
movq 0x10(%rbx), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x3100
movq %rbx, %rdi
callq 0xbb00
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x49bd
callq 0x3350
jmp 0x49bd
movq %rbx, %rdi
callq 0xbb00
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x49e0
callq 0x3350
movq %rbx, %rdi
callq 0x35b0
// File: /workspace/github_cpp_makefile_star2_O3/Sherhang[P]redis-for-cpp/credis.cpp
// Function: Redis::exists(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool Redis::exists(const std::string& key)
{  
    int64_t ret = 0;
    std::string cmd = "DEL " + key;
    execReplyInt(cmd, ret);
    return (ret > 0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq $0x0, (%r14)
leaq 0xf6bc(%rip), %rsi      # 0x140c6
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0xa64c
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x4928
movq 0x8(%rsp), %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4a3d
callq 0x3350
testq %rbx, %rbx
setg %al
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4a63
callq 0x3350
movq %rbx, %rdi
callq 0x35b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Sherhang[P]redis-for-cpp/credis.cpp
// Function: Redis::expire(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, long)
bool Redis::expire(const std::string& key, int64_t seconds)
{
    int64_t ret = 0;
    std::string cmd = "EXPIRE " + key + " " +  num2str<int64_t>(seconds);
    execReplyInt(cmd, ret);
    return (ret > 0);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rsi, %rax
movq %rdi, %rbx
movq %rdx, 0x70(%rsp)
movq $0x0, 0x8(%rsp)
leaq 0xf66c(%rip), %rsi      # 0x140fd
leaq 0x78(%rsp), %r14
movq %r14, %rdi
movq %rax, %rdx
callq 0xa64c
leaq 0x1014a(%rip), %rsi     # 0x14bf2
movq %r14, %rdi
callq 0x3600
leaq 0x40(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x4ad7
movq %rdx, 0x30(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x40(%rsp)
jmp 0x4ade
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
movq %rdx, 0x38(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x50(%rsp), %rdi
leaq 0x70(%rsp), %rdx
movq %rbx, %rsi
callq 0xa6ce
movq 0x30(%rsp), %rcx
movq 0x38(%rsp), %r8
movq 0x58(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %edi
cmpq %r14, %rcx
je 0x4b2a
movq 0x40(%rsp), %rdi
movq 0x50(%rsp), %rsi
cmpq %rdi, %rax
jbe 0x4b4d
leaq 0x60(%rsp), %r9
movl $0xf, %edi
cmpq %r9, %rsi
je 0x4b48
movq 0x60(%rsp), %rdi
cmpq %rdi, %rax
jbe 0x4b59
leaq 0x30(%rsp), %rdi
callq 0x3110
jmp 0x4b67
leaq 0x50(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x33e0
leaq 0x20(%rsp), %rdx
movq %rdx, -0x10(%rdx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
je 0x4b8b
movq %rsi, 0x10(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x20(%rsp)
jmp 0x4b91
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x18(%rsp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4bc1
callq 0x3350
movq 0x30(%rsp), %rdi
cmpq %r14, %rdi
je 0x4bd0
callq 0x3350
leaq 0x88(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4be6
callq 0x3350
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x4928
movq 0x8(%rsp), %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4c10
callq 0x3350
testq %rbx, %rbx
setg %al
addq $0x98, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rax
jmp 0x4c62
movq %rax, %rbx
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4c46
callq 0x3350
jmp 0x4c46
movq %rax, %rbx
movq 0x30(%rsp), %rdi
cmpq %r14, %rdi
je 0x4c5a
callq 0x3350
jmp 0x4c5a
movq %rax, %rbx
leaq 0x88(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4c70
callq 0x3350
movq %rbx, %rdi
callq 0x35b0
// File: /workspace/github_cpp_makefile_star2_O3/Sherhang[P]redis-for-cpp/credis.cpp
// Function: Redis::expireat(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, long)
bool Redis::expireat(const std::string& key, int64_t timestamp)
{
    int64_t ret = 0;
    std::string cmd = "EXPIREAT " + key + " " + num2str<int64_t>(timestamp);
    execReplyInt(cmd, ret);
    return (ret > 0);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rsi, %rax
movq %rdi, %rbx
movq %rdx, 0x70(%rsp)
movq $0x0, 0x8(%rsp)
leaq 0xf468(%rip), %rsi      # 0x14105
leaq 0x78(%rsp), %r14
movq %r14, %rdi
movq %rax, %rdx
callq 0xa64c
leaq 0xff3e(%rip), %rsi      # 0x14bf2
movq %r14, %rdi
callq 0x3600
leaq 0x40(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x4ce3
movq %rdx, 0x30(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x40(%rsp)
jmp 0x4cea
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
movq %rdx, 0x38(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x50(%rsp), %rdi
leaq 0x70(%rsp), %rdx
movq %rbx, %rsi
callq 0xa6ce
movq 0x30(%rsp), %rcx
movq 0x38(%rsp), %r8
movq 0x58(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %edi
cmpq %r14, %rcx
je 0x4d36
movq 0x40(%rsp), %rdi
movq 0x50(%rsp), %rsi
cmpq %rdi, %rax
jbe 0x4d59
leaq 0x60(%rsp), %r9
movl $0xf, %edi
cmpq %r9, %rsi
je 0x4d54
movq 0x60(%rsp), %rdi
cmpq %rdi, %rax
jbe 0x4d65
leaq 0x30(%rsp), %rdi
callq 0x3110
jmp 0x4d73
leaq 0x50(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x33e0
leaq 0x20(%rsp), %rdx
movq %rdx, -0x10(%rdx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
je 0x4d97
movq %rsi, 0x10(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x20(%rsp)
jmp 0x4d9d
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x18(%rsp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4dcd
callq 0x3350
movq 0x30(%rsp), %rdi
cmpq %r14, %rdi
je 0x4ddc
callq 0x3350
leaq 0x88(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4df2
callq 0x3350
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x4928
movq 0x8(%rsp), %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4e1c
callq 0x3350
testq %rbx, %rbx
setg %al
addq $0x98, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rax
jmp 0x4e6e
movq %rax, %rbx
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4e52
callq 0x3350
jmp 0x4e52
movq %rax, %rbx
movq 0x30(%rsp), %rdi
cmpq %r14, %rdi
je 0x4e66
callq 0x3350
jmp 0x4e66
movq %rax, %rbx
leaq 0x88(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4e7c
callq 0x3350
movq %rbx, %rdi
callq 0x35b0
// File: /workspace/github_cpp_makefile_star2_O3/Sherhang[P]redis-for-cpp/credis.cpp
// Function: Redis::keys(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<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>>>>&)
bool Redis::keys(const std::string& pattern, std::vector<std::string>& key_list)
{
    std::string cmd = "KEYS " + pattern; 
    if (execReplyArray(cmd, key_list))
    {
        return true;
    }
    return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %r14
leaq 0xf272(%rip), %rsi      # 0x1410f
movq %rsp, %r15
movq %r15, %rdi
callq 0xa64c
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x4ef6
movl %eax, %ebx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4ecb
callq 0x3350
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4eed
callq 0x3350
movq %rbx, %rdi
callq 0x35b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Sherhang[P]redis-for-cpp/credis.cpp
// Function: Redis::execReplyArray(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<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>>>>&)
bool Redis::execReplyArray(const std::string& cmd, std::vector<std::string>& ret)
{
    if(_context==NULL)
    {
        return false;
    }

    redisReply* _reply = (redisReply*)::redisCommand(_context, cmd.c_str());
    if (!isError(_reply))
    {
        if (_reply->type == REDIS_REPLY_ARRAY)
        {
            int32_t elements = _reply->elements;
            ret.reserve(elements);
            for(int32_t i=0; i<elements; ++i)
            {
                std::string strTemp(_reply->element[i]->str, _reply->element[i]->len);
                ret.push_back(strTemp);
            }
            freeReply(_reply);
            return true;
        }
    }
    freeReply(_reply);
    return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x4fb2
movq %rdx, %rbx
movq (%rsi), %rsi
xorl %ebp, %ebp
xorl %eax, %eax
callq 0xe1b0
testq %rax, %rax
je 0x4fb4
movq %rax, %r14
cmpl $0x2, (%rax)
jne 0x4faa
movq 0x20(%r14), %r12
movslq %r12d, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0xa7c6
testl %r15d, %r15d
jle 0x4f9d
leaq 0x18(%rsp), %r13
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
xorl %ebp, %ebp
leaq 0x8(%rsp), %r15
movq 0x28(%r14), %rax
movq (%rax,%rbp,8), %rax
movq 0x18(%rax), %rsi
movq 0x10(%rax), %rdx
addq %rsi, %rdx
movq %r13, 0x8(%rsp)
movq %r15, %rdi
callq 0x42ba
movq %rbx, %rdi
movq %r15, %rsi
callq 0xa8a6
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x4f95
callq 0x3350
incq %rbp
cmpq %rbp, %r12
jne 0x4f5b
movq %r14, %rdi
callq 0xbb00
movb $0x1, %bpl
jmp 0x4fb4
movq %r14, %rdi
callq 0xbb00
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x4fd7
callq 0x3350
movq %rbx, %rdi
callq 0x35b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Sherhang[P]redis-for-cpp/credis.cpp
// Function: Redis::execScan(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<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>>>>&)
int32_t Redis::execScan(const std::string& cmd, std::vector<std::string>& values)
{
    if(_context==NULL)
    {
        //DEBUG<<"NULL"<<std::endl;
        return -1;
    }
    redisReply* _reply = (redisReply*)::redisCommand(_context, cmd.c_str());
    if(isError(_reply))
    {
        //DEBUG<<"isError"<<std::endl;
        freeReply(_reply);
        return -2;
    }
    //DEBUG<<"_reply->type "<<_reply->type<<std::endl;
    if(_reply->type != REDIS_REPLY_ARRAY)
    {
        //DEBUG<<"not array"<<std::endl;
        freeReply(_reply);
        return -3;
    }
    redisReply* sub_reply = (_reply->element[1]);
    int32_t len = sub_reply->elements;
    values.clear();//
    values.reserve(len);
    for(int32_t i=0;i<len;++i)
    {
        std::string strTemp(sub_reply->element[i]->str, sub_reply->element[i]->len);
        values.push_back(strTemp);
    }
    int32_t ret = -1;
    std::string strTemp(_reply->element[0]->str, _reply->element[0]->len);
    ret = str2num<int32_t>(strTemp);
    freeReply(_reply);
    return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x5525
movq %rdx, %r15
movq (%rsi), %rsi
xorl %eax, %eax
callq 0xe1b0
testq %rax, %rax
je 0x552c
cmpl $0x2, (%rax)
jne 0x5533
movq %rbx, 0x28(%rsp)
movq %rax, 0x30(%rsp)
movq 0x28(%rax), %rax
movq 0x8(%rax), %rbp
movq 0x20(%rbp), %rbx
movq %r15, %rdi
callq 0xa780
movslq %ebx, %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0xa7c6
leaq 0x18(%rsp), %r13
testl %r12d, %r12d
jle 0x54d7
andl $0x7fffffff, %ebx       # imm = 0x7FFFFFFF
xorl %r14d, %r14d
leaq 0x8(%rsp), %r12
movq 0x28(%rbp), %rax
movq (%rax,%r14,8), %rax
movq 0x18(%rax), %rsi
movq 0x10(%rax), %rdx
addq %rsi, %rdx
movq %r13, 0x8(%rsp)
movq %r12, %rdi
callq 0x42ba
movq %r15, %rdi
movq %r12, %rsi
callq 0xa8a6
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x54cf
callq 0x3350
incq %r14
cmpq %r14, %rbx
jne 0x5495
movq 0x30(%rsp), %r14
movq 0x28(%r14), %rax
movq (%rax), %rax
movq 0x18(%rax), %rsi
movq 0x10(%rax), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
movq %r13, (%rdi)
callq 0x42ba
leaq 0x8(%rsp), %rsi
movq 0x28(%rsp), %rdi
callq 0xa8e4
movl %eax, %ebx
movq %r14, %rdi
callq 0xbb00
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x5540
callq 0x3350
jmp 0x5540
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x5540
movl $0xfffffffe, %ebx       # imm = 0xFFFFFFFE
jmp 0x5540
movq %rax, %rdi
callq 0xbb00
movl $0xfffffffd, %ebx       # imm = 0xFFFFFFFD
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5555
jmp 0x555a
movq %rax, %rbx
jmp 0x556c
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x556c
callq 0x3350
movq %rbx, %rdi
callq 0x35b0
// File: /workspace/github_cpp_makefile_star2_O3/Sherhang[P]redis-for-cpp/credis.cpp
// Function: Redis::type(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string Redis::type(const std::string& key)
{
    std::string ret;
    std::string cmd = "TYPE " + key;
    execReplyString(cmd, ret);
    return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0xe4eb(%rip), %rsi      # 0x1412a
movq %rsp, %rdi
callq 0xa64c
movq %rsp, %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x5d26
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5c68
callq 0x3350
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5c90
callq 0x3350
jmp 0x5c90
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x5c9d
callq 0x3350
movq %r14, %rdi
callq 0x35b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Sherhang[P]redis-for-cpp/credis.cpp
// Function: Redis::ttl(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int64_t Redis::ttl(const std::string& key)
{
    int64_t ret = -3;
    std::string cmd = "TTL " + key;
    execReplyInt(cmd, ret);
    return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq $-0x3, (%r14)
leaq 0xe45d(%rip), %rsi      # 0x14125
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0xa64c
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x4928
movq 0x8(%rsp), %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5cfb
callq 0x3350
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5d1e
callq 0x3350
movq %rbx, %rdi
callq 0x35b0
// File: /workspace/github_cpp_makefile_star2_O3/Sherhang[P]redis-for-cpp/credis.cpp
// Function: Redis::execReplyString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool Redis::execReplyString(const std::string& cmd, std::string& ret)
{
    if(_context==NULL)
    {
        //DEBUG<<"_context is NULL"<<std::endl;
        return false;
    }
    redisReply* _reply = (redisReply*)::redisCommand(_context, cmd.c_str());
    if (!(isError(_reply)))
    {
        if (_reply->type == REDIS_REPLY_STRING || _reply->type == REDIS_REPLY_STATUS)// status --> string
        {
            ret = _reply->str;
            freeReply(_reply);
            return true;
        }

        if (_reply->type == REDIS_REPLY_ERROR)
        {
            std::string reason = _reply->str;
            reason.resize(_reply->len);
            freeReply(_reply);
            return false;
        }
    }
    else
        DEBUG<<"isError(_reply)"<<std::endl;
    freeReply(_reply);
    return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x5ec6
movq %rdx, %r14
movq (%rsi), %rsi
xorl %eax, %eax
callq 0xe1b0
testq %rax, %rax
je 0x5d9e
movq %rax, %rbx
movl (%rax), %eax
cmpl $0x1, %eax
je 0x5d6c
cmpl $0x6, %eax
je 0x5e7d
cmpl $0x5, %eax
jne 0x5ebe
movq 0x18(%rbx), %r15
movq 0x8(%r14), %r12
movq %r15, %rdi
callq 0x3190
movq %r14, %rdi
xorl %esi, %esi
movq %r12, %rdx
movq %r15, %rcx
movq %rax, %r8
callq 0x3500
movq %rbx, %rdi
callq 0xbb00
movb $0x1, %al
jmp 0x5ec8
movq 0x14233(%rip), %rbx     # 0x19fd8
leaq 0xe31f(%rip), %rsi      # 0x140cb
movl $0x7, %edx
movq %rbx, %rdi
callq 0x33f0
leaq 0xe313(%rip), %rsi      # 0x140d3
movl $0xa, %edx
movq %rbx, %rdi
callq 0x33f0
leaq 0xe30a(%rip), %r14      # 0x140de
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x33f0
leaq 0xe418(%rip), %rsi      # 0x14203
movl $0xf, %edx
movq %rbx, %rdi
callq 0x33f0
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x33f0
leaq 0xe2d5(%rip), %rsi      # 0x140e4
movl $0x4, %edx
movq %rbx, %rdi
callq 0x33f0
movq %rbx, %rdi
movl $0x37a, %esi            # imm = 0x37A
callq 0x3590
movq %rax, %rbx
leaq 0xedbf(%rip), %rsi      # 0x14bf2
movl $0x1, %edx
movq %rax, %rdi
callq 0x33f0
leaq 0xe3cc(%rip), %rsi      # 0x14213
movl $0xf, %edx
movq %rbx, %rdi
callq 0x33f0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x3370
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x3280
jmp 0x5ec6
movq 0x18(%rbx), %rsi
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x3170
movq 0x10(%rbx), %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x3100
movq %rbx, %rdi
callq 0xbb00
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5ec6
callq 0x3350
jmp 0x5ec6
movq %rbx, %rdi
callq 0xbb00
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5eea
callq 0x3350
movq %rbx, %rdi
callq 0x35b0
// File: /workspace/github_cpp_makefile_star2_O3/Sherhang[P]redis-for-cpp/credis.cpp
// Function: Redis::execReplyStatus(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool Redis::execReplyStatus(const std::string& cmd)
{
    if(_context==NULL)
    {
        //DEBUG<<"_contex == NULL"<<std::endl;
        return false;
    }
    redisReply* _reply = (redisReply*)::redisCommand(_context, cmd.c_str());
    if (!isError(_reply))
    {
        //DEBUG<<"_reply->type "<<_reply->type<<std::endl;
        //DEBUG<<"_reply->str "<<_reply->str<<std::endl;
        if (_reply->type == REDIS_REPLY_STATUS && strcasecmp(_reply->str, "OK") == 0)
        {
            freeReply(_reply);
            return true;
        }
    }
    freeReply(_reply);
    return false;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x6091
movq (%rsi), %rsi
xorl %ebp, %ebp
xorl %eax, %eax
callq 0xe1b0
testq %rax, %rax
je 0x6093
movq %rax, %rbx
cmpl $0x5, (%rax)
jne 0x6085
movq 0x18(%rbx), %rdi
leaq 0xe0c0(%rip), %rsi      # 0x1413c
callq 0x33c0
testl %eax, %eax
je 0x609c
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0xbb00
jmp 0x6093
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movb $0x1, %bpl
jmp 0x6087
nop
// File: /workspace/github_cpp_makefile_star2_O3/Sherhang[P]redis-for-cpp/credis.cpp
// Function: Redis::get(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string Redis::get(const std::string & key)
{
    std::string value;
    if(_context==NULL)
    {
        return value;
    }
    
    redisReply* _reply = (redisReply*)::redisCommand(_context, "GET %s", key.c_str());
    if (!isError(_reply))
    {
        if (_reply->type == REDIS_REPLY_STRING)
        {
            value = std::string(_reply->str, _reply->len);
            freeReply(_reply);
            return value;
        }
        if (_reply->type == REDIS_REPLY_NIL)
        {
            freeReply(_reply);
            return value;
        }
    }
    freeReply(_reply);
    return value;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rdi
testq %rdi, %rdi
je 0x612c
movq (%rdx), %rdx
leaq 0xe058(%rip), %rsi      # 0x14130
xorl %eax, %eax
callq 0xe1b0
movq %rax, %r14
testq %rax, %rax
je 0x612c
cmpl $0x1, (%r14)
jne 0x6124
movq 0x18(%r14), %rsi
leaq 0x10(%rsp), %r13
movq 0x10(%r14), %rdx
addq %rsi, %rdx
movq %r13, -0x10(%r13)
movq %rsp, %rdi
callq 0x42ba
movq %rsp, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3440
movq (%r15), %rdi
cmpq %r13, %rdi
je 0x6124
callq 0x3350
movq %r14, %rdi
callq 0xbb00
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x613f
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x614f
callq 0x3350
movq %r14, %rdi
callq 0x35b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Sherhang[P]redis-for-cpp/credis.cpp
// Function: Redis::mset(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&, 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&)
bool Redis::mset(const std::vector<std::string> & keys, const std::vector<std::string> & values)
{
    if(_context==NULL)
    {
        return false;
    }
    
    if(keys.size() != values.size())
    {
        return false;
    }
    
    int len = keys.size()+values.size();
    int argc = 1;
    size_t argvlen[len+1];
    argvlen[0] = 4; 
    
    const char* argv[len+1];
    char argv1[] = "MSET";
    argv[0] = argv1;

    for(size_t t=0; t<keys.size(); t++)
    {
        argvlen[argc] = keys[t].size();
        argv[argc] = keys[t].c_str();
        argc++;
        
        argvlen[argc] = values[t].size();
        argv[argc] = values[t].c_str();
        argc++;
    }
    redisReply* _reply = (redisReply*)::redisCommandArgv(_context, argc, argv, argvlen);
    if (_reply && _reply->type == REDIS_REPLY_STATUS )
    {
        if(strcasecmp(_reply->str, "OK") == 0)
        {
            freeReply(_reply);
            return true;
        }
        else
        {
        }
    }
    freeReply(_reply);
    
    return false;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpq $0x0, 0x8(%rdi)
je 0x6221
movq %rdx, %rax
movq 0x8(%rsi), %rdx
subq (%rsi), %rdx
movq 0x8(%rax), %rcx
subq (%rax), %rcx
cmpq %rcx, %rdx
jne 0x6221
movq %rsp, %r15
shrq $0x4, %rdx
incl %edx
movq %rsp, %rcx
leaq 0xf(,%rdx,8), %r8
andq $-0x10, %r8
subq %r8, %rcx
movq %rcx, %rsp
movq $0x4, (%rcx)
movq %rsp, %rdx
subq %r8, %rdx
movq %rdx, %rsp
leaq -0x20(%rbp), %r8
movb $0x0, 0x4(%r8)
movl $0x5445534d, (%r8)      # imm = 0x5445534D
movq %r8, (%rdx)
movq (%rsi), %r8
movq 0x8(%rsi), %r9
subq %r8, %r9
je 0x6225
sarq $0x5, %r9
movq (%rax), %rax
cmpq $0x1, %r9
adcq $0x0, %r9
movl $0x1, %r10d
movl $0x1, %esi
movq (%r8,%r10,8), %r11
movq %r11, (%rcx,%rsi,8)
movq -0x8(%r8,%r10,8), %r11
movq %r11, (%rdx,%rsi,8)
movq (%rax,%r10,8), %r11
movq %r11, 0x8(%rcx,%rsi,8)
movq -0x8(%rax,%r10,8), %r11
movq %r11, 0x8(%rdx,%rsi,8)
addq $0x2, %rsi
addq $0x4, %r10
decq %r9
jne 0x61ee
jmp 0x622a
xorl %ebx, %ebx
jmp 0x6265
movl $0x1, %esi
movq 0x8(%rdi), %rdi
callq 0xe270
testq %rax, %rax
je 0x6260
movq %rax, %r14
cmpl $0x5, (%rax)
jne 0x6254
movq 0x18(%r14), %rdi
leaq 0xdef1(%rip), %rsi      # 0x1413c
callq 0x33c0
testl %eax, %eax
je 0x6272
xorl %ebx, %ebx
movq %r14, %rdi
callq 0xbb00
jmp 0x6262
xorl %ebx, %ebx
movq %r15, %rsp
movl %ebx, %eax
leaq -0x18(%rbp), %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, %bl
jmp 0x6256
// File: /workspace/github_cpp_makefile_star2_O3/Sherhang[P]redis-for-cpp/credis.cpp
// Function: Redis::incr(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int64_t Redis::incr(const std::string& key)
{
    int64_t ret = 0;
    std::string cmd =  "INCR " + key;
    execReplyInt(cmd, ret);
    return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq $0x0, (%r14)
leaq 0xdd0c(%rip), %rsi      # 0x14144
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0xa64c
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x4928
movq 0x8(%rsp), %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x646b
callq 0x3350
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x648e
callq 0x3350
movq %rbx, %rdi
callq 0x35b0
// File: /workspace/github_cpp_makefile_star2_O3/Sherhang[P]redis-for-cpp/credis.cpp
// Function: Redis::incrby(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, long)
int64_t Redis::incrby(const std::string& key, int64_t incr)
{
    int64_t ret = 0;
    std::string cmd =  "INCRBY " + key + " " + num2str<int64_t>(incr);
    execReplyInt(cmd, ret);
    return ret;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rsi, %rax
movq %rdi, %rbx
movq %rdx, 0x70(%rsp)
movq $0x0, 0x8(%rsp)
leaq 0xdcc0(%rip), %rsi      # 0x1417b
leaq 0x78(%rsp), %r14
movq %r14, %rdi
movq %rax, %rdx
callq 0xa64c
leaq 0xe720(%rip), %rsi      # 0x14bf2
movq %r14, %rdi
callq 0x3600
leaq 0x40(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x6501
movq %rdx, 0x30(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x40(%rsp)
jmp 0x6508
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
movq %rdx, 0x38(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x50(%rsp), %rdi
leaq 0x70(%rsp), %rdx
movq %rbx, %rsi
callq 0xa6ce
movq 0x30(%rsp), %rcx
movq 0x38(%rsp), %r8
movq 0x58(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %edi
cmpq %r14, %rcx
je 0x6554
movq 0x40(%rsp), %rdi
movq 0x50(%rsp), %rsi
cmpq %rdi, %rax
jbe 0x6577
leaq 0x60(%rsp), %r9
movl $0xf, %edi
cmpq %r9, %rsi
je 0x6572
movq 0x60(%rsp), %rdi
cmpq %rdi, %rax
jbe 0x6583
leaq 0x30(%rsp), %rdi
callq 0x3110
jmp 0x6591
leaq 0x50(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x33e0
leaq 0x20(%rsp), %rdx
movq %rdx, -0x10(%rdx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
je 0x65b5
movq %rsi, 0x10(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x20(%rsp)
jmp 0x65bb
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x18(%rsp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x65eb
callq 0x3350
movq 0x30(%rsp), %rdi
cmpq %r14, %rdi
je 0x65fa
callq 0x3350
leaq 0x88(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6610
callq 0x3350
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x4928
movq 0x8(%rsp), %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x663a
callq 0x3350
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rax
jmp 0x6689
movq %rax, %rbx
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x666d
callq 0x3350
jmp 0x666d
movq %rax, %rbx
movq 0x30(%rsp), %rdi
cmpq %r14, %rdi
je 0x6681
callq 0x3350
jmp 0x6681
movq %rax, %rbx
leaq 0x88(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6697
callq 0x3350
movq %rbx, %rdi
callq 0x35b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Sherhang[P]redis-for-cpp/credis.cpp
// Function: Redis::incrbyfloat(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, float)
float Redis::incrbyfloat(const std::string& key, float incr)
{
    float ret  = 0;
    std::string cmd =  "INCRBYFLOAT " + key + " " + num2str<float>(incr);
    std::string s;
    if (execReplyString(cmd, s))
    {
        ret = str2num<float>(s);
        return ret;
    }
    return ret;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rsi, %rdx
movq %rdi, %rbx
movss %xmm0, 0x4(%rsp)
leaq 0xda8d(%rip), %rsi      # 0x1414a
leaq 0x68(%rsp), %r14
movq %r14, %rdi
callq 0xa64c
leaq 0xe521(%rip), %rsi      # 0x14bf2
movq %r14, %rdi
callq 0x3600
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x6700
movq %rdx, 0x8(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x18(%rsp)
jmp 0x6707
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
movq %rdx, 0x10(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x48(%rsp), %rdi
leaq 0x4(%rsp), %rdx
movq %rbx, %rsi
callq 0xa970
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %r8
movq 0x50(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %edi
cmpq %r14, %rcx
je 0x6753
movq 0x18(%rsp), %rdi
movq 0x48(%rsp), %rsi
cmpq %rdi, %rax
jbe 0x6776
leaq 0x58(%rsp), %r9
movl $0xf, %edi
cmpq %r9, %rsi
je 0x6771
movq 0x58(%rsp), %rdi
cmpq %rdi, %rax
jbe 0x6782
leaq 0x8(%rsp), %rdi
callq 0x3110
jmp 0x6790
leaq 0x48(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x33e0
leaq 0x38(%rsp), %rdx
movq %rdx, -0x10(%rdx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
je 0x67b4
movq %rsi, 0x28(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x38(%rsp)
jmp 0x67ba
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x30(%rsp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x67ea
callq 0x3350
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x67f9
callq 0x3350
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x680c
callq 0x3350
leaq 0x8(%rsp), %rdx
movq %r14, (%rdx)
movq $0x0, 0x8(%rdx)
movb $0x0, 0x10(%rdx)
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x5d26
xorps %xmm0, %xmm0
testb %al, %al
je 0x6841
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xaa24
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
movss %xmm0, (%rsp)
je 0x685a
callq 0x3350
movss (%rsp), %xmm0
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6872
callq 0x3350
movss (%rsp), %xmm0
addq $0x88, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6898
callq 0x3350
jmp 0x6898
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x68ac
callq 0x3350
jmp 0x68ac
movq %rax, %rbx
leaq 0x78(%rsp), %rax
jmp 0x68ca
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x68c5
callq 0x3350
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x68d8
callq 0x3350
movq %rbx, %rdi
callq 0x35b0
// File: /workspace/github_cpp_makefile_star2_O3/Sherhang[P]redis-for-cpp/credis.cpp
// Function: Redis::decr(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int64_t Redis::decr(const std::string& key)
{
    int64_t ret = 0;
    std::string cmd =  "DECR " + key;
    execReplyInt(cmd, ret);
    return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq $0x0, (%r14)
leaq 0xd855(%rip), %rsi      # 0x14157
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0xa64c
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x4928
movq 0x8(%rsp), %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6935
callq 0x3350
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6958
callq 0x3350
movq %rbx, %rdi
callq 0x35b0
// File: /workspace/github_cpp_makefile_star2_O3/Sherhang[P]redis-for-cpp/credis.cpp
// Function: Redis::decrby(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, long)
int64_t Redis::decrby(const std::string& key, int64_t decr)
{
    int64_t ret = 0;
    std::string cmd =  "DECRBY " + key + " " + num2str<int64_t>(decr);
    execReplyInt(cmd, ret);
    return ret;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rsi, %rax
movq %rdi, %rbx
movq %rdx, 0x70(%rsp)
movq $0x0, 0x8(%rsp)
leaq 0xd7d8(%rip), %rsi      # 0x1415d
leaq 0x78(%rsp), %r14
movq %r14, %rdi
movq %rax, %rdx
callq 0xa64c
leaq 0xe256(%rip), %rsi      # 0x14bf2
movq %r14, %rdi
callq 0x3600
leaq 0x40(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x69cb
movq %rdx, 0x30(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x40(%rsp)
jmp 0x69d2
movups (%rcx), %xmm0
movups %xmm0, (%r14)
movq 0x8(%rax), %rdx
movq %rdx, 0x38(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x50(%rsp), %rdi
leaq 0x70(%rsp), %rdx
movq %rbx, %rsi
callq 0xa6ce
movq 0x30(%rsp), %rcx
movq 0x38(%rsp), %r8
movq 0x58(%rsp), %rdx
leaq (%rdx,%r8), %rax
movl $0xf, %edi
cmpq %r14, %rcx
je 0x6a1e
movq 0x40(%rsp), %rdi
movq 0x50(%rsp), %rsi
cmpq %rdi, %rax
jbe 0x6a41
leaq 0x60(%rsp), %r9
movl $0xf, %edi
cmpq %r9, %rsi
je 0x6a3c
movq 0x60(%rsp), %rdi
cmpq %rdi, %rax
jbe 0x6a4d
leaq 0x30(%rsp), %rdi
callq 0x3110
jmp 0x6a5b
leaq 0x50(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x33e0
leaq 0x20(%rsp), %rdx
movq %rdx, -0x10(%rdx)
movq (%rax), %rsi
leaq 0x10(%rax), %rcx
cmpq %rcx, %rsi
je 0x6a7f
movq %rsi, 0x10(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x20(%rsp)
jmp 0x6a85
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq %rax, %rdx
addq $0x8, %rdx
movq 0x8(%rax), %rsi
movq %rsi, 0x18(%rsp)
movq %rcx, (%rax)
movq $0x0, (%rdx)
movb $0x0, (%rcx)
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6ab5
callq 0x3350
movq 0x30(%rsp), %rdi
cmpq %r14, %rdi
je 0x6ac4
callq 0x3350
leaq 0x88(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6ada
callq 0x3350
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x4928
movq 0x8(%rsp), %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6b04
callq 0x3350
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rax
jmp 0x6b53
movq %rax, %rbx
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6b37
callq 0x3350
jmp 0x6b37
movq %rax, %rbx
movq 0x30(%rsp), %rdi
cmpq %r14, %rdi
je 0x6b4b
callq 0x3350
jmp 0x6b4b
movq %rax, %rbx
leaq 0x88(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6b61
callq 0x3350
movq %rbx, %rdi
callq 0x35b0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Sherhang[P]redis-for-cpp/credis.cpp
// Function: Redis::zcard(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int64_t Redis::zcard(const std::string& key)
{
    int64_t ret = -1;
    std::string cmd =  "ZCARD " + key;
    execReplyInt(cmd, ret);
    return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq $-0x1, (%r14)
leaq 0xd3d1(%rip), %rsi      # 0x1416b
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0xa64c
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x4928
movq 0x8(%rsp), %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6dcd
callq 0x3350
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6df0
callq 0x3350
movq %rbx, %rdi
callq 0x35b0
// File: /workspace/github_cpp_makefile_star2_O3/Sherhang[P]redis-for-cpp/credis.cpp
// Function: Redis::zscore(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string Redis::zscore(const std::string& key, const std::string& member)
{
    std::string score;
    std::string cmd = "ZSCORE " + key + " " + member;
    execReplyString(cmd, score);
    return score;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rcx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0xbb8d(%rip), %rsi      # 0x141c5
leaq 0x40(%rsp), %rdi
callq 0xa64c
leaq 0xc5a9(%rip), %rsi      # 0x14bf2
leaq 0x40(%rsp), %rdi
callq 0x3600
leaq 0x30(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x867a
movq %rdx, 0x20(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x30(%rsp)
jmp 0x8682
movups (%rcx), %xmm0
movups %xmm0, (%r13)
movq 0x8(%rax), %rdx
leaq 0x20(%rsp), %rdi
movq %rdx, 0x8(%rdi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
callq 0x3110
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x86d0
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x86d7
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x86fe
callq 0x3350
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8711
callq 0x3350
movq %rsp, %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x5d26
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x872d
callq 0x3350
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
jne 0x8771
jmp 0x877b
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x8763
callq 0x3350
jmp 0x8763
movq %rax, %r14
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x877b
callq 0x3350
jmp 0x877b
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x8788
callq 0x3350
movq %r14, %rdi
callq 0x35b0
// File: /workspace/github_cpp_makefile_star2_O3/Sherhang[P]redis-for-cpp/credis.cpp
// Function: Redis::exec(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool Redis::exec(const std::string& cmd)
{
    if(_context==NULL) 
    {
        return false;
    }
    redisReply* _reply = (redisReply*)::redisCommand(_context, cmd.c_str());
    if(isError(_reply))
    {
        freeReply(_reply);
        return false;
    }
    return true;
}

// Assembly:
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x976d
pushq %rax
movq (%rsi), %rsi
xorl %eax, %eax
callq 0xe1b0
testq %rax, %rax
setne %al
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/Sherhang[P]redis-for-cpp/credis.cpp
// Function: Redis::hmget(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<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&, 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>>>>&)
bool Redis::hmget(const std::string& key, const std::vector<std::string> & fields, std::vector<std::string> & values)
{
    if(_context == NULL) 
    {
        return false;
    }
    values.clear();
    std::string cmd = "HMGET " + key;
    for(uint32_t i = 0; i < fields.size(); ++i)
    {
        cmd = cmd + " " + fields[i];
    }
    return exec(cmd, values);

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
cmpq $0x0, 0x8(%rdi)
je 0x98ce
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, 0x8(%rsp)
movq %rcx, 0x10(%rsp)
movq %rcx, %rdi
callq 0xa780
leaq 0xaa3a(%rip), %rsi      # 0x141e2
leaq 0x38(%rsp), %rdi
movq %rbx, %rdx
callq 0xa64c
movq 0x8(%r15), %rax
cmpq (%r15), %rax
je 0x98a3
leaq 0x68(%rsp), %r14
movl $0x1, %r13d
leaq 0x28(%rsp), %rbp
xorl %ebx, %ebx
leaq 0x58(%rsp), %r12
movq %r14, 0x58(%rsp)
movq 0x38(%rsp), %rsi
movq 0x40(%rsp), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0xabea
movq %r12, %rdi
leaq 0xb3f5(%rip), %rsi      # 0x14bf2
callq 0x3600
movq (%r15), %rax
shlq $0x5, %rbx
movq (%rax,%rbx), %rsi
movq 0x8(%rax,%rbx), %rdx
movq %r12, %rdi
callq 0x3110
movq %rbp, 0x18(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x983d
movq %rdx, 0x18(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x28(%rsp)
jmp 0x9844
movups (%rcx), %xmm0
movups %xmm0, (%rbp)
movq 0x8(%rax), %rdx
movq %rdx, 0x20(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x3440
movq 0x18(%rsp), %rdi
cmpq %rbp, %rdi
je 0x987a
callq 0x3350
movq 0x58(%rsp), %rdi
cmpq %r14, %rdi
je 0x9889
callq 0x3350
movq 0x8(%r15), %rax
subq (%r15), %rax
movl %r13d, %ebx
sarq $0x5, %rax
incl %r13d
cmpq %rbx, %rax
ja 0x97d9
leaq 0x38(%rsp), %rsi
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
callq 0x4560
movl %eax, %ebx
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x98d0
callq 0x3350
jmp 0x98d0
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x98e3
movq %rax, %rbx
jmp 0x98fc
jmp 0x98ea
movq %rax, %rbx
movq 0x58(%rsp), %rdi
cmpq %r14, %rdi
je 0x98fc
callq 0x3350
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x990f
callq 0x3350
movq %rbx, %rdi
callq 0x35b0
nop