LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::Stream::release()
void Stream::release() {
        if( isOwned ) {
            delete streamBuf;
            streamBuf = NULL;
            isOwned = false;
        }
    }

// Assembly:
cmpb $0x1, 0x8(%rdi)
jne 0xa467
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0xa45e
movq (%rdi), %rax
callq *0x8(%rax)
andq $0x0, (%rbx)
movb $0x0, 0x8(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::createStream(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Stream createStream( std::string const& streamName ) {
        if( streamName == "stdout" ) return Stream( std::cout.rdbuf(), false );
        if( streamName == "stderr" ) return Stream( std::cerr.rdbuf(), false );
        if( streamName == "debug" ) return Stream( new StreamBufImpl<OutputDebugWriter>, true );

        throw std::domain_error( "Unknown stream: " + streamName );
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %r14
leaq 0x2620f(%rip), %rsi     # 0x306db
callq 0xd54f
testb %al, %al
je 0xa4de
movq 0x41ae4(%rip), %rax     # 0x4bfc0
jmp 0xa4f8
leaq 0x261fd(%rip), %rsi     # 0x306e2
movq %r14, %rdi
callq 0xd54f
testb %al, %al
je 0xa50b
movq 0x41af0(%rip), %rax     # 0x4bfe8
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq 0xe8(%rax,%rcx), %rbx
xorl %ebp, %ebp
jmp 0xa536
leaq 0x261d7(%rip), %rsi     # 0x306e9
movq %r14, %rdi
callq 0xd54f
testb %al, %al
je 0xa544
movl $0x148, %edi            # imm = 0x148
callq 0x93a0
movq %rax, %rbx
movb $0x1, %bpl
movq %rax, %rdi
callq 0xd55c
movq %rbx, %rax
movl %ebp, %edx
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x91c0
movq %rax, %rbx
leaq 0x26199(%rip), %rsi     # 0x306ef
movq %rsp, %rdi
movq %r14, %rdx
callq 0xd588
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x9430
xorl %ebp, %ebp
movq 0x41a20(%rip), %rsi     # 0x4bf98
movq 0x41a29(%rip), %rdx     # 0x4bfa8
movq %rbx, %rdi
callq 0x95e0
movq %rax, %r14
movq %rsp, %rdi
callq 0x91a0
testb %bpl, %bpl
jne 0xa59c
jmp 0xa5b6
movq %rax, %r14
movq %rbx, %rdi
callq 0x92d0
jmp 0xa5b6
movq %rax, %r14
movl $0x148, %esi            # imm = 0x148
movq %rbx, %rdi
callq 0x93c0
movq %r14, %rdi
callq 0x9610
// File: /workspace/github_cpp_makefile_star2_O2/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::toString(std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> const&)
inline void deleteAll( ContainerT& container ) {
        typename ContainerT::const_iterator it = container.begin();
        typename ContainerT::const_iterator itEnd = container.end();
        for(; it != itEnd; ++it )
            delete *it;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movq %rsi, %r14
movq %rdi, %rbx
movb $0x0, (%rax)
movq 0x8(%rsi), %rsi
movq %rsp, %rdi
callq 0x9510
xorl %r12d, %r12d
pushq $0x3f
popq %rbp
movq %rsp, %r15
cmpq 0x8(%r14), %r12
jae 0xbbd1
movq (%r14), %rax
movl (%rax,%r12,4), %eax
cmpl $0x100, %eax            # imm = 0x100
cmovgel %ebp, %eax
movsbl %al, %esi
movq %r15, %rdi
callq 0x9330
incq %r12
jmp 0xbbac
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xb974
movq %rsp, %rdi
callq 0x91a0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0xbbf6
movq %rax, %rbx
movq %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::toString[abi:cxx11](unsigned long)
std::string toString( unsigned long value ) {
    std::ostringstream oss;
    if( value > 8192 )
        oss << "0x" << std::hex << value;
    else
        oss << value;
    return oss.str();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x180, %rsp            # imm = 0x180
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x9480
cmpq $0x2001, %r14           # imm = 0x2001
jb 0xbdb2
leaq 0x2499d(%rip), %rsi     # 0x3072b
leaq 0x8(%rsp), %rdi
callq 0x9390
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rax
movl 0x18(%r15,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%r15,%rax)
movq %r15, %rdi
movq %r14, %rsi
callq 0x9270
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x9530
leaq 0x8(%rsp), %rdi
callq 0x90c0
movq %rbx, %rax
addq $0x180, %rsp            # imm = 0x180
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%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::ResultBuilder::captureExpression()
void ResultBuilder::captureExpression() {
        AssertionResult result = build();
        getResultCapture().assertionEnded( result );

        if( !result.isOk() ) {
            if( getCurrentContext().getConfig()->shouldDebugBreak() )
                m_shouldDebugBreak = true;
            if( getCurrentContext().getRunner()->aborting() || m_assertionInfo.resultDisposition == ResultDisposition::Normal )
                m_shouldThrow = true;
        }
    }

// Assembly:
pushq %rbp
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0xb1ce
callq 0x9d0c
movq (%rax), %rcx
leaq 0x10(%rsp), %rsi
movq %rax, %rdi
callq *0x10(%rcx)
testb $0x10, 0xc0(%rsp)
je 0xc140
movl 0x78(%rsp), %eax
andl $0x4, %eax
jne 0xc140
callq 0xa468
movq (%rax), %rcx
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq *0x30(%rcx)
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
movl %eax, %ebp
leaq 0x8(%rsp), %rdi
callq 0xdaf4
testb %bpl, %bpl
je 0xc115
movb $0x1, 0x298(%rbx)
callq 0xa468
movq (%rax), %rcx
movq %rax, %rdi
callq *0x18(%rcx)
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
cmpl $0x0, 0x68(%rbx)
sete %cl
orb %cl, %al
cmpb $0x1, %al
jne 0xc140
movb $0x1, 0x299(%rbx)
leaq 0x10(%rsp), %rdi
callq 0xa790
addq $0xc8, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xdaf4
jmp 0xc168
jmp 0xc165
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0xa790
movq %rbx, %rdi
callq 0x9610
// File: /workspace/github_cpp_makefile_star2_O2/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::RegistrarForTagAliases::RegistrarForTagAliases(char const*, char const*, Catch::SourceLineInfo const&)
RegistrarForTagAliases::RegistrarForTagAliases( char const* alias, char const* tag, SourceLineInfo const& lineInfo ) {
        try {
            TagAliasRegistry::get().add( alias, tag, lineInfo );
        }
        catch( std::exception& ex ) {
            Colour colourGuard( Colour::Red );
            std::cerr << ex.what() << std::endl;
            exit(1);
        }
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
callq 0xcbec
leaq 0x3f762(%rip), %rdi     # 0x4c408
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0xc7d8
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
cmpl $0x1, %edx
jne 0xcd1d
movq %rbx, %rdi
callq 0x9160
movq %rax, %rbx
movb $0x0, 0xf(%rsp)
pushq $0x2
popq %rdi
callq 0xa5c8
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
movq 0x3f2fa(%rip), %rdi     # 0x4bfe8
movq %rax, %rsi
callq 0x9390
movq %rax, %rdi
callq 0x91b0
pushq $0x1
popq %rdi
callq 0x9440
movq %rax, %rbx
leaq 0xf(%rsp), %rdi
callq 0xa5e8
jmp 0xcd18
movq %rax, %rbx
callq 0x95b0
movq %rbx, %rdi
callq 0x9610
movq %rax, %rdi
callq 0xd5fe
nop
// File: /workspace/github_cpp_makefile_star2_O2/minimind[P]simple-graph/unittest/main.cpp
// Function: ensureGraphTestLink()
void ensureGraphTestLink()
{
  ensureGraphConstructionTestLink();
  ensureGraphVisitorTestLink();
  ensureGraphCopyTopologyTestLink();
  ensureGraphAddTestLink();
  ensureGraphVisitorIgnoreKeyTestLink();
}

// Assembly:
pushq %rax
callq 0x2771e
callq 0x2f9ab
callq 0x2ad91
callq 0x23a22
popq %rax
jmp 0x2d195
nop
// File: /workspace/github_cpp_makefile_star2_O2/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::enforceNotReservedTag(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::SourceLineInfo const&)
inline void enforceNotReservedTag( std::string const& tag, SourceLineInfo const& _lineInfo ) {
        if( isReservedTag( tag ) ) {
            {
                Colour colourGuard( Colour::Red );
                std::cerr
                    << "Tag name [" << tag << "] not allowed.\n"
                    << "Tag names starting with non alpha-numeric characters are reserved\n";
            }
            {
                Colour colourGuard( Colour::FileName );
                std::cerr << _lineInfo << std::endl;
            }
            exit(1);
        }
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x11681
testb %al, %al
jne 0xd7ab
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movb $0x0, 0x7(%rsp)
pushq $0x2
popq %rdi
callq 0xa5c8
movq 0x3e829(%rip), %rdi     # 0x4bfe8
leaq 0x23165(%rip), %rsi     # 0x3092b
callq 0x9390
movq %rax, %rdi
movq %r14, %rsi
callq 0x9350
leaq 0x23159(%rip), %rsi     # 0x30936
movq %rax, %rdi
callq 0x9390
leaq 0x2315a(%rip), %rsi     # 0x30946
movq %rax, %rdi
callq 0x9390
leaq 0x7(%rsp), %rdi
callq 0xa5e8
movb $0x0, 0x6(%rsp)
pushq $0x17
popq %rdi
callq 0xa5c8
movq 0x3e7d6(%rip), %rdi     # 0x4bfe8
movq %rbx, %rsi
callq 0xa3f9
movq 0x3e7c7(%rip), %rdi     # 0x4bfe8
callq 0x91b0
leaq 0x6(%rsp), %rdi
callq 0xa5e8
pushq $0x1
popq %rdi
callq 0x9440
movq %rax, %rbx
leaq 0x6(%rsp), %rdi
jmp 0xd84a
movq %rax, %rbx
leaq 0x7(%rsp), %rdi
callq 0xa5e8
movq %rbx, %rdi
callq 0x9610
nop
// File: /workspace/github_cpp_makefile_star2_O2/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::parseSpecialTag(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline TestCaseInfo::SpecialProperties parseSpecialTag( std::string const& tag ) {
        if( tag == "." ||
            tag == "hide" ||
            tag == "!hide" )
            return TestCaseInfo::IsHidden;
        else if( tag == "!throws" )
            return TestCaseInfo::Throws;
        else if( tag == "!shouldfail" )
            return TestCaseInfo::ShouldFail;
        else if( tag == "!mayfail" )
            return TestCaseInfo::MayFail;
        else
            return TestCaseInfo::None;
    }

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x23f5b(%rip), %rsi     # 0x3180c
callq 0xd54f
pushq $0x2
popq %rbp
testb %al, %al
jne 0xd927
leaq 0x230c6(%rip), %rsi     # 0x3098a
movq %rbx, %rdi
callq 0xd54f
testb %al, %al
jne 0xd927
leaq 0x230b2(%rip), %rsi     # 0x30989
movq %rbx, %rdi
callq 0xd54f
testb %al, %al
jne 0xd927
leaq 0x230a5(%rip), %rsi     # 0x3098f
movq %rbx, %rdi
callq 0xd54f
testb %al, %al
je 0xd8fa
pushq $0x10
jmp 0xd90f
leaq 0x23096(%rip), %rsi     # 0x30997
movq %rbx, %rdi
callq 0xd54f
testb %al, %al
je 0xd912
pushq $0x4
popq %rbp
jmp 0xd927
leaq 0x2308a(%rip), %rsi     # 0x309a3
movq %rbx, %rdi
callq 0xd54f
movzbl %al, %ebp
shll $0x3, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::Session::Session()
Session()
        : m_cli( makeCommandLineParser() ) {
            if( alreadyInstantiated ) {
                std::string msg = "Only one instance of Catch::Session can ever be used";
                std::cerr << msg << std::endl;
                throw std::logic_error( msg );
            }
            alreadyInstantiated = true;
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0x11c1d
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%rbx)
andq $0x0, 0x70(%rbx)
leaq 0x78(%rbx), %r14
movq %r14, %rdi
callq 0x12a32
andq $0x0, 0x130(%rbx)
cmpb $0x1, 0x3e258(%rip)     # 0x4c3da
je 0xe197
movb $0x1, 0x3e24f(%rip)     # 0x4c3da
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x22815(%rip), %rsi     # 0x309b3
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xd4fa
movq 0x3de34(%rip), %rdi     # 0x4bfe8
leaq 0x8(%rsp), %rsi
callq 0x9350
movq %rax, %rdi
callq 0x91b0
pushq $0x10
popq %rdi
callq 0x91c0
movq %rax, %r12
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x94d0
movq 0x3ddeb(%rip), %rsi     # 0x4bfd0
movq 0x3ddcc(%rip), %rdx     # 0x4bfb8
movq %r12, %rdi
callq 0x95e0
movq %rax, %r15
movq %r12, %rdi
callq 0x92d0
jmp 0xe204
movq %rax, %r15
leaq 0x8(%rsp), %rdi
callq 0x91a0
jmp 0xe213
movq %rax, %r15
leaq 0x60(%rbx), %r12
leaq 0x130(%rbx), %rdi
callq 0x12aa6
movq %r14, %rdi
callq 0x12ac0
movq %r12, %rdi
callq 0x12afc
movq %rbx, %rdi
callq 0x12b1e
movq %r15, %rdi
callq 0x9610
nop
// File: /workspace/github_cpp_makefile_star2_O2/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::Session::run(int, char* const*)
int run( int argc, char* const argv[] ) {

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

// Assembly:
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rcx
callq 0x146fe
testl %eax, %eax
je 0xe256
popq %rbx
retq
movq %rbx, %rdi
popq %rbx
jmp 0x148a8
nop
// File: /workspace/github_cpp_makefile_star2_O2/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::TestSpec::NamePattern::matches(Catch::TestCaseInfo const&) const
virtual bool matches( TestCaseInfo const& testCase ) const {
                switch( m_wildcard ) {
                    case NoWildcard:
                        return m_name == toLower( testCase.name );
                    case WildcardAtStart:
                        return endsWith( toLower( testCase.name ), m_name );
                    case WildcardAtEnd:
                        return startsWith( toLower( testCase.name ), m_name );
                    case WildcardAtBothEnds:
                        return contains( toLower( testCase.name ), m_name );
                }

#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunreachable-code"
#endif
                throw std::logic_error( "Unknown enum" );
#ifdef __clang__
#pragma clang diagnostic pop
#endif
            }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl 0x30(%rdi), %eax
cmpq $0x3, %rax
ja 0xe586
movq %rdi, %rbx
leaq 0x21b9c(%rip), %rcx     # 0x30088
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
addq $0x10, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xac00
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd977
jmp 0xe54d
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xac00
addq $0x10, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa976
jmp 0xe570
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xac00
addq $0x10, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xb515
movl %eax, %ebx
movq %r14, %rdi
jmp 0xe577
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0xac00
addq $0x10, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xb4cb
movl %eax, %ebx
leaq 0x8(%rsp), %rdi
callq 0x91a0
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x91c0
movq %rax, %r14
leaq 0x22c1a(%rip), %rsi     # 0x311b2
movq %rax, %rdi
callq 0x94a0
movq 0x3da29(%rip), %rsi     # 0x4bfd0
movq 0x3da0a(%rip), %rdx     # 0x4bfb8
movq %r14, %rdi
callq 0x95e0
movq %rax, %rbx
movq %r14, %rdi
callq 0x92d0
jmp 0xe5d2
jmp 0xe5c5
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::TestRegistry::getFilteredTests(Catch::TestSpec const&, Catch::IConfig const&, std::vector<Catch::TestCase, std::allocator<Catch::TestCase>>&) const
virtual void getFilteredTests( TestSpec const& testSpec, IConfig const& config, std::vector<TestCase>& matchingTestCases ) const {
            for( std::vector<TestCase>::const_iterator  it = m_functionsInOrder.begin(),
                                                        itEnd = m_functionsInOrder.end();
                    it != itEnd;
                    ++it ) {
                if( testSpec.matches( *it ) && ( config.allowThrows() || !it->throws() ) )
                    matchingTestCases.push_back( *it );
            }
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq 0x38(%rdi), %r12
movq 0x40(%rdi), %r13
cmpq %r13, %r12
je 0xe75e
movq %r15, %rdi
movq %r12, %rsi
callq 0x1bfaa
testb %al, %al
je 0xe755
movq (%r14), %rax
movq %r14, %rdi
callq *0x20(%rax)
testb %al, %al
jne 0xe74a
testb $0x10, 0x108(%r12)
jne 0xe755
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1bfe0
addq $0x118, %r12            # imm = 0x118
jmp 0xe71e
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::CumulativeReporterBase::testRunEnded(Catch::TestRunStats const&)
virtual void testRunEnded( TestRunStats const& testRunStats ) {
            Ptr<TestRunNode> node = new TestRunNode( testRunStats );
            node->children.swap( m_testGroups );
            m_testRuns.push_back( node );
            testRunEndedCumulative();
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movl $0x88, %edi
callq 0x93a0
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
callq 0x1d712
leaq 0x8(%rsp), %r15
movq %r14, (%r15)
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
addq $0x70, %r14
leaq 0x68(%rbx), %rsi
movq %r14, %rdi
callq 0x1d81a
leaq 0x80(%rbx), %rdi
movq %r15, %rsi
callq 0x1d73e
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x80(%rax)
leaq 0x8(%rsp), %rdi
callq 0x1d778
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x88, %esi
movq %r14, %rdi
callq 0x93c0
jmp 0xeeba
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1d778
movq %rbx, %rdi
callq 0x9610
// File: /workspace/github_cpp_makefile_star2_O2/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::XmlReporter::StartTesting()
virtual void StartTesting() {
            m_xml.setStream( m_config.stream() );
            m_xml.startElement( "Catch" );
            if( !m_config.fullConfig()->name().empty() )
                m_xml.writeAttribute( "name", m_config.fullConfig()->name() );
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %r14
movq 0x10(%rdi), %rax
movq %rax, 0x68(%rdi)
leaq 0x22494(%rip), %rsi     # 0x31385
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0xd4fa
leaq 0x28(%r14), %rbx
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x1da90
leaq 0x10(%rsp), %rdi
callq 0x91a0
movq 0x18(%r14), %r15
movq %r15, 0x30(%rsp)
testq %r15, %r15
je 0xef32
movq (%r15), %rax
movq %r15, %rdi
callq *0x10(%rax)
movq (%r15), %rax
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
callq *0x30(%rax)
leaq 0x10(%rsp), %rdi
movq 0x8(%rdi), %r15
callq 0x91a0
leaq 0x30(%rsp), %rdi
callq 0xe054
testq %r15, %r15
je 0xefc8
leaq 0x21c08(%rip), %rsi     # 0x30b6c
leaq 0x10(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xd4fa
movq 0x18(%r14), %r14
movq %r14, 0x8(%rsp)
testq %r14, %r14
je 0xef8a
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq (%r14), %rax
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq *0x30(%rax)
leaq 0x10(%rsp), %rsi
leaq 0x30(%rsp), %rdx
movq %rbx, %rdi
callq 0x1dafa
leaq 0x30(%rsp), %rdi
callq 0x91a0
leaq 0x8(%rsp), %rdi
callq 0xe054
leaq 0x10(%rsp), %rdi
callq 0x91a0
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0xf003
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x91a0
jmp 0xefe6
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xe054
jmp 0xf006
jmp 0xf012
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0xe054
jmp 0xf015
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x91a0
jmp 0xf015
movq %rax, %rbx
movq %rbx, %rdi
callq 0x9610
nop
// File: /workspace/github_cpp_makefile_star2_O2/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::XmlReporter::EndTesting(Catch::Totals const&)
virtual void EndTesting( const Totals& totals ) {
            m_xml.scopedElement( "OverallResults" )
                .writeAttribute( "successes", totals.assertions.passed )
                .writeAttribute( "failures", totals.assertions.failed )
                .writeAttribute( "expectedFailures", totals.assertions.failedButOk );
            m_xml.endElement();
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x28, %rbx
leaq 0x22369(%rip), %rsi     # 0x313a4
leaq 0x70(%rsp), %r15
leaq 0x7(%rsp), %rdx
movq %r15, %rdi
callq 0xd4fa
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x1dcb8
leaq 0x2234f(%rip), %rsi     # 0x313b3
leaq 0x50(%rsp), %rdi
leaq 0x6(%rsp), %rdx
callq 0xd4fa
movq 0x8(%rsp), %rdi
leaq 0x50(%rsp), %rsi
movq %r14, %rdx
callq 0x1dd04
leaq 0x21b2e(%rip), %rsi     # 0x30bba
leaq 0x30(%rsp), %rdi
leaq 0x5(%rsp), %rdx
callq 0xd4fa
leaq 0x8(%r14), %rdx
movq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x1dd04
leaq 0x22308(%rip), %rsi     # 0x313bd
leaq 0x10(%rsp), %rdi
leaq 0x4(%rsp), %rdx
callq 0xd4fa
addq $0x10, %r14
movq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq %r14, %rdx
callq 0x1dd04
leaq 0x10(%rsp), %rdi
callq 0x91a0
leaq 0x30(%rsp), %rdi
callq 0x91a0
leaq 0x50(%rsp), %rdi
callq 0x91a0
leaq 0x8(%rsp), %rdi
callq 0x1dcec
leaq 0x70(%rsp), %rdi
callq 0x91a0
movq %rbx, %rdi
callq 0x11a62
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x91a0
jmp 0xf135
jmp 0xf132
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x91a0
jmp 0xf146
jmp 0xf143
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x91a0
leaq 0x8(%rsp), %rdi
callq 0x1dcec
leaq 0x70(%rsp), %rdi
callq 0x91a0
movq %rbx, %rdi
callq 0x9610
movq %rax, %rbx
jmp 0xf150
movq %rax, %rbx
jmp 0xf15a
// File: /workspace/github_cpp_makefile_star2_O2/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::XmlReporter::EndGroup(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::Totals const&)
virtual void EndGroup( const std::string&, const Totals& totals ) {
            m_xml.scopedElement( "OverallResults" )
                .writeAttribute( "successes", totals.assertions.passed )
                .writeAttribute( "failures", totals.assertions.failed )
                .writeAttribute( "expectedFailures", totals.assertions.failedButOk );
            m_xml.endElement();
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rdx, %r14
movq %rdi, %rbx
addq $0x28, %rbx
leaq 0x2216d(%rip), %rsi     # 0x313a4
leaq 0x70(%rsp), %r15
leaq 0x7(%rsp), %rdx
movq %r15, %rdi
callq 0xd4fa
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x1dcb8
leaq 0x22153(%rip), %rsi     # 0x313b3
leaq 0x50(%rsp), %rdi
leaq 0x6(%rsp), %rdx
callq 0xd4fa
movq 0x8(%rsp), %rdi
leaq 0x50(%rsp), %rsi
movq %r14, %rdx
callq 0x1dd04
leaq 0x21932(%rip), %rsi     # 0x30bba
leaq 0x30(%rsp), %rdi
leaq 0x5(%rsp), %rdx
callq 0xd4fa
leaq 0x8(%r14), %rdx
movq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x1dd04
leaq 0x2210c(%rip), %rsi     # 0x313bd
leaq 0x10(%rsp), %rdi
leaq 0x4(%rsp), %rdx
callq 0xd4fa
addq $0x10, %r14
movq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq %r14, %rdx
callq 0x1dd04
leaq 0x10(%rsp), %rdi
callq 0x91a0
leaq 0x30(%rsp), %rdi
callq 0x91a0
leaq 0x50(%rsp), %rdi
callq 0x91a0
leaq 0x8(%rsp), %rdi
callq 0x1dcec
leaq 0x70(%rsp), %rdi
callq 0x91a0
movq %rbx, %rdi
callq 0x11a62
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x91a0
jmp 0xf331
jmp 0xf32e
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x91a0
jmp 0xf342
jmp 0xf33f
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x91a0
leaq 0x8(%rsp), %rdi
callq 0x1dcec
leaq 0x70(%rsp), %rdi
callq 0x91a0
movq %rbx, %rdi
callq 0x9610
movq %rax, %rbx
jmp 0xf34c
movq %rax, %rbx
jmp 0xf356
// File: /workspace/github_cpp_makefile_star2_O2/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::XmlReporter::StartSection(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&)
virtual void StartSection( const std::string& sectionName, const std::string& description ) {
            if( m_sectionDepth++ > 0 ) {
                m_xml.startElement( "Section" )
                    .writeAttribute( "name", trim( sectionName ) )
                    .writeAttribute( "description", description );
            }
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl 0x70(%rdi), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x70(%rdi)
testl %eax, %eax
jle 0xf5e1
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x21e46(%rip), %rsi     # 0x3137d
leaq 0x68(%rsp), %r12
leaq 0x7(%rsp), %rdx
movq %r12, %rdi
callq 0xd4fa
addq $0x28, %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x1da90
movq %rax, %r15
leaq 0x2160a(%rip), %rsi     # 0x30b6c
leaq 0x48(%rsp), %rdi
leaq 0x6(%rsp), %rdx
callq 0xd4fa
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0xb553
leaq 0x48(%rsp), %rsi
leaq 0x28(%rsp), %rdx
movq %r15, %rdi
callq 0x1dafa
movq %rax, %r14
leaq 0x21e51(%rip), %rsi     # 0x313eb
leaq 0x8(%rsp), %rdi
leaq 0x5(%rsp), %rdx
callq 0xd4fa
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x1dafa
leaq 0x8(%rsp), %rdi
callq 0x91a0
leaq 0x28(%rsp), %rdi
callq 0x91a0
leaq 0x48(%rsp), %rdi
callq 0x91a0
leaq 0x68(%rsp), %rdi
callq 0x91a0
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x91a0
jmp 0xf604
jmp 0xf601
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x91a0
jmp 0xf613
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x91a0
jmp 0xf624
jmp 0xf621
movq %rax, %rbx
leaq 0x68(%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::XmlReporter::EndSection(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::Counts const&)
virtual void EndSection( const std::string& /*sectionName*/, const Counts& assertions ) {
            if( --m_sectionDepth > 0 ) {
                m_xml.scopedElement( "OverallResults" )
                    .writeAttribute( "successes", assertions.passed )
                    .writeAttribute( "failures", assertions.failed )
                    .writeAttribute( "expectedFailures", assertions.failedButOk );
                m_xml.endElement();
            }
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movl 0x70(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x70(%rdi)
cmpl $0x2, %eax
jl 0xf73e
movq %rdx, %r14
movq %rdi, %rbx
addq $0x28, %rbx
leaq 0x21d3f(%rip), %rsi     # 0x313a4
leaq 0x70(%rsp), %r15
leaq 0x7(%rsp), %rdx
movq %r15, %rdi
callq 0xd4fa
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x1dcb8
leaq 0x21d25(%rip), %rsi     # 0x313b3
leaq 0x50(%rsp), %rdi
leaq 0x6(%rsp), %rdx
callq 0xd4fa
movq 0x8(%rsp), %rdi
leaq 0x50(%rsp), %rsi
movq %r14, %rdx
callq 0x1dd04
leaq 0x21504(%rip), %rsi     # 0x30bba
leaq 0x30(%rsp), %rdi
leaq 0x5(%rsp), %rdx
callq 0xd4fa
leaq 0x8(%r14), %rdx
movq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x1dd04
leaq 0x21cde(%rip), %rsi     # 0x313bd
leaq 0x10(%rsp), %rdi
leaq 0x4(%rsp), %rdx
callq 0xd4fa
addq $0x10, %r14
movq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq %r14, %rdx
callq 0x1dd04
leaq 0x10(%rsp), %rdi
callq 0x91a0
leaq 0x30(%rsp), %rdi
callq 0x91a0
leaq 0x50(%rsp), %rdi
callq 0x91a0
leaq 0x8(%rsp), %rdi
callq 0x1dcec
leaq 0x70(%rsp), %rdi
callq 0x91a0
movq %rbx, %rdi
callq 0x11a62
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x91a0
jmp 0xf75f
jmp 0xf75c
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x91a0
jmp 0xf770
jmp 0xf76d
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x91a0
leaq 0x8(%rsp), %rdi
callq 0x1dcec
leaq 0x70(%rsp), %rdi
callq 0x91a0
movq %rbx, %rdi
callq 0x9610
movq %rax, %rbx
jmp 0xf77a
movq %rax, %rbx
jmp 0xf784
// File: /workspace/github_cpp_makefile_star2_O2/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::JunitReporter::testGroupStarting(Catch::GroupInfo const&)
virtual void testGroupStarting( GroupInfo const& groupInfo ) {
            suiteTimer.start();
            stdOutForSuite.str("");
            stdErrForSuite.str("");
            unexpectedExceptions = 0;
            CumulativeReporterBase::testGroupStarting( groupInfo );
        }

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
callq 0xb44a
movq %rax, 0x108(%rbx)
leaq 0x216e3(%rip), %rsi     # 0x31570
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xd4fa
leaq 0x118(%rbx), %rdi
leaq 0x10(%rsp), %rsi
callq 0x94f0
leaq 0x10(%rsp), %rdi
callq 0x91a0
leaq 0x216b2(%rip), %rsi     # 0x31570
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xd4fa
leaq 0x290(%rbx), %rdi
leaq 0x10(%rsp), %rsi
callq 0x94f0
leaq 0x10(%rsp), %rdi
callq 0x91a0
andl $0x0, 0x400(%rbx)
addq $0x30, %rsp
popq %rbx
retq
jmp 0xfef9
jmp 0xff08
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x91a0
jmp 0xff0b
movq %rax, %rbx
movq %rbx, %rdi
callq 0x9610
nop
// File: /workspace/github_cpp_makefile_star2_O2/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::ConsoleReporter::testRunEnded(Catch::TestRunStats const&)
virtual void testRunEnded( TestRunStats const& _testRunStats ) {
            printTotalsDivider( _testRunStats.totals );
            printTotals( _testRunStats.totals );
            stream << std::endl;
            StreamingReporterBase::testRunEnded( _testRunStats );
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x28(%rsi), %r15
movq %r15, %rsi
callq 0x204a6
movq %r14, %rdi
movq %r15, %rsi
callq 0x1f96e
movq 0x18(%r14), %rdi
callq 0x91b0
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xea44
nop
// File: /workspace/github_cpp_makefile_star2_O2/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::ReporterRegistry::create(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::Ptr<Catch::IConfig> const&) const
virtual IStreamingReporter* create( std::string const& name, Ptr<IConfig> const& config ) const {
            FactoryMap::const_iterator it =  m_factories.find( name );
            if( it == m_factories.end() )
                return NULL;
            return it->second->create( ReporterConfig( config ) );
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rdi, %r14
addq $0x8, %rdi
callq 0x105a0
addq $0x10, %r14
cmpq %r14, %rax
je 0x104a2
movq 0x40(%rax), %r14
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x10568
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0x10(%rax)
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xe054
jmp 0x104a4
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xe054
movq %rbx, %rdi
callq 0x9610
// File: /workspace/github_cpp_makefile_star2_O2/minimind[P]simple-graph/unittest/catch.hpp
// Function: void Catch::deleteAllValues<std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Catch::IReporterFactory*, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Catch::IReporterFactory*>>>>(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Catch::IReporterFactory*, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Catch::IReporterFactory*>>>&)
inline void deleteAllValues( AssociativeContainerT& container ) {
        typename AssociativeContainerT::const_iterator it = container.begin();
        typename AssociativeContainerT::const_iterator itEnd = container.end();
        for(; it != itEnd; ++it )
            delete it->second;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %r14
addq $0x8, %rbx
cmpq %rbx, %r14
je 0x104fb
movq 0x40(%r14), %rdi
testq %rdi, %rdi
je 0x104ee
movq (%rdi), %rax
callq *0x8(%rax)
movq %r14, %rdi
callq 0x9400
movq %rax, %r14
jmp 0x104da
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::ExceptionTranslatorRegistry::translateActiveException[abi:cxx11]() const
virtual std::string translateActiveException() const {
            try {
#ifdef __OBJC__
                // In Objective-C try objective-c exceptions first
                @try {
                    throw;
                }
                @catch (NSException *exception) {
                    return toString( [exception description] );
                }
#else
                throw;
#endif
            }
            catch( TestFailureException& ) {
                throw;
            }
            catch( std::exception& ex ) {
                return ex.what();
            }
            catch( std::string& msg ) {
                return msg;
            }
            catch( const char* msg ) {
                return msg;
            }
            catch(...) {
                return tryTranslators( m_translators.begin() );
            }
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x94c0
jmp 0x106fb
movq %rdx, %r15
movq %rax, %rdi
cmpl $0x5, %r15d
je 0x106f1
cmpl $0x4, %r15d
jne 0x1069b
callq 0x9160
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
leaq 0xe(%rsp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0xd4fa
jmp 0x106df
cmpl $0x3, %r15d
jne 0x106b3
callq 0x9160
movq %rbx, %rdi
movq %rax, %rsi
callq 0x9490
jmp 0x106df
callq 0x9160
cmpl $0x2, %r15d
jne 0x106d0
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0xd4fa
jmp 0x106df
movq 0x8(%r14), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x107b2
callq 0x95b0
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x9160
callq 0x94c0
movq %rax, %rbx
callq 0x95b0
jmp 0x1072b
movq %rax, %rbx
callq 0x95b0
jmp 0x1072b
movq %rax, %rbx
callq 0x95b0
jmp 0x1072b
movq %rax, %rbx
callq 0x95b0
jmp 0x1072b
movq %rax, %rbx
callq 0x95b0
movq %rbx, %rdi
callq 0x9610
movq %rax, %rdi
callq 0xd5fe
nop
// File: /workspace/github_cpp_makefile_star2_O2/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::ExceptionTranslatorRegistry::tryTranslators[abi:cxx11](__gnu_cxx::__normal_iterator<Catch::IExceptionTranslator const* const*, std::vector<Catch::IExceptionTranslator const*, std::allocator<Catch::IExceptionTranslator const*>>>) const
std::string tryTranslators( std::vector<const IExceptionTranslator*>::const_iterator it ) const {
            if( it == m_translators.end() )
                return "Unknown exception";

            try {
                return (*it)->translate();
            }
            catch(...) {
                return tryTranslators( it+1 );
            }
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpq %rdx, 0x10(%rsi)
je 0x107d8
movq %rdx, %r14
movq %rsi, %r15
movq (%rdx), %rsi
movq (%rsi), %rax
movq %rbx, %rdi
callq *0x10(%rax)
jmp 0x107ec
leaq 0x200c9(%rip), %rsi     # 0x308a8
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0xd4fa
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rdi
callq 0x9160
addq $0x8, %r14
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x107b2
callq 0x95b0
jmp 0x107ec
movq %rax, %rbx
callq 0x95b0
movq %rbx, %rdi
callq 0x9610
movq %rax, %rdi
callq 0xd5fe
// File: /workspace/github_cpp_makefile_star2_O2/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::Context::findGeneratorsForCurrentTest()
IGeneratorsForTest* findGeneratorsForCurrentTest() {
            std::string testName = getResultCapture()->getCurrentTestName();

            std::map<std::string, IGeneratorsForTest*>::const_iterator it =
            m_generatorsByTestName.find( testName );
            return it != m_generatorsByTestName.end()
                ? it->second
                : NULL;
        }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x10(%rax)
movq (%rax), %rcx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq *0x38(%rcx)
leaq 0x20(%rbx), %rdi
movq %r14, %rsi
callq 0x10dfe
addq $0x28, %rbx
cmpq %rbx, %rax
je 0x10dd2
movq 0x40(%rax), %rbx
jmp 0x10dd4
xorl %ebx, %ebx
leaq 0x8(%rsp), %rdi
callq 0x91a0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
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::Clara::CommandLine<Catch::ConfigData>::operator[](Catch::Clara::UnpositionalTag)
ArgBuilder operator[]( UnpositionalTag ) {
            if( m_floatingArg.get() )
                throw std::logic_error( "Only one unpositional argument can be added" );
            m_floatingArg = ArgAutoPtr( new Arg() );
            ArgBuilder builder( m_floatingArg.get() );
            return builder;
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
cmpq $0x0, 0x50(%rdi)
jne 0x1301f
movq %rdi, %rbx
movl $0xa8, %edi
callq 0x93a0
movq %rax, %r14
movq %rax, %rdi
callq 0x133e0
addq $0x50, %rbx
leaq 0x8(%rsp), %r15
andq $0x0, (%r15)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14412
movq %r15, %rdi
callq 0x143f8
movq (%rbx), %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
pushq $0x10
popq %rdi
callq 0x91c0
movq %rax, %rbx
leaq 0x1de08(%rip), %rsi     # 0x30e39
movq %rax, %rdi
callq 0x94a0
movq 0x38f90(%rip), %rsi     # 0x4bfd0
movq 0x38f71(%rip), %rdx     # 0x4bfb8
movq %rbx, %rdi
callq 0x95e0
movq %rax, %r15
movq %rbx, %rdi
callq 0x92d0
jmp 0x1306c
movq %rax, %r15
movl $0xa8, %esi
movq %r14, %rdi
callq 0x93c0
movq %r15, %rdi
callq 0x9610
// File: /workspace/github_cpp_makefile_star2_O2/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::Clara::Detail::BoundArgFunction<Catch::ConfigData>::operator=(Catch::Clara::Detail::BoundArgFunction<Catch::ConfigData> const&)
BoundArgFunction& operator = ( BoundArgFunction const& other ) {
                IArgFunction<ConfigT>* newFunctionObj = other.functionObj ? other.functionObj->clone() : NULL;
                delete functionObj;
                functionObj = newFunctionObj;
                return *this;
            }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x13330
movq (%rdi), %rax
callq *0x28(%rax)
movq %rax, %r14
jmp 0x13333
xorl %r14d, %r14d
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x13341
movq (%rdi), %rax
callq *0x8(%rax)
movq %r14, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::Session::applyCommandLine(int, char* const*, Catch::Session::OnUnusedOptions::DoWhat)
int applyCommandLine( int argc, char* const argv[], OnUnusedOptions::DoWhat unusedOptionBehaviour = OnUnusedOptions::Fail ) {
            try {
                m_cli.setThrowOnUnrecognisedTokens( unusedOptionBehaviour == OnUnusedOptions::Fail );
                m_unusedTokens = m_cli.parseInto( argc, argv, m_configData );
                if( m_configData.showHelp )
                    showHelp( m_configData.processName );
                m_config.reset();
            }
            catch( std::exception& ex ) {
                {
                    Colour colourGuard( Colour::Red );
                    std::cerr   << "\nError(s) in input:\n"
                                << Text( ex.what(), TextAttributes().setIndent(2) )
                                << "\n\n";
                }
                m_cli.usage( std::cout, m_configData.processName );
                return (std::numeric_limits<int>::max)();
            }
            return 0;
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movq %rdx, %rax
movl %esi, %edx
movq %rdi, %rbx
cmpl $0x1, %ecx
sete 0x5c(%rdi)
leaq 0x78(%rdi), %r8
leaq 0x30(%rsp), %rdi
movq %rbx, %rsi
movq %rax, %rcx
callq 0x14994
leaq 0x60(%rbx), %rdi
leaq 0x30(%rsp), %r14
movq %r14, %rsi
callq 0x16160
movq %r14, %rdi
callq 0x12afc
cmpb $0x1, 0x7f(%rbx)
jne 0x1475c
leaq 0xf8(%rbx), %rsi
movq %rbx, %rdi
callq 0x14abc
leaq 0x130(%rbx), %rdi
xorl %ebp, %ebp
callq 0x14bf4
movl %ebp, %eax
addq $0xa8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1477c
movq %rax, %r14
cmpl $0x1, %edx
jne 0x14898
movq %r14, %rdi
callq 0x9160
movq %rax, %r15
movb $0x0, 0xe(%rsp)
pushq $0x2
popq %rdi
callq 0xa5c8
movq 0x37841(%rip), %rdi     # 0x4bfe8
leaq 0x1c6d8(%rip), %rsi     # 0x30e86
callq 0x9390
movq %rax, %r14
movq (%r15), %rax
movq %r15, %rdi
callq *0x10(%rax)
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %rax, %rsi
callq 0xd4fa
leaq 0x88(%rsp), %rdx
orq $-0x1, (%rdx)
movq $0x4f, 0x10(%rdx)
movb $0x9, 0x18(%rdx)
movq $0x2, 0x8(%rdx)
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x14c5e
leaq 0x30(%rsp), %rsi
movq %r14, %rdi
callq 0x14c0c
leaq 0x1cd5a(%rip), %rsi     # 0x3156e
movq %rax, %rdi
callq 0x9390
leaq 0x30(%rsp), %rdi
callq 0x14fee
leaq 0x10(%rsp), %rdi
callq 0x91a0
leaq 0xe(%rsp), %rdi
callq 0xa5e8
leaq 0xf8(%rbx), %rdx
movq 0x37778(%rip), %rsi     # 0x4bfc0
movq %rbx, %rdi
callq 0x15004
callq 0x95b0
movl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
jmp 0x1476a
jmp 0x1486d
movq %rax, %r14
jmp 0x1487f
jmp 0x14868
movq %rax, %r14
jmp 0x14889
movq %rax, %r14
jmp 0x14893
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x14fee
leaq 0x10(%rsp), %rdi
callq 0x91a0
leaq 0xe(%rsp), %rdi
callq 0xa5e8
callq 0x95b0
movq %r14, %rdi
callq 0x9610
movq %rax, %rdi
callq 0xd5fe
// File: /workspace/github_cpp_makefile_star2_O2/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::Session::run()
int run() {
            if( m_configData.showHelp )
                return 0;

            try
            {
                config(); // Force config to be constructed
                Runner runner( m_config );

                // Handle list request
                if( Option<std::size_t> listed = list( config() ) )
                    return static_cast<int>( *listed );

                return static_cast<int>( runner.runTests().assertions.failed );
            }
            catch( std::exception& ex ) {
                std::cerr << ex.what() << std::endl;
                return (std::numeric_limits<int>::max)();
            }
        }

// Assembly:
pushq %r14
pushq %rbx
subq $0x278, %rsp            # imm = 0x278
xorl %r14d, %r14d
cmpb $0x0, 0x7f(%rdi)
jne 0x14916
movq %rdi, %rbx
callq 0x16b12
leaq 0x130(%rbx), %rsi
leaq 0x38(%rsp), %rdi
callq 0x16b74
movq %rbx, %rdi
callq 0x16b12
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x16c29
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0x148f8
movq (%rax), %r14
jmp 0x1490c
leaq 0x8(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x16cf0
movq 0x10(%rsp), %r14
leaq 0x38(%rsp), %rdi
callq 0x16ffc
movl %r14d, %eax
addq $0x278, %rsp            # imm = 0x278
popq %rbx
popq %r14
retq
jmp 0x14930
jmp 0x14928
movq %rdx, %r14
movq %rax, %rbx
jmp 0x14940
movq %rdx, %r14
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x16ffc
cmpl $0x1, %r14d
jne 0x14983
movq %rbx, %rdi
callq 0x9160
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq 0x3768a(%rip), %rdi     # 0x4bfe8
movq %rax, %rsi
callq 0x9390
movq %rax, %rdi
callq 0x91b0
callq 0x95b0
movl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
jmp 0x14916
movq %rax, %rbx
callq 0x95b0
movq %rbx, %rdi
callq 0x9610
movq %rax, %rdi
callq 0xd5fe
nop
// File: /workspace/github_cpp_makefile_star2_O2/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::Clara::CommandLine<Catch::ConfigData>::parseInto(int, char const* const*, Catch::ConfigData&) const
std::vector<Parser::Token> parseInto( int argc, char const * const * argv, ConfigT& config ) const {
            std::string processName = argv[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( argc, argv, tokens );
            return populate( tokens, config );
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r8, %r14
movq %rcx, %r12
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
movq (%rcx), %rsi
leaq 0x38(%rsp), %r13
leaq 0x18(%rsp), %rdx
movq %r13, %rdi
callq 0xd4fa
leaq 0x1c4cf(%rip), %rsi     # 0x30e9b
pushq $-0x1
popq %rdx
movq %r13, %rdi
callq 0x9380
cmpq $-0x1, %rax
je 0x14a0f
incq %rax
leaq 0x18(%rsp), %rdi
leaq 0x38(%rsp), %rsi
pushq $-0x1
popq %rcx
movq %rax, %rdx
callq 0x93e0
leaq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %r13
movq %r13, %rsi
callq 0x9450
movq %r13, %rdi
callq 0x91a0
movq (%r15), %rdi
movq (%rdi), %rax
leaq 0x38(%rsp), %rdx
movq %r14, %rsi
callq *0x10(%rax)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x1508a
leaq 0x18(%rsp), %rdi
movq %rsp, %rcx
movl %ebp, %esi
movq %r12, %rdx
callq 0x1509e
movq %rsp, %rdx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rcx
callq 0x1515c
leaq 0x18(%rsp), %rdi
callq 0x91a0
movq %rsp, %rdi
callq 0x12afc
leaq 0x38(%rsp), %rdi
callq 0x91a0
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x14a8f
movq %rax, %rbx
jmp 0x14aa1
movq %rax, %rbx
jmp 0x14aa9
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x91a0
movq %rsp, %rdi
callq 0x12afc
leaq 0x38(%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::Session::showHelp(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void showHelp( std::string const& processName ) {
            std::cout << "\nCatch v"    << libraryVersion.majorVersion << "."
                                        << libraryVersion.minorVersion << " build "
                                        << libraryVersion.buildNumber;
            if( libraryVersion.branchName != std::string( "master" ) )
                std::cout << " (" << libraryVersion.branchName << " branch)";
            std::cout << "\n";

            m_cli.usage( std::cout, processName );
            std::cout << "For more detail usage please see the project docs\n" << std::endl;
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x374eb(%rip), %rdi     # 0x4bfc0
leaq 0x1c44a(%rip), %rsi     # 0x30f26
callq 0x9390
movl 0x37901(%rip), %esi     # 0x4c3e8
movq %rax, %rdi
callq 0x9270
leaq 0x1cd16(%rip), %rsi     # 0x3180c
movq %rax, %rdi
callq 0x9390
movl 0x378e8(%rip), %esi     # 0x4c3ec
movq %rax, %rdi
callq 0x9270
leaq 0x1c41c(%rip), %rsi     # 0x30f2f
movq %rax, %rdi
callq 0x9390
movl 0x378cf(%rip), %esi     # 0x4c3f0
movq %rax, %rdi
callq 0x9270
movq 0x378c8(%rip), %r15     # 0x4c3f8
leaq 0x1bbce(%rip), %rsi     # 0x30705
leaq 0x10(%rsp), %r12
leaq 0xf(%rsp), %rdx
movq %r12, %rdi
callq 0xd4fa
movq %r15, %rdi
movq %r12, %rsi
callq 0x151fe
movl %eax, %ebp
leaq 0x10(%rsp), %rdi
callq 0x91a0
testb %bpl, %bpl
je 0x14b96
movq 0x37454(%rip), %rdi     # 0x4bfc0
leaq 0x1c392(%rip), %rsi     # 0x30f05
callq 0x9390
movq 0x37879(%rip), %rsi     # 0x4c3f8
movq %rax, %rdi
callq 0x9390
leaq 0x1c3a9(%rip), %rsi     # 0x30f37
movq %rax, %rdi
callq 0x9390
movq 0x37423(%rip), %r15     # 0x4bfc0
leaq 0x1c9cb(%rip), %rsi     # 0x3156f
movq %r15, %rdi
callq 0x9390
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x15004
leaq 0x1c37f(%rip), %rsi     # 0x30f40
movq %r15, %rdi
callq 0x9390
movq %rax, %rdi
callq 0x91b0
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x91a0
movq %rbx, %rdi
callq 0x9610
nop