LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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 %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x20(%rsi), %r14
movq 0x28(%rsi), %rdx
testq %rdx, %rdx
jne 0x1d774
movq %rsi, %r15
cmpq $0x0, 0x40(%rsi)
je 0x1d772
leaq 0x40(%r15), %r12
leaq -0x40(%rbp), %r13
movq %r13, %rdi
callq 0x2d4e2
movq 0x10(%r13), %rdi
movq %r12, %rsi
callq 0x1d0eb
movq -0x30(%rbp), %rsi
addq $0x8, %rsi
leaq -0x60(%rbp), %rdi
callq 0x1b7f0
leaq -0x60(%rbp), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x1b640
movq (%r12), %rdi
leaq -0x50(%rbp), %rax
cmpq %rax, %rdi
je 0x1d763
callq 0x1b4d0
leaq -0x40(%rbp), %rdi
callq 0x2d528
movq 0x28(%r15), %rdx
jmp 0x1d774
xorl %edx, %edx
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x4a8c2
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1d79d
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x2d528
movq %rbx, %rdi
callq 0x1b910
nop
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x28(%rsi), %rsi
addq $0x3, %rsi
callq 0x1b7e0
testb $0x4, 0x30(%r14)
je 0x1d92e
leaq 0x5ce93(%rip), %rsi     # 0x7a7b9
movq %rbx, %rdi
callq 0x1b9d0
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
movq %rbx, %rdi
callq 0x1b0c0
testb $0x4, 0x30(%r14)
je 0x1d952
movq %rbx, %rdi
movl $0x29, %esi
callq 0x1b480
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x1d970
callq 0x1b4d0
movq %r14, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x1da1e
movq 0x28(%r14), %rcx
leaq (%rax,%rcx), %rsi
addq $0x4, %rsi
movq %rbx, %rdi
callq 0x1b7e0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x1b0c0
leaq 0x5cd09(%rip), %rsi     # 0x7a6fe
movq %rbx, %rdi
callq 0x1b9d0
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
movq %rbx, %rdi
callq 0x1b0c0
leaq 0x5cced(%rip), %rsi     # 0x7a701
movq %rbx, %rdi
callq 0x1b9d0
jmp 0x1da57
movq 0x20(%r14), %rsi
leaq -0x30(%rbp), %r12
movq 0x28(%r14), %rdx
addq %rsi, %rdx
movq %r12, -0x10(%r12)
leaq -0x40(%rbp), %rdi
callq 0x431c8
leaq -0x40(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1b640
movq (%r14), %rdi
cmpq %r12, %rdi
je 0x1da57
callq 0x1b4d0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1da69
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x1da79
callq 0x1b4d0
movq %r14, %rdi
callq 0x1b910
nop
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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 0x1d6ea
movq 0x8(%r15), %rdx
testq %rdx, %rdx
je 0x1db72
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq -0x38(%rbp), %rsi
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x4a8c2
jmp 0x1db7d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1d8e8
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1db8f
callq 0x1b4d0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1dbb2
callq 0x1b4d0
movq %rbx, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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 %rsi, %r14
movq %rdi, %rbx
movl $0x0, (%rdi)
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 0x1b640
movq (%r15), %rdi
leaq -0x28(%rbp), %rax
cmpq %rax, %rdi
je 0x2331b
callq 0x1b4d0
movq 0x80(%rbx), %rax
cmpq %rax, 0x88(%rbx)
je 0x23332
movq %rax, 0x88(%rbx)
leaq 0x40(%rbx), %rdi
movq 0x28(%rbx), %rsi
callq 0x1b7e0
leaq 0x60(%rbx), %rdi
movq 0x28(%rbx), %rsi
callq 0x1b7e0
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
cmpq $0x0, 0x28(%rbx)
je 0x23392
xorl %eax, %eax
movq 0x20(%rbx), %rcx
movsbl (%rcx,%rax), %esi
movq %rbx, %rdi
callq 0x306b2
testb %al, %al
je 0x23383
movq 0x10(%rbx), %rax
incq %rax
movq %rax, 0x10(%rbx)
cmpq 0x28(%rbx), %rax
jb 0x2335c
jmp 0x23392
leaq 0xc8(%rbx), %rdi
movq %r14, %rsi
callq 0x3fc4c
movq %rbx, %rdi
callq 0x30806
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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 %rbx
pushq %rax
movl %edi, %ebx
movb 0x870f2(%rip), %al      # 0xaa9a8
testb %al, %al
je 0x238de
movq 0x870df(%rip), %rdi     # 0xaa9a0
testq %rdi, %rdi
je 0x238d7
movq (%rdi), %rax
movq 0x10(%rax), %rax
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmpq *%rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x870c3(%rip), %rdi     # 0xaa9a8
callq 0x1b930
testl %eax, %eax
je 0x238ba
callq 0x2395a
movq %rax, 0x870a6(%rip)     # 0xaa9a0
leaq 0x870a7(%rip), %rdi     # 0xaa9a8
callq 0x1b300
jmp 0x238ba
movq %rax, %rbx
leaq 0x87096(%rip), %rdi     # 0xaa9a8
callq 0x1b2f0
movq %rbx, %rdi
callq 0x1b910
nop
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::(anonymous namespace)::platformColourInstance()
IColourImpl* platformColourInstance() {
        ErrnoGuard guard;
        IConfigPtr config = getCurrentContext().getConfig();
        UseColour::YesOrNo colourMode = config
            ? config->useColour()
            : UseColour::Auto;
        if( colourMode == UseColour::Auto )
            colourMode = useColourOnPlatform()
                ? UseColour::Yes
                : UseColour::No;
        return colourMode == UseColour::Yes
            ? PosixColourImpl::instance()
            : NoColourImpl::instance();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq -0x1c(%rbp), %rdi
callq 0x2436e
leaq 0x8703c(%rip), %rbx     # 0xaa9b0
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x23981
movq (%rdi), %rax
jmp 0x239b2
movl $0x30, %edi
callq 0x1b510
movq %rax, %rdi
leaq 0x8239b(%rip), %rcx     # 0xa5d30
leaq 0x10(%rcx), %rax
movq %rax, (%rdi)
addq $0x60, %rcx
movq %rcx, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
movq %rdi, (%rbx)
callq *0x20(%rax)
movq (%rax), %rdi
movq 0x8(%rax), %rbx
testq %rbx, %rbx
je 0x239d6
movq 0x865c8(%rip), %rax     # 0xa9f90
cmpb $0x0, (%rax)
je 0x239d2
incl 0x8(%rbx)
jmp 0x239d6
lock
incl 0x8(%rbx)
testq %rdi, %rdi
je 0x239ed
movq (%rdi), %rax
callq *0x90(%rax)
cmpl $0x1, %eax
je 0x239fb
testl %eax, %eax
jne 0x23a0e
movl $0x1, %edi
callq 0x1b8e0
testl %eax, %eax
je 0x23a0e
movb 0x873e7(%rip), %al      # 0xaade8
testb %al, %al
je 0x23a43
leaq 0x86b3c(%rip), %r14     # 0xaa548
jmp 0x23a1f
movb 0x873dc(%rip), %al      # 0xaadf0
testb %al, %al
je 0x23a5b
leaq 0x86b31(%rip), %r14     # 0xaa550
testq %rbx, %rbx
je 0x23a2c
movq %rbx, %rdi
callq 0x43a1a
leaq -0x1c(%rbp), %rdi
callq 0x24388
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x8739e(%rip), %r15     # 0xaade8
movq %r15, %rdi
callq 0x1b930
leaq 0x86aef(%rip), %r14     # 0xaa548
jmp 0x23a71
leaq 0x8738e(%rip), %r15     # 0xaadf0
movq %r15, %rdi
callq 0x1b930
leaq 0x86adf(%rip), %r14     # 0xaa550
testl %eax, %eax
je 0x23a1f
movq %r15, %rdi
callq 0x1b300
jmp 0x23a1f
movq %rax, %r14
testq %rbx, %rbx
je 0x23a94
movq %rbx, %rdi
callq 0x43a1a
jmp 0x23a94
movq %rax, %r14
leaq -0x1c(%rbp), %rdi
callq 0x24388
movq %r14, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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 0x2436e
leaq 0x57264(%rip), %rsi     # 0x7ae76
leaq -0x250(%rbp), %rbx
movq %rbx, %rdi
movl $0x8, %edx
callq 0x1b940
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
leaq -0x48(%rbp), %r14
leaq 0x57240(%rip), %r15     # 0x7ae88
movq -0x250(%rbp), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x1b4f0
movsbl %al, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1b960
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x23ca6
movl $0xb, %edx
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rcx
callq 0x1b6c0
testl %eax, %eax
jne 0x23c48
movq -0x48(%rbp), %rdi
cmpq $0xc, -0x40(%rbp)
jb 0x23caa
cmpb $0x30, 0xb(%rdi)
setne %bl
jmp 0x23cac
movq -0x48(%rbp), %rdi
xorl %ebx, %ebx
cmpq %r12, %rdi
je 0x23cb6
callq 0x1b4d0
leaq -0x250(%rbp), %rdi
callq 0x1b120
leaq -0x24(%rbp), %rdi
callq 0x24388
movl %ebx, %eax
addq $0x230, %rsp            # imm = 0x230
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x23cff
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x23cf3
callq 0x1b4d0
leaq -0x250(%rbp), %rdi
callq 0x1b120
leaq -0x24(%rbp), %rdi
callq 0x24388
movq %rbx, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, -0x30(%rbp)
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r13
movq 0x8(%rsi), %rdx
movq 0x8(%r8), %rax
addq %rdx, %rax
leaq 0x5fe0c(%rip), %r12     # 0x83b52
cmpq $0x27, %rax
ja 0x23d90
movq %r14, %rdi
movl $0xa, %esi
xorl %edx, %edx
callq 0x1b680
cmpq $-0x1, %rax
je 0x23d67
movq 0x8(%r14), %rdx
jmp 0x23d90
movq %rbx, %rdi
movl $0xa, %esi
xorl %edx, %edx
callq 0x1b680
cmpq $-0x1, %rax
movq 0x8(%r14), %rdx
leaq 0x57918(%rip), %rax     # 0x7b69d
leaq 0x5fdc6(%rip), %r12     # 0x83b52
cmoveq %rax, %r12
movq (%r14), %rsi
movq %r13, %rdi
callq 0x1b5e0
movq %rax, %r14
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x1b5e0
movq %r14, %rdi
movq %r15, %rsi
movq -0x30(%rbp), %rdx
callq 0x1b690
movq %rax, %r14
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x1b5e0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1b5e0
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x28, %rsp
movq %rdi, %rbx
leaq -0x50(%rbp), %r14
movq %r14, %rdi
movl $0x2c, %ecx
callq 0x23f80
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq 0x8(%r14), %rsi
subq (%r14), %rsi
sarq $0x4, %rsi
movq %rbx, %rdi
callq 0x3ea24
movq -0x50(%rbp), %r14
movq -0x48(%rbp), %r12
cmpq %r12, %r14
je 0x23f39
xorl %r13d, %r13d
leaq 0x56fc0(%rip), %r15     # 0x7ae93
movq (%r14), %rdi
movq 0x8(%r14), %rsi
movq %rsi, %rcx
movq %rcx, %rax
subq $0x1, %rcx
jb 0x23eed
cmpb $0x3a, -0x1(%rdi,%rax)
jne 0x23edd
addq %rax, %rdi
subq %rax, %rsi
cmovbq %r13, %rsi
cmovbeq %r15, %rdi
callq 0x24093
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x23f20
movups -0x38(%rbp), %xmm0
movups %xmm0, (%rsi)
addq $0x10, 0x8(%rbx)
jmp 0x23f2c
movq %rbx, %rdi
leaq -0x38(%rbp), %rdx
callq 0x4c9ac
addq $0x10, %r14
cmpq %r12, %r14
jne 0x23ed3
movq -0x50(%rbp), %r14
testq %r14, %r14
je 0x23f46
movq %r14, %rdi
callq 0x1b4d0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x23f5a
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x23f6a
callq 0x1b4d0
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x23f78
callq 0x1b4d0
movq %r14, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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 $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
testq %rdx, %rdx
je 0x24031
movl %ecx, %r12d
xorl %r13d, %r13d
xorl %eax, %eax
cmpb %r12b, (%r15,%r13)
jne 0x24013
movq %r13, %rcx
subq %rax, %rcx
cmpq $0x2, %rcx
jb 0x24024
leaq (%r15,%rax), %rdx
movq %r14, %rsi
subq %rax, %rsi
leaq 0x56eb7(%rip), %rdi     # 0x7ae93
cmovbeq %rdi, %rdx
cmpq %rcx, %rsi
cmovaeq %rcx, %rsi
cmpq %rax, %r14
movl $0x0, %eax
cmovbeq %rax, %rsi
movq %rdx, -0x38(%rbp)
movq %rsi, -0x30(%rbp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x24018
movups -0x38(%rbp), %xmm0
movups %xmm0, (%rsi)
addq $0x10, 0x8(%rbx)
jmp 0x24024
incq %r13
jmp 0x2402a
movq %rbx, %rdi
leaq -0x38(%rbp), %rdx
callq 0x4c9ac
incq %r13
movq %r13, %rax
cmpq %r14, %r13
jne 0x23fb9
jmp 0x24033
xorl %eax, %eax
subq %rax, %r14
jbe 0x24067
addq %rax, %r15
movq %r15, -0x38(%rbp)
movq %r14, -0x30(%rbp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x2405b
movups -0x38(%rbp), %xmm0
movups %xmm0, (%rsi)
addq $0x10, 0x8(%rbx)
jmp 0x24067
leaq -0x38(%rbp), %rdx
movq %rbx, %rdi
callq 0x4c9ac
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2407b
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2408b
callq 0x1b4d0
movq %r14, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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:
testq %rsi, %rsi
je 0x240c7
movb $0x1, %cl
xorl %eax, %eax
movabsq $0x100002600, %rdx      # imm = 0x100002600
movzbl (%rdi,%rax), %r8d
cmpq $0x20, %r8
ja 0x240cb
btq %r8, %rdx
jae 0x240cb
incq %rax
cmpq %rsi, %rax
setb %cl
jne 0x240a6
movq %rsi, %rax
jmp 0x24105
xorl %eax, %eax
xorl %ecx, %ecx
cmpq %rsi, %rax
jae 0x24105
movabsq $0x100002600, %r8       # imm = 0x100002600
movq %rsi, %rdx
leaq -0x1(%rdx), %r9
cmpq %rsi, %r9
jae 0x2412d
movzbl -0x1(%rdi,%rdx), %r10d
cmpq $0x20, %r10
ja 0x24108
btq %r10, %r8
jae 0x24108
movq %r9, %rdx
cmpq %rax, %r9
ja 0x240dd
movq %rax, %rdx
jmp 0x24108
movq %rsi, %rdx
subq %rax, %rdx
addq %rax, %rdi
subq %rax, %rsi
cmpq %rdx, %rsi
cmovaeq %rdx, %rsi
xorl %edx, %edx
testb $0x1, %cl
cmovneq %rsi, %rdx
leaq 0x56d6b(%rip), %rax     # 0x7ae93
cmovneq %rdi, %rax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x58874(%rip), %rdi     # 0x7c9ac
leaq 0x56d96(%rip), %rsi     # 0x7aed5
leaq 0x58875(%rip), %rcx     # 0x7c9bb
movl $0x283, %edx            # imm = 0x283
callq 0x1b320
// File: /workspace/github_cpp_makefile_star2_O3/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, %r12
movq %r8, -0x30(%rbp)
movq %rcx, -0x48(%rbp)
movq %rdx, %r13
movq %rsi, %rbx
movq %rdi, %r14
movl $0x28, %edi
callq 0x1b510
leaq 0x10(%rax), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movq $0x0, 0x20(%rax)
movq %rax, (%r14)
movq %rbx, (%rax)
movq %rax, -0x40(%rbp)
movq %r13, 0x8(%rax)
movq 0x8(%r12), %rsi
subq (%r12), %rsi
sarq $0x2, %rsi
movq %r15, %rdi
callq 0x3eace
leaq -0x60(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x23e76
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rax
subq %rdi, %rax
sarq $0x4, %rax
movq (%r12), %r13
movq 0x8(%r12), %r12
movq %r12, %rcx
subq %r13, %rcx
sarq $0x2, %rcx
cmpq %rcx, %rax
jne 0x24293
cmpq %r12, %r13
je 0x24277
movq %r14, -0x30(%rbp)
xorl %r14d, %r14d
leaq -0x34(%rbp), %rbx
movl (%r13), %eax
movl %eax, -0x34(%rbp)
movq -0x60(%rbp), %rdx
addq %r14, %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3eb96
addq $0x4, %r13
addq $0x10, %r14
cmpq %r12, %r13
jne 0x24249
movq -0x60(%rbp), %rdi
movq -0x30(%rbp), %r14
testq %rdi, %rdi
je 0x24281
callq 0x1b4d0
movq %r14, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x56c18(%rip), %rdi     # 0x7aeb2
leaq 0x56c34(%rip), %rsi     # 0x7aed5
leaq 0x56c60(%rip), %rcx     # 0x7af08
movl $0x2984, %edx           # imm = 0x2984
callq 0x1b320
jmp 0x242b4
movq %r14, -0x30(%rbp)
movq %rax, %r15
jmp 0x242ce
movq %rax, %r15
movq -0x60(%rbp), %rdi
testq %rdi, %rdi
je 0x242ce
callq 0x1b4d0
movq -0x40(%rbp), %rbx
movq %rbx, %rdi
callq 0x24150
movq %rbx, %rdi
callq 0x1b4d0
movq -0x30(%rbp), %rax
movq $0x0, (%rax)
movq %r15, %rdi
callq 0x1b910
nop
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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 0x245c3
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 0x1b5a0
movq %rbx, %rdi
callq 0x1b550
movq %rax, %rbx
cmpq $0x0, -0x10(%rbp)
je 0x245ea
leaq -0x10(%rbp), %rdi
callq 0x1b460
movq %rbx, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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, 0x863c4(%rip)     # 0xaa9c8
jne 0x24656
movq 0x863c3(%rip), %rbx     # 0xaa9d0
testq %rbx, %rbx
jne 0x24632
movl $0xfa, %edi
callq 0x1b310
cmpq $0x8001, %rax           # imm = 0x8001
movl $0x8000, %ebx           # imm = 0x8000
cmovaeq %rax, %rbx
movq %rbx, 0x8639e(%rip)     # 0xaa9d0
movq %rbx, %rdi
callq 0x1b030
movq %rax, %r14
movq %rax, %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x1b2a0
movq %r14, 0x86377(%rip)     # 0xaa9c8
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x56950(%rip), %rdi     # 0x7afad
leaq 0x56871(%rip), %rsi     # 0x7aed5
leaq 0x56993(%rip), %rcx     # 0x7affe
movl $0x2aaa, %edx           # imm = 0x2AAA
callq 0x1b320
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x86317(%rip), %rax     # 0xaa9c8
leaq -0x38(%rbp), %rdi
movq %rax, (%rdi)
movq 0x86311(%rip), %rax     # 0xaa9d0
movq %rax, 0x10(%rdi)
movl $0x0, 0x8(%rdi)
leaq 0x86307(%rip), %rsi     # 0xaa9d8
callq 0x1b990
leaq -0xc8(%rbp), %rbx
xorl %r15d, %r15d
movl $0x90, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1b2a0
leaq 0x53(%rip), %rax        # 0x24749
movq %rax, -0x8(%rbx)
movl $0x8000000, 0x80(%rbx)  # imm = 0x8000000
leaq 0x862e5(%rip), %rbx     # 0xaa9f0
leaq 0x816be(%rip), %r12     # 0xa5dd0
leaq -0xd0(%rbp), %r14
movl (%r15,%r12), %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1b650
addq $0x10, %r15
addq $0x98, %rbx
cmpq $0x60, %r15
jne 0x24719
addq $0xb0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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
movl $0x8, %eax
leaq 0x8166a(%rip), %rcx     # 0xa5dd0
leaq 0x57ef9(%rip), %r14     # 0x7c666
cmpl %ebx, -0x8(%rax,%rcx)
je 0x2477f
addq $0x10, %rax
cmpq $0x68, %rax
jne 0x2476d
jmp 0x24783
movq (%rax,%rcx), %r14
callq 0x2480f
leaq 0x86221(%rip), %r15     # 0xaa9b0
movq (%r15), %rdi
testq %rdi, %rdi
je 0x2479c
movq (%rdi), %rax
jmp 0x247cd
movl $0x30, %edi
callq 0x1b510
movq %rax, %rdi
leaq 0x81580(%rip), %rcx     # 0xa5d30
leaq 0x10(%rcx), %rax
movq %rax, (%rdi)
addq $0x60, %rcx
movq %rcx, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
movq %rdi, (%r15)
callq *0x10(%rax)
movq %rax, %r15
leaq -0x30(%rbp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x2d8fc
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq (%r15), %rax
movq %r15, %rdi
callq *0x48(%rax)
movl %ebx, %edi
callq 0x1b530
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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 0x861d0(%rip), %rbx     # 0xaa9f0
xorl %r14d, %r14d
leaq 0x815a6(%rip), %r15     # 0xa5dd0
movl (%r14,%r15), %edi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x1b650
addq $0x10, %r14
addq $0x98, %rbx
cmpq $0x60, %r14
jne 0x2482a
leaq 0x86188(%rip), %rdi     # 0xaa9d8
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1b990
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rsi, %r13
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rax
subq (%rsi), %rax
movq %rdx, %r15
sarq $0x3, %rax
movabsq $-0x2c8590b21642c859, %rsi # imm = 0xD37A6F4DE9BD37A7
imulq %rax, %rsi
callq 0x3ffa6
movq (%r13), %r12
movq 0x8(%r13), %r13
cmpq %r13, %r12
je 0x25825
movq (%r15), %rax
cmpq 0x8(%r15), %rax
je 0x25806
movq %r15, %rdi
movq %r12, %rsi
callq 0x2edde
testb %al, %al
je 0x2581c
testb $0x10, 0xa0(%r12)
je 0x25811
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
testb %al, %al
jne 0x25811
jmp 0x2581c
testb $0x2, 0xa0(%r12)
jne 0x2581c
movq %rbx, %rdi
movq %r12, %rsi
callq 0x40086
addq $0xb8, %r12
jmp 0x257cf
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x25839
movq %rax, %r14
movq %rbx, %rdi
callq 0x3f08c
movq %r14, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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 %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x60(%rsi), %rax
movq 0x68(%rsi), %rcx
movq %rcx, %rsi
subq %rax, %rsi
sarq $0x4, %rsi
cmpq %rax, %rcx
je 0x258d0
addq 0x8(%rax), %rsi
addq $0x20, %rax
cmpq %rcx, %rax
jne 0x258c3
movq %rbx, %rdi
callq 0x1b7e0
movq 0x60(%r14), %r12
movq 0x68(%r14), %r14
cmpq %r14, %r12
je 0x25916
movq %rbx, %rdi
movl $0x5b, %esi
callq 0x1b480
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %rbx, %rdi
callq 0x1b150
movq %rbx, %rdi
movl $0x5d, %esi
callq 0x1b480
addq $0x20, %r12
jmp 0x258e0
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x25924
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x25934
callq 0x1b4d0
movq %r14, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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 $0x28, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
callq *0x68(%rax)
movq %rax, %r14
callq 0x3cd2c
movq (%rax), %rcx
movq %rax, %rdi
callq *0x18(%rcx)
movq (%rax), %rcx
movq %rax, %rdi
movq %rbx, %rsi
callq *0x18(%rcx)
leaq -0x48(%rbp), %r15
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x25781
movq (%r15), %r12
movq 0x8(%r15), %r13
xorl %r14d, %r14d
cmpq %r13, %r12
je 0x25acc
movq 0x84593(%rip), %r15     # 0xa9f98
movq (%r12), %rsi
movq 0x8(%r12), %rdx
testq %rdx, %rdx
je 0x25a55
cmpb $0x23, (%rsi)
jne 0x25a55
movb $0x22, -0x29(%rbp)
movl $0x1, %edx
movq %r15, %rdi
leaq -0x29(%rbp), %rsi
callq 0x1b5e0
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %rax, %rdi
callq 0x1b5e0
movb $0x22, -0x29(%rbp)
movl $0x1, %edx
movq %rax, %rdi
leaq -0x29(%rbp), %rsi
callq 0x1b5e0
jmp 0x25a5d
movq %r15, %rdi
callq 0x1b5e0
movq (%rbx), %rax
movq %rbx, %rdi
callq *0xa0(%rax)
cmpl $0x2, %eax
jl 0x25a92
movl $0x2, %edx
movq %r15, %rdi
leaq 0x5560c(%rip), %rsi     # 0x7b089
callq 0x1b5e0
leaq 0x90(%r12), %rsi
movq %r15, %rdi
callq 0x22e17
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x1b4f0
movsbl %al, %esi
movq %r15, %rdi
callq 0x1b040
movq %rax, %rdi
callq 0x1b360
addq $0xb8, %r12
incq %r14
cmpq %r13, %r12
jne 0x25a05
leaq -0x48(%rbp), %rdi
callq 0x3f08c
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x3f08c
movq %rbx, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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), %r12
xorl %r15d, %r15d
cmpq %r12, %rax
je 0x25b5b
movq 0x28(%rax), %rcx
addq %rcx, %r15
addq $0x2, %r15
movq %rax, %rdi
callq 0x1b600
jmp 0x25b41
leaq 0x10(%rbx), %r13
movq %r13, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1b7e0
movq 0x18(%r14), %r14
cmpq %r12, %r14
je 0x25bbc
movq %rbx, %rdi
movl $0x5b, %esi
callq 0x1b480
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
movq %rbx, %rdi
callq 0x1b150
movq %rbx, %rdi
movl $0x5d, %esi
callq 0x1b480
movq %r14, %rdi
callq 0x1b600
movq %rax, %r14
cmpq %r12, %rax
jne 0x25b82
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x25bd0
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r13, %rdi
je 0x25be0
callq 0x1b4d0
movq %r14, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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 %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq $0x0, (%rdi)
leaq 0x844a2(%rip), %r15     # 0xaa9b0
movq (%r15), %rdi
testq %rdi, %rdi
jne 0x26547
movl $0x30, %edi
callq 0x1b510
movq %rax, %rdi
leaq 0x7f806(%rip), %rax     # 0xa5d30
leaq 0x10(%rax), %rcx
movq %rcx, (%rdi)
addq $0x60, %rax
movq %rax, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
movups %xmm0, 0x20(%rdi)
movq %rdi, (%r15)
movq (%r14), %rax
movq %rax, -0x28(%rbp)
movq 0x8(%r14), %rax
movq %rax, -0x20(%rbp)
testq %rax, %rax
je 0x26570
movq 0x83a2e(%rip), %rcx     # 0xa9f90
cmpb $0x0, (%rcx)
je 0x2656c
incl 0x8(%rax)
jmp 0x26570
lock
incl 0x8(%rax)
movq (%rdi), %rax
leaq -0x28(%rbp), %rsi
callq *0x38(%rax)
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x26588
callq 0x43a1a
movq (%r14), %rdi
cmpb $0x1, 0x8(%rdi)
jne 0x265b7
movq (%rbx), %rax
testq %rax, %rax
je 0x2659e
movq (%rax), %r15
jmp 0x265a1
xorl %r15d, %r15d
callq 0x25252
addq %r15, %rax
leaq 0x8(%rbx), %rcx
movq %rax, 0x8(%rbx)
movq %rcx, (%rbx)
movq (%r14), %rdi
cmpb $0x1, 0xb(%rdi)
jne 0x265e3
movq (%rbx), %rax
testq %rax, %rax
je 0x265ca
movq (%rax), %r15
jmp 0x265cd
xorl %r15d, %r15d
callq 0x2599f
addq %r15, %rax
leaq 0x8(%rbx), %rcx
movq %rax, 0x8(%rbx)
movq %rcx, (%rbx)
movq (%r14), %rdi
cmpb $0x1, 0x9(%rdi)
jne 0x2660f
movq (%rbx), %rax
testq %rax, %rax
je 0x265f6
movq (%rax), %r15
jmp 0x265f9
xorl %r15d, %r15d
callq 0x25be8
addq %r15, %rax
leaq 0x8(%rbx), %rcx
movq %rax, 0x8(%rbx)
movq %rcx, (%rbx)
movq (%r14), %rdi
cmpb $0x1, 0xa(%rdi)
jne 0x26638
movq (%rbx), %rax
testq %rax, %rax
je 0x26622
movq (%rax), %r14
jmp 0x26625
xorl %r14d, %r14d
callq 0x2621b
addq %r14, %rax
leaq 0x8(%rbx), %rcx
movq %rax, 0x8(%rbx)
movq %rcx, (%rbx)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2664e
jmp 0x2664e
jmp 0x2664e
jmp 0x2664e
movq %rax, %r14
movq $0x0, (%rbx)
movq %r14, %rdi
callq 0x1b910
movq %rax, %r14
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x26651
callq 0x43a1a
jmp 0x26651
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
leaq 0x18(%rdi), %r15
movq %r15, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
leaq 0x7f32e(%rip), %rax     # 0xa5f40
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 0x26c4d
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %rbx
leaq -0x30(%rbp), %rdi
callq 0x2d4e2
movq -0x20(%rbp), %rdi
leaq 0x544ce(%rip), %rsi     # 0x7b132
movl $0x38, %edx
callq 0x1b5e0
movq -0x20(%rbp), %rsi
addq $0x8, %rsi
leaq -0x50(%rbp), %rdi
callq 0x1b7f0
leaq -0x50(%rbp), %rdi
callq 0x1cf32
movq %rax, %r14
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x26ca2
callq 0x1b4d0
jmp 0x26ca2
movq %rax, %r14
leaq -0x30(%rbp), %rdi
callq 0x2d528
jmp 0x26cb0
movq %rax, %r14
leaq 0x7f219(%rip), %rax     # 0xa5ed0
addq $0x10, %rax
movq %rax, (%rbx)
movq 0x8(%rbx), %rdi
cmpq %r15, %rdi
je 0x26ccc
callq 0x1b4d0
movq %r14, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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 0x26d3d
testl %eax, %eax
jne 0x26dbc
cvtsd2ss (%rsi), %xmm0
cvtsd2ss 0x30(%rdi), %xmm1
ucomiss %xmm1, %xmm0
jp 0x26db8
movd %xmm0, %eax
movd %xmm1, %ecx
movl %ecx, %edx
xorl %eax, %edx
js 0x26da5
subl %ecx, %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
andps 0x5233e(%rip), %xmm0    # 0x79060
cvttss2si %xmm0, %rax
movq %rax, %rcx
subss 0x523ce(%rip), %xmm0    # 0x79100
sarq $0x3f, %rcx
cvttss2si %xmm0, %rdx
jmp 0x26d8a
movsd (%rsi), %xmm0
movsd 0x30(%rdi), %xmm1
ucomisd %xmm1, %xmm0
jp 0x26db8
movq %xmm0, %rax
movq %xmm1, %rcx
movq %rcx, %rdx
xorq %rax, %rdx
js 0x26d99
subq %rcx, %rax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
andpd 0x522af(%rip), %xmm0    # 0x79020
cvttsd2si %xmm0, %rax
movq %rax, %rcx
subsd 0x52347(%rip), %xmm0    # 0x790c8
sarq $0x3f, %rcx
cvttsd2si %xmm0, %rdx
andq %rcx, %rdx
orq %rax, %rdx
cmpq %rdx, 0x38(%rdi)
setae %al
jmp 0x26db1
cmpeqsd %xmm1, %xmm0
movq %xmm0, %rax
jmp 0x26dae
cmpeqss %xmm1, %xmm0
movd %xmm0, %eax
andl $0x1, %eax
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
xorl %eax, %eax
jmp 0x26db1
leaq -0x20(%rbp), %rbx
movq %rbx, %rdi
callq 0x2d4e2
leaq 0x54106(%rip), %rax     # 0x7aed5
leaq -0x50(%rbp), %rsi
movq %rax, (%rsi)
movq $0x2d54, 0x8(%rsi)      # imm = 0x2D54
movq 0x10(%rbx), %rdi
callq 0x22e17
movq -0x10(%rbp), %rdi
leaq 0x54379(%rip), %rsi     # 0x7b16b
movl $0x19, %edx
callq 0x1b5e0
movq -0x10(%rbp), %rdi
leaq 0x5437e(%rip), %rsi     # 0x7b185
movl $0x1f, %edx
callq 0x1b5e0
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
leaq -0x40(%rbp), %rdi
callq 0x1b7f0
leaq -0x40(%rbp), %rdi
callq 0x23e01
movq %rax, %rbx
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x26e45
callq 0x1b4d0
jmp 0x26e45
movq %rax, %rbx
leaq -0x20(%rbp), %rdi
callq 0x2d528
movq %rbx, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O3/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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 0x275a2
movq %rsi, %rdx
leaq 0x53d14(%rip), %rsi     # 0x7b26f
leaq -0x30(%rbp), %r14
movq %r14, %rdi
callq 0x3f209
movq 0x8(%r14), %rsi
movl $0x1, %ecx
movq %r14, %rdi
xorl %edx, %edx
movl $0x22, %r8d
callq 0x1b980
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x275c1
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x275c7
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x53ca1(%rip), %rsi     # 0x7b251
leaq 0x53cb7(%rip), %rdx     # 0x7b26e
movq %rbx, %rdi
callq 0x431c8
jmp 0x275f0
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x275f0
callq 0x1b4d0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x20(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x27611
callq 0x1b4d0
movq %rbx, %rdi
callq 0x1b910
nop