LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-nanomap/unit_tests/catch.hpp
// Function: Catch::addReporter(Catch::Ptr<Catch::IStreamingReporter> const&, Catch::Ptr<Catch::IStreamingReporter> const&)
Ptr<IStreamingReporter> addReporter( Ptr<IStreamingReporter> const& existingReporter, Ptr<IStreamingReporter> const& additionalReporter ) {
    Ptr<IStreamingReporter> resultingReporter;

    if( existingReporter ) {
        MultipleReporters* multi = existingReporter->tryAsMulti();
        if( !multi ) {
            multi = new MultipleReporters;
            resultingReporter = Ptr<IStreamingReporter>( multi );
            if( existingReporter )
                multi->add( existingReporter );
        }
        else
            resultingReporter = existingReporter;
        multi->add( additionalReporter );
    }
    else
        resultingReporter = additionalReporter;

    return resultingReporter;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
movq $0x0, (%rdi)
movq (%rsi), %rdi
testq %rdi, %rdi
je 0xc200
movq %rsi, %r12
movq (%rdi), %rax
callq *0x88(%rax)
movq %rax, %r15
testq %rax, %rax
je 0xc20d
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2349e
jmp 0xc276
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2349e
jmp 0xc285
movl $0x28, %edi
callq 0xb380
movq %rax, %r15
movl $0x0, 0x8(%rax)
leaq 0x53370(%rip), %rax     # 0x5f598
movq %rax, (%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r15)
movq $0x0, 0x20(%r15)
movq %rsp, %rsi
movq %r15, (%rsi)
movl $0x1, 0x8(%r15)
movq %rbx, %rdi
callq 0x2349e
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xc260
movq (%rdi), %rax
callq *0x18(%rax)
cmpq $0x0, (%r12)
je 0xc276
movq %r15, %rdi
addq $0x10, %rdi
movq %r12, %rsi
callq 0x2f8f8
addq $0x10, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x2f8f8
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xc2c7
movq %rax, %r14
movq (%rsp), %rdi
testq %rdi, %rdi
je 0xc2b1
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0xc2b1
jmp 0xc2c7
jmp 0xc2ae
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xc2bf
movq (%rdi), %rax
callq *0x18(%rax)
movq %r14, %rdi
callq 0xb660
movq %rax, %rdi
callq 0x243f3
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-nanomap/unit_tests/catch.hpp
// Function: Catch::CompactReporter::AssertionPrinter::printRemainingMessages(Catch::Colour::Code)
Generic::AnyOf<ExpressionT> Matcher<ExpressionT>::operator || ( Matcher<ExpressionT> const& other ) const {
        Generic::AnyOf<ExpressionT> anyOfExpr;
        anyOfExpr.add( *this );
        anyOfExpr.add( other );
        return anyOfExpr;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq 0x20(%rdi), %rbp
movq 0x30(%rdi), %r12
cmpq %rbp, %r12
je 0x42466
movq %rdi, %rbx
movb $0x0, 0xf(%rsp)
movl %esi, %edi
callq 0xdd0a
movq (%rbx), %r14
leaq 0x58b4(%rip), %rsi      # 0x47bb0
movl $0x6, %edx
movq %r14, %rdi
callq 0xb400
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x5696(%rip), %rsi      # 0x479af
leaq 0x5696(%rip), %rdx      # 0x479b6
leaq 0x10(%rsp), %rdi
callq 0x34f44
movq %rbp, %rax
subq %r12, %rax
sarq $0x3, %rax
movabsq $-0x1111111111111111, %rcx # imm = 0xEEEEEEEEEEEEEEEF
imulq %rax, %rcx
leaq 0x38(%rsp), %rdi
movq %rcx, -0x8(%rdi)
leaq 0x48(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
addq %rsi, %rdx
callq 0x43058
leaq 0x30(%rsp), %rsi
movq %r14, %rdi
callq 0xfb4b
leaq 0x3957(%rip), %rsi      # 0x45cd2
movl $0x1, %edx
movq %r14, %rdi
callq 0xb400
movq 0x38(%rsp), %rdi
cmpq %r12, %rdi
je 0x4239f
movq 0x48(%rsp), %rsi
incq %rsi
callq 0xb3a0
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x423b6
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xb3a0
xorl %edi, %edi
callq 0xdd0a
movq 0x30(%rbx), %rax
cmpq %rbp, %rax
je 0x42466
leaq 0x3eed(%rip), %r14      # 0x462be
leaq 0x3ee7(%rip), %r15      # 0x462bf
leaq 0x57d8(%rip), %r12      # 0x47bb7
cmpb $0x0, 0x38(%rbx)
jne 0x423eb
cmpl $0x1, 0x48(%rax)
je 0x42459
movq (%rbx), %r13
movl $0x2, %edx
movq %r13, %rdi
movq %r14, %rsi
callq 0xb400
movq 0x30(%rbx), %rax
movq 0x50(%rax), %rsi
movq 0x58(%rax), %rdx
movq %r13, %rdi
callq 0xb400
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0xb400
movq 0x30(%rbx), %rax
addq $0x78, %rax
movq %rax, 0x30(%rbx)
cmpq %rbp, %rax
je 0x42459
movb $0x0, 0x30(%rsp)
movl $0x17, %edi
callq 0xdd0a
movq (%rbx), %rdi
movl $0x4, %edx
movq %r12, %rsi
callq 0xb400
xorl %edi, %edi
callq 0xdd0a
movq 0x30(%rbx), %rax
cmpq %rbp, %rax
jne 0x423df
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x424d0
movq %rax, %rbx
jmp 0x4249d
jmp 0x4247e
movq %rax, %rbx
jmp 0x424b4
movq %rax, %rbx
movq 0x38(%rsp), %rdi
cmpq %r12, %rdi
je 0x4249d
movq 0x48(%rsp), %rsi
incq %rsi
callq 0xb3a0
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x424b4
movq 0x20(%rsp), %rsi
incq %rsi
callq 0xb3a0
leaq 0xf(%rsp), %rdi
jmp 0x424c3
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xdd74
movq %rbx, %rdi
callq 0xb660
movq %rax, %rdi
callq 0x243f3
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-nanomap/unit_tests/catch.hpp
// Function: Catch::Session::run(int, char const* const*)
int run( int argc, char const* const* const argv ) {

            int returnCode = applyCommandLine( argc, argv );
            if( returnCode == 0 )
                returnCode = run();
            return returnCode;
        }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %ecx
callq 0x33b1e
testl %eax, %eax
je 0x255ca
popq %rbx
retq
movq %rbx, %rdi
popq %rbx
jmp 0x33df6
nop
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-nanomap/unit_tests/catch.hpp
// Function: Catch::TestCaseTracking::SectionTracker::acquire(Catch::TestCaseTracking::TrackerContext&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static SectionTracker& acquire( TrackerContext& ctx, std::string const& name ) {
            SectionTracker* section = CATCH_NULL;

            ITracker& currentTracker = ctx.currentTracker();
            if( ITracker* childTracker = currentTracker.findChild( name ) ) {
                assert( childTracker );
                assert( childTracker->isSectionTracker() );
                section = static_cast<SectionTracker*>( childTracker );
            }
            else {
                section = new SectionTracker( name, ctx, &currentTracker );
                currentTracker.addChild( section );
            }
            if( !ctx.completedCycle() && !section->isComplete() ) {

                section->open();
            }
            return *section;
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %r14
movq 0x8(%rdi), %r15
movq (%r15), %rax
movq %r15, %rdi
callq *0x70(%rax)
testq %rax, %rax
je 0x2af94
movq %rax, %rbx
movq (%rax), %rax
movq %rbx, %rdi
callq *0x80(%rax)
testb %al, %al
jne 0x2b00d
leaq 0x1ad07(%rip), %rdi     # 0x45c83
leaq 0x1aa89(%rip), %rsi     # 0x45a0c
leaq 0x1ac8a(%rip), %rcx     # 0x45c14
movl $0x164b, %edx           # imm = 0x164B
callq 0xb240
movl $0x60, %edi
callq 0xb380
movq %rax, %rbx
movl $0x0, 0x8(%rax)
leaq 0x33071(%rip), %rax     # 0x5e020
movq %rax, (%rbx)
leaq 0x10(%rbx), %rdi
leaq 0x20(%rbx), %rax
movq %rax, 0x10(%rbx)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
callq 0x43058
movq %r14, 0x30(%rbx)
movq %r15, 0x38(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x4c(%rbx)
leaq 0x3342f(%rip), %rax     # 0x5e418
movq %rax, (%rbx)
movq %rsp, %rsi
movq %rbx, (%rsi)
incl 0x8(%rbx)
movq (%r15), %rax
movq %r15, %rdi
callq *0x68(%rax)
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x2b00d
movq (%rdi), %rax
callq *0x18(%rax)
cmpl $0x2, 0x10(%r14)
je 0x2b03f
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
testb %al, %al
jne 0x2b03f
movl $0x1, 0x58(%rbx)
movq 0x30(%rbx), %rax
movq %rbx, 0x8(%rax)
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x2b03f
movq (%rdi), %rax
callq *0x78(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x2b064
movq %rax, %r14
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x2b07c
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x2b07c
movq %rax, %rdi
callq 0x243f3
movq %rax, %r14
movl $0x60, %esi
movq %rbx, %rdi
callq 0xb3a0
movq %r14, %rdi
callq 0xb660
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-nanomap/unit_tests/catch.hpp
// Function: Catch::setUseColour(Catch::ConfigData&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline void setUseColour( ConfigData& config, std::string const& value ) {
        std::string mode = toLower( value );

        if( mode == "yes" )
            config.useColour = UseColour::Yes;
        else if( mode == "no" )
            config.useColour = UseColour::No;
        else if( mode == "auto" )
            config.useColour = UseColour::Auto;
        else
            throw std::runtime_error( "colour mode must be one of: auto, yes or no" );
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xe5ba
leaq 0x13f9a(%rip), %rsi     # 0x46285
movq %r14, %rdi
callq 0xb0f0
testl %eax, %eax
je 0x32355
leaq 0x14134(%rip), %rsi     # 0x46432
leaq 0x8(%rsp), %rdi
callq 0xb0f0
testl %eax, %eax
je 0x3235c
leaq 0x140f1(%rip), %rsi     # 0x46404
leaq 0x8(%rsp), %rdi
callq 0xb0f0
xorl %ecx, %ecx
testl %eax, %eax
je 0x32361
movl $0x10, %edi
callq 0xb1a0
movq %rax, %r14
leaq 0x140d2(%rip), %rsi     # 0x46409
movq %rax, %rdi
callq 0xb140
movq 0x2dcaa(%rip), %rsi     # 0x5fff0
movq 0x2dc4b(%rip), %rdx     # 0x5ff98
movq %r14, %rdi
callq 0xb610
movl $0x1, %ecx
jmp 0x32361
movl $0x2, %ecx
movl %ecx, 0x24(%rbx)
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3237f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb3a0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
jmp 0x32397
movq %rax, %rbx
movq %r14, %rdi
callq 0xb2c0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x323b2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb3a0
movq %rbx, %rdi
callq 0xb660
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-nanomap/unit_tests/catch.hpp
// Function: Catch::Clara::CommandLine<Catch::ConfigData>::parseInto(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, Catch::ConfigData&) const
std::vector<Parser::Token> parseInto( std::vector<std::string> const& args, ConfigT& config ) const {
            std::string processName = args[0];
            std::size_t lastSlash = processName.find_last_of( "/\\" );
            if( lastSlash != std::string::npos )
                processName = processName.substr( lastSlash+1 );
            m_boundProcessName.set( config, processName );
            std::vector<Parser::Token> tokens;
            Parser parser;
            parser.parseIntoTokens( args, tokens );
            return populate( tokens, config );
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdx), %rax
leaq 0x10(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rsp, %r13
movq %r13, %rdi
callq 0x43058
leaq 0x1247c(%rip), %rsi     # 0x4644a
movl $0x2, %ecx
movq %r13, %rdi
movq $-0x1, %rdx
callq 0xb710
cmpq $-0x1, %rax
je 0x3402d
incq %rax
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
movq %rax, %rdx
movq $-0x1, %rcx
callq 0xb3d0
movq %rsp, %rdi
leaq 0x20(%rsp), %r13
movq %r13, %rsi
callq 0xb460
movq (%r13), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x3402d
movq 0x30(%rsp), %rsi
incq %rsi
callq 0xb3a0
movq (%r15), %rdi
movq (%rdi), %rax
movq %rsp, %rdx
movq %r14, %rsi
callq *0x10(%rax)
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rdx
movaps %xmm0, (%rdx)
xorl %eax, %eax
movq %rax, 0x10(%rdx)
leaq 0x40(%rsp), %rdi
movl $0x0, (%rdi)
movq %rax, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %r12, %rsi
callq 0x34834
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rcx
callq 0x34928
leaq 0x20(%rsp), %rdi
callq 0x313f6
movq (%rsp), %rdi
cmpq %rbp, %rdi
je 0x3409b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb3a0
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x340af
movq %rax, %rbx
jmp 0x340c1
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x313f6
movq (%rsp), %rdi
cmpq %rbp, %rdi
je 0x340d7
movq 0x10(%rsp), %rsi
incq %rsi
callq 0xb3a0
movq %rbx, %rdi
callq 0xb660
nop
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-nanomap/unit_tests/catch.hpp
// Function: Catch::Clara::Parser::parseIntoTokens(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<Catch::Clara::Parser::Token, std::allocator<Catch::Clara::Parser::Token>>&)
void parseIntoTokens( std::string const& arg, std::vector<Token>& tokens ) {
            for( std::size_t i = 0; i <= arg.size(); ++i ) {
                char c = arg[i];
                if( c == '"' )
                    inQuotes = !inQuotes;
                mode = handleMode( i, c, arg, tokens );
            }
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
movq (%r14), %rax
movb (%rax,%r12), %al
cmpb $0x22, %al
jne 0x34a8a
xorb $0x1, 0x10(%r15)
movsbl %al, %edx
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rcx
movq %rbx, %r8
callq 0x34ab6
movl %eax, (%r15)
incq %r12
cmpq 0x8(%r14), %r12
jbe 0x34a7a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-nanomap/unit_tests/catch.hpp
// Function: Catch::Clara::Parser::handleMode(unsigned long, char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<Catch::Clara::Parser::Token, std::allocator<Catch::Clara::Parser::Token>>&)
Mode handleMode( std::size_t i, char c, std::string const& arg, std::vector<Token>& tokens ) {
            switch( mode ) {
                case None: return handleNone( i, c );
                case MaybeShortOpt: return handleMaybeShortOpt( i, c );
                case ShortOpt:
                case LongOpt:
                case SlashOpt: return handleOpt( i, c, arg, tokens );
                case Positional: return handlePositional( i, c, arg, tokens );
                default: throw std::logic_error( "Unknown mode" );
            }
        }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl (%rdi), %eax
cmpq $0x5, %rax
ja 0x34b2f
leaq 0x10ce3(%rip), %r9      # 0x457ac
movslq (%r9,%rax,4), %rax
addq %r9, %rax
jmpq *%rax
movsbl %dl, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x34b74
cmpb $0x1, 0x10(%rdi)
je 0x34af1
movl $0x1, %eax
cmpb $0x2d, %dl
je 0x34b27
movq %rsi, 0x8(%rdi)
movl $0x5, %eax
jmp 0x34b27
cmpb $0x2d, %dl
jne 0x34b1e
incq %rsi
movq %rsi, 0x8(%rdi)
movl $0x4, %eax
jmp 0x34b27
movsbl %dl, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x34df0
movq %rsi, 0x8(%rdi)
movl $0x3, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0xb1a0
movq %rax, %rbx
leaq 0x1190a(%rip), %rsi     # 0x4644d
movq %rax, %rdi
callq 0xb4d0
movq 0x2b47e(%rip), %rsi     # 0x5ffd0
movq 0x2b44f(%rip), %rdx     # 0x5ffa8
movq %rbx, %rdi
callq 0xb610
movq %rax, %r14
movq %rbx, %rdi
callq 0xb2c0
movq %r14, %rdi
callq 0xb660
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-nanomap/unit_tests/catch.hpp
// Function: Catch::Clara::Parser::handlePositional(unsigned long, char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<Catch::Clara::Parser::Token, std::allocator<Catch::Clara::Parser::Token>>&)
Mode handlePositional( std::size_t i, char c, std::string const& arg, std::vector<Token>& tokens ) {
            if( inQuotes || std::string( "\0", 3 ).find( c ) == std::string::npos )
                return mode;

            std::string data = arg.substr( from, i-from );
            tokens.push_back( Token( Token::Positional, data ) );
            return None;
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %r12
movb 0x10(%rdi), %r13b
movb $0x1, %bpl
testb %r13b, %r13b
jne 0x34e44
leaq 0x58(%rsp), %rax
movq %rax, -0x10(%rax)
movl $0x0, (%rax)
movq $0x3, -0x8(%rax)
movsbl %dl, %esi
leaq 0x48(%rsp), %rdi
xorl %edx, %edx
callq 0xb490
cmpq $-0x1, %rax
sete %bpl
testb %r13b, %r13b
jne 0x34e64
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x34e64
movq 0x58(%rsp), %rsi
incq %rsi
callq 0xb3a0
testb %bpl, %bpl
je 0x34e72
movl (%r12), %eax
jmp 0x34ef2
movq 0x8(%r12), %rdx
subq %rdx, %r15
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rcx
callq 0xb3d0
leaq 0x8(%rsp), %rdi
movl $0x0, -0x8(%rdi)
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
callq 0x43058
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x34fd4
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x34ed5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb3a0
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x34ef0
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xb3a0
xorl %eax, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x34f20
movq 0x18(%rsp), %rsi
incq %rsi
callq 0xb3a0
jmp 0x34f20
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x34f3b
movq 0x38(%rsp), %rsi
incq %rsi
callq 0xb3a0
movq %rbx, %rdi
callq 0xb660
nop
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-nanomap/include/gdc/nanomap.hpp
// Function: gdc::nanomap<int, myvalue, std::equal_to<int>>::at(int const&)
mapped_type& at(const key_type& key)
		{
			const_iterator it(_find(key));
			
			if (it == end())
			{
				throw std::out_of_range("item not found");
			}
			
			return _values[it._index];
		}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl (%rdi), %eax
cmpq $0x10000, %rax          # imm = 0x10000
jb 0x39373
movl %eax, %edx
shrl $0x10, %edx
movq 0x8(%rdi), %r8
movl (%rsi), %esi
xorl %ecx, %ecx
cmpl %esi, (%r8,%rcx,4)
je 0x39375
incq %rcx
cmpq %rcx, %rdx
jne 0x39365
movl %eax, %ecx
cmpw %ax, %cx
je 0x3938c
movzwl %cx, %eax
shll $0x2, %eax
addq 0x10(%rdi), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0xb1a0
movq %rax, %rbx
leaq 0xe102(%rip), %rsi      # 0x474a2
movq %rax, %rdi
callq 0xb080
movq 0x26c11(%rip), %rsi     # 0x5ffc0
movq 0x26c02(%rip), %rdx     # 0x5ffb8
movq %rbx, %rdi
callq 0xb610
movq %rax, %r14
movq %rbx, %rdi
callq 0xb2c0
movq %r14, %rdi
callq 0xb660
nop
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-nanomap/include/gdc/nanomap.hpp
// Function: gdc::nanomap<int, myvalue, std::equal_to<int>>::operator[](int const&)
mapped_type& operator[](const key_type& key)
		{
			iterator it = find(key);
			
			if (it == end())
			{
				if (_size >= _capacity)
				{
					throw std::overflow_error("nanomap is full");
				}
				
				size_type i = _size++;
				new (&_keys[i]) key_type(key);
				new (&_values[i]) mapped_type();
				return _values[i];
			}
			
			return _values[it._index];
		}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl (%rdi), %eax
cmpq $0x10000, %rax          # imm = 0x10000
jb 0x393fc
movl %eax, %edx
shrl $0x10, %edx
movq 0x8(%rdi), %r8
movl (%rsi), %r9d
xorl %ecx, %ecx
cmpl %r9d, (%r8,%rcx,4)
je 0x393fe
incq %rcx
cmpq %rcx, %rdx
jne 0x393ee
movl %eax, %ecx
cmpw %ax, %cx
jne 0x3943a
movl %eax, %ecx
shrl $0x10, %ecx
movzwl %ax, %edx
cmpl %edx, %ecx
jae 0x3944c
andl $0xffff0000, %eax       # imm = 0xFFFF0000
addl %edx, %eax
addl $0x10000, %eax          # imm = 0x10000
movl %eax, (%rdi)
movq 0x8(%rdi), %rax
shll $0x2, %ecx
movl (%rsi), %edx
movl %edx, (%rax,%rcx)
movq 0x10(%rdi), %rdx
leaq (%rdx,%rcx), %rax
movl $0x0, (%rdx,%rcx)
jmp 0x39444
movzwl %cx, %eax
shll $0x2, %eax
addq 0x10(%rdi), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0xb1a0
movq %rax, %rbx
leaq 0xe051(%rip), %rsi      # 0x474b1
movq %rax, %rdi
callq 0xb0a0
movq 0x26af1(%rip), %rsi     # 0x5ff60
movq 0x26ada(%rip), %rdx     # 0x5ff50
movq %rbx, %rdi
callq 0xb610
movq %rax, %r14
movq %rbx, %rdi
callq 0xb2c0
movq %r14, %rdi
callq 0xb660
nop
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-nanomap/include/gdc/nanomap.hpp
// Function: gdc::nanomap<int, myvalue, std::equal_to<int>>::operator[](int&&)
mapped_type& operator[](key_type&& key)
		{
			iterator it = find(key);
			
			if (it == end())
			{
				if (_size >= _capacity)
				{
					throw std::overflow_error("nanomap is full");
				}
				
				size_type i = _size++;
				new (&_keys[i]) key_type(std::move(key));
				new (&_values[i]) mapped_type();
				return _values[i];
			}
			
			return _values[it._index];
		}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl (%rdi), %eax
cmpq $0x10000, %rax          # imm = 0x10000
jb 0x394bc
movl %eax, %edx
shrl $0x10, %edx
movq 0x8(%rdi), %r8
movl (%rsi), %r9d
xorl %ecx, %ecx
cmpl %r9d, (%r8,%rcx,4)
je 0x394be
incq %rcx
cmpq %rcx, %rdx
jne 0x394ae
movl %eax, %ecx
cmpw %ax, %cx
jne 0x394fa
movl %eax, %ecx
shrl $0x10, %ecx
movzwl %ax, %edx
cmpl %edx, %ecx
jae 0x3950c
andl $0xffff0000, %eax       # imm = 0xFFFF0000
addl %edx, %eax
addl $0x10000, %eax          # imm = 0x10000
movl %eax, (%rdi)
movq 0x8(%rdi), %rax
shll $0x2, %ecx
movl (%rsi), %edx
movl %edx, (%rax,%rcx)
movq 0x10(%rdi), %rdx
leaq (%rdx,%rcx), %rax
movl $0x0, (%rdx,%rcx)
jmp 0x39504
movzwl %cx, %eax
shll $0x2, %eax
addq 0x10(%rdi), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0xb1a0
movq %rax, %rbx
leaq 0xdf91(%rip), %rsi      # 0x474b1
movq %rax, %rdi
callq 0xb0a0
movq 0x26a31(%rip), %rsi     # 0x5ff60
movq 0x26a1a(%rip), %rdx     # 0x5ff50
movq %rbx, %rdi
callq 0xb610
movq %rax, %r14
movq %rbx, %rdi
callq 0xb2c0
movq %r14, %rdi
callq 0xb660
nop
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-nanomap/include/gdc/nanomap.hpp
// Function: gdc::nanomap<int, myvalue, std::equal_to<int>>::erase(gdc::nanomap_iterator<true, int, myvalue, std::equal_to<int>>)
iterator erase(const_iterator it)
		{
			if (it._index == max_size())
			{
				std::abort();
			}
			
			_keys[it._index].~key_type();
			_values[it._index].~mapped_type();

			if (it._index < --_size)
			{
				new (&_keys[it._index]) key_type(std::move(_keys[_size]));
				new (&_values[it._index]) mapped_type(std::move(_values[_size]));
				_keys[_size].~key_type();
				_values[_size].~mapped_type();
			}
			else
			{
				it._index = end()._index;
			}

			return iterator(it._map, it._index);
		}

// Assembly:
movzwl 0x8(%rdx), %ecx
cmpw (%rsi), %cx
je 0x39609
movq 0x10(%rsi), %rax
movl $0x2a, (%rax,%rcx,4)
movl (%rsi), %r8d
movl %r8d, %r9d
shrl $0x10, %r9d
decl %r9d
movzwl %r9w, %r9d
movw %r9w, 0x2(%rsi)
cmpl %ecx, %r9d
jbe 0x395f2
movq 0x8(%rsi), %rcx
movzwl 0x8(%rdx), %r8d
shll $0x2, %r8d
movl (%rcx,%r9,4), %r9d
movl %r9d, (%rcx,%r8)
movzwl 0x2(%rsi), %ecx
movl (%rax,%rcx,4), %ecx
movl %ecx, (%rax,%r8)
movzwl 0x2(%rsi), %ecx
movl $0x2a, (%rax,%rcx,4)
jmp 0x395f7
movw %r8w, 0x8(%rdx)
movq (%rdx), %rax
movzwl 0x8(%rdx), %ecx
movq %rax, (%rdi)
movw %cx, 0x8(%rdi)
movq %rdi, %rax
retq
pushq %rax
callq 0xb1f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-nanomap/include/gdc/nanomap.hpp
// Function: gdc::nanomap_factory<int, myvalue, (unsigned short)32, std::equal_to<int>>::nanomap_factory(gdc::nanomap_factory<int, myvalue, (unsigned short)32, std::equal_to<int>> const&)
nanomap_factory(const nanomap_factory& f) : _map(_keys, _values, _capacity, f._map.size())
		{
			for (size_type i = 0; i < _capacity; ++i)
			{
				new (&_keys[i]) key_type(f._keys[i]);
			}
			
			for (size_type i = 0; i < _capacity; ++i)
			{
				new (&_values[i]) mapped_type(f._values[i]);
			}
		}

// Assembly:
leaq 0x18(%rdi), %rcx
leaq 0x98(%rdi), %rax
movzwl 0x2(%rsi), %edx
shll $0x10, %edx
orl $0x20, %edx
movl %edx, (%rdi)
movq %rcx, 0x8(%rdi)
movq %rax, 0x10(%rdi)
xorl %edx, %edx
movl $0x0, (%rax,%rdx)
addq $0x4, %rdx
cmpq $0x80, %rdx
jne 0x39631
xorl %edx, %edx
movl 0x18(%rsi,%rdx,4), %edi
movl %edi, (%rcx,%rdx,4)
incq %rdx
cmpq $0x20, %rdx
jne 0x39647
xorl %ecx, %ecx
movl 0x98(%rsi,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
incq %rcx
cmpq $0x20, %rcx
jne 0x39659
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/dadocolussi[P]gdc-nanomap/include/gdc/nanomap.hpp
// Function: gdc::nanomap_factory<int, myvalue, (unsigned short)32, std::equal_to<int>>::nanomap_factory(gdc::nanomap_factory<int, myvalue, (unsigned short)32, std::equal_to<int>>&&)
nanomap_factory(nanomap_factory&& f) : _map(_keys, _values, _capacity, f._map.size())
		{
			for (size_type i = 0; i < _capacity; ++i)
			{
				new (&_keys[i]) key_type(std::move(f._keys[i]));
			}
			
			for (size_type i = 0; i < _capacity; ++i)
			{
				new (&_values[i]) mapped_type(std::move(f._values[i]));
			}
			
			f._map.clear();
		}

// Assembly:
leaq 0x18(%rdi), %rcx
leaq 0x98(%rdi), %rax
movzwl 0x2(%rsi), %edx
shll $0x10, %edx
orl $0x20, %edx
movl %edx, (%rdi)
movq %rcx, 0x8(%rdi)
movq %rax, 0x10(%rdi)
xorl %ecx, %ecx
movl $0x0, (%rax,%rcx)
addq $0x4, %rcx
cmpq $0x80, %rcx
jne 0x3968f
movl $0x6, %eax
movl (%rsi,%rax,4), %ecx
movl %ecx, (%rdi,%rax,4)
incq %rax
cmpq $0x26, %rax
jne 0x396a8
movl $0x26, %eax
movl (%rsi,%rax,4), %ecx
movl %ecx, (%rdi,%rax,4)
incq %rax
cmpq $0x46, %rax
jne 0x396bc
movl (%rsi), %edx
cmpl $0x10000, %edx          # imm = 0x10000
jb 0x396f0
movq 0x10(%rsi), %rax
xorl %ecx, %ecx
movl $0x2a, (%rax,%rcx,4)
incq %rcx
movl (%rsi), %edx
movl %edx, %edi
shrl $0x10, %edi
cmpl %ecx, %edi
ja 0x396db
movzwl %dx, %eax
movl %eax, (%rsi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/devinsmith[P]qvdreader/LineageInfo.cpp
// Function: QvdLineageInfo::ParseXml(_xmlNode const*)
void QvdLineageInfo::ParseXml(const xmlNode *node)
{
  for (const xmlNode *child = node->children; child; child = child->next) {
    if (child->type == XML_ELEMENT_NODE) {
      xmlChar *nodeContent = xmlNodeGetContent(child);
      if (nodeContent == NULL)
        continue;

      if (strlen((char *)nodeContent) == 0) {
        xmlFree(nodeContent);
        continue;
      }

      if (strcmp((char *)child->name, "Discriminator") == 0) {
        Discriminator = (char *)nodeContent;
      } else if (strcmp((char *)child->name, "Statement") == 0) {
        Statement = (char *)nodeContent;
      } else {
        printf("Unprocessed LineageInfo tag: %s\n", child->name);
      }
      xmlFree(nodeContent);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x18(%rsi), %r14
testq %r14, %r14
je 0x490b
movq %rdi, %rbx
leaq 0x20(%rdi), %rax
movq %rax, (%rsp)
movq 0x877a(%rip), %r13      # 0xcfe0
leaq 0x5793(%rip), %r12      # 0xa000
cmpl $0x1, 0x8(%r14)
jne 0x48fe
movq %r14, %rdi
callq 0x43b0
testq %rax, %rax
je 0x48fe
movq %rax, %rbp
cmpb $0x0, (%rax)
je 0x48f7
movq 0x10(%r14), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x4470
testl %eax, %eax
je 0x48c6
movq %r15, %rdi
leaq 0x5764(%rip), %rsi      # 0xa00e
callq 0x4470
testl %eax, %eax
je 0x48d7
leaq 0x575e(%rip), %rdi      # 0xa018
movq %r15, %rsi
xorl %eax, %eax
callq 0x4030
jmp 0x48f7
movq 0x8(%rbx), %r15
movq %rbp, %rdi
callq 0x4130
movq %rbx, %rdi
jmp 0x48e7
movq 0x28(%rbx), %r15
movq %rbp, %rdi
callq 0x4130
movq (%rsp), %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %rbp, %rcx
movq %rax, %r8
callq 0x44f0
movq %rbp, %rdi
callq *(%r13)
movq 0x30(%r14), %r14
testq %r14, %r14
jne 0x486d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/devinsmith[P]qvdreader/main.cpp
// Function: main
int
main(int argc, char *argv[])
{
  if (argc < 2) {
    fprintf(stderr, "usage: %s qvdfile.qvd\n", argv[0]);
    exit(1);
  }

  QvdFile qvd;

  if (!qvd.Load(argv[1])) {
    fprintf(stderr, "The file '%s' could not be loaded.\n", argv[1]);
    exit(1);
  }

  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x2150, %rsp           # imm = 0x2150
movq %rsi, %rbx
cmpl $0x1, %edi
jle 0x4a3b
leaq 0x10(%rsp), %rcx
movq %rcx, -0x10(%rcx)
xorl %eax, %eax
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq 0x30(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq 0x50(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
movl $0x0, 0x10(%rcx)
leaq 0x78(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq 0xf8(%rsp), %r14
xorps %xmm0, %xmm0
movups %xmm0, -0x70(%r14)
movups %xmm0, -0x60(%r14)
movups %xmm0, -0x50(%r14)
movups %xmm0, -0x40(%r14)
movups %xmm0, -0x30(%r14)
movups %xmm0, -0x24(%r14)
movq %r14, -0x10(%r14)
movq %rax, -0x8(%r14)
movb %al, (%r14)
leaq 0x118(%rsp), %r15
movq %r15, -0x10(%r15)
movq %rax, -0x8(%r15)
movb %al, (%r15)
movq %rax, 0x10(%r15)
movq %rax, 0x202c(%r15)
movb %al, 0x2028(%r15)
movups %xmm0, 0x2018(%r15)
movq 0x8(%rbx), %rsi
movq %rsp, %rdi
callq 0x41a0
testb %al, %al
je 0x4a43
movq 0x108(%rsp), %rdi
cmpq %r15, %rdi
je 0x4a07
movq 0x118(%rsp), %rsi
incq %rsi
callq 0x4370
movq 0xe8(%rsp), %rdi
cmpq %r14, %rdi
je 0x4a24
movq 0xf8(%rsp), %rsi
incq %rsi
callq 0x4370
movq %rsp, %rdi
callq 0x4390
xorl %eax, %eax
addq $0x2150, %rsp           # imm = 0x2150
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
callq 0x46a7
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x4680
movq %rax, %rbx
movq %rsp, %rdi
callq 0x41d0
movq %rbx, %rdi
callq 0x45c0
// File: /workspace/github_cpp_makefile_star2_O1/devinsmith[P]qvdreader/QvdField.cpp
// Function: QvdField::ParseNumberFormat(_xmlNode const*)
void QvdField::ParseNumberFormat(const xmlNode *node)
{
  for (const xmlNode *child = node->children; child; child = child->next) {
    if (child->type == XML_ELEMENT_NODE) {
      xmlChar *nodeContent = xmlNodeGetContent(child);
      if (nodeContent == NULL)
        continue;

      if (strlen((char *)nodeContent) == 0) {
        xmlFree(nodeContent);
        continue;
      }

      if (strcmp((char *)child->name, "Type") == 0) {
        Type = (char *)nodeContent;
      } else if (strcmp((char *)child->name, "Dec") == 0) {
        Dec = (char *)nodeContent;
      } else if (strcmp((char *)child->name, "Thou") == 0) {
        Thou = (char *)nodeContent;
      } else if (strcmp((char *)child->name, "nDec") == 0) {
        nDec = atoi((char *)nodeContent);
      } else if (strcmp((char *)child->name, "UseThou") == 0) {
        UseThou = atoi((char *)nodeContent);
      } else {
        printf("Unprocessed NumberFormat tag: %s\n", child->name);
      }
      xmlFree(nodeContent);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x18(%rsi), %r14
testq %r14, %r14
je 0x4e59
movq %rdi, %rbx
leaq 0x78(%rdi), %rax
movq %rax, (%rsp)
leaq 0x58(%rdi), %rax
movq %rax, 0x8(%rsp)
leaq 0x30(%rdi), %rax
movq %rax, 0x10(%rsp)
movq 0x82a5(%rip), %r13      # 0xcfe0
leaq 0x5332(%rip), %rbp      # 0xa074
cmpl $0x1, 0x8(%r14)
jne 0x4e30
movq %r14, %rdi
callq 0x43b0
testq %rax, %rax
je 0x4e30
movq %rax, %r12
cmpb $0x0, (%rax)
je 0x4e29
movq 0x10(%r14), %r15
movq %r15, %rdi
movq %rbp, %rsi
callq 0x4470
testl %eax, %eax
je 0x4de0
movq %r15, %rdi
leaq 0x52f3(%rip), %rsi      # 0xa07a
callq 0x4470
testl %eax, %eax
je 0x4df3
movq %r15, %rdi
leaq 0x52e7(%rip), %rsi      # 0xa081
callq 0x4470
testl %eax, %eax
je 0x4e06
movq %r15, %rdi
leaq 0x52cc(%rip), %rsi      # 0xa079
callq 0x4470
testl %eax, %eax
je 0x4e3f
movq %r15, %rdi
leaq 0x52ba(%rip), %rsi      # 0xa07e
callq 0x4470
testl %eax, %eax
je 0x4e4c
leaq 0x52b2(%rip), %rdi      # 0xa086
movq %r15, %rsi
xorl %eax, %eax
callq 0x4030
jmp 0x4e29
movq 0x38(%rbx), %r15
movq %r12, %rdi
callq 0x4130
movq 0x10(%rsp), %rdi
jmp 0x4e19
movq 0x60(%rbx), %r15
movq %r12, %rdi
callq 0x4130
movq 0x8(%rsp), %rdi
jmp 0x4e19
movq 0x80(%rbx), %r15
movq %r12, %rdi
callq 0x4130
movq (%rsp), %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %r12, %rcx
movq %rax, %r8
callq 0x44f0
movq %r12, %rdi
callq *(%r13)
movq 0x30(%r14), %r14
testq %r14, %r14
jne 0x4d42
jmp 0x4e59
movq %r12, %rdi
callq 0x4500
movl %eax, 0x50(%rbx)
jmp 0x4e29
movq %r12, %rdi
callq 0x4500
movl %eax, 0x54(%rbx)
jmp 0x4e29
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/devinsmith[P]qvdreader/QvdFile.cpp
// Function: QvdFile::Load(char const*)
bool QvdFile::Load(const char *filename)
{
  _fp = fopen(filename, "rb");
  if (_fp == NULL) {
    return false;
  }

  if (!parseXmlHeader(filename)) {
    return false;
  }

  if (_eof && _bufLen == 0) {
    // XML header parsed but missing symbol table and data.
    return false;
  }

  // The start of the dataPtr might have the ending \r and \n from
  // the XML portion, if so skip past that.
  char c;
  while (_bufLen > 0) {
    c = peekByte();
    if (c == '\r' || c == '\n' || c == '\0') {
      advanceBytes(1);
      continue;
    }
    break;
  }

  if (_eof && _bufLen == 0) {
    // XML header parsed but missing symbol table and data.
    return false;
  }

  DEBUG(fprintf(stdout, "%zu bytes left\n", _bufLen););

  parseSymbolAndData();

  // First 2 bytes seem to store a type:
  // 00 01 - INT
  // 00 04 - Text
  // 00 05 - Dual INT


  //dump_hex(0, _dataPtrStart, _bufLen);

  // Read rest of file.
  while (!_eof) {
    size_t len = readBytes();

    DEBUG(printf("Read %zu bytes.\n", len););
  }

  fclose(_fp);

  return true;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x4fbb(%rip), %rsi      # 0xa150
movq %r14, %rdi
callq 0x43f0
movq %rax, 0x128(%rbx)
testq %rax, %rax
je 0x5218
movq %rbx, %rdi
movq %r14, %rsi
callq 0x40d0
testb %al, %al
je 0x5218
cmpb $0x1, 0x2140(%rbx)
jne 0x51cb
cmpq $0x0, 0x2138(%rbx)
je 0x5218
cmpq $0x0, 0x2138(%rbx)
je 0x5205
movl $0x2401, %ebp           # imm = 0x2401
movq %rbx, %rdi
callq 0x4320
cmpb $0xd, %al
ja 0x5205
movzbl %al, %eax
btl %eax, %ebp
jae 0x5205
movl $0x1, %esi
movq %rbx, %rdi
callq 0x4650
cmpq $0x0, 0x2138(%rbx)
jne 0x51da
cmpb $0x1, 0x2140(%rbx)
jne 0x521f
cmpq $0x0, 0x2138(%rbx)
jne 0x521f
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
callq 0x44b0
cmpb $0x0, 0x2140(%rbx)
jne 0x5276
leaq 0x130(%rbx), %r14
movq 0x128(%rbx), %rcx
movl $0x1, %esi
movl $0x2000, %edx           # imm = 0x2000
movq %r14, %rdi
callq 0x44c0
cmpq $0x1fff, %rax           # imm = 0x1FFF
ja 0x525f
movb $0x1, 0x2140(%rbx)
movq %r14, 0x2130(%rbx)
movq %rax, 0x2138(%rbx)
cmpb $0x1, 0x2140(%rbx)
jne 0x5237
movq 0x128(%rbx), %rdi
callq 0x4330
movb $0x1, %al
jmp 0x521a
// File: /workspace/github_cpp_makefile_star2_O1/devinsmith[P]qvdreader/QvdFile.cpp
// Function: QvdFile::peekByte()
char QvdFile::peekByte()
{
  char c;

  if (_bufLen == 0) {
    if (!_eof) {
      readBytes();
    } else {
      return 0; // throw an error.
    }
  }

  c = *_dataPtrStart;

  return c;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x2138(%rdi)
jne 0x5423
cmpb $0x0, 0x2140(%rbx)
je 0x53e6
xorl %eax, %eax
jmp 0x542c
leaq 0x130(%rbx), %r14
movq 0x128(%rbx), %rcx
movl $0x1, %esi
movl $0x2000, %edx           # imm = 0x2000
movq %r14, %rdi
callq 0x44c0
cmpq $0x1fff, %rax           # imm = 0x1FFF
ja 0x5415
movb $0x1, 0x2140(%rbx)
movq %r14, 0x2130(%rbx)
movq %rax, 0x2138(%rbx)
movq 0x2130(%rbx), %rax
movb (%rax), %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/devinsmith[P]qvdreader/QvdFile.cpp
// Function: QvdFile::advanceBytes(unsigned long)
void QvdFile::advanceBytes(size_t nBytes)
{
  if (_bufLen < nBytes) {
    if (!_eof) {
      readBytes();
    } else {
      return; // throw an error.
    }
  }

  if (_bufLen < nBytes) {
    return; // throw an error.
  }

  _bufLen -= nBytes;
  _dataPtrStart += nBytes;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpq %rsi, 0x2138(%rdi)
jae 0x5490
cmpb $0x0, 0x2140(%r14)
jne 0x54aa
leaq 0x130(%r14), %r15
movq 0x128(%r14), %rcx
movl $0x1, %esi
movl $0x2000, %edx           # imm = 0x2000
movq %r15, %rdi
callq 0x44c0
cmpq $0x1fff, %rax           # imm = 0x1FFF
ja 0x5482
movb $0x1, 0x2140(%r14)
movq %r15, 0x2130(%r14)
movq %rax, 0x2138(%r14)
movq 0x2138(%r14), %rax
subq %rbx, %rax
jb 0x54aa
movq %rax, 0x2138(%r14)
addq %rbx, 0x2130(%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/devinsmith[P]qvdreader/QvdFile.cpp
// Function: QvdFile::readBytes()
size_t QvdFile::readBytes()
{
  size_t len = fread(_buf, 1, sizeof(_buf), _fp);
  if (len < sizeof(_buf)) {
    _eof = true;
  }
  _dataPtrStart = _buf;
  _bufLen = len;
  return len;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x130(%rdi), %r14
movq 0x128(%rdi), %rcx
movl $0x1, %esi
movl $0x2000, %edx           # imm = 0x2000
movq %r14, %rdi
callq 0x44c0
cmpq $0x1fff, %rax           # imm = 0x1FFF
ja 0x57fc
movb $0x1, 0x2140(%rbx)
movq %r14, 0x2130(%rbx)
movq %rax, 0x2138(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/devinsmith[P]qvdreader/QvdFile.cpp
// Function: QvdFile::readByte()
char QvdFile::readByte()
{
  char c;

  if (_bufLen == 0) {
    if (!_eof) {
      readBytes();
    } else {
      return 0; // throw an error.
    }
  }

  _bufLen--;
  c = *_dataPtrStart++;

  return c;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x2138(%rdi)
jne 0x586d
cmpb $0x0, 0x2140(%rbx)
je 0x5830
xorl %eax, %eax
jmp 0x5888
leaq 0x130(%rbx), %r14
movq 0x128(%rbx), %rcx
movl $0x1, %esi
movl $0x2000, %edx           # imm = 0x2000
movq %r14, %rdi
callq 0x44c0
cmpq $0x1fff, %rax           # imm = 0x1FFF
ja 0x585f
movb $0x1, 0x2140(%rbx)
movq %r14, 0x2130(%rbx)
movq %rax, 0x2138(%rbx)
decq 0x2138(%rbx)
movq 0x2130(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x2130(%rbx)
movb (%rax), %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/devinsmith[P]qvdreader/QvdFile.cpp
// Function: QvdFile::readInt32()
int QvdFile::readInt32()
{
  return static_cast<int>(static_cast<unsigned char>(readByte())       |
                          static_cast<unsigned char>(readByte()) <<  8 |
                          static_cast<unsigned char>(readByte()) << 16 |
                          static_cast<unsigned char>(readByte()) << 24);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x42b0
movzbl %al, %ebp
movq %rbx, %rdi
callq 0x42b0
movzbl %al, %r14d
shll $0x8, %r14d
orl %ebp, %r14d
movq %rbx, %rdi
callq 0x42b0
movzbl %al, %ebp
shll $0x10, %ebp
orl %r14d, %ebp
movq %rbx, %rdi
callq 0x42b0
movzbl %al, %eax
shll $0x18, %eax
orl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/devinsmith[P]qvdreader/QvdFile.cpp
// Function: QvdFile::readDouble()
double QvdFile::readDouble()
{
  double d;
  unsigned char c[8];

  for (int i=0; i<8; i++) {
    c[i] = static_cast<unsigned char>(readByte());
  }
  d = *reinterpret_cast<double*>(c);
  return d;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x42b0
movb %al, (%rsp,%r14)
incq %r14
cmpq $0x8, %r14
jne 0x58e2
movsd (%rsp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/devinsmith[P]qvdreader/QvdFile.cpp
// Function: QvdFile::get_bits_index(unsigned long)
int QvdFile::get_bits_index(size_t nBits)
{
  int i = 0;

  while (nBits > _bitBufferSz) {
    unsigned int byte = (unsigned char)readByte();
    //DEBUG(printf("Requesting %zu bits, but only have %d bits\n", nBits, _bitBufferSz););
    //DEBUG(printf("Read byte 0x%02x\n", byte););
    byte = byte << _bitBufferSz;
    _bitBufferSz += 8;
    _bitBuffer += byte;
  }
  //DEBUG(printf("_bitBufferSz: %d\n", _bitBufferSz););
  int mask = ((1 << nBits) - 1);
  i = (_bitBuffer) & mask;
  _bitBuffer = _bitBuffer >> nBits;
  _bitBufferSz -= nBits;

  return i;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl 0x2148(%rdi), %edx
cmpq %rsi, %rdx
jae 0x5942
movq %rbx, %rdi
callq 0x42b0
movzbl %al, %eax
movl 0x2148(%rbx), %edx
movl %edx, %ecx
shll %cl, %eax
addl $0x8, %edx
movl %edx, 0x2148(%rbx)
addl %eax, 0x2144(%rbx)
cmpq %r14, %rdx
jb 0x5919
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %r14d, %ecx
shll %cl, %eax
notl %eax
movl 0x2144(%rbx), %esi
andl %esi, %eax
shrl %cl, %esi
movl %esi, 0x2144(%rbx)
subl %r14d, %edx
movl %edx, 0x2148(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/devinsmith[P]qvdreader/QvdTableHeader.cpp
// Function: QvdTableHeader::ParseFields(_xmlNode const*)
void QvdTableHeader::ParseFields(const xmlNode *node)
{
  for (const xmlNode *child = node->children; child; child = child->next) {
    if (child->type == XML_ELEMENT_NODE) {
      xmlChar *nodeContent = xmlNodeGetContent(child);
      if (nodeContent == NULL)
        continue;

      if (strlen((char *)nodeContent) == 0) {
        xmlFree(nodeContent);
        continue;
      }

      if (strcmp((char *)child->name, "QvdFieldHeader") == 0) {
        QvdField field;
        field.ParseXml(child);

        Fields.push_back(field);
      } else {
        printf("Unprocessed Fields tag: %s\n", child->name);
      }
      xmlFree(nodeContent);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq 0x18(%rsi), %r14
testq %r14, %r14
je 0x80f3
movq %rdi, %rbx
addq $0x98, %rbx
xorl %r15d, %r15d
leaq 0x8(%rsp), %r12
cmpl $0x1, 0x8(%r14)
jne 0x80e6
movq %r14, %rdi
callq 0x43b0
testq %rax, %rax
je 0x80e6
movq %rax, %rbp
cmpb $0x0, (%rax)
je 0x80da
movq 0x10(%r14), %r13
movq %r13, %rdi
leaq 0x225f(%rip), %rsi      # 0xa1f1
callq 0x4470
testl %eax, %eax
je 0x7fb1
leaq 0x225e(%rip), %rdi      # 0xa200
movq %r13, %rsi
xorl %eax, %eax
callq 0x4030
jmp 0x80da
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %r15, 0x10(%rsp)
movb %r15b, 0x18(%rsp)
movq %r15, 0x28(%rsp)
movl %r15d, 0x30(%rsp)
leaq 0x48(%rsp), %rax
movq %rax, 0x38(%rsp)
movq %r15, 0x40(%rsp)
movb %r15b, 0x48(%rsp)
movq %r15, 0x58(%rsp)
leaq 0x70(%rsp), %rax
movq %rax, 0x60(%rsp)
movq %r15, 0x68(%rsp)
movb %r15b, 0x70(%rsp)
leaq 0x90(%rsp), %rax
movq %rax, 0x80(%rsp)
movq %r15, 0x88(%rsp)
movb %r15b, 0x90(%rsp)
movq %r15, 0xa0(%rsp)
movl %r15d, 0xa8(%rsp)
leaq 0xb0(%rsp), %rax
movq %r15, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %r12, %rdi
movq %r14, %rsi
callq 0x4140
movq %rbx, %rdi
movq %r12, %rsi
callq 0x40b0
leaq 0xb0(%rsp), %rdi
callq 0x4230
movq 0x80(%rsp), %rdi
leaq 0x90(%rsp), %rax
cmpq %rax, %rdi
je 0x8086
movq 0x90(%rsp), %rsi
incq %rsi
callq 0x4370
movq 0x60(%rsp), %rdi
leaq 0x70(%rsp), %rax
cmpq %rax, %rdi
je 0x80a2
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x4370
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x80be
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x4370
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x80da
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4370
movq %rbp, %rdi
movq 0x4efc(%rip), %rax      # 0xcfe0
callq *(%rax)
movq 0x30(%r14), %r14
testq %r14, %r14
jne 0x7f5c
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4060
movq %rbx, %rdi
callq 0x45c0
// File: /workspace/github_cpp_makefile_star2_O1/devinsmith[P]qvdreader/QvdTableHeader.cpp
// Function: QvdTableHeader::ParseLineage(_xmlNode const*)
void QvdTableHeader::ParseLineage(const xmlNode *node)
{
  for (const xmlNode *child = node->children; child; child = child->next) {
    if (child->type == XML_ELEMENT_NODE) {
      xmlChar *nodeContent = xmlNodeGetContent(child);
      if (nodeContent == NULL)
        continue;

      if (strlen((char *)nodeContent) == 0) {
        xmlFree(nodeContent);
        continue;
      }

      if (strcmp((char *)child->name, "LineageInfo") == 0) {
        QvdLineageInfo lin;
        lin.ParseXml(child);

        Lineages.push_back(lin);
      } else {
        printf("Unprocessed Lineage tag: %s\n", child->name);
      }
      xmlFree(nodeContent);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq 0x18(%rsi), %r14
testq %r14, %r14
je 0x8227
movq %rdi, %rbx
addq $0xb0, %rbx
movq 0x4e9a(%rip), %r12      # 0xcfe0
leaq 0x8(%rsp), %r15
cmpl $0x1, 0x8(%r14)
jne 0x821a
movq %r14, %rdi
callq 0x43b0
testq %rax, %rax
je 0x821a
movq %rax, %rbp
cmpb $0x0, (%rax)
je 0x8213
movq 0x10(%r14), %r13
movq %r13, %rdi
leaq 0x209b(%rip), %rsi      # 0xa21c
callq 0x4470
testl %eax, %eax
je 0x819d
leaq 0x2097(%rip), %rdi      # 0xa228
movq %r13, %rsi
xorl %eax, %eax
callq 0x4030
jmp 0x8213
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
xorl %ecx, %ecx
movq %rcx, 0x10(%rsp)
movb %cl, 0x18(%rsp)
leaq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
movq %rcx, 0x30(%rsp)
movb %cl, 0x38(%rsp)
movq %r15, %rdi
movq %r14, %rsi
callq 0x4080
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4360
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x81f7
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x4370
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x8213
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x4370
movq %rbp, %rdi
callq *(%r12)
movq 0x30(%r14), %r14
testq %r14, %r14
jne 0x814b
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4660
movq %rbx, %rdi
callq 0x45c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/devinsmith[P]qvdreader/utils/conversions.cpp
// Function: utils::mem_to_uint(char const*, unsigned long)
unsigned int mem_to_uint(const char *buf, size_t len)
{
  unsigned int n = 0;

  while (len--) {
    n = n * 10 + *buf++ - '0';
  }

  return n;
}

// Assembly:
testq %rsi, %rsi
je 0x8eff
xorl %ecx, %ecx
xorl %eax, %eax
leal (%rax,%rax,4), %eax
movsbl (%rdi,%rcx), %edx
leal (%rdx,%rax,2), %eax
addl $-0x30, %eax
incq %rcx
cmpq %rcx, %rsi
jne 0x8ee9
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/devinsmith[P]qvdreader/utils/conversions.cpp
// Function: utils::mem_to_int(char const*, unsigned long)
int mem_to_int(const char *buf, size_t len)
{
  bool neg = false;
  int n = 0;

  if (*buf == '-')
    neg = true;

  while (len--) {
    n = n * 10 + *buf++ - '0';
  }

  return neg ? -n : n;
}

// Assembly:
movb (%rdi), %cl
testq %rsi, %rsi
je 0x8f26
xorl %eax, %eax
xorl %edx, %edx
leal (%rdx,%rdx,4), %edx
movsbl (%rdi,%rax), %r8d
leal (%r8,%rdx,2), %edx
addl $-0x30, %edx
incq %rax
cmpq %rax, %rsi
jne 0x8f0d
jmp 0x8f28
xorl %edx, %edx
movl %edx, %eax
negl %eax
cmpb $0x2d, %cl
cmovnel %edx, %eax
retq
nop