LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::Config::Config(Catch::ConfigData const&)
Config( ConfigData const& data )
        :   m_data( data ),
            m_os( std::cout.rdbuf() )
        {
            if( !data.testsOrTags.empty() ) {
                TestSpecParser parser( ITagAliasRegistry::get() );
                for( std::size_t i = 0; i < data.testsOrTags.size(); ++i )
                    parser.parse( data.testsOrTags[i] );
                m_testSpec = parser.testSpec();
            }
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %r14
andl $0x0, 0x8(%rdi)
movq %rsi, %r15
leaq 0x3374c(%rip), %rax     # 0x4a798
movq %rax, (%rdi)
leaq 0x10(%rdi), %rbx
movq %rbx, %rdi
callq 0x171de
andq $0x0, 0xc8(%r14)
movb $0x0, 0xd0(%r14)
leaq 0xd8(%r14), %rdi
movq 0x34f47(%rip), %rax     # 0x4bfc0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq 0xe8(%rax,%rcx), %rsi
callq 0x9150
xorps %xmm0, %xmm0
andq $0x0, 0x1f8(%r14)
movups %xmm0, 0x1e8(%r14)
movq 0xa0(%r15), %rax
cmpq 0xa8(%r15), %rax
je 0x1715b
leaq 0x1e8(%r14), %rax
movq %rax, 0x8(%rsp)
callq 0xcbec
leaq 0x50(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x30(%rax)
leaq 0x3531c(%rip), %rcx     # 0x4c408
movq %rcx, 0x40(%rax)
xorl %ebp, %ebp
leaq 0x28(%rsp), %r13
xorl %r12d, %r12d
movq 0xa0(%r15), %rsi
movq 0xa8(%r15), %rax
subq %rsi, %rax
sarq $0x5, %rax
cmpq %rax, %r12
jae 0x17128
addq %rbp, %rsi
movq %r13, %rdi
callq 0x172a0
incq %r12
addq $0x20, %rbp
jmp 0x170fa
leaq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x1731c
leaq 0x10(%rsp), %rbx
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x18102
movq %rbx, %rdi
callq 0x18154
leaq 0x28(%rsp), %rdi
callq 0x17348
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x17174
movq %rax, %r15
jmp 0x1719a
movq %rax, %r15
leaq 0x28(%rsp), %rdi
callq 0x17348
movq 0x8(%rsp), %rdi
callq 0x18154
addq $0xe0, %r14
movq %r14, %rdi
callq 0x9120
movq %rbx, %rdi
callq 0x12ac0
movq %r15, %rdi
callq 0x9610
// File: /workspace/github_cpp_makefile_star2_O2/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::TestSpec::NamePattern::NamePattern(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
NamePattern( std::string const& name ) : m_name( toLower( name ) ), m_wildcard( NoWildcard ) {
                if( startsWith( m_name, "*" ) ) {
                    m_name = m_name.substr( 1 );
                    m_wildcard = WildcardAtStart;
                }
                if( endsWith( m_name, "*" ) ) {
                    m_name = m_name.substr( 0, m_name.size()-1 );
                    m_wildcard = static_cast<WildcardPosition>( m_wildcard | WildcardAtEnd );
                }
            }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
andl $0x0, 0x8(%rdi)
leaq 0x325a6(%rip), %rax     # 0x4a478
movq %rax, (%rdi)
leaq 0x10(%rdi), %rbx
movq %rbx, %rdi
callq 0xac00
andl $0x0, 0x30(%r14)
leaq 0x1979c(%rip), %rsi     # 0x31689
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xd4fa
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xa976
movl %eax, %ebp
leaq 0x8(%rsp), %rdi
callq 0x91a0
testb %bpl, %bpl
je 0x17f4d
leaq 0x8(%rsp), %rdi
pushq $0x1
popq %rdx
pushq $-0x1
popq %rcx
movq %rbx, %rsi
callq 0x93e0
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9450
movq %r15, %rdi
callq 0x91a0
movl $0x1, 0x30(%r14)
leaq 0x19735(%rip), %rsi     # 0x31689
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xd4fa
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xb4cb
movl %eax, %ebp
leaq 0x8(%rsp), %rdi
callq 0x91a0
testb %bpl, %bpl
je 0x17fb4
movq 0x18(%r14), %rcx
decq %rcx
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x93e0
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x9450
movq %r15, %rdi
callq 0x91a0
orb $0x2, 0x30(%r14)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x17fd6
jmp 0x17fd6
jmp 0x17fc7
jmp 0x17fd6
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x91a0
jmp 0x17fd9
movq %rax, %r14
movq %rbx, %rdi
callq 0x91a0
movq %r14, %rdi
callq 0x9610
nop
// File: /workspace/github_cpp_makefile_star2_O2/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::Runner::makeReporter()
void makeReporter() {
            std::string reporterName = m_config->getReporterName().empty()
                ? "console"
                : m_config->getReporterName();

            m_reporter = getRegistryHub().getReporterRegistry().create( reporterName, m_config.get() );
            if( !m_reporter ) {
                std::ostringstream oss;
                oss << "No reporter registered with name: '" << reporterName << "'";
                throw std::domain_error( oss.str() );
            }
        }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1c0, %rsp            # imm = 0x1C0
movq %rdi, %rbx
movq (%rdi), %rsi
addq $0x30, %rsi
leaq 0x48(%rsp), %r14
movq %r14, %rdi
callq 0x9490
cmpq $0x0, 0x8(%r14)
je 0x182c2
movq (%rbx), %rsi
addq $0x30, %rsi
leaq 0x8(%rsp), %rdi
callq 0x9490
jmp 0x182d8
leaq 0x185c6(%rip), %rsi     # 0x3088f
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0xd4fa
leaq 0x48(%rsp), %rdi
callq 0x91a0
callq 0xa1cd
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq %rax, %r14
movq (%rbx), %rdi
movq %rdi, 0x48(%rsp)
testq %rdi, %rdi
je 0x18306
movq (%rdi), %rax
callq *0x10(%rax)
movq (%r14), %rax
leaq 0x8(%rsp), %rsi
leaq 0x48(%rsp), %rdx
movq %r14, %rdi
callq *0x10(%rax)
addq $0x208, %rbx            # imm = 0x208
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1847e
leaq 0x48(%rsp), %rdi
callq 0xe054
cmpq $0x0, (%rbx)
je 0x18351
leaq 0x8(%rsp), %rdi
callq 0x91a0
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x48(%rsp), %rdi
callq 0x9480
leaq 0x18cd8(%rip), %rsi     # 0x3103a
leaq 0x48(%rsp), %rdi
callq 0x9390
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x9350
leaq 0x18a31(%rip), %rsi     # 0x30db1
movq %rax, %rdi
callq 0x9390
pushq $0x10
popq %rdi
callq 0x91c0
movq %rax, %r14
leaq 0x50(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0x9530
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0x9430
xorl %ebp, %ebp
movq 0x33bdd(%rip), %rsi     # 0x4bf98
movq 0x33be6(%rip), %rdx     # 0x4bfa8
movq %r14, %rdi
callq 0x95e0
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x91a0
testb %bpl, %bpl
jne 0x183e1
jmp 0x183f0
movq %rax, %rbx
movq %r14, %rdi
callq 0x92d0
jmp 0x183f0
jmp 0x18400
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x90c0
jmp 0x1841c
jmp 0x18419
jmp 0x18419
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
jmp 0x18421
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0xe054
jmp 0x1841c
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x91a0
movq %rbx, %rdi
callq 0x9610
// File: /workspace/github_cpp_makefile_star2_O2/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::listTestsNamesOnly(Catch::Config const&)
inline std::size_t listTestsNamesOnly( Config const& config ) {
        TestSpec testSpec = config.testSpec();
        if( !config.testSpec().hasFilters() )
            testSpec = TestSpecParser( ITagAliasRegistry::get() ).parse( "*" ).testSpec();
        std::size_t matchedTests = 0;
        std::vector<TestCase> matchedTestCases;
        getRegistryHub().getTestCaseRegistry().getFilteredTests( testSpec, config, matchedTestCases );
        for( std::vector<TestCase>::const_iterator it = matchedTestCases.begin(), itEnd = matchedTestCases.end();
                it != itEnd;
                ++it ) {
            matchedTests++;
            TestCaseInfo const& testCaseInfo = it->getTestCaseInfo();
            std::cout << testCaseInfo.name << std::endl;
        }
        return matchedTests;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x68(%rax)
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x17fea
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x68(%rax)
movq (%rax), %rcx
cmpq 0x8(%rax), %rcx
jne 0x18960
callq 0xcbec
leaq 0x68(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x30(%rax)
leaq 0x33b12(%rip), %rcx     # 0x4c408
movq %rcx, 0x40(%rax)
leaq 0x18d88(%rip), %rsi     # 0x31689
leaq 0x20(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xd4fa
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x172a0
leaq 0xb0(%rsp), %rdi
movq %rax, %rsi
callq 0x1731c
leaq 0x8(%rsp), %rdi
leaq 0xb0(%rsp), %r14
movq %r14, %rsi
callq 0x18102
movq %r14, %rdi
callq 0x18154
leaq 0x20(%rsp), %rdi
callq 0x91a0
leaq 0x40(%rsp), %rdi
callq 0x17348
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
andq $0x0, 0x50(%rsp)
callq 0xa1cd
movq (%rax), %rcx
movq %rax, %rdi
callq *0x18(%rcx)
movq (%rax), %r8
leaq 0x8(%rsp), %rsi
leaq 0x40(%rsp), %rcx
movq %rax, %rdi
movq %rbx, %rdx
callq *0x18(%r8)
movq 0x40(%rsp), %r14
movq 0x48(%rsp), %r12
xorl %ebx, %ebx
movq 0x3361a(%rip), %r15     # 0x4bfc0
cmpq %r12, %r14
je 0x189ca
movq %r15, %rdi
movq %r14, %rsi
callq 0x9350
movq %rax, %rdi
callq 0x91b0
addq $0x118, %r14            # imm = 0x118
incq %rbx
jmp 0x189a6
leaq 0x40(%rsp), %rdi
callq 0xe0d2
leaq 0x8(%rsp), %rdi
callq 0x18154
movq %rbx, %rax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
jmp 0x18a02
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x91a0
leaq 0x40(%rsp), %rdi
callq 0x17348
jmp 0x18a22
movq %rax, %rbx
jmp 0x18a22
jmp 0x18a15
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0xe0d2
leaq 0x8(%rsp), %rdi
callq 0x18154
movq %rbx, %rdi
callq 0x9610
// File: /workspace/github_cpp_makefile_star2_O2/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::RunContext::~RunContext()
virtual ~RunContext() {
            m_reporter->testRunEnded( TestRunStats( m_runInfo, m_totals, aborting() ) );
            m_context.setRunner( m_prevRunner );
            m_context.setConfig( NULL );
            m_context.setResultCapture( m_prevResultCapture );
            m_context.setConfig( m_prevConfig );
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq 0x31ca1(%rip), %rax     # 0x4b850
movq %rax, (%rdi)
leaq 0x31cf7(%rip), %rax     # 0x4b8b0
movq %rax, 0x8(%rdi)
movq 0x1a8(%rdi), %r15
callq 0x19890
leaq 0x10(%rbx), %r14
leaq 0x178(%rbx), %rdx
movzbl %al, %ecx
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x1beec
movq (%r15), %rax
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq *0x78(%rax)
leaq 0x8(%rsp), %rdi
callq 0xce5e
movq 0x30(%rbx), %rdi
movq 0x1c8(%rbx), %rsi
movq (%rdi), %rax
callq *0x40(%rax)
movq 0x30(%rbx), %rdi
leaq 0x8(%rsp), %rsi
andq $0x0, (%rsi)
movq (%rdi), %rax
callq *0x48(%rax)
leaq 0x8(%rsp), %rdi
callq 0xdaf4
movq 0x30(%rbx), %rdi
movq 0x1d0(%rbx), %rsi
movq (%rdi), %rax
callq *0x38(%rax)
movq 0x30(%rbx), %rdi
leaq 0x1d8(%rbx), %r15
movq (%rdi), %rax
movq %r15, %rsi
callq *0x48(%rax)
leaq 0x1a8(%rbx), %r12
leaq 0x250(%rbx), %rdi
callq 0x19cca
leaq 0x1e0(%rbx), %rdi
callq 0xd642
movq %r15, %rdi
callq 0xdaf4
leaq 0x1b0(%rbx), %rdi
callq 0xdf4c
movq %r12, %rdi
callq 0x1842e
leaq 0x170(%rbx), %rdi
callq 0xdaf4
leaq 0xb8(%rbx), %rdi
callq 0xa790
addq $0x40, %rbx
movq %rbx, %rdi
callq 0x1a1aa
movq %r14, %rdi
callq 0x91a0
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rdi
callq 0xd5fe
// File: /workspace/github_cpp_makefile_star2_O2/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::RunContext::sectionStarted(Catch::SectionInfo const&, Catch::Counts&)
virtual bool sectionStarted (
            SectionInfo const& sectionInfo,
            Counts& assertions
        )
        {
            std::ostringstream oss;
            oss << sectionInfo.name << "@" << sectionInfo.lineInfo;

            if( !m_testCaseTracker->enterSection( oss.str() ) )
                return false;

            m_lastAssertionInfo.lineInfo = sectionInfo.lineInfo;

            m_reporter->sectionStarting( sectionInfo );

            assertions = m_totals.assertions;

            return true;
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x20(%rsp), %r12
movq %r12, %rdi
callq 0x9480
movq %r12, %rdi
movq %r15, %rsi
callq 0x9350
leaq 0x16975(%rip), %rsi     # 0x30818
movq %rax, %rdi
callq 0x9390
leaq 0x40(%r15), %r12
movq %rax, %rdi
movq %r12, %rsi
callq 0xa3f9
movq 0x40(%r14), %r13
leaq 0x28(%rsp), %rsi
movq %rsp, %rdi
callq 0x9530
movq %rsp, %rsi
movq %r13, %rdi
callq 0x1a986
movl %eax, %ebp
movq %rsp, %rdi
callq 0x91a0
testb %bpl, %bpl
je 0x19f1a
leaq 0x200(%r14), %rdi
movq %r12, %rsi
callq 0x1a964
movq 0x1a8(%r14), %rdi
movq (%rdi), %rax
movq %r15, %rsi
callq *0x48(%rax)
movq 0x188(%r14), %rax
movq %rax, 0x10(%rbx)
movups 0x178(%r14), %xmm0
movups %xmm0, (%rbx)
leaq 0x20(%rsp), %rdi
callq 0x90c0
movl %ebp, %eax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x91a0
jmp 0x19f4a
jmp 0x19f47
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x90c0
movq %rbx, %rdi
callq 0x9610
// File: /workspace/github_cpp_makefile_star2_O2/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::RunContext::sectionEnded(Catch::SectionInfo const&, Catch::Counts const&, double)
virtual void sectionEnded( SectionInfo const& info, Counts const& prevAssertions, double _durationInSeconds ) {
            if( std::uncaught_exception() ) {
                m_unfinishedSections.push_back( UnfinishedSections( info, prevAssertions, _durationInSeconds ) );
                return;
            }

            Counts assertions = m_totals.assertions - prevAssertions;
            bool missingAssertions = testForMissingAssertions( assertions );

            m_testCaseTracker->leaveSection();

            m_reporter->sectionEnded( SectionStats( info, assertions, _durationInSeconds, missingAssertions ) );
            m_messages.clear();
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
callq 0x9040
testb %al, %al
je 0x19fd9
addq $0x250, %rbx            # imm = 0x250
leaq 0x30(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0xda7e
movq 0x10(%r15), %rax
movq %rax, 0x78(%r12)
movups (%r15), %xmm0
movups %xmm0, 0x68(%r12)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x80(%r12)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1ae8a
leaq 0x30(%rsp), %rdi
callq 0xdad4
jmp 0x1a064
movdqu 0x178(%rbx), %xmm0
movdqu (%r15), %xmm1
psubq %xmm1, %xmm0
leaq 0x10(%rsp), %r12
movdqa %xmm0, (%r12)
movq 0x188(%rbx), %rax
subq 0x10(%r15), %rax
movq %rax, 0x10(%r12)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1ad94
movl %eax, %ebp
movq 0x40(%rbx), %rdi
callq 0x1ade8
movq 0x1a8(%rbx), %r15
movzbl %bpl, %ecx
leaq 0x30(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rdx
movsd 0x8(%rsp), %xmm0
callq 0x1ae2c
movq (%r15), %rax
movq %r15, %rdi
movq %r13, %rsi
callq *0x60(%rax)
leaq 0x30(%rsp), %rdi
callq 0xcdbc
addq $0x1b0, %rbx            # imm = 0x1B0
movq %rbx, %rdi
callq 0x1a3fe
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xcdbc
jmp 0x1a092
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xdad4
movq %rbx, %rdi
callq 0x9610
// File: /workspace/github_cpp_makefile_star2_O2/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::SectionTracking::TestCaseTracker::enterSection(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool enterSection( std::string const& name ) {
            TrackedSection* child = m_currentSection->acquireChild( name );
            if( m_completedASectionThisRun || child->runState() == TrackedSection::Completed )
                return false;

            m_currentSection = child;
            m_currentSection->enter();
            return true;
        }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
callq 0x1a9bc
cmpb $0x0, 0x68(%rbx)
jne 0x1a9a4
movq %rax, %rcx
movl 0x20(%rax), %edx
cmpl $0x3, %edx
jne 0x1a9a8
xorl %eax, %eax
popq %rbx
retq
movq %rcx, 0x60(%rbx)
movb $0x1, %al
testl %edx, %edx
jne 0x1a9a6
movl $0x1, 0x20(%rcx)
jmp 0x1a9a6
nop
// File: /workspace/github_cpp_makefile_star2_O2/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::SectionTracking::TrackedSection::acquireChild(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
TrackedSection* acquireChild( std::string const& childName ) {
            if( TrackedSection* child = findChild( childName ) )
                return child;
            m_children.insert( std::make_pair( childName, TrackedSection( childName, this ) ) );
            return findChild( childName );
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xe0, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1aa54
testq %rax, %rax
jne 0x1aa24
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1aa78
leaq 0x60(%rsp), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x1ad6e
leaq 0x28(%r14), %rdi
leaq 0x60(%rsp), %rsi
callq 0x1ab40
leaq 0x60(%rsp), %rdi
callq 0x1aab4
movq %rsp, %rdi
callq 0x1a1c2
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1aa54
addq $0xe0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x1aab4
jmp 0x1aa43
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1a1c2
movq %rbx, %rdi
callq 0x9610
nop
// File: /workspace/github_cpp_makefile_star2_O2/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::SectionTracking::TrackedSection::findChild(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
TrackedSection* findChild( std::string const& childName ) {
            TrackedSections::iterator it = m_children.find( childName );
            return it != m_children.end()
                ? &it->second
                : NULL;
        }

// Assembly:
pushq %rbx
movq %rdi, %rbx
addq $0x28, %rdi
callq 0x1aaca
addq $0x30, %rbx
leaq 0x40(%rax), %rdx
xorl %ecx, %ecx
cmpq %rbx, %rax
cmovneq %rdx, %rcx
movq %rcx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::SectionTracking::TestCaseTracker::leaveSection()
void leaveSection() {
            m_currentSection->leave();
            m_currentSection = m_currentSection->getParent();
            assert( m_currentSection != NULL );
            m_completedASectionThisRun = true;
        }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x60(%rdi), %rdi
callq 0x1b0e2
movq 0x60(%rbx), %rax
movq 0x58(%rax), %rax
movq %rax, 0x60(%rbx)
testq %rax, %rax
je 0x1ae0c
movb $0x1, 0x68(%rbx)
popq %rbx
retq
leaq 0x1630d(%rip), %rdi     # 0x31120
leaq 0x15963(%rip), %rsi     # 0x3077d
leaq 0x16318(%rip), %rcx     # 0x31139
movl $0x1308, %edx           # imm = 0x1308
callq 0x9260
nop
// File: /workspace/github_cpp_makefile_star2_O2/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::SectionTracking::TrackedSection::leave()
void leave() {
            for( TrackedSections::const_iterator it = m_children.begin(), itEnd = m_children.end();
                    it != itEnd;
                    ++it )
                if( it->second.runState() != Completed ) {
                    m_runState = ExecutingChildren;
                    return;
                }
            m_runState = Completed;
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x40(%rdi), %rax
leaq 0x30(%rdi), %r14
pushq $0x3
popq %rbp
pushq $0x2
popq %r15
cmpq %r14, %rax
je 0x1b113
cmpl $0x3, 0x60(%rax)
jne 0x1b110
movq %rax, %rdi
callq 0x9400
jmp 0x1b0fb
movl %r15d, %ebp
movl %ebp, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::XmlWriter::writeAttribute(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&)
XmlWriter& writeAttribute( std::string const& name, std::string const& attribute ) {
            if( !name.empty() && !attribute.empty() ) {
                stream() << " " << name << "=\"";
                writeEncodedText( attribute );
                stream() << "\"";
            }
            return *this;
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x8(%rsi)
je 0x1db5b
movq %rdx, %r14
cmpq $0x0, 0x8(%rdx)
je 0x1db5b
movq %rsi, %r15
movq 0x40(%rbx), %rdi
leaq 0x12bee(%rip), %rsi     # 0x3070f
callq 0x9390
movq %rax, %rdi
movq %r15, %rsi
callq 0x9350
leaq 0x13853(%rip), %rsi     # 0x3138b
movq %rax, %rdi
callq 0x9390
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1db82
movq 0x40(%rbx), %rdi
leaq 0x13690(%rip), %rsi     # 0x311e6
callq 0x9390
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::XmlWriter::writeEncodedText(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void writeEncodedText( std::string const& text ) {
            static const char* charsToEncode = "<&\"";
            std::string mtext = text;
            std::string::size_type pos = mtext.find_first_of( charsToEncode );
            while( pos != std::string::npos ) {
                stream() << mtext.substr( 0, pos );

                switch( mtext[pos] ) {
                    case '<':
                        stream() << "&lt;";
                        break;
                    case '&':
                        stream() << "&amp;";
                        break;
                    case '\"':
                        stream() << "&quot;";
                        break;
                }
                mtext = mtext.substr( pos+1 );
                pos = mtext.find_first_of( charsToEncode );
            }
            stream() << mtext;
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x9490
movq 0x2e811(%rip), %rsi     # 0x4c3b8
movq %r14, %rdi
xorl %edx, %edx
callq 0x91d0
movq %rax, %r13
leaq 0x28(%rsp), %r15
pushq $-0x1
popq %r12
movq 0x40(%rbx), %rbp
cmpq $-0x1, %r13
je 0x1dc67
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %r13, %rcx
callq 0x93e0
movq %rbp, %rdi
movq %r15, %rsi
callq 0x9350
movq %r15, %rdi
callq 0x91a0
movq 0x8(%rsp), %rax
movzbl (%rax,%r13), %eax
cmpl $0x22, %eax
je 0x1dc17
leaq 0x13793(%rip), %rsi     # 0x31397
cmpl $0x26, %eax
je 0x1dc1e
cmpl $0x3c, %eax
jne 0x1dc27
leaq 0x1377d(%rip), %rsi     # 0x31392
jmp 0x1dc1e
leaq 0x1377f(%rip), %rsi     # 0x3139d
movq 0x40(%rbx), %rdi
callq 0x9390
incq %r13
movq %r15, %rdi
movq %r14, %rsi
movq %r13, %rdx
movq %r12, %rcx
callq 0x93e0
movq %r14, %rdi
movq %r15, %rsi
callq 0x9450
movq %r15, %rdi
callq 0x91a0
movq 0x2e763(%rip), %rsi     # 0x4c3b8
movq %r14, %rdi
xorl %edx, %edx
callq 0x91d0
movq %rax, %r13
jmp 0x1dbbd
leaq 0x8(%rsp), %rsi
movq %rbp, %rdi
callq 0x9350
leaq 0x8(%rsp), %rdi
callq 0x91a0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1dc93
jmp 0x1dc93
jmp 0x1dc93
movq %rax, %rbx
jmp 0x1dca5
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x91a0
leaq 0x8(%rsp), %rdi
callq 0x91a0
movq %rbx, %rdi
callq 0x9610
nop
// File: /workspace/github_cpp_makefile_star2_O2/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::XmlWriter::writeText(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
XmlWriter& writeText( std::string const& text, bool indent = true ) {
            if( !text.empty() ){
                bool tagWasOpen = m_tagIsOpen;
                ensureTagClosed();
                if( tagWasOpen && indent )
                    stream() << m_indent;
                writeEncodedText( text );
                m_needsNewline = true;
            }
            return *this;
        }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x8(%rsi)
je 0x1de24
movl %edx, %ebp
movq %rsi, %r14
andb (%rbx), %bpl
movq %rbx, %rdi
callq 0x1db64
cmpb $0x1, %bpl
jne 0x1de15
movq 0x40(%rbx), %rdi
leaq 0x20(%rbx), %rsi
callq 0x9350
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1db82
movb $0x1, 0x1(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::ConsoleReporter::lazyPrintRunInfo()
void lazyPrintRunInfo() {
            stream  << "\n" << getLineOfChars<'~'>() << "\n";
            Colour colour( Colour::SecondaryText );
            stream  << currentTestRunInfo->name
                    << " is a Catch v"  << libraryVersion.majorVersion << "."
                    << libraryVersion.minorVersion << " b"
                    << libraryVersion.buildNumber;
            if( libraryVersion.branchName != std::string( "master" ) )
                stream << " (" << libraryVersion.branchName << ")";
            stream  << " host application.\n"
                    << "Run with -? for options\n\n";

            currentTestRunInfo.used = true;
        }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
leaq 0x12583(%rip), %rsi     # 0x3156f
callq 0x9390
cmpb $0x0, 0x2d478(%rip)     # 0x4c470
jne 0x1f02b
movaps 0x1104f(%rip), %xmm0    # 0x30050
movups %xmm0, 0x2d4a7(%rip)    # 0x4c4af
movaps %xmm0, 0x2d491(%rip)    # 0x4c4a0
movaps %xmm0, 0x2d47a(%rip)    # 0x4c490
movaps %xmm0, 0x2d463(%rip)    # 0x4c480
movaps %xmm0, 0x2d44c(%rip)    # 0x4c470
movb $0x0, 0x2d494(%rip)     # 0x4c4bf
leaq 0x2d43e(%rip), %rsi     # 0x4c470
movq %rax, %rdi
callq 0x9390
leaq 0x1252e(%rip), %rsi     # 0x3156f
movq %rax, %rdi
callq 0x9390
movb $0x0, 0xe(%rsp)
pushq $0x17
popq %rdi
callq 0xa5c8
movq 0x18(%rbx), %rdi
movq 0x20(%rbx), %rsi
callq 0x9350
leaq 0x124c8(%rip), %rsi     # 0x31532
movq %rax, %rdi
callq 0x9390
movl 0x2d370(%rip), %esi     # 0x4c3e8
movq %rax, %rdi
callq 0x9270
leaq 0x12785(%rip), %rsi     # 0x3180c
movq %rax, %rdi
callq 0x9390
movl 0x2d357(%rip), %esi     # 0x4c3ec
movq %rax, %rdi
callq 0x9270
leaq 0x1249c(%rip), %rsi     # 0x31540
movq %rax, %rdi
callq 0x9390
movl 0x2d33e(%rip), %esi     # 0x4c3f0
movq %rax, %rdi
callq 0x9270
movq 0x2d337(%rip), %r14     # 0x4c3f8
leaq 0x1163d(%rip), %rsi     # 0x30705
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xd4fa
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x151fe
movl %eax, %ebp
leaq 0x10(%rsp), %rdi
callq 0x91a0
testb %bpl, %bpl
je 0x1f123
movq 0x18(%rbx), %rdi
leaq 0x11e05(%rip), %rsi     # 0x30f05
callq 0x9390
movq 0x2d2ec(%rip), %rsi     # 0x4c3f8
movq %rax, %rdi
callq 0x9390
leaq 0x13bbc(%rip), %rsi     # 0x32cd7
movq %rax, %rdi
callq 0x9390
movq 0x18(%rbx), %rdi
leaq 0x12415(%rip), %rsi     # 0x31543
callq 0x9390
leaq 0x1241d(%rip), %rsi     # 0x31557
movq %rax, %rdi
callq 0x9390
movb $0x1, 0x48(%rbx)
leaq 0xe(%rsp), %rdi
callq 0xa5e8
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x91a0
jmp 0x1f16d
jmp 0x1f16a
movq %rax, %rbx
leaq 0xe(%rsp), %rdi
callq 0xa5e8
movq %rbx, %rdi
callq 0x9610
nop
// File: /workspace/github_cpp_makefile_star2_O2/minimind[P]simple-graph/unittest/../graph/graph.hpp
// Function: Graph<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::remove_node(SimpleGraph::NodeIterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&)
typename Graph<N,E>::node_iterator Graph<N,E>::remove_node( typename Graph<N,E>::node_iterator& n )
{
  // You can only remove a node it it has no edges in it
  if ( !n.m_iterator->second->m_edges.empty() )
  {
    throw std::runtime_error( "Cannot remove a node if it is still connected by an edge" );
  }

  typename Graph<N,E>::node_iterator toReturn = n;
  ++toReturn;

  nodes.m_nodes.erase( n.m_iterator );
  return toReturn;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
addq $0x28, %rdi
callq 0x24382
leaq 0x28(%rax), %rcx
cmpq %rcx, 0x28(%rax)
jne 0x27805
movq (%r14), %r14
movq %r14, %rdi
callq 0x9290
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x27c2c
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
pushq $0x10
popq %rdi
callq 0x91c0
movq %rax, %rbx
leaq 0xb1cb(%rip), %rsi      # 0x329e2
movq %rax, %rdi
callq 0x9140
movq 0x247ca(%rip), %rsi     # 0x4bff0
movq 0x24783(%rip), %rdx     # 0x4bfb0
movq %rbx, %rdi
callq 0x95e0
movq %rax, %r14
movq %rbx, %rdi
callq 0x92d0
movq %r14, %rdi
callq 0x9610
// File: /workspace/github_cpp_makefile_star2_O2/minimind[P]simple-graph/unittest/../graph/graph.hpp
// Function: Graph<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::remove_edge(SimpleGraph::EdgeIterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&)
typename Graph<N,E>::edge_iterator Graph<N,E>::remove_edge( typename Graph<N,E>::edge_iterator& e )
{
  typename boost::shared_ptr< SimpleGraph::SimpleEdge<N,E> >& simpleEdge( *( e.m_iterator ) );
  typename std::list< boost::shared_ptr< SimpleGraph::SimpleEdge<N,E> > >::iterator mainIterator  = simpleEdge->m_mainIterator;
  typename std::list< boost::shared_ptr< SimpleGraph::SimpleEdge<N,E> > >::iterator leftIterator  = simpleEdge->m_leftIterator;
  typename std::list< boost::shared_ptr< SimpleGraph::SimpleEdge<N,E> > >::iterator rightIterator = simpleEdge->m_rightIterator;

  bool leftAndRightTheSame = &( *leftIterator ) == &( *rightIterator );
  bool leftAndMainTheSame  = &( *mainIterator ) == &( *leftIterator  );
  bool rightAndMainTheSame = &( *mainIterator ) == &( *rightIterator );

  typename Graph<N,E>::edge_iterator toReturn( mainIterator );
  ++toReturn;

  std::list< boost::shared_ptr< SimpleGraph::SimpleEdge<N,E> > >& eLeftIteratorEdges  = e.left().m_iterator->second->m_edges;
  std::list< boost::shared_ptr< SimpleGraph::SimpleEdge<N,E> > >& eRightIteratorEdges = e.right().m_iterator->second->m_edges;

  eLeftIteratorEdges.erase( leftIterator );

  if ( !leftAndRightTheSame )
  {
    eRightIteratorEdges.erase( rightIterator );
  }

  if ( !leftAndMainTheSame && !( rightAndMainTheSame && !leftAndRightTheSame ) )
  {
    edges.m_edges.erase( mainIterator );
  }

  return toReturn;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbp
movq %rdi, %rbx
movq (%rsi), %r15
addq $0x10, %r15
movq %r15, %rdi
callq 0x24358
movq 0x30(%rax), %r14
movq %r15, %rdi
callq 0x24358
movq 0x38(%rax), %r12
movq %r15, %rdi
callq 0x24358
movq 0x40(%rax), %r13
movq (%r14), %rax
movq %rax, (%rsp)
movq %rbp, %rdi
callq 0x23e58
leaq 0x28(%rax), %rdi
callq 0x24382
leaq 0x28(%rax), %r15
movq %rbp, %rdi
callq 0x23e6c
leaq 0x28(%rax), %rdi
callq 0x24382
movq %rax, %rbp
movq %r15, %rdi
movq %r12, %rsi
callq 0x27c7a
cmpq %r13, %r12
je 0x278e7
addq $0x28, %rbp
movq %rbp, %rdi
movq %r13, %rsi
callq 0x27c7a
cmpq %r13, %r14
setne %al
cmpq %r13, %r12
sete %cl
cmpq %r12, %r14
je 0x2790b
orb %cl, %al
je 0x2790b
addq $0x30, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x27c7a
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/minimind[P]simple-graph/unittest/../graph/graph.hpp
// Function: Graph<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>::add_node(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long)
typename Graph<N,E>::node_iterator Graph<N,E>::add_node( const N& n, const unsigned long key )
{
  if ( nodes.m_nodes.find( key ) != nodes.m_nodes.end() )
  {
    throw std::runtime_error( "Key already exists in graph" );
  }
  else if ( key >= m_counter )
  {
    m_counter = key + 1;
  }

  return hidden_add_node( n, key );
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %rsi
movq %rdx, (%rsi)
callq 0x2457e
leaq 0x8(%r14), %rcx
cmpq %rcx, %rax
jne 0x2817f
movq (%rsp), %rdx
cmpq 0x48(%r14), %rdx
jb 0x2816c
leaq 0x1(%rdx), %rax
movq %rax, 0x48(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x23e96
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x91c0
movq %rax, %rbx
leaq 0xac1e(%rip), %rsi      # 0x32daf
movq %rax, %rdi
callq 0x9140
movq 0x23e50(%rip), %rsi     # 0x4bff0
movq 0x23e09(%rip), %rdx     # 0x4bfb0
movq %rbx, %rdi
callq 0x95e0
movq %rax, %r14
movq %rbx, %rdi
callq 0x92d0
movq %r14, %rdi
callq 0x9610
// File: /workspace/github_cpp_makefile_star2_O2/minimind[P]simple-graph/unittest/catch.hpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> Catch::Detail::rangeToString<__gnu_cxx::__normal_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const*, 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>>>>>>(__gnu_cxx::__normal_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const*, 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>>>>>, __gnu_cxx::__normal_iterator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const*, 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>>>>>)
std::string rangeToString( InputIterator first, InputIterator last ) {
        std::ostringstream oss;
        oss << "{ ";
        if( first != last ) {
            oss << toString( *first );
            for( ++first ; first != last ; ++first ) {
                oss << ", " << toString( *first );
            }
        }
        oss << " }";
        return oss.str();
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, 0x8(%rsp)
leaq 0x30(%rsp), %rbx
movq %rbx, %rdi
callq 0x9480
leaq 0x6e48(%rip), %rsi      # 0x33140
movq %rbx, %rdi
callq 0x9390
cmpq %r14, %r15
je 0x2c375
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0xb974
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x9350
leaq 0x10(%rsp), %r12
movq %r12, %rdi
callq 0x91a0
addq $0x20, %r15
leaq 0x4be5(%rip), %r13      # 0x30f1e
leaq 0x30(%rsp), %rbp
cmpq %r14, %r15
je 0x2c375
movq %rbp, %rdi
movq %r13, %rsi
callq 0x9390
movq %rax, %rbx
movq %r12, %rdi
movq %r15, %rsi
callq 0xb974
movq %rbx, %rdi
movq %r12, %rsi
callq 0x9350
movq %r12, %rdi
callq 0x91a0
addq $0x20, %r15
jmp 0x2c33e
leaq 0x6dc7(%rip), %rsi      # 0x33143
leaq 0x30(%rsp), %rdi
callq 0x9390
leaq 0x38(%rsp), %rsi
movq 0x8(%rsp), %rdi
callq 0x9530
leaq 0x30(%rsp), %rdi
callq 0x90c0
movq 0x8(%rsp), %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2c3c3
jmp 0x2c3be
jmp 0x2c3be
jmp 0x2c3be
movq %rax, %rbx
jmp 0x2c3d0
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x91a0
leaq 0x30(%rsp), %rdi
callq 0x90c0
movq %rbx, %rdi
callq 0x9610
nop
// File: /workspace/github_cpp_makefile_star2_O2/plasma-umass[P]simplesocket/server.cpp
// Function: messageNumber()
int messageNumber () {
  static int number = 0;
  static pthread_mutex_t numberLock = PTHREAD_MUTEX_INITIALIZER;
  int v;
  pthread_mutex_lock (&numberLock);
  v = number;
  number++;
  pthread_mutex_unlock (&numberLock);
  return v;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x3d11(%rip), %rbx      # 0x61e8
movq %rbx, %rdi
callq 0x22a0
movl 0x3cfe(%rip), %r14d     # 0x61e4
leal 0x1(%r14), %eax
movl %eax, 0x3cf4(%rip)      # 0x61e4
movq %rbx, %rdi
callq 0x2190
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/plasma-umass[P]simplesocket/server.cpp
// Function: main
int main (int argc, char * argv[])
{
  if (argc < 2) {
    cerr << "Usage: " << argv[0] << " <port>" << endl;
    exit (-1);
  }
  int port;
  stringstream (argv[1]) >> port;
  serversocket * s = new serversocket (port);
  cout << "Entering loop.\n" << endl;
  while (true) {
    // Create one thread per connection.
    auto c = s->accept();
    pthread_t * t = new pthread_t;
    pthread_create (t, NULL, serve, (void *) c);
  }
  // We will never get here...
  s->close();
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movq %rsi, %rbx
cmpl $0x1, %edi
jle 0x2718
movq 0x8(%rbx), %rsi
leaq 0x10(%rsp), %rdi
leaq 0xb(%rsp), %rdx
callq 0x287e
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
pushq $0x18
popq %rdx
callq 0x22d0
leaq 0x30(%rsp), %rdi
leaq 0xc(%rsp), %rsi
callq 0x2130
leaq 0x30(%rsp), %rdi
callq 0x2170
leaq 0x10(%rsp), %rdi
callq 0x20e0
movl $0x1e0, %edi            # imm = 0x1E0
callq 0x2210
movq %rax, %rbx
movl 0xc(%rsp), %esi
pushq $-0x1
popq %rdx
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x28ba
movq 0x38f4(%rip), %rdi      # 0x5fc8
leaq 0x1950(%rip), %rsi      # 0x402b
callq 0x2200
movq %rax, %rdi
callq 0x20f0
pushq $0x8
popq %r14
leaq -0x1f0(%rip), %r15      # 0x2503
movq %rbx, %rdi
callq 0x32fe
movq %rax, %r12
movq %r14, %rdi
callq 0x2210
movq %rax, %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %r12, %rcx
callq 0x2340
jmp 0x26f3
movq 0x38d1(%rip), %rdi      # 0x5ff0
leaq 0x18f5(%rip), %rsi      # 0x401b
callq 0x2200
movq (%rbx), %rsi
movq %rax, %rdi
callq 0x2200
leaq 0x18e6(%rip), %rsi      # 0x4023
movq %rax, %rdi
callq 0x2200
movq %rax, %rdi
callq 0x20f0
pushq $-0x1
popq %rdi
callq 0x2240
movq %rax, %r14
movl $0x1e0, %esi            # imm = 0x1E0
movq %rbx, %rdi
callq 0x2220
jmp 0x2788
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x2170
jmp 0x2779
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x20e0
jmp 0x2788
movq %rax, %r14
movq %r14, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/willprice[P]parallel-cpp-workshop/sum.cpp
// Function: main
int main(int argc, char **argv)
{
    int (*a)(int, int) = &sum;
    auto result = a(3, 7);
    std::cout << result << std::endl;
    return 0;
}

// Assembly:
pushq %rax
movq 0x2e30(%rip), %rdi      # 0x3fd8
pushq $0xa
popq %rsi
callq 0x1060
movq %rax, %rdi
callq 0x1030
xorl %eax, %eax
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O2/onai[P]npio/npio_test_c.c
// Function: test1
void test1()
{
  int err;
  size_t i;
  int64_t *data, total;
  npio_Array array;

  npio_init_array(&array);
  err = npio_load("test1.npy", &array);
  if (err)
  {
    fprintf(stderr, "npio_load: %s\n", strerror(err));
    exit(1);
  }

  printf("data type: ");
  if (array.floating_point)
    printf("%d-bit float\n", array.bit_width);
  else if (array.is_signed)
    printf("%d-bit signed integer\n", array.bit_width);
  else
    printf("%d-bit unsigned integer\n", array.bit_width);

  printf("shape: ");
  for (i = 0; i < array.dim; ++i)
    printf("%ld ", array.shape[i]);
  printf("\n");

  assert(array.bit_width == 64 && !array.floating_point && array.is_signed);

  data = (int64_t*) array.data;
  total = 0;
  for (i = 0; i < array.size; ++i)
    total += data[i];

  assert(total == 4950);

  npio_free_array(&array);
  printf("test1 passed\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsp, %rsi
movw $0x1, (%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rsi)
movups %xmm0, 0x18(%rsi)
movups %xmm0, 0x24(%rsi)
movaps 0x1cd5(%rip), %xmm1     # 0x3010
movups %xmm1, 0x34(%rsi)
andq $0x0, 0x48(%rsi)
andl $0x0, 0x50(%rsi)
movups %xmm0, 0x58(%rsi)
movups %xmm0, 0x68(%rsi)
andq $0x0, 0x78(%rsi)
leaq 0x1edb(%rip), %rdi      # 0x3237
callq 0x14b3
testl %eax, %eax
jne 0x1450
leaq 0x1d1f(%rip), %rdi      # 0x308f
xorl %eax, %eax
callq 0x10b0
movl 0x38(%rsp), %ebp
testl %ebp, %ebp
je 0x138c
movl 0x40(%rsp), %ebx
leaq 0x1d11(%rip), %rdi      # 0x309b
jmp 0x13a7
cmpl $0x0, 0x3c(%rsp)
movl 0x40(%rsp), %ebx
je 0x13a0
leaq 0x1d0b(%rip), %rdi      # 0x30a9
jmp 0x13a7
leaq 0x1d19(%rip), %rdi      # 0x30c0
movl %ebx, %esi
xorl %eax, %eax
callq 0x10b0
leaq 0x1d22(%rip), %rdi      # 0x30d9
xorl %eax, %eax
callq 0x10b0
movq 0x18(%rsp), %r15
movq 0x20(%rsp), %r12
leaq 0x1d12(%rip), %r14      # 0x30e1
xorl %r13d, %r13d
cmpq %r13, %r15
je 0x13ea
movq (%r12,%r13,8), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x10b0
incq %r13
jmp 0x13d2
pushq $0xa
popq %rdi
callq 0x1040
testl %ebp, %ebp
jne 0x147d
cmpl $0x40, %ebx
jne 0x147d
cmpl $0x0, 0x3c(%rsp)
je 0x147d
movq 0x28(%rsp), %rax
movq 0x48(%rsp), %rcx
xorl %edx, %edx
xorl %esi, %esi
cmpq %rdx, %rax
je 0x1422
addq (%rcx,%rdx,8), %rsi
incq %rdx
jmp 0x1414
cmpq $0x1356, %rsi           # imm = 0x1356
jne 0x1496
movq %rsp, %rdi
callq 0x14f2
leaq 0x1e58(%rip), %rdi      # 0x3292
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1060
movq 0x3ba1(%rip), %rcx      # 0x4ff8
movq (%rcx), %rbx
movl %eax, %edi
callq 0x11f0
leaq 0x1c18(%rip), %rsi      # 0x3080
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1100
pushq $0x1
popq %rdi
callq 0x11d0
leaq 0x1c62(%rip), %rdi      # 0x30e6
leaq 0x1c9d(%rip), %rsi      # 0x3128
leaq 0x1ca4(%rip), %rcx      # 0x3136
pushq $0x28
jmp 0x14ad
leaq 0x1ca6(%rip), %rdi      # 0x3143
leaq 0x1c84(%rip), %rsi      # 0x3128
leaq 0x1c8b(%rip), %rcx      # 0x3136
pushq $0x2f
popq %rdx
callq 0x10d0
// File: /workspace/github_cpp_makefile_star2_O2/onai[P]npio/./npio.h
// Function: npio_free_array
static inline void npio_free_array(npio_Array* array)
{
  if (array->dtype)
  {
    free(array->dtype);
    array->dtype = 0;
  }

  if (array->shape)
  {
    free(array->shape);
    array->shape = 0;
  }

  if (array->data && !array->_buf)
  {
    free(array->data);
    array->data = 0;
  }

  if (array->_mmapped)
  {
    munmap(array->_buf, array->_buf_size);
    array->_buf = 0;
  }

  if (array->_fd >= 0)
  {
    close(array->_fd);
    array->_fd = -1;
  }

  if (array->_hdr_buf)
  {
    free(array->_hdr_buf);
    array->_hdr_buf = 0;
  }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x1509
callq 0x1030
andq $0x0, 0x10(%rbx)
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x151c
callq 0x1030
andq $0x0, 0x20(%rbx)
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x1536
cmpq $0x0, 0x58(%rbx)
jne 0x1536
callq 0x1030
andq $0x0, 0x48(%rbx)
cmpl $0x0, 0x78(%rbx)
je 0x154e
movq 0x58(%rbx), %rdi
movq 0x60(%rbx), %rsi
callq 0x1180
andq $0x0, 0x58(%rbx)
movl 0x50(%rbx), %edi
testl %edi, %edi
js 0x155e
callq 0x10e0
orl $-0x1, 0x50(%rbx)
movq 0x68(%rbx), %rdi
testq %rdi, %rdi
je 0x1571
callq 0x1030
andq $0x0, 0x68(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/onai[P]npio/npio_test_c.c
// Function: test2
void test2()
{
  int err;
  size_t i;
  float *data, total;
  npio_Array array;

  npio_init_array(&array);
  err = npio_load("test2.npy", &array);
  if (err)
  {
    fprintf(stderr, "npio_load: %s\n", strerror(err));
    exit(1);
  }

  printf("data type: ");
  if (array.floating_point)
    printf("%d-bit float\n", array.bit_width);
  else if (array.is_signed)
    printf("%d-bit signed integer\n", array.bit_width);
  else
    printf("%d-bit unsigned integer\n", array.bit_width);

  printf("shape: ");
  for (i = 0; i < array.dim; ++i)
    printf("%ld ", array.shape[i]);
  printf("\n");

  assert(array.bit_width == 32 && array.floating_point);

  data = (float*) array.data;
  total = 0;
  for (i = 0; i < array.size; ++i)
    total += data[i];
  assert(fabs(total / 5005.37f - 1.0f) < 1e-6f);

  npio_free_array(&array);
  printf("test2 passed\n");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsp, %rsi
movw $0x1, (%rsi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rsi)
movups %xmm0, 0x18(%rsi)
movups %xmm0, 0x24(%rsi)
movaps 0x1a6e(%rip), %xmm1     # 0x3010
movups %xmm1, 0x34(%rsi)
andq $0x0, 0x48(%rsi)
andl $0x0, 0x50(%rsi)
movups %xmm0, 0x58(%rsi)
movups %xmm0, 0x68(%rsi)
andq $0x0, 0x78(%rsi)
leaq 0x1b8e(%rip), %rdi      # 0x3151
callq 0x14b3
testl %eax, %eax
jne 0x16d1
leaq 0x1ab8(%rip), %rdi      # 0x308f
xorl %eax, %eax
callq 0x10b0
movl 0x38(%rsp), %ebp
testl %ebp, %ebp
je 0x15f3
movl 0x40(%rsp), %ebx
leaq 0x1aaa(%rip), %rdi      # 0x309b
jmp 0x160e
cmpl $0x0, 0x3c(%rsp)
movl 0x40(%rsp), %ebx
je 0x1607
leaq 0x1aa4(%rip), %rdi      # 0x30a9
jmp 0x160e
leaq 0x1ab2(%rip), %rdi      # 0x30c0
movl %ebx, %esi
xorl %eax, %eax
callq 0x10b0
leaq 0x1abb(%rip), %rdi      # 0x30d9
xorl %eax, %eax
callq 0x10b0
movq 0x18(%rsp), %r15
movq 0x20(%rsp), %r12
leaq 0x1aab(%rip), %r14      # 0x30e1
xorl %r13d, %r13d
cmpq %r13, %r15
je 0x1651
movq (%r12,%r13,8), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x10b0
incq %r13
jmp 0x1639
pushq $0xa
popq %rdi
callq 0x1040
testl %ebp, %ebp
je 0x16fe
cmpl $0x20, %ebx
jne 0x16fe
movq 0x28(%rsp), %rax
movq 0x48(%rsp), %rcx
xorps %xmm0, %xmm0
xorl %edx, %edx
cmpq %rdx, %rax
je 0x1688
addss (%rcx,%rdx,4), %xmm0
incq %rdx
jmp 0x1679
divss 0x19c0(%rip), %xmm0     # 0x3050
addss 0x19bc(%rip), %xmm0     # 0x3054
andps 0x1981(%rip), %xmm0     # 0x3020
movss 0x19b1(%rip), %xmm1     # 0x3058
ucomiss %xmm0, %xmm1
jbe 0x1717
movq %rsp, %rdi
callq 0x14f2
leaq 0x1be4(%rip), %rdi      # 0x329f
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1060
movq 0x3920(%rip), %rcx      # 0x4ff8
movq (%rcx), %rbx
movl %eax, %edi
callq 0x11f0
leaq 0x1997(%rip), %rsi      # 0x3080
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1100
pushq $0x1
popq %rdi
callq 0x11d0
leaq 0x1a56(%rip), %rdi      # 0x315b
leaq 0x1a1c(%rip), %rsi      # 0x3128
leaq 0x1a76(%rip), %rcx      # 0x3189
pushq $0x53
jmp 0x172e
leaq 0x1a78(%rip), %rdi      # 0x3196
leaq 0x1a03(%rip), %rsi      # 0x3128
leaq 0x1a5d(%rip), %rcx      # 0x3189
pushq $0x59
popq %rdx
callq 0x10d0