LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: ChaohuiYu[P]BPlusTree/SlottedPageStructure.cpp
// Function: SlottedPageStructure::insertRecordAtEnd(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int SlottedPageStructure::insertRecordAtEnd(const string& record) {
    int spaceId = _records.size();
    _records.push_back(record);
    _recordsExist.push_back(true);
    return spaceId2rid(spaceId);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x20, %rdi
callq 0x5550
movq -0x20(%rbp), %rdi
movl %eax, -0x14(%rbp)
addq $0x20, %rdi
movq -0x10(%rbp), %rsi
callq 0x5400
movq -0x20(%rbp), %rdi
addq $0x38, %rdi
movl $0x1, %esi
callq 0xc7d0
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0xc590
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: ChaohuiYu[P]BPlusTree/SlottedPageStructure.cpp
// Function: SlottedPageStructure::insertRecordAtMiddle(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int SlottedPageStructure::insertRecordAtMiddle(const string& record) {
    if (_freeSpaces.empty()) {
        cerr << "error: try to insertRecordAtMiddle but no free spaces\n";
        return -1;
    }
    std::sort(_freeSpaces.begin(), _freeSpaces.end(), std::greater<int>());
    int freeSpaceId = _freeSpaces.back();
    _records[freeSpaceId] = record;
    _recordsExist[freeSpaceId] = true;
    _freeSpaces.pop_back();
    return spaceId2rid(freeSpaceId);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x60, %rdi
