LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: zeeev[P]DASVC/bamtools/src/toolkit/bamtools_merge.cpp
// Function: BamTools::MergeTool::Run(int, char**)
int MergeTool::Run(int argc, char* argv[]) {
  
    // parse command line arguments
    Options::Parse(argc, argv, 1);
    
    // initialize MergeTool with settings
    m_impl = new MergeToolPrivate(m_settings);

    // run MergeTool, return success/fail
    if ( m_impl->Run() )
        return 0;
    else
        return 1;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x34(%rsp), %edi
movq 0x28(%rsp), %rsi
movl $0x1, %edx
callq 0x10e260
movl $0x8, %edi
callq 0x86720
movq %rax, %rdi
movq 0x8(%rsp), %rax
movq %rdi, %rcx
movq %rcx, 0x10(%rsp)
movq 0x8(%rax), %rsi
callq 0xc4a50
jmp 0xc45d4
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%rax), %rdi
callq 0xc2c40
testb $0x1, %al
jne 0xc45f1
jmp 0xc4615
movl $0x0, 0x44(%rsp)
jmp 0xc461d
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x866a0
jmp 0xc4626
movl $0x1, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x86d80
// File: zeeev[P]DASVC/bamtools/src/toolkit/bamtools_random.cpp
// Function: BamTools::RandomTool::~RandomTool()
RandomTool::~RandomTool(void) { 

    delete m_settings;
    m_settings = 0;

    delete m_impl;
    m_impl = 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x9dfae(%rip), %rcx     # 0x164a38
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0xc6ab6
movq 0x18(%rsp), %rdi
callq 0xc7250
jmp 0xc6aac
movq 0x18(%rsp), %rdi
callq 0x866a0
movq 0x10(%rsp), %rax
movq $0x0, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0xc6ae8
movq 0x8(%rsp), %rdi
callq 0xc7320
jmp 0xc6ade
movq 0x8(%rsp), %rdi
callq 0x866a0
movq 0x10(%rsp), %rdi
movq $0x0, 0x10(%rdi)
callq 0x92a20
addq $0x38, %rsp
retq
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x866a0
jmp 0xc6b31
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x866a0
movq 0x10(%rsp), %rdi
callq 0x92a20
jmp 0xc6b3d
jmp 0xc6b3f
movq 0x28(%rsp), %rdi
callq 0x86d80
movq %rax, %rdi
callq 0x91290
nopw %cs:(%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/toolkit/bamtools_random.cpp
// Function: BamTools::RandomTool::Run(int, char**)
int RandomTool::Run(int argc, char* argv[]) { 

    // parse command line arguments
    Options::Parse(argc, argv, 1);

    // initialize RandomTool with settings
    m_impl = new RandomToolPrivate(m_settings);

    // run RandomTool, return success/fail
    if ( m_impl->Run() )
        return 0;
    else
        return 1;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x34(%rsp), %edi
movq 0x28(%rsp), %rsi
movl $0x1, %edx
callq 0x10e260
movl $0x8, %edi
callq 0x86720
movq %rax, %rdi
movq 0x8(%rsp), %rax
movq %rdi, %rcx
movq %rcx, 0x10(%rsp)
movq 0x8(%rax), %rsi
callq 0xc7330
jmp 0xc6c14
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%rax), %rdi
callq 0xc4ae0
testb $0x1, %al
jne 0xc6c31
jmp 0xc6c55
movl $0x0, 0x44(%rsp)
jmp 0xc6c5d
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x866a0
jmp 0xc6c66
movl $0x1, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x86d80
// File: zeeev[P]DASVC/bamtools/src/toolkit/bamtools_resolve.cpp
// Function: ReadGroupResolver::ReadGroupResolver()
ReadGroupResolver::ReadGroupResolver(void)
    : MinFragmentLength(0)
    , MedianFragmentLength(0)
    , MaxFragmentLength(0)
    , TopModelId(ModelType::DUMMY_ID)
    , NextTopModelId(ModelType::DUMMY_ID)
    , IsAmbiguous(false)
    , HasData(false)
{
    // pre-allocate space for 8 models
    Models.reserve(NUM_MODELS);
    for ( uint16_t i = 0; i < NUM_MODELS; ++i )
        Models.push_back( ModelType(i+1) );
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movl $0x0, (%rdi)
movl $0x0, 0x4(%rdi)
movl $0x0, 0x8(%rdi)
movw $0x64, 0xc(%rdi)
movw $0x64, 0xe(%rdi)
movb $0x0, 0x10(%rdi)
movb $0x0, 0x11(%rdi)
addq $0x18, %rdi
movq %rdi, 0x8(%rsp)
callq 0xced30
movq 0x10(%rsp), %rdi
addq $0x30, %rdi
movq %rdi, 0x18(%rsp)
callq 0xced40
jmp 0xc761e
movq 0x10(%rsp), %rdi
addq $0x18, %rdi
movl $0x8, %esi
callq 0xced50
jmp 0xc7633
movw $0x0, 0x42(%rsp)
movzwl 0x42(%rsp), %eax
cmpl $0x8, %eax
jge 0xc76d5
movq 0x10(%rsp), %rax
addq $0x18, %rax
movq %rax, (%rsp)
movzwl 0x42(%rsp), %eax
incl %eax
movzwl %ax, %esi
leaq 0x20(%rsp), %rdi
callq 0xceed0
jmp 0xc766b
movq (%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0xcee60
jmp 0xc767b
leaq 0x20(%rsp), %rdi
callq 0xcef40
jmp 0xc7687
jmp 0xc7689
movw 0x42(%rsp), %ax
addw $0x1, %ax
movw %ax, 0x42(%rsp)
jmp 0xc763a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0xc76e8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0xc76da
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x20(%rsp), %rdi
callq 0xcef40
jmp 0xc76d3
jmp 0xc76da
addq $0x58, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0xcef60
jmp 0xc76e6
jmp 0xc76e8
movq 0x8(%rsp), %rdi
callq 0xcef70
jmp 0xc76f4
jmp 0xc76f6
movq 0x48(%rsp), %rdi
callq 0x86d80
movq %rax, %rdi
callq 0x91290
nopl (%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/toolkit/bamtools_resolve.cpp
// Function: BamTools::ResolveTool::ReadNamesFileReader::Open(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool ResolveTool::ReadNamesFileReader::Open(const string& filename) {

    // make sure stream is fresh
    Close();

    // attempt to open filename, return status
    m_stream.open(filename.c_str(), ifstream::in);
    return m_stream.good();
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xc8250
movq 0x8(%rsp), %rdi
callq 0x86320
movq (%rsp), %rdi
movq %rax, %rsi
movl $0x8, %edx
callq 0x86490
movq (%rsp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x86d00
andb $0x1, %al
addq $0x18, %rsp
retq
nop
// File: zeeev[P]DASVC/bamtools/src/toolkit/bamtools_resolve.cpp
// Function: BamTools::ResolveTool::ReadNamesFileWriter::Open(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool ResolveTool::ReadNamesFileWriter::Open(const string& filename) {

    // make sure stream is fresh
    Close();

    // attempt to open filename, return status
    m_stream.open(filename.c_str(), ofstream::out);
    return m_stream.good();
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xc8700
movq 0x8(%rsp), %rdi
callq 0x86320
movq (%rsp), %rdi
movq %rax, %rsi
movl $0x10, %edx
callq 0x86090
movq (%rsp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x86d00
andb $0x1, %al
addq $0x18, %rsp
retq
nop
// File: zeeev[P]DASVC/bamtools/src/toolkit/bamtools_resolve.cpp
// Function: BamTools::ResolveTool::StatsFileReader::Open(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool ResolveTool::StatsFileReader::Open(const string& filename) {

    // make sure stream is fresh
    Close();

    // attempt to open filename, return status
    m_stream.open(filename.c_str(), ifstream::in);
    return m_stream.good();
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xc87d0
movq 0x8(%rsp), %rdi
callq 0x86320
movq (%rsp), %rdi
movq %rax, %rsi
movl $0x8, %edx
callq 0x86490
movq (%rsp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x86d00
andb $0x1, %al
addq $0x18, %rsp
retq
nop
// File: zeeev[P]DASVC/bamtools/src/toolkit/bamtools_resolve.cpp
// Function: BamTools::ResolveTool::StatsFileReader::SkipCommentsAndWhitespace[abi:cxx11]()
string ResolveTool::StatsFileReader::SkipCommentsAndWhitespace(void) {
    string line;
    do {
        if ( m_stream.eof() )
            return string();
        getline(m_stream, line);
    } while ( IsWhitespace(line) || IsComment(line) );
    return line;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x86a30
movq 0x20(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x86e40
movb %al, 0xf(%rsp)
jmp 0xc9449
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0xc9453
jmp 0xc9489
movq 0x10(%rsp), %rdi
callq 0x86a30
jmp 0xc945f
movl $0x1, 0x28(%rsp)
jmp 0xc9506
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x86f68
jmp 0xc951a
movq 0x20(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x86140
jmp 0xc949a
jmp 0xc949c
movq 0x20(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0xc8830
movb %al, 0xe(%rsp)
jmp 0xc94b1
movb 0xe(%rsp), %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0xd(%rsp)
jne 0xc94e1
jmp 0xc94c2
movq 0x20(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0xc8800
movb %al, 0xc(%rsp)
jmp 0xc94d7
movb 0xc(%rsp), %al
movb %al, 0xd(%rsp)
jmp 0xc94e1
movb 0xd(%rsp), %al
testb $0x1, %al
jne 0xc942f
movq 0x10(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x86350
jmp 0xc94fe
movl $0x1, 0x28(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x86f68
movq 0x18(%rsp), %rax
addq $0x68, %rsp
retq
jmp 0xc951c
movq 0x30(%rsp), %rdi
callq 0x86d80
movq %rax, %rdi
callq 0x91290
nop
// File: zeeev[P]DASVC/bamtools/src/toolkit/bamtools_resolve.cpp
// Function: BamTools::ResolveTool::StatsFileWriter::Open(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool ResolveTool::StatsFileWriter::Open(const string& filename) {

    // make sure stream is fresh
    Close();

    // attempt to open filename, return status
    m_stream.open(filename.c_str(), ofstream::out);
    return m_stream.good();
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xc9530
movq 0x8(%rsp), %rdi
callq 0x86320
movq (%rsp), %rdi
movq %rax, %rsi
movl $0x10, %edx
callq 0x86090
movq (%rsp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x86d00
andb $0x1, %al
addq $0x18, %rsp
retq
nop
// File: zeeev[P]DASVC/bamtools/src/toolkit/bamtools_resolve.cpp
// Function: BamTools::ResolveTool::StatsFileWriter::Write(BamTools::ResolveTool::ResolveSettings*, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, ReadGroupResolver, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, ReadGroupResolver>>> const&)
bool ResolveTool::StatsFileWriter::Write(ResolveTool::ResolveSettings* settings,
                                         const map<string, ReadGroupResolver>& readGroups)
{
    // return failure if file not open
    if ( !m_stream.is_open() )
        return false;

    // write stats file elements
    WriteHeader();
    WriteInput(settings);
    WriteOptions(settings);
    WriteReadGroups(readGroups);

    // return success
    return true;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x86590
testb $0x1, %al
jne 0xc95dc
movb $0x0, 0x27(%rsp)
jmp 0xc9614
movq (%rsp), %rdi
callq 0xc9620
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xc9900
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xc9970
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xc9ac0
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nop
// File: zeeev[P]DASVC/bamtools/src/toolkit/bamtools_resolve.cpp
// Function: BamTools::ResolveTool::StatsFileWriter::WriteInput(BamTools::ResolveTool::ResolveSettings*)
void ResolveTool::StatsFileWriter::WriteInput(ResolveTool::ResolveSettings* settings) {

    // [Input]
    // filename
    // \n

    m_stream << INPUT_TOKEN << endl
             << settings->InputBamFilename << endl
             << endl;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x9c3a6(%rip), %rsi     # 0x165cc0
callq 0x86640
movq %rax, %rdi
movq 0x9b647(%rip), %rsi     # 0x164f70
callq 0x86770
movq %rax, %rdi
movq 0x8(%rsp), %rsi
addq $0x10, %rsi
callq 0x86640
movq %rax, %rdi
movq 0x9b627(%rip), %rsi     # 0x164f70
callq 0x86770
movq %rax, %rdi
movq 0x9b618(%rip), %rsi     # 0x164f70
callq 0x86770
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/toolkit/bamtools_resolve.cpp
// Function: BamTools::ResolveTool::StatsFileWriter::WriteOptions(BamTools::ResolveTool::ResolveSettings*)
void ResolveTool::StatsFileWriter::WriteOptions(ResolveTool::ResolveSettings* settings) {

    // [Options]
    // ConfidenceInterval=<double>
    // ForceMarkReadGroups=<true|false>
    // MinimumMapQuality=<uint16_t>
    // UnusedModelThreshold=<double>
    // \n

    m_stream << OPTIONS_TOKEN << endl
             << OPTION_CONFIDENCEINTERVAL   << EQUAL_CHAR << settings->ConfidenceInterval << endl
             << OPTION_FORCEMARKREADGROUPS  << EQUAL_CHAR << boolalpha << settings->HasForceMarkReadGroups << endl
             << OPTION_MINIMUMMAPQUALITY    << EQUAL_CHAR << settings->MinimumMapQuality << endl
             << OPTION_UNUSEDMODELTHRESHOLD << EQUAL_CHAR << settings->UnusedModelThreshold << endl
             << endl;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x9c356(%rip), %rsi     # 0x165ce0
callq 0x86640
movq %rax, %rdi
movq 0x9b5d7(%rip), %rsi     # 0x164f70
callq 0x86770
movq %rax, %rdi
leaq 0x9c378(%rip), %rsi     # 0x165d20
callq 0x86640
movq %rax, %rdi
movl $0x3d, %esi
callq 0x86890
movq %rax, %rdi
movq 0x8(%rsp), %rax
movsd 0x90(%rax), %xmm0
callq 0x86eb0
movq %rax, %rdi
movq 0x9b597(%rip), %rsi     # 0x164f70
callq 0x86770
movq %rax, %rdi
leaq 0x9c398(%rip), %rsi     # 0x165d80
callq 0x86640
movq %rax, %rdi
movl $0x3d, %esi
callq 0x86890
movq %rax, %rdi
leaq -0x20464(%rip), %rsi    # 0xa95a0
callq 0x86290
movq %rax, %rdi
movq 0x8(%rsp), %rax
movb 0x8(%rax), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x86dc0
movq %rax, %rdi
movq 0x9b548(%rip), %rsi     # 0x164f70
callq 0x86770
movq %rax, %rdi
leaq 0x9c309(%rip), %rsi     # 0x165d40
callq 0x86640
movq %rax, %rdi
movl $0x3d, %esi
callq 0x86890
movq %rax, %rdi
movq 0x8(%rsp), %rax
movzwl 0x98(%rax), %esi
callq 0x86cb0
movq %rax, %rdi
movq 0x9b509(%rip), %rsi     # 0x164f70
callq 0x86770
movq %rax, %rdi
leaq 0x9c2ea(%rip), %rsi     # 0x165d60
callq 0x86640
movq %rax, %rdi
movl $0x3d, %esi
callq 0x86890
movq %rax, %rdi
movq 0x8(%rsp), %rax
movsd 0xa0(%rax), %xmm0
callq 0x86eb0
movq %rax, %rdi
movq 0x9b4c9(%rip), %rsi     # 0x164f70
callq 0x86770
movq %rax, %rdi
movq 0x9b4ba(%rip), %rsi     # 0x164f70
callq 0x86770
addq $0x18, %rsp
retq
// File: zeeev[P]DASVC/bamtools/src/toolkit/bamtools_resolve.cpp
// Function: BamTools::ResolveTool::ResolveToolPrivate::ParseHeader(BamTools::SamHeader const&)
void ResolveTool::ResolveToolPrivate::ParseHeader(const SamHeader& header) {

    // iterate over header read groups, creating a 'resolver' for each
    SamReadGroupConstIterator rgIter = header.ReadGroups.ConstBegin();
    SamReadGroupConstIterator rgEnd  = header.ReadGroups.ConstEnd();
    for ( ; rgIter != rgEnd; ++rgIter ) {
        const SamReadGroup& rg = (*rgIter);
        m_readGroups.insert( make_pair<string, ReadGroupResolver>(rg.ID, ReadGroupResolver()) );
    }
}

// Assembly:
subq $0x1e8, %rsp            # imm = 0x1E8
movq %rdi, 0x1e0(%rsp)
movq %rsi, 0x1d8(%rsp)
movq 0x1e0(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x1d8(%rsp), %rdi
addq $0xc0, %rdi
callq 0x86c80
movq %rax, 0x1d0(%rsp)
movq 0x1d8(%rsp), %rdi
addq $0xc0, %rdi
callq 0x86e00
movq %rax, 0x1c8(%rsp)
leaq 0x1d0(%rsp), %rdi
leaq 0x1c8(%rsp), %rsi
callq 0xcff50
testb $0x1, %al
jne 0xcb69a
jmp 0xcb80f
leaq 0x1d0(%rsp), %rdi
callq 0xcff90
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x1c0(%rsp)
addq $0x8, %rax
movq %rax, 0x10(%rsp)
movq 0x1c0(%rsp), %rsi
addq $0x40, %rsi
leaq 0xa0(%rsp), %rdi
callq 0x86350
leaq 0x40(%rsp), %rdi
callq 0xc75c0
jmp 0xcb6e5
leaq 0xc0(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
leaq 0x40(%rsp), %rdx
callq 0xcf980
jmp 0xcb701
leaq 0x140(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
callq 0xcfa40
jmp 0xcb718
movq 0x10(%rsp), %rdi
leaq 0x140(%rsp), %rsi
callq 0xcf930
movb %dl, 0x7(%rsp)
movq %rax, 0x8(%rsp)
jmp 0xcb735
movb 0x7(%rsp), %al
movq 0x8(%rsp), %rcx
movq %rcx, 0x20(%rsp)
movb %al, 0x28(%rsp)
leaq 0x140(%rsp), %rdi
callq 0xcfab0
jmp 0xcb756
leaq 0xc0(%rsp), %rdi
callq 0xcfb10
jmp 0xcb765
leaq 0x40(%rsp), %rdi
callq 0xcfb70
jmp 0xcb771
leaq 0xa0(%rsp), %rdi
callq 0x86f68
leaq 0x1d0(%rsp), %rdi
callq 0xcffa0
jmp 0xcb67c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0xcb7fe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0xcb7f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0xcb7df
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x140(%rsp), %rdi
callq 0xcfab0
jmp 0xcb7dd
jmp 0xcb7df
leaq 0xc0(%rsp), %rdi
callq 0xcfb10
jmp 0xcb7ee
jmp 0xcb7f0
leaq 0x40(%rsp), %rdi
callq 0xcfb70
jmp 0xcb7fc
jmp 0xcb7fe
leaq 0xa0(%rsp), %rdi
callq 0x86f68
jmp 0xcb80d
jmp 0xcb817
addq $0x1e8, %rsp            # imm = 0x1E8
retq
movq 0x38(%rsp), %rdi
callq 0x86d80
movq %rax, %rdi
callq 0x91290
nopl (%rax)
// File: zeeev[P]DASVC/bamtools/src/toolkit/bamtools_resolve.cpp
// Function: BamTools::ResolveTool::ResolveToolPrivate::ReadStatsFile()
bool ResolveTool::ResolveToolPrivate::ReadStatsFile(void) {

    // skip if no filename provided
    if ( m_settings->StatsFilename.empty() )
        return false;

    // attempt to open stats file
    ResolveTool::StatsFileReader statsReader;
    if ( !statsReader.Open(m_settings->StatsFilename) ) {
        cerr << "bamtools resolve ERROR - could not open stats file: "
             << m_settings->StatsFilename << " for reading" << endl;
        return false;
    }

    // attempt to read stats data
    if ( !statsReader.Read(m_settings, m_readGroups) ) {
        cerr << "bamtools resolve ERROR - could not parse stats file: "
             << m_settings->StatsFilename << " for data" << endl;
        return false;
    }

    // return success
    return true;
}

// Assembly:
subq $0x278, %rsp            # imm = 0x278
movq %rdi, 0x268(%rsp)
movq 0x268(%rsp), %rax
movq %rax, 0x48(%rsp)
movq (%rax), %rdi
addq $0x50, %rdi
callq 0x86c90
testb $0x1, %al
jne 0xcb85e
jmp 0xcb86b
movb $0x0, 0x277(%rsp)
jmp 0xcb9ee
leaq 0x60(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0xcffc0
movq 0x48(%rsp), %rax
movq 0x38(%rsp), %rdi
movq (%rax), %rsi
addq $0x50, %rsi
callq 0xc8880
movb %al, 0x47(%rsp)
jmp 0xcb896
movb 0x47(%rsp), %al
testb $0x1, %al
jne 0xcb938
jmp 0xcb8a4
movq 0x99735(%rip), %rdi     # 0x164fe0
leaq 0x658ac(%rip), %rsi     # 0x13115e
callq 0x86700
movq %rax, 0x30(%rsp)
jmp 0xcb8be
movq 0x30(%rsp), %rdi
movq 0x48(%rsp), %rax
movq (%rax), %rsi
addq $0x50, %rsi
callq 0x86640
movq %rax, 0x28(%rsp)
jmp 0xcb8db
movq 0x28(%rsp), %rdi
leaq 0x68599(%rip), %rsi     # 0x133e80
callq 0x86700
movq %rax, 0x20(%rsp)
jmp 0xcb8f3
movq 0x20(%rsp), %rdi
movq 0x99671(%rip), %rsi     # 0x164f70
callq 0x86770
jmp 0xcb906
movb $0x0, 0x277(%rsp)
movl $0x1, 0x50(%rsp)
jmp 0xcb9e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x60(%rsp), %rdi
callq 0xcffd0
jmp 0xcb9ec
movq 0x48(%rsp), %rdx
movq (%rdx), %rsi
addq $0x8, %rdx
leaq 0x60(%rsp), %rdi
callq 0xc9180
movb %al, 0x1f(%rsp)
jmp 0xcb954
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0xcb9d0
jmp 0xcb95e
movq 0x9967b(%rip), %rdi     # 0x164fe0
leaq 0x65827(%rip), %rsi     # 0x131193
callq 0x86700
movq %rax, 0x10(%rsp)
jmp 0xcb978
movq 0x10(%rsp), %rdi
movq 0x48(%rsp), %rax
movq (%rax), %rsi
addq $0x50, %rsi
callq 0x86640
movq %rax, 0x8(%rsp)
jmp 0xcb995
movq 0x8(%rsp), %rdi
leaq 0x65828(%rip), %rsi     # 0x1311c9
callq 0x86700
movq %rax, (%rsp)
jmp 0xcb9ac
movq (%rsp), %rdi
movq 0x995b9(%rip), %rsi     # 0x164f70
callq 0x86770
jmp 0xcb9be
movb $0x0, 0x277(%rsp)
movl $0x1, 0x50(%rsp)
jmp 0xcb9e0
movb $0x1, 0x277(%rsp)
movl $0x1, 0x50(%rsp)
leaq 0x60(%rsp), %rdi
callq 0xcffd0
jmp 0xcb9ee
jmp 0xcb9ff
movb 0x277(%rsp), %al
andb $0x1, %al
addq $0x278, %rsp            # imm = 0x278
retq
movq 0x58(%rsp), %rdi
callq 0x86d80
movq %rax, %rdi
callq 0x91290
nopw %cs:(%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/toolkit/bamtools_resolve.cpp
// Function: BamTools::ResolveTool::ResolveToolPrivate::WriteStatsFile()
bool ResolveTool::ResolveToolPrivate::WriteStatsFile(void) {

    // skip if no filename provided
    if ( m_settings->StatsFilename.empty() )
        return false;

    // attempt to open stats file
    ResolveTool::StatsFileWriter statsWriter;
    if ( !statsWriter.Open(m_settings->StatsFilename) ) {
        cerr << "bamtools resolve ERROR - could not open stats file: "
             << m_settings->StatsFilename << " for writing" << endl;
        return false;
    }

    // attempt to write stats data
    if ( !statsWriter.Write(m_settings, m_readGroups) ) {
        cerr << "bamtools resolve ERROR - could not write stats file: "
             << m_settings->StatsFilename << " for data" << endl;
        return false;
    }

    // return success
    return true;
}

// Assembly:
subq $0x278, %rsp            # imm = 0x278
movq %rdi, 0x268(%rsp)
movq 0x268(%rsp), %rax
movq %rax, 0x50(%rsp)
movq (%rax), %rdi
addq $0x50, %rdi
callq 0x86c90
testb $0x1, %al
jne 0xccc0e
jmp 0xccc1b
movb $0x0, 0x277(%rsp)
jmp 0xccda0
leaq 0x68(%rsp), %rdi
movq %rdi, 0x40(%rsp)
callq 0xd01d0
movq 0x50(%rsp), %rax
movq 0x40(%rsp), %rdi
movq (%rax), %rsi
addq $0x50, %rsi
callq 0xc9560
movb %al, 0x4f(%rsp)
jmp 0xccc46
movb 0x4f(%rsp), %al
testb $0x1, %al
jne 0xccce8
jmp 0xccc54
movq 0x98385(%rip), %rdi     # 0x164fe0
leaq 0x644fc(%rip), %rsi     # 0x13115e
callq 0x86700
movq %rax, 0x38(%rsp)
jmp 0xccc6e
movq 0x38(%rsp), %rdi
movq 0x50(%rsp), %rax
movq (%rax), %rsi
addq $0x50, %rsi
callq 0x86640
movq %rax, 0x30(%rsp)
jmp 0xccc8b
movq 0x30(%rsp), %rdi
leaq 0x647a1(%rip), %rsi     # 0x131438
callq 0x86700
movq %rax, 0x28(%rsp)
jmp 0xccca3
movq 0x28(%rsp), %rdi
movq 0x982c1(%rip), %rsi     # 0x164f70
callq 0x86770
jmp 0xcccb6
movb $0x0, 0x277(%rsp)
movl $0x1, 0x58(%rsp)
jmp 0xccd92
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x68(%rsp), %rdi
callq 0xd01e0
jmp 0xccd9e
movq 0x50(%rsp), %rdx
movq (%rdx), %rsi
addq $0x8, %rdx
leaq 0x68(%rsp), %rdi
callq 0xc95b0
movb %al, 0x27(%rsp)
jmp 0xccd04
movb 0x27(%rsp), %al
testb $0x1, %al
jne 0xccd82
jmp 0xccd0e
movq 0x982cb(%rip), %rdi     # 0x164fe0
leaq 0x64648(%rip), %rsi     # 0x131364
callq 0x86700
movq %rax, 0x18(%rsp)
jmp 0xccd28
movq 0x18(%rsp), %rdi
movq 0x50(%rsp), %rax
movq (%rax), %rsi
addq $0x50, %rsi
callq 0x86640
movq %rax, 0x10(%rsp)
jmp 0xccd45
movq 0x10(%rsp), %rdi
leaq 0x64478(%rip), %rsi     # 0x1311c9
callq 0x86700
movq %rax, 0x8(%rsp)
jmp 0xccd5d
movq 0x8(%rsp), %rdi
movq 0x98207(%rip), %rsi     # 0x164f70
callq 0x86770
jmp 0xccd70
movb $0x0, 0x277(%rsp)
movl $0x1, 0x58(%rsp)
jmp 0xccd92
movb $0x1, 0x277(%rsp)
movl $0x1, 0x58(%rsp)
leaq 0x68(%rsp), %rdi
callq 0xd01e0
jmp 0xccda0
jmp 0xccdb1
movb 0x277(%rsp), %al
andb $0x1, %al
addq $0x278, %rsp            # imm = 0x278
retq
movq 0x60(%rsp), %rdi
callq 0x86d80
movq %rax, %rdi
callq 0x91290
nopw %cs:(%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/toolkit/bamtools_resolve.cpp
// Function: BamTools::ResolveTool::~ResolveTool()
ResolveTool::~ResolveTool(void) {

    delete m_settings;
    m_settings = 0;

    delete m_impl;
    m_impl = 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x95f56(%rip), %rcx     # 0x164a80
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0xceb56
movq 0x18(%rsp), %rdi
callq 0xd07a0
jmp 0xceb4c
movq 0x18(%rsp), %rdi
callq 0x866a0
movq 0x10(%rsp), %rax
movq $0x0, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0xceb88
movq 0x8(%rsp), %rdi
callq 0xd0870
jmp 0xceb7e
movq 0x8(%rsp), %rdi
callq 0x866a0
movq 0x10(%rsp), %rdi
movq $0x0, 0x10(%rdi)
callq 0x92a20
addq $0x38, %rsp
retq
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x866a0
jmp 0xcebd1
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x866a0
movq 0x10(%rsp), %rdi
callq 0x92a20
jmp 0xcebdd
jmp 0xcebdf
movq 0x28(%rsp), %rdi
callq 0x86d80
movq %rax, %rdi
callq 0x91290
nopw %cs:(%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/toolkit/bamtools_resolve.cpp
// Function: BamTools::ResolveTool::Run(int, char**)
int ResolveTool::Run(int argc, char* argv[]) {

    // parse command line arguments
    Options::Parse(argc, argv, 1);

    // initialize ResolveTool
    m_impl = new ResolveToolPrivate(m_settings);

    // run ResolveTool, return success/failure
    if ( m_impl->Run() )
        return 0;
    else
        return 1;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x34(%rsp), %edi
movq 0x28(%rsp), %rsi
movl $0x1, %edx
callq 0x10e260
movl $0x38, %edi
callq 0x86720
movq %rax, %rdi
movq 0x8(%rsp), %rax
movq %rdi, %rcx
movq %rcx, 0x10(%rsp)
movq 0x8(%rax), %rsi
callq 0xd0890
jmp 0xcecb4
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%rax), %rdi
callq 0xcc3f0
testb $0x1, %al
jne 0xcecd1
jmp 0xcecf5
movl $0x0, 0x44(%rsp)
jmp 0xcecfd
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x866a0
jmp 0xced06
movl $0x1, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x86d80
// File: zeeev[P]DASVC/bamtools/src/toolkit/bamtools_revert.cpp
// Function: BamTools::RevertTool::RevertToolPrivate::RevertAlignment(BamTools::BamAlignment&)
void RevertTool::RevertToolPrivate::RevertAlignment(BamAlignment& al) {

    // replace Qualities with OQ contents, if requested
    if ( !m_settings->IsKeepQualities ) {
        string originalQualities;
        if ( al.GetTag(OQ_TAG, originalQualities) ) {
            al.Qualities = originalQualities;
            al.RemoveTag(OQ_TAG);
        }
    }

    // clear duplicate flag, if requested
    if ( !m_settings->IsKeepDuplicateFlag )
        al.SetIsDuplicate(false);
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movq (%rax), %rax
testb $0x1, 0x4(%rax)
jne 0xd98da
leaq 0x28(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x86a30
movq (%rsp), %rdx
movq 0x48(%rsp), %rdi
leaq 0x8c5b5(%rip), %rsi     # 0x165e28
callq 0xbe2f0
movb %al, 0xf(%rsp)
jmp 0xd987e
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0xd9888
jmp 0xd98cc
movq 0x48(%rsp), %rdi
addq $0x68, %rdi
leaq 0x28(%rsp), %rsi
callq 0x86070
jmp 0xd989d
movq 0x48(%rsp), %rdi
leaq 0x8c57f(%rip), %rsi     # 0x165e28
callq 0x86800
jmp 0xd98b0
jmp 0xd98cc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x86f68
jmp 0xd98d8
leaq 0x28(%rsp), %rdi
callq 0x86f68
jmp 0xd98da
jmp 0xd98f9
movq 0x10(%rsp), %rax
movq (%rax), %rax
testb $0x1, 0x3(%rax)
jne 0xd98f4
movq 0x48(%rsp), %rdi
xorl %esi, %esi
callq 0x86f40
addq $0x58, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x86d80
movq %rax, %rdi
callq 0x91290
nopl (%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/toolkit/bamtools_revert.cpp
// Function: BamTools::RevertTool::~RevertTool()
RevertTool::~RevertTool(void) {

    delete m_settings;
    m_settings = 0;
    
    delete m_impl;
    m_impl = 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x8a066(%rip), %rcx     # 0x164b00
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0xdaac6
movq 0x18(%rsp), %rdi
callq 0xdad20
jmp 0xdaabc
movq 0x18(%rsp), %rdi
callq 0x866a0
movq 0x10(%rsp), %rax
movq $0x0, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0xdaaf8
movq 0x8(%rsp), %rdi
callq 0xdad90
jmp 0xdaaee
movq 0x8(%rsp), %rdi
callq 0x866a0
movq 0x10(%rsp), %rdi
movq $0x0, 0x10(%rdi)
callq 0x92a20
addq $0x38, %rsp
retq
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x866a0
jmp 0xdab41
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x866a0
movq 0x10(%rsp), %rdi
callq 0x92a20
jmp 0xdab4d
jmp 0xdab4f
movq 0x28(%rsp), %rdi
callq 0x86d80
movq %rax, %rdi
callq 0x91290
nopw %cs:(%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/toolkit/bamtools_revert.cpp
// Function: BamTools::RevertTool::Run(int, char**)
int RevertTool::Run(int argc, char* argv[]) {
  
    // parse command line arguments
    Options::Parse(argc, argv, 1);

    // intialize RevertTool with settings
    m_impl = new RevertToolPrivate(m_settings);
    
    // run RevertTool, return success/fail
    if ( m_impl->Run() )
        return 0;
    else
        return 1;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x34(%rsp), %edi
movq 0x28(%rsp), %rsi
movl $0x1, %edx
callq 0x10e260
movl $0x8, %edi
callq 0x86720
movq %rax, %rdi
movq 0x8(%rsp), %rax
movq %rdi, %rcx
movq %rcx, 0x10(%rsp)
movq 0x8(%rax), %rsi
callq 0xdada0
jmp 0xdac24
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%rax), %rdi
callq 0xd9910
testb $0x1, %al
jne 0xdac41
jmp 0xdac65
movl $0x0, 0x44(%rsp)
jmp 0xdac6d
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x866a0
jmp 0xdac76
movl $0x1, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x86d80
// File: zeeev[P]DASVC/bamtools/src/toolkit/bamtools_sort.cpp
// Function: BamTools::SortTool::SortToolPrivate::SortToolPrivate(BamTools::SortTool::SortSettings*)
SortTool::SortToolPrivate::SortToolPrivate(SortTool::SortSettings* settings) 
    : m_settings(settings)
    , m_numberOfRuns(0) 
{ 
    // set filename stub depending on inputfile path
    // that way multiple sort runs don't trip on each other's temp files
    if ( m_settings) {
        size_t extensionFound = m_settings->InputBamFilename.find(".bam");
        if ( extensionFound != string::npos )
            m_tempFilenameStub = m_settings->InputBamFilename.substr(0,extensionFound);
        m_tempFilenameStub.append(".sort.temp.");
    }
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rdi
movq %rdi, 0x20(%rsp)
movq 0x68(%rsp), %rax
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, 0x18(%rsp)
callq 0x86a30
movq 0x20(%rsp), %rdi
movl $0x0, 0x28(%rdi)
addq $0x30, %rdi
movq %rdi, 0x28(%rsp)
callq 0x86a30
jmp 0xdae0a
movq 0x20(%rsp), %rdi
addq $0x50, %rdi
movq %rdi, 0x10(%rsp)
callq 0x92d70
jmp 0xdae1f
movq 0x20(%rsp), %rdi
addq $0x68, %rdi
movq %rdi, 0x8(%rsp)
callq 0x92a40
jmp 0xdae34
movq 0x20(%rsp), %rax
cmpq $0x0, (%rax)
je 0xdaf36
movq 0x20(%rsp), %rax
movq (%rax), %rdi
addq $0x8, %rdi
leaq 0x574c9(%rip), %rsi     # 0x13231f
xorl %eax, %eax
movl %eax, %edx
callq 0x86f10
movq %rax, (%rsp)
jmp 0xdae65
movq (%rsp), %rax
movq %rax, 0x50(%rsp)
cmpq $-0x1, 0x50(%rsp)
je 0xdaf1d
movq 0x20(%rsp), %rax
movq (%rax), %rsi
addq $0x8, %rsi
movq 0x50(%rsp), %rcx
xorl %eax, %eax
movl %eax, %edx
leaq 0x30(%rsp), %rdi
callq 0x86750
jmp 0xdae9b
movq 0x20(%rsp), %rdi
addq $0x8, %rdi
leaq 0x30(%rsp), %rsi
callq 0x86070
jmp 0xdaeb0
leaq 0x30(%rsp), %rdi
callq 0x86f68
jmp 0xdaebc
jmp 0xdaf1d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0xdaf65
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0xdaf57
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0xdaf49
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0xdaf3b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x86f68
jmp 0xdaf1b
jmp 0xdaf3b
movq 0x20(%rsp), %rdi
addq $0x8, %rdi
leaq 0x573f7(%rip), %rsi     # 0x132324
callq 0x86ed0
jmp 0xdaf34
jmp 0xdaf36
addq $0x78, %rsp
retq
movq 0x8(%rsp), %rdi
callq 0x92a50
jmp 0xdaf47
jmp 0xdaf49
movq 0x10(%rsp), %rdi
callq 0x91560
jmp 0xdaf55
jmp 0xdaf57
movq 0x28(%rsp), %rdi
callq 0x86f68
jmp 0xdaf63
jmp 0xdaf65
movq 0x18(%rsp), %rdi
callq 0x86f68
jmp 0xdaf71
jmp 0xdaf73
movq 0x60(%rsp), %rdi
callq 0x86d80
movq %rax, %rdi
callq 0x91290
nopw %cs:(%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/toolkit/bamtools_sort.cpp
// Function: BamTools::SortTool::SortToolPrivate::CreateSortedTempFile(std::vector<BamTools::BamAlignment, std::allocator<BamTools::BamAlignment>>&)
bool SortTool::SortToolPrivate::CreateSortedTempFile(vector<BamAlignment>& buffer) {
 
    // do sorting
    SortBuffer(buffer);
  
    // write sorted contents to temp file, store success/fail
    stringstream tempStr;
    tempStr << m_tempFilenameStub << m_numberOfRuns;
    bool success = WriteTempFile( buffer, tempStr.str() );
    
    // save temp filename for merging later
    m_tempFilenames.push_back(tempStr.str());
    
    // clear buffer contents & update run counter
    buffer.clear();
    ++m_numberOfRuns;
    
    // return success/fail of writing to temp file
    // TODO: a failure returned here is not actually caught and handled anywhere
    return success;
}

// Assembly:
subq $0x218, %rsp            # imm = 0x218
movq %rdi, 0x210(%rsp)
movq %rsi, 0x208(%rsp)
movq 0x210(%rsp), %rdi
movq %rdi, 0x20(%rsp)
movq 0x208(%rsp), %rsi
callq 0xdb650
leaq 0x80(%rsp), %rdi
callq 0x86520
movq 0x20(%rsp), %rsi
leaq 0x90(%rsp), %rdi
addq $0x8, %rsi
callq 0x86640
movq %rax, 0x28(%rsp)
jmp 0xdb4fb
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rax
movl 0x28(%rax), %esi
callq 0x86d40
jmp 0xdb50f
movq 0x208(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x866f0
jmp 0xdb530
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdi
leaq 0x50(%rsp), %rdx
callq 0xdb710
movb %al, 0x17(%rsp)
jmp 0xdb54a
leaq 0x50(%rsp), %rdi
callq 0x86f68
jmp 0xdb556
movq 0x20(%rsp), %rax
movb 0x17(%rsp), %cl
andb $0x1, %cl
movb %cl, 0x73(%rsp)
addq $0x68, %rax
movq %rax, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x866f0
jmp 0xdb583
movq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x91220
jmp 0xdb594
leaq 0x30(%rsp), %rdi
callq 0x86f68
jmp 0xdb5a0
movq 0x208(%rsp), %rdi
callq 0xdd200
jmp 0xdb5af
movq 0x20(%rsp), %rax
movl 0x28(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x28(%rax)
movb 0x73(%rsp), %al
movb %al, 0x7(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x86580
movb 0x7(%rsp), %al
andb $0x1, %al
addq $0x218, %rsp            # imm = 0x218
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0xdb628
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x86f68
jmp 0xdb60a
jmp 0xdb628
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x86f68
jmp 0xdb626
jmp 0xdb628
leaq 0x80(%rsp), %rdi
callq 0x86580
jmp 0xdb637
jmp 0xdb639
movq 0x78(%rsp), %rdi
callq 0x86d80
movq %rax, %rdi
callq 0x91290
nopl (%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/toolkit/bamtools_sort.cpp
// Function: BamTools::SortTool::SortToolPrivate::SortBuffer(std::vector<BamTools::BamAlignment, std::allocator<BamTools::BamAlignment>>&)
void SortTool::SortToolPrivate::SortBuffer(vector<BamAlignment>& buffer) {
 
    // ** add further custom sort options later ?? **
    
    // sort buffer by desired method
    if ( m_settings->IsSortingByName )
        std::stable_sort( buffer.begin(), buffer.end(), Sort::ByName() );
    else
        std::stable_sort( buffer.begin(), buffer.end(), Sort::ByPosition() );
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq (%rax), %rax
testb $0x1, 0x4(%rax)
je 0xdb6b6
movq 0x38(%rsp), %rdi
callq 0xdd280
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
callq 0xdd2b0
movq %rax, 0x28(%rsp)
movl $0x0, 0x20(%rsp)
leaq 0x24(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0xdd2e0
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movl 0x24(%rsp), %edx
callq 0xdd220
jmp 0xdb6fe
movq 0x38(%rsp), %rdi
callq 0xdd280
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
callq 0xdd2b0
movq %rax, 0x10(%rsp)
movl $0x0, 0x8(%rsp)
leaq 0xc(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xdd360
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl 0xc(%rsp), %edx
callq 0xdd300
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/toolkit/bamtools_sort.cpp
// Function: BamTools::SortTool::SortToolPrivate::WriteTempFile(std::vector<BamTools::BamAlignment, std::allocator<BamTools::BamAlignment>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool SortTool::SortToolPrivate::WriteTempFile(const vector<BamAlignment>& buffer,
                                              const string& tempFilename)
{
    // open temp file for writing
    BamWriter tempWriter;
    if ( !tempWriter.Open(tempFilename, m_headerText, m_references) ) {
        cerr << "bamtools sort ERROR: could not open " << tempFilename
             << " for writing." << endl;
        return false;
    }
  
    // write data
    vector<BamAlignment>::const_iterator buffIter = buffer.begin();
    vector<BamAlignment>::const_iterator buffEnd  = buffer.end();
    for ( ; buffIter != buffEnd; ++buffIter )  {
        const BamAlignment& al = (*buffIter);
        tempWriter.SaveAlignment(al);
    }
  
    // close temp file & return success
    tempWriter.Close();
    return true;
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0x98(%rsp)
movq %rsi, 0x90(%rsp)
movq %rdx, 0x88(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x40(%rsp)
leaq 0x80(%rsp), %rdi
movq %rdi, 0x48(%rsp)
callq 0x863f0
movq 0x40(%rsp), %rcx
movq 0x48(%rsp), %rdi
movq 0x88(%rsp), %rsi
movq %rcx, %rdx
addq $0x30, %rdx
addq $0x50, %rcx
callq 0x86bd0
movb %al, 0x57(%rsp)
jmp 0xdb776
movb 0x57(%rsp), %al
testb $0x1, %al
jne 0xdb817
jmp 0xdb784
movq 0x89855(%rip), %rdi     # 0x164fe0
leaq 0x56b9e(%rip), %rsi     # 0x132330
callq 0x86700
movq %rax, 0x38(%rsp)
jmp 0xdb79e
movq 0x38(%rsp), %rdi
movq 0x88(%rsp), %rsi
callq 0x86640
movq %rax, 0x30(%rsp)
jmp 0xdb7b7
movq 0x30(%rsp), %rdi
leaq 0x53e82(%rip), %rsi     # 0x12f645
callq 0x86700
movq %rax, 0x28(%rsp)
jmp 0xdb7cf
movq 0x28(%rsp), %rdi
movq 0x89795(%rip), %rsi     # 0x164f70
callq 0x86770
jmp 0xdb7e2
movb $0x0, 0xa7(%rsp)
movl $0x1, 0x70(%rsp)
jmp 0xdb8d0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x86510
jmp 0xdb8ee
movq 0x90(%rsp), %rdi
callq 0xdd380
movq %rax, 0x20(%rsp)
jmp 0xdb82b
movq 0x20(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x90(%rsp), %rdi
callq 0xdd3b0
movq %rax, 0x18(%rsp)
jmp 0xdb849
movq 0x18(%rsp), %rax
movq %rax, 0x60(%rsp)
leaq 0x68(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0xdd3e0
movb %al, 0x17(%rsp)
jmp 0xdb868
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0xdb872
jmp 0xdb8b1
leaq 0x68(%rsp), %rdi
callq 0xdd420
movq %rax, 0x8(%rsp)
jmp 0xdb883
movq 0x8(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rsi
leaq 0x80(%rsp), %rdi
callq 0x86e80
jmp 0xdb8a1
jmp 0xdb8a3
leaq 0x68(%rsp), %rdi
callq 0xdd430
jmp 0xdb8af
jmp 0xdb853
leaq 0x80(%rsp), %rdi
callq 0x86410
jmp 0xdb8c0
movb $0x1, 0xa7(%rsp)
movl $0x1, 0x70(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x86510
movb 0xa7(%rsp), %al
andb $0x1, %al
addq $0xa8, %rsp
retq
jmp 0xdb8f0
movq 0x78(%rsp), %rdi
callq 0x86d80
movq %rax, %rdi
callq 0x91290
nopw %cs:(%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/toolkit/bamtools_sort.cpp
// Function: BamTools::SortTool::SortToolPrivate::Run()
bool SortTool::SortToolPrivate::Run(void) {
 
    // this does a single pass, chunking up the input file into smaller sorted temp files, 
    // then write out using BamMultiReader to handle merging
    
    if ( GenerateSortedRuns() )
        return MergeSortedRuns();
    else 
        return false;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xdaf90
testb $0x1, %al
jne 0xdbccd
jmp 0xdbcde
movq (%rsp), %rdi
callq 0xdb910
andb $0x1, %al
movb %al, 0x17(%rsp)
jmp 0xdbce3
movb $0x0, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nop
// File: zeeev[P]DASVC/bamtools/src/toolkit/bamtools_sort.cpp
// Function: BamTools::SortTool::~SortTool()
SortTool::~SortTool(void) {

    delete m_settings;
    m_settings = 0;

    delete m_impl;
    m_impl = 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x87dbe(%rip), %rcx     # 0x164b48
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0xdcdb6
movq 0x18(%rsp), %rdi
callq 0xdd500
jmp 0xdcdac
movq 0x18(%rsp), %rdi
callq 0x866a0
movq 0x10(%rsp), %rax
movq $0x0, 0x8(%rax)
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0xdcde8
movq 0x8(%rsp), %rdi
callq 0xdd570
jmp 0xdcdde
movq 0x8(%rsp), %rdi
callq 0x866a0
movq 0x10(%rsp), %rdi
movq $0x0, 0x10(%rdi)
callq 0x92a20
addq $0x38, %rsp
retq
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x866a0
jmp 0xdce31
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x866a0
movq 0x10(%rsp), %rdi
callq 0x92a20
jmp 0xdce3d
jmp 0xdce3f
movq 0x28(%rsp), %rdi
callq 0x86d80
movq %rax, %rdi
callq 0x91290
nopw %cs:(%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/toolkit/bamtools_sort.cpp
// Function: BamTools::SortTool::Run(int, char**)
int SortTool::Run(int argc, char* argv[]) {

    // parse command line arguments
    Options::Parse(argc, argv, 1);

    // initialize SortTool with settings
    m_impl = new SortToolPrivate(m_settings);

    // run SortTool, return success/fail
    if ( m_impl->Run() )
        return 0;
    else
        return 1;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x34(%rsp), %edi
movq 0x28(%rsp), %rsi
movl $0x1, %edx
callq 0x10e260
movl $0x80, %edi
callq 0x86720
movq %rax, %rdi
movq 0x8(%rsp), %rax
movq %rdi, %rcx
movq %rcx, 0x10(%rsp)
movq 0x8(%rax), %rsi
callq 0xdadc0
jmp 0xdcf14
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%rax), %rdi
callq 0xdbcb0
testb $0x1, %al
jne 0xdcf31
jmp 0xdcf55
movl $0x0, 0x44(%rsp)
jmp 0xdcf5d
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x866a0
jmp 0xdcf66
movl $0x1, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x86d80
// File: zeeev[P]DASVC/bamtools/src/toolkit/bamtools_split.cpp
// Function: BamTools::GetTimestampString[abi:cxx11]()
string GetTimestampString(void) {

    // get human readable timestamp
    time_t currentTime;
    time(&currentTime);
    stringstream timeStream("");
    timeStream << ctime(&currentTime);

    // convert whitespace to '_'
    string timeString = timeStream.str();
    size_t found = timeString.find(" ");
    while (found != string::npos) {
        timeString.replace(found, 1, "_");
        found = timeString.find(" ", found+1);
    }
    return timeString;
}

// Assembly:
subq $0x218, %rsp            # imm = 0x218
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0x210(%rsp)
leaq 0x208(%rsp), %rdi
callq 0x86670
leaq 0x5f(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0x86da0
movq 0x38(%rsp), %rdx
leaq 0x4ff0f(%rip), %rsi     # 0x134c73
leaq 0x60(%rsp), %rdi
callq 0x86a00
jmp 0xe4d70
movl $0x10, %edi
movl $0x8, %esi
callq 0x928c0
movl %eax, 0x24(%rsp)
jmp 0xe4d85
movl 0x24(%rsp), %edx
leaq 0x80(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x86be0
jmp 0xe4d9d
leaq 0x60(%rsp), %rdi
callq 0x86f68
jmp 0xe4da9
leaq 0x5f(%rsp), %rdi
callq 0x867b0
leaq 0x90(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x208(%rsp), %rdi
callq 0x862e0
movq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0x86700
jmp 0xe4ddc
movq 0x28(%rsp), %rdi
movb $0x0, 0x4b(%rsp)
leaq 0x80(%rsp), %rsi
callq 0x866f0
jmp 0xe4df5
movq 0x28(%rsp), %rdi
leaq 0x4e862(%rip), %rsi     # 0x133663
xorl %eax, %eax
movl %eax, %edx
callq 0x86f10
movq %rax, 0x10(%rsp)
jmp 0xe4e11
movq 0x10(%rsp), %rax
movq %rax, 0x40(%rsp)
cmpq $-0x1, 0x40(%rsp)
je 0xe4ed2
movq 0x28(%rsp), %rdi
movq 0x40(%rsp), %rsi
leaq 0x4e032(%rip), %rcx     # 0x132e6a
movl $0x1, %edx
callq 0x86440
jmp 0xe4e44
movq 0x28(%rsp), %rdi
movq 0x40(%rsp), %rdx
incq %rdx
leaq 0x4e80b(%rip), %rsi     # 0x133663
callq 0x86f10
movq %rax, 0x8(%rsp)
jmp 0xe4e64
movq 0x8(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0xe4e1b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0xe4e9c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x86f68
jmp 0xe4e9a
jmp 0xe4e9c
leaq 0x5f(%rsp), %rdi
callq 0x867b0
jmp 0xe4f19
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0xe4f08
movq 0x28(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
callq 0x86f68
jmp 0xe4f06
movb $0x1, 0x4b(%rsp)
testb $0x1, 0x4b(%rsp)
jne 0xe4eec
movq 0x28(%rsp), %rdi
callq 0x86f68
jmp 0xe4eea
jmp 0xe4eec
leaq 0x80(%rsp), %rdi
callq 0x86580
movq 0x30(%rsp), %rax
addq $0x218, %rsp            # imm = 0x218
retq
jmp 0xe4f08
leaq 0x80(%rsp), %rdi
callq 0x86580
jmp 0xe4f17
jmp 0xe4f19
movq 0x50(%rsp), %rdi
callq 0x86d80
movq %rax, %rdi
callq 0x91290
nopl (%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/toolkit/bamtools_split.cpp
// Function: BamTools::SplitTool::SplitToolPrivate::DetermineOutputFilenameStub()
void SplitTool::SplitToolPrivate::DetermineOutputFilenameStub(void) {
  
    // if user supplied output filename stub, use that
    if ( m_settings->HasCustomOutputStub ) 
        m_outputFilenameStub = m_settings->CustomOutputStub;
    
    // else if user supplied input BAM filename, use that (minus ".bam" extension) as stub
    else if ( m_settings->HasInputFilename )
        m_outputFilenameStub = RemoveFilenameExtension(m_settings->InputFilename);
        
    // otherwise, user did not specify -stub, and input is coming from STDIN
    // generate stub from timestamp
    else m_outputFilenameStub = GetTimestampString();      
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x18(%rsp)
movq (%rax), %rax
testb $0x1, 0x1(%rax)
je 0xe4fc6
movq 0x18(%rsp), %rdi
movq (%rdi), %rsi
addq $0x10, %rsi
addq $0x8, %rdi
callq 0x86070
jmp 0xe5079
movq 0x18(%rsp), %rax
movq (%rax), %rax
testb $0x1, (%rax)
je 0xe502b
movq 0x18(%rsp), %rax
movq (%rax), %rsi
addq $0x70, %rsi
leaq 0x50(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xe4f30
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
addq $0x8, %rdi
callq 0x86070
jmp 0xe5003
leaq 0x50(%rsp), %rdi
callq 0x86f68
jmp 0xe5077
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x86f68
jmp 0xe5029
jmp 0xe507e
leaq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xe4d20
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x8, %rdi
callq 0x86070
jmp 0xe504f
leaq 0x20(%rsp), %rdi
callq 0x86f68
jmp 0xe5077
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x86f68
jmp 0xe5075
jmp 0xe507e
jmp 0xe5079
addq $0x78, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x86d80
movq %rax, %rdi
callq 0x91290