LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: zeeev[P]DASVC/bamtools/src/api/internal/bam/BamMultiReader_p.cpp
// Function: BamTools::Internal::BamMultiReaderPrivate::Rewind()
bool BamMultiReaderPrivate::Rewind(void) {

    // skip if no readers open
    if ( m_readers.empty() )
        return true;

    // attempt to rewind files
    if ( !RewindReaders() ) {
        const string currentError = m_errorString;
        const string message = string("could not rewind readers: \n\t") + currentError;
        SetErrorString("BamMultiReader::Rewind", message);
        return false;
    }

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

// Assembly:
subq $0xc8, %rsp
movq %rdi, 0xb8(%rsp)
movq 0xb8(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x764e0
testb $0x1, %al
jne 0xa07d7
jmp 0xa07e4
movb $0x1, 0xc7(%rsp)
jmp 0xa0986
movq 0x10(%rsp), %rdi
callq 0x7bea0
testb $0x1, %al
jne 0xa0973
movq 0x10(%rsp), %rsi
addq $0x28, %rsi
leaq 0x98(%rsp), %rdi
callq 0x73370
leaq 0x57(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x7b5f0
movq 0x8(%rsp), %rdx
leaq 0x4a040(%rip), %rsi     # 0xea867
leaq 0x58(%rsp), %rdi
callq 0x78e70
jmp 0xa0833
leaq 0x78(%rsp), %rdi
leaq 0x58(%rsp), %rsi
leaq 0x98(%rsp), %rdx
callq 0x7c720
jmp 0xa084c
leaq 0x58(%rsp), %rdi
callq 0x7cce8
jmp 0xa0858
leaq 0x57(%rsp), %rdi
callq 0x76f80
leaq 0x1f(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x7b5f0
movq (%rsp), %rdx
leaq 0x4a009(%rip), %rsi     # 0xea884
leaq 0x20(%rsp), %rdi
callq 0x78e70
jmp 0xa0887
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rsi
leaq 0x78(%rsp), %rdx
callq 0x77c30
jmp 0xa089d
leaq 0x20(%rsp), %rdi
callq 0x7cce8
jmp 0xa08a9
leaq 0x1f(%rsp), %rdi
callq 0x76f80
movb $0x0, 0xc7(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x7cce8
jmp 0xa0941
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0xa08f3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x7cce8
jmp 0xa08f1
jmp 0xa08f3
leaq 0x57(%rsp), %rdi
callq 0x76f80
jmp 0xa0962
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0xa092b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x7cce8
jmp 0xa0929
jmp 0xa092b
leaq 0x1f(%rsp), %rdi
callq 0x76f80
leaq 0x78(%rsp), %rdi
callq 0x7cce8
jmp 0xa0960
leaq 0x98(%rsp), %rdi
callq 0x7cce8
jmp 0xa0986
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0xa0962
jmp 0xa0962
leaq 0x98(%rsp), %rdi
callq 0x7cce8
jmp 0xa0971
jmp 0xa0997
movq 0x10(%rsp), %rdi
callq 0x710d0
andb $0x1, %al
movb %al, 0xc7(%rsp)
movb 0xc7(%rsp), %al
andb $0x1, %al
addq $0xc8, %rsp
retq
movq 0x48(%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::SaveNextAlignment(BamTools::BamReader*, BamTools::BamAlignment*)
void BamMultiReaderPrivate::SaveNextAlignment(BamReader* reader, BamAlignment* alignment) {

    // if can read alignment from reader, store in cache
    //
    // N.B. - lazy building of alignment's char data - populated only:
    //        automatically by alignment cache to maintain its sorting OR
    //        on demand from client call to future call to GetNextAlignment()

    if ( reader->GetNextAlignmentCore(*alignment) )
        m_alignmentCache->Add( MergeItem(reader, alignment) );
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x7aa30
testb $0x1, %al
jne 0xa24d2
jmp 0xa2536
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %rdx
leaq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x71910
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
jmp 0xa250e
leaq 0x30(%rsp), %rdi
callq 0x7bb70
jmp 0xa2536
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x7bb70
jmp 0xa2534
jmp 0xa253b
addq $0x58, %rsp
retq
movq 0x28(%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::RewindReaders()
bool BamMultiReaderPrivate::RewindReaders(void) {

    m_errorString.clear();
    bool errorsEncountered = false;

    // 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;

        // attempt rewind on BamReader
        if ( !reader->Rewind() ) {
            m_errorString.append(1, '\t');
            m_errorString.append( reader->GetErrorString() );
            m_errorString.append(1, '\n');
            errorsEncountered = true;
        }
    }

    return !errorsEncountered;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x28, %rdi
callq 0x78800
movq 0x10(%rsp), %rdi
movb $0x0, 0x6f(%rsp)
callq 0x73770
movq 0x10(%rsp), %rdi
movq %rax, 0x60(%rsp)
callq 0x74890
movq %rax, 0x58(%rsp)
leaq 0x60(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x74d10
testb $0x1, %al
jne 0xa25a7
jmp 0xa2678
leaq 0x60(%rsp), %rdi
callq 0x762d0
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x48(%rsp)
cmpq $0x0, 0x48(%rsp)
jne 0xa25d0
jmp 0xa2669
movq 0x48(%rsp), %rdi
callq 0x7be40
testb $0x1, %al
jne 0xa2667
movq 0x10(%rsp), %rdi
addq $0x28, %rdi
movq %rdi, (%rsp)
movl $0x1, %esi
movl $0x9, %edx
callq 0x76f60
movq 0x48(%rsp), %rsi
leaq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x74350
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x7c8b0
jmp 0xa2622
leaq 0x28(%rsp), %rdi
callq 0x7cce8
movq 0x10(%rsp), %rdi
addq $0x28, %rdi
movl $0x1, %esi
movl $0xa, %edx
callq 0x76f60
movb $0x1, 0x6f(%rsp)
jmp 0xa2667
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x7cce8
jmp 0xa2665
jmp 0xa2685
jmp 0xa2669
leaq 0x60(%rsp), %rdi
callq 0x74ed0
jmp 0xa258f
movb 0x6f(%rsp), %al
xorb $-0x1, %al
andb $0x1, %al
addq $0x78, %rsp
retq
movq 0x20(%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::SetRegion(BamTools::BamRegion const&)
bool BamMultiReaderPrivate::SetRegion(const BamRegion& region) {

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

    // iterate over alignments
    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;

        // set region of interest
        reader->SetRegion(region);
    }

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

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 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 0xa2b14
jmp 0xa2b55
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 0xa2b3a
jmp 0xa2b49
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x730a0
leaq 0x20(%rsp), %rdi
callq 0x74ed0
jmp 0xa2aff
movq (%rsp), %rdi
callq 0x710d0
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: zeeev[P]DASVC/bamtools/src/api/internal/bam/BamMultiMerger_p.h
// Function: BamTools::Internal::MultiMerger<BamTools::Algorithms::Sort::ByPosition>::Add(BamTools::Internal::MergeItem)
inline void MultiMerger<Compare>::Add(MergeItem item) {

    // N.B. - any future custom Compare types must define this method
    //        see algorithms/Sort.h

    if ( CompareType::UsesCharData() )
        item.Alignment->BuildCharData();
    m_data.insert(item);
}

// Assembly:
subq $0x28, %rsp
movq %rsi, (%rsp)
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x72020
testb $0x1, %al
jne 0xa4dc7
jmp 0xa4dd4
movq (%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x76980
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
callq 0x78e60
movq %rax, 0x10(%rsp)
addq $0x28, %rsp
retq
// File: zeeev[P]DASVC/bamtools/src/api/internal/bam/BamMultiMerger_p.h
// Function: BamTools::Internal::MultiMerger<BamTools::Algorithms::Sort::ByPosition>::Remove(BamTools::BamReader*)
inline void MultiMerger<Compare>::Remove(BamReader* reader) {

    if ( reader == 0 ) return;
    const std::string& filenameToRemove = reader->GetFilename();

    // iterate over readers in cache
    DataIterator dataIter = m_data.begin();
    DataIterator dataEnd  = m_data.end();
    for ( ; dataIter != dataEnd; ++dataIter ) {
        const MergeItem& item = (*dataIter);
        const BamReader* itemReader = item.Reader;
        if ( itemReader == 0 ) continue;

        // remove iterator on match
        if ( itemReader->GetFilename() == filenameToRemove ) {
            m_data.erase(dataIter);
            return;
        }
    }
}

// Assembly:
subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq 0xc0(%rsp), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, 0xb8(%rsp)
jne 0xa4ea4
jmp 0xa5028
movq 0xb8(%rsp), %rsi
leaq 0x90(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x741b0
movq 0x18(%rsp), %rax
movq 0x28(%rsp), %rdi
movq %rax, 0xb0(%rsp)
addq $0x8, %rdi
callq 0x7a050
movq %rax, 0x20(%rsp)
jmp 0xa4ee0
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rax
movq %rax, 0x88(%rsp)
addq $0x8, %rdi
callq 0x73740
movq %rax, 0x10(%rsp)
jmp 0xa4f02
movq 0x10(%rsp), %rax
movq %rax, 0x70(%rsp)
leaq 0x88(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x7bcc0
movb %al, 0xf(%rsp)
jmp 0xa4f24
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0xa4f31
jmp 0xa5013
leaq 0x88(%rsp), %rdi
callq 0x729d0
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x60(%rsp)
cmpq $0x0, 0x60(%rsp)
jne 0xa4f73
jmp 0xa4fff
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
jmp 0xa5030
movq 0x60(%rsp), %rsi
leaq 0x40(%rsp), %rdi
callq 0x741b0
jmp 0xa4f84
movq 0xb0(%rsp), %rsi
leaq 0x40(%rsp), %rdi
callq 0x74120
movb %al, 0xe(%rsp)
jmp 0xa4f9c
leaq 0x40(%rsp), %rdi
callq 0x7cce8
jmp 0xa4fa8
movb 0xe(%rsp), %al
testb $0x1, %al
jne 0xa4fb2
jmp 0xa4ffd
movq 0x28(%rsp), %rdi
addq $0x8, %rdi
movq 0x88(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rsi
callq 0x79420
jmp 0xa4fd4
movl $0x1, 0x34(%rsp)
jmp 0xa501b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x7cce8
jmp 0xa4ffb
jmp 0xa5030
jmp 0xa4fff
leaq 0x88(%rsp), %rdi
callq 0x75990
jmp 0xa500e
jmp 0xa4f0c
movl $0x0, 0x34(%rsp)
leaq 0x90(%rsp), %rdi
callq 0x7cce8
addq $0xc8, %rsp
retq
leaq 0x90(%rsp), %rdi
callq 0x7cce8
jmp 0xa503f
jmp 0xa5041
movq 0x80(%rsp), %rdi
callq 0x7b550
movq %rax, %rdi
callq 0x88ef0
nopw %cs:(%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/api/internal/bam/BamMultiMerger_p.h
// Function: BamTools::Internal::MultiMerger<BamTools::Algorithms::Sort::ByPosition>::TakeFirst()
inline MergeItem MultiMerger<Compare>::TakeFirst(void) {
    DataIterator firstIter = m_data.begin();
    MergeItem    firstItem = (*firstIter);
    m_data.erase(firstIter);
    return firstItem;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x48(%rsp), %rdi
addq $0x8, %rdi
movq %rdi, 0x18(%rsp)
callq 0x7a050
movq %rax, 0x40(%rsp)
movb $0x0, 0x3f(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x729d0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x79cc0
movq 0x18(%rsp), %rdi
movq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rsi
callq 0x79420
jmp 0xa50ea
movb $0x1, 0x3f(%rsp)
testb $0x1, 0x3f(%rsp)
jne 0xa511c
jmp 0xa5112
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x7bb70
jmp 0xa5126
movq 0x10(%rsp), %rdi
callq 0x7bb70
movq 0x8(%rsp), %rax
addq $0x58, %rsp
retq
jmp 0xa5128
movq 0x28(%rsp), %rdi
callq 0x7b550
movq %rax, %rdi
callq 0x88ef0
nopw (%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/api/algorithms/Sort.h
// Function: BamTools::Algorithms::Sort::ByPosition::operator()(BamTools::BamAlignment const&, BamTools::BamAlignment const&)
bool operator()(const BamTools::BamAlignment& lhs, const BamTools::BamAlignment& rhs) {

            // force unmapped aligmnents to end
            if ( lhs.RefID == -1 ) return false;
            if ( rhs.RefID == -1 ) return true;

            // if on same reference, sort on position
            if ( lhs.RefID == rhs.RefID )
                return sort_helper(m_order, lhs.Position, rhs.Position);

            // otherwise sort on reference ID
            return sort_helper(m_order, lhs.RefID, rhs.RefID);
        }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
cmpl $-0x1, 0xa8(%rax)
jne 0xa59d1
movb $0x0, 0x27(%rsp)
jmp 0xa5a4e
movq 0x8(%rsp), %rax
cmpl $-0x1, 0xa8(%rax)
jne 0xa59e6
movb $0x1, 0x27(%rsp)
jmp 0xa5a4e
movq 0x10(%rsp), %rax
movl 0xa8(%rax), %eax
movq 0x8(%rsp), %rcx
cmpl 0xa8(%rcx), %eax
jne 0xa5a27
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
addq $0xac, %rsi
movq 0x8(%rsp), %rdx
addq $0xac, %rdx
callq 0x772f0
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0xa5a4e
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
addq $0xa8, %rsi
movq 0x8(%rsp), %rdx
addq $0xa8, %rdx
callq 0x772f0
andb $0x1, %al
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax)
// File: zeeev[P]DASVC/bamtools/src/api/algorithms/Sort.h
// Function: bool BamTools::Algorithms::Sort::sort_helper<int>(BamTools::Algorithms::Sort::Order const&, int const&, int const&)
static inline bool sort_helper(const Sort::Order& order, const ElemType& lhs, const ElemType& rhs) {
        switch ( order ) {
            case ( Sort::AscendingOrder  ) : { std::less<ElemType> comp;    return comp(lhs, rhs); }
            case ( Sort::DescendingOrder ) : { std::greater<ElemType> comp; return comp(lhs, rhs); }
            default : BT_ASSERT_UNREACHABLE;
        }
        return false; // <-- unreachable
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rax
movl (%rax), %eax
movl %eax, (%rsp)
testl %eax, %eax
je 0xa5a8d
jmp 0xa5a83
movl (%rsp), %eax
subl $0x1, %eax
je 0xa5aa9
jmp 0xa5ac5
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0x7(%rsp), %rdi
callq 0x79040
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0xa5acf
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0x6(%rsp), %rdi
callq 0x7c370
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0xa5acf
callq 0x761a0
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/api/internal/bam/BamRandomAccessController_p.cpp
// Function: BamTools::Internal::BamRandomAccessController::AdjustRegion(int const&)
void BamRandomAccessController::AdjustRegion(const int& referenceCount) {

    // skip if no index available
    if ( m_index == 0 )
        return;

    // see if any references in region have alignments
    m_hasAlignmentsInRegion = false;
    int currentId = m_region.LeftRefID;
    const int rightBoundRefId = ( m_region.isRightBoundSpecified() ? m_region.RightRefID : referenceCount - 1 );
    while ( currentId <= rightBoundRefId ) {
        m_hasAlignmentsInRegion = m_index->HasAlignments(currentId);
        if ( m_hasAlignmentsInRegion ) break;
        ++currentId;
    }

    // if no data found on any reference in region
    if ( !m_hasAlignmentsInRegion )
        return;

    // if left bound of desired region had no data, use first reference that had data
    // otherwise, leave requested region as-is
    if ( currentId != m_region.LeftRefID ) {
        m_region.LeftRefID = currentId;
        m_region.LeftPosition = 0;
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, (%rax)
jne 0xa8163
jmp 0xa8213
movq 0x8(%rsp), %rdi
movb $0x0, 0x18(%rdi)
movl 0x8(%rdi), %eax
movl %eax, 0x14(%rsp)
addq $0x8, %rdi
callq 0x77110
testb $0x1, %al
jne 0xa8182
jmp 0xa8190
movq 0x8(%rsp), %rax
movl 0x10(%rax), %eax
movl %eax, 0x4(%rsp)
jmp 0xa819e
movq 0x18(%rsp), %rax
movl (%rax), %eax
subl $0x1, %eax
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
movl %eax, 0x10(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x10(%rsp), %eax
jg 0xa81e5
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movq (%rdi), %rax
leaq 0x14(%rsp), %rsi
callq *0x18(%rax)
movb %al, %cl
movq 0x8(%rsp), %rax
andb $0x1, %cl
movb %cl, 0x18(%rax)
testb $0x1, 0x18(%rax)
je 0xa81d8
jmp 0xa81e5
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0xa81a6
movq 0x8(%rsp), %rax
testb $0x1, 0x18(%rax)
jne 0xa81f2
jmp 0xa8213
movq 0x8(%rsp), %rcx
movl 0x14(%rsp), %eax
cmpl 0x8(%rcx), %eax
je 0xa8213
movq 0x8(%rsp), %rax
movl 0x14(%rsp), %ecx
movl %ecx, 0x8(%rax)
movl $0x0, 0xc(%rax)
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/api/internal/bam/BamReader_p.cpp
// Function: BamTools::Internal::BamReaderPrivate::GetNextAlignment(BamTools::BamAlignment&)
bool BamReaderPrivate::GetNextAlignment(BamAlignment& alignment) {

    // if valid alignment found
    if ( GetNextAlignmentCore(alignment) ) {

        // store alignment's "source" filename
        alignment.Filename = m_filename;

        // return success/failure of parsing char data
        if ( alignment.BuildCharData() )
            return true;
        else {
            const string alError = alignment.GetErrorString();
            const string message = string("could not populate alignment data: \n\t") + alError;
            SetErrorString("BamReader::GetNextAlignment", message);
            return false;
        }
    }

    // no valid alignment found
    return false;
}

// Assembly:
subq $0xd8, %rsp
movq %rdi, 0xc8(%rsp)
movq %rsi, 0xc0(%rsp)
movq 0xc8(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movq 0xc0(%rsp), %rsi
callq 0x719a0
testb $0x1, %al
jne 0xaa59a
jmp 0xaa761
movq 0x18(%rsp), %rsi
addq $0x8, %rsi
movq 0xc0(%rsp), %rdi
addq $0xe0, %rdi
callq 0x71240
movq 0xc0(%rsp), %rdi
callq 0x76980
testb $0x1, %al
jne 0xaa5ca
jmp 0xaa5d7
movb $0x1, 0xd7(%rsp)
jmp 0xaa769
movq 0xc0(%rsp), %rsi
leaq 0xa0(%rsp), %rdi
callq 0x79ca0
leaq 0x5f(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x7b5f0
movq 0x10(%rsp), %rdx
leaq 0x406ad(%rip), %rsi     # 0xeacb4
leaq 0x60(%rsp), %rdi
callq 0x78e70
jmp 0xaa613
leaq 0x80(%rsp), %rdi
leaq 0x60(%rsp), %rsi
leaq 0xa0(%rsp), %rdx
callq 0x7c720
jmp 0xaa62f
leaq 0x60(%rsp), %rdi
callq 0x7cce8
jmp 0xaa63b
leaq 0x5f(%rsp), %rdi
callq 0x76f80
leaq 0x27(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x7b5f0
movq 0x8(%rsp), %rdx
leaq 0x4067a(%rip), %rsi     # 0xeacda
leaq 0x28(%rsp), %rdi
callq 0x78e70
jmp 0xaa66c
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x80(%rsp), %rdx
callq 0x774d0
jmp 0xaa685
leaq 0x28(%rsp), %rdi
callq 0x7cce8
jmp 0xaa691
leaq 0x27(%rsp), %rdi
callq 0x76f80
movb $0x0, 0xd7(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x7cce8
jmp 0xaa72f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0xaa6de
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x7cce8
jmp 0xaa6dc
jmp 0xaa6de
leaq 0x5f(%rsp), %rdi
callq 0x76f80
jmp 0xaa750
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0xaa716
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x7cce8
jmp 0xaa714
jmp 0xaa716
leaq 0x27(%rsp), %rdi
callq 0x76f80
leaq 0x80(%rsp), %rdi
callq 0x7cce8
jmp 0xaa74e
leaq 0xa0(%rsp), %rdi
callq 0x7cce8
jmp 0xaa769
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0xaa750
jmp 0xaa750
leaq 0xa0(%rsp), %rdi
callq 0x7cce8
jmp 0xaa75f
jmp 0xaa77a
movb $0x0, 0xd7(%rsp)
movb 0xd7(%rsp), %al
andb $0x1, %al
addq $0xd8, %rsp
retq
movq 0x50(%rsp), %rdi
callq 0x7b550
movq %rax, %rdi
callq 0x88ef0
nopl (%rax)
// File: zeeev[P]DASVC/bamtools/src/api/internal/bam/BamReader_p.cpp
// Function: BamTools::Internal::BamReaderPrivate::GetReferenceID(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
int BamReaderPrivate::GetReferenceID(const string& refName) const {

    // retrieve names from reference data
    vector<string> refNames;
    RefVector::const_iterator refIter = m_references.begin();
    RefVector::const_iterator refEnd  = m_references.end();
    for ( ; refIter != refEnd; ++refIter)
        refNames.push_back( (*refIter).RefName );

    // return 'index-of' refName (or -1 if not found)
    int index = distance(refNames.begin(), find(refNames.begin(), refNames.end(), refName));
    if ( index == (int)m_references.size() ) return -1;
    else return index;
}

// Assembly:
subq $0xe8, %rsp
movq %rdi, 0xd8(%rsp)
movq %rsi, 0xd0(%rsp)
movq 0xd8(%rsp), %rax
movq %rax, 0x58(%rsp)
leaq 0xb8(%rsp), %rdi
callq 0x7b6e0
movq 0x58(%rsp), %rdi
addq $0x28, %rdi
callq 0x71f60
movq %rax, 0x60(%rsp)
jmp 0xab096
movq 0x58(%rsp), %rdi
movq 0x60(%rsp), %rax
movq %rax, 0xb0(%rsp)
addq $0x28, %rdi
callq 0x77310
movq %rax, 0x50(%rsp)
jmp 0xab0b8
movq 0x50(%rsp), %rax
movq %rax, 0x98(%rsp)
leaq 0xb0(%rsp), %rdi
leaq 0x98(%rsp), %rsi
callq 0x78c70
movb %al, 0x4f(%rsp)
jmp 0xab0e0
movb 0x4f(%rsp), %al
testb $0x1, %al
jne 0xab0ea
jmp 0xab14b
leaq 0xb0(%rsp), %rdi
callq 0x74b80
movq %rax, 0x40(%rsp)
jmp 0xab0fe
movq 0x40(%rsp), %rsi
leaq 0xb8(%rsp), %rdi
callq 0x73a70
jmp 0xab112
jmp 0xab114
leaq 0xb0(%rsp), %rdi
callq 0x74d20
jmp 0xab123
jmp 0xab0c5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
leaq 0xb8(%rsp), %rdi
callq 0x74e60
jmp 0xab26f
leaq 0xb8(%rsp), %rdi
callq 0x7aa40
movq %rax, 0x38(%rsp)
jmp 0xab15f
movq 0x38(%rsp), %rax
movq %rax, 0x88(%rsp)
leaq 0xb8(%rsp), %rdi
callq 0x7aa40
movq %rax, 0x30(%rsp)
jmp 0xab180
movq 0x30(%rsp), %rax
movq %rax, 0x78(%rsp)
leaq 0xb8(%rsp), %rdi
callq 0x7ad60
movq %rax, 0x28(%rsp)
jmp 0xab19e
movq 0x28(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0xd0(%rsp), %rdx
movq 0x78(%rsp), %rdi
movq 0x70(%rsp), %rsi
callq 0x7a2d0
movq %rax, 0x20(%rsp)
jmp 0xab1c6
movq 0x20(%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0x88(%rsp), %rdi
movq 0x80(%rsp), %rsi
callq 0x7c1e0
movq %rax, 0x18(%rsp)
jmp 0xab1ef
movq 0x58(%rsp), %rdi
movq 0x18(%rsp), %rax
movl %eax, 0x94(%rsp)
movl 0x94(%rsp), %eax
movl %eax, 0xc(%rsp)
addq $0x28, %rdi
callq 0x71440
movq %rax, 0x10(%rsp)
jmp 0xab21b
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl %ecx, %eax
jne 0xab23d
movl $0xffffffff, 0xe4(%rsp) # imm = 0xFFFFFFFF
movl $0x1, 0x6c(%rsp)
jmp 0xab253
movl 0x94(%rsp), %eax
movl %eax, 0xe4(%rsp)
movl $0x1, 0x6c(%rsp)
leaq 0xb8(%rsp), %rdi
callq 0x74e60
movl 0xe4(%rsp), %eax
addq $0xe8, %rsp
retq
jmp 0xab271
movq 0xa8(%rsp), %rdi
callq 0x7b550
movq %rax, %rdi
callq 0x88ef0
nopw %cs:(%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/api/internal/bam/BamReader_p.cpp
// Function: BamTools::Internal::BamReaderPrivate::LocateIndex(BamTools::BamIndex::IndexType const&)
bool BamReaderPrivate::LocateIndex(const BamIndex::IndexType& preferredType) {

    if ( m_randomAccessController.LocateIndex(this, preferredType) )
        return true;
    else {
        const string bracError = m_randomAccessController.GetErrorString();
        const string message = string("could not locate index: \n\t") + bracError;
        SetErrorString("BamReader::LocateIndex", message);
        return false;
    }
}

// Assembly:
subq $0xd8, %rsp
movq %rdi, 0xc8(%rsp)
movq %rsi, 0xc0(%rsp)
movq 0xc8(%rsp), %rsi
movq %rsi, 0x18(%rsp)
movq %rsi, %rdi
addq $0x1a8, %rdi            # imm = 0x1A8
movq 0xc0(%rsp), %rdx
callq 0x79890
testb $0x1, %al
jne 0xab691
jmp 0xab69e
movb $0x1, 0xd7(%rsp)
jmp 0xab82c
movq 0x18(%rsp), %rsi
addq $0x1a8, %rsi            # imm = 0x1A8
leaq 0xa0(%rsp), %rdi
callq 0x7a020
leaq 0x5f(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x7b5f0
movq 0x10(%rsp), %rdx
leaq 0x3f67a(%rip), %rsi     # 0xead4c
leaq 0x60(%rsp), %rdi
callq 0x78e70
jmp 0xab6de
leaq 0x80(%rsp), %rdi
leaq 0x60(%rsp), %rsi
leaq 0xa0(%rsp), %rdx
callq 0x7c720
jmp 0xab6fa
leaq 0x60(%rsp), %rdi
callq 0x7cce8
jmp 0xab706
leaq 0x5f(%rsp), %rdi
callq 0x76f80
leaq 0x27(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x7b5f0
movq 0x8(%rsp), %rdx
leaq 0x3f63c(%rip), %rsi     # 0xead67
leaq 0x28(%rsp), %rdi
callq 0x78e70
jmp 0xab737
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x80(%rsp), %rdx
callq 0x774d0
jmp 0xab750
leaq 0x28(%rsp), %rdi
callq 0x7cce8
jmp 0xab75c
leaq 0x27(%rsp), %rdi
callq 0x76f80
movb $0x0, 0xd7(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x7cce8
jmp 0xab7fa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0xab7a9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x7cce8
jmp 0xab7a7
jmp 0xab7a9
leaq 0x5f(%rsp), %rdi
callq 0x76f80
jmp 0xab81b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0xab7e1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x7cce8
jmp 0xab7df
jmp 0xab7e1
leaq 0x27(%rsp), %rdi
callq 0x76f80
leaq 0x80(%rsp), %rdi
callq 0x7cce8
jmp 0xab819
leaq 0xa0(%rsp), %rdi
callq 0x7cce8
jmp 0xab82c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0xab81b
jmp 0xab81b
leaq 0xa0(%rsp), %rdi
callq 0x7cce8
jmp 0xab82a
jmp 0xab83d
movb 0xd7(%rsp), %al
andb $0x1, %al
addq $0xd8, %rsp
retq
movq 0x50(%rsp), %rdi
callq 0x7b550
movq %rax, %rdi
callq 0x88ef0
nop
// File: zeeev[P]DASVC/bamtools/src/api/internal/bam/BamReader_p.cpp
// Function: BamTools::Internal::BamReaderPrivate::OpenIndex(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool BamReaderPrivate::OpenIndex(const std::string& indexFilename) {

    if ( m_randomAccessController.OpenIndex(indexFilename, this) )
        return true;
    else {
        const string bracError = m_randomAccessController.GetErrorString();
        const string message = string("could not open index: \n\t") + bracError;
        SetErrorString("BamReader::OpenIndex", message);
        return false;
    }
}

// Assembly:
subq $0xd8, %rsp
movq %rdi, 0xc8(%rsp)
movq %rsi, 0xc0(%rsp)
movq 0xc8(%rsp), %rdx
movq %rdx, 0x18(%rsp)
movq %rdx, %rdi
addq $0x1a8, %rdi            # imm = 0x1A8
movq 0xc0(%rsp), %rsi
callq 0x75a70
testb $0x1, %al
jne 0xabc81
jmp 0xabc8e
movb $0x1, 0xd7(%rsp)
jmp 0xabe1c
movq 0x18(%rsp), %rsi
addq $0x1a8, %rsi            # imm = 0x1A8
leaq 0xa0(%rsp), %rdi
callq 0x7a020
leaq 0x5f(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x7b5f0
movq 0x10(%rsp), %rdx
leaq 0x3f0cc(%rip), %rsi     # 0xead8e
leaq 0x60(%rsp), %rdi
callq 0x78e70
jmp 0xabcce
leaq 0x80(%rsp), %rdi
leaq 0x60(%rsp), %rsi
leaq 0xa0(%rsp), %rdx
callq 0x7c720
jmp 0xabcea
leaq 0x60(%rsp), %rdi
callq 0x7cce8
jmp 0xabcf6
leaq 0x5f(%rsp), %rdi
callq 0x76f80
leaq 0x27(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x7b5f0
movq 0x8(%rsp), %rdx
leaq 0x3f08c(%rip), %rsi     # 0xeada7
leaq 0x28(%rsp), %rdi
callq 0x78e70
jmp 0xabd27
movq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x80(%rsp), %rdx
callq 0x774d0
jmp 0xabd40
leaq 0x28(%rsp), %rdi
callq 0x7cce8
jmp 0xabd4c
leaq 0x27(%rsp), %rdi
callq 0x76f80
movb $0x0, 0xd7(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x7cce8
jmp 0xabdea
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0xabd99
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x7cce8
jmp 0xabd97
jmp 0xabd99
leaq 0x5f(%rsp), %rdi
callq 0x76f80
jmp 0xabe0b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0xabdd1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x7cce8
jmp 0xabdcf
jmp 0xabdd1
leaq 0x27(%rsp), %rdi
callq 0x76f80
leaq 0x80(%rsp), %rdi
callq 0x7cce8
jmp 0xabe09
leaq 0xa0(%rsp), %rdi
callq 0x7cce8
jmp 0xabe1c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0xabe0b
jmp 0xabe0b
leaq 0xa0(%rsp), %rdi
callq 0x7cce8
jmp 0xabe1a
jmp 0xabe2d
movb 0xd7(%rsp), %al
andb $0x1, %al
addq $0xd8, %rsp
retq
movq 0x50(%rsp), %rdi
callq 0x7b550
movq %rax, %rdi
callq 0x88ef0
nop
// File: zeeev[P]DASVC/bamtools/src/api/internal/bam/BamReader_p.cpp
// Function: BamTools::Internal::BamReaderPrivate::Rewind()
bool BamReaderPrivate::Rewind(void) {

    // reset region
    m_randomAccessController.ClearRegion();

    // return status of seeking back to first alignment
    if ( Seek(m_alignmentsBeginOffset) )
        return true;
    else {
        const string currentError = m_errorString;
        const string message = string("could not rewind: \n\t") + currentError;
        SetErrorString("BamReader::Rewind", message);
        return false;
    }
}

// Assembly:
subq $0xc8, %rsp
movq %rdi, 0xb8(%rsp)
movq 0xb8(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x1a8, %rdi            # imm = 0x1A8
callq 0x765f0
movq 0x10(%rsp), %rsi
movq %rsi, %rdi
callq 0x76a30
testb $0x1, %al
jne 0xabe7b
jmp 0xabe88
movb $0x1, 0xc7(%rsp)
jmp 0xac008
movq 0x10(%rsp), %rsi
addq $0x228, %rsi            # imm = 0x228
leaq 0x98(%rsp), %rdi
callq 0x73370
leaq 0x57(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x7b5f0
movq 0x8(%rsp), %rdx
leaq 0x3ef00(%rip), %rsi     # 0xeadbc
leaq 0x58(%rsp), %rdi
callq 0x78e70
jmp 0xabec8
leaq 0x78(%rsp), %rdi
leaq 0x58(%rsp), %rsi
leaq 0x98(%rsp), %rdx
callq 0x7c720
jmp 0xabee1
leaq 0x58(%rsp), %rdi
callq 0x7cce8
jmp 0xabeed
leaq 0x57(%rsp), %rdi
callq 0x76f80
leaq 0x1f(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x7b5f0
movq (%rsp), %rdx
leaq 0x3eec1(%rip), %rsi     # 0xeadd1
leaq 0x20(%rsp), %rdi
callq 0x78e70
jmp 0xabf1c
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rsi
leaq 0x78(%rsp), %rdx
callq 0x774d0
jmp 0xabf32
leaq 0x20(%rsp), %rdi
callq 0x7cce8
jmp 0xabf3e
leaq 0x1f(%rsp), %rdi
callq 0x76f80
movb $0x0, 0xc7(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x7cce8
jmp 0xabfd6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0xabf88
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x7cce8
jmp 0xabf86
jmp 0xabf88
leaq 0x57(%rsp), %rdi
callq 0x76f80
jmp 0xabff7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0xabfc0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x7cce8
jmp 0xabfbe
jmp 0xabfc0
leaq 0x1f(%rsp), %rdi
callq 0x76f80
leaq 0x78(%rsp), %rdi
callq 0x7cce8
jmp 0xabff5
leaq 0x98(%rsp), %rdi
callq 0x7cce8
jmp 0xac008
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0xabff7
jmp 0xabff7
leaq 0x98(%rsp), %rdi
callq 0x7cce8
jmp 0xac006
jmp 0xac019
movb 0xc7(%rsp), %al
andb $0x1, %al
addq $0xc8, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x7b550
movq %rax, %rdi
callq 0x88ef0
nopl (%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/api/internal/bam/BamReader_p.cpp
// Function: BamTools::Internal::BamReaderPrivate::SetRegion(BamTools::BamRegion const&)
bool BamReaderPrivate::SetRegion(const BamRegion& region) {

    if ( m_randomAccessController.SetRegion(region, m_references.size()) )
        return true;
    else {
        const string bracError = m_randomAccessController.GetErrorString();
        const string message = string("could not set region: \n\t") + bracError;
        SetErrorString("BamReader::SetRegion", message);
        return false;
    }
}

// Assembly:
subq $0xe8, %rsp
movq %rdi, 0xd8(%rsp)
movq %rsi, 0xd0(%rsp)
movq 0xd8(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
addq $0x1a8, %rax            # imm = 0x1A8
movq %rax, 0x18(%rsp)
movq 0xd0(%rsp), %rax
movq %rax, 0x20(%rsp)
addq $0x28, %rdi
callq 0x71440
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl %eax, 0xcc(%rsp)
leaq 0xcc(%rsp), %rdx
callq 0x749c0
testb $0x1, %al
jne 0xac4fc
jmp 0xac509
movb $0x1, 0xe7(%rsp)
jmp 0xac695
movq 0x10(%rsp), %rsi
addq $0x1a8, %rsi            # imm = 0x1A8
leaq 0xa8(%rsp), %rdi
callq 0x7a020
leaq 0x67(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x7b5f0
movq 0x8(%rsp), %rdx
leaq 0x3e8f6(%rip), %rsi     # 0xeae33
leaq 0x68(%rsp), %rdi
callq 0x78e70
jmp 0xac549
leaq 0x88(%rsp), %rdi
leaq 0x68(%rsp), %rsi
leaq 0xa8(%rsp), %rdx
callq 0x7c720
jmp 0xac565
leaq 0x68(%rsp), %rdi
callq 0x7cce8
jmp 0xac571
leaq 0x67(%rsp), %rdi
callq 0x76f80
leaq 0x2f(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x7b5f0
movq (%rsp), %rdx
leaq 0x3e8b8(%rip), %rsi     # 0xeae4c
leaq 0x30(%rsp), %rdi
callq 0x78e70
jmp 0xac5a0
movq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x88(%rsp), %rdx
callq 0x774d0
jmp 0xac5b9
leaq 0x30(%rsp), %rdi
callq 0x7cce8
jmp 0xac5c5
leaq 0x2f(%rsp), %rdi
callq 0x76f80
movb $0x0, 0xe7(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x7cce8
jmp 0xac663
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0xac612
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x7cce8
jmp 0xac610
jmp 0xac612
leaq 0x67(%rsp), %rdi
callq 0x76f80
jmp 0xac684
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0xac64a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x7cce8
jmp 0xac648
jmp 0xac64a
leaq 0x2f(%rsp), %rdi
callq 0x76f80
leaq 0x88(%rsp), %rdi
callq 0x7cce8
jmp 0xac682
leaq 0xa8(%rsp), %rdi
callq 0x7cce8
jmp 0xac695
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0xac684
jmp 0xac684
leaq 0xa8(%rsp), %rdi
callq 0x7cce8
jmp 0xac693
jmp 0xac6a6
movb 0xe7(%rsp), %al
andb $0x1, %al
addq $0xe8, %rsp
retq
movq 0x58(%rsp), %rdi
callq 0x7b550
movq %rax, %rdi
callq 0x88ef0
nopl (%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/api/BamAux.h
// Function: BamTools::SwapEndian_32(int&)
API_EXPORT inline void SwapEndian_32(int32_t& x) {
    x = ( (x >> 24) | 
         ((x << 8) & 0x00FF0000) | 
         ((x >> 8) & 0x0000FF00) | 
          (x << 24)
        );
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movl (%rax), %ecx
sarl $0x18, %ecx
movq -0x8(%rsp), %rax
movl (%rax), %eax
shll $0x8, %eax
andl $0xff0000, %eax         # imm = 0xFF0000
orl %eax, %ecx
movq -0x8(%rsp), %rax
movl (%rax), %eax
sarl $0x8, %eax
andl $0xff00, %eax           # imm = 0xFF00
orl %eax, %ecx
movq -0x8(%rsp), %rax
movl (%rax), %eax
shll $0x18, %eax
orl %eax, %ecx
movq -0x8(%rsp), %rax
movl %ecx, (%rax)
retq
nopw %cs:(%rax,%rax)
nop
// File: zeeev[P]DASVC/bamtools/src/api/internal/bam/BamWriter_p.cpp
// Function: BamTools::Internal::BamWriterPrivate::Close()
void BamWriterPrivate::Close(void) {

    // skip if file not open
    if ( !IsOpen() ) return;

    // close output stream
    try {
        m_stream.Close();
    } catch ( BamException& e ) {
        m_errorString = e.what();
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x72ef0
testb $0x1, %al
jne 0xae2ad
jmp 0xae309
movq (%rsp), %rdi
callq 0x75340
jmp 0xae2b8
jmp 0xae309
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0xae325
movq 0x18(%rsp), %rdi
callq 0x72fc0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq (%rsp), %rdi
movq %rax, %rsi
addq $0x48, %rdi
callq 0x78d10
jmp 0xae304
callq 0x7a790
addq $0x28, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
callq 0x7a790
jmp 0xae323
jmp 0xae325
movq 0x18(%rsp), %rdi
callq 0x7b550
movq %rax, %rdi
callq 0x88ef0
nopw (%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/api/internal/bam/BamWriter_p.cpp
// Function: BamTools::Internal::BamWriterPrivate::CalculateMinimumBin(int, int) const
uint32_t BamWriterPrivate::CalculateMinimumBin(const int begin, int end) const {
    --end;
    if ( (begin >> 14) == (end >> 14) ) return 4681 + (begin >> 14);
    if ( (begin >> 17) == (end >> 17) ) return  585 + (begin >> 17);
    if ( (begin >> 20) == (end >> 20) ) return   73 + (begin >> 20);
    if ( (begin >> 23) == (end >> 23) ) return    9 + (begin >> 23);
    if ( (begin >> 26) == (end >> 26) ) return    1 + (begin >> 26);
    return 0;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
movl %edx, -0x18(%rsp)
movl -0x18(%rsp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rsp)
movl -0x14(%rsp), %eax
sarl $0xe, %eax
movl -0x18(%rsp), %ecx
sarl $0xe, %ecx
cmpl %ecx, %eax
jne 0xae37f
movl -0x14(%rsp), %eax
sarl $0xe, %eax
addl $0x1249, %eax           # imm = 0x1249
movl %eax, -0x4(%rsp)
jmp 0xae411
movl -0x14(%rsp), %eax
sarl $0x11, %eax
movl -0x18(%rsp), %ecx
sarl $0x11, %ecx
cmpl %ecx, %eax
jne 0xae3a3
movl -0x14(%rsp), %eax
sarl $0x11, %eax
addl $0x249, %eax            # imm = 0x249
movl %eax, -0x4(%rsp)
jmp 0xae411
movl -0x14(%rsp), %eax
sarl $0x14, %eax
movl -0x18(%rsp), %ecx
sarl $0x14, %ecx
cmpl %ecx, %eax
jne 0xae3c5
movl -0x14(%rsp), %eax
sarl $0x14, %eax
addl $0x49, %eax
movl %eax, -0x4(%rsp)
jmp 0xae411
movl -0x14(%rsp), %eax
sarl $0x17, %eax
movl -0x18(%rsp), %ecx
sarl $0x17, %ecx
cmpl %ecx, %eax
jne 0xae3e7
movl -0x14(%rsp), %eax
sarl $0x17, %eax
addl $0x9, %eax
movl %eax, -0x4(%rsp)
jmp 0xae411
movl -0x14(%rsp), %eax
sarl $0x1a, %eax
movl -0x18(%rsp), %ecx
sarl $0x1a, %ecx
cmpl %ecx, %eax
jne 0xae409
movl -0x14(%rsp), %eax
sarl $0x1a, %eax
addl $0x1, %eax
movl %eax, -0x4(%rsp)
jmp 0xae411
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/api/internal/bam/BamWriter_p.cpp
// Function: BamTools::Internal::BamWriterPrivate::Open(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<BamTools::RefData, std::allocator<BamTools::RefData>> const&)
bool BamWriterPrivate::Open(const string& filename,
                            const string& samHeaderText,
                            const RefVector& referenceSequences)
{
    try {

        // open the BGZF file for writing
        m_stream.Open(filename, IBamIODevice::WriteOnly);

        // write BAM file 'metadata' components
        WriteMagicNumber();
        WriteSamHeaderText(samHeaderText);
        WriteReferences(referenceSequences);

        // return success
        return true;

    } catch ( BamException& e ) {
        m_errorString = e.what();
        return false;
    }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x30(%rsp), %rsi
movl $0x2, %edx
callq 0x7b1a0
jmp 0xaeb82
movq (%rsp), %rdi
callq 0x7c8e0
jmp 0xaeb8d
movq (%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x73b20
jmp 0xaeb9d
movq (%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x72e30
jmp 0xaebad
movb $0x1, 0x47(%rsp)
jmp 0xaec21
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0xaec2c
movq 0x18(%rsp), %rdi
callq 0x72fc0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq (%rsp), %rdi
movq %rax, %rsi
addq $0x48, %rdi
callq 0x78d10
jmp 0xaebfe
movb $0x0, 0x47(%rsp)
callq 0x7a790
jmp 0xaec21
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
callq 0x7a790
jmp 0xaec1f
jmp 0xaec2c
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x7b550
movq %rax, %rdi
callq 0x88ef0
nop
// File: zeeev[P]DASVC/bamtools/src/api/internal/bam/BamWriter_p.cpp
// Function: BamTools::Internal::BamWriterPrivate::WriteSamHeaderText(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void BamWriterPrivate::WriteSamHeaderText(const std::string& samHeaderText) {

    // write the SAM header  text length
    const uint32_t actualHeaderLen = samHeaderText.size();
    uint32_t maybeSwappedHeaderLen = samHeaderText.size();
    if ( m_isBigEndian ) BamTools::SwapEndian_32(maybeSwappedHeaderLen);
    m_stream.Write((char*)&maybeSwappedHeaderLen, Constants::BAM_SIZEOF_INT);

    // write the SAM header text
    if ( actualHeaderLen > 0 )
        m_stream.Write(samHeaderText.data(), actualHeaderLen);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x74cd0
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rdi
callq 0x74cd0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movl %ecx, 0x10(%rsp)
testb $0x1, 0x40(%rax)
je 0xaecac
leaq 0x10(%rsp), %rdi
callq 0x77400
movq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movl $0x4, %edx
callq 0x7b740
cmpl $0x0, 0x14(%rsp)
jbe 0xaece4
movq 0x18(%rsp), %rdi
callq 0x785e0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movl 0x14(%rsp), %eax
movl %eax, %edx
callq 0x7b740
addq $0x28, %rsp
retq
nopl (%rax)
// File: zeeev[P]DASVC/bamtools/src/api/internal/bam/BamWriter_p.cpp
// Function: BamTools::Internal::BamWriterPrivate::WriteReferences(std::vector<BamTools::RefData, std::allocator<BamTools::RefData>> const&)
void BamWriterPrivate::WriteReferences(const BamTools::RefVector& referenceSequences) {

    // write the number of reference sequences
    uint32_t numReferenceSequences = referenceSequences.size();
    if ( m_isBigEndian ) BamTools::SwapEndian_32(numReferenceSequences);
    m_stream.Write((char*)&numReferenceSequences, Constants::BAM_SIZEOF_INT);

    // foreach reference sequence
    RefVector::const_iterator rsIter = referenceSequences.begin();
    RefVector::const_iterator rsEnd  = referenceSequences.end();
    for ( ; rsIter != rsEnd; ++rsIter ) {

        // write the reference sequence name length (+1 for terminator)
        const uint32_t actualNameLen = rsIter->RefName.size() + 1;
        uint32_t maybeSwappedNameLen = actualNameLen;
        if ( m_isBigEndian ) BamTools::SwapEndian_32(maybeSwappedNameLen);
        m_stream.Write((char*)&maybeSwappedNameLen, Constants::BAM_SIZEOF_INT);

        // write the reference sequence name
        m_stream.Write(rsIter->RefName.c_str(), actualNameLen);

        // write the reference sequence length
        int32_t referenceLength = rsIter->RefLength;
        if ( m_isBigEndian ) BamTools::SwapEndian_32(referenceLength);
        m_stream.Write((char*)&referenceLength, Constants::BAM_SIZEOF_INT);
    }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
callq 0x71440
movq %rax, %rcx
movq 0x8(%rsp), %rax
movl %ecx, 0x34(%rsp)
testb $0x1, 0x40(%rax)
je 0xaed2e
leaq 0x34(%rsp), %rdi
callq 0x77400
movq 0x8(%rsp), %rdi
leaq 0x34(%rsp), %rsi
movl $0x4, %edx
callq 0x7b740
movq 0x38(%rsp), %rdi
callq 0x71f60
movq %rax, 0x28(%rsp)
movq 0x38(%rsp), %rdi
callq 0x77310
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x78c70
testb $0x1, %al
jne 0xaed78
jmp 0xaee37
leaq 0x28(%rsp), %rdi
callq 0x7ad40
movq %rax, %rdi
callq 0x74cd0
movq %rax, %rcx
movq 0x8(%rsp), %rax
addq $0x1, %rcx
movl %ecx, 0x1c(%rsp)
movl 0x1c(%rsp), %ecx
movl %ecx, 0x18(%rsp)
testb $0x1, 0x40(%rax)
je 0xaedb2
leaq 0x18(%rsp), %rdi
callq 0x77400
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
movl $0x4, %edx
callq 0x7b740
leaq 0x28(%rsp), %rdi
callq 0x7ad40
movq %rax, %rdi
callq 0x73020
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movl 0x1c(%rsp), %eax
movl %eax, %edx
callq 0x7b740
leaq 0x28(%rsp), %rdi
callq 0x7ad40
movq %rax, %rcx
movq 0x8(%rsp), %rax
movl 0x20(%rcx), %ecx
movl %ecx, 0x14(%rsp)
testb $0x1, 0x40(%rax)
je 0xaee14
leaq 0x14(%rsp), %rdi
callq 0x75b80
movq 0x8(%rsp), %rdi
leaq 0x14(%rsp), %rsi
movl $0x4, %edx
callq 0x7b740
leaq 0x28(%rsp), %rdi
callq 0x74d20
jmp 0xaed60
addq $0x48, %rsp
retq
nopl (%rax)
// File: zeeev[P]DASVC/bamtools/src/api/internal/bam/BamWriter_p.cpp
// Function: BamTools::Internal::BamWriterPrivate::SaveAlignment(BamTools::BamAlignment const&)
bool BamWriterPrivate::SaveAlignment(const BamAlignment& al) {

    try {

        // if BamAlignment contains only the core data and a raw char data buffer
        // (as a result of BamReader::GetNextAlignmentCore())
        if ( al.SupportData.HasCoreOnly )
            WriteCoreAlignment(al);

        // otherwise, BamAlignment should contain character in the standard fields: Name, QueryBases, etc
        // (resulting from BamReader::GetNextAlignment() *OR* being generated directly by client code)
        else WriteAlignment(al);

        // if we get here, everything OK
        return true;

    } catch ( BamException& e ) {
        m_errorString = e.what();
        return false;
    }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rax
testb $0x1, 0x130(%rax)
je 0xaeecd
movq (%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x73610
jmp 0xaee75
jmp 0xaeedf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0xaef08
movq 0x18(%rsp), %rdi
callq 0x72fc0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq (%rsp), %rdi
movq %rax, %rsi
addq $0x48, %rdi
callq 0x78d10
jmp 0xaeec1
movb $0x0, 0x37(%rsp)
callq 0x7a790
jmp 0xaeefd
movq (%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x73e50
jmp 0xaeedd
jmp 0xaeedf
movb $0x1, 0x37(%rsp)
jmp 0xaeefd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
callq 0x7a790
jmp 0xaeefb
jmp 0xaef08
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x7b550
movq %rax, %rdi
callq 0x88ef0
nopw (%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/api/internal/index/BamIndexFactory_p.cpp
// Function: BamTools::Internal::BamIndexFactory::CreateIndexFilename(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, BamTools::BamIndex::IndexType const&)
const string BamIndexFactory::CreateIndexFilename(const string& bamFilename,
                                                  const BamIndex::IndexType& type)
{
    switch ( type ) {
        case ( BamIndex::STANDARD ) : return ( bamFilename + BamStandardIndex::Extension() );
        case ( BamIndex::BAMTOOLS ) : return ( bamFilename + BamToolsIndex::Extension() );
        default :
            return string();
    }
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq 0x90(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x3c(%rsp)
testl %eax, %eax
je 0xb017c
jmp 0xb0110
movl 0x3c(%rsp), %eax
subl $0x1, %eax
jne 0xb01d6
jmp 0xb011f
movq 0x98(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x70(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x78cd0
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x7c720
jmp 0xb0151
leaq 0x70(%rsp), %rdi
callq 0x7cce8
jmp 0xb01e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x7cce8
jmp 0xb017a
jmp 0xb01ed
movq 0x98(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x40(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x7a0e0
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x7c720
jmp 0xb01ae
leaq 0x40(%rsp), %rdi
callq 0x7cce8
jmp 0xb01e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x7cce8
jmp 0xb01d4
jmp 0xb01ed
movq 0x28(%rsp), %rdi
callq 0x79100
movq 0x30(%rsp), %rax
addq $0xa8, %rsp
retq
movq 0x68(%rsp), %rdi
callq 0x7b550
movq %rax, %rdi
callq 0x88ef0
nop