callq 0xa930
testb $0x1, %al
jne 0xbe67
jmp 0xbe86
movq 0x14182(%rip), %rdi     # 0x1fff0
leaq 0xa865(%rip), %rsi      # 0x166da
callq 0x3280
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xbf2f
movq -0x48(%rbp), %rdi
addq $0x60, %rdi
callq 0xa970
movq -0x48(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x60, %rdi
callq 0xa9a0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xc8a0
movq -0x48(%rbp), %rdi
addq $0x60, %rdi
callq 0xc8e0
movq -0x48(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
addq $0x20, %rdi
movslq -0x30(%rbp), %rsi
callq 0x55b0
movq -0x50(%rbp), %rsi
movq %rax, %rdi
callq 0x3050
movq -0x48(%rbp), %rdi
addq $0x38, %rdi
movslq -0x30(%rbp), %rsi
callq 0xc660
movq %rax, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
leaq -0x40(%rbp), %rdi
movl $0x1, %esi
callq 0xc6f0
movq -0x48(%rbp), %rdi
addq $0x60, %rdi
callq 0xc920
movq -0x48(%rbp), %rdi
movl -0x30(%rbp), %esi
callq 0xc590
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: ChaohuiYu[P]BPlusTree/SlottedPageStructure.cpp
// Function: SlottedPageStructure::deleteRecord(int)
void SlottedPageStructure::deleteRecord(int rid) {
    int spaceId = rid2spaceId(rid);
    if (spaceId >= _records.size()) {
        cerr << "error: in deleteRecord, spaceId out of range\n";
        return;
    }
    if (_recordsExist[spaceId] == false) {
        cerr << "error: in deleteRecord, record has been deleted\n";
        return;
    }
    _recordsExist[spaceId] = false;
    _freeSpaces.push_back(spaceId);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
movl -0xc(%rbp), %esi
callq 0xc020
movq -0x40(%rbp), %rdi
movl %eax, -0x10(%rbp)
movslq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
addq $0x20, %rdi
callq 0x5550
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jb 0xbf98
movq 0x14066(%rip), %rdi     # 0x1fff0
leaq 0xa60b(%rip), %rsi      # 0x1659c
callq 0x3280
jmp 0xc00e
movq -0x40(%rbp), %rdi
addq $0x38, %rdi
movslq -0x10(%rbp), %rsi
callq 0xc660
movq %rax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xc6c0
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0xbfd9
movq 0x14025(%rip), %rdi     # 0x1fff0
leaq 0xa5f8(%rip), %rsi      # 0x165ca
callq 0x3280
jmp 0xc00e
movq -0x40(%rbp), %rdi
addq $0x38, %rdi
movslq -0x10(%rbp), %rsi
callq 0xc660
movq %rax, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
callq 0xc6f0
movq -0x40(%rbp), %rdi
addq $0x60, %rdi
leaq -0x10(%rbp), %rsi
callq 0xc740
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ChaohuiYu[P]BPlusTree/SlottedPageStructure.cpp
// Function: SlottedPageStructure::queryRecord[abi:cxx11](int)
string SlottedPageStructure::queryRecord(int rid) {
    int spaceId = rid2spaceId(rid);
    if (spaceId >= _records.size()) {
        cerr << "error: in queryRecord, spaceId out of range\n";
        return "";
    }
    if (_recordsExist[spaceId] == false) {
        cerr << "error: in queryRecord, record has been deleted\n";
        return "";
    }
    return _records[spaceId];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movl -0x14(%rbp), %esi
callq 0xc020
movq -0x58(%rbp), %rdi
movl %eax, -0x18(%rbp)
movslq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
addq $0x20, %rdi
callq 0x5550
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jb 0xc113
movq 0x13f34(%rip), %rdi     # 0x1fff0
leaq 0xa538(%rip), %rsi      # 0x165fb
callq 0x3280
leaq -0x19(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x3420
movq -0x68(%rbp), %rdi
movq -0x70(%rbp), %rdx
leaq 0xa0ea(%rip), %rsi      # 0x161ce
callq 0x3810
jmp 0xc0eb
leaq -0x19(%rbp), %rdi
callq 0x32f0
jmp 0xc1b4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x19(%rbp), %rdi
callq 0x32f0
jmp 0xc1c1
movq -0x58(%rbp), %rdi
addq $0x38, %rdi
movslq -0x18(%rbp), %rsi
callq 0xc660
movq %rax, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xc6c0
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0xc197
movq 0x13eaa(%rip), %rdi     # 0x1fff0
leaq 0xa4db(%rip), %rsi      # 0x16628
callq 0x3280
leaq -0x41(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x3420
movq -0x68(%rbp), %rdi
movq -0x78(%rbp), %rdx
leaq 0xa060(%rip), %rsi      # 0x161ce
callq 0x3810
jmp 0xc175
leaq -0x41(%rbp), %rdi
callq 0x32f0
jmp 0xc1b4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x41(%rbp), %rdi
callq 0x32f0
jmp 0xc1c1
movq -0x58(%rbp), %rdi
addq $0x20, %rdi
movslq -0x18(%rbp), %rsi
callq 0x55b0
movq -0x68(%rbp), %rdi
movq %rax, %rsi
callq 0x3120
movq -0x60(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3410
nopw (%rax,%rax)
// File: ChaohuiYu[P]BPlusTree/SlottedPageStructure.cpp
// Function: SlottedPageStructure::print()
void SlottedPageStructure::print() {
    cout << "slot num per page: " << _slotNum << endl;
    cout << "filled slot num: " << _records.size() - _freeSpaces.size() << endl;
    for (int spaceId = 0; spaceId < _records.size(); ++spaceId) {
        if (_recordsExist[spaceId]) {
            cout << "pageId: " << spaceId2pageId(spaceId);
            cout << ", slotId: " << spaceId2slotId(spaceId);
            // cout << ", rid: " << spaceId2rid(spaceId);
            cout << ", record: \"" << _records[spaceId] << "\"" << endl;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq 0x13ddd(%rip), %rdi     # 0x1ffc8
leaq 0xa466(%rip), %rsi      # 0x16658
callq 0x3280
movq %rax, %rdi
movq -0x38(%rbp), %rax
movl 0x1c(%rax), %esi
callq 0x3400
movq %rax, %rdi
movq 0x13da8(%rip), %rsi     # 0x1ffb8
callq 0x32d0
movq 0x13dac(%rip), %rdi     # 0x1ffc8
leaq 0xa449(%rip), %rsi      # 0x1666c
callq 0x3280
movq -0x38(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x20, %rdi
callq 0x5550
movq -0x38(%rbp), %rdi
movq %rax, -0x30(%rbp)
addq $0x60, %rdi
callq 0xc7b0
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdi
subq %rax, %rsi
callq 0x30b0
movq %rax, %rdi
movq 0x13d54(%rip), %rsi     # 0x1ffb8
callq 0x32d0
movl $0x0, -0xc(%rbp)
movq -0x38(%rbp), %rdi
movslq -0xc(%rbp), %rax
movq %rax, -0x40(%rbp)
addq $0x20, %rdi
callq 0x5550
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0xc37e
movq -0x38(%rbp), %rdi
addq $0x38, %rdi
movslq -0xc(%rbp), %rsi
callq 0xc660
movq %rax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xc6c0
testb $0x1, %al
jne 0xc2c0
jmp 0xc36e
movq 0x13d01(%rip), %rdi     # 0x1ffc8
leaq 0xa3b0(%rip), %rsi      # 0x1667e
callq 0x3280
movq -0x38(%rbp), %rdi
movq %rax, -0x58(%rbp)
movl -0xc(%rbp), %esi
callq 0xc390
movq -0x58(%rbp), %rdi
movl %eax, %esi
callq 0x3400
movq 0x13cd3(%rip), %rdi     # 0x1ffc8
leaq 0xa38b(%rip), %rsi      # 0x16687
callq 0x3280
movq -0x38(%rbp), %rdi
movq %rax, -0x50(%rbp)
movl -0xc(%rbp), %esi
callq 0xc3b0
movq -0x50(%rbp), %rdi
movl %eax, %esi
callq 0x3400
movq 0x13ca5(%rip), %rdi     # 0x1ffc8
leaq 0xa368(%rip), %rsi      # 0x16692
callq 0x3280
movq -0x38(%rbp), %rdi
movq %rax, -0x48(%rbp)
addq $0x20, %rdi
movslq -0xc(%rbp), %rsi
callq 0x55b0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x3250
movq %rax, %rdi
leaq 0xa342(%rip), %rsi      # 0x1669c
callq 0x3280
movq %rax, %rdi
movq 0x13c4f(%rip), %rsi     # 0x1ffb8
callq 0x32d0
jmp 0xc370
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xc270
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ChaohuiYu[P]BPlusTree/SlottedPageStructure.cpp
// Function: SlottedPageStructure::printPage(int)
void SlottedPageStructure::printPage(int pageId) {
    cout << "Records in page " << pageId << ":" << endl;
    int pageNum = getPageNum();
    if (pageId >= pageNum) {
        cout << "    error: page " << pageId << " doesn't exist." << endl;
        return;
    }
    for (int spaceId = pageId * _slotNum; spaceId < (pageId+1) * _slotNum; ++spaceId) {
        cout << "    slot " << spaceId2slotId(spaceId) << ": ";
        if (_recordsExist[spaceId]) {
            cout << _records[spaceId];
        }
        cout << endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x13bda(%rip), %rdi     # 0x1ffc8
leaq 0xa2a9(%rip), %rsi      # 0x1669e
callq 0x3280
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x3400
movq %rax, %rdi
leaq 0xa139(%rip), %rsi      # 0x16548
callq 0x3280
movq %rax, %rdi
movq 0x13b9a(%rip), %rsi     # 0x1ffb8
callq 0x32d0
movq -0x30(%rbp), %rdi
callq 0xc550
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
cmpl -0x10(%rbp), %eax
jl 0xc478
movq 0x13b8a(%rip), %rdi     # 0x1ffc8
leaq 0xa26a(%rip), %rsi      # 0x166af
callq 0x3280
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x3400
movq %rax, %rdi
leaq 0xa261(%rip), %rsi      # 0x166c0
callq 0x3280
movq %rax, %rdi
movq 0x13b4a(%rip), %rsi     # 0x1ffb8
callq 0x32d0
jmp 0xc545
movq -0x30(%rbp), %rcx
movl -0xc(%rbp), %eax
imull 0x1c(%rcx), %eax
movl %eax, -0x14(%rbp)
movq -0x30(%rbp), %rdx
movl -0x14(%rbp), %eax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
imull 0x1c(%rdx), %ecx
cmpl %ecx, %eax
jge 0xc545
movq 0x13b22(%rip), %rdi     # 0x1ffc8
leaq 0xa223(%rip), %rsi      # 0x166d0
callq 0x3280
movq -0x30(%rbp), %rdi
movq %rax, -0x38(%rbp)
movl -0x14(%rbp), %esi
callq 0xc3b0
movq -0x38(%rbp), %rdi
movl %eax, %esi
callq 0x3400
movq %rax, %rdi
leaq 0xa021(%rip), %rsi      # 0x164f8
callq 0x3280
movq -0x30(%rbp), %rdi
addq $0x38, %rdi
movslq -0x14(%rbp), %rsi
callq 0xc660
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xc6c0
testb $0x1, %al
jne 0xc504
jmp 0xc524
movq -0x30(%rbp), %rdi
addq $0x20, %rdi
movslq -0x14(%rbp), %rsi
callq 0x55b0
movq %rax, %rsi
movq 0x13aa9(%rip), %rdi     # 0x1ffc8
callq 0x3250
movq 0x13a9d(%rip), %rdi     # 0x1ffc8
movq 0x13a86(%rip), %rsi     # 0x1ffb8
callq 0x32d0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xc486
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: ChaohuiYu[P]BPlusTree/BPlusTree.cpp
// Function: BPlusTree<int>::BPlusTree(int)
BPT<T>::BPT(int maxKeyCount) {
    _maxKeyCount = maxKeyCount;
    _root = new BPT_NODE(true, true, _maxKeyCount);
    _nodeCount = 1;
    _leafCount = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, 0x8(%rax)
movl $0x38, %edi
callq 0x3290
movq %rax, %rdi
movq -0x30(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0x28(%rbp)
movl 0x8(%rax), %ecx
movl $0x1, %edx
movl %edx, %esi
callq 0x10dd0
jmp 0xfef6
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
movl $0x1, 0xc(%rax)
movl $0x1, 0x10(%rax)
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x38, %esi
callq 0x32a0
movq -0x18(%rbp), %rdi
callq 0x3410
nopl (%rax,%rax)
// File: ChaohuiYu[P]BPlusTree/BPlusTree.cpp
// Function: BPlusTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::checkKeyExist(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool BPT<T>::checkKeyExist(T key) {
    BPT_NODE* leaf = findLeaf(key);

    // if key in leaf->_keys, don't insert
    FOR(i, 0, leaf->_keyCount)
        if (key == leaf->_keys[i])
            return true;

    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x70(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x3120
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x11900
movq %rax, -0x58(%rbp)
jmp 0x1186c
leaq -0x40(%rbp), %rdi
callq 0x3190
movq -0x58(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x50(%rbp)
movl -0x50(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x118dc
movq -0x70(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rsi
movslq -0x50(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rsi
callq 0x119b0
testb $0x1, %al
jne 0x118b2
jmp 0x118cf
movb $0x1, -0x1(%rbp)
jmp 0x118e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3190
jmp 0x118eb
jmp 0x118d1
movl -0x50(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x50(%rbp)
jmp 0x11884
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3410
nopw %cs:(%rax,%rax)
nop
// File: ChaohuiYu[P]BPlusTree/BPlusTree.cpp
// Function: BPlusTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::findLeaf(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
typename BPT_NODE* BPT<T>::findLeaf(T key) {
    BPT_NODE* node = _root;
    while (!node->_isLeaf) {
        FOR(i, 0, node->_keyCount + 1) {
            if (i == node->_keyCount || key < node->_keys[i]) {
                node = (BPT_NODE*)node->_pointers[i];
                break;
            }
        }
    }
    return node;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movb 0x8(%rax), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1192e
jmp 0x11999
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
movl 0x4(%rcx), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0x11997
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x4(%rcx), %eax
je 0x11974
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
movslq -0x1c(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rsi
callq 0x8720
testb $0x1, %al
jne 0x11974
jmp 0x1198a
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
jmp 0x11997
jmp 0x1198c
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x11935
jmp 0x1191f
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ChaohuiYu[P]BPlusTree/BPlusTree.cpp
// Function: BPlusTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::insertValue(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
bool BPT<T>::insertValue(T key, int value) {
    // find the leaf page that the key may be in.
    BPT_NODE* leaf = findLeaf(key);

    // if key in leaf->_keys, don't insert
    FOR(i, 0, leaf->_keyCount)
        if (key == leaf->_keys[i])
            return false;

    insertInNode(leaf, key, (void *)value);
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rsi, -0x98(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x3120
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
callq 0x11900
movq %rax, -0x80(%rbp)
jmp 0x11a91
leaq -0x48(%rbp), %rdi
callq 0x3190
movq -0x80(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x58(%rbp)
movl -0x58(%rbp), %eax
movq -0x28(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x11b0a
movq -0x98(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rsi
movslq -0x58(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rsi
callq 0x119b0
testb $0x1, %al
jne 0x11ada
jmp 0x11afd
movb $0x0, -0x1(%rbp)
jmp 0x11b72
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3190
jmp 0x11b80
jmp 0x11aff
movl -0x58(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x58(%rbp)
jmp 0x11aa9
movq -0x98(%rbp), %rsi
movq -0x28(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0x78(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x3120
movq -0x90(%rbp), %rdi
movq -0xa8(%rbp), %rsi
movq -0xa0(%rbp), %rdx
movslq -0x1c(%rbp), %rcx
callq 0x11b90
jmp 0x11b4c
leaq -0x78(%rbp), %rdi
callq 0x3190
movb $0x1, -0x1(%rbp)
jmp 0x11b72
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x3190
jmp 0x11b80
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xb0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x3410
nopl (%rax)
// File: ChaohuiYu[P]BPlusTree/BPlusTree.cpp
// Function: BPlusTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::deleteValue(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool BPT<T>::deleteValue(T key) {
    // find the leaf page that the key may be in.
    BPT_NODE* leaf = findLeaf(key);

    // if key in leaf->_keys, delete it
    FOR(i, 0, leaf->_keyCount) {
        if (key == leaf->_keys[i]) {
            deleteInNode(leaf, key);
            return true;
        }
    }

    // if key doesn't exist
    // cout << "error: key " << key << " doesn't exist.\n";
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rsi, -0x90(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x3120
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rsi
callq 0x11900
movq %rax, -0x78(%rbp)
jmp 0x11d48
leaq -0x40(%rbp), %rdi
callq 0x3190
movq -0x78(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x50(%rbp)
movl -0x50(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x11e20
movq -0x90(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rsi
movslq -0x50(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rsi
callq 0x119b0
testb $0x1, %al
jne 0x11d95
jmp 0x11e10
movq -0x90(%rbp), %rsi
movq -0x20(%rbp), %rax
movq %rax, -0xa0(%rbp)
leaq -0x70(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x3120
movq -0x88(%rbp), %rdi
movq -0xa0(%rbp), %rsi
movq -0x98(%rbp), %rdx
callq 0x11e40
jmp 0x11dd3
leaq -0x70(%rbp), %rdi
callq 0x3190
movb $0x1, -0x1(%rbp)
jmp 0x11e24
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3190
jmp 0x11e32
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x3190
jmp 0x11e32
jmp 0x11e12
movl -0x50(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x50(%rbp)
jmp 0x11d60
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xa0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3410
nopl (%rax,%rax)
// File: ChaohuiYu[P]BPlusTree/BPlusTree.cpp
// Function: BPlusTree<int>::deleteInNode(BPlusTree<int>::BPlusTreeNode*, int)
void BPT<T>::deleteInNode(BPT_NODE* node, T key) {
    int deleteIdx = 0 ;
    while (key != node->_keys[deleteIdx]) deleteIdx++ ;
    for (int i = deleteIdx; i < node->_keyCount - 1; i++)
        node->_keys[i] = node->_keys[i+1];
    for (int i = deleteIdx + 1; i < node->_keyCount; i++)
        node->_pointers[i] = node->_pointers[i+1];
    node->_keyCount--;

    // if the number of elements in a node < _maxKeyCount/2
    // redistribute the keys and values in siblings
    if (node->_keyCount < (_maxKeyCount+1)/2) {
        redistributeNode(node);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movslq -0x18(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
je 0x102e1
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x102c2
movl -0x18(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
movl 0x4(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x10326
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x1c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x1c(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x102e7
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x1036b
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movl -0x20(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdx
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x20(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1032f
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x4(%rcx), %edx
addl $-0x1, %edx
movl %edx, 0x4(%rcx)
movq -0x10(%rbp), %rcx
movl 0x4(%rcx), %ecx
movl %ecx, -0x2c(%rbp)
movl 0x8(%rax), %eax
addl $0x1, %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
jge 0x103aa
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x11130
addq $0x30, %rsp
popq %rbp
retq
// File: ChaohuiYu[P]BPlusTree/BPlusTree.cpp
// Function: BPlusTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::queryValue(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int BPT<T>::queryValue(T key) {
    // find the leaf page that the key may be in.
    BPT_NODE* leaf = findLeaf(key);

    // if key in leaf->_keys, return it
    FOR(i, 0, leaf->_keyCount)
        if (key == leaf->_keys[i])
            return (int)(long long)(leaf->_pointers[i+1]);

    // if key doesn't exist
    // cout << "    error: key " << key << " doesn't exist.\n";
    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x70(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x3120
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x11900
movq %rax, -0x58(%rbp)
jmp 0x11fac
leaq -0x40(%rbp), %rdi
callq 0x3190
movq -0x58(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x50(%rbp)
movl -0x50(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x12030
movq -0x70(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rsi
movslq -0x50(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rsi
callq 0x119b0
testb $0x1, %al
jne 0x11ff2
jmp 0x12023
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movl -0x50(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movl %eax, -0x4(%rbp)
jmp 0x12037
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3190
jmp 0x12040
jmp 0x12025
movl -0x50(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x50(%rbp)
jmp 0x11fc4
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3410
nopl (%rax)
// File: ChaohuiYu[P]BPlusTree/BPlusTree.cpp
// Function: BPlusTree<int>::BPlusTreeNode::printNode()
void BPT_NODE::printNode() {
    if (_isLeaf) {
        FOR(i, 0, _keyCount) {
            cout << _keys[i] << ":" << (int)(long long)_pointers[i+1] << " | ";
        }
        cout << endl;
    }
    else {
        FOR(i, 0, _keyCount) {
            cout << _pointers[i] << " | ";
            cout << _keys[i] << ":";
        }
        cout << _pointers[_keyCount] << endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, 0x8(%rax)
je 0x1093c
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x4(%rcx), %eax
jge 0x10924
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %esi
movq 0xf6f1(%rip), %rdi      # 0x1ffc8
callq 0x3400
movq %rax, %rdi
leaq 0x5c62(%rip), %rsi      # 0x16548
callq 0x3280
movq %rax, %rdi
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movl -0xc(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movl %eax, %esi
callq 0x3400
movq %rax, %rdi
leaq 0x5e19(%rip), %rsi      # 0x1672d
callq 0x3280
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x108b5
movq 0xf69d(%rip), %rdi      # 0x1ffc8
movq 0xf686(%rip), %rsi      # 0x1ffb8
callq 0x32d0
jmp 0x109da
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %eax
cmpl 0x4(%rcx), %eax
jge 0x109af
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movq 0xf662(%rip), %rdi      # 0x1ffc8
callq 0x3200
movq %rax, %rdi
leaq 0x5db8(%rip), %rsi      # 0x1672d
callq 0x3280
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %esi
movq 0xf638(%rip), %rdi      # 0x1ffc8
callq 0x3400
movq %rax, %rdi
leaq 0x5ba9(%rip), %rsi      # 0x16548
callq 0x3280
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x10943
movq -0x18(%rbp), %rcx
movq 0x18(%rcx), %rax
movslq 0x4(%rcx), %rcx
movq (%rax,%rcx,8), %rsi
movq 0xf602(%rip), %rdi      # 0x1ffc8
callq 0x3200
movq %rax, %rdi
movq 0xf5e3(%rip), %rsi      # 0x1ffb8
callq 0x32d0
addq $0x20, %rsp
popq %rbp
retq
// File: ChaohuiYu[P]BPlusTree/BPlusTree.cpp
// Function: BPlusTree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::BPlusTreeNode::BPlusTreeNode(bool, bool, int)
BPT_NODE::BPlusTreeNode(bool isLeaf, bool isRoot, int maxKeyCount) {
    _maxKeyCount = maxKeyCount;
    _keyCount = 0;
    _isLeaf = isLeaf;
    _isRoot = isRoot;
    // _keys = vector<T>();
    // _pointers = vector<void*>();
    _keys = new T[_maxKeyCount];
    _pointers = new void*[_maxKeyCount+1];
    _pointers[0] = NULL;
    _father = NULL;
    _prev = NULL;
    _next = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dl, %al
movb %sil, %dl
movq %rdi, -0x8(%rbp)
andb $0x1, %dl
movb %dl, -0x9(%rbp)
andb $0x1, %al
movb %al, -0xa(%rbp)
movl %ecx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x10(%rbp), %ecx
movl %ecx, (%rax)
movl $0x0, 0x4(%rax)
movb -0x9(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x8(%rax)
movb -0xa(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x9(%rax)
movslq (%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x20, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
addq $0x8, %rdi
setb %al
orb %al, %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3030
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rax, (%rcx)
addq $0x8, %rcx
movq %rcx, -0x18(%rbp)
cmpq $0x0, %rax
je 0x12b1a
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rdx
shlq $0x5, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movq %rcx, -0x38(%rbp)
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x3360
movq -0x40(%rbp), %rax
movq -0x38(%rbp), %rcx
addq $0x20, %rax
cmpq %rcx, %rax
movq %rax, -0x30(%rbp)
jne 0x12af8
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x10(%rax)
movl (%rax), %eax
addl $0x1, %eax
cltq
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3030
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq 0x18(%rax), %rcx
movq $0x0, (%rcx)
movq $0x0, 0x20(%rax)
movq $0x0, 0x28(%rax)
movq $0x0, 0x30(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: BGI-Qingdao[P]ExtractNGSReads/./utils/argsparser.h
// Function: BGIQD::ARGS::args_union::~args_union()
~args_union()
            {
                if( t == is_string && d.s )
                    delete d.s ;
                if ( t== is_vector_string && d.vs )
                    delete d.vs ;
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $0x1, 0x68(%rax)
jne 0x994b
movq -0x10(%rbp), %rax
cmpq $0x0, 0x70(%rax)
je 0x994b
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x9949
movq -0x18(%rbp), %rdi
callq 0x5250
movq -0x18(%rbp), %rdi
callq 0x5370
jmp 0x994b
movq -0x10(%rbp), %rax
cmpl $0x5, 0x68(%rax)
jne 0x9986
movq -0x10(%rbp), %rax
cmpq $0x0, 0x70(%rax)
je 0x9986
movq -0x10(%rbp), %rax
movq 0x70(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x9984
movq -0x20(%rbp), %rdi
callq 0xb5f0
movq -0x20(%rbp), %rdi
callq 0x5370
jmp 0x9986
movq -0x10(%rbp), %rdi
addq $0x48, %rdi
callq 0x5250
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
callq 0x5250
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x5250
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: BGI-Qingdao[P]ExtractNGSReads/./utils/fastq.h
// Function: BGIQD::FASTQ::stLFRHeader::operator=(BGIQD::FASTQ::stLFRHeader const&)
stLFRHeader & operator = ( const stLFRHeader & a ) {
                if( &a != this )
                {
                    type = a.type ;
                    readIndex  = a.readIndex ;
                    barcode_num = a.barcode_num ;
                    barcode_str = a.barcode_str ;
                    readName = a.readName ;
                }
                return *this ;
            }

// 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)
cmpq %rax, -0x10(%rbp)
je 0xc4a4
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, (%rdi)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, 0x4(%rdi)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x8(%rdi)
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
addq $0x10, %rdi
callq 0x5040
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x30, %rsi
addq $0x30, %rdi
callq 0x5040
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: BGI-Qingdao[P]ExtractNGSReads/./utils/fastq.h
// Function: BGIQD::FASTQ::Fastq<BGIQD::FASTQ::stLFRHeader>::Reset()
void Reset() 
                {
                    head.Reset();
                    seq.Reset();
                    quality.Reset();
                    flags = 0 ;
                    Set_UnSet();
                }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x8, %rdi
callq 0xdf50
movq -0x18(%rbp), %rdi
addq $0x58, %rdi
callq 0xdfb0
movq -0x18(%rbp), %rdi
addq $0x78, %rdi
callq 0xdfb0
leaq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xdfd0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, (%rdi)
callq 0xe020
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: BGI-Qingdao[P]ExtractNGSReads/./utils/fastq.h
// Function: BGIQD::FASTQ::Fastq<BGIQD::FASTQ::stLFRHeader>::Is_Setted() const
bool Is_Setted() const { 
                    return  (!Is_UnSet() )
                        && Is_Set_head() 
                        && Is_Set_seq()
                        && Is_Set_3() 
                        && Is_Set_quality();
                }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0xe210
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x9(%rbp)
jne 0xdc16
movq -0x18(%rbp), %rdi
callq 0xe240
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x9(%rbp)
jne 0xdbdc
jmp 0xdc16
movq -0x18(%rbp), %rdi
callq 0xe270
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x9(%rbp)
jne 0xdbf3
jmp 0xdc16
movq -0x18(%rbp), %rdi
callq 0xe2a0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x9(%rbp)
jne 0xdc0a
jmp 0xdc16
movq -0x18(%rbp), %rdi
callq 0xe2d0
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: BGI-Qingdao[P]ExtractNGSReads/./utils/fastq.h
// Function: BGIQD::FASTQ::Fastq<BGIQD::FASTQ::stLFRHeader>::AddSeq(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void AddSeq(const std::string & line )
                {
                    if( Is_UnSet() || ! Is_Set_head() )
                    {
                        assert(0);
                    }
                    Set_Set_seq();
                    seq.AddPartSeq(line);
                }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0xe210
testb $0x1, %al
jne 0xdd0e
movq -0x18(%rbp), %rdi
callq 0xe240
testb $0x1, %al
jne 0xdd2d
leaq 0x682c(%rip), %rdi      # 0x14541
leaq 0x66d3(%rip), %rsi      # 0x143ef
movl $0x86, %edx
leaq 0x681b(%rip), %rcx      # 0x14543
callq 0x5270
movq -0x18(%rbp), %rdi
callq 0xee20
movq -0x18(%rbp), %rdi
addq $0x58, %rdi
movq -0x10(%rbp), %rsi
callq 0xee50
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: BGI-Qingdao[P]ExtractNGSReads/./utils/fastq.h
// Function: BGIQD::FASTQ::Fastq<BGIQD::FASTQ::stLFRHeader>::Add3(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Add3(const std::string & )
                {
                    if( Is_UnSet()
                            || ! Is_Set_head() 
                            || ! Is_Set_seq() )
                    {
                        assert(0);
                    }
                    Set_Set_3();
                }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0xe210
testb $0x1, %al
jne 0xdddd
movq -0x18(%rbp), %rdi
callq 0xe240
testb $0x1, %al
jne 0xddd0
jmp 0xdddd
movq -0x18(%rbp), %rdi
callq 0xe270
testb $0x1, %al
jne 0xddfc
leaq 0x675d(%rip), %rdi      # 0x14541
leaq 0x6604(%rip), %rsi      # 0x143ef
movl $0x92, %edx
leaq 0x67bd(%rip), %rcx      # 0x145b4
callq 0x5270
movq -0x18(%rbp), %rdi
callq 0xee80
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: BGI-Qingdao[P]ExtractNGSReads/./utils/fastq.h
// Function: BGIQD::FASTQ::Fastq<BGIQD::FASTQ::stLFRHeader>::AddQuality(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void AddQuality( const std::string & line )
                {

                    if( Is_UnSet() || ! Is_Set_3() )
                    {
                        assert(0);
                    }
                    Set_Set_quality();
                    quality.AddPartSeq(line);
                }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0xe210
testb $0x1, %al
jne 0xde3e
movq -0x18(%rbp), %rdi
callq 0xe2a0
testb $0x1, %al
jne 0xde5d
leaq 0x66fc(%rip), %rdi      # 0x14541
leaq 0x65a3(%rip), %rsi      # 0x143ef
movl $0x9c, %edx
leaq 0x67cb(%rip), %rcx      # 0x14623
callq 0x5270
movq -0x18(%rbp), %rdi
callq 0xeeb0
movq -0x18(%rbp), %rdi
addq $0x78, %rdi
movq -0x10(%rbp), %rsi
callq 0xee50
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: BGI-Qingdao[P]ExtractNGSReads/./utils/fastq.h
// Function: BGIQD::FASTQ::stLFRHeader::Reset()
void Reset()
            {
                type = Unknow ;
                readName ="";
                barcode_str = "" ;
                readIndex = 0 ;
                barcode_num = 0 ;
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movl $0x0, (%rdi)
addq $0x30, %rdi
leaq 0x6139(%rip), %rsi      # 0x140ae
callq 0x5500
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
leaq 0x6125(%rip), %rsi      # 0x140ae
callq 0x5500
movq -0x10(%rbp), %rax
movl $0x0, 0x4(%rax)
movl $0x0, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: BGI-Qingdao[P]ExtractNGSReads/./utils/fastq.h
// Function: BGIQD::FASTQ::stLFRHeader::stLFRHeader(BGIQD::FASTQ::stLFRHeader const&)
stLFRHeader(const stLFRHeader & a) {
                type = a.type ;
                readIndex  = a.readIndex ;
                barcode_num = a.barcode_num ;
                barcode_str = a.barcode_str ;
                readName = a.readName ;
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x10, %rdi
movq %rdi, -0x28(%rbp)
callq 0x5520
movq -0x30(%rbp), %rdi
addq $0x30, %rdi
movq %rdi, -0x38(%rbp)
callq 0x5520
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, (%rax)
movq -0x10(%rbp), %rcx
movl 0x4(%rcx), %ecx
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x5040
jmp 0xe7d9
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x30, %rsi
addq $0x30, %rdi
callq 0x5040
jmp 0xe7f0
addq $0x40, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x5250
movq -0x28(%rbp), %rdi
callq 0x5250
movq -0x18(%rbp), %rdi
callq 0x5690
nopl (%rax)
// File: BGI-Qingdao[P]ExtractNGSReads/utils/fastq.cpp
// Function: BGIQD::FASTQ::stLFRHeader::Head[abi:cxx11]() const
std::string stLFRHeader::Head() const 
        {
            assert(type != Unknow );
            std::ostringstream ost ;
            ost<<'@'<<readName<<'#'<<barcode_str;
            if( type == readName_barcodeStr_index )
                ost<<'/'<<readIndex;
            if( type == readName_barcodeStr_index_barcodeNum )
                ost<<'/'<<readIndex<<'\t'<<barcode_num;
            return ost.str();
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1f0, %rsp            # imm = 0x1F0
movq %rdi, -0x1b0(%rbp)
movq %rdi, %rax
movq %rax, -0x1a8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x1a0(%rbp)
cmpl $0x0, (%rax)
je 0x10c56
jmp 0x10c75
leaq 0x3c6c(%rip), %rdi      # 0x148c9
leaq 0x3be5(%rip), %rsi      # 0x14849
movl $0x34, %edx
leaq 0x3c68(%rip), %rcx      # 0x148d8
callq 0x5270
leaq -0x188(%rbp), %rdi
movq %rdi, -0x1c0(%rbp)
callq 0x54f0
movq -0x1c0(%rbp), %rdi
movl $0x40, %esi
callq 0x5470
movq %rax, -0x1b8(%rbp)
jmp 0x10ca2
movq -0x1b8(%rbp), %rdi
movq -0x1a0(%rbp), %rsi
addq $0x30, %rsi
callq 0x5350
movq %rax, -0x1c8(%rbp)
jmp 0x10cc2
movq -0x1c8(%rbp), %rdi
movl $0x23, %esi
callq 0x5470
movq %rax, -0x1d0(%rbp)
jmp 0x10cdc
movq -0x1d0(%rbp), %rdi
movq -0x1a0(%rbp), %rsi
addq $0x10, %rsi
callq 0x5350
jmp 0x10cf5
movq -0x1a0(%rbp), %rax
cmpl $0x2, (%rax)
jne 0x10d58
leaq -0x188(%rbp), %rdi
movl $0x2f, %esi
callq 0x5470
movq %rax, -0x1d8(%rbp)
jmp 0x10d1b
movq -0x1d8(%rbp), %rdi
movq -0x1a0(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x5670
jmp 0x10d33
jmp 0x10d58
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
leaq -0x188(%rbp), %rdi
callq 0x50d0
jmp 0x10e02
movq -0x1a0(%rbp), %rax
cmpl $0x3, (%rax)
jne 0x10dd1
leaq -0x188(%rbp), %rdi
movl $0x2f, %esi
callq 0x5470
movq %rax, -0x1e0(%rbp)
jmp 0x10d7e
movq -0x1e0(%rbp), %rdi
movq -0x1a0(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x5670
movq %rax, -0x1e8(%rbp)
jmp 0x10d9d
movq -0x1e8(%rbp), %rdi
movl $0x9, %esi
callq 0x5470
movq %rax, -0x1f0(%rbp)
jmp 0x10db7
movq -0x1f0(%rbp), %rdi
movq -0x1a0(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x5670
jmp 0x10dcf
jmp 0x10dd1
movq -0x1b0(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0x53d0
jmp 0x10de6
leaq -0x188(%rbp), %rdi
callq 0x50d0
movq -0x1a8(%rbp), %rax
addq $0x1f0, %rsp            # imm = 0x1F0
popq %rbp
retq
movq -0x190(%rbp), %rdi
callq 0x5690
nop
// File: BGI-Qingdao[P]ExtractNGSReads/utils/fastq.cpp
// Function: BGIQD::FASTQ::Id_Desc_Head::Init(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Id_Desc_Head::Init( const std::string &line )
        {
            Reset() ;
            bool turn = false ;
            assert(line.size() > 1);
            assert(line[0] == '@');
            for( int i = 1 ; i < (int)line.size() ; i++ )
            {
                if( !turn  )
                {
                    if( ! std::isblank(line[i]) )
                        Id += line[i] ;
                    else 
                        turn = true ;
                }
                if( turn )
                    Desc += line[i] ;
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x10fa0
movb $0x0, -0x11(%rbp)
movq -0x10(%rbp), %rdi
callq 0x52c0
cmpq $0x1, %rax
jbe 0x10e42
jmp 0x10e61
leaq 0x3ac3(%rip), %rdi      # 0x1490c
leaq 0x39f9(%rip), %rsi      # 0x14849
movl $0x42, %edx
leaq 0x3ac0(%rip), %rcx      # 0x1491c
callq 0x5270
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5460
movsbl (%rax), %eax
cmpl $0x40, %eax
jne 0x10e78
jmp 0x10e97
leaq 0x3ad8(%rip), %rdi      # 0x14957
leaq 0x39c3(%rip), %rsi      # 0x14849
movl $0x43, %edx
leaq 0x3a8a(%rip), %rcx      # 0x1491c
callq 0x5270
movl $0x1, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
callq 0x52c0
movq %rax, %rcx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
jge 0x10f2f
testb $0x1, -0x11(%rbp)
jne 0x10efa
movq -0x10(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0x5460
movsbl (%rax), %edi
callq 0x53e0
cmpl $0x0, %eax
jne 0x10ef4
movq -0x10(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0x5460
movq -0x20(%rbp), %rdi
movb (%rax), %al
movsbl %al, %esi
callq 0x5260
jmp 0x10ef8
movb $0x1, -0x11(%rbp)
jmp 0x10efa
testb $0x1, -0x11(%rbp)
je 0x10f1f
movq -0x10(%rbp), %rdi
movslq -0x18(%rbp), %rsi
callq 0x5460
movq -0x20(%rbp), %rdi
movb (%rax), %al
addq $0x20, %rdi
movsbl %al, %esi
callq 0x5260
jmp 0x10f21
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x10e9e
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: BGI-Qingdao[P]ExtractNGSReads/utils/file_reader.cpp
// Function: BGIQD::FILES::FileReaderFactory::GenerateReaderFromFileName(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::istream * FileReaderFactory::GenerateReaderFromFileName(const std::string & file_name )
    {
        std::istream * ret = NULL;
        if( file_name.rfind(".gz") == file_name.length() - 3 )
        {// gzip file
            ret = (new igzstream(file_name.c_str()));
        }
        else
        { // treat as txt file now //TODO
            ret = (new std::ifstream(file_name.c_str()));
        }
        if (ret && ! ret->good() )
        {
            delete ret ;
            ret = NULL;
        }
        return ret;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x3937(%rip), %rsi      # 0x14966
movq $-0x1, %rdx
callq 0x5630
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x55b0
movq %rax, %rcx
movq -0x28(%rbp), %rax
subq $0x3, %rcx
cmpq %rcx, %rax
jne 0x110c8
movl $0x2a0, %edi            # imm = 0x2A0
callq 0x53c0
movq %rax, -0x30(%rbp)
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
callq 0x51b0
movq -0x30(%rbp), %rdi
movq %rax, %rsi
movl $0x8, %edx
callq 0x11290
jmp 0x11086
movq -0x38(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movq %rax, -0x40(%rbp)
je 0x110a4
movq -0x38(%rbp), %rax
addq $0x188, %rax            # imm = 0x188
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x11117
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x5370
jmp 0x1115c
movl $0x208, %edi            # imm = 0x208
callq 0x53c0
movq %rax, -0x48(%rbp)
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rdi
callq 0x51b0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
movl $0x8, %edx
callq 0x56e0
jmp 0x110f6
movq -0x50(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x11117
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x5370
jmp 0x1115c
cmpq $0x0, -0x10(%rbp)
je 0x11152
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x5660
testb $0x1, %al
jne 0x11152
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
je 0x1114a
movq -0x58(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x5690
nopw %cs:(%rax,%rax)
// File: BGI-Qingdao[P]ExtractNGSReads/utils/file_reader.cpp
// Function: BGIQD::FILES::FileReaderFactory::ResizeBuff(std::istream&, unsigned long)
void FileReaderFactory::ResizeBuff( std::istream & ist, size_t size )
    {
        char * buffer = (char *) calloc( sizeof(char) , size );
        if( buffer == 0 )
        {
            std::cerr<<"Fatal buffer calloc failed . System has no more memory ."<<std::endl;
            exit(1);
        }
        (ist.rdbuf())->pubsetbuf(buffer,size);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movl $0x1, %edi
callq 0x5280
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x111c5
movq 0xbe50(%rip), %rdi      # 0x1cff0
leaq 0x37c3(%rip), %rsi      # 0x1496a
callq 0x53b0
movq %rax, %rdi
movq 0xbdf2(%rip), %rsi      # 0x1cfa8
callq 0x5410
movl $0x1, %edi
callq 0x5480
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x51d0
movq %rax, %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x5060
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)