LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, (%rax)
movb $0x0, 0x8(%rax)
movq 0xe0(%rax), %rsi
movq -0x10(%rbp), %rdx
movq (%rsi), %rax
leaq -0x30(%rbp), %rdi
callq *0x18(%rax)
movq -0x38(%rbp), %rdi
addq $0x20, %rdi
leaq -0x30(%rbp), %rsi
callq 0x528a0
leaq -0x30(%rbp), %rdi
callq 0x52e58
movq -0x38(%rbp), %rdi
addq $0x80, %rdi
callq 0x92e80
movq -0x38(%rbp), %rdi
movq %rdi, %rax
addq $0x40, %rax
movq %rax, -0x48(%rbp)
addq $0x20, %rdi
callq 0x52500
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x52ae0
movq -0x38(%rbp), %rdi
movq %rdi, %rax
addq $0x60, %rax
movq %rax, -0x40(%rbp)
addq $0x20, %rdi
callq 0x52500
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x52ae0
movq -0x38(%rbp), %rax
movq $0x0, 0x18(%rax)
movq $0x0, 0x10(%rax)
movq -0x38(%rbp), %rdi
movq 0x10(%rdi), %rax
movq %rax, -0x50(%rbp)
addq $0x20, %rdi
callq 0x52500
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq %rcx, %rax
jae 0x5a750
movq -0x38(%rbp), %rax
movq %rax, %rdi
addq $0x20, %rdi
movq 0x10(%rax), %rsi
callq 0x52e00
movq -0x38(%rbp), %rdi
movsbl (%rax), %esi
callq 0x6bf50
testb $0x1, %al
jne 0x5a73c
movq -0x38(%rbp), %rdi
addq $0xb0, %rdi
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
callq 0x91260
jmp 0x5a750
jmp 0x5a73e
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
jmp 0x5a6dd
movq -0x38(%rbp), %rdi
callq 0x6c0a0
movq -0x38(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::makeStream(Catch::StringRef const&)
auto makeStream( StringRef const &filename ) -> IStream const* {
        if( filename.empty() )
            return new Detail::CoutStream();
        else if( filename[0] == '%' ) {
            if( filename == "%debug" )
                return new Detail::DebugOutStream();
            else
                CATCH_ERROR( "Unrecognised stream: '" << filename << "'" );
        }
        else
            return new Detail::FileStream( filename );
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8af30
testb $0x1, %al
jne 0x5ac9e
jmp 0x5ace9
movl $0x118, %edi            # imm = 0x118
callq 0x52720
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x88(%rbp)
callq 0x67a50
jmp 0x5acbc
movq -0x88(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5ae82
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x526b0
jmp 0x5ae8f
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x8eb80
movsbl %al, %eax
cmpl $0x25, %eax
jne 0x5ae2a
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x30(%rbp), %rdi
leaq 0xe4ab3(%rip), %rsi     # 0x13f7cb
callq 0x68380
movq -0x90(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x67ad0
testb $0x1, %al
jne 0x5ad33
jmp 0x5ad7e
movl $0x120, %edi            # imm = 0x120
callq 0x52720
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x98(%rbp)
callq 0x67b30
jmp 0x5ad51
movq -0x98(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5ae82
movq -0x98(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x526b0
jmp 0x5ae8f
leaq -0x68(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x67d90
movq -0xa8(%rbp), %rdi
leaq 0xe4a36(%rip), %rsi     # 0x13f7d2
callq 0x90b10
movq %rax, -0xa0(%rbp)
jmp 0x5adaa
movq -0xa0(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x90b40
movq %rax, -0xb0(%rbp)
jmp 0x5adc3
movq -0xb0(%rbp), %rdi
leaq 0xe4cc3(%rip), %rsi     # 0x13fa94
callq 0x90b70
movq %rax, -0xb8(%rbp)
jmp 0x5addf
movq -0xb8(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x53b70
jmp 0x5adf1
leaq -0x50(%rbp), %rdi
callq 0x53dd0
jmp 0x5adfc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x5ae1f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x52e58
leaq -0x68(%rbp), %rdi
callq 0x67e50
jmp 0x5ae8f
movl $0x208, %edi            # imm = 0x208
callq 0x52720
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0xc0(%rbp)
movq -0x10(%rbp), %rax
movups (%rax), %xmm0
movaps %xmm0, -0x80(%rbp)
movq -0x80(%rbp), %rsi
movq -0x78(%rbp), %rdx
callq 0x67c00
jmp 0x5ae5b
movq -0xc0(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5ae82
movq -0xc0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x526b0
jmp 0x5ae8f
movq -0x8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x52c90
nopl (%rax,%rax)
// File: 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
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
cmpb $0x0, 0x166d26(%rip)    # 0x1c1c08
jne 0x5af17
leaq 0x166d1d(%rip), %rdi    # 0x1c1c08
callq 0x52ce0
cmpl $0x0, %eax
je 0x5af17
callq 0x5aff0
movq %rax, -0x20(%rbp)
jmp 0x5af00
movq -0x20(%rbp), %rax
movq %rax, 0x166cf5(%rip)    # 0x1c1c00
leaq 0x166cf6(%rip), %rdi    # 0x1c1c08
callq 0x52490
cmpq $0x0, 0x166ce1(%rip)    # 0x1c1c00
je 0x5af4d
movq 0x166cd8(%rip), %rdi    # 0x1c1c00
movl -0x4(%rbp), %esi
movq (%rdi), %rax
callq *0x10(%rax)
jmp 0x5af4d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq 0x166cc2(%rip), %rdi    # 0x1c1c08
callq 0x52480
jmp 0x5af53
addq $0x20, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0x52c90
nopl (%rax)
// File: 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
subq $0x70, %rsp
leaq -0x4(%rbp), %rdi
callq 0x5c080
callq 0x8ae00
movq %rax, -0x30(%rbp)
jmp 0x5b00c
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
movq 0x20(%rax), %rax
callq *%rax
movq %rax, -0x38(%rbp)
jmp 0x5b01f
movq -0x38(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0x8cd20
leaq -0x18(%rbp), %rdi
callq 0xa1e10
testb $0x1, %al
jne 0x5b03b
jmp 0x5b060
leaq -0x18(%rbp), %rdi
callq 0x8ae10
movq %rax, %rdi
movq (%rdi), %rax
movq 0x90(%rax), %rax
callq *%rax
movl %eax, -0x3c(%rbp)
jmp 0x5b058
movl -0x3c(%rbp), %eax
movl %eax, -0x40(%rbp)
jmp 0x5b067
xorl %eax, %eax
movl %eax, -0x40(%rbp)
jmp 0x5b067
movl -0x40(%rbp), %eax
movl %eax, -0x28(%rbp)
cmpl $0x0, -0x28(%rbp)
jne 0x5b0ba
callq 0x7b3d0
movb %al, -0x41(%rbp)
jmp 0x5b07d
movb -0x41(%rbp), %dl
movl $0x2, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x28(%rbp)
jmp 0x5b0ba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x5b10e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x8c0e0
jmp 0x5b10e
cmpl $0x1, -0x28(%rbp)
jne 0x5b0d5
callq 0x7b3f0
movq %rax, -0x50(%rbp)
jmp 0x5b0cb
movq -0x50(%rbp), %rax
movq %rax, -0x58(%rbp)
jmp 0x5b0ea
callq 0x7b440
movq %rax, -0x60(%rbp)
jmp 0x5b0e0
movq -0x60(%rbp), %rax
movq %rax, -0x58(%rbp)
jmp 0x5b0ea
movq -0x58(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x8c0e0
leaq -0x4(%rbp), %rdi
callq 0x5c0b0
movq -0x68(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
leaq -0x4(%rbp), %rdi
callq 0x5c0b0
movq -0x20(%rbp), %rdi
callq 0x52c90
// File: 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
subq $0x270, %rsp            # imm = 0x270
leaq -0x8(%rbp), %rdi
callq 0x5c080
leaq 0xe3b97(%rip), %rsi     # 0x13ef72
leaq -0x210(%rbp), %rdi
movl $0x8, %edx
callq 0x52cf0
jmp 0x5b3ee
leaq -0x240(%rbp), %rdi
callq 0x52a00
leaq -0x210(%rbp), %rdi
leaq -0x240(%rbp), %rsi
callq 0x52150
movq %rax, -0x250(%rbp)
jmp 0x5b416
movq -0x250(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x528f0
movb %al, -0x251(%rbp)
jmp 0x5b434
movb -0x251(%rbp), %al
testb $0x1, %al
jne 0x5b495
jmp 0x5b440
movl $0x2, -0x244(%rbp)
jmp 0x5b52d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
jmp 0x5b577
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
leaq -0x240(%rbp), %rdi
callq 0x52e58
leaq -0x210(%rbp), %rdi
callq 0x521a0
jmp 0x5b577
leaq 0xe3ae8(%rip), %rcx     # 0x13ef84
xorl %eax, %eax
movl %eax, %esi
leaq -0x240(%rbp), %rdi
movl $0xb, %edx
callq 0x529a0
movl %eax, -0x258(%rbp)
jmp 0x5b4b9
movl -0x258(%rbp), %eax
cmpl $0x0, %eax
jne 0x5b528
leaq -0x240(%rbp), %rdi
callq 0x52a90
movq %rax, %rcx
xorl %eax, %eax
cmpq $0xb, %rcx
movb %al, -0x259(%rbp)
jbe 0x5b511
leaq -0x240(%rbp), %rdi
movl $0xb, %esi
callq 0x52e00
movq %rax, -0x268(%rbp)
jmp 0x5b4fb
movq -0x268(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
setne %al
movb %al, -0x259(%rbp)
movb -0x259(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movl $0x1, -0x244(%rbp)
jmp 0x5b52d
jmp 0x5b3fa
leaq -0x240(%rbp), %rdi
callq 0x52e58
movl -0x244(%rbp), %eax
subl $0x2, %eax
jne 0x5b554
jmp 0x5b546
movb $0x0, -0x1(%rbp)
movl $0x1, -0x244(%rbp)
leaq -0x210(%rbp), %rdi
callq 0x521a0
leaq -0x8(%rbp), %rdi
callq 0x5c0b0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x270, %rsp            # imm = 0x270
popq %rbp
retq
leaq -0x8(%rbp), %rdi
callq 0x5c0b0
movq -0x218(%rbp), %rdi
callq 0x52c90
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdx, -0x10(%rbp)
movq %rcx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x52500
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x52500
movq %rax, %rcx
movq -0x30(%rbp), %rax
addq %rcx, %rax
cmpq $0x28, %rax
jae 0x5b667
movq -0x20(%rbp), %rdi
movl $0xa, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x52950
cmpq $-0x1, %rax
jne 0x5b667
movq -0x28(%rbp), %rdi
movl $0xa, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x52950
cmpq $-0x1, %rax
jne 0x5b667
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x52670
movq %rax, %rdi
leaq 0xe41b3(%rip), %rsi     # 0x13f7ec
callq 0x52710
movq %rax, %rdi
leaq -0x10(%rbp), %rsi
callq 0x5b6b0
movq %rax, %rdi
leaq 0xe4198(%rip), %rsi     # 0x13f7ec
callq 0x52710
movq %rax, %rdi
movq -0x28(%rbp), %rsi
callq 0x52670
jmp 0x5b6aa
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x52670
movq %rax, %rdi
leaq 0xee147(%rip), %rsi     # 0x1497c5
callq 0x52710
movq %rax, %rdi
leaq -0x10(%rbp), %rsi
callq 0x5b6b0
movq %rax, %rdi
leaq 0xee12c(%rip), %rsi     # 0x1497c5
callq 0x52710
movq %rax, %rdi
movq -0x28(%rbp), %rsi
callq 0x52670
addq $0x30, %rsp
popq %rbp
retq
// File: 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
subq $0xf0, %rsp
movq %rdi, -0xb8(%rbp)
movq %rdi, %rax
movq %rax, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movups -0x18(%rbp), %xmm0
movaps %xmm0, -0x40(%rbp)
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
leaq -0x30(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
movl $0x2c, %ecx
callq 0x5b990
movq -0xb8(%rbp), %rdi
movb $0x0, -0x41(%rbp)
callq 0x8c1e0
movq -0xc0(%rbp), %rdi
callq 0x8c300
movq -0xb8(%rbp), %rdi
movq %rax, %rsi
callq 0x8c200
jmp 0x5b83a
leaq -0x30(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
callq 0x8c320
movq %rax, -0x68(%rbp)
movq -0x60(%rbp), %rdi
callq 0x8c350
movq %rax, -0x70(%rbp)
leaq -0x68(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x8c380
testb $0x1, %al
jne 0x5b872
jmp 0x5b950
leaq -0x68(%rbp), %rdi
callq 0x8c3c0
movq %rax, -0x78(%rbp)
movq -0x78(%rbp), %rax
movups (%rax), %xmm0
movaps %xmm0, -0xb0(%rbp)
movq -0xb0(%rbp), %rdi
movq -0xa8(%rbp), %rsi
callq 0x5bc10
movq %rdx, -0xd8(%rbp)
movq %rax, -0xd0(%rbp)
jmp 0x5b8b0
movq -0xd8(%rbp), %rax
movq -0xd0(%rbp), %rcx
movq %rcx, -0x98(%rbp)
movq %rax, -0x90(%rbp)
movq -0x98(%rbp), %rdi
movq -0x90(%rbp), %rsi
callq 0x5bb20
movq %rdx, -0xe8(%rbp)
movq %rax, -0xe0(%rbp)
jmp 0x5b8ef
movq -0xb8(%rbp), %rdi
movq -0xe8(%rbp), %rax
movq -0xe0(%rbp), %rcx
movq %rcx, -0x88(%rbp)
movq %rax, -0x80(%rbp)
leaq -0x88(%rbp), %rsi
callq 0x8c3e0
jmp 0x5b91d
jmp 0x5b91f
leaq -0x68(%rbp), %rdi
callq 0x8c410
jmp 0x5b85c
movq -0xb8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
callq 0x8c430
leaq -0x30(%rbp), %rdi
callq 0x8c430
jmp 0x5b97f
movb $0x1, -0x41(%rbp)
testb $0x1, -0x41(%rbp)
jne 0x5b966
movq -0xb8(%rbp), %rdi
callq 0x8c430
leaq -0x30(%rbp), %rdi
callq 0x8c430
movq -0xc8(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x52c90
nopl (%rax,%rax)
// File: 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
subq $0x90, %rsp
movq %rdi, -0x70(%rbp)
movb %cl, %al
movq %rdi, %rcx
movq %rcx, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movb %al, -0x19(%rbp)
movb $0x0, -0x1a(%rbp)
callq 0x8c1e0
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x8af50
movq %rax, %rcx
movq -0x78(%rbp), %rax
cmpq %rcx, %rax
jae 0x5ba7d
movq -0x30(%rbp), %rsi
leaq -0x18(%rbp), %rdi
callq 0x8eb80
movsbl %al, %eax
movsbl -0x19(%rbp), %ecx
cmpl %ecx, %eax
jne 0x5ba6a
movq -0x30(%rbp), %rax
subq -0x28(%rbp), %rax
cmpq $0x1, %rax
jbe 0x5ba5e
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
subq %rsi, %rdx
leaq -0x18(%rbp), %rdi
callq 0x68080
movq -0x70(%rbp), %rdi
movq %rax, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
leaq -0x40(%rbp), %rsi
callq 0x8c3e0
jmp 0x5ba42
jmp 0x5ba5e
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0x8c430
jmp 0x5bb0b
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x5ba6c
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x5b9d0
movq -0x28(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x8af50
movq %rax, %rcx
movq -0x80(%rbp), %rax
cmpq %rcx, %rax
jae 0x5baeb
movq -0x28(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x18(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x8af50
movq -0x90(%rbp), %rdi
movq -0x88(%rbp), %rsi
movq %rax, %rdx
movq -0x28(%rbp), %rax
subq %rax, %rdx
callq 0x68080
movq -0x70(%rbp), %rdi
movq %rax, -0x60(%rbp)
movq %rdx, -0x58(%rbp)
leaq -0x60(%rbp), %rsi
callq 0x8c3e0
jmp 0x5bae9
jmp 0x5baeb
movb $0x1, -0x1a(%rbp)
testb $0x1, -0x1a(%rbp)
jne 0x5bafe
movq -0x70(%rbp), %rdi
callq 0x8c430
movq -0x68(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x52c90
nopw %cs:(%rax,%rax)
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::trim(Catch::StringRef)
StringRef trim(StringRef ref) {
        const auto is_ws = [](char c) {
            return c == ' ' || c == '\t' || c == '\n' || c == '\r';
        };
        size_t real_begin = 0;
        while (real_begin < ref.size() && is_ws(ref[real_begin])) { ++real_begin; }
        size_t real_end = ref.size();
        while (real_end > real_begin && is_ws(ref[real_end - 1])) { --real_end; }

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x8af50
movq -0x48(%rbp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x39(%rbp)
jae 0x5bb76
movq -0x30(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x8eb80
leaq -0x21(%rbp), %rdi
movsbl %al, %esi
callq 0x68030
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x5bb7f
jmp 0x5bb8d
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x5bb38
leaq -0x20(%rbp), %rdi
callq 0x8af50
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rcx
xorl %eax, %eax
cmpq -0x30(%rbp), %rcx
movb %al, -0x49(%rbp)
jbe 0x5bbc9
movq -0x38(%rbp), %rsi
subq $0x1, %rsi
leaq -0x20(%rbp), %rdi
callq 0x8eb80
leaq -0x21(%rbp), %rdi
movsbl %al, %esi
callq 0x68030
movb %al, -0x49(%rbp)
movb -0x49(%rbp), %al
testb $0x1, %al
jne 0x5bbd2
jmp 0x5bbe0
movq -0x38(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x5bb9a
movq -0x30(%rbp), %rsi
movq -0x38(%rbp), %rdx
subq %rsi, %rdx
leaq -0x20(%rbp), %rdi
callq 0x68080
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::Detail::(anonymous namespace)::extractInstanceName(Catch::StringRef)
StringRef extractInstanceName(StringRef enumInstance) {
                // Find last occurrence of ":"
                size_t name_start = enumInstance.size();
                while (name_start > 0 && enumInstance[name_start - 1] != ':') {
                    --name_start;
                }
                return enumInstance.substr(name_start, enumInstance.size() - name_start);
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x8af50
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x28(%rbp)
movb %al, -0x29(%rbp)
jbe 0x5bc56
movq -0x28(%rbp), %rsi
subq $0x1, %rsi
leaq -0x20(%rbp), %rdi
callq 0x8eb80
movsbl %al, %eax
cmpl $0x3a, %eax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x5bc5f
jmp 0x5bc6d
movq -0x28(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x5bc2d
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x8af50
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq %rax, %rdx
movq -0x28(%rbp), %rax
subq %rax, %rdx
callq 0x68080
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x40, %rsp
popq %rbp
retq
nop
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::Detail::EnumInfo::lookup(int) const
StringRef EnumInfo::lookup( int value ) const {
            for( auto const& valueToName : m_values ) {
                if( valueToName.first == value )
                    return valueToName.second;
            }
            return "{** unexpected enum value **}"_sr;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movq -0x18(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x8c4f0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x8c520
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x8c550
testb $0x1, %al
jne 0x5bd18
jmp 0x5bd53
leaq -0x30(%rbp), %rdi
callq 0x8c590
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movl (%rax), %eax
cmpl -0x1c(%rbp), %eax
jne 0x5bd46
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rcx
movq %rcx, -0x10(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x5bd6c
jmp 0x5bd48
leaq -0x30(%rbp), %rdi
callq 0x8c5b0
jmp 0x5bd05
leaq 0xe3236(%rip), %rdi     # 0x13ef90
movl $0x1d, %esi
callq 0x8c5d0
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0xd0, %rsp
movq %rdi, -0xa8(%rbp)
movq %rdi, %rax
movq %rax, -0xb8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x30(%rbp)
movb $0x0, -0x31(%rbp)
movl $0x28, %edi
callq 0x52720
movq %rax, %rdi
movq %rdi, -0xb0(%rbp)
callq 0x8c600
movq -0xb0(%rbp), %rsi
movq -0xa8(%rbp), %rdi
callq 0x8c630
movq -0xa8(%rbp), %rdi
callq 0x8c660
movq -0xa8(%rbp), %rdi
movups -0x18(%rbp), %xmm0
movups %xmm0, (%rax)
callq 0x8c660
addq $0x10, %rax
movq %rax, -0xa0(%rbp)
movq -0x30(%rbp), %rdi
callq 0x8c780
movq -0xa0(%rbp), %rdi
movq %rax, %rsi
callq 0x8c680
jmp 0x5be28
movups -0x28(%rbp), %xmm0
movaps %xmm0, -0x70(%rbp)
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rdx
leaq -0x60(%rbp), %rdi
callq 0x5b7c0
jmp 0x5be43
leaq -0x60(%rbp), %rdi
callq 0x8c300
movq %rax, -0xc0(%rbp)
movq -0x30(%rbp), %rdi
callq 0x8c780
movq %rax, %rcx
movq -0xc0(%rbp), %rax
cmpq %rcx, %rax
jne 0x5be6d
jmp 0x5be9d
leaq 0xe313a(%rip), %rdi     # 0x13efae
leaq 0xe3156(%rip), %rsi     # 0x13efd1
movl $0x2984, %edx           # imm = 0x2984
leaq 0xe317d(%rip), %rcx     # 0x13f004
callq 0x524b0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x5bf9c
movq $0x0, -0x78(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rdi
callq 0x8c7a0
movq %rax, -0x88(%rbp)
movq -0x80(%rbp), %rdi
callq 0x8c7d0
movq %rax, -0x90(%rbp)
leaq -0x88(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x8c800
testb $0x1, %al
jne 0x5bee9
jmp 0x5bf6d
leaq -0x88(%rbp), %rdi
callq 0x8c840
movq -0xa8(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0x94(%rbp)
callq 0x8c660
addq $0x10, %rax
movq %rax, -0xc8(%rbp)
movq -0x78(%rbp), %rsi
movq %rsi, %rax
incq %rax
movq %rax, -0x78(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x8c8e0
movq -0xc8(%rbp), %rdi
movq %rax, %rdx
leaq -0x94(%rbp), %rsi
callq 0x8c860
jmp 0x5bf43
jmp 0x5bf45
leaq -0x88(%rbp), %rdi
callq 0x8c900
jmp 0x5becd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x8c430
jmp 0x5bf9c
movb $0x1, -0x31(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x8c430
testb $0x1, -0x31(%rbp)
jne 0x5bf8c
movq -0xa8(%rbp), %rdi
callq 0x8c920
movq -0xb8(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq -0xa8(%rbp), %rdi
callq 0x8c920
movq -0x40(%rbp), %rdi
callq 0x52c90
nopw %cs:(%rax,%rax)
// File: 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
subq $0x70, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x8, %rdi
callq 0x8cbc0
testb $0x1, %al
jne 0x5c522
jmp 0x5c551
leaq -0x18(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x52800
movq -0x60(%rbp), %rdi
callq 0x52750
jmp 0x5c53a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x8cb90
jmp 0x5c5c2
movq -0x48(%rbp), %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x8cc00
movq %rax, %rdi
callq 0x8cc20
movq -0x48(%rbp), %rdi
movq %rax, -0x68(%rbp)
addq $0x8, %rdi
callq 0x8cc40
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rdi
movl $0x1, %esi
callq 0x8cc70
movq -0x48(%rbp), %rdi
movq %rax, -0x30(%rbp)
addq $0x8, %rdi
callq 0x8ccb0
movq -0x58(%rbp), %rdi
movq -0x68(%rbp), %rsi
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rdx
movq -0x40(%rbp), %rcx
movq (%rsi), %rax
callq *0x10(%rax)
movq -0x50(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x52c90
nopl (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movb $0x0, (%rax)
xorl %eax, %eax
cmpq $0x0, 0x16563b(%rip)    # 0x1c1c28
movb %al, -0x11(%rbp)
jne 0x5c5f9
movb $0x1, %al
movb %al, -0x11(%rbp)
jmp 0x5c5f9
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x5c602
jmp 0x5c604
jmp 0x5c623
leaq 0xe2add(%rip), %rdi     # 0x13f0e8
leaq 0xe29bf(%rip), %rsi     # 0x13efd1
movl $0x2aaa, %edx           # imm = 0x2AAA
leaq 0xe2b1b(%rip), %rcx     # 0x13f139
callq 0x524b0
cmpq $0x0, 0x165605(%rip)    # 0x1c1c30
jne 0x5c655
movl $0xfa, %edi
callq 0x524a0
movq %rax, -0x10(%rbp)
leaq -0x10(%rbp), %rdi
leaq 0xe0be2(%rip), %rsi     # 0x13d228
callq 0x8cce0
movq (%rax), %rax
movq %rax, 0x1655db(%rip)    # 0x1c1c30
movq 0x1655d4(%rip), %rdi    # 0x1c1c30
movq %rdi, -0x28(%rbp)
callq 0x52040
movq -0x28(%rbp), %rdx
movq %rax, %rdi
movq %rdi, -0x20(%rbp)
xorl %esi, %esi
callq 0x523d0
movq -0x20(%rbp), %rax
movq %rax, 0x1655a6(%rip)    # 0x1c1c28
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::FatalConditionHandler::~FatalConditionHandler()
FatalConditionHandler::~FatalConditionHandler() {
        delete[] altStackMem;
        // We signal that another instance can be constructed by zeroing
        // out the pointer.
        altStackMem = nullptr;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq 0x165585(%rip), %rax    # 0x1c1c28
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x5c6b6
movq -0x10(%rbp), %rdi
callq 0x52930
movq $0x0, 0x165567(%rip) # 0x1c1c28
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq 0x165542(%rip), %rax    # 0x1c1c28
movq %rax, -0x20(%rbp)
movq 0x16553f(%rip), %rax    # 0x1c1c30
movq %rax, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
leaq -0x20(%rbp), %rdi
leaq 0x165531(%rip), %rsi    # 0x1c1c38
callq 0x52d20
leaq -0xb8(%rbp), %rdi
xorl %esi, %esi
movl $0x98, %edx
callq 0x523d0
leaq 0x7a(%rip), %rax        # 0x5c7a0
movq %rax, -0xb8(%rbp)
movl $0x8000000, -0x30(%rbp) # imm = 0x8000000
movq $0x0, -0xc0(%rbp)
cmpq $0x6, -0xc0(%rbp)
jae 0x5c795
movq -0xc0(%rbp), %rcx
leaq 0x164fe9(%rip), %rax    # 0x1c1740
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %edi
leaq 0x1654e9(%rip), %rdx    # 0x1c1c50
imulq $0x98, -0xc0(%rbp), %rax
addq %rax, %rdx
leaq -0xb8(%rbp), %rsi
callq 0x528e0
movq -0xc0(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xc0(%rbp)
jmp 0x5c73f
addq $0xc0, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
leaq 0xe401b(%rip), %rax     # 0x1407cd
movq %rax, -0x10(%rbp)
leaq 0x164f83(%rip), %rax    # 0x1c1740
movq %rax, -0x18(%rbp)
leaq 0x164f78(%rip), %rax    # 0x1c1740
movq %rax, -0x20(%rbp)
leaq 0x164f6d(%rip), %rax    # 0x1c1740
addq $0x60, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
je 0x5c816
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x4(%rbp), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x5c806
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x5c816
jmp 0x5c808
movq -0x20(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
jmp 0x5c7db
callq 0x5c860
movq -0x10(%rbp), %rdi
callq 0x7b8d0
movl -0x4(%rbp), %edi
callq 0x52730
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
movq $0x0, -0x8(%rbp)
cmpq $0x6, -0x8(%rbp)
jae 0x5c8b4
movq -0x8(%rbp), %rcx
leaq 0x164ebe(%rip), %rax    # 0x1c1740
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %edi
leaq 0x1653be(%rip), %rsi    # 0x1c1c50
imulq $0x98, -0x8(%rbp), %rax
addq %rax, %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x528e0
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x5c870
leaq 0x16537d(%rip), %rdi    # 0x1c1c38
xorl %eax, %eax
movl %eax, %esi
callq 0x52d20
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x70, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movb $0x0, -0x21(%rbp)
callq 0x91ce0
movq -0x10(%rbp), %rdi
callq 0x8d5e0
movq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0x91d00
jmp 0x5db83
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x91b20
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
callq 0x91b50
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x91b80
testb $0x1, %al
jne 0x5dbbb
jmp 0x5dc5c
leaq -0x48(%rbp), %rdi
callq 0x91bc0
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6a2b0
movb %al, -0x69(%rbp)
jmp 0x5dbd6
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0x5dbee
jmp 0x5dbdf
movq -0x58(%rbp), %rdi
callq 0x5dcc0
testb $0x1, %al
jne 0x5dbee
jmp 0x5dc24
movq -0x18(%rbp), %rdi
callq 0x6a2b0
movb %al, -0x6a(%rbp)
jmp 0x5dbfc
movb -0x6a(%rbp), %al
testb $0x1, %al
jne 0x5dc05
jmp 0x5dc4c
movq -0x58(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x69fb0
movb %al, -0x6b(%rbp)
jmp 0x5dc1b
movb -0x6b(%rbp), %al
testb $0x1, %al
jne 0x5dc24
jmp 0x5dc4c
movq -0x60(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x92080
jmp 0x5dc33
jmp 0x5dc4c
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x8d630
jmp 0x5dc79
jmp 0x5dc4e
leaq -0x48(%rbp), %rdi
callq 0x91c60
jmp 0x5dba5
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x5dc6f
movq -0x60(%rbp), %rdi
callq 0x8d630
movq -0x68(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x52c90
nopw %cs:(%rax,%rax)
// File: 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
subq $0x90, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x52a00
movq -0x78(%rbp), %rdi
addq $0x60, %rdi
callq 0x916d0
movq %rax, %rcx
movq -0x78(%rbp), %rax
shlq %rcx
movq %rcx, -0x20(%rbp)
addq $0x60, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x8d7e0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x8d810
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x8d840
testb $0x1, %al
jne 0x5dd62
jmp 0x5dd8b
leaq -0x30(%rbp), %rdi
callq 0x8d880
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x52500
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x8da50
jmp 0x5dd4f
movq -0x88(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x52ae0
jmp 0x5dd9d
movq -0x78(%rbp), %rax
addq $0x60, %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
callq 0x8d7e0
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rdi
callq 0x8d810
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x8d840
testb $0x1, %al
jne 0x5ddd6
jmp 0x5de42
leaq -0x60(%rbp), %rdi
callq 0x8d880
movq -0x88(%rbp), %rdi
movq %rax, -0x70(%rbp)
movl $0x5b, %esi
callq 0x52630
jmp 0x5ddf6
movq -0x88(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x52dd0
jmp 0x5de08
movq -0x88(%rbp), %rdi
movl $0x5d, %esi
callq 0x52630
jmp 0x5de1b
jmp 0x5de1d
leaq -0x60(%rbp), %rdi
callq 0x8da50
jmp 0x5ddc3
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0x52e58
jmp 0x5de65
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x5de58
movq -0x88(%rbp), %rdi
callq 0x52e58
movq -0x80(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x52c90
nop
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
callq *0x68(%rax)
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5dc90
movq %rax, %rsi
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rcx
leaq -0x30(%rbp), %rdi
callq 0x5db40
leaq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x8d310
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x8d340
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x8d370
testb $0x1, %al
jne 0x5df4a
jmp 0x5e093
leaq -0x40(%rbp), %rdi
callq 0x8d3b0
movq %rax, -0x50(%rbp)
movq -0x18(%rbp), %rax
incq %rax
movq %rax, -0x18(%rbp)
movq -0x50(%rbp), %rdi
movl $0x23, %esi
callq 0x5e0c0
movb %al, -0x5d(%rbp)
jmp 0x5df75
movb -0x5d(%rbp), %al
testb $0x1, %al
jne 0x5df7e
jmp 0x5dfdc
callq 0x5b3b0
movq %rax, -0x68(%rbp)
jmp 0x5df89
movq -0x68(%rbp), %rdi
movl $0x22, %esi
callq 0x52870
movq %rax, -0x70(%rbp)
jmp 0x5df9d
movq -0x70(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x52670
movq %rax, -0x78(%rbp)
jmp 0x5dfb0
movq -0x78(%rbp), %rdi
movl $0x22, %esi
callq 0x52870
jmp 0x5dfc0
jmp 0x5dff8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x8d630
jmp 0x5e0b7
callq 0x5b3b0
movq %rax, -0x80(%rbp)
jmp 0x5dfe7
movq -0x80(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x52670
jmp 0x5dff6
jmp 0x5dff8
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
movq 0xa0(%rax), %rax
callq *%rax
movl %eax, -0x84(%rbp)
jmp 0x5e010
movl -0x84(%rbp), %eax
cmpl $0x2, %eax
jl 0x5e060
callq 0x5b3b0
movq %rax, -0x90(%rbp)
jmp 0x5e029
movq -0x90(%rbp), %rdi
leaq 0xe118d(%rip), %rsi     # 0x13f1c4
callq 0x52710
movq %rax, -0x98(%rbp)
jmp 0x5e045
movq -0x98(%rbp), %rdi
movq -0x50(%rbp), %rsi
addq $0x90, %rsi
callq 0x5a100
jmp 0x5e05e
jmp 0x5e060
callq 0x5b3b0
movq %rax, -0xa0(%rbp)
jmp 0x5e06e
movq -0xa0(%rbp), %rdi
movq 0x162ebc(%rip), %rsi    # 0x1c0f38
callq 0x527a0
jmp 0x5e083
jmp 0x5e085
leaq -0x40(%rbp), %rdi
callq 0x8d5c0
jmp 0x5df34
movq -0x18(%rbp), %rax
movq %rax, -0xa8(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x8d630
movq -0xa8(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x52c90
// File: 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
subq $0x90, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movq $0x0, -0x18(%rbp)
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x8d6e0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x8d710
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x8d740
testb $0x1, %al
jne 0x5e1b2
jmp 0x5e1df
leaq -0x28(%rbp), %rdi
callq 0x8d770
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x52500
addq $0x2, %rax
addq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x8d790
jmp 0x5e19f
movq -0x88(%rbp), %rdi
movb $0x0, -0x39(%rbp)
callq 0x52a00
movq -0x88(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x52ae0
jmp 0x5e201
movq -0x78(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
callq 0x8d6e0
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rdi
callq 0x8d710
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x8d740
testb $0x1, %al
jne 0x5e236
jmp 0x5e2a2
leaq -0x60(%rbp), %rdi
callq 0x8d770
movq -0x88(%rbp), %rdi
movq %rax, -0x70(%rbp)
movl $0x5b, %esi
callq 0x52470
jmp 0x5e256
movq -0x88(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x52910
jmp 0x5e268
movq -0x88(%rbp), %rdi
movl $0x5d, %esi
callq 0x52470
jmp 0x5e27b
jmp 0x5e27d
leaq -0x60(%rbp), %rdi
callq 0x8d790
jmp 0x5e223
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0x52e58
jmp 0x5e2c5
movb $0x1, -0x39(%rbp)
testb $0x1, -0x39(%rbp)
jne 0x5e2b8
movq -0x88(%rbp), %rdi
callq 0x52e58
movq -0x80(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x52c90
nop
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::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
subq $0x80, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x8e3c0
movq -0x70(%rbp), %rax
leaq 0x15d5cb(%rip), %rcx    # 0x1bcc00
addq $0x10, %rcx
movq %rcx, (%rax)
leaq 0x15d5bd(%rip), %rcx    # 0x1bcc00
addq $0x40, %rcx
movq %rcx, 0x28(%rax)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, 0x30(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x38(%rax)
movb -0x19(%rbp), %cl
movb %cl, 0x40(%rax)
movq -0x70(%rbp), %rax
cmpb $0x1, 0x40(%rax)
je 0x5f706
movq -0x70(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x78(%rbp)
callq 0x8e590
movl %eax, %ecx
movq -0x78(%rbp), %rax
movl %ecx, %ecx
cmpq %rcx, %rax
jb 0x5f706
leaq -0x58(%rbp), %rdi
callq 0x67d90
jmp 0x5f69a
leaq 0xdfbcc(%rip), %rsi     # 0x13f26d
leaq -0x58(%rbp), %rdi
callq 0x8e5a0
movq %rax, -0x80(%rbp)
jmp 0x5f6b0
movq -0x80(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x53b70
jmp 0x5f6bf
leaq -0x40(%rbp), %rdi
callq 0x53dd0
jmp 0x5f6ca
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x5f713
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x5f6fb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x52e58
leaq -0x58(%rbp), %rdi
callq 0x67e50
jmp 0x5f713
jmp 0x5f708
jmp 0x5f70a
addq $0x80, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0xa5f10
movq -0x60(%rbp), %rdi
callq 0x52c90
nopw %cs:(%rax,%rax)