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::(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 0x2d49a
cmpq $0x0, (%r14)
je 0x3d0c1
leaq -0x18(%rbp), %rdi
callq 0x1b460
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x43a86
leaq 0x6a75d(%rip), %rax     # 0xa8708
addq $0x10, %rax
movq %rax, (%rbx)
leaq -0x58(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x3e120(%rip), %rsi     # 0x7c0e2
leaq 0x3e132(%rip), %rdx     # 0x7c0fb
leaq -0x68(%rbp), %rdi
callq 0x431c8
leaq 0x40(%rbx), %rdi
leaq -0x68(%rbp), %rsi
callq 0x1b290
leaq -0x98(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x3e10b(%rip), %rsi     # 0x7c0fc
leaq 0x3e106(%rip), %rdx     # 0x7c0fe
leaq -0xa8(%rbp), %rdi
callq 0x431c8
leaq 0x60(%rbx), %r14
leaq -0xa8(%rbp), %rsi
movq %r14, %rdi
callq 0x3fc4c
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0x3e0d9(%rip), %rsi     # 0x7c0ff
leaq 0x3e0d4(%rip), %rdx     # 0x7c101
leaq -0x48(%rbp), %rdi
callq 0x431c8
leaq -0x48(%rbp), %rsi
movq %r14, %rdi
callq 0x3fc4c
leaq -0x78(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x3e0b1(%rip), %rsi     # 0x7c102
leaq 0x3e0b0(%rip), %rdx     # 0x7c108
leaq -0x88(%rbp), %rdi
callq 0x431c8
leaq -0x88(%rbp), %rsi
movq %r14, %rdi
callq 0x3fc4c
movl $0x0, 0x8(%rbx)
movq -0x88(%rbp), %rdi
cmpq %r15, %rdi
je 0x3e08b
callq 0x1b4d0
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x3e09d
callq 0x1b4d0
movq -0xa8(%rbp), %rdi
cmpq %r13, %rdi
je 0x3e0ae
callq 0x1b4d0
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x3e0bc
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 0x3e0e9
callq 0x1b4d0
jmp 0x3e0e9
jmp 0x3e0e6
movq %rax, %r14
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x3e102
callq 0x1b4d0
jmp 0x3e102
jmp 0x3e0ff
movq %rax, %r14
movq -0xa8(%rbp), %rdi
cmpq %r13, %rdi
je 0x3e11a
callq 0x1b4d0
jmp 0x3e11a
jmp 0x3e117
movq %rax, %r14
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0x3e12d
callq 0x1b4d0
jmp 0x3e12d
movq %rax, %r14
movq %rbx, %rdi
callq 0x3e634
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::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), %r12
movq %r12, %rdi
callq 0x461a8
movq 0x8(%r14), %r15
subq (%r14), %r15
sarq $0x5, %r15
cmpq $0x0, 0x10(%r12)
jne 0x3efb9
cmpq %r15, -0x70(%rbp)
jne 0x3efb9
cmpq %r14, -0x78(%rbp)
jne 0x3efb9
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq -0x48(%rbp), %rdi
movq %r12, %rsi
callq 0x45fe6
leaq 0x44b86(%rip), %r13     # 0x83b52
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 0x3efee
callq 0x1b4d0
movq %r12, %rdi
callq 0x460be
cmpq $0x0, -0x68(%rbp)
jne 0x3f009
cmpq %r15, -0x70(%rbp)
jne 0x3f009
cmpq %r14, -0x78(%rbp)
je 0x3efa7
leaq -0x48(%rbp), %rdi
movq %r12, %rsi
callq 0x45fe6
movl $0x1, %edx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1b5e0
jmp 0x3efcc
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x3f03c
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::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 0x46b08
leaq -0x70(%rbp), %rdi
movq %r14, %rsi
callq 0x46e62
movb $0x1, %r13b
leaq -0x98(%rbp), %r14
leaq -0x70(%rbp), %r15
leaq -0x48(%rbp), %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x467ea
testb %al, %al
je 0x3f190
movq %r12, %rdi
movq %r14, %rsi
callq 0x46848
testb $0x1, %r13b
jne 0x3f161
movl $0x1, %edx
movq %rbx, %rdi
leaq 0x449f6(%rip), %rsi     # 0x83b52
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 0x3f183
callq 0x1b4d0
xorl %r13d, %r13d
movq %r14, %rdi
callq 0x46a7e
jmp 0x3f12d
movq -0x68(%rbp), %rdi
testq %rdi, %rdi
je 0x3f19e
callq 0x1b4d0
movq -0x90(%rbp), %rdi
testq %rdi, %rdi
je 0x3f1af
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 0x3f1f0
jmp 0x3f1df
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x3f1e2
callq 0x1b4d0
jmp 0x3f1e2
movq %rax, %rbx
movq -0x68(%rbp), %rdi
testq %rdi, %rdi
je 0x3f1f0
callq 0x1b4d0
movq -0x90(%rbp), %rdi
testq %rdi, %rdi
je 0x3f201
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::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 0x3fb40
movq -0x8(%rcx), %rax
addq $-0x8, %rcx
movq %rcx, 0x20(%rbx)
jmp 0x3fb81
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 0x49a9e
movq -0x18(%rbp), %rdi
testq %rdi, %rdi
je 0x3fb73
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 0x3fba9
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x3fba9
movq %rax, %rbx
movq %r14, %rdi
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: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> Catch::fpToString<float>(float, int)
std::string fpToString( T value, int precision ) {
    if (Catch::isnan(value)) {
        return "nan";
    }

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movss %xmm0, -0x1c(%rbp)
ucomiss %xmm0, %xmm0
jp 0x40525
movl %esi, %r14d
leaq -0x38(%rbp), %r15
movq %r15, %rdi
callq 0x2d4e2
movq 0x10(%r15), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rcx
movslq %r14d, %rdx
movq %rdx, 0x8(%rdi,%rcx)
movq -0x18(%rax), %rax
movl $0xfffffefb, %ecx       # imm = 0xFFFFFEFB
andl 0x18(%rdi,%rax), %ecx
orl $0x4, %ecx
movl %ecx, 0x18(%rdi,%rax)
xorps %xmm0, %xmm0
cvtss2sd -0x1c(%rbp), %xmm0
callq 0x1b810
movq -0x28(%rbp), %rsi
addq $0x8, %rsi
movq %rbx, %rdi
callq 0x1b7f0
movq %rbx, %rdi
movl $0x30, %esi
movq $-0x1, %rdx
callq 0x1b370
cmpq $-0x1, %rax
je 0x4050e
movq 0x8(%rbx), %rcx
decq %rcx
cmpq %rcx, %rax
je 0x4050e
movq (%rbx), %rcx
xorl %edx, %edx
cmpb $0x2e, (%rcx,%rax)
sete %dl
leaq (%rax,%rdx), %rcx
incq %rcx
leaq -0x58(%rbp), %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x1b580
leaq -0x58(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1b640
movq (%r14), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x4050e
callq 0x1b4d0
leaq -0x38(%rbp), %rdi
callq 0x2d528
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x3d543(%rip), %rsi     # 0x7da76
leaq 0x3d53f(%rip), %rdx     # 0x7da79
movq %rbx, %rdi
callq 0x431c8
jmp 0x40517
movq %rax, %r14
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x4055f
callq 0x1b4d0
jmp 0x4055f
jmp 0x4055c
movq %rax, %r14
leaq -0x38(%rbp), %rdi
callq 0x2d528
movq %r14, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::TablePrinter::close()
void close() {
        if (m_isOpen) {
            *this << RowBreak();
            m_os << std::endl;
            m_isOpen = false;
        }
    }

// Assembly:
cmpb $0x1, 0x19c(%rdi)
jne 0x40cb5
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpl $0x0, 0x198(%rdi)
jle 0x40c7c
movq (%rbx), %rdi
leaq -0x11(%rbp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
callq 0x1b5e0
movl $0xffffffff, 0x198(%rbx) # imm = 0xFFFFFFFF
movq (%rbx), %r14
movq (%r14), %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
movb $0x0, 0x19c(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::SummaryColumn::addRow(unsigned long)
SummaryColumn addRow( std::size_t count ) {
        ReusableStringStream rss;
        rss << count;
        std::string row = rss.str();
        for (auto& oldRow : rows) {
            while (oldRow.size() < row.size())
                oldRow = ' ' + oldRow;
            while (oldRow.size() > row.size())
                row = ' ' + row;
        }
        rows.push_back(row);
        return *this;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x70(%rbp), %r12
movq %r12, %rdi
callq 0x2d4e2
movq 0x10(%r12), %rdi
movq %r15, %rsi
callq 0x1b350
movq %rbx, -0x38(%rbp)
movq -0x60(%rbp), %rsi
addq $0x8, %rsi
leaq -0x58(%rbp), %rdi
callq 0x1b7f0
movq 0x28(%r14), %r15
movq %r14, -0x30(%rbp)
movq 0x30(%r14), %rbx
cmpq %rbx, %r15
je 0x40ed4
leaq -0x80(%rbp), %r14
leaq -0x58(%rbp), %r12
movq 0x8(%r12), %rax
leaq -0x90(%rbp), %r13
movq 0x8(%r15), %rcx
cmpq %rax, %rcx
jae 0x40e8c
movq %r13, %rdi
movl $0x20, %esi
movq %r15, %rdx
callq 0x403b9
movq %r15, %rdi
movq %r13, %rsi
callq 0x1b640
movq -0x90(%rbp), %rdi
cmpq %r14, %rdi
je 0x40e82
callq 0x1b4d0
movq 0x8(%r15), %rcx
movq -0x50(%rbp), %rax
jmp 0x40e51
cmpq %rax, %rcx
jbe 0x40ec7
movq %r13, %rdi
movl $0x20, %esi
movq %r12, %rdx
callq 0x403b9
movq %r12, %rdi
movq %r13, %rsi
callq 0x1b640
movq -0x90(%rbp), %rdi
cmpq %r14, %rdi
je 0x40ebd
callq 0x1b4d0
movq -0x50(%rbp), %rax
cmpq %rax, 0x8(%r15)
ja 0x40e91
addq $0x20, %r15
cmpq %rbx, %r15
jne 0x40e4d
movq -0x30(%rbp), %r14
leaq 0x28(%r14), %r15
leaq -0x58(%rbp), %rsi
movq %r15, %rdi
callq 0x3fc4c
movq -0x38(%rbp), %r12
leaq 0x10(%r12), %rbx
movq %rbx, (%r12)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x4a8c2
movl 0x20(%r14), %eax
movl %eax, 0x20(%r12)
leaq 0x28(%r12), %rdi
movq %r15, %rsi
callq 0x3fd36
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x40f2f
callq 0x1b4d0
leaq -0x70(%rbp), %rdi
callq 0x2d528
movq %r12, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%r12), %rdi
cmpq %rbx, %rdi
je 0x40f6b
callq 0x1b4d0
jmp 0x40f6b
jmp 0x40f5f
movq %rax, %r14
jmp 0x40f7d
jmp 0x40f68
jmp 0x40f68
movq %rax, %r14
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x40f7d
callq 0x1b4d0
leaq -0x70(%rbp), %rdi
callq 0x2d528
movq %r14, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::CumulativeReporterBase<Catch::JunitReporter>::assertionEnded(Catch::AssertionStats const&)
bool assertionEnded(AssertionStats const& assertionStats) override {
            assert(!m_sectionStack.empty());
            // AssertionResult holds a pointer to a temporary DecomposedExpression,
            // which getExpandedExpression() calls to build the expression string.
            // Our section stack copy of the assertionResult will likely outlive the
            // temporary, so it must be expanded or discarded now to avoid calling
            // a destroyed object later.
            prepareExpandedExpression(const_cast<AssertionResult&>( assertionStats.assertionResult ) );
            SectionNode& sectionNode = *m_sectionStack.back();
            sectionNode.assertions.push_back(assertionStats);
            return true;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0xb8(%rdi), %rax
cmpq 0xc0(%rdi), %rax
je 0x412e9
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsi), %rdi
callq 0x32ab7
movq 0xc0(%r14), %rax
movl $0xa0, %edi
addq -0x10(%rax), %rdi
movq %rbx, %rsi
callq 0x612e0
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x3a817(%rip), %rdi     # 0x7bb07
leaq 0x39bde(%rip), %rsi     # 0x7aed5
leaq 0x3c7ab(%rip), %rcx     # 0x7daa9
movl $0x1712, %edx           # imm = 0x1712
callq 0x1b320
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::CumulativeReporterBase<Catch::JunitReporter>::testCaseEnded(Catch::TestCaseStats const&)
void testCaseEnded(TestCaseStats const& testCaseStats) override {
            auto node = std::make_shared<TestCaseNode>(testCaseStats);
            assert(m_sectionStack.size() == 0);
            node->children.push_back(m_rootSection);
            m_testCases.push_back(node);
            m_rootSection.reset();

            assert(m_deepestSection);
            m_deepestSection->stdOut = testCaseStats.stdOut;
            m_deepestSection->stdErr = testCaseStats.stdErr;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x20(%rbp), %rdi
movq $0x0, -0x8(%rdi)
leaq -0x28(%rbp), %rsi
leaq -0x11(%rbp), %rdx
movq %rbx, %rcx
callq 0x6178a
movq 0xc0(%r14), %rax
cmpq 0xb8(%r14), %rax
jne 0x413d8
movl $0x138, %edi            # imm = 0x138
addq -0x28(%rbp), %rdi
leaq 0x98(%r14), %rsi
callq 0x616ee
leaq 0x50(%r14), %rdi
leaq -0x28(%rbp), %rsi
callq 0x6173c
xorps %xmm0, %xmm0
movq 0xa0(%r14), %rdi
movups %xmm0, 0x98(%r14)
testq %rdi, %rdi
je 0x41387
callq 0x43a1a
movq 0xa8(%r14), %rdi
testq %rdi, %rdi
je 0x413f7
leaq 0xe8(%rbx), %rsi
addq $0xb8, %rdi
callq 0x1b290
addq $0x108, %rbx            # imm = 0x108
movl $0xd8, %edi
addq 0xa8(%r14), %rdi
movq %rbx, %rsi
callq 0x1b290
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x413cf
callq 0x43a1a
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x3c755(%rip), %rdi     # 0x7db34
leaq 0x39aef(%rip), %rsi     # 0x7aed5
leaq 0x3c762(%rip), %rcx     # 0x7db4f
movl $0x1725, %edx           # imm = 0x1725
callq 0x1b320
leaq 0x3c7da(%rip), %rdi     # 0x7dbd8
leaq 0x39ad0(%rip), %rsi     # 0x7aed5
leaq 0x3c743(%rip), %rcx     # 0x7db4f
movl $0x172a, %edx           # imm = 0x172A
callq 0x1b320
movq %rax, %rbx
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x41427
callq 0x43a1a
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: int Catch::Session::run<char>(int, char const* const*)
int run(int argc, CharT const * const argv[]) {
            if (m_startupExceptions)
                return 1;
            int returnCode = applyCommandLine(argc, argv);
            if (returnCode == 0)
                returnCode = run();
            return returnCode;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl $0x1, %eax
cmpb $0x0, 0x188(%rdi)
jne 0x41e96
movq %rdi, %rbx
callq 0x2c394
testl %eax, %eax
je 0x41e9d
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2c742
nop
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::CumulativeReporterBase<Catch::JunitReporter>::sectionEnded(Catch::SectionStats const&)
void sectionEnded(SectionStats const& sectionStats) override {
            assert(!m_sectionStack.empty());
            SectionNode& node = *m_sectionStack.back();
            node.stats = sectionStats;
            m_sectionStack.pop_back();
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0xc0(%rdi), %rax
cmpq %rax, 0xb8(%rdi)
je 0x43058
movq %rsi, %r14
movq %rdi, %rbx
movq -0x10(%rax), %r15
leaq 0x10(%r15), %rdi
addq $0x8, %rsi
callq 0x1b290
leaq 0x30(%r15), %rdi
leaq 0x28(%r14), %rsi
callq 0x1b290
movups 0x48(%r14), %xmm0
movups %xmm0, 0x50(%r15)
movups 0x58(%r14), %xmm0
movups 0x68(%r14), %xmm1
movups %xmm0, 0x60(%r15)
movups %xmm1, 0x70(%r15)
movb 0x78(%r14), %al
movb %al, 0x80(%r15)
movq 0xc0(%rbx), %rax
leaq -0x10(%rax), %rcx
movq %rcx, 0xc0(%rbx)
movq -0x8(%rax), %rdi
addq $0x8, %rsp
testq %rdi, %rdi
je 0x43051
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x43a1a
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x38aa8(%rip), %rdi     # 0x7bb07
leaq 0x37e6f(%rip), %rsi     # 0x7aed5
leaq 0x3ab7c(%rip), %rcx     # 0x7dbe9
movl $0x171e, %edx           # imm = 0x171E
callq 0x1b320
nop
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::CumulativeReporterBase<Catch::JunitReporter>::testRunEnded(Catch::TestRunStats const&)
void testRunEnded(TestRunStats const& testRunStats) override {
            auto node = std::make_shared<TestRunNode>(testRunStats);
            node->children.swap(m_testGroups);
            m_testRuns.push_back(node);
            testRunEndedCumulative();
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rcx
movq %rdi, %rbx
leaq -0x20(%rbp), %rdi
movq $0x0, -0x8(%rdi)
leaq -0x28(%rbp), %r14
leaq -0x11(%rbp), %rdx
movq %r14, %rsi
callq 0x62c4a
movq (%r14), %rax
movups 0x70(%rax), %xmm0
movq 0x80(%rax), %rcx
movq 0x68(%rbx), %rdx
movq %rdx, 0x70(%rax)
movq 0x70(%rbx), %rdx
movq %rdx, 0x78(%rax)
movq 0x78(%rbx), %rdx
movq %rdx, 0x80(%rax)
movups %xmm0, 0x68(%rbx)
movq %rcx, 0x78(%rbx)
leaq 0x80(%rbx), %rdi
movq %r14, %rsi
callq 0x62bfc
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x90(%rax)
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x430ff
callq 0x43a1a
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x43119
callq 0x43a1a
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::clara::detail::BasicResult<void>::enforceOk() const
void enforceOk() const override {

            // Errors shouldn't reach this point, but if they do
            // the actual error message will be in m_errorMessage
            assert( m_type != ResultBase::LogicError );
            assert( m_type != ResultBase::RuntimeError );
            if( m_type != ResultBase::Ok )
                std::abort();
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x8(%rdi), %eax
testl %eax, %eax
jne 0x43503
popq %rbp
retq
cmpl $0x2, %eax
je 0x4352c
cmpl $0x1, %eax
jne 0x4354b
leaq 0x38a1b(%rip), %rdi     # 0x7bf2f
leaq 0x379ba(%rip), %rsi     # 0x7aed5
leaq 0x38a2e(%rip), %rcx     # 0x7bf50
movl $0x233d, %edx           # imm = 0x233D
callq 0x1b320
leaq 0x38a6c(%rip), %rdi     # 0x7bf9f
leaq 0x3799b(%rip), %rsi     # 0x7aed5
leaq 0x38a0f(%rip), %rcx     # 0x7bf50
movl $0x233e, %edx           # imm = 0x233E
callq 0x1b320
callq 0x1b2b0
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::clara::detail::Opt::validate() const
auto validate() const -> Result override {
            if( m_optNames.empty() )
                return Result::logicError( "No options supplied to Opt" );
            for( auto const &name : m_optNames ) {
                if( name.empty() )
                    return Result::logicError( "Option name cannot be empty" );
#ifdef CATCH_PLATFORM_WINDOWS
                if( name[0] != '-' && name[0] != '/' )
                    return Result::logicError( "Option name must begin with '-' or '/'" );
#else
                if( name[0] != '-' )
                    return Result::logicError( "Option name must begin with '-'" );
#endif
            }
            return ParserRefImpl::validate();
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x60(%rsi), %rax
movq 0x68(%rsi), %rcx
cmpq %rcx, %rax
je 0x43bf5
cmpq $0x0, 0x8(%rax)
je 0x43c27
movq (%rax), %rdx
cmpb $0x2d, (%rdx)
jne 0x43c59
addq $0x20, %rax
cmpq %rcx, %rax
jne 0x43bab
movl $0x0, 0x8(%rbx)
leaq 0x648eb(%rip), %rax     # 0xa84c0
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x20(%rbx), %rax
movq %rax, 0x10(%rbx)
movq $0x0, 0x18(%rbx)
movb $0x0, 0x20(%rbx)
jmp 0x43c97
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x38505(%rip), %rsi     # 0x7c109
leaq 0x38518(%rip), %rdx     # 0x7c123
leaq -0x30(%rbp), %rdi
callq 0x431c8
leaq -0x30(%rbp), %rdx
movq %rbx, %rdi
movl $0x1, %esi
callq 0x44458
jmp 0x43c89
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x384ee(%rip), %rsi     # 0x7c124
leaq 0x38502(%rip), %rdx     # 0x7c13f
leaq -0x30(%rbp), %rdi
callq 0x431c8
leaq -0x30(%rbp), %rdx
movq %rbx, %rdi
movl $0x1, %esi
callq 0x44458
jmp 0x43c89
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x384d8(%rip), %rsi     # 0x7c140
leaq 0x384f0(%rip), %rdx     # 0x7c15f
leaq -0x30(%rbp), %rdi
callq 0x431c8
leaq -0x30(%rbp), %rdx
movq %rbx, %rdi
movl $0x1, %esi
callq 0x44458
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x43c97
callq 0x1b4d0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x43cab
jmp 0x43cbe
jmp 0x43cab
jmp 0x43cbe
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x43cc1
callq 0x1b4d0
jmp 0x43cc1
movq %rax, %rbx
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::clara::detail::Opt::isMatch(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
auto isMatch( std::string const &optToken ) const -> bool {
            auto normalisedToken = normaliseOpt( optToken );
            for( auto const &name : m_optNames ) {
                if( normaliseOpt( name ) == normalisedToken )
                    return true;
            }
            return false;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x4a8c2
movq 0x60(%rbx), %r13
movq 0x68(%rbx), %r12
cmpq %r12, %r13
je 0x44654
leaq -0x58(%rbp), %rbx
movq %rbx, -0x68(%rbp)
movq (%r13), %rsi
movq 0x8(%r13), %rdx
addq %rsi, %rdx
leaq -0x68(%rbp), %rdi
callq 0x4a8c2
movq -0x60(%rbp), %rdx
cmpq -0x40(%rbp), %rdx
jne 0x4462a
movq -0x68(%rbp), %r15
testq %rdx, %rdx
je 0x44633
movq -0x48(%rbp), %rsi
movq %r15, %rdi
callq 0x1b570
testl %eax, %eax
sete %r14b
jmp 0x44636
movq -0x68(%rbp), %r15
xorl %r14d, %r14d
jmp 0x44636
movb $0x1, %r14b
cmpq %rbx, %r15
je 0x44643
movq %r15, %rdi
callq 0x1b4d0
addq $0x20, %r13
cmpq %r12, %r13
sete %al
orb %r14b, %al
je 0x445eb
jmp 0x44657
xorl %r14d, %r14d
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x44669
callq 0x1b4d0
movl %r14d, %eax
addq $0x48, %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 0x44690
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::clara::detail::TokenStream::operator++()
auto operator++() -> TokenStream & {
            if( m_tokenBuffer.size() >= 2 ) {
                m_tokenBuffer.erase( m_tokenBuffer.begin() );
            } else {
                if( it != itEnd )
                    ++it;
                loadBuffer();
            }
            return *this;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rsi
movq 0x18(%rdi), %rax
subq %rsi, %rax
sarq $0x3, %rax
movabsq $-0x3333333333333333, %rcx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rax, %rcx
cmpq $0x2, %rcx
jb 0x44761
leaq 0x10(%rbx), %rdi
callq 0x449ee
jmp 0x44779
movq (%rbx), %rax
cmpq 0x8(%rbx), %rax
je 0x44771
addq $0x20, %rax
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x44784
movq %rbx, %rax
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::clara::detail::BoundValueRef<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>>>>>::setValue(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
auto setValue( std::string const &arg ) -> ParserResult override {
            T temp;
            auto result = convertInto( arg, temp );
            if( result )
                m_ref.push_back( temp );
            return result;
        }

// 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 -0x38(%rbp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
leaq -0x48(%rbp), %rdi
movq %rdx, %rsi
callq 0x1b290
xorl %eax, %eax
movq %rax, 0x8(%rbx)
leaq 0x6310e(%rip), %r12     # 0xa8688
addq $0x10, %r12
movq %r12, (%rbx)
leaq 0x20(%rbx), %r13
movq %r13, 0x10(%rbx)
movq %rax, 0x18(%rbx)
movb $0x0, 0x20(%rbx)
movq 0x8(%r14), %rdi
leaq -0x48(%rbp), %rsi
callq 0x3fc4c
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0x455ac
callq 0x1b4d0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %r12, (%rbx)
movq 0x10(%rbx), %rdi
cmpq %r13, %rdi
je 0x455d2
callq 0x1b4d0
leaq 0x63107(%rip), %rax     # 0xa86e0
addq $0x10, %rax
movq %rax, (%rbx)
jmp 0x455e5
movq %rax, %r14
movq -0x48(%rbp), %rdi
cmpq %r15, %rdi
je 0x455f3
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::clara::detail::Parser::validate() const
auto validate() const -> Result override {
            for( auto const &opt : m_options ) {
                auto result = opt.validate();
                if( !result )
                    return result;
            }
            for( auto const &arg : m_args ) {
                auto result = arg.validate();
                if( !result )
                    return result;
            }
            return Result::ok();
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x30(%rsi), %r15
movq %rsi, -0x30(%rbp)
movq 0x38(%rsi), %r12
cmpq %r12, %r15
je 0x4575f
leaq 0x20(%rbx), %r13
leaq 0x62d95(%rip), %r14     # 0xa84c0
addq $0x10, %r14
movq (%r15), %rax
movq %rbx, %rdi
movq %r15, %rsi
callq *0x10(%rax)
cmpl $0x0, 0x8(%rbx)
jne 0x457d4
movq %r14, (%rbx)
movq 0x10(%rbx), %rdi
cmpq %r13, %rdi
je 0x45756
callq 0x1b4d0
addq $0x78, %r15
cmpq %r12, %r15
jne 0x4572f
movq -0x30(%rbp), %rax
movq 0x48(%rax), %r15
movq 0x50(%rax), %r14
cmpq %r14, %r15
je 0x457ab
leaq 0x20(%rbx), %r12
leaq 0x62d45(%rip), %r13     # 0xa84c0
addq $0x10, %r13
movq (%r15), %rax
movq %rbx, %rdi
movq %r15, %rsi
callq *0x10(%rax)
cmpl $0x0, 0x8(%rbx)
jne 0x457d4
movq %r13, (%rbx)
movq 0x10(%rbx), %rdi
cmpq %r12, %rdi
je 0x457a2
callq 0x1b4d0
addq $0x60, %r15
cmpq %r14, %r15
jne 0x4577f
movl $0x0, 0x8(%rbx)
leaq 0x62d07(%rip), %rax     # 0xa84c0
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x20(%rbx), %rax
movq %rax, 0x10(%rbx)
movq $0x0, 0x18(%rbx)
movb $0x0, 0x20(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
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::clara::detail::ResultValueBase<Catch::clara::detail::ParseState>::operator=(Catch::clara::detail::ResultValueBase<Catch::clara::detail::ParseState> const&)
auto operator=( ResultValueBase const &other ) -> ResultValueBase & {
            if( m_type == ResultBase::Ok )
                m_value.~T();
            ResultBase::operator=(other);
            if( m_type == ResultBase::Ok )
                new( &m_value ) T( other.m_value );
            return *this;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
cmpl $0x0, 0x8(%rdi)
jne 0x45f62
leaq 0x28(%rbx), %rdi
callq 0x43810
movl 0x8(%r14), %eax
movl %eax, 0x8(%rbx)
testl %eax, %eax
jne 0x45f8d
movl 0x10(%r14), %eax
movl %eax, 0x10(%rbx)
movups 0x18(%r14), %xmm0
movups %xmm0, 0x18(%rbx)
leaq 0x28(%rbx), %rdi
addq $0x28, %r14
movq %r14, %rsi
callq 0x43686
movq %rbx, %rax
popq %rbx
popq %r14
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::clara::TextFlow::Column::iterator::operator++()
auto operator ++() -> iterator& {
			m_pos += m_len;
			if (m_pos < line().size() && line()[m_pos] == '\n')
				m_pos += 1;
			else
				while (m_pos < line().size() && isWhitespace(line()[m_pos]))
					++m_pos;

			if (m_pos == line().size()) {
				m_pos = 0;
				++m_stringIndex;
			}
			if (m_stringIndex < m_column.m_strings.size())
				calcLength();
			return *this;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rcx
addq 0x18(%rdi), %rcx
movq %rcx, 0x10(%rdi)
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
movq (%rsi), %rdi
movq %rdx, %rax
shlq $0x5, %rax
cmpq 0x8(%rdi,%rax), %rcx
jae 0x46104
addq %rdi, %rax
movq (%rax), %r8
cmpb $0xa, (%r8,%rcx)
jne 0x46145
incq %rcx
movq %rcx, 0x10(%rbx)
movq %rdx, %rax
shlq $0x5, %rax
cmpq 0x8(%rdi,%rax), %rcx
jne 0x46121
movq $0x0, 0x10(%rbx)
incq %rdx
movq %rdx, 0x8(%rbx)
movq 0x8(%rsi), %rax
subq %rdi, %rax
sarq $0x5, %rax
cmpq %rax, %rdx
jae 0x46139
movq %rbx, %rdi
callq 0x4623a
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x64d2c(%rip), %r15     # 0xaae78
leaq 0x64d05(%rip), %r14     # 0xaae58
movq (%rax), %rax
movb (%rax,%rcx), %r12b
movb (%r15), %al
testb %al, %al
je 0x461a1
movsbl %r12b, %esi
movq %r14, %rdi
xorl %edx, %edx
callq 0x1b680
movq 0x10(%rbx), %rcx
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq (%rsi), %rdi
cmpq $-0x1, %rax
je 0x46104
incq %rcx
movq %rcx, 0x10(%rbx)
movq %rdx, %r8
shlq $0x5, %r8
leaq (%rdi,%r8), %rax
cmpq 0x8(%rdi,%r8), %rcx
jb 0x46153
jmp 0x46104
callq 0x1bb52
jmp 0x46161
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::clara::TextFlow::Column::iterator::iterator(Catch::clara::TextFlow::Column const&)
explicit iterator(Column const& column) : m_column(column) {
			assert(m_column.m_width > m_column.m_indent);
			assert(m_column.m_initialIndent == std::string::npos || m_column.m_width > m_column.m_initialIndent);
			calcLength();
			if (m_len == 0)
				m_stringIndex++; // Empty string
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movups %xmm0, 0x18(%rdi)
movb $0x0, 0x28(%rdi)
movq 0x18(%rsi), %rax
cmpq 0x20(%rsi), %rax
jbe 0x461fc
movq 0x28(%rsi), %rcx
cmpq $-0x1, %rcx
sete %dl
cmpq %rcx, %rax
seta %al
orb %dl, %al
je 0x4621b
movq %rdi, %rbx
callq 0x4623a
cmpq $0x0, 0x18(%rbx)
jne 0x461f5
addq $0x8, %rbx
incq (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x3655b(%rip), %rdi     # 0x7c75e
leaq 0x34ccb(%rip), %rsi     # 0x7aed5
leaq 0x36572(%rip), %rcx     # 0x7c783
movl $0x217c, %edx           # imm = 0x217C
callq 0x1b320
leaq 0x365a4(%rip), %rdi     # 0x7c7c6
leaq 0x34cac(%rip), %rsi     # 0x7aed5
leaq 0x36553(%rip), %rcx     # 0x7c783
movl $0x217d, %edx           # imm = 0x217D
callq 0x1b320
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::clara::TextFlow::Column::iterator::calcLength()
void calcLength() {
			assert(m_stringIndex < m_column.m_strings.size());

			m_suffix = false;
			auto width = m_column.m_width - indent();
			m_end = m_pos;
			if (line()[m_pos] == '\n') {
				++m_end;
			}
			while (m_end < line().size() && line()[m_end] != '\n')
				++m_end;

			if (m_end < m_pos + width) {
				m_len = m_end - m_pos;
			} else {
				size_t len = width;
				while (len > 0 && !isBoundary(m_pos + len))
					--len;
				while (len > 0 && isWhitespace(line()[m_pos + len - 1]))
					--len;

				if (len > 0) {
					m_len = len;
				} else {
					m_suffix = true;
					m_len = width - 1;
				}
			}
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %rsi
movq 0x8(%rdi), %rcx
movq (%rsi), %rdx
movq 0x8(%rsi), %rax
subq %rdx, %rax
sarq $0x5, %rax
cmpq %rax, %rcx
jae 0x4636c
movq %rdi, %rbx
movb $0x0, 0x28(%rdi)
movq 0x10(%rdi), %rax
movq %rax, %rdi
orq %rcx, %rdi
je 0x4627f
movq 0x20(%rsi), %rdi
jmp 0x46289
movq 0x28(%rsi), %rdi
cmpq $-0x1, %rdi
je 0x46279
movq 0x18(%rsi), %r15
movq %rax, 0x20(%rbx)
shlq $0x5, %rcx
leaq (%rdx,%rcx), %rsi
movq (%rdx,%rcx), %rcx
cmpb $0xa, (%rcx,%rax)
movq %rax, %r12
jne 0x462ae
leaq 0x1(%rax), %r12
movq %r12, 0x20(%rbx)
subq %rdi, %r15
movq 0x8(%rsi), %rdx
cmpq %rdx, %r12
jae 0x462d0
cmpb $0xa, (%rcx,%r12)
je 0x462d0
incq %r12
movq %r12, 0x20(%rbx)
cmpq %r12, %rdx
jne 0x462ba
movq %rdx, %r12
leaq (%r15,%rax), %rcx
cmpq %rcx, %r12
jae 0x462de
subq %rax, %r12
jmp 0x46308
testq %r15, %r15
je 0x462fe
movq %r15, %r12
movq 0x10(%rbx), %rsi
addq %r12, %rsi
movq %rbx, %rdi
callq 0x4638c
testb %al, %al
jne 0x4631b
decq %r12
jne 0x462e6
movb $0x1, 0x28(%rbx)
decq %r15
movq %r15, %r12
movq %r12, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x64b36(%rip), %r14     # 0xaae58
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movq (%rax), %rax
shlq $0x5, %rcx
movq (%rax,%rcx), %rax
addq 0x10(%rbx), %rax
movb -0x1(%r12,%rax), %r13b
leaq 0x64b34(%rip), %rax     # 0xaae78
movb (%rax), %al
testb %al, %al
je 0x46365
movsbl %r13b, %esi
movq %r14, %rdi
xorl %edx, %edx
callq 0x1b680
cmpq $-0x1, %rax
je 0x46308
decq %r12
jne 0x46322
jmp 0x462fe
callq 0x1bba9
jmp 0x4634a
leaq 0x364b0(%rip), %rdi     # 0x7c823
leaq 0x34b5b(%rip), %rsi     # 0x7aed5
leaq 0x364cc(%rip), %rcx     # 0x7c84d
movl $0x214e, %edx           # imm = 0x214E
callq 0x1b320
nop
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::clara::TextFlow::Column::iterator::isBoundary(unsigned long) const
auto isBoundary(size_t at) const -> bool {
			assert(at > 0);
			assert(at <= line().size());

			return at == line().size() ||
				(isWhitespace(line()[at]) && !isWhitespace(line()[at - 1])) ||
				isBreakableBefore(line()[at]) ||
				isBreakableAfter(line()[at - 1]);
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x464cd
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
movq (%rax), %rdx
shlq $0x5, %rcx
leaq (%rdx,%rcx), %rax
cmpq %rsi, 0x8(%rdx,%rcx)
jb 0x464ec
movb $0x1, %r15b
je 0x464bb
movq (%rax), %rax
movb (%rax,%rbx), %r13b
leaq 0x64a9b(%rip), %r12     # 0xaae78
movb (%r12), %al
testb %al, %al
je 0x4650b
movsbl %r13b, %esi
leaq 0x64a64(%rip), %rdi     # 0xaae58
xorl %edx, %edx
callq 0x1b680
cmpq $-0x1, %rax
je 0x4643c
movq (%r14), %rax
movq 0x8(%r14), %rcx
movq (%rax), %rax
shlq $0x5, %rcx
movq (%rax,%rcx), %rax
movb -0x1(%rax,%rbx), %r13b
movb (%r12), %al
testb %al, %al
je 0x4651f
movsbl %r13b, %esi
leaq 0x64a29(%rip), %rdi     # 0xaae58
xorl %edx, %edx
callq 0x1b680
cmpq $-0x1, %rax
je 0x464bb
movq (%r14), %rax
movq 0x8(%r14), %rcx
movq (%rax), %rax
shlq $0x5, %rcx
movq (%rax,%rcx), %rax
movb (%rax,%rbx), %r12b
leaq 0x649cf(%rip), %rax     # 0xaae28
movb (%rax), %al
testb %al, %al
je 0x46515
movsbl %r12b, %esi
leaq 0x6499a(%rip), %rdi     # 0xaae08
xorl %edx, %edx
callq 0x1b680
cmpq $-0x1, %rax
jne 0x464bb
movq (%r14), %rax
movq 0x8(%r14), %rcx
movq (%rax), %rax
shlq $0x5, %rcx
movq (%rax,%rcx), %rax
movb -0x1(%rax,%rbx), %bl
leaq 0x649b8(%rip), %rax     # 0xaae50
movb (%rax), %al
testb %al, %al
je 0x46529
movsbl %bl, %esi
leaq 0x64984(%rip), %rdi     # 0xaae30
xorl %edx, %edx
callq 0x1b680
cmpq $-0x1, %rax
setne %r15b
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x363b5(%rip), %rdi     # 0x7c889
leaq 0x349fa(%rip), %rsi     # 0x7aed5
leaq 0x363ae(%rip), %rcx     # 0x7c890
movl $0x2144, %edx           # imm = 0x2144
callq 0x1b320
leaq 0x363e5(%rip), %rdi     # 0x7c8d8
leaq 0x349db(%rip), %rsi     # 0x7aed5
leaq 0x3638f(%rip), %rcx     # 0x7c890
movl $0x2145, %edx           # imm = 0x2145
callq 0x1b320
callq 0x1bc00
jmp 0x463e9
callq 0x1bcae
jmp 0x46463
callq 0x1bc57
jmp 0x46424
callq 0x1bd07
jmp 0x464a2
nop
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::clara::TextFlow::Columns::iterator::operator++()
auto operator ++() -> iterator& {
			for (size_t i = 0; i < m_columns.size(); ++i) {
				if (m_iterators[i] != m_columns[i].end())
					++m_iterators[i];
			}
			return *this;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movq (%rax), %rcx
cmpq %rcx, 0x8(%rax)
je 0x46afb
xorl %r14d, %r14d
movabsq $-0x5555555555555555, %r15 # imm = 0xAAAAAAAAAAAAAAAB
xorl %r12d, %r12d
movq 0x8(%rbx), %rdx
leaq (%rdx,%r14), %rdi
cmpq $0x0, 0x10(%rdx,%r14)
jne 0x46ad5
movq 0x8(%rcx,%r14), %rsi
subq (%rcx,%r14), %rsi
sarq $0x5, %rsi
cmpq %rsi, 0x8(%rdx,%r14)
jne 0x46ad5
leaq (%rcx,%r14), %rdx
cmpq (%rdi), %rdx
je 0x46ae0
callq 0x460be
movq (%rbx), %rax
movq (%rax), %rcx
incq %r12
movq 0x8(%rax), %rdx
subq %rcx, %rdx
sarq $0x4, %rdx
imulq %r15, %rdx
addq $0x30, %r14
cmpq %rdx, %r12
jb 0x46aa8
movq %rbx, %rax
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::clara::detail::Parser::getHelpColumns() const
auto getHelpColumns() const -> std::vector<HelpColumns> {
            std::vector<HelpColumns> cols;
            for (auto const &o : m_options) {
                auto childCols = o.getHelpColumns();
                cols.insert( cols.end(), childCols.begin(), childCols.end() );
            }
            return cols;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x30(%rsi), %r14
movq 0x38(%rsi), %r12
cmpq %r12, %r14
je 0x47ad5
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x47c0e
movq 0x8(%rbx), %rsi
movq -0x38(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq %rbx, %rdi
callq 0x47fc2
movq %r15, %rdi
callq 0x47bda
addq $0x78, %r14
cmpq %r12, %r14
jne 0x47aa5
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x47af6
movq %rax, %r14
leaq -0x38(%rbp), %rdi
callq 0x47bda
movq %rbx, %rdi
callq 0x47bda
movq %r14, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::clara::detail::Opt::getHelpColumns() const
auto getHelpColumns() const -> std::vector<HelpColumns> {
            std::ostringstream oss;
            bool first = true;
            for( auto const &opt : m_optNames ) {
                if (first)
                    first = false;
                else
                    oss << ", ";
                oss << opt;
            }
            if( !m_hint.empty() )
                oss << " <" << m_hint << ">";
            return { { oss.str(), m_description } };
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
movq %rsi, %r14
movq %rdi, -0x38(%rbp)
leaq -0x1f0(%rbp), %rdi
callq 0x1b6d0
movq 0x60(%r14), %r13
movq 0x68(%r14), %rbx
cmpq %rbx, %r13
je 0x47c81
movb $0x1, %al
leaq -0x1f0(%rbp), %r15
leaq 0x33561(%rip), %r12     # 0x7b1b3
testb $0x1, %al
jne 0x47c66
movl $0x2, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x1b5e0
movq (%r13), %rsi
movq 0x8(%r13), %rdx
movq %r15, %rdi
callq 0x1b5e0
addq $0x20, %r13
xorl %eax, %eax
cmpq %rbx, %r13
jne 0x47c52
cmpq $0x0, 0x28(%r14)
je 0x47cc8
leaq 0x34f5b(%rip), %rsi     # 0x7cbea
leaq -0x1f0(%rbp), %rdi
movl $0x2, %edx
callq 0x1b5e0
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
leaq -0x1f0(%rbp), %rdi
callq 0x1b5e0
leaq 0x33cae(%rip), %rsi     # 0x7b969
movl $0x1, %edx
movq %rax, %rdi
callq 0x1b5e0
leaq -0x1e8(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0x1b7f0
leaq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rbx
movq %rbx, -0x10(%rbx)
movq 0x40(%r14), %rsi
movq 0x48(%r14), %rdx
addq %rsi, %rdx
callq 0x4a8c2
leaq -0x78(%rbp), %rsi
leaq -0x29(%rbp), %rcx
movl $0x1, %edx
movq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x47dea
movq -0x58(%rbp), %rdi
cmpq %rbx, %rdi
je 0x47d1b
callq 0x1b4d0
leaq -0x68(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x47d2d
callq 0x1b4d0
movq 0x6224c(%rip), %rsi     # 0xa9f80
leaq -0x1f0(%rbp), %rdi
callq 0x1b280
leaq -0x180(%rbp), %rdi
callq 0x1b170
movq %r14, %rax
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x47db4
jmp 0x47d8d
movq %rax, %rbx
leaq -0x68(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x47d8d
callq 0x1b4d0
jmp 0x47d8d
jmp 0x47d8a
jmp 0x47d8a
movq %rax, %rbx
movq 0x621ec(%rip), %rsi     # 0xa9f80
leaq -0x1f0(%rbp), %rdi
callq 0x1b280
leaq -0x180(%rbp), %rdi
callq 0x1b170
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::MatchExpr<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Catch::Matchers::Impl::MatcherBase<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>> const&>::streamReconstructedExpression(std::ostream&) const
void streamReconstructedExpression( std::ostream &os ) const override {
            auto matcherAsString = m_matcher.toString();
            os << Catch::Detail::stringify( m_arg ) << ' ';
            if( matcherAsString == Detail::unprintableString )
                os << m_matcherString;
            else
                os << matcherAsString;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rsi
leaq -0x48(%rbp), %rdi
callq 0x26674
movq 0x10(%r14), %rsi
leaq -0x68(%rbp), %rdi
callq 0x31376
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
movq %rbx, %rdi
callq 0x1b5e0
leaq -0x21(%rbp), %rsi
movb $0x20, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x1b5e0
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4a9c5
callq 0x1b4d0
movq -0x40(%rbp), %r15
leaq 0x603c8(%rip), %rax     # 0xaad98
cmpq 0x8(%rax), %r15
jne 0x4aa03
testq %r15, %r15
je 0x4a9f1
movq (%rax), %rsi
movq -0x48(%rbp), %r12
movq %r12, %rdi
movq %r15, %rdx
callq 0x1b570
testl %eax, %eax
jne 0x4aa07
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
movq %rbx, %rdi
callq 0x1b690
jmp 0x4aa15
movq -0x48(%rbp), %r12
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x1b5e0
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4aa27
callq 0x1b4d0
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4aa36
movq %rax, %rbx
jmp 0x4aa50
movq %rax, %rbx
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4aa50
callq 0x1b4d0
leaq -0x38(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4aa62
callq 0x1b4d0
movq %rbx, %rdi
callq 0x1b910