LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::(anonymous namespace)::TestGroup::~TestGroup()
explicit TestGroup(std::shared_ptr<Config> const& config)
            : m_config{config}
            , m_context{config, makeReporter(config)}
            {
                auto const& allTestCases = getAllTestCasesSorted(*m_config);
                m_matches = m_config->testSpec().matchesByFilter(allTestCases, *m_config);
                auto const& invalidArgs = m_config->testSpec().getInvalidArgs();

                if (m_matches.empty() && invalidArgs.empty()) {
                    for (auto const& test : allTestCases)
                        if (!test.isHidden())
                            m_tests.emplace(&test);
                } else {
                    for (auto const& match : m_matches)
                        m_tests.insert(match.tests.begin(), match.tests.end());
                }
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x230, %rdi            # imm = 0x230
callq 0x402fc
leaq 0x200(%rbx), %rdi
callq 0x49a46
leaq 0x10(%rbx), %rdi
callq 0x292b8
movq 0x8(%rbx), %rdi
addq $0x8, %rsp
testq %rdi, %rdi
je 0x2d414
popq %rbx
popq %rbp
jmp 0x43a1a
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::TagAliasRegistry::find(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
TagAlias const* TagAliasRegistry::find( std::string const& alias ) const {
        auto it = m_registry.find( alias );
        if( it != m_registry.end() )
            return &(it->second);
        else
            return nullptr;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x8, %rdi
callq 0x5c330
addq $0x10, %rbx
leaq 0x40(%rax), %rdx
xorl %ecx, %ecx
cmpq %rbx, %rax
cmovneq %rdx, %rcx
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0x2e57e
movq (%rbx), %rcx
movl $0x2, %eax
cmpb $0x2e, (%rcx)
je 0x2e61b
leaq 0x4d1ca(%rip), %rsi     # 0x7b74f
movq %rbx, %rdi
callq 0x1b140
testl %eax, %eax
je 0x2e5fa
leaq 0x4e710(%rip), %rsi     # 0x7cca8
movq %rbx, %rdi
callq 0x1b140
testl %eax, %eax
je 0x2e601
leaq 0x4e705(%rip), %rsi     # 0x7ccb0
movq %rbx, %rdi
callq 0x1b140
testl %eax, %eax
je 0x2e608
leaq 0x4d76a(%rip), %rsi     # 0x7bd28
movq %rbx, %rdi
callq 0x1b140
testl %eax, %eax
je 0x2e60f
leaq 0x4e6eb(%rip), %rsi     # 0x7ccbc
movq %rbx, %rdi
callq 0x1b140
testl %eax, %eax
je 0x2e616
leaq 0x4e6e5(%rip), %rsi     # 0x7ccc9
movq %rbx, %rdi
callq 0x1b140
xorl %ecx, %ecx
testl %eax, %eax
movl $0x42, %eax
cmovnel %ecx, %eax
jmp 0x2e61b
movl $0x2, %eax
jmp 0x2e61b
movl $0x10, %eax
jmp 0x2e61b
movl $0x4, %eax
jmp 0x2e61b
movl $0x8, %eax
jmp 0x2e61b
movl $0x20, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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), %r12
movq 0x8(%rsi), %r15
cmpq %r15, %r12
je 0x2e679
movq %r15, %rax
subq %r12, %rax
sarq $0x5, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0x5ca31
movq %r12, %rdi
movq %r15, %rsi
callq 0x5cb05
movq (%rbx), %r12
movq 0x8(%rbx), %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0x5d1fb
movq 0x8(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5d2d6
leaq 0x78(%r14), %rdi
movq %rdi, -0x38(%rbp)
callq 0x3fcf0
movq (%rbx), %r15
movq 0x8(%rbx), %r12
cmpq %r12, %r15
je 0x2e709
movq %rbx, -0x30(%rbp)
leaq -0x58(%rbp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x261c3
movl 0xa0(%r14), %ebx
movq %r13, %rdi
callq 0x2e55d
orl %ebx, %eax
movl %eax, 0xa0(%r14)
movq -0x38(%rbp), %rdi
movq %r13, %rsi
callq 0x3fc4c
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x2e6f5
callq 0x1b4d0
addq $0x20, %r15
cmpq %r12, %r15
jne 0x2e6b4
movq -0x30(%rbp), %rbx
movq (%rbx), %r15
movq 0x8(%rbx), %r12
movups 0x60(%r14), %xmm0
movq 0x70(%r14), %rax
movq %r15, 0x60(%r14)
movq %r12, 0x68(%r14)
movq 0x10(%rbx), %rcx
movq %rcx, 0x70(%r14)
leaq -0x58(%rbp), %rdi
movups %xmm0, (%rdi)
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
callq 0x3fc98
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x2e764
callq 0x1b4d0
movq %rbx, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O3/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
movl $0x0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq (%rdi), %rbx
movq 0x8(%rdi), %r12
cmpq %r12, %rbx
je 0x2ef60
leaq -0x88(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x5f1c4
testb $0x1, %dl
je 0x2ef79
addq $0xb8, %rbx
cmpq %r12, %rbx
jne 0x2ef44
leaq -0x88(%rbp), %rdi
callq 0x49d26
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x38(%rbp), %rdi
callq 0x2d4e2
movq -0x28(%rbp), %rdi
leaq 0x4c7c5(%rip), %rsi     # 0x7b755
movl $0x13, %edx
callq 0x1b5e0
movq -0x28(%rbp), %rdi
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
callq 0x1b5e0
movq -0x28(%rbp), %rdi
leaq 0x4c7b4(%rip), %rsi     # 0x7b769
movl $0x15, %edx
callq 0x1b5e0
movq -0x28(%rbp), %rdi
leaq 0x4c7b5(%rip), %rsi     # 0x7b77f
movl $0xf, %edx
callq 0x1b5e0
addq $0xb0, %r14
movq -0x28(%rbp), %rdi
movq %r14, %rsi
callq 0x22e17
movq -0x28(%rbp), %rdi
leaq 0x54b60(%rip), %rsi     # 0x83b52
movl $0x1, %edx
callq 0x1b5e0
movq -0x28(%rbp), %rdi
leaq 0x4c788(%rip), %rsi     # 0x7b78f
movl $0xe, %edx
callq 0x1b5e0
addq $0x90, %rbx
movq -0x28(%rbp), %rdi
movq %rbx, %rsi
callq 0x22e17
movq -0x28(%rbp), %rsi
addq $0x8, %rsi
leaq -0x58(%rbp), %rdi
callq 0x1b7f0
leaq -0x58(%rbp), %rdi
callq 0x1cf32
movq %rax, %rbx
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2f058
callq 0x1b4d0
jmp 0x2f058
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x2d528
jmp 0x2f068
jmp 0x2f065
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x49d26
movq %rbx, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x68(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x78(%rbp), %r15
movq %r15, %rdi
callq 0x4a8c2
cmpq $0x0, 0x8(%r15)
je 0x2f0de
addq $0x8, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x40086
jmp 0x2f1c7
leaq -0x38(%rbp), %rdi
callq 0x2d4e2
movq -0x28(%rbp), %rdi
leaq 0x4c6ac(%rip), %rsi     # 0x7b79e
movl $0x14, %edx
callq 0x1b5e0
movq 0x40(%rbx), %rsi
incq %rsi
movq %rsi, 0x40(%rbx)
movq -0x28(%rbp), %rdi
callq 0x1b350
movq -0x28(%rbp), %rsi
addq $0x8, %rsi
leaq -0x58(%rbp), %rdi
callq 0x1b7f0
leaq -0x130(%rbp), %rdi
leaq -0x58(%rbp), %rdx
movq %r14, %rsi
callq 0x2ea1a
movq (%rbx), %rax
leaq -0x130(%rbp), %rsi
movq %rbx, %rdi
callq *0x20(%rax)
movq -0x80(%rbp), %rdi
testq %rdi, %rdi
je 0x2f152
callq 0x43a1a
leaq -0xb8(%rbp), %rdi
callq 0x3fc98
leaq -0xd0(%rbp), %rbx
movq %rbx, %rdi
callq 0x3fc98
movq -0x20(%rbx), %rdi
leaq -0xe0(%rbp), %rax
cmpq %rax, %rdi
je 0x2f182
callq 0x1b4d0
leaq -0x100(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2f197
callq 0x1b4d0
leaq -0x120(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2f1ac
callq 0x1b4d0
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2f1be
callq 0x1b4d0
leaq -0x38(%rbp), %rdi
callq 0x2d528
movq -0x78(%rbp), %rdi
cmpq %r12, %rdi
je 0x2f1d5
callq 0x1b4d0
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x130(%rbp), %rdi
callq 0x3fdc4
jmp 0x2f1f9
movq %rax, %rbx
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2f219
callq 0x1b4d0
jmp 0x2f219
jmp 0x2f216
jmp 0x2f211
movq %rax, %rbx
jmp 0x2f222
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x2d528
movq -0x78(%rbp), %rdi
cmpq %r12, %rdi
je 0x2f230
callq 0x1b4d0
movq %rbx, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x28(%rdi), %rax
cmpq 0x30(%rdi), %rax
jne 0x2f26a
leaq 0x8(%rbx), %rdi
callq 0x2ef06
leaq 0x28(%rbx), %r15
movl 0x20(%rbx), %r12d
movq (%r14), %rax
movq %r14, %rdi
callq *0x80(%rax)
cmpl %eax, %r12d
jne 0x2f28d
movq 0x28(%rbx), %rax
cmpq 0x30(%rbx), %rax
jne 0x2f2fa
leaq 0x8(%rbx), %rdx
leaq -0x40(%rbp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x2eb0e
movups 0x28(%rbx), %xmm0
movq 0x38(%rbx), %rax
movq (%r12), %rcx
movq %rcx, 0x28(%rbx)
movq 0x8(%r12), %rcx
movq %rcx, 0x30(%rbx)
movq 0x10(%r12), %rcx
movq %rcx, 0x38(%rbx)
leaq -0x58(%rbp), %rdi
movups %xmm0, (%rdi)
movq %rax, 0x10(%rdi)
xorps %xmm0, %xmm0
movaps %xmm0, (%r12)
movq $0x0, 0x10(%r12)
callq 0x3f08c
movq %r12, %rdi
callq 0x3f08c
movq (%r14), %rax
movq %r14, %rdi
callq *0x80(%rax)
movl %eax, 0x20(%rbx)
movq %r15, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq (%rsi), %rax
leaq 0x10(%rdi), %r12
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %r12, (%rdi)
movq %rax, %rsi
callq 0x431c8
cmpq $0x0, 0x8(%rbx)
je 0x2f3d8
movq (%rbx), %rax
cmpb $0x26, (%rax)
jne 0x2f3d8
leaq 0x4c448(%rip), %r14     # 0x7b7b3
movl $0x2, %ecx
movq %rbx, %rdi
movq %r14, %rsi
movq $-0x1, %rdx
callq 0x1b6f0
movq %rax, %r15
leaq -0x1(%rax), %rdx
movl $0x2, %ecx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1b6f0
cmpq $-0x1, %rax
movl $0x1, %edx
cmovneq %rax, %rdx
subq %rdx, %r15
leaq -0x40(%rbp), %rdi
movq %rbx, %rsi
movq %r15, %rcx
callq 0x1b580
leaq -0x40(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1b640
movq (%r14), %rdi
leaq -0x30(%rbp), %rax
cmpq %rax, %rdi
je 0x2f3d8
callq 0x1b4d0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x2f3f8
callq 0x1b4d0
movq %r14, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x18, %rsp
movq %rdx, %r14
movq 0x48(%rsi), %r12
movq 0x50(%rsi), %rcx
movq %rcx, %rax
subq %r12, %rax
movq %rax, %rbx
sarq $0x6, %rbx
testq %rbx, %rbx
jle 0x2f64b
movq %rcx, -0x30(%rbp)
movq %rdi, -0x38(%rbp)
andq $-0x40, %rax
movq %rax, %r15
addq %r12, %r15
incq %rbx
movq %r14, %rdi
movq %r12, %rsi
callq 0x3dcf4
testb %al, %al
jne 0x2f683
leaq 0x10(%r12), %r13
movq %r14, %rdi
movq %r13, %rsi
callq 0x3dcf4
testb %al, %al
jne 0x2f686
leaq 0x20(%r12), %r13
movq %r14, %rdi
movq %r13, %rsi
callq 0x3dcf4
testb %al, %al
jne 0x2f686
leaq 0x30(%r12), %r13
movq %r14, %rdi
movq %r13, %rsi
callq 0x3dcf4
testb %al, %al
jne 0x2f686
addq $0x40, %r12
decq %rbx
cmpq $0x1, %rbx
jg 0x2f5db
movq -0x30(%rbp), %rcx
movq %rcx, %rax
subq %r15, %rax
movq -0x38(%rbp), %rdi
jmp 0x2f64e
movq %r12, %r15
sarq $0x4, %rax
cmpq $0x1, %rax
je 0x2f6ab
cmpq $0x2, %rax
je 0x2f690
cmpq $0x3, %rax
jne 0x2f6f2
movq %rcx, %r12
movq %rdi, %rbx
movq %r14, %rdi
movq %r15, %rsi
callq 0x3dcf4
testb %al, %al
jne 0x2f6c2
addq $0x10, %r15
jmp 0x2f696
movq %r12, %r13
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %r12
jmp 0x2f6c8
movq %rcx, %r12
movq %rdi, %rbx
movq %r14, %rdi
movq %r15, %rsi
callq 0x3dcf4
testb %al, %al
jne 0x2f6c2
addq $0x10, %r15
jmp 0x2f6b1
movq %rcx, %r12
movq %rdi, %rbx
movq %r14, %rdi
movq %r15, %rsi
callq 0x3dcf4
testb %al, %al
cmoveq %r12, %r15
movq %r15, %r13
movq %rbx, %rdi
cmpq %r12, %r13
je 0x2f6f2
movq (%r13), %rax
movq %rax, (%rdi)
movq 0x8(%r13), %rax
movq %rax, 0x8(%rdi)
testq %rax, %rax
je 0x2f6fe
movq 0x7a8a8(%rip), %rcx     # 0xa9f90
cmpb $0x0, (%rcx)
je 0x2f6fa
incl 0x8(%rax)
jmp 0x2f6fe
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
jmp 0x2f6fe
lock
incl 0x8(%rax)
movq %rdi, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2f75f
movl $0x2, 0x60(%rdi)
movq 0x40(%rdi), %rdi
testq %rdi, %rdi
je 0x2f75f
movq (%rdi), %rax
popq %rbp
jmpq *0x68(%rax)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2f795
movq (%rdi), %rax
popq %rbp
jmpq *0x68(%rax)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2faaa
movq (%rdi), %rax
callq *0x50(%rax)
movq 0x40(%rbx), %rax
testq %rax, %rax
je 0x2faaa
movq 0x38(%rbx), %rcx
movq %rax, 0x10(%rcx)
movl $0x2, 0x18(%rcx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x4bd0c(%rip), %rdi     # 0x7b7bd
leaq 0x4b41d(%rip), %rsi     # 0x7aed5
leaq 0x4bd6a(%rip), %rcx     # 0x7b829
movl $0x38a4, %edx           # imm = 0x38A4
callq 0x1b320
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, %r14
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x7693a(%rip), %rax     # 0xa6430
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x8, %rdi
leaq 0x18(%rbx), %rax
movq %rax, 0x8(%rbx)
movq (%rsi), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
callq 0x4a8c2
movups 0x20(%r15), %xmm0
movups %xmm0, 0x28(%rbx)
movq %r12, 0x38(%rbx)
movq %r14, 0x40(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%rbx)
movups %xmm0, 0x54(%rbx)
leaq 0x76a15(%rip), %rax     # 0xa6550
addq $0x10, %rax
movq %rax, (%rbx)
movups %xmm0, 0x68(%rbx)
movq $0x0, 0x78(%rbx)
leaq 0x80(%rbx), %rdi
movq %r15, %rsi
callq 0x23233
testq %r14, %r14
je 0x2fb8c
movq (%r14), %rax
movq %r14, %rdi
callq *0x70(%rax)
testb %al, %al
jne 0x2fb7d
movq (%r14), %rax
movq %r14, %rdi
callq *0x38(%rax)
movq %rax, %r14
jmp 0x2fb62
addq $0x68, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2fbd0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2fb9c
movq %rax, %r14
jmp 0x2fbb7
movq %rax, %r14
movq 0x80(%rbx), %rdi
leaq 0x90(%rbx), %rax
cmpq %rax, %rdi
je 0x2fbb7
callq 0x1b4d0
leaq 0x68(%rbx), %rdi
callq 0x3fc98
movq %rbx, %rdi
callq 0x424a4
movq %r14, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2fc39
leaq 0x4b27d(%rip), %rsi     # 0x7ae93
callq 0x1b140
testl %eax, %eax
je 0x2fc39
movq 0x68(%rbx), %rdi
movq 0x70(%rbx), %rsi
leaq 0x80(%rbx), %rdx
callq 0x5b18a
cmpq 0x70(%rbx), %rax
je 0x2fc4c
movl 0x60(%rbx), %eax
andl $-0x2, %eax
cmpl $0x4, %eax
sete %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movb $0x1, %al
jmp 0x2fc45
// File: /workspace/github_cpp_makefile_star2_O3/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 0x768c1(%rip), %rax     # 0xa65e0
addq $0x10, %rax
movq %rax, (%rdi)
callq 0x3cd2c
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
movq %r13, %rsi
callq 0x2f32a
leaq -0x100(%rbp), %rdi
leaq -0x48(%rbp), %rdx
movq %r12, %rsi
movq %r14, %rcx
movq %r15, %r8
callq 0x2e0d0
addq $0x8, %rbx
movq (%rbx), %rax
leaq -0x100(%rbp), %rsi
movq %rbx, %rdi
callq *0x20(%rax)
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x2fd75
callq 0x43a1a
leaq -0x88(%rbp), %rdi
callq 0x3fc98
leaq -0xa0(%rbp), %rbx
movq %rbx, %rdi
callq 0x3fc98
movq -0x20(%rbx), %rdi
leaq -0xb0(%rbp), %rax
cmpq %rax, %rdi
je 0x2fda5
callq 0x1b4d0
leaq -0xd0(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2fdba
callq 0x1b4d0
leaq -0xf0(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2fdcf
callq 0x1b4d0
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2fde1
callq 0x1b4d0
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x100(%rbp), %rdi
callq 0x3fdc4
jmp 0x2fe07
movq %rax, %rbx
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2fe20
callq 0x1b4d0
jmp 0x2fe20
jmp 0x2fe1d
movq %rax, %rbx
movq %rbx, %rdi
callq 0x1b1f0
callq 0x3cd2c
movq %rax, %rdi
addq $0x8, %rdi
movq 0x8(%rax), %rax
callq *0x38(%rax)
callq 0x1b850
jmp 0x2fde1
movq %rax, %rdi
callq 0x3e96e
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
subq $0x50, %rsp
movl 0xc(%rdi), %eax
cmpq $0x3, %rax
ja 0x300e0
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0x4918d(%rip), %rcx     # 0x79150
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq -0x30(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x31f78
movq 0x18(%rbx), %rdx
cmpq 0x8(%r14), %rdx
je 0x30009
movq -0x30(%rbp), %r14
xorl %ebx, %ebx
jmp 0x300b7
leaq -0x30(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x31f78
movq 0x18(%rbx), %rdx
cmpq %rdx, 0x8(%r14)
jb 0x2ffe5
movq -0x30(%rbp), %r14
testq %rdx, %rdx
je 0x300b5
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x1b570
testl %eax, %eax
sete %bl
jmp 0x300b7
leaq -0x30(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x31f78
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rcx
movq %r14, %rdi
xorl %edx, %edx
callq 0x1b8d0
cmpq $-0x1, %rax
setne %bl
movq (%r14), %rdi
jmp 0x300c7
leaq -0x30(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x31f78
movq 0x8(%r14), %rax
movq 0x18(%rbx), %rcx
cmpq %rcx, %rax
jae 0x3007d
movq -0x30(%rbp), %rdi
xorl %ebx, %ebx
jmp 0x300c7
movq -0x30(%rbp), %rdi
testq %rcx, %rcx
je 0x300c5
movq 0x10(%rbx), %rdx
addq %rcx, %rdx
addq %rdi, %rax
negq %rcx
movq $-0x1, %rsi
movb (%rdx,%rsi), %r8b
cmpb (%rax,%rsi), %r8b
sete %bl
jne 0x300c7
leaq -0x1(%rsi), %r8
cmpq %rsi, %rcx
movq %r8, %rsi
jne 0x3009a
jmp 0x300c7
movb $0x1, %bl
leaq -0x20(%rbp), %rax
cmpq %rax, %r14
je 0x300d5
movq %r14, %rdi
jmp 0x300d0
movb $0x1, %bl
leaq -0x20(%rbp), %rax
cmpq %rax, %rdi
je 0x300d5
callq 0x1b4d0
movl %ebx, %eax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq -0x48(%rbp), %rbx
movq %rbx, %rdi
callq 0x2d4e2
leaq 0x4ade2(%rip), %rax     # 0x7aed5
leaq -0x58(%rbp), %rsi
movq %rax, (%rsi)
movq $0x3c44, 0x8(%rsi)      # imm = 0x3C44
movq 0x10(%rbx), %rdi
callq 0x22e17
movq -0x38(%rbp), %rdi
leaq 0x4b055(%rip), %rsi     # 0x7b16b
movl $0x19, %edx
callq 0x1b5e0
movq -0x38(%rbp), %rdi
leaq 0x4b80d(%rip), %rsi     # 0x7b938
movl $0xc, %edx
callq 0x1b5e0
movq -0x38(%rbp), %rsi
addq $0x8, %rsi
leaq -0x30(%rbp), %rdi
callq 0x1b7f0
leaq -0x30(%rbp), %rdi
callq 0x23e01
movq %rax, %rbx
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x30169
callq 0x1b4d0
jmp 0x30169
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x2d528
movq %rbx, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq (%rsi), %r14
movq 0x8(%rsi), %r12
cmpq %r12, %r14
je 0x30440
movq (%r14), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
movq %rbx, %rdi
callq 0x1b150
addq $0x10, %r14
jmp 0x30422
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x3045c
callq 0x1b4d0
movq %r14, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x78, %rsp
movq %rcx, %r14
movq %rdx, -0x60(%rbp)
movq %rsi, %rbx
movq 0x8(%rsi), %rax
subq (%rsi), %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rsi # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rsi
leaq -0xa0(%rbp), %rdx
movq %rdi, -0x30(%rbp)
callq 0x4025a
movq (%rbx), %r12
movq 0x8(%rbx), %rax
movq %rax, -0x58(%rbp)
cmpq %rax, %r12
je 0x305dd
movq -0x30(%rbp), %rax
movq (%rax), %r13
xorps %xmm0, %xmm0
movaps %xmm0, -0x50(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x60(%rbp), %rax
movq (%rax), %r15
movq 0x8(%rax), %rbx
cmpq %rbx, %r15
je 0x30536
testb $0x10, 0xa0(%r15)
je 0x304f9
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
testb %al, %al
je 0x3052d
movq %r12, %rdi
movq %r15, %rsi
callq 0x302ae
testb %al, %al
je 0x3052d
movq %r15, -0x68(%rbp)
movq -0x48(%rbp), %rsi
cmpq -0x40(%rbp), %rsi
je 0x30520
movq %r15, (%rsi)
addq $0x8, -0x48(%rbp)
jmp 0x3052d
leaq -0x50(%rbp), %rdi
leaq -0x68(%rbp), %rdx
callq 0x5fcfe
addq $0xb8, %r15
jmp 0x304dd
leaq -0xa0(%rbp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x303fa
leaq -0x80(%rbp), %rbx
movq %rbx, %rdi
leaq -0x50(%rbp), %rsi
callq 0x5fc7e
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x30566
callq 0x1b4d0
movq %r13, %rdi
movq %r15, %rsi
callq 0x1b640
movq 0x20(%r13), %rdi
movq -0x80(%rbp), %rax
movq %rax, 0x20(%r13)
movq -0x78(%rbp), %rax
movq %rax, 0x28(%r13)
movq -0x70(%rbp), %rax
movq %rax, 0x30(%r13)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
testq %rdi, %rdi
je 0x305b3
callq 0x1b4d0
movq -0x80(%rbp), %rdi
testq %rdi, %rdi
je 0x305b3
callq 0x1b4d0
movq -0xa0(%rbp), %rdi
leaq -0x90(%rbp), %rax
cmpq %rax, %rdi
je 0x305cb
callq 0x1b4d0
addq $0x18, %r12
addq $0x38, %r13
cmpq -0x58(%rbp), %r12
jne 0x304c3
movq -0x30(%rbp), %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x30611
movq %rax, %rbx
movq -0xa0(%rbp), %rdi
leaq -0x90(%rbp), %rax
cmpq %rax, %rdi
je 0x30614
callq 0x1b4d0
jmp 0x30614
jmp 0x30611
movq %rax, %rbx
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x30622
callq 0x1b4d0
movq -0x30(%rbp), %rdi
callq 0x402fc
movq %rbx, %rdi
callq 0x1b910
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r15d
movq %rdi, %rbx
movl (%rdi), %eax
cmpl $0x4, %eax
sete %cl
cmpb $0x5c, %r15b
setne %dl
orb %cl, %dl
jne 0x306f9
movq %rbx, %rdi
callq 0x308b6
leaq 0x40(%rbx), %rdi
movl $0x5c, %esi
callq 0x1b480
leaq 0x60(%rbx), %rdi
movl $0x5c, %esi
jmp 0x307ef
cmpl $0x4, %eax
sete %cl
cmpb $0x2c, %r15b
setne %dl
orb %cl, %dl
jne 0x3071c
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x308f8
movsbl %r15b, %r14d
cmpl $0x4, %eax
je 0x30759
cmpl $0x1, %eax
je 0x3074c
testl %eax, %eax
jne 0x3076f
cmpl $0x5a, %r14d
jg 0x30780
cmpl $0x20, %r14d
je 0x307f8
cmpl $0x22, %r14d
jne 0x30792
movl $0x2, (%rbx)
jmp 0x307a0
movq %rbx, %rdi
movl %r14d, %esi
callq 0x30998
jmp 0x307a0
movq %rbx, %rdi
callq 0x30806
leaq 0x40(%rbx), %rdi
movl %r14d, %esi
callq 0x1b480
jmp 0x307e8
movq %rbx, %rdi
movl %r14d, %esi
callq 0x309d6
testb %al, %al
je 0x307a0
jmp 0x307f8
cmpl $0x5b, %r14d
je 0x3079a
cmpl $0x7e, %r14d
jne 0x30792
movb $0x1, 0x8(%rbx)
jmp 0x307a0
movl $0x1, (%rbx)
jmp 0x307a0
movl $0x3, (%rbx)
leaq 0x40(%rbx), %rdi
movl %r14d, %esi
callq 0x1b480
movl (%rbx), %eax
cmpq $0x4, %rax
ja 0x307e8
leaq 0x489a5(%rip), %rcx     # 0x79160
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpb $0x7e, %r15b
jne 0x307e8
jmp 0x307f8
cmpl $0x5b, %r14d
je 0x307f8
cmpl $0x5d, %r14d
je 0x307f8
jmp 0x307e8
cmpb $0x5b, %r15b
jne 0x307e8
jmp 0x307f8
cmpb $0x22, %r15b
je 0x307f8
leaq 0x60(%rbx), %rdi
movl %r14d, %esi
callq 0x1b480
incq 0x18(%rbx)
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x30825
cmpl $0x3, %eax
je 0x3082b
cmpl $0x4, %eax
jne 0x30831
movl 0x4(%rdi), %eax
movl %eax, (%rdi)
jmp 0x30837
popq %rbp
jmp 0x30a8c
popq %rbp
jmp 0x30bb0
movl $0x0, (%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x30921
movq %rbx, %rdi
callq 0x30806
movq %rbx, %rdi
callq 0x3083a
jmp 0x30949
movl $0x0, (%rbx)
movq 0x28(%rbx), %rax
movq 0x40(%rbx), %rcx
movq %rax, 0x10(%rbx)
xorl %eax, %eax
movq %rax, 0x48(%rbx)
movb %al, (%rcx)
movq %rax, 0x68(%rbx)
movq 0x60(%rbx), %rcx
movb %al, (%rcx)
movq %rax, 0x18(%rbx)
cmpl $0x2, %r14d
setne %al
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x5a, %esi
jg 0x30971
cmpl $0x20, %esi
je 0x30989
cmpl $0x22, %esi
jne 0x30981
movl $0x2, (%rdi)
jmp 0x30993
cmpl $0x5b, %esi
je 0x3098d
cmpl $0x7e, %esi
jne 0x30981
movb $0x1, 0x8(%rdi)
jmp 0x30993
movl $0x1, (%rdi)
jmp 0x30993
movb $0x1, %al
jmp 0x30995
movl $0x3, (%rdi)
xorl %eax, %eax
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x309d5
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x40, %rdi
leaq 0x4af45(%rip), %rsi     # 0x7b8f7
callq 0x1b140
testl %eax, %eax
je 0x309c5
movq %rbx, %rdi
callq 0x30806
jmp 0x309c9
movb $0x1, 0x8(%rbx)
movl $0x3, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::TestSpecParser::processOtherChar(char)
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:
movl (%rdi), %eax
cmpq $0x4, %rax
ja 0x30a3d
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x48786(%rip), %rcx     # 0x79174
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpb $0x7e, %sil
je 0x30a15
jmp 0x30a34
movsbl %sil, %eax
cmpl $0x5b, %eax
je 0x30a15
cmpl $0x5d, %eax
je 0x30a15
jmp 0x30a34
cmpb $0x5b, %sil
jne 0x30a34
leaq 0x40(%rbx), %rdi
movsbl %sil, %esi
callq 0x1b480
movq %rbx, %rdi
callq 0x30806
movb $0x1, %al
jmp 0x30a36
cmpb $0x22, %sil
je 0x30a15
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x50, %rsp
movq %rdi, %rbx
leaq -0x60(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x30db4
cmpq $0x0, 0x8(%r14)
je 0x30b49
leaq 0x40(%rbx), %r8
leaq -0x28(%rbp), %rdi
movq $0x0, -0x8(%rdi)
leaq -0x30(%rbp), %rsi
leaq -0x11(%rbp), %rdx
leaq -0x60(%rbp), %rcx
callq 0x6001a
movups -0x30(%rbp), %xmm0
movups %xmm0, -0x40(%rbp)
cmpb $0x1, 0x8(%rbx)
jne 0x30b2b
leaq -0x28(%rbp), %rdi
movq $0x0, -0x8(%rdi)
leaq -0x30(%rbp), %rsi
leaq -0x11(%rbp), %rdx
leaq -0x40(%rbp), %rcx
callq 0x6010e
movaps -0x30(%rbp), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, -0x30(%rbp)
movq -0x38(%rbp), %rdi
movups %xmm0, -0x40(%rbp)
testq %rdi, %rdi
je 0x30b2b
callq 0x43a1a
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x30b2b
callq 0x43a1a
leaq 0x98(%rbx), %rdi
leaq -0x40(%rbp), %rsi
callq 0x4036c
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x30b49
callq 0x43a1a
movq $0x0, 0x48(%rbx)
movq 0x40(%rbx), %rax
xorl %ecx, %ecx
movb %cl, (%rax)
movb %cl, 0x8(%rbx)
movl $0x0, (%rbx)
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x30b74
callq 0x1b4d0
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x30b7f
movq %rax, %rbx
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x30b95
callq 0x43a1a
jmp 0x30b95
movq %rax, %rbx
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x30ba7
callq 0x1b4d0
movq %rbx, %rdi
callq 0x1b910
nop
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::(anonymous namespace)::estimateClockResolution()
auto estimateClockResolution() -> uint64_t {
            uint64_t sum = 0;
            static const uint64_t iterations = 1000000;

            auto startTime = getCurrentNanosecondsSinceEpoch();

            for( std::size_t i = 0; i < iterations; ++i ) {

                uint64_t ticks;
                uint64_t baseTicks = getCurrentNanosecondsSinceEpoch();
                do {
                    ticks = getCurrentNanosecondsSinceEpoch();
                } while( ticks == baseTicks );

                auto delta = ticks - baseTicks;
                sum += delta;

                // If we have been calibrating for over 3 seconds -- the clock
                // is terrible and we should move on.
                // TBD: How to signal that the measured resolution is probably wrong?
                if (ticks > startTime + 3 * nanosecondsInSecond) {
                    return sum / ( i + 1u );
                }
            }

            // We're just taking the mean, here. To do better we could take the std. dev and exclude outliers
            // - and potentially do more iterations if there's a high variance.
            return sum/iterations;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x1b090
movl $0xb2d05e00, %r15d      # imm = 0xB2D05E00
addq %rax, %r15
xorl %r12d, %r12d
xorl %ebx, %ebx
xorl %r13d, %r13d
callq 0x1b090
movq %rax, %r14
callq 0x1b090
movq %rax, %rcx
subq %r14, %rcx
je 0x311aa
addq %rcx, %rbx
leaq 0x1(%r13), %rcx
cmpq %r15, %rax
ja 0x311e1
cmpq $0xf423f, %r13          # imm = 0xF423F
setae %r12b
movq %rcx, %r13
cmpq $0xf4240, %rcx          # imm = 0xF4240
jne 0x311a2
movl $0xf4240, %ecx          # imm = 0xF4240
jmp 0x311ee
testb $0x1, %r12b
movl $0xf4240, %eax          # imm = 0xF4240
cmovneq %rax, %rcx
movq %rbx, %rax
xorl %edx, %edx
divq %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2d4e2
movq 0x10(%r12), %rdi
leaq 0x4a66a(%rip), %rsi     # 0x7b914
movl $0x2, %edx
callq 0x1b5e0
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rcx), %rdx
leaq (%rax,%rdx), %r12
cmpb $0x0, 0xe1(%rax,%rdx)
jne 0x312ea
movq %r12, %rdi
movl $0x20, %esi
callq 0x1b4f0
movb $0x1, 0xe1(%r12)
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movb $0x30, 0xe0(%r12)
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 0x31335
movq -0x28(%rbp), %rdi
movq (%rdi), %rcx
movq -0x18(%rcx), %rcx
movq $0x2, 0x10(%rdi,%rcx)
movzbl -0x1(%r14,%rax), %esi
callq 0x1b350
movq %r15, %rax
jmp 0x3130b
movq -0x28(%rbp), %rsi
addq $0x8, %rsi
movq %rbx, %rdi
callq 0x1b7f0
leaq -0x38(%rbp), %rdi
callq 0x2d528
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x31362
jmp 0x31362
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x2d528
movq %rbx, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O3/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
leaq 0x7961c(%rip), %r15     # 0xaa9b0
movq (%r15), %rdi
testq %rdi, %rdi
je 0x313a1
movq (%rdi), %rax
jmp 0x313d2
movl $0x30, %edi
callq 0x1b510
movq %rax, %rdi
leaq 0x7497b(%rip), %rcx     # 0xa5d30
leaq 0x10(%rcx), %rax
movq %rax, (%rdi)
addq $0x60, %rcx
movq %rcx, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
movq %rdi, (%r15)
callq *0x20(%rax)
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x50(%rax)
testb %al, %al
je 0x31460
leaq 0x10(%rbx), %rax
movq %rax, -0x30(%rbp)
movq %rax, (%rbx)
leaq 0x4a373(%rip), %rsi     # 0x7b767
leaq 0x4a36d(%rip), %rdx     # 0x7b768
movq %rbx, %rdi
callq 0x431c8
movq 0x8(%r14), %r12
testq %r12, %r12
je 0x3144f
movq (%r14), %r14
xorl %r13d, %r13d
leaq 0x4f893(%rip), %r15     # 0x80cac
movzbl (%r14,%r13), %eax
movq %r15, %rsi
cmpl $0x9, %eax
je 0x31432
cmpl $0xa, %eax
jne 0x3143c
leaq 0x4f8c8(%rip), %rsi     # 0x80cfa
movq %rbx, %rdi
callq 0x1b9d0
jmp 0x31447
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1b480
incq %r13
cmpq %r13, %r12
jne 0x31419
leaq 0x4a311(%rip), %rsi     # 0x7b767
movq %rbx, %rdi
callq 0x1b9d0
jmp 0x314de
leaq -0x50(%rbp), %r15
movq %r15, %rdi
movl $0x22, %esi
movq %r14, %rdx
callq 0x403b9
movq 0x8(%r15), %rsi
movl $0x1, %ecx
movq %r15, %rdi
xorl %edx, %edx
movl $0x22, %r8d
callq 0x1b980
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x314af
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x314b5
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x314de
callq 0x1b4d0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x31504
movq %rax, %r14
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0x31510
jmp 0x31515
movq %rax, %r14
movq (%rbx), %rdi
cmpq -0x30(%rbp), %rdi
je 0x31515
callq 0x1b4d0
movq %r14, %rdi
callq 0x1b910
nop