LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: xx01cyx[P]LSM-Tree/kvstore.cc
// Function: KVStore::del(unsigned long)
bool KVStore::del(uint64_t key)
{
    LsmValue value = get(key);
    bool find = (value.length() != 0) && (value != DELETE_SIGN);
    memTable->put(key, DELETE_SIGN);
    return find;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x78(%rbp)
movq -0x10(%rbp), %rdx
movq (%rsi), %rax
leaq -0x30(%rbp), %rdi
callq *0x8(%rax)
leaq -0x30(%rbp), %rdi
callq 0x4480
movq %rax, %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x6a(%rbp)
je 0x1124d
leaq 0x12063(%rip), %rsi     # 0x2329a
leaq -0x30(%rbp), %rdi
callq 0x15e80
movb %al, -0x79(%rbp)
jmp 0x11245
movb -0x79(%rbp), %al
movb %al, -0x6a(%rbp)
jmp 0x1124d
movq -0x78(%rbp), %rdi
movb -0x6a(%rbp), %al
andb $0x1, %al
movb %al, -0x31(%rbp)
addq $0x8, %rdi
callq 0x15e60
movq %rax, -0x98(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x69(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x4570
movq -0x88(%rbp), %rdx
leaq 0x12008(%rip), %rsi     # 0x2329a
leaq -0x68(%rbp), %rdi
callq 0x4b40
jmp 0x1129d
movq -0x90(%rbp), %rsi
movq -0x98(%rbp), %rdi
leaq -0x68(%rbp), %rdx
callq 0xbf00
jmp 0x112b6
leaq -0x68(%rbp), %rdi
callq 0x4608
leaq -0x69(%rbp), %rdi
callq 0x4320
movb -0x31(%rbp), %al
movb %al, -0x99(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4608
movb -0x99(%rbp), %al
andb $0x1, %al
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x11325
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x1131c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x4608
leaq -0x69(%rbp), %rdi
callq 0x4320
leaq -0x30(%rbp), %rdi
callq 0x4608
movq -0x40(%rbp), %rdi
callq 0x4560
nopw (%rax,%rax)
// File: xx01cyx[P]LSM-Tree/kvstore.cc
// Function: KVStore::reset()
void KVStore::reset()
{
    clearDisk();
    memTable->reset();
    memTableSize = HEADER_SIZE + BLOOM_FILTER_SIZE;
    ssTables.clear();
    ssTables[0] = make_shared<vector<SSTPtr>>();
    timeStamp = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x113f0
movq -0x48(%rbp), %rdi
addq $0x8, %rdi
callq 0x15e60
movq %rax, %rdi
callq 0xbdf0
movq -0x48(%rbp), %rdi
movl $0x2820, 0x18(%rdi)     # imm = 0x2820
addq $0x20, %rdi
movq %rdi, -0x40(%rbp)
callq 0x15eb0
leaq -0x18(%rbp), %rdi
callq 0x15d70
movq -0x40(%rbp), %rdi
movq $0x0, -0x20(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x15de0
movq %rax, -0x38(%rbp)
jmp 0x113aa
movq -0x38(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x15e10
leaq -0x18(%rbp), %rdi
callq 0x15e40
movq -0x48(%rbp), %rax
movq $0x1, 0x58(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x15e40
movq -0x28(%rbp), %rdi
callq 0x4560
// File: xx01cyx[P]LSM-Tree/kvstore.cc
// Function: KVStore::clearDisk()
void KVStore::clearDisk() {
    size_t levelNumber = ssTables.size();
    for (size_t level = 0; level < levelNumber; ++level) {
        vector<SSTPtr> levelSSTs = *ssTables[level];
        for (const auto& sst : levelSSTs)
            utils::rmfile(sst->getFilename().c_str());
        string dir = "./data/level-" + to_string(level);
        utils::rmdir(dir.c_str());
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
addq $0x20, %rdi
callq 0x16520
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x115b3
movq -0xc8(%rbp), %rdi
addq $0x20, %rdi
leaq -0x18(%rbp), %rsi
callq 0x16370
movq %rax, %rdi
callq 0x16540
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
callq 0x16570
leaq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x162a0
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x162d0
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x16660
testb $0x1, %al
jne 0x1148a
jmp 0x11500
leaq -0x40(%rbp), %rdi
callq 0x166a0
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0xd330
movq %rax, %rsi
leaq -0x70(%rbp), %rdi
callq 0x9070
jmp 0x114ae
leaq -0x70(%rbp), %rdi
callq 0x4100
movq %rax, %rdi
callq 0x11a70
jmp 0x114c1
leaq -0x70(%rbp), %rdi
callq 0x4608
leaq -0x40(%rbp), %rdi
callq 0x166c0
jmp 0x11477
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x115a8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x4608
jmp 0x115a8
movq -0x18(%rbp), %rsi
leaq -0xc0(%rbp), %rdi
callq 0x9ed0
jmp 0x11512
leaq 0x11c95(%rip), %rsi     # 0x231ae
leaq -0xa0(%rbp), %rdi
leaq -0xc0(%rbp), %rdx
callq 0x9e80
jmp 0x1152e
leaq -0xc0(%rbp), %rdi
callq 0x4608
leaq -0xa0(%rbp), %rdi
callq 0x4100
movq %rax, %rdi
callq 0x11a90
jmp 0x11550
leaq -0xa0(%rbp), %rdi
callq 0x4608
leaq -0x30(%rbp), %rdi
callq 0x163c0
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x1141f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x4608
jmp 0x115a8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x4608
leaq -0x30(%rbp), %rdi
callq 0x163c0
jmp 0x115bc
addq $0xd0, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x4560
nopw %cs:(%rax,%rax)
// File: xx01cyx[P]LSM-Tree/./utils.h
// Function: utils::scanDir(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
static inline int scanDir(std::string path, std::vector<std::string> &ret){
        DIR *dir;
        struct dirent *rent;
        dir = opendir(path.c_str());
        char s[100];
        while((rent = readdir(dir))){
            strcpy(s,rent->d_name);
            if (s[0] != '.'){
                ret.push_back(s);
            }   
        }
        closedir(dir);
        return ret.size();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x4100
movq %rax, %rdi
callq 0x4490
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x44a0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x116dd
leaq -0x90(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x13, %rsi
callq 0x4290
movsbl -0x90(%rbp), %eax
cmpl $0x2e, %eax
je 0x116d8
movq -0x10(%rbp), %rax
movq %rax, -0xd8(%rbp)
leaq -0xb1(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x4570
movq -0xd0(%rbp), %rdx
leaq -0xb0(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x4b40
jmp 0x11669
movq -0xd8(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x17cc0
jmp 0x1167e
leaq -0xb0(%rbp), %rdi
callq 0x4608
leaq -0xb1(%rbp), %rdi
callq 0x4320
jmp 0x116d8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
jmp 0x116ca
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x4608
leaq -0xb1(%rbp), %rdi
callq 0x4320
jmp 0x116f8
jmp 0x115f4
movq -0x18(%rbp), %rdi
callq 0x44e0
movq -0x10(%rbp), %rdi
callq 0x17cf0
addq $0xe0, %rsp
popq %rbp
retq
movq -0xc0(%rbp), %rdi
callq 0x4560
nopw %cs:(%rax,%rax)
// File: xx01cyx[P]LSM-Tree/kvstore.cc
// Function: KVStore::getMaxTimeStamp(std::vector<std::shared_ptr<SSTable>, std::allocator<std::shared_ptr<SSTable>>> const&)
TimeStamp KVStore::getMaxTimeStamp(const vector<SSTPtr> &SSTs) {
    TimeStamp maxTimeStamp = 0;
    for (const auto& SST : SSTs) {
        TimeStamp currentTimeStamp = SST->getTimeStamp();
        if (currentTimeStamp > maxTimeStamp)
            maxTimeStamp = currentTimeStamp;
    }
    return maxTimeStamp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x169d0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x16a00
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x16a30
testb $0x1, %al
jne 0x11a19
jmp 0x11a5a
leaq -0x20(%rbp), %rdi
callq 0x16a70
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0xd330
movq %rax, %rdi
callq 0x98c0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x10(%rbp), %rax
jbe 0x11a4d
movq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x11a4f
leaq -0x20(%rbp), %rdi
callq 0x16ba0
jmp 0x11a06
movq -0x10(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: xx01cyx[P]LSM-Tree/kvstore.cc
// Function: KVStore::levelOverflow(unsigned long)
uint32_t KVStore::levelOverflow(size_t level) {
    int currentNumber = ssTables[level]->size();
    int maxNumber = (uint32_t)pow(2, level + 1);
    int overflowNumber = currentNumber - maxNumber;
    return overflowNumber > 0 ? overflowNumber : 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
leaq -0x10(%rbp), %rsi
callq 0x16370
movq %rax, %rdi
callq 0x166e0
movq %rax, %rdi
callq 0x16120
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rsi
incq %rsi
movl $0x2, %edi
callq 0x16740
cvttsd2si %xmm0, %rax
movl %eax, -0x18(%rbp)
movl -0x14(%rbp), %eax
subl -0x18(%rbp), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jle 0x11b14
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
jmp 0x11b1b
xorl %eax, %eax
movl %eax, -0x20(%rbp)
jmp 0x11b1b
movl -0x20(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: xx01cyx[P]LSM-Tree/kvstore.cc
// Function: KVStore::compact(unsigned long, unsigned int)
void KVStore::compact(size_t upperLevel, uint32_t overflowNumber) {

    // New the lower level if it does not exist.
    size_t lowerLevel = upperLevel + 1;
    if (!ssTables.count(lowerLevel)) {
        ssTables[lowerLevel] = make_shared<vector<SSTPtr>>();
    }

    // Find the SSTs possessing the smallest time stamps or minimum keys.
    vector<SSTPtr> compactSSTs = getCompactSSTs(upperLevel, overflowNumber);

    // Compact the SSTs one by one.
    for (const auto& compactSST : compactSSTs)
        compactOneSST(compactSST, lowerLevel);

    // Reconstruct the upper level.
    reconstructUpperLevel(upperLevel, compactSSTs);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x80(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
addq $0x20, %rdi
leaq -0x20(%rbp), %rsi
callq 0x16790
cmpq $0x0, %rax
jne 0x11f25
leaq -0x30(%rbp), %rdi
callq 0x15d70
movq -0x80(%rbp), %rdi
addq $0x20, %rdi
leaq -0x20(%rbp), %rsi
callq 0x16370
movq %rax, -0x88(%rbp)
jmp 0x11ef0
movq -0x88(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x15e10
leaq -0x30(%rbp), %rdi
callq 0x15e40
jmp 0x11f25
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x15e40
jmp 0x11fd7
movq -0x80(%rbp), %rsi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
leaq -0x58(%rbp), %rdi
callq 0x13250
leaq -0x58(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
callq 0x162a0
movq %rax, -0x68(%rbp)
movq -0x60(%rbp), %rdi
callq 0x162d0
movq %rax, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x16660
testb $0x1, %al
jne 0x11f6e
jmp 0x11fb2
leaq -0x68(%rbp), %rdi
callq 0x166a0
movq -0x80(%rbp), %rdi
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x13380
jmp 0x11f8e
jmp 0x11f90
leaq -0x68(%rbp), %rdi
callq 0x166c0
jmp 0x11f5b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x163c0
jmp 0x11fd7
movq -0x80(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x58(%rbp), %rdx
callq 0x13620
jmp 0x11fc5
leaq -0x58(%rbp), %rdi
callq 0x163c0
addq $0x90, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x4560
// File: xx01cyx[P]LSM-Tree/kvstore.cc
// Function: KVStore::sstBinarySearch(std::vector<std::shared_ptr<SSTable>, std::allocator<std::shared_ptr<SSTable>>> const&, unsigned long, unsigned int, unsigned int)
uint32_t KVStore::sstBinarySearch(const vector<SSTPtr> &SSTs, LsmKey key,
                                  uint32_t left, uint32_t right) {
    if (left >= right) {
        if (right && SSTs[right]->getMinKey() > key)
            right--;
        return right;
    }

    uint32_t mid = left + (right - left) / 2;
    LsmKey midMinKey = SSTs[mid]->getMinKey();

    if (key < midMinKey)
        return sstBinarySearch(SSTs, key, left, mid ? mid - 1 : mid);
    if (key > midMinKey)
        return sstBinarySearch(SSTs, key, mid + 1, right);
    return mid;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl %ecx, -0x20(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jb 0x1210c
cmpl $0x0, -0x20(%rbp)
je 0x12101
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %eax
movl %eax, %esi
callq 0x16fc0
movq %rax, %rdi
callq 0xd330
movq %rax, %rdi
callq 0x98e0
cmpq -0x18(%rbp), %rax
jbe 0x12101
movl -0x20(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x121b8
movl -0x1c(%rbp), %eax
movl -0x20(%rbp), %ecx
subl -0x1c(%rbp), %ecx
shrl %ecx
addl %ecx, %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x16fc0
movq %rax, %rdi
callq 0xd330
movq %rax, %rdi
callq 0x98e0
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x1218d
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x1216f
movl -0x24(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x12175
movl -0x24(%rbp), %eax
movl %eax, -0x4c(%rbp)
movl -0x34(%rbp), %edx
movq -0x40(%rbp), %rsi
movq -0x48(%rbp), %rdi
movl -0x4c(%rbp), %ecx
callq 0x120b0
movl %eax, -0x4(%rbp)
jmp 0x121b8
movq -0x18(%rbp), %rax
cmpq -0x30(%rbp), %rax
jbe 0x121b2
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x24(%rbp), %edx
addl $0x1, %edx
movl -0x20(%rbp), %ecx
callq 0x120b0
movl %eax, -0x4(%rbp)
jmp 0x121b8
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: xx01cyx[P]LSM-Tree/kvstore.cc
// Function: KVStore::getCompact0Range(unsigned long&, unsigned long&)
void KVStore::getCompact0Range(LsmKey& minKey, LsmKey& maxKey) {
    vector<SSTPtr> L0SSTs = *ssTables[0];
    minKey = min(min(L0SSTs[0]->getMinKey(), L0SSTs[1]->getMinKey()),
                 L0SSTs[2]->getMinKey());
    maxKey = max(max(L0SSTs[0]->getMaxKey(), L0SSTs[1]->getMaxKey()),
                 L0SSTs[2]->getMaxKey());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
movq $0x0, -0x38(%rbp)
leaq -0x38(%rbp), %rsi
callq 0x15de0
movq %rax, %rdi
callq 0x16540
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x16570
movq -0x88(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x16170
movq %rax, %rdi
callq 0xd330
movq %rax, %rdi
callq 0x98e0
movq %rax, -0x80(%rbp)
jmp 0x12241
movq -0x80(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x30(%rbp), %rdi
movl $0x1, %esi
callq 0x16170
movq %rax, %rdi
callq 0xd330
movq %rax, %rdi
callq 0x98e0
movq %rax, -0x90(%rbp)
jmp 0x12270
movq -0x90(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x70d0
movq %rax, -0x98(%rbp)
jmp 0x12291
leaq -0x30(%rbp), %rdi
movl $0x2, %esi
callq 0x16170
movq %rax, %rdi
callq 0xd330
movq %rax, %rdi
callq 0x98e0
movq %rax, -0xa0(%rbp)
jmp 0x122b8
movq -0x98(%rbp), %rdi
movq -0xa0(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x60(%rbp), %rsi
callq 0x70d0
movq %rax, -0xa8(%rbp)
jmp 0x122dc
movq -0xa8(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
xorl %eax, %eax
movl %eax, %esi
leaq -0x30(%rbp), %rdi
callq 0x16170
movq %rax, %rdi
callq 0xd330
movq %rax, %rdi
callq 0x9900
movq %rax, -0xb0(%rbp)
jmp 0x12313
movq -0xb0(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x30(%rbp), %rdi
movl $0x1, %esi
callq 0x16170
movq %rax, %rdi
callq 0xd330
movq %rax, %rdi
callq 0x9900
movq %rax, -0xb8(%rbp)
jmp 0x12345
movq -0xb8(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x7010
movq %rax, -0xc0(%rbp)
jmp 0x12366
leaq -0x30(%rbp), %rdi
movl $0x2, %esi
callq 0x16170
movq %rax, %rdi
callq 0xd330
movq %rax, %rdi
callq 0x9900
movq %rax, -0xc8(%rbp)
jmp 0x1238d
movq -0xc0(%rbp), %rdi
movq -0xc8(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x78(%rbp), %rsi
callq 0x7010
movq %rax, -0xd0(%rbp)
jmp 0x123b1
movq -0xd0(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
leaq -0x30(%rbp), %rdi
callq 0x163c0
addq $0xd0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x163c0
movq -0x48(%rbp), %rdi
callq 0x4560
nopw %cs:(%rax,%rax)
// File: xx01cyx[P]LSM-Tree/kvstore.cc
// Function: KVStore::getCompactionData[abi:cxx11](std::vector<std::shared_ptr<SSTable>, std::allocator<std::shared_ptr<SSTable>>> const&)
KVPair KVStore::getCompactionData(const vector<SSTPtr>& SSTs) {

    // Sort the SSTs according to their time tokens so that the value of the same key
    // in a newer SST will always overwrite the previous one.

    auto sortByTimeStamp = [](const SSTPtr& sstA, const SSTPtr& sstB) {
        return sstA->getTimeStamp() < sstB->getTimeStamp();
    };

    vector<SSTPtr> tempSSTs(SSTs);
    sort(tempSSTs.begin(), tempSSTs.end(), sortByTimeStamp);

    KVPair sstData;
    for (const auto& sst : tempSSTs)
        sst->getValuesFromDisk(sstData);

    return sstData;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x30(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x16570
movq -0x80(%rbp), %rdi
callq 0x162a0
movq -0x80(%rbp), %rdi
movq %rax, -0x38(%rbp)
callq 0x162d0
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x14a30
jmp 0x126de
movq -0x90(%rbp), %rdi
movb $0x0, -0x55(%rbp)
callq 0x16fe0
leaq -0x30(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
callq 0x162a0
movq %rax, -0x68(%rbp)
movq -0x60(%rbp), %rdi
callq 0x162d0
movq %rax, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x16660
testb $0x1, %al
jne 0x12723
jmp 0x1277f
leaq -0x68(%rbp), %rdi
callq 0x166a0
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rdi
callq 0xd330
movq -0x90(%rbp), %rsi
movq %rax, %rdi
callq 0x94b0
jmp 0x1274a
jmp 0x1274c
leaq -0x68(%rbp), %rdi
callq 0x166c0
jmp 0x12710
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x127ae
movq -0x90(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
callq 0x168b0
jmp 0x127ae
movb $0x1, -0x55(%rbp)
testb $0x1, -0x55(%rbp)
jne 0x12795
movq -0x90(%rbp), %rdi
callq 0x168b0
leaq -0x30(%rbp), %rdi
callq 0x163c0
movq -0x88(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x163c0
movq -0x50(%rbp), %rdi
callq 0x4560
// File: xx01cyx[P]LSM-Tree/kvstore.cc
// Function: KVStore::reconstructLowerLevelDisk(long, long, unsigned long)
void KVStore::reconstructLowerLevelDisk(int64_t minOverlapIndex, int64_t maxOverlapIndex, size_t lowerLevel) {

    if (minOverlapIndex == -1 && maxOverlapIndex == -1)
        return;

    vector<SSTPtr> previousSSTs = *ssTables[lowerLevel];
    for (uint32_t i = minOverlapIndex; i < maxOverlapIndex; ++i)
        removeSSTFromDisk(previousSSTs[i]);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpq $-0x1, -0x10(%rbp)
jne 0x127f0
cmpq $-0x1, -0x18(%rbp)
jne 0x127f0
jmp 0x1286a
movq -0x58(%rbp), %rdi
addq $0x20, %rdi
leaq -0x20(%rbp), %rsi
callq 0x16370
movq %rax, %rdi
callq 0x16540
movq %rax, %rsi
leaq -0x38(%rbp), %rdi
callq 0x16570
movq -0x10(%rbp), %rax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpq -0x18(%rbp), %rax
jge 0x12861
movl -0x3c(%rbp), %eax
movl %eax, %esi
leaq -0x38(%rbp), %rdi
callq 0x16170
movq %rax, %rdi
callq 0x14960
jmp 0x1283d
jmp 0x1283f
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x1281c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x163c0
jmp 0x12870
leaq -0x38(%rbp), %rdi
callq 0x163c0
addq $0x60, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x4560
nopl (%rax)
// File: xx01cyx[P]LSM-Tree/kvstore.cc
// Function: KVStore::reconstructL0()
void KVStore::reconstructL0() {
    vector<SSTPtr> L0SST = *ssTables[0];
    for (const auto& sst : L0SST)
        removeSSTFromDisk(sst);
    ssTables[0]->clear();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
addq $0x20, %rdi
movq $0x0, -0x28(%rbp)
leaq -0x28(%rbp), %rsi
callq 0x15de0
movq %rax, %rdi
callq 0x16540
movq %rax, %rsi
leaq -0x20(%rbp), %rdi
callq 0x16570
leaq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x162a0
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x162d0
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x16660
testb $0x1, %al
jne 0x131c2
jmp 0x131fe
leaq -0x38(%rbp), %rdi
callq 0x166a0
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x14960
jmp 0x131da
jmp 0x131dc
leaq -0x38(%rbp), %rdi
callq 0x166c0
jmp 0x131af
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x163c0
jmp 0x1323d
movq -0x68(%rbp), %rdi
addq $0x20, %rdi
movq $0x0, -0x60(%rbp)
leaq -0x60(%rbp), %rsi
callq 0x15de0
movq %rax, -0x70(%rbp)
jmp 0x1321d
movq -0x70(%rbp), %rdi
callq 0x166e0
movq %rax, %rdi
callq 0x16eb0
leaq -0x20(%rbp), %rdi
callq 0x163c0
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x4560
nopw %cs:(%rax,%rax)
// File: xx01cyx[P]LSM-Tree/kvstore.cc
// Function: KVStore::getCompactSSTs(unsigned long, unsigned int)
vector<SSTPtr> KVStore::getCompactSSTs(size_t level, uint32_t overflowNumber) {

    vector<SSTPtr> levelSSTs = *ssTables[level];
    SSTTimeStampPriorComparator sstComparator;
    sort(levelSSTs.begin(), levelSSTs.end(), sstComparator);

    vector<SSTPtr> compactSSTs;
    for (uint32_t i = 0; i < overflowNumber; ++i)
        compactSSTs.push_back(levelSSTs[i]);

    return compactSSTs;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
leaq -0x18(%rbp), %rsi
callq 0x16370
movq %rax, %rdi
callq 0x16540
movq %rax, %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x16570
movq -0x78(%rbp), %rdi
callq 0x162a0
movq -0x78(%rbp), %rdi
movq %rax, -0x48(%rbp)
callq 0x162d0
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x16930
jmp 0x132ca
movq -0x88(%rbp), %rdi
movb $0x0, -0x65(%rbp)
callq 0x15ef0
movl $0x0, -0x6c(%rbp)
movl -0x6c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jae 0x1333d
movl -0x6c(%rbp), %eax
movl %eax, %esi
leaq -0x38(%rbp), %rdi
callq 0x16170
movq -0x88(%rbp), %rdi
movq %rax, %rsi
callq 0x16050
jmp 0x13308
jmp 0x1330a
movl -0x6c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x6c(%rbp)
jmp 0x132e1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x13369
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
callq 0x163c0
jmp 0x13369
movb $0x1, -0x65(%rbp)
testb $0x1, -0x65(%rbp)
jne 0x13353
movq -0x88(%rbp), %rdi
callq 0x163c0
leaq -0x38(%rbp), %rdi
callq 0x163c0
movq -0x80(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0x163c0
movq -0x60(%rbp), %rdi
callq 0x4560
nopl (%rax,%rax)
// File: xx01cyx[P]LSM-Tree/kvstore.cc
// Function: KVStore::reconstructUpperLevel(unsigned long, std::vector<std::shared_ptr<SSTable>, std::allocator<std::shared_ptr<SSTable>>> const&)
void KVStore::reconstructUpperLevel(size_t upperLevel, const vector<SSTPtr> &compactSSTs) {
    vector<SSTPtr> levelSSTs = *ssTables[upperLevel];
    for (const auto& compactSST : compactSSTs) {
        auto delIt = find(ssTables[upperLevel]->begin(), ssTables[upperLevel]->end(), compactSST);
        if (delIt != ssTables[upperLevel]->end()) {
            removeSSTFromDisk(*delIt);
            ssTables[upperLevel]->erase(delIt);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x98(%rbp)
addq $0x20, %rdi
leaq -0x10(%rbp), %rsi
callq 0x16370
movq %rax, %rdi
callq 0x16540
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
callq 0x16570
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x169d0
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x16a00
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x16a30
testb $0x1, %al
jne 0x1369b
jmp 0x13828
leaq -0x40(%rbp), %rdi
callq 0x16a70
movq -0x98(%rbp), %rdi
movq %rax, -0x50(%rbp)
addq $0x20, %rdi
leaq -0x10(%rbp), %rsi
callq 0x16370
movq %rax, -0xa0(%rbp)
jmp 0x136c5
movq -0xa0(%rbp), %rdi
callq 0x166e0
movq %rax, %rdi
callq 0x162a0
movq -0x98(%rbp), %rdi
movq %rax, -0x60(%rbp)
addq $0x20, %rdi
leaq -0x10(%rbp), %rsi
callq 0x16370
movq %rax, -0xa8(%rbp)
jmp 0x136fa
movq -0xa8(%rbp), %rdi
callq 0x166e0
movq %rax, %rdi
callq 0x162d0
movq %rax, -0x78(%rbp)
movq -0x50(%rbp), %rdx
movq -0x60(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0x16ed0
movq %rax, -0xb0(%rbp)
jmp 0x1372c
movq -0x98(%rbp), %rdi
movq -0xb0(%rbp), %rax
movq %rax, -0x58(%rbp)
addq $0x20, %rdi
leaq -0x10(%rbp), %rsi
callq 0x16370
movq %rax, -0xb8(%rbp)
jmp 0x13754
movq -0xb8(%rbp), %rdi
callq 0x166e0
movq %rax, %rdi
callq 0x162d0
movq %rax, -0x80(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x16660
testb $0x1, %al
jne 0x13782
jmp 0x13818
leaq -0x58(%rbp), %rdi
callq 0x166a0
movq %rax, %rdi
callq 0x14960
jmp 0x13795
movq -0x98(%rbp), %rdi
addq $0x20, %rdi
leaq -0x10(%rbp), %rsi
callq 0x16370
movq %rax, -0xc0(%rbp)
jmp 0x137b2
movq -0xc0(%rbp), %rdi
callq 0x166e0
movq %rax, -0xd0(%rbp)
leaq -0x88(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x16870
movq -0xd0(%rbp), %rdi
movq -0x88(%rbp), %rsi
callq 0x16f20
movq %rax, -0xc8(%rbp)
jmp 0x137f1
movq -0xc8(%rbp), %rax
movq %rax, -0x90(%rbp)
jmp 0x13818
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x163c0
jmp 0x1383a
jmp 0x1381a
leaq -0x40(%rbp), %rdi
callq 0x16ba0
jmp 0x13685
leaq -0x30(%rbp), %rdi
callq 0x163c0
addq $0xd0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x4560
nopw %cs:(%rax,%rax)
// File: xx01cyx[P]LSM-Tree/kvstore.cc
// Function: KVStore::getMaxTimeStamp(std::shared_ptr<SSTable> const&, std::vector<std::shared_ptr<SSTable>, std::allocator<std::shared_ptr<SSTable>>> const&)
TimeStamp KVStore::getMaxTimeStamp(const SSTPtr& oneSST, const vector<SSTPtr> &SSTs) {
    TimeStamp maxTimeStamp = oneSST->getTimeStamp();
    for (const auto& SST : SSTs) {
        TimeStamp currentTimeStamp = SST->getTimeStamp();
        if (currentTimeStamp > maxTimeStamp)
            maxTimeStamp = currentTimeStamp;
    }
    return maxTimeStamp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xd330
movq %rax, %rdi
callq 0x98c0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x169d0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x16a00
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x16a30
testb $0x1, %al
jne 0x1392a
jmp 0x1396b
leaq -0x28(%rbp), %rdi
callq 0x16a70
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0xd330
movq %rax, %rdi
callq 0x98c0
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq -0x18(%rbp), %rax
jbe 0x1395e
movq -0x40(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x13960
leaq -0x28(%rbp), %rdi
callq 0x16ba0
jmp 0x13917
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: xx01cyx[P]LSM-Tree/kvstore.cc
// Function: KVStore::removeSSTFromDisk(std::shared_ptr<SSTable> const&)
void KVStore::removeSSTFromDisk(const SSTPtr& delSST) {
    string filename = delSST->getFilename();
    if (utils::rmfile(filename.c_str()) < 0) {
        cerr << "Fail to remove file `" << filename << "`." << endl;
        exit(-1);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xd330
movq %rax, %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x9070
movq -0x40(%rbp), %rdi
callq 0x4100
movq %rax, %rdi
callq 0x11a70
movl %eax, -0x38(%rbp)
jmp 0x1499b
movl -0x38(%rbp), %eax
cmpl $0x0, %eax
jge 0x14a18
movq 0x1d646(%rip), %rdi     # 0x31ff0
leaq 0xea87(%rip), %rsi      # 0x23438
callq 0x42c0
movq %rax, -0x48(%rbp)
jmp 0x149bc
movq -0x48(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x4270
movq %rax, -0x50(%rbp)
jmp 0x149cf
movq -0x50(%rbp), %rdi
leaq 0xe7d1(%rip), %rsi      # 0x231ab
callq 0x42c0
movq %rax, -0x58(%rbp)
jmp 0x149e5
movq -0x58(%rbp), %rdi
movq 0x1d5c0(%rip), %rsi     # 0x31fb0
callq 0x4300
jmp 0x149f7
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x4360
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x4608
jmp 0x14a27
leaq -0x28(%rbp), %rdi
callq 0x4608
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x4560
// File: xx01cyx[P]LSM-Tree/./SSTable.h
// Function: SSTTimeStampPriorComparator::operator()(std::shared_ptr<SSTable> const&, std::shared_ptr<SSTable> const&)
bool operator() (const SSTPtr& sst1, const SSTPtr& sst2) {
        TimeStamp stamp1 = sst1->getTimeStamp();
        TimeStamp stamp2 = sst2->getTimeStamp();
        LsmKey minKey1 = sst1->getMinKey();
        LsmKey minKey2 = sst2->getMinKey();
        if (stamp1 != stamp2)
            return stamp1 < stamp2;
        return minKey1 < minKey2;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0xd330
movq %rax, %rdi
callq 0x98c0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0xd330
movq %rax, %rdi
callq 0x98c0
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0xd330
movq %rax, %rdi
callq 0x98e0
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
callq 0xd330
movq %rax, %rdi
callq 0x98e0
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
je 0x16244
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
setb %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x16254
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
setb %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nop
// File: Computer-Kids-Club[P]screenshare-pro-backend/base64.c
// Function: base64_encode_value(char)
char base64_encode_value(char value_in) {
    static const char *encoding = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
    if (value_in > 63)
        return '=';
    return encoding[(int)value_in];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x2(%rbp)
movsbl -0x2(%rbp), %eax
cmpl $0x3f, %eax
jle 0xeb39
movb $0x3d, -0x1(%rbp)
jmp 0xeb4d
movq 0xb7b0(%rip), %rax      # 0x1a2f0
movsbl -0x2(%rbp), %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Computer-Kids-Club[P]screenshare-pro-backend/base64.c
// Function: base64_encode_blockend(char*, base64_encodestate*)
int base64_encode_blockend(char *code_out, base64_encodestate *state_in) {
    char *codechar = code_out;

    switch (state_in->step) {
        case step_B:
            *codechar++ = base64_encode_value(state_in->result);
            *codechar++ = '=';
            *codechar++ = '=';
            break;
        case step_C:
            *codechar++ = base64_encode_value(state_in->result);
            *codechar++ = '=';
            break;
        case step_A:
            break;
    }
    *codechar++ = '\n';

    return codechar - code_out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
testl %eax, %eax
je 0xee89
jmp 0xedfb
movl -0x1c(%rbp), %eax
subl $0x1, %eax
je 0xee0f
jmp 0xee05
movl -0x1c(%rbp), %eax
subl $0x2, %eax
je 0xee55
jmp 0xee8b
movq -0x10(%rbp), %rax
movsbl 0x4(%rax), %edi
callq 0xeb20
movb %al, %cl
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movb %cl, (%rax)
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb $0x3d, (%rax)
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb $0x3d, (%rax)
jmp 0xee8b
movq -0x10(%rbp), %rax
movsbl 0x4(%rax), %edi
callq 0xeb20
movb %al, %cl
movq -0x18(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x18(%rbp)
movb %cl, (%rax)
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb $0x3d, (%rax)
jmp 0xee8b
jmp 0xee8b
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rbp)
movb $0xa, (%rax)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: Computer-Kids-Club[P]screenshare-pro-backend/sha1.c
// Function: SHA1Reset(SHA1Context*)
void SHA1Reset(SHA1Context *context)
{
    context->Length_Low             = 0;
    context->Length_High            = 0;
    context->Message_Block_Index    = 0;

    context->Message_Digest[0]      = 0x67452301;
    context->Message_Digest[1]      = 0xEFCDAB89;
    context->Message_Digest[2]      = 0x98BADCFE;
    context->Message_Digest[3]      = 0x10325476;
    context->Message_Digest[4]      = 0xC3D2E1F0;

    context->Computed   = 0;
    context->Corrupted  = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x14(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x5c(%rax)
movq -0x8(%rbp), %rax
movl $0x67452301, (%rax)     # imm = 0x67452301
movq -0x8(%rbp), %rax
movl $0xefcdab89, 0x4(%rax)  # imm = 0xEFCDAB89
movq -0x8(%rbp), %rax
movl $0x98badcfe, 0x8(%rax)  # imm = 0x98BADCFE
movq -0x8(%rbp), %rax
movl $0x10325476, 0xc(%rax)  # imm = 0x10325476
movq -0x8(%rbp), %rax
movl $0xc3d2e1f0, 0x10(%rax) # imm = 0xC3D2E1F0
movq -0x8(%rbp), %rax
movl $0x0, 0x60(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x64(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: Computer-Kids-Club[P]screenshare-pro-backend/sha1.c
// Function: SHA1Result(SHA1Context*)
int SHA1Result(SHA1Context *context)
{

    if (context->Corrupted)
    {
        return 0;
    }

    if (!context->Computed)
    {
        SHA1PadMessage(context);
        context->Computed = 1;
    }

    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x64(%rax)
je 0xf9ff
movl $0x0, -0x4(%rbp)
jmp 0xfa24
movq -0x10(%rbp), %rax
cmpl $0x0, 0x60(%rax)
jne 0xfa1d
movq -0x10(%rbp), %rdi
callq 0xfa30
movq -0x10(%rbp), %rax
movl $0x1, 0x60(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: Computer-Kids-Club[P]screenshare-pro-backend/sha1.c
// Function: SHA1Input(SHA1Context*, unsigned char const*, unsigned int)
void SHA1Input(     SHA1Context         *context,
                    const unsigned char *message_array,
                    unsigned            length)
{
    if (!length)
    {
        return;
    }

    if (context->Computed || context->Corrupted)
    {
        context->Corrupted = 1;
        return;
    }

    while(length-- && !context->Corrupted)
    {
        context->Message_Block[context->Message_Block_Index++] =
                                                (*message_array & 0xFF);

        context->Length_Low += 8;
        /* Force it to 32 bits */
        context->Length_Low &= 0xFFFFFFFF;
        if (context->Length_Low == 0)
        {
            context->Length_High++;
            /* Force it to 32 bits */
            context->Length_High &= 0xFFFFFFFF;
            if (context->Length_High == 0)
            {
                /* Message is too long */
                context->Corrupted = 1;
            }
        }

        if (context->Message_Block_Index == 64)
        {
            SHA1ProcessMessageBlock(context);
        }

        message_array++;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0xfbee
jmp 0xfce6
movq -0x8(%rbp), %rax
cmpl $0x0, 0x60(%rax)
jne 0xfc02
movq -0x8(%rbp), %rax
cmpl $0x0, 0x64(%rax)
je 0xfc12
movq -0x8(%rbp), %rax
movl $0x1, 0x64(%rax)
jmp 0xfce6
jmp 0xfc14
movl -0x14(%rbp), %ecx
movl %ecx, %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x15(%rbp)
je 0xfc39
movq -0x8(%rbp), %rax
cmpl $0x0, 0x64(%rax)
setne %al
xorb $-0x1, %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0xfc45
jmp 0xfce6
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
andl $0xff, %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movq -0x8(%rbp), %rsi
movl 0x5c(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x5c(%rsi)
movslq %ecx, %rcx
movb %dl, 0x1c(%rax,%rcx)
movq -0x8(%rbp), %rax
movl 0x14(%rax), %ecx
addl $0x8, %ecx
movl %ecx, 0x14(%rax)
movq -0x8(%rbp), %rax
movl 0x14(%rax), %ecx
andl $-0x1, %ecx
movl %ecx, 0x14(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x14(%rax)
jne 0xfcc2
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
movq -0x8(%rbp), %rax
movl 0x18(%rax), %ecx
andl $-0x1, %ecx
movl %ecx, 0x18(%rax)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x18(%rax)
jne 0xfcc0
movq -0x8(%rbp), %rax
movl $0x1, 0x64(%rax)
jmp 0xfcc2
movq -0x8(%rbp), %rax
cmpl $0x40, 0x5c(%rax)
jne 0xfcd5
movq -0x8(%rbp), %rdi
callq 0xfcf0
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xfc14
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Computer-Kids-Club[P]screenshare-pro-backend/utils.cpp
// Function: get_file_contents[abi:cxx11](char const*)
std::string get_file_contents(const char *filename) {
    std::ifstream in(filename, std::ios::in | std::ios::binary);
    if (in) {
        return (std::string((std::istreambuf_iterator<char>(in)), std::istreambuf_iterator<char>()));
    }
    throw(errno);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x280, %rsp            # imm = 0x280
movq %rdi, -0x268(%rbp)
movq %rdi, %rax
movq %rax, -0x260(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x258(%rbp)
movl $0x8, %edi
movl $0x4, %esi
callq 0x103d0
movq -0x258(%rbp), %rsi
movl %eax, %edx
leaq -0x218(%rbp), %rdi
callq 0x3550
movq -0x218(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x218(%rbp,%rax), %rdi
callq 0x33e0
movb %al, -0x24a(%rbp)
jmp 0x102b3
movb -0x24a(%rbp), %al
testb $0x1, %al
jne 0x102c2
jmp 0x10380
leaq -0x238(%rbp), %rdi
leaq -0x218(%rbp), %rsi
callq 0x103f0
leaq -0x248(%rbp), %rdi
callq 0x10450
leaq -0x249(%rbp), %rdi
movq %rdi, -0x270(%rbp)
callq 0x3510
movq -0x268(%rbp), %rdi
movq -0x270(%rbp), %r9
movq -0x238(%rbp), %rsi
movl -0x230(%rbp), %edx
movq -0x248(%rbp), %rcx
movl -0x240(%rbp), %r8d
callq 0x10480
jmp 0x10324
leaq -0x249(%rbp), %rdi
callq 0x3340
leaq -0x218(%rbp), %rdi
callq 0x30e0
movq -0x260(%rbp), %rax
addq $0x280, %rsp            # imm = 0x280
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
jmp 0x103b3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
leaq -0x249(%rbp), %rdi
callq 0x3340
jmp 0x103b3
movl $0x4, %edi
callq 0x31c0
movq %rax, -0x278(%rbp)
callq 0x3050
movq -0x278(%rbp), %rdi
movl (%rax), %eax
movl %eax, (%rdi)
movq 0x9c20(%rip), %rsi      # 0x19fc8
xorl %eax, %eax
movl %eax, %edx
callq 0x34d0
jmp 0x103cb
leaq -0x218(%rbp), %rdi
callq 0x30e0
movq -0x220(%rbp), %rdi
callq 0x3500
nopl (%rax,%rax)
// File: Computer-Kids-Club[P]screenshare-pro-backend/websocket.c
// Function: generate_ws_frame(char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int generate_ws_frame(char *buf, std::string msg) {
    const char *cmsg = msg.c_str();
    int cmsg_len = msg.length();

    int payload_offset = 2;

    buf[0] = 0b10000001;
    if (cmsg_len > 125) {
        payload_offset += 2;
        buf[1] = (char)(126 & 0b01111111);
        buf[3] = (char)(cmsg_len >> 8);
        buf[4] = (char)(cmsg_len);
    } else {
        buf[1] = (char)(cmsg_len & 0b01111111);
    }

    for (int cmsg_i = 0; cmsg_i < cmsg_len; cmsg_i++) {
        buf[payload_offset + cmsg_i] = cmsg[cmsg_i];
    }

    buf[payload_offset + cmsg_len] = '\0';

    return payload_offset + cmsg_len;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, %rax
movq -0x38(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
callq 0x3160
movq -0x30(%rbp), %rdi
movq %rax, -0x18(%rbp)
callq 0x3470
movl %eax, -0x1c(%rbp)
movl $0x2, -0x20(%rbp)
movq -0x8(%rbp), %rax
movb $-0x7f, (%rax)
cmpl $0x7d, -0x1c(%rbp)
jle 0x10c16
movl -0x20(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movb $0x7e, 0x1(%rax)
movl -0x1c(%rbp), %eax
sarl $0x8, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x3(%rax)
movl -0x1c(%rbp), %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x4(%rax)
jmp 0x10c25
movl -0x1c(%rbp), %eax
andl $0x7f, %eax
movb %al, %cl
movq -0x8(%rbp), %rax
movb %cl, 0x1(%rax)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x10c5a
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movl -0x20(%rbp), %ecx
addl -0x24(%rbp), %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x10c2c
movq -0x8(%rbp), %rax
movl -0x20(%rbp), %ecx
addl -0x1c(%rbp), %ecx
movslq %ecx, %rcx
movb $0x0, (%rax,%rcx)
movl -0x20(%rbp), %eax
addl -0x1c(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
// File: realuptime[P]PolyDetector/PolyDetector.cpp
// Function: RmLinesTypeStr(RmLinesType)
const char *RmLinesTypeStr(RmLinesType type)
{
    switch (type)
    {
        case RmLinesType::TakenTwice: return "TakenTwice";
        case RmLinesType::Collinear: return "Collinear";
        case RmLinesType::NoPointNeigh: return "NoPointNeigh";
        case RmLinesType::PointConsumed: return "PointConsumed";
    }
    return "UNKN";
}

// Assembly:
movl %edi, -0xc(%rsp)
movl -0xc(%rsp), %eax
movq %rax, -0x18(%rsp)
subq $0x3, %rax
ja 0x2440
movq -0x18(%rsp), %rax
leaq 0x23c05(%rip), %rcx     # 0x26004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x23c49(%rip), %rax     # 0x26058
movq %rax, -0x8(%rsp)
jmp 0x244c
leaq 0x23c46(%rip), %rax     # 0x26063
movq %rax, -0x8(%rsp)
jmp 0x244c
leaq 0x23c42(%rip), %rax     # 0x2606d
movq %rax, -0x8(%rsp)
jmp 0x244c
leaq 0x23c41(%rip), %rax     # 0x2607a
movq %rax, -0x8(%rsp)
jmp 0x244c
leaq 0x23c41(%rip), %rax     # 0x26088
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: realuptime[P]PolyDetector/PolyDetector.cpp
// Function: between(vec const&, vec const&, vec const&)
static bool between(const PointType &p, const PointType &a, const PointType &b)
{
    // if this point is not collinear with a and b
    // then it cannot be between this two points
    if (!collinearVecs(p, a, b))
        return false;
    
    auto &_x = p.x;
    auto &_y = p.y;
    
    return
        ((a.x <= _x && _x <= b.x) && (a.y <= _y && _y <= b.y)) ||
        ((b.x <= _x && _x <= a.x) && (b.y <= _y && _y <= a.y));
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0xd670
testb $0x1, %al
jne 0x2525
movb $0x0, 0x37(%rsp)
jmp 0x2634
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movss (%rax), %xmm1
movq 0x10(%rsp), %rax
movss (%rax), %xmm0
ucomiss %xmm1, %xmm0
jb 0x25a5
movq 0x10(%rsp), %rax
movss (%rax), %xmm1
movq 0x18(%rsp), %rax
movss (%rax), %xmm0
ucomiss %xmm1, %xmm0
jb 0x25a5
movq 0x20(%rsp), %rax
movss 0x4(%rax), %xmm1
movq 0x8(%rsp), %rax
movss (%rax), %xmm0
ucomiss %xmm1, %xmm0
jb 0x25a5
movq 0x8(%rsp), %rax
movss (%rax), %xmm1
movq 0x18(%rsp), %rax
movss 0x4(%rax), %xmm0
movb $0x1, %al
ucomiss %xmm1, %xmm0
movb %al, 0x7(%rsp)
jae 0x262a
movq 0x18(%rsp), %rax
movss (%rax), %xmm1
movq 0x10(%rsp), %rax
movss (%rax), %xmm0
xorl %eax, %eax
ucomiss %xmm1, %xmm0
movb %al, 0x6(%rsp)
jb 0x2622
movq 0x10(%rsp), %rax
movss (%rax), %xmm1
movq 0x20(%rsp), %rax
movss (%rax), %xmm0
xorl %eax, %eax
ucomiss %xmm1, %xmm0
movb %al, 0x6(%rsp)
jb 0x2622
movq 0x18(%rsp), %rax
movss 0x4(%rax), %xmm1
movq 0x8(%rsp), %rax
movss (%rax), %xmm0
xorl %eax, %eax
ucomiss %xmm1, %xmm0
movb %al, 0x5(%rsp)
jb 0x261a
movq 0x8(%rsp), %rax
movss (%rax), %xmm1
movq 0x20(%rsp), %rax
movss 0x4(%rax), %xmm0
ucomiss %xmm1, %xmm0
setae %al
movb %al, 0x5(%rsp)
movb 0x5(%rsp), %al
movb %al, 0x6(%rsp)
movb 0x6(%rsp), %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
andb $0x1, %al
movb %al, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nop
// File: realuptime[P]PolyDetector/PolyDetector.cpp
// Function: doIntersect(vec const&, vec const&, vec const&, vec const&)
static bool doIntersect(const PointType &p1, const PointType &q1, const PointType &p2, const PointType &q2)
{
    // Find the four orientations needed for general and
    // special cases
    int o1 = orientation(p1, q1, p2);
    int o2 = orientation(p1, q1, q2);
    int o3 = orientation(p2, q2, p1);
    int o4 = orientation(p2, q2, q1);
  
    // General case
    if (o1 != o2 && o3 != o4)
        return true;
  
    // Special Cases
    // p1, q1 and p2 are colinear and p2 lies on segment p1q1
    if (o1 == 0 && onSegment(p1, p2, q1)) return true;
  
    // p1, q1 and q2 are colinear and q2 lies on segment p1q1
    if (o2 == 0 && onSegment(p1, q2, q1)) return true;
  
    // p2, q2 and p1 are colinear and p1 lies on segment p2q2
    if (o3 == 0 && onSegment(p2, p1, q2)) return true;
  
     // p2, q2 and q1 are colinear and q1 lies on segment p2q2
    if (o4 == 0 && onSegment(p2, q1, q2)) return true;
  
    return false; // Doesn't fall in any of the above cases
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0xd6b0
movl %eax, 0xc(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0xd6b0
movl %eax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0xd6b0
movl %eax, 0x4(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0xd6b0
movl %eax, (%rsp)
movl 0xc(%rsp), %eax
cmpl 0x8(%rsp), %eax
je 0x2714
movl 0x4(%rsp), %eax
cmpl (%rsp), %eax
je 0x2714
movb $0x1, 0x37(%rsp)
jmp 0x27b8
cmpl $0x0, 0xc(%rsp)
jne 0x273c
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0xd770
testb $0x1, %al
jne 0x2735
jmp 0x273c
movb $0x1, 0x37(%rsp)
jmp 0x27b8
cmpl $0x0, 0x8(%rsp)
jne 0x2764
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0xd770
testb $0x1, %al
jne 0x275d
jmp 0x2764
movb $0x1, 0x37(%rsp)
jmp 0x27b8
cmpl $0x0, 0x4(%rsp)
jne 0x278c
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0xd770
testb $0x1, %al
jne 0x2785
jmp 0x278c
movb $0x1, 0x37(%rsp)
jmp 0x27b8
cmpl $0x0, (%rsp)
jne 0x27b3
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0xd770
testb $0x1, %al
jne 0x27ac
jmp 0x27b3
movb $0x1, 0x37(%rsp)
jmp 0x27b8
movb $0x0, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)