LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: zeeev[P]DASVC/bamtools/src/api/internal/index/BamIndexFactory_p.cpp
// Function: BamTools::Internal::BamIndexFactory::CreateIndexFromFilename(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, BamTools::Internal::BamReaderPrivate*)
BamIndex* BamIndexFactory::CreateIndexFromFilename(const string& indexFilename, BamReaderPrivate* reader) {

    // get file extension from index filename, including dot (".EXT")
    // if can't get file extension, return null index
    const string extension = FileExtension(indexFilename);
    if ( extension.empty() )
        return 0;

    // create index based on extension
    if      ( extension == BamStandardIndex::Extension() ) return new BamStandardIndex(reader);
    else if ( extension == BamToolsIndex::Extension()    ) return new BamToolsIndex(reader);
    else
        return 0;
}

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0xa8(%rsp)
movq %rsi, 0xa0(%rsp)
movq 0xa8(%rsp), %rsi
leaq 0x80(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x77040
movq 0x20(%rsp), %rdi
callq 0x7aba0
movb %al, 0x2f(%rsp)
jmp 0xb0241
movb 0x2f(%rsp), %al
testb $0x1, %al
jne 0xb024b
jmp 0xb0277
movq $0x0, 0xb0(%rsp)
movl $0x1, 0x70(%rsp)
jmp 0xb03e8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0xb0405
leaq 0x50(%rsp), %rdi
callq 0x78cd0
jmp 0xb0283
leaq 0x80(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x74120
movb %al, 0x1f(%rsp)
jmp 0xb029b
leaq 0x50(%rsp), %rdi
callq 0x7cce8
jmp 0xb02a7
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0xb02b1
jmp 0xb032c
movl $0x68, %edi
callq 0x76970
movq %rax, 0x10(%rsp)
jmp 0xb02c2
movq 0x10(%rsp), %rdi
movq 0xa0(%rsp), %rsi
callq 0x78d50
jmp 0xb02d6
movq 0x10(%rsp), %rax
movq %rax, 0xb0(%rsp)
movl $0x1, 0x70(%rsp)
jmp 0xb03e8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x7cce8
jmp 0xb030a
jmp 0xb0405
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
callq 0x764d0
jmp 0xb0405
leaq 0x30(%rsp), %rdi
callq 0x7a0e0
jmp 0xb0338
leaq 0x80(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x74120
movb %al, 0xf(%rsp)
jmp 0xb0350
leaq 0x30(%rsp), %rdi
callq 0x7cce8
jmp 0xb035c
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0xb0366
jmp 0xb03d4
movl $0x68, %edi
callq 0x76970
movq %rax, (%rsp)
jmp 0xb0376
movq (%rsp), %rdi
movq 0xa0(%rsp), %rsi
callq 0x774c0
jmp 0xb0389
movq (%rsp), %rax
movq %rax, 0xb0(%rsp)
movl $0x1, 0x70(%rsp)
jmp 0xb03e8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x7cce8
jmp 0xb03b9
jmp 0xb0405
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
callq 0x764d0
jmp 0xb0405
movq $0x0, 0xb0(%rsp)
movl $0x1, 0x70(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x7cce8
movq 0xb0(%rsp), %rax
addq $0xb8, %rsp
retq
leaq 0x80(%rsp), %rdi
callq 0x7cce8
jmp 0xb0414
jmp 0xb0416
movq 0x78(%rsp), %rdi
callq 0x7b550
movq %rax, %rdi
callq 0x88ef0
nopl (%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/api/internal/index/BamIndexFactory_p.cpp
// Function: BamTools::Internal::BamIndexFactory::FileExtension(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
const string BamIndexFactory::FileExtension(const string& filename) {

    // if filename cannot contain valid path + extension, return empty string
    if ( filename.empty() || filename.length() <= 4 )
        return string();

    // look for last dot in filename
    const size_t lastDotPosition = filename.find_last_of('.');

    // if none found, return empty string
    if ( lastDotPosition == string::npos )
        return string();

    // return substring from last dot position
    return filename.substr(lastDotPosition);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x7aba0
testb $0x1, %al
jne 0xb0468
movq 0x18(%rsp), %rdi
callq 0x79c80
cmpq $0x4, %rax
ja 0xb0473
movq (%rsp), %rdi
callq 0x79100
jmp 0xb04bb
movq 0x18(%rsp), %rdi
movl $0x2e, %esi
movq $-0x1, %rdx
callq 0x7c570
movq %rax, 0x10(%rsp)
cmpq $-0x1, 0x10(%rsp)
jne 0xb04a1
movq (%rsp), %rdi
callq 0x79100
jmp 0xb04bb
movq (%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq $-0x1, %rcx
callq 0x76c50
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/api/internal/index/BamIndexFactory_p.cpp
// Function: BamTools::Internal::BamIndexFactory::CreateIndexOfType(BamTools::BamIndex::IndexType const&, BamTools::Internal::BamReaderPrivate*)
BamIndex* BamIndexFactory::CreateIndexOfType(const BamIndex::IndexType& type,
                                             BamReaderPrivate* reader)
{
    switch ( type ) {
        case ( BamIndex::STANDARD ) : return new BamStandardIndex(reader);
        case ( BamIndex::BAMTOOLS ) : return new BamToolsIndex(reader);
        default :
            return 0;
    }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x10(%rsp)
testl %eax, %eax
je 0xb0545
jmp 0xb04ef
movl 0x10(%rsp), %eax
subl $0x1, %eax
jne 0xb0589
jmp 0xb04fe
movl $0x68, %edi
callq 0x76970
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rsi
callq 0x78d50
jmp 0xb051f
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0xb0592
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
callq 0x764d0
jmp 0xb059c
movl $0x68, %edi
callq 0x76970
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rsi
callq 0x774c0
jmp 0xb0565
movq (%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0xb0592
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
callq 0x764d0
jmp 0xb059c
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x7b550
nopw %cs:(%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/api/internal/index/BamStandardIndex_p.cpp
// Function: BamTools::Internal::BamStandardIndex::RaiiWrapper::~RaiiWrapper()
BamStandardIndex::RaiiWrapper::~RaiiWrapper(void) {

    if ( Device ) {
        Device->Close();
        delete Device;
        Device = 0;
    }

    if ( Buffer ) {
        delete[] Buffer;
        Buffer = 0;
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, (%rax)
je 0xb08b1
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0xb08a5
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rsp), %rax
movq $0x0, (%rax)
movq 0x18(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0xb08e8
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0xb08db
movq 0x8(%rsp), %rdi
callq 0x785d0
movq 0x18(%rsp), %rax
movq $0x0, 0x8(%rax)
addq $0x28, %rsp
retq
nopl (%rax)
// File: zeeev[P]DASVC/bamtools/src/api/internal/index/BamStandardIndex_p.cpp
// Function: BamTools::Internal::BamStandardIndex::CloseFile()
void BamStandardIndex::CloseFile(void) {

    // close file stream
    if ( IsDeviceOpen() ) {
        m_resources.Device->Close();
        delete m_resources.Device;
        m_resources.Device = 0;
    }

    // clear index file summary data
    m_indexFileSummary.clear();

    // clean up I/O buffer
    delete[] m_resources.Buffer;
    m_resources.Buffer = 0;
    m_bufferLength = 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x715c0
testb $0x1, %al
jne 0xb0ace
jmp 0xb0b09
movq 0x18(%rsp), %rax
movq 0x58(%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x18(%rsp), %rax
movq 0x58(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0xb0afc
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rsp), %rax
movq $0x0, 0x58(%rax)
movq 0x18(%rsp), %rdi
addq $0x38, %rdi
callq 0x74d40
movq 0x18(%rsp), %rax
movq 0x60(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0xb0b35
movq 0x8(%rsp), %rdi
callq 0x785d0
movq 0x18(%rsp), %rax
movq $0x0, 0x60(%rax)
movl $0x0, 0x50(%rax)
addq $0x28, %rsp
retq
nop
// File: zeeev[P]DASVC/bamtools/src/api/internal/index/BamStandardIndex_p.cpp
// Function: BamTools::Internal::BamStandardIndex::ReadBinIntoBuffer(unsigned int&, int&)
void BamStandardIndex::ReadBinIntoBuffer(uint32_t& binId, int32_t& numAlignmentChunks) {

    // read bin header
    ReadBinID(binId);
    ReadNumAlignmentChunks(numAlignmentChunks);

    // read bin contents
    const unsigned int bytesRequested = numAlignmentChunks*BamStandardIndex::SIZEOF_ALIGNMENTCHUNK;
    ReadIntoBuffer(bytesRequested);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x18(%rsp), %rsi
callq 0x74960
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x7c940
movq (%rsp), %rdi
movq 0x10(%rsp), %rax
movl (%rax), %eax
shll $0x4, %eax
movl %eax, 0xc(%rsp)
leaq 0xc(%rsp), %rsi
callq 0x77610
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/api/internal/index/BamStandardIndex_p.cpp
// Function: BamTools::Internal::BamStandardIndex::CalculateMinOffset(BamTools::Internal::BaiReferenceSummary const&, unsigned int const&)
uint64_t BamStandardIndex::CalculateMinOffset(const BaiReferenceSummary& refSummary,
                                              const uint32_t& begin)
{
    // if no linear offsets exist, return 0
    if ( refSummary.NumLinearOffsets == 0 )
        return 0;

    // if 'begin' starts beyond last linear offset, use the last linear offset as minimum
    // else use the offset corresponding to the requested start position
    const int shiftedBegin = begin>>BamStandardIndex::BAM_LIDX_SHIFT;
    if ( shiftedBegin >= refSummary.NumLinearOffsets )
        return LookupLinearOffset( refSummary, refSummary.NumLinearOffsets-1 );
    else
        return LookupLinearOffset( refSummary, shiftedBegin );
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
cmpl $0x0, 0x4(%rax)
jne 0xb13e3
movq $0x0, 0x30(%rsp)
jmp 0xb1442
movq 0x18(%rsp), %rax
movl (%rax), %eax
shrl $0xe, %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jl 0xb1429
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x20(%rsp), %rax
movl 0x4(%rax), %eax
subl $0x1, %eax
movl %eax, 0x10(%rsp)
leaq 0x10(%rsp), %rdx
callq 0x71ef0
movq %rax, 0x30(%rsp)
jmp 0xb1442
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
leaq 0x14(%rsp), %rdx
callq 0x71ef0
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: zeeev[P]DASVC/bamtools/src/api/internal/index/BamStandardIndex_p.cpp
// Function: BamTools::Internal::BamStandardIndex::LookupLinearOffset(BamTools::Internal::BaiReferenceSummary const&, int const&)
uint64_t BamStandardIndex::LookupLinearOffset(const BaiReferenceSummary& refSummary, const int& index) {

    // attempt seek to proper index file position
    const int64_t linearOffsetFilePosition = (int64_t)refSummary.FirstLinearOffsetFilePosition +
                                             index*BamStandardIndex::SIZEOF_LINEAROFFSET;
    Seek(linearOffsetFilePosition, SEEK_SET);

    // read linear offset from BAI file
    uint64_t linearOffset;
    ReadLinearOffset(linearOffset);
    return linearOffset;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x20(%rsp), %rcx
movl (%rcx), %ecx
shll $0x3, %ecx
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
leaq 0x18(%rsp), %rsi
xorl %edx, %edx
callq 0x73a20
movq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x74230
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
// File: zeeev[P]DASVC/bamtools/src/api/internal/index/BamStandardIndex_p.cpp
// Function: BamTools::Internal::BamStandardIndex::WriteHeader()
void BamStandardIndex::WriteHeader(void) {

    int64_t numBytesWritten = 0;

    // write magic number
    numBytesWritten += m_resources.Device->Write(BamStandardIndex::BAI_MAGIC, 4);

    // write number of reference sequences
    int32_t numReferences = m_indexFileSummary.size();
    if ( m_isBigEndian ) SwapEndian_32(numReferences);
    numBytesWritten += m_resources.Device->Write((const char*)&numReferences, sizeof(numReferences));

    if ( numBytesWritten != sizeof(numReferences)+4 )
        throw BamException("BamStandardIndex::WriteHeader", "could not write BAI header");
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x18(%rsp)
movq $0x0, 0x88(%rsp)
movq 0x58(%rax), %rdi
movq (%rdi), %rax
leaq 0x37c92(%rip), %rsi     # 0xeb0d8
movl $0x4, %edx
callq *0x40(%rax)
movq 0x18(%rsp), %rdi
addq 0x88(%rsp), %rax
movq %rax, 0x88(%rsp)
addq $0x38, %rdi
callq 0x7ae80
movq %rax, %rcx
movq 0x18(%rsp), %rax
movl %ecx, 0x84(%rsp)
testb $0x1, 0x30(%rax)
je 0xb348e
leaq 0x84(%rsp), %rdi
callq 0x75b80
movq 0x18(%rsp), %rax
movq 0x58(%rax), %rdi
movq (%rdi), %rax
leaq 0x84(%rsp), %rsi
movl $0x4, %edx
callq *0x40(%rax)
addq 0x88(%rsp), %rax
movq %rax, 0x88(%rsp)
cmpq $0x8, 0x88(%rsp)
je 0xb35d4
movb $0x1, 0x26(%rsp)
movl $0x28, %edi
callq 0x737c0
movq %rax, 0x8(%rsp)
leaq 0x5f(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x7b5f0
movq 0x10(%rsp), %rdx
leaq 0x3810a(%rip), %rsi     # 0xeb602
leaq 0x60(%rsp), %rdi
callq 0x78e70
jmp 0xb3504
leaq 0x27(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x7b5f0
movq (%rsp), %rdx
leaq 0x38103(%rip), %rsi     # 0xeb620
leaq 0x28(%rsp), %rdi
callq 0x78e70
jmp 0xb3529
movq 0x8(%rsp), %rdi
leaq 0x60(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x79cd0
jmp 0xb353f
movq 0x8(%rsp), %rdi
movb $0x0, 0x26(%rsp)
movq 0x5e9c0(%rip), %rsi     # 0x111f10
movq 0x5ea09(%rip), %rdx     # 0x111f60
callq 0x7b010
jmp 0xb35ee
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0xb35b5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0xb359d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x7cce8
jmp 0xb359b
jmp 0xb359d
leaq 0x27(%rsp), %rdi
callq 0x76f80
leaq 0x60(%rsp), %rdi
callq 0x7cce8
jmp 0xb35b3
jmp 0xb35b5
leaq 0x5f(%rsp), %rdi
callq 0x76f80
testb $0x1, 0x26(%rsp)
jne 0xb35c8
jmp 0xb35d2
movq 0x8(%rsp), %rdi
callq 0x74e00
jmp 0xb35dc
addq $0x98, %rsp
retq
movq 0x50(%rsp), %rdi
callq 0x7b550
movq %rax, %rdi
callq 0x88ef0
nop
// File: zeeev[P]DASVC/bamtools/src/api/internal/index/BamStandardIndex_p.cpp
// Function: BamTools::Internal::BamStandardIndex::SaveLinearOffsetEntry(std::vector<unsigned long, std::allocator<unsigned long>>&, int const&, int const&, unsigned long const&)
void BamStandardIndex::SaveLinearOffsetEntry(BaiLinearOffsetVector& offsets,
                                             const int& alignmentStartPosition,
                                             const int& alignmentStopPosition,
                                             const uint64_t& lastOffset)
{
    // get converted offsets
    const int beginOffset = alignmentStartPosition >> BamStandardIndex::BAM_LIDX_SHIFT;
    const int endOffset   = (alignmentStopPosition - 1) >> BamStandardIndex::BAM_LIDX_SHIFT;

    // resize vector if necessary
    int oldSize = offsets.size();
    int newSize = endOffset + 1;
    if ( oldSize < newSize )
        offsets.resize(newSize, 0);

    // store offset
    for( int i = beginOffset + 1; i <= endOffset; ++i ) {
        if ( offsets[i] == 0 )
            offsets[i] = lastOffset;
    }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq 0x30(%rsp), %rax
movl (%rax), %eax
sarl $0xe, %eax
movl %eax, 0x1c(%rsp)
movq 0x28(%rsp), %rax
movl (%rax), %eax
subl $0x1, %eax
sarl $0xe, %eax
movl %eax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
callq 0x79820
movl %eax, 0x14(%rsp)
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x10(%rsp), %eax
jge 0xb38b2
movq 0x38(%rsp), %rdi
movslq 0x10(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x73f40
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x18(%rsp), %eax
jg 0xb390d
movq 0x38(%rsp), %rdi
movslq 0xc(%rsp), %rsi
callq 0x72370
cmpq $0x0, (%rax)
jne 0xb38fe
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
movq 0x38(%rsp), %rdi
movslq 0xc(%rsp), %rsi
callq 0x72370
movq (%rsp), %rcx
movq %rcx, (%rax)
jmp 0xb3900
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0xb38bd
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/api/internal/index/BamStandardIndex_p.cpp
// Function: BamTools::Internal::BamStandardIndex::HasAlignments(int const&) const
bool BamStandardIndex::HasAlignments(const int& referenceID) const {
    if ( referenceID < 0 || referenceID >= (int)m_indexFileSummary.size() )
        return false;
    const BaiReferenceSummary& refSummary = m_indexFileSummary.at(referenceID);
    return ( refSummary.NumBins > 0 );
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
cmpl $0x0, (%rax)
jl 0xb41b6
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rax
movl (%rax), %eax
movl %eax, 0xc(%rsp)
addq $0x38, %rdi
callq 0x7ae80
movq %rax, %rcx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jl 0xb41bd
movb $0x0, 0x37(%rsp)
jmp 0xb41e9
movq 0x10(%rsp), %rdi
addq $0x38, %rdi
movq 0x20(%rsp), %rax
movslq (%rax), %rsi
callq 0x72be0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpl $0x0, (%rax)
setg %al
andb $0x1, %al
movb %al, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/api/internal/index/BamStandardIndex_p.cpp
// Function: BamTools::Internal::BamStandardIndex::Load(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool BamStandardIndex::Load(const std::string& filename) {

    try {

        // attempt to open file (read-only)
        OpenFile(filename, IBamIODevice::ReadOnly);

        // validate format
        CheckMagicNumber();

        // load in-memory summary of index data
        SummarizeIndexFile();

        // return success
        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), %rdi
movq %rdi, (%rsp)
movq 0x20(%rsp), %rsi
movl $0x1, %edx
callq 0x7a8f0
jmp 0xb4468
movq (%rsp), %rdi
callq 0x76930
jmp 0xb4473
movq (%rsp), %rdi
callq 0x79540
jmp 0xb447e
movb $0x1, 0x37(%rsp)
jmp 0xb44f2
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 0xb44fd
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 $0x10, %rdi
callq 0x78d10
jmp 0xb44cf
movb $0x0, 0x37(%rsp)
callq 0x7a790
jmp 0xb44f2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
callq 0x7a790
jmp 0xb44f0
jmp 0xb44fd
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x7b550
movq %rax, %rdi
callq 0x88ef0
nop
// File: zeeev[P]DASVC/bamtools/src/api/internal/index/BamStandardIndex_p.cpp
// Function: BamTools::Internal::BamStandardIndex::SummarizeIndexFile()
void BamStandardIndex::SummarizeIndexFile(void) {

    // load number of reference sequences
    int numReferences;
    ReadNumReferences(numReferences);

    // initialize file summary data
    ReserveForSummary(numReferences);

    // iterate over reference entries
    BaiFileSummary::iterator summaryIter = m_indexFileSummary.begin();
    BaiFileSummary::iterator summaryEnd  = m_indexFileSummary.end();
    for ( int i = 0; summaryIter != summaryEnd; ++summaryIter, ++i )
        SummarizeReference(*summaryIter);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
leaq 0x2c(%rsp), %rsi
callq 0x7b490
movq 0x8(%rsp), %rdi
leaq 0x2c(%rsp), %rsi
callq 0x7a670
movq 0x8(%rsp), %rdi
addq $0x38, %rdi
callq 0x71f40
movq 0x8(%rsp), %rdi
movq %rax, 0x20(%rsp)
addq $0x38, %rdi
callq 0x71650
movq %rax, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x762c0
testb $0x1, %al
jne 0xb457f
jmp 0xb45ad
leaq 0x20(%rsp), %rdi
callq 0x76830
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x71130
leaq 0x20(%rsp), %rdi
callq 0x7a650
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0xb456a
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/api/internal/index/BamStandardIndex_p.cpp
// Function: BamTools::Internal::BamStandardIndex::ReadLinearOffset(unsigned long&)
void BamStandardIndex::ReadLinearOffset(uint64_t& linearOffset) {
    const int64_t numBytesRead = m_resources.Device->Read((char*)&linearOffset, sizeof(linearOffset));
    if ( m_isBigEndian ) SwapEndian_64(linearOffset);
    if ( numBytesRead != sizeof(linearOffset) )
        throw BamException("BamStandardIndex::ReadLinearOffset", "could not read BAI linear offset");
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x58(%rax), %rdi
movq 0x88(%rsp), %rsi
movq (%rdi), %rax
movl $0x8, %edx
callq *0x28(%rax)
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x80(%rsp)
testb $0x1, 0x30(%rax)
je 0xb461e
movq 0x88(%rsp), %rdi
callq 0x72ec0
cmpq $0x8, 0x80(%rsp)
je 0xb4738
movb $0x1, 0x26(%rsp)
movl $0x28, %edi
callq 0x737c0
movq %rax, 0x8(%rsp)
leaq 0x5f(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x7b5f0
movq 0x10(%rsp), %rdx
leaq 0x36d4a(%rip), %rsi     # 0xeb3a6
leaq 0x60(%rsp), %rdi
callq 0x78e70
jmp 0xb4668
leaq 0x27(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x7b5f0
movq (%rsp), %rdx
leaq 0x36d48(%rip), %rsi     # 0xeb3c9
leaq 0x28(%rsp), %rdi
callq 0x78e70
jmp 0xb468d
movq 0x8(%rsp), %rdi
leaq 0x60(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x79cd0
jmp 0xb46a3
movq 0x8(%rsp), %rdi
movb $0x0, 0x26(%rsp)
movq 0x5d85c(%rip), %rsi     # 0x111f10
movq 0x5d8a5(%rip), %rdx     # 0x111f60
callq 0x7b010
jmp 0xb4752
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0xb4719
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0xb4701
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x7cce8
jmp 0xb46ff
jmp 0xb4701
leaq 0x27(%rsp), %rdi
callq 0x76f80
leaq 0x60(%rsp), %rdi
callq 0x7cce8
jmp 0xb4717
jmp 0xb4719
leaq 0x5f(%rsp), %rdi
callq 0x76f80
testb $0x1, 0x26(%rsp)
jne 0xb472c
jmp 0xb4736
movq 0x8(%rsp), %rdi
callq 0x74e00
jmp 0xb4740
addq $0x98, %rsp
retq
movq 0x50(%rsp), %rdi
callq 0x7b550
movq %rax, %rdi
callq 0x88ef0
nopw %cs:(%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/api/internal/index/BamStandardIndex_p.cpp
// Function: BamTools::Internal::BamStandardIndex::ReadBinID(unsigned int&)
void BamStandardIndex::ReadBinID(uint32_t& binId) {
    const int64_t numBytesRead = m_resources.Device->Read((char*)&binId, sizeof(binId));
    if ( m_isBigEndian ) SwapEndian_32(binId);
    if ( numBytesRead != sizeof(binId) )
        throw BamException("BamStandardIndex::ReadBinID", "could not read BAI bin ID");
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x58(%rax), %rdi
movq 0x88(%rsp), %rsi
movq (%rdi), %rax
movl $0x4, %edx
callq *0x28(%rax)
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x80(%rsp)
testb $0x1, 0x30(%rax)
je 0xb497e
movq 0x88(%rsp), %rdi
callq 0x77400
cmpq $0x4, 0x80(%rsp)
je 0xb4a98
movb $0x1, 0x26(%rsp)
movl $0x28, %edi
callq 0x737c0
movq %rax, 0x8(%rsp)
leaq 0x5f(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x7b5f0
movq 0x10(%rsp), %rdx
leaq 0x36964(%rip), %rsi     # 0xeb320
leaq 0x60(%rsp), %rdi
callq 0x78e70
jmp 0xb49c8
leaq 0x27(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x7b5f0
movq (%rsp), %rdx
leaq 0x3695b(%rip), %rsi     # 0xeb33c
leaq 0x28(%rsp), %rdi
callq 0x78e70
jmp 0xb49ed
movq 0x8(%rsp), %rdi
leaq 0x60(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x79cd0
jmp 0xb4a03
movq 0x8(%rsp), %rdi
movb $0x0, 0x26(%rsp)
movq 0x5d4fc(%rip), %rsi     # 0x111f10
movq 0x5d545(%rip), %rdx     # 0x111f60
callq 0x7b010
jmp 0xb4ab2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0xb4a79
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0xb4a61
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x7cce8
jmp 0xb4a5f
jmp 0xb4a61
leaq 0x27(%rsp), %rdi
callq 0x76f80
leaq 0x60(%rsp), %rdi
callq 0x7cce8
jmp 0xb4a77
jmp 0xb4a79
leaq 0x5f(%rsp), %rdi
callq 0x76f80
testb $0x1, 0x26(%rsp)
jne 0xb4a8c
jmp 0xb4a96
movq 0x8(%rsp), %rdi
callq 0x74e00
jmp 0xb4aa0
addq $0x98, %rsp
retq
movq 0x50(%rsp), %rdi
callq 0x7b550
movq %rax, %rdi
callq 0x88ef0
nopw %cs:(%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/api/internal/index/BamStandardIndex_p.cpp
// Function: BamTools::Internal::BamStandardIndex::ReadNumAlignmentChunks(int&)
void BamStandardIndex::ReadNumAlignmentChunks(int& numAlignmentChunks) {
    const int64_t numBytesRead = m_resources.Device->Read((char*)&numAlignmentChunks, sizeof(numAlignmentChunks));
    if ( m_isBigEndian ) SwapEndian_32(numAlignmentChunks);
    if ( numBytesRead != sizeof(numAlignmentChunks) )
        throw BamException("BamStandardIndex::ReadNumAlignmentChunks", "could not read BAI chunk count");
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x58(%rax), %rdi
movq 0x88(%rsp), %rsi
movq (%rdi), %rax
movl $0x4, %edx
callq *0x28(%rax)
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x80(%rsp)
testb $0x1, 0x30(%rax)
je 0xb4b1e
movq 0x88(%rsp), %rdi
callq 0x75b80
cmpq $0x4, 0x80(%rsp)
je 0xb4c38
movb $0x1, 0x26(%rsp)
movl $0x28, %edi
callq 0x737c0
movq %rax, 0x8(%rsp)
leaq 0x5f(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x7b5f0
movq 0x10(%rsp), %rdx
leaq 0x3688e(%rip), %rsi     # 0xeb3ea
leaq 0x60(%rsp), %rdi
callq 0x78e70
jmp 0xb4b68
leaq 0x27(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x7b5f0
movq (%rsp), %rdx
leaq 0x36892(%rip), %rsi     # 0xeb413
leaq 0x28(%rsp), %rdi
callq 0x78e70
jmp 0xb4b8d
movq 0x8(%rsp), %rdi
leaq 0x60(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x79cd0
jmp 0xb4ba3
movq 0x8(%rsp), %rdi
movb $0x0, 0x26(%rsp)
movq 0x5d35c(%rip), %rsi     # 0x111f10
movq 0x5d3a5(%rip), %rdx     # 0x111f60
callq 0x7b010
jmp 0xb4c52
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0xb4c19
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0xb4c01
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x7cce8
jmp 0xb4bff
jmp 0xb4c01
leaq 0x27(%rsp), %rdi
callq 0x76f80
leaq 0x60(%rsp), %rdi
callq 0x7cce8
jmp 0xb4c17
jmp 0xb4c19
leaq 0x5f(%rsp), %rdi
callq 0x76f80
testb $0x1, 0x26(%rsp)
jne 0xb4c2c
jmp 0xb4c36
movq 0x8(%rsp), %rdi
callq 0x74e00
jmp 0xb4c40
addq $0x98, %rsp
retq
movq 0x50(%rsp), %rdi
callq 0x7b550
movq %rax, %rdi
callq 0x88ef0
nopw %cs:(%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/api/internal/index/BamStandardIndex_p.cpp
// Function: BamTools::Internal::BamStandardIndex::ReadNumBins(int&)
void BamStandardIndex::ReadNumBins(int& numBins) {
    const int64_t numBytesRead = m_resources.Device->Read((char*)&numBins, sizeof(numBins));
    if ( m_isBigEndian ) SwapEndian_32(numBins);
    if ( numBytesRead != sizeof(numBins) )
        throw BamException("BamStandardIndex::ReadNumBins", "could not read BAI bin count");
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x58(%rax), %rdi
movq 0x88(%rsp), %rsi
movq (%rdi), %rax
movl $0x4, %edx
callq *0x28(%rax)
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x80(%rsp)
testb $0x1, 0x30(%rax)
je 0xb4fce
movq 0x88(%rsp), %rdi
callq 0x75b80
cmpq $0x4, 0x80(%rsp)
je 0xb50e8
movb $0x1, 0x26(%rsp)
movl $0x28, %edi
callq 0x737c0
movq %rax, 0x8(%rsp)
leaq 0x5f(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x7b5f0
movq 0x10(%rsp), %rdx
leaq 0x36426(%rip), %rsi     # 0xeb432
leaq 0x60(%rsp), %rdi
callq 0x78e70
jmp 0xb5018
leaq 0x27(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x7b5f0
movq (%rsp), %rdx
leaq 0x3641f(%rip), %rsi     # 0xeb450
leaq 0x28(%rsp), %rdi
callq 0x78e70
jmp 0xb503d
movq 0x8(%rsp), %rdi
leaq 0x60(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x79cd0
jmp 0xb5053
movq 0x8(%rsp), %rdi
movb $0x0, 0x26(%rsp)
movq 0x5ceac(%rip), %rsi     # 0x111f10
movq 0x5cef5(%rip), %rdx     # 0x111f60
callq 0x7b010
jmp 0xb5102
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0xb50c9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0xb50b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x7cce8
jmp 0xb50af
jmp 0xb50b1
leaq 0x27(%rsp), %rdi
callq 0x76f80
leaq 0x60(%rsp), %rdi
callq 0x7cce8
jmp 0xb50c7
jmp 0xb50c9
leaq 0x5f(%rsp), %rdi
callq 0x76f80
testb $0x1, 0x26(%rsp)
jne 0xb50dc
jmp 0xb50e6
movq 0x8(%rsp), %rdi
callq 0x74e00
jmp 0xb50f0
addq $0x98, %rsp
retq
movq 0x50(%rsp), %rdi
callq 0x7b550
movq %rax, %rdi
callq 0x88ef0
nopw %cs:(%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/api/internal/index/BamStandardIndex_p.cpp
// Function: BamTools::Internal::BamStandardIndex::ReadNumLinearOffsets(int&)
void BamStandardIndex::ReadNumLinearOffsets(int& numLinearOffsets) {
    const int64_t numBytesRead = m_resources.Device->Read((char*)&numLinearOffsets, sizeof(numLinearOffsets));
    if ( m_isBigEndian ) SwapEndian_32(numLinearOffsets);
    if ( numBytesRead != sizeof(numLinearOffsets) )
        throw BamException("BamStandardIndex::ReadNumAlignmentChunks", "could not read BAI linear offset count");
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x58(%rax), %rdi
movq 0x88(%rsp), %rsi
movq (%rdi), %rax
movl $0x4, %edx
callq *0x28(%rax)
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x80(%rsp)
testb $0x1, 0x30(%rax)
je 0xb516e
movq 0x88(%rsp), %rdi
callq 0x75b80
cmpq $0x4, 0x80(%rsp)
je 0xb5288
movb $0x1, 0x26(%rsp)
movl $0x28, %edi
callq 0x737c0
movq %rax, 0x8(%rsp)
leaq 0x5f(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x7b5f0
movq 0x10(%rsp), %rdx
leaq 0x3623e(%rip), %rsi     # 0xeb3ea
leaq 0x60(%rsp), %rdi
callq 0x78e70
jmp 0xb51b8
leaq 0x27(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x7b5f0
movq (%rsp), %rdx
leaq 0x3629c(%rip), %rsi     # 0xeb46d
leaq 0x28(%rsp), %rdi
callq 0x78e70
jmp 0xb51dd
movq 0x8(%rsp), %rdi
leaq 0x60(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x79cd0
jmp 0xb51f3
movq 0x8(%rsp), %rdi
movb $0x0, 0x26(%rsp)
movq 0x5cd0c(%rip), %rsi     # 0x111f10
movq 0x5cd55(%rip), %rdx     # 0x111f60
callq 0x7b010
jmp 0xb52a2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0xb5269
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0xb5251
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x7cce8
jmp 0xb524f
jmp 0xb5251
leaq 0x27(%rsp), %rdi
callq 0x76f80
leaq 0x60(%rsp), %rdi
callq 0x7cce8
jmp 0xb5267
jmp 0xb5269
leaq 0x5f(%rsp), %rdi
callq 0x76f80
testb $0x1, 0x26(%rsp)
jne 0xb527c
jmp 0xb5286
movq 0x8(%rsp), %rdi
callq 0x74e00
jmp 0xb5290
addq $0x98, %rsp
retq
movq 0x50(%rsp), %rdi
callq 0x7b550
movq %rax, %rdi
callq 0x88ef0
nopw %cs:(%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/api/internal/index/BamStandardIndex_p.cpp
// Function: BamTools::Internal::BamStandardIndex::ReadNumReferences(int&)
void BamStandardIndex::ReadNumReferences(int& numReferences) {
    const int64_t numBytesRead = m_resources.Device->Read((char*)&numReferences, sizeof(numReferences));
    if ( m_isBigEndian ) SwapEndian_32(numReferences);
    if ( numBytesRead != sizeof(numReferences) )
        throw BamException("BamStandardIndex::ReadNumReferences", "could not read reference count");
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x58(%rax), %rdi
movq 0x88(%rsp), %rsi
movq (%rdi), %rax
movl $0x4, %edx
callq *0x28(%rax)
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x80(%rsp)
testb $0x1, 0x30(%rax)
je 0xb530e
movq 0x88(%rsp), %rdi
callq 0x75b80
cmpq $0x4, 0x80(%rsp)
je 0xb5428
movb $0x1, 0x26(%rsp)
movl $0x28, %edi
callq 0x737c0
movq %rax, 0x8(%rsp)
leaq 0x5f(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x7b5f0
movq 0x10(%rsp), %rdx
leaq 0x36148(%rip), %rsi     # 0xeb494
leaq 0x60(%rsp), %rdi
callq 0x78e70
jmp 0xb5358
leaq 0x27(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x7b5f0
movq (%rsp), %rdx
leaq 0x36147(%rip), %rsi     # 0xeb4b8
leaq 0x28(%rsp), %rdi
callq 0x78e70
jmp 0xb537d
movq 0x8(%rsp), %rdi
leaq 0x60(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x79cd0
jmp 0xb5393
movq 0x8(%rsp), %rdi
movb $0x0, 0x26(%rsp)
movq 0x5cb6c(%rip), %rsi     # 0x111f10
movq 0x5cbb5(%rip), %rdx     # 0x111f60
callq 0x7b010
jmp 0xb5442
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0xb5409
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0xb53f1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x7cce8
jmp 0xb53ef
jmp 0xb53f1
leaq 0x27(%rsp), %rdi
callq 0x76f80
leaq 0x60(%rsp), %rdi
callq 0x7cce8
jmp 0xb5407
jmp 0xb5409
leaq 0x5f(%rsp), %rdi
callq 0x76f80
testb $0x1, 0x26(%rsp)
jne 0xb541c
jmp 0xb5426
movq 0x8(%rsp), %rdi
callq 0x74e00
jmp 0xb5430
addq $0x98, %rsp
retq
movq 0x50(%rsp), %rdi
callq 0x7b550
movq %rax, %rdi
callq 0x88ef0
nopw %cs:(%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/api/internal/index/BamStandardIndex_p.cpp
// Function: BamTools::Internal::BamStandardIndex::SkipBins(int const&)
void BamStandardIndex::SkipBins(const int& numBins) {
    uint32_t binId;
    int32_t numAlignmentChunks;
    for (int i = 0; i < numBins; ++i)
        ReadBinIntoBuffer(binId, numAlignmentChunks); // results & buffer ignored
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl (%rcx), %eax
jge 0xb557c
movq (%rsp), %rdi
leaq 0x14(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x76d70
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0xb554f
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/api/internal/index/BamStandardIndex_p.cpp
// Function: BamTools::Internal::BamStandardIndex::SummarizeBins(BamTools::Internal::BaiReferenceSummary&)
void BamStandardIndex::SummarizeBins(BaiReferenceSummary& refSummary) {

    // load number of bins
    int numBins;
    ReadNumBins(numBins);

    // store bins summary for this reference
    refSummary.NumBins = numBins;
    refSummary.FirstBinFilePosition = Tell();

    // skip this reference's bins
    SkipBins(numBins);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
leaq 0x14(%rsp), %rsi
callq 0x76a60
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
callq 0x71040
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x8(%rax)
leaq 0x14(%rsp), %rsi
callq 0x778a0
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/api/internal/index/BamStandardIndex_p.cpp
// Function: BamTools::Internal::BamStandardIndex::SummarizeLinearOffsets(BamTools::Internal::BaiReferenceSummary&)
void BamStandardIndex::SummarizeLinearOffsets(BaiReferenceSummary& refSummary) {

    // load number of linear offsets
    int numLinearOffsets;
    ReadNumLinearOffsets(numLinearOffsets);

    // store bin summary data for this reference
    refSummary.NumLinearOffsets = numLinearOffsets;
    refSummary.FirstLinearOffsetFilePosition = Tell();

    // skip linear offsets in index file
    SkipLinearOffsets(numLinearOffsets);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
leaq 0x14(%rsp), %rsi
callq 0x74610
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x4(%rax)
callq 0x71040
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x10(%rax)
leaq 0x14(%rsp), %rsi
callq 0x764c0
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/api/internal/index/BamStandardIndex_p.cpp
// Function: BamTools::Internal::BamStandardIndex::WriteAlignmentChunk(BamTools::Internal::BaiAlignmentChunk const&)
void BamStandardIndex::WriteAlignmentChunk(const BaiAlignmentChunk& chunk) {

    // localize alignment chunk offsets
    uint64_t start = chunk.Start;
    uint64_t stop  = chunk.Stop;

    // swap endian-ness if necessary
    if ( m_isBigEndian ) {
        SwapEndian_64(start);
        SwapEndian_64(stop);
    }

    // write to index file
    int64_t numBytesWritten = 0;
    numBytesWritten += m_resources.Device->Write((const char*)&start, sizeof(start));
    numBytesWritten += m_resources.Device->Write((const char*)&stop, sizeof(stop));
    if ( numBytesWritten != (sizeof(start)+sizeof(stop)) )
        throw BamException("BamStandardIndex::WriteAlignmentChunk", "could not write BAI alignment chunk");
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x98(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, 0x90(%rsp)
movq 0x98(%rsp), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, 0x88(%rsp)
testb $0x1, 0x30(%rax)
je 0xb576b
leaq 0x90(%rsp), %rdi
callq 0x72ec0
leaq 0x88(%rsp), %rdi
callq 0x72ec0
movq 0x18(%rsp), %rax
movq $0x0, 0x80(%rsp)
movq 0x58(%rax), %rdi
movq (%rdi), %rax
leaq 0x90(%rsp), %rsi
movl $0x8, %edx
callq *0x40(%rax)
movq %rax, %rcx
movq 0x18(%rsp), %rax
addq 0x80(%rsp), %rcx
movq %rcx, 0x80(%rsp)
movq 0x58(%rax), %rdi
movq (%rdi), %rax
leaq 0x88(%rsp), %rsi
movl $0x8, %edx
callq *0x40(%rax)
addq 0x80(%rsp), %rax
movq %rax, 0x80(%rsp)
cmpq $0x10, 0x80(%rsp)
je 0xb58ec
movb $0x1, 0x26(%rsp)
movl $0x28, %edi
callq 0x737c0
movq %rax, 0x8(%rsp)
leaq 0x5f(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x7b5f0
movq 0x10(%rsp), %rdx
leaq 0x35cf9(%rip), %rsi     # 0xeb509
leaq 0x60(%rsp), %rdi
callq 0x78e70
jmp 0xb581c
leaq 0x27(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x7b5f0
movq (%rsp), %rdx
leaq 0x35cfa(%rip), %rsi     # 0xeb52f
leaq 0x28(%rsp), %rdi
callq 0x78e70
jmp 0xb5841
movq 0x8(%rsp), %rdi
leaq 0x60(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x79cd0
jmp 0xb5857
movq 0x8(%rsp), %rdi
movb $0x0, 0x26(%rsp)
movq 0x5c6a8(%rip), %rsi     # 0x111f10
movq 0x5c6f1(%rip), %rdx     # 0x111f60
callq 0x7b010
jmp 0xb5906
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0xb58cd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0xb58b5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x7cce8
jmp 0xb58b3
jmp 0xb58b5
leaq 0x27(%rsp), %rdi
callq 0x76f80
leaq 0x60(%rsp), %rdi
callq 0x7cce8
jmp 0xb58cb
jmp 0xb58cd
leaq 0x5f(%rsp), %rdi
callq 0x76f80
testb $0x1, 0x26(%rsp)
jne 0xb58e0
jmp 0xb58ea
movq 0x8(%rsp), %rdi
callq 0x74e00
jmp 0xb58f4
addq $0xa8, %rsp
retq
movq 0x50(%rsp), %rdi
callq 0x7b550
movq %rax, %rdi
callq 0x88ef0
nopw %cs:(%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/api/internal/index/BamStandardIndex_p.cpp
// Function: BamTools::Internal::BamStandardIndex::WriteBin(unsigned int const&, std::vector<BamTools::Internal::BaiAlignmentChunk, std::allocator<BamTools::Internal::BaiAlignmentChunk>>&)
void BamStandardIndex::WriteBin(const uint32_t& binId, BaiAlignmentChunkVector& chunks) {

    // write BAM bin ID
    uint32_t binKey = binId;
    if ( m_isBigEndian ) SwapEndian_32(binKey);
    const int64_t numBytesWritten = m_resources.Device->Write((const char*)&binKey, sizeof(binKey));
    if ( numBytesWritten != sizeof(binKey) )
        throw BamException("BamStandardIndex::WriteBin", "could not write bin ID");

    // write bin's alignment chunks
    WriteAlignmentChunks(chunks);
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x98(%rsp), %rcx
movl (%rcx), %ecx
movl %ecx, 0x8c(%rsp)
testb $0x1, 0x30(%rax)
je 0xb5bb0
leaq 0x8c(%rsp), %rdi
callq 0x77400
movq 0x18(%rsp), %rax
movq 0x58(%rax), %rdi
movq (%rdi), %rax
leaq 0x8c(%rsp), %rsi
movl $0x4, %edx
callq *0x40(%rax)
movq %rax, 0x80(%rsp)
cmpq $0x4, 0x80(%rsp)
je 0xb5cee
movb $0x1, 0x26(%rsp)
movl $0x28, %edi
callq 0x737c0
movq %rax, 0x8(%rsp)
leaq 0x5f(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x7b5f0
movq 0x10(%rsp), %rdx
leaq 0x35988(%rip), %rsi     # 0xeb59a
leaq 0x60(%rsp), %rdi
callq 0x78e70
jmp 0xb5c1e
leaq 0x27(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x7b5f0
movq (%rsp), %rdx
leaq 0x3597e(%rip), %rsi     # 0xeb5b5
leaq 0x28(%rsp), %rdi
callq 0x78e70
jmp 0xb5c43
movq 0x8(%rsp), %rdi
leaq 0x60(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x79cd0
jmp 0xb5c59
movq 0x8(%rsp), %rdi
movb $0x0, 0x26(%rsp)
movq 0x5c2a6(%rip), %rsi     # 0x111f10
movq 0x5c2ef(%rip), %rdx     # 0x111f60
callq 0x7b010
jmp 0xb5d1a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0xb5ccf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0xb5cb7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x7cce8
jmp 0xb5cb5
jmp 0xb5cb7
leaq 0x27(%rsp), %rdi
callq 0x76f80
leaq 0x60(%rsp), %rdi
callq 0x7cce8
jmp 0xb5ccd
jmp 0xb5ccf
leaq 0x5f(%rsp), %rdi
callq 0x76f80
testb $0x1, 0x26(%rsp)
jne 0xb5ce2
jmp 0xb5cec
movq 0x8(%rsp), %rdi
callq 0x74e00
jmp 0xb5d08
movq 0x18(%rsp), %rdi
movq 0x90(%rsp), %rsi
callq 0x7acf0
addq $0xa8, %rsp
retq
movq 0x50(%rsp), %rdi
callq 0x7b550
movq %rax, %rdi
callq 0x88ef0
nopw (%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/api/BamAux.h
// Function: BamTools::SwapEndian_64(unsigned long&)
API_EXPORT inline void SwapEndian_64(uint64_t& x) {
    x = ( (x >> 56) | 
         ((x << 40) & 0x00FF000000000000ll) |
         ((x << 24) & 0x0000FF0000000000ll) |
         ((x << 8)  & 0x000000FF00000000ll) |
         ((x >> 8)  & 0x00000000FF000000ll) |
         ((x >> 24) & 0x0000000000FF0000ll) |
         ((x >> 40) & 0x000000000000FF00ll) |
          (x << 56)
        );
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq (%rax), %rcx
shrq $0x38, %rcx
movq -0x8(%rsp), %rax
movq (%rax), %rax
shlq $0x28, %rax
movabsq $0xff000000000000, %rdx # imm = 0xFF000000000000
andq %rdx, %rax
orq %rax, %rcx
movq -0x8(%rsp), %rax
movq (%rax), %rax
shlq $0x18, %rax
movabsq $0xff0000000000, %rdx   # imm = 0xFF0000000000
andq %rdx, %rax
orq %rax, %rcx
movq -0x8(%rsp), %rax
movq (%rax), %rax
shlq $0x8, %rax
movabsq $0xff00000000, %rdx     # imm = 0xFF00000000
andq %rdx, %rax
orq %rax, %rcx
movq -0x8(%rsp), %rax
movq (%rax), %rax
shrq $0x8, %rax
movabsq $0xff000000, %rdx       # imm = 0xFF000000
andq %rdx, %rax
orq %rax, %rcx
movq -0x8(%rsp), %rax
movq (%rax), %rax
shrq $0x18, %rax
andq $0xff0000, %rax         # imm = 0xFF0000
orq %rax, %rcx
movq -0x8(%rsp), %rax
movq (%rax), %rax
shrq $0x28, %rax
andq $0xff00, %rax           # imm = 0xFF00
orq %rax, %rcx
movq -0x8(%rsp), %rax
movq (%rax), %rax
shlq $0x38, %rax
orq %rax, %rcx
movq -0x8(%rsp), %rax
movq %rcx, (%rax)
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: zeeev[P]DASVC/bamtools/src/api/internal/index/BamToolsIndex_p.cpp
// Function: BamTools::Internal::BamToolsIndex::RaiiWrapper::~RaiiWrapper()
BamToolsIndex::RaiiWrapper::~RaiiWrapper(void) {
    if ( Device ) {
        Device->Close();
        delete Device;
        Device = 0;
    }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, (%rax)
je 0xc022f
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0xc0223
movq (%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/api/internal/index/BamToolsIndex_p.cpp
// Function: BamTools::Internal::BamToolsIndex::CloseFile()
void BamToolsIndex::CloseFile(void) {
    if ( IsDeviceOpen() ) {
        m_resources.Device->Close();
        delete m_resources.Device;
        m_resources.Device = 0;
    }
    m_indexFileSummary.clear();
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x7cc50
testb $0x1, %al
jne 0xc042e
jmp 0xc0467
movq 0x8(%rsp), %rax
movq 0x60(%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x8(%rsp), %rax
movq 0x60(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0xc045a
movq (%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x60(%rax)
movq 0x8(%rsp), %rdi
addq $0x38, %rdi
callq 0x76d90
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/api/internal/index/BamToolsIndex_p.cpp
// Function: BamTools::Internal::BamToolsIndex::WriteReferenceEntry(BamTools::Internal::BtiReferenceEntry const&)
void BamToolsIndex::WriteReferenceEntry(const BtiReferenceEntry& refEntry) {

    // write number of blocks this reference
    uint32_t numBlocks = refEntry.Blocks.size();
    if ( m_isBigEndian ) SwapEndian_32(numBlocks);
    const int64_t numBytesWritten = m_resources.Device->Write((const char*)&numBlocks, sizeof(numBlocks));
    if ( numBytesWritten != sizeof(numBlocks) )
        throw BamException("BamToolsIndex::WriteReferenceEntry", "could not write number of blocks");

    // write actual block entries
    WriteBlocks(refEntry.Blocks);
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x98(%rsp), %rdi
addq $0x8, %rdi
callq 0x72980
movq %rax, %rcx
movq 0x20(%rsp), %rax
movl %ecx, 0x94(%rsp)
testb $0x1, 0x30(%rax)
je 0xc20d7
leaq 0x94(%rsp), %rdi
callq 0x77400
movq 0x20(%rsp), %rax
movq 0x60(%rax), %rdi
movq (%rdi), %rax
leaq 0x94(%rsp), %rsi
movl $0x4, %edx
callq *0x40(%rax)
movq %rax, 0x88(%rsp)
cmpq $0x4, 0x88(%rsp)
je 0xc2217
movb $0x1, 0x2e(%rsp)
movl $0x28, %edi
callq 0x737c0
movq %rax, 0x10(%rsp)
leaq 0x67(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x7b5f0
movq 0x18(%rsp), %rdx
leaq 0x299b3(%rip), %rsi     # 0xebaec
leaq 0x68(%rsp), %rdi
callq 0x78e70
jmp 0xc2145
leaq 0x2f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x7b5f0
movq 0x8(%rsp), %rdx
leaq 0x299af(%rip), %rsi     # 0xebb0f
leaq 0x30(%rsp), %rdi
callq 0x78e70
jmp 0xc216c
movq 0x10(%rsp), %rdi
leaq 0x68(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x79cd0
jmp 0xc2182
movq 0x10(%rsp), %rdi
movb $0x0, 0x2e(%rsp)
movq 0x4fd7d(%rip), %rsi     # 0x111f10
movq 0x4fdc6(%rip), %rdx     # 0x111f60
callq 0x7b010
jmp 0xc2247
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0xc21f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
jmp 0xc21e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x7cce8
jmp 0xc21de
jmp 0xc21e0
leaq 0x2f(%rsp), %rdi
callq 0x76f80
leaq 0x68(%rsp), %rdi
callq 0x7cce8
jmp 0xc21f6
jmp 0xc21f8
leaq 0x67(%rsp), %rdi
callq 0x76f80
testb $0x1, 0x2e(%rsp)
jne 0xc220b
jmp 0xc2215
movq 0x10(%rsp), %rdi
callq 0x74e00
jmp 0xc2235
movq 0x20(%rsp), %rdi
movq 0x98(%rsp), %rsi
addq $0x8, %rsi
callq 0x73170
addq $0xa8, %rsp
retq
movq 0x58(%rsp), %rdi
callq 0x7b550
movq %rax, %rdi
callq 0x88ef0
nopw (%rax,%rax)