LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::Matchers::StdString::StringMatcherBase::describe[abi:cxx11]() const
std::string StringMatcherBase::describe() const {
            std::string description;
            description.reserve(5 + m_operation.size() + m_comparator.m_str.size() +
                                        m_comparator.caseSensitivitySuffix().size());
            description += m_operation;
            description += ": \"";
            description += m_comparator.m_str;
            description += "\"";
            description += m_comparator.caseSensitivitySuffix();
            return description;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x40(%rsi), %r13
movq 0x60(%rsi), %r12
leaq 0x30(%rsi), %r14
leaq -0x48(%rbp), %rdi
movq %r14, %rsi
callq 0x2c936
addq %r13, %r12
movq -0x40(%rbp), %rax
leaq (%rax,%r12), %rsi
addq $0x5, %rsi
movq %rbx, %rdi
callq 0x24810
leaq 0x58(%r15), %r12
leaq -0x48(%rbp), %rdi
callq 0x24ad8
movq %rbx, %rdi
movq %r12, %rsi
callq 0x24a60
leaq 0x477fd(%rip), %rsi     # 0x74258
movq %rbx, %rdi
callq 0x24a10
addq $0x38, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x24a60
leaq 0x47cc6(%rip), %rsi     # 0x7473f
movq %rbx, %rdi
callq 0x24a10
leaq -0x48(%rbp), %rdi
movq %r14, %rsi
callq 0x2c936
leaq -0x48(%rbp), %rsi
movq %rbx, %rdi
callq 0x24a60
leaq -0x48(%rbp), %rdi
callq 0x24ad8
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2cab8
jmp 0x2cac8
movq %rax, %r14
leaq -0x48(%rbp), %rdi
callq 0x24ad8
jmp 0x2cacb
jmp 0x2cac8
movq %rax, %r14
movq %rbx, %rdi
callq 0x24ad8
movq %r14, %rdi
callq 0x24950
nop
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::Matchers::StdString::RegexMatcher::match(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
bool RegexMatcher::match(std::string const& matchee) const {
            auto flags = std::regex::ECMAScript; // ECMAScript is the default syntax option anyway
            if (m_caseSensitivity == CaseSensitive::Choice::No) {
                flags |= std::regex::icase;
            }
            auto reg = std::regex(m_regex, flags);
            return std::regex_match(matchee, reg);
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
xorl %edx, %edx
cmpl $0x1, 0x50(%rdi)
movq %rsi, %rbx
sete %dl
orl $0x10, %edx
leaq 0x30(%rdi), %rsi
leaq -0x30(%rbp), %r14
movq %r14, %rdi
callq 0x3e7ac
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x3e813
movl %eax, %ebx
leaq -0x30(%rbp), %rdi
callq 0x3e830
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x3e830
movq %rbx, %rdi
callq 0x24950
nop
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::Capturer::~Capturer()
Capturer::~Capturer() {
        if ( !uncaught_exceptions() ){
            assert( m_captured == m_messages.size() );
            for( size_t i = 0; i < m_captured; ++i  )
                m_resultCapture.popScopedMessage( m_messages[i] );
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x24060
testb %al, %al
je 0x2d6ee
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3e066
movq 0x8(%rbx), %rax
movq 0x20(%rbx), %rcx
subq (%rbx), %rax
pushq $0x48
popq %rsi
cqto
idivq %rsi
cmpq %rax, %rcx
jne 0x2d72e
xorl %r14d, %r14d
xorl %r15d, %r15d
cmpq %rcx, %r15
jae 0x2d6dc
movq 0x18(%rbx), %rdi
movq (%rbx), %rsi
addq %r14, %rsi
movq (%rdi), %rax
callq *0x38(%rax)
incq %r15
movq 0x20(%rbx), %rcx
addq $0x48, %r14
jmp 0x2d70c
leaq 0x46c1a(%rip), %rdi     # 0x7434f
leaq 0x46771(%rip), %rsi     # 0x73ead
leaq 0x46c2c(%rip), %rcx     # 0x7436f
movl $0x2e95, %edx           # imm = 0x2E95
callq 0x24390
movq %rax, %rdi
callq 0x3dcad
nop
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::Capturer::captureValue(unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Capturer::captureValue( size_t index, std::string const& value ) {
        assert( index < m_messages.size() );
        m_messages[index].message += value;
        m_resultCapture.pushScopedMessage( m_messages[index] );
        m_captured++;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %rcx
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x8(%rbx), %rax
subq %rdi, %rax
pushq $0x48
popq %r8
cqto
idivq %r8
cmpq %rsi, %rax
jbe 0x2d7a7
imulq $0x48, %rsi, %r14
addq %r14, %rdi
addq $0x10, %rdi
movq %rcx, %rsi
callq 0x24a60
movq 0x18(%rbx), %rdi
addq (%rbx), %r14
movq (%rdi), %rax
movq %r14, %rsi
callq *0x30(%rax)
incq 0x20(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x46bde(%rip), %rdi     # 0x7438c
leaq 0x466f8(%rip), %rsi     # 0x73ead
leaq 0x46bea(%rip), %rcx     # 0x743a6
movl $0x2e9c, %edx           # imm = 0x2E9C
callq 0x24390
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::SimplePcg32::seed(unsigned int)
void SimplePcg32::seed(result_type seed_) {
        m_state = 0;
        (*this)();
        m_state += seed_;
        (*this)();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
andq $0x0, (%rdi)
callq 0x2da50
movl %ebx, %eax
addq %rax, (%r14)
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2da50
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
subq $0x1, %rbx
jb 0x2daab
movq %r14, %rdi
callq 0x2da50
jmp 0x2da9b
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
callq 0x30da4
movq 0x81348(%rip), %rax     # 0xaee38
movq (%rax), %rbx
movq 0x8(%rax), %r14
cmpq %r14, %rbx
je 0x2db10
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2db0a
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %rbx
jmp 0x2daf7
movq 0x81321(%rip), %rbx     # 0xaee38
testq %rbx, %rbx
je 0x2db24
movq %rbx, %rdi
callq 0x58aa6
movq %rbx, %rdi
callq 0x24540
andq $0x0, 0x81304(%rip)     # 0xaee38
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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 0x4902e
addq $0x10, %r15
cmpq %r15, %rax
je 0x2dbe2
movq 0x40(%rax), %r15
leaq -0x38(%rbp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x2a8f4
movq (%r15), %rax
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq *0x10(%rax)
leaq -0x28(%rbp), %rdi
callq 0x423de
jmp 0x2dbe6
andq $0x0, (%rbx)
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0x423de
movq %rbx, %rdi
callq 0x24950
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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 %r14
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
leaq 0x46370(%rip), %rsi     # 0x7478e
leaq -0x50(%rbp), %r14
leaq -0x11(%rbp), %rdx
movq %r14, %rdi
callq 0x24210
leaq 0x45a78(%rip), %rax     # 0x73ead
leaq -0x90(%rbp), %rdx
movq %rax, (%rdx)
movq $0x3824, 0x8(%rdx)      # imm = 0x3824
leaq -0x80(%rbp), %rdi
movq %r14, %rsi
callq 0x32494
leaq -0x30(%rbp), %rcx
andq $0x0, (%rcx)
leaq -0x28(%rbp), %rdi
leaq -0x80(%rbp), %rsi
movq %rbx, %rdx
callq 0x3f732
leaq -0x28(%rbp), %rsi
movq %rbx, %rdi
callq 0x5b090
leaq -0x20(%rbp), %rdi
callq 0x423de
leaq -0x80(%rbp), %rdi
callq 0x24ad8
leaq -0x50(%rbp), %rdi
callq 0x24ad8
andq $0x0, 0x10(%rbx)
movl $0x1, 0x18(%rbx)
movq (%rbx), %rax
addq $0x80, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x24ad8
jmp 0x2e4be
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x24ad8
movq %rbx, %rdi
callq 0x24950
nop
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::TestCaseTracking::SectionTracker::acquire(Catch::TestCaseTracking::TrackerContext&, Catch::TestCaseTracking::NameAndLocation const&)
SectionTracker& SectionTracker::acquire( TrackerContext& ctx, NameAndLocation const& nameAndLocation ) {
        std::shared_ptr<SectionTracker> section;

        ITracker& currentTracker = ctx.currentTracker();
        if( ITrackerPtr childTracker = currentTracker.findChild( nameAndLocation ) ) {
            assert( childTracker );
            assert( childTracker->isSectionTracker() );
            section = std::static_pointer_cast<SectionTracker>( childTracker );
        }
        else {
            section = std::make_shared<SectionTracker>( nameAndLocation, ctx, &currentTracker );
            currentTracker.addChild( section );
        }
        if( !ctx.completedCycle() )
            section->tryOpen();
        return *section;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, -0x40(%rbp)
movq 0x10(%rdi), %r14
movq (%r14), %rax
leaq -0x50(%rbp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq *0x60(%rax)
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x2e5c7
movq (%rdi), %rax
callq *0x70(%rax)
testb %al, %al
je 0x2e64f
leaq -0x30(%rbp), %r14
leaq -0x50(%rbp), %rsi
movq %r14, %rdi
callq 0x3f80c
leaq -0x40(%rbp), %rdi
movq %r14, %rsi
callq 0x5b278
jmp 0x2e611
leaq -0x58(%rbp), %rcx
movq %r14, (%rcx)
leaq -0x30(%rbp), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x3f832
leaq -0x40(%rbp), %r15
leaq -0x30(%rbp), %rsi
movq %r15, %rdi
callq 0x5b278
leaq -0x28(%rbp), %rdi
callq 0x423de
leaq -0x30(%rbp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x5b384
movq (%r14), %rax
movq %r14, %rdi
movq %r12, %rsi
callq *0x58(%rax)
leaq -0x28(%rbp), %rdi
callq 0x423de
leaq -0x48(%rbp), %rdi
callq 0x423de
cmpl $0x2, 0x18(%rbx)
je 0x2e632
movq -0x40(%rbp), %rdi
callq 0x32b9a
leaq -0x38(%rbp), %rdi
movq -0x8(%rdi), %rbx
callq 0x423de
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x46258(%rip), %rdi     # 0x748ae
leaq 0x45850(%rip), %rsi     # 0x73ead
leaq 0x461d7(%rip), %rcx     # 0x7483b
movl $0x38cb, %edx           # imm = 0x38CB
callq 0x24390
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0x423de
jmp 0x2e683
jmp 0x2e680
jmp 0x2e68e
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x423de
jmp 0x2e691
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x423de
movq %rbx, %rdi
callq 0x24950
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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 %r12
pushq %rbx
subq $0xf0, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movl 0x88(%rsi), %eax
testl %eax, %eax
je 0x2ea6e
testb $0x10, %al
je 0x2ea75
movl 0x30(%rbx), %eax
andl $0x8, %eax
jne 0x2ea75
movb $0x0, 0x1e9(%r14)
movq 0x38(%r14), %rax
testb $0xc, 0xa0(%rax)
je 0x2eb1f
incq 0x108(%r14)
jmp 0x2ea7d
incq 0xf8(%r14)
movb $0x1, 0x1e9(%r14)
movq 0x128(%r14), %r15
leaq 0x130(%r14), %rdx
leaq 0xf0(%r14), %rcx
leaq -0x108(%rbp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x2a98e
movq (%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
callq *0x50(%rax)
leaq -0x108(%rbp), %rdi
callq 0x2ab14
cmpl $0x2, 0x88(%rbx)
je 0x2ead1
leaq 0x148(%r14), %rdi
callq 0x3ea28
leaq 0x45393(%rip), %rax     # 0x73e6b
movq %rax, 0x160(%r14)
andq $0x0, 0x168(%r14)
leaq 0x4594b(%rip), %rax     # 0x74439
movq %rax, 0x180(%r14)
movq $0x2c, 0x188(%r14)
addq $0x48, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3ea36
addq $0xf0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
incq 0x100(%r14)
jmp 0x2ea7d
movq %rax, %rbx
leaq -0x108(%rbp), %rdi
callq 0x2ab14
movq %rbx, %rdi
callq 0x24950
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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 0x32494
movq %rbx, %rdi
movq %r13, %rsi
callq 0x2e562
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x24ad8
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
movl %eax, %r13d
testb %al, %al
je 0x2ec2e
leaq 0x1b0(%r14), %rdi
leaq -0x60(%rbp), %rsi
movq %rbx, (%rsi)
callq 0x57e96
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 -0x60(%rbp), %rdi
callq 0x24ad8
movq %rbx, %rdi
callq 0x24950
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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 %rbx
subq $0x68, %rsp
movq %rcx, %rbx
movq %rdi, %r14
leaq -0x78(%rbp), %rax
movq %rsi, (%rax)
movq %rdx, 0x8(%rax)
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x3d4fc
leaq -0x68(%rbp), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x32494
leaq 0x1c8(%r14), %rdi
leaq -0x68(%rbp), %rsi
callq 0x3ea6c
movq %rax, %r15
leaq -0x68(%rbp), %rdi
callq 0x24ad8
leaq -0x38(%rbp), %rdi
callq 0x24ad8
movups (%rbx), %xmm0
movups %xmm0, 0x170(%r14)
addq $0x68, %r15
movq %r15, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x24ad8
jmp 0x2ece3
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x24ad8
movq %rbx, %rdi
callq 0x24950
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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
movq 0xf8(%rdi), %rax
subq 0x50(%rsi), %rax
leaq -0x38(%rbp), %rsi
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 0x2ecf4
movl %eax, %r15d
movq 0x1b8(%rbx), %rax
cmpq %rax, 0x1b0(%rbx)
je 0x2edd8
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 -0xb8(%rbp), %r15
leaq -0x38(%rbp), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x2ab66
movq (%r12), %rax
movq %r12, %rdi
movq %r15, %rsi
callq *0x58(%rax)
leaq -0xb8(%rbp), %rdi
callq 0x2abc0
leaq 0x130(%rbx), %rdi
callq 0x3ec32
addq $0x148, %rbx            # imm = 0x148
movq %rbx, %rdi
callq 0x3ea28
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0xb8(%rbp), %rdi
callq 0x2abc0
movq %rbx, %rdi
callq 0x24950
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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
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_O2/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
movq %rdi, %r14
leaq 0x198(%rdi), %rbx
movq 0x198(%rdi), %r12
movq 0x1a0(%rdi), %r15
cmpq %r12, %r15
je 0x2f2b6
addq $-0x70, %r15
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0x18(%rax)
jmp 0x2f29f
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3ecf8
// File: /workspace/github_cpp_makefile_star2_O2/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
movb $0x1, 0x1e9(%rdi)
incq 0xf8(%rdi)
leaq 0x44b80(%rip), %rax     # 0x73e6b
movq %rax, 0x160(%rdi)
andq $0x0, 0x168(%rdi)
leaq 0x45138(%rip), %rax     # 0x74439
movq %rax, 0x180(%rdi)
movq $0x2c, 0x188(%rdi)
addq $0x148, %rdi            # imm = 0x148
popq %rbp
jmp 0x3ea28
// File: /workspace/github_cpp_makefile_star2_O2/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, %r15
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movq 0x128(%rdi), %rdi
movq (%rdi), %rax
callq *0x48(%rax)
movl 0x30(%r12), %r8d
andl $0x4, %r8d
shrl $0x2, %r8d
cmpb 0x9(%r14), %r8b
je 0x2f46c
cmpb $0x0, 0x1eb(%rbx)
je 0x2f490
movq %rbx, %rdi
movq %r12, %rsi
xorl %edx, %edx
movq %r14, %rcx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2f4a4
pushq $0x11
popq %rdx
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rcx
callq 0x2f4a4
movq %rbx, %rdi
movq %r15, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2f590
movq (%rbx), %rax
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmpq *0x88(%rax)
// File: /workspace/github_cpp_makefile_star2_O2/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 -0xc0(%rbp), %r13
movq %r13, %rdi
movl %r8d, %esi
callq 0x25734
leaq -0x118(%rbp), %r14
movq %r14, %rdi
movl %r15d, %esi
movq %r13, %rdx
callq 0x25bae
leaq -0xc0(%rbp), %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x25cc0
leaq -0xc0(%rbp), %rsi
movq -0x30(%rbp), %rax
movq %rax, 0x78(%rsi)
movq %rbx, %rdi
callq 0x2ea1e
leaq -0x88(%rbp), %rdi
callq 0x3ecc2
leaq -0x118(%rbp), %rdi
callq 0x3ecc2
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x3ecc2
jmp 0x2f57c
movq %rax, %rbx
leaq -0x118(%rbp), %rdi
callq 0x3ecc2
movq %rbx, %rdi
callq 0x24950
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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 0x25734
leaq -0x110(%rbp), %rdi
movl %r12d, %esi
movq %r13, %rdx
callq 0x25bae
leaq -0xb8(%rbp), %rdi
movq %r15, %rsi
callq 0x3d4fc
leaq 0x160(%r14), %r15
leaq -0x110(%rbp), %r12
movq %r12, %rdi
movq %r13, %rsi
callq 0x24690
movq %r13, %rdi
callq 0x24ad8
leaq -0xb8(%rbp), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x25cc0
leaq -0xb8(%rbp), %rsi
movq %r14, %rdi
callq 0x2ea1e
testb $0x10, -0x30(%rbp)
je 0x2f6c4
movl -0x88(%rbp), %eax
andl $0x8, %eax
jne 0x2f6c4
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2f590
leaq -0x80(%rbp), %rdi
callq 0x3ecc2
leaq -0x110(%rbp), %rdi
callq 0x3ecc2
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2f6ed
movq %rax, %rbx
jmp 0x2f6fe
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
callq 0x3ecc2
leaq -0x110(%rbp), %rdi
callq 0x3ecc2
movq %rbx, %rdi
callq 0x24950
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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 0x25734
leaq -0x88(%rbp), %rbx
movq %rbx, %rdi
movl $0x111, %esi            # imm = 0x111
movq %r13, %rdx
callq 0x25bae
movq %rbx, %rdi
movq %r12, %rsi
callq 0x242f0
leaq -0x118(%rbp), %rdi
leaq -0x88(%rbp), %rdx
movq %r15, %rsi
callq 0x25cc0
leaq -0x118(%rbp), %rsi
movq %r14, %rdi
callq 0x2ea1e
movq %r14, %rdi
movq -0x30(%rbp), %rsi
callq 0x2f590
leaq -0xe0(%rbp), %rdi
callq 0x3ecc2
leaq -0x88(%rbp), %rdi
callq 0x3ecc2
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2f802
movq %rax, %rbx
jmp 0x2f816
movq %rax, %rbx
leaq -0xe0(%rbp), %rdi
callq 0x3ecc2
leaq -0x88(%rbp), %rdi
callq 0x3ecc2
movq %rbx, %rdi
callq 0x24950
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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 0x25734
leaq -0x78(%rbp), %r12
movq %r12, %rdi
movl $0x111, %esi            # imm = 0x111
movq %r15, %rdx
callq 0x25bae
leaq 0x44bd9(%rip), %rsi     # 0x74470
movq %r12, %rdi
callq 0x24a20
leaq -0x108(%rbp), %rdi
leaq -0x78(%rbp), %rdx
movq %r14, %rsi
callq 0x25cc0
leaq -0x108(%rbp), %rsi
movq %rbx, %rdi
callq 0x2ea1e
leaq -0xd0(%rbp), %rdi
callq 0x3ecc2
leaq -0x78(%rbp), %rdi
callq 0x3ecc2
addq $0xf0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0xd0(%rbp), %rdi
callq 0x3ecc2
jmp 0x2f8fc
jmp 0x2f8f9
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x3ecc2
movq %rbx, %rdi
callq 0x24950
nop
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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 0x25734
leaq -0x118(%rbp), %rbx
movq %rbx, %rdi
movl %r15d, %esi
movq %r13, %rdx
callq 0x25bae
leaq -0xc0(%rbp), %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x25cc0
leaq -0xc0(%rbp), %rsi
movq %r14, %rdi
callq 0x2ea1e
testb $0x10, -0x38(%rbp)
je 0x2f9bc
movl -0x90(%rbp), %eax
andl $0x8, %eax
jne 0x2f9bc
movq %r14, %rdi
movq -0x30(%rbp), %rsi
callq 0x2f590
leaq -0x88(%rbp), %rdi
callq 0x3ecc2
leaq -0x118(%rbp), %rdi
callq 0x3ecc2
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x2f9fa
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x3ecc2
leaq -0x118(%rbp), %rdi
callq 0x3ecc2
movq %rbx, %rdi
callq 0x24950
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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 %rbx
subq $0x78, %rsp
movq %rdi, %rbx
leaq 0x7a8b7(%rip), %rax     # 0xaa398
addq $0x10, %rax
movq %rax, (%rdi)
cmpb $0x1, 0x90(%rdi)
jne 0x2fb52
leaq 0x8(%rbx), %rsi
leaq -0x78(%rbp), %rdi
callq 0x3e092
movq 0x88(%rbx), %rax
movq %rax, -0x18(%rbp)
movups 0x78(%rbx), %xmm0
movups %xmm0, -0x28(%rbp)
leaq 0x98(%rbx), %rdi
callq 0x2f3ea
movsd %xmm0, -0x10(%rbp)
callq 0x24060
testb %al, %al
je 0x2fb34
callq 0x25825
pushq $0x20
jmp 0x2fb3b
callq 0x25825
pushq $0x18
popq %rcx
movq (%rax), %rdx
leaq -0x78(%rbp), %rsi
movq %rax, %rdi
callq *(%rdx,%rcx)
leaq -0x78(%rbp), %rdi
callq 0x3e0d2
leaq 0x58(%rbx), %rdi
callq 0x24ad8
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x3e0d2
addq $0x78, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rdi
callq 0x3dcad
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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, %rbx
movq 0x7df89(%rip), %rdi     # 0xadf98
leaq 0x4450a(%rip), %rsi     # 0x74520
callq 0x24570
movq %rax, %r14
callq 0x30104
leaq 0x7edce(%rip), %rsi     # 0xaedf8
movq %r14, %rdi
callq 0x30076
leaq 0x4d1a5(%rip), %rsi     # 0x7d1de
movq %r14, %rdi
callq 0x24570
movq %rax, %r14
addq $0x8, %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x45cbc
movq %r14, %rdi
callq 0x242a0
leaq 0x444c7(%rip), %rsi     # 0x74529
movq %rax, %rdi
callq 0x24570
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x242a0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl (%rsi), %esi
callq 0x243c0
pushq $0x2e
popq %r15
movq %rax, %rdi
movl %r15d, %esi
callq 0x24670
movl 0x4(%r14), %esi
movq %rax, %rdi
callq 0x243c0
movq %rax, %rdi
movl %r15d, %esi
callq 0x24670
movl 0x8(%r14), %esi
movq %rax, %rdi
callq 0x243c0
movq 0x10(%r14), %rax
cmpb $0x0, (%rax)
je 0x300f6
pushq $0x2d
popq %rsi
movq %rbx, %rdi
callq 0x24670
movq 0x10(%r14), %rsi
movq %rax, %rdi
callq 0x24570
pushq $0x2e
popq %rsi
movq %rax, %rdi
callq 0x24670
movl 0x18(%r14), %esi
movq %rax, %rdi
callq 0x243c0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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 %r14
pushq %rbx
movq 0x7de14(%rip), %rdi     # 0xadf98
movq (%rdi), %rax
movq -0x18(%rax), %rcx
movl $0xffffff4f, %ebx       # imm = 0xFFFFFF4F
movl 0x18(%rdi,%rcx), %edx
andl %ebx, %edx
orl $0x20, %edx
movl %edx, 0x18(%rdi,%rcx)
movq -0x18(%rax), %rax
pushq $0x10
popq %r14
movq %r14, 0x10(%rdi,%rax)
leaq 0x443ad(%rip), %rsi     # 0x7455e
callq 0x24570
leaq 0x443af(%rip), %rsi     # 0x7456c
movq %rax, %rdi
callq 0x24570
movq (%rax), %rcx
movq -0x18(%rcx), %rdx
movl 0x18(%rax,%rdx), %esi
andl %ebx, %esi
orl $0x20, %esi
movl %esi, 0x18(%rax,%rdx)
movq -0x18(%rcx), %rcx
movq %r14, 0x10(%rax,%rcx)
leaq 0x4439d(%rip), %rsi     # 0x74586
movq %rax, %rdi
callq 0x24570
leaq 0x44399(%rip), %rsi     # 0x74591
movq %rax, %rdi
callq 0x24570
movq (%rax), %rcx
movq -0x18(%rcx), %rdx
movl 0x18(%rax,%rdx), %esi
andl %ebx, %esi
orl $0x20, %esi
movl %esi, 0x18(%rax,%rdx)
movq -0x18(%rcx), %rcx
movq %r14, 0x10(%rax,%rcx)
leaq 0x4437c(%rip), %rsi     # 0x745a0
movq %rax, %rdi
callq 0x24570
leaq 0x44379(%rip), %rsi     # 0x745ac
movq %rax, %rdi
callq 0x24570
movq (%rax), %rcx
movq -0x18(%rcx), %rdx
andl 0x18(%rax,%rdx), %ebx
orl $0x20, %ebx
movl %ebx, 0x18(%rax,%rdx)
movq -0x18(%rcx), %rcx
movq %r14, 0x10(%rax,%rcx)
leaq 0x4435b(%rip), %rsi     # 0x745b8
movq %rax, %rdi
callq 0x24570
movq %rax, %rbx
callq 0x30104
leaq 0x7eb84(%rip), %rsi     # 0xaedf8
movq %rbx, %rdi
callq 0x30076
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x242a0
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::Session::applyCommandLine(int, char const* const*)
int Session::applyCommandLine( int argc, char const * const * argv ) {
        if( m_startupExceptions )
            return 1;

        auto result = m_cli.parse( clara::Args( argc, argv ) );
        if( !result ) {
            config();
            getCurrentMutableContext().setConfig(m_config);
            Catch::cerr()
                << Colour( Colour::Red )
                << "\nError(s) in input:\n"
                << Column( result.errorMessage() ).indent( 2 )
                << "\n\n";
            Catch::cerr() << "Run with -? for usage\n" << std::endl;
            return MaxExitCode;
        }

        if( m_configData.showHelp )
            showHelp();
        if( m_configData.libIdentify )
            libIdentify();
        m_config.reset();
        return 0;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xc8, %rsp
cmpb $0x0, 0x188(%rdi)
je 0x302a9
pushq $0x1
popq %rbx
jmp 0x303f0
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
leaq -0x58(%rbp), %r15
movq %r15, %rdi
callq 0x3ef40
leaq -0xd8(%rbp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x3eebc
leaq -0x58(%rbp), %rdi
callq 0x3ef98
cmpl $0x0, -0xd0(%rbp)
je 0x303ba
movq %rbx, %rdi
callq 0x2ff3c
callq 0x3e53f
movq %rax, %r14
addq $0x178, %rbx            # imm = 0x178
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4b9a6
movq (%r14), %rax
movq %r14, %rdi
movq %r15, %rsi
callq *0x38(%rax)
leaq -0x50(%rbp), %rdi
callq 0x423de
leaq -0x19(%rbp), %rdi
pushq $0x2
popq %rsi
callq 0x29a20
movq 0x7dcb2(%rip), %rdi     # 0xadfe0
leaq 0x4428d(%rip), %rsi     # 0x745c2
callq 0x24570
movq %rax, %rbx
leaq -0x98(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0x24760
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x3e2d8
leaq -0x58(%rbp), %rsi
movq $0x2, 0x20(%rsi)
movq %rbx, %rdi
callq 0x3e20a
leaq 0x4ce68(%rip), %rsi     # 0x7d1dd
movq %rax, %rdi
callq 0x24570
leaq -0x58(%rbp), %rdi
callq 0x3f34e
leaq -0x78(%rbp), %rdi
callq 0x24ad8
leaq -0x19(%rbp), %rdi
callq 0x29ba2
movq 0x7dc41(%rip), %rdi     # 0xadfe0
leaq 0x44231(%rip), %rsi     # 0x745d7
callq 0x24570
movl $0xff, %ebx
movq %rax, %rdi
callq 0x242a0
jmp 0x303e4
cmpb $0x1, 0x6f(%rbx)
jne 0x303c8
movq %rbx, %rdi
callq 0x2fffe
cmpb $0x1, 0x72(%rbx)
jne 0x303d3
callq 0x30176
addq $0x178, %rbx            # imm = 0x178
movq %rbx, %rdi
callq 0x3efb8
xorl %ebx, %ebx
leaq -0xd8(%rbp), %rdi
callq 0x3efe6
movl %ebx, %eax
addq $0xc8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x30436
jmp 0x30407
movq %rax, %rbx
jmp 0x3043f
jmp 0x3044a
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x423de
jmp 0x3044d
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x3ef98
jmp 0x30459
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x3f34e
leaq -0x78(%rbp), %rdi
callq 0x24ad8
leaq -0x19(%rbp), %rdi
callq 0x29ba2
jmp 0x3044d
movq %rax, %rbx
leaq -0xd8(%rbp), %rdi
callq 0x3efe6
movq %rbx, %rdi
callq 0x24950
nop
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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 0x304bd
movq 0x7daf4(%rip), %rdi     # 0xadf98
leaq 0x44143(%rip), %rsi     # 0x745ee
callq 0x24570
movq %rax, %rdi
callq 0x242a0
callq 0x24770
movq %r14, %rdi
callq 0x30502
movl %eax, %ebx
testb $0x2, 0xc0(%r14)
je 0x304fb
movq 0x7dac0(%rip), %rdi     # 0xadf98
leaq 0x4413c(%rip), %rsi     # 0x7461b
callq 0x24570
movq %rax, %rdi
movl %ebx, %esi
callq 0x24900
movq %rax, %rdi
callq 0x242a0
callq 0x24770
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3f98e
leaq 0x200(%rbx), %rdi
callq 0x47d9c
leaq 0x10(%rbx), %rdi
callq 0x2df3a
addq $0x8, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x423de
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::(anonymous namespace)::getSingletons()
static auto getSingletons() -> std::vector<ISingleton*>*& {
            static std::vector<ISingleton*>* g_singletons = nullptr;
            if( !g_singletons )
                g_singletons = new std::vector<ISingleton*>();
            return g_singletons;
        }

// Assembly:
cmpq $0x0, 0x7e08c(%rip)     # 0xaee38
je 0x30daf
retq
pushq %rbp
movq %rsp, %rbp
pushq $0x18
popq %rdi
callq 0x24580
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
andq $0x0, 0x10(%rax)
movq %rax, 0x7e06b(%rip)     # 0xaee38
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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 0x58fdc
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_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::TagAliasRegistry::expandAliases(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
std::string TagAliasRegistry::expandAliases( std::string const& unexpandedTestSpec ) const {
        std::string expandedTestSpec = unexpandedTestSpec;
        for( auto const& registryKvp : m_registry ) {
            std::size_t pos = expandedTestSpec.find( registryKvp.first );
            if( pos != std::string::npos ) {
                expandedTestSpec =  expandedTestSpec.substr( 0, pos ) +
                                    registryKvp.second.tag +
                                    expandedTestSpec.substr( pos + registryKvp.first.size() );
            }
        }
        return expandedTestSpec;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r14
movq %rdi, %r13
movq %rdx, %rsi
callq 0x24760
movq 0x20(%r14), %r15
addq $0x10, %r14
movq %r14, -0x38(%rbp)
leaq -0xb8(%rbp), %r14
movq %r13, -0x30(%rbp)
cmpq -0x38(%rbp), %r15
je 0x313cc
leaq 0x20(%r15), %rsi
movq %r13, %rdi
xorl %edx, %edx
callq 0x24aa0
cmpq $-0x1, %rax
je 0x313bc
movq %rax, %r12
movq %r13, %rsi
leaq -0x58(%rbp), %r13
movq %r13, %rdi
xorl %edx, %edx
movq %rax, %rcx
callq 0x245e0
leaq 0x40(%r15), %rdx
leaq -0x78(%rbp), %rdi
movq %r13, %rsi
callq 0x3f2a1
addq 0x28(%r15), %r12
leaq -0x98(%rbp), %rbx
movq %rbx, %rdi
movq -0x30(%rbp), %r13
movq %r13, %rsi
movq %r12, %rdx
pushq $-0x1
popq %rcx
callq 0x245e0
movq %r14, %rdi
leaq -0x78(%rbp), %r12
movq %r12, %rsi
movq %rbx, %rdx
callq 0x3e66e
movq %r13, %rdi
movq %r14, %rsi
callq 0x24690
movq %r14, %rdi
callq 0x24ad8
movq %rbx, %rdi
callq 0x24ad8
movq %r12, %rdi
callq 0x24ad8
leaq -0x58(%rbp), %rdi
callq 0x24ad8
movq %r15, %rdi
callq 0x24650
movq %rax, %r15
jmp 0x31315
movq %r13, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x98(%rbp), %rdi
callq 0x24ad8
jmp 0x313ff
movq %rax, %r14
jmp 0x31411
movq %rax, %r14
jmp 0x31408
movq %rax, %r14
leaq -0x78(%rbp), %rdi
callq 0x24ad8
leaq -0x58(%rbp), %rdi
callq 0x24ad8
movq -0x30(%rbp), %rdi
callq 0x24ad8
movq %r14, %rdi
callq 0x24950