LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::StringMaker<char const*, void>::convert[abi:cxx11](char const*)
std::string StringMaker<char const*>::convert(char const* str) {
    if (str) {
        return ::Catch::Detail::stringify(std::string{ str });
    } else {
        return{ "{null string}" };
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
testq %rsi, %rsi
je 0x31577
movq %rsi, %r14
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq %rsi, %rdi
callq 0x1b220
leaq (%rax,%r14), %rdx
leaq -0x40(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x431c8
movq %rbx, %rdi
movq %r15, %rsi
callq 0x31376
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x31594
callq 0x1b4d0
jmp 0x31594
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x4a37f(%rip), %rsi     # 0x7b904
leaq 0x4a385(%rip), %rdx     # 0x7b911
movq %rbx, %rdi
callq 0x431c8
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x315b5
callq 0x1b4d0
movq %rbx, %rdi
callq 0x1b910
nop
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::StringMaker<char*, void>::convert[abi:cxx11](char*)
std::string StringMaker<char*>::convert(char* str) {
    if (str) {
        return ::Catch::Detail::stringify(std::string{ str });
    } else {
        return{ "{null string}" };
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
testq %rsi, %rsi
je 0x31617
movq %rsi, %r14
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq %rsi, %rdi
callq 0x1b220
leaq (%rax,%r14), %rdx
leaq -0x40(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x431c8
movq %rbx, %rdi
movq %r15, %rsi
callq 0x31376
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x31634
callq 0x1b4d0
jmp 0x31634
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x4a2df(%rip), %rsi     # 0x7b904
leaq 0x4a2e5(%rip), %rdx     # 0x7b911
movq %rbx, %rdi
callq 0x431c8
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x31655
callq 0x1b4d0
movq %rbx, %rdi
callq 0x1b910
nop
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::StringMaker<std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>, void>::convert(std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> const&)
std::string StringMaker<std::wstring>::convert(const std::wstring& wstr) {
    std::string s;
    s.reserve(wstr.size());
    for (auto c : wstr) {
        s += (c <= 0xff) ? static_cast<char>(c) : '?';
    }
    return ::Catch::Detail::stringify(s);
}

// 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 -0x40(%rbp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x8(%rsi), %rsi
leaq -0x50(%rbp), %rdi
callq 0x1b7e0
movq %rbx, -0x30(%rbp)
movq 0x8(%r14), %r12
testq %r12, %r12
je 0x316d6
movq (%r14), %r13
shlq $0x2, %r12
xorl %r15d, %r15d
movl $0x3f, %ebx
leaq -0x50(%rbp), %r14
movl (%r13,%r15), %eax
cmpl $0x100, %eax            # imm = 0x100
cmovgel %ebx, %eax
movsbl %al, %esi
movq %r14, %rdi
callq 0x1b480
addq $0x4, %r15
cmpq %r15, %r12
jne 0x316b5
leaq -0x50(%rbp), %rsi
movq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x31376
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x316f8
callq 0x1b4d0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3170c
movq %rax, %rbx
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x31721
callq 0x1b4d0
movq %rbx, %rdi
callq 0x1b910
nop
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::StringMaker<wchar_t const*, void>::convert[abi:cxx11](wchar_t const*)
std::string StringMaker<wchar_t const*>::convert(wchar_t const * str) {
    if (str) {
        return ::Catch::Detail::stringify(std::wstring{ str });
    } else {
        return{ "{null string}" };
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
testq %rsi, %rsi
je 0x31783
movq %rsi, %r14
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq %rsi, %rdi
callq 0x1b440
leaq (%r14,%rax,4), %rdx
leaq -0x40(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x60566
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3165e
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x317a0
callq 0x1b4d0
jmp 0x317a0
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x4a173(%rip), %rsi     # 0x7b904
leaq 0x4a179(%rip), %rdx     # 0x7b911
movq %rbx, %rdi
callq 0x431c8
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x317c1
callq 0x1b4d0
movq %rbx, %rdi
callq 0x1b910
nop
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::StringMaker<wchar_t*, void>::convert[abi:cxx11](wchar_t*)
std::string StringMaker<wchar_t *>::convert(wchar_t * str) {
    if (str) {
        return ::Catch::Detail::stringify(std::wstring{ str });
    } else {
        return{ "{null string}" };
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
testq %rsi, %rsi
je 0x31823
movq %rsi, %r14
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq %rsi, %rdi
callq 0x1b440
leaq (%r14,%rax,4), %rdx
leaq -0x40(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x60566
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3165e
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x31840
callq 0x1b4d0
jmp 0x31840
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x4a0d3(%rip), %rsi     # 0x7b904
leaq 0x4a0d9(%rip), %rdx     # 0x7b911
movq %rbx, %rdi
callq 0x431c8
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x31861
callq 0x1b4d0
movq %rbx, %rdi
callq 0x1b910
nop
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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 $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x38(%rbp), %r15
movq %r15, %rdi
callq 0x2d4e2
movq 0x10(%r15), %rdi
movq %r14, %rsi
callq 0x1b190
cmpq $0x100, %r14            # imm = 0x100
jl 0x3191d
movq -0x28(%rbp), %rdi
leaq 0x4a035(%rip), %rsi     # 0x7b912
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 0x1b190
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 0x2d528
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x31946
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x2d528
movq %rbx, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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 0x2d4e2
movq 0x10(%r15), %rdi
movq %r14, %rsi
callq 0x1b340
cmpq $0x100, %r14            # imm = 0x100
jb 0x31a0b
movq -0x28(%rbp), %rdi
leaq 0x49f47(%rip), %rsi     # 0x7b912
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 0x2d528
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x31a34
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x2d528
movq %rbx, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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 0x31b1c
leaq 0x476f7(%rip), %rcx     # 0x7919c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x49e75(%rip), %rsi     # 0x7b931
leaq 0x49e72(%rip), %rdx     # 0x7b935
jmp 0x31b08
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x49e54(%rip), %rsi     # 0x7b927
leaq 0x49e51(%rip), %rdx     # 0x7b92b
jmp 0x31b08
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x49e42(%rip), %rsi     # 0x7b92c
leaq 0x49e3f(%rip), %rdx     # 0x7b930
jmp 0x31b08
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x49e21(%rip), %rsi     # 0x7b922
leaq 0x49e1e(%rip), %rdx     # 0x7b926
movq %rbx, %rdi
callq 0x431c8
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
cmpb $0x1f, %sil
ja 0x31b2f
movslq %esi, %rsi
movq %rbx, %rdi
callq 0x3198c
jmp 0x31b10
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 0x31b0b
nop
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::Totals::operator-(Catch::Totals const&) const
Totals Totals::operator - ( Totals const& other ) const {
        Totals diff;
        diff.assertions = assertions - other.assertions;
        diff.testCases = testCases - other.testCases;
        return diff;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movl $0x0, (%rdi)
movq 0x8(%rsi), %rcx
movq 0x10(%rsi), %rdi
subq 0x8(%rdx), %rcx
subq 0x10(%rdx), %rdi
movq 0x18(%rsi), %r8
subq 0x18(%rdx), %r8
movq %rcx, 0x8(%rax)
movq %rdi, 0x10(%rax)
movq %r8, 0x18(%rax)
movq 0x20(%rsi), %rcx
movq 0x28(%rsi), %rdi
subq 0x20(%rdx), %rcx
subq 0x28(%rdx), %rdi
movq 0x30(%rsi), %rsi
subq 0x30(%rdx), %rsi
movq %rcx, 0x20(%rax)
movq %rdi, 0x28(%rax)
movq %rsi, 0x30(%rax)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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 0x74812(%rip), %rcx     # 0xa66a0
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 0x31f78
movq 0x18(%rbx), %rcx
testq %rcx, %rcx
je 0x31f4d
movq (%r14), %rax
cmpb $0x2a, (%rax)
jne 0x31f0e
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 0x31efe
callq 0x1b4d0
movl $0x1, 0xc(%rbx)
movq 0x18(%rbx), %rcx
testq %rcx, %rcx
je 0x31f4d
movq (%r14), %rax
cmpb $0x2a, -0x1(%rax,%rcx)
jne 0x31f4d
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 0x31f49
callq 0x1b4d0
orb $0x2, 0xc(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x31f5a
movq %rax, %r14
movq 0x10(%rbx), %rdi
addq $0x20, %rbx
cmpq %rbx, %rdi
je 0x31f6f
callq 0x1b4d0
movq %r14, %rdi
callq 0x1b910
nop
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::(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 0x4aa6d(%rip), %rsi     # 0x7cd35
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), %rcx
leaq (%rbx,%rcx), %r15
cmpb $0x0, 0xe1(%rbx,%rcx)
jne 0x3231d
movq %r15, %rdi
movl $0x20, %esi
callq 0x1b4f0
movb $0x1, 0xe1(%r15)
movq (%rbx), %rax
movb $0x30, 0xe0(%r15)
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_O3/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 0x323bd
movl $0x3, %esi
callq 0x323ea
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 0x3e96e
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x32439
callq 0x1b4d0
cmpb $0x1, (%rbx)
jne 0x32458
movq 0x40(%rbx), %rdi
leaq 0x49513(%rip), %rsi     # 0x7b95c
movl $0x2, %edx
callq 0x1b5e0
movb $0x0, (%rbx)
jmp 0x324b7
movq %rbx, %rdi
callq 0x326d8
testb $0x1, %r14b
je 0x32477
movq 0x40(%rbx), %rdi
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdx
callq 0x1b5e0
movq 0x40(%rbx), %r15
leaq 0x494dd(%rip), %rsi     # 0x7b95f
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 0x494bf(%rip), %rsi     # 0x7b969
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 0x324e9
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_O3/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 0x325bd
movl %edx, %r14d
movq %rsi, %r15
movb (%rbx), %r12b
movq %rbx, %rdi
callq 0x327b6
testb $0x1, %r14b
je 0x32580
testb %r12b, %r12b
je 0x32580
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 0x3200c
movq %r13, %rdi
movq %r12, %rsi
callq 0x3203a
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x325b2
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 0x325e4
callq 0x1b4d0
movq %rbx, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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 0x327b6
movq %r14, %rdi
callq 0x326d8
testb $0x1, %bl
je 0x32769
movq 0x40(%r14), %rdi
leaq 0x20(%r14), %r12
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
callq 0x1b5e0
leaq 0x50b4a(%rip), %rsi     # 0x832ab
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 0x3fc4c
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_O3/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 0x327f2
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 0x326d8
movb $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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 0x327b6
testb $0x1, %bl
je 0x329f0
movq 0x40(%r14), %rdi
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
callq 0x1b5e0
movq 0x40(%r14), %r12
leaq 0x48f67(%rip), %rsi     # 0x7b962
movl $0x4, %edx
movq %r12, %rdi
callq 0x1b5e0
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r12, %rdi
callq 0x1b5e0
leaq 0x48f49(%rip), %rsi     # 0x7b967
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_O3/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 0x2436e
leaq 0x48eae(%rip), %rsi     # 0x7b9bb
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 0x431c8
leaq -0x14(%rbp), %rdi
callq 0x24388
movq %rbx, %rax
addq $0x150, %rsp            # imm = 0x150
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x14(%rbp), %rdi
callq 0x24388
movq %rbx, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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 0x32bc6
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x58(%rax)
cmpl $0x2, %eax
jne 0x32ba6
xorl %eax, %eax
jmp 0x32bc6
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_O3/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, %r14
movq %rdi, %rbx
leaq -0x40(%rbp), %rdi
callq 0x2d4e2
movq (%r14), %r15
movq 0x8(%r14), %r12
cmpq %r12, %r15
je 0x32c33
movb $0x1, %al
leaq -0x21(%rbp), %r14
testb $0x1, %al
jne 0x32c18
movq -0x30(%rbp), %rdi
movb $0x20, -0x21(%rbp)
movl $0x1, %edx
movq %r14, %rsi
callq 0x1b5e0
movq -0x30(%rbp), %rdi
movq (%r15), %rsi
movq 0x8(%r15), %rdx
callq 0x1b5e0
addq $0x20, %r15
xorl %eax, %eax
cmpq %r12, %r15
jne 0x32bff
movq -0x30(%rbp), %rsi
addq $0x8, %rsi
movq %rbx, %rdi
callq 0x1b7f0
leaq -0x40(%rbp), %rdi
callq 0x2d528
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x32c60
jmp 0x32c60
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x2d528
movq %rbx, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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 0x3510f
movq %rsi, %r14
movq %rbx, %rdi
callq 0x35144
movq 0x18(%rbx), %r15
leaq 0x46a04(%rip), %rsi     # 0x7ba94
movl $0x13, %edx
movq %r15, %rdi
callq 0x1b5e0
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
movq %r15, %rdi
callq 0x1b5e0
leaq 0x469f4(%rip), %rsi     # 0x7baa8
movl $0x3, %edx
movq %rax, %rdi
callq 0x1b5e0
addq $0x38, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x351b8
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 0x35129
movq (%rax), %rdi
addq $0x10, %rax
cmpq %rax, %rdi
je 0x35129
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_O3/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 0x35b74
movq %r14, %rdi
movq %r15, %rsi
callq 0x351b8
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 0x40d4c
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x35fe1
movq %rbx, %rdi
callq 0x36012
cmpb $0x0, 0x88(%rbx)
jne 0x35ff2
movq %rbx, %rdi
callq 0x36188
cmpb $0x0, 0x170(%rbx)
jne 0x3600a
movq %rbx, %rdi
callq 0x36206
movb $0x1, 0x170(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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 0x74ee2(%rip), %rax     # 0xaaf20
cmpb $0x0, (%rax)
jne 0x36061
movaps 0x43036(%rip), %xmm0    # 0x79080
movups %xmm0, 0x3f(%rax)
movaps %xmm0, 0x30(%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, (%rax)
movb $0x0, 0x4f(%rax)
leaq 0x74eb8(%rip), %r15     # 0xaaf20
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 0x23898
movq 0x18(%rbx), %rdi
movq 0x20(%rbx), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
callq 0x1b5e0
movq %rax, %r14
leaq 0x459ee(%rip), %rsi     # 0x7baac
movl $0xd, %edx
movq %rax, %rdi
callq 0x1b5e0
callq 0x2c1b5
leaq 0x74ce1(%rip), %rsi     # 0xaadb8
movq %r14, %rdi
callq 0x2c0cb
leaq 0x459d4(%rip), %rsi     # 0x7baba
movl $0x13, %edx
movq %r14, %rdi
callq 0x1b5e0
leaq 0x459d4(%rip), %rsi     # 0x7bace
movl $0x19, %edx
movq %r14, %rdi
callq 0x1b5e0
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *0x88(%rax)
testl %eax, %eax
je 0x3615b
movq 0x18(%rbx), %r14
leaq 0x459c5(%rip), %rsi     # 0x7bae8
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 0x4da03(%rip), %rsi     # 0x83b51
movl $0x2, %edx
movq %rax, %rdi
callq 0x1b5e0
movb $0x1, 0x48(%rbx)
leaq -0x19(%rbp), %rdi
callq 0x23940
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x19(%rbp), %rdi
callq 0x23940
movq %rbx, %rdi
callq 0x1b910
nop
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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 0x45106(%rip), %rsi     # 0x7b679
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 0x3f044
addq %rbx, %r13
movq %r13, 0x20(%r12)
movq %rbx, 0x28(%r12)
movq %r15, %rdi
movq %r12, %rsi
callq 0x3ef65
leaq -0x29(%rbp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x1b5e0
leaq -0x60(%rbp), %rdi
callq 0x3fc98
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x3fc98
movq %rbx, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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 0x60bc4
movl 0x1b8(%r14), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x1b8(%r14)
testl %eax, %eax
jle 0x392da
leaq 0x170(%r14), %r15
leaq -0x78(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x449b1(%rip), %rsi     # 0x7dbe1
leaq 0x449b1(%rip), %rdx     # 0x7dbe8
leaq -0x88(%rbp), %r12
movq %r12, %rdi
callq 0x431c8
movq %r15, %rdi
movq %r12, %rsi
movl $0x3, %edx
callq 0x3271c
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x416b3(%rip), %rsi     # 0x7a919
leaq 0x416b0(%rip), %rdx     # 0x7a91d
leaq -0x48(%rbp), %rdi
callq 0x431c8
leaq -0x68(%rbp), %rdi
movq %rbx, %rsi
callq 0x23233
leaq -0x48(%rbp), %rsi
leaq -0x68(%rbp), %rdx
movq %r15, %rdi
callq 0x32852
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x392a4
callq 0x1b4d0
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x392b2
callq 0x1b4d0
movq -0x88(%rbp), %rdi
cmpq %r13, %rdi
je 0x392c3
callq 0x1b4d0
addq $0x40, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x38aa6
movq %r15, %rdi
callq 0x327b6
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 0x39303
callq 0x1b4d0
jmp 0x39303
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x39318
callq 0x1b4d0
jmp 0x39318
jmp 0x39315
movq %rax, %rbx
movq -0x88(%rbp), %rdi
cmpq %r13, %rdi
je 0x39329
callq 0x1b4d0
movq %rbx, %rdi
callq 0x1b910
nop
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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 0x3aba2
movq %rdi, %rbx
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x431c8
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0x6f411(%rip), %rdi     # 0xa9f98
callq 0x1b5e0
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x3ab9a
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 0x3abc0
callq 0x1b4d0
movq %rbx, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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 0x3ac3b
movq 0x30(%r14), %rax
cmpq %rax, 0x20(%r14)
je 0x3abfe
movq 0x28(%r14), %rcx
cmpq %rax, %rcx
jae 0x3ac46
movb %bl, (%rcx)
incq 0x28(%r14)
jmp 0x3ac3b
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 0x6f370(%rip), %rdi     # 0xa9f98
callq 0x1b5e0
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x3ac3b
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 0x3ac3b
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x3ac65
callq 0x1b4d0
movq %rbx, %rdi
callq 0x1b910
nop
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::(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 0x3ad77
movq %rdx, %r14
movq %rdi, %rbx
leaq -0x11(%rbp), %rdi
callq 0x23898
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 0x23940
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 0x23940
movq %rbx, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::(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 0x1da82
testb %al, %al
je 0x3ae96
leaq -0x30(%rbp), %rdi
movl $0x17, %esi
callq 0x23898
movq (%rbx), %rdi
leaq 0x41f7a(%rip), %rsi     # 0x7cdc9
movl $0x6, %edx
callq 0x1b5e0
leaq -0x30(%rbp), %rdi
callq 0x23940
movq (%rbx), %r14
movq 0x8(%rbx), %rsi
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x1db2e
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x1b5e0
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3ae96
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 0x3aec2
callq 0x1b4d0
jmp 0x3aec2
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x23940
movq %rbx, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::(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 0x3b005
movq %rdi, %rbx
leaq -0x29(%rbp), %rdi
callq 0x23898
movq (%rbx), %r14
leaq 0x46f8b(%rip), %rsi     # 0x81e8d
movl $0x6, %edx
movq %r14, %rdi
callq 0x1b5e0
leaq -0x40(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x4204f(%rip), %rsi     # 0x7cf6d
leaq 0x4204f(%rip), %rdx     # 0x7cf74
leaq -0x50(%rbp), %rdi
callq 0x431c8
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 0x2d8d6
leaq -0x78(%rbp), %rsi
movq %r14, %rdi
callq 0x2593c
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 0x3af85
callq 0x1b4d0
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
je 0x3af93
callq 0x1b4d0
leaq -0x29(%rbp), %rdi
callq 0x23940
movq 0x28(%rbx), %rax
cmpq %r12, %rax
je 0x3b005
leaq -0x78(%rbp), %r14
leaq 0x41e20(%rip), %r15     # 0x7cdd0
cmpb $0x0, 0x30(%rbx)
jne 0x3afc6
cmpl $0x1, 0x40(%rax)
jne 0x3afc6
addq $0x48, %rax
movq %rax, 0x28(%rbx)
jmp 0x3b000
movq %rbx, %rdi
callq 0x3b05e
movq 0x28(%rbx), %rax
cmpq %r12, %rax
je 0x3b000
movq %r14, %rdi
movl $0x17, %esi
callq 0x23898
movq (%rbx), %rdi
movl $0x4, %edx
movq %r15, %rsi
callq 0x1b5e0
movq %r14, %rdi
callq 0x23940
movq 0x28(%rbx), %rax
cmpq %r12, %rax
jne 0x3afb0
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x3b035
jmp 0x3b01b
movq %rax, %rbx
jmp 0x3b043
movq %rax, %rbx
leaq -0x60(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3b035
callq 0x1b4d0
movq -0x50(%rbp), %rdi
cmpq %r15, %rdi
je 0x3b043
callq 0x1b4d0
leaq -0x29(%rbp), %rdi
jmp 0x3b050
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x23940
movq %rbx, %rdi
callq 0x1b910
nop
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::(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 0x3b11f
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 0x23898
movq (%rbx), %rdi
leaq 0x41cd1(%rip), %rsi     # 0x7cdd5
movl $0x10, %edx
callq 0x1b5e0
leaq -0x9(%rbp), %rdi
callq 0x23940
movq %rbx, %rdi
callq 0x3ad94
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x9(%rbp), %rdi
callq 0x23940
movq %rbx, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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
movq 0x6e0c2(%rip), %rax     # 0xaae00
testq %rax, %rax
jne 0x3ceb7
movl $0x150, %edi            # imm = 0x150
callq 0x1b510
movq %rax, %rbx
leaq 0x6b42d(%rip), %rax     # 0xa8188
movq %rax, (%rbx)
leaq 0x6b4a3(%rip), %rax     # 0xa8208
movq %rax, 0x8(%rbx)
leaq 0x6b4f0(%rip), %rax     # 0xa8260
movq %rax, 0x10(%rbx)
leaq 0x6a76d(%rip), %rax     # 0xa74e8
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 0x693ca(%rip), %rax     # 0xa6178
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 0x68fb4(%rip), %rcx     # 0xa5da0
addq $0x10, %rcx
movq %rcx, 0xb8(%rbx)
movups %xmm0, 0xc0(%rbx)
movq %rax, 0xd0(%rbx)
leaq 0x695cc(%rip), %rcx     # 0xa63d8
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 0x69f10(%rip), %rdx     # 0xa6d60
addq $0x10, %rdx
movq %rdx, 0x128(%rbx)
movq %rax, 0x140(%rbx)
movups %xmm0, 0x130(%rbx)
movq %rbx, %rdi
addq $0x148, %rdi            # imm = 0x148
leaq 0x6b176(%rip), %rax     # 0xa7ff0
movq %rax, (%rbx)
leaq 0x6b15c(%rip), %rax     # 0xa7fe0
leaq 0x6b1e5(%rip), %rdx     # 0xa8070
movq %rdx, 0x8(%rbx)
addq %rcx, %rax
movq %rax, 0x10(%rbx)
leaq 0x6b24b(%rip), %rax     # 0xa80e8
movq %rax, 0x148(%rbx)
movq %rbx, 0x6df55(%rip)     # 0xaae00
callq 0x2d43a
movq 0x6df49(%rip), %rax     # 0xaae00
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
movq %r15, %rdi
callq 0x3f08c
movq %r14, %rdi
callq 0x3f08c
movq %rbx, %rdi
callq 0x1b4d0
movq %r12, %rdi
callq 0x1b910
nop