LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: eecs280staff[P]unit_test_framework/./unit_test_framework.hpp
// Function: unit_test_framework::Assertions::assert_false(bool, int, char const*)
static void assert_false(bool value, int line_number,
                             const char* assertion_text) {
      if (not value) {
        return;
      }
      std::ostringstream reason;
      reason << "Expected false, but was true";
      throw TestFailure(reason.str(), line_number, assertion_text);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
movb %dil, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
testb $0x1, -0x1(%rbp)
jne 0x58f9
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
leaq -0x188(%rbp), %rdi
movq %rdi, -0x1c8(%rbp)
callq 0x2250
movq -0x1c8(%rbp), %rdi
leaq 0x2ca7(%rip), %rsi      # 0x85c1
callq 0x2180
jmp 0x5921
movb $0x1, -0x1b9(%rbp)
movl $0x30, %edi
callq 0x2090
movq %rax, -0x1d0(%rbp)
leaq -0x1b8(%rbp), %rdi
leaq -0x188(%rbp), %rsi
callq 0x21b0
jmp 0x594e
movq -0x1d0(%rbp), %rdi
movl -0x8(%rbp), %edx
movq -0x10(%rbp), %rcx
leaq -0x1b8(%rbp), %rsi
callq 0x6260
jmp 0x596a
movq -0x1d0(%rbp), %rdi
movb $0x0, -0x1b9(%rbp)
leaq 0x6411(%rip), %rsi      # 0xbd90
leaq 0x91a(%rip), %rdx       # 0x62a0
callq 0x22a0
jmp 0x5a04
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
jmp 0x59ec
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
jmp 0x59d3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x190(%rbp)
movl %eax, -0x194(%rbp)
leaq -0x1b8(%rbp), %rdi
callq 0x20c0
testb $0x1, -0x1b9(%rbp)
jne 0x59de
jmp 0x59ea
movq -0x1d0(%rbp), %rdi
callq 0x2110
jmp 0x59ec
leaq -0x188(%rbp), %rdi
callq 0x2040
movq -0x190(%rbp), %rdi
callq 0x22c0
nopw %cs:(%rax,%rax)
nop
// File: zeeev[P]DASVC/bamtools/src/toolkit/bamtools_convert.cpp
// Function: BamTools::ConvertTool::ConvertToolPrivate::RunPileupConversion(BamTools::BamMultiReader*)
bool ConvertTool::ConvertToolPrivate::RunPileupConversion(BamMultiReader* reader) {
  
    // check for valid BamMultiReader
    if ( reader == 0 ) return false;
  
    // set up our pileup format 'visitor'
    ConvertPileupFormatVisitor* v = new ConvertPileupFormatVisitor(m_references, 
                                                                   m_settings->FastaFilename,
                                                                   m_settings->IsPrintingPileupMapQualities, 
                                                                   &m_out);

    // set up PileupEngine
    PileupEngine pileup;
    pileup.AddVisitor(v);
    
    // iterate through data
    BamAlignment al;
    while ( reader->GetNextAlignment(al) )
        pileup.AddAlignment(al);
    pileup.Flush();
    
    // clean up
    delete v;
    v = 0;
    
    // return success
    return true;
}

// Assembly:
subq $0x1b8, %rsp            # imm = 0x1B8
movq %rdi, 0x1a8(%rsp)
movq %rsi, 0x1a0(%rsp)
movq 0x1a8(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x1a0(%rsp)
jne 0x8c35c
movb $0x0, 0x1b7(%rsp)
jmp 0x8c4e5
movl $0x38, %edi
callq 0x86720
movq 0x20(%rsp), %r8
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %r8, %rsi
addq $0x8, %rsi
movq (%r8), %rax
movq %rax, %rdx
addq $0xa0, %rdx
addq $0x20, %r8
movzbl 0x7(%rax), %ecx
andl $0x1, %ecx
callq 0x8ff60
jmp 0x8c39c
movq 0x18(%rsp), %rax
movq %rax, 0x198(%rsp)
leaq 0x180(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x111d30
movq 0x10(%rsp), %rdi
movq 0x198(%rsp), %rsi
callq 0x111e40
jmp 0x8c3cf
leaq 0x28(%rsp), %rdi
callq 0x86260
jmp 0x8c3db
jmp 0x8c3dd
movq 0x1a0(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x86330
movb %al, 0xf(%rsp)
jmp 0x8c3f5
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x8c3ff
jmp 0x8c471
leaq 0x180(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x111e10
jmp 0x8c413
jmp 0x8c3dd
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x190(%rsp)
movl %eax, 0x18c(%rsp)
callq 0x866a0
jmp 0x8c4f6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x190(%rsp)
movl %eax, 0x18c(%rsp)
jmp 0x8c4d4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x190(%rsp)
movl %eax, 0x18c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x86b30
jmp 0x8c4d2
leaq 0x180(%rsp), %rdi
callq 0x111e70
jmp 0x8c480
movq 0x198(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x8c4a3
movq (%rsp), %rdi
movq (%rdi), %rax
movq 0x8(%rax), %rax
callq *%rax
jmp 0x8c4a1
jmp 0x8c4a3
movq $0x0, 0x198(%rsp)
movb $0x1, 0x1b7(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x86b30
jmp 0x8c4c3
leaq 0x180(%rsp), %rdi
callq 0x111da0
jmp 0x8c4e5
jmp 0x8c4d4
leaq 0x180(%rsp), %rdi
callq 0x111da0
jmp 0x8c4e3
jmp 0x8c4f6
movb 0x1b7(%rsp), %al
andb $0x1, %al
addq $0x1b8, %rsp            # imm = 0x1B8
retq
movq 0x190(%rsp), %rdi
callq 0x86d80
movq %rax, %rdi
callq 0x91290
nopl (%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/toolkit/bamtools_convert.cpp
// Function: BamTools::ConvertTool::ConvertToolPrivate::PrintBed(BamTools::BamAlignment const&)
void ConvertTool::ConvertToolPrivate::PrintBed(const BamAlignment& a) { 
  
    // tab-delimited, 0-based half-open 
    // (e.g. a 50-base read aligned to pos 10 could have BED coordinates (10, 60) instead of BAM coordinates (10, 59) )
    // <chromName> <chromStart> <chromEnd> <readName> <score> <strand>

    m_out << m_references.at(a.RefID).RefName << "\t"
          << a.Position << "\t"
          << a.GetEndPosition() << "\t"
          << a.Name << "\t"
          << a.MapQuality << "\t"
          << (a.IsReverseStrand() ? "-" : "+") << endl;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, %rax
addq $0x20, %rax
movq %rax, 0x10(%rsp)
addq $0x8, %rdi
movq 0x28(%rsp), %rax
movslq 0xa8(%rax), %rsi
callq 0x916c0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x86640
movq %rax, %rdi
leaq 0xa8717(%rip), %rsi     # 0x134c72
callq 0x86700
movq %rax, %rdi
movq 0x28(%rsp), %rax
movl 0xac(%rax), %esi
callq 0x86d40
movq %rax, %rdi
leaq 0xa86f5(%rip), %rsi     # 0x134c72
callq 0x86700
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x86660
movq 0x18(%rsp), %rdi
movl %eax, %esi
callq 0x86d40
movq %rax, %rdi
leaq 0xa86c7(%rip), %rsi     # 0x134c72
callq 0x86700
movq %rax, %rdi
movq 0x28(%rsp), %rsi
callq 0x86640
movq %rax, %rdi
leaq 0xa86ab(%rip), %rsi     # 0x134c72
callq 0x86700
movq %rax, %rdi
movq 0x28(%rsp), %rax
movzwl 0xb2(%rax), %esi
callq 0x86cb0
movq %rax, %rdi
leaq 0xa8688(%rip), %rsi     # 0x134c72
callq 0x86700
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x86a40
testb $0x1, %al
jne 0x8c604
jmp 0x8c612
leaq 0xa1f09(%rip), %rax     # 0x12e514
movq %rax, 0x8(%rsp)
jmp 0x8c620
leaq 0xa1e31(%rip), %rax     # 0x12e44a
movq %rax, 0x8(%rsp)
jmp 0x8c620
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x86700
movq %rax, %rdi
movq 0xd8937(%rip), %rsi     # 0x164f70
callq 0x86770
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/toolkit/bamtools_convert.cpp
// Function: BamTools::ConvertTool::~ConvertTool()
ConvertTool::~ConvertTool(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 0xd47ce(%rip), %rcx     # 0x164548
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x8fda6
movq 0x18(%rsp), %rdi
callq 0x92460
jmp 0x8fd9c
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 0x8fdd8
movq 0x8(%rsp), %rdi
callq 0x92590
jmp 0x8fdce
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 0x8fe21
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 0x8fe2d
jmp 0x8fe2f
movq 0x28(%rsp), %rdi
callq 0x86d80
movq %rax, %rdi
callq 0x91290
nopw %cs:(%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/toolkit/bamtools_convert.cpp
// Function: BamTools::ConvertTool::Run(int, char**)
int ConvertTool::Run(int argc, char* argv[]) {
  
    // parse command line arguments
    Options::Parse(argc, argv, 1);
    
    // initialize ConvertTool with settings
    m_impl = new ConvertToolPrivate(m_settings);
    
    // run ConvertTool, 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 $0x130, %edi            # imm = 0x130
callq 0x86720
movq %rax, %rdi
movq 0x8(%rsp), %rax
movq %rdi, %rcx
movq %rcx, 0x10(%rsp)
movq 0x8(%rax), %rsi
callq 0x92600
jmp 0x8ff04
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%rax), %rdi
callq 0x8b680
testb $0x1, %al
jne 0x8ff21
jmp 0x8ff45
movl $0x0, 0x44(%rsp)
jmp 0x8ff4d
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x866a0
jmp 0x8ff56
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_convert.cpp
// Function: BamTools::ConvertPileupFormatVisitor::~ConvertPileupFormatVisitor()
ConvertPileupFormatVisitor::~ConvertPileupFormatVisitor(void) { 
    // be sure to close Fasta reader
    if ( m_hasFasta ) {
        m_fasta.Close();
        m_hasFasta = false;
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0xd431e(%rip), %rcx     # 0x164578
addq $0x10, %rcx
movq %rcx, (%rax)
testb $0x1, 0x10(%rax)
je 0x902a0
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
callq 0x10c0f0
jmp 0x90277
movq 0x8(%rsp), %rax
movb $0x0, 0x10(%rax)
jmp 0x902a0
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
addq $0x20, %rdi
callq 0x91560
jmp 0x902df
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
callq 0x91560
jmp 0x902b0
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
callq 0x10c080
jmp 0x902c0
movq 0x8(%rsp), %rdi
callq 0x92e50
addq $0x28, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
jmp 0x902f1
jmp 0x902f1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
jmp 0x90303
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
callq 0x10c080
jmp 0x90301
jmp 0x90303
movq 0x8(%rsp), %rdi
callq 0x92e50
jmp 0x9030f
jmp 0x90311
movq 0x18(%rsp), %rdi
callq 0x86d80
movq %rax, %rdi
callq 0x91290
nopw %cs:(%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/api/BamAux.h
// Function: BamTools::UnpackSignedShort(char const*)
API_EXPORT inline signed short UnpackSignedShort(const char* buffer) {
    union { signed short value; unsigned char valueBuffer[sizeof(signed short)]; } un;
    un.value = 0;
    un.valueBuffer[0] = buffer[0];
    un.valueBuffer[1] = buffer[1];
    return un.value;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movw $0x0, -0xa(%rsp)
movq -0x8(%rsp), %rax
movb (%rax), %al
movb %al, -0xa(%rsp)
movq -0x8(%rsp), %rax
movb 0x1(%rax), %al
movb %al, -0x9(%rsp)
movw -0xa(%rsp), %ax
retq
nopl (%rax)
// File: zeeev[P]DASVC/bamtools/src/api/BamAux.h
// Function: BamTools::UnpackFloat(char const*)
API_EXPORT inline float UnpackFloat(const char* buffer) {
    union { float value; unsigned char valueBuffer[sizeof(float)]; } un;
    un.value = 0;
    un.valueBuffer[0] = buffer[0];
    un.valueBuffer[1] = buffer[1];
    un.valueBuffer[2] = buffer[2];
    un.valueBuffer[3] = buffer[3];
    return un.value;
}

// Assembly:
movq %rdi, -0x8(%rsp)
xorps %xmm0, %xmm0
movss %xmm0, -0xc(%rsp)
movq -0x8(%rsp), %rax
movb (%rax), %al
movb %al, -0xc(%rsp)
movq -0x8(%rsp), %rax
movb 0x1(%rax), %al
movb %al, -0xb(%rsp)
movq -0x8(%rsp), %rax
movb 0x2(%rax), %al
movb %al, -0xa(%rsp)
movq -0x8(%rsp), %rax
movb 0x3(%rax), %al
movb %al, -0x9(%rsp)
movss -0xc(%rsp), %xmm0
retq
nopw %cs:(%rax,%rax)
nop
// File: zeeev[P]DASVC/bamtools/src/utils/bamtools_variant.h
// Function: BamTools::Variant::operator=(BamTools::Variant const&)
Variant& operator= (const Variant& rhs) {
            if ( rhs.data != NULL ) 
                rhs.data->AddRef();
            if ( data != NULL ) 
                data->Release();
            data = rhs.data;
            return *this;
        }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
je 0x94a1f
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x95150
movq (%rsp), %rax
cmpq $0x0, (%rax)
je 0x94a35
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x952b0
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: zeeev[P]DASVC/bamtools/src/utils/bamtools_options.h
// Function: BamTools::OptionValue::~OptionValue()
struct UTILS_EXPORT OptionValue {
  
    // data members
    bool* pFoundArgument;
    void* pValue;
    std::string ValueTypeDescription;
    bool UseVector;
    bool StoreValue;
    bool IsRequired;
    Variant VariantValue;

    // constructor
    OptionValue(void)
        : pFoundArgument(NULL)
        , pValue(NULL)
        , UseVector(false)
        , StoreValue(true)
        , IsRequired(false)
    { } 
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x38, %rdi
callq 0x94a50
jmp 0x94f9e
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
callq 0x86f68
addq $0x28, %rsp
retq
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
addq $0x10, %rdi
callq 0x86f68
jmp 0x94fcf
jmp 0x94fd1
movq 0x18(%rsp), %rdi
callq 0x86d80
movq %rax, %rdi
callq 0x91290
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: zeeev[P]DASVC/bamtools/src/utils/bamtools_options.h
// Function: BamTools::Option::~Option()
struct UTILS_EXPORT Option {
  
    // data members
    std::string Argument;
    std::string ValueDescription;
    std::string Description;
    bool StoreValue;
    bool HasDefaultValue;
    Variant DefaultValue;

    // constructor
    Option(void)
        : StoreValue(true)
        , HasDefaultValue(false)
    { }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x68, %rdi
callq 0x94a50
jmp 0x9500e
movq 0x8(%rsp), %rdi
addq $0x40, %rdi
callq 0x86f68
jmp 0x9501e
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
callq 0x86f68
jmp 0x9502e
movq 0x8(%rsp), %rdi
callq 0x86f68
addq $0x28, %rsp
retq
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
addq $0x40, %rdi
callq 0x86f68
jmp 0x9506b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
jmp 0x9507d
jmp 0x9507d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
jmp 0x9508f
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
callq 0x86f68
jmp 0x9508d
jmp 0x9508f
movq 0x8(%rsp), %rdi
callq 0x86f68
jmp 0x9509b
jmp 0x9509d
movq 0x18(%rsp), %rdi
callq 0x86d80
movq %rax, %rdi
callq 0x91290
nop
// File: zeeev[P]DASVC/bamtools/src/toolkit/bamtools_count.cpp
// Function: BamTools::CountTool::~CountTool()
CountTool::~CountTool(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 0xcbe1e(%rip), %rcx     # 0x1646e8
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x988f6
movq 0x18(%rsp), %rdi
callq 0x98b60
jmp 0x988ec
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 0x98928
movq 0x8(%rsp), %rdi
callq 0x98c00
jmp 0x9891e
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 0x98971
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 0x9897d
jmp 0x9897f
movq 0x28(%rsp), %rdi
callq 0x86d80
movq %rax, %rdi
callq 0x91290
nopw %cs:(%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/toolkit/bamtools_count.cpp
// Function: BamTools::CountTool::Run(int, char**)
int CountTool::Run(int argc, char* argv[]) { 

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

    // initialize CountTool with settings
    m_impl = new CountToolPrivate(m_settings);

    // run CountTool, 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 0x98c10
jmp 0x98a54
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%rax), %rdi
callq 0x97730
testb $0x1, %al
jne 0x98a71
jmp 0x98a95
movl $0x0, 0x44(%rsp)
jmp 0x98a9d
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x866a0
jmp 0x98aa6
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_coverage.cpp
// Function: BamTools::CoverageTool::~CoverageTool()
CoverageTool::~CoverageTool(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 0xcadc6(%rip), %rcx     # 0x164730
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x99996
movq 0x18(%rsp), %rdi
callq 0x99c70
jmp 0x9998c
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 0x999c8
movq 0x8(%rsp), %rdi
callq 0x99ce0
jmp 0x999be
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 0x99a11
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 0x99a1d
jmp 0x99a1f
movq 0x28(%rsp), %rdi
callq 0x86d80
movq %rax, %rdi
callq 0x91290
nopw %cs:(%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/toolkit/bamtools_coverage.cpp
// Function: BamTools::CoverageTool::Run(int, char**)
int CoverageTool::Run(int argc, char* argv[]) { 

    // parse command line arguments
    Options::Parse(argc, argv, 1);
    
    // initialize CoverageTool with settings
    m_impl = new CoverageToolPrivate(m_settings);
    
    // run CoverageTool, 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 $0x130, %edi            # imm = 0x130
callq 0x86720
movq %rax, %rdi
movq 0x8(%rsp), %rax
movq %rdi, %rcx
movq %rcx, 0x10(%rsp)
movq 0x8(%rax), %rsi
callq 0x99d50
jmp 0x99af4
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%rax), %rdi
callq 0x98c30
testb $0x1, %al
jne 0x99b11
jmp 0x99b35
movl $0x0, 0x44(%rsp)
jmp 0x99b3d
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x866a0
jmp 0x99b46
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_filter.cpp
// Function: BamTools::FilterTool::FilterToolPrivate::SetupFilters()
bool FilterTool::FilterToolPrivate::SetupFilters(void) {
  
    // set up filter engine with supported properties
    InitProperties();
    
    // parse script for filter rules, if given
    if ( m_settings->HasScript )
        return ParseScript();
    
    // otherwise check command line for filters
    else return ParseCommandLine();
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x9a980
movq (%rsp), %rax
movq 0x18(%rax), %rax
testb $0x1, 0x4(%rax)
je 0x9e356
movq (%rsp), %rdi
callq 0x9d090
andb $0x1, %al
movb %al, 0x17(%rsp)
jmp 0x9e365
movq (%rsp), %rdi
callq 0x9abb0
andb $0x1, %al
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
// File: zeeev[P]DASVC/bamtools/src/toolkit/bamtools_filter.cpp
// Function: BamTools::FilterTool::~FilterTool()
FilterTool::~FilterTool(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 0xc24fe(%rip), %rcx     # 0x1647b8
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0xa22e6
movq 0x18(%rsp), %rdi
callq 0xa80b0
jmp 0xa22dc
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 0xa2318
movq 0x8(%rsp), %rdi
callq 0x99fb0
jmp 0xa230e
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 0xa2361
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 0xa236d
jmp 0xa236f
movq 0x28(%rsp), %rdi
callq 0x86d80
movq %rax, %rdi
callq 0x91290
nopw %cs:(%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/toolkit/bamtools_filter.cpp
// Function: BamTools::FilterTool::Run(int, char**)
int FilterTool::Run(int argc, char* argv[]) {

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

    // initialize FilterTool with settings
    m_impl = new FilterToolPrivate(m_settings);

    // run FilterTool, 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 $0x148, %edi            # imm = 0x148
callq 0x86720
movq %rax, %rdi
movq 0x8(%rsp), %rax
movq %rdi, %rcx
movq %rcx, 0x10(%rsp)
movq 0x8(%rax), %rsi
callq 0x99f40
jmp 0xa2444
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%rax), %rdi
callq 0x9d960
testb $0x1, %al
jne 0xa2461
jmp 0xa2485
movl $0x0, 0x44(%rsp)
jmp 0xa248d
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x866a0
jmp 0xa2496
movl $0x1, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x86d80
// File: zeeev[P]DASVC/bamtools/src/utils/bamtools_filter_engine.h
// Function: BamTools::FilterEngine<BamTools::BamAlignmentChecker>::addProperty(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline bool FilterEngine<FilterChecker>::addProperty(const std::string& propertyName) {
    const std::vector<std::string> propertyNames = allPropertyNames();
    bool found = std::binary_search( propertyNames.begin(), propertyNames.end(), propertyName );
    if ( found ) return false;
    m_properties.push_back( Property(propertyName) );
    std::sort( m_properties.begin(), m_properties.end() );
    return true;
}

// Assembly:
subq $0xd8, %rsp
movq %rdi, 0xc8(%rsp)
movq %rsi, 0xc0(%rsp)
movq 0xc8(%rsp), %rsi
movq %rsi, 0x28(%rsp)
leaq 0xa8(%rsp), %rdi
movq %rdi, 0x30(%rsp)
callq 0xbf3e0
movq 0x30(%rsp), %rdi
callq 0x96000
movq %rax, 0x38(%rsp)
jmp 0xa72b7
movq 0x38(%rsp), %rax
movq %rax, 0x98(%rsp)
leaq 0xa8(%rsp), %rdi
callq 0x96030
movq %rax, 0x20(%rsp)
jmp 0xa72d8
movq 0x20(%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0xc0(%rsp), %rdx
movq 0x98(%rsp), %rdi
movq 0x80(%rsp), %rsi
callq 0xbf540
movb %al, 0x1f(%rsp)
jmp 0xa7308
movb 0x1f(%rsp), %al
andb $0x1, %al
movb %al, 0xa7(%rsp)
testb $0x1, 0xa7(%rsp)
je 0xa734d
movb $0x0, 0xd7(%rsp)
movl $0x1, 0x7c(%rsp)
jmp 0xa740f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0xa742d
movq 0x28(%rsp), %rax
addq $0x30, %rax
movq %rax, 0x10(%rsp)
movq 0xc0(%rsp), %rsi
leaq 0x50(%rsp), %rdi
xorl %edx, %edx
callq 0xac040
jmp 0xa7371
movq 0x10(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0xabfd0
jmp 0xa7382
leaq 0x50(%rsp), %rdi
callq 0xab1e0
jmp 0xa738e
movq 0x28(%rsp), %rdi
addq $0x30, %rdi
callq 0xabf30
movq %rax, 0x8(%rsp)
jmp 0xa73a3
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rax
movq %rax, 0x48(%rsp)
addq $0x30, %rdi
callq 0xabf60
movq %rax, (%rsp)
jmp 0xa73c1
movq (%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0xac080
jmp 0xa73db
movb $0x1, 0xd7(%rsp)
movl $0x1, 0x7c(%rsp)
jmp 0xa740f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0x50(%rsp), %rdi
callq 0xab1e0
jmp 0xa740d
jmp 0xa742d
leaq 0xa8(%rsp), %rdi
callq 0x92a50
movb 0xd7(%rsp), %al
andb $0x1, %al
addq $0xd8, %rsp
retq
leaq 0xa8(%rsp), %rdi
callq 0x92a50
jmp 0xa743c
jmp 0xa743e
movq 0x90(%rsp), %rdi
callq 0x86d80
movq %rax, %rdi
callq 0x91290
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: zeeev[P]DASVC/bamtools/src/utils/bamtools_filter_engine.h
// Function: BamTools::FilterEngine<BamTools::BamAlignmentChecker>::buildRuleQueue()
inline void FilterEngine<FilterChecker>::buildRuleQueue(void) {
  
    // skip if no filters present
    if ( m_filters.empty() ) return;
  
    // clear out any prior expression queue data
    while ( !m_ruleQueue.empty() )
        m_ruleQueue.pop();
  
    // create a rule string, if not provided
    if ( m_ruleString.empty() ) 
        buildDefaultRuleString();
    
    // initialize RuleParser, run, and retrieve results
    RuleParser ruleParser(m_ruleString);
    ruleParser.parse();
    m_ruleQueue = ruleParser.results();
    
    // set flag if rule queue contains any values
    m_isRuleQueueGenerated = (!m_ruleQueue.empty());    
}

// Assembly:
subq $0x158, %rsp            # imm = 0x158
movq %rdi, 0x150(%rsp)
movq 0x150(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xb0900
testb $0x1, %al
jne 0xaf7d7
jmp 0xaf7dc
jmp 0xaf8ab
jmp 0xaf7de
movq 0x10(%rsp), %rdi
addq $0x68, %rdi
callq 0xafa20
xorb $-0x1, %al
testb $0x1, %al
jne 0xaf7f4
jmp 0xaf804
movq 0x10(%rsp), %rdi
addq $0x68, %rdi
callq 0xb08e0
jmp 0xaf7de
movq 0x10(%rsp), %rdi
addq $0x48, %rdi
callq 0x86c90
testb $0x1, %al
jne 0xaf818
jmp 0xaf822
movq 0x10(%rsp), %rdi
callq 0xb0920
movq 0x10(%rsp), %rsi
addq $0x48, %rsi
leaq 0x78(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xb0c30
movq 0x8(%rsp), %rdi
callq 0xb0e10
jmp 0xaf846
leaq 0x18(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0xb1260
jmp 0xaf857
movq 0x10(%rsp), %rdi
addq $0x68, %rdi
leaq 0x18(%rsp), %rsi
callq 0xb1290
jmp 0xaf86c
leaq 0x18(%rsp), %rdi
callq 0xa9a30
jmp 0xaf878
movq 0x10(%rsp), %rdi
addq $0x68, %rdi
callq 0xafa20
movb %al, 0x7(%rsp)
jmp 0xaf88c
movq 0x10(%rsp), %rax
movb 0x7(%rsp), %cl
xorb $-0x1, %cl
andb $0x1, %cl
movb %cl, 0xb8(%rax)
leaq 0x78(%rsp), %rdi
callq 0xb12c0
addq $0x158, %rsp            # imm = 0x158
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
jmp 0xaf8df
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x18(%rsp), %rdi
callq 0xa9a30
jmp 0xaf8dd
jmp 0xaf8df
leaq 0x78(%rsp), %rdi
callq 0xb12c0
jmp 0xaf8eb
jmp 0xaf8ed
movq 0x70(%rsp), %rdi
callq 0x86d80
movq %rax, %rdi
callq 0x91290
nop
// File: zeeev[P]DASVC/bamtools/src/utils/bamtools_filter_ruleparser.h
// Function: BamTools::RuleParser::RuleParser(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
RuleParser(const std::string& ruleString)
            : m_ruleString(ruleString)
        { 
            // initialize char markers
            m_begin = (char*)m_ruleString.c_str();
            m_end   = m_begin + m_ruleString.length();
            ignoreQuotes();
        }

// Assembly:
subq $0xf8, %rsp
movq %rdi, 0xf0(%rsp)
movq %rsi, 0xe8(%rsp)
movq 0xf0(%rsp), %rdi
movq %rdi, 0x28(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq 0xe8(%rsp), %rsi
callq 0x86350
movq 0x28(%rsp), %rax
addq $0x38, %rax
movq %rax, 0x30(%rsp)
leaq 0x98(%rsp), %rdi
callq 0xa9960
jmp 0xb0c86
movq 0x30(%rsp), %rdi
leaq 0x98(%rsp), %rsi
callq 0xa9970
jmp 0xb0c9a
leaq 0x98(%rsp), %rdi
callq 0xa99a0
jmp 0xb0ca9
movq 0x20(%rsp), %rax
addq $0x88, %rax
movq %rax, 0x18(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xb1440
jmp 0xb0cc5
movq 0x18(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0xb1450
jmp 0xb0cd6
leaq 0x38(%rsp), %rdi
callq 0xb1480
jmp 0xb0ce2
movq 0x20(%rsp), %rdi
callq 0x86320
movq %rax, 0x10(%rsp)
jmp 0xb0cf3
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rdi)
movq 0x20(%rdi), %rax
movq %rax, (%rsp)
callq 0x86ac0
movq %rax, 0x8(%rsp)
jmp 0xb0d15
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
addq %rcx, %rax
movq %rax, 0x30(%rdi)
callq 0xb1510
jmp 0xb0d31
addq $0xf8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0xb0ddf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0x98(%rsp), %rdi
callq 0xa99a0
jmp 0xb0d75
jmp 0xb0ddf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
jmp 0xb0dd1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xb1480
jmp 0xb0dad
jmp 0xb0dd1
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x90(%rsp)
movl %eax, 0x8c(%rsp)
callq 0xb1560
jmp 0xb0dcf
jmp 0xb0dd1
movq 0x30(%rsp), %rdi
callq 0xa9a30
jmp 0xb0ddd
jmp 0xb0ddf
movq 0x28(%rsp), %rdi
callq 0x86f68
jmp 0xb0deb
jmp 0xb0ded
movq 0x90(%rsp), %rdi
callq 0x86d80
movq %rax, %rdi
callq 0x91290
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: zeeev[P]DASVC/bamtools/src/utils/bamtools_filter_ruleparser.h
// Function: BamTools::priority(BamTools::RuleToken const&)
inline int priority(const RuleToken& token) {
    switch ( token.Type ) {
        case ( RuleToken::NOT_OPERATOR )      : return 3;
        case ( RuleToken::AND_OPERATOR )      : return 2;
        case ( RuleToken::OR_OPERATOR  )      : return 1;
        case ( RuleToken::LEFT_PARENTHESIS )  : return 0;
        case ( RuleToken::RIGHT_PARENTHESIS ) : return 0;
        default:
            BAMTOOLS_ASSERT_UNREACHABLE;
            return -1;
    } 
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl (%rax), %eax
decl %eax
movl %eax, %ecx
movq %rcx, (%rsp)
subl $0x4, %eax
ja 0xb3033
movq (%rsp), %rax
leaq 0x7bec0(%rip), %rcx     # 0x12eeb8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x3, 0x14(%rsp)
jmp 0xb3040
movl $0x2, 0x14(%rsp)
jmp 0xb3040
movl $0x1, 0x14(%rsp)
jmp 0xb3040
movl $0x0, 0x14(%rsp)
jmp 0xb3040
movl $0x0, 0x14(%rsp)
jmp 0xb3040
callq 0xafa50
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: zeeev[P]DASVC/bamtools/src/utils/bamtools_filter_ruleparser.h
// Function: BamTools::RuleParser::skipSpaces()
inline
void RuleParser::skipSpaces(void) {
    while ( m_current != m_end ) {
        const char c = *m_current;
        if ( c == ' ' || c == '\t' || c == '\r' || c == '\n')
            ++m_current;
        else break;
    }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x18(%rsp)
movq -0x18(%rsp), %rcx
movq 0x28(%rcx), %rax
cmpq 0x30(%rcx), %rax
je 0xb316c
movq -0x18(%rsp), %rax
movq 0x28(%rax), %rax
movb (%rax), %al
movb %al, -0x9(%rsp)
movsbl -0x9(%rsp), %eax
cmpl $0x20, %eax
je 0xb3155
movsbl -0x9(%rsp), %eax
cmpl $0x9, %eax
je 0xb3155
movsbl -0x9(%rsp), %eax
cmpl $0xd, %eax
je 0xb3155
movsbl -0x9(%rsp), %eax
cmpl $0xa, %eax
jne 0xb3168
movq -0x18(%rsp), %rax
movq 0x28(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x28(%rax)
jmp 0xb316a
jmp 0xb316c
jmp 0xb310f
retq
nopl (%rax)
// File: zeeev[P]DASVC/bamtools/src/utils/bamtools_variant.h
// Function: BamTools::Variant::Impl<unsigned int>* BamTools::Variant::CastFromBase<unsigned int>(BamTools::Variant::ImplBase*)
static Impl<T>* CastFromBase(ImplBase* v) {
            // This upcast will fail if T is other than the T used
            // with the constructor of variant_t.
            Impl<T>* p = dynamic_cast< Impl<T>* > (v);
            if ( p == NULL ) 
                throw std::invalid_argument( typeid(T).name() + std::string(" is not a valid type") );
            return p;
        }

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, %rax
je 0xbae55
movq 0x28(%rsp), %rdi
leaq 0xa982a(%rip), %rsi     # 0x164668
leaq 0xa9a13(%rip), %rdx     # 0x164858
xorl %eax, %eax
movl %eax, %ecx
callq 0x86830
movq %rax, 0x20(%rsp)
jmp 0xbae5e
xorl %eax, %eax
movq %rax, 0x20(%rsp)
jmp 0xbae5e
movq 0x20(%rsp), %rax
movq %rax, 0x88(%rsp)
cmpq $0x0, 0x88(%rsp)
jne 0xbaf8a
movb $0x1, 0x36(%rsp)
movl $0x10, %edi
callq 0x863c0
movq %rax, 0x10(%rsp)
movq 0xaa11b(%rip), %rdi     # 0x164fb0
callq 0xbb0f0
movq %rax, 0x18(%rsp)
jmp 0xbaea1
leaq 0x37(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x86da0
movq 0x8(%rsp), %rdx
leaq 0x74f7f(%rip), %rsi     # 0x12fe3b
leaq 0x38(%rsp), %rdi
callq 0x86a00
jmp 0xbaec8
movq 0x18(%rsp), %rsi
leaq 0x68(%rsp), %rdi
leaq 0x38(%rsp), %rdx
callq 0xbafb0
jmp 0xbaede
movq 0x10(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x86d50
jmp 0xbaeef
movq 0x10(%rsp), %rdi
movb $0x0, 0x36(%rsp)
movq 0xaa0c8(%rip), %rsi     # 0x164fc8
movq 0xaa0b1(%rip), %rdx     # 0x164fb8
callq 0x86d20
jmp 0xbafac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0xbaf75
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0xbaf6b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0xbaf5d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x86f68
jmp 0xbaf5b
jmp 0xbaf5d
leaq 0x38(%rsp), %rdi
callq 0x86f68
jmp 0xbaf69
jmp 0xbaf6b
leaq 0x37(%rsp), %rdi
callq 0x867b0
testb $0x1, 0x36(%rsp)
jne 0xbaf7e
jmp 0xbaf88
movq 0x10(%rsp), %rdi
callq 0x86550
jmp 0xbaf9a
movq 0x88(%rsp), %rax
addq $0x98, %rsp
retq
movq 0x60(%rsp), %rdi
callq 0x86d80
movq %rax, %rdi
callq 0x91290
nopl (%rax)
// File: zeeev[P]DASVC/bamtools/src/api/BamAlignment.h
// Function: bool BamTools::BamAlignment::GetTag<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) const
inline bool BamAlignment::GetTag<std::string>(const std::string& tag,
                                              std::string& destination) const
{
    // skip if alignment is core-only
    if ( SupportData.HasCoreOnly ) {
        // TODO: set error string?
        return false;
    }

    // skip if no tags present
    if ( TagData.empty() ) {
        // TODO: set error string?
        return false;
    }

    // localize the tag data
    char* pTagData = (char*)TagData.data();
    const unsigned int tagDataLength = TagData.size();
    unsigned int numBytesParsed = 0;

    // return failure if tag not found
    if ( !FindTag(tag, pTagData, tagDataLength, numBytesParsed) ) {
        // TODO: set error string?
        return false;
    }

    // otherwise copy data into destination
    const unsigned int dataLength = strlen(pTagData);
    destination.clear();
    destination.resize(dataLength);
    memcpy( (char*)destination.data(), pTagData, dataLength );

    // return success
    return true;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
testb $0x1, 0x130(%rax)
je 0xbe320
movb $0x0, 0x47(%rsp)
jmp 0xbe3e7
movq 0x8(%rsp), %rdi
addq $0x88, %rdi
callq 0x86c90
testb $0x1, %al
jne 0xbe337
jmp 0xbe341
movb $0x0, 0x47(%rsp)
jmp 0xbe3e7
movq 0x8(%rsp), %rdi
addq $0x88, %rdi
callq 0x86940
movq 0x8(%rsp), %rdi
movq %rax, 0x20(%rsp)
addq $0x88, %rdi
callq 0x86500
movq 0x8(%rsp), %rdi
movl %eax, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movq 0x30(%rsp), %rsi
leaq 0x20(%rsp), %rdx
leaq 0x1c(%rsp), %rcx
leaq 0x18(%rsp), %r8
callq 0x868b0
testb $0x1, %al
jne 0xbe39d
movb $0x0, 0x47(%rsp)
jmp 0xbe3e7
movq 0x20(%rsp), %rdi
callq 0x86360
movl %eax, 0x14(%rsp)
movq 0x28(%rsp), %rdi
callq 0x86970
movq 0x28(%rsp), %rdi
movl 0x14(%rsp), %eax
movl %eax, %esi
callq 0x86a20
movq 0x28(%rsp), %rdi
callq 0x86940
movq %rax, %rdi
movq 0x20(%rsp), %rsi
movl 0x14(%rsp), %eax
movl %eax, %edx
callq 0x865e0
movb $0x1, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: zeeev[P]DASVC/bamtools/src/api/BamConstants.h
// Function: BamTools::TagTypeHelper<unsigned int>::CanConvertFrom(char)
static bool CanConvertFrom(const char c) {
        return ( c == Constants::BAM_TAG_TYPE_ASCII  ||
                 c == Constants::BAM_TAG_TYPE_UINT8  ||
                 c == Constants::BAM_TAG_TYPE_UINT16 ||
                 c == Constants::BAM_TAG_TYPE_UINT32 );
    }

// Assembly:
movb %dil, %al
movb %al, -0x1(%rsp)
movsbl -0x1(%rsp), %ecx
movb $0x1, %al
cmpl $0x41, %ecx
movb %al, -0x2(%rsp)
je 0xbe7f6
movsbl -0x1(%rsp), %ecx
movb $0x1, %al
cmpl $0x43, %ecx
movb %al, -0x2(%rsp)
je 0xbe7f6
movsbl -0x1(%rsp), %ecx
movb $0x1, %al
cmpl $0x53, %ecx
movb %al, -0x2(%rsp)
je 0xbe7f6
movsbl -0x1(%rsp), %eax
cmpl $0x49, %eax
sete %al
movb %al, -0x2(%rsp)
movb -0x2(%rsp), %al
andb $0x1, %al
retq
nopl (%rax)
// File: zeeev[P]DASVC/bamtools/src/utils/bamtools_filter_engine.h
// Function: BamTools::FilterEngine<BamTools::BamAlignmentChecker>::allPropertyNames[abi:cxx11]()
inline const std::vector<std::string> FilterEngine<FilterChecker>::allPropertyNames(void) {
    // set up stringlist
    std::vector<std::string> names;
    names.reserve(m_properties.size());
    // iterate through all properties, appending to stringlist
    std::vector<Property>::const_iterator propIter = m_properties.begin();
    std::vector<Property>::const_iterator propEnd  = m_properties.end();
    for ( ; propIter != propEnd; ++propIter )
        names.push_back( (*propIter).Name );  
    // return stringlist
    return names;
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x38(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x30(%rsp)
movb $0x0, 0x77(%rsp)
callq 0x92a40
movq 0x30(%rsp), %rdi
addq $0x30, %rdi
callq 0xad630
movq 0x38(%rsp), %rdi
movq %rax, %rsi
callq 0xbf5e0
jmp 0xbf432
movq 0x30(%rsp), %rdi
addq $0x30, %rdi
callq 0xabf30
movq %rax, 0x20(%rsp)
jmp 0xbf447
movq 0x20(%rsp), %rax
movq %rax, 0x50(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0xbf6f0
jmp 0xbf462
movq 0x30(%rsp), %rdi
addq $0x30, %rdi
callq 0xabf60
movq %rax, 0x18(%rsp)
jmp 0xbf477
movq 0x18(%rsp), %rax
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0xbf6f0
jmp 0xbf492
jmp 0xbf494
leaq 0x58(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0xbf730
movb %al, 0x17(%rsp)
jmp 0xbf4a9
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0xbf4b3
jmp 0xbf4ff
leaq 0x58(%rsp), %rdi
callq 0xbf770
movq %rax, 0x8(%rsp)
jmp 0xbf4c4
movq 0x8(%rsp), %rsi
movq 0x38(%rsp), %rdi
callq 0x91220
jmp 0xbf4d5
jmp 0xbf4d7
leaq 0x58(%rsp), %rdi
callq 0xbf780
jmp 0xbf4e3
jmp 0xbf494
movq 0x38(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
callq 0x92a50
jmp 0xbf522
movb $0x1, 0x77(%rsp)
testb $0x1, 0x77(%rsp)
jne 0xbf515
movq 0x38(%rsp), %rdi
callq 0x92a50
movq 0x28(%rsp), %rax
addq $0x88, %rsp
retq
jmp 0xbf524
movq 0x68(%rsp), %rdi
callq 0x86d80
movq %rax, %rdi
callq 0x91290
nopw %cs:(%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/toolkit/bamtools_header.cpp
// Function: BamTools::HeaderTool::~HeaderTool()
HeaderTool::~HeaderTool(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 0xa2b06(%rip), %rcx     # 0x164960
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0xc1e86
movq 0x18(%rsp), %rdi
callq 0xc20b0
jmp 0xc1e7c
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 0xc1eb8
movq 0x8(%rsp), %rdi
callq 0xc2120
jmp 0xc1eae
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 0xc1f01
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 0xc1f0d
jmp 0xc1f0f
movq 0x28(%rsp), %rdi
callq 0x86d80
movq %rax, %rdi
callq 0x91290
nopw %cs:(%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/toolkit/bamtools_header.cpp
// Function: BamTools::HeaderTool::Run(int, char**)
int HeaderTool::Run(int argc, char* argv[]) {
  
    // parse command line arguments
    Options::Parse(argc, argv, 1);
  
    // initialize HeaderTool with settings
    m_impl = new HeaderToolPrivate(m_settings);

    // run HeaderTool, 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 0xc2130
jmp 0xc1fe4
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%rax), %rdi
callq 0xc1290
testb $0x1, %al
jne 0xc2001
jmp 0xc2025
movl $0x0, 0x44(%rsp)
jmp 0xc202d
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x866a0
jmp 0xc2036
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_index.cpp
// Function: BamTools::IndexTool::IndexToolPrivate::Run()
bool IndexTool::IndexToolPrivate::Run(void) {

    // open our BAM reader
    BamReader reader;
    if ( !reader.Open(m_settings->InputBamFilename) ) {
        cerr << "bamtools index ERROR: could not open BAM file: "
             << m_settings->InputBamFilename << endl;
        return false;
    }

    // create index for BAM file
    const BamIndex::IndexType type = ( m_settings->IsUsingBamtoolsIndex ? BamIndex::BAMTOOLS
                                                                        : BamIndex::STANDARD );
    reader.CreateIndex(type);

    // clean & exit
    reader.Close();
    return true;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x40(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x864d0
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rdi
movq (%rax), %rsi
addq $0x8, %rsi
callq 0x86980
movb %al, 0x2b(%rsp)
jmp 0xc218e
movb 0x2b(%rsp), %al
testb $0x1, %al
jne 0xc220b
jmp 0xc2198
movq 0xa2e41(%rip), %rdi     # 0x164fe0
leaq 0x6df28(%rip), %rsi     # 0x1300ce
callq 0x86700
movq %rax, 0x10(%rsp)
jmp 0xc21b2
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movq (%rax), %rsi
addq $0x8, %rsi
callq 0x86640
movq %rax, 0x8(%rsp)
jmp 0xc21cf
movq 0x8(%rsp), %rdi
movq 0xa2d95(%rip), %rsi     # 0x164f70
callq 0x86770
jmp 0xc21e2
movb $0x0, 0x57(%rsp)
movl $0x1, 0x30(%rsp)
jmp 0xc224c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x86790
jmp 0xc2261
movq 0x18(%rsp), %rax
movq (%rax), %rax
movb 0x1(%rax), %al
notb %al
movzbl %al, %eax
andl $0x1, %eax
movl %eax, 0x2c(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x2c(%rsp), %rsi
callq 0x86d90
jmp 0xc2233
leaq 0x40(%rsp), %rdi
callq 0x860c0
jmp 0xc223f
movb $0x1, 0x57(%rsp)
movl $0x1, 0x30(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x86790
movb 0x57(%rsp), %al
andb $0x1, %al
addq $0x58, %rsp
retq
jmp 0xc2263
movq 0x38(%rsp), %rdi
callq 0x86d80
movq %rax, %rdi
callq 0x91290
nopw %cs:(%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/toolkit/bamtools_index.cpp
// Function: BamTools::IndexTool::~IndexTool()
IndexTool::~IndexTool(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 0xa1fde(%rip), %rcx     # 0x1649a8
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0xc29f6
movq 0x18(%rsp), %rdi
callq 0xc2bf0
jmp 0xc29ec
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 0xc2a28
movq 0x8(%rsp), %rdi
callq 0xc2c10
jmp 0xc2a1e
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 0xc2a71
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 0xc2a7d
jmp 0xc2a7f
movq 0x28(%rsp), %rdi
callq 0x86d80
movq %rax, %rdi
callq 0x91290
nopw %cs:(%rax,%rax)
// File: zeeev[P]DASVC/bamtools/src/toolkit/bamtools_index.cpp
// Function: BamTools::IndexTool::Run(int, char**)
int IndexTool::Run(int argc, char* argv[]) {
  
    // parse command line arguments
    Options::Parse(argc, argv, 1);
    
    // initialize IndexTool with settings
    m_impl = new IndexToolPrivate(m_settings);

    // run IndexTool, 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 0xc2c20
jmp 0xc2b54
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%rax), %rdi
callq 0xc2150
testb $0x1, %al
jne 0xc2b71
jmp 0xc2b95
movl $0x0, 0x44(%rsp)
jmp 0xc2b9d
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x866a0
jmp 0xc2ba6
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_merge.cpp
// Function: BamTools::MergeTool::~MergeTool()
MergeTool::~MergeTool(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 0xa05a6(%rip), %rcx     # 0x1649f0
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0xc4476
movq 0x18(%rsp), %rdi
callq 0xc4970
jmp 0xc446c
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 0xc44a8
movq 0x8(%rsp), %rdi
callq 0xc4a40
jmp 0xc449e
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 0xc44f1
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 0xc44fd
jmp 0xc44ff
movq 0x28(%rsp), %rdi
callq 0x86d80
movq %rax, %rdi
callq 0x91290
nopw %cs:(%rax,%rax)