LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %r14
movq 0x10(%rdi), %rax
movq %rax, 0x68(%rdi)
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x2c1ab(%rip), %rsi     # 0x3e380
leaq 0x2c1a9(%rip), %rdx     # 0x3e385
movq %rsp, %rdi
callq 0x2ace6
leaq 0x28(%r14), %rbx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x255a6
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x12209
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x9330
movq 0x18(%r14), %r15
testq %r15, %r15
je 0x1221b
movq (%r15), %rax
movq %r15, %rdi
callq *0x10(%rax)
movq (%r15), %rax
movq %rsp, %rdi
movq %r15, %rsi
callq *0x30(%rax)
movq (%rsp), %rdi
movq 0x8(%rsp), %r13
cmpq %r12, %rdi
je 0x12242
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x9330
movq (%r15), %rax
movq %r15, %rdi
callq *0x18(%rax)
testq %r13, %r13
je 0x122d7
movq %rsp, %rdi
movq %r12, (%rdi)
leaq 0x2b90b(%rip), %rsi     # 0x3db6c
leaq 0x2b908(%rip), %rdx     # 0x3db70
callq 0x2ace6
movq 0x18(%r14), %r14
testq %r14, %r14
je 0x1227f
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq (%r14), %rax
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq *0x30(%rax)
movq %rsp, %rsi
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
callq 0x25658
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x122b8
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x9330
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x122d7
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x9330
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x12333
jmp 0x1232b
movq %rax, %rbx
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1230c
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x9330
jmp 0x1230c
movq %rax, %rbx
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
jmp 0x12336
jmp 0x1232b
jmp 0x1234e
jmp 0x1232b
movq %rax, %rbx
movq (%r15), %rax
movq %r15, %rdi
callq *0x18(%rax)
jmp 0x12351
movq %rax, %rdi
callq 0xffa7
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x12351
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x9330
jmp 0x12351
movq %rax, %rbx
movq %rbx, %rdi
callq 0x95c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x28, %rbx
leaq 0x78(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x2c019(%rip), %rsi     # 0x3e39f
leaq 0x2c020(%rip), %rdx     # 0x3e3ad
leaq 0x68(%rsp), %r15
movq %r15, %rdi
callq 0x2ace6
movq %rbx, (%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x255a6
leaq 0x58(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2bff5(%rip), %rsi     # 0x3e3ae
leaq 0x2bff7(%rip), %rdx     # 0x3e3b7
leaq 0x48(%rsp), %rdi
callq 0x2ace6
movq (%rsp), %rdi
leaq 0x48(%rsp), %rsi
movq %r14, %rdx
callq 0x258de
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x2b7cf(%rip), %rsi     # 0x3dbba
leaq 0x2b7d0(%rip), %rdx     # 0x3dbc2
leaq 0x28(%rsp), %rdi
callq 0x2ace6
leaq 0x8(%r14), %rdx
movq (%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x258de
leaq 0x18(%rsp), %rbp
movq %rbp, -0x10(%rbp)
leaq 0x2bf9a(%rip), %rsi     # 0x3e3b8
leaq 0x2bfa3(%rip), %rdx     # 0x3e3c8
leaq 0x8(%rsp), %rdi
callq 0x2ace6
addq $0x10, %r14
movq (%rsp), %rdi
leaq 0x8(%rsp), %rsi
movq %r14, %rdx
callq 0x258de
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x1245b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x9330
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x12472
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x9330
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x12489
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x9330
movq %rsp, %rdi
callq 0x258c6
movq 0x68(%rsp), %rdi
cmpq %r12, %rdi
je 0x124a8
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x9330
movq %rbx, %rdi
callq 0x158a4
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x124e3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x9330
jmp 0x124e3
jmp 0x124e0
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x12501
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x9330
jmp 0x12501
jmp 0x124fe
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x1251f
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x9330
jmp 0x1251f
jmp 0x1251c
movq %rax, %rbx
movq %rsp, %rdi
callq 0x258c6
movq 0x68(%rsp), %rdi
cmpq %r12, %rdi
je 0x1253e
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x9330
movq %rbx, %rdi
callq 0x95c0
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r14
movq %rdi, %rbx
addq $0x28, %rbx
leaq 0x78(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x2bd39(%rip), %rsi     # 0x3e39f
leaq 0x2bd40(%rip), %rdx     # 0x3e3ad
leaq 0x68(%rsp), %r15
movq %r15, %rdi
callq 0x2ace6
movq %rbx, (%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x255a6
leaq 0x58(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2bd15(%rip), %rsi     # 0x3e3ae
leaq 0x2bd17(%rip), %rdx     # 0x3e3b7
leaq 0x48(%rsp), %rdi
callq 0x2ace6
movq (%rsp), %rdi
leaq 0x48(%rsp), %rsi
movq %r14, %rdx
callq 0x258de
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x2b4ef(%rip), %rsi     # 0x3dbba
leaq 0x2b4f0(%rip), %rdx     # 0x3dbc2
leaq 0x28(%rsp), %rdi
callq 0x2ace6
leaq 0x8(%r14), %rdx
movq (%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x258de
leaq 0x18(%rsp), %rbp
movq %rbp, -0x10(%rbp)
leaq 0x2bcba(%rip), %rsi     # 0x3e3b8
leaq 0x2bcc3(%rip), %rdx     # 0x3e3c8
leaq 0x8(%rsp), %rdi
callq 0x2ace6
addq $0x10, %r14
movq (%rsp), %rdi
leaq 0x8(%rsp), %rsi
movq %r14, %rdx
callq 0x258de
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x1273b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x9330
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x12752
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x9330
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x12769
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x9330
movq %rsp, %rdi
callq 0x258c6
movq 0x68(%rsp), %rdi
cmpq %r12, %rdi
je 0x12788
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x9330
movq %rbx, %rdi
callq 0x158a4
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x127c3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x9330
jmp 0x127c3
jmp 0x127c0
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x127e1
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x9330
jmp 0x127e1
jmp 0x127de
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x127ff
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x9330
jmp 0x127ff
jmp 0x127fc
movq %rax, %rbx
movq %rsp, %rdi
callq 0x258c6
movq 0x68(%rsp), %rdi
cmpq %r12, %rdi
je 0x1281e
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x9330
movq %rbx, %rdi
callq 0x95c0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x80, %rsp
movl 0x70(%rdi), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x70(%rdi)
testl %eax, %eax
jle 0x12b9e
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x70(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x2b8d0(%rip), %rsi     # 0x3e378
leaq 0x2b8d0(%rip), %rdx     # 0x3e37f
leaq 0x60(%rsp), %r12
movq %r12, %rdi
callq 0x2ace6
addq $0x28, %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x255a6
movq %rax, %r15
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x2b08d(%rip), %rsi     # 0x3db6c
leaq 0x2b08a(%rip), %rdx     # 0x3db70
leaq 0x20(%rsp), %rdi
callq 0x2ace6
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
callq 0xc95f
leaq 0x20(%rsp), %rsi
leaq 0x40(%rsp), %rdx
movq %r15, %rdi
callq 0x25658
movq %rax, %r14
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2b8c4(%rip), %rsi     # 0x3e3e6
leaq 0x2b8c8(%rip), %rdx     # 0x3e3f1
movq %rsp, %rdi
callq 0x2ace6
movq %rsp, %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x25658
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x12b55
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x9330
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x12b70
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x9330
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x12b87
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x9330
movq 0x60(%rsp), %rdi
cmpq %r13, %rdi
je 0x12b9e
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x9330
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x12bcf
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x9330
jmp 0x12bcf
jmp 0x12bcc
movq %rax, %rbx
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x12bef
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x9330
jmp 0x12bef
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x12c0d
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x9330
jmp 0x12c0d
jmp 0x12c0a
movq %rax, %rbx
movq 0x60(%rsp), %rdi
cmpq %r13, %rdi
je 0x12c24
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x9330
movq %rbx, %rdi
callq 0x95c0
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl 0x70(%rdi), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x70(%rdi)
cmpl $0x2, %eax
jl 0x12d94
movq %rdx, %r14
movq %rdi, %rbx
addq $0x28, %rbx
leaq 0x78(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x2b735(%rip), %rsi     # 0x3e39f
leaq 0x2b73c(%rip), %rdx     # 0x3e3ad
leaq 0x68(%rsp), %r15
movq %r15, %rdi
callq 0x2ace6
movq %rbx, (%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x255a6
leaq 0x58(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2b711(%rip), %rsi     # 0x3e3ae
leaq 0x2b713(%rip), %rdx     # 0x3e3b7
leaq 0x48(%rsp), %rdi
callq 0x2ace6
movq (%rsp), %rdi
leaq 0x48(%rsp), %rsi
movq %r14, %rdx
callq 0x258de
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x2aeeb(%rip), %rsi     # 0x3dbba
leaq 0x2aeec(%rip), %rdx     # 0x3dbc2
leaq 0x28(%rsp), %rdi
callq 0x2ace6
leaq 0x8(%r14), %rdx
movq (%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x258de
leaq 0x18(%rsp), %rbp
movq %rbp, -0x10(%rbp)
leaq 0x2b6b6(%rip), %rsi     # 0x3e3b8
leaq 0x2b6bf(%rip), %rdx     # 0x3e3c8
leaq 0x8(%rsp), %rdi
callq 0x2ace6
addq $0x10, %r14
movq (%rsp), %rdi
leaq 0x8(%rsp), %rsi
movq %r14, %rdx
callq 0x258de
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x12d3f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x9330
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x12d56
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x9330
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x12d6d
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x9330
movq %rsp, %rdi
callq 0x258c6
movq 0x68(%rsp), %rdi
cmpq %r12, %rdi
je 0x12d8c
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x9330
movq %rbx, %rdi
callq 0x158a4
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x12dc7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x9330
jmp 0x12dc7
jmp 0x12dc4
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x12de5
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x9330
jmp 0x12de5
jmp 0x12de2
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0x12e03
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x9330
jmp 0x12e03
jmp 0x12e00
movq %rax, %rbx
movq %rsp, %rdi
callq 0x258c6
movq 0x68(%rsp), %rdi
cmpq %r12, %rdi
je 0x12e22
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x9330
movq %rbx, %rdi
callq 0x95c0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x94f0
imulq $0xf4240, (%r14), %rax  # imm = 0xF4240
addq 0x8(%r14), %rax
movq %rax, 0x108(%rbx)
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x2acae(%rip), %rdx     # 0x3e56b
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x2ace6
leaq 0x118(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x9480
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x138f2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x9330
leaq 0x8(%rsp), %rdi
movq %r14, (%rdi)
leaq 0x2ac6a(%rip), %rdx     # 0x3e56b
movq %rdx, %rsi
callq 0x2ace6
leaq 0x290(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x9480
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x13931
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x9330
movl $0x0, 0x400(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0x13947
jmp 0x13963
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x13966
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x9330
jmp 0x13966
movq %rax, %rbx
movq %rbx, %rdi
callq 0x95c0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x290be
movq %r14, %rdi
movq %r15, %rsi
callq 0x280e4
movq 0x18(%r14), %r15
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x92f0
movsbl %al, %esi
movq %r15, %rdi
callq 0x9030
movq %rax, %rdi
callq 0x9210
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x11a56
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rdi, %rbx
addq $0x8, %rdi
callq 0x142b8
addq $0x10, %rbx
cmpq %rbx, %rax
je 0x14207
movq 0x40(%rax), %rbx
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movq %rax, 0x8(%rsp)
movq (%r14), %rdi
movq %rdi, 0x10(%rsp)
testq %rdi, %rdi
je 0x141e4
movq (%rdi), %rax
callq *0x10(%rax)
movq (%rbx), %rax
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq *0x10(%rax)
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x14209
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x14209
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
jmp 0x14231
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x14229
movq (%rdi), %rax
callq *0x18(%rax)
movq %rbx, %rdi
callq 0x95c0
movq %rax, %rdi
callq 0xffa7
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x9450
jmp 0x14471
movq %rdx, %r15
movq %rax, %rdi
cmpl $0x5, %r15d
je 0x14467
cmpl $0x4, %r15d
jne 0x14403
callq 0x9130
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
leaq 0xe(%rsp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0xfeba
jmp 0x14455
cmpl $0x3, %r15d
jne 0x14429
callq 0x9130
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x2ac50
jmp 0x14455
callq 0x9130
cmpl $0x2, %r15d
jne 0x14446
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0xfeba
jmp 0x14455
movq 0x8(%r14), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x144dc
callq 0x9540
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x9130
callq 0x9450
movq %rax, %rbx
callq 0x9540
jmp 0x144a1
movq %rax, %rbx
callq 0x9540
jmp 0x144a1
movq %rax, %rbx
callq 0x9540
jmp 0x144a1
movq %rax, %rbx
callq 0x9540
jmp 0x144a1
movq %rax, %rbx
callq 0x9540
movq %rbx, %rdi
callq 0x95c0
movq %rax, %rdi
callq 0xffa7
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movq %rdi, %rbx
cmpq %rdx, 0x10(%rsi)
je 0x144fe
movq %rdx, %r14
movq %rsi, %r15
movq (%rdx), %rsi
movq (%rsi), %rax
movq %rbx, %rdi
callq *0x10(%rax)
jmp 0x1451b
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x2939c(%rip), %rsi     # 0x3d8a8
leaq 0x293a6(%rip), %rdx     # 0x3d8b9
movq %rbx, %rdi
callq 0x2ace6
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rdi
callq 0x9130
addq $0x8, %r14
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x144dc
callq 0x9540
jmp 0x1451b
movq %rax, %rbx
callq 0x9540
movq %rbx, %rdi
callq 0x95c0
movq %rax, %rdi
callq 0xffa7
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x14c06
addq $0x28, %rbx
cmpq %rbx, %rax
je 0x14bb8
movq 0x40(%rax), %rbx
jmp 0x14bba
xorl %ebx, %ebx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x14bd5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x9330
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x14bfe
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x9330
movq %rbx, %rdi
callq 0x95c0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
cmpq $0x0, 0x50(%rdi)
jne 0x17572
movq %rdi, %rbx
movl $0xa8, %edi
callq 0x9310
xorl %ecx, %ecx
movq %rcx, (%rax)
leaq 0x18(%rax), %rdx
movq %rdx, 0x8(%rax)
movq %rcx, 0x10(%rax)
movb %cl, 0x18(%rax)
leaq 0x38(%rax), %rdx
movq %rdx, 0x28(%rax)
movq %rcx, 0x30(%rax)
movb %cl, 0x38(%rax)
leaq 0x58(%rax), %rdx
movq %rdx, 0x48(%rax)
movq %rcx, 0x50(%rax)
movb %cl, 0x58(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x68(%rax)
movq %rcx, 0x78(%rax)
leaq 0x90(%rax), %rdx
movq %rdx, 0x80(%rax)
movq %rcx, 0x88(%rax)
movb %cl, 0x90(%rax)
movl $0xffffffff, 0xa0(%rax) # imm = 0xFFFFFFFF
movq %rax, 0x50(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x9160
movq %rax, %rbx
leaq 0x268b3(%rip), %rsi     # 0x3de39
movq %rax, %rdi
callq 0x9430
movq 0x3ea3b(%rip), %rsi     # 0x55fd0
movq 0x3ea1c(%rip), %rdx     # 0x55fb8
movq %rbx, %rdi
callq 0x9580
movq %rax, %r14
movq %rbx, %rdi
callq 0x9270
movq %r14, %rdi
callq 0x95c0
// File: /workspace/github_cpp_makefile_star2_O3/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::Clara::Detail::BoundBinaryFunction<Catch::ConfigData, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>::setFlag(Catch::ConfigData&) 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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
movl $0x10, %edi
callq 0x9160
movq %rax, %r14
leaq 0x24c9e(%rip), %rsi     # 0x3dce0
movq %rax, %rdi
callq 0x9110
movq 0x3cf9f(%rip), %rsi     # 0x55ff0
movq 0x3cf50(%rip), %rdx     # 0x55fa8
movq %r14, %rdi
callq 0x9580
movq %rax, %rbx
jmp 0x19070
movq %rax, %rbx
movq %r14, %rdi
callq 0x9270
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x19086
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x9330
movq %rbx, %rdi
callq 0x95c0
// File: /workspace/github_cpp_makefile_star2_O3/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 %ebx, %ebx
cmpb $0x0, 0x7f(%rdi)
jne 0x19866
movq %rdi, %r14
callq 0x1c8a2
leaq 0x130(%r14), %rsi
leaq 0x38(%rsp), %rdi
callq 0x1c904
movq %r14, %rdi
callq 0x1c8a2
movq %rax, %rbx
movq $0x0, 0x8(%rsp)
cmpb $0x1, 0x10(%rax)
jne 0x1979c
movq %rbx, %rdi
callq 0x1e604
movq %rax, %r14
leaq 0x10(%rsp), %rax
movq %r14, (%rax)
movq %rax, -0x8(%rax)
cmpb $0x0, 0x13(%rbx)
jne 0x197a5
jmp 0x197bc
cmpb $0x1, 0x13(%rbx)
jne 0x197c4
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x1ec75
addq %rax, %r14
leaq 0x10(%rsp), %rax
movq %r14, (%rax)
movq %rax, -0x8(%rax)
cmpb $0x0, 0x11(%rbx)
jne 0x197d1
jmp 0x197e8
cmpb $0x1, 0x11(%rbx)
jne 0x19873
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x1eede
addq %rax, %r14
leaq 0x10(%rsp), %rax
movq %r14, (%rax)
movq %rax, -0x8(%rax)
cmpb $0x0, 0x12(%rbx)
je 0x197fe
movq %rbx, %rdi
callq 0x1f85f
addq %r14, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rbx
leaq 0x248(%rsp), %r14
movq %r14, %rdi
callq 0x15a4a
movq -0x8(%r14), %rdi
testq %rdi, %rdi
je 0x19822
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x3c76f(%rip), %rax     # 0x55f98
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x48(%rsp), %r14
movq %rcx, -0x8(%r14)
movq -0x18(%rcx), %rcx
movq %rax, 0x40(%rsp,%rcx)
movq %r14, %rdi
callq 0x92b0
leaq 0x138(%rsp), %rdi
callq 0x90f0
movq -0x10(%r14), %rdi
testq %rdi, %rdi
je 0x19866
movq (%rdi), %rax
callq *0x18(%rax)
movl %ebx, %eax
addq $0x278, %rsp            # imm = 0x278
popq %rbx
popq %r14
retq
cmpb $0x1, 0x12(%rbx)
jne 0x19881
xorl %r14d, %r14d
jmp 0x197ee
leaq 0x8(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x1c9d0
jmp 0x197fe
jmp 0x198a9
jmp 0x198a9
jmp 0x198a9
jmp 0x198a9
jmp 0x198a9
jmp 0x198a1
movq %rax, %rdi
callq 0xffa7
movq %rdx, %r14
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x1ce44
jmp 0x198c3
jmp 0x198bd
movq %rdx, %r14
movq %rax, %rbx
cmpl $0x1, %r14d
jne 0x19908
movq %rbx, %rdi
callq 0x9130
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq 0x3c707(%rip), %rdi     # 0x55fe8
movq %rax, %rsi
callq 0x9300
movq %rax, %rdi
callq 0x9150
callq 0x9540
movl $0x7fffffff, %ebx       # imm = 0x7FFFFFFF
jmp 0x19866
movq %rax, %rbx
callq 0x9540
movq %rbx, %rdi
callq 0x95c0
jmp 0x198a1
// File: /workspace/github_cpp_makefile_star2_O3/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 0x20(%rsp), %r13
movq %rsp, %rdx
movq %r13, %rdi
callq 0xfeba
leaq 0x24553(%rip), %rsi     # 0x3de9b
movl $0x2, %ecx
movq %r13, %rdi
movq $-0x1, %rdx
callq 0x9670
cmpq $-0x1, %rax
je 0x199a7
incq %rax
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
movq %rax, %rdx
movq $-0x1, %rcx
callq 0x9360
leaq 0x20(%rsp), %rdi
movq %rsp, %r13
movq %r13, %rsi
callq 0x93e0
movq (%r13), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x199a7
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x9330
movq (%r15), %rdi
movq (%rdi), %rax
leaq 0x20(%rsp), %rdx
movq %r14, %rsi
callq *0x10(%rax)
xorps %xmm0, %xmm0
leaq 0x40(%rsp), %rcx
movaps %xmm0, (%rcx)
movq $0x0, 0x10(%rcx)
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movl $0x3a3d0920, (%r13)     # imm = 0x3A3D0920
movq $0x4, -0x8(%r13)
movb $0x0, 0x4(%r13)
movq %rsp, %rdi
movl %ebp, %esi
movq %r12, %rdx
callq 0x1a30e
leaq 0x40(%rsp), %rdx
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rcx
callq 0x1a422
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x19a1f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x9330
leaq 0x40(%rsp), %rdi
callq 0x16e06
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x19a44
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x9330
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x19a58
movq %rax, %rbx
jmp 0x19a80
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x19a76
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x9330
leaq 0x40(%rsp), %rdi
callq 0x16e06
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x19a9b
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x9330
movq %rbx, %rdi
callq 0x95c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, (%rsp)
movq %rdi, %r15
movq 0x3c500(%rip), %rbx     # 0x55fc0
leaq 0x2445a(%rip), %rsi     # 0x3df21
movl $0x8, %edx
movq %rbx, %rdi
callq 0x9390
movl 0x3c8ce(%rip), %esi     # 0x563a8
movq %rbx, %rdi
callq 0x9200
movq %rax, %r12
leaq 0x24d1b(%rip), %rsi     # 0x3e807
movl $0x1, %edx
movq %rax, %rdi
callq 0x9390
movl 0x3c8ad(%rip), %esi     # 0x563ac
movq %r12, %rdi
callq 0x9200
movq %rax, %r12
leaq 0x24419(%rip), %rsi     # 0x3df2a
movl $0x7, %edx
movq %rax, %rdi
callq 0x9390
movl 0x3c88c(%rip), %esi     # 0x563b0
movq %r12, %rdi
callq 0x9200
movq 0x3c885(%rip), %r12     # 0x563b8
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x23bc2(%rip), %rsi     # 0x3d705
leaq 0x23bc1(%rip), %rdx     # 0x3d70b
leaq 0x8(%rsp), %r13
movq %r13, %rdi
callq 0x2ace6
movq %r13, %rdi
movq %r12, %rsi
callq 0x90d0
movl %eax, %ebp
movq (%r13), %rdi
cmpq %r14, %rdi
je 0x19b7a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x9330
testl %ebp, %ebp
je 0x19bf2
movq 0x3c43b(%rip), %r12     # 0x55fc0
leaq 0x24374(%rip), %rsi     # 0x3df00
movl $0x2, %edx
movq %r12, %rdi
callq 0x9390
movq 0x3c818(%rip), %r13     # 0x563b8
testq %r13, %r13
je 0x19bc1
movq %r13, %rdi
callq 0x9140
movq 0x3c40c(%rip), %rdi     # 0x55fc0
movq %r13, %rsi
movq %rax, %rdx
callq 0x9390
jmp 0x19bda
movq (%r12), %rax
movq -0x18(%rax), %rax
leaq (%r12,%rax), %rdi
movl 0x20(%r12,%rax), %esi
orl $0x1, %esi
callq 0x9560
movq 0x3c3df(%rip), %rdi     # 0x55fc0
leaq 0x2434a(%rip), %rsi     # 0x3df32
movl $0x8, %edx
callq 0x9390
leaq 0x24971(%rip), %rsi     # 0x3e56a
movl $0x1, %edx
movq %rbx, %rdi
callq 0x9390
movq %r15, %rdi
movq %rbx, %rsi
movq (%rsp), %rdx
callq 0x1a26c
leaq 0x2431f(%rip), %rsi     # 0x3df3b
movl $0x32, %edx
movq %rbx, %rdi
callq 0x9390
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x92f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x9030
movq %rax, %rdi
callq 0x9210
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::Config::Config(Catch::ConfigData const&)
Config( ConfigData const& data )
        :   m_data( data ),
            m_os( std::cout.rdbuf() )
        {
            if( !data.testsOrTags.empty() ) {
                TestSpecParser parser( ITagAliasRegistry::get() );
                for( std::size_t i = 0; i < data.testsOrTags.size(); ++i )
                    parser.parse( data.testsOrTags[i] );
                m_testSpec = parser.testSpec();
            }
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rsi, %r15
movq %rdi, %r14
movl $0x0, 0x8(%rdi)
leaq 0x378a3(%rip), %rax     # 0x54778
movq %rax, (%rdi)
leaq 0x10(%rdi), %rbx
movq %rbx, %rdi
callq 0x1d100
movq $0x0, 0xc8(%r14)
movb $0x0, 0xd0(%r14)
leaq 0xd8(%r14), %rdi
movq 0x390bb(%rip), %rax     # 0x55fc0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq 0xe8(%rax,%rcx), %rsi
callq 0x9120
xorps %xmm0, %xmm0
movups %xmm0, 0x1e8(%r14)
movq $0x0, 0x1f8(%r14)
movq 0xa0(%r15), %rax
cmpq 0xa8(%r15), %rax
je 0x1d069
movq %rbx, 0x8(%rsp)
callq 0xf1b4
leaq 0x58(%rsp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r13)
movups %xmm0, 0x20(%r13)
movups %xmm0, 0x30(%r13)
leaq 0x3944c(%rip), %rax     # 0x563c8
movq %rax, 0x40(%r13)
movq 0xa0(%r15), %rsi
cmpq %rsi, 0xa8(%r15)
je 0x1cfc5
xorl %ebp, %ebp
leaq 0x30(%rsp), %r12
xorl %ebx, %ebx
addq %rbp, %rsi
movq %r12, %rdi
callq 0x1d26e
incq %rbx
movq 0xa0(%r15), %rsi
movq 0xa8(%r15), %rax
subq %rsi, %rax
sarq $0x5, %rax
addq $0x20, %rbp
cmpq %rax, %rbx
jb 0x1cf99
leaq 0x30(%rsp), %rdi
callq 0x1d692
leaq 0x80(%rsp), %r15
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x1e0b2
leaq 0x68(%rsp), %rbx
movq 0x1f8(%r14), %rax
leaq 0x10(%rsp), %r12
movaps (%r12), %xmm0
movq 0x10(%r12), %rcx
movq %rcx, 0x1f8(%r14)
movups 0x1e8(%r14), %xmm1
movups %xmm0, 0x1e8(%r14)
leaq 0xa0(%rsp), %rdi
movaps %xmm1, (%rdi)
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movaps %xmm0, (%r12)
movq $0x0, 0x10(%r12)
callq 0x1e1d2
movq %r12, %rdi
callq 0x1e1d2
movq %r15, %rdi
callq 0x1e1d2
movq %rbx, %rdi
callq 0x1dc8c
movq -0x20(%rbx), %rdi
cmpq %r13, %rdi
je 0x1d069
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x9330
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, 0x8(%rsp)
movq %rax, %r15
jmp 0x1d0b2
jmp 0x1d087
movq %rax, %r15
leaq 0x1e8(%r14), %r12
leaq 0x30(%rsp), %rdi
callq 0x1d310
movq %r12, %rdi
callq 0x1e1d2
addq $0xe0, %r14
movq %r14, %rdi
callq 0x90f0
movq 0x8(%rsp), %rdi
callq 0x16d8c
movq %r15, %rdi
callq 0x95c0
// File: /workspace/github_cpp_makefile_star2_O3/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::TestSpec::NamePattern::NamePattern(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
NamePattern( std::string const& name ) : m_name( toLower( name ) ), m_wildcard( NoWildcard ) {
                if( startsWith( m_name, "*" ) ) {
                    m_name = m_name.substr( 1 );
                    m_wildcard = WildcardAtStart;
                }
                if( endsWith( m_name, "*" ) ) {
                    m_name = m_name.substr( 0, m_name.size()-1 );
                    m_wildcard = static_cast<WildcardPosition>( m_wildcard | WildcardAtEnd );
                }
            }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
xorl %ebp, %ebp
movl %ebp, 0x8(%rdi)
leaq 0x36511(%rip), %rax     # 0x54458
movq %rax, (%rdi)
leaq 0x10(%rdi), %r14
movq %r14, %rdi
callq 0xba07
movl %ebp, 0x30(%rbx)
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x2071a(%rip), %rsi     # 0x3e684
leaq 0x20714(%rip), %rdx     # 0x3e685
movq %rsp, %rdi
callq 0x2ace6
movq %rsp, %rsi
movq %r14, %rdi
callq 0xb564
movl %eax, %ebp
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x1df9c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x9330
testb %bpl, %bpl
je 0x1dfe2
movq %rsp, %rdi
movl $0x1, %edx
movq %r14, %rsi
movq $-0x1, %rcx
callq 0x9360
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x93e0
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x1dfdb
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x9330
movl $0x1, 0x30(%rbx)
movq %rsp, %rdi
movq %r12, (%rdi)
leaq 0x20695(%rip), %rsi     # 0x3e684
leaq 0x2068f(%rip), %rdx     # 0x3e685
callq 0x2ace6
movq %rsp, %rsi
movq %r14, %rdi
callq 0xc894
movl %eax, %ebp
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x1e01e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x9330
testb %bpl, %bpl
je 0x1e05e
movq 0x18(%rbx), %rcx
decq %rcx
movq %rsp, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x9360
movq %rsp, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x93e0
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x1e05a
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x9330
orb $0x2, 0x30(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1e08e
jmp 0x1e08e
jmp 0x1e073
jmp 0x1e08e
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x1e091
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x9330
jmp 0x1e091
movq %rax, %r14
movq 0x10(%rbx), %rdi
addq $0x20, %rbx
cmpq %rbx, %rdi
je 0x1e0a9
movq (%rbx), %rsi
incq %rsi
callq 0x9330
movq %r14, %rdi
callq 0x95c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq 0x34f0c(%rip), %rax     # 0x55830
movq %rax, (%rdi)
leaq 0x34f62(%rip), %rax     # 0x55890
movq %rax, 0x8(%rdi)
movq 0x1a8(%rdi), %r14
movq 0x170(%rdi), %rdi
movq 0x180(%rbx), %r13
movq (%rdi), %rax
callq *0x50(%rax)
movl %eax, %ebp
leaq 0x3381a(%rip), %r15     # 0x54170
leaq 0x10(%rsp), %rdi
movq %r15, -0x8(%rdi)
leaq 0x20(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rdx
addq %rsi, %rdx
callq 0x2ac50
movslq %ebp, %rax
cmpq %rax, %r13
movups 0x178(%rbx), %xmm0
movups 0x188(%rbx), %xmm1
movups 0x198(%rbx), %xmm2
leaq 0x8(%rsp), %rsi
movups %xmm2, 0x48(%rsi)
movups %xmm1, 0x38(%rsi)
movups %xmm0, 0x28(%rsi)
sete 0x58(%rsi)
movq (%r14), %rax
movq %r14, %rdi
callq *0x78(%rax)
movq %r15, 0x8(%rsp)
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x209ce
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x9330
movq 0x30(%rbx), %rdi
movq 0x1c8(%rbx), %rsi
movq (%rdi), %rax
callq *0x40(%rax)
movq 0x30(%rbx), %rdi
leaq 0x8(%rsp), %rsi
movq $0x0, (%rsi)
movq (%rdi), %rax
callq *0x48(%rax)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x20a05
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x30(%rbx), %rdi
movq 0x1d0(%rbx), %rsi
movq (%rdi), %rax
callq *0x38(%rax)
movq 0x30(%rbx), %rdi
leaq 0x1d8(%rbx), %r14
movq (%rdi), %rax
movq %r14, %rsi
callq *0x48(%rax)
leaq 0x250(%rbx), %rdi
callq 0x20b1a
movq 0x228(%rbx), %rdi
leaq 0x238(%rbx), %rax
cmpq %rax, %rdi
je 0x20a54
movq (%rax), %rsi
incq %rsi
callq 0x9330
movq 0x200(%rbx), %rdi
leaq 0x210(%rbx), %rax
cmpq %rax, %rdi
je 0x20a72
movq (%rax), %rsi
incq %rsi
callq 0x9330
movq 0x1e0(%rbx), %rdi
leaq 0x1f0(%rbx), %rax
cmpq %rax, %rdi
je 0x20a90
movq (%rax), %rsi
incq %rsi
callq 0x9330
movq (%r14), %rdi
testq %rdi, %rdi
je 0x20a9e
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0x1b0(%rbx), %rdi
callq 0x10952
movq 0x1a8(%rbx), %rdi
testq %rdi, %rdi
je 0x20abc
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x170(%rbx), %rdi
testq %rdi, %rdi
je 0x20ace
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0xb8(%rbx), %rdi
callq 0xb15a
leaq 0x40(%rbx), %rdi
callq 0x2123a
movq 0x10(%rbx), %rdi
addq $0x20, %rbx
cmpq %rbx, %rdi
je 0x20afb
movq (%rbx), %rsi
incq %rsi
callq 0x9330
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x20b12
jmp 0x20b12
jmp 0x20b12
jmp 0x20b12
movq %rax, %rdi
callq 0xffa7
// File: /workspace/github_cpp_makefile_star2_O3/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::RunContext::sectionStarted(Catch::SectionInfo const&, Catch::Counts&)
virtual bool sectionStarted (
            SectionInfo const& sectionInfo,
            Counts& assertions
        )
        {
            std::ostringstream oss;
            oss << sectionInfo.name << "@" << sectionInfo.lineInfo;

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

            m_lastAssertionInfo.lineInfo = sectionInfo.lineInfo;

            m_reporter->sectionStarting( sectionInfo );

            assertions = m_totals.assertions;

            return true;
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x20(%rsp), %r12
movq %r12, %rdi
callq 0x9400
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r12, %rdi
callq 0x9390
movq %rax, %r13
leaq 0x1ca0c(%rip), %rsi     # 0x3d818
movl $0x1, %edx
movq %rax, %rdi
callq 0x9390
leaq 0x40(%r15), %r12
movq %r13, %rdi
movq %r12, %rsi
callq 0xabbc
movq 0x40(%r14), %r13
leaq 0x28(%rsp), %rsi
movq %rsp, %rdi
callq 0x94d0
movq %rsp, %rsi
movq %r13, %rdi
callq 0x21eb0
movl %eax, %ebp
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x20e61
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x9330
testb %bpl, %bpl
je 0x20ea6
leaq 0x200(%r14), %rdi
movq %r12, %rsi
callq 0x9190
movq 0x60(%r15), %rax
movq %rax, 0x220(%r14)
movq 0x1a8(%r14), %rdi
movq (%rdi), %rax
movq %r15, %rsi
callq *0x48(%rax)
movq 0x188(%r14), %rax
movq %rax, 0x10(%rbx)
movups 0x178(%r14), %xmm0
movups %xmm0, (%rbx)
movq 0x35103(%rip), %rsi     # 0x55fb0
leaq 0x20(%rsp), %rdi
callq 0x9180
leaq 0x90(%rsp), %rdi
callq 0x90f0
movl %ebp, %eax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x20efd
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x9330
jmp 0x20efd
jmp 0x20efa
movq %rax, %rbx
movq 0x350ac(%rip), %rsi     # 0x55fb0
leaq 0x20(%rsp), %rdi
callq 0x9180
leaq 0x90(%rsp), %rdi
callq 0x90f0
movq %rbx, %rdi
callq 0x95c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::RunContext::sectionEnded(Catch::SectionInfo const&, Catch::Counts const&, double)
virtual void sectionEnded( SectionInfo const& info, Counts const& prevAssertions, double _durationInSeconds ) {
            if( std::uncaught_exception() ) {
                m_unfinishedSections.push_back( UnfinishedSections( info, prevAssertions, _durationInSeconds ) );
                return;
            }

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

            m_testCaseTracker->leaveSection();

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movsd %xmm0, (%rsp)
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
callq 0x9050
testb %al, %al
je 0x20fd4
addq $0x250, %rbx            # imm = 0x250
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
movsd (%rsp), %xmm0
callq 0x223f0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x226a0
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x20f95
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x9330
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x20fb0
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x9330
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x21068
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x9330
jmp 0x21068
movdqu 0x178(%rbx), %xmm0
movdqu (%r15), %xmm1
psubq %xmm1, %xmm0
leaq 0xa0(%rsp), %r12
movdqa %xmm0, (%r12)
movq 0x188(%rbx), %rax
subq 0x10(%r15), %rax
movq %rax, 0x10(%r12)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x224c8
movl %eax, %ebp
movq 0x40(%rbx), %rdi
callq 0x2251c
movq 0x1a8(%rbx), %r15
movzbl %bpl, %ecx
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rdx
movsd (%rsp), %xmm0
callq 0x22590
movq (%r15), %rax
movq %r15, %rdi
movq %r13, %rsi
callq *0x60(%rax)
leaq 0x8(%rsp), %rdi
callq 0xf366
movq 0x1b0(%rbx), %rsi
addq $0x1b0, %rbx            # imm = 0x1B0
movq %rbx, %rdi
callq 0x21e80
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0xf366
jmp 0x21096
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x211ec
movq %rbx, %rdi
callq 0x95c0
// File: /workspace/github_cpp_makefile_star2_O3/minimind[P]simple-graph/unittest/catch.hpp
// Function: Catch::SectionTracking::TestCaseTracker::enterSection(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool enterSection( std::string const& name ) {
            TrackedSection* child = m_currentSection->acquireChild( name );
            if( m_completedASectionThisRun || child->runState() == TrackedSection::Completed )
                return false;

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rsi, %r14
movq %rdi, %r12
leaq 0x28(%rdi), %r15
movq %r15, %rdi
callq 0x22082
movq %rax, %rbx
leaq 0x30(%r12), %rax
cmpq %rax, %rbx
je 0x21f22
addq $0x40, %rbx
movq %rbx, %rax
jmp 0x2200c
leaq 0x18(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r13
movq %r13, %rdi
callq 0x2ac50
xorl %eax, %eax
movl %eax, 0x20(%r13)
leaq 0x38(%rsp), %rcx
movl %eax, (%rcx)
movq %rax, 0x8(%rcx)
movq %rcx, 0x10(%rcx)
movq %rcx, 0x18(%rcx)
movq %rax, 0x20(%rcx)
movq %r12, 0x28(%rcx)
leaq 0x68(%rsp), %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x2236a
leaq 0x68(%rsp), %rsi
movq %r15, %rdi
callq 0x2210c
leaq 0xb0(%rsp), %r12
movq %r12, %rdi
callq 0x212c8
movq -0x28(%r12), %rdi
leaq 0x98(%rsp), %rax
cmpq %rax, %rdi
je 0x21fb2
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x9330
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x21fcd
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x9330
leaq 0x30(%rsp), %r12
movq %r12, %rdi
callq 0x212c8
movq -0x28(%r12), %rdi
cmpq %rbp, %rdi
je 0x21ff1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x9330
movq %r15, %rdi
movq %r14, %rsi
callq 0x22082
movq %rax, %rcx
leaq 0x40(%rax), %rdx
xorl %eax, %eax
cmpq %rbx, %rcx
cmovneq %rdx, %rax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x22042
jmp 0x22030
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x212a0
movq %rbx, %rdi
callq 0x95c0