LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::Matchers::Floating::WithinUlpsMatcher::match(double const&) const
bool WithinUlpsMatcher::match(double const& matchee) const {
        switch (m_type) {
        case FloatingPointKind::Float:
            return almostEqualUlps<float>(static_cast<float>(matchee), static_cast<float>(m_target), m_ulps);
        case FloatingPointKind::Double:
            return almostEqualUlps<double>(matchee, m_target, m_ulps);
        default:
            CATCH_INTERNAL_ERROR( "Unknown FloatingPointKind value" );
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movb 0x40(%rax), %al
movb %al, -0x6d(%rbp)
testb %al, %al
je 0x5f760
jmp 0x5f757
movb -0x6d(%rbp), %al
subb $0x1, %al
je 0x5f78c
jmp 0x5f7b0
movq -0x78(%rbp), %rax
movq -0x18(%rbp), %rcx
movsd (%rcx), %xmm0
cvtsd2ss %xmm0, %xmm0
movsd 0x30(%rax), %xmm1
cvtsd2ss %xmm1, %xmm1
movq 0x38(%rax), %rdi
callq 0x5f890
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x5f875
movq -0x78(%rbp), %rax
movq -0x18(%rbp), %rcx
movsd (%rcx), %xmm0
movsd 0x30(%rax), %xmm1
movq 0x38(%rax), %rdi
callq 0x5f980
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x5f875
leaq -0x50(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x67d90
leaq 0xdf80a(%rip), %rsi     # 0x13efd1
leaq -0x60(%rbp), %rdi
movq %rdi, -0x88(%rbp)
movl $0x2d54, %edx           # imm = 0x2D54
callq 0x8e600
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
callq 0x8e5d0
movq %rax, -0x80(%rbp)
jmp 0x5f7f5
movq -0x80(%rbp), %rdi
leaq 0xdfaa6(%rip), %rsi     # 0x13f2a6
callq 0x8ace0
movq %rax, -0x98(%rbp)
jmp 0x5f80e
movq -0x98(%rbp), %rdi
leaq 0xdfaa4(%rip), %rsi     # 0x13f2c0
callq 0x8e440
movq %rax, -0xa0(%rbp)
jmp 0x5f82a
movq -0xa0(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x53b70
jmp 0x5f83c
leaq -0x38(%rbp), %rdi
callq 0x5b700
jmp 0x5f847
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x5f86a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x52e58
leaq -0x50(%rbp), %rdi
callq 0x67e50
jmp 0x5f883
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xa0, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x52c90
nopl (%rax)
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: bool Catch::(anonymous namespace)::almostEqualUlps<float>(float, float, unsigned long)
bool almostEqualUlps(FP lhs, FP rhs, uint64_t maxUlpDiff) {
        // Comparison with NaN should always be false.
        // This way we can rule it out before getting into the ugly details
        if (Catch::isnan(lhs) || Catch::isnan(rhs)) {
            return false;
        }

        auto lc = convert(lhs);
        auto rc = convert(rhs);

        if ((lc < 0) != (rc < 0)) {
            // Potentially we can have +0 and -0
            return lhs == rhs;
        }

        // static cast as a workaround for IBM XLC
        auto ulpDiff = std::abs(static_cast<FP>(lc - rc));
        return static_cast<uint64_t>(ulpDiff) <= maxUlpDiff;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movss %xmm0, -0x8(%rbp)
movss %xmm1, -0xc(%rbp)
movq %rdi, -0x18(%rbp)
movss -0x8(%rbp), %xmm0
callq 0x62310
testb $0x1, %al
jne 0x5f8c4
movss -0xc(%rbp), %xmm0
callq 0x62310
testb $0x1, %al
jne 0x5f8c4
jmp 0x5f8cd
movb $0x0, -0x1(%rbp)
jmp 0x5f969
movss -0x8(%rbp), %xmm0
callq 0x882d0
movl %eax, -0x1c(%rbp)
movss -0xc(%rbp), %xmm0
callq 0x882d0
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x1c(%rbp)
setl %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, -0x20(%rbp)
setl %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
je 0x5f91c
movss -0x8(%rbp), %xmm0
ucomiss -0xc(%rbp), %xmm0
sete %al
setnp %cl
andb %cl, %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x5f969
movl -0x1c(%rbp), %eax
movl -0x20(%rbp), %ecx
subl %ecx, %eax
cvtsi2ss %eax, %xmm0
callq 0xc2aa0
movss %xmm0, -0x24(%rbp)
movss -0x24(%rbp), %xmm0
movss 0xdd6cd(%rip), %xmm2    # 0x13d00c
movaps %xmm0, %xmm1
subss %xmm2, %xmm1
cvttss2si %xmm1, %rcx
cvttss2si %xmm0, %rax
movq %rax, %rdx
sarq $0x3f, %rdx
andq %rdx, %rcx
orq %rcx, %rax
cmpq -0x18(%rbp), %rax
setbe %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: double Catch::(anonymous namespace)::step<double>(double, double, unsigned long)
FP step(FP start, FP direction, uint64_t steps) {
    for (uint64_t i = 0; i < steps; ++i) {
#if defined(CATCH_CONFIG_GLOBAL_NEXTAFTER)
        start = Catch::nextafter(start, direction);
#else
        start = std::nextafter(start, direction);
#endif
    }
    return start;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x5fe8a
movsd -0x8(%rbp), %xmm0
movsd -0x10(%rbp), %xmm1
callq 0x88310
movsd %xmm0, -0x8(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x5fe5e
movsd -0x8(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::Matchers::Generic::Detail::finalizeDescription(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string Catch::Matchers::Generic::Detail::finalizeDescription(const std::string& desc) {
    if (desc.empty()) {
        return "matches undescribed predicate";
    } else {
        return "matches predicate: \"" + desc + '"';
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x52bb0
testb $0x1, %al
jne 0x6052a
jmp 0x6056f
leaq -0x11(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x52ca0
movq -0x58(%rbp), %rdi
movq -0x60(%rbp), %rdx
leaq 0xdee46(%rip), %rsi     # 0x13f38c
callq 0x529e0
jmp 0x6054d
leaq -0x11(%rbp), %rdi
callq 0x527d0
jmp 0x605bd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x11(%rbp), %rdi
callq 0x527d0
jmp 0x605c7
movq -0x10(%rbp), %rdx
leaq 0xdee30(%rip), %rsi     # 0x13f3aa
leaq -0x48(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x8e240
movq -0x58(%rbp), %rdi
movq -0x68(%rbp), %rsi
movl $0x22, %edx
callq 0x8e740
jmp 0x6059b
leaq -0x48(%rbp), %rdi
callq 0x52e58
jmp 0x605bd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x52e58
jmp 0x605c7
movq -0x50(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x52c90
// File: 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
subq $0xa0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x52a00
movq -0x88(%rbp), %rdi
addq $0x58, %rdi
callq 0x52500
movq -0x88(%rbp), %rdi
movq %rax, -0x78(%rbp)
movq %rdi, %rax
addq $0x30, %rax
movq %rax, -0x80(%rbp)
addq $0x38, %rdi
callq 0x52500
movq -0x80(%rbp), %rsi
movq %rax, %rcx
movq -0x78(%rbp), %rax
leaq 0x5(%rax,%rcx), %rax
movq %rax, -0x70(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x60660
jmp 0x60826
leaq -0x38(%rbp), %rdi
callq 0x52500
movq -0x70(%rbp), %rsi
movq -0x98(%rbp), %rdi
addq %rax, %rsi
callq 0x52ae0
jmp 0x60844
leaq -0x38(%rbp), %rdi
callq 0x52e58
movq -0x88(%rbp), %rsi
movq -0x98(%rbp), %rdi
addq $0x58, %rsi
callq 0x52910
jmp 0x60866
movq -0x98(%rbp), %rdi
leaq 0xdeb47(%rip), %rsi     # 0x13f3bb
callq 0x526e0
jmp 0x6087b
movq -0x98(%rbp), %rdi
movq -0x88(%rbp), %rsi
addq $0x38, %rsi
callq 0x52910
jmp 0x60894
movq -0x98(%rbp), %rdi
leaq 0xdf014(%rip), %rsi     # 0x13f8b6
callq 0x526e0
jmp 0x608a9
movq -0x88(%rbp), %rsi
addq $0x30, %rsi
leaq -0x68(%rbp), %rdi
callq 0x60660
jmp 0x608bf
movq -0x98(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x52910
jmp 0x608d1
leaq -0x68(%rbp), %rdi
callq 0x52e58
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x6092e
jmp 0x60922
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x6093e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x52e58
jmp 0x6093e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x52e58
jmp 0x6093e
movq -0x98(%rbp), %rdi
callq 0x52e58
movq -0x90(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x98(%rbp), %rdi
callq 0x52e58
movq -0x40(%rbp), %rdi
callq 0x52c90
nopw %cs:(%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movl $0x10, -0x14(%rbp)
cmpl $0x1, 0x50(%rax)
jne 0x61093
leaq -0x14(%rbp), %rdi
movl $0x1, %esi
callq 0x8e8d0
movq -0x50(%rbp), %rsi
addq $0x30, %rsi
movl -0x14(%rbp), %edx
leaq -0x38(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x8e900
movq -0x60(%rbp), %rsi
movq -0x10(%rbp), %rdi
xorl %edx, %edx
callq 0x8e9b0
movb %al, -0x51(%rbp)
jmp 0x610bf
leaq -0x38(%rbp), %rdi
callq 0x8ea00
movb -0x51(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x8ea00
movq -0x40(%rbp), %rdi
callq 0x52c90
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x616a0
movb %al, -0x11(%rbp)
jmp 0x61dfe
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x61e98
jmp 0x61e0b
movq -0x20(%rbp), %rdi
movq 0x20(%rdi), %rax
movq %rax, -0x28(%rbp)
callq 0x8ed40
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jne 0x61e2a
jmp 0x61e49
leaq 0xdd695(%rip), %rdi     # 0x13f4c6
leaq 0xdd199(%rip), %rsi     # 0x13efd1
movl $0x2e95, %edx           # imm = 0x2E95
leaq 0xdd6a2(%rip), %rcx     # 0x13f4e6
callq 0x524b0
movq $0x0, -0x10(%rbp)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
cmpq 0x20(%rcx), %rax
jae 0x61e96
movq -0x20(%rbp), %rdi
movq 0x18(%rdi), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rsi
callq 0x8ed70
movq -0x30(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
movq 0x38(%rax), %rax
callq *%rax
jmp 0x61e86
jmp 0x61e88
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x61e51
jmp 0x61e98
movq -0x20(%rbp), %rdi
callq 0x8cf60
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x8c060
nop
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0x8ed40
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jae 0x61ee7
jmp 0x61f06
leaq 0xdd615(%rip), %rdi     # 0x13f503
leaq 0xdd0dc(%rip), %rsi     # 0x13efd1
movl $0x2e9c, %edx           # imm = 0x2E9C
leaq 0xdd61c(%rip), %rcx     # 0x13f51d
callq 0x524b0
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rsi
callq 0x8ed70
movq -0x38(%rbp), %rsi
movq %rax, %rdi
addq $0x10, %rdi
callq 0x52910
movq -0x28(%rbp), %rdi
movq 0x18(%rdi), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rsi
callq 0x8ed70
movq -0x30(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x30(%rax)
movq -0x28(%rbp), %rax
movq 0x20(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq $0x0, (%rdi)
callq 0x623c0
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
addq (%rdi), %rax
movq %rax, (%rdi)
callq 0x623c0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::SimplePcg32::operator()()
SimplePcg32::result_type SimplePcg32::operator()() {
        // prepare the output value
        const uint32_t xorshifted = static_cast<uint32_t>(((m_state >> 18u) ^ m_state) >> 27u);
        const auto output = rotate_right(xorshifted, m_state >> 59u);

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

        return output;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq (%rax), %rcx
shrq $0x12, %rcx
xorq (%rax), %rcx
shrq $0x1b, %rcx
movl %ecx, -0xc(%rbp)
movl -0xc(%rbp), %edi
movq (%rax), %rax
shrq $0x3b, %rax
movl %eax, %esi
callq 0x62480
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, -0x10(%rbp)
movabsq $0x5851f42d4c957f2d, %rcx # imm = 0x5851F42D4C957F2D
imulq (%rax), %rcx
movabsq $0x27da198a7f2728ed, %rdx # imm = 0x27DA198A7F2728ED
addq %rdx, %rcx
movq %rcx, (%rax)
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x62471
movq -0x20(%rbp), %rdi
callq 0x623c0
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x62450
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x40, %rsp
callq 0x67990
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x90960
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x90990
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x909c0
testb $0x1, %al
jne 0x62599
jmp 0x625ce
leaq -0x18(%rbp), %rdi
callq 0x90a00
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x625c1
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x625c3
leaq -0x18(%rbp), %rdi
callq 0x90a20
jmp 0x62586
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x625f1
movq -0x38(%rbp), %rdi
callq 0x90a40
movq -0x38(%rbp), %rdi
callq 0x526b0
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x80, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x60(%rbp)
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
callq 0x8eee0
movq -0x60(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x8, %rdi
callq 0x8dce0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x8ef10
testb $0x1, %al
jne 0x626f3
jmp 0x62702
movq -0x70(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x8ef40
jmp 0x62765
leaq -0x28(%rbp), %rdi
callq 0x8ef80
movq %rax, %rdi
addq $0x20, %rdi
callq 0x8dfe0
movq %rax, -0x80(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x48(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x5ca20
movq -0x70(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rdx
movq (%rsi), %rax
movq 0x10(%rax), %rax
callq *%rax
jmp 0x62743
leaq -0x48(%rbp), %rdi
callq 0x8efa0
jmp 0x62765
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x8efa0
jmp 0x62772
movq -0x68(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x52c90
nopl (%rax,%rax)
// File: 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
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0x69(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x52ca0
movq -0xa0(%rbp), %rdx
leaq 0xdc2fd(%rip), %rsi     # 0x13f905
leaq -0x68(%rbp), %rdi
callq 0x529e0
jmp 0x63613
leaq 0xdb9b7(%rip), %rsi     # 0x13efd1
leaq -0x90(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
movl $0x3824, %edx           # imm = 0x3824
callq 0x8e600
movq -0xb0(%rbp), %rdx
leaq -0x48(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x6a6d0
jmp 0x63648
movq -0xa8(%rbp), %rdx
movq $0x0, -0x98(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x48(%rbp), %rsi
leaq -0x98(%rbp), %rcx
callq 0x921b0
jmp 0x63670
movq -0xa8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x92230
leaq -0x18(%rbp), %rdi
callq 0x92260
leaq -0x48(%rbp), %rdi
callq 0x8f400
leaq -0x68(%rbp), %rdi
callq 0x52e58
leaq -0x69(%rbp), %rdi
callq 0x527d0
movq -0xa8(%rbp), %rdi
movq $0x0, 0x10(%rdi)
movl $0x1, 0x18(%rdi)
callq 0x92280
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x63702
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x636f9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x8f400
leaq -0x68(%rbp), %rdi
callq 0x52e58
leaq -0x69(%rbp), %rdi
callq 0x527d0
movq -0x78(%rbp), %rdi
callq 0x52c90
nopw %cs:(%rax,%rax)
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::TestCaseTracking::SectionTracker::addInitialFilters(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
void SectionTracker::addInitialFilters( std::vector<std::string> const& filters ) {
        if( !filters.empty() ) {
            m_filters.reserve( m_filters.size() + filters.size() + 2 );
            m_filters.emplace_back(""); // Root - should never be consulted
            m_filters.emplace_back(""); // Test Case - not a section filter
            m_filters.insert( m_filters.end(), filters.begin(), filters.end() );
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8bdd0
testb $0x1, %al
jne 0x63806
movq -0x40(%rbp), %rdi
movq %rdi, %rax
addq $0x68, %rax
movq %rax, -0x50(%rbp)
addq $0x68, %rdi
callq 0x916d0
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0x916d0
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdi
addq %rax, %rsi
addq $0x2, %rsi
callq 0x92840
movq -0x40(%rbp), %rdi
addq $0x68, %rdi
leaq 0xdb7fe(%rip), %rsi     # 0x13ef8f
callq 0x92940
movq -0x40(%rbp), %rdi
addq $0x68, %rdi
leaq 0xdb7ea(%rip), %rsi     # 0x13ef8f
callq 0x92940
movq -0x40(%rbp), %rdi
movq %rdi, %rax
addq $0x68, %rax
movq %rax, -0x48(%rbp)
addq $0x68, %rdi
callq 0x8bd20
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x91380
movq -0x10(%rbp), %rdi
callq 0x8d7e0
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8d810
movq -0x48(%rbp), %rdi
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
callq 0x929b0
movq %rax, -0x38(%rbp)
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x110(%rbp)
movq -0x10(%rbp), %rdi
callq 0x549c0
cmpl $0x0, %eax
jne 0x6409e
movq -0x110(%rbp), %rax
movq 0xf8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0xf8(%rax)
movb $0x1, 0x1e9(%rax)
jmp 0x64116
movq -0x10(%rbp), %rdi
callq 0x54950
testb $0x1, %al
jne 0x64106
movq -0x110(%rbp), %rax
movb $0x0, 0x1e9(%rax)
movq 0x38(%rax), %rdi
callq 0x5ea60
movq %rax, %rdi
callq 0x64200
testb $0x1, %al
jne 0x640d0
jmp 0x640eb
movq -0x110(%rbp), %rax
movq 0x108(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x108(%rax)
jmp 0x64104
movq -0x110(%rbp), %rax
movq 0x100(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x100(%rax)
jmp 0x64114
movq -0x110(%rbp), %rax
movb $0x1, 0x1e9(%rax)
jmp 0x64116
movq -0x110(%rbp), %rdi
addq $0x128, %rdi            # imm = 0x128
callq 0x8f220
movq -0x110(%rbp), %rcx
movq %rax, -0x120(%rbp)
movq -0x10(%rbp), %rsi
movq %rcx, %rdx
addq $0x130, %rdx            # imm = 0x130
addq $0xf0, %rcx
leaq -0xf8(%rbp), %rdi
movq %rdi, -0x118(%rbp)
callq 0x5cb80
movq -0x120(%rbp), %rdi
movq -0x118(%rbp), %rsi
movq (%rdi), %rax
movq 0x50(%rax), %rax
callq *%rax
jmp 0x64178
leaq -0xf8(%rbp), %rdi
callq 0x5cdc0
movq -0x10(%rbp), %rdi
callq 0x549c0
cmpl $0x2, %eax
je 0x641c7
movq -0x110(%rbp), %rdi
addq $0x148, %rdi            # imm = 0x148
callq 0x8f450
jmp 0x641c7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x100(%rbp)
movl %eax, -0x104(%rbp)
leaq -0xf8(%rbp), %rdi
callq 0x5cdc0
jmp 0x641f0
movq -0x110(%rbp), %rdi
callq 0x64220
movq -0x110(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x48, %rdi
callq 0x8f470
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
movq -0x100(%rbp), %rdi
callq 0x52c90
nopl (%rax)
// File: 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
subq $0x90, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
addq $0x1c8, %rax            # imm = 0x1C8
movq %rax, -0x88(%rbp)
movq -0x18(%rbp), %rsi
movq %rsi, %rdx
addq $0x40, %rdx
leaq -0x58(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x6a6d0
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rsi
callq 0x63850
movq %rax, -0x78(%rbp)
jmp 0x6430d
leaq -0x58(%rbp), %rdi
callq 0x8f400
movq -0x78(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
testb $0x1, %al
jne 0x6434f
movb $0x0, -0x1(%rbp)
jmp 0x643d7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x8f400
jmp 0x643e5
movq -0x90(%rbp), %rdi
addq $0x1b0, %rdi            # imm = 0x1B0
movq -0x28(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x70(%rbp), %rsi
callq 0x8f4c0
movq -0x90(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x40(%rax), %rcx
movq %rcx, 0x170(%rdi)
movq 0x48(%rax), %rax
movq %rax, 0x178(%rdi)
addq $0x128, %rdi            # imm = 0x128
callq 0x8f220
movq %rax, %rdi
movq -0x18(%rbp), %rsi
movq (%rdi), %rax
callq *0x40(%rax)
movq -0x90(%rbp), %rcx
movq -0x20(%rbp), %rax
movq 0xf8(%rcx), %rdx
movq %rdx, (%rax)
movq 0x100(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x108(%rcx), %rcx
movq %rcx, 0x10(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x52c90
nop
// File: 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
subq $0xb0, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xa0(%rbp)
addq $0x1c8, %rax            # imm = 0x1C8
movq %rax, -0x98(%rbp)
leaq -0x78(%rbp), %rdi
movq %rdi, -0x90(%rbp)
leaq -0x10(%rbp), %rsi
callq 0x8af90
movq -0x90(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x58(%rbp), %rdi
callq 0x6a6d0
jmp 0x6444d
movq -0x98(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x8f4f0
movq %rax, -0xa8(%rbp)
jmp 0x64466
leaq -0x58(%rbp), %rdi
callq 0x8f400
leaq -0x78(%rbp), %rdi
callq 0x52e58
movq -0xa8(%rbp), %rcx
movq -0xa0(%rbp), %rax
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, 0x170(%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x178(%rax)
movq -0x28(%rbp), %rax
addq $0x68, %rax
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x644dd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x8f400
leaq -0x78(%rbp), %rdi
callq 0x52e58
movq -0x80(%rbp), %rdi
callq 0x52c90
nop
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::RunContext::testForMissingAssertions(Catch::Counts&)
bool RunContext::testForMissingAssertions(Counts& assertions) {
        if (assertions.total() != 0)
            return false;
        if (!m_config->warnAboutMissingAssertions())
            return false;
        if (m_trackerContext.currentTracker().hasChildren())
            return false;
        m_totals.assertions.failed++;
        assertions.failed++;
        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x645a0
cmpq $0x0, %rax
je 0x6451d
movb $0x0, -0x1(%rbp)
jmp 0x6458f
movq -0x20(%rbp), %rdi
addq $0xe0, %rdi
callq 0x8ae10
movq %rax, %rdi
movq (%rdi), %rax
callq *0x38(%rax)
testb $0x1, %al
jne 0x64540
movb $0x0, -0x1(%rbp)
jmp 0x6458f
movq -0x20(%rbp), %rdi
addq $0x1c8, %rdi            # imm = 0x1C8
callq 0x645c0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x28(%rax)
testb $0x1, %al
jne 0x6455f
jmp 0x64565
movb $0x0, -0x1(%rbp)
jmp 0x6458f
movq -0x20(%rbp), %rax
movq 0x100(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x100(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0xc8(%rbp)
addq $0xf0, %rsi
addq $0x8, %rsi
movq -0x10(%rbp), %rdx
addq $0x50, %rdx
leaq -0x28(%rbp), %rdi
callq 0x64740
movq -0xc8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x644f0
movq -0xc8(%rbp), %rdi
andb $0x1, %al
movb %al, -0x29(%rbp)
addq $0x1b0, %rdi            # imm = 0x1B0
callq 0x8f880
testb $0x1, %al
jne 0x64675
movq -0xc8(%rbp), %rdi
addq $0x1b0, %rdi            # imm = 0x1B0
callq 0x8f8c0
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
movq -0xc8(%rbp), %rdi
addq $0x1b0, %rdi            # imm = 0x1B0
callq 0x8f900
movq -0xc8(%rbp), %rdi
addq $0x128, %rdi            # imm = 0x128
callq 0x8f220
movq %rax, -0xd8(%rbp)
movq -0x10(%rbp), %rsi
movsd 0x68(%rsi), %xmm0
movzbl -0x29(%rbp), %ecx
andl $0x1, %ecx
leaq -0xb0(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
leaq -0x28(%rbp), %rdx
callq 0x5ce40
movq -0xd8(%rbp), %rdi
movq -0xd0(%rbp), %rsi
movq (%rdi), %rax
movq 0x58(%rax), %rax
callq *%rax
jmp 0x646cf
leaq -0xb0(%rbp), %rdi
callq 0x5cec0
movq -0xc8(%rbp), %rdi
addq $0x130, %rdi            # imm = 0x130
callq 0x8f930
movq -0xc8(%rbp), %rdi
addq $0x148, %rdi            # imm = 0x148
callq 0x8f450
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x5cec0
movq -0xb8(%rbp), %rdi
callq 0x52c90
nopw %cs:(%rax,%rax)
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::RunContext::sectionEndedEarly(Catch::SectionEndInfo const&)
void RunContext::sectionEndedEarly(SectionEndInfo const & endInfo) {
        if (m_unfinishedSections.empty())
            m_activeSections.back()->fail();
        else
            m_activeSections.back()->close();
        m_activeSections.pop_back();

        m_unfinishedSections.push_back(endInfo);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x198, %rdi            # imm = 0x198
callq 0x8f950
testb $0x1, %al
jne 0x647da
jmp 0x647f5
movq -0x18(%rbp), %rdi
addq $0x1b0, %rdi            # imm = 0x1B0
callq 0x8f8c0
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x48(%rax)
jmp 0x6480e
movq -0x18(%rbp), %rdi
addq $0x1b0, %rdi            # imm = 0x1B0
callq 0x8f8c0
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
movq -0x18(%rbp), %rdi
addq $0x1b0, %rdi            # imm = 0x1B0
callq 0x8f900
movq -0x18(%rbp), %rdi
addq $0x198, %rdi            # imm = 0x198
movq -0x10(%rbp), %rsi
callq 0x8f990
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x20(%rbp)
addq $0x198, %rsi            # imm = 0x198
leaq -0x10(%rbp), %rdi
callq 0x8fd20
movq -0x20(%rbp), %rsi
addq $0x198, %rsi            # imm = 0x198
leaq -0x18(%rbp), %rdi
callq 0x8fd70
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x8fdc0
testb $0x1, %al
jne 0x64f1b
jmp 0x64f3c
leaq -0x10(%rbp), %rdi
callq 0x8fdf0
movq -0x20(%rbp), %rdi
movq %rax, %rsi
movq (%rdi), %rax
callq *0x18(%rax)
leaq -0x10(%rbp), %rdi
callq 0x8fe20
jmp 0x64f08
movq -0x20(%rbp), %rdi
addq $0x198, %rdi            # imm = 0x198
callq 0x8fe50
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movb $0x1, 0x1e9(%rdi)
movq 0xf8(%rdi), %rax
addq $0x1, %rax
movq %rax, 0xf8(%rdi)
callq 0x64220
movq -0x10(%rbp), %rdi
addq $0x148, %rdi            # imm = 0x148
callq 0x8f450
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x128, %rdi            # imm = 0x128
callq 0x8f220
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x48(%rax)
movq -0x10(%rbp), %rax
movl 0x30(%rax), %edi
callq 0x8af70
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x18(%rbp), %rdi
callq 0x8fe70
andb $0x1, %al
movzbl %al, %eax
movb -0x21(%rbp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
setne %al
andb $0x1, %al
movb %al, -0x22(%rbp)
testb $0x1, -0x22(%rbp)
je 0x6520b
movq -0x30(%rbp), %rax
testb $0x1, 0x1eb(%rax)
jne 0x651ed
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
callq *0x88(%rax)
jmp 0x65209
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rcx
movb -0x21(%rbp), %al
xorl %edx, %edx
andb $0x1, %al
movzbl %al, %r8d
callq 0x65240
jmp 0x65237
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rcx
movb -0x21(%rbp), %al
movl $0x11, %edx
andb $0x1, %al
movzbl %al, %r8d
callq 0x65240
movq -0x30(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x65380
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x150, %rsp            # imm = 0x150
movb %r8b, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x150(%rbp)
movq -0x10(%rbp), %rcx
movl 0x30(%rcx), %edx
movl %edx, 0x190(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups 0x20(%rcx), %xmm2
movups %xmm2, 0x180(%rax)
movups %xmm1, 0x170(%rax)
movups %xmm0, 0x160(%rax)
movl -0x14(%rbp), %eax
movl %eax, -0x144(%rbp)
movzbl -0x21(%rbp), %esi
andl $0x1, %esi
leaq -0x90(%rbp), %rdi
movq %rdi, -0x140(%rbp)
callq 0x53fc0
movl -0x144(%rbp), %esi
movq -0x140(%rbp), %rdx
leaq -0x80(%rbp), %rdi
movq %rdi, -0x138(%rbp)
callq 0x54740
movq -0x138(%rbp), %rdx
movq -0x10(%rbp), %rsi
leaq -0x120(%rbp), %rdi
callq 0x548b0
jmp 0x652f3
movq -0x150(%rbp), %rdi
movq -0x20(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0x120(%rbp), %rsi
callq 0x64050
jmp 0x65313
leaq -0x120(%rbp), %rdi
callq 0x8cfc0
leaq -0x80(%rbp), %rdi
callq 0x8fc40
addq $0x150, %rsp            # imm = 0x150
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x128(%rbp)
movl %eax, -0x12c(%rbp)
jmp 0x65363
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x128(%rbp)
movl %eax, -0x12c(%rbp)
leaq -0x120(%rbp), %rdi
callq 0x8cfc0
leaq -0x80(%rbp), %rdi
callq 0x8fc40
movq -0x128(%rbp), %rdi
callq 0x52c90
nopl (%rax,%rax)
// File: 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
subq $0x180, %rsp            # imm = 0x180
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x168(%rbp)
addq $0x128, %rdi            # imm = 0x128
callq 0x8f220
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
movq 0x48(%rax), %rax
callq *%rax
movq -0x168(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x30(%rcx), %edx
movl %edx, 0x190(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups 0x20(%rcx), %xmm2
movups %xmm2, 0x180(%rax)
movups %xmm1, 0x170(%rax)
movups %xmm0, 0x160(%rax)
movl -0x14(%rbp), %eax
movl %eax, -0x15c(%rbp)
leaq -0x90(%rbp), %rdi
movq %rdi, -0x158(%rbp)
xorl %esi, %esi
callq 0x53fc0
movl -0x15c(%rbp), %esi
movq -0x158(%rbp), %rdx
leaq -0x80(%rbp), %rdi
callq 0x54740
movq -0x20(%rbp), %rsi
leaq -0xb0(%rbp), %rdi
callq 0x8af90
jmp 0x654bf
leaq -0x80(%rbp), %rdi
movq %rdi, -0x170(%rbp)
leaq -0xb0(%rbp), %rsi
movq %rsi, -0x178(%rbp)
callq 0x528a0
movq -0x178(%rbp), %rdi
callq 0x52e58
movq -0x168(%rbp), %rsi
movq -0x170(%rbp), %rdx
addq $0x160, %rsi            # imm = 0x160
leaq -0x150(%rbp), %rdi
callq 0x548b0
jmp 0x6550c
movq -0x168(%rbp), %rdi
leaq -0x150(%rbp), %rsi
callq 0x64050
jmp 0x65521
leaq -0x150(%rbp), %rdi
callq 0x54950
movb %al, -0x179(%rbp)
jmp 0x65535
movb -0x179(%rbp), %al
testb $0x1, %al
jne 0x65589
jmp 0x65541
movq -0x168(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x65380
jmp 0x65553
jmp 0x65589
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x655a7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0x150(%rbp), %rdi
callq 0x8cfc0
jmp 0x655a7
leaq -0x150(%rbp), %rdi
callq 0x8cfc0
leaq -0x80(%rbp), %rdi
callq 0x8fc40
addq $0x180, %rsp            # imm = 0x180
popq %rbp
retq
leaq -0x80(%rbp), %rdi
callq 0x8fc40
movq -0xb8(%rbp), %rdi
callq 0x52c90
nopl (%rax)
// File: 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
subq $0x140, %rsp            # imm = 0x140
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x140(%rbp)
movq -0x10(%rbp), %rcx
movl 0x30(%rcx), %edx
movl %edx, 0x190(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups 0x20(%rcx), %xmm2
movups %xmm2, 0x180(%rax)
movups %xmm1, 0x170(%rax)
movups %xmm0, 0x160(%rax)
leaq -0x88(%rbp), %rdi
movq %rdi, -0x138(%rbp)
xorl %esi, %esi
callq 0x53fc0
movq -0x138(%rbp), %rdx
leaq -0x78(%rbp), %rdi
movq %rdi, -0x130(%rbp)
movl $0x111, %esi            # imm = 0x111
callq 0x54740
movq -0x130(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x52070
jmp 0x65696
movq -0x10(%rbp), %rsi
leaq -0x128(%rbp), %rdi
leaq -0x78(%rbp), %rdx
callq 0x548b0
jmp 0x656ac
movq -0x140(%rbp), %rdi
leaq -0x128(%rbp), %rsi
callq 0x64050
jmp 0x656c1
movq -0x140(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x65380
jmp 0x656d3
leaq -0x128(%rbp), %rdi
callq 0x8cfc0
leaq -0x78(%rbp), %rdi
callq 0x8fc40
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x65723
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x128(%rbp), %rdi
callq 0x8cfc0
leaq -0x78(%rbp), %rdi
callq 0x8fc40
movq -0x90(%rbp), %rdi
callq 0x52c90
nopl (%rax,%rax)
// File: 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
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x130(%rbp)
movq -0x10(%rbp), %rcx
movl 0x30(%rcx), %edx
movl %edx, 0x190(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups 0x20(%rcx), %xmm2
movups %xmm2, 0x180(%rax)
movups %xmm1, 0x170(%rax)
movups %xmm0, 0x160(%rax)
leaq -0x78(%rbp), %rdi
movq %rdi, -0x128(%rbp)
xorl %esi, %esi
callq 0x53fc0
movq -0x128(%rbp), %rdx
leaq -0x68(%rbp), %rdi
movq %rdi, -0x120(%rbp)
movl $0x111, %esi            # imm = 0x111
callq 0x54740
movq -0x120(%rbp), %rdi
leaq 0xd9e20(%rip), %rsi     # 0x13f5e7
callq 0x529d0
jmp 0x657ce
movq -0x10(%rbp), %rsi
leaq -0x118(%rbp), %rdi
leaq -0x68(%rbp), %rdx
callq 0x548b0
jmp 0x657e4
movq -0x130(%rbp), %rdi
leaq -0x118(%rbp), %rsi
callq 0x64050
jmp 0x657f9
leaq -0x118(%rbp), %rdi
callq 0x8cfc0
leaq -0x68(%rbp), %rdi
callq 0x8fc40
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
jmp 0x65843
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x118(%rbp), %rdi
callq 0x8cfc0
leaq -0x68(%rbp), %rdi
callq 0x8fc40
movq -0x80(%rbp), %rdi
callq 0x52c90
nopw %cs:(%rax,%rax)