LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1d706
movq 0x8(%r15), %rdx
testq %rdx, %rdx
je 0x1db7e
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq -0x38(%rbp), %rsi
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x4ad3e
jmp 0x1db89
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1d8f8
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1db9b
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 0x1dbbe
callq 0x1b4d0
movq %rbx, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O1/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 0x23357
callq 0x1b4d0
movq 0x80(%rbx), %rax
cmpq %rax, 0x88(%rbx)
je 0x2336e
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 0x233ce
xorl %eax, %eax
movq 0x20(%rbx), %rcx
movsbl (%rcx,%rax), %esi
movq %rbx, %rdi
callq 0x306f0
testb %al, %al
je 0x233bf
movq 0x10(%rbx), %rax
incq %rax
movq %rax, 0x10(%rbx)
cmpq 0x28(%rbx), %rax
jb 0x23398
jmp 0x233ce
leaq 0xc8(%rbx), %rdi
movq %r14, %rsi
callq 0x3ff26
movq %rbx, %rdi
callq 0x3083c
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x890b6(%rip), %al      # 0xac9a8
testb %al, %al
je 0x2391a
movq 0x890a3(%rip), %rdi     # 0xac9a0
testq %rdi, %rdi
je 0x23913
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 0x89087(%rip), %rdi     # 0xac9a8
callq 0x1b930
testl %eax, %eax
je 0x238f6
callq 0x23996
movq %rax, 0x8906a(%rip)     # 0xac9a0
leaq 0x8906b(%rip), %rdi     # 0xac9a8
callq 0x1b300
jmp 0x238f6
movq %rax, %rbx
leaq 0x8905a(%rip), %rdi     # 0xac9a8
callq 0x1b2f0
movq %rbx, %rdi
callq 0x1b910
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x243a2
leaq 0x89000(%rip), %rbx     # 0xac9b0
cmpq $0x0, (%rbx)
jne 0x239e7
movl $0x30, %edi
callq 0x1b510
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x10(%rax)
leaq 0x841fb(%rip), %rcx     # 0xa7bd0
leaq 0x10(%rcx), %rdx
movq %rdx, (%rax)
addq $0x60, %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%rbx)
movq (%rbx), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq (%rax), %rdi
movq 0x8(%rax), %rbx
testq %rbx, %rbx
je 0x23a11
movq 0x8858d(%rip), %rax     # 0xabf90
cmpb $0x0, (%rax)
je 0x23a0d
incl 0x8(%rbx)
jmp 0x23a11
lock
incl 0x8(%rbx)
testq %rdi, %rdi
je 0x23a21
movq (%rdi), %rax
callq *0x90(%rax)
jmp 0x23a23
xorl %eax, %eax
testl %eax, %eax
jne 0x23a3b
movl $0x1, %edi
callq 0x1b8e0
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x1, %ecx
adcl $0x1, %eax
cmpl $0x1, %eax
jne 0x23a53
movb 0x893a2(%rip), %al      # 0xacde8
testb %al, %al
je 0x23a88
leaq 0x88af7(%rip), %r14     # 0xac548
jmp 0x23a64
movb 0x89397(%rip), %al      # 0xacdf0
testb %al, %al
je 0x23aa0
leaq 0x88aec(%rip), %r14     # 0xac550
testq %rbx, %rbx
je 0x23a71
movq %rbx, %rdi
callq 0x43ca8
leaq -0x1c(%rbp), %rdi
callq 0x243bc
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x89359(%rip), %r15     # 0xacde8
movq %r15, %rdi
callq 0x1b930
leaq 0x88aaa(%rip), %r14     # 0xac548
jmp 0x23ab6
leaq 0x89349(%rip), %r15     # 0xacdf0
movq %r15, %rdi
callq 0x1b930
leaq 0x88a9a(%rip), %r14     # 0xac550
testl %eax, %eax
je 0x23a64
movq %r15, %rdi
callq 0x1b300
jmp 0x23a64
movq %rax, %r14
testq %rbx, %rbx
je 0x23ad9
movq %rbx, %rdi
callq 0x43ca8
jmp 0x23ad9
movq %rax, %r14
leaq -0x1c(%rbp), %rdi
callq 0x243bc
movq %r14, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O1/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 0x243a2
leaq 0x5821a(%rip), %rsi     # 0x7be76
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 0x581f6(%rip), %r15     # 0x7be88
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 0x23cf0
movl $0xb, %edx
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rcx
callq 0x1b6c0
testl %eax, %eax
jne 0x23c92
cmpq $0xc, -0x40(%rbp)
jb 0x23cf0
movq -0x48(%rbp), %rax
cmpb $0x30, 0xb(%rax)
setne %bl
jmp 0x23cf2
xorl %ebx, %ebx
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x23d00
callq 0x1b4d0
leaq -0x250(%rbp), %rdi
callq 0x1b120
leaq -0x24(%rbp), %rdi
callq 0x243bc
movl %ebx, %eax
addq $0x230, %rsp            # imm = 0x230
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x23d49
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x23d3d
callq 0x1b4d0
leaq -0x250(%rbp), %rdi
callq 0x1b120
leaq -0x24(%rbp), %rdi
callq 0x243bc
movq %rbx, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O1/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, %r13
movq %rdi, %r12
movq 0x8(%r8), %rax
addq 0x8(%rsi), %rax
cmpq $0x27, %rax
ja 0x23db6
movq %r13, %rdi
movl $0xa, %esi
xorl %edx, %edx
callq 0x1b680
cmpq $-0x1, %rax
jne 0x23db6
movq %rbx, %rdi
movl $0xa, %esi
xorl %edx, %edx
callq 0x1b680
cmpq $-0x1, %rax
je 0x23e1f
leaq 0x60dc5(%rip), %r14     # 0x84b82
movq (%r13), %rsi
movq 0x8(%r13), %rdx
movq %r12, %rdi
callq 0x1b5e0
movq %rax, %r12
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x1b5e0
movq %r12, %rdi
movq %r15, %rsi
movq -0x30(%rbp), %rdx
callq 0x1b690
movq %rax, %r15
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x1b5e0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1b5e0
leaq 0x58877(%rip), %r14     # 0x7c69d
jmp 0x23dbd
// File: /workspace/github_cpp_makefile_star2_O1/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 0x23fc5
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq 0x8(%r14), %rsi
subq (%r14), %rsi
sarq $0x4, %rsi
movq %rbx, %rdi
callq 0x3ed3a
movq -0x50(%rbp), %r15
movq -0x48(%rbp), %r12
cmpq %r12, %r15
je 0x23f7d
leaq 0x57f89(%rip), %r13     # 0x7be93
leaq -0x38(%rbp), %r14
movq (%r15), %rdi
movq 0x8(%r15), %rax
leaq 0x1(%rax), %rdx
cmpq $0x1, %rdx
je 0x23f2f
leaq -0x1(%rdx), %rcx
cmpb $0x3a, -0x2(%rdi,%rdx)
movq %rcx, %rdx
jne 0x23f19
jmp 0x23f31
xorl %ecx, %ecx
addq %rcx, %rdi
subq %rcx, %rax
movl $0x0, %esi
cmovaeq %rax, %rsi
cmovbeq %r13, %rdi
callq 0x240d0
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x23f69
movups -0x38(%rbp), %xmm0
movups %xmm0, (%rsi)
addq $0x10, 0x8(%rbx)
jmp 0x23f74
movq %rbx, %rdi
movq %r14, %rdx
callq 0x4cefc
addq $0x10, %r15
cmpq %r12, %r15
jne 0x23f0e
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x23f8b
callq 0x1b4d0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x23f9f
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x23faf
callq 0x1b4d0
movq -0x50(%rbp), %rdi
testq %rdi, %rdi
je 0x23fbd
callq 0x1b4d0
movq %r14, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2406e
movl %ecx, %r12d
xorl %r13d, %r13d
xorl %eax, %eax
cmpb %r12b, (%r15,%r13)
jne 0x24064
movq %r13, %rcx
subq %rax, %rcx
cmpq $0x2, %rcx
jb 0x24060
leaq (%r15,%rax), %rdx
movq %r14, %rsi
subq %rax, %rsi
leaq 0x57e76(%rip), %rdi     # 0x7be93
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 0x24054
movups -0x38(%rbp), %xmm0
movups %xmm0, (%rsi)
addq $0x10, 0x8(%rbx)
jmp 0x24060
movq %rbx, %rdi
leaq -0x38(%rbp), %rdx
callq 0x4cefc
leaq 0x1(%r13), %rax
incq %r13
cmpq %r13, %r14
jne 0x23ffa
jmp 0x24070
xorl %eax, %eax
subq %rax, %r14
jbe 0x240a4
addq %rax, %r15
movq %r15, -0x38(%rbp)
movq %r14, -0x30(%rbp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x24098
movups -0x38(%rbp), %xmm0
movups %xmm0, (%rsi)
addq $0x10, 0x8(%rbx)
jmp 0x240a4
leaq -0x38(%rbp), %rdx
movq %rbx, %rdi
callq 0x4cefc
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x240b8
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x240c8
callq 0x1b4d0
movq %r14, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O1/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:
movabsq $0x100002600, %rdx      # imm = 0x100002600
testq %rsi, %rsi
setne %al
je 0x24105
xorl %ecx, %ecx
movzbl (%rdi,%rcx), %r8d
cmpq $0x20, %r8
ja 0x24107
btq %r8, %rdx
jae 0x24107
incq %rcx
cmpq %rsi, %rcx
setb %al
jne 0x240e4
movq %rsi, %rcx
jmp 0x24107
xorl %ecx, %ecx
movq %rsi, %r8
subq %rcx, %r8
jbe 0x2413a
movq %rsi, %r9
leaq -0x1(%r9), %r10
cmpq %rsi, %r10
jae 0x2415e
movzbl -0x1(%rdi,%r9), %r11d
cmpq $0x20, %r11
ja 0x2413d
btq %r11, %rdx
jae 0x2413d
movq %r10, %r9
cmpq %rcx, %r10
ja 0x24112
movq %rcx, %r9
jmp 0x2413d
movq %rsi, %r9
subq %rcx, %r9
addq %rcx, %rdi
cmpq %r9, %r8
cmovbq %r8, %r9
xorl %edx, %edx
testb $0x1, %al
cmovneq %r9, %rdx
leaq 0x57d3a(%rip), %rax     # 0x7be93
cmovneq %rdi, %rax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x59843(%rip), %rdi     # 0x7d9ac
leaq 0x57d65(%rip), %rsi     # 0x7bed5
leaq 0x59844(%rip), %rcx     # 0x7d9bb
movl $0x283, %edx            # imm = 0x283
callq 0x1b320
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, -0x48(%rbp)
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %r14
movl $0x28, %edi
callq 0x1b510
leaq 0x57c88(%rip), %rcx     # 0x7be93
movq %rcx, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movups %xmm0, 0x18(%rax)
movq %r14, -0x38(%rbp)
movq %rax, (%r14)
movq %r13, (%rax)
movq %r15, 0x8(%rax)
movq %rax, -0x40(%rbp)
leaq 0x10(%rax), %r15
movq 0x8(%r12), %rsi
subq (%r12), %rsi
sarq $0x2, %rsi
movq %r15, %rdi
callq 0x3ede4
leaq -0x60(%rbp), %rdi
movq %rbx, %rsi
movq -0x48(%rbp), %rdx
callq 0x23eb0
movq -0x58(%rbp), %rax
subq -0x60(%rbp), %rax
sarq $0x4, %rax
movq (%r12), %r13
movq 0x8(%r12), %r12
movq %r12, %rcx
subq %r13, %rcx
sarq $0x2, %rcx
cmpq %rcx, %rax
jne 0x242cb
cmpq %r12, %r13
je 0x242aa
xorl %r14d, %r14d
leaq -0x2c(%rbp), %rbx
movl (%r13), %eax
movl %eax, -0x2c(%rbp)
movq -0x60(%rbp), %rdx
addq %r14, %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3eeac
addq $0x4, %r13
addq $0x10, %r14
cmpq %r12, %r13
jne 0x24284
movq -0x60(%rbp), %rdi
testq %rdi, %rdi
je 0x242b8
callq 0x1b4d0
movq -0x38(%rbp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x57be0(%rip), %rdi     # 0x7beb2
leaq 0x57bfc(%rip), %rsi     # 0x7bed5
leaq 0x57c28(%rip), %rcx     # 0x7bf08
movl $0x2984, %edx           # imm = 0x2984
callq 0x1b320
jmp 0x242ec
movq %rax, %r15
jmp 0x24302
movq %rax, %r15
movq -0x60(%rbp), %rdi
testq %rdi, %rdi
je 0x24302
callq 0x1b4d0
movq -0x40(%rbp), %rbx
movq %rbx, %rdi
callq 0x24182
movq %rbx, %rdi
callq 0x1b4d0
movq -0x38(%rbp), %rax
movq $0x0, (%rax)
movq %r15, %rdi
callq 0x1b910
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x245fd
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 0x24624
leaq -0x10(%rbp), %rdi
callq 0x1b460
movq %rbx, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O1/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, 0x8838a(%rip)     # 0xac9c8
jne 0x24695
cmpq $0x0, 0x88388(%rip)     # 0xac9d0
jne 0x2466a
movl $0xfa, %edi
callq 0x1b310
cmpq $0x8001, %rax           # imm = 0x8001
movl $0x8000, %ecx           # imm = 0x8000
cmovaeq %rax, %rcx
movq %rcx, 0x88366(%rip)     # 0xac9d0
movq 0x8835f(%rip), %rbx     # 0xac9d0
movq %rbx, %rdi
callq 0x1b030
movq %rax, %r14
movq %rax, %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x1b2a0
movq %r14, 0x88338(%rip)     # 0xac9c8
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x57911(%rip), %rdi     # 0x7bfad
leaq 0x57832(%rip), %rsi     # 0x7bed5
leaq 0x57954(%rip), %rcx     # 0x7bffe
movl $0x2aaa, %edx           # imm = 0x2AAA
callq 0x1b320
// File: /workspace/github_cpp_makefile_star2_O1/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 0x882d9(%rip), %rax     # 0xac9c8
leaq -0x38(%rbp), %rdi
movq %rax, (%rdi)
movq 0x882d3(%rip), %rax     # 0xac9d0
movq %rax, 0x10(%rdi)
movl $0x0, 0x8(%rdi)
leaq 0x882c9(%rip), %rsi     # 0xac9d8
callq 0x1b990
leaq -0xd0(%rbp), %rbx
xorl %r15d, %r15d
movl $0x98, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x1b2a0
leaq 0x4b(%rip), %rax        # 0x2477f
movq %rax, (%rbx)
movl $0x8000000, 0x88(%rbx)  # imm = 0x8000000
leaq 0x882a8(%rip), %r14     # 0xac9f0
leaq 0x83521(%rip), %r12     # 0xa7c70
movl (%r15,%r12), %edi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1b650
addq $0x10, %r15
addq $0x98, %r14
cmpq $0x60, %r15
jne 0x2474f
addq $0xb0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
leaq 0x58ecf(%rip), %r14     # 0x7d666
movl $0x8, %ecx
leaq 0x834cd(%rip), %rax     # 0xa7c70
movl -0x8(%rcx,%rax), %edx
cmpl %ebx, %edx
jne 0x247af
movq (%rcx,%rax), %r14
cmpl %ebx, %edx
je 0x247c0
leaq 0x10(%rcx), %rdx
cmpq $0x58, %rcx
movq %rdx, %rcx
jne 0x247a3
callq 0x2484b
leaq 0x881e4(%rip), %r15     # 0xac9b0
cmpq $0x0, (%r15)
jne 0x24803
movl $0x30, %edi
callq 0x1b510
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x10(%rax)
movaps %xmm0, 0x20(%rax)
leaq 0x833df(%rip), %rcx     # 0xa7bd0
leaq 0x10(%rcx), %rdx
movq %rdx, (%rax)
addq $0x60, %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%r15)
movq (%r15), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %r15
leaq -0x30(%rbp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x2d91c
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_O1/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 0x88194(%rip), %rbx     # 0xac9f0
xorl %r14d, %r14d
leaq 0x8340a(%rip), %r15     # 0xa7c70
movl (%r14,%r15), %edi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x1b650
addq $0x10, %r14
addq $0x98, %rbx
cmpq $0x60, %r14
jne 0x24866
leaq 0x8814c(%rip), %rdi     # 0xac9d8
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1b990
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x40276
movq (%r13), %r12
movq 0x8(%r13), %r13
cmpq %r13, %r12
je 0x2586b
movq (%r15), %rax
movq 0x8(%r15), %rcx
cmpq %rcx, %rax
je 0x25845
movq %r15, %rdi
movq %r12, %rsi
callq 0x2ee02
testb %al, %al
je 0x2585b
testb $0x10, 0xa0(%r12)
je 0x25850
movq (%r14), %rax
movq %r14, %rdi
callq *0x10(%rax)
testb %al, %al
jne 0x25850
jmp 0x2585b
testb $0x2, 0xa0(%r12)
jne 0x25864
movq %rbx, %rdi
movq %r12, %rsi
callq 0x40356
addq $0xb8, %r12
jmp 0x2580b
cmpq %rcx, %rax
jne 0x2581c
jmp 0x2585b
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2587f
movq %rax, %r14
movq %rbx, %rdi
callq 0x3f392
movq %r14, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O1/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 0x25916
addq 0x8(%rax), %rsi
addq $0x20, %rax
cmpq %rcx, %rax
jne 0x25909
movq %rbx, %rdi
callq 0x1b7e0
movq 0x60(%r14), %r12
movq 0x68(%r14), %r14
cmpq %r14, %r12
je 0x2595c
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 0x25926
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2596a
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x2597a
callq 0x1b4d0
movq %r14, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3cfe8
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 0x257bd
movq (%r15), %r12
movq 0x8(%r15), %r13
xorl %r14d, %r14d
cmpq %r13, %r12
je 0x25b16
movq 0x8654d(%rip), %r15     # 0xabf98
movq 0x8(%r12), %rdx
testq %rdx, %rdx
je 0x25a9b
movq (%r12), %rax
cmpb $0x23, (%rax)
jne 0x25a9b
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 0x25aa7
movq (%r12), %rsi
movq %r15, %rdi
callq 0x1b5e0
movq (%rbx), %rax
movq %rbx, %rdi
callq *0xa0(%rax)
cmpl $0x2, %eax
jl 0x25adc
movl $0x2, %edx
movq %r15, %rdi
leaq 0x565c2(%rip), %rsi     # 0x7c089
callq 0x1b5e0
leaq 0x90(%r12), %rsi
movq %r15, %rdi
callq 0x22e23
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 0x25a4b
leaq -0x48(%rbp), %rdi
callq 0x3f392
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 0x3f392
movq %rbx, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O1/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 0x25ba5
movq 0x28(%rax), %rcx
addq %rcx, %r15
addq $0x2, %r15
movq %rax, %rdi
callq 0x1b600
jmp 0x25b8b
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 0x25c06
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 0x25bcc
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x25c1a
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r13, %rdi
je 0x25c2a
callq 0x1b4d0
movq %r14, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O1/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 0x86444(%rip), %r15     # 0xac9b0
cmpq $0x0, (%r15)
jne 0x265a3
movl $0x30, %edi
callq 0x1b510
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
movaps %xmm0, 0x20(%rax)
movaps %xmm0, 0x10(%rax)
leaq 0x8163f(%rip), %rcx     # 0xa7bd0
leaq 0x10(%rcx), %rdx
movq %rdx, (%rax)
addq $0x60, %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%r15)
movq (%r15), %rdi
movq (%r14), %rax
movq %rax, -0x28(%rbp)
movq 0x8(%r14), %rax
movq %rax, -0x20(%rbp)
testq %rax, %rax
je 0x265cf
movq 0x859cf(%rip), %rcx     # 0xabf90
cmpb $0x0, (%rcx)
je 0x265cb
incl 0x8(%rax)
jmp 0x265cf
lock
incl 0x8(%rax)
movq (%rdi), %rax
leaq -0x28(%rbp), %rsi
callq *0x38(%rax)
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x265e7
callq 0x43ca8
movq (%r14), %rdi
cmpb $0x1, 0x8(%rdi)
jne 0x26613
movq (%rbx), %rax
testq %rax, %rax
je 0x265fd
movq (%rax), %r15
jmp 0x26600
xorl %r15d, %r15d
callq 0x2528e
addq %r15, %rax
leaq 0x8(%rbx), %rcx
movq %rax, 0x8(%rbx)
movq %rcx, (%rbx)
movq (%r14), %rdi
cmpb $0x1, 0xb(%rdi)
jne 0x2663f
movq (%rbx), %rax
testq %rax, %rax
je 0x26629
movq (%rax), %r15
jmp 0x2662c
xorl %r15d, %r15d
callq 0x259e5
addq %r15, %rax
leaq 0x8(%rbx), %rcx
movq %rax, 0x8(%rbx)
movq %rcx, (%rbx)
movq (%r14), %rdi
cmpb $0x1, 0x9(%rdi)
jne 0x2666b
movq (%rbx), %rax
testq %rax, %rax
je 0x26655
movq (%rax), %r15
jmp 0x26658
xorl %r15d, %r15d
callq 0x25c32
addq %r15, %rax
leaq 0x8(%rbx), %rcx
movq %rax, 0x8(%rbx)
movq %rcx, (%rbx)
movq (%r14), %rax
cmpb $0x1, 0xa(%rax)
jne 0x26697
movq (%rbx), %rax
testq %rax, %rax
je 0x26681
movq (%rax), %r14
jmp 0x26684
xorl %r14d, %r14d
callq 0x26275
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 0x266ad
jmp 0x266ad
jmp 0x266ad
jmp 0x266ad
movq %rax, %r14
movq $0x0, (%rbx)
movq %r14, %rdi
callq 0x1b910
movq %rax, %r14
movq -0x20(%rbp), %rdi
testq %rdi, %rdi
je 0x266b0
callq 0x43ca8
jmp 0x266b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8116e(%rip), %rax     # 0xa7de0
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 0x26cad
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rdi, %rbx
leaq -0x30(%rbp), %rdi
callq 0x2d4f4
movq -0x20(%rbp), %rdi
leaq 0x5546e(%rip), %rsi     # 0x7c132
movl $0x38, %edx
callq 0x1b5e0
movq -0x20(%rbp), %rsi
addq $0x8, %rsi
leaq -0x50(%rbp), %rdi
callq 0x1b7f0
leaq -0x50(%rbp), %rdi
callq 0x1cf52
movq %rax, %r14
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x26d02
callq 0x1b4d0
jmp 0x26d02
movq %rax, %r14
leaq -0x30(%rbp), %rdi
callq 0x2d53a
jmp 0x26d10
movq %rax, %r14
leaq 0x81059(%rip), %rax     # 0xa7d70
addq $0x10, %rax
movq %rax, (%rbx)
movq 0x8(%rbx), %rdi
cmpq %r15, %rdi
je 0x26d2c
callq 0x1b4d0
movq %r14, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O1/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 0x26d9d
testl %eax, %eax
jne 0x26e1c
cvtsd2ss (%rsi), %xmm0
cvtsd2ss 0x30(%rdi), %xmm1
ucomiss %xmm1, %xmm0
jp 0x26e18
movd %xmm0, %eax
movd %xmm1, %ecx
movl %ecx, %edx
xorl %eax, %edx
js 0x26e05
subl %ecx, %eax
xorps %xmm0, %xmm0
cvtsi2ss %eax, %xmm0
andps 0x532de(%rip), %xmm0    # 0x7a060
cvttss2si %xmm0, %rax
movq %rax, %rcx
subss 0x5336e(%rip), %xmm0    # 0x7a100
sarq $0x3f, %rcx
cvttss2si %xmm0, %rdx
jmp 0x26dea
movsd (%rsi), %xmm0
movsd 0x30(%rdi), %xmm1
ucomisd %xmm1, %xmm0
jp 0x26e18
movq %xmm0, %rax
movq %xmm1, %rcx
movq %rcx, %rdx
xorq %rax, %rdx
js 0x26df9
subq %rcx, %rax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
andpd 0x5324f(%rip), %xmm0    # 0x7a020
cvttsd2si %xmm0, %rax
movq %rax, %rcx
subsd 0x532e7(%rip), %xmm0    # 0x7a0c8
sarq $0x3f, %rcx
cvttsd2si %xmm0, %rdx
andq %rcx, %rdx
orq %rax, %rdx
cmpq %rdx, 0x38(%rdi)
setae %al
jmp 0x26e11
cmpeqsd %xmm1, %xmm0
movq %xmm0, %rax
jmp 0x26e0e
cmpeqss %xmm1, %xmm0
movd %xmm0, %eax
andl $0x1, %eax
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
xorl %eax, %eax
jmp 0x26e11
leaq -0x20(%rbp), %rbx
movq %rbx, %rdi
callq 0x2d4f4
leaq 0x550a6(%rip), %rax     # 0x7bed5
leaq -0x50(%rbp), %rsi
movq %rax, (%rsi)
movq $0x2d54, 0x8(%rsi)      # imm = 0x2D54
movq 0x10(%rbx), %rdi
callq 0x22e23
movq -0x10(%rbp), %rdi
leaq 0x55319(%rip), %rsi     # 0x7c16b
movl $0x19, %edx
callq 0x1b5e0
movq -0x10(%rbp), %rdi
leaq 0x5531e(%rip), %rsi     # 0x7c185
movl $0x1f, %edx
callq 0x1b5e0
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
leaq -0x40(%rbp), %rdi
callq 0x1b7f0
leaq -0x40(%rbp), %rdi
callq 0x23e3c
movq %rax, %rbx
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x26ea5
callq 0x1b4d0
jmp 0x26ea5
movq %rax, %rbx
leaq -0x20(%rbp), %rdi
callq 0x2d53a
movq %rbx, %rdi
callq 0x1b910
// File: /workspace/github_cpp_makefile_star2_O1/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 0x27602
movq %rsi, %rdx
leaq 0x54cb4(%rip), %rsi     # 0x7c26f
leaq -0x30(%rbp), %r14
movq %r14, %rdi
callq 0x3f511
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 0x27621
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x27627
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x54c41(%rip), %rsi     # 0x7c251
leaq 0x54c57(%rip), %rdx     # 0x7c26e
movq %rbx, %rdi
callq 0x43438
jmp 0x27650
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 0x27650
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 0x27671
callq 0x1b4d0
movq %rbx, %rdi
callq 0x1b910
nop
// File: /workspace/github_cpp_makefile_star2_O1/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::Matchers::StdString::StringMatcherBase::describe[abi:cxx11]() const
std::string StringMatcherBase::describe() const {
            std::string description;
            description.reserve(5 + m_operation.size() + m_comparator.m_str.size() +
                                        m_comparator.caseSensitivitySuffix().size());
            description += m_operation;
            description += ": \"";
            description += m_comparator.m_str;
            description += "\"";
            description += m_comparator.caseSensitivitySuffix();
            return description;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, -0x58(%rbp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x40(%rsi), %r15
movq 0x60(%rsi), %r13
cmpl $0x1, 0x30(%rsi)
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
jne 0x27862
leaq -0x50(%rbp), %rsi
movq $0x13, (%rsi)
leaq -0x48(%rbp), %rdi
xorl %edx, %edx
callq 0x1b920
movq %rax, -0x48(%rbp)
movq -0x50(%rbp), %rcx
movq %rcx, -0x38(%rbp)
movups 0x54a3a(%rip), %xmm0    # 0x7c284
movups %xmm0, (%rax)
movl $0x29657669, 0xf(%rax)  # imm = 0x29657669
movq %rcx, -0x40(%rbp)
movq -0x48(%rbp), %rax
movb $0x0, (%rax,%rcx)
jmp 0x2786e
movq $0x0, -0x40(%rbp)
movb $0x0, -0x38(%rbp)
addq %r15, %r13
movq -0x40(%rbp), %rax
leaq (%rax,%r13), %rsi
addq $0x5, %rsi
movq %rbx, %rdi
callq 0x1b7e0
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x27893
callq 0x1b4d0
movq 0x58(%r14), %rsi
movq 0x60(%r14), %rdx
movq %rbx, %rdi
callq 0x1b150
leaq 0x549d6(%rip), %rsi     # 0x7c280
movq %rbx, %rdi
callq 0x1b9d0
movq 0x38(%r14), %rsi
movq 0x40(%r14), %rdx
movq %rbx, %rdi
callq 0x1b150
leaq 0x54e9e(%rip), %rsi     # 0x7c767
movq %rbx, %rdi
callq 0x1b9d0
cmpl $0x1, 0x30(%r14)
movq %r12, -0x48(%rbp)
jne 0x2791d
leaq -0x50(%rbp), %rsi
movq $0x13, (%rsi)
leaq -0x48(%rbp), %rdi
xorl %edx, %edx
callq 0x1b920
movq %rax, -0x48(%rbp)
movq -0x50(%rbp), %rcx
movq %rcx, -0x38(%rbp)
movups 0x5497f(%rip), %xmm0    # 0x7c284
movups %xmm0, (%rax)
movl $0x29657669, 0xf(%rax)  # imm = 0x29657669
movq %rcx, -0x40(%rbp)
movq -0x48(%rbp), %rax
movb $0x0, (%rax,%rcx)
jmp 0x27929
movq $0x0, -0x40(%rbp)
movb $0x0, -0x38(%rbp)
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq %rbx, %rdi
callq 0x1b150
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x27947
callq 0x1b4d0
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x27972
jmp 0x27972
jmp 0x2795f
movq %rax, %r14
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0x27975
callq 0x1b4d0
jmp 0x27975
movq %rax, %r14
movq (%rbx), %rdi
cmpq -0x58(%rbp), %rdi
je 0x27983
callq 0x1b4d0
movq %r14, %rdi
callq 0x1b910
nop
// File: /workspace/github_cpp_makefile_star2_O1/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::Matchers::StdString::RegexMatcher::match(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
bool RegexMatcher::match(std::string const& matchee) const {
            auto flags = std::regex::ECMAScript; // ECMAScript is the default syntax option anyway
            if (m_caseSensitivity == CaseSensitive::Choice::No) {
                flags |= std::regex::icase;
            }
            auto reg = std::regex(m_regex, flags);
            return std::regex_match(matchee, reg);
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
xorl %edx, %edx
cmpl $0x1, 0x50(%rdi)
movq %rsi, %rbx
sete %dl
orl $0x10, %edx
leaq 0x30(%rdi), %rsi
leaq -0x50(%rbp), %r14
movq %r14, %rdi
callq 0x3f624
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
addq %rdi, %rsi
xorps %xmm0, %xmm0
leaq -0x30(%rbp), %rdx
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, (%rdx)
movq %r14, %rcx
xorl %r8d, %r8d
callq 0x58c4f
movl %eax, %ebx
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x27f43
callq 0x1b4d0
leaq -0x50(%rbp), %rdi
callq 0x3f68e
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x27f68
callq 0x1b4d0
leaq -0x50(%rbp), %rdi
callq 0x3f68e
movq %rbx, %rdi
callq 0x1b910
nop
// File: /workspace/github_cpp_makefile_star2_O1/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::Capturer::~Capturer()
Capturer::~Capturer() {
        if ( !uncaught_exceptions() ){
            assert( m_captured == m_messages.size() );
            for( size_t i = 0; i < m_captured; ++i  )
                m_resultCapture.popScopedMessage( m_messages[i] );
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1b070
testb %al, %al
jne 0x289a7
movq 0x8(%rbx), %rax
subq (%rbx), %rax
sarq $0x3, %rax
movabsq $-0x71c71c71c71c71c7, %rcx # imm = 0x8E38E38E38E38E39
imulq %rax, %rcx
cmpq %rcx, 0x20(%rbx)
jne 0x289b9
cmpq $0x0, 0x20(%rbx)
je 0x289a7
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x18(%rbx), %rdi
movq (%rbx), %rsi
addq %r14, %rsi
movq (%rdi), %rax
callq *0x38(%rax)
incq %r15
addq $0x48, %r14
cmpq 0x20(%rbx), %r15
jb 0x2898a
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3f03c
leaq 0x539b7(%rip), %rdi     # 0x7c377
leaq 0x5350e(%rip), %rsi     # 0x7bed5
leaq 0x539c9(%rip), %rcx     # 0x7c397
movl $0x2e95, %edx           # imm = 0x2E95
callq 0x1b320
movq %rax, %rdi
callq 0x3ec84
// File: /workspace/github_cpp_makefile_star2_O1/xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::Capturer::captureValue(unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Capturer::captureValue( size_t index, std::string const& value ) {
        assert( index < m_messages.size() );
        m_messages[index].message += value;
        m_resultCapture.pushScopedMessage( m_messages[index] );
        m_captured++;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movabsq $-0x71c71c71c71c71c7, %rdi # imm = 0x8E38E38E38E38E39
imulq %rcx, %rdi
cmpq %rsi, %rdi
jbe 0x28a40
shlq $0x3, %rsi
leaq (%rsi,%rsi,8), %r14
leaq (%rax,%r14), %rdi
addq $0x10, %rdi
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
callq 0x1b150
movq 0x18(%rbx), %rdi
addq (%rbx), %r14
movq (%rdi), %rax
movq %r14, %rsi
callq *0x30(%rax)
incq 0x20(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x5396d(%rip), %rdi     # 0x7c3b4
leaq 0x53487(%rip), %rsi     # 0x7bed5
leaq 0x53979(%rip), %rcx     # 0x7c3ce
movl $0x2e9c, %edx           # imm = 0x2E9C
callq 0x1b320
nop