LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::(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 0x3b49f
movq %rdi, %rbx
movq (%rdi), %rdi
pushq $0x3b
popq %rsi
callq 0x24670
leaq -0x9(%rbp), %rdi
pushq $0x17
popq %rsi
callq 0x29a20
movq (%rbx), %rdi
leaq 0x3a8f2(%rip), %rsi     # 0x75d7b
callq 0x24570
leaq -0x9(%rbp), %rdi
callq 0x29ba2
movq %rbx, %rdi
callq 0x3b19c
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x9(%rbp), %rdi
callq 0x29ba2
movq %rbx, %rdi
callq 0x24950
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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 %r14
pushq %rbx
movq 0x72288(%rip), %rax     # 0xaee40
testq %rax, %rax
jne 0x3cd0b
movl $0x150, %edi            # imm = 0x150
callq 0x24580
movq %rax, %rbx
leaq 0x6f5d3(%rip), %rax     # 0xac1a8
movq %rax, (%rbx)
leaq 0x6f649(%rip), %rax     # 0xac228
movq %rax, 0x8(%rbx)
leaq 0x6f696(%rip), %rax     # 0xac280
movq %rax, 0x10(%rbx)
leaq 0x18(%rbx), %rdi
callq 0x57786
leaq 0x6d59a(%rip), %rax     # 0xaa198
addq $0x10, %rax
movq %rax, 0x68(%rbx)
andl $0x0, 0x78(%rbx)
andq $0x0, 0x80(%rbx)
leaq 0x78(%rbx), %rax
movq %rax, 0x88(%rbx)
movq %rax, 0x90(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x98(%rbx)
movups %xmm0, 0xa8(%rbx)
leaq 0x6d184(%rip), %rax     # 0xa9dc0
addq $0x10, %rax
movq %rax, 0xb8(%rbx)
andq $0x0, 0xd0(%rbx)
movups %xmm0, 0xc0(%rbx)
leaq 0x6d79b(%rip), %rax     # 0xaa3f8
addq $0x10, %rax
movq %rax, 0xd8(%rbx)
andl $0x0, 0xe8(%rbx)
movl $0xe8, %eax
andq $0x0, 0xf0(%rbx)
leaq (%rbx,%rax), %rcx
movq %rcx, 0xf8(%rbx)
movq %rcx, 0x100(%rbx)
movups %xmm0, 0x108(%rbx)
movups %xmm0, 0x118(%rbx)
leaq 0x6e0dd(%rip), %rcx     # 0xaad80
addq $0x10, %rcx
movq %rcx, 0x128(%rbx)
movups %xmm0, 0x130(%rbx)
andq $0x0, 0x140(%rbx)
movq %rbx, %rdi
addq $0x148, %rdi            # imm = 0x148
leaq 0x6f342(%rip), %rcx     # 0xac010
movq %rcx, (%rbx)
leaq 0x6f328(%rip), %rcx     # 0xac000
leaq 0x6f3b1(%rip), %rdx     # 0xac090
movq %rdx, 0x8(%rbx)
addq %rax, %rcx
movq %rcx, 0x10(%rbx)
leaq 0x6f417(%rip), %rax     # 0xac108
movq %rax, 0x148(%rbx)
movq %rbx, 0x72141(%rip)     # 0xaee40
callq 0x30d7c
movq 0x72135(%rip), %rax     # 0xaee40
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x24540
movq %r14, %rdi
callq 0x24950
nop
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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 %r14
pushq %rbx
subq $0x90, %rsp
movq %rdi, %rbx
leaq -0x38(%rbp), %rax
movq %rsi, (%rax)
movq %rax, %rsi
callq 0x4246e
leaq 0x6f0c7(%rip), %rax     # 0xac738
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x37a3b(%rip), %rsi     # 0x750ba
leaq -0x38(%rbp), %rdi
leaq -0x14(%rbp), %rdx
callq 0x24210
leaq 0x40(%rbx), %rdi
leaq -0x38(%rbp), %rsi
callq 0x242f0
leaq 0x37a34(%rip), %rsi     # 0x750d4
leaq -0x98(%rbp), %rdi
leaq -0x13(%rbp), %rdx
callq 0x24210
leaq 0x60(%rbx), %r14
leaq -0x98(%rbp), %rsi
movq %r14, %rdi
callq 0x3f2ea
leaq 0x37a0d(%rip), %rsi     # 0x750d7
leaq -0x78(%rbp), %rdi
leaq -0x12(%rbp), %rdx
callq 0x24210
leaq -0x78(%rbp), %rsi
movq %r14, %rdi
callq 0x3f2ea
leaq 0x379f0(%rip), %rsi     # 0x750da
leaq -0x58(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0x24210
leaq -0x58(%rbp), %rsi
movq %r14, %rdi
callq 0x3f2ea
andl $0x0, 0x8(%rbx)
leaq -0x58(%rbp), %rdi
callq 0x24ad8
leaq -0x78(%rbp), %rdi
callq 0x24ad8
leaq -0x98(%rbp), %rdi
callq 0x24ad8
leaq -0x38(%rbp), %rdi
callq 0x24ad8
addq $0x90, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
leaq -0x58(%rbp), %rdi
callq 0x24ad8
jmp 0x3d74d
jmp 0x3d74a
movq %rax, %r14
leaq -0x78(%rbp), %rdi
callq 0x24ad8
jmp 0x3d75d
jmp 0x3d75a
movq %rax, %r14
leaq -0x98(%rbp), %rdi
callq 0x24ad8
jmp 0x3d770
jmp 0x3d76d
movq %rax, %r14
leaq -0x38(%rbp), %rdi
callq 0x24ad8
movq %rbx, %rdi
callq 0x3da48
movq %r14, %rdi
callq 0x24950
movq %rax, %r14
jmp 0x3d779
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x88, %rsp
movq %rsi, %r12
movq %rdi, %rbx
leaq -0xa8(%rbp), %r14
movq %r14, %rdi
callq 0x4458c
movq 0x8(%r12), %rax
subq (%r12), %rax
sarq $0x5, %rax
leaq -0x78(%rbp), %r15
movq %r12, (%r15)
movq %rax, 0x8(%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r15)
movups %xmm0, 0x19(%r15)
movb $0x1, %r13b
leaq -0x48(%rbp), %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x443f6
testb %al, %al
je 0x3e2ae
movq %r12, %rdi
movq %r14, %rsi
callq 0x44404
testb $0x1, %r13b
jne 0x3e28e
movq %rbx, %rdi
leaq 0x3ef55(%rip), %rsi     # 0x7d1de
callq 0x24570
movq %rbx, %rdi
movq %r12, %rsi
callq 0x24510
movq %r12, %rdi
callq 0x24ad8
movq %r14, %rdi
callq 0x444ca
xorl %r13d, %r13d
jmp 0x3e25f
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x24ad8
movq %rbx, %rdi
callq 0x24950
nop
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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, %rbx
movq %rdi, %r14
leaq -0x78(%rbp), %rdi
callq 0x44f22
leaq -0x50(%rbp), %rdi
movq %rbx, %rsi
callq 0x45262
leaq -0x70(%rbp), %r15
movb $0x1, %bl
leaq -0x98(%rbp), %r12
leaq -0x78(%rbp), %r13
movq %r15, %rdi
leaq -0x48(%rbp), %rsi
callq 0x4530e
testb %al, %al
je 0x3e46b
movq %r12, %rdi
movq %r13, %rsi
callq 0x44c94
testb $0x1, %bl
jne 0x3e44c
movq %r14, %rdi
leaq 0x3ed97(%rip), %rsi     # 0x7d1de
callq 0x24570
movq %r14, %rdi
movq %r12, %rsi
callq 0x24510
movq %r12, %rdi
callq 0x24ad8
xorl %ebx, %ebx
movq %r13, %rdi
callq 0x44e86
jmp 0x3e41d
leaq -0x48(%rbp), %rdi
callq 0x4524e
movq %r15, %rdi
callq 0x4524e
movq %r14, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x3e4b2
jmp 0x3e4a6
movq %rax, %r14
leaq -0x98(%rbp), %rdi
callq 0x24ad8
jmp 0x3e4a9
movq %rax, %r14
leaq -0x48(%rbp), %rdi
callq 0x4524e
leaq -0x70(%rbp), %rdi
callq 0x4524e
movq %r14, %rdi
callq 0x24950
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::clara::TextFlow::Column::operator+(Catch::clara::TextFlow::Column const&)
inline auto Column::operator + (Column const& other) -> Columns {
	Columns cols;
	cols += *this;
	cols += other;
	return cols;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
callq 0x453c6
movq %rbx, %rdi
movq %r14, %rsi
callq 0x453c6
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x45646
movq %r14, %rdi
callq 0x24950
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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 0x3f178
movq -0x8(%rcx), %rax
addq $-0x8, %rcx
movq %rcx, 0x20(%rbx)
jmp 0x3f1b9
movl $0x178, %edi            # imm = 0x178
callq 0x24580
movq %rax, %r14
movq %rax, %rdi
callq 0x24740
leaq -0x18(%rbp), %rsi
movq %r14, (%rsi)
movq %rbx, %rdi
callq 0x47e14
movq -0x18(%rbp), %rdi
testq %rdi, %rdi
je 0x3f1ab
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 0x3f1e1
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x3f1e1
movq %rax, %rbx
movq %r14, %rdi
callq 0x24540
movq %rbx, %rdi
callq 0x24950
nop
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: 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 0x3fca7
movl %esi, %r14d
leaq -0x38(%rbp), %r15
movq %r15, %rdi
callq 0x30e18
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)
movss -0x1c(%rbp), %xmm0
callq 0x24450
movq -0x28(%rbp), %rsi
addq $0x8, %rsi
movq %rbx, %rdi
callq 0x24830
pushq $0x30
popq %rsi
pushq $-0x1
popq %rdx
movq %rbx, %rdi
callq 0x243e0
cmpq $-0x1, %rax
je 0x3fc90
movq 0x8(%rbx), %rcx
decq %rcx
cmpq %rcx, %rax
je 0x3fc90
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 0x245e0
leaq -0x58(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x24690
movq %r14, %rdi
callq 0x24ad8
leaq -0x38(%rbp), %rdi
callq 0x30e5e
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x36d63(%rip), %rsi     # 0x76a11
leaq -0x58(%rbp), %rdx
movq %rbx, %rdi
callq 0x24210
jmp 0x3fc99
movq %rax, %r14
movq %rbx, %rdi
callq 0x24ad8
jmp 0x3fcce
jmp 0x3fccb
movq %rax, %r14
leaq -0x38(%rbp), %rdi
callq 0x30e5e
movq %r14, %rdi
callq 0x24950
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::TablePrinter::close()
void close() {
        if (m_isOpen) {
            *this << RowBreak();
            m_os << std::endl;
            m_isOpen = false;
        }
    }

// Assembly:
cmpb $0x1, 0x19c(%rdi)
jne 0x40238
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x198(%rdi)
jle 0x40223
movq (%rbx), %rdi
pushq $0xa
popq %rsi
callq 0x24670
orl $-0x1, 0x198(%rbx)
movq (%rbx), %rdi
callq 0x242a0
movb $0x0, 0x19c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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 $0x78, %rsp
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r14
leaq -0x78(%rbp), %r15
movq %r15, %rdi
callq 0x30e18
movq 0x10(%r15), %rdi
movq %rbx, %rsi
callq 0x243c0
movq %r14, -0x40(%rbp)
movq -0x68(%rbp), %rsi
addq $0x8, %rsi
leaq -0x60(%rbp), %rdi
callq 0x24830
leaq 0x28(%r13), %rax
movq %rax, -0x38(%rbp)
movq 0x28(%r13), %r12
movq %r13, -0x30(%rbp)
movq 0x30(%r13), %r14
leaq -0x98(%rbp), %r13
pushq $0x20
popq %rbx
leaq -0x60(%rbp), %r15
cmpq %r14, %r12
je 0x403b6
movq 0x8(%r12), %rax
movq -0x58(%rbp), %rcx
cmpq %rcx, %rax
jae 0x403ab
movq %r13, %rdi
movl %ebx, %esi
movq %r12, %rdx
callq 0x3fb60
movq %r12, %rdi
movq %r13, %rsi
callq 0x24690
movq %r13, %rdi
callq 0x24ad8
jmp 0x40352
movq %r13, %rdi
movl %ebx, %esi
movq %r15, %rdx
callq 0x3fb60
movq %r15, %rdi
movq %r13, %rsi
callq 0x24690
movq %r13, %rdi
callq 0x24ad8
movq 0x8(%r12), %rax
movq -0x58(%rbp), %rcx
cmpq %rcx, %rax
ja 0x40382
addq $0x20, %r12
jmp 0x4034d
leaq -0x60(%rbp), %rsi
movq -0x38(%rbp), %rdi
callq 0x3f2ea
movq -0x40(%rbp), %rbx
movq %rbx, %rdi
movq -0x30(%rbp), %rsi
callq 0x4046c
leaq -0x60(%rbp), %rdi
callq 0x24ad8
leaq -0x78(%rbp), %rdi
callq 0x30e5e
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x403f9
movq %rax, %rbx
jmp 0x4040e
jmp 0x40402
jmp 0x40402
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x24ad8
leaq -0x78(%rbp), %rdi
callq 0x30e5e
movq %rbx, %rdi
callq 0x24950
nop
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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 0x4070d
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsi), %rdi
callq 0x34f56
movq 0xc0(%r14), %rax
movl $0xa0, %edi
addq -0x10(%rax), %rdi
movq %rbx, %rsi
callq 0x5d232
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x343cb(%rip), %rdi     # 0x74adf
leaq 0x33792(%rip), %rsi     # 0x73ead
leaq 0x36322(%rip), %rcx     # 0x76a44
movl $0x1712, %edx           # imm = 0x1712
callq 0x24390
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x28(%rbp), %rdi
callq 0x5d546
movq 0xc0(%r14), %rax
cmpq 0xb8(%r14), %rax
jne 0x407d3
movl $0x138, %edi            # imm = 0x138
addq -0x28(%rbp), %rdi
leaq 0x98(%r14), %r15
movq %r15, %rsi
callq 0x5d566
leaq 0x50(%r14), %rdi
leaq -0x28(%rbp), %rsi
callq 0x5d5a2
movq %r15, %rdi
callq 0x5d5de
movq 0xa8(%r14), %rdi
testq %rdi, %rdi
je 0x407f2
leaq 0xe8(%rbx), %rsi
addq $0xb8, %rdi
callq 0x242f0
addq $0x108, %rbx            # imm = 0x108
movl $0xd8, %edi
addq 0xa8(%r14), %rdi
movq %rbx, %rsi
callq 0x242f0
leaq -0x20(%rbp), %rdi
callq 0x423de
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x362f5(%rip), %rdi     # 0x76acf
leaq 0x336cc(%rip), %rsi     # 0x73ead
leaq 0x36302(%rip), %rcx     # 0x76aea
movl $0x1725, %edx           # imm = 0x1725
callq 0x24390
leaq 0x3637a(%rip), %rdi     # 0x76b73
leaq 0x336ad(%rip), %rsi     # 0x73ead
leaq 0x362e3(%rip), %rcx     # 0x76aea
movl $0x172a, %edx           # imm = 0x172A
callq 0x24390
movq %rax, %rbx
leaq -0x20(%rbp), %rdi
callq 0x423de
movq %rbx, %rdi
callq 0x24950
nop
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: 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
cmpb $0x0, 0x188(%rdi)
je 0x4101c
pushq $0x1
popq %rax
jmp 0x41028
movq %rdi, %rbx
callq 0x30288
testl %eax, %eax
je 0x4102f
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3048a
nop
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::CumulativeReporterBase<Catch::JunitReporter>::sectionStarting(Catch::SectionInfo const&)
void sectionStarting( SectionInfo const& sectionInfo ) override {
            SectionStats incompleteStats( sectionInfo, Counts(), 0, false );
            std::shared_ptr<SectionNode> node;
            if( m_sectionStack.empty() ) {
                if( !m_rootSection )
                    m_rootSection = std::make_shared<SectionNode>( incompleteStats );
                node = m_rootSection;
            }
            else {
                SectionNode& parentNode = *m_sectionStack.back();
                auto it =
                    std::find_if(   parentNode.childSections.begin(),
                                    parentNode.childSections.end(),
                                    BySectionInfo( sectionInfo ) );
                if( it == parentNode.childSections.end() ) {
                    node = std::make_shared<SectionNode>( incompleteStats );
                    parentNode.childSections.push_back( node );
                }
                else
                    node = *it;
            }
            m_sectionStack.push_back( node );
            m_deepestSection = std::move(node);
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xb8, %rsp
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq -0x40(%rbp), %r14
movaps %xmm0, (%r14)
andq $0x0, 0x10(%r14)
leaq -0xc8(%rbp), %rdi
xorps %xmm0, %xmm0
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x2ab66
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
movq 0xc0(%rbx), %rax
cmpq %rax, 0xb8(%rbx)
je 0x4180c
movq -0x10(%rax), %r14
movq 0x88(%r14), %rdi
movq 0x90(%r14), %rsi
leaq -0x48(%rbp), %rdx
movq %r15, (%rdx)
callq 0x5ea79
movq %rax, %r15
cmpq 0x90(%r14), %rax
jne 0x41842
leaq -0x28(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
callq 0x5ea5a
addq $0x88, %r14
leaq -0x40(%rbp), %r15
leaq -0x28(%rbp), %rsi
movq %r15, %rdi
callq 0x5ed70
leaq -0x20(%rbp), %rdi
callq 0x423de
movq %r14, %rdi
movq %r15, %rsi
callq 0x5d566
jmp 0x4184e
leaq 0x98(%rbx), %r15
cmpq $0x0, 0x98(%rbx)
jne 0x41842
leaq -0x28(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
callq 0x5ea5a
leaq -0x28(%rbp), %rsi
movq %r15, %rdi
callq 0x5ed70
leaq -0x20(%rbp), %rdi
callq 0x423de
leaq -0x40(%rbp), %rdi
movq %r15, %rsi
callq 0x5edaa
leaq 0xb8(%rbx), %rdi
leaq -0x40(%rbp), %rsi
callq 0x5d566
addq $0xa8, %rbx
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0x5ed70
leaq -0x38(%rbp), %rdi
callq 0x423de
leaq -0xc8(%rbp), %rdi
callq 0x2abc0
addq $0xb8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4189a
jmp 0x4189a
jmp 0x4189a
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x423de
leaq -0xc8(%rbp), %rdi
callq 0x2abc0
movq %rbx, %rdi
callq 0x24950
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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 %rbx
pushq %rax
movq 0xc0(%rdi), %rax
cmpq %rax, 0xb8(%rdi)
je 0x418fb
movq %rdi, %rbx
addq $0xb8, %rbx
movq -0x10(%rax), %rdi
addq $0x8, %rdi
callq 0x5ef20
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x5ef5c
leaq 0x331dd(%rip), %rdi     # 0x74adf
leaq 0x325a4(%rip), %rsi     # 0x73ead
leaq 0x35274(%rip), %rcx     # 0x76b84
movl $0x171e, %edx           # imm = 0x171E
callq 0x24390
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x10, %rsp
movq %rdi, %rbx
leaq -0x20(%rbp), %r14
movq %r14, %rdi
callq 0x5efaa
movq (%r14), %rdi
addq $0x70, %rdi
leaq 0x68(%rbx), %rsi
callq 0x5f280
leaq 0x80(%rbx), %rdi
movq %r14, %rsi
callq 0x5efca
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x90(%rax)
leaq -0x18(%rbp), %rdi
callq 0x423de
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x18(%rbp), %rdi
callq 0x423de
movq %rbx, %rdi
callq 0x24950
nop
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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 0x41da7
popq %rbp
retq
cmpl $0x2, %eax
je 0x41dd0
cmpl $0x1, %eax
jne 0x41def
leaq 0x3314f(%rip), %rdi     # 0x74f07
leaq 0x320ee(%rip), %rsi     # 0x73ead
leaq 0x33162(%rip), %rcx     # 0x74f28
movl $0x233d, %edx           # imm = 0x233D
callq 0x24390
leaq 0x331a0(%rip), %rdi     # 0x74f77
leaq 0x320cf(%rip), %rsi     # 0x73ead
leaq 0x33143(%rip), %rcx     # 0x74f28
movl $0x233e, %edx           # imm = 0x233E
callq 0x24390
callq 0x24310
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x60(%rsi), %rax
movq 0x68(%rsi), %rcx
cmpq %rcx, %rax
je 0x42553
cmpq %rcx, %rax
je 0x42575
cmpq $0x0, 0x8(%rax)
je 0x4259a
movq (%rax), %rdx
addq $0x20, %rax
cmpb $0x2d, (%rdx)
je 0x42519
leaq 0x32be0(%rip), %rsi     # 0x75118
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x24210
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x42ca6
jmp 0x425ba
leaq 0x32b87(%rip), %rsi     # 0x750e1
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x24210
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x42ca6
jmp 0x425ba
andl $0x0, 0x8(%rbx)
leaq 0x69f70(%rip), %rax     # 0xac4f0
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x20(%rbx), %rax
movq %rax, 0x10(%rbx)
andq $0x0, 0x18(%rbx)
movb $0x0, 0x20(%rbx)
jmp 0x425c3
leaq 0x32b5b(%rip), %rsi     # 0x750fc
leaq -0x30(%rbp), %rdi
leaq -0x9(%rbp), %rdx
callq 0x24210
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
callq 0x42ca6
leaq -0x30(%rbp), %rdi
callq 0x24ad8
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
jmp 0x425d5
jmp 0x425e3
jmp 0x425d5
jmp 0x425e3
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x24ad8
jmp 0x425e6
movq %rax, %rbx
movq %rbx, %rdi
callq 0x24950
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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, %r14
leaq -0x48(%rbp), %rbx
movq %rbx, %rdi
callq 0x24760
movq 0x60(%r14), %rax
movq 0x68(%r14), %r13
leaq -0x68(%rbp), %r14
movq %rax, %r15
cmpq %r13, %rax
je 0x42e4e
movq %r14, %rdi
movq %r15, %rsi
callq 0x24760
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3e788
movl %eax, %r12d
movq %r14, %rdi
callq 0x24ad8
leaq 0x20(%r15), %rax
testb %r12b, %r12b
je 0x42e1c
cmpq %r13, %r15
setne %bl
leaq -0x48(%rbp), %rdi
callq 0x24ad8
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x24ad8
movq %rbx, %rdi
callq 0x24950
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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
pushq $0x28
popq %rcx
cqto
idivq %rcx
cmpq $0x2, %rax
jb 0x42f17
leaq 0x10(%rbx), %rdi
callq 0x42f58
jmp 0x42f2f
movq (%rbx), %rax
cmpq 0x8(%rbx), %rax
je 0x42f27
addq $0x20, %rax
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0x42f62
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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 %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x20(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x30(%rbp), %rax
movq %rdx, %rsi
movq %rax, %rdx
callq 0x4229e
cmpl $0x0, 0x8(%rbx)
jne 0x43bdb
movq 0x8(%r14), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3f2ea
leaq -0x30(%rbp), %rdi
callq 0x24ad8
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x422de
jmp 0x43c00
movq %rax, %r14
leaq -0x30(%rbp), %rdi
callq 0x24ad8
movq %r14, %rdi
callq 0x24950
nop
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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 %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x30(%rsi), %r15
movq 0x38(%rsi), %r12
cmpq %r12, %r15
je 0x43cc4
movq (%r15), %rax
movq %rbx, %rdi
movq %r15, %rsi
callq *0x10(%rax)
cmpl $0x0, 0x8(%rbx)
jne 0x43d14
movq %rbx, %rdi
callq 0x41d62
addq $0x78, %r15
jmp 0x43c9f
movq 0x48(%r14), %r15
movq 0x50(%r14), %r14
cmpq %r14, %r15
je 0x43cf1
movq (%r15), %rax
movq %rbx, %rdi
movq %r15, %rsi
callq *0x10(%rax)
cmpl $0x0, 0x8(%rbx)
jne 0x43d14
movq %rbx, %rdi
callq 0x41d62
addq $0x60, %r15
jmp 0x43ccc
andl $0x0, 0x8(%rbx)
leaq 0x687f4(%rip), %rax     # 0xac4f0
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x20(%rbx), %rax
movq %rax, 0x10(%rbx)
andq $0x0, 0x18(%rbx)
movb $0x0, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::clara::detail::ExeName::set(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
auto set( std::string const& newName ) -> ParserResult {

            auto lastSlash = newName.find_last_of( "\\/" );
            auto filename = ( lastSlash == std::string::npos )
                    ? newName
                    : newName.substr( lastSlash+1 );

            *m_name = filename;
            if( m_ref )
                return m_ref->setValue( filename );
            else
                return ParserResult::ok( ParseResultType::Matched );
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x31443(%rip), %rsi     # 0x755c4
pushq $-0x1
popq %rdx
movq %r15, %rdi
callq 0x24550
cmpq $-0x1, %rax
je 0x441a9
incq %rax
leaq -0x38(%rbp), %rdi
pushq $-0x1
popq %rcx
movq %r15, %rsi
movq %rax, %rdx
callq 0x245e0
jmp 0x441b5
leaq -0x38(%rbp), %rdi
movq %r15, %rsi
callq 0x24760
movq 0x8(%r14), %rdi
leaq -0x38(%rbp), %rsi
callq 0x242f0
movq 0x18(%r14), %rsi
testq %rsi, %rsi
je 0x441da
movq (%rsi), %rax
leaq -0x38(%rbp), %rdx
movq %rbx, %rdi
callq *0x20(%rax)
jmp 0x441fe
andq $0x0, 0x8(%rbx)
leaq 0x684d2(%rip), %rax     # 0xac6b8
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x20(%rbx), %rax
movq %rax, 0x10(%rbx)
andq $0x0, 0x18(%rbx)
movb $0x0, 0x20(%rbx)
leaq -0x38(%rbp), %rdi
callq 0x24ad8
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x24ad8
movq %rbx, %rdi
callq 0x24950
nop
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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 0x442a8
leaq 0x28(%rbx), %rdi
callq 0x420d0
movl 0x8(%r14), %eax
movl %eax, 0x8(%rbx)
testl %eax, %eax
jne 0x442c3
leaq 0x10(%rbx), %rdi
addq $0x10, %r14
movq %r14, %rsi
callq 0x41ee0
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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 %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rsi
addq 0x18(%rdi), %rsi
movq %rsi, 0x10(%rdi)
movq (%rdi), %rdx
movq 0x8(%rdi), %rcx
movq (%rdx), %rax
movq %rcx, %r8
shlq $0x5, %r8
movq 0x8(%rax,%r8), %rdi
cmpq %rdi, %rsi
jae 0x44510
addq %rax, %r8
movq (%r8), %r8
cmpb $0xa, (%r8,%rsi)
jne 0x44510
incq %rsi
movq %rsi, 0x10(%rbx)
jmp 0x44550
cmpq %rdi, %rsi
jae 0x44550
shlq $0x5, %rcx
movq (%rax,%rcx), %rax
movsbl (%rax,%rsi), %edi
callq 0x4483b
movq 0x10(%rbx), %rsi
movq (%rbx), %rdx
movq 0x8(%rbx), %rcx
testb %al, %al
je 0x4454d
incq %rsi
movq %rsi, 0x10(%rbx)
movq (%rdx), %rax
movq %rcx, %rdi
shlq $0x5, %rdi
movq 0x8(%rax,%rdi), %rdi
jmp 0x44510
movq (%rdx), %rax
movq %rcx, %rdi
shlq $0x5, %rdi
cmpq 0x8(%rax,%rdi), %rsi
jne 0x4456a
andq $0x0, 0x10(%rbx)
incq %rcx
movq %rcx, 0x8(%rbx)
movq 0x8(%rdx), %rdx
subq %rax, %rdx
sarq $0x5, %rdx
cmpq %rdx, %rcx
jae 0x44582
movq %rbx, %rdi
callq 0x4461e
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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 0x445e0
movq 0x28(%rsi), %rcx
cmpq $-0x1, %rcx
sete %dl
cmpq %rcx, %rax
seta %al
orb %dl, %al
je 0x445ff
movq %rdi, %rbx
callq 0x4461e
cmpq $0x0, 0x18(%rbx)
jne 0x445d9
addq $0x8, %rbx
incq (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x3114f(%rip), %rdi     # 0x75736
leaq 0x2f8bf(%rip), %rsi     # 0x73ead
leaq 0x31166(%rip), %rcx     # 0x7575b
movl $0x217c, %edx           # imm = 0x217C
callq 0x24390
leaq 0x31198(%rip), %rdi     # 0x7579e
leaq 0x2f8a0(%rip), %rsi     # 0x73ead
leaq 0x31147(%rip), %rcx     # 0x7575b
movl $0x217d, %edx           # imm = 0x217D
callq 0x24390
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
movq (%rdi), %rax
movq 0x8(%rax), %rcx
subq (%rax), %rcx
sarq $0x5, %rcx
cmpq %rcx, 0x8(%rdi)
jae 0x44710
movq %rdi, %rbx
movb $0x0, 0x28(%rdi)
movq 0x18(%rax), %r14
callq 0x44730
movq 0x10(%rbx), %rcx
movq %rcx, 0x20(%rbx)
movq (%rbx), %rdx
movq 0x8(%rbx), %rdi
movq (%rdx), %rdx
shlq $0x5, %rdi
leaq (%rdx,%rdi), %rsi
movq (%rdx,%rdi), %rdx
cmpb $0xa, (%rdx,%rcx)
movq %rcx, %r15
jne 0x44680
leaq 0x1(%rcx), %r15
movq %r15, 0x20(%rbx)
subq %rax, %r14
movq 0x8(%rsi), %rax
cmpq %rax, %r15
jae 0x4469c
cmpb $0xa, (%rdx,%r15)
je 0x4469c
incq %r15
movq %r15, 0x20(%rbx)
jmp 0x44687
leaq (%rcx,%r14), %rax
cmpq %rax, %r15
jae 0x446aa
subq %rcx, %r15
jmp 0x44703
movq %r14, %r15
movq %r15, %r12
subq $0x1, %r15
jb 0x446f0
movq 0x10(%rbx), %rsi
addq %r12, %rsi
movq %rbx, %rdi
callq 0x44752
testb %al, %al
je 0x446ad
jmp 0x446f0
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
movq (%rax), %rax
shlq $0x5, %rcx
movq (%rax,%rcx), %rax
addq 0x10(%rbx), %rax
movsbl -0x1(%r15,%rax), %edi
callq 0x4483b
testb %al, %al
je 0x44703
movq %r12, %r15
subq $0x1, %r12
jae 0x446cb
movb $0x1, 0x28(%rbx)
decq %r14
movq %r14, %r15
movq %r15, 0x18(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x310e4(%rip), %rdi     # 0x757fb
leaq 0x2f78f(%rip), %rsi     # 0x73ead
leaq 0x31100(%rip), %rcx     # 0x75825
movl $0x214e, %edx           # imm = 0x214E
callq 0x24390
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
testq %rsi, %rsi
je 0x447fd
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 0x4481c
je 0x447d6
movq (%rax), %rax
movsbl (%rax,%rbx), %edi
callq 0x4483b
testb %al, %al
je 0x447b7
movq (%r14), %rax
movq 0x8(%r14), %rcx
movq (%rax), %rax
shlq $0x5, %rcx
movq (%rax,%rcx), %rax
movsbl -0x1(%rax,%rbx), %edi
callq 0x4483b
testb %al, %al
je 0x447d6
movq (%r14), %rax
movq 0x8(%r14), %rcx
movq (%rax), %rax
shlq $0x5, %rcx
movq (%rax,%rcx), %rax
movsbl (%rax,%rbx), %edi
callq 0x448d5
testb %al, %al
je 0x447dd
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
movq (%r14), %rax
movq 0x8(%r14), %rcx
movq (%rax), %rax
shlq $0x5, %rcx
movq (%rax,%rcx), %rax
movsbl -0x1(%rax,%rbx), %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x4496f
leaq 0x3105d(%rip), %rdi     # 0x75861
leaq 0x2f6a2(%rip), %rsi     # 0x73ead
leaq 0x31056(%rip), %rcx     # 0x75868
movl $0x2144, %edx           # imm = 0x2144
callq 0x24390
leaq 0x3108d(%rip), %rdi     # 0x758b0
leaq 0x2f683(%rip), %rsi     # 0x73ead
leaq 0x31037(%rip), %rcx     # 0x75868
movl $0x2145, %edx           # imm = 0x2145
callq 0x24390
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::clara::TextFlow::Columns::iterator::operator*[abi:cxx11]() const
auto operator *() const -> std::string {
			std::string row, padding;

			for (size_t i = 0; i < m_columns.size(); ++i) {
				auto width = m_columns[i].width();
				if (m_iterators[i] != m_columns[i].end()) {
					std::string col = *m_iterators[i];
					row += padding + col;
					if (col.size() < width)
						padding = std::string(width - col.size(), ' ');
					else
						padding = "";
				} else {
					padding += std::string(width, ' ');
				}
			}
			return row;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r8
xorl %r13d, %r13d
leaq -0x50(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movq %rdi, -0x30(%rbp)
movb %r13b, 0x10(%rdi)
movb %r13b, (%rax)
leaq -0x90(%rbp), %rbx
leaq -0xb0(%rbp), %r15
xorl %edi, %edi
movq %rsi, -0x38(%rbp)
movq (%r8), %rax
movq (%rax), %rcx
movq 0x8(%rax), %rax
subq %rcx, %rax
cqto
pushq $0x30
popq %rsi
idivq %rsi
cmpq %rax, %rdi
jae 0x44e1d
movq %rdi, -0x40(%rbp)
leaq (%rcx,%r13), %rax
movq 0x18(%rcx,%r13), %r14
movq 0x8(%r8), %rdi
addq %r13, %rdi
movq 0x8(%rcx,%r13), %rdx
subq (%rcx,%r13), %rdx
sarq $0x5, %rdx
movq %rax, -0x90(%rbp)
movq %rdx, -0x88(%rbp)
leaq -0x80(%rbp), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x9(%rax)
movups %xmm0, (%rax)
movq %rbx, %r12
movq %rbx, %rsi
callq 0x443f6
testb %al, %al
je 0x44dc4
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rsi
addq %r13, %rsi
movq %r12, %rbx
movq %r12, %rdi
callq 0x44404
movq %r15, %rdi
leaq -0x60(%rbp), %rsi
movq %rbx, %rdx
callq 0x4538e
movq -0x30(%rbp), %rdi
movq %r15, %rsi
callq 0x24a60
movq %r15, %rdi
callq 0x24ad8
subq -0x88(%rbp), %r14
jbe 0x44dee
leaq -0xa0(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq %r15, %rdi
movq %r14, %rsi
pushq $0x20
popq %rdx
callq 0x24660
leaq -0x60(%rbp), %rdi
movq %r15, %rsi
callq 0x24690
movq %r15, %rdi
callq 0x24ad8
jmp 0x44de9
leaq -0x80(%rbp), %rax
movq %rax, -0x90(%rbp)
movq %r12, %rdi
movq %r14, %rsi
pushq $0x20
popq %rdx
callq 0x24660
leaq -0x60(%rbp), %rdi
movq %r12, %rsi
callq 0x24a60
movq %r12, %rbx
jmp 0x44e01
leaq -0x60(%rbp), %rdi
leaq 0x2f072(%rip), %rsi     # 0x73e6b
callq 0x24a20
movq %r12, %rbx
movq %rbx, %rdi
callq 0x24ad8
movq -0x40(%rbp), %rdi
incq %rdi
addq $0x30, %r13
movq -0x38(%rbp), %r8
jmp 0x44ce6
leaq -0x60(%rbp), %rdi
callq 0x24ad8
movq -0x30(%rbp), %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x44e57
jmp 0x44e57
jmp 0x44e68
movq %rax, %rbx
leaq -0xb0(%rbp), %rdi
callq 0x24ad8
jmp 0x44e5a
jmp 0x44e68
jmp 0x44e57
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
callq 0x24ad8
jmp 0x44e6b
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x24ad8
movq -0x30(%rbp), %rdi
callq 0x24ad8
movq %rbx, %rdi
callq 0x24950
nop
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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 %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq -0x48(%rbp), %r15
xorl %r12d, %r12d
leaq -0x58(%rbp), %r14
xorl %r13d, %r13d
movq (%rbx), %rax
movq (%rax), %rcx
movq 0x8(%rax), %rax
subq %rcx, %rax
cqto
pushq $0x30
popq %rsi
idivq %rsi
cmpq %rax, %r13
jae 0x44f0f
movq 0x8(%rbx), %rdi
addq %r12, %rdi
leaq (%rcx,%r12), %rax
movq 0x8(%rcx,%r12), %rdx
subq (%rcx,%r12), %rdx
sarq $0x5, %rdx
movq %rax, -0x58(%rbp)
movq %rdx, -0x50(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, 0x9(%r15)
movups %xmm0, (%r15)
movq %r14, %rsi
callq 0x443f6
testb %al, %al
je 0x44f06
movq 0x8(%rbx), %rdi
addq %r12, %rdi
callq 0x444ca
incq %r13
addq $0x30, %r12
jmp 0x44ea8
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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
andq $0x0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq 0x30(%rsi), %r14
movq 0x38(%rsi), %r12
leaq -0x38(%rbp), %r15
cmpq %r12, %r14
je 0x460a3
movq %r15, %rdi
movq %r14, %rsi
callq 0x461a0
movq 0x8(%rbx), %rsi
movq -0x38(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq %rbx, %rdi
callq 0x462d0
movq %r15, %rdi
callq 0x46174
addq $0x78, %r14
jmp 0x46071
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x460c4
movq %rax, %r14
leaq -0x38(%rbp), %rdi
callq 0x46174
movq %rbx, %rdi
callq 0x46174
movq %r14, %rdi
callq 0x24950