LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: zeeev[P]DASVC/bamtools/src/api/SamProgramChain.cpp
// Function: BamTools::SamProgramChain::Last() const
const SamProgram& SamProgramChain::Last(void) const {
    // find first record in container that has no NextProgramID entry
    SamProgramConstIterator iter = ConstBegin();
    SamProgramConstIterator end  = ConstEnd();
    for ( ; iter != end; ++iter ) {
        const SamProgram& current = (*iter);
        if ( !current.HasNextProgramID() )
            return current;
    }

    // otherwise error
    cerr << "SamProgramChain::Last: could not determine last record" << endl;
    exit(1);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x738b0
movq (%rsp), %rdi
movq %rax, 0x18(%rsp)
callq 0x7c8a0
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x71760
testb $0x1, %al
jne 0x9228f
jmp 0x922c4
leaq 0x18(%rsp), %rdi
callq 0x7b140
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x77ed0
testb $0x1, %al
jne 0x922b6
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
jmp 0x922b8
leaq 0x18(%rsp), %rdi
callq 0x78180
jmp 0x9227a
movq 0x7fd1d(%rip), %rdi     # 0x111fe8
leaq 0x581e5(%rip), %rsi     # 0xea4b7
callq 0x768e0
movq %rax, %rdi
movq 0x7fc37(%rip), %rsi     # 0x111f18
callq 0x76cc0
movl $0x1, %edi
callq 0x77ea0
// File: zeeev[P]DASVC/bamtools/src/api/SamProgramChain.cpp
// Function: BamTools::SamProgramChain::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
SamProgram& SamProgramChain::operator[](const std::string& programId) {

    // look up program record matching this ID
    int index = IndexOf(programId);

    // if record not found
    if ( index == (int)m_data.size() ) {
        cerr << "SamProgramChain::operator[] - unknown programId: " << programId << endl;
        exit(1);
    }

    // otherwise return program record at index
    return m_data.at(index);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x18(%rsp), %rsi
callq 0x7c520
movq 0x8(%rsp), %rdi
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl %eax, 0x10(%rsp)
callq 0x79460
movq %rax, %rcx
movl 0x10(%rsp), %eax
cmpl %ecx, %eax
jne 0x9237c
movq 0x7fc9e(%rip), %rdi     # 0x111fe8
leaq 0x5819d(%rip), %rsi     # 0xea4ee
callq 0x768e0
movq %rax, %rdi
movq 0x18(%rsp), %rsi
callq 0x75e40
movq %rax, %rdi
movq 0x7fbab(%rip), %rsi     # 0x111f18
callq 0x76cc0
movl $0x1, %edi
callq 0x77ea0
movq 0x8(%rsp), %rdi
movslq 0x14(%rsp), %rsi
callq 0x74ce0
addq $0x28, %rsp
retq
// File: zeeev[P]DASVC/bamtools/src/api/SamReadGroup.cpp
// Function: BamTools::SamReadGroup::Clear()
void SamReadGroup::Clear(void) {
    Description.clear();
    FlowOrder.clear();
    ID.clear();
    KeySequence.clear();
    Library.clear();
    PlatformUnit.clear();
    PredictedInsertSize.clear();
    ProductionDate.clear();
    Program.clear();
    Sample.clear();
    SequencingCenter.clear();
    SequencingTechnology.clear();
    CustomTags.clear();
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x78800
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
callq 0x78800
movq 0x8(%rsp), %rdi
addq $0x40, %rdi
callq 0x78800
movq 0x8(%rsp), %rdi
addq $0x60, %rdi
callq 0x78800
movq 0x8(%rsp), %rdi
addq $0x80, %rdi
callq 0x78800
movq 0x8(%rsp), %rdi
addq $0xa0, %rdi
callq 0x78800
movq 0x8(%rsp), %rdi
addq $0xc0, %rdi
callq 0x78800
movq 0x8(%rsp), %rdi
addq $0xe0, %rdi
callq 0x78800
movq 0x8(%rsp), %rdi
addq $0x100, %rdi            # imm = 0x100
callq 0x78800
movq 0x8(%rsp), %rdi
addq $0x120, %rdi            # imm = 0x120
callq 0x78800
movq 0x8(%rsp), %rdi
addq $0x140, %rdi            # imm = 0x140
callq 0x78800
movq 0x8(%rsp), %rdi
addq $0x160, %rdi            # imm = 0x160
callq 0x78800
movq 0x8(%rsp), %rdi
addq $0x180, %rdi            # imm = 0x180
callq 0x73dc0
addq $0x18, %rsp
retq
// File: zeeev[P]DASVC/bamtools/src/api/SamReadGroupDictionary.cpp
// Function: BamTools::SamReadGroupDictionary::Add(BamTools::SamReadGroupDictionary const&)
void SamReadGroupDictionary::Add(const SamReadGroupDictionary& readGroups) {
    SamReadGroupConstIterator rgIter = readGroups.ConstBegin();
    SamReadGroupConstIterator rgEnd  = readGroups.ConstEnd();
    for ( ; rgIter != rgEnd; ++rgIter )
        Add(*rgIter);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
callq 0x7ab20
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x7b990
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x736e0
testb $0x1, %al
jne 0x950ba
jmp 0x950dc
leaq 0x10(%rsp), %rdi
callq 0x737d0
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x79d30
leaq 0x10(%rsp), %rdi
callq 0x7aa70
jmp 0x950a5
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/api/SamReadGroupDictionary.cpp
// Function: BamTools::SamReadGroupDictionary::Add(std::vector<BamTools::SamReadGroup, std::allocator<BamTools::SamReadGroup>> const&)
void SamReadGroupDictionary::Add(const std::vector<SamReadGroup>& readGroups) {
    vector<SamReadGroup>::const_iterator rgIter = readGroups.begin();
    vector<SamReadGroup>::const_iterator rgEnd  = readGroups.end();
    for ( ; rgIter!= rgEnd; ++rgIter )
        Add(*rgIter);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
callq 0x796d0
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x7ba00
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x736e0
testb $0x1, %al
jne 0x9519a
jmp 0x951bc
leaq 0x10(%rsp), %rdi
callq 0x737d0
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x79d30
leaq 0x10(%rsp), %rdi
callq 0x7aa70
jmp 0x95185
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/api/SamReadGroupDictionary.cpp
// Function: BamTools::SamReadGroupDictionary::Add(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
void SamReadGroupDictionary::Add(const std::vector<std::string>& readGroupIds) {
    vector<string>::const_iterator rgIter = readGroupIds.begin();
    vector<string>::const_iterator rgEnd  = readGroupIds.end();
    for ( ; rgIter!= rgEnd; ++rgIter )
        Add(*rgIter);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
callq 0x71c40
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x74ae0
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x750f0
testb $0x1, %al
jne 0x9521a
jmp 0x9523c
leaq 0x10(%rsp), %rdi
callq 0x71410
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x71d00
leaq 0x10(%rsp), %rdi
callq 0x75880
jmp 0x95205
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/api/SamReadGroupDictionary.cpp
// Function: BamTools::SamReadGroupDictionary::Remove(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void SamReadGroupDictionary::Remove(const std::string& readGroupId) {

    // skip if empty dictionary or if ID unknown
    if ( IsEmpty() || !Contains(readGroupId) )
        return;

    // update 'lookup index' for every entry after @readGroupId
    const size_t indexToRemove = m_lookupData[readGroupId];
    const size_t numEntries = m_data.size();
    for ( size_t i = indexToRemove+1; i < numEntries; ++i ) {
        const SamReadGroup& rg = m_data.at(i);
        --m_lookupData[rg.ID];
    }

    // erase entry from containers
    m_data.erase( Begin() + indexToRemove );
    m_lookupData.erase(readGroupId);
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x7b4c0
testb $0x1, %al
jne 0x95404
movq 0x8(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x77900
testb $0x1, %al
jne 0x95409
jmp 0x954dc
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
movq 0x48(%rsp), %rsi
callq 0x7b520
movq 0x8(%rsp), %rdi
movq (%rax), %rax
movq %rax, 0x40(%rsp)
callq 0x79280
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
cmpq 0x38(%rsp), %rax
jae 0x95492
movq 0x8(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x7bc50
movq 0x8(%rsp), %rdi
movq %rax, 0x28(%rsp)
addq $0x18, %rdi
movq 0x28(%rsp), %rsi
addq $0x40, %rsi
callq 0x7b520
movq (%rax), %rcx
addq $-0x1, %rcx
movq %rcx, (%rax)
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x95441
movq 0x8(%rsp), %rdi
callq 0x75400
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rsi
leaq 0x18(%rsp), %rdi
callq 0x77580
movq 0x8(%rsp), %rdi
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rsi
callq 0x7a330
movq 0x8(%rsp), %rdi
movq %rax, 0x10(%rsp)
addq $0x18, %rdi
movq 0x48(%rsp), %rsi
callq 0x7caf0
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/api/SamReadGroupDictionary.cpp
// Function: BamTools::SamReadGroupDictionary::Remove(std::vector<BamTools::SamReadGroup, std::allocator<BamTools::SamReadGroup>> const&)
void SamReadGroupDictionary::Remove(const std::vector<SamReadGroup>& readGroups) {
    vector<SamReadGroup>::const_iterator rgIter = readGroups.begin();
    vector<SamReadGroup>::const_iterator rgEnd  = readGroups.end();
    for ( ; rgIter!= rgEnd; ++rgIter )
        Remove(*rgIter);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
callq 0x796d0
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x7ba00
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x736e0
testb $0x1, %al
jne 0x9553a
jmp 0x9555c
leaq 0x10(%rsp), %rdi
callq 0x737d0
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x7b800
leaq 0x10(%rsp), %rdi
callq 0x7aa70
jmp 0x95525
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/api/SamReadGroupDictionary.cpp
// Function: BamTools::SamReadGroupDictionary::Remove(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
void SamReadGroupDictionary::Remove(const std::vector<std::string>& readGroupIds) {
    vector<string>::const_iterator rgIter = readGroupIds.begin();
    vector<string>::const_iterator rgEnd  = readGroupIds.end();
    for ( ; rgIter!= rgEnd; ++rgIter )
        Remove(*rgIter);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
callq 0x71c40
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x74ae0
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x750f0
testb $0x1, %al
jne 0x955ba
jmp 0x955dc
leaq 0x10(%rsp), %rdi
callq 0x71410
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x72f30
leaq 0x10(%rsp), %rdi
callq 0x75880
jmp 0x955a5
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/api/SamReadGroupDictionary.cpp
// Function: BamTools::SamReadGroupDictionary::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
SamReadGroup& SamReadGroupDictionary::operator[](const std::string& readGroupId) {

    if ( !Contains(readGroupId) ) {
        SamReadGroup rg(readGroupId);
        m_data.push_back(rg);
        m_lookupData[readGroupId] = m_data.size() - 1;
    }

    const size_t index = m_lookupData[readGroupId];
    return m_data.at(index);
}

// Assembly:
subq $0x1e8, %rsp            # imm = 0x1E8
movq %rdi, 0x1e0(%rsp)
movq %rsi, 0x1d8(%rsp)
movq 0x1e0(%rsp), %rdi
movq %rdi, 0x20(%rsp)
movq 0x1d8(%rsp), %rsi
callq 0x77900
testb $0x1, %al
jne 0x956cf
movq 0x1d8(%rsp), %rsi
leaq 0x40(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x79ec0
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x7a990
jmp 0x95661
movq 0x20(%rsp), %rdi
callq 0x79280
movq %rax, 0x10(%rsp)
jmp 0x95672
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rax
decq %rax
movq %rax, (%rsp)
addq $0x18, %rdi
movq 0x1d8(%rsp), %rsi
callq 0x7b520
movq %rax, 0x8(%rsp)
jmp 0x9569b
movq 0x8(%rsp), %rax
movq (%rsp), %rcx
movq %rcx, (%rax)
leaq 0x40(%rsp), %rdi
callq 0x7ba40
jmp 0x956cf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x7ba40
jmp 0x956cd
jmp 0x95704
movq 0x20(%rsp), %rdi
addq $0x18, %rdi
movq 0x1d8(%rsp), %rsi
callq 0x7b520
movq 0x20(%rsp), %rdi
movq (%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rsi
callq 0x7bc50
addq $0x1e8, %rsp            # imm = 0x1E8
retq
movq 0x38(%rsp), %rdi
callq 0x7b550
movq %rax, %rdi
callq 0x88ef0
nopw %cs:(%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/api/SamSequence.cpp
// Function: BamTools::SamSequence::Clear()
void SamSequence::Clear(void) {
    AssemblyID.clear();
    Checksum.clear();
    Length.clear();
    Name.clear();
    Species.clear();
    URI.clear();
    CustomTags.clear();
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x78800
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
callq 0x78800
movq 0x8(%rsp), %rdi
addq $0x40, %rdi
callq 0x78800
movq 0x8(%rsp), %rdi
addq $0x60, %rdi
callq 0x78800
movq 0x8(%rsp), %rdi
addq $0x80, %rdi
callq 0x78800
movq 0x8(%rsp), %rdi
addq $0xa0, %rdi
callq 0x78800
movq 0x8(%rsp), %rdi
addq $0xc0, %rdi
callq 0x73dc0
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/api/SamSequenceDictionary.cpp
// Function: BamTools::SamSequenceDictionary::Add(BamTools::SamSequenceDictionary const&)
void SamSequenceDictionary::Add(const SamSequenceDictionary& sequences) {
    SamSequenceConstIterator seqIter = sequences.ConstBegin();
    SamSequenceConstIterator seqEnd  = sequences.ConstEnd();
    for ( ; seqIter != seqEnd; ++seqIter )
        Add(*seqIter);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
callq 0x79d20
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x7bfb0
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x75e90
testb $0x1, %al
jne 0x9aeca
jmp 0x9aeec
leaq 0x10(%rsp), %rdi
callq 0x767c0
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x79580
leaq 0x10(%rsp), %rdi
callq 0x76200
jmp 0x9aeb5
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/api/SamSequenceDictionary.cpp
// Function: BamTools::SamSequenceDictionary::Add(std::vector<BamTools::SamSequence, std::allocator<BamTools::SamSequence>> const&)
void SamSequenceDictionary::Add(const std::vector<SamSequence>& sequences) {
    vector<SamSequence>::const_iterator seqIter = sequences.begin();
    vector<SamSequence>::const_iterator seqEnd  = sequences.end();
    for ( ; seqIter!= seqEnd; ++seqIter )
        Add(*seqIter);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
callq 0x74a60
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x7acc0
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x75e90
testb $0x1, %al
jne 0x9afaa
jmp 0x9afcc
leaq 0x10(%rsp), %rdi
callq 0x767c0
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x79580
leaq 0x10(%rsp), %rdi
callq 0x76200
jmp 0x9af95
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/api/SamSequenceDictionary.cpp
// Function: BamTools::SamSequenceDictionary::Add(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>> const&)
void SamSequenceDictionary::Add(const std::map<std::string, int>& sequenceMap) {
    map<string, int>::const_iterator seqIter = sequenceMap.begin();
    map<string, int>::const_iterator seqEnd  = sequenceMap.end();
    for ( ; seqIter != seqEnd; ++seqIter ) {
        const string& name = (*seqIter).first;
        const int& length = (*seqIter).second;
        Add( SamSequence(name, length) );
    }
}

// Assembly:
subq $0x138, %rsp            # imm = 0x138
movq %rdi, 0x130(%rsp)
movq %rsi, 0x128(%rsp)
movq 0x130(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x128(%rsp), %rdi
callq 0x7ab80
movq %rax, 0x120(%rsp)
movq 0x128(%rsp), %rdi
callq 0x7a260
movq %rax, 0x118(%rsp)
leaq 0x120(%rsp), %rdi
leaq 0x118(%rsp), %rsi
callq 0x759c0
testb $0x1, %al
jne 0x9b04c
jmp 0x9b0e4
leaq 0x120(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x7c240
movq 0x8(%rsp), %rdi
movq %rax, 0x110(%rsp)
callq 0x7c240
addq $0x20, %rax
movq %rax, 0x108(%rsp)
movq 0x110(%rsp), %rsi
movq 0x108(%rsp), %rdx
leaq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x76350
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x79580
jmp 0x9b0ac
leaq 0x30(%rsp), %rdi
callq 0x7c470
leaq 0x120(%rsp), %rdi
callq 0x7b2b0
jmp 0x9b02e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x7c470
jmp 0x9b0e2
jmp 0x9b0ec
addq $0x138, %rsp            # imm = 0x138
retq
movq 0x28(%rsp), %rdi
callq 0x7b550
movq %rax, %rdi
callq 0x88ef0
nop
// File: zeeev[P]DASVC/bamtools/src/api/SamSequenceDictionary.cpp
// Function: BamTools::SamSequenceDictionary::Remove(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void SamSequenceDictionary::Remove(const std::string& sequenceName) {

    // skip if empty dictionary or if name unknown
    if ( IsEmpty() || !Contains(sequenceName) )
        return;

    // update 'lookup index' for every entry after @sequenceName
    const size_t indexToRemove = m_lookupData[sequenceName];
    const size_t numEntries = m_data.size();
    for ( size_t i = indexToRemove+1; i < numEntries; ++i ) {
        const SamSequence& sq = m_data.at(i);
        --m_lookupData[sq.Name];
    }

    // erase entry from containers
    m_data.erase( Begin() + indexToRemove );
    m_lookupData.erase(sequenceName);
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x7b840
testb $0x1, %al
jne 0x9b2b4
movq 0x8(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x750d0
testb $0x1, %al
jne 0x9b2b9
jmp 0x9b38c
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
movq 0x48(%rsp), %rsi
callq 0x7b520
movq 0x8(%rsp), %rdi
movq (%rax), %rax
movq %rax, 0x40(%rsp)
callq 0x71700
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
cmpq 0x38(%rsp), %rax
jae 0x9b342
movq 0x8(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x745f0
movq 0x8(%rsp), %rdi
movq %rax, 0x28(%rsp)
addq $0x18, %rdi
movq 0x28(%rsp), %rsi
addq $0x60, %rsi
callq 0x7b520
movq (%rax), %rcx
addq $-0x1, %rcx
movq %rcx, (%rax)
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x9b2f1
movq 0x8(%rsp), %rdi
callq 0x76a20
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rsi
leaq 0x18(%rsp), %rdi
callq 0x782b0
movq 0x8(%rsp), %rdi
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rsi
callq 0x77120
movq 0x8(%rsp), %rdi
movq %rax, 0x10(%rsp)
addq $0x18, %rdi
movq 0x48(%rsp), %rsi
callq 0x7caf0
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/api/SamSequenceDictionary.cpp
// Function: BamTools::SamSequenceDictionary::Remove(std::vector<BamTools::SamSequence, std::allocator<BamTools::SamSequence>> const&)
void SamSequenceDictionary::Remove(const std::vector<SamSequence>& sequences) {
    vector<SamSequence>::const_iterator rgIter = sequences.begin();
    vector<SamSequence>::const_iterator rgEnd  = sequences.end();
    for ( ; rgIter!= rgEnd; ++rgIter )
        Remove(*rgIter);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
callq 0x74a60
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x7acc0
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x75e90
testb $0x1, %al
jne 0x9b3ea
jmp 0x9b40c
leaq 0x10(%rsp), %rdi
callq 0x767c0
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x7c250
leaq 0x10(%rsp), %rdi
callq 0x76200
jmp 0x9b3d5
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/api/SamSequenceDictionary.cpp
// Function: BamTools::SamSequenceDictionary::Remove(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
void SamSequenceDictionary::Remove(const std::vector<std::string>& sequenceNames) {
    vector<string>::const_iterator rgIter = sequenceNames.begin();
    vector<string>::const_iterator rgEnd  = sequenceNames.end();
    for ( ; rgIter!= rgEnd; ++rgIter )
        Remove(*rgIter);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
callq 0x71c40
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x74ae0
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x750f0
testb $0x1, %al
jne 0x9b46a
jmp 0x9b48c
leaq 0x10(%rsp), %rdi
callq 0x71410
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x77190
leaq 0x10(%rsp), %rdi
callq 0x75880
jmp 0x9b455
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/api/SamSequenceDictionary.cpp
// Function: BamTools::SamSequenceDictionary::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
SamSequence& SamSequenceDictionary::operator[](const std::string& sequenceName) {

    if ( !Contains(sequenceName) ) {
        SamSequence seq(sequenceName, 0);
        m_data.push_back(seq);
        m_lookupData[sequenceName] = m_data.size() - 1;
    }

    const size_t index = m_lookupData[sequenceName];
    return m_data.at(index);
}

// Assembly:
subq $0x138, %rsp            # imm = 0x138
movq %rdi, 0x130(%rsp)
movq %rsi, 0x128(%rsp)
movq 0x130(%rsp), %rdi
movq %rdi, 0x28(%rsp)
movq 0x128(%rsp), %rsi
callq 0x750d0
testb $0x1, %al
jne 0x9b58e
movq 0x128(%rsp), %rsi
movl $0x0, 0x4c(%rsp)
leaq 0x50(%rsp), %rdi
movq %rdi, 0x20(%rsp)
leaq 0x4c(%rsp), %rdx
callq 0x76350
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x74160
jmp 0x9b51e
movq 0x28(%rsp), %rdi
callq 0x71700
movq %rax, 0x18(%rsp)
jmp 0x9b52f
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rax
decq %rax
movq %rax, 0x8(%rsp)
addq $0x18, %rdi
movq 0x128(%rsp), %rsi
callq 0x7b520
movq %rax, 0x10(%rsp)
jmp 0x9b559
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, (%rax)
leaq 0x50(%rsp), %rdi
callq 0x7c470
jmp 0x9b58e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x7c470
jmp 0x9b58c
jmp 0x9b5c3
movq 0x28(%rsp), %rdi
addq $0x18, %rdi
movq 0x128(%rsp), %rsi
callq 0x7b520
movq 0x28(%rsp), %rdi
movq (%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rsi
callq 0x745f0
addq $0x138, %rsp            # imm = 0x138
retq
movq 0x40(%rsp), %rdi
callq 0x7b550
movq %rax, %rdi
callq 0x88ef0
nopw %cs:(%rax,%rax)
nop
// File: zeeev[P]DASVC/bamtools/src/api/internal/bam/BamHeader_p.cpp
// Function: BamTools::Internal::BamHeader::Load(BamTools::Internal::BgzfStream*)
void BamHeader::Load(BgzfStream* stream) {

    // read & check magic number
    CheckMagicNumber(stream);

    // read header (length, then actual text)
    uint32_t length(0);
    ReadHeaderLength(stream, length);
    ReadHeaderText(stream, length);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x18(%rsp), %rsi
callq 0x725f0
movq 0x8(%rsp), %rdi
movl $0x0, 0x14(%rsp)
movq 0x18(%rsp), %rsi
leaq 0x14(%rsp), %rdx
callq 0x7a270
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
leaq 0x14(%rsp), %rdx
callq 0x71c10
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/api/internal/bam/BamHeader_p.cpp
// Function: BamTools::Internal::BamHeader::ReadHeaderLength(BamTools::Internal::BgzfStream*, unsigned int&)
void BamHeader::ReadHeaderLength(BgzfStream* stream, uint32_t& length) {

    // read BAM header text length
    char buffer[sizeof(uint32_t)];
    const size_t numBytesRead = stream->Read(buffer, sizeof(uint32_t));
    if ( numBytesRead != sizeof(uint32_t) )
        throw BamException("BamHeader::ReadHeaderLength", "could not read header length");

    // convert char buffer to length
    length = BamTools::UnpackUnsignedInt(buffer);
    if ( BamTools::SystemIsBigEndian() )
        BamTools::SwapEndian_32(length);
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq 0x98(%rsp), %rdi
leaq 0x8c(%rsp), %rsi
movl $0x4, %edx
callq 0x79a30
movq %rax, 0x80(%rsp)
cmpq $0x4, 0x80(%rsp)
je 0x9d5cd
movb $0x1, 0x26(%rsp)
movl $0x28, %edi
callq 0x737c0
movq %rax, 0x10(%rsp)
leaq 0x5f(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x7b5f0
movq 0x18(%rsp), %rdx
leaq 0x4d0c8(%rip), %rsi     # 0xea5b7
leaq 0x60(%rsp), %rdi
callq 0x78e70
jmp 0x9d4fb
leaq 0x27(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x7b5f0
movq 0x8(%rsp), %rdx
leaq 0x4d0bd(%rip), %rsi     # 0xea5d3
leaq 0x28(%rsp), %rdi
callq 0x78e70
jmp 0x9d522
movq 0x10(%rsp), %rdi
leaq 0x60(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x79cd0
jmp 0x9d538
movq 0x10(%rsp), %rdi
movb $0x0, 0x26(%rsp)
movq 0x749c7(%rip), %rsi     # 0x111f10
movq 0x74a10(%rip), %rdx     # 0x111f60
callq 0x7b010
jmp 0x9d618
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x9d5ae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x9d596
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x7cce8
jmp 0x9d594
jmp 0x9d596
leaq 0x27(%rsp), %rdi
callq 0x76f80
leaq 0x60(%rsp), %rdi
callq 0x7cce8
jmp 0x9d5ac
jmp 0x9d5ae
leaq 0x5f(%rsp), %rdi
callq 0x76f80
testb $0x1, 0x26(%rsp)
jne 0x9d5c1
jmp 0x9d5cb
movq 0x10(%rsp), %rdi
callq 0x74e00
jmp 0x9d606
leaq 0x8c(%rsp), %rdi
callq 0x754e0
movl %eax, %ecx
movq 0x90(%rsp), %rax
movl %ecx, (%rax)
callq 0x744b0
testb $0x1, %al
jne 0x9d5f1
jmp 0x9d5fe
movq 0x90(%rsp), %rdi
callq 0x77400
addq $0xa8, %rsp
retq
movq 0x50(%rsp), %rdi
callq 0x7b550
movq %rax, %rdi
callq 0x88ef0
nopl (%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/api/BamAux.h
// Function: BamTools::UnpackUnsignedInt(char const*)
API_EXPORT inline unsigned int UnpackUnsignedInt(const char* buffer) {
    union { unsigned int value; unsigned char valueBuffer[sizeof(unsigned int)]; } un;
    un.value = 0;
    un.valueBuffer[0] = buffer[0];
    un.valueBuffer[1] = buffer[1];
    un.valueBuffer[2] = buffer[2];
    un.valueBuffer[3] = buffer[3];
    return un.value;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl $0x0, -0xc(%rsp)
movq -0x8(%rsp), %rax
movb (%rax), %al
movb %al, -0xc(%rsp)
movq -0x8(%rsp), %rax
movb 0x1(%rax), %al
movb %al, -0xb(%rsp)
movq -0x8(%rsp), %rax
movb 0x2(%rax), %al
movb %al, -0xa(%rsp)
movq -0x8(%rsp), %rax
movb 0x3(%rax), %al
movb %al, -0x9(%rsp)
movl -0xc(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/api/internal/bam/BamMultiReader_p.cpp
// Function: BamTools::Internal::BamMultiReaderPrivate::Close()
bool BamMultiReaderPrivate::Close(void) {

    m_errorString.clear();

    if ( CloseFiles(Filenames()) )
        return true;
    else {
        const string currentError = m_errorString;
        const string message = string("error encountered while closing all files: \n\t") + currentError;
        SetErrorString("BamMultiReader::Close", message);
        return false;
    }
}

// Assembly:
subq $0xe8, %rsp
movq %rdi, 0xd8(%rsp)
movq 0xd8(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x28, %rdi
callq 0x78800
movq 0x10(%rsp), %rsi
leaq 0xc0(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x78590
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x7bf80
movb %al, 0x26(%rsp)
jmp 0x9dca1
leaq 0xc0(%rsp), %rdi
callq 0x74e60
movb 0x26(%rsp), %al
testb $0x1, %al
jne 0x9dcb8
jmp 0x9dced
movb $0x1, 0xe7(%rsp)
jmp 0x9de8b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
leaq 0xc0(%rsp), %rdi
callq 0x74e60
jmp 0x9dce8
jmp 0x9de9c
movq 0x10(%rsp), %rsi
addq $0x28, %rsi
leaq 0x90(%rsp), %rdi
callq 0x73370
leaq 0x4f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x7b5f0
movq 0x8(%rsp), %rdx
leaq 0x4c90c(%rip), %rsi     # 0xea62a
leaq 0x50(%rsp), %rdi
callq 0x78e70
jmp 0x9dd2a
leaq 0x70(%rsp), %rdi
leaq 0x50(%rsp), %rsi
leaq 0x90(%rsp), %rdx
callq 0x7c720
jmp 0x9dd43
leaq 0x50(%rsp), %rdi
callq 0x7cce8
jmp 0x9dd4f
leaq 0x4f(%rsp), %rdi
callq 0x76f80
leaq 0x27(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x7b5f0
movq (%rsp), %rdx
leaq 0x4c8e6(%rip), %rsi     # 0xea658
leaq 0x28(%rsp), %rdi
callq 0x78e70
jmp 0x9dd7e
movq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x70(%rsp), %rdx
callq 0x77c30
jmp 0x9dd94
leaq 0x28(%rsp), %rdi
callq 0x7cce8
jmp 0x9dda0
leaq 0x27(%rsp), %rdi
callq 0x76f80
movb $0x0, 0xe7(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x7cce8
jmp 0x9de53
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
jmp 0x9ddf9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x7cce8
jmp 0x9ddf7
jmp 0x9ddf9
leaq 0x4f(%rsp), %rdi
callq 0x76f80
jmp 0x9de7a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
jmp 0x9de3d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x7cce8
jmp 0x9de3b
jmp 0x9de3d
leaq 0x27(%rsp), %rdi
callq 0x76f80
leaq 0x70(%rsp), %rdi
callq 0x7cce8
jmp 0x9de78
leaq 0x90(%rsp), %rdi
callq 0x7cce8
jmp 0x9de8b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xb8(%rsp)
movl %eax, 0xb4(%rsp)
jmp 0x9de7a
jmp 0x9de7a
leaq 0x90(%rsp), %rdi
callq 0x7cce8
jmp 0x9de89
jmp 0x9de9c
movb 0xe7(%rsp), %al
andb $0x1, %al
addq $0xe8, %rsp
retq
movq 0xb8(%rsp), %rdi
callq 0x7b550
movq %rax, %rdi
callq 0x88ef0
nopw %cs:(%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/api/internal/bam/BamMultiReader_p.cpp
// Function: BamTools::Internal::BamMultiReaderPrivate::Filenames[abi:cxx11]() const
const vector<string> BamMultiReaderPrivate::Filenames(void) const {

    // init filename container
    vector<string> filenames;
    filenames.reserve( m_readers.size() );

    // iterate over readers
    vector<MergeItem>::const_iterator itemIter = m_readers.begin();
    vector<MergeItem>::const_iterator itemEnd  = m_readers.end();
    for ( ; itemIter != itemEnd; ++itemIter ) {
        const MergeItem& item = (*itemIter);
        const BamReader* reader = item.Reader;
        if ( reader == 0 ) continue;

        // store filename if not empty
        const string& filename = reader->GetFilename();
        if ( !filename.empty() )
            filenames.push_back(filename);
    }

    // return result
    return filenames;
}

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0x38(%rsp)
movb $0x0, 0xa7(%rsp)
callq 0x7b6e0
movq 0x38(%rsp), %rdi
callq 0x79560
movq %rax, 0x40(%rsp)
jmp 0x9e2ff
movq 0x40(%rsp), %rsi
movq 0x28(%rsp), %rdi
callq 0x78130
jmp 0x9e310
movq 0x38(%rsp), %rdi
callq 0x7c190
movq %rax, 0x20(%rsp)
jmp 0x9e321
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rax
movq %rax, 0x88(%rsp)
callq 0x7a500
movq %rax, 0x18(%rsp)
jmp 0x9e33f
movq 0x18(%rsp), %rax
movq %rax, 0x80(%rsp)
leaq 0x88(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x732a0
movb %al, 0x17(%rsp)
jmp 0x9e367
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x9e374
jmp 0x9e451
leaq 0x88(%rsp), %rdi
callq 0x7aa50
movq %rax, 0x8(%rsp)
jmp 0x9e388
movq 0x8(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x78(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x70(%rsp)
cmpq $0x0, 0x70(%rsp)
jne 0x9e3c5
jmp 0x9e43b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0x9e47a
movq 0x70(%rsp), %rsi
leaq 0x48(%rsp), %rdi
callq 0x741b0
jmp 0x9e3d6
leaq 0x48(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rdi
callq 0x7aba0
movb %al, 0x7(%rsp)
jmp 0x9e3f0
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x9e42d
jmp 0x9e3fa
movq 0x28(%rsp), %rdi
movq 0x68(%rsp), %rsi
callq 0x73a70
jmp 0x9e40b
jmp 0x9e42d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x7cce8
jmp 0x9e44f
leaq 0x48(%rsp), %rdi
callq 0x7cce8
jmp 0x9e439
jmp 0x9e43b
leaq 0x88(%rsp), %rdi
callq 0x717c0
jmp 0x9e44a
jmp 0x9e34c
jmp 0x9e47a
movb $0x1, 0xa7(%rsp)
testb $0x1, 0xa7(%rsp)
jne 0x9e46d
movq 0x28(%rsp), %rdi
callq 0x74e60
movq 0x30(%rsp), %rax
addq $0xb8, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x74e60
jmp 0x9e486
jmp 0x9e488
movq 0x98(%rsp), %rdi
callq 0x7b550
movq %rax, %rdi
callq 0x88ef0
nopl (%rax)
// File: zeeev[P]DASVC/bamtools/src/api/internal/bam/BamMultiReader_p.cpp
// Function: BamTools::Internal::BamMultiReaderPrivate::GetHeaderText[abi:cxx11]() const
string BamMultiReaderPrivate::GetHeaderText(void) const {

    // N.B. - right now, simply copies all header data from first BAM,
    //        and then appends RG's from other BAM files
    // TODO: make this more intelligent wrt other header lines/fields

    // if no readers open
    const size_t numReaders = m_readers.size();
    if ( numReaders == 0 ) return string();

    // retrieve first reader's header
    const MergeItem& firstItem = m_readers.front();
    const BamReader* reader = firstItem.Reader;
    if ( reader == 0 ) return string();
    SamHeader mergedHeader = reader->GetHeader();

    // iterate over any remaining readers (skipping the first)
    for ( size_t i = 1; i < numReaders; ++i ) {
        const MergeItem& item = m_readers.at(i);
        const BamReader* reader = item.Reader;
        if ( reader == 0 ) continue;

        // retrieve current reader's header
        const SamHeader currentHeader = reader->GetHeader();

        // append current reader's RG entries to merged header
        // N.B. - SamReadGroupDictionary handles duplicate-checking
        mergedHeader.ReadGroups.Add(currentHeader.ReadGroups);

        // TODO: merge anything else??
    }

    // return stringified header
    return mergedHeader.ToString();
}

// Assembly:
subq $0x328, %rsp            # imm = 0x328
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x320(%rsp)
movq %rsi, 0x318(%rsp)
movq 0x318(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x79560
movq %rax, 0x310(%rsp)
cmpq $0x0, 0x310(%rsp)
jne 0x9f0d8
movq 0x10(%rsp), %rdi
callq 0x79100
jmp 0x9f255
movq 0x20(%rsp), %rdi
callq 0x74af0
movq %rax, 0x308(%rsp)
movq 0x308(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x300(%rsp)
cmpq $0x0, 0x300(%rsp)
jne 0x9f117
movq 0x10(%rsp), %rdi
callq 0x79100
jmp 0x9f255
movq 0x300(%rsp), %rsi
leaq 0x1a8(%rsp), %rdi
callq 0x78a30
movq $0x1, 0x1a0(%rsp)
movq 0x1a0(%rsp), %rax
cmpq 0x310(%rsp), %rax
jae 0x9f221
movq 0x20(%rsp), %rdi
movq 0x1a0(%rsp), %rsi
callq 0x74090
movq %rax, 0x8(%rsp)
jmp 0x9f167
movq 0x8(%rsp), %rax
movq %rax, 0x198(%rsp)
movq 0x198(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x180(%rsp)
cmpq $0x0, 0x180(%rsp)
jne 0x9f1ad
jmp 0x9f1e6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x190(%rsp)
movl %eax, 0x18c(%rsp)
jmp 0x9f244
movq 0x180(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0x78a30
jmp 0x9f1c1
leaq 0x268(%rsp), %rdi
leaq 0xe8(%rsp), %rsi
callq 0x7c1f0
jmp 0x9f1d8
leaq 0x28(%rsp), %rdi
callq 0x766b0
jmp 0x9f1e4
jmp 0x9f1e6
movq 0x1a0(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x1a0(%rsp)
jmp 0x9f138
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x190(%rsp)
movl %eax, 0x18c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x766b0
jmp 0x9f21f
jmp 0x9f244
movq 0x10(%rsp), %rdi
leaq 0x1a8(%rsp), %rsi
callq 0x7a090
jmp 0x9f235
leaq 0x1a8(%rsp), %rdi
callq 0x766b0
jmp 0x9f255
leaq 0x1a8(%rsp), %rdi
callq 0x766b0
jmp 0x9f253
jmp 0x9f262
movq 0x18(%rsp), %rax
addq $0x328, %rsp            # imm = 0x328
retq
movq 0x190(%rsp), %rdi
callq 0x7b550
movq %rax, %rdi
callq 0x88ef0
nopw (%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/api/internal/bam/BamMultiReader_p.cpp
// Function: BamTools::Internal::BamMultiReaderPrivate::PopNextCachedAlignment(BamTools::BamAlignment&, bool)
bool BamMultiReaderPrivate::PopNextCachedAlignment(BamAlignment& al, const bool needCharData) {

    // skip if no alignments available
    if ( m_alignmentCache == 0 || m_alignmentCache->IsEmpty() )
        return false;

    // pop next merge item entry from cache
    MergeItem item = m_alignmentCache->TakeFirst();
    BamReader* reader = item.Reader;
    BamAlignment* alignment = item.Alignment;
    if ( reader == 0 || alignment == 0 )
        return false;

    // set char data if requested
    if ( needCharData ) {
        alignment->BuildCharData();
        alignment->Filename = reader->GetFilename();
    }

    // store cached alignment into destination parameter (by copy)
    al = *alignment;

    // load next alignment from reader & store in cache
    SaveNextAlignment(reader, alignment);
    return true;
}

// Assembly:
subq $0x88, %rsp
movb %dl, %al
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
andb $0x1, %al
movb %al, 0x6f(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x18(%rax)
je 0x9f2ff
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
testb $0x1, %al
jne 0x9f2ff
jmp 0x9f30c
movb $0x0, 0x87(%rsp)
jmp 0x9f420
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rsi
movq (%rsi), %rax
leaq 0x58(%rsp), %rdi
callq *0x40(%rax)
movq 0x58(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x48(%rsp)
cmpq $0x0, 0x50(%rsp)
je 0x9f344
cmpq $0x0, 0x48(%rsp)
jne 0x9f359
movb $0x0, 0x87(%rsp)
movl $0x1, 0x44(%rsp)
jmp 0x9f406
testb $0x1, 0x6f(%rsp)
je 0x9f3cf
movq 0x48(%rsp), %rdi
callq 0x76980
jmp 0x9f36c
movq 0x50(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x741b0
jmp 0x9f37d
movq 0x48(%rsp), %rdi
addq $0xe0, %rdi
leaq 0x10(%rsp), %rsi
callq 0x71240
jmp 0x9f395
leaq 0x10(%rsp), %rdi
callq 0x7cce8
jmp 0x9f3a1
jmp 0x9f3cf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x9f412
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x7cce8
jmp 0x9f3cd
jmp 0x9f412
movq 0x48(%rsp), %rsi
movq 0x70(%rsp), %rdi
callq 0x74150
jmp 0x9f3e0
movq 0x8(%rsp), %rdi
movq 0x50(%rsp), %rsi
movq 0x48(%rsp), %rdx
callq 0x75480
jmp 0x9f3f6
movb $0x1, 0x87(%rsp)
movl $0x1, 0x44(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x7bb70
jmp 0x9f420
leaq 0x58(%rsp), %rdi
callq 0x7bb70
jmp 0x9f41e
jmp 0x9f431
movb 0x87(%rsp), %al
andb $0x1, %al
addq $0x88, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x7b550
movq %rax, %rdi
callq 0x88ef0
nopw %cs:(%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/api/internal/bam/BamMultiReader_p.cpp
// Function: BamTools::Internal::BamMultiReaderPrivate::GetReferenceCount() const
int BamMultiReaderPrivate::GetReferenceCount(void) const {

    // handle empty multireader
    if ( m_readers.empty() ) return 0;

    // return reference count from first reader
    const MergeItem& item = m_readers.front();
    const BamReader* reader = item.Reader;
    if ( reader == 0 ) return 0;
    else
        return reader->GetReferenceCount();
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x764e0
testb $0x1, %al
jne 0x9f49d
jmp 0x9f4a7
movl $0x0, 0x24(%rsp)
jmp 0x9f4e2
movq (%rsp), %rdi
callq 0x74af0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x9f4d4
movl $0x0, 0x24(%rsp)
jmp 0x9f4e2
movq 0x8(%rsp), %rdi
callq 0x73420
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/api/internal/bam/BamMultiReader_p.cpp
// Function: BamTools::Internal::BamMultiReaderPrivate::GetReferenceData() const
const RefVector BamMultiReaderPrivate::GetReferenceData(void) const {

    // handle empty multireader
    if ( m_readers.empty() ) return RefVector();

    // return reference data from first BamReader
    const MergeItem& item = m_readers.front();
    const BamReader* reader = item.Reader;
    if ( reader == 0 ) return RefVector();
    else
        return reader->GetReferenceData();
}

// Assembly:
subq $0x38, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x764e0
testb $0x1, %al
jne 0x9f51f
jmp 0x9f52a
movq (%rsp), %rdi
callq 0x77fb0
jmp 0x9f56f
movq 0x10(%rsp), %rdi
callq 0x74af0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x9f559
movq (%rsp), %rdi
callq 0x77fb0
jmp 0x9f56f
movq 0x18(%rsp), %rdi
callq 0x713d0
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x7ae00
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: zeeev[P]DASVC/bamtools/src/api/internal/bam/BamMultiReader_p.cpp
// Function: BamTools::Internal::BamMultiReaderPrivate::GetReferenceID(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
int BamMultiReaderPrivate::GetReferenceID(const string& refName) const {

    // handle empty multireader
    if ( m_readers.empty() ) return -1;

    // return reference ID from first BamReader
    const MergeItem& item = m_readers.front();
    const BamReader* reader = item.Reader;
    if ( reader == 0 ) return -1;
    else
        return reader->GetReferenceID(refName);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x764e0
testb $0x1, %al
jne 0x9f5a3
jmp 0x9f5ad
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x9f5ee
movq 0x8(%rsp), %rdi
callq 0x74af0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x9f5db
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x9f5ee
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x733d0
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/api/internal/bam/BamMultiReader_p.cpp
// Function: BamTools::Internal::BamMultiReaderPrivate::HasIndexes() const
bool BamMultiReaderPrivate::HasIndexes(void) const {

    // handle empty multireader
    if ( m_readers.empty() )
        return false;

    bool result = true;

    // iterate over readers
    vector<MergeItem>::const_iterator readerIter = m_readers.begin();
    vector<MergeItem>::const_iterator readerEnd  = m_readers.end();
    for ( ; readerIter != readerEnd; ++readerIter ) {
        const MergeItem& item = (*readerIter);
        const BamReader* reader = item.Reader;
        if ( reader  == 0 ) continue;

        // see if current reader has index data
        result &= reader->HasIndex();
    }

    return result;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x764e0
testb $0x1, %al
jne 0x9f61e
jmp 0x9f628
movb $0x0, 0x47(%rsp)
jmp 0x9f6c2
movq 0x8(%rsp), %rdi
movb $0x1, 0x37(%rsp)
callq 0x7c190
movq 0x8(%rsp), %rdi
movq %rax, 0x28(%rsp)
callq 0x7a500
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x732a0
testb $0x1, %al
jne 0x9f660
jmp 0x9f6b8
leaq 0x28(%rsp), %rdi
callq 0x7aa50
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x9f686
jmp 0x9f6ac
movq 0x10(%rsp), %rdi
callq 0x71900
andb $0x1, %al
movzbl %al, %ecx
movb 0x37(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
andl %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, 0x37(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x717c0
jmp 0x9f64b
movb 0x37(%rsp), %al
andb $0x1, %al
movb %al, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopl (%rax)
// File: zeeev[P]DASVC/bamtools/src/api/internal/bam/BamMultiReader_p.cpp
// Function: BamTools::Internal::BamMultiReaderPrivate::HasOpenReaders()
bool BamMultiReaderPrivate::HasOpenReaders(void) {

    // iterate over readers
    vector<MergeItem>::const_iterator readerIter = m_readers.begin();
    vector<MergeItem>::const_iterator readerEnd  = m_readers.end();
    for ( ; readerIter != readerEnd; ++readerIter ) {
        const MergeItem& item = (*readerIter);
        const BamReader* reader = item.Reader;
        if ( reader == 0 ) continue;

        // return true whenever an open reader is found
        if ( reader->IsOpen() ) return true;
    }

    // no readers open
    return false;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x73770
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x7b230
movq (%rsp), %rdi
callq 0x74890
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x7b230
leaq 0x30(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x732a0
testb $0x1, %al
jne 0x9f72d
jmp 0x9f778
leaq 0x30(%rsp), %rdi
callq 0x7aa50
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x9f753
jmp 0x9f76c
movq 0x8(%rsp), %rdi
callq 0x79950
testb $0x1, %al
jne 0x9f763
jmp 0x9f76a
movb $0x1, 0x47(%rsp)
jmp 0x9f77d
jmp 0x9f76c
leaq 0x30(%rsp), %rdi
callq 0x717c0
jmp 0x9f718
movb $0x0, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/api/internal/bam/BamMultiReader_p.cpp
// Function: BamTools::Internal::BamMultiReaderPrivate::Jump(int, int)
bool BamMultiReaderPrivate::Jump(int refID, int position) {

    // NB: While it may make sense to track readers in which we can
    // successfully Jump, in practice a failure of Jump means "no
    // alignments here."  It makes sense to simply accept the failure,
    // UpdateAlignments(), and continue.

    // iterate over readers
    vector<MergeItem>::iterator readerIter = m_readers.begin();
    vector<MergeItem>::iterator readerEnd  = m_readers.end();
    for ( ; readerIter != readerEnd; ++readerIter ) {
        MergeItem& item = (*readerIter);
        BamReader* reader = item.Reader;
        if ( reader == 0 ) continue;

        // jump in each BamReader to position of interest
        reader->Jump(refID, position);
    }

    // returns status of cache update
    return UpdateAlignmentCache();
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl %edx, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x73770
movq (%rsp), %rdi
movq %rax, 0x20(%rsp)
callq 0x74890
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x74d10
testb $0x1, %al
jne 0x9f7d7
jmp 0x9f81b
leaq 0x20(%rsp), %rdi
callq 0x762d0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x9f7fd
jmp 0x9f80f
movq 0x8(%rsp), %rdi
movl 0x2c(%rsp), %esi
movl 0x28(%rsp), %edx
callq 0x72600
leaq 0x20(%rsp), %rdi
callq 0x74ed0
jmp 0x9f7c2
movq (%rsp), %rdi
callq 0x710d0
andb $0x1, %al
addq $0x38, %rsp
retq
nopl (%rax,%rax)