LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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 $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, -0x58(%rbp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x40(%rsi), %r13
movq 0x60(%rsi), %r15
cmpl $0x1, 0x30(%rsi)
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
jne 0x27806
leaq -0x50(%rbp), %rsi
movq $0x13, (%rsi)
leaq -0x48(%rbp), %rdi
xorl %edx, %edx
callq 0x1b920
movq %rax, -0x48(%rbp)
movq -0x50(%rbp), %rcx
movq %rcx, -0x38(%rbp)
movups 0x53a9a(%rip), %xmm0    # 0x7b284
movups %xmm0, (%rax)
movl $0x29657669, 0xf(%rax)  # imm = 0x29657669
movq %rcx, -0x40(%rbp)
movq -0x48(%rbp), %rax
movb $0x0, (%rax,%rcx)
movq -0x40(%rbp), %rax
jmp 0x27814
movq $0x0, -0x40(%rbp)
movb $0x0, -0x38(%rbp)
xorl %eax, %eax
addq %r13, %r15
leaq (%rax,%r15), %rsi
addq $0x5, %rsi
movq %rbx, %rdi
callq 0x1b7e0
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x27835
callq 0x1b4d0
movq 0x58(%r14), %rsi
movq 0x60(%r14), %rdx
movq %rbx, %rdi
callq 0x1b150
leaq 0x53a34(%rip), %rsi     # 0x7b280
movq %rbx, %rdi
callq 0x1b9d0
movq 0x38(%r14), %rsi
movq 0x40(%r14), %rdx
movq %rbx, %rdi
callq 0x1b150
leaq 0x53efc(%rip), %rsi     # 0x7b767
movq %rbx, %rdi
callq 0x1b9d0
cmpl $0x1, 0x30(%r14)
movq %r12, -0x48(%rbp)
jne 0x278c7
leaq -0x50(%rbp), %rsi
movq $0x13, (%rsi)
leaq -0x48(%rbp), %rdi
xorl %edx, %edx
callq 0x1b920
movq %rax, -0x48(%rbp)
movq -0x50(%rbp), %rcx
movq %rcx, -0x38(%rbp)
movups 0x539dd(%rip), %xmm0    # 0x7b284
movups %xmm0, (%rax)
movl $0x29657669, 0xf(%rax)  # imm = 0x29657669
movq %rcx, -0x40(%rbp)
movq -0x48(%rbp), %rax
movb $0x0, (%rax,%rcx)
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
jmp 0x278d8
movq $0x0, -0x40(%rbp)
movb $0x0, -0x38(%rbp)
xorl %edx, %edx
movq %r12, %rsi
movq %rbx, %rdi
callq 0x1b150
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x278ee
callq 0x1b4d0
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x27919
jmp 0x27919
jmp 0x27906
movq %rax, %r14
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x2791c
callq 0x1b4d0
jmp 0x2791c
movq %rax, %r14
movq (%rbx), %rdi
cmpq -0x58(%rbp), %rdi
je 0x2792a
callq 0x1b4d0
movq %r14, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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 $0x40, %rsp
xorl %edx, %edx
cmpl $0x1, 0x50(%rdi)
movq %rsi, %rbx
sete %dl
orl $0x10, %edx
leaq 0x30(%rdi), %rsi
leaq -0x50(%rbp), %r14
movq %r14, %rdi
callq 0x3f31c
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
addq %rdi, %rsi
xorps %xmm0, %xmm0
leaq -0x30(%rbp), %rdx
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, (%rdx)
movq %r14, %rcx
xorl %r8d, %r8d
callq 0x58783
movl %eax, %ebx
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x27ed3
callq 0x1b4d0
leaq -0x50(%rbp), %rdi
callq 0x3f386
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x27ef8
callq 0x1b4d0
leaq -0x50(%rbp), %rdi
callq 0x3f386
movq %rbx, %rdi
callq 0x1b910
nop
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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 0x1b070
testb %al, %al
jne 0x28904
movq 0x8(%rbx), %rcx
movq 0x20(%rbx), %rax
subq (%rbx), %rcx
sarq $0x3, %rcx
movabsq $-0x71c71c71c71c71c7, %rdx # imm = 0x8E38E38E38E38E39
imulq %rcx, %rdx
cmpq %rdx, %rax
jne 0x28916
testq %rax, %rax
je 0x28904
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x18(%rbx), %rdi
movq (%rbx), %rsi
addq %r14, %rsi
movq (%rdi), %rax
callq *0x38(%rax)
incq %r15
addq $0x48, %r14
cmpq 0x20(%rbx), %r15
jb 0x288e7
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3ed30
leaq 0x52a5a(%rip), %rdi     # 0x7b377
leaq 0x525b1(%rip), %rsi     # 0x7aed5
leaq 0x52a6c(%rip), %rcx     # 0x7b397
movl $0x2e95, %edx           # imm = 0x2E95
callq 0x1b320
movq %rax, %rdi
callq 0x3e96e
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rdi, %rbx
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movabsq $-0x71c71c71c71c71c7, %rdi # imm = 0x8E38E38E38E38E39
imulq %rcx, %rdi
cmpq %rsi, %rdi
jbe 0x2899e
shlq $0x3, %rsi
leaq (%rsi,%rsi,8), %r14
leaq (%rax,%r14), %rdi
addq $0x10, %rdi
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
callq 0x1b150
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 0x52a0f(%rip), %rdi     # 0x7b3b4
leaq 0x52529(%rip), %rsi     # 0x7aed5
leaq 0x52a1b(%rip), %rcx     # 0x7b3ce
movl $0x2e9c, %edx           # imm = 0x2E9C
callq 0x1b320
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x28d01
movq (%rdi), %rax
movabsq $0x5851f42d4c957f2d, %rcx # imm = 0x5851F42D4C957F2D
movabsq $0x27da198a7f2728ed, %rdx # imm = 0x27DA198A7F2728ED
imulq %rcx, %rax
addq %rdx, %rax
decq %rsi
jne 0x28cf2
movq %rax, (%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x820b7(%rip), %rbx     # 0xaadf8
testq %rbx, %rbx
je 0x28d4b
movq (%rbx), %r14
jmp 0x28d70
movl $0x18, %edi
callq 0x1b510
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rax, 0x8208b(%rip)     # 0xaadf8
xorl %r14d, %r14d
movq 0x8(%rbx), %r15
cmpq %r15, %r14
je 0x28d9c
movq (%r14), %rdi
testq %rdi, %rdi
je 0x28d87
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
cmpq %r15, %r14
jne 0x28d79
movq 0x82061(%rip), %rbx     # 0xaadf8
testq %rbx, %rbx
je 0x28dab
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x28dad
callq 0x1b4d0
jmp 0x28dad
xorl %ebx, %ebx
movq %rbx, %rdi
callq 0x1b4d0
movq $0x0, 0x82038(%rip) # 0xaadf8
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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 0x4ac1e
addq $0x10, %r15
cmpq %r15, %rax
je 0x28e79
movq 0x40(%rax), %r15
leaq -0x38(%rbp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x248f8
movq (%r15), %rax
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq *0x10(%rax)
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x28e80
callq 0x43a1a
jmp 0x28e80
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 0x28ea1
callq 0x43a1a
movq %rbx, %rdi
callq 0x1b910
nop
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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 0x51e74(%rip), %rsi     # 0x7b7b6
leaq 0x51e73(%rip), %rdx     # 0x7b7bc
leaq -0x58(%rbp), %r14
movq %r14, %rdi
callq 0x431c8
leaq 0x51579(%rip), %rax     # 0x7aed5
leaq -0x98(%rbp), %rdx
movq %rax, (%rdx)
movq $0x3824, 0x8(%rdx)      # imm = 0x3824
leaq -0x88(%rbp), %rdi
movq %r14, %rsi
callq 0x2f400
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 0x5f3b4
movaps -0x30(%rbp), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, -0x30(%rbp)
movq 0x8(%rbx), %rdi
movups %xmm0, (%rbx)
testq %rdi, %rdi
je 0x299cf
callq 0x43a1a
movq -0x28(%rbp), %rdi
testq %rdi, %rdi
je 0x299cf
callq 0x43a1a
leaq -0x78(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x299e1
callq 0x1b4d0
movq -0x58(%rbp), %rdi
cmpq %r15, %rdi
je 0x299ef
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 0x29a29
callq 0x1b4d0
jmp 0x29a29
movq %rax, %rbx
movq -0x58(%rbp), %rdi
cmpq %r15, %rdi
je 0x29a37
callq 0x1b4d0
movq %rbx, %rdi
callq 0x1b910
nop
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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 $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %r12
movq (%r12), %rax
leaq -0x48(%rbp), %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq *0x60(%rax)
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0x29b31
movq (%rdi), %rax
callq *0x70(%rax)
testb %al, %al
je 0x29c05
movq -0x48(%rbp), %r15
movq -0x40(%rbp), %rbx
testq %rbx, %rbx
je 0x29b7d
movq 0x80469(%rip), %rax     # 0xa9f90
cmpb $0x0, (%rax)
je 0x29b81
incl 0x8(%rbx)
jmp 0x29ba7
leaq -0x50(%rbp), %r9
movq %r12, (%r9)
leaq -0x30(%rbp), %rdi
movq $0x0, -0x8(%rdi)
leaq -0x38(%rbp), %rsi
leaq -0x21(%rbp), %rdx
movq %rbx, %rcx
movq %r14, %r8
callq 0x5f636
movq -0x38(%rbp), %r15
movq -0x30(%rbp), %rbx
movq %r15, -0x38(%rbp)
movq %rbx, -0x30(%rbp)
testq %rbx, %rbx
je 0x29b8b
movq 0x8041d(%rip), %rax     # 0xa9f90
cmpb $0x0, (%rax)
je 0x29b87
incl 0x8(%rbx)
jmp 0x29b8b
xorl %ebx, %ebx
jmp 0x29ba7
lock
incl 0x8(%rbx)
jmp 0x29ba7
lock
incl 0x8(%rbx)
movq (%r12), %rax
leaq -0x38(%rbp), %rsi
movq %r12, %rdi
callq *0x58(%rax)
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x29ba7
callq 0x43a1a
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x29bb5
callq 0x43a1a
cmpl $0x2, 0x18(%r14)
je 0x29be8
movq (%r15), %rax
movq %r15, %rdi
callq *0x10(%rax)
testb %al, %al
jne 0x29be8
movl $0x1, 0x60(%r15)
movq 0x38(%r15), %rax
movq %r15, 0x10(%rax)
movq 0x40(%r15), %rdi
testq %rdi, %rdi
je 0x29be8
movq (%rdi), %rax
callq *0x68(%rax)
testq %rbx, %rbx
je 0x29bf5
movq %rbx, %rdi
callq 0x43a1a
movq %r15, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x51cca(%rip), %rdi     # 0x7b8d6
leaq 0x512c2(%rip), %rsi     # 0x7aed5
leaq 0x51c49(%rip), %rcx     # 0x7b863
movl $0x38cb, %edx           # imm = 0x38CB
callq 0x1b320
movq %rax, %r14
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x29c3e
callq 0x43a1a
jmp 0x29c3e
jmp 0x29c39
movq %rax, %r14
xorl %ebx, %ebx
movq -0x40(%rbp), %rdi
testq %rdi, %rdi
je 0x29c58
callq 0x43a1a
jmp 0x29c58
movq %rax, %r14
jmp 0x29c58
movq %rax, %r14
xorl %ebx, %ebx
testq %rbx, %rbx
je 0x29c65
movq %rbx, %rdi
callq 0x43a1a
movq %r14, %rdi
callq 0x1b910
nop
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::Totals::delta(Catch::Totals const&) const
Totals Totals::delta( Totals const& prevTotals ) const {
        Totals diff = *this - prevTotals;
        if( diff.assertions.failed > 0 )
            ++diff.testCases.failed;
        else if( diff.assertions.failedButOk > 0 )
            ++diff.testCases.failedButOk;
        else
            ++diff.testCases.passed;
        return diff;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x31dcc
xorl %eax, %eax
cmpq $0x0, 0x18(%rbx)
setne %al
shll $0x4, %eax
orq $0x20, %rax
cmpq $0x0, 0x10(%rbx)
movl $0x28, %ecx
cmoveq %rax, %rcx
incq (%rbx,%rcx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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 0x2a0de
testb $0x10, %al
je 0x2a0e5
movl 0x30(%rbx), %eax
andl $0x8, %eax
jne 0x2a0e5
movb $0x0, 0x1e9(%r14)
movq 0x38(%r14), %rax
testb $0xc, 0xa0(%rax)
je 0x2a1b6
incq 0x108(%r14)
jmp 0x2a0ed
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 0x24a0c
movq (%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
callq *0x50(%rax)
leaq -0x110(%rbp), %rdi
callq 0x24c86
cmpl $0x2, 0x88(%rbx)
je 0x2a163
movq 0x148(%r14), %r12
movq 0x150(%r14), %r13
cmpq %r12, %r13
je 0x2a163
movq %r12, %r15
movq %r15, %rdi
callq 0x2839e
addq $0x50, %r15
cmpq %r13, %r15
jne 0x2a14b
movq %r12, 0x150(%r14)
leaq 0x50d29(%rip), %rax     # 0x7ae93
movq %rax, 0x160(%r14)
movq $0x0, 0x168(%r14)
leaq 0x512de(%rip), %rax     # 0x7b461
movq %rax, 0x180(%r14)
movq $0x2c, 0x188(%r14)
addq $0x48, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3f522
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
incq 0x100(%r14)
jmp 0x2a0ed
movq %rax, %rbx
leaq -0x110(%rbp), %rdi
callq 0x24c86
movq %rbx, %rdi
callq 0x1b910
nop
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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 0x2f400
movq %rbx, %rdi
movq %r13, %rsi
callq 0x29ad2
movq %rax, %rbx
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2a277
callq 0x1b4d0
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x20(%rax)
movl %eax, %r13d
testb %al, %al
je 0x2a2ef
movq %rbx, -0x60(%rbp)
movq 0x1b8(%r14), %rsi
cmpq 0x1c0(%r14), %rsi
je 0x2a2a8
movq %rbx, (%rsi)
addq $0x8, 0x1b8(%r14)
jmp 0x2a2b8
leaq 0x1b0(%r14), %rdi
leaq -0x60(%rbp), %rdx
callq 0x5b34e
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 0x2a316
callq 0x1b4d0
movq %rbx, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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 0x431c8
leaq -0x70(%rbp), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x2f400
leaq 0x1c8(%r14), %rdi
leaq -0x70(%rbp), %rsi
callq 0x3f606
movq %rax, %r15
leaq -0x60(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2a37f
callq 0x1b4d0
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x2a38d
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 0x2a3c6
callq 0x1b4d0
jmp 0x2a3c6
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x2a3d4
callq 0x1b4d0
movq %rbx, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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 0x2a3dc
movl %eax, %r15d
movq 0x1b8(%rbx), %rax
cmpq %rax, 0x1b0(%rbx)
je 0x2a4c0
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 0x24cf2
movq (%r12), %rax
movq %r12, %rdi
movq %r15, %rsi
callq *0x58(%rax)
leaq -0xb8(%rbp), %rdi
callq 0x24db6
leaq 0x130(%rbx), %rdi
callq 0x3f84e
movq 0x148(%rbx), %r15
movq 0x150(%rbx), %r12
cmpq %r15, %r12
je 0x2a53a
movq %r15, %r14
movq %r14, %rdi
callq 0x2839e
addq $0x50, %r14
cmpq %r12, %r14
jne 0x2a522
movq %r15, 0x150(%rbx)
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0xb8(%rbp), %rdi
callq 0x24db6
movq %rbx, %rdi
callq 0x1b910
nop
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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), %r14
movq 0x1a0(%rdi), %r12
cmpq %r14, %r12
je 0x2aa76
movq %rdi, %r15
addq $-0x70, %r12
movq (%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
callq *0x18(%rax)
cmpq %r14, %r12
jne 0x2aa5e
movq (%rbx), %r14
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x5bc86
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x503dd(%rip), %rax     # 0x7ae93
movq %rax, 0x160(%rdi)
movq $0x0, 0x168(%rdi)
leaq 0x50992(%rip), %rax     # 0x7b461
movq %rax, 0x180(%rdi)
movq $0x2c, 0x188(%rdi)
movq 0x148(%rdi), %r15
movq 0x150(%rdi), %r12
cmpq %r15, %r12
je 0x2ab12
movq %rdi, %rbx
movq %r15, %r14
movq %r14, %rdi
callq 0x2839e
addq $0x50, %r14
cmpq %r12, %r14
jne 0x2aafa
movq %r15, 0x150(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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 0x2acbf
cmpb $0x0, 0x1eb(%r14)
je 0x2ad1b
movq %r14, %rdi
movq %r12, %rsi
xorl %edx, %edx
movq %r15, %rcx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2ad30
movq %r14, %rdi
movq %r12, %rsi
movl $0x11, %edx
movq %r15, %rcx
callq 0x2ad30
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_O3/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 0x1d0b8
leaq -0x88(%rbp), %r14
movq %r14, %rdi
movl %r15d, %esi
movq %r13, %rdx
callq 0x1d67a
leaq -0x118(%rbp), %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x1d7b2
leaq -0x118(%rbp), %rsi
movq -0x30(%rbp), %rax
movq %rax, 0x78(%rsi)
movq %rbx, %rdi
callq 0x2a08c
leaq -0xb0(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2addf
callq 0x1b4d0
leaq -0xd0(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2adf4
callq 0x1b4d0
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2ae06
callq 0x1b4d0
leaq -0x78(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2ae18
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 0x3ed90
jmp 0x2ae3e
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x3f90e
movq %rbx, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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 0x1d0b8
leaq -0x110(%rbp), %rdi
movl %r12d, %esi
movq %r13, %rdx
callq 0x1d67a
movq (%r15), %rsi
leaq -0xa8(%rbp), %r13
movq 0x8(%r15), %rdx
addq %rsi, %rdx
movq %r13, -0x10(%r13)
leaq -0xb8(%rbp), %rdi
callq 0x431c8
leaq 0x160(%r14), %r15
leaq -0x110(%rbp), %rdi
leaq -0xb8(%rbp), %r12
movq %r12, %rsi
callq 0x1b640
movq (%r12), %rdi
cmpq %r13, %rdi
je 0x2af7f
callq 0x1b4d0
leaq -0xb8(%rbp), %rdi
leaq -0x110(%rbp), %rdx
movq %r15, %rsi
callq 0x1d7b2
leaq -0xb8(%rbp), %rsi
movq %r14, %rdi
callq 0x2a08c
testb $0x10, -0x30(%rbp)
je 0x2aff5
movl -0x88(%rbp), %eax
andl $0x8, %eax
jne 0x2aff5
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 0x2b007
callq 0x1b4d0
leaq -0x70(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2b019
callq 0x1b4d0
leaq -0xe0(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2b02e
callq 0x1b4d0
leaq -0x100(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2b043
callq 0x1b4d0
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2b057
movq %rax, %rbx
jmp 0x2b06b
movq %rax, %rbx
leaq -0xb8(%rbp), %rdi
callq 0x3ed90
leaq -0x110(%rbp), %rdi
callq 0x3f90e
movq %rbx, %rdi
callq 0x1b910
nop
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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 0x1d0b8
leaq -0x88(%rbp), %rbx
movq %rbx, %rdi
movl $0x111, %esi            # imm = 0x111
movq %r13, %rdx
callq 0x1d67a
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1b290
leaq -0x118(%rbp), %rdi
leaq -0x88(%rbp), %rdx
movq %r15, %rsi
callq 0x1d7b2
leaq -0x118(%rbp), %rsi
movq %r14, %rdi
callq 0x2a08c
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 0x2b193
callq 0x1b4d0
leaq -0xd0(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2b1a8
callq 0x1b4d0
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2b1ba
callq 0x1b4d0
leaq -0x78(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2b1cc
callq 0x1b4d0
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2b1e0
movq %rax, %rbx
jmp 0x2b1f4
movq %rax, %rbx
leaq -0x118(%rbp), %rdi
callq 0x3ed90
leaq -0x88(%rbp), %rdi
callq 0x3f90e
movq %rbx, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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 0x1d0b8
leaq -0x78(%rbp), %r12
movq %r12, %rdi
movl $0x111, %esi            # imm = 0x111
movq %r15, %rdx
callq 0x1d67a
movq 0x8(%r12), %rdx
leaq 0x5021e(%rip), %rcx     # 0x7b498
movl $0x3f, %r8d
movq %r12, %rdi
xorl %esi, %esi
callq 0x1b7d0
leaq -0x108(%rbp), %rdi
leaq -0x78(%rbp), %rdx
movq %r14, %rsi
callq 0x1d7b2
leaq -0x108(%rbp), %rsi
movq %rbx, %rdi
callq 0x2a08c
leaq -0xa0(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2b2c1
callq 0x1b4d0
leaq -0xc0(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2b2d6
callq 0x1b4d0
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2b2e8
callq 0x1b4d0
leaq -0x68(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2b2fa
callq 0x1b4d0
addq $0xf0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x108(%rbp), %rdi
callq 0x3ed90
jmp 0x2b320
jmp 0x2b31d
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x3f90e
movq %rbx, %rdi
callq 0x1b910
nop
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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 0x1d0b8
leaq -0x118(%rbp), %rbx
movq %rbx, %rdi
movl %r15d, %esi
movq %r13, %rdx
callq 0x1d67a
leaq -0xc0(%rbp), %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x1d7b2
leaq -0xc0(%rbp), %rsi
movq %r14, %rdi
callq 0x2a08c
testb $0x10, -0x38(%rbp)
je 0x2b41c
movl -0x90(%rbp), %eax
andl $0x8, %eax
jne 0x2b41c
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 0x2b42e
callq 0x1b4d0
leaq -0x78(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2b440
callq 0x1b4d0
leaq -0xe8(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2b455
callq 0x1b4d0
leaq -0x108(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2b46a
callq 0x1b4d0
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x2b490
movq %rax, %rbx
leaq -0xc0(%rbp), %rdi
callq 0x3ed90
leaq -0x118(%rbp), %rdi
callq 0x3f90e
movq %rbx, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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 0x7ad69(%rip), %rax     # 0xa6378
addq $0x10, %rax
movq %rax, (%rdi)
cmpb $0x1, 0x90(%rdi)
jne 0x2b6fd
leaq -0x78(%rbp), %r14
movq %r14, -0x10(%r14)
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
addq %rsi, %rdx
leaq -0x88(%rbp), %rdi
callq 0x4a8c2
leaq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %r15
movq %r15, -0x10(%r15)
movq 0x28(%rbx), %rsi
movq 0x30(%rbx), %rdx
addq %rsi, %rdx
callq 0x4a8c2
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 0x4da4e(%rip), %xmm0    # 0x790f8
movsd %xmm0, -0x20(%rbp)
callq 0x1b070
testb %al, %al
je 0x2b6c4
callq 0x1d1b6
movl $0x20, %ecx
jmp 0x2b6ce
callq 0x1d1b6
movl $0x18, %ecx
movq (%rax), %rdx
leaq -0x88(%rbp), %rsi
movq %rax, %rdi
callq *(%rdx,%rcx)
movq -0x68(%rbp), %rdi
cmpq %r15, %rdi
je 0x2b6ec
callq 0x1b4d0
movq -0x88(%rbp), %rdi
cmpq %r14, %rdi
je 0x2b6fd
callq 0x1b4d0
movq 0x58(%rbx), %rdi
leaq 0x68(%rbx), %rax
cmpq %rax, %rdi
je 0x2b70f
callq 0x1b4d0
movq 0x28(%rbx), %rdi
leaq 0x38(%rbx), %rax
cmpq %rax, %rdi
je 0x2b721
callq 0x1b4d0
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0x2b733
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 0x2b757
callq 0x1b4d0
jmp 0x2b757
movq %rax, %rbx
movq %rbx, %rdi
callq 0x3e96e
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7df81(%rip), %rbx     # 0xa9f98
leaq 0x4f52a(%rip), %rsi     # 0x7b548
movl $0x8, %edx
movq %rbx, %rdi
callq 0x1b5e0
callq 0x2c1b5
leaq 0x7ed81(%rip), %rsi     # 0xaadb8
movq %rbx, %rdi
callq 0x2c0cb
leaq 0x57b0c(%rip), %rsi     # 0x83b52
movl $0x1, %edx
movq %rbx, %rdi
callq 0x1b5e0
addq $0x8, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x475fc
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 0x4f4be(%rip), %rsi     # 0x7b551
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_O3/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 0x2c1a5
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 0x2c16b
movq %r12, %rdi
callq 0x1b220
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x1b5e0
jmp 0x2c185
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_O3/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 0x7dd59(%rip), %rbx     # 0xa9f98
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 0x4f316(%rip), %rsi     # 0x7b586
movl $0xd, %edx
movq %rbx, %rdi
callq 0x1b5e0
leaq 0x4f310(%rip), %rsi     # 0x7b594
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 0x4f2f8(%rip), %rsi     # 0x7b5ae
movl $0xa, %edx
movq %rbx, %rdi
callq 0x1b5e0
leaq 0x4f2ef(%rip), %rsi     # 0x7b5b9
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 0x4f2cc(%rip), %rsi     # 0x7b5c8
movl $0xb, %edx
movq %rbx, %rdi
callq 0x1b5e0
leaq 0x4f2c4(%rip), %rsi     # 0x7b5d4
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 0x4f29e(%rip), %rsi     # 0x7b5e0
movl $0x9, %edx
movq %rbx, %rdi
callq 0x1b5e0
callq 0x2c1b5
leaq 0x7ea5d(%rip), %rsi     # 0xaadb8
movq %rbx, %rdi
callq 0x2c0cb
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_O3/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 0x2c79c
movq 0x7d83c(%rip), %rbx     # 0xa9f98
leaq 0x4eeb3(%rip), %rsi     # 0x7b616
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 0x2c80c
movl %eax, %ebx
testb $0x2, 0xc0(%r14)
je 0x2c804
movq 0x7d7e1(%rip), %r14     # 0xa9f98
leaq 0x4ee85(%rip), %rsi     # 0x7b643
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