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::AssertionResultData::reconstructExpression[abi:cxx11]() const
std::string AssertionResultData::reconstructExpression() const {

        if( reconstructedExpression.empty() ) {
            if( lazyExpression ) {
                ReusableStringStream rss;
                rss << lazyExpression;
                reconstructedExpression = rss.str();
            }
        }
        return reconstructedExpression;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x20(%rsi), %r14
cmpq $0x0, 0x28(%rsi)
jne 0x25c8f
movq %rsi, %r15
cmpq $0x0, 0x40(%rsi)
je 0x25c8f
addq $0x40, %r15
leaq -0x38(%rbp), %r12
movq %r12, %rdi
callq 0x30e18
movq 0x10(%r12), %rdi
movq %r15, %rsi
callq 0x2575f
movq -0x28(%rbp), %rsi
addq $0x8, %rsi
leaq -0x58(%rbp), %rdi
callq 0x24830
leaq -0x58(%rbp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x24690
movq %r15, %rdi
callq 0x24ad8
leaq -0x38(%rbp), %rdi
callq 0x30e5e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x24760
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x25cac
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x30e5e
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::AssertionResult::getExpression[abi:cxx11]() const
std::string AssertionResult::getExpression() const {
        // Possibly overallocating by 3 characters should be basically free
        std::string expr; expr.reserve(m_info.capturedExpression.size() + 3);
        if (isFalseTest(m_info.resultDisposition)) {
            expr += "!(";
        }
        expr += m_info.capturedExpression;
        if (isFalseTest(m_info.resultDisposition)) {
            expr += ')';
        }
        return expr;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r14
movb $0x0, 0x10(%rdi)
movq 0x28(%rsi), %rsi
addq $0x3, %rsi
callq 0x24810
testb $0x4, 0x30(%r14)
je 0x25da0
leaq 0x4d9f9(%rip), %rsi     # 0x73791
movq %rbx, %rdi
callq 0x24a10
leaq 0x20(%r14), %rsi
movq %rbx, %rdi
callq 0x25dd9
testb $0x4, 0x30(%r14)
je 0x25dbe
pushq $0x29
popq %rsi
movq %rbx, %rdi
callq 0x244e0
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x24ad8
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::AssertionResult::getExpressionInMacro[abi:cxx11]() const
std::string AssertionResult::getExpressionInMacro() const {
        std::string expr;
        if( m_info.macroName.empty() )
            expr = static_cast<std::string>(m_info.capturedExpression);
        else {
            expr.reserve( m_info.macroName.size() + m_info.capturedExpression.size() + 4 );
            expr += m_info.macroName;
            expr += "( ";
            expr += m_info.capturedExpression;
            expr += " )";
        }
        return expr;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r14
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x25e74
movq 0x28(%r14), %rcx
leaq (%rax,%rcx), %rsi
addq $0x4, %rsi
movq %rbx, %rdi
callq 0x24810
movq %rbx, %rdi
movq %r14, %rsi
callq 0x25dd9
leaq 0x4d88a(%rip), %rsi     # 0x736d6
movq %rbx, %rdi
callq 0x24a10
addq $0x20, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x25dd9
leaq 0x4d86f(%rip), %rsi     # 0x736d9
movq %rbx, %rdi
callq 0x24a10
jmp 0x25e9b
addq $0x20, %r14
leaq -0x30(%rbp), %rdi
movq %r14, %rsi
callq 0x3d4fc
leaq -0x30(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x24690
movq %r14, %rdi
callq 0x24ad8
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x25ea9
movq %rax, %r14
movq %rbx, %rdi
callq 0x24ad8
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::AssertionResult::getExpandedExpression[abi:cxx11]() const
std::string AssertionResult::getExpandedExpression() const {
        std::string expr = m_resultData.reconstructExpression();
        return expr.empty()
                ? getExpression()
                : expr;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x38, %rsi
leaq -0x38(%rbp), %r15
movq %r15, %rdi
callq 0x25c1a
cmpq $0x0, 0x8(%r15)
je 0x25f6e
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x24760
jmp 0x25f79
movq %rbx, %rdi
movq %r14, %rsi
callq 0x25d60
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
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::Config::Config(Catch::ConfigData const&)
Config::Config( ConfigData const& data )
    :   m_data( data ),
        m_stream( openStream() )
    {
        // We need to trim filter specs to avoid trouble with superfluous
        // whitespace (esp. important for bdd macros, as those are manually
        // aligned with whitespace).

        for (auto& elem : m_data.testsOrTags) {
            elem = trim(elem);
        }
        for (auto& elem : m_data.sectionsToRun) {
            elem = trim(elem);
        }

        TestSpecParser parser(ITagAliasRegistry::get());
        if (!m_data.testsOrTags.empty()) {
            m_hasTestFilters = true;
            for (auto const& testOrTags : m_data.testsOrTags) {
                parser.parse(testOrTags);
            }
        }
        m_testSpec = parser.testSpec();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
movq %rdi, %rbx
leaq 0x809b2(%rip), %rax     # 0xa9c70
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x8(%rdi), %r14
movq %r14, %rdi
callq 0x3daa8
movq %r14, -0x38(%rbp)
movq %rbx, %rdi
callq 0x29470
leaq 0x118(%rbx), %rcx
movq %rcx, -0x30(%rbp)
movq %rax, 0x118(%rbx)
leaq 0x120(%rbx), %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x120(%rbx)
movups %xmm0, 0x130(%rbx)
movups %xmm0, 0x140(%rbx)
movb $0x0, 0x150(%rbx)
movq 0xe8(%rbx), %r13
movq 0xf0(%rbx), %r14
leaq -0x150(%rbp), %r15
cmpq %r14, %r13
je 0x29353
movq %r15, %rdi
movq %r13, %rsi
callq 0x29499
movq %r13, %rdi
movq %r15, %rsi
callq 0x24690
movq %r15, %rdi
callq 0x24ad8
addq $0x20, %r13
jmp 0x2932a
movq 0x100(%rbx), %r13
movq 0x108(%rbx), %r14
leaq -0x150(%rbp), %r15
cmpq %r14, %r13
je 0x29391
movq %r15, %rdi
movq %r13, %rsi
callq 0x29499
movq %r13, %rdi
movq %r15, %rsi
callq 0x24690
movq %r15, %rdi
callq 0x24ad8
addq $0x20, %r13
jmp 0x29368
callq 0x2950a
leaq -0x150(%rbp), %rdi
movq %rax, %rsi
callq 0x332dc
movq 0xe8(%rbx), %r15
movq 0xf0(%rbx), %r14
cmpq %r14, %r15
je 0x293dc
movb $0x1, 0x150(%rbx)
leaq -0x150(%rbp), %r13
cmpq %r14, %r15
je 0x293dc
movq %r13, %rdi
movq %r15, %rsi
callq 0x2951e
addq $0x20, %r15
jmp 0x293c6
leaq -0x68(%rbp), %rdi
leaq -0x150(%rbp), %rsi
callq 0x295e8
leaq -0x68(%rbp), %rbx
movq %r12, %rdi
movq %rbx, %rsi
callq 0x3db98
movq %rbx, %rdi
callq 0x3dbc2
leaq -0x150(%rbp), %rdi
callq 0x3dbe2
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2942f
movq %rax, %r13
jmp 0x29456
movq %rax, %r13
jmp 0x2945f
jmp 0x29442
movq %rax, %r13
leaq -0x150(%rbp), %rdi
callq 0x3dbe2
jmp 0x29445
jmp 0x29442
movq %rax, %r13
movq %r12, %rdi
callq 0x3dbc2
movq -0x30(%rbp), %rdi
callq 0x3dc34
movq -0x38(%rbp), %rdi
callq 0x3dc56
movq %rbx, %rdi
callq 0x2927e
movq %r13, %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::TestSpecParser::parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
TestSpecParser& TestSpecParser::parse( std::string const& arg ) {
        m_mode = None;
        m_exclusion = false;
        m_arg = m_tagAliases->expandAliases( arg );
        m_escapeChars.clear();
        m_substring.reserve(m_arg.size());
        m_patternName.reserve(m_arg.size());
        m_realPatternPos = 0;

        for( m_pos = 0; m_pos < m_arg.size(); ++m_pos )
          //if visitChar fails
           if( !visitChar( m_arg[m_pos] ) ){
               m_testSpec.m_invalidArgs.push_back(arg);
               break;
           }
        endMode();
        return *this;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
andl $0x0, (%rdi)
movq %rsi, %r14
movb $0x0, 0x8(%rdi)
movq 0xe0(%rdi), %rsi
movq (%rsi), %rax
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %r14, %rdx
callq *0x18(%rax)
leaq 0x20(%rbx), %rdi
movq %r15, %rsi
callq 0x24690
movq %r15, %rdi
callq 0x24ad8
movq 0x80(%rbx), %rax
cmpq %rax, 0x88(%rbx)
je 0x2957a
movq %rax, 0x88(%rbx)
leaq 0x40(%rbx), %rdi
movq 0x28(%rbx), %rsi
callq 0x24810
leaq 0x60(%rbx), %rdi
movq 0x28(%rbx), %rsi
callq 0x24810
andq $0x0, 0x18(%rbx)
xorl %eax, %eax
movq %rax, 0x10(%rbx)
cmpq 0x28(%rbx), %rax
jae 0x295d1
movq 0x20(%rbx), %rcx
movsbl (%rcx,%rax), %esi
movq %rbx, %rdi
callq 0x33354
testb %al, %al
je 0x295c2
movq 0x10(%rbx), %rax
incq %rax
jmp 0x2959b
leaq 0xc8(%rbx), %rdi
movq %r14, %rsi
callq 0x3f2ea
movq %rbx, %rdi
callq 0x33414
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
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::Colour::use(Catch::Colour::Code)
void Colour::use( Code _colourCode ) {
        static IColourImpl* impl = platformColourInstance();
        // Strictly speaking, this cannot possibly happen.
        // However, under some conditions it does happen (see #1626),
        // and this change is small enough that we can let practicality
        // triumph over purity in this case.
        if (impl != nullptr) {
            impl->use( _colourCode );
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %edi, %ebx
movb 0x84fa3(%rip), %al      # 0xae9e8
testb %al, %al
je 0x29a68
movq 0x84f90(%rip), %rdi     # 0xae9e0
testq %rdi, %rdi
je 0x29a5d
movq (%rdi), %rax
movl %ebx, %esi
callq *0x10(%rax)
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x84f79(%rip), %rdi     # 0xae9e8
callq 0x24980
testl %eax, %eax
je 0x29a49
leaq -0x1c(%rbp), %rdi
callq 0x2a3c8
callq 0x3e53f
movq (%rax), %rcx
movq %rax, %rdi
callq *0x20(%rcx)
leaq -0x30(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x443de
movq (%r14), %rdi
testq %rdi, %rdi
je 0x29ab8
movq (%rdi), %rax
callq *0x90(%rax)
cmpl $0x1, %eax
je 0x29ac4
testl %eax, %eax
jne 0x29ad7
pushq $0x1
popq %rdi
callq 0x24910
testl %eax, %eax
je 0x29ad7
movb 0x8535e(%rip), %al      # 0xaee28
testb %al, %al
je 0x29b12
leaq 0x84ab3(%rip), %r15     # 0xae588
jmp 0x29ae8
movb 0x85353(%rip), %al      # 0xaee30
testb %al, %al
je 0x29b2a
leaq 0x84aa8(%rip), %r15     # 0xae590
leaq -0x28(%rbp), %rdi
callq 0x423de
leaq -0x1c(%rbp), %rdi
callq 0x2a3e2
movq %r15, 0x84edf(%rip)     # 0xae9e0
leaq 0x84ee0(%rip), %rdi     # 0xae9e8
callq 0x24370
jmp 0x29a49
leaq 0x8530f(%rip), %r14     # 0xaee28
movq %r14, %rdi
callq 0x24980
leaq 0x84a60(%rip), %r15     # 0xae588
jmp 0x29b40
leaq 0x852ff(%rip), %r14     # 0xaee30
movq %r14, %rdi
callq 0x24980
leaq 0x84a50(%rip), %r15     # 0xae590
testl %eax, %eax
je 0x29ae8
movq %r14, %rdi
callq 0x24370
jmp 0x29ae8
movq %rax, %rbx
leaq -0x28(%rbp), %rdi
callq 0x423de
jmp 0x29b64
movq %rax, %rbx
jmp 0x29b6d
movq %rax, %rbx
leaq -0x1c(%rbp), %rdi
callq 0x2a3e2
leaq 0x84e74(%rip), %rdi     # 0xae9e8
callq 0x24360
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::isDebuggerActive()
bool isDebuggerActive(){
            // Libstdc++ has a bug, where std::ifstream sets errno to 0
            // This way our users can properly assert over errno values
            ErrnoGuard guard;
            std::ifstream in("/proc/self/status");
            for( std::string line; std::getline(in, line); ) {
                static const int PREFIX_LEN = 11;
                if( line.compare(0, PREFIX_LEN, "TracerPid:\t") == 0 ) {
                    // We're traced if the PID is not 0 and no other PID starts
                    // with 0 digit, so it's enough to check for just a single
                    // character.
                    return line.length() > PREFIX_LEN && line[PREFIX_LEN] != '0';
                }
            }

            return false;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x230, %rsp            # imm = 0x230
leaq -0x24(%rbp), %rdi
callq 0x2a3c8
leaq 0x4a106(%rip), %rsi     # 0x73e4e
leaq -0x250(%rbp), %rdi
pushq $0x8
popq %rdx
callq 0x249a0
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x250(%rbp), %rbx
leaq -0x48(%rbp), %r14
leaq 0x4a0e7(%rip), %r15     # 0x73e60
pushq $0xb
popq %r12
movq %rbx, %rdi
movq %r14, %rsi
callq 0x24100
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x29dbe
movq %r14, %rdi
xorl %esi, %esi
movq %r12, %rdx
movq %r15, %rcx
callq 0x24730
testl %eax, %eax
jne 0x29d7d
cmpq $0xc, -0x40(%rbp)
jb 0x29dbe
movq -0x48(%rbp), %rax
cmpb $0x30, 0xb(%rax)
setne %bl
jmp 0x29dc0
xorl %ebx, %ebx
leaq -0x48(%rbp), %rdi
callq 0x24ad8
leaq -0x250(%rbp), %rdi
callq 0x24150
leaq -0x24(%rbp), %rdi
callq 0x2a3e2
movl %ebx, %eax
addq $0x230, %rsp            # imm = 0x230
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x29e0d
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x24ad8
leaq -0x250(%rbp), %rdi
callq 0x24150
leaq -0x24(%rbp), %rdi
callq 0x2a3e2
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::formatReconstructedExpression(std::ostream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::StringRef, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void formatReconstructedExpression( std::ostream &os, std::string const& lhs, StringRef op, std::string const& rhs ) {
        if( lhs.size() + rhs.size() < 40 &&
                lhs.find('\n') == std::string::npos &&
                rhs.find('\n') == std::string::npos )
            os << lhs << " " << op << " " << rhs;
        else
            os << lhs << "\n" << op << "\n" << rhs;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r8, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rdx, -0x30(%rbp)
movq %rcx, -0x28(%rbp)
movq 0x8(%r8), %rax
addq 0x8(%rsi), %rax
cmpq $0x27, %rax
ja 0x29e78
pushq $0xa
popq %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x246f0
cmpq $-0x1, %rax
jne 0x29e78
pushq $0xa
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x246f0
cmpq $-0x1, %rax
je 0x29ec3
leaq 0x5335f(%rip), %r12     # 0x7d1de
movq %r15, %rdi
movq %r14, %rsi
callq 0x24510
movq %rax, %rdi
movq %r12, %rsi
callq 0x24570
leaq -0x30(%rbp), %rsi
movq %rax, %rdi
callq 0x29ecc
movq %rax, %rdi
movq %r12, %rsi
callq 0x24570
movq %rax, %rdi
movq %rbx, %rsi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x24510
leaq 0x4a7ab(%rip), %r12     # 0x74675
jmp 0x29e7f
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::Detail::parseEnums(Catch::StringRef)
std::vector<StringRef> parseEnums( StringRef enums ) {
            auto enumValues = splitStringRef( enums, ',' );
            std::vector<StringRef> parsed;
            parsed.reserve( enumValues.size() );
            for( auto const& enumValue : enumValues ) {
                parsed.push_back(trim(extractInstanceName(enumValue)));
            }
            return parsed;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq -0x58(%rbp), %r14
pushq $0x2c
popq %rcx
movq %r14, %rdi
callq 0x2a064
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
movq 0x8(%r14), %rsi
subq (%r14), %rsi
sarq $0x4, %rsi
movq %rbx, -0x30(%rbp)
movq %rbx, %rdi
callq 0x3dd6e
movq -0x58(%rbp), %r13
movq -0x50(%rbp), %r14
leaq -0x40(%rbp), %r15
cmpq %r14, %r13
je 0x2a029
movq (%r13), %rax
movq 0x8(%r13), %r12
movq %rax, -0x40(%rbp)
movq %r12, -0x38(%rbp)
movq %r12, %rcx
negq %rcx
decq %r12
movq %rcx, %rbx
testq %rcx, %rcx
je 0x29fe1
movq %r15, %rdi
movq %r12, %rsi
callq 0x3e8aa
leaq 0x1(%rbx), %rcx
decq %r12
cmpb $0x3a, %al
jne 0x29fc3
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
subq %rbx, %rdi
negq %rbx
subq %rbx, %rsi
movl $0x0, %eax
cmovbq %rax, %rsi
leaq 0x49e69(%rip), %rax     # 0x73e6b
cmovbeq %rax, %rdi
callq 0x2a14f
movq %rax, -0x68(%rbp)
movq %rdx, -0x60(%rbp)
movq -0x30(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x4aa90
addq $0x10, %r13
jmp 0x29fa5
leaq -0x58(%rbp), %rdi
callq 0x4aa32
movq -0x30(%rbp), %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2a047
movq %rax, %r14
movq -0x30(%rbp), %rdi
callq 0x4aa32
leaq -0x58(%rbp), %rdi
callq 0x4aa32
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::splitStringRef(Catch::StringRef, char)
std::vector<StringRef> splitStringRef( StringRef str, char delimiter ) {
        std::vector<StringRef> subStrings;
        std::size_t start = 0;
        for(std::size_t pos = 0; pos < str.size(); ++pos ) {
            if( str[pos] == delimiter ) {
                if( pos - start > 1 )
                    subStrings.push_back( str.substr( start, pos-start ) );
                start = pos+1;
            }
        }
        if( start < str.size() )
            subStrings.push_back( str.substr( start, str.size()-start ) );
        return subStrings;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %r14d
movq %rdi, %rbx
leaq -0x38(%rbp), %r15
movq %rsi, (%r15)
movq %rdx, 0x8(%r15)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
xorl %r12d, %r12d
xorl %r13d, %r13d
cmpq %rdx, %r13
jae 0x2a10c
movq %r15, %rdi
movq %r13, %rsi
callq 0x3e8aa
cmpb %r14b, %al
jne 0x2a103
movq %r13, %rax
subq %r12, %rax
cmpq $0x2, %rax
jb 0x2a0fb
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %rdx
addq %r12, %rdx
movq %rcx, %rsi
subq %r12, %rsi
leaq 0x49d9b(%rip), %rdi     # 0x73e6b
cmovbeq %rdi, %rdx
cmpq %rax, %rsi
cmovaeq %rax, %rsi
cmpq %r12, %rcx
movl $0x0, %eax
cmovbeq %rax, %rsi
movq %rdx, -0x48(%rbp)
movq %rsi, -0x40(%rbp)
movq %rbx, %rdi
leaq -0x48(%rbp), %rsi
callq 0x4aa90
incq %r13
movq %r13, %r12
jmp 0x2a106
incq %r13
movq -0x30(%rbp), %rdx
jmp 0x2a097
subq %r12, %rdx
jbe 0x2a128
addq -0x38(%rbp), %r12
leaq -0x48(%rbp), %rsi
movq %r12, (%rsi)
movq %rdx, 0x8(%rsi)
movq %rbx, %rdi
callq 0x4aa90
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2a13c
movq %rax, %r14
movq %rbx, %rdi
callq 0x4aa32
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::trim(Catch::StringRef)
StringRef trim(StringRef ref) {
        const auto is_ws = [](char c) {
            return c == ' ' || c == '\t' || c == '\n' || c == '\r';
        };
        size_t real_begin = 0;
        while (real_begin < ref.size() && is_ws(ref[real_begin])) { ++real_begin; }
        size_t real_end = ref.size();
        while (real_end > real_begin && is_ws(ref[real_end - 1])) { --real_end; }

        return ref.substr(real_begin, real_end - real_begin);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
leaq -0x38(%rbp), %r15
movq %rdi, (%r15)
movq %rsi, 0x8(%r15)
xorl %ebx, %ebx
movabsq $0x100002600, %r12      # imm = 0x100002600
cmpq %r14, %rbx
jae 0x2a1a4
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3e8aa
cmpb $0x20, %al
ja 0x2a1a0
movzbl %al, %eax
btq %rax, %r12
jae 0x2a1a0
incq %rbx
movq -0x30(%rbp), %r14
jmp 0x2a17a
movq -0x30(%rbp), %r14
movq %r14, %r13
subq %rbx, %r13
leaq -0x38(%rbp), %r15
cmpq %rbx, %r14
jbe 0x2a1d3
decq %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x3e8aa
cmpb $0x20, %al
ja 0x2a1d3
movzbl %al, %eax
btq %rax, %r12
jae 0x2a1d3
decq %r13
jmp 0x2a1ae
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %rdx
addq %rbx, %rdx
movq %rcx, %rsi
subq %rbx, %rsi
leaq 0x49c80(%rip), %rax     # 0x73e6b
cmovaq %rdx, %rax
cmpq %r13, %rsi
cmovaeq %r13, %rsi
xorl %edx, %edx
cmpq %rbx, %rcx
cmovaq %rsi, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
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::Detail::EnumInfo::lookup(int) const
StringRef EnumInfo::lookup( int value ) const {
            for( auto const& valueToName : m_values ) {
                if( valueToName.first == value )
                    return valueToName.second;
            }
            return "{** unexpected enum value **}"_sr;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x10(%rdi), %rcx
movq 0x18(%rdi), %rdi
movabsq $0x1d, %rdx
leaq 0x49c33(%rip), %rax     # 0x73e6c
cmpq %rdi, %rcx
je 0x2a250
cmpl %esi, (%rcx)
je 0x2a248
addq $0x18, %rcx
jmp 0x2a239
movq 0x8(%rcx), %rax
movq 0x10(%rcx), %rdx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::Detail::makeEnumInfo(Catch::StringRef, Catch::StringRef, std::vector<int, std::allocator<int>> const&)
std::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRef allValueNames, std::vector<int> const& values ) {
            std::unique_ptr<EnumInfo> enumInfo( new EnumInfo );
            enumInfo->m_name = enumName;
            enumInfo->m_values.reserve( values.size() );

            const auto valueNames = Catch::Detail::parseEnums( allValueNames );
            assert( valueNames.size() == values.size() );
            std::size_t i = 0;
            for( auto value : values )
                enumInfo->m_values.emplace_back(value, valueNames[i++]);

            return enumInfo;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r9, %r15
movq %r8, -0x48(%rbp)
movq %rcx, -0x40(%rbp)
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r13
pushq $0x28
popq %rdi
callq 0x24580
leaq 0x10(%rax), %r14
xorps %xmm0, %xmm0
andq $0x0, 0x20(%rax)
movups %xmm0, 0x10(%rax)
movq %r13, -0x38(%rbp)
movq %rax, (%r13)
movq %r12, (%rax)
movq %rbx, 0x8(%rax)
movq 0x8(%r15), %rsi
subq (%r15), %rsi
sarq $0x2, %rsi
movq %r14, %rdi
callq 0x3de16
leaq -0x60(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0x29f54
movq -0x58(%rbp), %rax
subq -0x60(%rbp), %rax
sarq $0x4, %rax
movq (%r15), %rbx
movq 0x8(%r15), %r12
movq %r12, %rcx
subq %rbx, %rcx
sarq $0x2, %rcx
cmpq %rcx, %rax
jne 0x2a32d
xorl %r13d, %r13d
leaq -0x2c(%rbp), %r15
cmpq %r12, %rbx
je 0x2a311
movl (%rbx), %eax
movl %eax, -0x2c(%rbp)
movq -0x60(%rbp), %rdx
addq %r13, %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x3ded0
addq $0x4, %rbx
addq $0x10, %r13
jmp 0x2a2eb
leaq -0x60(%rbp), %rdi
callq 0x4aa32
movq -0x38(%rbp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x49b56(%rip), %rdi     # 0x73e8a
leaq 0x49b72(%rip), %rsi     # 0x73ead
leaq 0x49b9e(%rip), %rcx     # 0x73ee0
movl $0x2984, %edx           # imm = 0x2984
callq 0x24390
jmp 0x2a34e
movq %rax, %r14
jmp 0x2a35f
movq %rax, %r14
leaq -0x60(%rbp), %rdi
callq 0x4aa32
movq -0x38(%rbp), %rdi
callq 0x3defc
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::ExceptionTranslatorRegistry::tryTranslators[abi:cxx11]() const
std::string ExceptionTranslatorRegistry::tryTranslators() const {
        if (m_translators.empty()) {
            std::rethrow_exception(std::current_exception());
        } else {
            return m_translators[0]->translate(m_translators.begin() + 1, m_translators.end());
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x8(%rsi), %rdx
movq 0x10(%rsi), %rcx
cmpq %rcx, %rdx
je 0x2a601
movq %rdi, %rbx
movq (%rdx), %rsi
addq $0x8, %rdx
movq (%rsi), %rax
callq *0x10(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq -0x10(%rbp), %rbx
movq %rbx, %rdi
callq 0x24610
movq %rbx, %rdi
callq 0x245b0
movq %rax, %rbx
leaq -0x10(%rbp), %rdi
callq 0x3df6e
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::FatalConditionHandler::FatalConditionHandler()
FatalConditionHandler::FatalConditionHandler() {
        assert(!altStackMem && "Cannot initialize POSIX signal handler when one already exists");
        if (altStackSize == 0) {
            altStackSize = std::max(static_cast<size_t>(SIGSTKSZ), minStackSizeForErrors);
        }
        altStackMem = new char[altStackSize]();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movb $0x0, (%rdi)
cmpq $0x0, 0x843cc(%rip)     # 0xaea08
jne 0x2a68e
movq 0x843cb(%rip), %rbx     # 0xaea10
testq %rbx, %rbx
jne 0x2a66a
movl $0xfa, %edi
callq 0x24380
cmpq $0x8001, %rax           # imm = 0x8001
movl $0x8000, %ebx           # imm = 0x8000
cmovaeq %rax, %rbx
movq %rbx, 0x843a6(%rip)     # 0xaea10
movq %rbx, %rdi
callq 0x24030
movq %rax, %r14
movq %rax, %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x24300
movq %r14, 0x8437f(%rip)     # 0xaea08
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x498f0(%rip), %rdi     # 0x73f85
leaq 0x49811(%rip), %rsi     # 0x73ead
leaq 0x49933(%rip), %rcx     # 0x73fd6
movl $0x2aaa, %edx           # imm = 0x2AAA
callq 0x24390
nop
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::FatalConditionHandler::engage_platform()
void FatalConditionHandler::engage_platform() {
        stack_t sigStack;
        sigStack.ss_sp = altStackMem;
        sigStack.ss_size = altStackSize;
        sigStack.ss_flags = 0;
        sigaltstack(&sigStack, &oldSigStack);
        struct sigaction sa = { };

        sa.sa_handler = handleSignal;
        sa.sa_flags = SA_ONSTACK;
        for (std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i) {
            sigaction(signalDefs[i].id, &sa, &oldSigActions[i]);
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xb0, %rsp
movq 0x84321(%rip), %rax     # 0xaea08
leaq -0x38(%rbp), %rdi
movq %rax, (%rdi)
movq 0x8431b(%rip), %rax     # 0xaea10
movq %rax, 0x10(%rdi)
andl $0x0, 0x8(%rdi)
leaq 0x84314(%rip), %rsi     # 0xaea18
callq 0x249d0
leaq -0xc8(%rbp), %rbx
xorl %r15d, %r15d
movl $0x90, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x24300
leaq 0x55(%rip), %rax        # 0x2a77e
movq %rax, -0x8(%rbx)
movl $0x8000000, 0x80(%rbx)  # imm = 0x8000000
leaq 0x842f2(%rip), %rbx     # 0xaea30
leaq 0x7f6ab(%rip), %r12     # 0xa9df0
leaq -0xd0(%rbp), %r14
cmpq $0x60, %r15
je 0x2a76e
movl (%r15,%r12), %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x246b0
addq $0x10, %r15
addq $0x98, %rbx
jmp 0x2a74c
addq $0xb0, %rsp
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::handleSignal(int)
static void handleSignal( int sig ) {
        char const * name = "<unknown signal>";
        for (auto const& def : signalDefs) {
            if (sig == def.id) {
                name = def.name;
                break;
            }
        }
        // We need to restore previous signal handlers and let them do
        // their thing, so that the users can have the debugger break
        // when a signal is raised, and so on.
        restorePreviousSignalHandlers();
        reportFatal( name );
        raise( sig );
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebx
xorl %eax, %eax
leaq 0x4aea6(%rip), %r14     # 0x7563e
leaq 0x7f651(%rip), %rcx     # 0xa9df0
cmpq $0x60, %rax
je 0x2a7b6
leaq 0x10(%rax), %rdx
cmpl %ebx, (%rax,%rcx)
movq %rdx, %rax
jne 0x2a79f
movq -0x8(%rdx,%rcx), %r14
callq 0x2a809
callq 0x3e53f
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq %rax, %r15
leaq -0x30(%rbp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x310d0
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq (%r15), %rax
movq %r15, %rdi
callq *0x48(%rax)
movl %ebx, %edi
callq 0x24590
addq $0x10, %rsp
popq %rbx
popq %r12
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::restorePreviousSignalHandlers()
static void restorePreviousSignalHandlers() {
        // We set signal handlers back to the previous ones. Hopefully
        // nobody overwrote them in the meantime, and doesn't expect
        // their signal handlers to live past ours given that they
        // installed them after ours..
        for (std::size_t i = 0; i < sizeof(signalDefs) / sizeof(SignalDefs); ++i) {
            sigaction(signalDefs[i].id, &oldSigActions[i], nullptr);
        }
        // Return the old stack
        sigaltstack(&oldSigStack, nullptr);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x84216(%rip), %rbx     # 0xaea30
xorl %r14d, %r14d
leaq 0x7f5cc(%rip), %r15     # 0xa9df0
cmpq $0x60, %r14
je 0x2a845
movl (%r14,%r15), %edi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x246b0
addq $0x10, %r14
addq $0x98, %rbx
jmp 0x2a824
leaq 0x841cc(%rip), %rdi     # 0xaea18
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x249d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::filterTests(std::vector<Catch::TestCase, std::allocator<Catch::TestCase>> const&, Catch::TestSpec const&, Catch::IConfig const&)
std::vector<TestCase> filterTests( std::vector<TestCase> const& testCases, TestSpec const& testSpec, IConfig const& config ) {
        std::vector<TestCase> filtered;
        filtered.reserve( testCases.size() );
        for (auto const& testCase : testCases) {
            if ((!testSpec.hasFilters() && !testCase.isHidden()) ||
                (testSpec.hasFilters() && matchTest(testCase, testSpec, config))) {
                filtered.push_back(testCase);
            }
        }
        return filtered;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rax
subq (%rsi), %rax
movl $0xb8, %ecx
cqto
idivq %rcx
movq %rax, %rsi
callq 0x3f61c
movq (%r13), %r12
movq 0x8(%r13), %r13
cmpq %r13, %r12
je 0x2b318
movq (%r15), %rax
cmpq 0x8(%r15), %rax
je 0x2b2f9
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x31f7b
testb %al, %al
jne 0x2b304
jmp 0x2b30f
testb $0x2, 0xa0(%r12)
jne 0x2b30f
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3f6f4
addq $0xb8, %r12
jmp 0x2b2d7
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2b32c
movq %rax, %r14
movq %rbx, %rdi
callq 0x3e31c
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::TestCaseInfo::tagsAsString[abi:cxx11]() const
std::string TestCaseInfo::tagsAsString() const {
        std::string ret;
        // '[' and ']' per tag
        std::size_t full_size = 2 * tags.size();
        for (const auto& tag : tags) {
            full_size += tag.size();
        }
        ret.reserve(full_size);
        for (const auto& tag : tags) {
            ret.push_back('[');
            ret.append(tag);
            ret.push_back(']');
        }

        return ret;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r15
movb $0x0, 0x10(%rdi)
movq 0x60(%rsi), %rax
movq 0x68(%rsi), %rcx
movq %rcx, %rsi
subq %rax, %rsi
sarq $0x4, %rsi
cmpq %rcx, %rax
je 0x2b3c1
addq 0x8(%rax), %rsi
addq $0x20, %rax
jmp 0x2b3b2
movq %rbx, %rdi
callq 0x24810
movq 0x60(%r15), %r14
movq 0x68(%r15), %r13
pushq $0x5b
popq %r15
pushq $0x5d
popq %r12
cmpq %r13, %r14
je 0x2b405
movq %rbx, %rdi
movl %r15d, %esi
callq 0x244e0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x24a60
movq %rbx, %rdi
movl %r12d, %esi
callq 0x244e0
addq $0x20, %r14
jmp 0x2b3d9
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2b419
movq %rax, %r14
movq %rbx, %rdi
callq 0x24ad8
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::listTestsNamesOnly(Catch::Config const&)
std::size_t listTestsNamesOnly( Config const& config ) {
        TestSpec const& testSpec = config.testSpec();
        std::size_t matchedTests = 0;
        std::vector<TestCase> matchedTestCases = filterTests( getAllTestCasesSorted( config ), testSpec, config );
        for( auto const& testCaseInfo : matchedTestCases ) {
            matchedTests++;
            if( startsWith( testCaseInfo.name, '#' ) )
               Catch::cout() << '"' << testCaseInfo.name << '"';
            else
               Catch::cout() << testCaseInfo.name;
            if ( config.verbosity() >= Verbosity::High )
                Catch::cout() << "\t@" << testCaseInfo.lineInfo;
            Catch::cout() << std::endl;
        }
        return matchedTests;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x68(%rax)
movq %rax, %r14
movq %rbx, %rdi
callq 0x2b33f
leaq -0x40(%rbp), %r12
movq %r12, %rdi
movq %rax, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x2b291
movq (%r12), %r15
movq 0x8(%r12), %r13
xorl %r14d, %r14d
movq 0x82ada(%rip), %r12     # 0xadf98
cmpq %r13, %r15
je 0x2b54a
cmpq $0x0, 0x8(%r15)
je 0x2b4f9
movq (%r15), %rax
cmpb $0x23, (%rax)
jne 0x2b4f9
movq %r12, %rdi
pushq $0x22
popq %rsi
callq 0x24670
movq %rax, %rdi
movq %r15, %rsi
callq 0x24510
movq %rax, %rdi
pushq $0x22
popq %rsi
callq 0x24670
jmp 0x2b504
movq %r12, %rdi
movq %r15, %rsi
callq 0x24510
movq (%rbx), %rax
movq %rbx, %rdi
callq *0xa0(%rax)
cmpl $0x2, %eax
jl 0x2b533
movq %r12, %rdi
leaq 0x48b42(%rip), %rsi     # 0x74061
callq 0x24570
leaq 0x90(%r15), %rsi
movq %rax, %rdi
callq 0x2921b
movq %r12, %rdi
callq 0x242a0
addq $0xb8, %r15
incq %r14
jmp 0x2b4be
leaq -0x40(%rbp), %rdi
callq 0x3e31c
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x3e31c
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::TagInfo::all[abi:cxx11]() const
std::string TagInfo::all() const {
        size_t size = 0;
        for (auto const& spelling : spellings) {
            // Add 2 for the brackes
            size += spelling.size() + 2;
        }

        std::string out; out.reserve(size);
        for (auto const& spelling : spellings) {
            out += '[';
            out += spelling;
            out += ']';
        }
        return out;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rsi), %rax
leaq 0x8(%rsi), %r13
xorl %r15d, %r15d
cmpq %r13, %rax
je 0x2b5d9
movq 0x28(%rax), %rcx
addq %rcx, %r15
addq $0x2, %r15
movq %rax, %rdi
callq 0x24650
jmp 0x2b5bf
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x24810
movq 0x18(%r14), %r12
pushq $0x5b
popq %r14
pushq $0x5d
popq %r15
cmpq %r13, %r12
je 0x2b635
movq %rbx, %rdi
movl %r14d, %esi
callq 0x244e0
leaq 0x20(%r12), %rsi
movq %rbx, %rdi
callq 0x24a60
movq %rbx, %rdi
movl %r15d, %esi
callq 0x244e0
movq %r12, %rdi
callq 0x24650
movq %rax, %r12
jmp 0x2b600
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2b649
movq %rax, %r14
movq %rbx, %rdi
callq 0x24ad8
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::list(std::shared_ptr<Catch::Config> const&)
Option<std::size_t> list( std::shared_ptr<Config> const& config ) {
        Option<std::size_t> listedCount;
        getCurrentMutableContext().setConfig( config );
        if( config->listTests() )
            listedCount = listedCount.valueOr(0) + listTests( *config );
        if( config->listTestNamesOnly() )
            listedCount = listedCount.valueOr(0) + listTestsNamesOnly( *config );
        if( config->listTags() )
            listedCount = listedCount.valueOr(0) + listTags( *config );
        if( config->listReporters() )
            listedCount = listedCount.valueOr(0) + listReporters();
        return listedCount;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
andq $0x0, (%rdi)
callq 0x3e53f
movq %rax, %r15
leaq -0x30(%rbp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x4b9a6
movq (%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
callq *0x38(%rax)
leaq -0x28(%rbp), %rdi
callq 0x423de
movq (%r14), %rdi
cmpb $0x1, 0x8(%rdi)
jne 0x2bd26
callq 0x2aee8
leaq 0x8(%rbx), %rcx
movq %rax, 0x8(%rbx)
movq %rcx, (%rbx)
movq (%r14), %rdi
cmpb $0x0, 0xb(%rdi)
je 0x2bd45
movq (%rcx), %r15
jmp 0x2bd2f
cmpb $0x0, 0xb(%rdi)
je 0x2bd50
xorl %r15d, %r15d
callq 0x2b471
addq %r15, %rax
leaq 0x8(%rbx), %rcx
movq %rax, 0x8(%rbx)
movq %rcx, (%rbx)
movq (%r14), %rdi
cmpb $0x0, 0x9(%rdi)
je 0x2bd6f
movq (%rcx), %r15
jmp 0x2bd59
cmpb $0x0, 0x9(%rdi)
je 0x2bd9b
xorl %r15d, %r15d
callq 0x2b65c
addq %r15, %rax
leaq 0x8(%rbx), %rcx
movq %rax, 0x8(%rbx)
movq %rcx, (%rbx)
movq (%r14), %rdi
cmpb $0x0, 0xa(%rdi)
je 0x2bd8b
movq (%rcx), %r14
callq 0x2ba9d
addq %r14, %rax
leaq 0x8(%rbx), %rcx
movq %rax, 0x8(%rbx)
movq %rcx, (%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
cmpb $0x0, 0xa(%rdi)
je 0x2bd8b
xorl %r14d, %r14d
jmp 0x2bd78
jmp 0x2bdbc
jmp 0x2bdbc
jmp 0x2bdbc
jmp 0x2bdbc
movq %rax, %r14
leaq -0x28(%rbp), %rdi
callq 0x423de
jmp 0x2bdbf
movq %rax, %r14
andq $0x0, (%rbx)
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::Matchers::Floating::WithinUlpsMatcher::WithinUlpsMatcher(double, unsigned long, Catch::Matchers::Floating::FloatingPointKind)
WithinUlpsMatcher::WithinUlpsMatcher(double target, uint64_t ulps, FloatingPointKind baseType)
        :m_target{ target }, m_ulps{ ulps }, m_type{ baseType } {
        CATCH_ENFORCE(m_type == FloatingPointKind::Double
                   || m_ulps < (std::numeric_limits<uint32_t>::max)(),
            "Provided ULP is impossibly large for a float comparison.");
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
leaq 0x7de31(%rip), %rax     # 0xa9f60
leaq 0x10(%rax), %rcx
movq %rcx, (%rdi)
addq $0x40, %rax
movq %rax, 0x28(%rdi)
movsd %xmm0, 0x30(%rdi)
movq %rsi, 0x38(%rdi)
movb %dl, 0x40(%rdi)
cmpl $0x1, %edx
sete %al
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rcx, %rsi
setb %cl
orb %al, %cl
je 0x2c168
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rdi, %rbx
leaq -0x28(%rbp), %rdi
callq 0x30e18
movq -0x18(%rbp), %rdi
leaq 0x47f8b(%rip), %rsi     # 0x7410a
callq 0x24570
movq -0x18(%rbp), %rsi
addq $0x8, %rsi
leaq -0x48(%rbp), %rdi
callq 0x24830
leaq -0x48(%rbp), %rdi
callq 0x255ca
movq %rax, %r14
leaq -0x48(%rbp), %rdi
callq 0x24ad8
jmp 0x2c1af
movq %rax, %r14
leaq -0x28(%rbp), %rdi
callq 0x30e5e
jmp 0x2c1bd
movq %rax, %r14
movq %rbx, %rdi
callq 0x3ac44
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::Matchers::Floating::WithinUlpsMatcher::match(double const&) const
bool WithinUlpsMatcher::match(double const& matchee) const {
        switch (m_type) {
        case FloatingPointKind::Float:
            return almostEqualUlps<float>(static_cast<float>(matchee), static_cast<float>(m_target), m_ulps);
        case FloatingPointKind::Double:
            return almostEqualUlps<double>(matchee, m_target, m_ulps);
        default:
            CATCH_INTERNAL_ERROR( "Unknown FloatingPointKind value" );
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x48, %rsp
movzbl 0x40(%rdi), %eax
cmpl $0x1, %eax
je 0x2c234
testl %eax, %eax
jne 0x2c2b0
cvtsd2ss (%rsi), %xmm0
cvtsd2ss 0x30(%rdi), %xmm1
ucomiss %xmm1, %xmm0
jp 0x2c2ac
movd %xmm0, %eax
movd %xmm1, %ecx
movl %ecx, %edx
xorl %eax, %edx
js 0x2c299
subl %ecx, %eax
cvtsi2ss %eax, %xmm0
andps 0x45e47(%rip), %xmm0    # 0x72060
cvttss2si %xmm0, %rax
movq %rax, %rcx
subss 0x45ed7(%rip), %xmm0    # 0x72100
sarq $0x3f, %rcx
cvttss2si %xmm0, %rdx
jmp 0x2c27e
movsd (%rsi), %xmm0
movsd 0x30(%rdi), %xmm1
ucomisd %xmm1, %xmm0
jp 0x2c2ac
movq %xmm0, %rax
movq %xmm1, %rcx
movq %rcx, %rdx
xorq %rax, %rdx
js 0x2c28d
subq %rcx, %rax
cvtsi2sd %rax, %xmm0
andpd 0x45dbb(%rip), %xmm0    # 0x72020
cvttsd2si %xmm0, %rax
movq %rax, %rcx
subsd 0x45e53(%rip), %xmm0    # 0x720c8
sarq $0x3f, %rcx
cvttsd2si %xmm0, %rdx
andq %rcx, %rdx
orq %rax, %rdx
cmpq %rdx, 0x38(%rdi)
setae %al
jmp 0x2c2a5
cmpeqsd %xmm1, %xmm0
movq %xmm0, %rax
jmp 0x2c2a2
cmpeqss %xmm1, %xmm0
movd %xmm0, %eax
andl $0x1, %eax
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
xorl %eax, %eax
jmp 0x2c2a5
leaq -0x20(%rbp), %rbx
movq %rbx, %rdi
callq 0x30e18
leaq 0x47bea(%rip), %rax     # 0x73ead
leaq -0x50(%rbp), %rsi
movq %rax, (%rsi)
movq $0x2d54, 0x8(%rsi)      # imm = 0x2D54
movq 0x10(%rbx), %rdi
callq 0x2921b
movq -0x10(%rbp), %rdi
leaq 0x47e5d(%rip), %rsi     # 0x74143
callq 0x24570
movq -0x10(%rbp), %rdi
leaq 0x47e67(%rip), %rsi     # 0x7415d
callq 0x24570
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
leaq -0x40(%rbp), %rdi
callq 0x24830
leaq -0x40(%rbp), %rdi
callq 0x29ee0
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x24ad8
jmp 0x2c326
movq %rax, %rbx
leaq -0x20(%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::Matchers::Floating::WithinUlpsMatcher::describe[abi:cxx11]() const
std::string WithinUlpsMatcher::describe() const {
        std::stringstream ret;

        ret << "is within " << m_ulps << " ULPs of ";

        if (m_type == FloatingPointKind::Float) {
            write(ret, static_cast<float>(m_target));
            ret << 'f';
        } else {
            write(ret, m_target);
        }

        ret << " ([";
        if (m_type == FloatingPointKind::Double) {
            write(ret, step(m_target, static_cast<double>(-INFINITY), m_ulps));
            ret << ", ";
            write(ret, step(m_target, static_cast<double>( INFINITY), m_ulps));
        } else {
            // We have to cast INFINITY to float because of MinGW, see #1782
            write(ret, step(static_cast<float>(m_target), static_cast<float>(-INFINITY), m_ulps));
            ret << ", ";
            write(ret, step(static_cast<float>(m_target), static_cast<float>( INFINITY), m_ulps));
        }
        ret << "])";

        return ret.str();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x188, %rsp            # imm = 0x188
movq %rsi, %r15
movq %rdi, %rbx
leaq -0x1a0(%rbp), %rdi
callq 0x24400
leaq -0x190(%rbp), %r14
leaq 0x47d89(%rip), %rsi     # 0x740ff
movq %r14, %rdi
callq 0x24570
movq 0x38(%r15), %rsi
movq %rax, %rdi
callq 0x243c0
leaq 0x47dec(%rip), %rsi     # 0x7417d
movq %rax, %rdi
callq 0x24570
cmpb $0x0, 0x40(%r15)
movsd 0x30(%r15), %xmm0
je 0x2c3b0
movq %r14, %rdi
callq 0x2c4fa
jmp 0x2c3c7
cvtsd2ss %xmm0, %xmm0
movq %r14, %rdi
callq 0x2c4c9
pushq $0x66
popq %rsi
movq %r14, %rdi
callq 0x24670
leaq 0x47db9(%rip), %rsi     # 0x74187
movq %r14, %rdi
callq 0x24570
cmpb $0x1, 0x40(%r15)
movsd 0x30(%r15), %xmm0
jne 0x2c42c
movq 0x38(%r15), %rdi
movsd 0x45ce1(%rip), %xmm1    # 0x720d0
callq 0x2c52b
movq %r14, %rdi
callq 0x2c4fa
leaq 0x47d88(%rip), %rsi     # 0x7418b
movq %r14, %rdi
callq 0x24570
movsd 0x30(%r15), %xmm0
movq 0x38(%r15), %rdi
movsd 0x45cbb(%rip), %xmm1    # 0x720d8
callq 0x2c52b
movq %r14, %rdi
callq 0x2c4fa
jmp 0x2c477
cvtsd2ss %xmm0, %xmm0
movq 0x38(%r15), %rdi
movss 0x45cc8(%rip), %xmm1    # 0x72104
callq 0x2c552
movq %r14, %rdi
callq 0x2c4c9
leaq 0x47d3b(%rip), %rsi     # 0x7418b
movq %r14, %rdi
callq 0x24570
cvtsd2ss 0x30(%r15), %xmm0
movq 0x38(%r15), %rdi
movss 0x45c9e(%rip), %xmm1    # 0x72108
callq 0x2c552
movq %r14, %rdi
callq 0x2c4c9
leaq 0x47d10(%rip), %rsi     # 0x7418e
movq %r14, %rdi
callq 0x24570
leaq -0x188(%rbp), %rsi
movq %rbx, %rdi
callq 0x24830
leaq -0x1a0(%rbp), %rdi
callq 0x24460
movq %rbx, %rax
addq $0x188, %rsp            # imm = 0x188
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x1a0(%rbp), %rdi
callq 0x24460
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: double Catch::(anonymous namespace)::step<double>(double, double, unsigned long)
FP step(FP start, FP direction, uint64_t steps) {
    for (uint64_t i = 0; i < steps; ++i) {
#if defined(CATCH_CONFIG_GLOBAL_NEXTAFTER)
        start = Catch::nextafter(start, direction);
#else
        start = std::nextafter(start, direction);
#endif
    }
    return start;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movsd %xmm1, -0x10(%rbp)
subq $0x1, %rbx
jb 0x2c54b
movsd -0x10(%rbp), %xmm1
callq 0x24440
jmp 0x2c539
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::Matchers::Generic::Detail::finalizeDescription(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string Catch::Matchers::Generic::Detail::finalizeDescription(const std::string& desc) {
    if (desc.empty()) {
        return "matches undescribed predicate";
    } else {
        return "matches predicate: \"" + desc + '"';
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x8(%rsi)
je 0x2c8b8
movq %rsi, %rdx
leaq 0x479b4(%rip), %rsi     # 0x74247
leaq -0x30(%rbp), %r14
movq %r14, %rdi
callq 0x3e5a5
pushq $0x22
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3e746
leaq -0x30(%rbp), %rdi
callq 0x24ad8
jmp 0x2c8cb
leaq 0x4796a(%rip), %rsi     # 0x74229
leaq -0x30(%rbp), %rdx
movq %rbx, %rdi
callq 0x24210
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x24ad8
movq %rbx, %rdi
callq 0x24950
nop