LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2ef75
leaq -0x88(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x5feca
testb $0x1, %dl
je 0x2ef8e
addq $0xb8, %rbx
cmpq %r12, %rbx
jne 0x2ef59
leaq -0x88(%rbp), %rdi
callq 0x4a208
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x38(%rbp), %rdi
callq 0x2d4f4
movq -0x28(%rbp), %rdi
leaq 0x4d7b0(%rip), %rsi     # 0x7c755
movl $0x13, %edx
callq 0x1b5e0
movq -0x28(%rbp), %rdi
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
callq 0x1b5e0
movq -0x28(%rbp), %rdi
leaq 0x4d79f(%rip), %rsi     # 0x7c769
movl $0x15, %edx
callq 0x1b5e0
movq -0x28(%rbp), %rdi
leaq 0x4d7a0(%rip), %rsi     # 0x7c77f
movl $0xf, %edx
callq 0x1b5e0
addq $0xb0, %r14
movq -0x28(%rbp), %rdi
movq %r14, %rsi
callq 0x22e23
movq -0x28(%rbp), %rdi
leaq 0x55b7b(%rip), %rsi     # 0x84b82
movl $0x1, %edx
callq 0x1b5e0
movq -0x28(%rbp), %rdi
leaq 0x4d773(%rip), %rsi     # 0x7c78f
movl $0xe, %edx
callq 0x1b5e0
addq $0x90, %rbx
movq -0x28(%rbp), %rdi
movq %rbx, %rsi
callq 0x22e23
movq -0x28(%rbp), %rsi
addq $0x8, %rsi
leaq -0x58(%rbp), %rdi
callq 0x1b7f0
leaq -0x58(%rbp), %rdi
callq 0x1cf52
movq %rax, %rbx
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2f06d
callq 0x1b4d0
jmp 0x2f06d
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x2d53a
jmp 0x2f07d
jmp 0x2f07a
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x4a208
movq %rbx, %rdi
callq 0x1b910
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4ad3e
cmpq $0x0, 0x8(%r15)
je 0x2f0f4
addq $0x8, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x40356
jmp 0x2f1dd
leaq -0x38(%rbp), %rdi
callq 0x2d4f4
movq -0x28(%rbp), %rdi
leaq 0x4d696(%rip), %rsi     # 0x7c79e
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 0x2ea44
movq (%rbx), %rax
leaq -0x130(%rbp), %rsi
movq %rbx, %rdi
callq *0x20(%rax)
movq -0x80(%rbp), %rdi
testq %rdi, %rdi
je 0x2f168
callq 0x43ca8
leaq -0xb8(%rbp), %rdi
callq 0x3ff72
leaq -0xd0(%rbp), %rbx
movq %rbx, %rdi
callq 0x3ff72
movq -0x20(%rbx), %rdi
leaq -0xe0(%rbp), %rax
cmpq %rax, %rdi
je 0x2f198
callq 0x1b4d0
leaq -0x100(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2f1ad
callq 0x1b4d0
leaq -0x120(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2f1c2
callq 0x1b4d0
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2f1d4
callq 0x1b4d0
leaq -0x38(%rbp), %rdi
callq 0x2d53a
movq -0x78(%rbp), %rdi
cmpq %r12, %rdi
je 0x2f1eb
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 0x40094
jmp 0x2f20f
movq %rax, %rbx
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2f22f
callq 0x1b4d0
jmp 0x2f22f
jmp 0x2f22c
jmp 0x2f227
movq %rax, %rbx
jmp 0x2f238
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x2d53a
movq -0x78(%rbp), %rdi
cmpq %r12, %rdi
je 0x2f246
callq 0x1b4d0
movq %rbx, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2f280
leaq 0x8(%rbx), %rdi
callq 0x2ef1b
leaq 0x28(%rbx), %r15
movl 0x20(%rbx), %r12d
movq (%r14), %rax
movq %r14, %rdi
callq *0x80(%rax)
cmpl %eax, %r12d
jne 0x2f2a7
movq 0x28(%rbx), %rax
cmpq 0x30(%rbx), %rax
jne 0x2f32a
leaq 0x8(%rbx), %rdx
leaq -0x58(%rbp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x2eb38
xorps %xmm0, %xmm0
leaq -0x40(%rbp), %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x28(%rbx), %rax
movups 0x30(%rbx), %xmm0
movq (%r12), %rcx
movq %rcx, 0x28(%rbx)
movq 0x8(%r12), %rcx
movq %rcx, 0x30(%rbx)
movq 0x10(%r12), %rcx
movq %rcx, 0x38(%rbx)
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
movq 0x10(%rdi), %rsi
movq %rax, (%rdi)
movups %xmm0, 0x8(%rdi)
movq %rcx, (%r12)
movq %rdx, 0x8(%r12)
movq %rsi, 0x10(%r12)
callq 0x3f392
movq %r12, %rdi
callq 0x3f392
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_O1/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 0x43438
cmpq $0x0, 0x8(%rbx)
je 0x2f408
movq (%rbx), %rax
cmpb $0x26, (%rax)
jne 0x2f408
leaq 0x4d418(%rip), %r14     # 0x7c7b3
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 0x2f408
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 0x2f428
callq 0x1b4d0
movq %r14, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O1/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 %rdi, %r12
movq 0x48(%rsi), %r14
movq 0x50(%rsi), %rcx
movq %rdx, -0x40(%rbp)
movq %rcx, %rbx
subq %r14, %rbx
movq %rbx, %r13
sarq $0x6, %r13
testq %r13, %r13
jle 0x2f670
movq %rcx, -0x30(%rbp)
movq %r12, -0x38(%rbp)
andq $-0x40, %rbx
addq %r14, %rbx
incq %r13
leaq -0x40(%rbp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x3dffe
testb %al, %al
jne 0x2f6a8
leaq 0x10(%r14), %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0x3dffe
testb %al, %al
jne 0x2f6ab
leaq 0x20(%r14), %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0x3dffe
testb %al, %al
jne 0x2f6ab
leaq 0x30(%r14), %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0x3dffe
testb %al, %al
jne 0x2f6ab
addq $0x40, %r14
decq %r13
cmpq $0x1, %r13
jg 0x2f60c
movq %rbx, %r14
movq -0x38(%rbp), %r12
movq -0x30(%rbp), %rcx
movq %rcx, %rax
subq %r14, %rax
sarq $0x4, %rax
cmpq $0x1, %rax
je 0x2f6d0
cmpq $0x2, %rax
je 0x2f6b5
movq %rcx, %r15
cmpq $0x3, %rax
jne 0x2f6f1
movq %rcx, %rbx
leaq -0x40(%rbp), %rdi
movq %r14, %rsi
callq 0x3dffe
testb %al, %al
jne 0x2f6c8
addq $0x10, %r14
jmp 0x2f6b8
movq %r14, %r15
movq -0x38(%rbp), %r12
movq -0x30(%rbp), %rcx
jmp 0x2f6f1
movq %rcx, %rbx
leaq -0x40(%rbp), %rdi
movq %r14, %rsi
callq 0x3dffe
testb %al, %al
je 0x2f6d5
movq %r14, %r15
movq %rbx, %rcx
jmp 0x2f6f1
movq %rcx, %rbx
jmp 0x2f6d9
addq $0x10, %r14
leaq -0x40(%rbp), %rdi
movq %r14, %rsi
callq 0x3dffe
testb %al, %al
movq %rbx, %rcx
cmoveq %rbx, %r14
movq %r14, %r15
cmpq %rcx, %r15
je 0x2f71c
movq (%r15), %rax
movq %rax, (%r12)
movq 0x8(%r15), %rax
movq %rax, 0x8(%r12)
testq %rax, %rax
je 0x2f72a
movq 0x7c87e(%rip), %rcx     # 0xabf90
cmpb $0x0, (%rcx)
je 0x2f726
incl 0x8(%rax)
jmp 0x2f72a
xorps %xmm0, %xmm0
movups %xmm0, (%r12)
jmp 0x2f72a
lock
incl 0x8(%rax)
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2f78b
movl $0x2, 0x60(%rdi)
movq 0x40(%rdi), %rdi
testq %rdi, %rdi
je 0x2f78b
movq (%rdi), %rax
popq %rbp
jmpq *0x68(%rax)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2f7c1
movq (%rdi), %rax
popq %rbp
jmpq *0x68(%rax)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2facd
movq (%rdi), %rax
callq *0x50(%rax)
movq 0x40(%rbx), %rax
testq %rax, %rax
je 0x2faec
movq 0x38(%rbx), %rcx
movq %rax, 0x10(%rcx)
movl $0x2, 0x18(%rcx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x4ccca(%rip), %rdi     # 0x7c7bd
leaq 0x4c3db(%rip), %rsi     # 0x7bed5
leaq 0x4cd28(%rip), %rcx     # 0x7c829
movl $0x38a4, %edx           # imm = 0x38A4
callq 0x1b320
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x78798(%rip), %rax     # 0xa82d0
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 0x4ad3e
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 0x78873(%rip), %rax     # 0xa83f0
addq $0x10, %rax
movq %rax, (%rbx)
movups %xmm0, 0x68(%rbx)
movq $0x0, 0x78(%rbx)
leaq 0x80(%rbx), %rdi
movq %r15, %rsi
callq 0x2326f
testq %r14, %r14
je 0x2fbce
movq (%r14), %rax
movq %r14, %rdi
callq *0x70(%rax)
testb %al, %al
jne 0x2fbbf
movq (%r14), %rax
movq %r14, %rdi
callq *0x38(%rax)
movq %rax, %r14
jmp 0x2fba4
addq $0x68, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2fc12
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2fbde
movq %rax, %r14
jmp 0x2fbf9
movq %rax, %r14
movq 0x80(%rbx), %rdi
leaq 0x90(%rbx), %rax
cmpq %rax, %rdi
je 0x2fbf9
callq 0x1b4d0
leaq 0x68(%rbx), %rdi
callq 0x3ff72
movq %rbx, %rdi
callq 0x426fc
movq %r14, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2fc7b
leaq 0x4c23b(%rip), %rsi     # 0x7be93
callq 0x1b140
testl %eax, %eax
je 0x2fc7b
movq 0x68(%rbx), %rdi
movq 0x70(%rbx), %rsi
leaq 0x80(%rbx), %rdx
callq 0x5b656
cmpq 0x70(%rbx), %rax
je 0x2fc8e
movl 0x60(%rbx), %eax
andl $-0x2, %eax
cmpl $0x4, %eax
sete %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movb $0x1, %al
jmp 0x2fc87
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7871b(%rip), %rax     # 0xa8480
addq $0x10, %rax
movq %rax, (%rdi)
callq 0x3cfe8
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
movq %r13, %rsi
callq 0x2f35a
leaq -0x100(%rbp), %rdi
leaq -0x48(%rbp), %rdx
movq %r12, %rsi
movq %r14, %rcx
movq %r15, %r8
callq 0x2e0e8
addq $0x8, %rbx
movq (%rbx), %rax
leaq -0x100(%rbp), %rsi
movq %rbx, %rdi
callq *0x20(%rax)
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x2fdbb
callq 0x43ca8
leaq -0x88(%rbp), %rdi
callq 0x3ff72
leaq -0xa0(%rbp), %rbx
movq %rbx, %rdi
callq 0x3ff72
movq -0x20(%rbx), %rdi
leaq -0xb0(%rbp), %rax
cmpq %rax, %rdi
je 0x2fdeb
callq 0x1b4d0
leaq -0xd0(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2fe00
callq 0x1b4d0
leaq -0xf0(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2fe15
callq 0x1b4d0
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2fe27
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 0x40094
jmp 0x2fe4d
movq %rax, %rbx
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2fe66
callq 0x1b4d0
jmp 0x2fe66
jmp 0x2fe63
movq %rax, %rbx
movq %rbx, %rdi
callq 0x1b1f0
callq 0x3cfe8
movq %rax, %rdi
addq $0x8, %rdi
movq 0x8(%rax), %rax
callq *0x38(%rax)
callq 0x1b850
jmp 0x2fe27
movq %rax, %rdi
callq 0x3ec84
// File: /workspace/github_cpp_makefile_star2_O1/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 0x30472
movq (%r14), %rax
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
movq %rbx, %rdi
callq 0x1b150
addq $0x10, %r14
jmp 0x30454
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x3048e
callq 0x1b4d0
movq %r14, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O1/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 0x40522
movq (%rbx), %r12
movq 0x8(%rbx), %rax
movq %rax, -0x58(%rbp)
cmpq %rax, %r12
je 0x3061c
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 0x30568
testb $0x10, 0xa0(%r15)
je 0x3052b
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
testb %al, %al
je 0x3055f
movq %r12, %rdi
movq %r15, %rsi
callq 0x3030e
testb %al, %al
je 0x3055f
movq %r15, -0x68(%rbp)
movq -0x48(%rbp), %rsi
cmpq -0x40(%rbp), %rsi
je 0x30552
movq %r15, (%rsi)
addq $0x8, -0x48(%rbp)
jmp 0x3055f
leaq -0x50(%rbp), %rdi
leaq -0x68(%rbp), %rdx
callq 0x60a50
addq $0xb8, %r15
jmp 0x3050f
leaq -0xa0(%rbp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x3042c
leaq -0x80(%rbp), %rbx
movq %rbx, %rdi
leaq -0x50(%rbp), %rsi
callq 0x609d0
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x30598
callq 0x1b4d0
movq %r13, %rdi
movq %r15, %rsi
callq 0x1b640
movq 0x20(%r13), %rdi
movups 0x28(%r13), %xmm0
movq -0x80(%rbp), %rax
movq %rax, 0x20(%r13)
movq -0x78(%rbp), %rax
movq %rax, 0x28(%r13)
movq -0x70(%rbp), %rax
movq %rax, 0x30(%r13)
movq %rdi, -0x80(%rbp)
movups %xmm0, -0x78(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
testq %rdi, %rdi
je 0x305e4
callq 0x1b4d0
movq -0x80(%rbp), %rdi
testq %rdi, %rdi
je 0x305f2
callq 0x1b4d0
movq -0xa0(%rbp), %rdi
leaq -0x90(%rbp), %rax
cmpq %rax, %rdi
je 0x3060a
callq 0x1b4d0
addq $0x18, %r12
addq $0x38, %r13
cmpq -0x58(%rbp), %r12
jne 0x304f5
movq -0x30(%rbp), %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x30650
movq %rax, %rbx
movq -0xa0(%rbp), %rdi
leaq -0x90(%rbp), %rax
cmpq %rax, %rdi
je 0x30653
callq 0x1b4d0
jmp 0x30653
jmp 0x30650
movq %rax, %rbx
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x30661
callq 0x1b4d0
movq -0x30(%rbp), %rdi
callq 0x405ba
movq %rbx, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O1/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 0x30748
movq %rbx, %rdi
callq 0x30922
leaq 0x40(%rbx), %rdi
movsbl %r15b, %r14d
movl %r14d, %esi
callq 0x1b480
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
cmpl $0x4, %eax
sete %cl
cmpb $0x2c, %r15b
setne %dl
orb %cl, %dl
jne 0x3076b
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x30964
movsbl %r15b, %r14d
cmpl $0x4, %eax
je 0x307a4
cmpl $0x1, %eax
je 0x30797
testl %eax, %eax
jne 0x307b5
cmpl $0x5a, %r14d
jg 0x307ca
cmpl $0x20, %r14d
je 0x3073b
cmpl $0x22, %r14d
jne 0x307dc
movl $0x2, (%rbx)
jmp 0x307ea
movq %rbx, %rdi
movl %r14d, %esi
callq 0x30a04
jmp 0x307ea
movq %rbx, %rdi
callq 0x3083c
leaq 0x40(%rbx), %rdi
jmp 0x30723
movq %rbx, %rdi
movl %r14d, %esi
callq 0x30a42
testb %al, %al
jne 0x3073b
jmp 0x307ea
cmpl $0x5b, %r14d
je 0x307e4
cmpl $0x7e, %r14d
jne 0x307dc
movb $0x1, 0x8(%rbx)
jmp 0x307ea
movl $0x1, (%rbx)
jmp 0x307ea
movl $0x3, (%rbx)
leaq 0x40(%rbx), %rdi
movl %r14d, %esi
callq 0x1b480
movl (%rbx), %eax
cmpq $0x4, %rax
ja 0x3072b
leaq 0x49957(%rip), %rcx     # 0x7a160
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpb $0x7e, %r15b
jmp 0x3082c
addb $-0x5b, %r15b
testb $-0x3, %r15b
jmp 0x3082c
cmpb $0x5b, %r15b
jmp 0x3082c
cmpb $0x22, %r15b
sete %al
testb %al, %al
je 0x3072b
jmp 0x3073b
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3085b
cmpl $0x3, %eax
je 0x30861
cmpl $0x4, %eax
jne 0x30867
movl 0x4(%rdi), %eax
movl %eax, (%rdi)
jmp 0x3086d
popq %rbp
jmp 0x30af8
popq %rbp
jmp 0x30c1c
movl $0x0, (%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3098d
movq %rbx, %rdi
callq 0x3083c
movq %rbx, %rdi
callq 0x30870
jmp 0x309b5
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_O1/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 0x309dd
cmpl $0x20, %esi
je 0x309f5
cmpl $0x22, %esi
jne 0x309ed
movl $0x2, (%rdi)
jmp 0x309ff
cmpl $0x5b, %esi
je 0x309f9
cmpl $0x7e, %esi
jne 0x309ed
movb $0x1, 0x8(%rdi)
jmp 0x309ff
movl $0x1, (%rdi)
jmp 0x309ff
movb $0x1, %al
jmp 0x30a01
movl $0x3, (%rdi)
xorl %eax, %eax
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x30a41
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x40, %rdi
leaq 0x4bed9(%rip), %rsi     # 0x7c8f7
callq 0x1b140
testl %eax, %eax
je 0x30a31
movq %rbx, %rdi
callq 0x3083c
jmp 0x30a35
movb $0x1, 0x8(%rbx)
movl $0x3, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
movq %rdi, %rbx
movl (%rdi), %eax
cmpq $0x4, %rax
ja 0x30aa6
leaq 0x49719(%rip), %rcx     # 0x7a174
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpb $0x7e, %sil
jmp 0x30a80
movb $0x1, %r14b
jmp 0x30a84
cmpb $0x22, %sil
jmp 0x30a80
leal -0x5b(%rsi), %eax
testb $-0x3, %al
jmp 0x30a80
cmpb $0x5b, %sil
sete %r14b
testb %r14b, %r14b
je 0x30a9e
leaq 0x40(%rbx), %rdi
movsbl %sil, %esi
callq 0x1b480
movq %rbx, %rdi
callq 0x3083c
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
xorl %r14d, %r14d
jmp 0x30a84
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x30aeb
leaq 0x496c9(%rip), %rcx     # 0x7a188
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cmpb $0x7e, %sil
jmp 0x30ae6
movb $0x1, %al
jmp 0x30ae9
cmpb $0x22, %sil
jmp 0x30ae6
addb $-0x5b, %sil
testb $-0x3, %sil
jmp 0x30ae6
cmpb $0x5b, %sil
sete %al
popq %rbp
retq
xorl %eax, %eax
jmp 0x30ae9
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x30e20
cmpq $0x0, 0x8(%r14)
je 0x30bb5
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 0x60d6c
movups -0x30(%rbp), %xmm0
movups %xmm0, -0x40(%rbp)
cmpb $0x1, 0x8(%rbx)
jne 0x30b97
leaq -0x28(%rbp), %rdi
movq $0x0, -0x8(%rdi)
leaq -0x30(%rbp), %rsi
leaq -0x11(%rbp), %rdx
leaq -0x40(%rbp), %rcx
callq 0x60e66
movaps -0x30(%rbp), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, -0x30(%rbp)
movq -0x38(%rbp), %rdi
movups %xmm0, -0x40(%rbp)
testq %rdi, %rdi
je 0x30b89
callq 0x43ca8
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x30b97
callq 0x43ca8
leaq 0x98(%rbx), %rdi
leaq -0x40(%rbp), %rsi
callq 0x4062a
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x30bb5
callq 0x43ca8
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 0x30be0
callq 0x1b4d0
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x30beb
movq %rax, %rbx
movq -0x38(%rbp), %rdi
testq %rdi, %rdi
je 0x30c01
callq 0x43ca8
jmp 0x30c01
movq %rax, %rbx
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x30c13
callq 0x1b4d0
movq %rbx, %rdi
callq 0x1b910
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, %r13d      # imm = 0xB2D05E00
addq %rax, %r13
xorl %r12d, %r12d
xorl %r14d, %r14d
xorl %ebx, %ebx
callq 0x1b090
movq %rax, %r15
callq 0x1b090
movq %rax, %rcx
subq %r15, %rax
je 0x31211
addq %rax, %r14
cmpq %r13, %rcx
jbe 0x31236
leaq 0x1(%rbx), %rsi
movq %r14, %rax
xorl %edx, %edx
divq %rsi
movq %rax, -0x30(%rbp)
cmpq %r13, %rcx
ja 0x31255
cmpq $0xf423f, %rbx          # imm = 0xF423F
leaq 0x1(%rbx), %rax
setae %r12b
movq %rax, %rbx
cmpq $0xf4240, %rax          # imm = 0xF4240
jne 0x31209
movabsq $0x431bde82d7b634db, %rcx # imm = 0x431BDE82D7B634DB
movq %r14, %rax
mulq %rcx
shrq $0x12, %rdx
testb $0x1, %r12b
movq -0x30(%rbp), %rax
cmovneq %rdx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2d4f4
movq 0x10(%r12), %rdi
leaq 0x4b5ec(%rip), %rsi     # 0x7c914
movl $0x2, %edx
callq 0x1b5e0
movq -0x28(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
leaq (%rax,%rcx), %r12
cmpb $0x0, 0xe1(%rax,%rcx)
jne 0x31369
movq %r12, %rdi
movl $0x20, %esi
callq 0x1b4f0
movb %al, 0xe0(%r12)
movb $0x1, 0xe1(%r12)
movb $0x30, 0xe0(%r12)
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 0x313bb
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 0x31391
movq -0x28(%rbp), %rsi
addq $0x8, %rsi
movq %rbx, %rdi
callq 0x1b7f0
leaq -0x38(%rbp), %rdi
callq 0x2d53a
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x313e8
jmp 0x313e8
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x2d53a
movq %rbx, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7b596(%rip), %r15     # 0xac9b0
cmpq $0x0, (%r15)
jne 0x31451
movl $0x30, %edi
callq 0x1b510
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
leaq 0x76791(%rip), %rcx     # 0xa7bd0
leaq 0x10(%rcx), %rdx
movq %rdx, (%rax)
addq $0x60, %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%r15)
movq (%r15), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x50(%rax)
testb %al, %al
je 0x314e5
leaq 0x10(%rbx), %rax
movq %rax, -0x30(%rbp)
movq %rax, (%rbx)
leaq 0x4b2ee(%rip), %rsi     # 0x7c767
leaq 0x4b2e8(%rip), %rdx     # 0x7c768
movq %rbx, %rdi
callq 0x43438
movq 0x8(%r14), %r12
testq %r12, %r12
je 0x314d4
movq (%r14), %r14
xorl %r13d, %r13d
leaq 0x5083e(%rip), %r15     # 0x81cdc
movzbl (%r14,%r13), %eax
movq %r15, %rsi
cmpl $0x9, %eax
je 0x314b7
cmpl $0xa, %eax
jne 0x314c1
leaq 0x50873(%rip), %rsi     # 0x81d2a
movq %rbx, %rdi
callq 0x1b9d0
jmp 0x314cc
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1b480
incq %r13
cmpq %r13, %r12
jne 0x3149e
leaq 0x4b28c(%rip), %rsi     # 0x7c767
movq %rbx, %rdi
callq 0x1b9d0
jmp 0x31563
leaq -0x50(%rbp), %r15
movq %r15, %rdi
movl $0x22, %esi
movq %r14, %rdx
callq 0x40670
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 0x31534
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x3153a
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 0x31563
callq 0x1b4d0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x31589
movq %rax, %r14
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0x31595
jmp 0x3159a
movq %rax, %r14
movq (%rbx), %rdi
cmpq -0x30(%rbp), %rdi
je 0x3159a
callq 0x1b4d0
movq %r14, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
testq %rsi, %rsi
je 0x315fb
movq %rsi, %r14
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq %rsi, %rdi
callq 0x1b220
leaq (%rax,%r14), %rdx
leaq -0x40(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x43438
movq %rbx, %rdi
movq %r15, %rsi
callq 0x313fc
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x31618
callq 0x1b4d0
jmp 0x31618
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x4b2fb(%rip), %rsi     # 0x7c904
leaq 0x4b301(%rip), %rdx     # 0x7c911
movq %rbx, %rdi
callq 0x43438
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x31639
callq 0x1b4d0
movq %rbx, %rdi
callq 0x1b910
nop
// File: /workspace/github_cpp_makefile_star2_O1/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::StringMaker<char*, void>::convert[abi:cxx11](char*)
std::string StringMaker<char*>::convert(char* str) {
    if (str) {
        return ::Catch::Detail::stringify(std::string{ str });
    } else {
        return{ "{null string}" };
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
testq %rsi, %rsi
je 0x3169b
movq %rsi, %r14
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq %rsi, %rdi
callq 0x1b220
leaq (%rax,%r14), %rdx
leaq -0x40(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x43438
movq %rbx, %rdi
movq %r15, %rsi
callq 0x313fc
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x316b8
callq 0x1b4d0
jmp 0x316b8
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x4b25b(%rip), %rsi     # 0x7c904
leaq 0x4b261(%rip), %rdx     # 0x7c911
movq %rbx, %rdi
callq 0x43438
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x316d9
callq 0x1b4d0
movq %rbx, %rdi
callq 0x1b910
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x40(%rbp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x8(%rsi), %rsi
leaq -0x50(%rbp), %rdi
callq 0x1b7e0
movq %rbx, -0x30(%rbp)
movq 0x8(%r14), %r12
testq %r12, %r12
je 0x3175a
movq (%r14), %r13
shlq $0x2, %r12
xorl %r15d, %r15d
movl $0x3f, %ebx
leaq -0x50(%rbp), %r14
movl (%r13,%r15), %eax
cmpl $0x100, %eax            # imm = 0x100
cmovgel %ebx, %eax
movsbl %al, %esi
movq %r14, %rdi
callq 0x1b480
addq $0x4, %r15
cmpq %r15, %r12
jne 0x31739
leaq -0x50(%rbp), %rsi
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x313fc
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x3177c
callq 0x1b4d0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x31790
movq %rax, %rbx
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x317a5
callq 0x1b4d0
movq %rbx, %rdi
callq 0x1b910
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
testq %rsi, %rsi
je 0x31807
movq %rsi, %r14
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq %rsi, %rdi
callq 0x1b440
leaq (%r14,%rax,4), %rdx
leaq -0x40(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x612d2
movq %rbx, %rdi
movq %r15, %rsi
callq 0x316e2
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x31824
callq 0x1b4d0
jmp 0x31824
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x4b0ef(%rip), %rsi     # 0x7c904
leaq 0x4b0f5(%rip), %rdx     # 0x7c911
movq %rbx, %rdi
callq 0x43438
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x31845
callq 0x1b4d0
movq %rbx, %rdi
callq 0x1b910
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
testq %rsi, %rsi
je 0x318a7
movq %rsi, %r14
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq %rsi, %rdi
callq 0x1b440
leaq (%r14,%rax,4), %rdx
leaq -0x40(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x612d2
movq %rbx, %rdi
movq %r15, %rsi
callq 0x316e2
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x318c4
callq 0x1b4d0
jmp 0x318c4
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x4b04f(%rip), %rsi     # 0x7c904
leaq 0x4b055(%rip), %rdx     # 0x7c911
movq %rbx, %rdi
callq 0x43438
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x318e5
callq 0x1b4d0
movq %rbx, %rdi
callq 0x1b910
nop
// File: /workspace/github_cpp_makefile_star2_O1/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::StringMaker<long long, void>::convert[abi:cxx11](long long)
std::string StringMaker<long long>::convert(long long value) {
    ReusableStringStream rss;
    rss << value;
    if (value > Detail::hexThreshold) {
        rss << " (0x" << std::hex << value << ')';
    }
    return rss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x38(%rbp), %r15
movq %r15, %rdi
callq 0x2d4f4
movq 0x10(%r15), %rdi
movq %r14, %rsi
callq 0x1b190
cmpq $0x100, %r14            # imm = 0x100
jl 0x319a1
movq -0x28(%rbp), %rdi
leaq 0x4afb1(%rip), %rsi     # 0x7c912
movl $0x4, %edx
callq 0x1b5e0
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
movl 0x18(%rdi,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%rdi,%rax)
movq %r14, %rsi
callq 0x1b190
movq -0x28(%rbp), %rdi
leaq -0x19(%rbp), %rsi
movb $0x29, (%rsi)
movl $0x1, %edx
callq 0x1b5e0
movq -0x28(%rbp), %rsi
addq $0x8, %rsi
movq %rbx, %rdi
callq 0x1b7f0
leaq -0x38(%rbp), %rdi
callq 0x2d53a
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x319ca
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x2d53a
movq %rbx, %rdi
callq 0x1b910