LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, 0x8(%rax)
jne 0x7518
movb $0x0, -0x1(%rbp)
jmp 0x7598
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3190
movq -0x30(%rbp), %rdi
movq %rax, %rsi
movb $0x0, %al
callq 0x11a60
movq -0x28(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
callq 0x59f0
testb $0x1, %al
jne 0x7587
movq -0x20(%rbp), %rax
cmpl $0x5, (%rax)
jne 0x7585
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdi
leaq 0x10bac(%rip), %rsi     # 0x18114
callq 0x3430
cmpl $0x0, %eax
jne 0x7585
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x59c0
movb $0x1, -0x1(%rbp)
jmp 0x7598
jmp 0x7587
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x59c0
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x3530
movq -0x68(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x75fe
movb $0x1, -0x19(%rbp)
movl $0x1, -0x20(%rbp)
jmp 0x7753
movq -0x68(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x88(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3190
movq -0x88(%rbp), %rdi
movq %rax, %rdx
leaq 0x10ae1(%rip), %rsi     # 0x18108
xorl %eax, %eax
callq 0x11a60
movq %rax, -0x80(%rbp)
jmp 0x7634
movq -0x68(%rbp), %rdi
movq -0x80(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
callq 0x59f0
testb $0x1, %al
jne 0x7739
movq -0x28(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x7712
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rcx
movq %rcx, -0x98(%rbp)
movq 0x18(%rax), %rax
movq %rax, -0xa0(%rbp)
leaq -0x59(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x3670
movq -0xa0(%rbp), %rsi
movq -0x98(%rbp), %rdx
movq -0x90(%rbp), %rcx
leaq -0x58(%rbp), %rdi
callq 0x3450
jmp 0x76a8
movq -0x78(%rbp), %rdi
leaq -0x58(%rbp), %rsi
movq %rsi, -0xa8(%rbp)
callq 0x34a0
movq -0xa8(%rbp), %rdi
callq 0x3290
leaq -0x59(%rbp), %rdi
callq 0x3410
movq -0x68(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x59c0
jmp 0x76e0
movb $0x1, -0x19(%rbp)
movl $0x1, -0x20(%rbp)
jmp 0x7753
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x776f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x59(%rbp), %rdi
callq 0x3410
jmp 0x776f
movq -0x28(%rbp), %rax
cmpl $0x4, (%rax)
jne 0x7737
movq -0x68(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x59c0
jmp 0x772a
movb $0x1, -0x19(%rbp)
movl $0x1, -0x20(%rbp)
jmp 0x7753
jmp 0x7739
movq -0x68(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x59c0
jmp 0x7748
movb $0x1, -0x19(%rbp)
movl $0x1, -0x20(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x7762
movq -0x78(%rbp), %rdi
callq 0x3290
movq -0x70(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x3290
movq -0x30(%rbp), %rdi
callq 0x3660
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdx
leaq 0x10411(%rip), %rsi     # 0x1811c
leaq -0x38(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0xb510
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x5bc0
jmp 0x7d2b
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3290
movq -0x60(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3290
movq -0x40(%rbp), %rdi
callq 0x3660
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdx
leaq 0x103ae(%rip), %rsi     # 0x18153
leaq -0x80(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0xb510
movq -0xb8(%rbp), %rsi
leaq 0x10e0f(%rip), %rdx     # 0x18bd2
leaq -0x60(%rbp), %rdi
callq 0xb6f0
jmp 0x7dce
movq -0xc0(%rbp), %rsi
leaq -0xb0(%rbp), %rdi
leaq -0x18(%rbp), %rdx
callq 0xb740
jmp 0x7de7
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rsi
leaq -0xb0(%rbp), %rdx
callq 0xb620
jmp 0x7dfd
leaq -0xb0(%rbp), %rdi
callq 0x3290
leaq -0x60(%rbp), %rdi
callq 0x3290
leaq -0x80(%rbp), %rdi
callq 0x3290
movq -0xc0(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x5bc0
jmp 0x7e31
movq -0x20(%rbp), %rax
movq %rax, -0xc8(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3290
movq -0xc8(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x7ea4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x7e9b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x3290
leaq -0x60(%rbp), %rdi
callq 0x3290
leaq -0x80(%rbp), %rdi
callq 0x3290
jmp 0x7eca
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3290
movq -0x88(%rbp), %rdi
callq 0x3660
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movss %xmm0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xe8(%rbp)
movl $0x0, -0x20(%rbp)
movq -0x18(%rbp), %rdx
leaq 0x1020d(%rip), %rsi     # 0x18122
leaq -0x80(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0xb510
movq -0xe0(%rbp), %rsi
leaq 0x10c9f(%rip), %rdx     # 0x18bd2
leaq -0x60(%rbp), %rdi
callq 0xb6f0
jmp 0x7f3e
movq -0xe8(%rbp), %rsi
leaq -0xb0(%rbp), %rdi
leaq -0x1c(%rbp), %rdx
callq 0xbae0
jmp 0x7f57
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rsi
leaq -0xb0(%rbp), %rdx
callq 0xb620
jmp 0x7f6d
leaq -0xb0(%rbp), %rdi
callq 0x3290
leaq -0x60(%rbp), %rdi
callq 0x3290
leaq -0x80(%rbp), %rdi
callq 0x3290
leaq -0xd0(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
callq 0x3530
movq -0xe8(%rbp), %rdi
movq -0xf8(%rbp), %rdx
leaq -0x40(%rbp), %rsi
callq 0x71c0
movb %al, -0xe9(%rbp)
jmp 0x7fbd
movb -0xe9(%rbp), %al
testb $0x1, %al
jne 0x7fcc
jmp 0x8092
movq -0xe8(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
callq 0xbbe0
movss %xmm0, -0xfc(%rbp)
jmp 0x7fe9
movss -0xfc(%rbp), %xmm0
movss %xmm0, -0x20(%rbp)
movss -0x20(%rbp), %xmm0
movss %xmm0, -0x4(%rbp)
movl $0x1, -0xd4(%rbp)
jmp 0x80a6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x805e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x8055
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x3290
leaq -0x60(%rbp), %rdi
callq 0x3290
leaq -0x80(%rbp), %rdi
callq 0x3290
jmp 0x80c9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0x3290
leaq -0x40(%rbp), %rdi
callq 0x3290
jmp 0x80c9
movss -0x20(%rbp), %xmm0
movss %xmm0, -0x4(%rbp)
movl $0x1, -0xd4(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0x3290
leaq -0x40(%rbp), %rdi
callq 0x3290
movss -0x4(%rbp), %xmm0
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0x3660
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rdx
leaq 0x10024(%rip), %rsi     # 0x1812f
leaq -0x38(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0xb510
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x5bc0
jmp 0x812b
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3290
movq -0x60(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3290
movq -0x40(%rbp), %rdi
callq 0x3660
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rdx
leaq 0xff90(%rip), %rsi      # 0x18135
leaq -0x80(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0xb510
movq -0xb8(%rbp), %rsi
leaq 0x10a0f(%rip), %rdx     # 0x18bd2
leaq -0x60(%rbp), %rdi
callq 0xb6f0
jmp 0x81ce
movq -0xc0(%rbp), %rsi
leaq -0xb0(%rbp), %rdi
leaq -0x18(%rbp), %rdx
callq 0xb740
jmp 0x81e7
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rsi
leaq -0xb0(%rbp), %rdx
callq 0xb620
jmp 0x81fd
leaq -0xb0(%rbp), %rdi
callq 0x3290
leaq -0x60(%rbp), %rdi
callq 0x3290
leaq -0x80(%rbp), %rdi
callq 0x3290
movq -0xc0(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x5bc0
jmp 0x8231
movq -0x20(%rbp), %rax
movq %rax, -0xc8(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3290
movq -0xc8(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x82a4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x829b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x3290
leaq -0x60(%rbp), %rdi
callq 0x3290
leaq -0x80(%rbp), %rdi
callq 0x3290
jmp 0x82ca
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3290
movq -0x88(%rbp), %rdi
callq 0x3660
nopw %cs:(%rax,%rax)
// File: Sherhang[P]redis-for-cpp/credis.cpp
// Function: Redis::zadd(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<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&)
int64_t Redis::zadd(const std::string& key, const std::map<std::string, std::string>& members)
{
    int64_t ret = -1;
    std::string cmd =  "ZADD " + key;
    std::map<std::string, std::string>::const_iterator it = members.begin();
    for (; it != members.end(); ++it)
    {
        cmd += " " + it->first + " " + it->second;
    }
    execReplyInt(cmd, ret);
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq $-0x1, -0x20(%rbp)
movq -0x10(%rbp), %rdx
leaq -0x40(%rbp), %rdi
leaq 0xfe24(%rip), %rsi      # 0x1813d
callq 0xb510
movq -0x18(%rbp), %rdi
callq 0xbc80
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rdi
callq 0xbce0
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xbcb0
testb $0x1, %al
jne 0x834e
jmp 0x845f
leaq -0x48(%rbp), %rdi
callq 0xbd10
movq %rax, %rdx
leaq 0x10871(%rip), %rsi     # 0x18bd2
leaq -0xb0(%rbp), %rdi
callq 0xb510
jmp 0x836f
leaq 0x1085c(%rip), %rdx     # 0x18bd2
leaq -0x90(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0xb6f0
jmp 0x838b
leaq -0x48(%rbp), %rdi
callq 0xbd10
movq %rax, %rdx
addq $0x20, %rdx
leaq -0x70(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x46d0
jmp 0x83ad
leaq -0x40(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x34d0
jmp 0x83bc
leaq -0x70(%rbp), %rdi
callq 0x3290
leaq -0x90(%rbp), %rdi
callq 0x3290
leaq -0xb0(%rbp), %rdi
callq 0x3290
leaq -0x48(%rbp), %rdi
callq 0xbd40
jmp 0x832b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x8499
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x8451
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x8445
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x3290
leaq -0x90(%rbp), %rdi
callq 0x3290
leaq -0xb0(%rbp), %rdi
callq 0x3290
jmp 0x8499
movq -0xc8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x5bc0
jmp 0x8475
movq -0x20(%rbp), %rax
movq %rax, -0xd0(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3290
movq -0xd0(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
leaq -0x40(%rbp), %rdi
callq 0x3290
movq -0xb8(%rbp), %rdi
callq 0x3660
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq $-0x1, -0x18(%rbp)
movq -0x10(%rbp), %rdx
leaq 0xfc68(%rip), %rsi      # 0x18143
leaq -0x38(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0xb510
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x5bc0
jmp 0x84fb
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3290
movq -0x60(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3290
movq -0x40(%rbp), %rdi
callq 0x3660
nopw %cs:(%rax,%rax)
// File: Sherhang[P]redis-for-cpp/credis.cpp
// Function: Redis::zcount(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, double, double)
int64_t Redis::zcount(const std::string& key, double min, double max)
{
    int64_t ret = -1;
    std::string cmd = "ZCOUNT " + key + " " + num2str<double>(min) + " " + num2str<double>(max);
    //DEBUG<<cmd<<std::endl;
    execReplyInt(cmd, ret);
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x128(%rbp)
movq $-0x1, -0x28(%rbp)
movq -0x10(%rbp), %rdx
leaq 0xfbcf(%rip), %rsi      # 0x1814a
leaq -0xc8(%rbp), %rdi
movq %rdi, -0x120(%rbp)
callq 0xb510
movq -0x120(%rbp), %rsi
leaq 0x10636(%rip), %rdx     # 0x18bd2
leaq -0xa8(%rbp), %rdi
callq 0xb6f0
jmp 0x85aa
movq -0x128(%rbp), %rsi
leaq -0xf8(%rbp), %rdi
leaq -0x18(%rbp), %rdx
callq 0xbd70
jmp 0x85c3
leaq -0x88(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
leaq -0xf8(%rbp), %rdx
callq 0xb620
jmp 0x85df
leaq 0x105ec(%rip), %rdx     # 0x18bd2
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0xb6f0
jmp 0x85f8
movq -0x128(%rbp), %rsi
leaq -0x118(%rbp), %rdi
leaq -0x20(%rbp), %rdx
callq 0xbd70
jmp 0x8611
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
leaq -0x118(%rbp), %rdx
callq 0xb620
jmp 0x8627
leaq -0x118(%rbp), %rdi
callq 0x3290
leaq -0x68(%rbp), %rdi
callq 0x3290
leaq -0x88(%rbp), %rdi
callq 0x3290
leaq -0xf8(%rbp), %rdi
callq 0x3290
leaq -0xa8(%rbp), %rdi
callq 0x3290
leaq -0xc8(%rbp), %rdi
callq 0x3290
movq -0x128(%rbp), %rdi
leaq -0x48(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x5bc0
jmp 0x8682
movq -0x28(%rbp), %rax
movq %rax, -0x130(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3290
movq -0x130(%rbp), %rax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
jmp 0x8758
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
jmp 0x874c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
jmp 0x8740
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
jmp 0x8734
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
jmp 0x872b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
leaq -0x118(%rbp), %rdi
callq 0x3290
leaq -0x68(%rbp), %rdi
callq 0x3290
leaq -0x88(%rbp), %rdi
callq 0x3290
leaq -0xf8(%rbp), %rdi
callq 0x3290
leaq -0xa8(%rbp), %rdi
callq 0x3290
leaq -0xc8(%rbp), %rdi
callq 0x3290
jmp 0x8781
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3290
movq -0xd0(%rbp), %rdi
callq 0x3660
nopl (%rax)
// File: Sherhang[P]redis-for-cpp/credis.cpp
// Function: Redis::zincrby(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, double, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string Redis::zincrby(const std::string& key, double incr, const std::string& member)
{
    std::string ret;
    std::string cmd = "ZINCRBY " + key + " " + num2str<double>(incr) + " " + member;
    execReplyString(cmd, ret);
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x118(%rbp)
movq %rdi, %rax
movq %rax, -0x110(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x108(%rbp)
movb $0x0, -0x29(%rbp)
callq 0x3530
movq -0x18(%rbp), %rdx
leaq 0xf972(%rip), %rsi      # 0x18152
leaq -0xd0(%rbp), %rdi
callq 0xb510
jmp 0x87ee
leaq 0x103dd(%rip), %rdx     # 0x18bd2
leaq -0xb0(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
callq 0xb6f0
jmp 0x880a
movq -0x108(%rbp), %rsi
leaq -0x100(%rbp), %rdi
leaq -0x20(%rbp), %rdx
callq 0xbd70
jmp 0x8823
leaq -0x90(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
leaq -0x100(%rbp), %rdx
callq 0xb620
jmp 0x883f
leaq 0x1038c(%rip), %rdx     # 0x18bd2
leaq -0x70(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0xb6f0
jmp 0x8858
movq -0x28(%rbp), %rdx
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x46d0
jmp 0x886b
leaq -0x70(%rbp), %rdi
callq 0x3290
leaq -0x90(%rbp), %rdi
callq 0x3290
leaq -0x100(%rbp), %rdi
callq 0x3290
leaq -0xb0(%rbp), %rdi
callq 0x3290
leaq -0xd0(%rbp), %rdi
callq 0x3290
movq -0x108(%rbp), %rdi
movq -0x118(%rbp), %rdx
leaq -0x50(%rbp), %rsi
callq 0x71c0
jmp 0x88bd
movb $0x1, -0x29(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x3290
testb $0x1, -0x29(%rbp)
jne 0x89b6
jmp 0x89aa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0x89c6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0x897f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0x8973
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0x8967
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0x895b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x3290
leaq -0x90(%rbp), %rdi
callq 0x3290
leaq -0x100(%rbp), %rdi
callq 0x3290
leaq -0xb0(%rbp), %rdi
callq 0x3290
leaq -0xd0(%rbp), %rdi
callq 0x3290
jmp 0x89c6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x3290
jmp 0x89c6
movq -0x118(%rbp), %rdi
callq 0x3290
movq -0x110(%rbp), %rax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
movq -0x118(%rbp), %rdi
callq 0x3290
movq -0xd8(%rbp), %rdi
callq 0x3660
nop
// File: Sherhang[P]redis-for-cpp/credis.cpp
// Function: Redis::zremrangebyrank(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, long, long)
int64_t Redis::zremrangebyrank(const std::string& key, int64_t start, int64_t stop)
{
    int64_t ret = -1;
    std::string cmd = "ZREMRANGEBYRANK " + key + " " + num2str<int64_t>(start) + " " + num2str<int64_t>(stop);
    execReplyInt(cmd, ret);
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x128(%rbp)
movq $-0x1, -0x28(%rbp)
movq -0x10(%rbp), %rdx
leaq 0xf1a1(%rip), %rsi      # 0x1817a
leaq -0xc8(%rbp), %rdi
movq %rdi, -0x120(%rbp)
callq 0xb510
movq -0x120(%rbp), %rsi
leaq 0xfbd8(%rip), %rdx      # 0x18bd2
leaq -0xa8(%rbp), %rdi
callq 0xb6f0
jmp 0x9008
movq -0x128(%rbp), %rsi
leaq -0xf8(%rbp), %rdi
leaq -0x18(%rbp), %rdx
callq 0xb740
jmp 0x9021
leaq -0x88(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
leaq -0xf8(%rbp), %rdx
callq 0xb620
jmp 0x903d
leaq 0xfb8e(%rip), %rdx      # 0x18bd2
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0xb6f0
jmp 0x9056
movq -0x128(%rbp), %rsi
leaq -0x118(%rbp), %rdi
leaq -0x20(%rbp), %rdx
callq 0xb740
jmp 0x906f
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
leaq -0x118(%rbp), %rdx
callq 0xb620
jmp 0x9085
leaq -0x118(%rbp), %rdi
callq 0x3290
leaq -0x68(%rbp), %rdi
callq 0x3290
leaq -0x88(%rbp), %rdi
callq 0x3290
leaq -0xf8(%rbp), %rdi
callq 0x3290
leaq -0xa8(%rbp), %rdi
callq 0x3290
leaq -0xc8(%rbp), %rdi
callq 0x3290
movq -0x128(%rbp), %rdi
leaq -0x48(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x5bc0
jmp 0x90e0
movq -0x28(%rbp), %rax
movq %rax, -0x130(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3290
movq -0x130(%rbp), %rax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
jmp 0x91b6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
jmp 0x91aa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
jmp 0x919e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
jmp 0x9192
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
jmp 0x9189
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
leaq -0x118(%rbp), %rdi
callq 0x3290
leaq -0x68(%rbp), %rdi
callq 0x3290
leaq -0x88(%rbp), %rdi
callq 0x3290
leaq -0xf8(%rbp), %rdi
callq 0x3290
leaq -0xa8(%rbp), %rdi
callq 0x3290
leaq -0xc8(%rbp), %rdi
callq 0x3290
jmp 0x91df
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3290
movq -0xd0(%rbp), %rdi
callq 0x3660
nopl (%rax,%rax)
// File: Sherhang[P]redis-for-cpp/credis.cpp
// Function: Redis::zremrangebyscore(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, double, double)
int64_t Redis::zremrangebyscore(const std::string& key, double min, double max)
{
    int64_t ret = -1;
    std::string cmd = "ZREMRANGEBYSCORE " + key + " " + num2str<double>(min) + " "
        + num2str<double>(max);
    execReplyInt(cmd, ret);
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x128(%rbp)
movq $-0x1, -0x28(%rbp)
movq -0x10(%rbp), %rdx
leaq 0xef60(%rip), %rsi      # 0x1818b
leaq -0xc8(%rbp), %rdi
movq %rdi, -0x120(%rbp)
callq 0xb510
movq -0x120(%rbp), %rsi
leaq 0xf986(%rip), %rdx      # 0x18bd2
leaq -0xa8(%rbp), %rdi
callq 0xb6f0
jmp 0x925a
movq -0x128(%rbp), %rsi
leaq -0xf8(%rbp), %rdi
leaq -0x18(%rbp), %rdx
callq 0xbd70
jmp 0x9273
leaq -0x88(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
leaq -0xf8(%rbp), %rdx
callq 0xb620
jmp 0x928f
leaq 0xf93c(%rip), %rdx      # 0x18bd2
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0xb6f0
jmp 0x92a8
movq -0x128(%rbp), %rsi
leaq -0x118(%rbp), %rdi
leaq -0x20(%rbp), %rdx
callq 0xbd70
jmp 0x92c1
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
leaq -0x118(%rbp), %rdx
callq 0xb620
jmp 0x92d7
leaq -0x118(%rbp), %rdi
callq 0x3290
leaq -0x68(%rbp), %rdi
callq 0x3290
leaq -0x88(%rbp), %rdi
callq 0x3290
leaq -0xf8(%rbp), %rdi
callq 0x3290
leaq -0xa8(%rbp), %rdi
callq 0x3290
leaq -0xc8(%rbp), %rdi
callq 0x3290
movq -0x128(%rbp), %rdi
leaq -0x48(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0x5bc0
jmp 0x9332
movq -0x28(%rbp), %rax
movq %rax, -0x130(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3290
movq -0x130(%rbp), %rax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
jmp 0x9408
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
jmp 0x93fc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
jmp 0x93f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
jmp 0x93e4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
jmp 0x93db
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
leaq -0x118(%rbp), %rdi
callq 0x3290
leaq -0x68(%rbp), %rdi
callq 0x3290
leaq -0x88(%rbp), %rdi
callq 0x3290
leaq -0xf8(%rbp), %rdi
callq 0x3290
leaq -0xa8(%rbp), %rdi
callq 0x3290
leaq -0xc8(%rbp), %rdi
callq 0x3290
jmp 0x9431
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3290
movq -0xd0(%rbp), %rdi
callq 0x3660
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0xb0(%rbp)
movq %rdi, %rax
movq %rax, -0xa8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa0(%rbp)
movb $0x0, -0x21(%rbp)
callq 0x3530
movq -0x18(%rbp), %rdx
leaq 0xed12(%rip), %rsi      # 0x1819d
leaq -0x88(%rbp), %rdi
callq 0xb510
jmp 0x9499
leaq 0xf732(%rip), %rdx      # 0x18bd2
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0xb6f0
jmp 0x94b2
movq -0x20(%rbp), %rdx
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x46d0
jmp 0x94c5
leaq -0x68(%rbp), %rdi
callq 0x3290
leaq -0x88(%rbp), %rdi
callq 0x3290
movq -0xa0(%rbp), %rdi
movq -0xb0(%rbp), %rdx
leaq -0x48(%rbp), %rsi
callq 0x71c0
jmp 0x94f3
movb $0x1, -0x21(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3290
testb $0x1, -0x21(%rbp)
jne 0x9582
jmp 0x9576
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x9592
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x954b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x3290
leaq -0x88(%rbp), %rdi
callq 0x3290
jmp 0x9592
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3290
jmp 0x9592
movq -0xb0(%rbp), %rdi
callq 0x3290
movq -0xa8(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0xb0(%rbp), %rdi
callq 0x3290
movq -0x90(%rbp), %rdi
callq 0x3660
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, 0x8(%rax)
jne 0xa415
movb $0x0, -0x1(%rbp)
jmp 0xa466
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3190
movq -0x30(%rbp), %rdi
movq %rax, %rsi
movb $0x0, %al
callq 0x11a60
movq -0x28(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
callq 0x59f0
testb $0x1, %al
jne 0xa44f
jmp 0xa462
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x59c0
movb $0x0, -0x1(%rbp)
jmp 0xa466
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xa8(%rbp)
cmpq $0x0, 0x8(%rax)
jne 0xa4b6
movb $0x0, -0x1(%rbp)
jmp 0xa5dd
movq -0x28(%rbp), %rdi
callq 0xb890
movq -0x18(%rbp), %rdx
leaq -0x48(%rbp), %rdi
leaq 0xdcec(%rip), %rsi      # 0x181ba
callq 0xb510
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
movq %rax, -0xb0(%rbp)
movq -0x20(%rbp), %rdi
callq 0x4540
movq %rax, %rcx
movq -0xb0(%rbp), %rax
cmpq %rcx, %rax
jae 0xa5a0
leaq 0xe6cb(%rip), %rdx      # 0x18bd2
leaq -0x90(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xbf70
jmp 0xa519
movq -0x20(%rbp), %rdi
movl -0x4c(%rbp), %eax
movl %eax, %esi
callq 0xbac0
movq %rax, %rdx
leaq -0x70(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x46d0
jmp 0xa53c
leaq -0x48(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x34a0
leaq -0x70(%rbp), %rdi
callq 0x3290
leaq -0x90(%rbp), %rdi
callq 0x3290
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0xa4da
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
jmp 0xa5d2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x98(%rbp)
movl %eax, -0x9c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x3290
jmp 0xa5d2
movq -0xa8(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq -0x48(%rbp), %rsi
callq 0x54a0
movb %al, -0xb1(%rbp)
jmp 0xa5bc
movb -0xb1(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3290
jmp 0xa5dd
leaq -0x48(%rbp), %rdi
callq 0x3290
jmp 0xa5eb
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xc0, %rsp
popq %rbp
retq
movq -0x98(%rbp), %rdi
callq 0x3660
nopw (%rax,%rax)
// File: Sherhang[P]redis-for-cpp/./credis.h
// Function: int Redis::str2num<int>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
T str2num(const std::string& str)
    {
        std::stringstream ss;
        T num;
        ss << str;
        ss >> num;
        return num;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x32e0
leaq -0x188(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3390
jmp 0xba51
leaq -0x198(%rbp), %rdi
leaq -0x19c(%rbp), %rsi
callq 0x3280
jmp 0xba66
movl -0x19c(%rbp), %eax
movl %eax, -0x1b0(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x3300
movl -0x1b0(%rbp), %eax
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x3300
movq -0x1a8(%rbp), %rdi
callq 0x3660
nopw (%rax,%rax)
// File: Sherhang[P]redis-for-cpp/redis_connect_pool.cpp
// Function: RedisConnectPool::~RedisConnectPool()
RedisConnectPool::~RedisConnectPool()
{
    {
	MutexGuard guard(&_mutex);
	list<redisContext*>::iterator it = _connectPool.begin();
	list<redisContext*>::iterator itEnd = _connectPool.end();
	for (; it != itEnd; ++it)
	{
	    //if(*it != NULL)
            {
                redisFree(*it);
                *it = NULL;
            }
	}
	_connectPool.clear();
    }

	pthread_mutex_destroy(&_mutex);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x28(%rbp)
addq $0x68, %rsi
leaq -0x10(%rbp), %rdi
callq 0xe900
jmp 0xdf43
movq -0x28(%rbp), %rdi
addq $0x50, %rdi
callq 0xe930
movq -0x28(%rbp), %rdi
movq %rax, -0x18(%rbp)
addq $0x50, %rdi
callq 0xe960
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0xe990
testb $0x1, %al
jne 0xdf78
jmp 0xdfa6
leaq -0x18(%rbp), %rdi
callq 0xe9c0
movq (%rax), %rdi
callq 0x10ca0
jmp 0xdf8b
leaq -0x18(%rbp), %rdi
callq 0xe9c0
movq $0x0, (%rax)
leaq -0x18(%rbp), %rdi
callq 0xe9e0
jmp 0xdf65
movq -0x28(%rbp), %rdi
addq $0x50, %rdi
callq 0xea00
leaq -0x10(%rbp), %rdi
callq 0xea30
movq -0x28(%rbp), %rdi
addq $0x68, %rdi
callq 0x3470
movq -0x28(%rbp), %rdi
addq $0x50, %rdi
callq 0xea50
movq -0x28(%rbp), %rdi
addq $0x28, %rdi
callq 0x3290
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
callq 0x3290
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x4b40
nop
// File: Sherhang[P]redis-for-cpp/redis_connect_pool.cpp
// Function: RedisConnectPool::init(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool RedisConnectPool::init(int iPoolSize, const string& redisIP, int redisPort, const string& passwd)
{
    MutexGuard guard(&_mutex);    
    _redisIP = redisIP;
    _redisProt = redisPort;
    _passwd = passwd;
    _iPoolSize = iPoolSize;
    _iUsedCount = 0;
    _needPasswd = true;
    return initConnectPool();   
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x48(%rbp)
addq $0x68, %rsi
leaq -0x30(%rbp), %rdi
callq 0xe900
movq -0x48(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x8, %rdi
callq 0x3050
jmp 0xe042
movq -0x48(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, 0x48(%rdi)
movq -0x28(%rbp), %rsi
addq $0x28, %rdi
callq 0x3050
jmp 0xe05b
movq -0x48(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, (%rdi)
movl $0x0, 0x4(%rdi)
movb $0x1, 0x90(%rdi)
callq 0xe0b0
movb %al, -0x49(%rbp)
jmp 0xe07c
leaq -0x30(%rbp), %rdi
callq 0xea30
movb -0x49(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xea30
movq -0x38(%rbp), %rdi
callq 0x3660
nop
// File: Sherhang[P]redis-for-cpp/redis_connect_pool.cpp
// Function: RedisConnectPool::initConnectPool()
bool RedisConnectPool::initConnectPool()
{
	for (int i = 0; i < _iPoolSize; ++i)
	{
	    redisContext *redisConn = connect();
            if(redisConn)
            {
    	        _connectPool.push_back(redisConn);
            }
        }
	
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x20(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl (%rcx), %eax
jge 0xe108
movq -0x20(%rbp), %rdi
callq 0xe120
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xe0fb
movq -0x20(%rbp), %rdi
addq $0x50, %rdi
leaq -0x18(%rbp), %rsi
callq 0xea70
jmp 0xe0fd
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xe0cb
movb $0x1, %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Sherhang[P]redis-for-cpp/redis_connect_pool.cpp
// Function: RedisConnectPool::reConnect(redisContext*&)
bool RedisConnectPool::reConnect(redisContext* &redisConn)
{
    if(redisConn)
    {
	redisFree(redisConn);
        redisConn = NULL;
    }
	redisConn = connect();
    if(redisConn == NULL)
        return false;
    
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
je 0xe409
movq -0x18(%rbp), %rax
movq (%rax), %rdi
callq 0x10ca0
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x20(%rbp), %rdi
callq 0xe120
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xe42c
movb $0x0, -0x1(%rbp)
jmp 0xe430
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Sherhang[P]redis-for-cpp/redis_connect_pool.cpp
// Function: RedisConnectPool::getConnect()
redisContext * RedisConnectPool::getConnect()
{
	redisContext *retConn = NULL;
	MutexGuard guard(&_mutex);    
	{
		if (_connectPool.empty())
		{
			return retConn;
		}
		else
		{
		    retConn = _connectPool.front();
		    _connectPool.pop_front();
                    _iUsedCount++;
		}
	}

	if (retConn == NULL)
	{
		reConnect(retConn);
	}

	return retConn;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x40(%rbp)
movq $0x0, -0x18(%rbp)
addq $0x68, %rsi
leaq -0x20(%rbp), %rdi
callq 0xe900
movq -0x40(%rbp), %rdi
addq $0x50, %rdi
callq 0xeab0
testb $0x1, %al
jne 0xe47c
jmp 0xe48d
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0x24(%rbp)
jmp 0xe4f9
movq -0x40(%rbp), %rdi
addq $0x50, %rdi
callq 0xead0
movq -0x40(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x18(%rbp)
addq $0x50, %rdi
callq 0xeb00
movq -0x40(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
cmpq $0x0, -0x18(%rbp)
jne 0xe4ea
movq -0x40(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xe3d0
jmp 0xe4d1
jmp 0xe4ea
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xea30
jmp 0xe50c
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0x24(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xea30
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x3660
nopw %cs:(%rax,%rax)
// File: Sherhang[P]redis-for-cpp/redis_connect_pool.cpp
// Function: RedisConnectPool::getConnect(int)
redisContext * RedisConnectPool::getConnect(int retry)
{
    redisContext * context = getConnect();
    while(context == NULL && retry-->0)
    {
        context = getConnect();
    }
    if(context == NULL)
    {
        return NULL;
    }

    return context;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0xe440
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0x29(%rbp)
jne 0xe560
movl -0x14(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x14(%rbp)
cmpl $0x0, %eax
setg %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0xe569
jmp 0xe578
movq -0x28(%rbp), %rdi
callq 0xe440
movq %rax, -0x20(%rbp)
jmp 0xe540
cmpq $0x0, -0x20(%rbp)
jne 0xe589
movq $0x0, -0x8(%rbp)
jmp 0xe591
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: Sherhang[P]redis-for-cpp/redis_connect_pool.cpp
// Function: RedisConnectPool::releaseConnect(redisContext*)
void RedisConnectPool::releaseConnect(redisContext *redisConn)
{
    if(redisConn == NULL)
        return ;
    if(find(_connectPool.begin(), _connectPool.end(), redisConn) != _connectPool.end())
    {
        return;
    }
    MutexGuard guard(&_mutex);    
	if(redisConn != NULL)
    {
            if(redisConn->err)
            {
                if (!reConnect(redisConn)) 
                {
                    return;
                }
            }
        if(isUseful(redisConn))
        {
	        _connectPool.push_back(redisConn);
            _iUsedCount--;
        }
	}

	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xe5c4
jmp 0xe6d3
movq -0x50(%rbp), %rdi
addq $0x50, %rdi
callq 0xe930
movq -0x50(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x50, %rdi
callq 0xe960
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
leaq -0x10(%rbp), %rdx
callq 0xeb30
movq -0x50(%rbp), %rdi
movq %rax, -0x18(%rbp)
addq $0x50, %rdi
callq 0xe960
movq %rax, -0x30(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xe990
testb $0x1, %al
jne 0xe61f
jmp 0xe624
jmp 0xe6d3
movq -0x50(%rbp), %rsi
addq $0x68, %rsi
leaq -0x38(%rbp), %rdi
callq 0xe900
cmpq $0x0, -0x10(%rbp)
je 0xe6c3
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
je 0xe686
movq -0x50(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0xe3d0
movb %al, -0x51(%rbp)
jmp 0xe65b
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0xe684
jmp 0xe664
movl $0x1, -0x48(%rbp)
jmp 0xe6ca
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xea30
jmp 0xe6d9
jmp 0xe686
movq -0x50(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0xe6f0
movb %al, -0x52(%rbp)
jmp 0xe698
movb -0x52(%rbp), %al
testb $0x1, %al
jne 0xe6a1
jmp 0xe6c1
movq -0x50(%rbp), %rdi
addq $0x50, %rdi
leaq -0x10(%rbp), %rsi
callq 0xea70
jmp 0xe6b4
movq -0x50(%rbp), %rax
movl 0x4(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x4(%rax)
jmp 0xe6c3
movl $0x1, -0x48(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xea30
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3660
nopw %cs:(%rax,%rax)
// File: Sherhang[P]redis-for-cpp/redis_connect_pool.cpp
// Function: RedisConnectPool::isUseful(redisContext*&)
bool RedisConnectPool::isUseful(redisContext* &redisConn)
{
	if (NULL == redisConn)
	{
		return false;
	}
    
	bool bPingRet = true;
	string command = "PING";
	redisReply *reply = (redisReply*)redisCommand(redisConn, command.c_str());
	if (reply == NULL && redisConn->err != 0)
	{
		bPingRet = false;
	}

	if (reply->type == REDIS_REPLY_STATUS)
	{
		string strRet = reply->str;
		if (strRet.find("PONG") != string::npos)
		{
			freeReplyObject(reply);
            reply = NULL;
		}
	}
    if(reply)
    {
	    freeReplyObject(reply);
        reply = NULL;
    }
	
	return bPingRet;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq (%rcx), %rax
jne 0xe717
movb $0x0, -0x1(%rbp)
jmp 0xe8c2
movb $0x1, -0x19(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x3670
movq -0x90(%rbp), %rdx
leaq 0x995b(%rip), %rsi      # 0x18094
leaq -0x40(%rbp), %rdi
callq 0x3510
jmp 0xe744
leaq -0x41(%rbp), %rdi
callq 0x3410
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xa0(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3190
movq -0xa0(%rbp), %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x11a60
movq %rax, -0x98(%rbp)
jmp 0xe77e
movq -0x98(%rbp), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, -0x60(%rbp)
jne 0xe7cd
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpl $0x0, (%rax)
je 0xe7cd
movb $0x0, -0x19(%rbp)
jmp 0xe7cd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x41(%rbp), %rdi
callq 0x3410
jmp 0xe8d0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0xe8b7
movq -0x60(%rbp), %rax
cmpl $0x5, (%rax)
jne 0xe88a
movq -0x60(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0xb0(%rbp)
leaq -0x81(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x3670
movq -0xb0(%rbp), %rsi
movq -0xa8(%rbp), %rdx
leaq -0x80(%rbp), %rdi
callq 0x3510
jmp 0xe815
leaq -0x81(%rbp), %rdi
callq 0x3410
leaq -0x80(%rbp), %rdi
leaq 0x986d(%rip), %rsi      # 0x18099
xorl %eax, %eax
movl %eax, %edx
callq 0x36f0
cmpq $-0x1, %rax
je 0xe881
movq -0x60(%rbp), %rdi
callq 0xf3b0
jmp 0xe846
movq $0x0, -0x60(%rbp)
jmp 0xe881
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x81(%rbp), %rdi
callq 0x3410
jmp 0xe8b7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x3290
jmp 0xe8b7
leaq -0x80(%rbp), %rdi
callq 0x3290
cmpq $0x0, -0x60(%rbp)
je 0xe8a4
movq -0x60(%rbp), %rdi
callq 0xf3b0
jmp 0xe89c
movq $0x0, -0x60(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3290
jmp 0xe8c2
leaq -0x40(%rbp), %rdi
callq 0x3290
jmp 0xe8d0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xb0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x3660
nopl (%rax)