LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: yangwanyuan[P]HLKVDS/src/DS_MultiVolume_Impl.cc
// Function: hlkvds::DS_MultiVolume_Impl::updateMeta(hlkvds::Request*)
Status DS_MultiVolume_Impl::updateMeta(Request *req) {
    bool res = req->GetWriteStat();
    // update index
    if (!res) {
        return Status::Aborted("Write failed");
    }
    KVSlice *slice = &req->GetSlice();
    res = idxMgr_->UpdateIndex(slice);
    // minus the segment delete counter
    SegForReq *seg = req->GetSeg();
    if (!seg->CommitedAndGetNum()) {
        idxMgr_->AddToReaper(seg);
    }
    return Status::OK();
}

// Assembly:
subq $0x48, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
callq 0x16a70
andb $0x1, %al
movb %al, 0x2f(%rsp)
testb $0x1, 0x2f(%rsp)
jne 0x151a2
movq (%rsp), %rdi
leaq 0x3d710(%rip), %rsi     # 0x528ab
callq 0x163e0
jmp 0x15209
movq 0x30(%rsp), %rdi
callq 0x16a90
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x20(%rsp)
movq 0x20(%rax), %rdi
movq 0x20(%rsp), %rsi
xorl %edx, %edx
callq 0x25ec0
andb $0x1, %al
movb %al, 0x2f(%rsp)
movq 0x30(%rsp), %rdi
callq 0x16aa0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x16ab0
cmpl $0x0, %eax
jne 0x15200
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0x27450
movq (%rsp), %rdi
callq 0x16560
movq 0x8(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: yangwanyuan[P]HLKVDS/src/DS_MultiVolume_Impl.cc
// Function: hlkvds::DS_MultiVolume_Impl::getTotalFreeSegs()
uint32_t DS_MultiVolume_Impl::getTotalFreeSegs() {
    uint32_t free_num = 0;
    for (uint32_t i = 0; i < volNum_; i++) {
        free_num += volMap_[i]->GetTotalFreeSegs();
    }
    return free_num;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movq 0x8(%rsp), %rcx
movl 0x18(%rsp), %eax
cmpl 0xe0(%rcx), %eax
jae 0x1528c
movq 0x8(%rsp), %rdi
addq $0x28, %rdi
movl 0x18(%rsp), %eax
movl %eax, 0x14(%rsp)
leaq 0x14(%rsp), %rsi
callq 0x160f0
movq (%rax), %rdi
callq 0x510f0
addl 0x1c(%rsp), %eax
movl %eax, 0x1c(%rsp)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x15243
movl 0x1c(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: yangwanyuan[P]HLKVDS/src/DS_MultiVolume_Impl.cc
// Function: hlkvds::DS_MultiVolume_Impl::SegWrite(hlkvds::SegForReq*)
void DS_MultiVolume_Impl::SegWrite(SegForReq *seg) {
    Volume *vol =  seg->GetSelfVolume();

    uint32_t seg_id = 0;
    bool res;
    while (!vol->Alloc(seg_id)) {
        res = vol->ForeGC();
        if (!res) {
            __ERROR("Cann't get a new Empty Segment.\n");
            seg->Notify(res);
        }
    }
    uint32_t free_size = seg->GetFreeSize();
    seg->SetSegId(seg_id);
    res = seg->WriteSegToDevice();
    if (res) {
        vol->Use(seg_id, free_size);
    } else {
        vol->FreeForFailed(seg_id);
    }
    seg->Notify(res);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x16f70
movq %rax, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
leaq 0x1c(%rsp), %rsi
callq 0x50e40
xorb $-0x1, %al
testb $0x1, %al
jne 0x1564f
jmp 0x156f2
movq 0x20(%rsp), %rdi
callq 0x51250
andb $0x1, %al
movb %al, 0x1b(%rsp)
testb $0x1, 0x1b(%rsp)
jne 0x156ed
jmp 0x1566c
movq 0x5b965(%rip), %rax     # 0x70fd8
movq (%rax), %rax
movq %rax, 0x8(%rsp)
callq 0x8480
movq 0x8(%rsp), %rdi
movq %rax, %rdx
leaq 0x3ce22(%rip), %rsi     # 0x524b1
leaq 0x3d252(%rip), %rcx     # 0x528e8
leaq 0x3ceb4(%rip), %r8      # 0x52551
movl $0x2a7, %r9d            # imm = 0x2A7
movb $0x0, %al
callq 0x86f0
movq 0x5b927(%rip), %rax     # 0x70fd8
movq (%rax), %rdi
leaq 0x3d00c(%rip), %rsi     # 0x526c7
movb $0x0, %al
callq 0x86f0
movq 0x5b90f(%rip), %rax     # 0x70fd8
movq (%rax), %rdi
leaq 0x3d6f2(%rip), %rsi     # 0x52dc5
movb $0x0, %al
callq 0x86f0
movq 0x28(%rsp), %rdi
movb 0x1b(%rsp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x42d10
jmp 0x15635
movq 0x28(%rsp), %rdi
callq 0x16540
movl %eax, 0x14(%rsp)
movq 0x28(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x164f0
movq 0x28(%rsp), %rdi
callq 0x41bb0
andb $0x1, %al
movb %al, 0x1b(%rsp)
testb $0x1, 0x1b(%rsp)
je 0x15739
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
movl 0x14(%rsp), %edx
callq 0x51220
jmp 0x15747
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x511c0
movq 0x28(%rsp), %rdi
movb 0x1b(%rsp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x42d10
addq $0x38, %rsp
retq
nop
// File: yangwanyuan[P]HLKVDS/./src/include/WorkQueue.h
// Function: dslab::WorkQueue<hlkvds::Request>::Stop()
void Stop() {
        stop_.store(true);
        cv_.notify_all();
        for (auto &t : threads_) {
            t.join();
        }
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0xcc, %rdi
movl $0x1, %esi
movl $0x5, %edx
callq 0x15f20
movq 0x8(%rsp), %rdi
addq $0x80, %rdi
callq 0x87e0
movq 0x8(%rsp), %rax
addq $0xb0, %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x1c0a0
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x1bee0
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x1efd0
testb $0x1, %al
jne 0x1627d
jmp 0x162a2
leaq 0x20(%rsp), %rdi
callq 0x1f010
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x87f0
leaq 0x20(%rsp), %rdi
callq 0x1f020
jmp 0x16268
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: yangwanyuan[P]HLKVDS/./src/include/WorkQueue.h
// Function: dslab::WorkQueue<hlkvds::Request>::worker()
void worker()
    {
        while(1) {
            std::unique_lock<std::mutex> lck(mtx_, std::defer_lock);
            lck.lock();
            cv_.wait_for(lck, std::chrono::milliseconds(1000), [this] {return !dataQueue_.empty();});

            if (this->stop_.load() && this->dataQueue_.empty()) {
                lck.unlock();
                return;
            }
                
            if  (!this->dataQueue_.empty()) {
                T* data = dataQueue_.front();
                dataQueue_.pop();
                lck.unlock();
                _void_process(data);
            }
            else {
                lck.unlock();
            }
        }
    }

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rsi
addq $0x58, %rsi
leaq 0x70(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x16db0
movq 0x20(%rsp), %rdi
callq 0x16dd0
jmp 0x1ba40
movq 0x28(%rsp), %rax
subq $-0x80, %rax
movq %rax, 0x18(%rsp)
movl $0x3e8, 0x4c(%rsp)      # imm = 0x3E8
leaq 0x50(%rsp), %rdi
leaq 0x4c(%rsp), %rsi
callq 0x1c530
jmp 0x1ba67
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rcx
leaq 0x70(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0x1c4a0
jmp 0x1ba8c
movq 0x28(%rsp), %rdi
addq $0xcc, %rdi
movl $0x5, %esi
callq 0x1c550
testb $0x1, %al
jne 0x1baa8
jmp 0x1bafc
movq 0x28(%rsp), %rdi
addq $0x8, %rdi
callq 0x1c5e0
movb %al, 0x17(%rsp)
jmp 0x1babc
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x1bac6
jmp 0x1bafc
leaq 0x70(%rsp), %rdi
callq 0x16e30
jmp 0x1bad2
movl $0x1, 0x3c(%rsp)
jmp 0x1bb81
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x15c30
jmp 0x1bba4
movq 0x28(%rsp), %rdi
addq $0x8, %rdi
callq 0x1c5e0
movb %al, 0x16(%rsp)
jmp 0x1bb10
movb 0x16(%rsp), %al
testb $0x1, %al
jne 0x1bb6b
jmp 0x1bb1a
movq 0x28(%rsp), %rdi
addq $0x8, %rdi
callq 0x1c600
movq %rax, 0x8(%rsp)
jmp 0x1bb2f
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x30(%rsp)
addq $0x8, %rdi
callq 0x1c610
jmp 0x1bb4c
leaq 0x70(%rsp), %rdi
callq 0x16e30
jmp 0x1bb58
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x1c620
jmp 0x1bb69
jmp 0x1bb79
leaq 0x70(%rsp), %rdi
callq 0x16e30
jmp 0x1bb77
jmp 0x1bb79
movl $0x0, 0x3c(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x15c30
movl 0x3c(%rsp), %eax
testl %eax, %eax
je 0x1bb97
jmp 0x1bb95
jmp 0x1bb9c
jmp 0x1ba1c
addq $0x88, %rsp
retq
movq 0x60(%rsp), %rdi
callq 0x8820
nop
// File: yangwanyuan[P]HLKVDS/src/DataStor.cc
// Function: hlkvds::DataStor::Create(hlkvds::Options&, std::vector<hlkvds::BlockDevice*, std::allocator<hlkvds::BlockDevice*>>&, hlkvds::SuperBlockManager*, hlkvds::IndexManager*, int)
DataStor* DataStor::Create(Options &opts, std::vector<BlockDevice*> &dev_vec, SuperBlockManager* sb, IndexManager* idx, int datastor_type) {

    switch (datastor_type) {
        case 0:
            return new DS_MultiVolume_Impl(opts, dev_vec, sb, idx);
        case 1:
            return new DS_MultiTier_Impl(opts, dev_vec, sb, idx);
        default:
            __ERROR("UnKnow DataStor Type!");
            return NULL;
    }
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq %rcx, 0x30(%rsp)
movl %r8d, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
movl %eax, 0x18(%rsp)
testl %eax, %eax
je 0x21b69
jmp 0x21b5b
movl 0x18(%rsp), %eax
subl $0x1, %eax
je 0x21bc5
jmp 0x21c21
movl $0x170, %edi            # imm = 0x170
callq 0x84f0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq 0x38(%rsp), %rcx
movq 0x30(%rsp), %r8
callq 0x11830
jmp 0x21b99
movq 0x10(%rsp), %rax
movq %rax, 0x50(%rsp)
jmp 0x21c98
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x84b0
jmp 0x21ca2
movl $0x48, %edi
callq 0x84f0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq 0x38(%rsp), %rcx
movq 0x30(%rsp), %r8
callq 0x106c0
jmp 0x21bf5
movq 0x8(%rsp), %rax
movq %rax, 0x50(%rsp)
jmp 0x21c98
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x84b0
jmp 0x21ca2
jmp 0x21c23
movq 0x4f3ae(%rip), %rax     # 0x70fd8
movq (%rax), %rax
movq %rax, (%rsp)
callq 0x8480
movq (%rsp), %rdi
movq %rax, %rdx
leaq 0x3086d(%rip), %rsi     # 0x524b1
leaq 0x30ee1(%rip), %rcx     # 0x52b2c
leaq 0x30ee1(%rip), %r8      # 0x52b33
movl $0xf, %r9d
movb $0x0, %al
callq 0x86f0
movq 0x4f372(%rip), %rax     # 0x70fd8
movq (%rax), %rdi
leaq 0x30ed3(%rip), %rsi     # 0x52b43
movb $0x0, %al
callq 0x86f0
movq 0x4f35a(%rip), %rax     # 0x70fd8
movq (%rax), %rdi
leaq 0x3113d(%rip), %rsi     # 0x52dc5
movb $0x0, %al
callq 0x86f0
movq $0x0, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x8820
nopl (%rax)
// File: yangwanyuan[P]HLKVDS/src/GcManager.cc
// Function: hlkvds::GcManager::GcManager(hlkvds::IndexManager*, hlkvds::Volume*, hlkvds::Options&)
GcManager::GcManager(IndexManager* im, Volume* vol, Options &opt) :
    options_(opt), dataBuf_(NULL) {
    idxMgr_ = im;
    vol_ = vol;

    uint32_t seg_size = vol_->GetSegmentSize();
    posix_memalign((void **)&dataBuf_, 4096, seg_size);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rdi)
addq $0x18, %rdi
callq 0x15800
movq 0x8(%rsp), %rax
movq $0x0, 0x40(%rax)
movq 0x28(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rcx
movq %rcx, (%rax)
movq (%rax), %rdi
callq 0x234a0
movq 0x8(%rsp), %rdi
movl %eax, 0x14(%rsp)
addq $0x40, %rdi
movl 0x14(%rsp), %eax
movl %eax, %edx
movl $0x1000, %esi           # imm = 0x1000
callq 0x8230
addq $0x38, %rsp
retq
nopl (%rax)
// File: yangwanyuan[P]HLKVDS/src/GcManager.cc
// Function: hlkvds::GcManager::ForeGC()
bool GcManager::ForeGC() {
    std::lock_guard < std::mutex > lck_gc(gcMtx_);
    //check free segment;
    uint32_t free_seg_num = vol_->GetTotalFreeSegs();
    if (free_seg_num > SEG_RESERVED_FOR_GC) {
        __DEBUG("some thread already called doForeGC, ignore this call!");
        return true;
    }

    free_seg_num = 0;
    __DEBUG("Begin Fore GC !");
    while (!free_seg_num) {
        std::multimap < uint32_t, uint32_t > cands_map;
        vol_->SortSegsByUtils(cands_map, options_.seg_full_rate);
        if (cands_map.empty()) {
            break;
        }
        free_seg_num = doMerge(cands_map);
        cands_map.clear();
        __DEBUG("Once merge total free %d segments!", free_seg_num);
    }
    return free_seg_num ? true : false;
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movq 0x78(%rsp), %rsi
movq %rsi, 0x18(%rsp)
addq $0x18, %rsi
leaq 0x70(%rsp), %rdi
callq 0xb5f0
movq 0x18(%rsp), %rax
movq (%rax), %rdi
callq 0x510f0
movl %eax, 0x24(%rsp)
jmp 0x21d97
movl 0x24(%rsp), %eax
movl %eax, 0x6c(%rsp)
cmpl $0x2, 0x6c(%rsp)
jbe 0x21dce
movb $0x1, 0x87(%rsp)
movl $0x1, 0x58(%rsp)
jmp 0x21eb1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x21ecc
movl $0x0, 0x6c(%rsp)
cmpl $0x0, 0x6c(%rsp)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x21de9
jmp 0x21e96
leaq 0x28(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x234b0
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rsi
movq (%rax), %rdi
movq 0x10(%rax), %rax
movsd 0x20(%rax), %xmm0
callq 0x51130
jmp 0x21e15
leaq 0x28(%rsp), %rdi
callq 0x234c0
testb $0x1, %al
jne 0x21e25
jmp 0x21e4c
movl $0x3, 0x58(%rsp)
jmp 0x21e7b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x234f0
jmp 0x21ecc
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x21ee0
movl %eax, 0xc(%rsp)
jmp 0x21e61
movl 0xc(%rsp), %eax
movl %eax, 0x6c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x234e0
movl $0x0, 0x58(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x234f0
movl 0x58(%rsp), %eax
testl %eax, %eax
je 0x21e91
jmp 0x21e8f
jmp 0x21e96
jmp 0x21dd6
movl 0x6c(%rsp), %ecx
xorl %eax, %eax
negl %ecx
sbbl %eax, %eax
andb $0x1, %al
movb %al, 0x87(%rsp)
movl $0x1, 0x58(%rsp)
leaq 0x70(%rsp), %rdi
callq 0xb830
movb 0x87(%rsp), %al
andb $0x1, %al
addq $0x88, %rsp
retq
leaq 0x70(%rsp), %rdi
callq 0xb830
movq 0x60(%rsp), %rdi
callq 0x8820
// File: yangwanyuan[P]HLKVDS/src/GcManager.cc
// Function: hlkvds::GcManager::loadKvList(unsigned int, std::__cxx11::list<hlkvds::KVSlice*, std::allocator<hlkvds::KVSlice*>>&)
bool GcManager::loadKvList(uint32_t seg_id, std::list<KVSlice*> &slice_list) {
    uint64_t seg_phy_off;
    vol_->CalcSegOffsetFromId(seg_id, seg_phy_off);

    uint32_t seg_size = vol_->GetSegmentSize();
    if (!vol_->Read(dataBuf_, seg_size, seg_phy_off)) {
        return false;
    }

    SegHeaderOnDisk seg_header;
    memcpy(&seg_header, dataBuf_, SegBase::SizeOfSegOnDisk());

    uint32_t num_keys = seg_header.number_keys;

    loadSegKV(slice_list, num_keys, seg_phy_off);
    return true;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movl %esi, 0x64(%rsp)
movq %rdx, 0x58(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x10(%rsp)
movq (%rax), %rdi
movl 0x64(%rsp), %esi
leaq 0x50(%rsp), %rdx
callq 0x23960
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x234a0
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x4c(%rsp)
movq (%rax), %rdi
movq 0x40(%rax), %rsi
movl 0x4c(%rsp), %eax
movl %eax, %edx
movq 0x50(%rsp), %rcx
callq 0x50ed0
testb $0x1, %al
jne 0x22e5a
movb $0x0, 0x77(%rsp)
jmp 0x22edd
leaq 0x28(%rsp), %rdi
callq 0x40a80
movq 0x10(%rsp), %rax
movq 0x40(%rax), %rax
movq %rax, (%rsp)
callq 0x166a0
movq %rax, 0x8(%rsp)
jmp 0x22e7d
movq 0x8(%rsp), %rdx
movq (%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0x8410
movq 0x10(%rsp), %rdi
movl 0x44(%rsp), %eax
movl %eax, 0x18(%rsp)
movq 0x58(%rsp), %rsi
movl 0x18(%rsp), %edx
movq 0x50(%rsp), %rcx
callq 0x22fc0
jmp 0x22eb2
movb $0x1, 0x77(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x40ac0
jmp 0x22edd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x40ac0
jmp 0x22ee8
movb 0x77(%rsp), %al
andb $0x1, %al
addq $0x78, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x8820
nopw %cs:(%rax,%rax)
// File: yangwanyuan[P]HLKVDS/src/GcManager.cc
// Function: hlkvds::GcManager::cleanKvList(std::__cxx11::list<hlkvds::KVSlice*, std::allocator<hlkvds::KVSlice*>>&)
void GcManager::cleanKvList(std::list<KVSlice*> &slice_list) {
    while (!slice_list.empty()) {
        KVSlice *slice = slice_list.front();
        slice_list.pop_front();
        const char* key = slice->GetKey();
        delete[] key;
        const char* data = slice->GetData();
        delete[] data;
        delete slice;
    }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0x239b0
xorb $-0x1, %al
testb $0x1, %al
jne 0x22f23
jmp 0x22fba
movq 0x38(%rsp), %rdi
callq 0x239d0
movq (%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
callq 0x23a00
movq 0x30(%rsp), %rdi
callq 0x23a30
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x22f68
movq 0x18(%rsp), %rdi
callq 0x8610
movq 0x30(%rsp), %rdi
callq 0x23a40
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x22f91
movq 0x10(%rsp), %rdi
callq 0x8610
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x22fb5
movq 0x8(%rsp), %rdi
callq 0x40c40
movq 0x8(%rsp), %rdi
callq 0x84b0
jmp 0x22f0e
addq $0x48, %rsp
retq
nop
// File: yangwanyuan[P]HLKVDS/./src/include/Volume.h
// Function: hlkvds::Volume::CalcSegOffsetFromId(unsigned int, unsigned long&)
inline bool CalcSegOffsetFromId(uint32_t seg_id, uint64_t& offset) {
        if (seg_id >= segNum_) {
            return false;
        }
        offset = ((uint64_t) seg_id << segSizeBit_);
        return true;
    }

// Assembly:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
movq %rdx, -0x20(%rsp)
movq -0x10(%rsp), %rcx
movq %rcx, -0x28(%rsp)
movl -0x14(%rsp), %eax
cmpl 0x3c(%rcx), %eax
jb 0x23988
movb $0x0, -0x1(%rsp)
jmp 0x239a7
movq -0x28(%rsp), %rcx
movl -0x14(%rsp), %eax
movl 0x40(%rcx), %ecx
shlq %cl, %rax
movq %rax, %rcx
movq -0x20(%rsp), %rax
movq %rcx, (%rax)
movb $0x1, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nop
// File: yangwanyuan[P]HLKVDS/src/IndexManager.cc
// Function: hlkvds::HashEntry::~HashEntry()
HashEntry::~HashEntry() {
    cachePtr_ = NULL;
    if (entryPtr_) {
        delete entryPtr_;
    }
    if (stampPtr_) {
        delete stampPtr_;
    }
    return;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq $0x0, 0x10(%rax)
cmpq $0x0, (%rax)
je 0x253fa
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x253f8
movq 0x10(%rsp), %rdi
callq 0x24fa0
movq 0x10(%rsp), %rdi
callq 0x84b0
jmp 0x253fa
movq 0x18(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x25430
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x2542e
movq 0x8(%rsp), %rdi
callq 0x27690
movq 0x8(%rsp), %rdi
callq 0x84b0
jmp 0x25430
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: yangwanyuan[P]HLKVDS/src/IndexManager.cc
// Function: hlkvds::HashEntry::operator=(hlkvds::HashEntry const&)
HashEntry& HashEntry::operator=(const HashEntry& toBeCopied) {
    *entryPtr_ = *toBeCopied.entryPtr_;
    *stampPtr_ = *toBeCopied.stampPtr_;
    cachePtr_ = toBeCopied.cachePtr_;
    return *this;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rcx
movq (%rcx), %rsi
movq (%rax), %rdi
callq 0x24fd0
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rsi
movq 0x8(%rax), %rdi
callq 0x276d0
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: yangwanyuan[P]HLKVDS/src/IndexManager.cc
// Function: hlkvds::IndexManager::InitMeta(unsigned int, unsigned long, unsigned long, unsigned int)
void IndexManager::InitMeta(uint32_t ht_size, uint64_t ondisk_size, uint64_t data_theory_size, uint32_t element_num) {
    htSize_ = ht_size;
    sizeOndisk_ = ondisk_size;
    initHashTable();

    //Set dataTheorySize
    dataTheorySize_ = data_theory_size;
    keyCounter_ = element_num;

}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movl %r8d, 0x14(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl 0x2c(%rsp), %eax
movl %eax, 0x8(%rdi)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rdi)
callq 0x25750
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, 0x20(%rax)
movl 0x14(%rsp), %ecx
movl %ecx, 0x18(%rax)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: yangwanyuan[P]HLKVDS/src/IndexManager.cc
// Function: hlkvds::IndexManager::IsSameInMem(hlkvds::HashEntry&)
bool IndexManager::IsSameInMem(HashEntry &entry)
{
    Kvdb_Digest digest = entry.GetKeyDigest();
    uint32_t hash_index = KeyDigestHandle::Hash(&digest) % htSize_;

    std::lock_guard<std::mutex> l(hashtable_[hash_index].slotMtx_);
    LinkedList<HashEntry> *entry_list = hashtable_[hash_index].entryList_;

    bool is_exist = entry_list->search(entry);
    if (!is_exist) {
        __DEBUG("Not Same, because entry is not exist!");
        return false;
    } else {
        HashEntry *entry_inMem = entry_list->getRef(entry);
        if (entry_inMem->GetHeaderAddress() == entry.GetHeaderAddress()) {
            __DEBUG("Same, because entry is same with in memory!");
            return true;
        }
    }

    __DEBUG("Not Same, because entry is not same with in memory!");
    return false;
}

// Assembly:
subq $0xc8, %rsp
movq %rdi, 0xb8(%rsp)
movq %rsi, 0xb0(%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0xb0(%rsp), %rsi
leaq 0x9c(%rsp), %rdi
movq %rdi, 0x40(%rsp)
callq 0x276a0
movq 0x40(%rsp), %rdi
callq 0x2a0b0
movl %eax, 0x4c(%rsp)
jmp 0x2665e
movq 0x38(%rsp), %rcx
movl 0x4c(%rsp), %eax
movl 0x8(%rcx), %ecx
xorl %edx, %edx
divl %ecx
movq 0x38(%rsp), %rax
movl %edx, 0x98(%rsp)
movq (%rax), %rax
movl 0x98(%rsp), %ecx
leaq (%rcx,%rcx,2), %rcx
shlq $0x4, %rcx
leaq 0x8(%rax,%rcx), %rsi
leaq 0x80(%rsp), %rdi
callq 0xb5f0
jmp 0x266a0
movq 0x38(%rsp), %rax
movq (%rax), %rax
movl 0x98(%rsp), %ecx
leaq (%rcx,%rcx,2), %rcx
shlq $0x4, %rcx
movq (%rax,%rcx), %rax
movq %rax, 0x78(%rsp)
movq 0x78(%rsp), %rdi
movq 0xb0(%rsp), %rsi
callq 0x27b80
movb %al, 0x37(%rsp)
jmp 0x266d8
movb 0x37(%rsp), %al
andb $0x1, %al
movb %al, 0x77(%rsp)
testb $0x1, 0x77(%rsp)
jne 0x26730
movb $0x0, 0xc7(%rsp)
movl $0x1, 0x70(%rsp)
jmp 0x26800
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0x26838
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0x2682b
movq 0x78(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0xb0(%rsp), %rsi
leaq 0x50(%rsp), %rdi
callq 0x252e0
jmp 0x2674e
movq 0x28(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x27be0
movq %rax, 0x20(%rsp)
jmp 0x26764
leaq 0x50(%rsp), %rdi
callq 0x253b0
movq 0x20(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rdi
callq 0x27e40
movq %rax, 0x18(%rsp)
jmp 0x26789
movq 0xb0(%rsp), %rdi
callq 0x27e40
movq %rax, 0x10(%rsp)
jmp 0x2679d
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdi
callq 0x27e60
movb %al, 0xf(%rsp)
jmp 0x267b2
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x267bc
jmp 0x267ee
movb $0x1, 0xc7(%rsp)
movl $0x1, 0x70(%rsp)
jmp 0x26800
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x253b0
jmp 0x2682b
jmp 0x267f0
movb $0x0, 0xc7(%rsp)
movl $0x1, 0x70(%rsp)
leaq 0x80(%rsp), %rdi
callq 0xb830
leaq 0x9c(%rsp), %rdi
callq 0x29d50
movb 0xc7(%rsp), %al
andb $0x1, %al
addq $0xc8, %rsp
retq
leaq 0x80(%rsp), %rdi
callq 0xb830
leaq 0x9c(%rsp), %rdi
callq 0x29d50
movq 0x90(%rsp), %rdi
callq 0x8820
nopw %cs:(%rax,%rax)
// File: yangwanyuan[P]HLKVDS/src/IndexManager.cc
// Function: hlkvds::IndexManager::UpdateIndexes(std::__cxx11::list<hlkvds::KVSlice*, std::allocator<hlkvds::KVSlice*>>&)
void IndexManager::UpdateIndexes(list<KVSlice*> &slice_list) {
    std::lock_guard<std::mutex> l(batch_mtx_);
    for (list<KVSlice *>::iterator iter = slice_list.begin(); iter
            != slice_list.end(); iter++) {
        KVSlice *slice = *iter;
        UpdateIndex(slice);
    } __DEBUG("UpdateToIndex Success!");
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rsi
movq %rsi, 0x8(%rsp)
addq $0x70, %rsi
leaq 0x40(%rsp), %rdi
callq 0xb5f0
movq 0x48(%rsp), %rdi
callq 0x16410
movq %rax, 0x38(%rsp)
movq 0x48(%rsp), %rdi
callq 0x16460
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x16440
testb $0x1, %al
jne 0x268b9
jmp 0x2690d
leaq 0x38(%rsp), %rdi
callq 0x16490
movq 0x8(%rsp), %rdi
movq (%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rsi
xorl %edx, %edx
callq 0x25ec0
jmp 0x268de
jmp 0x268e0
leaq 0x38(%rsp), %rdi
xorl %esi, %esi
callq 0x164c0
movq %rax, 0x10(%rsp)
jmp 0x26895
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xb830
jmp 0x2691c
leaq 0x40(%rsp), %rdi
callq 0xb830
addq $0x58, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x8820
nopw %cs:(%rax,%rax)
// File: yangwanyuan[P]HLKVDS/src/IndexManager.cc
// Function: hlkvds::IndexManager::UpdateIndexesForGC(std::__cxx11::list<hlkvds::KVSlice*, std::allocator<hlkvds::KVSlice*>>&)
void IndexManager::UpdateIndexesForGC(std::list<KVSlice*> &slice_list) {
    std::lock_guard<std::mutex> l(batch_mtx_);
    for (list<KVSlice *>::iterator iter = slice_list.begin(); iter
            != slice_list.end(); iter++) {
        KVSlice *slice = *iter;
        UpdateIndex(slice, true);
    } __DEBUG("UpdateToIndexForGC Success!");
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rsi
movq %rsi, 0x8(%rsp)
addq $0x70, %rsi
leaq 0x40(%rsp), %rdi
callq 0xb5f0
movq 0x48(%rsp), %rdi
callq 0x16410
movq %rax, 0x38(%rsp)
movq 0x48(%rsp), %rdi
callq 0x16460
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x16440
testb $0x1, %al
jne 0x26f69
jmp 0x26fc0
leaq 0x38(%rsp), %rdi
callq 0x16490
movq 0x8(%rsp), %rdi
movq (%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rsi
movl $0x1, %edx
callq 0x25ec0
jmp 0x26f91
jmp 0x26f93
leaq 0x38(%rsp), %rdi
xorl %esi, %esi
callq 0x164c0
movq %rax, 0x10(%rsp)
jmp 0x26f45
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0xb830
jmp 0x26fcf
leaq 0x40(%rsp), %rdi
callq 0xb830
addq $0x58, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x8820
nopl (%rax)
// File: yangwanyuan[P]HLKVDS/src/IndexManager.cc
// Function: hlkvds::IndexManager::CalcIndexSizeOnDevice(unsigned int)
uint64_t IndexManager::CalcIndexSizeOnDevice(uint32_t ht_size) {
    uint64_t index_size = sizeof(time_t)
            + sizeof(int) * ht_size
            + IndexManager::SizeOfHashEntryOnDisk() * ht_size;
    uint64_t index_size_pages = index_size / getpagesize();
    return (index_size_pages + 1) * getpagesize();
}

// Assembly:
subq $0x38, %rsp
movl %edi, 0x34(%rsp)
movl 0x34(%rsp), %eax
shlq $0x2, %rax
addq $0x8, %rax
movq %rax, 0x8(%rsp)
callq 0x166b0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movl 0x34(%rsp), %edx
imulq %rdx, %rcx
addq %rcx, %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x8860
movl %eax, %ecx
movq 0x10(%rsp), %rax
movslq %ecx, %rcx
xorl %edx, %edx
divq %rcx
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
callq 0x8860
movl %eax, %ecx
movq 0x18(%rsp), %rax
movslq %ecx, %rcx
imulq %rcx, %rax
addq $0x38, %rsp
retq
nop
// File: yangwanyuan[P]HLKVDS/src/IndexManager.cc
// Function: hlkvds::IndexManager::~IndexManager()
IndexManager::~IndexManager() {
    if (lastTime_) {
        delete lastTime_;
    }
    if (hashtable_) {
        destroyHashTable();
    }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x40(%rax)
je 0x27201
movq 0x8(%rsp), %rax
movq 0x40(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x271ff
movq (%rsp), %rdi
callq 0x50920
movq (%rsp), %rdi
callq 0x84b0
jmp 0x27201
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
je 0x2721a
movq 0x8(%rsp), %rdi
callq 0x27230
jmp 0x27218
jmp 0x2721a
addq $0x18, %rsp
retq
movq %rax, %rdi
callq 0xa6a0
nopw (%rax,%rax)
// File: yangwanyuan[P]HLKVDS/src/IndexManager.cc
// Function: hlkvds::IndexManager::CalcHashSizeForPower2(unsigned int)
uint32_t IndexManager::CalcHashSizeForPower2(uint32_t number) {
    // Gets the next highest power of 2 larger than number
    number--;
    number = (number >> 1) | number;
    number = (number >> 2) | number;
    number = (number >> 4) | number;
    number = (number >> 8) | number;
    number = (number >> 16) | number;
    number++;
    return number;
}

// Assembly:
movl %edi, -0x4(%rsp)
movl -0x4(%rsp), %eax
addl $-0x1, %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
shrl %eax
orl -0x4(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
shrl $0x2, %eax
orl -0x4(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
shrl $0x4, %eax
orl -0x4(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
shrl $0x8, %eax
orl -0x4(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
shrl $0x10, %eax
orl -0x4(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax)
// File: yangwanyuan[P]HLKVDS/./src/include/LinkedList.h
// Function: hlkvds::LinkedList<hlkvds::HashEntry>::get()
std::vector<T> LinkedList<T>::get() {
    std::vector<T> tempVector;
    if (head_ != NULL) {
        Node<T>* tempNode = head_;
        while (tempNode != NULL) {
            tempVector.push_back(tempNode->data);
            tempNode = tempNode->next;
        }
    }
    return tempVector;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movb $0x0, 0x37(%rsp)
callq 0x28130
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax)
je 0x27839
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x27837
movq (%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x28140
jmp 0x2780e
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x28(%rsp)
jmp 0x277f6
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x27970
jmp 0x27858
jmp 0x27839
movb $0x1, 0x37(%rsp)
testb $0x1, 0x37(%rsp)
jne 0x2784e
movq (%rsp), %rdi
callq 0x27970
movq 0x8(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x8820
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: yangwanyuan[P]HLKVDS/./src/include/LinkedList.h
// Function: hlkvds::LinkedList<hlkvds::HashEntry>::put(hlkvds::HashEntry&)
bool LinkedList<T>::put(T& toBePuted) {
    bool is_new = true;

    Node<T>* newNode = new Node<T> (toBePuted, NULL);
    if (head_ == NULL) {
        head_ = newNode;
        size_++;
    } else {
        Node<T>* curNode = head_;
        Node<T>* preNode;
        while (curNode != NULL) {
            if (curNode->data == toBePuted) {
                curNode->data = toBePuted;
                is_new = false;
                delete newNode;
                break;
            }
            preNode = curNode;
            curNode = curNode->next;
        }
        if (is_new) {
            curNode = newNode;
            preNode->next = curNode;
            size_++;
        }
    }
    return is_new;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
movb $0x1, 0x67(%rsp)
movl $0x20, %edi
callq 0x84f0
movq %rax, 0x18(%rsp)
movb $0x1, 0x33(%rsp)
movq 0x68(%rsp), %rsi
leaq 0x40(%rsp), %rdi
callq 0x252e0
jmp 0x27a12
movq 0x18(%rsp), %rdi
xorl %eax, %eax
movl %eax, %edx
leaq 0x40(%rsp), %rsi
callq 0x28cf0
jmp 0x27a27
movb $0x0, 0x33(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x253b0
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x58(%rsp)
cmpq $0x0, (%rax)
jne 0x27aa6
movq 0x10(%rsp), %rax
movq 0x58(%rsp), %rcx
movq %rcx, (%rax)
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
jmp 0x27b53
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x27a8e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x253b0
testb $0x1, 0x33(%rsp)
jne 0x27a97
jmp 0x27aa1
movq 0x18(%rsp), %rdi
callq 0x84b0
jmp 0x27b5e
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x27b24
movq 0x28(%rsp), %rdi
movq 0x68(%rsp), %rsi
callq 0x25440
testb $0x1, %al
jne 0x27ad0
jmp 0x27b0a
movq 0x68(%rsp), %rsi
movq 0x28(%rsp), %rdi
callq 0x25500
movb $0x0, 0x67(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x27b08
movq 0x8(%rsp), %rdi
callq 0x280b0
movq 0x8(%rsp), %rdi
callq 0x84b0
jmp 0x27b24
movq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x28(%rsp)
jmp 0x27ab3
testb $0x1, 0x67(%rsp)
je 0x27b51
movq 0x10(%rsp), %rax
movq 0x58(%rsp), %rcx
movq %rcx, 0x28(%rsp)
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rcx
movq %rdx, 0x18(%rcx)
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
jmp 0x27b53
movb 0x67(%rsp), %al
andb $0x1, %al
addq $0x78, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x8820
nopl (%rax,%rax)
// File: yangwanyuan[P]HLKVDS/./src/include/LinkedList.h
// Function: hlkvds::LinkedList<hlkvds::HashEntry>::search(hlkvds::HashEntry&)
bool LinkedList<T>::search(T& toBeSearched) {
    Node<T>* curNode = head_;

    while (curNode != NULL) {
        if (curNode->data == toBeSearched) {
            return true;
        }
        curNode = curNode->next;
    }
    return false;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x27bcf
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x25440
testb $0x1, %al
jne 0x27bb8
jmp 0x27bbf
movb $0x1, 0x27(%rsp)
jmp 0x27bd4
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x27b9b
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nop
// File: yangwanyuan[P]HLKVDS/./src/include/LinkedList.h
// Function: hlkvds::LinkedList<hlkvds::HashEntry>::getRef(hlkvds::HashEntry)
T* LinkedList<T>::getRef(T toBeGeted) {

    Node<T>* tempNode = head_;

    while (tempNode != NULL) {
        if (tempNode->data == toBeGeted) {
            return &tempNode->data;
        }
        tempNode = tempNode->next;

    }
    return NULL;

}

// Assembly:
subq $0x28, %rsp
movq %rsi, (%rsp)
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x27c37
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
callq 0x25440
testb $0x1, %al
jne 0x27c1b
jmp 0x27c27
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x27c40
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x27bff
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: yangwanyuan[P]HLKVDS/./src/include/IndexManager.h
// Function: hlkvds::HashEntry::LogicStamp::operator<(hlkvds::HashEntry::LogicStamp const&)
bool operator<(const LogicStamp& toBeCopied) {
            if ((segTime_ < toBeCopied.segTime_) || (segTime_
                    == toBeCopied.segTime_ && (keyNo_ < toBeCopied.keyNo_))) {
                return true;
            }
            return false;
        }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x10(%rsp), %rsi
callq 0x50820
testb $0x1, %al
jne 0x27cad
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x50890
testb $0x1, %al
jne 0x27c9b
jmp 0x27cb4
movq 0x8(%rsp), %rax
movl 0x10(%rax), %eax
movq 0x10(%rsp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x27cb4
movb $0x1, 0x27(%rsp)
jmp 0x27cb9
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: yangwanyuan[P]HLKVDS/./src/include/LinkedList.h
// Function: hlkvds::LinkedList<hlkvds::HashEntry>::remove(hlkvds::HashEntry&)
bool LinkedList<T>::remove(T& toBeRemoved) {
    bool flag = false;
    if (head_ == NULL) {
        return flag;
    }

    Node<T>* preNode = head_;
    Node<T>* curNode = preNode->next;

    if (head_->data == toBeRemoved) {
        head_ = curNode;
        delete preNode;
        size_--;
        flag = true;
    } else {
        while (curNode != NULL) {
            if (curNode->data == toBeRemoved) {
                preNode->next = curNode->next;
                delete curNode;
                size_--;
                flag = true;
                break;
            }
            preNode = curNode;
            curNode = curNode->next;
        }
    }
    return flag;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movb $0x0, 0x2f(%rsp)
cmpq $0x0, (%rax)
jne 0x27d12
movb 0x2f(%rsp), %al
andb $0x1, %al
movb %al, 0x47(%rsp)
jmp 0x27e16
movq 0x10(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x20(%rsp)
movq 0x20(%rsp), %rcx
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rsp)
movq (%rax), %rdi
movq 0x30(%rsp), %rsi
callq 0x25440
testb $0x1, %al
jne 0x27d40
jmp 0x27d89
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, (%rax)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x27d71
movq 0x8(%rsp), %rdi
callq 0x280b0
movq 0x8(%rsp), %rdi
callq 0x84b0
movq 0x10(%rsp), %rax
movl 0x8(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x8(%rax)
movb $0x1, 0x2f(%rsp)
jmp 0x27e0c
jmp 0x27d8b
cmpq $0x0, 0x18(%rsp)
je 0x27e0a
movq 0x18(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x25440
testb $0x1, %al
jne 0x27da8
jmp 0x27df0
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x27ddb
movq (%rsp), %rdi
callq 0x280b0
movq (%rsp), %rdi
callq 0x84b0
movq 0x10(%rsp), %rax
movl 0x8(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x8(%rax)
movb $0x1, 0x2f(%rsp)
jmp 0x27e0a
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
jmp 0x27d8b
jmp 0x27e0c
movb 0x2f(%rsp), %al
andb $0x1, %al
movb %al, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: yangwanyuan[P]HLKVDS/./src/include/LinkedList.h
// Function: hlkvds::LinkedList<hlkvds::HashEntry>::removeAll()
void LinkedList<T>::removeAll() {
    Node<T>* tempNode = head_;
    while (tempNode != NULL) {
        tempNode = head_->next;
        delete head_;
        head_ = tempNode;
    }
    size_ = 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq (%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x28095
movq 0x10(%rsp), %rax
movq (%rax), %rcx
movq 0x18(%rcx), %rcx
movq %rcx, 0x18(%rsp)
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x28086
movq 0x8(%rsp), %rdi
callq 0x280b0
movq 0x8(%rsp), %rdi
callq 0x84b0
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, (%rax)
jmp 0x2804b
movq 0x10(%rsp), %rax
movl $0x0, 0x8(%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: yangwanyuan[P]HLKVDS/src/KernelDevice.cc
// Function: hlkvds::KernelDevice::set_device_zero()
int KernelDevice::set_device_zero() {
    int r = 0;

    lseek(bufFd_, 0, SEEK_SET);
    r = fill_file_with_zeros();
    if (r < 0) {
        __ERROR("Could not zero out DB file.\n");
        return KD_ERR;
    }

    return KD_OK;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x14(%rsp)
movl 0xc(%rax), %edi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x88b0
movq 0x8(%rsp), %rdi
callq 0x28f70
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jge 0x28f56
jmp 0x28ee0
movq 0x480f1(%rip), %rax     # 0x70fd8
movq (%rax), %rax
movq %rax, (%rsp)
callq 0x8480
movq (%rsp), %rdi
movq %rax, %rdx
leaq 0x295b0(%rip), %rsi     # 0x524b1
leaq 0x29e7e(%rip), %rcx     # 0x52d86
leaq 0x29e87(%rip), %r8      # 0x52d96
movl $0x28, %r9d
movb $0x0, %al
callq 0x86f0
movq 0x480b5(%rip), %rax     # 0x70fd8
movq (%rax), %rdi
leaq 0x29e7d(%rip), %rsi     # 0x52daa
movb $0x0, %al
callq 0x86f0
movq 0x4809d(%rip), %rax     # 0x70fd8
movq (%rax), %rdi
leaq 0x29e80(%rip), %rsi     # 0x52dc5
movb $0x0, %al
callq 0x86f0
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x28f5e
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: yangwanyuan[P]HLKVDS/src/KernelDevice.cc
// Function: hlkvds::KernelDevice::fill_file_with_zeros()
int KernelDevice::fill_file_with_zeros() {
    size_t nbytes = capacity_;

    static const size_t BLOCKSIZE = 8192;
    char zeros[BLOCKSIZE];
    memset(zeros, 0, BLOCKSIZE);
    while (nbytes > 0) {
        size_t bytes_to_write = min(nbytes, BLOCKSIZE);
        ssize_t ret = write(bufFd_, zeros, bytes_to_write);
        if (ret < 0) {
            __ERROR("error in fill_file_with_zeros write: %s\n", strerror(errno));
            return KD_ERR;
        }
        nbytes -= bytes_to_write;
    }
    return KD_OK;
}

// Assembly:
subq $0x2048, %rsp           # imm = 0x2048
movq %rdi, 0x2038(%rsp)
movq 0x2038(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x2030(%rsp)
leaq 0x30(%rsp), %rdi
xorl %esi, %esi
movl $0x2000, %edx           # imm = 0x2000
callq 0x8280
cmpq $0x0, 0x2030(%rsp)
jbe 0x290b2
leaq 0x2030(%rsp), %rdi
leaq 0x29f59(%rip), %rsi     # 0x52f20
callq 0x1b7a0
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq (%rcx), %rcx
movq %rcx, 0x28(%rsp)
movl 0xc(%rax), %edi
leaq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0x8150
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jge 0x29095
jmp 0x29001
movq 0x47fd0(%rip), %rax     # 0x70fd8
movq (%rax), %rax
movq %rax, 0x8(%rsp)
callq 0x8480
movq 0x8(%rsp), %rdi
movq %rax, %rdx
leaq 0x2948d(%rip), %rsi     # 0x524b1
leaq 0x29d9c(%rip), %rcx     # 0x52dc7
leaq 0x29d64(%rip), %r8      # 0x52d96
movl $0x39, %r9d
movb $0x0, %al
callq 0x86f0
movq 0x47f92(%rip), %rax     # 0x70fd8
movq (%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x8070
movl (%rax), %edi
callq 0x8130
movq 0x10(%rsp), %rdi
movq %rax, %rdx
leaq 0x29d73(%rip), %rsi     # 0x52ddc
movb $0x0, %al
callq 0x86f0
movq 0x47f61(%rip), %rax     # 0x70fd8
movq (%rax), %rdi
leaq 0x29d44(%rip), %rsi     # 0x52dc5
movb $0x0, %al
callq 0x86f0
movl $0xffffffff, 0x2044(%rsp) # imm = 0xFFFFFFFF
jmp 0x290bd
movq 0x28(%rsp), %rcx
movq 0x2030(%rsp), %rax
subq %rcx, %rax
movq %rax, 0x2030(%rsp)
jmp 0x28fa9
movl $0x0, 0x2044(%rsp)
movl 0x2044(%rsp), %eax
addq $0x2048, %rsp           # imm = 0x2048
retq
nopl (%rax)
// File: yangwanyuan[P]HLKVDS/src/KernelDevice.cc
// Function: hlkvds::KernelDevice::get_block_device_capacity()
uint64_t KernelDevice::get_block_device_capacity() {
    uint64_t blocksize;
    if (ioctl(bufFd_, BLKGETSIZE64, &blocksize) < 0) {
        __ERROR("Could not get block size: %s\n", strerror(errno));
        return KD_ERR;
    }

    return blocksize;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movl 0xc(%rax), %edi
movl $0x80081272, %esi       # imm = 0x80081272
leaq 0x10(%rsp), %rdx
movb $0x0, %al
callq 0x86d0
cmpl $0x0, %eax
jge 0x2918d
jmp 0x290fd
movq 0x47ed4(%rip), %rax     # 0x70fd8
movq (%rax), %rax
movq %rax, (%rsp)
callq 0x8480
movq (%rsp), %rdi
movq %rax, %rdx
leaq 0x29393(%rip), %rsi     # 0x524b1
leaq 0x29ce0(%rip), %rcx     # 0x52e05
leaq 0x29c6a(%rip), %r8      # 0x52d96
movl $0x44, %r9d
movb $0x0, %al
callq 0x86f0
movq 0x47e98(%rip), %rax     # 0x70fd8
movq (%rax), %rax
movq %rax, 0x8(%rsp)
callq 0x8070
movl (%rax), %edi
callq 0x8130
movq 0x8(%rsp), %rdi
movq %rax, %rdx
leaq 0x29cbc(%rip), %rsi     # 0x52e1f
movb $0x0, %al
callq 0x86f0
movq 0x47e67(%rip), %rax     # 0x70fd8
movq (%rax), %rdi
leaq 0x29c4a(%rip), %rsi     # 0x52dc5
movb $0x0, %al
callq 0x86f0
movq $-0x1, 0x20(%rsp)
jmp 0x29197
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: yangwanyuan[P]HLKVDS/src/KernelDevice.cc
// Function: hlkvds::KernelDevice::lock_device()
int KernelDevice::lock_device()
{
    struct flock l;
    memset(&l, 0, sizeof(l));
    l.l_type = F_WRLCK;
    l.l_whence = SEEK_SET;
    int r = ::fcntl(directFd_, F_SETLK, &l);
    if (r < 0) {
        return KD_ERR;
    }
    return KD_OK;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x18(%rsp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x8280
movq 0x8(%rsp), %rax
movw $0x1, 0x18(%rsp)
movw $0x0, 0x1a(%rsp)
movl 0x8(%rax), %edi
movl $0x6, %esi
leaq 0x18(%rsp), %rdx
movb $0x0, %al
callq 0x82a0
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jge 0x29210
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0x29218
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: yangwanyuan[P]HLKVDS/src/KernelDevice.cc
// Function: hlkvds::KernelDevice::Close()
void KernelDevice::Close() {
    isOpen_ = false;

    if (directFd_ != -1) {
        close(directFd_);
    }
    if (bufFd_ != -1) {
        close(bufFd_);
    }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movb $0x0, 0x40(%rax)
cmpl $-0x1, 0x8(%rax)
je 0x298aa
movq 0x8(%rsp), %rax
movl 0x8(%rax), %edi
callq 0x8900
movq 0x8(%rsp), %rax
cmpl $-0x1, 0xc(%rax)
je 0x298c2
movq 0x8(%rsp), %rax
movl 0xc(%rax), %edi
callq 0x8900
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: yangwanyuan[P]HLKVDS/src/KernelDevice.cc
// Function: hlkvds::KernelDevice::pWrite(void const*, unsigned long, long)
ssize_t KernelDevice::pWrite(const void* buf, size_t count, off_t offset) {
    if (IsPageAligned(buf) &&
        IsSectorAligned(count) &&
        IsSectorAligned(offset)) {
        return DirectWriteAligned(buf, count, offset);
    }
    __INFO("Buffered FD Pwrite, write size = %ld, block_size = %d",
            count, GetBlockSize());
    //return pwrite(bufFd_, buf, count, offset);
    ssize_t ret = pwrite(bufFd_, buf, count, offset);
    fsync(bufFd_);
    return ret;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq %rcx, 0x30(%rsp)
movq 0x48(%rsp), %rdi
movq %rdi, 0x20(%rsp)
movq 0x40(%rsp), %rsi
callq 0x29b70
testb $0x1, %al
jne 0x29902
jmp 0x2994f
movq 0x20(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x29bb0
testb $0x1, %al
jne 0x29917
jmp 0x2994f
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x29bb0
testb $0x1, %al
jne 0x2992c
jmp 0x2994f
movq 0x20(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq 0x30(%rsp), %rcx
callq 0x29a30
movq %rax, 0x50(%rsp)
jmp 0x29a20
jmp 0x29951
movq 0x47680(%rip), %rax     # 0x70fd8
movq (%rax), %rax
movq %rax, 0x8(%rsp)
callq 0x8480
movq 0x8(%rsp), %rdi
movq %rax, %rdx
leaq 0x28a48(%rip), %rsi     # 0x523bc
leaq 0x29562(%rip), %rcx     # 0x52edd
leaq 0x29414(%rip), %r8      # 0x52d96
movl $0xaf, %r9d
movb $0x0, %al
callq 0x86f0
movq 0x20(%rsp), %rdi
movq 0x4763d(%rip), %rax     # 0x70fd8
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movq (%rdi), %rax
callq *0x40(%rax)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rdx
movl %eax, %ecx
leaq 0x2951e(%rip), %rsi     # 0x52ee4
movb $0x0, %al
callq 0x86f0
movq 0x47604(%rip), %rax     # 0x70fd8
movq (%rax), %rdi
leaq 0x293e7(%rip), %rsi     # 0x52dc5
movb $0x0, %al
callq 0x86f0
movq 0x20(%rsp), %rax
movl 0xc(%rax), %edi
movq 0x40(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq 0x30(%rsp), %rcx
callq 0x8110
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x28(%rsp)
movl 0xc(%rax), %edi
callq 0x8450
movq 0x28(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nopw (%rax,%rax)
// File: yangwanyuan[P]HLKVDS/src/KeyDigestHandle.cc
// Function: hlkvds::KeyDigestHandle::Hash(hlkvds::Kvdb_Key const*)
uint32_t KeyDigestHandle::Hash(const Kvdb_Key *key) {
    Kvdb_Digest result;
    CalcDigest(key, result);

    uint32_t hash_value = Hash(&result);

    return hash_value;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
leaq 0x2c(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x29ce0
movq 0x10(%rsp), %rsi
movq 0x40(%rsp), %rdi
callq 0x29e70
jmp 0x2a059
leaq 0x2c(%rsp), %rdi
callq 0x2a0b0
movl %eax, 0xc(%rsp)
jmp 0x2a069
movl 0xc(%rsp), %eax
movl %eax, 0x18(%rsp)
movl 0x18(%rsp), %eax
movl %eax, 0x8(%rsp)
leaq 0x2c(%rsp), %rdi
callq 0x29d50
movl 0x8(%rsp), %eax
addq $0x48, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x2c(%rsp), %rdi
callq 0x29d50
movq 0x20(%rsp), %rdi
callq 0x8820
nop