LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
callq 0x21c50
movq -0x50(%rbp), %rdi
addq $0x60, %rdi
movq %rdi, -0x58(%rbp)
callq 0x240f0
movq -0x50(%rbp), %rdi
addq $0x78, %rdi
movq %rdi, -0x48(%rbp)
callq 0x24110
jmp 0x15b27
movq -0x60(%rbp), %rdi
addq $0x130, %rdi            # imm = 0x130
movq %rdi, -0x68(%rbp)
callq 0x241b0
jmp 0x15b3d
testb $0x1, 0x97a46(%rip)     # 0xad58a
je 0x15c3a
leaq -0x39(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0xb930
movq -0x70(%rbp), %rdx
leaq 0x62e09(%rip), %rsi     # 0x7896b
leaq -0x38(%rbp), %rdi
callq 0x134e0
jmp 0x15b6d
leaq -0x39(%rbp), %rdi
callq 0xb5c0
movq 0x9746b(%rip), %rdi     # 0xacfe8
leaq -0x38(%rbp), %rsi
callq 0xb4c0
movq %rax, -0x78(%rbp)
jmp 0x15b8c
movq -0x78(%rbp), %rdi
movq 0x973e9(%rip), %rsi     # 0xacf80
callq 0xb5a0
jmp 0x15b9e
movl $0x10, %edi
callq 0xb290
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x80(%rbp)
leaq -0x38(%rbp), %rsi
callq 0xb750
jmp 0x15bbd
movq -0x80(%rbp), %rdi
movq 0x97408(%rip), %rsi     # 0xacfd0
movq 0x973e1(%rip), %rdx     # 0xacfb0
callq 0xb8d0
jmp 0x15c77
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x15c5c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x15c53
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq -0x39(%rbp), %rdi
callq 0xb5c0
jmp 0x15c4a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x15c2f
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0xb400
leaq -0x38(%rbp), %rdi
callq 0xb330
jmp 0x15c4a
movb $0x1, 0x97949(%rip)     # 0xad58a
addq $0x80, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x241d0
movq -0x48(%rbp), %rdi
callq 0x24210
movq -0x58(%rbp), %rdi
callq 0x24270
movq -0x50(%rbp), %rdi
callq 0x242d0
movq -0x10(%rbp), %rdi
callq 0xb920
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
movl $0x1, %ecx
callq 0x29940
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x15cc1
movq -0x28(%rbp), %rdi
callq 0x29c10
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb8(%rbp)
movl 0x30(%rax), %eax
movq %rax, -0xb0(%rbp)
subq $0x3, %rax
ja 0x162ca
movq -0xb0(%rbp), %rax
leaq 0x61ec0(%rip), %rcx     # 0x78030
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0xb8(%rbp), %rax
addq $0x10, %rax
movq %rax, -0xc0(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0xddc0
movq -0xc0(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x14270
andb $0x1, %al
movb %al, -0x1(%rbp)
leaq -0x38(%rbp), %rdi
callq 0xb330
jmp 0x16323
movq -0x18(%rbp), %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0xddc0
movq -0xb8(%rbp), %rsi
movq -0xd0(%rbp), %rdi
addq $0x10, %rsi
callq 0xef10
movb %al, -0xc1(%rbp)
jmp 0x161ee
movb -0xc1(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xb330
jmp 0x16323
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0xb330
jmp 0x16331
movq -0x18(%rbp), %rsi
leaq -0x88(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0xddc0
movq -0xb8(%rbp), %rsi
movq -0xe0(%rbp), %rdi
addq $0x10, %rsi
callq 0xd990
movb %al, -0xd1(%rbp)
jmp 0x16257
movb -0xd1(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
leaq -0x88(%rbp), %rdi
callq 0xb330
jmp 0x16323
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x88(%rbp), %rdi
callq 0xb330
jmp 0x16331
movq -0x18(%rbp), %rsi
leaq -0xa8(%rbp), %rdi
callq 0xddc0
movq -0xb8(%rbp), %rsi
addq $0x10, %rsi
leaq -0xa8(%rbp), %rdi
callq 0xefd0
andb $0x1, %al
movb %al, -0x1(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0xb330
jmp 0x16323
movl $0x10, %edi
callq 0xb290
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0xe8(%rbp)
leaq 0x62e82(%rip), %rsi     # 0x7916a
callq 0xb730
jmp 0x162ef
movq -0xe8(%rbp), %rdi
movq 0x96cd3(%rip), %rsi     # 0xacfd0
movq 0x96cac(%rip), %rdx     # 0xacfb0
callq 0xb8d0
movq -0xe8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
callq 0xb400
jmp 0x16331
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xf0, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0xb920
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x38, %rdi
callq 0x3f390
movq -0x38(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x38, %rdi
callq 0x3f3c0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x35890
testb $0x1, %al
jne 0x16741
jmp 0x167b4
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x37400
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x3f3f0
testb $0x1, %al
jne 0x16764
jmp 0x167a4
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
testb $0x1, %al
jne 0x16787
leaq -0x28(%rbp), %rdi
callq 0x358d0
movq %rax, %rdi
callq 0xdff0
testb $0x1, %al
jne 0x167a4
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x37400
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x3f470
jmp 0x167a6
leaq -0x28(%rbp), %rdi
callq 0x35910
jmp 0x1672e
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::CumulativeReporterBase::sectionEnded(Catch::SectionStats const&)
virtual void sectionEnded( SectionStats const& sectionStats ) {
            assert( !m_sectionStack.empty() );
            SectionNode& node = *m_sectionStack.back();
            node.stats = sectionStats;
            m_sectionStack.pop_back();
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0xa8, %rdi
callq 0x40d60
xorb $-0x1, %al
testb $0x1, %al
jne 0x1735c
jmp 0x1735e
jmp 0x1737d
leaq 0x61ea1(%rip), %rdi     # 0x79206
leaq 0x613c9(%rip), %rsi     # 0x78735
movl $0x1cba, %edx           # imm = 0x1CBA
leaq 0x61ef9(%rip), %rcx     # 0x79271
callq 0xb380
movq -0x20(%rbp), %rdi
addq $0xa8, %rdi
callq 0x40f20
movq %rax, %rdi
callq 0x40f60
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
callq 0x430c0
movq -0x20(%rbp), %rdi
addq $0xa8, %rdi
callq 0x43110
addq $0x20, %rsp
popq %rbp
retq
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x88, %edi
callq 0xb530
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rsi
callq 0x44dd0
jmp 0x17697
movq -0x30(%rbp), %rsi
leaq -0x18(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x44e40
movq -0x48(%rbp), %rdi
callq 0x44e80
movq %rax, -0x40(%rbp)
jmp 0x176b7
movq -0x38(%rbp), %rsi
movq -0x40(%rbp), %rdi
addq $0x70, %rdi
addq $0x68, %rsi
callq 0x44ea0
movq -0x38(%rbp), %rdi
subq $-0x80, %rdi
leaq -0x18(%rbp), %rsi
callq 0x44f00
jmp 0x176df
movq -0x38(%rbp), %rdi
movq (%rdi), %rax
movq 0x80(%rax), %rax
callq *%rax
jmp 0x176f1
leaq -0x18(%rbp), %rdi
callq 0x44f70
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x88, %esi
callq 0xb550
jmp 0x17731
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x44f70
movq -0x20(%rbp), %rdi
callq 0xb920
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
movq %rdi, %rax
addq $0x28, %rax
movq %rax, -0xc8(%rbp)
addq $0x10, %rdi
callq 0x45c80
movq -0xc8(%rbp), %rdi
movq %rax, %rsi
callq 0x45c60
leaq -0x29(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0xb930
movq -0xc0(%rbp), %rdx
leaq 0x61b2f(%rip), %rsi     # 0x7933d
leaq -0x28(%rbp), %rdi
callq 0x134e0
jmp 0x17819
movq -0xc8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x45ca0
jmp 0x1782b
leaq -0x28(%rbp), %rdi
callq 0xb330
leaq -0x29(%rbp), %rdi
callq 0xb5c0
movq -0xd0(%rbp), %rsi
addq $0x10, %rsi
leaq -0x68(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x45d30
movq -0xd8(%rbp), %rdi
callq 0x1b1c0
movq %rax, %rsi
movq (%rsi), %rax
movq 0x30(%rax), %rax
leaq -0x60(%rbp), %rdi
callq *%rax
jmp 0x17876
leaq -0x60(%rbp), %rdi
callq 0xb890
xorb $-0x1, %al
movb %al, -0xd9(%rbp)
leaq -0x60(%rbp), %rdi
callq 0xb330
leaq -0x68(%rbp), %rdi
callq 0x15840
movb -0xd9(%rbp), %al
testb $0x1, %al
jne 0x178a8
jmp 0x17a24
movq -0xd0(%rbp), %rax
addq $0x28, %rax
movq %rax, -0xf0(%rbp)
leaq -0x89(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0xb930
movq -0xe8(%rbp), %rdx
leaq 0x61249(%rip), %rsi     # 0x78b24
leaq -0x88(%rbp), %rdi
callq 0x134e0
jmp 0x178e9
movq -0xd0(%rbp), %rsi
addq $0x10, %rsi
leaq -0xb8(%rbp), %rdi
callq 0x45d30
jmp 0x17902
leaq -0xb8(%rbp), %rdi
callq 0x1b1c0
movq %rax, %rsi
movq (%rsi), %rax
movq 0x30(%rax), %rax
leaq -0xb0(%rbp), %rdi
callq *%rax
jmp 0x17923
movq -0xf0(%rbp), %rdi
leaq -0x88(%rbp), %rsi
leaq -0xb0(%rbp), %rdx
callq 0x45d60
jmp 0x1793f
leaq -0xb0(%rbp), %rdi
callq 0xb330
leaq -0xb8(%rbp), %rdi
callq 0x15840
leaq -0x88(%rbp), %rdi
callq 0xb330
leaq -0x89(%rbp), %rdi
callq 0xb5c0
jmp 0x17a24
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x17997
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xb330
leaq -0x29(%rbp), %rdi
callq 0xb5c0
jmp 0x17a2d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x15840
jmp 0x17a2d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x17a16
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x17a0a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x179fe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0xb330
leaq -0xb8(%rbp), %rdi
callq 0x15840
leaq -0x88(%rbp), %rdi
callq 0xb330
leaq -0x89(%rbp), %rdi
callq 0xb5c0
jmp 0x17a2d
addq $0xf0, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0xb920
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0xc8(%rbp)
movl 0x70(%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0x70(%rcx)
cmpl $0x0, %eax
jle 0x185d7
movq -0xc8(%rbp), %rax
addq $0x28, %rax
movq %rax, -0xd8(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0xb930
movq -0xd0(%rbp), %rdx
leaq 0x60f1f(%rip), %rsi     # 0x79335
leaq -0x38(%rbp), %rdi
callq 0x134e0
jmp 0x18421
movq -0xd8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x45ca0
movq %rax, -0xe0(%rbp)
jmp 0x1843a
leaq -0x71(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0xb930
movq -0xe8(%rbp), %rdx
leaq 0x606cc(%rip), %rsi     # 0x78b24
leaq -0x70(%rbp), %rdi
callq 0x134e0
jmp 0x18463
movq -0x10(%rbp), %rsi
leaq -0x98(%rbp), %rdi
callq 0xf060
jmp 0x18475
movq -0xe0(%rbp), %rdi
leaq -0x70(%rbp), %rsi
leaq -0x98(%rbp), %rdx
callq 0x45d60
movq %rax, -0xf0(%rbp)
jmp 0x18495
leaq -0xb9(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
callq 0xb930
movq -0xf8(%rbp), %rdx
leaq 0x60eed(%rip), %rsi     # 0x793a3
leaq -0xb8(%rbp), %rdi
callq 0x134e0
jmp 0x184c4
movq -0xf0(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq -0xb8(%rbp), %rsi
callq 0x45d60
jmp 0x184dd
leaq -0xb8(%rbp), %rdi
callq 0xb330
leaq -0xb9(%rbp), %rdi
callq 0xb5c0
leaq -0x98(%rbp), %rdi
callq 0xb330
leaq -0x70(%rbp), %rdi
callq 0xb330
leaq -0x71(%rbp), %rdi
callq 0xb5c0
leaq -0x38(%rbp), %rdi
callq 0xb330
leaq -0x39(%rbp), %rdi
callq 0xb5c0
jmp 0x185d7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x185cc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x185c3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x185ba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x185b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x185a5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x18599
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0xb330
leaq -0xb9(%rbp), %rdi
callq 0xb5c0
leaq -0x98(%rbp), %rdi
callq 0xb330
leaq -0x70(%rbp), %rdi
callq 0xb330
leaq -0x71(%rbp), %rdi
callq 0xb5c0
leaq -0x38(%rbp), %rdi
callq 0xb330
leaq -0x39(%rbp), %rdi
callq 0xb5c0
jmp 0x185e0
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0xb920
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x88(%rbp)
addq $0x108, %rdi            # imm = 0x108
callq 0xedf0
movq -0x88(%rbp), %rax
addq $0x110, %rax            # imm = 0x110
movq %rax, -0x80(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0xb930
movq -0x78(%rbp), %rdx
leaq 0x5fd95(%rip), %rsi     # 0x79528
leaq -0x30(%rbp), %rdi
callq 0x134e0
jmp 0x1979e
movq -0x80(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xb260
jmp 0x197ad
leaq -0x30(%rbp), %rdi
callq 0xb330
leaq -0x31(%rbp), %rdi
callq 0xb5c0
movq -0x88(%rbp), %rax
addq $0x288, %rax            # imm = 0x288
movq %rax, -0x98(%rbp)
leaq -0x69(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0xb930
movq -0x90(%rbp), %rdx
leaq 0x5fd37(%rip), %rsi     # 0x79528
leaq -0x68(%rbp), %rdi
callq 0x134e0
jmp 0x197fc
movq -0x98(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0xb260
jmp 0x1980e
leaq -0x68(%rbp), %rdi
callq 0xb330
leaq -0x69(%rbp), %rdi
callq 0xb5c0
movq -0x88(%rbp), %rdi
movl $0x0, 0x400(%rdi)
movq -0x10(%rbp), %rsi
callq 0x16ef0
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x19866
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xb330
leaq -0x31(%rbp), %rdi
callq 0xb5c0
jmp 0x1989d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x19894
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0xb330
leaq -0x69(%rbp), %rdi
callq 0xb5c0
movq -0x40(%rbp), %rdi
callq 0xb920
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
callq 0x4baf0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
callq 0x49c40
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movq 0x9303b(%rip), %rsi     # 0xacf80
callq 0xb5a0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x16e90
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x58(%rbp)
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
callq 0x1ae30
movq -0x58(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x8, %rdi
callq 0x1ae90
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1ae60
testb $0x1, %al
jne 0x1a6e1
jmp 0x1a6eb
movq $0x0, -0x8(%rbp)
jmp 0x1a74e
leaq -0x28(%rbp), %rdi
callq 0x1a990
movq 0x20(%rax), %rax
movq %rax, -0x70(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x1aec0
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq %rax, -0x60(%rbp)
jmp 0x1a724
movq -0x60(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x159a0
jmp 0x1a74e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x159a0
jmp 0x1a758
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0xb920
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1a8e0
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x1a910
movq -0x8(%rbp), %rdi
callq 0x1a930
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x1a910
leaq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x1a960
testb $0x1, %al
jne 0x1a883
jmp 0x1a8b1
leaq -0x10(%rbp), %rdi
callq 0x1a990
movq 0x20(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x1a8a4
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x1a8a6
leaq -0x10(%rbp), %rdi
callq 0x1a9c0
jmp 0x1a870
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x8, %rdi
callq 0x1bb80
movq %rax, -0x20(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x1bb40
testb $0x1, %al
jne 0x1ba37
jmp 0x1ba7f
leaq -0x21(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0xb930
movq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rdx
leaq 0x5ce0d(%rip), %rsi     # 0x78860
callq 0x134e0
jmp 0x1ba5a
leaq -0x21(%rbp), %rdi
callq 0xb5c0
jmp 0x1baf2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x21(%rbp), %rdi
callq 0xb5c0
jmp 0x1bafc
leaq -0x10(%rbp), %rdi
callq 0x1b7c0
movq -0x58(%rbp), %rdi
movq (%rax), %rsi
movq (%rsi), %rax
movq 0x10(%rax), %rax
callq *%rax
jmp 0x1ba9a
jmp 0x1baf2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movq -0x30(%rbp), %rdi
callq 0xb1e0
leaq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x1bbb0
movq -0x58(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdx
callq 0x1b9f0
jmp 0x1bad6
callq 0xb870
jmp 0x1baf2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0xb870
jmp 0x1baf0
jmp 0x1bafc
movq -0x50(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0xb920
movq %rax, %rdi
callq 0x13830
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq %rax, %rsi
movq (%rsi), %rax
movq 0x38(%rax), %rax
leaq -0x28(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq *%rax
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rsi
addq $0x20, %rdi
callq 0x1d4d0
movq %rax, -0x60(%rbp)
jmp 0x1d38b
movq -0x60(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x1d500
movq -0x70(%rbp), %rdi
addq $0x20, %rdi
callq 0x1d550
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x1d500
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x1d520
testb $0x1, %al
jne 0x1d3d1
jmp 0x1d3e4
leaq -0x30(%rbp), %rdi
callq 0x1d580
movq 0x20(%rax), %rax
movq %rax, -0x78(%rbp)
jmp 0x1d3ec
xorl %eax, %eax
movq %rax, -0x78(%rbp)
jmp 0x1d3ec
movq -0x78(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xb330
movq -0x80(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xb330
movq -0x40(%rbp), %rdi
callq 0xb920
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x50, %rdi
callq 0x28870
cmpq $0x0, %rax
je 0x24b73
movl $0x10, %edi
callq 0xb290
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
leaq 0x542b3(%rip), %rsi     # 0x78df1
callq 0xb730
jmp 0x24b45
movq -0x40(%rbp), %rdi
movq 0x88480(%rip), %rsi     # 0xacfd0
movq 0x88459(%rip), %rdx     # 0xacfb0
callq 0xb8d0
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0xb400
jmp 0x24bf2
movl $0xa8, %edi
callq 0xb530
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
callq 0x258b0
jmp 0x24b8e
movq -0x48(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x288a0
movq -0x38(%rbp), %rdi
addq $0x50, %rdi
leaq -0x30(%rbp), %rsi
callq 0x288d0
leaq -0x30(%rbp), %rdi
callq 0x28900
movq -0x38(%rbp), %rdi
addq $0x50, %rdi
callq 0x28870
movq %rax, %rsi
leaq -0x8(%rbp), %rdi
callq 0x28950
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0xa8, %esi
callq 0xb550
movq -0x20(%rbp), %rdi
callq 0xb920
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0x25615
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movq %rax, -0x28(%rbp)
jmp 0x2561d
xorl %eax, %eax
movq %rax, -0x28(%rbp)
jmp 0x2561d
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x25640
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x2e0, %rsp            # imm = 0x2E0
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x2b8(%rbp)
testb $0x1, 0x7f(%rax)
je 0x29c3c
movl $0x0, -0x4(%rbp)
jmp 0x29e0c
movq -0x2b8(%rbp), %rdi
callq 0x2ef60
jmp 0x29c4a
movq -0x2b8(%rbp), %rsi
addq $0x130, %rsi            # imm = 0x130
leaq -0x260(%rbp), %rdi
callq 0x2f000
jmp 0x29c66
movq -0x2b8(%rbp), %rdi
callq 0x2ef60
movq %rax, -0x2c0(%rbp)
jmp 0x29c7b
movq -0x2c0(%rbp), %rsi
leaq -0x270(%rbp), %rdi
callq 0x2f0e0
jmp 0x29c90
leaq -0x270(%rbp), %rdi
callq 0x2f310
movq %rax, -0x2c8(%rbp)
jmp 0x29ca5
movq -0x2c8(%rbp), %rax
cmpq $0x0, %rax
je 0x29d19
leaq -0x270(%rbp), %rdi
callq 0x2f340
movq %rax, -0x2d0(%rbp)
jmp 0x29cc7
movq -0x2d0(%rbp), %rax
movq (%rax), %rax
movl %eax, -0x4(%rbp)
movl $0x1, -0x274(%rbp)
jmp 0x29d23
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x29d81
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x29d75
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x270(%rbp), %rdi
callq 0x2f360
jmp 0x29d75
movl $0x0, -0x274(%rbp)
leaq -0x270(%rbp), %rdi
callq 0x2f360
movl -0x274(%rbp), %eax
testl %eax, %eax
jne 0x29d64
jmp 0x29d3b
leaq -0x2a8(%rbp), %rdi
leaq -0x260(%rbp), %rsi
callq 0x2f380
jmp 0x29d50
movq -0x2a0(%rbp), %rax
movl %eax, -0x4(%rbp)
movl $0x1, -0x274(%rbp)
leaq -0x260(%rbp), %rdi
callq 0x2f9a0
jmp 0x29e0c
leaq -0x260(%rbp), %rdi
callq 0x2f9a0
movl -0x1c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x29e18
movq -0x18(%rbp), %rdi
callq 0xb1e0
movq %rax, -0x2b0(%rbp)
movq -0x2b0(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq %rax, %rsi
movq 0x8322d(%rip), %rdi     # 0xacfe8
callq 0xb520
movq %rax, -0x2d8(%rbp)
jmp 0x29dc9
movq -0x2d8(%rbp), %rdi
movq 0x831a9(%rip), %rsi     # 0xacf80
callq 0xb5a0
jmp 0x29dde
callq 0x2aa50
movl %eax, -0x4(%rbp)
movl $0x1, -0x274(%rbp)
callq 0xb870
jmp 0x29e0c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0xb870
jmp 0x29e0a
jmp 0x29e18
movl -0x4(%rbp), %eax
addq $0x2e0, %rsp            # imm = 0x2E0
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0xb920
movq %rax, %rdi
callq 0x13830
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0xe8(%rbp)
movq %rdi, %rax
movq %rax, -0xe0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xd8(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xd0(%rbp)
leaq -0x49(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0xb930
movq -0xd0(%rbp), %rsi
movq -0xc8(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0x134e0
jmp 0x29ec1
leaq -0x49(%rbp), %rdi
callq 0xb5c0
leaq -0x48(%rbp), %rdi
leaq 0x4ef7e(%rip), %rsi     # 0x78e53
movq $-0x1, %rdx
callq 0xb4f0
movq %rax, -0x68(%rbp)
cmpq $-0x1, -0x68(%rbp)
je 0x29f55
movq -0x68(%rbp), %rdx
incq %rdx
leaq -0x88(%rbp), %rdi
leaq -0x48(%rbp), %rsi
movq $-0x1, %rcx
callq 0xb580
jmp 0x29f0c
leaq -0x48(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0xb670
leaq -0x88(%rbp), %rdi
callq 0xb330
jmp 0x29f55
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x49(%rbp), %rdi
callq 0xb5c0
jmp 0x2a02d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x2a024
movq -0xd8(%rbp), %rdi
movq -0x28(%rbp), %rsi
leaq -0x48(%rbp), %rdx
callq 0x2aa60
jmp 0x29f6b
leaq -0xa0(%rbp), %rdi
callq 0x240f0
leaq -0xc0(%rbp), %rdi
callq 0x2aa90
jmp 0x29f85
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
leaq -0xc0(%rbp), %rdi
leaq -0xa0(%rbp), %rcx
callq 0x2ab00
jmp 0x29fa1
movq -0xd8(%rbp), %rsi
movq -0xe8(%rbp), %rdi
movq -0x28(%rbp), %rcx
leaq -0xa0(%rbp), %rdx
callq 0x2aca0
jmp 0x29fc1
leaq -0xc0(%rbp), %rdi
callq 0x2ada0
leaq -0xa0(%rbp), %rdi
callq 0x24270
leaq -0x48(%rbp), %rdi
callq 0xb330
movq -0xe0(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x2a018
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x2ada0
leaq -0xa0(%rbp), %rdi
callq 0x24270
leaq -0x48(%rbp), %rdi
callq 0xb330
movq -0x58(%rbp), %rdi
callq 0xb920
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq 0x82f29(%rip), %rdi     # 0xacfb8
leaq 0x4ee48(%rip), %rsi     # 0x78ede
callq 0xb520
movq %rax, %rdi
movl 0x834f4(%rip), %esi     # 0xad598
callq 0xb6f0
movq %rax, %rdi
leaq 0x4f711(%rip), %rsi     # 0x797c4
callq 0xb520
movq %rax, %rdi
movl 0x834db(%rip), %esi     # 0xad59c
callq 0xb6f0
movq %rax, %rdi
leaq 0x4ee17(%rip), %rsi     # 0x78ee7
callq 0xb520
movq %rax, %rdi
movl 0x834c2(%rip), %esi     # 0xad5a0
callq 0xb6f0
movq 0x834be(%rip), %rax     # 0xad5a8
movq %rax, -0x58(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0xb930
movq -0x50(%rbp), %rdx
leaq 0x4e5b7(%rip), %rsi     # 0x786bd
leaq -0x30(%rbp), %rdi
callq 0x134e0
jmp 0x2a111
movq -0x58(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2adc0
movb %al, -0x61(%rbp)
jmp 0x2a123
leaq -0x30(%rbp), %rdi
callq 0xb330
leaq -0x31(%rbp), %rdi
callq 0xb5c0
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0x2a13e
jmp 0x2a19f
movq 0x82e73(%rip), %rdi     # 0xacfb8
leaq 0x4ed71(%rip), %rsi     # 0x78ebd
callq 0xb520
movq %rax, %rdi
movq 0x8344d(%rip), %rsi     # 0xad5a8
callq 0xb520
movq %rax, %rdi
leaq 0x4ed85(%rip), %rsi     # 0x78eef
callq 0xb520
jmp 0x2a19f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x2a194
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xb330
leaq -0x31(%rbp), %rdi
callq 0xb5c0
jmp 0x2a1ee
movq 0x82e12(%rip), %rdi     # 0xacfb8
leaq 0x4f37a(%rip), %rsi     # 0x79527
callq 0xb520
movq -0x60(%rbp), %rdi
movq -0x10(%rbp), %rdx
movq 0x82df7(%rip), %rsi     # 0xacfb8
callq 0x2a9a0
movq 0x82deb(%rip), %rdi     # 0xacfb8
leaq 0x4ed24(%rip), %rsi     # 0x78ef8
callq 0xb520
movq %rax, %rdi
movq 0x82d9d(%rip), %rsi     # 0xacf80
callq 0xb5a0
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0xb920
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x2fce0
movq -0xc0(%rbp), %rdi
leaq 0x7b93f(%rip), %rax     # 0xab380
movq %rax, (%rdi)
addq $0x10, %rdi
movq %rdi, -0xb8(%rbp)
movq -0x10(%rbp), %rsi
callq 0x2fd20
jmp 0x2fa5a
movq -0xc0(%rbp), %rdi
addq $0xc8, %rdi
callq 0xcf60
jmp 0x2fa6f
movq -0xc0(%rbp), %rax
addq $0xd8, %rax
movq %rax, -0xd0(%rbp)
movq 0x7d52e(%rip), %rdi     # 0xacfb8
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0xb240
movq %rax, -0xc8(%rbp)
jmp 0x2faa2
movq -0xc8(%rbp), %rsi
movq -0xd0(%rbp), %rdi
callq 0xb1d0
jmp 0x2fab7
movq -0xc0(%rbp), %rdi
addq $0x1e8, %rdi            # imm = 0x1E8
movq %rdi, -0xd8(%rbp)
callq 0x2fe40
movq -0x10(%rbp), %rdi
addq $0xa0, %rdi
callq 0x212e0
testb $0x1, %al
jne 0x2fc0a
callq 0x11e50
movq %rax, %rsi
leaq -0x90(%rbp), %rdi
callq 0x2fe60
jmp 0x2faff
movq $0x0, -0x98(%rbp)
movq -0x98(%rbp), %rax
movq %rax, -0xe0(%rbp)
movq -0x10(%rbp), %rdi
addq $0xa0, %rdi
callq 0x26d50
movq %rax, %rcx
movq -0xe0(%rbp), %rax
cmpq %rcx, %rax
jae 0x2fbc3
movq -0x10(%rbp), %rdi
addq $0xa0, %rdi
movq -0x98(%rbp), %rsi
callq 0x2ef40
movq %rax, %rsi
leaq -0x90(%rbp), %rdi
callq 0x2feb0
jmp 0x2fb63
jmp 0x2fb65
movq -0x98(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x98(%rbp)
jmp 0x2fb0a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x2fc37
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x2fc2b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x2fc13
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x30030
jmp 0x2fc13
leaq -0xb0(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x2ff90
jmp 0x2fbd8
movq -0xc0(%rbp), %rdi
addq $0x1e8, %rdi            # imm = 0x1E8
leaq -0xb0(%rbp), %rsi
callq 0x2ffe0
leaq -0xb0(%rbp), %rdi
callq 0x30010
leaq -0x90(%rbp), %rdi
callq 0x30030
addq $0xe0, %rsp
popq %rbp
retq
movq -0xd8(%rbp), %rdi
callq 0x30010
movq -0xd0(%rbp), %rdi
callq 0xb800
movq -0xb8(%rbp), %rdi
callq 0x24210
movq -0xc0(%rbp), %rdi
callq 0x300b0
movq -0x18(%rbp), %rdi
callq 0xb920
nopl (%rax)
// File: minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::Runner::openStream()
void openStream() {
            // Open output file, if specified
            if( !m_config->getFilename().empty() ) {
                m_ofs.open( m_config->getFilename().c_str() );
                if( m_ofs.fail() ) {
                    std::ostringstream oss;
                    oss << "Unable to open file: '" << m_config->getFilename() << "'";
                    throw std::domain_error( oss.str() );
                }
                m_config->setStreamBuf( m_ofs.rdbuf() );
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x1c0(%rbp)
callq 0x33d60
movq %rax, %rdi
callq 0x33d80
movq %rax, %rdi
callq 0xb890
testb $0x1, %al
jne 0x33a0a
movq -0x1c0(%rbp), %rdi
movq %rdi, %rax
addq $0x8, %rax
movq %rax, -0x1c8(%rbp)
callq 0x33d60
movq %rax, %rdi
callq 0x33d80
movq %rax, %rdi
callq 0xb200
movq -0x1c8(%rbp), %rdi
movq %rax, %rsi
movl $0x10, %edx
callq 0xb080
movq -0x1c0(%rbp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movq 0x8(%rax), %rax
addq -0x18(%rax), %rdi
callq 0xb030
testb $0x1, %al
jne 0x33879
jmp 0x339d8
leaq -0x180(%rbp), %rdi
movq %rdi, -0x1d8(%rbp)
callq 0xb700
movq -0x1d8(%rbp), %rdi
leaq 0x45741(%rip), %rsi     # 0x78fdb
callq 0xb520
movq %rax, -0x1d0(%rbp)
jmp 0x338a8
movq -0x1c0(%rbp), %rdi
callq 0x33d60
movq %rax, -0x1e0(%rbp)
jmp 0x338bd
movq -0x1e0(%rbp), %rdi
callq 0x33d80
movq %rax, -0x1e8(%rbp)
jmp 0x338d2
movq -0x1e8(%rbp), %rsi
movq -0x1d0(%rbp), %rdi
callq 0xb4c0
movq %rax, -0x1f0(%rbp)
jmp 0x338ee
movq -0x1f0(%rbp), %rdi
leaq 0x4546d(%rip), %rsi     # 0x78d69
callq 0xb520
jmp 0x33903
movb $0x1, -0x1b1(%rbp)
movl $0x10, %edi
callq 0xb290
movq %rax, -0x1f8(%rbp)
leaq -0x1b0(%rbp), %rdi
leaq -0x180(%rbp), %rsi
callq 0xb560
jmp 0x33930
movq -0x1f8(%rbp), %rdi
leaq -0x1b0(%rbp), %rsi
callq 0xb650
jmp 0x33945
movq -0x1f8(%rbp), %rdi
movb $0x0, -0x1b1(%rbp)
movq 0x7962e(%rip), %rsi     # 0xacf88
movq 0x79637(%rip), %rdx     # 0xacf98
callq 0xb8d0
jmp 0x33a1f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x188(%rbp)
movl %eax, -0x18c(%rbp)
jmp 0x339ca
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x188(%rbp)
movl %eax, -0x18c(%rbp)
jmp 0x339b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x188(%rbp)
movl %eax, -0x18c(%rbp)
leaq -0x1b0(%rbp), %rdi
callq 0xb330
testb $0x1, -0x1b1(%rbp)
jne 0x339bc
jmp 0x339c8
movq -0x1f8(%rbp), %rdi
callq 0xb400
jmp 0x339ca
leaq -0x180(%rbp), %rdi
callq 0xb100
jmp 0x33a13
movq -0x1c0(%rbp), %rdi
callq 0x33d60
movq -0x1c0(%rbp), %rdi
movq %rax, -0x200(%rbp)
addq $0x8, %rdi
callq 0xb9a0
movq -0x200(%rbp), %rdi
movq %rax, %rsi
callq 0x33da0
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
movq -0x188(%rbp), %rdi
callq 0xb920
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x98(%rbp)
leaq 0x74b5f(%rip), %rax     # 0xac560
movq %rax, (%rdi)
leaq 0x74bb5(%rip), %rax     # 0xac5c0
movq %rax, 0x8(%rdi)
addq $0x1a8, %rdi            # imm = 0x1A8
callq 0x37d10
movq -0x98(%rbp), %rdi
movq %rax, -0x90(%rbp)
movq %rdi, %rax
addq $0x10, %rax
movq %rax, -0x88(%rbp)
movq %rdi, %rax
addq $0x178, %rax            # imm = 0x178
movq %rax, -0x80(%rbp)
movq (%rdi), %rax
movq 0x48(%rax), %rax
callq *%rax
movb %al, -0x71(%rbp)
jmp 0x37a52
movq -0x80(%rbp), %rdx
movq -0x88(%rbp), %rsi
movb -0x71(%rbp), %al
movzbl %al, %ecx
andl $0x1, %ecx
leaq -0x68(%rbp), %rdi
callq 0x3efa0
jmp 0x37a71
movq -0x90(%rbp), %rdi
movq (%rdi), %rax
movq 0x78(%rax), %rax
leaq -0x68(%rbp), %rsi
callq *%rax
jmp 0x37a87
leaq -0x68(%rbp), %rdi
callq 0x123a0
movq -0x98(%rbp), %rax
movq 0x30(%rax), %rdi
movq 0x1c8(%rax), %rsi
movq (%rdi), %rax
movq 0x40(%rax), %rax
callq *%rax
jmp 0x37aad
movq -0x98(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0xa0(%rbp)
xorl %eax, %eax
movl %eax, %esi
leaq -0x70(%rbp), %rdi
callq 0x1cbb0
jmp 0x37ace
movq -0xa0(%rbp), %rdi
movq (%rdi), %rax
movq 0x48(%rax), %rax
leaq -0x70(%rbp), %rsi
callq *%rax
jmp 0x37ae4
leaq -0x70(%rbp), %rdi
callq 0x14930
movq -0x98(%rbp), %rax
movq 0x30(%rax), %rdi
movq 0x1d0(%rax), %rsi
movq (%rdi), %rax
movq 0x38(%rax), %rax
callq *%rax
jmp 0x37b0a
movq -0x98(%rbp), %rsi
movq 0x30(%rsi), %rdi
addq $0x1d8, %rsi            # imm = 0x1D8
movq (%rdi), %rax
movq 0x48(%rax), %rax
callq *%rax
jmp 0x37b27
movq -0x98(%rbp), %rdi
addq $0x250, %rdi            # imm = 0x250
callq 0x37d30
movq -0x98(%rbp), %rdi
addq $0x1e0, %rdi            # imm = 0x1E0
callq 0x13930
movq -0x98(%rbp), %rdi
addq $0x1d8, %rdi            # imm = 0x1D8
callq 0x14930
movq -0x98(%rbp), %rdi
addq $0x1b0, %rdi            # imm = 0x1B0
callq 0x15520
movq -0x98(%rbp), %rdi
addq $0x1a8, %rdi            # imm = 0x1A8
callq 0x33d20
movq -0x98(%rbp), %rdi
addq $0x170, %rdi            # imm = 0x170
callq 0x14930
movq -0x98(%rbp), %rdi
addq $0xb8, %rdi
callq 0xd570
movq -0x98(%rbp), %rdi
addq $0x40, %rdi
callq 0x37d90
movq -0x98(%rbp), %rdi
addq $0x10, %rdi
callq 0x155a0
movq -0x98(%rbp), %rdi
addq $0x8, %rdi
callq 0x126a0
movq -0x98(%rbp), %rdi
callq 0x12040
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x13830
nopl (%rax)