LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
subq $0xf0, %rsp
movq %rdi, -0xe0(%rbp)
movq %rdi, %rax
movq %rax, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xd0(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x67d90
movq -0xc8(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x8db50
jmp 0x94bb5
leaq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x53b70
jmp 0x94bc4
movq -0xd0(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rdi
callq 0x8bcf0
movq %rax, -0x70(%rbp)
movq -0x68(%rbp), %rdi
callq 0x8bd20
movq %rax, -0x78(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x8bd50
testb $0x1, %al
jne 0x94c03
jmp 0x94d07
leaq -0x70(%rbp), %rdi
callq 0x8bd90
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rdi
callq 0x52500
movq %rax, -0xe8(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x52500
movq %rax, %rcx
movq -0xe8(%rbp), %rax
cmpq %rcx, %rax
jae 0x94c98
movq -0x80(%rbp), %rdx
leaq -0xa0(%rbp), %rdi
movl $0x20, %esi
callq 0x93630
jmp 0x94c4f
movq -0x80(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x528a0
leaq -0xa0(%rbp), %rdi
callq 0x52e58
jmp 0x94c10
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x94d54
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x52e58
jmp 0x94d54
jmp 0x94c9a
movq -0x80(%rbp), %rdi
callq 0x52500
movq %rax, -0xf0(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x52500
movq %rax, %rcx
movq -0xf0(%rbp), %rax
cmpq %rcx, %rax
jbe 0x94cf7
leaq -0xc0(%rbp), %rdi
movl $0x20, %esi
leaq -0x60(%rbp), %rdx
callq 0x93630
jmp 0x94cd9
leaq -0x60(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0x528a0
leaq -0xc0(%rbp), %rdi
callq 0x52e58
jmp 0x94c9a
jmp 0x94cf9
leaq -0x70(%rbp), %rdi
callq 0x8bdb0
jmp 0x94bed
movq -0xd0(%rbp), %rdi
addq $0x28, %rdi
leaq -0x60(%rbp), %rsi
callq 0x91260
jmp 0x94d1d
movq -0xd0(%rbp), %rsi
movq -0xe0(%rbp), %rdi
callq 0x94ec0
jmp 0x94d32
leaq -0x60(%rbp), %rdi
callq 0x52e58
leaq -0x30(%rbp), %rdi
callq 0x67e50
movq -0xd8(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x67e50
movq -0x38(%rbp), %rdi
callq 0x52c90
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0xb8, %rdi
callq 0x103c80
xorb $-0x1, %al
testb $0x1, %al
jne 0x9537c
jmp 0x9537e
jmp 0x9539d
leaq 0xaa8e2(%rip), %rdi     # 0x13fc67
leaq 0xa9c45(%rip), %rsi     # 0x13efd1
movl $0x1712, %edx           # imm = 0x1712
leaq 0xac9a6(%rip), %rcx     # 0x141d3e
callq 0x524b0
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x6f460
movq -0x20(%rbp), %rdi
addq $0xb8, %rdi
callq 0x103cc0
movq %rax, %rdi
callq 0x95bc0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0xa0, %rdi
movq -0x10(%rbp), %rsi
callq 0x103d00
movb $0x1, %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x1047c0
movq -0x38(%rbp), %rdi
addq $0xb8, %rdi
callq 0x95b70
cmpq $0x0, %rax
jne 0x9542d
jmp 0x9544c
leaq 0xac995(%rip), %rdi     # 0x141dc9
leaq 0xa9b96(%rip), %rsi     # 0x13efd1
movl $0x1725, %edx           # imm = 0x1725
leaq 0xac99d(%rip), %rcx     # 0x141de4
callq 0x524b0
leaq -0x20(%rbp), %rdi
callq 0x104830
movq -0x38(%rbp), %rsi
movq %rax, %rdi
addq $0x138, %rdi            # imm = 0x138
addq $0x98, %rsi
callq 0x104850
jmp 0x95471
movq -0x38(%rbp), %rdi
addq $0x50, %rdi
leaq -0x20(%rbp), %rsi
callq 0x1048c0
jmp 0x95484
movq -0x38(%rbp), %rdi
addq $0x98, %rdi
callq 0x104930
movq -0x38(%rbp), %rdi
addq $0xa8, %rdi
callq 0x104970
testb $0x1, %al
jne 0x954aa
jmp 0x954ac
jmp 0x954e2
leaq 0xac9ba(%rip), %rdi     # 0x141e6d
leaq 0xa9b17(%rip), %rsi     # 0x13efd1
movl $0x172a, %edx           # imm = 0x172A
leaq 0xac91e(%rip), %rcx     # 0x141de4
callq 0x524b0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xb5b20
jmp 0x95557
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rax
addq $0xe8, %rax
movq %rax, -0x40(%rbp)
addq $0xa8, %rdi
callq 0x104990
movq -0x40(%rbp), %rsi
movq %rax, %rdi
addq $0xb8, %rdi
callq 0x52070
jmp 0x95515
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rax
addq $0x108, %rax            # imm = 0x108
movq %rax, -0x48(%rbp)
addq $0xa8, %rdi
callq 0x104990
movq -0x48(%rbp), %rsi
movq %rax, %rdi
addq $0xd8, %rdi
callq 0x52070
jmp 0x95548
leaq -0x20(%rbp), %rdi
callq 0xb5b20
addq $0x50, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x52c90
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
testb $0x1, 0x188(%rax)
je 0x96abd
movl $0x1, -0x4(%rbp)
jmp 0x96ae8
movq -0x30(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x66700
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jne 0x96ae2
movq -0x30(%rbp), %rdi
callq 0x66ad0
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0xb8, %rdi
callq 0x103c80
xorb $-0x1, %al
testb $0x1, %al
jne 0x97d4c
jmp 0x97d4e
jmp 0x97d6d
leaq 0xa7f12(%rip), %rdi     # 0x13fc67
leaq 0xa7275(%rip), %rsi     # 0x13efd1
movl $0x171e, %edx           # imm = 0x171E
leaq 0xaa116(%rip), %rcx     # 0x141e7e
callq 0x524b0
movq -0x20(%rbp), %rdi
addq $0xb8, %rdi
callq 0x103cc0
movq %rax, %rdi
callq 0x95bc0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x10bde0
movq -0x20(%rbp), %rdi
addq $0xb8, %rdi
callq 0x10be30
addq $0x20, %rsp
popq %rbp
retq
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x10bec0
movq -0x38(%rbp), %rdi
callq 0x10bf30
movq -0x40(%rbp), %rsi
movq %rax, %rdi
addq $0x70, %rdi
addq $0x68, %rsi
callq 0x10bf50
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
subq $-0x80, %rdi
callq 0x10bfb0
jmp 0x97e09
movq -0x40(%rbp), %rdi
movq (%rdi), %rax
movq 0x90(%rax), %rax
callq *%rax
jmp 0x97e1b
leaq -0x20(%rbp), %rdi
callq 0xb56a0
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xb56a0
movq -0x28(%rbp), %rdi
callq 0x52c90
nopl (%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpl $0x1, 0x8(%rax)
je 0x98e4c
jmp 0x98e6b
leaq 0xa7243(%rip), %rdi     # 0x140096
leaq 0xa6177(%rip), %rsi     # 0x13efd1
movl $0x233d, %edx           # imm = 0x233D
leaq 0xa7251(%rip), %rcx     # 0x1400b7
callq 0x524b0
movq -0x10(%rbp), %rax
cmpl $0x2, 0x8(%rax)
je 0x98e77
jmp 0x98e96
leaq 0xa7288(%rip), %rdi     # 0x140106
leaq 0xa614c(%rip), %rsi     # 0x13efd1
movl $0x233e, %edx           # imm = 0x233E
leaq 0xa7226(%rip), %rcx     # 0x1400b7
callq 0x524b0
movq -0x10(%rbp), %rax
cmpl $0x0, 0x8(%rax)
je 0x98ea5
callq 0x523e0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::clara::detail::ParserRefImpl<Catch::clara::detail::Opt>::cardinality() const
auto cardinality() const -> size_t override {
            if( m_ref->isContainer() )
                return 0;
            else
                return 1;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0x9cab0
movq %rax, %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testb $0x1, %al
jne 0x9b708
jmp 0x9b712
movq $0x0, -0x8(%rbp)
jmp 0x9b71a
movq $0x1, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x9ce20
movq -0x90(%rbp), %rax
addq $0x60, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x8d7e0
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
callq 0x8d810
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x8d840
testb $0x1, %al
jne 0x9c9f7
jmp 0x9ca75
leaq -0x48(%rbp), %rdi
callq 0x8d880
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0x9ce20
jmp 0x9ca13
leaq -0x78(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x8e840
movb %al, -0x91(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x52e58
movb -0x91(%rbp), %al
testb $0x1, %al
jne 0x9ca3b
jmp 0x9ca65
movb $0x1, -0x1(%rbp)
movl $0x1, -0x88(%rbp)
jmp 0x9ca83
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x52e58
jmp 0x9ca9a
jmp 0x9ca67
leaq -0x48(%rbp), %rdi
callq 0x8da50
jmp 0x9c9e4
movb $0x0, -0x1(%rbp)
movl $0x1, -0x88(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x52e58
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xa0, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x52c90
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
addq $0x10, %rdi
callq 0x992f0
cmpq $0x2, %rax
jb 0x9cc4f
movq -0x28(%rbp), %rdi
movq %rdi, %rax
addq $0x10, %rax
movq %rax, -0x30(%rbp)
addq $0x10, %rdi
callq 0x9cf30
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x9cf60
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x9cec0
movq %rax, -0x20(%rbp)
jmp 0x9cc77
movq -0x28(%rbp), %rdi
movq %rdi, %rsi
addq $0x8, %rsi
callq 0x8d840
testb $0x1, %al
jne 0x9cc65
jmp 0x9cc6e
movq -0x28(%rbp), %rdi
callq 0x8da50
movq -0x28(%rbp), %rdi
callq 0x9cfa0
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
subq $0x70, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x52a00
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rdx
movb $0x0, -0x39(%rbp)
movq -0x18(%rbp), %rsi
callq 0x9a510
jmp 0x9ff5b
movq -0x60(%rbp), %rdi
callq 0x9caf0
testb $0x1, %al
jne 0x9ff6a
jmp 0x9ffa4
movq -0x68(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0x38(%rbp), %rsi
callq 0x91260
jmp 0x9ff7d
jmp 0x9ffa4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x9ffca
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0x9a630
jmp 0x9ffca
movb $0x1, -0x39(%rbp)
testb $0x1, -0x39(%rbp)
jne 0x9ffb7
movq -0x60(%rbp), %rdi
callq 0x9a630
leaq -0x38(%rbp), %rdi
callq 0x52e58
movq -0x70(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
leaq -0x38(%rbp), %rdi
callq 0x52e58
movq -0x48(%rbp), %rdi
callq 0x52c90
nopl (%rax)
// File: 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
subq $0x80, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
addq $0x30, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xa0f10
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0xa0f40
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xa0f70
testb $0x1, %al
jne 0xa031b
jmp 0xa0385
leaq -0x20(%rbp), %rdi
callq 0xa0fb0
movq -0x78(%rbp), %rdi
movq %rax, -0x30(%rbp)
movb $0x0, -0x31(%rbp)
movq -0x30(%rbp), %rsi
movq (%rsi), %rax
callq *0x10(%rax)
movq -0x78(%rbp), %rdi
callq 0x9c770
testb $0x1, %al
jne 0xa0354
movb $0x1, -0x31(%rbp)
movl $0x1, -0x38(%rbp)
jmp 0xa035b
movl $0x0, -0x38(%rbp)
testb $0x1, -0x31(%rbp)
jne 0xa036a
movq -0x78(%rbp), %rdi
callq 0x98dc0
movl -0x38(%rbp), %eax
testl %eax, %eax
je 0xa0378
jmp 0xa0373
jmp 0xa042e
jmp 0xa037a
leaq -0x20(%rbp), %rdi
callq 0xa0fd0
jmp 0xa0308
movq -0x68(%rbp), %rax
addq $0x48, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0xa0ff0
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
callq 0xa1020
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xa1050
testb $0x1, %al
jne 0xa03be
jmp 0xa0425
leaq -0x48(%rbp), %rdi
callq 0xa1090
movq -0x78(%rbp), %rdi
movq %rax, -0x58(%rbp)
movb $0x0, -0x59(%rbp)
movq -0x58(%rbp), %rsi
movq (%rsi), %rax
callq *0x10(%rax)
movq -0x78(%rbp), %rdi
callq 0x9c770
testb $0x1, %al
jne 0xa03f7
movb $0x1, -0x59(%rbp)
movl $0x1, -0x38(%rbp)
jmp 0xa03fe
movl $0x0, -0x38(%rbp)
testb $0x1, -0x59(%rbp)
jne 0xa040d
movq -0x78(%rbp), %rdi
callq 0x98dc0
movl -0x38(%rbp), %eax
testl %eax, %eax
je 0xa0418
jmp 0xa0416
jmp 0xa042e
jmp 0xa041a
leaq -0x48(%rbp), %rdi
callq 0xa10b0
jmp 0xa03ab
movq -0x78(%rbp), %rdi
callq 0x98d10
movq -0x70(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x70, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x9f571(%rip), %rsi     # 0x140753
movq $-0x1, %rdx
callq 0x526c0
movq %rax, -0x20(%rbp)
cmpq $-0x1, -0x20(%rbp)
jne 0xa1208
movq -0x18(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x52300
jmp 0xa1224
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
addq $0x1, %rdx
leaq -0x40(%rbp), %rdi
movq $-0x1, %rcx
callq 0x52780
movq -0x60(%rbp), %rdi
addq $0x8, %rdi
callq 0xa13d0
movq %rax, %rdi
leaq -0x40(%rbp), %rsi
callq 0x52070
jmp 0xa123f
movq -0x60(%rbp), %rdi
addq $0x18, %rdi
callq 0xa1400
testb $0x1, %al
jne 0xa1252
jmp 0xa1295
movq -0x60(%rbp), %rdi
addq $0x18, %rdi
callq 0xa1420
movq -0x70(%rbp), %rdi
movq %rax, %rsi
movq (%rsi), %rax
movq 0x20(%rax), %rax
leaq -0x40(%rbp), %rdx
callq *%rax
jmp 0xa1275
movl $0x1, -0x50(%rbp)
jmp 0xa12b2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x52e58
jmp 0xa12c5
movq -0x70(%rbp), %rdi
movl $0x0, -0x54(%rbp)
leaq -0x54(%rbp), %rsi
callq 0x9a560
jmp 0xa12ab
movl $0x1, -0x50(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x52e58
movq -0x68(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x52c90
nop
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, 0x8(%rax)
jne 0xa14eb
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
callq 0x98f90
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xa1530
movq -0x18(%rbp), %rax
cmpl $0x0, 0x8(%rax)
jne 0xa1517
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
movq -0x10(%rbp), %rsi
addq $0x10, %rsi
callq 0x99120
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq 0x18(%rdi), %rax
addq 0x10(%rdi), %rax
movq %rax, 0x10(%rdi)
movq 0x10(%rdi), %rax
movq %rax, -0x10(%rbp)
callq 0xa2740
movq %rax, %rdi
callq 0x52500
movq %rax, %rcx
movq -0x10(%rbp), %rax
cmpq %rcx, %rax
jae 0xa22d4
movq -0x18(%rbp), %rdi
callq 0xa2740
movq %rax, %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x527f0
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0xa22d4
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
jmp 0xa2341
jmp 0xa22d6
movq -0x18(%rbp), %rdi
movq 0x10(%rdi), %rax
movq %rax, -0x28(%rbp)
callq 0xa2740
movq %rax, %rdi
callq 0x52500
movq -0x28(%rbp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x19(%rbp)
jae 0xa2324
movq -0x18(%rbp), %rdi
callq 0xa2740
movq %rax, %rdi
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rsi
callq 0x527f0
movsbl (%rax), %edi
callq 0xa28d0
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0xa232d
jmp 0xa233f
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
jmp 0xa22d6
jmp 0xa2341
movq -0x18(%rbp), %rdi
movq 0x10(%rdi), %rax
movq %rax, -0x30(%rbp)
callq 0xa2740
movq %rax, %rdi
callq 0x52500
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jne 0xa237e
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq %rcx, -0x38(%rbp)
movq (%rax), %rdi
callq 0x916d0
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0xa23a7
movq -0x18(%rbp), %rdi
callq 0xa24c0
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, (%rcx)
movq $0x0, 0x8(%rcx)
movq $0x0, 0x10(%rcx)
movq $0x0, 0x18(%rcx)
movq $0x0, 0x20(%rcx)
movb $0x0, 0x28(%rcx)
movq (%rcx), %rax
movq 0x18(%rax), %rax
movq (%rcx), %rcx
cmpq 0x20(%rcx), %rax
jbe 0xa2415
jmp 0xa2434
leaq 0x9e4a9(%rip), %rdi     # 0x1408c5
leaq 0x9cbae(%rip), %rsi     # 0x13efd1
movl $0x217c, %edx           # imm = 0x217C
leaq 0x9e4bb(%rip), %rcx     # 0x1408ea
callq 0x524b0
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movb $0x1, %al
cmpq $-0x1, 0x28(%rcx)
movb %al, -0x19(%rbp)
je 0xa245f
movq -0x18(%rbp), %rcx
movq (%rcx), %rax
movq 0x18(%rax), %rax
movq (%rcx), %rcx
cmpq 0x28(%rcx), %rax
seta %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0xa2468
jmp 0xa246a
jmp 0xa2489
leaq 0x9e4bc(%rip), %rdi     # 0x14092d
leaq 0x9cb59(%rip), %rsi     # 0x13efd1
movl $0x217d, %edx           # imm = 0x217D
leaq 0x9e466(%rip), %rcx     # 0x1408ea
callq 0x524b0
movq -0x18(%rbp), %rdi
callq 0xa24c0
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0xa24ad
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jbe 0xa2791
jmp 0xa27b0
leaq 0x9e258(%rip), %rdi     # 0x1409f0
leaq 0x9c832(%rip), %rsi     # 0x13efd1
movl $0x2144, %edx           # imm = 0x2144
leaq 0x9e24c(%rip), %rcx     # 0x1409f7
callq 0x524b0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0xa2740
movq %rax, %rdi
callq 0x52500
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
ja 0xa27d7
jmp 0xa27f6
leaq 0x9e261(%rip), %rdi     # 0x140a3f
leaq 0x9c7ec(%rip), %rsi     # 0x13efd1
movl $0x2145, %edx           # imm = 0x2145
leaq 0x9e206(%rip), %rcx     # 0x1409f7
callq 0x524b0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
callq 0xa2740
movq %rax, %rdi
callq 0x52500
movq -0x30(%rbp), %rcx
movq %rax, %rdx
movb $0x1, %al
cmpq %rdx, %rcx
movb %al, -0x21(%rbp)
je 0xa28c3
movq -0x18(%rbp), %rdi
callq 0xa2740
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x527f0
movsbl (%rax), %edi
callq 0xa28d0
testb $0x1, %al
jne 0xa2847
jmp 0xa2876
movq -0x18(%rbp), %rdi
callq 0xa2740
movq %rax, %rdi
movq -0x10(%rbp), %rsi
subq $0x1, %rsi
callq 0x527f0
movsbl (%rax), %edi
callq 0xa28d0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x21(%rbp)
jne 0xa2876
jmp 0xa28c3
movq -0x18(%rbp), %rdi
callq 0xa2740
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x527f0
movsbl (%rax), %edi
callq 0xa29a0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x21(%rbp)
jne 0xa28c3
movq -0x18(%rbp), %rdi
callq 0xa2740
movq %rax, %rdi
movq -0x10(%rbp), %rsi
subq $0x1, %rsi
callq 0x527f0
movsbl (%rax), %edi
callq 0xa2a70
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nop
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::clara::TextFlow::Column::iterator::operator==(Catch::clara::TextFlow::Column::iterator const&) const
auto operator ==(iterator const& other) const -> bool {
			return
				m_pos == other.m_pos &&
				m_stringIndex == other.m_stringIndex &&
				&m_column == &other.m_column;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x10(%rax), %rcx
movq -0x10(%rbp), %rdx
xorl %eax, %eax
cmpq 0x10(%rdx), %rcx
movb %al, -0x11(%rbp)
jne 0xa2be2
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rdx
xorl %eax, %eax
cmpq 0x8(%rdx), %rcx
movb %al, -0x11(%rbp)
jne 0xa2be2
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
sete %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x48(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, -0x50(%rbp)
movq (%rax), %rdi
callq 0xa3e50
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jae 0xa3cef
movq -0x48(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
callq 0xa5050
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, -0x58(%rbp)
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0xa4f70
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
callq 0xa20f0
movq -0x58(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xa2130
testb $0x1, %al
jne 0xa3cc3
jmp 0xa3cdc
movq -0x48(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
callq 0xa5050
movq %rax, %rdi
callq 0xa2260
jmp 0xa3cde
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xa3c5c
movq -0x48(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0xb0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
movb $0x0, -0x11(%rbp)
callq 0xa96e0
movq -0x90(%rbp), %rax
addq $0x30, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0xa0f10
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0xa0f40
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xa0f70
testb $0x1, %al
jne 0xa9307
jmp 0xa93cf
leaq -0x28(%rbp), %rdi
callq 0xa0fb0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0xa9700
jmp 0xa9323
movq -0xa0(%rbp), %rdi
callq 0xa9440
movq %rax, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0xa9b30
leaq -0x50(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0xa9410
movq -0xb0(%rbp), %rdi
movq %rax, -0x78(%rbp)
callq 0xa9440
movq -0xa0(%rbp), %rdi
movq %rax, -0x80(%rbp)
movq -0x68(%rbp), %rsi
movq -0x78(%rbp), %rdx
movq -0x80(%rbp), %rcx
callq 0xa9a80
movq %rax, -0xa8(%rbp)
jmp 0xa9385
movq -0xa8(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xa9640
leaq -0x28(%rbp), %rdi
callq 0xa0fd0
jmp 0xa92f1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xa93f5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0xa9640
jmp 0xa93f5
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0xa93e5
movq -0xa0(%rbp), %rdi
callq 0xa9640
movq -0x98(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0xa0(%rbp), %rdi
callq 0xa9640
movq -0x58(%rbp), %rdi
callq 0x52c90
nopw (%rax,%rax)
// File: 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
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq 0x18(%rax), %rsi
leaq -0x30(%rbp), %rdi
callq 0x5f120
movq -0x70(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, -0x68(%rbp)
movq 0x10(%rax), %rsi
leaq -0x50(%rbp), %rdi
callq 0x8ea30
jmp 0xb76f3
movq -0x68(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x52670
movq %rax, -0x78(%rbp)
jmp 0xb7706
movq -0x78(%rbp), %rdi
movl $0x20, %esi
callq 0x52870
jmp 0xb7716
leaq -0x50(%rbp), %rdi
callq 0x52e58
leaq -0x30(%rbp), %rdi
leaq 0x10a8ce(%rip), %rsi    # 0x1c1ff8
callq 0x8e840
testb $0x1, %al
jne 0xb7735
jmp 0xb776f
movq -0x70(%rbp), %rsi
movq -0x10(%rbp), %rdi
addq $0x20, %rsi
callq 0x5b6b0
jmp 0xb7748
jmp 0xb7780
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xb7792
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x52e58
jmp 0xb7792
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x52670
jmp 0xb777e
jmp 0xb7780
leaq -0x30(%rbp), %rdi
callq 0x52e58
addq $0x80, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x52e58
movq -0x58(%rbp), %rdi
callq 0x52c90
nopw %cs:(%rax,%rax)
nop
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::clara::detail::BasicResult<Catch::clara::detail::ParseResultType> Catch::clara::detail::convertInto<int>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int&)
inline auto convertInto( std::string const &source, T& target ) -> ParserResult {
        std::stringstream ss;
        ss << source;
        ss >> target;
        if( ss.fail() )
            return ParserResult::runtimeError( "Unable to convert '" + source + "' to destination type" );
        else
            return ParserResult::ok( ParseResultType::Matched );
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x210, %rsp            # imm = 0x210
movq %rdi, -0x208(%rbp)
movq %rdi, %rax
movq %rax, -0x200(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x52510
leaq -0x190(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x52670
jmp 0xb92c6
movq -0x18(%rbp), %rsi
leaq -0x1a0(%rbp), %rdi
callq 0x52450
jmp 0xb92d8
movq -0x1a0(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x1a0(%rbp,%rax), %rdi
callq 0x52030
movb %al, -0x209(%rbp)
jmp 0xb92f8
movb -0x209(%rbp), %al
testb $0x1, %al
jne 0xb9307
jmp 0xb93cf
movq -0x10(%rbp), %rdx
leaq 0x87ff0(%rip), %rsi     # 0x141302
leaq -0x1f0(%rbp), %rdi
callq 0x8e240
jmp 0xb9320
leaq 0x87fef(%rip), %rdx     # 0x141316
leaq -0x1d0(%rbp), %rdi
leaq -0x1f0(%rbp), %rsi
callq 0x8e1f0
jmp 0xb933c
movq -0x208(%rbp), %rdi
leaq -0x1d0(%rbp), %rsi
callq 0xb9170
jmp 0xb9351
leaq -0x1d0(%rbp), %rdi
callq 0x52e58
leaq -0x1f0(%rbp), %rdi
callq 0x52e58
movl $0x1, -0x1f4(%rbp)
jmp 0xb93f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
jmp 0xb9414
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
jmp 0xb93c1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x1d0(%rbp), %rdi
callq 0x52e58
leaq -0x1f0(%rbp), %rdi
callq 0x52e58
jmp 0xb9414
movq -0x208(%rbp), %rdi
movl $0x0, -0x1f8(%rbp)
leaq -0x1f8(%rbp), %rsi
callq 0x9a560
jmp 0xb93ee
movl $0x1, -0x1f4(%rbp)
leaq -0x1a0(%rbp), %rdi
callq 0x52580
movq -0x200(%rbp), %rax
addq $0x210, %rsp            # imm = 0x210
popq %rbp
retq
leaq -0x1a0(%rbp), %rdi
callq 0x52580
movq -0x1a8(%rbp), %rdi
callq 0x52c90
nopl (%rax)
// File: xelia-it[P]mustache/test/src/../../src/../third-party/json/single_include/nlohmann/json.hpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> nlohmann::json_abi_v3_11_2::detail::concat<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline OutStringType concat(Args && ... args)
{
    OutStringType str;
    str.reserve(concat_length(args...));
    concat_into(str, std::forward<Args>(args)...);
    return str;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
callq 0x52a00
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x1139e0
movq %rax, -0x40(%rbp)
jmp 0x113833
movq -0x40(%rbp), %rsi
movq -0x50(%rbp), %rdi
callq 0x52ae0
jmp 0x113842
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x113a20
jmp 0x113859
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x113885
jmp 0x11387c
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x52e58
jmp 0x11388f
movq -0x50(%rbp), %rdi
callq 0x52e58
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x52c90
nopl (%rax,%rax)
// File: xelia-it[P]mustache/test/src/../../src/../third-party/json/single_include/nlohmann/json.hpp
// Function: nlohmann::json_abi_v3_11_2::detail::lexer<nlohmann::json_abi_v3_11_2::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char const*>>::skip_bom()
bool skip_bom()
    {
        if (get() == 0xEF)
        {
            // check if we completely parse the BOM
            return get() == 0xBB && get() == 0xBF;
        }

        // the first character is not the beginning of the BOM; unget it to
        // process is later
        unget();
        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x115c20
cmpl $0xef, %eax
jne 0x114856
movq -0x18(%rbp), %rdi
callq 0x115c20
movl %eax, %ecx
xorl %eax, %eax
cmpl $0xbb, %ecx
movb %al, -0x19(%rbp)
jne 0x11484c
movq -0x18(%rbp), %rdi
callq 0x115c20
cmpl $0xbf, %eax
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x114863
movq -0x18(%rbp), %rdi
callq 0x115cf0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: xelia-it[P]mustache/test/src/../../src/../third-party/json/single_include/nlohmann/json.hpp
// Function: nlohmann::json_abi_v3_11_2::detail::lexer<nlohmann::json_abi_v3_11_2::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char const*>>::get()
char_int_type get()
    {
        ++position.chars_read_total;
        ++position.chars_read_current_line;

        if (next_unget)
        {
            // just reset the next_unget variable and work with current
            next_unget = false;
        }
        else
        {
            current = ia.get_character();
        }

        if (JSON_HEDLEY_LIKELY(current != std::char_traits<char_type>::eof()))
        {
            token_string.push_back(std::char_traits<char_type>::to_char_type(current));
        }

        if (current == '\n')
        {
            ++position.lines_read;
            position.chars_read_current_line = 0;
        }

        return current;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x20(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rax)
movq 0x28(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x28(%rax)
testb $0x1, 0x18(%rax)
je 0x115c5c
movq -0x18(%rbp), %rax
movb $0x0, 0x18(%rax)
jmp 0x115c6e
movq -0x18(%rbp), %rdi
callq 0x115dc0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x18(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x1c(%rbp)
callq 0x114550
movl %eax, %ecx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x115c91
jmp 0x115cb9
movq -0x18(%rbp), %rdi
movq %rdi, %rax
addq $0x38, %rax
movq %rax, -0x28(%rbp)
addq $0x14, %rdi
callq 0x115e20
movq -0x28(%rbp), %rdi
movb %al, -0x9(%rbp)
leaq -0x9(%rbp), %rsi
callq 0xd93c0
movq -0x18(%rbp), %rax
cmpl $0xa, 0x14(%rax)
jne 0x115cdb
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x30(%rax)
movq $0x0, 0x28(%rax)
movq -0x18(%rbp), %rax
movl 0x14(%rax), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: xelia-it[P]mustache/test/src/../../src/../third-party/json/single_include/nlohmann/json.hpp
// Function: nlohmann::json_abi_v3_11_2::detail::lexer<nlohmann::json_abi_v3_11_2::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_2::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>, nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char const*>>::unget()
void unget()
    {
        next_unget = true;

        --position.chars_read_total;

        // in case we "unget" a newline, we have to also decrement the lines_read
        if (position.chars_read_current_line == 0)
        {
            if (position.lines_read > 0)
            {
                --position.lines_read;
            }
        }
        else
        {
            --position.chars_read_current_line;
        }

        if (JSON_HEDLEY_LIKELY(current != std::char_traits<char_type>::eof()))
        {
            JSON_ASSERT(!token_string.empty());
            token_string.pop_back();
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movb $0x1, 0x18(%rax)
movq 0x20(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x20(%rax)
cmpq $0x0, 0x28(%rax)
jne 0x115d38
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
jbe 0x115d36
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x30(%rax)
jmp 0x115d48
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x14(%rbp)
callq 0x114550
movl %eax, %ecx
movl -0x14(%rbp), %eax
cmpl %ecx, %eax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x115d6b
jmp 0x115dae
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
callq 0x115ec0
xorb $-0x1, %al
testb $0x1, %al
jne 0x115d80
jmp 0x115d82
jmp 0x115da1
leaq 0x2f68a(%rip), %rdi     # 0x145413
leaq 0x2eb56(%rip), %rsi     # 0x1448e6
movl $0x21fc, %edx           # imm = 0x21FC
leaq 0x2f68d(%rip), %rcx     # 0x145429
callq 0x524b0
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
callq 0x115f00
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: xelia-it[P]mustache/test/src/../../src/../third-party/json/single_include/nlohmann/json.hpp
// Function: nlohmann::json_abi_v3_11_2::detail::iterator_input_adapter<char const*>::get_character()
typename std::char_traits<char_type>::int_type get_character()
    {
        if (JSON_HEDLEY_LIKELY(current != end))
        {
            auto result = std::char_traits<char_type>::to_int_type(*current);
            std::advance(current, 1);
            return result;
        }

        return std::char_traits<char_type>::eof();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq (%rcx), %rax
cmpq 0x8(%rcx), %rax
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x115de8
jmp 0x115e0d
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x115e30
movq -0x20(%rbp), %rdi
movl %eax, -0x14(%rbp)
movl $0x1, %esi
callq 0x115e50
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x115e15
callq 0x114550
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop