LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::ConsoleReporter::assertionEnded(Catch::AssertionStats const&)
bool ConsoleReporter::assertionEnded(AssertionStats const& _assertionStats) {
    AssertionResult const& result = _assertionStats.assertionResult;

    bool includeResults = m_config->includeSuccessfulResults() || !result.isOk();

    // Drop out if result was successful but we're not printing them.
    if (!includeResults && result.getResultType() != ResultWas::Warning)
        return false;

    lazyPrint();

    ConsoleAssertionPrinter printer(stream, _assertionStats, includeResults);
    printer.print();
    stream << std::endl;
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x20(%rbp)
addq $0x8, %rdi
callq 0x8ae10
movq %rax, %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0xd5(%rbp)
jne 0x71d7c
movq -0x20(%rbp), %rdi
callq 0x54950
xorb $-0x1, %al
movb %al, -0xd5(%rbp)
movb -0xd5(%rbp), %al
andb $0x1, %al
movb %al, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x71da4
movq -0x20(%rbp), %rdi
callq 0x549c0
cmpl $0x2, %eax
je 0x71da4
movb $0x0, -0x1(%rbp)
jmp 0x71e32
movq -0xe0(%rbp), %rdi
callq 0x71e50
movq -0xe0(%rbp), %rax
movq 0x18(%rax), %rsi
movq -0x18(%rbp), %rdx
movzbl -0x21(%rbp), %ecx
andl $0x1, %ecx
leaq -0xc8(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x71e90
movq -0xe8(%rbp), %rdi
callq 0x72370
jmp 0x71de7
movq -0xe0(%rbp), %rax
movq 0x18(%rax), %rdi
movq 0x14f13f(%rip), %rsi    # 0x1c0f38
callq 0x527a0
jmp 0x71e00
movb $0x1, -0x1(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0x723f0
jmp 0x71e32
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd0(%rbp)
movl %eax, -0xd4(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0x723f0
jmp 0x71e40
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xf0, %rsp
popq %rbp
retq
movq -0xd0(%rbp), %rdi
callq 0x52c90
nopl (%rax)
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::(anonymous namespace)::ConsoleAssertionPrinter::print() const
void print() const {
        printSourceInfo();
        if (stats.totals.assertions.total() > 0) {
            printResultType();
            printOriginalExpression();
            printReconstructedExpression();
        } else {
            stream << '\n';
        }
        printMessage();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x7d8c0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
addq $0xb0, %rdi
addq $0x8, %rdi
callq 0x645a0
cmpq $0x0, %rax
jbe 0x723c4
movq -0x10(%rbp), %rdi
callq 0x7d950
movq -0x10(%rbp), %rdi
callq 0x7d9e0
movq -0x10(%rbp), %rdi
callq 0x7dac0
jmp 0x723d5
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl $0xa, %esi
callq 0x52870
movq -0x10(%rbp), %rdi
callq 0x7dbe0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::ConsoleReporter::testGroupEnded(Catch::TestGroupStats const&)
void ConsoleReporter::testGroupEnded(TestGroupStats const& _testGroupStats) {
    if (currentGroupInfo.used) {
        printSummaryDivider();
        stream << "Summary for group '" << _testGroupStats.groupInfo.name << "':\n";
        printTotals(_testGroupStats.totals);
        stream << '\n' << std::endl;
    }
    StreamingReporterBase::testGroupEnded(_testGroupStats);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, 0x88(%rax)
je 0x7279f
movq -0x18(%rbp), %rdi
callq 0x727c0
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
leaq 0xcd4ab(%rip), %rsi     # 0x13fbf4
callq 0x52710
movq %rax, %rdi
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
callq 0x52670
movq %rax, %rdi
leaq 0xcd4a0(%rip), %rsi     # 0x13fc08
callq 0x52710
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x38, %rsi
callq 0x72800
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movl $0xa, %esi
callq 0x52870
movq %rax, %rdi
movq 0x14e79e(%rip), %rsi    # 0x1c0f38
callq 0x527a0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x94760
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::ConsoleReporter::testRunEnded(Catch::TestRunStats const&)
void ConsoleReporter::testRunEnded(TestRunStats const& _testRunStats) {
    printTotalsDivider(_testRunStats.totals);
    printTotals(_testRunStats.totals);
    stream << std::endl;
    StreamingReporterBase::testRunEnded(_testRunStats);
}

// 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)
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
callq 0x732a0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x28, %rsi
callq 0x72800
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movq 0x14dcb3(%rip), %rsi    # 0x1c0f38
callq 0x527a0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x94790
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::ConsoleReporter::lazyPrintWithoutClosingBenchmarkTable()
void ConsoleReporter::lazyPrintWithoutClosingBenchmarkTable() {

    if (!currentTestRunInfo.used)
        lazyPrintRunInfo();
    if (!currentGroupInfo.used)
        lazyPrintGroupInfo();

    if (!m_headerPrinted) {
        printTestCaseAndSectionHeader();
        m_headerPrinted = true;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
testb $0x1, 0x48(%rax)
jne 0x73a43
movq -0x10(%rbp), %rdi
callq 0x73a80
movq -0x10(%rbp), %rax
testb $0x1, 0x88(%rax)
jne 0x73a59
movq -0x10(%rbp), %rdi
callq 0x73c40
movq -0x10(%rbp), %rax
testb $0x1, 0x170(%rax)
jne 0x73a7a
movq -0x10(%rbp), %rdi
callq 0x73cf0
movq -0x10(%rbp), %rax
movb $0x1, 0x170(%rax)
addq $0x10, %rsp
popq %rbp
retq
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::ConsoleReporter::lazyPrintRunInfo()
void ConsoleReporter::lazyPrintRunInfo() {
    stream << '\n' << getLineOfChars<'~'>() << '\n';
    Colour colour(Colour::SecondaryText);
    stream << currentTestRunInfo->name
        << " is a Catch v" << libraryVersion() << " host application.\n"
        << "Run with -? for options\n\n";

    if (m_config->rngSeed() != 0)
        stream << "Randomness seeded to: " << m_config->rngSeed() << "\n\n";

    currentTestRunInfo.used = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq 0x18(%rax), %rdi
movl $0xa, %esi
movl %esi, -0x3c(%rbp)
callq 0x52870
movq %rax, -0x48(%rbp)
callq 0x94810
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x52710
movl -0x3c(%rbp), %esi
movq %rax, %rdi
callq 0x52870
leaq -0x9(%rbp), %rdi
movl $0x17, %esi
callq 0x5aea0
movq -0x38(%rbp), %rdi
movq 0x18(%rdi), %rax
movq %rax, -0x30(%rbp)
addq $0x20, %rdi
callq 0x94850
movq %rax, -0x28(%rbp)
jmp 0x73af1
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdi
callq 0x52670
movq %rax, -0x50(%rbp)
jmp 0x73b04
movq -0x50(%rbp), %rdi
leaq 0xcc0fd(%rip), %rsi     # 0x13fc0c
callq 0x52710
movq %rax, -0x58(%rbp)
jmp 0x73b1a
callq 0x66510
movq %rax, -0x60(%rbp)
jmp 0x73b25
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdi
callq 0x66460
movq %rax, -0x68(%rbp)
jmp 0x73b38
movq -0x68(%rbp), %rdi
leaq 0xcc0d7(%rip), %rsi     # 0x13fc1a
callq 0x52710
movq %rax, -0x70(%rbp)
jmp 0x73b4e
movq -0x70(%rbp), %rdi
leaq 0xcc0d5(%rip), %rsi     # 0x13fc2e
callq 0x52710
jmp 0x73b60
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
callq 0x8ae10
movq %rax, %rdi
movq (%rdi), %rax
movq 0x88(%rax), %rax
callq *%rax
movl %eax, -0x74(%rbp)
jmp 0x73b81
movl -0x74(%rbp), %eax
cmpl $0x0, %eax
je 0x73c11
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rdi
leaq 0xcc0ac(%rip), %rsi     # 0x13fc48
callq 0x52710
movq %rax, -0x80(%rbp)
jmp 0x73ba7
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
callq 0x8ae10
movq %rax, %rdi
movq (%rdi), %rax
movq 0x88(%rax), %rax
callq *%rax
movl %eax, -0x84(%rbp)
jmp 0x73bcb
movl -0x84(%rbp), %esi
movq -0x80(%rbp), %rdi
callq 0x529b0
movq %rax, -0x90(%rbp)
jmp 0x73be3
movq -0x90(%rbp), %rdi
leaq 0xd5bd3(%rip), %rsi     # 0x1497c4
callq 0x52710
jmp 0x73bf8
jmp 0x73c11
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x9(%rbp), %rdi
callq 0x5afc0
jmp 0x73c2b
movq -0x38(%rbp), %rax
movb $0x1, 0x48(%rax)
leaq -0x9(%rbp), %rdi
callq 0x5afc0
addq $0x90, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x52c90
nopw %cs:(%rax,%rax)
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::ConsoleReporter::printHeaderString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long)
void ConsoleReporter::printHeaderString(std::string const& _string, std::size_t indent) {
    std::size_t i = _string.find(": ");
    if (i != std::string::npos)
        i += 2;
    else
        i = 0;
    stream << Column(_string).indent(indent + i).initialIndent(indent) << '\n';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xcb78e(%rip), %rsi     # 0x13f7c8
xorl %eax, %eax
movl %eax, %edx
callq 0x52df0
movq %rax, -0x20(%rbp)
cmpq $-0x1, -0x20(%rbp)
je 0x7405c
movq -0x20(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x20(%rbp)
jmp 0x74064
movq $0x0, -0x20(%rbp)
movq -0x68(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x50(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x8d4c0
movq -0x78(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rax
addq %rax, %rsi
callq 0x8d550
movq %rax, -0x70(%rbp)
jmp 0x7409b
movq -0x70(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x8d530
movq %rax, -0x88(%rbp)
jmp 0x740b1
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdi
callq 0x8d3d0
movq %rax, -0x90(%rbp)
jmp 0x740ca
movq -0x90(%rbp), %rdi
movl $0xa, %esi
callq 0x52870
jmp 0x740dd
leaq -0x50(%rbp), %rdi
callq 0x8d570
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x8d570
movq -0x58(%rbp), %rdi
callq 0x52c90
nopl (%rax)
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::(anonymous namespace)::findMax(unsigned long&, unsigned long&, unsigned long&)
std::size_t& findMax(std::size_t& i, std::size_t& j, std::size_t& k) {
    if (i > j && i > k)
        return i;
    else if (j > k)
        return j;
    else
        return k;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
jbe 0x7452a
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
cmpq (%rcx), %rax
jbe 0x7452a
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x7454c
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq -0x20(%rbp), %rcx
cmpq (%rcx), %rax
jbe 0x74544
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x7454c
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::JunitReporter::testGroupStarting(Catch::GroupInfo const&)
void JunitReporter::testGroupStarting( GroupInfo const& groupInfo ) {
        suiteTimer.start();
        stdOutForSuite.clear();
        stdErrForSuite.clear();
        unexpectedExceptions = 0;
        CumulativeReporterBase::testGroupStarting( groupInfo );
    }

// 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 $0x120, %rdi            # imm = 0x120
callq 0x65050
movq -0x18(%rbp), %rdi
addq $0x128, %rdi            # imm = 0x128
callq 0x52960
movq -0x18(%rbp), %rdi
addq $0x148, %rdi            # imm = 0x148
callq 0x52960
movq -0x18(%rbp), %rdi
movl $0x0, 0x168(%rdi)
movq -0x10(%rbp), %rsi
callq 0x95340
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::(anonymous namespace)::getCurrentTimestamp[abi:cxx11]()
std::string getCurrentTimestamp() {
            // Beware, this is not reentrant because of backward compatibility issues
            // Also, UTC only, again because of backward compatibility (%z is C++11)
            time_t rawtime;
            std::time(&rawtime);
            auto const timeStampSize = sizeof("2017-01-16T17:06:45Z");

#ifdef _MSC_VER
            std::tm timeInfo = {};
            gmtime_s(&timeInfo, &rawtime);
#else
            std::tm* timeInfo;
            timeInfo = std::gmtime(&rawtime);
#endif

            char timeStamp[timeStampSize];
            const char * const fmt = "%Y-%m-%dT%H:%M:%SZ";

#ifdef _MSC_VER
            std::strftime(timeStamp, timeStampSize, fmt, &timeInfo);
#else
            std::strftime(timeStamp, timeStampSize, fmt, timeInfo);
#endif
            return std::string(timeStamp, timeStampSize-1);
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x10(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x52690
movq -0x80(%rbp), %rdi
movq $0x15, -0x18(%rbp)
callq 0x52650
movq %rax, -0x20(%rbp)
leaq 0xcb53b(%rip), %rdx     # 0x141151
movq %rdx, -0x48(%rbp)
movq -0x20(%rbp), %rcx
leaq -0x40(%rbp), %rdi
movq %rdi, -0x70(%rbp)
movl $0x15, %esi
callq 0x525c0
leaq -0x49(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x52ca0
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rcx
movl $0x14, %edx
callq 0x52820
jmp 0x75c55
leaq -0x49(%rbp), %rdi
callq 0x527d0
movq -0x88(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x49(%rbp), %rdi
callq 0x527d0
movq -0x58(%rbp), %rdi
callq 0x52c90
nopl (%rax)
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::(anonymous namespace)::fileNameTag(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&)
std::string fileNameTag(const std::vector<std::string> &tags) {
            auto it = std::find_if(begin(tags),
                                   end(tags),
                                   [] (std::string const& tag) {return tag.front() == '#'; });
            if (it != tags.end())
                return it->substr(1);
            return std::string();
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x92aa0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x92ad0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x7dd80
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8d810
movq %rax, -0x38(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x8d840
testb $0x1, %al
jne 0x75ff6
jmp 0x76019
leaq -0x18(%rbp), %rdi
callq 0x9d9c0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
movl $0x1, %edx
movq $-0x1, %rcx
callq 0x52780
jmp 0x76022
movq -0x48(%rbp), %rdi
callq 0x52a00
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::XmlReporter::sectionStarting(Catch::SectionInfo const&)
void XmlReporter::sectionStarting( SectionInfo const& sectionInfo ) {
        StreamingReporterBase::sectionStarting( sectionInfo );
        if( m_sectionDepth++ > 0 ) {
            m_xml.startElement( "Section" )
                .writeAttribute( "name", trim( sectionInfo.name ) );
            writeSourceInfo( sectionInfo.lineInfo );
            m_xml.ensureTagClosed();
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x98(%rbp)
movq -0x10(%rbp), %rsi
callq 0x96820
movq -0x98(%rbp), %rcx
movl 0x1b8(%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0x1b8(%rcx)
cmpl $0x0, %eax
jle 0x78eb2
movq -0x98(%rbp), %rax
addq $0x170, %rax            # imm = 0x170
movq %rax, -0xa8(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x52ca0
movq -0xa0(%rbp), %rdx
leaq 0xc911c(%rip), %rsi     # 0x141e76
leaq -0x30(%rbp), %rdi
callq 0x529e0
jmp 0x78d65
movl $0x2, %edi
movl $0x1, %esi
callq 0x6e390
movq -0xa8(%rbp), %rdi
movl %eax, %edx
leaq -0x30(%rbp), %rsi
callq 0x6efb0
movq %rax, -0xb0(%rbp)
jmp 0x78d8f
leaq -0x69(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x52ca0
movq -0xb8(%rbp), %rdx
leaq 0xc5c68(%rip), %rsi     # 0x13ea15
leaq -0x68(%rbp), %rdi
callq 0x529e0
jmp 0x78db8
movq -0x10(%rbp), %rsi
leaq -0x90(%rbp), %rdi
callq 0x5a570
jmp 0x78dca
movq -0xb0(%rbp), %rdi
leaq -0x68(%rbp), %rsi
leaq -0x90(%rbp), %rdx
callq 0x6f1b0
jmp 0x78de3
leaq -0x90(%rbp), %rdi
callq 0x52e58
leaq -0x68(%rbp), %rdi
callq 0x52e58
leaq -0x69(%rbp), %rdi
callq 0x527d0
leaq -0x30(%rbp), %rdi
callq 0x52e58
leaq -0x31(%rbp), %rdi
callq 0x527d0
movq -0x98(%rbp), %rdi
movq -0x10(%rbp), %rsi
addq $0x40, %rsi
callq 0x780d0
movq -0x98(%rbp), %rdi
addq $0x170, %rdi            # imm = 0x170
callq 0x6f060
jmp 0x78eb2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x78ea7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x78e9e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x78e95
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x78e8c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x52e58
leaq -0x68(%rbp), %rdi
callq 0x52e58
leaq -0x69(%rbp), %rdi
callq 0x527d0
leaq -0x30(%rbp), %rdi
callq 0x52e58
leaq -0x31(%rbp), %rdi
callq 0x527d0
jmp 0x78ebb
addq $0xc0, %rsp
popq %rbp
retq
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::Detail::(anonymous namespace)::StreamBufImpl<Catch::Detail::(anonymous namespace)::OutputDebugWriter, 256ul>::sync()
int sync() override {
                if( pbase() != pptr() ) {
                    m_writer( std::string( pbase(), static_cast<std::string::size_type>( pptr() - pbase() ) ) );
                    setp( pbase(), epptr() );
                }
                return 0;
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x52200
movq -0x50(%rbp), %rdi
movq %rax, -0x48(%rbp)
callq 0x521e0
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
je 0x7c1f2
movq -0x50(%rbp), %rdi
movq %rdi, %rax
addq $0x140, %rax            # imm = 0x140
movq %rax, -0x78(%rbp)
callq 0x52200
movq -0x50(%rbp), %rdi
movq %rax, -0x68(%rbp)
callq 0x521e0
movq -0x50(%rbp), %rdi
movq %rax, -0x70(%rbp)
callq 0x52200
movq %rax, %rcx
movq -0x70(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x60(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x52ca0
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
movq -0x58(%rbp), %rcx
leaq -0x28(%rbp), %rdi
callq 0x52820
jmp 0x7c17b
movq -0x78(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x7c310
jmp 0x7c18a
leaq -0x28(%rbp), %rdi
callq 0x52e58
leaq -0x29(%rbp), %rdi
callq 0x527d0
movq -0x50(%rbp), %rdi
callq 0x52200
movq -0x50(%rbp), %rdi
movq %rax, -0x80(%rbp)
callq 0x52920
movq -0x50(%rbp), %rdi
movq -0x80(%rbp), %rsi
movq %rax, %rdx
callq 0x52b00
jmp 0x7c1f2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x7c1e7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x52e58
leaq -0x29(%rbp), %rdi
callq 0x527d0
jmp 0x7c1fd
xorl %eax, %eax
addq $0x80, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x52c90
nopw %cs:(%rax,%rax)
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::Detail::(anonymous namespace)::StreamBufImpl<Catch::Detail::(anonymous namespace)::OutputDebugWriter, 256ul>::overflow(int)
int overflow( int c ) override {
                sync();

                if( c != EOF ) {
                    if( pbase() == epptr() )
                        m_writer( std::string( 1, static_cast<char>( c ) ) );
                    else
                        sputc( static_cast<char>( c ) );
                }
                return 0;
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movq (%rdi), %rax
callq *0x30(%rax)
cmpl $-0x1, -0xc(%rbp)
je 0x7c2f8
movq -0x50(%rbp), %rdi
callq 0x52200
movq -0x50(%rbp), %rdi
movq %rax, -0x58(%rbp)
callq 0x52920
movq %rax, %rcx
movq -0x58(%rbp), %rax
cmpq %rcx, %rax
jne 0x7c2e7
movq -0x50(%rbp), %rax
addq $0x140, %rax            # imm = 0x140
movq %rax, -0x70(%rbp)
movsbl -0xc(%rbp), %eax
movl %eax, -0x64(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x52ca0
movl -0x64(%rbp), %edx
movq -0x60(%rbp), %rcx
leaq -0x30(%rbp), %rdi
movl $0x1, %esi
callq 0x524c0
jmp 0x7c296
movq -0x70(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x7c310
jmp 0x7c2a5
leaq -0x30(%rbp), %rdi
callq 0x52e58
leaq -0x31(%rbp), %rdi
callq 0x527d0
jmp 0x7c2f6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x7c2dc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x52e58
leaq -0x31(%rbp), %rdi
callq 0x527d0
jmp 0x7c300
movq -0x50(%rbp), %rdi
movl -0xc(%rbp), %eax
movsbl %al, %esi
callq 0x522c0
jmp 0x7c2f8
xorl %eax, %eax
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x52c90
nopl (%rax)
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::(anonymous namespace)::AssertionPrinter::printResultType(Catch::Colour::Code, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
void printResultType(Colour::Code colour, std::string const& passOrFail) const {
        if (!passOrFail.empty()) {
            {
                Colour colourGuard(colour);
                stream << ' ' << passOrFail;
            }
            stream << ':';
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x52bb0
testb $0x1, %al
jne 0x7c87d
movl -0xc(%rbp), %esi
leaq -0x19(%rbp), %rdi
callq 0x5aea0
movq -0x38(%rbp), %rax
movq (%rax), %rdi
movl $0x20, %esi
callq 0x52870
movq %rax, -0x40(%rbp)
jmp 0x7c83b
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x52670
jmp 0x7c84a
leaq -0x19(%rbp), %rdi
callq 0x5afc0
movq -0x38(%rbp), %rax
movq (%rax), %rdi
movl $0x3a, %esi
callq 0x52870
jmp 0x7c87d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x19(%rbp), %rdi
callq 0x5afc0
jmp 0x7c883
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x52c90
nopl (%rax)
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::(anonymous namespace)::AssertionPrinter::printReconstructedExpression() const
void printReconstructedExpression() const {
        if (result.hasExpandedExpression()) {
            {
                Colour colour(dimColour());
                stream << " for: ";
            }
            stream << result.getExpandedExpression();
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq 0x8(%rax), %rdi
callq 0x54cc0
testb $0x1, %al
jne 0x7c956
jmp 0x7c9e8
callq 0x7ccc0
movl %eax, %esi
leaq -0x9(%rbp), %rdi
callq 0x5aea0
movq -0x48(%rbp), %rax
movq (%rax), %rdi
leaq 0xc4618(%rip), %rsi     # 0x140f8c
callq 0x52710
jmp 0x7c97b
leaq -0x9(%rbp), %rdi
callq 0x5afc0
movq -0x48(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x58(%rbp)
movq 0x8(%rax), %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x54d80
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x52670
jmp 0x7c9af
leaq -0x40(%rbp), %rdi
callq 0x52e58
jmp 0x7c9e8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x9(%rbp), %rdi
callq 0x5afc0
jmp 0x7c9ee
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x52e58
jmp 0x7c9ee
addq $0x60, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x52c90
nopw (%rax,%rax)
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::(anonymous namespace)::AssertionPrinter::printExpressionWas()
void printExpressionWas() {
        if (result.hasExpression()) {
            stream << ';';
            {
                Colour colour(dimColour());
                stream << " expression was:";
            }
            printOriginalExpression();
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x8(%rax), %rdi
callq 0x549e0
testb $0x1, %al
jne 0x7cde3
jmp 0x7ce44
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movl $0x3b, %esi
callq 0x52870
callq 0x7ccc0
movl %eax, %esi
leaq -0x9(%rbp), %rdi
callq 0x5aea0
movq -0x28(%rbp), %rax
movq (%rax), %rdi
leaq 0xc4186(%rip), %rsi     # 0x140f98
callq 0x52710
jmp 0x7ce19
leaq -0x9(%rbp), %rdi
callq 0x5afc0
movq -0x28(%rbp), %rdi
callq 0x7c8a0
jmp 0x7ce44
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x9(%rbp), %rdi
callq 0x5afc0
jmp 0x7ce4a
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x52c90
nopw %cs:(%rax,%rax)
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::(anonymous namespace)::ConsoleAssertionPrinter::printOriginalExpression() const
void printOriginalExpression() const {
        if (result.hasExpression()) {
            Colour colourGuard(Colour::OriginalExpression);
            stream << "  ";
            stream << result.getExpressionInMacro();
            stream << '\n';
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq 0x10(%rax), %rdi
callq 0x549e0
testb $0x1, %al
jne 0x7da06
jmp 0x7daa7
leaq -0x9(%rbp), %rdi
movl $0x5, %esi
callq 0x5aea0
movq -0x48(%rbp), %rax
movq (%rax), %rdi
leaq 0xcafea(%rip), %rsi     # 0x148a0c
callq 0x52710
jmp 0x7da29
movq -0x48(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x50(%rbp)
movq 0x10(%rax), %rsi
leaq -0x40(%rbp), %rdi
callq 0x54b90
jmp 0x7da43
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x52670
jmp 0x7da52
leaq -0x40(%rbp), %rdi
callq 0x52e58
movq -0x48(%rbp), %rax
movq (%rax), %rdi
movl $0xa, %esi
callq 0x52870
jmp 0x7da6e
leaq -0x9(%rbp), %rdi
callq 0x5afc0
jmp 0x7daa7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x7da9c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x52e58
leaq -0x9(%rbp), %rdi
callq 0x5afc0
jmp 0x7daad
addq $0x50, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x52c90
nopw %cs:(%rax,%rax)
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::(anonymous namespace)::ConsoleAssertionPrinter::printReconstructedExpression() const
void printReconstructedExpression() const {
        if (result.hasExpandedExpression()) {
            stream << "with expansion:\n";
            Colour colourGuard(Colour::ReconstructedExpression);
            stream << Column(result.getExpandedExpression()).indent(2) << '\n';
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
movq 0x10(%rax), %rdi
callq 0x54cc0
testb $0x1, %al
jne 0x7dae9
jmp 0x7dbcb
movq -0x78(%rbp), %rax
movq (%rax), %rdi
leaq 0xc23af(%rip), %rsi     # 0x13fea6
callq 0x52710
leaq -0x9(%rbp), %rdi
movl $0x16, %esi
callq 0x5aea0
movq -0x78(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x80(%rbp)
movq 0x10(%rax), %rsi
leaq -0x60(%rbp), %rdi
callq 0x54d80
jmp 0x7db24
leaq -0x40(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x8d4c0
jmp 0x7db33
leaq -0x40(%rbp), %rdi
movl $0x2, %esi
callq 0x8d550
movq -0x80(%rbp), %rdi
movq %rax, %rsi
callq 0x8d3d0
movq %rax, -0x88(%rbp)
jmp 0x7db56
movq -0x88(%rbp), %rdi
movl $0xa, %esi
callq 0x52870
jmp 0x7db69
leaq -0x40(%rbp), %rdi
callq 0x8d570
leaq -0x60(%rbp), %rdi
callq 0x52e58
leaq -0x9(%rbp), %rdi
callq 0x5afc0
jmp 0x7dbcb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x7dbc0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x7dbb7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x8d570
leaq -0x60(%rbp), %rdi
callq 0x52e58
leaq -0x9(%rbp), %rdi
callq 0x5afc0
jmp 0x7dbd4
addq $0x90, %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: Catch::(anonymous namespace)::ConsoleAssertionPrinter::printMessage() const
void printMessage() const {
        if (!messageLabel.empty())
            stream << messageLabel << ':' << '\n';
        for (auto const& msg : messages) {
            // If this assertion is a warning ignore any INFO messages
            if (printInfoMessages || msg.type != ResultWas::Info)
                stream << Column(msg.message).indent(2) << '\n';
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
addq $0x40, %rdi
callq 0x52bb0
testb $0x1, %al
jne 0x7dc2e
movq -0x70(%rbp), %rsi
movq (%rsi), %rdi
addq $0x40, %rsi
callq 0x52670
movq %rax, %rdi
movl $0x3a, %esi
callq 0x52870
movq %rax, %rdi
movl $0xa, %esi
callq 0x52870
movq -0x70(%rbp), %rax
addq $0x80, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x96090
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x960c0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x960f0
testb $0x1, %al
jne 0x7dc6c
jmp 0x7dd1b
leaq -0x18(%rbp), %rdi
callq 0x96130
movq %rax, %rcx
movq -0x70(%rbp), %rax
movq %rcx, -0x28(%rbp)
testb $0x1, 0x98(%rax)
jne 0x7dc93
movq -0x28(%rbp), %rax
cmpl $0x1, 0x40(%rax)
je 0x7dd0b
movq -0x70(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x80(%rbp)
movq -0x28(%rbp), %rsi
addq $0x10, %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x8d4c0
movq -0x88(%rbp), %rdi
movl $0x2, %esi
callq 0x8d550
movq -0x80(%rbp), %rdi
movq %rax, %rsi
callq 0x8d3d0
movq %rax, -0x78(%rbp)
jmp 0x7dcd9
movq -0x78(%rbp), %rdi
movl $0xa, %esi
callq 0x52870
jmp 0x7dce9
leaq -0x58(%rbp), %rdi
callq 0x8d570
jmp 0x7dd0b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x8d570
jmp 0x7dd24
jmp 0x7dd0d
leaq -0x18(%rbp), %rdi
callq 0x96150
jmp 0x7dc56
addq $0x90, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x52c90
nopl (%rax)
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::operator<<(Catch::TablePrinter&, Catch::(anonymous namespace)::RowBreak)
TablePrinter& operator << (TablePrinter& tp, RowBreak) {
        if (tp.m_currentColumn > 0) {
            tp.m_os << '\n';
            tp.m_currentColumn = -1;
        }
        return tp;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x198(%rax)
jle 0x7dd68
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl $0xa, %esi
callq 0x52870
movq -0x10(%rbp), %rax
movl $0xffffffff, 0x198(%rax) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::clara::detail::BasicResult<Catch::clara::detail::ParseResultType> Catch::clara::detail::invokeLambda<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Catch::makeCommandLineParser(Catch::ConfigData&)::$_0>(Catch::makeCommandLineParser(Catch::ConfigData&)::$_0 const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline auto invokeLambda( L const &lambda, std::string const &arg ) -> ParserResult {
        ArgType temp{};
        auto result = convertInto( arg, temp );
        return !result
           ? result
           : LambdaInvoker<typename UnaryLambdaTraits<L>::ReturnType>::invoke( lambda, temp );
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x52a00
movq -0x80(%rbp), %rdx
movq -0x18(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x9a510
jmp 0x7eb28
leaq -0x68(%rbp), %rdi
callq 0x9caf0
testb $0x1, %al
jne 0x7eb49
movq -0x90(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0xb90b0
jmp 0x7eb47
jmp 0x7eb61
movq -0x90(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x7ebc0
jmp 0x7eb5f
jmp 0x7eb61
leaq -0x68(%rbp), %rdi
callq 0x9a630
leaq -0x38(%rbp), %rdi
callq 0x52e58
movq -0x88(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x7eba6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x9a630
leaq -0x38(%rbp), %rdi
callq 0x52e58
movq -0x70(%rbp), %rdi
callq 0x52c90
nopl (%rax,%rax)
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::Singleton<Catch::(anonymous namespace)::RegistryHub, Catch::IRegistryHub, Catch::IMutableRegistryHub>::getInternal()
static auto getInternal() -> Singleton* {
            static Singleton* s_instance = nullptr;
            if( !s_instance ) {
                s_instance = new Singleton;
                addSingleton( s_instance );
            }
            return s_instance;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
cmpq $0x0, 0x139ce0(%rip)    # 0x1c2060
jne 0x883ef
movl $0x150, %edi            # imm = 0x150
callq 0x52720
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x18(%rbp)
callq 0x88410
jmp 0x8839d
movq -0x18(%rbp), %rax
movq %rax, 0x139cb8(%rip)    # 0x1c2060
movq 0x139cb1(%rip), %rcx    # 0x1c2060
movq %rcx, -0x28(%rbp)
xorl %eax, %eax
cmpq $0x0, %rcx
movq %rax, -0x20(%rbp)
je 0x883cd
movq -0x28(%rbp), %rax
addq $0x148, %rax            # imm = 0x148
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x67960
jmp 0x883ef
movq -0x18(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x8(%rbp)
movl %eax, -0xc(%rbp)
callq 0x526b0
jmp 0x883fc
movq 0x139c6a(%rip), %rax    # 0x1c2060
addq $0x30, %rsp
popq %rbp
retq
movq -0x8(%rbp), %rdi
callq 0x52c90
nopw %cs:(%rax,%rax)
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::MatchExpr<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Catch::Matchers::Impl::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&>::MatchExpr(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::Matchers::Impl::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&, Catch::StringRef const&)
MatchExpr( ArgT const& arg, MatcherT const& matcher, StringRef const& matcherString )
        :   ITransientExpression{ true, matcher.match( arg ) },
            m_arg( arg ),
            m_matcher( matcher ),
            m_matcherString( matcherString )
        {}

// 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), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, %rdi
addq $0x28, %rdi
movq -0x10(%rbp), %rsi
movq 0x28(%rax), %rax
callq *(%rax)
movq -0x28(%rbp), %rdi
movzbl %al, %edx
andl $0x1, %edx
movl $0x1, %esi
callq 0xb7670
movq -0x28(%rbp), %rax
leaq 0x134dc4(%rip), %rcx    # 0x1bfe68
addq $0x10, %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq (%rcx), %rdx
movq %rdx, 0x20(%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x28(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::clara::TextFlow::operator<<(std::ostream&, Catch::clara::TextFlow::Column const&)
inline friend std::ostream& operator << (std::ostream& os, Column const& col) {
		bool first = true;
		for (auto line : col) {
			if (first)
				first = false;
			else
				os << "\n";
			os << line;
		}
		return os;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x1, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0xa20c0
movq -0x20(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0xa20f0
leaq -0x50(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0xa2130
testb $0x1, %al
jne 0x8d41c
jmp 0x8d498
leaq -0xa0(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xa2160
testb $0x1, -0x11(%rbp)
je 0x8d438
movb $0x0, -0x11(%rbp)
jmp 0x8d46c
movq -0x8(%rbp), %rdi
leaq 0xbc382(%rip), %rsi     # 0x1497c5
callq 0x52710
jmp 0x8d44a
jmp 0x8d46c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x52e58
jmp 0x8d4a5
movq -0x8(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x52670
jmp 0x8d47e
leaq -0xa0(%rbp), %rdi
callq 0x52e58
leaq -0x50(%rbp), %rdi
callq 0xa2260
jmp 0x8d409
movq -0x8(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0xa8(%rbp), %rdi
callq 0x52c90
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::clara::TextFlow::operator<<(std::ostream&, Catch::clara::TextFlow::Columns const&)
inline friend std::ostream& operator << (std::ostream& os, Columns const& cols) {

		bool first = true;
		for (auto line : cols) {
			if (first)
				first = false;
			else
				os << "\n";
			os << line;
		}
		return os;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x1, -0x11(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0xa3810
movq -0x20(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0xa3840
jmp 0x8ddcb
jmp 0x8ddcd
leaq -0x48(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0xa3870
movb %al, -0xa1(%rbp)
jmp 0x8dde2
movb -0xa1(%rbp), %al
testb $0x1, %al
jne 0x8de24
jmp 0x8ddee
leaq -0x70(%rbp), %rdi
callq 0xa3d00
leaq -0x48(%rbp), %rdi
callq 0xa3d00
jmp 0x8deb2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x8dea7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x8de9e
leaq -0xa0(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xa38a0
jmp 0x8de36
testb $0x1, -0x11(%rbp)
je 0x8de42
movb $0x0, -0x11(%rbp)
jmp 0x8de70
movq -0x8(%rbp), %rdi
leaq 0xbb978(%rip), %rsi     # 0x1497c5
callq 0x52710
jmp 0x8de54
jmp 0x8de70
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x52e58
jmp 0x8de9e
movq -0x8(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x52670
jmp 0x8de82
leaq -0xa0(%rbp), %rdi
callq 0x52e58
leaq -0x48(%rbp), %rdi
callq 0xa3c40
jmp 0x8de99
jmp 0x8ddcd
leaq -0x70(%rbp), %rdi
callq 0xa3d00
leaq -0x48(%rbp), %rdi
callq 0xa3d00
jmp 0x8debf
movq -0x8(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x52c90
nopl (%rax,%rax)
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::clara::TextFlow::Column::operator+(Catch::clara::TextFlow::Column const&)
inline auto Column::operator + (Column const& other) -> Columns {
	Columns cols;
	cols += *this;
	cols += other;
	return cols;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movb $0x0, -0x19(%rbp)
callq 0xa5070
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0xa5090
jmp 0x8df8f
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xa5090
jmp 0x8df9e
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x8dfca
jmp 0x8dfc1
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x8e000
jmp 0x8dfd4
movq -0x40(%rbp), %rdi
callq 0x8e000
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x52c90
nopl (%rax)
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::StringStreams::add()
auto add() -> std::size_t {
            if( m_unused.empty() ) {
                m_streams.push_back( std::unique_ptr<std::ostringstream>( new std::ostringstream ) );
                return m_streams.size()-1;
            }
            else {
                auto index = m_unused.back();
                m_unused.pop_back();
                return index;
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x18, %rdi
callq 0xb19e0
testb $0x1, %al
jne 0x90bd6
jmp 0x90c63
movq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x178, %edi            # imm = 0x178
callq 0x52720
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
callq 0x529c0
jmp 0x90bf9
movq -0x40(%rbp), %rsi
leaq -0x18(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0xb1a50
movq -0x48(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0xb1a20
jmp 0x90c19
leaq -0x18(%rbp), %rdi
callq 0xb1a80
movq -0x38(%rbp), %rdi
callq 0xb1ae0
subq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x90c8c
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x526b0
jmp 0x90c96
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xb1a80
jmp 0x90c96
movq -0x38(%rbp), %rdi
addq $0x18, %rdi
callq 0xb1b00
movq -0x38(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x30(%rbp)
addq $0x18, %rdi
callq 0xb1b40
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x52c90
nop
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> Catch::fpToString<float>(float, int)
std::string fpToString( T value, int precision ) {
    if (Catch::isnan(value)) {
        return "nan";
    }

    ReusableStringStream rss;
    rss << std::setprecision( precision )
        << std::fixed
        << value;
    std::string d = rss.str();
    std::size_t i = d.find_last_not_of( '0' );
    if( i != std::string::npos && i != d.size()-1 ) {
        if( d[i] == '.' )
            i++;
        d = d.substr( 0, i+1 );
    }
    return d;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movss -0xc(%rbp), %xmm0
callq 0x62310
testb $0x1, %al
jne 0x93a02
jmp 0x93a53
leaq -0x11(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x52ca0
movq -0x80(%rbp), %rdi
movq -0x88(%rbp), %rdx
leaq 0xae2e7(%rip), %rsi     # 0x141d0b
callq 0x529e0
jmp 0x93a2b
leaq -0x11(%rbp), %rdi
callq 0x527d0
jmp 0x93bc8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x11(%rbp), %rdi
callq 0x527d0
jmp 0x93bd5
leaq -0x40(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x67d90
movl -0x10(%rbp), %edi
callq 0xb60e0
movq -0x98(%rbp), %rdi
movl %eax, -0x44(%rbp)
leaq -0x44(%rbp), %rsi
callq 0xb60a0
movq %rax, -0x90(%rbp)
jmp 0x93a87
movq -0x90(%rbp), %rdi
leaq 0x225db(%rip), %rsi     # 0xb6070
callq 0x93590
movq %rax, -0xa0(%rbp)
jmp 0x93aa3
movq -0xa0(%rbp), %rdi
leaq -0xc(%rbp), %rsi
callq 0xfe3f0
jmp 0x93ab5
movq -0x80(%rbp), %rdi
movb $0x0, -0x45(%rbp)
leaq -0x40(%rbp), %rsi
callq 0x53b70
jmp 0x93ac8
movq -0x80(%rbp), %rdi
movl $0x30, %esi
movq $-0x1, %rdx
callq 0x524d0
movq %rax, -0x50(%rbp)
cmpq $-0x1, -0x50(%rbp)
je 0x93b9f
movq -0x80(%rbp), %rdi
movq -0x50(%rbp), %rax
movq %rax, -0xa8(%rbp)
callq 0x52500
movq %rax, %rcx
movq -0xa8(%rbp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
je 0x93b9f
movq -0x80(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x52e00
movq %rax, -0xb0(%rbp)
jmp 0x93b2d
movq -0xb0(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x93b6f
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
jmp 0x93b6f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x93bbd
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x52e58
jmp 0x93bbd
movq -0x80(%rbp), %rsi
movq -0x50(%rbp), %rcx
incq %rcx
xorl %eax, %eax
movl %eax, %edx
leaq -0x70(%rbp), %rdi
callq 0x52780
jmp 0x93b89
movq -0x80(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x528a0
leaq -0x70(%rbp), %rdi
callq 0x52e58
movb $0x1, -0x45(%rbp)
testb $0x1, -0x45(%rbp)
jne 0x93bb2
movq -0x80(%rbp), %rdi
callq 0x52e58
leaq -0x40(%rbp), %rdi
callq 0x67e50
jmp 0x93bc8
leaq -0x40(%rbp), %rdi
callq 0x67e50
jmp 0x93bd5
movq -0x78(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x52c90
nop
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::TablePrinter::close()
void close() {
        if (m_isOpen) {
            *this << RowBreak();
            m_os << std::endl;
            m_isOpen = false;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, 0x19c(%rax)
je 0x94694
movq -0x18(%rbp), %rdi
callq 0x7dd30
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq 0x12c8b4(%rip), %rsi    # 0x1c0f38
callq 0x527a0
movq -0x18(%rbp), %rax
movb $0x0, 0x19c(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: char const* Catch::getLineOfChars<(char)126>()
char const* getLineOfChars() {
        static char line[CATCH_CONFIG_CONSOLE_WIDTH] = {0};
        if( !*line ) {
            std::memset( line, C, CATCH_CONFIG_CONSOLE_WIDTH-1 );
            line[CATCH_CONFIG_CONSOLE_WIDTH-1] = 0;
        }
        return line;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x12d965(%rip), %rax    # 0x1c2180
cmpb $0x0, (%rax)
jne 0x94841
leaq 0x12d959(%rip), %rdi    # 0x1c2180
movl $0x7e, %esi
movl $0x4f, %edx
callq 0x523d0
leaq 0x12d943(%rip), %rax    # 0x1c2180
movb $0x0, 0x4f(%rax)
leaq 0x12d938(%rip), %rax    # 0x1c2180
popq %rbp
retq
nopw (%rax,%rax)