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::SimplePcg32::operator()()
SimplePcg32::result_type SimplePcg32::operator()() {
        // prepare the output value
        const uint32_t xorshifted = static_cast<uint32_t>(((m_state >> 18u) ^ m_state) >> 27u);
        const auto output = rotate_right(xorshifted, m_state >> 59u);

        // advance state
        m_state = m_state * 6364136223846793005ULL + s_inc;

        return output;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rax
movq %rax, %rdx
movq %rax, %rcx
movabsq $0x5851f42d4c957f2d, %rsi # imm = 0x5851F42D4C957F2D
imulq %rax, %rsi
shrq $0x2d, %rax
shrq $0x1b, %rdx
xorl %edx, %eax
shrq $0x3b, %rcx
rorl %cl, %eax
movabsq $0x27da198a7f2728ed, %rcx # imm = 0x27DA198A7F2728ED
addq %rsi, %rcx
movq %rcx, (%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::SimplePcg32::discard(unsigned long)
void SimplePcg32::discard(uint64_t skip) {
        // We could implement this to run in O(log n) steps, but this
        // should suffice for our use case.
        for (uint64_t s = 0; s < skip; ++s) {
            static_cast<void>((*this)());
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
testq %rsi, %rsi
je 0x28da3
movq (%rdi), %rax
movabsq $0x5851f42d4c957f2d, %rcx # imm = 0x5851F42D4C957F2D
movabsq $0x27da198a7f2728ed, %rdx # imm = 0x27DA198A7F2728ED
imulq %rcx, %rax
addq %rdx, %rax
decq %rsi
jne 0x28d94
movq %rax, (%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::cleanupSingletons()
void cleanupSingletons() {
        auto& singletons = getSingletons();
        for( auto singleton : *singletons )
            delete singleton;
        delete singletons;
        singletons = nullptr;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
cmpq $0x0, 0x84017(%rip)     # 0xacdf8
jne 0x28e02
movl $0x18, %edi
callq 0x1b510
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rax, 0x83ff6(%rip)     # 0xacdf8
movq 0x83fef(%rip), %rax     # 0xacdf8
movq (%rax), %rbx
movq 0x8(%rax), %r14
cmpq %r14, %rbx
je 0x28e29
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x28e23
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %rbx
jmp 0x28e10
movq 0x83fc8(%rip), %rbx     # 0xacdf8
testq %rbx, %rbx
je 0x28e4a
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x28e42
callq 0x1b4d0
movq %rbx, %rdi
callq 0x1b4d0
movq $0x0, 0x83fa3(%rip) # 0xacdf8
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::ReporterRegistry::create(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::shared_ptr<Catch::IConfig const> const&) const
IStreamingReporterPtr ReporterRegistry::create( std::string const& name, IConfigPtr const& config ) const {
        auto it =  m_factories.find( name );
        if( it == m_factories.end() )
            return nullptr;
        return it->second->create( ReporterConfig( config ) );
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsi), %rdi
movq %rdx, %rsi
callq 0x4b0be
addq $0x10, %r15
cmpq %r15, %rax
je 0x28f07
movq 0x40(%rax), %r15
leaq -0x38(%rbp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x24934
movq (%r15), %rax
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq *0x10(%rax)
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x28f0e
callq 0x43ca8
jmp 0x28f0e
movq $0x0, (%rbx)
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x28f2f
callq 0x43ca8
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::TestCaseTracking::TrackerContext::startRun()
ITracker& TrackerContext::startRun() {
        m_rootTracker = std::make_shared<SectionTracker>( NameAndLocation( "{root}", CATCH_INTERNAL_LINEINFO ), *this, nullptr );
        m_currentTracker = nullptr;
        m_runState = Executing;
        return *m_rootTracker;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
leaq -0x48(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x52e6a(%rip), %rsi     # 0x7c7b6
leaq 0x52e69(%rip), %rdx     # 0x7c7bc
leaq -0x58(%rbp), %r14
movq %r14, %rdi
callq 0x43438
leaq 0x5256f(%rip), %rax     # 0x7bed5
leaq -0x98(%rbp), %rdx
movq %rax, (%rdx)
movq $0x3824, 0x8(%rdx)      # imm = 0x3824
leaq -0x88(%rbp), %rdi
movq %r14, %rsi
callq 0x2f430
xorl %eax, %eax
leaq -0x38(%rbp), %r9
movq %rax, (%r9)
leaq -0x28(%rbp), %rdi
movq %rax, -0x8(%rdi)
leaq -0x30(%rbp), %rsi
leaq -0x19(%rbp), %rdx
leaq -0x88(%rbp), %rcx
movq %rbx, %r8
callq 0x600c4
movaps -0x30(%rbp), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, -0x30(%rbp)
movq 0x8(%rbx), %rdi
movups %xmm0, (%rbx)
testq %rdi, %rdi
je 0x299cb
callq 0x43ca8
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x299d9
callq 0x43ca8
leaq -0x78(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x299eb
callq 0x1b4d0
movq -0x58(%rbp), %rdi
cmpq %r15, %rdi
je 0x299f9
callq 0x1b4d0
movq $0x0, 0x10(%rbx)
movl $0x1, 0x18(%rbx)
movq (%rbx), %rax
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x78(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x29a33
callq 0x1b4d0
jmp 0x29a33
movq %rax, %rbx
movq -0x58(%rbp), %rdi
cmpq %r15, %rdi
je 0x29a41
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::Counts::operator+=(Catch::Counts const&)
Counts& Counts::operator += ( Counts const& other ) {
        passed += other.passed;
        failed += other.failed;
        failedButOk += other.failedButOk;
        return *this;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movq (%rsi), %rcx
addq %rcx, (%rdi)
movq 0x8(%rsi), %rcx
addq %rcx, 0x8(%rdi)
movq 0x10(%rsi), %rcx
addq %rcx, 0x10(%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::RunContext::assertionEnded(Catch::AssertionResult const&)
void RunContext::assertionEnded(AssertionResult const & result) {
        if (result.getResultType() == ResultWas::Ok) {
            m_totals.assertions.passed++;
            m_lastAssertionPassed = true;
        } else if (!result.isOk()) {
            m_lastAssertionPassed = false;
            if( m_activeTestCase->getTestCaseInfo().okToFail() )
                m_totals.assertions.failedButOk++;
            else
                m_totals.assertions.failed++;
        }
        else {
            m_lastAssertionPassed = true;
        }

        // We have no use for the return value (whether messages should be cleared), because messages were made scoped
        // and should be let to clear themselves out.
        static_cast<void>(m_reporter->assertionEnded(AssertionStats(result, m_messages, m_totals)));

        if (result.getResultType() != ResultWas::Warning)
            m_messageScopes.clear();

        // Reset working state
        resetAssertionInfo();
        m_lastResult = result;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl 0x88(%rsi), %eax
testl %eax, %eax
je 0x2a110
testb $0x10, %al
je 0x2a117
movl 0x30(%rbx), %eax
andl $0x8, %eax
jne 0x2a117
movb $0x0, 0x1e9(%r14)
movq 0x38(%r14), %rax
testb $0xc, 0xa0(%rax)
je 0x2a1e8
incq 0x108(%r14)
jmp 0x2a11f
incq 0xf8(%r14)
movb $0x1, 0x1e9(%r14)
movq 0x128(%r14), %r15
leaq 0x130(%r14), %rdx
leaq 0xf0(%r14), %rcx
leaq -0x110(%rbp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x24a48
movq (%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
callq *0x50(%rax)
leaq -0x110(%rbp), %rdi
callq 0x24cc2
cmpl $0x2, 0x88(%rbx)
je 0x2a195
movq 0x148(%r14), %r12
movq 0x150(%r14), %r13
cmpq %r12, %r13
je 0x2a195
movq %r12, %r15
movq %r15, %rdi
callq 0x2840e
addq $0x50, %r15
cmpq %r13, %r15
jne 0x2a17d
movq %r12, 0x150(%r14)
leaq 0x51cf7(%rip), %rax     # 0x7be93
movq %rax, 0x160(%r14)
movq $0x0, 0x168(%r14)
leaq 0x522ac(%rip), %rax     # 0x7c461
movq %rax, 0x180(%r14)
movq $0x2c, 0x188(%r14)
addq $0x48, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3f80e
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
incq 0x100(%r14)
jmp 0x2a11f
movq %rax, %rbx
leaq -0x110(%rbp), %rdi
callq 0x24cc2
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::RunContext::sectionStarted(Catch::SectionInfo const&, Catch::Counts&)
bool RunContext::sectionStarted(SectionInfo const & sectionInfo, Counts & assertions) {
        ITracker& sectionTracker = SectionTracker::acquire(m_trackerContext, TestCaseTracking::NameAndLocation(sectionInfo.name, sectionInfo.lineInfo));
        if (!sectionTracker.isOpen())
            return false;
        m_activeSections.push_back(&sectionTracker);

        m_lastAssertionInfo.lineInfo = sectionInfo.lineInfo;

        m_reporter->sectionStarting(sectionInfo);

        assertions = m_totals.assertions;

        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, -0x30(%rbp)
movq %rsi, %r15
movq %rdi, %r14
leaq 0x1c8(%rdi), %rbx
leaq 0x40(%rsi), %r12
leaq -0x60(%rbp), %r13
movq %r13, %rdi
movq %r12, %rdx
callq 0x2f430
movq %rbx, %rdi
movq %r13, %rsi
callq 0x29adc
movq %rax, %rbx
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2a2a9
callq 0x1b4d0
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
movl %eax, %r13d
testb %al, %al
je 0x2a321
movq %rbx, -0x60(%rbp)
movq 0x1b8(%r14), %rsi
cmpq 0x1c0(%r14), %rsi
je 0x2a2da
movq %rbx, (%rsi)
addq $0x8, 0x1b8(%r14)
jmp 0x2a2ea
leaq 0x1b0(%r14), %rdi
leaq -0x60(%rbp), %rdx
callq 0x5b80a
movups (%r12), %xmm0
movups %xmm0, 0x170(%r14)
movq 0x128(%r14), %rdi
movq (%rdi), %rax
movq %r15, %rsi
callq *0x40(%rax)
movq 0x108(%r14), %rax
movq -0x30(%rbp), %rcx
movq %rax, 0x10(%rcx)
movups 0xf8(%r14), %xmm0
movups %xmm0, (%rcx)
movl %r13d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2a348
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::RunContext::acquireGeneratorTracker(Catch::StringRef, Catch::SourceLineInfo const&)
auto RunContext::acquireGeneratorTracker( StringRef generatorName, SourceLineInfo const& lineInfo ) -> IGeneratorTracker& {
        using namespace Generators;
        GeneratorTracker& tracker = GeneratorTracker::acquire(m_trackerContext,
                                                              TestCaseTracking::NameAndLocation( static_cast<std::string>(generatorName), lineInfo ) );
        m_lastAssertionInfo.lineInfo = lineInfo;
        return tracker;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rcx, %rbx
movq %rdi, %r14
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
addq %rsi, %rdx
leaq -0x40(%rbp), %r15
movq %r15, %rdi
callq 0x43438
leaq -0x70(%rbp), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x2f430
leaq 0x1c8(%r14), %rdi
leaq -0x70(%rbp), %rsi
callq 0x3f8f2
movq %rax, %r15
leaq -0x60(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2a3b1
callq 0x1b4d0
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x2a3bf
callq 0x1b4d0
movups (%rbx), %xmm0
movups %xmm0, 0x170(%r14)
addq $0x68, %r15
movq %r15, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x60(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2a3f8
callq 0x1b4d0
jmp 0x2a3f8
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x2a406
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::RunContext::sectionEnded(Catch::SectionEndInfo const&)
void RunContext::sectionEnded(SectionEndInfo const & endInfo) {
        Counts assertions = m_totals.assertions - endInfo.prevAssertions;
        bool missingAssertions = testForMissingAssertions(assertions);

        if (!m_activeSections.empty()) {
            m_activeSections.back()->close();
            m_activeSections.pop_back();
        }

        m_reporter->sectionEnded(SectionStats(endInfo.sectionInfo, assertions, endInfo.durationInSeconds, missingAssertions));
        m_messages.clear();
        m_messageScopes.clear();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq -0x40(%rbp), %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
movq 0xf8(%rdi), %rax
subq 0x50(%r14), %rax
movq %rax, (%rsi)
movq 0x100(%rdi), %rax
subq 0x58(%r14), %rax
movq %rax, 0x8(%rsi)
movq 0x108(%rdi), %rax
subq 0x60(%r14), %rax
movq %rax, 0x10(%rsi)
callq 0x2a40e
movl %eax, %r15d
movq 0x1b8(%rbx), %rax
cmpq %rax, 0x1b0(%rbx)
je 0x2a500
movq -0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
addq $-0x8, 0x1b8(%rbx)
movq 0x128(%rbx), %r12
movsd 0x68(%r14), %xmm0
movzbl %r15b, %ecx
leaq -0xc0(%rbp), %r15
leaq -0x40(%rbp), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x24d2e
movq (%r12), %rax
movq %r12, %rdi
movq %r15, %rsi
callq *0x58(%rax)
leaq -0xc0(%rbp), %rdi
callq 0x24df2
leaq 0x130(%rbx), %rdi
callq 0x3fb2c
movq 0x148(%rbx), %r15
movq 0x150(%rbx), %r12
cmpq %r15, %r12
je 0x2a57a
movq %r15, %r14
movq %r14, %rdi
callq 0x2840e
addq $0x50, %r14
cmpq %r12, %r14
jne 0x2a562
movq %r15, 0x150(%rbx)
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0xc0(%rbp), %rdi
callq 0x24df2
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::Counts::operator-(Catch::Counts const&) const
Counts Counts::operator - ( Counts const& other ) const {
        Counts diff;
        diff.passed = passed - other.passed;
        diff.failed = failed - other.failed;
        diff.failedButOk = failedButOk - other.failedButOk;
        return diff;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rsi), %rcx
subq (%rdx), %rcx
movq %rcx, (%rdi)
movq 0x8(%rsi), %rcx
subq 0x8(%rdx), %rcx
movq %rcx, 0x8(%rdi)
movq 0x10(%rsi), %rcx
subq 0x10(%rdx), %rcx
movq %rcx, 0x10(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::RunContext::sectionEndedEarly(Catch::SectionEndInfo const&)
void RunContext::sectionEndedEarly(SectionEndInfo const & endInfo) {
        if (m_unfinishedSections.empty())
            m_activeSections.back()->fail();
        else
            m_activeSections.back()->close();
        m_activeSections.pop_back();

        m_unfinishedSections.push_back(endInfo);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x198(%rdi), %r15
movq 0x198(%rdi), %rax
xorl %ecx, %ecx
cmpq 0x1a0(%rdi), %rax
movq 0x1b8(%rdi), %rax
sete %cl
movq -0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x40(%rax,%rcx,8)
addq $-0x8, 0x1b8(%r14)
movq %r15, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3fb78
nop
// File: /workspace/github_cpp_makefile_star2_O1/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::RunContext::handleUnfinishedSections()
void RunContext::handleUnfinishedSections() {
        // If sections ended prematurely due to an exception we stored their
        // infos here so we can tear them down outside the unwind process.
        for (auto it = m_unfinishedSections.rbegin(),
             itEnd = m_unfinishedSections.rend();
             it != itEnd;
             ++it)
            sectionEnded(*it);
        m_unfinishedSections.clear();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
leaq 0x198(%rdi), %rbx
movq 0x198(%rdi), %r12
movq 0x1a0(%rdi), %r15
cmpq %r12, %r15
je 0x2aac1
movq %rdi, %r14
addq $-0x70, %r15
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0x18(%rax)
cmpq %r12, %r15
jne 0x2aaac
movq (%rbx), %rsi
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x5c11a
// File: /workspace/github_cpp_makefile_star2_O1/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::RunContext::assertionPassed()
void RunContext::assertionPassed() {
        m_lastAssertionPassed = true;
        ++m_totals.assertions.passed;
        resetAssertionInfo();
        m_messageScopes.clear();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movb $0x1, 0x1e9(%rdi)
incq 0xf8(%rdi)
leaq 0x51393(%rip), %rax     # 0x7be93
movq %rax, 0x160(%rdi)
movq $0x0, 0x168(%rdi)
leaq 0x51948(%rip), %rax     # 0x7c461
movq %rax, 0x180(%rdi)
movq $0x2c, 0x188(%rdi)
movq 0x148(%rdi), %r15
movq 0x150(%rdi), %r12
cmpq %r15, %r12
je 0x2ab5c
movq %rdi, %rbx
movq %r15, %r14
movq %r14, %rdi
callq 0x2840e
addq $0x50, %r14
cmpq %r12, %r14
jne 0x2ab44
movq %r15, 0x150(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
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::RunContext::handleExpr(Catch::AssertionInfo const&, Catch::ITransientExpression const&, Catch::AssertionReaction&)
void RunContext::handleExpr(
        AssertionInfo const& info,
        ITransientExpression const& expr,
        AssertionReaction& reaction
    ) {
        m_reporter->assertionStarting( info );

        bool negated = isFalseTest( info.resultDisposition );
        bool result = expr.getResult() != negated;

        if( result ) {
            if (!m_includeSuccessfulResults) {
                assertionPassed();
            }
            else {
                reportExpr(info, ResultWas::Ok, &expr, negated);
            }
        }
        else {
            reportExpr(info, ResultWas::ExpressionFailed, &expr, negated );
            populateReaction( reaction );
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq 0x128(%rdi), %rdi
movq (%rdi), %rax
callq *0x48(%rax)
movl 0x30(%r12), %r8d
andl $0x4, %r8d
shrl $0x2, %r8d
cmpb 0x9(%r15), %r8b
je 0x2ad09
cmpb $0x0, 0x1eb(%r14)
je 0x2ad65
movq %r14, %rdi
movq %r12, %rsi
xorl %edx, %edx
movq %r15, %rcx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2ad7a
movq %r14, %rdi
movq %r12, %rsi
movl $0x11, %edx
movq %r15, %rcx
callq 0x2ad7a
movq 0xe0(%r14), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movb %al, (%rbx)
movq 0xe0(%r14), %rdi
movq 0x100(%r14), %r15
movq (%rdi), %rax
callq *0x48(%rax)
cltq
movb 0x190(%r14), %cl
andb $0x1, %cl
cmpq %rax, %r15
movzbl %cl, %eax
movl $0x1, %ecx
cmovbl %eax, %ecx
movb %cl, 0x1(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq (%r14), %rax
movq %r14, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *0x88(%rax)
nop
// File: /workspace/github_cpp_makefile_star2_O1/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::RunContext::reportExpr(Catch::AssertionInfo const&, Catch::ResultWas::OfType, Catch::ITransientExpression const*, bool)
void RunContext::reportExpr(
            AssertionInfo const &info,
            ResultWas::OfType resultType,
            ITransientExpression const *expr,
            bool negated ) {

        m_lastAssertionInfo = info;
        AssertionResultData data( resultType, LazyExpression( negated ) );

        AssertionResult assertionResult{ info, data };
        assertionResult.m_resultData.lazyExpression.m_transientExpression = expr;

        assertionEnded( assertionResult );
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rcx, -0x30(%rbp)
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %rbx
movl 0x30(%rsi), %eax
movl %eax, 0x190(%rdi)
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movups 0x20(%rsi), %xmm2
movups %xmm2, 0x180(%rdi)
movups %xmm1, 0x170(%rdi)
movups %xmm0, 0x160(%rdi)
leaq -0x118(%rbp), %r13
movq %r13, %rdi
movl %r8d, %esi
callq 0x1d0d8
leaq -0x88(%rbp), %r14
movq %r14, %rdi
movl %r15d, %esi
movq %r13, %rdx
callq 0x1d696
leaq -0x118(%rbp), %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x1d7c2
leaq -0x118(%rbp), %rsi
movq -0x30(%rbp), %rax
movq %rax, 0x78(%rsi)
movq %rbx, %rdi
callq 0x2a0be
leaq -0xb0(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2ae29
callq 0x1b4d0
leaq -0xd0(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2ae3e
callq 0x1b4d0
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2ae50
callq 0x1b4d0
leaq -0x78(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2ae62
callq 0x1b4d0
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x118(%rbp), %rdi
callq 0x3f096
jmp 0x2ae88
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x3fbec
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::RunContext::handleMessage(Catch::AssertionInfo const&, Catch::ResultWas::OfType, Catch::StringRef const&, Catch::AssertionReaction&)
void RunContext::handleMessage(
            AssertionInfo const& info,
            ResultWas::OfType resultType,
            StringRef const& message,
            AssertionReaction& reaction
    ) {
        m_reporter->assertionStarting( info );

        m_lastAssertionInfo = info;

        AssertionResultData data( resultType, LazyExpression( false ) );
        data.message = static_cast<std::string>(message);
        AssertionResult assertionResult{ m_lastAssertionInfo, data };
        assertionEnded( assertionResult );
        if( !assertionResult.isOk() )
            populateReaction( reaction );
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %r8, %rbx
movq %rcx, %r15
movl %edx, %r12d
movq %rsi, %r13
movq %rdi, %r14
movq 0x128(%rdi), %rdi
movq (%rdi), %rax
callq *0x48(%rax)
movl 0x30(%r13), %eax
movl %eax, 0x190(%r14)
movups (%r13), %xmm0
movups 0x10(%r13), %xmm1
movups 0x20(%r13), %xmm2
movups %xmm2, 0x180(%r14)
movups %xmm1, 0x170(%r14)
movups %xmm0, 0x160(%r14)
leaq -0xb8(%rbp), %r13
movq %r13, %rdi
xorl %esi, %esi
callq 0x1d0d8
leaq -0x110(%rbp), %rdi
movl %r12d, %esi
movq %r13, %rdx
callq 0x1d696
movq (%r15), %rsi
leaq -0xa8(%rbp), %r13
movq 0x8(%r15), %rdx
addq %rsi, %rdx
movq %r13, -0x10(%r13)
leaq -0xb8(%rbp), %rdi
callq 0x43438
leaq 0x160(%r14), %r15
leaq -0x110(%rbp), %rdi
leaq -0xb8(%rbp), %r12
movq %r12, %rsi
callq 0x1b640
movq (%r12), %rdi
cmpq %r13, %rdi
je 0x2afc9
callq 0x1b4d0
leaq -0xb8(%rbp), %rdi
leaq -0x110(%rbp), %rdx
movq %r15, %rsi
callq 0x1d7c2
leaq -0xb8(%rbp), %rsi
movq %r14, %rdi
callq 0x2a0be
testb $0x10, -0x30(%rbp)
je 0x2b03f
movl -0x88(%rbp), %eax
andl $0x8, %eax
jne 0x2b03f
movq 0xe0(%r14), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movb %al, (%rbx)
movq 0xe0(%r14), %rdi
movq 0x100(%r14), %r15
movq (%rdi), %rax
callq *0x48(%rax)
cltq
movb 0x190(%r14), %cl
andb $0x1, %cl
cmpq %rax, %r15
movzbl %cl, %eax
movl $0x1, %ecx
cmovbl %eax, %ecx
movb %cl, 0x1(%rbx)
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2b051
callq 0x1b4d0
leaq -0x70(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2b063
callq 0x1b4d0
leaq -0xe0(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2b078
callq 0x1b4d0
leaq -0x100(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2b08d
callq 0x1b4d0
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2b0a1
movq %rax, %rbx
jmp 0x2b0b5
movq %rax, %rbx
leaq -0xb8(%rbp), %rdi
callq 0x3f096
leaq -0x110(%rbp), %rdi
callq 0x3fbec
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::RunContext::handleUnexpectedInflightException(Catch::AssertionInfo const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::AssertionReaction&)
void RunContext::handleUnexpectedInflightException(
            AssertionInfo const& info,
            std::string const& message,
            AssertionReaction& reaction
    ) {
        m_lastAssertionInfo = info;

        AssertionResultData data( ResultWas::ThrewException, LazyExpression( false ) );
        data.message = message;
        AssertionResult assertionResult{ info, data };
        assertionEnded( assertionResult );
        populateReaction( reaction );
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rcx, -0x30(%rbp)
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
movl 0x30(%rsi), %eax
movl %eax, 0x190(%rdi)
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movups 0x20(%rsi), %xmm2
movups %xmm2, 0x180(%rdi)
movups %xmm1, 0x170(%rdi)
movups %xmm0, 0x160(%rdi)
leaq -0x118(%rbp), %r13
movq %r13, %rdi
xorl %esi, %esi
callq 0x1d0d8
leaq -0x88(%rbp), %rbx
movq %rbx, %rdi
movl $0x111, %esi            # imm = 0x111
movq %r13, %rdx
callq 0x1d696
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1b290
leaq -0x118(%rbp), %rdi
leaq -0x88(%rbp), %rdx
movq %r15, %rsi
callq 0x1d7c2
leaq -0x118(%rbp), %rsi
movq %r14, %rdi
callq 0x2a0be
movq -0x30(%rbp), %r15
movq 0xe0(%r14), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movb %al, (%r15)
movq 0xe0(%r14), %rdi
movq 0x100(%r14), %rbx
movq (%rdi), %rax
callq *0x48(%rax)
cltq
movb 0x190(%r14), %cl
andb $0x1, %cl
cmpq %rax, %rbx
movzbl %cl, %eax
movl $0x1, %ecx
cmovbl %eax, %ecx
movb %cl, 0x1(%r15)
leaq -0xb0(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2b1dd
callq 0x1b4d0
leaq -0xd0(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2b1f2
callq 0x1b4d0
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2b204
callq 0x1b4d0
leaq -0x78(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2b216
callq 0x1b4d0
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2b22a
movq %rax, %rbx
jmp 0x2b23e
movq %rax, %rbx
leaq -0x118(%rbp), %rdi
callq 0x3f096
leaq -0x88(%rbp), %rdi
callq 0x3fbec
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::RunContext::handleIncomplete(Catch::AssertionInfo const&)
void RunContext::handleIncomplete(
            AssertionInfo const& info
    ) {
        m_lastAssertionInfo = info;

        AssertionResultData data( ResultWas::ThrewException, LazyExpression( false ) );
        data.message = "Exception translation was disabled by CATCH_CONFIG_FAST_COMPILE";
        AssertionResult assertionResult{ info, data };
        assertionEnded( assertionResult );
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xf0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x30(%rsi), %eax
movl %eax, 0x190(%rdi)
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movups 0x20(%rsi), %xmm2
movups %xmm2, 0x180(%rdi)
movups %xmm1, 0x170(%rdi)
movups %xmm0, 0x160(%rdi)
leaq -0x108(%rbp), %r15
movq %r15, %rdi
xorl %esi, %esi
callq 0x1d0d8
leaq -0x78(%rbp), %r12
movq %r12, %rdi
movl $0x111, %esi            # imm = 0x111
movq %r15, %rdx
callq 0x1d696
movq 0x8(%r12), %rdx
leaq 0x511d4(%rip), %rcx     # 0x7c498
movl $0x3f, %r8d
movq %r12, %rdi
xorl %esi, %esi
callq 0x1b7d0
leaq -0x108(%rbp), %rdi
leaq -0x78(%rbp), %rdx
movq %r14, %rsi
callq 0x1d7c2
leaq -0x108(%rbp), %rsi
movq %rbx, %rdi
callq 0x2a0be
leaq -0xa0(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2b30b
callq 0x1b4d0
leaq -0xc0(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2b320
callq 0x1b4d0
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2b332
callq 0x1b4d0
leaq -0x68(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2b344
callq 0x1b4d0
addq $0xf0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x108(%rbp), %rdi
callq 0x3f096
jmp 0x2b36a
jmp 0x2b367
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x3fbec
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::RunContext::handleNonExpr(Catch::AssertionInfo const&, Catch::ResultWas::OfType, Catch::AssertionReaction&)
void RunContext::handleNonExpr(
            AssertionInfo const &info,
            ResultWas::OfType resultType,
            AssertionReaction &reaction
    ) {
        m_lastAssertionInfo = info;

        AssertionResultData data( resultType, LazyExpression( false ) );
        AssertionResult assertionResult{ info, data };
        assertionEnded( assertionResult );

        if( !assertionResult.isOk() )
            populateReaction( reaction );
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rcx, -0x30(%rbp)
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %r14
movl 0x30(%rsi), %eax
movl %eax, 0x190(%rdi)
movups (%rsi), %xmm0
movups 0x10(%rsi), %xmm1
movups 0x20(%rsi), %xmm2
movups %xmm2, 0x180(%rdi)
movups %xmm1, 0x170(%rdi)
movups %xmm0, 0x160(%rdi)
leaq -0xc0(%rbp), %r13
movq %r13, %rdi
xorl %esi, %esi
callq 0x1d0d8
leaq -0x118(%rbp), %rbx
movq %rbx, %rdi
movl %r15d, %esi
movq %r13, %rdx
callq 0x1d696
leaq -0xc0(%rbp), %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x1d7c2
leaq -0xc0(%rbp), %rsi
movq %r14, %rdi
callq 0x2a0be
testb $0x10, -0x38(%rbp)
je 0x2b466
movl -0x90(%rbp), %eax
andl $0x8, %eax
jne 0x2b466
movq 0xe0(%r14), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movq -0x30(%rbp), %rcx
movb %al, (%rcx)
movq 0xe0(%r14), %rdi
movq 0x100(%r14), %rbx
movq (%rdi), %rax
callq *0x48(%rax)
cltq
movb 0x190(%r14), %cl
andb $0x1, %cl
cmpq %rax, %rbx
movzbl %cl, %eax
movl $0x1, %ecx
cmovbl %eax, %ecx
movq -0x30(%rbp), %rax
movb %cl, 0x1(%rax)
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2b478
callq 0x1b4d0
leaq -0x78(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2b48a
callq 0x1b4d0
leaq -0xe8(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2b49f
callq 0x1b4d0
leaq -0x108(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2b4b4
callq 0x1b4d0
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x2b4da
movq %rax, %rbx
leaq -0xc0(%rbp), %rdi
callq 0x3f096
leaq -0x118(%rbp), %rdi
callq 0x3fbec
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::Section::~Section()
Section::~Section() {
        if( m_sectionIncluded ) {
            SectionEndInfo endInfo{ m_info, m_assertions, m_timer.getElapsedSeconds() };
            if( uncaught_exceptions() )
                getResultCapture().sectionEndedEarly( endInfo );
            else
                getResultCapture().sectionEnded( endInfo );
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
leaq 0x7cbbf(%rip), %rax     # 0xa8218
addq $0x10, %rax
movq %rax, (%rdi)
cmpb $0x1, 0x90(%rdi)
jne 0x2b747
leaq -0x78(%rbp), %r14
movq %r14, -0x10(%r14)
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
addq %rsi, %rdx
leaq -0x88(%rbp), %rdi
callq 0x4ad3e
leaq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %r15
movq %r15, -0x10(%r15)
movq 0x28(%rbx), %rsi
movq 0x30(%rbx), %rdx
addq %rsi, %rdx
callq 0x4ad3e
movups 0x48(%rbx), %xmm0
movups %xmm0, -0x48(%rbp)
movups 0x78(%rbx), %xmm0
movups %xmm0, -0x38(%rbp)
movq 0x88(%rbx), %rax
movq %rax, -0x28(%rbp)
callq 0x1b090
subq 0x98(%rbx), %rax
shrq $0x3, %rax
movabsq $0x20c49ba5e353f7cf, %rcx # imm = 0x20C49BA5E353F7CF
mulq %rcx
shrq $0x4, %rdx
xorps %xmm0, %xmm0
cvtsi2sd %rdx, %xmm0
divsd 0x4ea04(%rip), %xmm0    # 0x7a0f8
movsd %xmm0, -0x20(%rbp)
callq 0x1b070
testb %al, %al
je 0x2b70e
callq 0x1d1d6
movl $0x20, %ecx
jmp 0x2b718
callq 0x1d1d6
movl $0x18, %ecx
movq (%rax), %rdx
leaq -0x88(%rbp), %rsi
movq %rax, %rdi
callq *(%rdx,%rcx)
movq -0x68(%rbp), %rdi
cmpq %r15, %rdi
je 0x2b736
callq 0x1b4d0
movq -0x88(%rbp), %rdi
cmpq %r14, %rdi
je 0x2b747
callq 0x1b4d0
movq 0x58(%rbx), %rdi
leaq 0x68(%rbx), %rax
cmpq %rax, %rdi
je 0x2b759
callq 0x1b4d0
movq 0x28(%rbx), %rdi
leaq 0x38(%rbx), %rax
cmpq %rax, %rdi
je 0x2b76b
callq 0x1b4d0
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0x2b77d
callq 0x1b4d0
addq $0x78, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x88(%rbp), %rdi
cmpq %r14, %rdi
je 0x2b7a1
callq 0x1b4d0
jmp 0x2b7a1
movq %rax, %rbx
movq %rbx, %rdi
callq 0x3ec84
nop
// File: /workspace/github_cpp_makefile_star2_O1/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::Session::showHelp() const
void Session::showHelp() const {
        Catch::cout()
                << "\nCatch v" << libraryVersion() << "\n"
                << m_cli << std::endl
                << "For more detailed usage please see the project docs\n" << std::endl;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x7ff05(%rip), %rbx     # 0xabf98
leaq 0x504ae(%rip), %rsi     # 0x7c548
movl $0x8, %edx
movq %rbx, %rdi
callq 0x1b5e0
callq 0x2c231
leaq 0x80d05(%rip), %rsi     # 0xacdb8
movq %rbx, %rdi
callq 0x2c147
leaq 0x58ac0(%rip), %rsi     # 0x84b82
movl $0x1, %edx
movq %rbx, %rdi
callq 0x1b5e0
addq $0x8, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x47aea
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1b4f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1b040
movq %rax, %rdi
callq 0x1b360
movq %rax, %rbx
leaq 0x50442(%rip), %rsi     # 0x7c551
movl $0x34, %edx
movq %rax, %rdi
callq 0x1b5e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1b4f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1b040
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x1b360
// File: /workspace/github_cpp_makefile_star2_O1/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::operator<<(std::ostream&, Catch::Version const&)
std::ostream& operator << ( std::ostream& os, Version const& version ) {
        os  << version.majorVersion << '.'
            << version.minorVersion << '.'
            << version.patchNumber;
        // branchName is never null -> 0th char is \0 if it is empty
        if (version.branchName[0]) {
            os << '-' << version.branchName
               << '.' << version.buildNumber;
        }
        return os;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %esi
callq 0x1b350
movb $0x2e, %r15b
leaq -0x21(%rbp), %rsi
movb %r15b, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x1b5e0
movl 0x4(%r14), %esi
movq %rax, %rdi
callq 0x1b350
leaq -0x22(%rbp), %rsi
movb %r15b, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x1b5e0
movl 0x8(%r14), %esi
movq %rax, %rdi
callq 0x1b350
movq 0x10(%r14), %rax
cmpb $0x0, (%rax)
je 0x2c221
leaq -0x23(%rbp), %rsi
movb $0x2d, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x1b5e0
movq %rax, %r15
movq 0x10(%r14), %r12
testq %r12, %r12
je 0x2c1e7
movq %r12, %rdi
callq 0x1b220
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x1b5e0
jmp 0x2c201
movq (%r15), %rax
movq -0x18(%rax), %rax
movq %r15, %rdi
addq %rax, %rdi
movl 0x20(%r15,%rax), %esi
orl $0x1, %esi
callq 0x1b890
leaq -0x24(%rbp), %rsi
movb $0x2e, (%rsi)
movl $0x1, %edx
movq %r15, %rdi
callq 0x1b5e0
movl 0x18(%r14), %esi
movq %rax, %rdi
callq 0x1b350
movq %rbx, %rax
addq $0x10, %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::Session::libIdentify()
void Session::libIdentify() {
        Catch::cout()
                << std::left << std::setw(16) << "description: " << "A Catch2 test executable\n"
                << std::left << std::setw(16) << "category: " << "testframework\n"
                << std::left << std::setw(16) << "framework: " << "Catch Test\n"
                << std::left << std::setw(16) << "version: " << libraryVersion() << std::endl;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x7fcdd(%rip), %rbx     # 0xabf98
movq (%rbx), %rax
movq -0x18(%rax), %rcx
movl $0xffffff4f, %r14d      # imm = 0xFFFFFF4F
movl 0x18(%rbx,%rcx), %edx
andl %r14d, %edx
orl $0x20, %edx
movl %edx, 0x18(%rbx,%rcx)
movq -0x18(%rax), %rax
movl $0x10, %r15d
movq %r15, 0x10(%rbx,%rax)
leaq 0x5029a(%rip), %rsi     # 0x7c586
movl $0xd, %edx
movq %rbx, %rdi
callq 0x1b5e0
leaq 0x50294(%rip), %rsi     # 0x7c594
movl $0x19, %edx
movq %rbx, %rdi
callq 0x1b5e0
movq (%rbx), %rax
movq -0x18(%rax), %rcx
movl 0x18(%rbx,%rcx), %edx
andl %r14d, %edx
orl $0x20, %edx
movl %edx, 0x18(%rbx,%rcx)
movq -0x18(%rax), %rax
movq %r15, 0x10(%rbx,%rax)
leaq 0x5027c(%rip), %rsi     # 0x7c5ae
movl $0xa, %edx
movq %rbx, %rdi
callq 0x1b5e0
leaq 0x50273(%rip), %rsi     # 0x7c5b9
movl $0xe, %edx
movq %rbx, %rdi
callq 0x1b5e0
movq (%rbx), %rax
movq -0x18(%rax), %rcx
movl 0x18(%rbx,%rcx), %edx
andl %r14d, %edx
orl $0x20, %edx
movl %edx, 0x18(%rbx,%rcx)
movq -0x18(%rax), %rax
movq %r15, 0x10(%rbx,%rax)
leaq 0x50250(%rip), %rsi     # 0x7c5c8
movl $0xb, %edx
movq %rbx, %rdi
callq 0x1b5e0
leaq 0x50248(%rip), %rsi     # 0x7c5d4
movl $0xb, %edx
movq %rbx, %rdi
callq 0x1b5e0
movq (%rbx), %rax
movq -0x18(%rax), %rcx
andl 0x18(%rbx,%rcx), %r14d
orl $0x20, %r14d
movl %r14d, 0x18(%rbx,%rcx)
movq -0x18(%rax), %rax
movq %r15, 0x10(%rbx,%rax)
leaq 0x50222(%rip), %rsi     # 0x7c5e0
movl $0x9, %edx
movq %rbx, %rdi
callq 0x1b5e0
callq 0x2c231
leaq 0x809e1(%rip), %rsi     # 0xacdb8
movq %rbx, %rdi
callq 0x2c147
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1b4f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1b040
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1b360
// File: /workspace/github_cpp_makefile_star2_O1/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::Session::run()
int Session::run() {
        if( ( m_configData.waitForKeypress & WaitForKeypress::BeforeStart ) != 0 ) {
            Catch::cout() << "...waiting for enter/ return before starting" << std::endl;
            static_cast<void>(std::getchar());
        }
        int exitCode = runInternal();
        if( ( m_configData.waitForKeypress & WaitForKeypress::BeforeExit ) != 0 ) {
            Catch::cout() << "...waiting for enter/ return before exiting, with code: " << exitCode << std::endl;
            static_cast<void>(std::getchar());
        }
        return exitCode;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
testb $0x1, 0xc0(%rdi)
je 0x2c818
movq 0x7f7c0(%rip), %rbx     # 0xabf98
leaq 0x4fe37(%rip), %rsi     # 0x7c616
movl $0x2c, %edx
movq %rbx, %rdi
callq 0x1b5e0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1b4f0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1b040
movq %rax, %rdi
callq 0x1b360
callq 0x1b700
movq %r14, %rdi
callq 0x2c888
movl %eax, %ebx
testb $0x2, 0xc0(%r14)
je 0x2c880
movq 0x7f765(%rip), %r14     # 0xabf98
leaq 0x4fe09(%rip), %rsi     # 0x7c643
movl $0x38, %edx
movq %r14, %rdi
callq 0x1b5e0
movq %r14, %rdi
movl %ebx, %esi
callq 0x1b8c0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x1b4f0
movsbl %al, %esi
movq %r14, %rdi
callq 0x1b040
movq %rax, %rdi
callq 0x1b360
callq 0x1b700
movl %ebx, %eax
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::(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 0x405ba
leaq 0x200(%rbx), %rdi
callq 0x49f28
leaq 0x10(%rbx), %rdi
callq 0x29352
movq 0x8(%rbx), %rdi
addq $0x8, %rsp
testq %rdi, %rdi
je 0x2d424
popq %rbx
popq %rbp
jmp 0x43ca8
popq %rbx
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::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 0x5c7be
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_O1/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 0x2e5de
movq (%rbx), %rcx
movl $0x2, %eax
cmpb $0x2e, (%rcx)
je 0x2e67b
leaq 0x4e16a(%rip), %rsi     # 0x7c74f
movq %rbx, %rdi
callq 0x1b140
testl %eax, %eax
je 0x2e65a
leaq 0x4f6b0(%rip), %rsi     # 0x7dca8
movq %rbx, %rdi
callq 0x1b140
testl %eax, %eax
je 0x2e661
leaq 0x4f6a5(%rip), %rsi     # 0x7dcb0
movq %rbx, %rdi
callq 0x1b140
testl %eax, %eax
je 0x2e668
leaq 0x4e70a(%rip), %rsi     # 0x7cd28
movq %rbx, %rdi
callq 0x1b140
testl %eax, %eax
je 0x2e66f
leaq 0x4f68b(%rip), %rsi     # 0x7dcbc
movq %rbx, %rdi
callq 0x1b140
testl %eax, %eax
je 0x2e676
leaq 0x4f685(%rip), %rsi     # 0x7dcc9
movq %rbx, %rdi
callq 0x1b140
xorl %ecx, %ecx
testl %eax, %eax
movl $0x42, %eax
cmovnel %ecx, %eax
jmp 0x2e67b
movl $0x2, %eax
jmp 0x2e67b
movl $0x10, %eax
jmp 0x2e67b
movl $0x4, %eax
jmp 0x2e67b
movl $0x8, %eax
jmp 0x2e67b
movl $0x20, %eax
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::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), %r15
movq 0x8(%rsi), %r12
cmpq %r12, %r15
je 0x2e6d2
movq %r12, %rax
subq %r15, %rax
sarq $0x5, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x5ced1
movq %r15, %rdi
movq %r12, %rsi
callq 0x5cfc2
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
callq 0x5d6de
movq 0x8(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5d7b8
leaq 0x78(%r14), %rdi
movq %rdi, -0x38(%rbp)
callq 0x3ffc0
movq (%rbx), %r12
movq %rbx, -0x30(%rbp)
movq 0x8(%rbx), %rbx
cmpq %rbx, %r12
je 0x2e759
leaq -0x58(%rbp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x2621d
movl 0xa0(%r14), %r15d
movq %r13, %rdi
callq 0x2e5bd
orl %r15d, %eax
movl %eax, 0xa0(%r14)
movq -0x38(%rbp), %rdi
movq %r13, %rsi
callq 0x3ff26
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x2e750
callq 0x1b4d0
addq $0x20, %r12
cmpq %rbx, %r12
jne 0x2e70e
addq $0x60, %r14
movq %r14, %rdi
movq -0x30(%rbp), %rsi
callq 0x4ce4c
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x2e78d
callq 0x1b4d0
movq %r14, %rdi
callq 0x1b910
nop