LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x38(%rbp), %r15
movq %r15, %rdi
callq 0x2d4f4
movq 0x10(%r15), %rdi
movq %r14, %rsi
callq 0x1b340
cmpq $0x100, %r14            # imm = 0x100
jb 0x31a8f
movq -0x28(%rbp), %rdi
leaq 0x4aec3(%rip), %rsi     # 0x7c912
movl $0x4, %edx
callq 0x1b5e0
movq -0x28(%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 0x1b340
movq -0x28(%rbp), %rdi
leaq -0x19(%rbp), %rsi
movb $0x29, (%rsi)
movl $0x1, %edx
callq 0x1b5e0
movq -0x28(%rbp), %rsi
addq $0x8, %rsi
movq %rbx, %rdi
callq 0x1b7f0
leaq -0x38(%rbp), %rdi
callq 0x2d53a
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x31ab8
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x2d53a
movq %rbx, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leal -0x9(%rsi), %eax
cmpl $0x4, %eax
ja 0x31ba0
leaq 0x48673(%rip), %rcx     # 0x7a19c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x4adf1(%rip), %rsi     # 0x7c931
leaq 0x4adee(%rip), %rdx     # 0x7c935
jmp 0x31b8c
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x4add0(%rip), %rsi     # 0x7c927
leaq 0x4adcd(%rip), %rdx     # 0x7c92b
jmp 0x31b8c
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x4adbe(%rip), %rsi     # 0x7c92c
leaq 0x4adbb(%rip), %rdx     # 0x7c930
jmp 0x31b8c
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x4ad9d(%rip), %rsi     # 0x7c922
leaq 0x4ad9a(%rip), %rdx     # 0x7c926
movq %rbx, %rdi
callq 0x43438
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
cmpb $0x1f, %sil
ja 0x31bb3
movslq %esi, %rsi
movq %rbx, %rdi
callq 0x31a10
jmp 0x31b94
leaq -0x14(%rbp), %r14
movl $0x272027, (%r14)       # imm = 0x272027
movb %sil, 0x1(%r14)
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x1b220
leaq (%rax,%rbp), %rdx
addq $-0x14, %rdx
movq %rbx, %rdi
movq %r14, %rsi
jmp 0x31b8f
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, %rbx
leaq 0x76620(%rip), %rcx     # 0xa8540
addq $0x10, %rcx
movq %rcx, (%rdi)
movl %edx, 0x8(%rdi)
movl $0x0, 0xc(%rdi)
leaq 0x10(%rdi), %r14
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x32004
cmpq $0x0, 0x18(%rbx)
je 0x31f91
movq (%r14), %rax
cmpb $0x2a, (%rax)
jne 0x31f91
leaq -0x38(%rbp), %rdi
movl $0x1, %edx
movq %r14, %rsi
movq $-0x1, %rcx
callq 0x1b580
leaq -0x38(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x1b640
movq (%r15), %rdi
leaq -0x28(%rbp), %rax
cmpq %rax, %rdi
je 0x31f8a
callq 0x1b4d0
movl $0x1, 0xc(%rbx)
movq 0x18(%rbx), %rcx
testq %rcx, %rcx
je 0x31fd9
movq (%r14), %rax
cmpb $0x2a, -0x1(%rax,%rcx)
jne 0x31fd9
decq %rcx
leaq -0x38(%rbp), %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x1b580
leaq -0x38(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x1b640
movq (%r15), %rdi
leaq -0x28(%rbp), %rax
cmpq %rax, %rdi
je 0x31fd5
callq 0x1b4d0
orb $0x2, 0xc(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x31fe6
movq %rax, %r14
movq 0x10(%rbx), %rdi
addq $0x20, %rbx
cmpq %rbx, %rdi
je 0x31ffb
callq 0x1b4d0
movq %r14, %rdi
callq 0x1b910
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
movq (%rdi), %rax
movq -0x18(%rax), %rax
movl 0x18(%rdi,%rax), %r12d
leaq 0x4b8cf(%rip), %rsi     # 0x7dd35
movl $0x2, %edx
callq 0x1b5e0
movq (%rbx), %rax
movq -0x18(%rax), %rcx
orl $0x4000, 0x18(%rbx,%rcx) # imm = 0x4000
movq -0x18(%rax), %rcx
movl 0x18(%rbx,%rcx), %edx
andl $-0x4b, %edx
orl $0x8, %edx
movl %edx, 0x18(%rbx,%rcx)
movq -0x18(%rax), %rax
leaq (%rbx,%rax), %r15
cmpb $0x0, 0xe1(%rbx,%rax)
jne 0x324bf
movq %r15, %rdi
movl $0x20, %esi
callq 0x1b4f0
movb %al, 0xe0(%r15)
movb $0x1, 0xe1(%r15)
movb $0x30, 0xe0(%r15)
movq (%rbx), %rax
movq -0x18(%rax), %rax
movq $0x2, 0x10(%rbx,%rax)
movzbl %r14b, %esi
movq %rbx, %rdi
callq 0x1b8c0
movq (%rbx), %rax
movq -0x18(%rax), %rax
movl %r12d, 0x18(%rbx,%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x32561
movl $0x3, %esi
callq 0x3258e
movq (%r14), %rax
movq %rax, (%rbx)
movq $0x0, (%r14)
movl 0x8(%r14), %eax
movl %eax, 0x8(%rbx)
movl $0x0, 0x8(%r14)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rdi
callq 0x3ec84
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1b580
movq %r15, %rdi
movq %r12, %rsi
callq 0x1b640
movq (%r12), %rdi
leaq -0x30(%rbp), %rax
cmpq %rax, %rdi
je 0x325dd
callq 0x1b4d0
cmpb $0x1, (%rbx)
jne 0x325fc
movq 0x40(%rbx), %rdi
leaq 0x4a36f(%rip), %rsi     # 0x7c95c
movl $0x2, %edx
callq 0x1b5e0
movb $0x0, (%rbx)
jmp 0x3265b
movq %rbx, %rdi
callq 0x3287c
testb $0x1, %r14b
je 0x3261b
movq 0x40(%rbx), %rdi
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdx
callq 0x1b5e0
movq 0x40(%rbx), %r15
leaq 0x4a339(%rip), %rsi     # 0x7c95f
movl $0x2, %edx
movq %r15, %rdi
callq 0x1b5e0
movq 0x10(%rbx), %rax
movq -0x20(%rax), %rsi
movq -0x18(%rax), %rdx
movq %r15, %rdi
callq 0x1b5e0
leaq 0x4a31b(%rip), %rsi     # 0x7c969
movl $0x1, %edx
movq %rax, %rdi
callq 0x1b5e0
movq 0x40(%rbx), %rdi
callq 0x1b360
shrb %r14b
andb $0x1, %r14b
movb %r14b, 0x1(%rbx)
movq 0x10(%rbx), %rax
leaq -0x20(%rax), %rcx
movq %rcx, 0x10(%rbx)
movq -0x20(%rax), %rdi
addq $-0x10, %rax
cmpq %rax, %rdi
je 0x3268d
callq 0x1b4d0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x32761
movl %edx, %r14d
movq %rsi, %r15
movb (%rbx), %r12b
movq %rbx, %rdi
callq 0x3295a
testb $0x1, %r14b
je 0x32724
testb %r12b, %r12b
je 0x32724
movq 0x40(%rbx), %rdi
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdx
callq 0x1b5e0
movq 0x40(%rbx), %r12
leaq -0x50(%rbp), %r13
movq %r13, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x32098
movq %r13, %rdi
movq %r12, %rsi
callq 0x320c6
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x32756
callq 0x1b4d0
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 -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x32788
callq 0x1b4d0
movq %rbx, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O1/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
subq $0x10, %rsp
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
callq 0x3295a
movq %r14, %rdi
callq 0x3287c
testb $0x1, %bl
je 0x3290d
movq 0x40(%r14), %rdi
leaq 0x20(%r14), %r12
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
callq 0x1b5e0
leaq 0x519d6(%rip), %rsi     # 0x842db
movq %r12, %rdi
callq 0x1b9d0
movq 0x40(%r14), %rdi
leaq -0x21(%rbp), %rsi
movb $0x3c, (%rsi)
movl $0x1, %edx
callq 0x1b5e0
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rax, %rdi
callq 0x1b5e0
leaq 0x8(%r14), %rdi
movq %r15, %rsi
callq 0x3ff26
movb $0x1, (%r14)
shrb %bl
andb $0x1, %bl
movb %bl, 0x1(%r14)
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x32996
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x40(%rdi), %rdi
leaq -0x9(%rbp), %rsi
movb $0x3e, (%rsi)
movl $0x1, %edx
callq 0x1b5e0
movq %rax, %rdi
callq 0x1b360
movq %rbx, %rdi
callq 0x3287c
movb $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
callq 0x3295a
testb $0x1, %bl
je 0x32b94
movq 0x40(%r14), %rdi
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
callq 0x1b5e0
movq 0x40(%r14), %r12
leaq 0x49dc3(%rip), %rsi     # 0x7c962
movl $0x4, %edx
movq %r12, %rdi
callq 0x1b5e0
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r12, %rdi
callq 0x1b5e0
leaq 0x49da5(%rip), %rsi     # 0x7c967
movl $0x3, %edx
movq %rax, %rdi
callq 0x1b5e0
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_O1/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 -0x14(%rbp), %rdi
callq 0x243a2
leaq 0x49d0a(%rip), %rsi     # 0x7c9bb
leaq -0x160(%rbp), %r14
movq %r14, %rdi
movsd -0x20(%rbp), %xmm0
movb $0x1, %al
callq 0x1b0f0
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x1b220
leaq (%rax,%rbp), %rdx
addq $-0x160, %rdx           # imm = 0xFEA0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x43438
leaq -0x14(%rbp), %rdi
callq 0x243bc
movq %rbx, %rax
addq $0x150, %rsp            # imm = 0x150
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x14(%rbp), %rdi
callq 0x243bc
movq %rbx, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O1/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 0x32d6a
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x58(%rax)
cmpl $0x2, %eax
jne 0x32d4a
xorl %eax, %eax
jmp 0x32d6a
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_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x48(%rbp), %rdi
callq 0x2d4f4
movq (%r14), %r15
movq 0x8(%r14), %r12
cmpq %r12, %r15
je 0x32ddf
movb $0x1, %r13b
leaq -0x29(%rbp), %r14
testb $0x1, %r13b
je 0x32db1
xorl %r13d, %r13d
jmp 0x32dc6
movq -0x38(%rbp), %rdi
movb $0x20, -0x29(%rbp)
movl $0x1, %edx
movq %r14, %rsi
callq 0x1b5e0
movq -0x38(%rbp), %rdi
movq (%r15), %rsi
movq 0x8(%r15), %rdx
callq 0x1b5e0
addq $0x20, %r15
cmpq %r12, %r15
jne 0x32da6
movq -0x38(%rbp), %rsi
addq $0x8, %rsi
movq %rbx, %rdi
callq 0x1b7f0
leaq -0x48(%rbp), %rdi
callq 0x2d53a
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x32e0e
jmp 0x32e0e
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x2d53a
movq %rbx, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x1, 0x88(%rdi)
jne 0x352d1
movq %rsi, %r14
movq %rbx, %rdi
callq 0x35306
movq 0x18(%rbx), %r15
leaq 0x47842(%rip), %rsi     # 0x7ca94
movl $0x13, %edx
movq %r15, %rdi
callq 0x1b5e0
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
movq %r15, %rdi
callq 0x1b5e0
leaq 0x47832(%rip), %rsi     # 0x7caa8
movl $0x3, %edx
movq %rax, %rdi
callq 0x1b5e0
addq $0x38, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3537a
movq 0x18(%rbx), %rdi
leaq -0x19(%rbp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
callq 0x1b5e0
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x1b4f0
movsbl %al, %esi
movq %r14, %rdi
callq 0x1b040
movq %rax, %rdi
callq 0x1b360
movq 0x50(%rbx), %rax
testq %rax, %rax
je 0x352eb
movq (%rax), %rdi
addq $0x10, %rax
cmpq %rax, %rdi
je 0x352eb
callq 0x1b4d0
movq $0x0, 0x50(%rbx)
movb $0x0, 0x88(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x35d36
movq %r14, %rdi
movq %r15, %rsi
callq 0x3537a
movq 0x18(%r14), %r15
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x1b4f0
movsbl %al, %esi
movq %r15, %rdi
callq 0x1b040
movq %rax, %rdi
callq 0x1b360
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x40fe0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x361ad
movq %rbx, %rdi
callq 0x361de
cmpb $0x0, 0x88(%rbx)
jne 0x361be
movq %rbx, %rdi
callq 0x36354
cmpb $0x0, 0x170(%rbx)
jne 0x361d6
movq %rbx, %rdi
callq 0x363d2
movb $0x1, 0x170(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
leaq -0x1a(%rbp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
callq 0x1b5e0
movq %rax, %r14
leaq 0x76d16(%rip), %rax     # 0xacf20
cmpb $0x0, (%rax)
jne 0x3622d
movaps 0x43e6a(%rip), %xmm0    # 0x7a080
movups %xmm0, 0x3f(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movb $0x0, 0x4f(%rax)
leaq 0x76cec(%rip), %r15     # 0xacf20
movq %r15, %rdi
callq 0x1b220
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x1b5e0
leaq -0x1b(%rbp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %r14, %rdi
callq 0x1b5e0
leaq -0x19(%rbp), %rdi
movl $0x17, %esi
callq 0x238d4
movq 0x18(%rbx), %rdi
movq 0x20(%rbx), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
callq 0x1b5e0
movq %rax, %r14
leaq 0x46822(%rip), %rsi     # 0x7caac
movl $0xd, %edx
movq %rax, %rdi
callq 0x1b5e0
callq 0x2c231
leaq 0x76b15(%rip), %rsi     # 0xacdb8
movq %r14, %rdi
callq 0x2c147
leaq 0x46808(%rip), %rsi     # 0x7caba
movl $0x13, %edx
movq %r14, %rdi
callq 0x1b5e0
leaq 0x46808(%rip), %rsi     # 0x7cace
movl $0x19, %edx
movq %r14, %rdi
callq 0x1b5e0
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *0x88(%rax)
testl %eax, %eax
je 0x36327
movq 0x18(%rbx), %r14
leaq 0x467f9(%rip), %rsi     # 0x7cae8
movl $0x16, %edx
movq %r14, %rdi
callq 0x1b5e0
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *0x88(%rax)
movl %eax, %esi
movq %r14, %rdi
callq 0x1b350
leaq 0x4e867(%rip), %rsi     # 0x84b81
movl $0x2, %edx
movq %rax, %rdi
callq 0x1b5e0
movb $0x1, 0x48(%rbx)
leaq -0x19(%rbp), %rdi
callq 0x2397c
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x19(%rbp), %rdi
callq 0x2397c
movq %rbx, %rdi
callq 0x1b910
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x45f3c(%rip), %rsi     # 0x7c679
xorl %r12d, %r12d
movl $0x2, %ecx
movq %r14, %rdi
xorl %edx, %edx
callq 0x1b8d0
leaq 0x2(%rax), %r13
cmpq $-0x1, %rax
cmoveq %r12, %r13
movq 0x18(%r15), %r15
leaq -0x60(%rbp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x3f34a
addq %rbx, %r13
movq %r13, 0x20(%r12)
movq %rbx, 0x28(%r12)
movq %r15, %rdi
movq %r12, %rsi
callq 0x3f26b
leaq -0x29(%rbp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x1b5e0
leaq -0x60(%rbp), %rdi
callq 0x3ff72
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x3ff72
movq %rbx, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1b090
movq %rax, 0x120(%rbx)
xorl %eax, %eax
movq %rax, 0x130(%rbx)
movq 0x128(%rbx), %rcx
movb %al, (%rcx)
movq %rax, 0x150(%rbx)
movq 0x148(%rbx), %rcx
movb %al, (%rcx)
movl $0x0, 0x168(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, %r14
addq $0x148, %rdi            # imm = 0x148
callq 0x61928
movl 0x1b8(%r14), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x1b8(%r14)
testl %eax, %eax
jle 0x394b4
leaq 0x170(%r14), %r15
leaq -0x78(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x45806(%rip), %rsi     # 0x7ec10
leaq 0x45806(%rip), %rdx     # 0x7ec17
leaq -0x88(%rbp), %r12
movq %r12, %rdi
callq 0x43438
movq %r15, %rdi
movq %r12, %rsi
movl $0x3, %edx
callq 0x328c0
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x424d9(%rip), %rsi     # 0x7b919
leaq 0x424d6(%rip), %rdx     # 0x7b91d
leaq -0x48(%rbp), %rdi
callq 0x43438
leaq -0x68(%rbp), %rdi
movq %rbx, %rsi
callq 0x2326f
leaq -0x48(%rbp), %rsi
leaq -0x68(%rbp), %rdx
movq %r15, %rdi
callq 0x329f6
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3947e
callq 0x1b4d0
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x3948c
callq 0x1b4d0
movq -0x88(%rbp), %rdi
cmpq %r13, %rdi
je 0x3949d
callq 0x1b4d0
addq $0x40, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x38c80
movq %r15, %rdi
callq 0x3295a
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x394dd
callq 0x1b4d0
jmp 0x394dd
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x394f2
callq 0x1b4d0
jmp 0x394f2
jmp 0x394ef
movq %rax, %rbx
movq -0x88(%rbp), %rdi
cmpq %r13, %rdi
je 0x39503
callq 0x1b4d0
movq %rbx, %rdi
callq 0x1b910
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq 0x20(%rdi), %rsi
movq 0x28(%rdi), %rdx
cmpq %rdx, %rsi
je 0x3ad86
movq %rdi, %rbx
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x43438
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0x7122d(%rip), %rdi     # 0xabf98
callq 0x1b5e0
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x3ad7e
callq 0x1b4d0
movq 0x20(%rbx), %rax
movq %rax, 0x28(%rbx)
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x3ada4
callq 0x1b4d0
movq %rbx, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3ae1f
movq 0x30(%r14), %rax
cmpq %rax, 0x20(%r14)
je 0x3ade2
movq 0x28(%r14), %rcx
cmpq %rax, %rcx
jae 0x3ae2a
movb %bl, (%rcx)
incq 0x28(%r14)
jmp 0x3ae1f
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
movsbl %bl, %edx
leaq -0x30(%rbp), %rbx
movl $0x1, %esi
movq %rbx, %rdi
callq 0x1b610
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0x7118c(%rip), %rdi     # 0xabf98
callq 0x1b5e0
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x3ae1f
callq 0x1b4d0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movzbl %bl, %esi
movq (%r14), %rax
movq %r14, %rdi
callq *0x68(%rax)
jmp 0x3ae1f
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x3ae49
callq 0x1b4d0
movq %rbx, %rdi
callq 0x1b910
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3af5b
movq %rdx, %r14
movq %rdi, %rbx
leaq -0x11(%rbp), %rdi
callq 0x238d4
movq (%rbx), %rdi
leaq -0x12(%rbp), %rsi
movb $0x20, (%rsi)
movl $0x1, %edx
callq 0x1b5e0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rax, %rdi
callq 0x1b5e0
leaq -0x11(%rbp), %rdi
callq 0x2397c
movq (%rbx), %rdi
leaq -0x13(%rbp), %rsi
movb $0x3a, (%rsi)
movl $0x1, %edx
callq 0x1b5e0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x11(%rbp), %rdi
callq 0x2397c
movq %rbx, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1da92
testb %al, %al
je 0x3b07a
leaq -0x30(%rbp), %rdi
movl $0x17, %esi
callq 0x238d4
movq (%rbx), %rdi
leaq 0x42dc5(%rip), %rsi     # 0x7ddf8
movl $0x6, %edx
callq 0x1b5e0
leaq -0x30(%rbp), %rdi
callq 0x2397c
movq (%rbx), %r14
movq 0x8(%rbx), %rsi
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x1db3a
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x1b5e0
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3b07a
callq 0x1b4d0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3b0a6
callq 0x1b4d0
jmp 0x3b0a6
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x2397c
movq %rbx, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O1/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), %r12
movq 0x28(%rdi), %r13
cmpq %r12, %r13
je 0x3b1e6
movq %rdi, %rbx
leaq -0x29(%rbp), %rdi
callq 0x238d4
movq (%rbx), %r14
leaq 0x47dd7(%rip), %rsi     # 0x82ebd
movl $0x6, %edx
movq %r14, %rdi
callq 0x1b5e0
leaq -0x40(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x42e9a(%rip), %rsi     # 0x7df9c
leaq 0x42e9a(%rip), %rdx     # 0x7dfa3
leaq -0x50(%rbp), %rdi
callq 0x43438
movq %r12, %rax
subq %r13, %rax
sarq $0x3, %rax
movabsq $-0x71c71c71c71c71c7, %rsi # imm = 0x8E38E38E38E38E39
imulq %rax, %rsi
leaq -0x78(%rbp), %rdi
leaq -0x50(%rbp), %rdx
callq 0x2d8f6
leaq -0x78(%rbp), %rsi
movq %r14, %rdi
callq 0x25982
leaq -0x2a(%rbp), %rsi
movb $0x3a, (%rsi)
movl $0x1, %edx
movq %r14, %rdi
callq 0x1b5e0
leaq -0x60(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3b169
callq 0x1b4d0
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
je 0x3b177
callq 0x1b4d0
leaq -0x29(%rbp), %rdi
callq 0x2397c
movq 0x28(%rbx), %rax
cmpq %r12, %rax
je 0x3b1e6
leaq -0x78(%rbp), %r14
leaq 0x42c6b(%rip), %r15     # 0x7ddff
cmpb $0x0, 0x30(%rbx)
jne 0x3b1aa
cmpl $0x1, 0x40(%rax)
jne 0x3b1aa
addq $0x48, %rax
movq %rax, 0x28(%rbx)
jmp 0x3b1dd
movq %rbx, %rdi
callq 0x3b23e
cmpq %r12, 0x28(%rbx)
je 0x3b1dd
movq %r14, %rdi
movl $0x17, %esi
callq 0x238d4
movq (%rbx), %rdi
movl $0x4, %edx
movq %r15, %rsi
callq 0x1b5e0
movq %r14, %rdi
callq 0x2397c
movq 0x28(%rbx), %rax
cmpq %r12, %rax
jne 0x3b194
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x3b216
jmp 0x3b1fc
movq %rax, %rbx
jmp 0x3b224
movq %rax, %rbx
leaq -0x60(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3b216
callq 0x1b4d0
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
je 0x3b224
callq 0x1b4d0
leaq -0x29(%rbp), %rdi
jmp 0x3b231
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x2397c
movq %rbx, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq 0x8(%rdi), %rax
cmpq $0x0, 0x28(%rax)
je 0x3b2ff
movq %rdi, %rbx
movq (%rdi), %rdi
leaq -0xa(%rbp), %rsi
movb $0x3b, (%rsi)
movl $0x1, %edx
callq 0x1b5e0
leaq -0x9(%rbp), %rdi
movl $0x17, %esi
callq 0x238d4
movq (%rbx), %rdi
leaq 0x42b20(%rip), %rsi     # 0x7de04
movl $0x10, %edx
callq 0x1b5e0
leaq -0x9(%rbp), %rdi
callq 0x2397c
movq %rbx, %rdi
callq 0x3af78
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x9(%rbp), %rdi
callq 0x2397c
movq %rbx, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpq $0x0, 0x6fe05(%rip)     # 0xace00
jne 0x3d16a
movl $0x150, %edi            # imm = 0x150
callq 0x1b510
movq %rax, %rbx
leaq 0x6d013(%rip), %rax     # 0xaa028
movq %rax, (%rbx)
leaq 0x6d089(%rip), %rax     # 0xaa0a8
movq %rax, 0x8(%rbx)
leaq 0x6d0d6(%rip), %rax     # 0xaa100
movq %rax, 0x10(%rbx)
leaq 0x6c353(%rip), %rax     # 0xa9388
addq $0x10, %rax
movq %rax, 0x18(%rbx)
leaq 0x20(%rbx), %r14
leaq 0x40(%rbx), %r15
leaq 0x60(%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x2c(%rbx)
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x50(%rbx)
callq 0x1b7c0
leaq 0x6afb0(%rip), %rax     # 0xa8018
addq $0x10, %rax
movq %rax, 0x68(%rbx)
leaq 0x78(%rbx), %rcx
xorl %eax, %eax
movl %eax, 0x78(%rbx)
movq %rax, 0x80(%rbx)
movq %rcx, 0x88(%rbx)
movq %rcx, 0x90(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x98(%rbx)
movups %xmm0, 0xa8(%rbx)
leaq 0x6ab9a(%rip), %rcx     # 0xa7c40
addq $0x10, %rcx
movq %rcx, 0xb8(%rbx)
movups %xmm0, 0xc0(%rbx)
movq %rax, 0xd0(%rbx)
leaq 0x6b1b2(%rip), %rcx     # 0xa8278
addq $0x10, %rcx
movq %rcx, 0xd8(%rbx)
movl $0xe8, %ecx
leaq (%rbx,%rcx), %rdx
movl %eax, 0xe8(%rbx)
movq %rax, 0xf0(%rbx)
movq %rdx, 0xf8(%rbx)
movq %rdx, 0x100(%rbx)
movups %xmm0, 0x108(%rbx)
movups %xmm0, 0x118(%rbx)
leaq 0x6baf6(%rip), %rdx     # 0xa8c00
addq $0x10, %rdx
movq %rdx, 0x128(%rbx)
movq %rax, 0x140(%rbx)
movups %xmm0, 0x130(%rbx)
movq %rbx, %rdi
addq $0x148, %rdi            # imm = 0x148
leaq 0x6cd5c(%rip), %rax     # 0xa9e90
movq %rax, (%rbx)
leaq 0x6cd42(%rip), %rax     # 0xa9e80
leaq 0x6cdcb(%rip), %rdx     # 0xa9f10
movq %rdx, 0x8(%rbx)
addq %rcx, %rax
movq %rax, 0x10(%rbx)
leaq 0x6ce31(%rip), %rax     # 0xa9f88
movq %rax, 0x148(%rbx)
movq %rbx, 0x6fc9b(%rip)     # 0xace00
callq 0x2d44a
movq 0x6fc8f(%rip), %rax     # 0xace00
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
movq %r15, %rdi
callq 0x3f392
movq %r14, %rdi
callq 0x3f392
movq %rbx, %rdi
callq 0x1b4d0
movq %r12, %rdi
callq 0x1b910
nop
// File: /workspace/github_cpp_makefile_star2_O1/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::(anonymous namespace)::RegistryHub::registerStartupException()
void registerStartupException() noexcept override {
#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
                m_exceptionRegistry.add(std::current_exception());
#else
                CATCH_INTERNAL_ERROR("Attempted to register active exception under CATCH_CONFIG_DISABLE_EXCEPTIONS!");
#endif
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
addq $0x110, %rbx            # imm = 0x110
leaq -0x18(%rbp), %r14
movq %r14, %rdi
callq 0x1b5a0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2d4ac
cmpq $0x0, (%r14)
je 0x3d37b
leaq -0x18(%rbp), %rdi
callq 0x1b460
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::clara::detail::Help::Help(bool&)
Help( bool &showHelpFlag )
        :   Opt([&]( bool flag ) {
                showHelpFlag = flag;
                return ParserResult::ok( ParseResultType::ShortCircuitAll );
            })
        {
            static_cast<Opt &>( *this )
                    ("display usage information")
                    ["-?"]["-h"]["--help"]
                    .optional();
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
leaq -0x68(%rbp), %rax
movq %rsi, (%rax)
movq %rax, %rsi
callq 0x43d14
leaq 0x6c347(%rip), %rax     # 0xaa608
addq $0x10, %rax
movq %rax, (%rbx)
leaq -0x58(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x3ee0a(%rip), %rsi     # 0x7d0e2
leaq 0x3ee1c(%rip), %rdx     # 0x7d0fb
leaq -0x68(%rbp), %rdi
callq 0x43438
leaq 0x40(%rbx), %rdi
leaq -0x68(%rbp), %rsi
callq 0x1b290
leaq -0x98(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x3edf5(%rip), %rsi     # 0x7d0fc
leaq 0x3edf0(%rip), %rdx     # 0x7d0fe
leaq -0xa8(%rbp), %rdi
callq 0x43438
leaq 0x60(%rbx), %r14
leaq -0xa8(%rbp), %rsi
movq %r14, %rdi
callq 0x3ff26
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0x3edc3(%rip), %rsi     # 0x7d0ff
leaq 0x3edbe(%rip), %rdx     # 0x7d101
leaq -0x48(%rbp), %rdi
callq 0x43438
leaq -0x48(%rbp), %rsi
movq %r14, %rdi
callq 0x3ff26
leaq -0x78(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x3ed9b(%rip), %rsi     # 0x7d102
leaq 0x3ed9a(%rip), %rdx     # 0x7d108
leaq -0x88(%rbp), %rdi
callq 0x43438
leaq -0x88(%rbp), %rsi
movq %r14, %rdi
callq 0x3ff26
movl $0x0, 0x8(%rbx)
movq -0x88(%rbp), %rdi
cmpq %r15, %rdi
je 0x3e3a1
callq 0x1b4d0
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x3e3b3
callq 0x1b4d0
movq -0xa8(%rbp), %rdi
cmpq %r13, %rdi
je 0x3e3c4
callq 0x1b4d0
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x3e3d2
callq 0x1b4d0
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x88(%rbp), %rdi
cmpq %r15, %rdi
je 0x3e3ff
callq 0x1b4d0
jmp 0x3e3ff
jmp 0x3e3fc
movq %rax, %r14
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x3e418
callq 0x1b4d0
jmp 0x3e418
jmp 0x3e415
movq %rax, %r14
movq -0xa8(%rbp), %rdi
cmpq %r13, %rdi
je 0x3e430
callq 0x1b4d0
jmp 0x3e430
jmp 0x3e42d
movq %rax, %r14
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x3e443
callq 0x1b4d0
jmp 0x3e443
movq %rax, %r14
movq %rbx, %rdi
callq 0x3e94a
movq %r14, %rdi
callq 0x1b910
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x78(%rbp), %r15
movq %r15, %rdi
callq 0x4664a
movq 0x8(%r14), %r13
subq (%r14), %r13
sarq $0x5, %r13
cmpq $0x0, 0x10(%r15)
jne 0x3f2ac
cmpq %r13, -0x70(%rbp)
jne 0x3f2ac
cmpq %r14, -0x78(%rbp)
je 0x3f31b
movb $0x1, %r15b
leaq -0x78(%rbp), %r12
leaq -0x48(%rbp), %rdi
movq %r12, %rsi
callq 0x46468
testb $0x1, %r15b
je 0x3f2ca
xorl %r15d, %r15d
jmp 0x3f2de
movl $0x1, %edx
movq %rbx, %rdi
leaq 0x458a9(%rip), %rsi     # 0x84b82
callq 0x1b5e0
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq %rbx, %rdi
callq 0x1b5e0
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x3f300
callq 0x1b4d0
movq %r12, %rdi
callq 0x4653c
cmpq $0x0, -0x68(%rbp)
jne 0x3f2b3
cmpq %r13, -0x70(%rbp)
jne 0x3f2b3
cmpq %r14, -0x78(%rbp)
jne 0x3f2b3
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x3f342
callq 0x1b4d0
movq %rbx, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x98(%rbp), %rdi
callq 0x46fe2
leaq -0x70(%rbp), %rdi
movq %r14, %rsi
callq 0x4733c
movb $0x1, %r13b
leaq -0x98(%rbp), %r14
leaq -0x70(%rbp), %r15
leaq -0x48(%rbp), %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x46cb2
testb %al, %al
je 0x3f498
movq %r12, %rdi
movq %r14, %rsi
callq 0x46d24
testb $0x1, %r13b
je 0x3f458
xorl %r13d, %r13d
jmp 0x3f46c
movl $0x1, %edx
movq %rbx, %rdi
leaq 0x4571b(%rip), %rsi     # 0x84b82
callq 0x1b5e0
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq %rbx, %rdi
callq 0x1b5e0
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x3f48e
callq 0x1b4d0
movq %r14, %rdi
callq 0x46f5a
jmp 0x3f433
movq -0x68(%rbp), %rdi
testq %rdi, %rdi
je 0x3f4a6
callq 0x1b4d0
movq -0x90(%rbp), %rdi
testq %rdi, %rdi
je 0x3f4b7
callq 0x1b4d0
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x3f4f8
jmp 0x3f4e7
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x3f4ea
callq 0x1b4d0
jmp 0x3f4ea
movq %rax, %rbx
movq -0x68(%rbp), %rdi
testq %rdi, %rdi
je 0x3f4f8
callq 0x1b4d0
movq -0x90(%rbp), %rdi
testq %rdi, %rdi
je 0x3f509
callq 0x1b4d0
movq %rbx, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x20(%rdi), %rcx
cmpq %rcx, 0x18(%rdi)
je 0x3fe18
movq -0x8(%rcx), %rax
addq $-0x8, %rcx
movq %rcx, 0x20(%rbx)
jmp 0x3fe59
movl $0x178, %edi            # imm = 0x178
callq 0x1b510
movq %rax, %r14
movq %rax, %rdi
callq 0x1b6d0
leaq -0x18(%rbp), %rsi
movq %r14, (%rsi)
movq %rbx, %rdi
callq 0x49f80
movq -0x18(%rbp), %rdi
testq %rdi, %rdi
je 0x3fe4b
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x8(%rbx), %rax
subq (%rbx), %rax
sarq $0x3, %rax
decq %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x18(%rbp), %rdi
testq %rdi, %rdi
je 0x3fe74
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, -0x18(%rbp)
jmp 0x3fe89
movq %rax, %rbx
movq %r14, %rdi
callq 0x1b4d0
movq %rbx, %rdi
callq 0x1b910
nop