LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: yangwanyuan[P]HLKVDS/src/KeyDigestHandle.cc
// Function: hlkvds::KeyDigestHandle::Hash(hlkvds::Kvdb_Digest const*)
uint32_t KeyDigestHandle::Hash(const Kvdb_Digest *digest) {
    uint32_t hash_value;
    const uint32_t *pi = &digest->value[4];
    unsigned char key_char[4];
    key_char[0] = *((const char *) pi + 0);
    key_char[1] = *((const char *) pi + 1);
    key_char[2] = *((const char *) pi + 2);
    key_char[3] = *((const char *) pi + 3);
    hash_value = (key_char[0]) + (key_char[1] << 8) + (key_char[2] << 16)
            + (key_char[3] << 24);
    return hash_value;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
addq $0x10, %rax
movq %rax, -0x18(%rsp)
movq -0x18(%rsp), %rax
movb (%rax), %al
movb %al, -0x1c(%rsp)
movq -0x18(%rsp), %rax
movb 0x1(%rax), %al
movb %al, -0x1b(%rsp)
movq -0x18(%rsp), %rax
movb 0x2(%rax), %al
movb %al, -0x1a(%rsp)
movq -0x18(%rsp), %rax
movb 0x3(%rax), %al
movb %al, -0x19(%rsp)
movzbl -0x1c(%rsp), %eax
movzbl -0x1b(%rsp), %ecx
shll $0x8, %ecx
addl %ecx, %eax
movzbl -0x1a(%rsp), %ecx
shll $0x10, %ecx
addl %ecx, %eax
movzbl -0x19(%rsp), %ecx
shll $0x18, %ecx
addl %ecx, %eax
movl %eax, -0xc(%rsp)
movl -0xc(%rsp), %eax
retq
nop
// File: yangwanyuan[P]HLKVDS/src/KeyDigestHandle.cc
// Function: hlkvds::KeyDigestHandle::Tostring[abi:cxx11](hlkvds::Kvdb_Digest*)
string KeyDigestHandle::Tostring(Kvdb_Digest *digest) {
    int digest_size = KeyDigestHandle::SizeOfDigest();
    unsigned char *temp = digest->GetDigest();

    int str_len = 2 * digest_size + 1;
    char *res = new char[str_len];
    for (int i = 0; i < digest_size; i++) {
        sprintf(&res[2 * i], "%02x", temp[i]);
    }
    string result = string((const char*) res);
    delete[] res;
    //delete[] temp;
    return result;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
callq 0x2a270
movl %eax, 0x64(%rsp)
movq 0x68(%rsp), %rdi
callq 0x2a2a0
movq %rax, 0x58(%rsp)
movl 0x64(%rsp), %eax
shll %eax
addl $0x1, %eax
movl %eax, 0x54(%rsp)
movslq 0x54(%rsp), %rdi
movq $-0x1, %rax
cmpq $0x0, %rdi
cmovlq %rax, %rdi
callq 0x8040
movq %rax, 0x48(%rsp)
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
cmpl 0x64(%rsp), %eax
jge 0x2a1c9
movq 0x48(%rsp), %rdi
movl 0x44(%rsp), %eax
shll %eax
cltq
addq %rax, %rdi
movq 0x58(%rsp), %rax
movslq 0x44(%rsp), %rcx
movzbl (%rax,%rcx), %edx
leaq 0x28da2(%rip), %rsi     # 0x52f57
movb $0x0, %al
callq 0x80d0
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x44(%rsp)
jmp 0x2a186
movb $0x0, 0x43(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x42(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x8830
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x8680
jmp 0x2a1fd
leaq 0x42(%rsp), %rdi
callq 0x8540
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x2a221
movq 0x8(%rsp), %rdi
callq 0x8610
movb $0x1, 0x43(%rsp)
testb $0x1, 0x43(%rsp)
jne 0x2a253
jmp 0x2a249
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x42(%rsp), %rdi
callq 0x8540
jmp 0x2a25d
movq 0x20(%rsp), %rdi
callq 0x8928
movq 0x28(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x8820
nopw (%rax,%rax)
// File: yangwanyuan[P]HLKVDS/src/Kvdb.cc
// Function: hlkvds::DB::CreateDB(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, hlkvds::Options)
bool DB::CreateDB(string filename, Options opts) {
    KVDS* new_kvds;
    new_kvds = KVDS::Create_KVDS(filename.c_str(), opts);
    if (!new_kvds) {
        std::cout << "CreateDB failed" << std::endl;
        return false;
    }

    delete new_kvds;
    return true;
}

// Assembly:
subq $0xd8, %rsp
leaq 0xe0(%rsp), %rax
movq %rax, 0x60(%rsp)
movq %rdi, 0xc8(%rsp)
callq 0x8180
movq 0x60(%rsp), %rsi
movq %rax, 0x68(%rsp)
leaq 0x70(%rsp), %rdi
movl $0x50, %edx
callq 0x8410
movq 0x68(%rsp), %rdi
movups 0xb0(%rsp), %xmm0
movq %rsp, %rax
movups %xmm0, 0x40(%rax)
movups 0x70(%rsp), %xmm0
movups 0x80(%rsp), %xmm1
movups 0x90(%rsp), %xmm2
movups 0xa0(%rsp), %xmm3
movups %xmm3, 0x30(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x2b5c0
movq %rax, 0xc0(%rsp)
cmpq $0x0, 0xc0(%rsp)
jne 0x2a36e
movq 0x46c87(%rip), %rdi     # 0x70fd0
leaq 0x28c0c(%rip), %rsi     # 0x52f5c
callq 0x84e0
movq %rax, %rdi
movq 0x46c41(%rip), %rsi     # 0x70fa0
callq 0x8520
movb $0x0, 0xd7(%rsp)
jmp 0x2a394
movq 0xc0(%rsp), %rax
movq %rax, 0x58(%rsp)
cmpq $0x0, %rax
je 0x2a38c
movq 0x58(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movb $0x1, 0xd7(%rsp)
movb 0xd7(%rsp), %al
andb $0x1, %al
addq $0xd8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: yangwanyuan[P]HLKVDS/src/Kvdb.cc
// Function: hlkvds::DB::OpenDB(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, hlkvds::DB**, hlkvds::Options)
bool DB::OpenDB(string filename, DB** db, Options opts) {
    std::unique_lock<std::mutex> l(db_->mtx_);
    if ( db_->kvds_ == NULL ) {
        db_->kvds_ = KVDS::Open_KVDS(filename.c_str(), opts);
        if (!db_->kvds_) {
            std::cout << "OpenDB failed" << std::endl;
            return false;
        }
    }

    *db = db_;
    return true;
}

// Assembly:
subq $0xf8, %rsp
movq %rdi, 0x60(%rsp)
leaq 0x100(%rsp), %rax
movq %rax, 0x68(%rsp)
movq %rdi, 0xe8(%rsp)
movq %rsi, 0xe0(%rsp)
leaq 0x471f0(%rip), %rax     # 0x715d0
movq (%rax), %rsi
addq $0x10, %rsi
leaq 0xd0(%rsp), %rdi
callq 0x15a10
leaq 0x471d5(%rip), %rax     # 0x715d0
movq (%rax), %rax
cmpq $0x0, 0x8(%rax)
jne 0x2a522
movq 0x60(%rsp), %rdi
callq 0x8180
movq %rax, %rdi
movq 0x68(%rsp), %rax
movups 0x40(%rax), %xmm0
movaps %xmm0, 0xc0(%rsp)
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movups 0x30(%rax), %xmm3
movaps %xmm3, 0xb0(%rsp)
movaps %xmm2, 0xa0(%rsp)
movaps %xmm1, 0x90(%rsp)
movaps %xmm0, 0x80(%rsp)
movaps 0xc0(%rsp), %xmm0
movq %rsp, %rax
movups %xmm0, 0x40(%rax)
movaps 0x80(%rsp), %xmm0
movaps 0x90(%rsp), %xmm1
movaps 0xa0(%rsp), %xmm2
movaps 0xb0(%rsp), %xmm3
movups %xmm3, 0x30(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x2bce0
movq %rax, 0x58(%rsp)
jmp 0x2a4a0
movq 0x58(%rsp), %rcx
leaq 0x47124(%rip), %rax     # 0x715d0
movq (%rax), %rax
movq %rcx, 0x8(%rax)
leaq 0x47116(%rip), %rax     # 0x715d0
movq (%rax), %rax
cmpq $0x0, 0x8(%rax)
jne 0x2a520
movq 0x46b05(%rip), %rdi     # 0x70fd0
leaq 0x28a9a(%rip), %rsi     # 0x52f6c
callq 0x84e0
movq %rax, 0x50(%rsp)
jmp 0x2a4de
movq 0x50(%rsp), %rdi
movq 0x46ab6(%rip), %rsi     # 0x70fa0
callq 0x8520
jmp 0x2a4f1
movb $0x0, 0xf7(%rsp)
movl $0x1, 0x70(%rsp)
jmp 0x2a547
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0xd0(%rsp), %rdi
callq 0x15c30
jmp 0x2a565
jmp 0x2a522
leaq 0x470a7(%rip), %rax     # 0x715d0
movq (%rax), %rcx
movq 0xe0(%rsp), %rax
movq %rcx, (%rax)
movb $0x1, 0xf7(%rsp)
movl $0x1, 0x70(%rsp)
leaq 0xd0(%rsp), %rdi
callq 0x15c30
movb 0xf7(%rsp), %al
andb $0x1, %al
addq $0xf8, %rsp
retq
movq 0x78(%rsp), %rdi
callq 0x8820
nop
// File: yangwanyuan[P]HLKVDS/src/Kvdb.cc
// Function: hlkvds::DB::Insert(char const*, unsigned int, char const*, unsigned short, bool)
Status DB::Insert(const char* key, uint32_t key_len, const char* data,
                uint16_t length, bool immediately) {
    Status s = kvds_->Insert(key, key_len, data, length, immediately);
    if (!s.ok()) {
        std::cout << "DB Insert failed" << std::endl;
    }
    return s;
}

// Assembly:
subq $0x78, %rsp
movl %r9d, %eax
movl %ecx, 0x1c(%rsp)
movq %rdx, %rcx
movl 0x1c(%rsp), %edx
movq %rcx, 0x20(%rsp)
movq %rsi, %r9
movq 0x20(%rsp), %rsi
movq %rdi, 0x30(%rsp)
movw %ax, %cx
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movb 0x80(%rsp), %al
movq %rdi, 0x70(%rsp)
movq %r9, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movl %edx, 0x5c(%rsp)
movq %r8, 0x50(%rsp)
movw %cx, 0x4e(%rsp)
andb $0x1, %al
movb %al, 0x4d(%rsp)
movq 0x68(%rsp), %rax
movb $0x0, 0x4c(%rsp)
movq 0x8(%rax), %rsi
movq 0x60(%rsp), %rdx
movl 0x5c(%rsp), %ecx
movq 0x50(%rsp), %r8
movzwl 0x4e(%rsp), %r9d
movzbl 0x4d(%rsp), %r10d
andl $0x1, %r10d
movq %rsp, %rax
movl %r10d, (%rax)
callq 0x2c700
movq 0x30(%rsp), %rdi
callq 0xa890
movb %al, 0x3b(%rsp)
jmp 0x2a740
movb 0x3b(%rsp), %al
testb $0x1, %al
jne 0x2a793
jmp 0x2a74a
movq 0x4687f(%rip), %rdi     # 0x70fd0
leaq 0x28822(%rip), %rsi     # 0x52f7a
callq 0x84e0
movq %rax, 0x10(%rsp)
jmp 0x2a764
movq 0x10(%rsp), %rdi
movq 0x46830(%rip), %rsi     # 0x70fa0
callq 0x8520
jmp 0x2a777
jmp 0x2a793
movq 0x30(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
callq 0xa8b0
jmp 0x2a7b3
movb $0x1, 0x4c(%rsp)
testb $0x1, 0x4c(%rsp)
jne 0x2a7a9
movq 0x30(%rsp), %rdi
callq 0xa8b0
movq 0x28(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x8820
nopl (%rax)
// File: yangwanyuan[P]HLKVDS/src/Kvdb.cc
// Function: hlkvds::DB::Delete(char const*, unsigned int)
Status DB::Delete(const char* key, uint32_t key_len) {
    Status s = kvds_->Delete(key, key_len);
    if (!s.ok()) {
        std::cout << "DB Delete failed" << std::endl;
    }
    return s;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movl %ecx, 0x2c(%rsp)
movq 0x38(%rsp), %rax
movb $0x0, 0x2b(%rsp)
movq 0x8(%rax), %rsi
movq 0x30(%rsp), %rdx
movl 0x2c(%rsp), %ecx
callq 0x2c9b0
movq 0x10(%rsp), %rdi
callq 0xa890
movb %al, 0x1b(%rsp)
jmp 0x2a810
movb 0x1b(%rsp), %al
testb $0x1, %al
jne 0x2a861
jmp 0x2a81a
movq 0x467af(%rip), %rdi     # 0x70fd0
leaq 0x28763(%rip), %rsi     # 0x52f8b
callq 0x84e0
movq %rax, (%rsp)
jmp 0x2a833
movq (%rsp), %rdi
movq 0x46762(%rip), %rsi     # 0x70fa0
callq 0x8520
jmp 0x2a845
jmp 0x2a861
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0xa8b0
jmp 0x2a881
movb $0x1, 0x2b(%rsp)
testb $0x1, 0x2b(%rsp)
jne 0x2a877
movq 0x10(%rsp), %rdi
callq 0xa8b0
movq 0x8(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x8820
nopl (%rax,%rax)
// File: yangwanyuan[P]HLKVDS/src/Kvdb.cc
// Function: hlkvds::DB::Get(char const*, unsigned int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
Status DB::Get(const char* key, uint32_t key_len, string &data) {
    Status s = kvds_->Get(key, key_len, data);
    if (!s.ok()) {
        std::cout << "DB Get failed" << std::endl;
    }
    return s;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movl %ecx, 0x3c(%rsp)
movq %r8, 0x30(%rsp)
movq 0x48(%rsp), %rax
movb $0x0, 0x2f(%rsp)
movq 0x8(%rax), %rsi
movq 0x40(%rsp), %rdx
movl 0x3c(%rsp), %ecx
movq 0x30(%rsp), %r8
callq 0x2ca00
movq 0x10(%rsp), %rdi
callq 0xa890
movb %al, 0x1b(%rsp)
jmp 0x2a8ea
movb 0x1b(%rsp), %al
testb $0x1, %al
jne 0x2a93b
jmp 0x2a8f4
movq 0x466d5(%rip), %rdi     # 0x70fd0
leaq 0x2869a(%rip), %rsi     # 0x52f9c
callq 0x84e0
movq %rax, (%rsp)
jmp 0x2a90d
movq (%rsp), %rdi
movq 0x46688(%rip), %rsi     # 0x70fa0
callq 0x8520
jmp 0x2a91f
jmp 0x2a93b
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0xa8b0
jmp 0x2a95b
movb $0x1, 0x2f(%rsp)
testb $0x1, 0x2f(%rsp)
jne 0x2a951
movq 0x10(%rsp), %rdi
callq 0xa8b0
movq 0x8(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x8820
nopw %cs:(%rax,%rax)
// File: yangwanyuan[P]HLKVDS/src/KvdbIter.cc
// Function: hlkvds::KvdbIter::SeekToFirst()
void KvdbIter::SeekToFirst() {
    LinkedList<HashEntry> *entry_list;
    hashEntry_ = NULL;
    htSize_ = idxMgr_->GetHashTableSize();
    for (int i = 0; i < htSize_; i++) {
        entry_list = idxMgr_->GetEntryListByNo(i);
        int entry_list_size = entry_list->get_size();
        if (entry_list_size > 0) {
            hashTableCur_ = i;
            entryListCur_ = 0;
            hashEntry_ = entry_list->getByNo(entryListCur_);
            break;
        }
    }

    if (NULL != hashEntry_) {
        valid_ = true;
    } else {
        valid_ = false;
    }

    //status_ = Stats::OK()
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq $0x0, 0x20(%rax)
movq 0x8(%rax), %rdi
callq 0x2b480
movl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x38(%rax)
movl $0x0, 0x14(%rsp)
movq 0x8(%rsp), %rcx
movl 0x14(%rsp), %eax
cmpl 0x38(%rcx), %eax
jge 0x2ac8d
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
movl 0x14(%rsp), %esi
callq 0x2b490
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x277a0
movl %eax, 0x10(%rsp)
cmpl $0x0, 0x10(%rsp)
jle 0x2ac7e
movq 0x8(%rsp), %rax
movl 0x14(%rsp), %ecx
movl %ecx, 0x3c(%rax)
movl $0x0, 0x40(%rax)
movq 0x18(%rsp), %rdi
movl 0x40(%rax), %esi
callq 0x2b4b0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
jmp 0x2ac8d
jmp 0x2ac80
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x2ac16
movq 0x8(%rsp), %rcx
xorl %eax, %eax
cmpq 0x20(%rcx), %rax
je 0x2aca5
movq 0x8(%rsp), %rax
movb $0x1, 0x18(%rax)
jmp 0x2acae
movq 0x8(%rsp), %rax
movb $0x0, 0x18(%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: yangwanyuan[P]HLKVDS/src/KvdbIter.cc
// Function: hlkvds::KvdbIter::SeekToLast()
void KvdbIter::SeekToLast() {
    LinkedList<HashEntry> *entry_list;
    hashEntry_ = NULL;
    htSize_ = idxMgr_->GetHashTableSize();
    for (int i = htSize_ - 1; i >= 0; i--) {
        entry_list = idxMgr_->GetEntryListByNo(i);
        int entry_list_size = entry_list->get_size();
        //__INFO("entry_list_size=%d",entry_list_size);
        if (entry_list_size > 0) {
            hashTableCur_ = i;
            entryListCur_ = entry_list_size - 1;
            hashEntry_ = entry_list->getByNo(entryListCur_);
            break;
        }
    }

    if (NULL != hashEntry_) {
        valid_ = true;
    } else {
        valid_ = false;
    }
    //__INFO("hastTableCur_ = %d, entryListCur_ = %d", hashTableCur_, entryListCur_);

}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq $0x0, 0x20(%rax)
movq 0x8(%rax), %rdi
callq 0x2b480
movl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x38(%rax)
movl 0x38(%rax), %eax
subl $0x1, %eax
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jl 0x2ad6b
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
movl 0x14(%rsp), %esi
callq 0x2b490
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x277a0
movl %eax, 0x10(%rsp)
cmpl $0x0, 0x10(%rsp)
jle 0x2ad5c
movq 0x8(%rsp), %rax
movl 0x14(%rsp), %ecx
movl %ecx, 0x3c(%rax)
movl 0x10(%rsp), %ecx
subl $0x1, %ecx
movl %ecx, 0x40(%rax)
movq 0x18(%rsp), %rdi
movl 0x40(%rax), %esi
callq 0x2b4b0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
jmp 0x2ad6b
jmp 0x2ad5e
movl 0x14(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x2acf8
movq 0x8(%rsp), %rcx
xorl %eax, %eax
cmpq 0x20(%rcx), %rax
je 0x2ad83
movq 0x8(%rsp), %rax
movb $0x1, 0x18(%rax)
jmp 0x2ad8c
movq 0x8(%rsp), %rax
movb $0x0, 0x18(%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: yangwanyuan[P]HLKVDS/src/KvdbIter.cc
// Function: hlkvds::KvdbIter::Next()
void KvdbIter::Next() {
    LinkedList<HashEntry> *entry_list;
    entry_list = idxMgr_->GetEntryListByNo(hashTableCur_);
    hashEntry_ = NULL;
    int entry_list_size = entry_list->get_size();
    if ( entryListCur_ < entry_list_size - 1) {
        entryListCur_++;
        hashEntry_ = entry_list->getByNo(entryListCur_);
    } else {
        hashTableCur_++;
        while (hashTableCur_ < htSize_) {
            entry_list = idxMgr_->GetEntryListByNo(hashTableCur_);
            entry_list_size = entry_list->get_size();
            if (entry_list_size  > 0) {
                entryListCur_ = 0;
                hashEntry_ = entry_list->getByNo(entryListCur_);
                break;
            }
            hashTableCur_++;
        }
    }

    if (NULL != hashEntry_) {
        valid_ = true;
    } else {
        valid_ = false;
    }
    //__INFO("hastTableCur_ = %d, entryListCur_ = %d", hashTableCur_, entryListCur_);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rax), %rdi
movl 0x3c(%rax), %esi
callq 0x2b490
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rsp)
movq $0x0, 0x20(%rax)
movq 0x18(%rsp), %rdi
callq 0x277a0
movl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x14(%rsp)
movl 0x40(%rax), %eax
movl 0x14(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x2b0e0
movq 0x8(%rsp), %rax
movl 0x40(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x40(%rax)
movq 0x18(%rsp), %rdi
movl 0x40(%rax), %esi
callq 0x2b4b0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
jmp 0x2b15f
movq 0x8(%rsp), %rax
movl 0x3c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x3c(%rax)
movq 0x8(%rsp), %rcx
movl 0x3c(%rcx), %eax
cmpl 0x38(%rcx), %eax
jge 0x2b15d
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
movl 0x3c(%rax), %esi
callq 0x2b490
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x277a0
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jle 0x2b14d
movq 0x8(%rsp), %rax
movl $0x0, 0x40(%rax)
movq 0x18(%rsp), %rdi
movl 0x40(%rax), %esi
callq 0x2b4b0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
jmp 0x2b15d
movq 0x8(%rsp), %rax
movl 0x3c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x3c(%rax)
jmp 0x2b0ee
jmp 0x2b15f
movq 0x8(%rsp), %rcx
xorl %eax, %eax
cmpq 0x20(%rcx), %rax
je 0x2b177
movq 0x8(%rsp), %rax
movb $0x1, 0x18(%rax)
jmp 0x2b180
movq 0x8(%rsp), %rax
movb $0x0, 0x18(%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: yangwanyuan[P]HLKVDS/src/KvdbIter.cc
// Function: hlkvds::KvdbIter::Prev()
void KvdbIter::Prev() {
    LinkedList<HashEntry> *entry_list;
    entry_list = idxMgr_->GetEntryListByNo(hashTableCur_);
    hashEntry_ = NULL;
    int entry_list_size = entry_list->get_size();
    if (entryListCur_ > 0) {
        entryListCur_--;
        hashEntry_ = entry_list->getByNo(entryListCur_);
    } else {
        hashTableCur_--;
        while (hashTableCur_ >= 0) {
            entry_list = idxMgr_->GetEntryListByNo(hashTableCur_);
            entry_list_size = entry_list->get_size();
            if ( entry_list_size > 0) {
                entryListCur_ = entry_list_size - 1;
                hashEntry_ = entry_list->getByNo(entryListCur_);
                break;
            }
            hashTableCur_--;
        }
    }

    if (NULL != hashEntry_) {
        valid_ = true;
    } else {
        valid_ = false;
    }
    //__INFO("hastTableCur_ = %d, entryListCur_ = %d", hashTableCur_, entryListCur_);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rax), %rdi
movl 0x3c(%rax), %esi
callq 0x2b490
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rsp)
movq $0x0, 0x20(%rax)
movq 0x18(%rsp), %rdi
callq 0x277a0
movl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x14(%rsp)
cmpl $0x0, 0x40(%rax)
jle 0x2b20b
movq 0x8(%rsp), %rax
movl 0x40(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x40(%rax)
movq 0x18(%rsp), %rdi
movl 0x40(%rax), %esi
callq 0x2b4b0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
jmp 0x2b28b
movq 0x8(%rsp), %rax
movl 0x3c(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x3c(%rax)
movq 0x8(%rsp), %rax
cmpl $0x0, 0x3c(%rax)
jl 0x2b289
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
movl 0x3c(%rax), %esi
callq 0x2b490
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x277a0
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jle 0x2b279
movq 0x8(%rsp), %rax
movl 0x14(%rsp), %ecx
subl $0x1, %ecx
movl %ecx, 0x40(%rax)
movq 0x18(%rsp), %rdi
movl 0x40(%rax), %esi
callq 0x2b4b0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
jmp 0x2b289
movq 0x8(%rsp), %rax
movl 0x3c(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x3c(%rax)
jmp 0x2b219
jmp 0x2b28b
movq 0x8(%rsp), %rcx
xorl %eax, %eax
cmpq 0x20(%rcx), %rax
je 0x2b2a3
movq 0x8(%rsp), %rax
movb $0x1, 0x18(%rax)
jmp 0x2b2ac
movq 0x8(%rsp), %rax
movb $0x0, 0x18(%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: yangwanyuan[P]HLKVDS/./src/include/LinkedList.h
// Function: hlkvds::LinkedList<hlkvds::HashEntry>::getByNo(int)
T* LinkedList<T>::getByNo(int no) {
    if (no > size_) {
        return NULL;
    }
    Node<T>* node = head_;
    while(no) {
        node = node->next;
        no--;
    }
    return &node->data;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
movq -0x10(%rsp), %rcx
movq %rcx, -0x28(%rsp)
movl -0x14(%rsp), %eax
cmpl 0x8(%rcx), %eax
jle 0x2b4d7
movq $0x0, -0x8(%rsp)
jmp 0x2b510
movq -0x28(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rsp)
cmpl $0x0, -0x14(%rsp)
je 0x2b506
movq -0x20(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rsp)
movl -0x14(%rsp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0x2b4e4
movq -0x20(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: yangwanyuan[P]HLKVDS/./src/include/LinkedList.h
// Function: hlkvds::LinkedList<hlkvds::HashEntry>::searchNo(hlkvds::HashEntry&)
int LinkedList<T>::searchNo(T& toBeSearched) {
    int no = 0;
    Node<T>* curNode = head_;

    while (curNode != NULL) {
        if (curNode->data == toBeSearched) {
            return no;
        }
        curNode = curNode->next;
        no++;
    }
    return -1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movl $0x0, 0xc(%rsp)
movq (%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x2b580
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x25440
testb $0x1, %al
jne 0x2b55d
jmp 0x2b567
movl 0xc(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x2b588
movq (%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, (%rsp)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x2b542
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: yangwanyuan[P]HLKVDS/src/Kvdb_Impl.cc
// Function: hlkvds::KVDS::openAllDevices(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool KVDS::openAllDevices(string paths) {

    vector<string> fields;
    boost::split(fields, paths, boost::is_any_of(FileDelim));
    vector<string>::iterator iter;
    for(iter = fields.begin(); iter != fields.end(); iter++){
        BlockDevice *bdev = new KernelDevice();

        if (bdev->Open(*iter) < 0) {
            return false;
        }__DEBUG("Open Device %s Success!", (*iter).c_str());

        bdVec_.push_back(bdev);
    }
    return true;
}

// Assembly:
subq $0xd8, %rsp
movq %rsi, 0x20(%rsp)
movq %rdi, 0xc8(%rsp)
movq %rsi, 0xc0(%rsp)
movq 0xc8(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0xa8(%rsp), %rdi
callq 0x2d200
leaq 0x45c1b(%rip), %rsi     # 0x715e8
leaq 0x90(%rsp), %rdi
callq 0x2d300
jmp 0x2b9dc
movq 0x20(%rsp), %rsi
leaq 0xa8(%rsp), %rdi
leaq 0x90(%rsp), %rdx
movl $0x1, %ecx
callq 0x2d210
jmp 0x2b9fd
leaq 0x90(%rsp), %rdi
callq 0x2d350
leaq 0x78(%rsp), %rdi
callq 0x2d3a0
leaq 0xa8(%rsp), %rdi
callq 0x2d3c0
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x78(%rsp)
leaq 0xa8(%rsp), %rdi
callq 0x2d430
movq %rax, 0x68(%rsp)
leaq 0x78(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x2d3f0
testb $0x1, %al
jne 0x2ba5a
jmp 0x2bb9d
movl $0x48, %edi
callq 0x84f0
movq %rax, 0x18(%rsp)
jmp 0x2ba6b
movq 0x18(%rsp), %rdi
callq 0x28d30
jmp 0x2ba77
movq 0x18(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x2d460
movq %rax, %rsi
leaq 0x40(%rsp), %rdi
callq 0x81a0
jmp 0x2baa4
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
leaq 0x40(%rsp), %rsi
movl $0x1, %edx
callq *%rax
movl %eax, 0xc(%rsp)
jmp 0x2bac2
leaq 0x40(%rsp), %rdi
callq 0x8928
movl 0xc(%rsp), %eax
cmpl $0x0, %eax
jge 0x2bb6d
movb $0x0, 0xd7(%rsp)
movl $0x1, 0x3c(%rsp)
jmp 0x2bbad
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
jmp 0x2bbcb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x90(%rsp), %rdi
callq 0x2d350
jmp 0x2bbcb
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
callq 0x84b0
jmp 0x2bbcb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x88(%rsp)
movl %eax, 0x84(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x8928
jmp 0x2bbcb
movq 0x28(%rsp), %rdi
addq $0xa0, %rdi
leaq 0x60(%rsp), %rsi
callq 0x2d470
jmp 0x2bb85
jmp 0x2bb87
leaq 0x78(%rsp), %rdi
xorl %esi, %esi
callq 0x2d4e0
movq %rax, 0x30(%rsp)
jmp 0x2ba30
movb $0x1, 0xd7(%rsp)
movl $0x1, 0x3c(%rsp)
leaq 0xa8(%rsp), %rdi
callq 0x2d520
movb 0xd7(%rsp), %al
andb $0x1, %al
addq $0xd8, %rsp
retq
leaq 0xa8(%rsp), %rdi
callq 0x2d520
movq 0x88(%rsp), %rdi
callq 0x8820
nopw %cs:(%rax,%rax)
// File: yangwanyuan[P]HLKVDS/src/Kvdb_Impl.cc
// Function: hlkvds::KVDS::printDbStates()
void KVDS::printDbStates() {
    sbMgr_->printSBInfo();
    dataStor_->printDeviceTopologyInfo();

    idxMgr_->printDynamicInfo();
    dataStor_->printDynamicInfo();
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rax), %rdi
callq 0x49390
movq 0x8(%rsp), %rax
movq 0x48(%rax), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x25630
movq 0x8(%rsp), %rax
movq 0x48(%rax), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: yangwanyuan[P]HLKVDS/src/Kvdb_Impl.cc
// Function: hlkvds::KVDS::Open_KVDS(char const*, hlkvds::Options)
KVDS* KVDS::Open_KVDS(const char* filename, Options opts) {
    KVDS *kvds = new KVDS(filename, opts);

    Status s = kvds->openDB();
    if (!s.ok()) {
        delete kvds;
        return NULL;
    }

    kvds->isOpen_ = true;
    return kvds;

}

// Assembly:
subq $0x108, %rsp            # imm = 0x108
leaq 0x110(%rsp), %rax
movq %rax, 0x68(%rsp)
movq %rdi, 0xf8(%rsp)
movl $0xc0, %edi
callq 0x84f0
movq %rax, %rdi
movq 0x68(%rsp), %rax
movq %rdi, %rcx
movq %rcx, 0x70(%rsp)
movq 0xf8(%rsp), %rsi
movups 0x40(%rax), %xmm0
movaps %xmm0, 0xe0(%rsp)
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movups 0x30(%rax), %xmm3
movaps %xmm3, 0xd0(%rsp)
movaps %xmm2, 0xc0(%rsp)
movaps %xmm1, 0xb0(%rsp)
movaps %xmm0, 0xa0(%rsp)
movaps 0xe0(%rsp), %xmm0
movq %rsp, %rax
movups %xmm0, 0x40(%rax)
movaps 0xa0(%rsp), %xmm0
movaps 0xb0(%rsp), %xmm1
movaps 0xc0(%rsp), %xmm2
movaps 0xd0(%rsp), %xmm3
movups %xmm3, 0x30(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x2c450
jmp 0x2bd9e
movq 0x70(%rsp), %rax
movq %rax, 0xf0(%rsp)
movq 0xf0(%rsp), %rsi
leaq 0x80(%rsp), %rdi
movq %rdi, 0x58(%rsp)
callq 0x2beb0
movq 0x58(%rsp), %rdi
callq 0xa890
movb %al, 0x67(%rsp)
jmp 0x2bdd5
movb 0x67(%rsp), %al
testb $0x1, %al
jne 0x2be56
jmp 0x2bddf
movq 0xf0(%rsp), %rax
movq %rax, 0x50(%rsp)
cmpq $0x0, %rax
je 0x2bdfd
movq 0x50(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x100(%rsp)
movl $0x1, 0x7c(%rsp)
jmp 0x2be7d
movq 0x70(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
callq 0x84b0
jmp 0x2be9a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
leaq 0x80(%rsp), %rdi
callq 0xa8b0
jmp 0x2be9a
movq 0xf0(%rsp), %rax
movb $0x1, 0xb8(%rax)
movq 0xf0(%rsp), %rax
movq %rax, 0x100(%rsp)
movl $0x1, 0x7c(%rsp)
leaq 0x80(%rsp), %rdi
callq 0xa8b0
movq 0x100(%rsp), %rax
addq $0x108, %rsp            # imm = 0x108
retq
movq 0x98(%rsp), %rdi
callq 0x8820
nopw (%rax,%rax)
// File: yangwanyuan[P]HLKVDS/src/Kvdb_Impl.cc
// Function: hlkvds::KVDS::closeDB()
Status KVDS::closeDB() {
    if (!metaStor_->PersistMetaData()) {
        __ERROR("Could not to write metadata to device\n");
        return Status::IOError("Could not to write metadata to device");
    }
    stopThds();
    return Status::OK();
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x40(%rax), %rdi
callq 0x35830
testb $0x1, %al
jne 0x2c189
jmp 0x2c108
movq 0x44ec9(%rip), %rax     # 0x70fd8
movq (%rax), %rax
movq %rax, 0x8(%rsp)
callq 0x8480
movq 0x8(%rsp), %rdi
movq %rax, %rdx
leaq 0x26386(%rip), %rsi     # 0x524b1
leaq 0x26f77(%rip), %rcx     # 0x530a9
leaq 0x26ec3(%rip), %r8      # 0x52ffc
movl $0x76, %r9d
movb $0x0, %al
callq 0x86f0
movq 0x44e8b(%rip), %rax     # 0x70fd8
movq (%rax), %rdi
leaq 0x26f5a(%rip), %rsi     # 0x530b1
movb $0x0, %al
callq 0x86f0
movq 0x44e73(%rip), %rax     # 0x70fd8
movq (%rax), %rdi
leaq 0x26c56(%rip), %rsi     # 0x52dc5
movb $0x0, %al
callq 0x86f0
movq 0x10(%rsp), %rdi
leaq 0x26f56(%rip), %rsi     # 0x530d8
callq 0x16510
jmp 0x2c19d
movq 0x20(%rsp), %rdi
callq 0x2c1b0
movq 0x10(%rsp), %rdi
callq 0x16560
movq 0x18(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: yangwanyuan[P]HLKVDS/src/Kvdb_Impl.cc
// Function: hlkvds::KVDS::~KVDS()
KVDS::~KVDS() {
    if (isOpen_) {
        closeDB();
    }
    delete idxMgr_;
    delete sbMgr_;
    if(!options_.disable_cache){
        delete rdCache_;
    }
    delete metaStor_;
    if (dataStor_) {
        delete dataStor_;
    }
    closeAllDevices();
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x4443e(%rip), %rcx     # 0x70638
addq $0x10, %rcx
movq %rcx, (%rax)
testb $0x1, 0xb8(%rax)
je 0x2c225
movq 0x28(%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x2c0d0
jmp 0x2c21b
leaq 0x30(%rsp), %rdi
callq 0xa8b0
movq 0x28(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, %rax
je 0x2c24d
movq 0x20(%rsp), %rdi
callq 0x271c0
movq 0x20(%rsp), %rdi
callq 0x84b0
movq 0x28(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x2c275
movq 0x18(%rsp), %rdi
callq 0x49740
movq 0x18(%rsp), %rdi
callq 0x84b0
movq 0x28(%rsp), %rax
testb $0x1, 0x50(%rax)
jne 0x2c2aa
movq 0x28(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x2c2a8
movq 0x10(%rsp), %rdi
callq 0x375e0
movq 0x10(%rsp), %rdi
callq 0x84b0
jmp 0x2c2aa
movq 0x28(%rsp), %rax
movq 0x40(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x2c2d2
movq 0x8(%rsp), %rdi
callq 0x34140
movq 0x8(%rsp), %rdi
callq 0x84b0
movq 0x28(%rsp), %rax
cmpq $0x0, 0x48(%rax)
je 0x2c2fd
movq 0x28(%rsp), %rax
movq 0x48(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x2c2fb
movq (%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x2c2fd
movq 0x28(%rsp), %rdi
callq 0x2c340
jmp 0x2c309
movq 0x28(%rsp), %rdi
addq $0xa0, %rdi
callq 0x2d1a0
movq 0x28(%rsp), %rdi
addq $0x8, %rdi
callq 0x8928
addq $0x48, %rsp
retq
movq %rax, %rdi
callq 0xa6a0
nopw %cs:(%rax,%rax)
// File: yangwanyuan[P]HLKVDS/src/Kvdb_Impl.cc
// Function: hlkvds::KVDS::closeAllDevices()
void KVDS::closeAllDevices() {
    vector<BlockDevice *>::iterator iter;
    for ( iter = bdVec_.begin() ; iter != bdVec_.end(); ) {
        BlockDevice *bdev = *iter;
        delete bdev;
        iter = bdVec_.erase(iter);
    }
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x2d580
movq 0x18(%rsp), %rdi
addq $0xa0, %rdi
callq 0x2d5a0
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x18(%rsp), %rdi
addq $0xa0, %rdi
callq 0x2d610
movq %rax, 0x38(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x2d5d0
testb $0x1, %al
jne 0x2c3a8
jmp 0x2c417
leaq 0x48(%rsp), %rdi
callq 0x2d640
movq (%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x2c3d5
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rsp), %rax
addq $0xa0, %rax
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x2d6c0
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x2d650
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x48(%rsp)
jmp 0x2c37d
addq $0x58, %rsp
retq
nopl (%rax)
// File: yangwanyuan[P]HLKVDS/src/Kvdb_Impl.cc
// Function: hlkvds::KVDS::InsertBatch(hlkvds::WriteBatch*)
Status KVDS::InsertBatch(WriteBatch *batch) {
    if (batch->batch_.empty()) {
        return Status::OK();
    }

    Status s = dataStor_->WriteBatchData(batch);

    if (s.ok()) {
        if(!options_.disable_cache) {
            for (std::list<KVSlice *>::iterator iter = batch->batch_.begin();
                    iter != batch->batch_.end(); iter++) {
                if(!(*iter)->GetDataLen()) {//no "" should be put in to the cache
                    rdCache_->Put((*iter)->GetKeyStr(), (*iter)->GetDataStr());
                }
            }
        }
    }

    return s;
}

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq %rdx, 0xa0(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0xa0(%rsp), %rdi
callq 0x239b0
testb $0x1, %al
jne 0x2ce4c
jmp 0x2ce5b
movq 0x18(%rsp), %rdi
callq 0x16560
jmp 0x2d02c
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rax
movb $0x0, 0x9f(%rsp)
movq 0x48(%rax), %rsi
movq 0xa0(%rsp), %rdx
movq (%rsi), %rax
movq 0x48(%rax), %rax
callq *%rax
movq 0x18(%rsp), %rdi
callq 0xa890
movb %al, 0x17(%rsp)
jmp 0x2ce92
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x2ce9f
jmp 0x2d002
movq 0x28(%rsp), %rax
testb $0x1, 0x50(%rax)
jne 0x2d000
movq 0xa0(%rsp), %rdi
callq 0x16410
movq %rax, 0x80(%rsp)
movq 0xa0(%rsp), %rdi
callq 0x16460
movq %rax, 0x78(%rsp)
leaq 0x80(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0x16440
testb $0x1, %al
jne 0x2cef0
jmp 0x2cffe
leaq 0x80(%rsp), %rdi
callq 0x16490
movq (%rax), %rdi
callq 0x163a0
movw %ax, 0x14(%rsp)
jmp 0x2cf0c
movw 0x14(%rsp), %ax
cmpw $0x0, %ax
jne 0x2cfe3
movq 0x28(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, 0x8(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x16490
movq (%rax), %rsi
leaq 0x58(%rsp), %rdi
callq 0x411e0
jmp 0x2cf45
leaq 0x80(%rsp), %rdi
callq 0x16490
movq (%rax), %rsi
leaq 0x38(%rsp), %rdi
callq 0x41270
jmp 0x2cf61
movq 0x8(%rsp), %rdi
leaq 0x58(%rsp), %rsi
leaq 0x38(%rsp), %rdx
callq 0x37640
jmp 0x2cf77
leaq 0x38(%rsp), %rdi
callq 0x8928
leaq 0x58(%rsp), %rdi
callq 0x8928
jmp 0x2cfe3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0x2d020
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0x2cfd7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x8928
leaq 0x58(%rsp), %rdi
callq 0x8928
jmp 0x2d020
jmp 0x2cfe5
leaq 0x80(%rsp), %rdi
xorl %esi, %esi
callq 0x164c0
movq %rax, 0x30(%rsp)
jmp 0x2cec3
jmp 0x2d000
jmp 0x2d002
movb $0x1, 0x9f(%rsp)
testb $0x1, 0x9f(%rsp)
jne 0x2d01e
movq 0x18(%rsp), %rdi
callq 0xa8b0
jmp 0x2d02c
movq 0x18(%rsp), %rdi
callq 0xa8b0
jmp 0x2d039
movq 0x20(%rsp), %rax
addq $0xb8, %rsp
retq
movq 0x90(%rsp), %rdi
callq 0x8820
nopw %cs:(%rax,%rax)
// File: yangwanyuan[P]HLKVDS/src/Kvdb_Impl.cc
// Function: hlkvds::KVDS::ClearReadCache()
void KVDS::ClearReadCache() {
    vector<BlockDevice*>::iterator iter;
    for (iter = bdVec_.begin(); iter != bdVec_.end(); iter++) {
        BlockDevice *bdev = *iter;
        bdev->ClearReadCache();
    }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
leaq 0x28(%rsp), %rdi
callq 0x2d580
movq (%rsp), %rdi
addq $0xa0, %rdi
callq 0x2d5a0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x28(%rsp)
movq (%rsp), %rdi
addq $0xa0, %rdi
callq 0x2d610
movq %rax, 0x18(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x2d5d0
testb $0x1, %al
jne 0x2d0d5
jmp 0x2d105
leaq 0x28(%rsp), %rdi
callq 0x2d640
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
leaq 0x28(%rsp), %rdi
xorl %esi, %esi
callq 0x2d740
movq %rax, 0x8(%rsp)
jmp 0x2d0ab
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: yangwanyuan[P]HLKVDS/src/MetaStor.cc
// Function: hlkvds::MetaStor::TryLoadSB(int&)
bool MetaStor::TryLoadSB(int &datastor_type) {
    verifyMetaDevice();

    //Load SuperBlock
    sbOff_ = 0;
    if (!loadSuperBlock()) {
        __ERROR("Load SuperBlock failed.");
        return false;
    }

    datastor_type = sbMgr_->GetDataStoreType();
    return true;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x34170
movq 0x8(%rsp), %rdi
movq $0x0, 0x38(%rdi)
callq 0x34280
testb $0x1, %al
jne 0x34258
jmp 0x341e5
movq 0x3cdec(%rip), %rax     # 0x70fd8
movq (%rax), %rax
movq %rax, (%rsp)
callq 0x8480
movq (%rsp), %rdi
movq %rax, %rdx
leaq 0x1e2ab(%rip), %rsi     # 0x524b1
leaq 0x1f036(%rip), %rcx     # 0x53243
leaq 0x1f039(%rip), %r8      # 0x5324d
movl $0x23, %r9d
movb $0x0, %al
callq 0x86f0
movq 0x3cdb0(%rip), %rax     # 0x70fd8
movq (%rax), %rdi
leaq 0x1f02b(%rip), %rsi     # 0x5325d
movb $0x0, %al
callq 0x86f0
movq 0x3cd98(%rip), %rax     # 0x70fd8
movq (%rax), %rdi
leaq 0x1eb7b(%rip), %rsi     # 0x52dc5
movb $0x0, %al
callq 0x86f0
movb $0x0, 0x27(%rsp)
jmp 0x34274
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x36190
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nop
// File: yangwanyuan[P]HLKVDS/src/MetaStor.cc
// Function: hlkvds::MetaStor::loadSuperBlock()
bool MetaStor::loadSuperBlock() {
    uint64_t length = SuperBlockManager::SuperBlockSizeOnDevice();
    char *buff = new char[length];
    memset(buff, 0, length);

    if ((uint64_t) metaDev_->pRead(buff, length, sbOff_) != length){
        __ERROR("Could not read superblock from device at %ld\n", sbOff_);
        delete[] buff;
        return false;
    }

    if (!sbMgr_->Set(buff, length))
    {
        __ERROR("Can't Set SuperBlock, Load Failed!");
        delete[] buff;
        return false;
    }
    delete[] buff;
    return true;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x30(%rsp)
callq 0x117e0
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0x8040
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movq 0x40(%rsp), %rdx
xorl %esi, %esi
callq 0x8280
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x38(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq 0x38(%rax), %rcx
movq (%rdi), %rax
callq *0x50(%rax)
cmpq 0x40(%rsp), %rax
je 0x34382
jmp 0x342e7
movq 0x3ccea(%rip), %rax     # 0x70fd8
movq (%rax), %rax
movq %rax, 0x28(%rsp)
callq 0x8480
movq 0x28(%rsp), %rdi
movq %rax, %rdx
leaq 0x1e1a7(%rip), %rsi     # 0x524b1
leaq 0x1f101(%rip), %rcx     # 0x53412
leaq 0x1ef35(%rip), %r8      # 0x5324d
movl $0xf1, %r9d
movb $0x0, %al
callq 0x86f0
movq 0x30(%rsp), %rax
movq 0x3cca7(%rip), %rcx     # 0x70fd8
movq (%rcx), %rdi
movq 0x38(%rax), %rdx
leaq 0x1f0e2(%rip), %rsi     # 0x53421
movb $0x0, %al
callq 0x86f0
movq 0x3cc8b(%rip), %rax     # 0x70fd8
movq (%rax), %rdi
leaq 0x1ea6e(%rip), %rsi     # 0x52dc5
movb $0x0, %al
callq 0x86f0
movq 0x38(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, %rax
je 0x34378
movq 0x20(%rsp), %rdi
callq 0x8610
movb $0x0, 0x57(%rsp)
jmp 0x34452
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x38(%rsp), %rsi
movq 0x40(%rsp), %rdx
callq 0x49510
testb $0x1, %al
jne 0x34433
jmp 0x343a4
movq 0x3cc2d(%rip), %rax     # 0x70fd8
movq (%rax), %rax
movq %rax, 0x18(%rsp)
callq 0x8480
movq 0x18(%rsp), %rdi
movq %rax, %rdx
leaq 0x1e0ea(%rip), %rsi     # 0x524b1
leaq 0x1f044(%rip), %rcx     # 0x53412
leaq 0x1ee78(%rip), %r8      # 0x5324d
movl $0xf8, %r9d
movb $0x0, %al
callq 0x86f0
movq 0x3cbef(%rip), %rax     # 0x70fd8
movq (%rax), %rdi
leaq 0x1effc(%rip), %rsi     # 0x533ef
movb $0x0, %al
callq 0x86f0
movq 0x3cbd7(%rip), %rax     # 0x70fd8
movq (%rax), %rdi
leaq 0x1e9ba(%rip), %rsi     # 0x52dc5
movb $0x0, %al
callq 0x86f0
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x3442c
movq 0x10(%rsp), %rdi
callq 0x8610
movb $0x0, 0x57(%rsp)
jmp 0x34452
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x3444d
movq 0x8(%rsp), %rdi
callq 0x8610
movb $0x1, 0x57(%rsp)
movb 0x57(%rsp), %al
andb $0x1, %al
addq $0x58, %rsp
retq
nopl (%rax)
// File: yangwanyuan[P]HLKVDS/src/MetaStor.cc
// Function: hlkvds::MetaStor::createSuperBlock()
bool MetaStor::createSuperBlock() {
    uint64_t length = SuperBlockManager::SuperBlockSizeOnDevice();
    char *buff = new char[length];
    memset(buff, 0, length);

    if (!sbMgr_->Set(buff, length))
    {
        __ERROR("Can't Set SuperBlock, Load Failed!");
        delete[] buff;
        return false;
    }
    delete[] buff;
    return true;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x20(%rsp)
callq 0x117e0
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x8040
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rdx
xorl %esi, %esi
callq 0x8280
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
callq 0x49510
testb $0x1, %al
jne 0x34b7e
jmp 0x34aef
movq 0x3c4e2(%rip), %rax     # 0x70fd8
movq (%rax), %rax
movq %rax, 0x18(%rsp)
callq 0x8480
movq 0x18(%rsp), %rdi
movq %rax, %rdx
leaq 0x1d99f(%rip), %rsi     # 0x524b1
leaq 0x1e8c5(%rip), %rcx     # 0x533de
leaq 0x1e72d(%rip), %r8      # 0x5324d
movl $0xe3, %r9d
movb $0x0, %al
callq 0x86f0
movq 0x3c4a4(%rip), %rax     # 0x70fd8
movq (%rax), %rdi
leaq 0x1e8b1(%rip), %rsi     # 0x533ef
movb $0x0, %al
callq 0x86f0
movq 0x3c48c(%rip), %rax     # 0x70fd8
movq (%rax), %rdi
leaq 0x1e26f(%rip), %rsi     # 0x52dc5
movb $0x0, %al
callq 0x86f0
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x34b77
movq 0x10(%rsp), %rdi
callq 0x8610
movb $0x0, 0x47(%rsp)
jmp 0x34b9d
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x34b98
movq 0x8(%rsp), %rdi
callq 0x8610
movb $0x1, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: yangwanyuan[P]HLKVDS/src/MetaStor.cc
// Function: hlkvds::MetaStor::createIndex(unsigned int, unsigned long)
bool MetaStor::createIndex(uint32_t ht_size, uint64_t index_size) {
    idxMgr_->InitMeta(ht_size, index_size, 0, 0);

    uint64_t length = index_size;
    char *buff = new char[length];
    memset(buff, 0, length);

    if(!idxMgr_->Set(buff, length)){
        __ERROR("Can't Set Index Region, Load Failed!");
        delete[] buff;
        return false;
    }

    delete[] buff;
    return true;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movl %esi, 0x44(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rax), %rdi
movl 0x44(%rsp), %esi
movq 0x38(%rsp), %rdx
xorl %eax, %eax
movl %eax, %ecx
xorl %r8d, %r8d
callq 0x256f0
movq 0x38(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x8040
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rdx
xorl %esi, %esi
callq 0x8280
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
callq 0x25b30
testb $0x1, %al
jne 0x34cc0
jmp 0x34c31
movq 0x3c3a0(%rip), %rax     # 0x70fd8
movq (%rax), %rax
movq %rax, 0x18(%rsp)
callq 0x8480
movq 0x18(%rsp), %rdi
movq %rax, %rdx
leaq 0x1d85d(%rip), %rsi     # 0x524b1
leaq 0x1e896(%rip), %rcx     # 0x534f1
leaq 0x1e5eb(%rip), %r8      # 0x5324d
movl $0x123, %r9d            # imm = 0x123
movb $0x0, %al
callq 0x86f0
movq 0x3c362(%rip), %rax     # 0x70fd8
movq (%rax), %rdi
leaq 0x1e87d(%rip), %rsi     # 0x534fd
movb $0x0, %al
callq 0x86f0
movq 0x3c34a(%rip), %rax     # 0x70fd8
movq (%rax), %rdi
leaq 0x1e12d(%rip), %rsi     # 0x52dc5
movb $0x0, %al
callq 0x86f0
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x34cb9
movq 0x10(%rsp), %rdi
callq 0x8610
movb $0x0, 0x57(%rsp)
jmp 0x34cdf
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x34cda
movq 0x8(%rsp), %rdi
callq 0x8610
movb $0x1, 0x57(%rsp)
movb 0x57(%rsp), %al
andb $0x1, %al
addq $0x58, %rsp
retq
nopw (%rax,%rax)
// File: yangwanyuan[P]HLKVDS/src/MetaStor.cc
// Function: hlkvds::MetaStor::createDataStor()
bool MetaStor::createDataStor() {
    if (!dataStor_->CreateAllComponents(sstOff_)) {
        __ERROR("Can't Create DataStore");
        return false;
    }

    uint64_t length = dataStor_->GetSSTsLengthOnDisk();

    char *buff = new char[length];
    memset(buff, 0 , length);

    if (!dataStor_->SetAllSSTs(buff, length)) {
        __ERROR("Can't Set SST Region, Load Failed!");
        delete[] buff;
        return false;
    }

    delete[] buff;
    return true;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x28(%rax), %rdi
movq 0x48(%rax), %rsi
movq (%rdi), %rax
callq *0x80(%rax)
testb $0x1, %al
jne 0x34d92
jmp 0x34d1a
movq 0x3c2b7(%rip), %rax     # 0x70fd8
movq (%rax), %rax
movq %rax, 0x18(%rsp)
callq 0x8480
movq 0x18(%rsp), %rdi
movq %rax, %rdx
leaq 0x1d774(%rip), %rsi     # 0x524b1
leaq 0x1e8a6(%rip), %rcx     # 0x535ea
leaq 0x1e502(%rip), %r8      # 0x5324d
movl $0x162, %r9d            # imm = 0x162
movb $0x0, %al
callq 0x86f0
movq 0x3c279(%rip), %rax     # 0x70fd8
movq (%rax), %rdi
leaq 0x1e890(%rip), %rsi     # 0x535f9
movb $0x0, %al
callq 0x86f0
movq 0x3c261(%rip), %rax     # 0x70fd8
movq (%rax), %rdi
leaq 0x1e044(%rip), %rsi     # 0x52dc5
movb $0x0, %al
callq 0x86f0
movb $0x0, 0x47(%rsp)
jmp 0x34e98
movq 0x20(%rsp), %rax
movq 0x28(%rax), %rdi
movq (%rdi), %rax
callq *0x98(%rax)
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x8040
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rdx
xorl %esi, %esi
callq 0x8280
movq 0x20(%rsp), %rax
movq 0x28(%rax), %rdi
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq (%rdi), %rax
callq *0x78(%rax)
testb $0x1, %al
jne 0x34e7b
jmp 0x34dec
movq 0x3c1e5(%rip), %rax     # 0x70fd8
movq (%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x8480
movq 0x10(%rsp), %rdi
movq %rax, %rdx
leaq 0x1d6a2(%rip), %rsi     # 0x524b1
leaq 0x1e7d4(%rip), %rcx     # 0x535ea
leaq 0x1e430(%rip), %r8      # 0x5324d
movl $0x16c, %r9d            # imm = 0x16C
movb $0x0, %al
callq 0x86f0
movq 0x3c1a7(%rip), %rax     # 0x70fd8
movq (%rax), %rdi
leaq 0x1e7d5(%rip), %rsi     # 0x53610
movb $0x0, %al
callq 0x86f0
movq 0x3c18f(%rip), %rax     # 0x70fd8
movq (%rax), %rdi
leaq 0x1df72(%rip), %rsi     # 0x52dc5
movb $0x0, %al
callq 0x86f0
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x34e74
movq 0x8(%rsp), %rdi
callq 0x8610
movb $0x0, 0x47(%rsp)
jmp 0x34e98
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x34e93
movq (%rsp), %rdi
callq 0x8610
movb $0x1, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: yangwanyuan[P]HLKVDS/src/MetaStor.cc
// Function: hlkvds::MetaStor::LoadMetaData()
bool MetaStor::LoadMetaData() {

    //Load Index
    uint32_t index_ht_size = sbMgr_->GetHTSize();
    uint64_t sb_region_length = SuperBlockManager::SuperBlockSizeOnDevice();
    uint64_t index_region_length = sbMgr_->GetIndexRegionLength();

    idxOff_ = sbOff_ + sb_region_length;
    if(!loadIndex(index_ht_size, index_region_length)) {
        __ERROR("Load Index failed.");
        return false;
    }

    //Load DataStor
    sstOff_ = idxOff_ + index_region_length;
    if (!loadDataStor()) {
        __ERROR("Load SSTs failed.");
        return false;
    }

    return true;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rax), %rdi
callq 0x36250
movl %eax, 0x34(%rsp)
callq 0x117e0
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x28(%rsp)
movq 0x18(%rax), %rdi
callq 0x36260
movq 0x18(%rsp), %rdi
movq %rax, 0x20(%rsp)
movq 0x38(%rdi), %rax
addq 0x28(%rsp), %rax
movq %rax, 0x40(%rdi)
movl 0x34(%rsp), %esi
movq 0x20(%rsp), %rdx
callq 0x35290
testb $0x1, %al
jne 0x351ee
jmp 0x35176
movq 0x3be5b(%rip), %rax     # 0x70fd8
movq (%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x8480
movq 0x10(%rsp), %rdi
movq %rax, %rdx
leaq 0x1d318(%rip), %rsi     # 0x524b1
leaq 0x1e1be(%rip), %rcx     # 0x5335e
leaq 0x1e0a6(%rip), %r8      # 0x5324d
movl $0xbb, %r9d
movb $0x0, %al
callq 0x86f0
movq 0x3be1d(%rip), %rax     # 0x70fd8
movq (%rax), %rdi
leaq 0x1e1a6(%rip), %rsi     # 0x5336b
movb $0x0, %al
callq 0x86f0
movq 0x3be05(%rip), %rax     # 0x70fd8
movq (%rax), %rdi
leaq 0x1dbe8(%rip), %rsi     # 0x52dc5
movb $0x0, %al
callq 0x86f0
movb $0x0, 0x47(%rsp)
jmp 0x35285
movq 0x18(%rsp), %rdi
movq 0x40(%rdi), %rax
addq 0x20(%rsp), %rax
movq %rax, 0x48(%rdi)
callq 0x354e0
testb $0x1, %al
jne 0x35280
jmp 0x3520b
movq 0x3bdc6(%rip), %rax     # 0x70fd8
movq (%rax), %rax
movq %rax, 0x8(%rsp)
callq 0x8480
movq 0x8(%rsp), %rdi
movq %rax, %rdx
leaq 0x1d283(%rip), %rsi     # 0x524b1
leaq 0x1e129(%rip), %rcx     # 0x5335e
leaq 0x1e011(%rip), %r8      # 0x5324d
movl $0xc2, %r9d
movb $0x0, %al
callq 0x86f0
movq 0x3bd88(%rip), %rax     # 0x70fd8
movq (%rax), %rdi
leaq 0x1e124(%rip), %rsi     # 0x5337e
movb $0x0, %al
callq 0x86f0
movq 0x3bd70(%rip), %rax     # 0x70fd8
movq (%rax), %rdi
leaq 0x1db53(%rip), %rsi     # 0x52dc5
movb $0x0, %al
callq 0x86f0
movb $0x0, 0x47(%rsp)
jmp 0x35285
movb $0x1, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq