LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::(anonymous namespace)::parseSpecialTag(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
TestCaseInfo::SpecialProperties parseSpecialTag( std::string const& tag ) {
            if( startsWith( tag, '.' ) ||
                tag == "!hide" )
                return TestCaseInfo::IsHidden;
            else if( tag == "!throws" )
                return TestCaseInfo::Throws;
            else if( tag == "!shouldfail" )
                return TestCaseInfo::ShouldFail;
            else if( tag == "!mayfail" )
                return TestCaseInfo::MayFail;
            else if( tag == "!nonportable" )
                return TestCaseInfo::NonPortable;
            else if( tag == "!benchmark" )
                return static_cast<TestCaseInfo::SpecialProperties>( TestCaseInfo::Benchmark | TestCaseInfo::IsHidden );
            else
                return TestCaseInfo::None;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
pushq $0x2
popq %r14
je 0x31a25
movq (%rbx), %rax
cmpb $0x2e, (%rax)
je 0x31a94
leaq 0x42cfb(%rip), %rsi     # 0x74727
movq %rbx, %rdi
callq 0x3f7fc
testb %al, %al
jne 0x31a94
leaq 0x4420f(%rip), %rsi     # 0x75c4e
movq %rbx, %rdi
callq 0x3f7fc
testb %al, %al
je 0x31a4f
pushq $0x10
jmp 0x31a92
leaq 0x44200(%rip), %rsi     # 0x75c56
movq %rbx, %rdi
callq 0x3f7fc
testb %al, %al
je 0x31a66
pushq $0x4
jmp 0x31a92
leaq 0x43293(%rip), %rsi     # 0x74d00
movq %rbx, %rdi
callq 0x3f7fc
testb %al, %al
je 0x31a7d
pushq $0x8
jmp 0x31a92
leaq 0x441de(%rip), %rsi     # 0x75c62
movq %rbx, %rdi
callq 0x3f7fc
testb %al, %al
je 0x31a9c
pushq $0x20
popq %r14
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x441cc(%rip), %rsi     # 0x75c6f
movq %rbx, %rdi
callq 0x3f7fc
xorl %ecx, %ecx
testb %al, %al
pushq $0x42
popq %r14
cmovel %ecx, %r14d
jmp 0x31a94
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::setTags(Catch::TestCaseInfo&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>)
void setTags( TestCaseInfo& testCaseInfo, std::vector<std::string> tags ) {
        std::sort(begin(tags), end(tags));
        tags.erase(std::unique(begin(tags), end(tags)), end(tags));
        testCaseInfo.lcaseTags.clear();

        for( auto const& tag : tags ) {
            std::string lcaseTag = toLower( tag );
            testCaseInfo.properties = static_cast<TestCaseInfo::SpecialProperties>( testCaseInfo.properties | parseSpecialTag( lcaseTag ) );
            testCaseInfo.lcaseTags.push_back( lcaseTag );
        }
        testCaseInfo.tags = std::move(tags);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rdi
movq 0x8(%rsi), %rsi
callq 0x59543
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
callq 0x59caa
movq 0x8(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3f37a
leaq 0x78(%r14), %rdi
movq %rdi, -0x38(%rbp)
callq 0x3f384
movq (%rbx), %r12
movq %rbx, -0x30(%rbp)
movq 0x8(%rbx), %rbx
leaq -0x58(%rbp), %r13
cmpq %rbx, %r12
je 0x31b56
movq %r13, %rdi
movq %r12, %rsi
callq 0x2ba6b
movl 0xa0(%r14), %r15d
movq %r13, %rdi
callq 0x31a08
orl %r15d, %eax
movl %eax, 0xa0(%r14)
movq -0x38(%rbp), %rdi
movq %r13, %rsi
callq 0x3f2ea
movq %r13, %rdi
callq 0x24ad8
addq $0x20, %r12
jmp 0x31b13
addq $0x60, %r14
movq %r14, %rdi
movq -0x30(%rbp), %rsi
callq 0x4a9a2
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x24ad8
movq %rbx, %rdi
callq 0x24950
nop
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::enforceNoDuplicateTestCases(std::vector<Catch::TestCase, std::allocator<Catch::TestCase>> const&)
void enforceNoDuplicateTestCases( std::vector<TestCase> const& functions ) {
        std::set<TestCase> seenFunctions;
        for( auto const& function : functions ) {
            auto prev = seenFunctions.insert( function );
            CATCH_ENFORCE( prev.second,
                    "error: TEST_CASE( \"" << function.name << "\" ) already defined.\n"
                    << "\tFirst seen at " << prev.first->getTestCaseInfo().lineInfo << "\n"
                    << "\tRedefined at " << function.getTestCaseInfo().lineInfo );
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
leaq -0x80(%rbp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
movq (%rdi), %rbx
movq 0x8(%rdi), %r12
leaq -0x88(%rbp), %r15
cmpq %r12, %rbx
je 0x32121
movq %r15, %rdi
movq %rbx, %rsi
callq 0x5ac56
testb $0x1, %dl
je 0x3213a
addq $0xb8, %rbx
jmp 0x32103
leaq -0x88(%rbp), %rdi
callq 0x480d4
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x38(%rbp), %rdi
callq 0x30e18
movq -0x28(%rbp), %rdi
leaq 0x425dc(%rip), %rsi     # 0x7472d
callq 0x24570
movq -0x28(%rbp), %rdi
movq %rbx, %rsi
callq 0x24510
movq -0x28(%rbp), %rdi
leaq 0x425d4(%rip), %rsi     # 0x74741
callq 0x24570
movq -0x28(%rbp), %rdi
leaq 0x425da(%rip), %rsi     # 0x74757
callq 0x24570
addq $0xb0, %r14
movq -0x28(%rbp), %rdi
movq %r14, %rsi
callq 0x2921b
movq -0x28(%rbp), %rdi
leaq 0x4b03e(%rip), %rsi     # 0x7d1de
callq 0x24570
movq -0x28(%rbp), %rdi
leaq 0x425b7(%rip), %rsi     # 0x74767
callq 0x24570
addq $0x90, %rbx
movq -0x28(%rbp), %rdi
movq %rbx, %rsi
callq 0x2921b
movq -0x28(%rbp), %rsi
addq $0x8, %rsi
leaq -0x58(%rbp), %rdi
callq 0x24830
leaq -0x58(%rbp), %rdi
callq 0x255ca
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x24ad8
jmp 0x321f3
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x30e5e
jmp 0x32203
jmp 0x32200
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x480d4
movq %rbx, %rdi
callq 0x24950
nop
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::TestRegistry::registerTest(Catch::TestCase const&)
void TestRegistry::registerTest( TestCase const& testCase ) {
        std::string name = testCase.getTestCaseInfo().name;
        if( name.empty() ) {
            ReusableStringStream rss;
            rss << "Anonymous test case " << ++m_unnamedCount;
            return registerTest( testCase.withName( rss.str() ) );
        }
        m_functions.push_back( testCase );
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x70(%rbp), %r15
movq %r15, %rdi
callq 0x24760
cmpq $0x0, 0x8(%r15)
je 0x32262
addq $0x8, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3f6f4
jmp 0x322de
leaq -0x30(%rbp), %rdi
callq 0x30e18
movq -0x20(%rbp), %rdi
leaq 0x42500(%rip), %rsi     # 0x74776
callq 0x24570
leaq 0x40(%rbx), %rsi
incq 0x40(%rbx)
leaq -0x30(%rbp), %rdi
callq 0x3e368
movq -0x20(%rbp), %rsi
addq $0x8, %rsi
leaq -0x50(%rbp), %rdi
callq 0x24830
leaq -0x128(%rbp), %rdi
leaq -0x50(%rbp), %rdx
movq %r14, %rsi
callq 0x31cc2
movq (%rbx), %rax
leaq -0x128(%rbp), %rsi
movq %rbx, %rdi
callq *0x20(%rax)
leaq -0x128(%rbp), %rdi
callq 0x3f4b6
leaq -0x50(%rbp), %rdi
callq 0x24ad8
leaq -0x30(%rbp), %rdi
callq 0x30e5e
leaq -0x70(%rbp), %rdi
callq 0x24ad8
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x128(%rbp), %rdi
callq 0x3f4b6
jmp 0x32309
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x24ad8
jmp 0x32320
jmp 0x3231d
jmp 0x32318
movq %rax, %rbx
jmp 0x32329
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x30e5e
leaq -0x70(%rbp), %rdi
callq 0x24ad8
movq %rbx, %rdi
callq 0x24950
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::TestRegistry::getAllTestsSorted(Catch::IConfig const&) const
std::vector<TestCase> const& TestRegistry::getAllTestsSorted( IConfig const& config ) const {
        if( m_sortedFunctions.empty() )
            enforceNoDuplicateTestCases( m_functions );

        if(  m_currentSortOrder != config.runOrder() || m_sortedFunctions.empty() ) {
            m_sortedFunctions = sortTests( config, m_functions );
            m_currentSortOrder = config.runOrder();
        }
        return m_sortedFunctions;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x28(%rdi), %rax
cmpq 0x30(%rdi), %rax
jne 0x3236c
leaq 0x8(%rbx), %rdi
callq 0x320cd
leaq 0x28(%rbx), %r15
movl 0x20(%rbx), %r12d
movq (%r14), %rax
movq %r14, %rdi
callq *0x80(%rax)
cmpl %eax, %r12d
jne 0x3238f
movq 0x28(%rbx), %rax
cmpq 0x30(%rbx), %rax
jne 0x323c4
leaq 0x8(%rbx), %rdx
leaq -0x38(%rbp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x31d48
movq %r15, %rdi
movq %r12, %rsi
callq 0x5ae80
movq %r12, %rdi
callq 0x3e31c
movq (%r14), %rax
movq %r14, %rdi
callq *0x80(%rax)
movl %eax, 0x20(%rbx)
movq %r15, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::extractClassName[abi:cxx11](Catch::StringRef const&)
std::string extractClassName( StringRef const& classOrQualifiedMethodName ) {
        std::string className(classOrQualifiedMethodName);
        if( startsWith( className, '&' ) )
        {
            std::size_t lastColons = className.rfind( "::" );
            std::size_t penultimateColons = className.rfind( "::", lastColons-1 );
            if( penultimateColons == std::string::npos )
                penultimateColons = 1;
            className = className.substr( penultimateColons, lastColons-penultimateColons );
        }
        return className;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0x3d4fc
cmpq $0x0, 0x8(%rbx)
je 0x32473
movq (%rbx), %rax
cmpb $0x26, (%rax)
jne 0x32473
leaq 0x4236c(%rip), %r14     # 0x7478b
pushq $-0x1
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x248c0
movq %rax, %r15
leaq -0x1(%rax), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x248c0
cmpq $-0x1, %rax
pushq $0x1
popq %rdx
cmovneq %rax, %rdx
subq %rdx, %r15
leaq -0x38(%rbp), %rdi
movq %rbx, %rsi
movq %r15, %rcx
callq 0x245e0
leaq -0x38(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x24690
movq %r14, %rdi
callq 0x24ad8
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x24ad8
movq %r14, %rdi
callq 0x24950
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::TestCaseTracking::TrackerBase::findChild(Catch::TestCaseTracking::NameAndLocation const&)
ITrackerPtr TrackerBase::findChild( NameAndLocation const& nameAndLocation ) {
        auto it = std::find_if( m_children.begin(), m_children.end(),
            [&nameAndLocation]( ITrackerPtr const& tracker ){
                return
                    tracker->nameAndLocation().location == nameAndLocation.location &&
                    tracker->nameAndLocation().name == nameAndLocation.name;
            } );
        return( it != m_children.end() )
            ? *it
            : nullptr;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, -0x38(%rbp)
movq 0x48(%rsi), %r15
movq %rsi, -0x30(%rbp)
movq 0x50(%rsi), %r14
leaq -0x40(%rbp), %r12
movq %rdx, (%r12)
movq %r14, -0x48(%rbp)
subq %r15, %r14
movq %r14, %rbx
sarq $0x6, %rbx
testq %rbx, %rbx
jle 0x32655
movq %r12, %rdi
movq %r15, %rsi
callq 0x3d3fe
testb %al, %al
jne 0x32689
leaq 0x10(%r15), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x3d3fe
testb %al, %al
jne 0x326b9
leaq 0x20(%r15), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x3d3fe
testb %al, %al
jne 0x326b9
leaq 0x30(%r15), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x3d3fe
testb %al, %al
jne 0x326b9
addq $0x40, %r15
decq %rbx
addq $-0x40, %r14
jmp 0x325ef
sarq $0x4, %r14
cmpq $0x1, %r14
je 0x326ab
cmpq $0x2, %r14
je 0x3268e
cmpq $0x3, %r14
jne 0x326b5
leaq -0x40(%rbp), %rdi
movq %r15, %rsi
callq 0x3d3fe
testb %al, %al
movq -0x38(%rbp), %rbx
movq -0x30(%rbp), %r14
jne 0x326a6
addq $0x10, %r15
jmp 0x32696
movq %r15, %r13
jmp 0x326b9
movq -0x38(%rbp), %rbx
movq -0x30(%rbp), %r14
leaq -0x40(%rbp), %rdi
movq %r15, %rsi
callq 0x3d3fe
testb %al, %al
je 0x326ec
movq %r15, %r13
jmp 0x326c1
movq -0x38(%rbp), %rbx
movq -0x30(%rbp), %r14
jmp 0x326f0
movq -0x48(%rbp), %r13
movq -0x38(%rbp), %rbx
movq -0x30(%rbp), %r14
cmpq 0x50(%r14), %r13
je 0x326d4
movq %rbx, %rdi
movq %r13, %rsi
callq 0x4816c
jmp 0x326da
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addq $0x10, %r15
leaq -0x40(%rbp), %rdi
movq %r15, %rsi
callq 0x3d3fe
testb %al, %al
movq -0x48(%rbp), %r13
cmovneq %r15, %r13
jmp 0x326c1
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::TestCaseTracking::TrackerBase::openChild()
void TrackerBase::openChild() {
        if( m_runState != ExecutingChildren ) {
            m_runState = ExecutingChildren;
            if( m_parent )
                m_parent->openChild();
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x2, 0x60(%rdi)
je 0x32757
movl $0x2, 0x60(%rdi)
movq 0x40(%rdi), %rdi
testq %rdi, %rdi
je 0x32757
movq (%rdi), %rax
popq %rbp
jmpq *0x68(%rax)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::TestCaseTracking::TrackerBase::open()
void TrackerBase::open() {
        m_runState = Executing;
        moveToThis();
        if( m_parent )
            m_parent->openChild();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x1, 0x60(%rdi)
movq 0x38(%rdi), %rax
movq %rdi, 0x10(%rax)
movq 0x40(%rdi), %rdi
testq %rdi, %rdi
je 0x3278d
movq (%rdi), %rax
popq %rbp
jmpq *0x68(%rax)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::TestCaseTracking::TrackerBase::fail()
void TrackerBase::fail() {
        m_runState = Failed;
        if( m_parent )
            m_parent->markAsNeedingAnotherRun();
        moveToParent();
        m_ctx.completeCycle();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x5, 0x60(%rdi)
movq 0x40(%rdi), %rdi
testq %rdi, %rdi
je 0x32a41
movq (%rdi), %rax
callq *0x50(%rax)
movq %rbx, %rdi
callq 0x329ec
movq 0x38(%rbx), %rax
movl $0x2, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::TestCaseTracking::SectionTracker::SectionTracker(Catch::TestCaseTracking::NameAndLocation const&, Catch::TestCaseTracking::TrackerContext&, Catch::TestCaseTracking::ITracker*)
SectionTracker::SectionTracker( NameAndLocation const& nameAndLocation, TrackerContext& ctx, ITracker* parent )
    :   TrackerBase( nameAndLocation, ctx, parent ),
        m_trimmed_name(trim(nameAndLocation.name))
    {
        if( parent ) {
            while( !parent->isSectionTracker() )
                parent = &parent->parent();

            SectionTracker& parentSection = static_cast<SectionTracker&>( *parent );
            addNextFilters( parentSection.m_filters );
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rsi, %r12
movq %rdi, %rbx
callq 0x3251a
leaq 0x77ae6(%rip), %rax     # 0xaa570
addq $0x10, %rax
movq %rax, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x68(%rbx)
andq $0x0, 0x78(%rbx)
leaq 0x80(%rbx), %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0x29499
testq %r15, %r15
je 0x32ade
movq (%r15), %rax
movq %r15, %rdi
callq *0x70(%rax)
testb %al, %al
jne 0x32acf
movq (%r15), %rax
movq %r15, %rdi
callq *0x38(%rax)
movq %rax, %r15
jmp 0x32ab4
addq $0x68, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x32b12
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x32aee
movq %rax, %r15
jmp 0x32af9
movq %rax, %r15
movq %r14, %rdi
callq 0x24ad8
leaq 0x68(%rbx), %rdi
callq 0x3f34e
movq %rbx, %rdi
callq 0x412f4
movq %r15, %rdi
callq 0x24950
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::TestCaseTracking::SectionTracker::isComplete() const
bool SectionTracker::isComplete() const {
        bool complete = true;

        if (m_filters.empty()
            || m_filters[0] == ""
            || std::find(m_filters.begin(), m_filters.end(), m_trimmed_name) != m_filters.end()) {
            complete = TrackerBase::isComplete();
        }
        return complete;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x68(%rdi), %rdi
cmpq 0x70(%rbx), %rdi
je 0x32b7b
leaq 0x41313(%rip), %rsi     # 0x73e6b
callq 0x3f7fc
testb %al, %al
jne 0x32b7b
movq 0x68(%rbx), %rdi
movq 0x70(%rbx), %rsi
leaq 0x80(%rbx), %rdx
callq 0x57cc2
cmpq 0x70(%rbx), %rax
je 0x32b8e
movl 0x60(%rbx), %eax
andl $-0x2, %eax
cmpl $0x4, %eax
sete %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movb $0x1, %al
jmp 0x32b87
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::AutoReg::AutoReg(Catch::ITestInvoker*, Catch::SourceLineInfo const&, Catch::StringRef const&, Catch::NameAndTags const&)
AutoReg::AutoReg( ITestInvoker* invoker, SourceLineInfo const& lineInfo, StringRef const& classOrMethod, NameAndTags const& nameAndTags ) noexcept {
        CATCH_TRY {
            getMutableRegistryHub()
                    .registerTest(
                        makeTestCase(
                            invoker,
                            extractClassName( classOrMethod ),
                            nameAndTags,
                            lineInfo));
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %r8, %r14
movq %rcx, %r13
movq %rdx, %r15
movq %rsi, %r12
leaq 0x779b7(%rip), %rax     # 0xaa600
addq $0x10, %rax
movq %rax, (%rdi)
callq 0x3cbaa
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
movq %r13, %rsi
callq 0x323f4
leaq -0x100(%rbp), %rdi
leaq -0x48(%rbp), %rdx
movq %r12, %rsi
movq %r14, %rcx
movq %r15, %r8
callq 0x31684
addq $0x8, %rbx
movq (%rbx), %rax
leaq -0x100(%rbp), %rsi
movq %rbx, %rdi
callq *0x20(%rax)
leaq -0x100(%rbp), %rdi
callq 0x3f4b6
leaq -0x48(%rbp), %rdi
callq 0x24ad8
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x100(%rbp), %rdi
callq 0x3f4b6
jmp 0x32ccc
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x24ad8
jmp 0x32cdc
jmp 0x32cd9
movq %rax, %rbx
movq %rbx, %rdi
callq 0x24220
callq 0x3cbaa
movq %rax, %rdi
addq $0x8, %rdi
movq 0x8(%rax), %rax
callq *0x38(%rax)
callq 0x24890
jmp 0x32ca6
movq %rax, %rdi
callq 0x3dcad
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::WildcardPattern::matches(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
bool WildcardPattern::matches( std::string const& str ) const {
        switch( m_wildcard ) {
            case NoWildcard:
                return m_pattern == normaliseString( str );
            case WildcardAtStart:
                return endsWith( normaliseString( str ), m_pattern );
            case WildcardAtEnd:
                return startsWith( normaliseString( str ), m_pattern );
            case WildcardAtBothEnds:
                return contains( normaliseString( str ), m_pattern );
            default:
                CATCH_INTERNAL_ERROR( "Unknown enum" );
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl 0xc(%rdi), %eax
cmpq $0x3, %rax
ja 0x32ebe
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x3f33b(%rip), %rcx     # 0x72150
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x10(%rbx), %r14
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x345d0
movq %r14, %rdi
movq %r15, %rsi
callq 0x3e788
movl %eax, %ebx
movq %r15, %rdi
jmp 0x32eac
leaq -0x38(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x345d0
addq $0x10, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2cd54
jmp 0x32ea6
leaq -0x38(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x345d0
addq $0x10, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2cc61
movl %eax, %ebx
movq %r14, %rdi
jmp 0x32eac
leaq -0x38(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x345d0
addq $0x10, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2ce5a
movl %eax, %ebx
leaq -0x38(%rbp), %rdi
callq 0x24ad8
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq -0x50(%rbp), %rbx
movq %rbx, %rdi
callq 0x30e18
leaq 0x40fdc(%rip), %rax     # 0x73ead
leaq -0x60(%rbp), %rsi
movq %rax, (%rsi)
movq $0x3c44, 0x8(%rsi)      # imm = 0x3C44
movq 0x10(%rbx), %rdi
callq 0x2921b
movq -0x40(%rbp), %rdi
leaq 0x4124f(%rip), %rsi     # 0x74143
callq 0x24570
movq -0x40(%rbp), %rdi
leaq 0x41a0c(%rip), %rsi     # 0x74910
callq 0x24570
movq -0x40(%rbp), %rsi
addq $0x8, %rsi
leaq -0x38(%rbp), %rdi
callq 0x24830
leaq -0x38(%rbp), %rdi
callq 0x29ee0
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x24ad8
jmp 0x32f34
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x30e5e
jmp 0x32f4d
jmp 0x32f41
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x24ad8
movq %rbx, %rdi
callq 0x24950
nop
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::TestSpec::Filter::name[abi:cxx11]() const
std::string TestSpec::Filter::name() const {
        std::string name;
        for( auto const& p : m_patterns )
            name += p->name();
        return name;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq (%rsi), %r14
movq 0x8(%rsi), %r15
cmpq %r15, %r14
je 0x3315a
movq (%r14), %rsi
addq $0x8, %rsi
movq %rbx, %rdi
callq 0x24a60
addq $0x10, %r14
jmp 0x33140
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x24ad8
movq %r14, %rdi
callq 0x24950
nop
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::TestSpec::matchesByFilter(std::vector<Catch::TestCase, std::allocator<Catch::TestCase>> const&, Catch::IConfig const&) const
TestSpec::Matches TestSpec::matchesByFilter( std::vector<TestCase> const& testCases, IConfig const& config ) const
    {
        Matches matches( m_filters.size() );
        std::transform( m_filters.begin(), m_filters.end(), matches.begin(), [&]( Filter const& filter ){
            std::vector<TestCase const*> currentMatches;
            for( auto const& test : testCases )
                if( isThrowSafe( test, config ) && filter.matches( test ) )
                    currentMatches.emplace_back( &test );
            return FilterMatch{ filter.name(), currentMatches };
        } );
        return matches;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rcx, %r14
movq %rdx, -0x38(%rbp)
movq %rsi, %rbx
movq %rdi, %r15
movq 0x8(%rsi), %rax
subq (%rsi), %rax
pushq $0x18
popq %rcx
cqto
idivq %rcx
leaq -0xa8(%rbp), %rdx
movq %rax, %rsi
callq 0x3f93c
movq (%rbx), %r13
movq 0x8(%rbx), %rax
movq %rax, -0x40(%rbp)
movq %r15, -0x30(%rbp)
movq (%r15), %r15
leaq -0x70(%rbp), %r12
cmpq -0x40(%rbp), %r13
je 0x3328a
movq %r15, -0x48(%rbp)
andq $0x0, -0x60(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x70(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rbx
movq 0x8(%rax), %r15
cmpq %r15, %rbx
je 0x33239
testb $0x10, 0xa0(%rbx)
je 0x33211
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
testb %al, %al
je 0x33230
movq %r13, %rdi
movq %rbx, %rsi
callq 0x3301c
testb %al, %al
je 0x33230
movq %rbx, -0x50(%rbp)
movq %r12, %rdi
leaq -0x50(%rbp), %rsi
callq 0x5b7ac
addq $0xb8, %rbx
jmp 0x331f6
leaq -0xa8(%rbp), %rdi
movq %r13, %rsi
callq 0x3311c
leaq -0x88(%rbp), %rdi
movq %r12, %rsi
callq 0x5b7d0
movq -0x48(%rbp), %r15
movq %r12, %rdi
callq 0x58778
movq %r15, %rdi
leaq -0xa8(%rbp), %rbx
movq %rbx, %rsi
callq 0x5b782
movq %rbx, %rdi
callq 0x58758
addq $0x18, %r13
addq $0x38, %r15
jmp 0x331d1
movq -0x30(%rbp), %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x332b5
movq %rax, %rbx
leaq -0xa8(%rbp), %rdi
callq 0x24ad8
jmp 0x332b8
jmp 0x332b5
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x58778
movq -0x30(%rbp), %rdi
callq 0x3f98e
movq %rbx, %rdi
callq 0x24950
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::TestSpecParser::visitChar(char)
bool TestSpecParser::visitChar( char c ) {
        if( (m_mode != EscapedName) && (c == '\\') ) {
            escape();
            addCharToPattern(c);
            return true;
        }else if((m_mode != EscapedName) && (c == ',') )  {
            return separate();
        }

        switch( m_mode ) {
        case None:
            if( processNoneChar( c ) )
                return true;
            break;
        case Name:
            processNameChar( c );
            break;
        case EscapedName:
            endMode();
            addCharToPattern(c);
            return true;
        default:
        case Tag:
        case QuotedName:
            if( processOtherChar( c ) )
                return true;
            break;
        }

        m_substring += c;
        if( !isControlChar( c ) ) {
            m_patternName += c;
            m_realPatternPos++;
        }
        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0x4, %eax
sete %cl
cmpb $0x5c, %sil
setne %dl
orb %cl, %dl
jne 0x3338b
movq %rbx, %rdi
callq 0x334a2
pushq $0x5c
popq %rsi
movq %rbx, %rdi
callq 0x3f9f4
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
cmpl $0x4, %eax
sete %cl
cmpb $0x2c, %sil
setne %dl
orb %cl, %dl
jne 0x333a8
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x334c6
movsbl %sil, %r14d
movq %rbx, %rdi
cmpl $0x4, %eax
je 0x333ce
movl %r14d, %esi
cmpl $0x1, %eax
je 0x333c7
testl %eax, %eax
jne 0x333db
callq 0x33524
jmp 0x333e0
callq 0x33560
jmp 0x333e4
callq 0x33414
movq %rbx, %rdi
movl %r14d, %esi
jmp 0x3337f
callq 0x3359e
testb %al, %al
jne 0x33384
leaq 0x40(%rbx), %rdi
movl %r14d, %esi
callq 0x244e0
movq %rbx, %rdi
movl %r14d, %esi
callq 0x335de
testb %al, %al
jne 0x33384
leaq 0x60(%rbx), %rdi
movl %r14d, %esi
callq 0x244e0
incq 0x18(%rbx)
jmp 0x33384
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::TestSpecParser::endMode()
void TestSpecParser::endMode() {
        switch( m_mode ) {
        case Name:
        case QuotedName:
            return addNamePattern();
        case Tag:
            return addTagPattern();
        case EscapedName:
            revertBackToLastMode();
            return;
        case None:
        default:
            return startNewMode( None );
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl (%rdi), %eax
leal -0x1(%rax), %ecx
cmpl $0x2, %ecx
jb 0x33433
cmpl $0x3, %eax
je 0x33439
cmpl $0x4, %eax
jne 0x3343f
movl 0x4(%rdi), %eax
movl %eax, (%rdi)
jmp 0x33442
popq %rbp
jmp 0x3362a
popq %rbp
jmp 0x33706
andl $0x0, (%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::TestSpecParser::separate()
bool TestSpecParser::separate() {
      if( (m_mode==QuotedName) || (m_mode==Tag) ){
         //invalid argument, signal failure to previous scope.
         m_mode = None;
         m_pos = m_arg.size();
         m_substring.clear();
         m_patternName.clear();
         m_realPatternPos = 0;
         return false;
      }
      endMode();
      addFilter();
      return true; //success
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %r14d
andl $-0x2, %r14d
cmpl $0x2, %r14d
je 0x334ef
movq %rbx, %rdi
callq 0x33414
movq %rbx, %rdi
callq 0x33444
jmp 0x33517
andl $0x0, (%rbx)
movq 0x28(%rbx), %rax
movq 0x40(%rbx), %rcx
movq %rax, 0x10(%rbx)
andq $0x0, 0x48(%rbx)
xorl %eax, %eax
movb %al, (%rcx)
andq $0x0, 0x68(%rbx)
movq 0x60(%rbx), %rcx
movb %al, (%rcx)
andq $0x0, 0x18(%rbx)
cmpl $0x2, %r14d
setne %al
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::TestSpecParser::processNoneChar(char)
bool TestSpecParser::processNoneChar( char c ) {
        switch( c ) {
        case ' ':
            return true;
        case '~':
            m_exclusion = true;
            return false;
        case '[':
            startNewMode( Tag );
            return false;
        case '"':
            startNewMode( QuotedName );
            return false;
        default:
            startNewMode( Name );
            return false;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x20, %esi
je 0x33552
cmpl $0x22, %esi
je 0x33542
cmpl $0x5b, %esi
je 0x3354a
cmpl $0x7e, %esi
jne 0x33556
movb $0x1, 0x8(%rdi)
jmp 0x3355c
movl $0x2, (%rdi)
jmp 0x3355c
movl $0x3, (%rdi)
jmp 0x3355c
movb $0x1, %al
jmp 0x3355e
movl $0x1, (%rdi)
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::TestSpecParser::processNameChar(char)
void TestSpecParser::processNameChar( char c ) {
        if( c == '[' ) {
            if( m_substring == "exclude:" )
                m_exclusion = true;
            else
                endMode();
            startNewMode( Tag );
        }
    }

// Assembly:
cmpb $0x5b, %sil
jne 0x3359d
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x40, %rdi
leaq 0x41355(%rip), %rsi     # 0x748cf
callq 0x3f7fc
testb %al, %al
je 0x33589
movb $0x1, 0x8(%rbx)
jmp 0x33591
movq %rbx, %rdi
callq 0x33414
movl $0x3, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::TestSpecParser::processOtherChar(char)
bool TestSpecParser::processOtherChar( char c ) {
        if( !isControlChar( c ) )
            return false;
        m_substring += c;
        endMode();
        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r15d
movq %rdi, %rbx
callq 0x335de
movl %eax, %r14d
testb %al, %al
je 0x335cf
leaq 0x40(%rbx), %rdi
movsbl %r15b, %esi
callq 0x244e0
movq %rbx, %rdi
callq 0x33414
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::TestSpecParser::isControlChar(char) const
bool TestSpecParser::isControlChar( char c ) const {
        switch( m_mode ) {
            default:
                return false;
            case None:
                return c == '~';
            case Name:
                return c == '[';
            case EscapedName:
                return true;
            case QuotedName:
                return c == '"';
            case Tag:
                return c == '[' || c == ']';
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl (%rdi), %eax
cmpq $0x4, %rax
ja 0x3361d
leaq 0x3eb6f(%rip), %rcx     # 0x72160
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpb $0x7e, %sil
jmp 0x33618
movb $0x1, %al
jmp 0x3361b
cmpb $0x22, %sil
jmp 0x33618
addb $-0x5b, %sil
testb $-0x3, %sil
jmp 0x33618
cmpb $0x5b, %sil
sete %al
popq %rbp
retq
xorl %eax, %eax
jmp 0x3361b
nop
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::TestSpecParser::addNamePattern()
void TestSpecParser::addNamePattern() {
        auto token = preprocessPattern();

        if (!token.empty()) {
            TestSpec::PatternPtr pattern = std::make_shared<TestSpec::NamePattern>(token, m_substring);
            if (m_exclusion)
                pattern = std::make_shared<TestSpec::ExcludedPattern>(pattern);
            m_currentFilter.m_patterns.push_back(pattern);
        }
        m_substring.clear();
        m_exclusion = false;
        m_mode = None;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq -0x50(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x33896
cmpq $0x0, 0x8(%r14)
je 0x336bd
leaq 0x40(%rbx), %rdx
leaq -0x20(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x3fa81
leaq -0x18(%rbp), %rdi
movups -0x8(%rdi), %xmm0
leaq -0x28(%rbp), %r14
movups %xmm0, -0x8(%r14)
xorps %xmm0, %xmm0
movups %xmm0, -0x8(%rdi)
callq 0x423de
cmpb $0x1, 0x8(%rbx)
jne 0x336a5
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3faa3
leaq -0x30(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x5beea
leaq -0x18(%rbp), %rdi
callq 0x423de
leaq 0x98(%rbx), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3fac2
movq %r14, %rdi
callq 0x423de
andq $0x0, 0x48(%rbx)
movq 0x40(%rbx), %rax
xorl %ecx, %ecx
movb %cl, (%rax)
movb %cl, 0x8(%rbx)
andl $0x0, (%rbx)
leaq -0x50(%rbp), %rdi
callq 0x24ad8
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x336e4
movq %rax, %rbx
movq %r14, %rdi
callq 0x423de
jmp 0x336f4
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x24ad8
movq %rbx, %rdi
callq 0x24950
nop
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::TestSpecParser::addTagPattern()
void TestSpecParser::addTagPattern() {
        auto token = preprocessPattern();

        if (!token.empty()) {
            // If the tag pattern is the "hide and tag" shorthand (e.g. [.foo])
            // we have to create a separate hide tag and shorten the real one
            if (token.size() > 1 && token[0] == '.') {
                token.erase(token.begin());
                TestSpec::PatternPtr pattern = std::make_shared<TestSpec::TagPattern>(".", m_substring);
                if (m_exclusion) {
                    pattern = std::make_shared<TestSpec::ExcludedPattern>(pattern);
                }
                m_currentFilter.m_patterns.push_back(pattern);
            }

            TestSpec::PatternPtr pattern = std::make_shared<TestSpec::TagPattern>(token, m_substring);

            if (m_exclusion) {
                pattern = std::make_shared<TestSpec::ExcludedPattern>(pattern);
            }
            m_currentFilter.m_patterns.push_back(pattern);
        }
        m_substring.clear();
        m_exclusion = false;
        m_mode = None;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq -0x50(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x33896
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x3382d
cmpq $0x1, %rax
je 0x337be
movq -0x50(%rbp), %rsi
cmpb $0x2e, (%rsi)
jne 0x337be
leaq -0x50(%rbp), %rdi
callq 0x246a0
leaq 0x40(%rbx), %rdx
leaq 0x4266d(%rip), %rsi     # 0x75dc4
leaq -0x20(%rbp), %rdi
callq 0x3fafd
leaq -0x18(%rbp), %rdi
movups -0x8(%rdi), %xmm0
leaq -0x28(%rbp), %r14
movups %xmm0, -0x8(%r14)
xorps %xmm0, %xmm0
movups %xmm0, -0x8(%rdi)
callq 0x423de
cmpb $0x1, 0x8(%rbx)
jne 0x337a6
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3faa3
leaq -0x30(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x5beea
leaq -0x18(%rbp), %rdi
callq 0x423de
leaq 0x98(%rbx), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3fac2
movq %r14, %rdi
callq 0x423de
leaq 0x40(%rbx), %rdx
leaq -0x20(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x3fb1f
leaq -0x18(%rbp), %rdi
movups -0x8(%rdi), %xmm0
leaq -0x28(%rbp), %r14
movups %xmm0, -0x8(%r14)
xorps %xmm0, %xmm0
movups %xmm0, -0x8(%rdi)
callq 0x423de
cmpb $0x1, 0x8(%rbx)
jne 0x33815
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3faa3
leaq -0x30(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x5beea
leaq -0x18(%rbp), %rdi
callq 0x423de
leaq 0x98(%rbx), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3fac2
movq %r14, %rdi
callq 0x423de
andq $0x0, 0x48(%rbx)
movq 0x40(%rbx), %rax
xorl %ecx, %ecx
movb %cl, (%rax)
movb %cl, 0x8(%rbx)
andl $0x0, (%rbx)
leaq -0x50(%rbp), %rdi
callq 0x24ad8
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x3385c
jmp 0x3385c
jmp 0x33869
jmp 0x33869
jmp 0x3385c
movq %rax, %rbx
movq %r14, %rdi
callq 0x423de
jmp 0x3386c
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x24ad8
movq %rbx, %rdi
callq 0x24950
nop
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::TestSpecParser::preprocessPattern[abi:cxx11]()
std::string TestSpecParser::preprocessPattern() {
        std::string token = m_patternName;
        for (std::size_t i = 0; i < m_escapeChars.size(); ++i)
            token = token.substr(0, m_escapeChars[i] - i) + token.substr(m_escapeChars[i] - i + 1);
        m_escapeChars.clear();
        if (startsWith(token, "exclude:")) {
            m_exclusion = true;
            token = token.substr(8);
        }

        m_patternName.clear();
        m_realPatternPos = 0;

        return token;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, -0x30(%rbp)
addq $0x60, %rsi
movq %rdi, -0x38(%rbp)
callq 0x24760
pushq $0x1
popq %r15
xorl %esi, %esi
leaq -0x88(%rbp), %r14
leaq -0xa8(%rbp), %r13
leaq -0x68(%rbp), %rbx
movq -0x38(%rbp), %r12
movq -0x30(%rbp), %rcx
movq 0x80(%rcx), %rax
movq 0x88(%rcx), %rcx
movq %rcx, %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %rdx, %rsi
jae 0x3398b
movq (%rax,%rsi,8), %rax
leaq (%r15,%rax), %rcx
decq %rcx
movq %r14, %rdi
movq %rsi, %r14
movq %r12, %rsi
xorl %edx, %edx
callq 0x245e0
movq -0x30(%rbp), %rax
movq 0x80(%rax), %rax
movq %r14, -0x40(%rbp)
movq (%rax,%r14,8), %rdx
movq %r15, -0x48(%rbp)
addq %r15, %rdx
movq %r13, %rdi
movq %r12, %rsi
pushq $-0x1
popq %rcx
callq 0x245e0
movq %rbx, %rdi
leaq -0x88(%rbp), %r14
movq %r14, %rsi
movq %r13, %rdx
callq 0x3e66e
movq -0x38(%rbp), %rdi
movq %rbx, %rsi
callq 0x24690
movq %rbx, %rdi
callq 0x24ad8
movq %r13, %rdi
callq 0x24ad8
movq %r14, %rdi
callq 0x24ad8
movq -0x40(%rbp), %rsi
incq %rsi
movq -0x48(%rbp), %r15
decq %r15
jmp 0x338d7
cmpq %rax, %rcx
je 0x3399b
movq -0x30(%rbp), %rcx
movq %rax, 0x88(%rcx)
leaq 0x40f2d(%rip), %rsi     # 0x748cf
leaq -0x68(%rbp), %rdi
leaq -0x88(%rbp), %rdx
movq -0x38(%rbp), %rbx
callq 0x24210
leaq -0x68(%rbp), %rsi
movq %rbx, %rdi
callq 0x2cd54
movl %eax, %r15d
leaq -0x68(%rbp), %rdi
callq 0x24ad8
testb %r15b, %r15b
je 0x33a04
movq -0x30(%rbp), %rax
movb $0x1, 0x8(%rax)
leaq -0x68(%rbp), %rdi
pushq $0x8
popq %rdx
pushq $-0x1
popq %rcx
movq %rbx, %rsi
callq 0x245e0
leaq -0x68(%rbp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x24690
movq %r15, %rdi
callq 0x24ad8
movq -0x30(%rbp), %rcx
andq $0x0, 0x68(%rcx)
movq 0x60(%rcx), %rax
movb $0x0, (%rax)
andq $0x0, 0x18(%rcx)
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x33a5d
movq %rax, %r14
leaq -0x68(%rbp), %rdi
jmp 0x33a56
jmp 0x33a5d
movq %rax, %r14
leaq -0xa8(%rbp), %rdi
callq 0x24ad8
jmp 0x33a4f
movq %rax, %r14
leaq -0x88(%rbp), %rdi
callq 0x24ad8
jmp 0x33a60
movq %rax, %r14
movq -0x38(%rbp), %rdi
callq 0x24ad8
movq %r14, %rdi
callq 0x24950
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::Detail::rawMemoryToString[abi:cxx11](void const*, unsigned long)
std::string rawMemoryToString( const void *object, std::size_t size ) {
        // Reverse order for little endian architectures
        int i = 0, end = static_cast<int>( size ), inc = 1;
        if( Endianness::which() == Endianness::Little ) {
            i = end-1;
            end = inc = -1;
        }

        unsigned char const *bytes = static_cast<unsigned char const *>(object);
        ReusableStringStream rss;
        rss << "0x" << std::setfill('0') << std::hex;
        for( ; i != end; i += inc )
             rss << std::setw(2) << static_cast<unsigned>(bytes[i]);
       return rss.str();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x38(%rbp), %r12
movq %r12, %rdi
callq 0x30e18
movq 0x10(%r12), %rdi
leaq 0x40ce3(%rip), %rsi     # 0x748ec
callq 0x24570
movq -0x28(%rbp), %rdi
pushq $0x30
popq %rsi
callq 0x24820
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %edx
andl $-0x4b, %edx
orl $0x8, %edx
movl %edx, 0x18(%rax,%rcx)
movslq %r15d, %rax
movq %rax, %r15
subq $0x1, %r15
jb 0x33c63
movq -0x28(%rbp), %rdi
movq (%rdi), %rcx
movq -0x18(%rcx), %rcx
movq $0x2, 0x10(%rdi,%rcx)
movzbl -0x1(%r14,%rax), %esi
callq 0x243c0
movq %r15, %rax
jmp 0x33c39
movq -0x28(%rbp), %rsi
addq $0x8, %rsi
movq %rbx, %rdi
callq 0x24830
leaq -0x38(%rbp), %rdi
callq 0x30e5e
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x33c90
jmp 0x33c90
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x30e5e
movq %rbx, %rdi
callq 0x24950
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::StringMaker<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, void>::convert(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string StringMaker<std::string>::convert(const std::string& str) {
    if (!getCurrentContext().getConfig()->showInvisibles()) {
        return '"' + str + '"';
    }

    std::string s("\"");
    for (char c : str) {
        switch (c) {
        case '\n':
            s.append("\\n");
            break;
        case '\t':
            s.append("\\t");
            break;
        default:
            s.push_back(c);
            break;
        }
    }
    s.append("\"");
    return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x3e53f
movq (%rax), %rcx
movq %rax, %rdi
callq *0x20(%rcx)
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x50(%rax)
testb %al, %al
je 0x33d32
leaq 0x40a62(%rip), %rsi     # 0x7473f
leaq -0x48(%rbp), %rdx
movq %rbx, %rdi
callq 0x24210
movq (%r14), %r15
movq 0x8(%r14), %r14
xorl %r12d, %r12d
leaq 0x4611e(%rip), %r13     # 0x79e18
cmpq %r12, %r14
je 0x33d61
movzbl (%r15,%r12), %eax
movq %r13, %rsi
cmpl $0x9, %eax
je 0x33d18
cmpl $0xa, %eax
jne 0x33d22
leaq 0x4614e(%rip), %rsi     # 0x79e66
movq %rbx, %rdi
callq 0x24a10
jmp 0x33d2d
movsbl %al, %esi
movq %rbx, %rdi
callq 0x244e0
incq %r12
jmp 0x33cfa
leaq -0x48(%rbp), %r15
pushq $0x22
popq %r12
movq %r15, %rdi
movl %r12d, %esi
movq %r14, %rdx
callq 0x3fb60
movq %rbx, %rdi
movq %r15, %rsi
movl %r12d, %edx
callq 0x3e746
leaq -0x48(%rbp), %rdi
callq 0x24ad8
jmp 0x33d70
leaq 0x409d7(%rip), %rsi     # 0x7473f
movq %rbx, %rdi
callq 0x24a10
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x33d8d
movq %rax, %r14
leaq -0x48(%rbp), %rdi
jmp 0x33d93
movq %rax, %r14
movq %rbx, %rdi
callq 0x24ad8
movq %r14, %rdi
callq 0x24950
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::StringMaker<char const*, void>::convert[abi:cxx11](char const*)
std::string StringMaker<char const*>::convert(char const* str) {
    if (str) {
        return ::Catch::Detail::stringify(std::string{ str });
    } else {
        return{ "{null string}" };
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
testq %rsi, %rsi
je 0x33dd9
leaq -0x38(%rbp), %r14
leaq -0x11(%rbp), %rdx
movq %r14, %rdi
callq 0x24210
movq %rbx, %rdi
movq %r14, %rsi
callq 0x33ca4
leaq -0x38(%rbp), %rdi
callq 0x24ad8
jmp 0x33dec
leaq 0x40afc(%rip), %rsi     # 0x748dc
leaq -0x38(%rbp), %rdx
movq %rbx, %rdi
callq 0x24210
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x24ad8
movq %rbx, %rdi
callq 0x24950
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::StringMaker<std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>, void>::convert(std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> const&)
std::string StringMaker<std::wstring>::convert(const std::wstring& wstr) {
    std::string s;
    s.reserve(wstr.size());
    for (auto c : wstr) {
        s += (c <= 0xff) ? static_cast<char>(c) : '?';
    }
    return ::Catch::Detail::stringify(s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
leaq -0x40(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movq %rsi, %r14
movq %rdi, %rbx
movb $0x0, (%rax)
movq 0x8(%rsi), %rsi
leaq -0x50(%rbp), %rdi
callq 0x24810
movq %rbx, -0x30(%rbp)
movq (%r14), %r15
movq 0x8(%r14), %r12
shlq $0x2, %r12
xorl %r13d, %r13d
pushq $0x3f
popq %rbx
leaq -0x50(%rbp), %r14
cmpq %r13, %r12
je 0x33ee7
movl (%r15,%r13), %eax
cmpl $0x100, %eax            # imm = 0x100
cmovgel %ebx, %eax
movsbl %al, %esi
movq %r14, %rdi
callq 0x244e0
addq $0x4, %r13
jmp 0x33ec5
leaq -0x50(%rbp), %rsi
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x33ca4
leaq -0x50(%rbp), %rdi
callq 0x24ad8
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x33f14
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x24ad8
movq %rbx, %rdi
callq 0x24950
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::StringMaker<wchar_t const*, void>::convert[abi:cxx11](wchar_t const*)
std::string StringMaker<wchar_t const*>::convert(wchar_t const * str) {
    if (str) {
        return ::Catch::Detail::stringify(std::wstring{ str });
    } else {
        return{ "{null string}" };
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
testq %rsi, %rsi
je 0x33f61
leaq -0x38(%rbp), %r14
leaq -0x11(%rbp), %rdx
movq %r14, %rdi
callq 0x24990
movq %rbx, %rdi
movq %r14, %rsi
callq 0x33e78
leaq -0x38(%rbp), %rdi
callq 0x240d0
jmp 0x33f74
leaq 0x40974(%rip), %rsi     # 0x748dc
leaq -0x38(%rbp), %rdx
movq %rbx, %rdi
callq 0x24210
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x240d0
movq %rbx, %rdi
callq 0x24950
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::StringMaker<wchar_t*, void>::convert[abi:cxx11](wchar_t*)
std::string StringMaker<wchar_t *>::convert(wchar_t * str) {
    if (str) {
        return ::Catch::Detail::stringify(std::wstring{ str });
    } else {
        return{ "{null string}" };
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
testq %rsi, %rsi
je 0x33fcd
leaq -0x38(%rbp), %r14
leaq -0x11(%rbp), %rdx
movq %r14, %rdi
callq 0x24990
movq %rbx, %rdi
movq %r14, %rsi
callq 0x33e78
leaq -0x38(%rbp), %rdi
callq 0x240d0
jmp 0x33fe0
leaq 0x40908(%rip), %rsi     # 0x748dc
leaq -0x38(%rbp), %rdx
movq %rbx, %rdi
callq 0x24210
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x240d0
movq %rbx, %rdi
callq 0x24950