LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::StringMaker<long long, void>::convert[abi:cxx11](long long)
std::string StringMaker<long long>::convert(long long value) {
    ReusableStringStream rss;
    rss << value;
    if (value > Detail::hexThreshold) {
        rss << " (0x" << std::hex << value << ')';
    }
    return rss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x30(%rbp), %r15
movq %r15, %rdi
callq 0x30e18
movq 0x10(%r15), %rdi
movq %r14, %rsi
callq 0x241c0
cmpq $0x100, %r14            # imm = 0x100
jl 0x340a5
movq -0x20(%rbp), %rdi
leaq 0x40877(%rip), %rsi     # 0x748ea
callq 0x24570
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
movl 0x18(%rdi,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%rdi,%rax)
movq %r14, %rsi
callq 0x241c0
movq -0x20(%rbp), %rdi
pushq $0x29
popq %rsi
callq 0x24670
movq -0x20(%rbp), %rsi
addq $0x8, %rsi
movq %rbx, %rdi
callq 0x24830
leaq -0x30(%rbp), %rdi
callq 0x30e5e
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x340ce
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x30e5e
movq %rbx, %rdi
callq 0x24950
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::StringMaker<unsigned long long, void>::convert[abi:cxx11](unsigned long long)
std::string StringMaker<unsigned long long>::convert(unsigned long long value) {
    ReusableStringStream rss;
    rss << value;
    if (value > Detail::hexThreshold) {
        rss << " (0x" << std::hex << value << ')';
    }
    return rss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x30(%rbp), %r15
movq %r15, %rdi
callq 0x30e18
movq 0x10(%r15), %rdi
movq %r14, %rsi
callq 0x243b0
cmpq $0x100, %r14            # imm = 0x100
jb 0x34185
movq -0x20(%rbp), %rdi
leaq 0x40797(%rip), %rsi     # 0x748ea
callq 0x24570
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
movl 0x18(%rdi,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%rdi,%rax)
movq %r14, %rsi
callq 0x243b0
movq -0x20(%rbp), %rdi
pushq $0x29
popq %rsi
callq 0x24670
movq -0x20(%rbp), %rsi
addq $0x8, %rsi
movq %rbx, %rdi
callq 0x24830
leaq -0x30(%rbp), %rdi
callq 0x30e5e
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x341ae
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x30e5e
movq %rbx, %rdi
callq 0x24950
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::StringMaker<signed char, void>::convert[abi:cxx11](signed char)
std::string StringMaker<signed char>::convert(signed char value) {
    if (value == '\r') {
        return "'\\r'";
    } else if (value == '\f') {
        return "'\\f'";
    } else if (value == '\n') {
        return "'\\n'";
    } else if (value == '\t') {
        return "'\\t'";
    } else if ('\0' <= value && value < ' ') {
        return ::Catch::Detail::stringify(static_cast<unsigned int>(value));
    } else {
        char chstr[] = "' '";
        chstr[1] = value;
        return chstr;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leal -0x9(%rsi), %eax
cmpl $0x4, %eax
ja 0x3425e
leaq 0x3df63(%rip), %rcx     # 0x72174
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x406e8(%rip), %rsi     # 0x74909
leaq -0xa(%rbp), %rdx
jmp 0x3424c
leaq 0x406d1(%rip), %rsi     # 0x748ff
leaq -0xc(%rbp), %rdx
jmp 0x3424c
leaq 0x406c9(%rip), %rsi     # 0x74904
leaq -0xb(%rbp), %rdx
jmp 0x3424c
leaq 0x406b2(%rip), %rsi     # 0x748fa
leaq -0xd(%rbp), %rdx
movq %rbx, %rdi
callq 0x24210
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
cmpb $0x1f, %sil
ja 0x34271
movslq %esi, %rsi
movq %rbx, %rdi
callq 0x34114
jmp 0x34254
leaq -0x14(%rbp), %rax
movl $0x272027, (%rax)       # imm = 0x272027
movb %sil, 0x1(%rax)
leaq -0x9(%rbp), %rdx
movq %rbx, %rdi
movq %rax, %rsi
jmp 0x3424f
nop
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::WildcardPattern::WildcardPattern(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::CaseSensitive::Choice)
WildcardPattern::WildcardPattern( std::string const& pattern,
                                      CaseSensitive::Choice caseSensitivity )
    :   m_caseSensitivity( caseSensitivity ),
        m_pattern( normaliseString( pattern ) )
    {
        if( startsWith( m_pattern, '*' ) ) {
            m_pattern = m_pattern.substr( 1 );
            m_wildcard = WildcardAtStart;
        }
        if( endsWith( m_pattern, '*' ) ) {
            m_pattern = m_pattern.substr( 0, m_pattern.size()-1 );
            m_wildcard = static_cast<WildcardPosition>( m_wildcard | WildcardAtEnd );
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rax
movq %rdi, %r14
leaq 0x761b2(%rip), %rcx     # 0xaa6c0
addq $0x10, %rcx
movq %rcx, (%rdi)
movl %edx, 0x8(%rdi)
andl $0x0, 0xc(%rdi)
leaq 0x10(%rdi), %rbx
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x345d0
movq 0x18(%r14), %rcx
testq %rcx, %rcx
je 0x345b0
movq (%rbx), %rax
cmpb $0x2a, (%rax)
jne 0x34579
leaq -0x38(%rbp), %rdi
pushq $0x1
popq %rdx
pushq $-0x1
popq %rcx
movq %rbx, %rsi
callq 0x245e0
leaq -0x38(%rbp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x24690
movq %r15, %rdi
callq 0x24ad8
movl $0x1, 0xc(%r14)
movq 0x18(%r14), %rcx
testq %rcx, %rcx
je 0x345b0
movq (%rbx), %rax
cmpb $0x2a, -0x1(%rax,%rcx)
jne 0x345b0
decq %rcx
leaq -0x38(%rbp), %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x245e0
leaq -0x38(%rbp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x24690
movq %r15, %rdi
callq 0x24ad8
orb $0x2, 0xc(%r14)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x345bd
movq %rax, %r14
movq %rbx, %rdi
callq 0x24ad8
movq %r14, %rdi
callq 0x24950
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::(anonymous namespace)::hexEscapeChar(std::ostream&, unsigned char)
void hexEscapeChar(std::ostream& os, unsigned char c) {
        std::ios_base::fmtflags f(os.flags());
        os << "\\x"
            << std::uppercase << std::hex << std::setfill('0') << std::setw(2)
            << static_cast<int>(c);
        os.flags(f);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
movq (%rdi), %rax
movq -0x18(%rax), %rax
movl 0x18(%rdi,%rax), %r15d
leaq 0x41408(%rip), %rsi     # 0x75cdb
callq 0x24570
movq (%rax), %rcx
movq -0x18(%rcx), %rdx
orl $0x4000, 0x18(%rax,%rdx) # imm = 0x4000
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %edx
andl $-0x4b, %edx
orl $0x8, %edx
movl %edx, 0x18(%rax,%rcx)
pushq $0x30
popq %rsi
movq %rax, %rdi
callq 0x24820
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq $0x2, 0x10(%rax,%rcx)
movq %rax, %rdi
movl %r14d, %esi
callq 0x24900
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl %r15d, 0x18(%rbx,%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::XmlWriter::ScopedElement::operator=(Catch::XmlWriter::ScopedElement&&)
XmlWriter::ScopedElement& XmlWriter::ScopedElement::operator=( ScopedElement&& other ) noexcept {
        if ( m_writer ) {
            m_writer->endElement();
        }
        m_writer = other.m_writer;
        other.m_writer = nullptr;
        m_fmt = other.m_fmt;
        other.m_fmt = XmlFormatting::None;
        return *this;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x34997
pushq $0x3
popq %rsi
callq 0x349be
movq (%r14), %rax
movq %rax, (%rbx)
andq $0x0, (%r14)
movl 0x8(%r14), %eax
movl %eax, 0x8(%rbx)
andl $0x0, 0x8(%r14)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rdi
callq 0x3dcad
nop
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::XmlWriter::endElement(Catch::XmlFormatting)
XmlWriter& XmlWriter::endElement(XmlFormatting fmt) {
        m_indent = m_indent.substr(0, m_indent.size() - 2);

        if( m_tagIsOpen ) {
            m_os << "/>";
            m_tagIsOpen = false;
        } else {
            newlineIfNecessary();
            if (shouldIndent(fmt)) {
                m_os << m_indent;
            }
            m_os << "</" << m_tags.back() << ">";
        }
        m_os << std::flush;
        applyFormatting(fmt);
        m_tags.pop_back();
        return *this;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %esi, %r14d
movq %rdi, %rbx
leaq 0x20(%rdi), %r15
movq 0x28(%rdi), %rcx
addq $-0x2, %rcx
leaq -0x40(%rbp), %r12
movq %r12, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x245e0
movq %r15, %rdi
movq %r12, %rsi
callq 0x24690
movq %r12, %rdi
callq 0x24ad8
cmpb $0x1, (%rbx)
jne 0x34a1d
movq 0x40(%rbx), %rdi
leaq 0x3ff21(%rip), %rsi     # 0x74934
callq 0x24570
movb $0x0, (%rbx)
jmp 0x34a66
movq %rbx, %rdi
callq 0x34c44
testb $0x1, %r14b
je 0x34a37
movq 0x40(%rbx), %rdi
movq %r15, %rsi
callq 0x24510
movq 0x40(%rbx), %rdi
leaq 0x3fef5(%rip), %rsi     # 0x74937
callq 0x24570
movq 0x10(%rbx), %rsi
addq $-0x20, %rsi
movq %rax, %rdi
callq 0x24510
leaq 0x3fee3(%rip), %rsi     # 0x74941
movq %rax, %rdi
callq 0x24570
movq 0x40(%rbx), %rdi
callq 0x243d0
shrb %r14b
andb $0x1, %r14b
movb %r14b, 0x1(%rbx)
leaq 0x8(%rbx), %rdi
callq 0x3fdf6
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::XmlWriter::writeText(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::XmlFormatting)
XmlWriter& XmlWriter::writeText( std::string const& text, XmlFormatting fmt) {
        if( !text.empty() ){
            bool tagWasOpen = m_tagIsOpen;
            ensureTagClosed();
            if (tagWasOpen && shouldIndent(fmt)) {
                m_os << m_indent;
            }
            m_os << XmlEncode( text );
            applyFormatting(fmt);
        }
        return *this;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x8(%rsi)
je 0x34b4a
movl %edx, %r14d
movq %rsi, %r15
movb (%rbx), %r12b
movq %rbx, %rdi
callq 0x34ce8
testb $0x1, %r14b
je 0x34b16
testb %r12b, %r12b
je 0x34b16
movq 0x40(%rbx), %rdi
leaq 0x20(%rbx), %rsi
callq 0x24510
movq 0x40(%rbx), %r12
leaq -0x50(%rbp), %r13
movq %r13, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x34644
movq %r13, %rdi
movq %r12, %rsi
callq 0x3465e
leaq -0x50(%rbp), %rdi
callq 0x24ad8
shrb %r14b
andb $0x1, %r14b
movb %r14b, 0x1(%rbx)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x24ad8
movq %rbx, %rdi
callq 0x24950
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::XmlWriter::startElement(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::XmlFormatting)
XmlWriter& XmlWriter::startElement( std::string const& name, XmlFormatting fmt ) {
        ensureTagClosed();
        newlineIfNecessary();
        if (shouldIndent(fmt)) {
            m_os << m_indent;
            m_indent += "  ";
        }
        m_os << '<' << name;
        m_tags.push_back( name );
        m_tagIsOpen = true;
        applyFormatting(fmt);
        return *this;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
callq 0x34ce8
movq %r14, %rdi
callq 0x34c44
testb $0x1, %bl
je 0x34cac
movq 0x40(%r14), %rdi
leaq 0x20(%r14), %r12
movq %r12, %rsi
callq 0x24510
leaq 0x47757(%rip), %rsi     # 0x7c3fb
movq %r12, %rdi
callq 0x24a10
movq 0x40(%r14), %rdi
pushq $0x3c
popq %rsi
callq 0x24670
movq %rax, %rdi
movq %r15, %rsi
callq 0x24510
leaq 0x8(%r14), %rdi
movq %r15, %rsi
callq 0x3f2ea
movb $0x1, (%r14)
shrb %bl
andb $0x1, %bl
movb %bl, 0x1(%r14)
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::XmlWriter::ensureTagClosed()
void XmlWriter::ensureTagClosed() {
        if( m_tagIsOpen ) {
            m_os << '>' << std::flush;
            newlineIfNecessary();
            m_tagIsOpen = false;
        }
    }

// Assembly:
cmpb $0x1, (%rdi)
jne 0x34d1b
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x40(%rdi), %rdi
pushq $0x3e
popq %rsi
callq 0x24670
movq %rax, %rdi
callq 0x243d0
movq %rbx, %rdi
callq 0x34c44
movb $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::XmlWriter::writeComment(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::XmlFormatting)
XmlWriter& XmlWriter::writeComment( std::string const& text, XmlFormatting fmt) {
        ensureTagClosed();
        if (shouldIndent(fmt)) {
            m_os << m_indent;
        }
        m_os << "<!--" << text << "-->";
        applyFormatting(fmt);
        return *this;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
callq 0x34ce8
testb $0x1, %bl
je 0x34eb7
movq 0x40(%r14), %rdi
leaq 0x20(%r14), %rsi
callq 0x24510
movq 0x40(%r14), %rdi
leaq 0x3fa78(%rip), %rsi     # 0x7493a
callq 0x24570
movq %rax, %rdi
movq %r15, %rsi
callq 0x24510
leaq 0x3fa66(%rip), %rsi     # 0x7493f
movq %rax, %rdi
callq 0x24570
shrb %bl
andb $0x1, %bl
movb %bl, 0x1(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::getFormattedDuration[abi:cxx11](double)
std::string getFormattedDuration( double duration ) {
        // Max exponent + 1 is required to represent the whole part
        // + 1 for decimal point
        // + 3 for the 3 decimal places
        // + 1 for null terminator
        const std::size_t maxDoubleSize = DBL_MAX_10_EXP + 1 + 1 + 3 + 1;
        char buffer[maxDoubleSize];

        // Save previous errno, to prevent sprintf from overwriting it
        ErrnoGuard guard;
#ifdef _MSC_VER
        sprintf_s(buffer, "%.3f", duration);
#else
        std::sprintf(buffer, "%.3f", duration);
#endif
        return std::string(buffer);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x150, %rsp            # imm = 0x150
movsd %xmm0, -0x20(%rbp)
movq %rdi, %rbx
leaq -0x18(%rbp), %rdi
callq 0x2a3c8
leaq 0x3f9f0(%rip), %rsi     # 0x74993
leaq -0x160(%rbp), %r14
movq %r14, %rdi
movsd -0x20(%rbp), %xmm0
movb $0x1, %al
callq 0x240f0
leaq -0x11(%rbp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x24210
leaq -0x18(%rbp), %rdi
callq 0x2a3e2
movq %rbx, %rax
addq $0x150, %rsp            # imm = 0x150
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x18(%rbp), %rdi
callq 0x2a3e2
movq %rbx, %rdi
callq 0x24950
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::shouldShowDuration(Catch::IConfig const&, double)
bool shouldShowDuration( IConfig const& config, double duration ) {
        if ( config.showDurations() == ShowDurations::Always ) {
            return true;
        }
        if ( config.showDurations() == ShowDurations::Never ) {
            return false;
        }
        const double min = config.minDuration();
        return min >= 0 && duration >= min;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movapd %xmm0, -0x20(%rbp)
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x58(%rax)
movl %eax, %ecx
movb $0x1, %al
cmpl $0x1, %ecx
je 0x35046
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x58(%rax)
cmpl $0x2, %eax
jne 0x35026
xorl %eax, %eax
jmp 0x35046
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x60(%rax)
xorpd %xmm1, %xmm1
cmplepd %xmm0, %xmm1
cmplepd -0x20(%rbp), %xmm0
andpd %xmm1, %xmm0
movd %xmm0, %eax
andb $0x1, %al
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::serializeFilters(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 serializeFilters( std::vector<std::string> const& container ) {
        ReusableStringStream oss;
        bool first = true;
        for (auto&& filter : container)
        {
            if (!first)
                oss << ' ';
            else
                first = false;

            oss << filter;
        }
        return oss.str();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq -0x38(%rbp), %rdi
callq 0x30e18
movq (%r15), %r14
movq 0x8(%r15), %r12
movb $0x1, %al
pushq $0x20
popq %r15
cmpq %r12, %r14
je 0x350a3
testb $0x1, %al
jne 0x3508f
movq -0x28(%rbp), %rdi
movl %r15d, %esi
callq 0x24670
movq -0x28(%rbp), %rdi
movq %r14, %rsi
callq 0x24510
addq $0x20, %r14
xorl %eax, %eax
jmp 0x3507a
movq -0x28(%rbp), %rsi
addq $0x8, %rsi
movq %rbx, %rdi
callq 0x24830
leaq -0x38(%rbp), %rdi
callq 0x30e5e
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x350d0
jmp 0x350d0
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x30e5e
movq %rbx, %rdi
callq 0x24950
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::ConsoleReporter::sectionEnded(Catch::SectionStats const&)
void ConsoleReporter::sectionEnded(SectionStats const& _sectionStats) {
    m_tablePrinter->close();
    if (_sectionStats.missingAssertions) {
        lazyPrint();
        Colour colour(Colour::ResultError);
        if (m_sectionStack.size() > 1)
            stream << "\nNo assertions in section";
        else
            stream << "\nNo assertions in test case";
        stream << " '" << _sectionStats.sectionInfo.name << "'\n" << std::endl;
    }
    double dur = _sectionStats.durationInSeconds;
    if (shouldShowDuration(*m_config, dur)) {
        stream << getFormattedDuration(dur) << " s: " << _sectionStats.sectionInfo.name << std::endl;
    }
    if (m_headerPrinted) {
        m_headerPrinted = false;
    }
    StreamingReporterBase::sectionEnded(_sectionStats);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x168(%rdi), %rdi
callq 0x401f6
cmpb $0x1, 0x78(%r14)
jne 0x369cf
movq %rbx, %rdi
callq 0x36888
leaq -0x48(%rbp), %rdi
pushq $0x12
popq %rsi
callq 0x29a20
movq 0x18(%rbx), %rdi
movq 0x150(%rbx), %rax
subq 0x148(%rbx), %rax
pushq $0x50
popq %rcx
cqto
idivq %rcx
cmpq $0x2, %rax
leaq 0x3e0b0(%rip), %rax     # 0x74a33
leaq 0x3e0c3(%rip), %rsi     # 0x74a4d
cmovaeq %rax, %rsi
callq 0x24570
movq 0x18(%rbx), %rdi
leaq 0x3f5bf(%rip), %rsi     # 0x75f5d
callq 0x24570
leaq 0x8(%r14), %rsi
movq %rax, %rdi
callq 0x24510
leaq 0x3e0b3(%rip), %rsi     # 0x74a69
movq %rax, %rdi
callq 0x24570
movq %rax, %rdi
callq 0x242a0
leaq -0x48(%rbp), %rdi
callq 0x29ba2
movsd 0x70(%r14), %xmm0
movq 0x8(%rbx), %rdi
movsd %xmm0, -0x28(%rbp)
callq 0x34ff4
testb %al, %al
je 0x36a36
movq 0x18(%rbx), %r15
leaq -0x48(%rbp), %r12
movq %r12, %rdi
movsd -0x28(%rbp), %xmm0
callq 0x34f7d
movq %r15, %rdi
movq %r12, %rsi
callq 0x24510
leaq 0x3dfdb(%rip), %rsi     # 0x749e9
movq %rax, %rdi
callq 0x24570
addq $0x8, %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x24510
movq %rax, %rdi
callq 0x242a0
leaq -0x48(%rbp), %rdi
callq 0x24ad8
cmpb $0x1, 0x170(%rbx)
jne 0x36a46
movb $0x0, 0x170(%rbx)
addq $0x148, %rbx            # imm = 0x148
movq %rbx, %rdi
callq 0x48634
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x24ad8
jmp 0x36a7c
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x29ba2
movq %rbx, %rdi
callq 0x24950
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x88(%rdi)
jne 0x36b20
movq %rsi, %r14
movq %rbx, %rdi
callq 0x36b30
movq 0x18(%rbx), %rdi
leaq 0x3df8f(%rip), %rsi     # 0x74a6c
callq 0x24570
leaq 0x8(%r14), %rsi
movq %rax, %rdi
callq 0x24510
leaq 0x3df8b(%rip), %rsi     # 0x74a80
movq %rax, %rdi
callq 0x24570
addq $0x38, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x36b7a
movq 0x18(%rbx), %rdi
pushq $0xa
popq %rsi
callq 0x24670
movq %rax, %rdi
callq 0x242a0
addq $0x50, %rbx
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x5c6ea
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x28(%rsi), %r15
movq %r15, %rsi
callq 0x3717a
movq %r14, %rdi
movq %r15, %rsi
callq 0x36b7a
movq 0x18(%r14), %rdi
callq 0x242a0
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4027e
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x0, 0x48(%rdi)
jne 0x37515
movq %rbx, %rdi
callq 0x37546
cmpb $0x0, 0x88(%rbx)
jne 0x37526
movq %rbx, %rdi
callq 0x37676
cmpb $0x0, 0x170(%rbx)
jne 0x3753e
movq %rbx, %rdi
callq 0x376e2
movb $0x1, 0x170(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
pushq $0xa
popq %rsi
callq 0x24670
leaq 0x779f9(%rip), %rcx     # 0xaef60
cmpb $0x0, (%rcx)
jne 0x3758a
movaps 0x3ab0d(%rip), %xmm0    # 0x72080
movups %xmm0, 0x3f(%rcx)
movaps %xmm0, 0x30(%rcx)
movaps %xmm0, 0x20(%rcx)
movaps %xmm0, 0x10(%rcx)
movaps %xmm0, (%rcx)
movb $0x0, 0x4f(%rcx)
leaq 0x779cf(%rip), %rsi     # 0xaef60
movq %rax, %rdi
callq 0x24570
pushq $0xa
popq %rsi
movq %rax, %rdi
callq 0x24670
leaq -0x11(%rbp), %rdi
pushq $0x17
popq %rsi
callq 0x29a20
movq 0x18(%rbx), %rdi
movq 0x20(%rbx), %rsi
callq 0x24510
leaq 0x3d4c0(%rip), %rsi     # 0x74a84
movq %rax, %rdi
callq 0x24570
movq %rax, %r14
callq 0x30104
leaq 0x7781d(%rip), %rsi     # 0xaedf8
movq %r14, %rdi
callq 0x30076
leaq 0x3d4a8(%rip), %rsi     # 0x74a92
movq %r14, %rdi
callq 0x24570
leaq 0x3d4ad(%rip), %rsi     # 0x74aa6
movq %rax, %rdi
callq 0x24570
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *0x88(%rax)
testl %eax, %eax
je 0x3764b
movq 0x18(%rbx), %rdi
leaq 0x3d4a3(%rip), %rsi     # 0x74ac0
callq 0x24570
movq %rax, %r14
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *0x88(%rax)
movl %eax, %esi
movq %r14, %rdi
callq 0x243c0
leaq 0x45b9a(%rip), %rsi     # 0x7d1dd
movq %rax, %rdi
callq 0x24570
movb $0x1, 0x48(%rbx)
leaq -0x11(%rbp), %rdi
callq 0x29ba2
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x11(%rbp), %rdi
callq 0x29ba2
movq %rbx, %rdi
callq 0x24950
nop
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::ConsoleReporter::printTestCaseAndSectionHeader()
void ConsoleReporter::printTestCaseAndSectionHeader() {
    assert(!m_sectionStack.empty());
    printOpenHeader(currentTestCaseInfo->name);

    if (m_sectionStack.size() > 1) {
        Colour colourGuard(Colour::Headers);

        auto
            it = m_sectionStack.begin() + 1, // Skip first section (test case)
            itEnd = m_sectionStack.end();
        for (; it != itEnd; ++it)
            printHeaderString(it->name, 2);
    }

    SourceLineInfo lineInfo = m_sectionStack.back().lineInfo;

    stream << getLineOfChars<'-'>() << '\n';
    Colour colourGuard(Colour::FileName);
    stream << lineInfo << '\n';
    stream << getLineOfChars<'.'>() << '\n' << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq 0x148(%rdi), %rax
cmpq 0x150(%rdi), %rax
je 0x37855
movq %rdi, %rbx
movq 0x90(%rdi), %rsi
callq 0x378ec
movq 0x150(%rbx), %rcx
movq %rcx, %rax
subq 0x148(%rbx), %rax
pushq $0x50
popq %rsi
cqto
idivq %rsi
cmpq $0x2, %rax
jb 0x3777e
leaq -0x40(%rbp), %rdi
pushq $0x1
popq %rsi
callq 0x29a20
movq 0x148(%rbx), %rsi
movq 0x150(%rbx), %r15
addq $0x50, %rsi
pushq $0x2
popq %r14
cmpq %r15, %rsi
je 0x3776e
leaq 0x50(%rsi), %r12
movq %rbx, %rdi
movq %r14, %rdx
callq 0x37982
movq %r12, %rsi
jmp 0x37755
leaq -0x40(%rbp), %rdi
callq 0x29ba2
movq 0x150(%rbx), %rcx
movups -0x10(%rcx), %xmm0
movaps %xmm0, -0x40(%rbp)
movq 0x18(%rbx), %rdi
leaq 0x7777f(%rip), %rax     # 0xaef10
cmpb $0x0, (%rax)
jne 0x377b4
movaps 0x3a8d3(%rip), %xmm0    # 0x72070
movups %xmm0, 0x3f(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movb $0x0, 0x4f(%rax)
leaq 0x77755(%rip), %rsi     # 0xaef10
callq 0x24570
pushq $0xa
popq %rsi
movq %rax, %rdi
callq 0x24670
leaq -0x21(%rbp), %rdi
pushq $0x17
popq %rsi
callq 0x29a20
movq 0x18(%rbx), %r14
leaq -0x40(%rbp), %rsi
movq %r14, %rdi
callq 0x2921b
pushq $0xa
popq %rsi
movq %r14, %rdi
callq 0x24670
movq 0x18(%rbx), %rdi
leaq 0x777b3(%rip), %rax     # 0xaefb0
cmpb $0x0, (%rax)
jne 0x37820
movaps 0x3a887(%rip), %xmm0    # 0x72090
movups %xmm0, 0x3f(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movb $0x0, 0x4f(%rax)
leaq 0x77789(%rip), %rsi     # 0xaefb0
callq 0x24570
pushq $0xa
popq %rsi
movq %rax, %rdi
callq 0x24670
movq %rax, %rdi
callq 0x242a0
leaq -0x21(%rbp), %rdi
callq 0x29ba2
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3d283(%rip), %rdi     # 0x74adf
leaq 0x3c64a(%rip), %rsi     # 0x73ead
leaq 0x3d28d(%rip), %rcx     # 0x74af7
movl $0x40ff, %edx           # imm = 0x40FF
callq 0x24390
movq %rax, %rbx
leaq -0x21(%rbp), %rdi
jmp 0x37884
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x29ba2
movq %rbx, %rdi
callq 0x24950
nop
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x3ccae(%rip), %rsi     # 0x74651
xorl %r12d, %r12d
movq %r14, %rdi
xorl %edx, %edx
callq 0x24a80
leaq 0x2(%rax), %r13
cmpq $-0x1, %rax
cmoveq %r12, %r13
movq 0x18(%r15), %r15
leaq -0x58(%rbp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x3e2d8
addq %rbx, %r13
movq %r13, 0x20(%r12)
movq %rbx, 0x28(%r12)
movq %r15, %rdi
movq %r12, %rsi
callq 0x3e20a
pushq $0xa
popq %rsi
movq %rax, %rdi
callq 0x24670
leaq -0x58(%rbp), %rdi
callq 0x3f34e
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x3f34e
movq %rbx, %rdi
callq 0x24950
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::ConsoleReporter::printSummaryRow(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<Catch::SummaryColumn, std::allocator<Catch::SummaryColumn>> const&, unsigned long)
void ConsoleReporter::printSummaryRow(std::string const& label, std::vector<SummaryColumn> const& cols, std::size_t row) {
    for (auto col : cols) {
        std::string value = col.rows[row];
        if (col.label.empty()) {
            stream << label << ": ";
            if (value != "0")
                stream << value;
            else
                stream << Colour(Colour::Warning) << "- none -";
        } else if (value != "0") {
            stream << Colour(Colour::LightGrey) << " | ";
            stream << Colour(col.colour)
                << value << ' ' << col.label;
        }
    }
    stream << '\n';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, -0x40(%rbp)
movq %rdi, -0x38(%rbp)
movq (%rdx), %r12
movq 0x8(%rdx), %rax
movq %rax, -0x50(%rbp)
leaq -0x90(%rbp), %r14
shlq $0x5, %rcx
movq %rcx, -0x48(%rbp)
leaq -0xb0(%rbp), %r15
cmpq -0x50(%rbp), %r12
je 0x37b8b
movq %r14, %rdi
movq %r12, %rsi
callq 0x4046c
movq -0x68(%rbp), %rsi
addq -0x48(%rbp), %rsi
movq %r15, %rdi
callq 0x24760
cmpq $0x0, -0x88(%rbp)
je 0x37b06
movq %r15, %rdi
leaq 0x3f054(%rip), %rsi     # 0x76ae8
callq 0x404ad
testb %al, %al
je 0x37b72
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rbx
leaq -0x29(%rbp), %rdi
pushq $0x17
popq %rsi
callq 0x29a20
movq %rbx, %rdi
leaq 0x3d0d4(%rip), %rsi     # 0x74b93
callq 0x24570
leaq -0x29(%rbp), %r13
movq %r13, %rdi
callq 0x29ba2
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rbx
movl -0x70(%rbp), %esi
movq %r13, %rdi
callq 0x29a20
movq %rbx, %rdi
movq %r15, %rsi
callq 0x24510
movq %rax, %rdi
pushq $0x20
popq %rsi
callq 0x24670
movq %rax, %rdi
movq %r14, %rsi
callq 0x24510
jmp 0x37b69
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x40(%rbp), %rsi
callq 0x24510
movq %rax, %rdi
leaq 0x3cb30(%rip), %rsi     # 0x74651
callq 0x24570
movq %r15, %rdi
leaq 0x3efb8(%rip), %rsi     # 0x76ae8
callq 0x404ad
movq -0x38(%rbp), %rcx
movq 0x18(%rcx), %rbx
testb %al, %al
je 0x37b4e
movq %rbx, %rdi
movq %r15, %rsi
callq 0x24510
jmp 0x37b72
leaq -0x29(%rbp), %rdi
pushq $0x16
popq %rsi
callq 0x29a20
movq %rbx, %rdi
leaq 0x3d026(%rip), %rsi     # 0x74b8a
callq 0x24570
leaq -0x29(%rbp), %rdi
callq 0x29ba2
movq %r15, %rdi
callq 0x24ad8
movq %r14, %rdi
callq 0x40420
addq $0x40, %r12
jmp 0x37a5b
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rdi
pushq $0xa
popq %rsi
callq 0x24670
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x37bbc
jmp 0x37bb7
jmp 0x37bb7
jmp 0x37bbc
jmp 0x37bb7
movq %rax, %rbx
jmp 0x37bc8
movq %rax, %rbx
leaq -0x29(%rbp), %rdi
callq 0x29ba2
leaq -0xb0(%rbp), %rdi
callq 0x24ad8
jmp 0x37bd9
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
callq 0x40420
movq %rbx, %rdi
callq 0x24950
nop
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x24080
movq %rax, 0x120(%rbx)
andq $0x0, 0x130(%rbx)
movq 0x128(%rbx), %rax
xorl %ecx, %ecx
movb %cl, (%rax)
andq $0x0, 0x150(%rbx)
movq 0x148(%rbx), %rax
movb %cl, (%rax)
andl $0x0, 0x168(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::XmlReporter::testCaseStarting(Catch::TestCaseInfo const&)
void XmlReporter::testCaseStarting( TestCaseInfo const& testInfo ) {
        StreamingReporterBase::testCaseStarting(testInfo);
        m_xml.startElement( "TestCase" )
            .writeAttribute( "name", trim( testInfo.name ) )
            .writeAttribute( "description", testInfo.description )
            .writeAttribute( "tags", testInfo.tagsAsString() );

        writeSourceInfo( testInfo.lineInfo );

        if ( m_config->showDurations() == ShowDurations::Always )
            m_testCaseTimer.start();
        m_xml.ensureTagClosed();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd0, %rsp
movq %rsi, %r15
movq %rdi, %rbx
addq $0x90, %rdi
callq 0x5e780
leaq 0x170(%rbx), %r14
leaq 0x3b2f9(%rip), %rsi     # 0x74dfb
leaq -0xe8(%rbp), %r12
leaq -0x24(%rbp), %rdx
movq %r12, %rdi
callq 0x24210
pushq $0x3
popq %rdx
movq %r14, %rdi
movq %r12, %rsi
callq 0x34c68
leaq 0x39dc7(%rip), %rsi     # 0x738f1
leaq -0xc8(%rbp), %rdi
leaq -0x23(%rbp), %rdx
callq 0x24210
leaq -0xa8(%rbp), %rdi
movq %r15, %rsi
callq 0x29499
leaq -0xc8(%rbp), %rsi
leaq -0xa8(%rbp), %rdx
movq %r14, %rdi
callq 0x34d7a
leaq 0x3b29e(%rip), %rsi     # 0x74e04
leaq -0x88(%rbp), %rdi
leaq -0x22(%rbp), %rdx
callq 0x24210
leaq 0x40(%r15), %rdx
leaq -0x88(%rbp), %rsi
movq %r14, %rdi
callq 0x34d7a
leaq 0x42cc3(%rip), %rsi     # 0x7c853
leaq -0x68(%rbp), %rdi
leaq -0x21(%rbp), %rdx
callq 0x24210
leaq -0x48(%rbp), %rdi
movq %r15, %rsi
callq 0x2b37c
leaq -0x68(%rbp), %rsi
leaq -0x48(%rbp), %rdx
movq %r14, %rdi
callq 0x34d7a
leaq -0x48(%rbp), %rdi
callq 0x24ad8
leaq -0x68(%rbp), %rdi
callq 0x24ad8
leaq -0x88(%rbp), %rdi
callq 0x24ad8
leaq -0xa8(%rbp), %rdi
callq 0x24ad8
leaq -0xc8(%rbp), %rdi
callq 0x24ad8
leaq -0xe8(%rbp), %rdi
callq 0x24ad8
addq $0x90, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x39730
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *0x58(%rax)
cmpl $0x1, %eax
jne 0x39c28
callq 0x24080
movq %rax, 0x168(%rbx)
movq %r14, %rdi
callq 0x34ce8
addq $0xd0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x24ad8
jmp 0x39c51
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x24ad8
jmp 0x39c61
jmp 0x39c5e
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x24ad8
jmp 0x39c74
jmp 0x39c71
movq %rax, %rbx
leaq -0xa8(%rbp), %rdi
callq 0x24ad8
leaq -0xc8(%rbp), %rdi
callq 0x24ad8
jmp 0x39c98
movq %rax, %rbx
jmp 0x39c80
jmp 0x39c95
movq %rax, %rbx
leaq -0xe8(%rbp), %rdi
callq 0x24ad8
movq %rbx, %rdi
callq 0x24950
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rsi, %rbx
movq %rdi, %r14
addq $0x148, %rdi            # imm = 0x148
callq 0x5cb32
movl 0x1b8(%r14), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x1b8(%r14)
testl %eax, %eax
jle 0x39d7a
leaq 0x170(%r14), %r15
leaq 0x3ce88(%rip), %rsi     # 0x76b7c
leaq -0x88(%rbp), %r12
leaq -0x22(%rbp), %rdx
movq %r12, %rdi
callq 0x24210
pushq $0x3
popq %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x34c68
leaq 0x39bd5(%rip), %rsi     # 0x738f1
leaq -0x68(%rbp), %rdi
leaq -0x21(%rbp), %rdx
callq 0x24210
leaq -0x48(%rbp), %rdi
movq %rbx, %rsi
callq 0x29499
leaq -0x68(%rbp), %rsi
leaq -0x48(%rbp), %rdx
movq %r15, %rdi
callq 0x34d7a
leaq -0x48(%rbp), %rdi
callq 0x24ad8
leaq -0x68(%rbp), %rdi
callq 0x24ad8
leaq -0x88(%rbp), %rdi
callq 0x24ad8
addq $0x40, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x39730
movq %r15, %rdi
callq 0x34ce8
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x24ad8
jmp 0x39d98
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x24ad8
jmp 0x39da8
jmp 0x39da5
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x24ad8
movq %rbx, %rdi
callq 0x24950
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::XmlReporter::sectionEnded(Catch::SectionStats const&)
void XmlReporter::sectionEnded( SectionStats const& sectionStats ) {
        StreamingReporterBase::sectionEnded( sectionStats );
        if( --m_sectionDepth > 0 ) {
            XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResults" );
            e.writeAttribute( "successes", sectionStats.assertions.passed );
            e.writeAttribute( "failures", sectionStats.assertions.failed );
            e.writeAttribute( "expectedFailures", sectionStats.assertions.failedButOk );

            if ( m_config->showDurations() == ShowDurations::Always )
                e.writeAttribute( "durationInSeconds", sectionStats.durationInSeconds );

            m_xml.endElement();
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %r15
addq $0x148, %rdi            # imm = 0x148
callq 0x48634
movl 0x1b8(%r15), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0x1b8(%r15)
cmpl $0x2, %eax
jl 0x3a4b0
leaq 0x3aabe(%rip), %rsi     # 0x74e60
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x24210
leaq 0x170(%r15), %r14
leaq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rdx
pushq $0x3
popq %rcx
movq %r14, %rsi
callq 0x34d2e
leaq -0x40(%rbp), %rdi
callq 0x24ad8
leaq 0x3aa96(%rip), %rsi     # 0x74e6f
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x24210
leaq 0x58(%rbx), %rdx
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x4091c
leaq -0x40(%rbp), %rdi
callq 0x24ad8
leaq 0x39515(%rip), %rsi     # 0x7391c
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x24210
leaq 0x60(%rbx), %rdx
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x4091c
leaq -0x40(%rbp), %rdi
callq 0x24ad8
leaq 0x3aa44(%rip), %rsi     # 0x74e79
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x24210
leaq 0x68(%rbx), %rdx
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x4091c
leaq -0x40(%rbp), %rdi
callq 0x24ad8
movq 0x8(%r15), %rdi
movq (%rdi), %rax
callq *0x58(%rax)
cmpl $0x1, %eax
jne 0x3a49c
leaq 0x3aa18(%rip), %rsi     # 0x74e8a
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x24210
addq $0x70, %rbx
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movq %rbx, %rdx
callq 0x5e7d6
leaq -0x40(%rbp), %rdi
callq 0x24ad8
pushq $0x3
popq %rsi
movq %r14, %rdi
callq 0x349be
leaq -0x50(%rbp), %rdi
callq 0x34a94
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3a4c7
jmp 0x3a4ea
jmp 0x3a4c7
jmp 0x3a4ea
jmp 0x3a4c7
jmp 0x3a4ea
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x24ad8
jmp 0x3a4ed
jmp 0x3a4ea
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x24ad8
jmp 0x3a4f6
movq %rax, %rbx
jmp 0x3a4f6
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x34a94
movq %rbx, %rdi
callq 0x24950
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq 0x20(%rdi), %rsi
movq 0x28(%rdi), %rdx
cmpq %rdx, %rsi
je 0x3b05a
movq %rdi, %rbx
leaq -0x20(%rbp), %rax
movq %rax, -0x10(%rax)
leaq -0x30(%rbp), %r14
movq %r14, %rdi
callq 0x419f4
movq %r14, %rdi
callq 0x29d05
leaq -0x30(%rbp), %rdi
callq 0x24ad8
movq 0x20(%rbx), %rax
movq %rax, 0x28(%rbx)
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x24ad8
movq %rbx, %rdi
callq 0x24950
nop
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %esi, %ebx
movq %rdi, %r14
movq (%rdi), %rax
callq *0x30(%rax)
cmpl $-0x1, %ebx
je 0x3b0d7
movq 0x20(%r14), %rax
cmpq 0x30(%r14), %rax
je 0x3b0ac
movsbl %bl, %esi
movq %r14, %rdi
callq 0x24230
jmp 0x3b0d7
leaq -0x20(%rbp), %rax
movq %rax, -0x10(%rax)
movsbl %bl, %edx
leaq -0x30(%rbp), %rbx
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x24660
movq %rbx, %rdi
callq 0x29d05
leaq -0x30(%rbp), %rdi
callq 0x24ad8
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x24ad8
movq %rbx, %rdi
callq 0x24950
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::(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
pushq %r14
pushq %rbx
subq $0x10, %rsp
cmpq $0x0, 0x8(%rdx)
je 0x3b17f
movq %rdx, %r14
movq %rdi, %rbx
leaq -0x11(%rbp), %rdi
callq 0x29a20
movq (%rbx), %rdi
pushq $0x20
popq %rsi
callq 0x24670
movq %rax, %rdi
movq %r14, %rsi
callq 0x24510
leaq -0x11(%rbp), %rdi
callq 0x29ba2
movq (%rbx), %rdi
pushq $0x3a
popq %rsi
callq 0x24670
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x11(%rbp), %rdi
callq 0x29ba2
movq %rbx, %rdi
callq 0x24950
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::(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
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x25ebc
testb %al, %al
je 0x3b26a
leaq -0x30(%rbp), %rdi
pushq $0x17
popq %rsi
callq 0x29a20
movq (%rbx), %rdi
leaq 0x3ab3a(%rip), %rsi     # 0x75d6f
callq 0x24570
leaq -0x30(%rbp), %rdi
callq 0x29ba2
movq (%rbx), %r14
movq 0x8(%rbx), %rsi
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x25f36
movq %r14, %rdi
movq %rbx, %rsi
callq 0x24510
leaq -0x30(%rbp), %rdi
callq 0x24ad8
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x24ad8
jmp 0x3b28d
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x29ba2
movq %rbx, %rdi
callq 0x24950
nop
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::(anonymous namespace)::AssertionPrinter::printRemainingMessages(Catch::Colour::Code)
void printRemainingMessages(Colour::Code colour = dimColour()) {
        if (itMessage == messages.end())
            return;

        const auto itEnd = messages.cend();
        const auto N = static_cast<std::size_t>(std::distance(itMessage, itEnd));

        {
            Colour colourGuard(colour);
            stream << " with " << pluralise(N, "message") << ':';
        }

        while (itMessage != itEnd) {
            // If this assertion is a warning ignore any INFO messages
            if (printInfoMessages || itMessage->type != ResultWas::Info) {
                printMessage();
                if (itMessage != itEnd) {
                    Colour colourGuard(dimColour());
                    stream << " and";
                }
                continue;
            }
            ++itMessage;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq 0x18(%rdi), %r13
movq 0x28(%rdi), %rcx
cmpq %r13, %rcx
je 0x3b399
movq %rdi, %rbx
movq %r13, %rax
subq %rcx, %rax
pushq $0x48
popq %rcx
cqto
idivq %rcx
movq %rax, %r15
leaq -0x29(%rbp), %rdi
callq 0x29a20
movq (%rbx), %rdi
leaq 0x3fd1a(%rip), %rsi     # 0x7aff9
callq 0x24570
movq %rax, %r14
leaq 0x3ac25(%rip), %rsi     # 0x75f13
leaq -0x78(%rbp), %rdi
leaq -0x2a(%rbp), %rdx
callq 0x24210
leaq -0x58(%rbp), %rdi
leaq -0x78(%rbp), %rdx
movq %r15, %rsi
callq 0x310bc
leaq -0x58(%rbp), %rsi
movq %r14, %rdi
callq 0x2b42c
pushq $0x3a
popq %rsi
movq %r14, %rdi
callq 0x24670
leaq -0x50(%rbp), %rdi
callq 0x24ad8
leaq -0x78(%rbp), %rdi
callq 0x24ad8
leaq -0x29(%rbp), %rdi
callq 0x29ba2
leaq -0x58(%rbp), %r14
pushq $0x17
popq %r15
leaq 0x3aa2a(%rip), %r12     # 0x75d76
movq 0x28(%rbx), %rax
cmpq %r13, %rax
je 0x3b399
cmpb $0x0, 0x30(%rbx)
jne 0x3b36b
cmpl $0x1, 0x40(%rax)
jne 0x3b36b
addq $0x48, %rax
movq %rax, 0x28(%rbx)
jmp 0x3b34c
movq %rbx, %rdi
callq 0x3b40a
cmpq %r13, 0x28(%rbx)
je 0x3b34c
movq %r14, %rdi
movl %r15d, %esi
callq 0x29a20
movq (%rbx), %rdi
movq %r12, %rsi
callq 0x24570
movq %r14, %rdi
callq 0x29ba2
jmp 0x3b34c
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x3b3c0
jmp 0x3b3af
movq %rax, %rbx
jmp 0x3b3c9
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x24ad8
leaq -0x78(%rbp), %rdi
callq 0x24ad8
leaq -0x29(%rbp), %rdi
jmp 0x3b3d6
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x29ba2
movq %rbx, %rdi
callq 0x24950
nop