LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::TestSpecParser::processNameChar(char)
void TestSpecParser::processNameChar( char c ) {
        if( c == '[' ) {
            if( m_substring == "exclude:" )
                m_exclusion = true;
            else
                endMode();
            startNewMode( Tag );
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movsbl -0x9(%rbp), %eax
cmpl $0x5b, %eax
jne 0x6c35e
movq -0x18(%rbp), %rdi
addq $0x40, %rdi
leaq 0xd3721(%rip), %rsi     # 0x13fa53
callq 0x925a0
testb $0x1, %al
jne 0x6c33d
jmp 0x6c347
movq -0x18(%rbp), %rax
movb $0x1, 0x8(%rax)
jmp 0x6c350
movq -0x18(%rbp), %rdi
callq 0x6c0a0
movq -0x18(%rbp), %rdi
movl $0x3, %esi
callq 0x6c470
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::TestSpecParser::processOtherChar(char)
bool TestSpecParser::processOtherChar( char c ) {
        if( !isControlChar( c ) )
            return false;
        m_substring += c;
        endMode();
        return true;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movsbl -0x11(%rbp), %esi
callq 0x6c3d0
testb $0x1, %al
jne 0x6c39d
movb $0x0, -0x1(%rbp)
jmp 0x6c3bd
movq -0x20(%rbp), %rdi
movb -0x11(%rbp), %al
addq $0x40, %rdi
movsbl %al, %esi
callq 0x52470
movq -0x20(%rbp), %rdi
callq 0x6c0a0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::TestSpecParser::isControlChar(char) const
bool TestSpecParser::isControlChar( char c ) const {
        switch( m_mode ) {
            default:
                return false;
            case None:
                return c == '~';
            case Name:
                return c == '[';
            case EscapedName:
                return true;
            case QuotedName:
                return c == '"';
            case Tag:
                return c == '[' || c == ']';
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movq %rax, -0x20(%rbp)
subq $0x4, %rax
ja 0x6c402
movq -0x20(%rbp), %rax
leaq 0xd0cef(%rip), %rcx     # 0x13d0e8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x0, -0x1(%rbp)
jmp 0x6c464
movsbl -0x11(%rbp), %eax
cmpl $0x7e, %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x6c464
movsbl -0x11(%rbp), %eax
cmpl $0x5b, %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x6c464
movb $0x1, -0x1(%rbp)
jmp 0x6c464
movsbl -0x11(%rbp), %eax
cmpl $0x22, %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x6c464
movsbl -0x11(%rbp), %ecx
movb $0x1, %al
cmpl $0x5b, %ecx
movb %al, -0x21(%rbp)
je 0x6c45c
movsbl -0x11(%rbp), %eax
cmpl $0x5d, %eax
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::TestSpecParser::addNamePattern()
void TestSpecParser::addNamePattern() {
        auto token = preprocessPattern();

        if (!token.empty()) {
            TestSpec::PatternPtr pattern = std::make_shared<TestSpec::NamePattern>(token, m_substring);
            if (m_exclusion)
                pattern = std::make_shared<TestSpec::ExcludedPattern>(pattern);
            m_currentFilter.m_patterns.push_back(pattern);
        }
        m_substring.clear();
        m_exclusion = false;
        m_mode = None;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x70(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x6c850
leaq -0x28(%rbp), %rdi
callq 0x52bb0
testb $0x1, %al
jne 0x6c560
movq -0x70(%rbp), %rdx
addq $0x40, %rdx
leaq -0x48(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x93110
jmp 0x6c4d5
leaq -0x38(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x93190
leaq -0x48(%rbp), %rdi
callq 0x931c0
movq -0x70(%rbp), %rax
testb $0x1, 0x8(%rax)
je 0x6c541
leaq -0x68(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x931e0
jmp 0x6c504
leaq -0x38(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x93250
leaq -0x68(%rbp), %rdi
callq 0x93280
jmp 0x6c541
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x6c58a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x93310
jmp 0x6c58a
movq -0x70(%rbp), %rdi
addq $0x98, %rdi
leaq -0x38(%rbp), %rsi
callq 0x932a0
jmp 0x6c557
leaq -0x38(%rbp), %rdi
callq 0x93310
movq -0x70(%rbp), %rdi
addq $0x40, %rdi
callq 0x52960
movq -0x70(%rbp), %rax
movb $0x0, 0x8(%rax)
movl $0x0, (%rax)
leaq -0x28(%rbp), %rdi
callq 0x52e58
addq $0x70, %rsp
popq %rbp
retq
leaq -0x28(%rbp), %rdi
callq 0x52e58
movq -0x50(%rbp), %rdi
callq 0x52c90
nopl (%rax)
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::(anonymous namespace)::estimateClockResolution()
auto estimateClockResolution() -> uint64_t {
            uint64_t sum = 0;
            static const uint64_t iterations = 1000000;

            auto startTime = getCurrentNanosecondsSinceEpoch();

            for( std::size_t i = 0; i < iterations; ++i ) {

                uint64_t ticks;
                uint64_t baseTicks = getCurrentNanosecondsSinceEpoch();
                do {
                    ticks = getCurrentNanosecondsSinceEpoch();
                } while( ticks == baseTicks );

                auto delta = ticks - baseTicks;
                sum += delta;

                // If we have been calibrating for over 3 seconds -- the clock
                // is terrible and we should move on.
                // TBD: How to signal that the measured resolution is probably wrong?
                if (ticks > startTime + 3 * nanosecondsInSecond) {
                    return sum / ( i + 1u );
                }
            }

            // We're just taking the mean, here. To do better we could take the std. dev and exclude outliers
            // - and potentially do more iterations if there's a high variance.
            return sum/iterations;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq $0x0, -0x10(%rbp)
callq 0x6cbf0
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0xf4240, -0x20(%rbp)   # imm = 0xF4240
jae 0x6cd4d
callq 0x6cbf0
movq %rax, -0x30(%rbp)
callq 0x6cbf0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
je 0x6cce4
movq -0x28(%rbp), %rax
subq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rax
movabsq $0xb2d05e00, %rcx       # imm = 0xB2D05E00
addq -0x18(%rbp), %rcx
cmpq %rcx, %rax
jbe 0x6cd3d
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
addq $0x1, %rcx
xorl %edx, %edx
divq %rcx
movq %rax, -0x8(%rbp)
jmp 0x6cd5f
jmp 0x6cd3f
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x6ccd1
movq -0x10(%rbp), %rax
movl $0xf4240, %ecx          # imm = 0xF4240
xorl %edx, %edx
divq %rcx
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::Detail::rawMemoryToString[abi:cxx11](void const*, unsigned long)
std::string rawMemoryToString( const void *object, std::size_t size ) {
        // Reverse order for little endian architectures
        int i = 0, end = static_cast<int>( size ), inc = 1;
        if( Endianness::which() == Endianness::Little ) {
            i = end-1;
            end = inc = -1;
        }

        unsigned char const *bytes = static_cast<unsigned char const *>(object);
        ReusableStringStream rss;
        rss << "0x" << std::setfill('0') << std::hex;
        for( ; i != end; i += inc )
             rss << std::setw(2) << static_cast<unsigned>(bytes[i]);
       return rss.str();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl %eax, -0x20(%rbp)
movl $0x1, -0x24(%rbp)
callq 0x6cf80
cmpl $0x1, %eax
jne 0x6ce58
movl -0x20(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
movl $0xffffffff, -0x20(%rbp) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x67d90
movq -0x80(%rbp), %rdi
leaq 0xd2bf8(%rip), %rsi     # 0x13fa70
callq 0x8ab90
movq %rax, -0x78(%rbp)
jmp 0x6ce83
movl $0x30, %edi
callq 0x93570
movb %al, -0x81(%rbp)
jmp 0x6ce95
movq -0x78(%rbp), %rdi
movb -0x81(%rbp), %al
movb %al, -0x55(%rbp)
leaq -0x55(%rbp), %rsi
callq 0x93530
movq %rax, -0x90(%rbp)
jmp 0x6ceb4
movq -0x90(%rbp), %rdi
leaq 0x266fe(%rip), %rsi     # 0x935c0
callq 0x93590
jmp 0x6cec9
jmp 0x6cecb
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
je 0x6cf49
movl $0x2, %edi
callq 0x8db30
movl %eax, -0x94(%rbp)
jmp 0x6cee5
movl -0x94(%rbp), %eax
movl %eax, -0x5c(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x5c(%rbp), %rsi
callq 0x8daf0
movq %rax, -0xa0(%rbp)
jmp 0x6cf04
movq -0xa0(%rbp), %rdi
movq -0x30(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, -0x60(%rbp)
leaq -0x60(%rbp), %rsi
callq 0x935f0
jmp 0x6cf25
jmp 0x6cf27
movl -0x24(%rbp), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x6cecb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x67e50
jmp 0x6cf6e
movq -0x70(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x53b70
jmp 0x6cf58
leaq -0x48(%rbp), %rdi
callq 0x67e50
movq -0x68(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x52c90
nopw (%rax,%rax)
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::Detail::(anonymous namespace)::Endianness::which()
static Arch which() {
                int one = 1;
                // If the lowest byte we read is non-zero, we can assume
                // that little endian format is used.
                auto value = *reinterpret_cast<char*>(&one);
                return value ? Little : Big;
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x1, -0x4(%rbp)
movb -0x4(%rbp), %al
movb %al, -0x5(%rbp)
movb -0x5(%rbp), %dl
xorl %eax, %eax
movl $0x1, %ecx
cmpb $0x0, %dl
cmovnel %ecx, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::StringMaker<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, void>::convert(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string StringMaker<std::string>::convert(const std::string& str) {
    if (!getCurrentContext().getConfig()->showInvisibles()) {
        return '"' + str + '"';
    }

    std::string s("\"");
    for (char c : str) {
        switch (c) {
        case '\n':
            s.append("\\n");
            break;
        case '\t':
            s.append("\\t");
            break;
        default:
            s.push_back(c);
            break;
        }
    }
    s.append("\"");
    return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x8ae00
movq %rax, %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq %rax, %rdi
callq 0x8ae10
movq %rax, %rdi
movq (%rdi), %rax
callq *0x50(%rax)
testb $0x1, %al
jne 0x6d044
movq -0x10(%rbp), %rdx
leaq -0x30(%rbp), %rdi
movq %rdi, -0x80(%rbp)
movl $0x22, %esi
movl %esi, -0x74(%rbp)
callq 0x93630
movq -0x70(%rbp), %rdi
movq -0x80(%rbp), %rsi
movl -0x74(%rbp), %edx
callq 0x8e740
jmp 0x6d01c
leaq -0x30(%rbp), %rdi
callq 0x52e58
jmp 0x6d17f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x52e58
jmp 0x6d18c
movb $0x0, -0x3d(%rbp)
leaq -0x3e(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x52ca0
movq -0x70(%rbp), %rdi
movq -0x88(%rbp), %rdx
leaq 0xd284c(%rip), %rsi     # 0x13f8b6
callq 0x529e0
jmp 0x6d071
leaq -0x3e(%rbp), %rdi
callq 0x527d0
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x526d0
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rdi
callq 0x52d30
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x93730
testb $0x1, %al
jne 0x6d0b2
jmp 0x6d158
leaq -0x50(%rbp), %rdi
callq 0x93770
movb (%rax), %al
movb %al, -0x59(%rbp)
movsbl -0x59(%rbp), %eax
movl %eax, -0x8c(%rbp)
subl $0x9, %eax
je 0x6d123
jmp 0x6d0d1
movl -0x8c(%rbp), %eax
subl $0xa, %eax
je 0x6d0f8
jmp 0x6d137
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x3e(%rbp), %rdi
callq 0x527d0
jmp 0x6d18c
movq -0x70(%rbp), %rdi
leaq 0xd8b53(%rip), %rsi     # 0x145c56
callq 0x52d80
jmp 0x6d10a
jmp 0x6d148
movq -0x70(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x52e58
jmp 0x6d18c
movq -0x70(%rbp), %rdi
leaq 0xd8ada(%rip), %rsi     # 0x145c08
callq 0x52d80
jmp 0x6d135
jmp 0x6d148
movq -0x70(%rbp), %rdi
movsbl -0x59(%rbp), %esi
callq 0x52630
jmp 0x6d146
jmp 0x6d148
jmp 0x6d14a
leaq -0x50(%rbp), %rdi
callq 0x93790
jmp 0x6d09c
movq -0x70(%rbp), %rdi
leaq 0xd2753(%rip), %rsi     # 0x13f8b6
callq 0x52d80
jmp 0x6d16a
movb $0x1, -0x3d(%rbp)
testb $0x1, -0x3d(%rbp)
jne 0x6d17d
movq -0x70(%rbp), %rdi
callq 0x52e58
jmp 0x6d17f
movq -0x68(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x52c90
nopw %cs:(%rax,%rax)
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::StringMaker<char const*, void>::convert[abi:cxx11](char const*)
std::string StringMaker<char const*>::convert(char const* str) {
    if (str) {
        return ::Catch::Detail::stringify(std::string{ str });
    } else {
        return{ "{null string}" };
    }
}

// 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)
cmpq $0x0, -0x10(%rbp)
je 0x6d23b
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x52ca0
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x529e0
jmp 0x6d1ea
movq -0x58(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x8ea30
jmp 0x6d1f9
leaq -0x30(%rbp), %rdi
callq 0x52e58
leaq -0x31(%rbp), %rdi
callq 0x527d0
jmp 0x6d280
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x6d230
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x52e58
leaq -0x31(%rbp), %rdi
callq 0x527d0
jmp 0x6d28a
leaq -0x45(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x52ca0
movq -0x58(%rbp), %rdi
movq -0x70(%rbp), %rdx
leaq 0xd2809(%rip), %rsi     # 0x13fa60
callq 0x529e0
jmp 0x6d25e
leaq -0x45(%rbp), %rdi
callq 0x527d0
jmp 0x6d280
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x45(%rbp), %rdi
callq 0x527d0
jmp 0x6d28a
movq -0x50(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
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::StringMaker<char*, void>::convert[abi:cxx11](char*)
std::string StringMaker<char*>::convert(char* str) {
    if (str) {
        return ::Catch::Detail::stringify(std::string{ str });
    } else {
        return{ "{null string}" };
    }
}

// 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)
cmpq $0x0, -0x10(%rbp)
je 0x6d33b
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x52ca0
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x529e0
jmp 0x6d2ea
movq -0x58(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x8ea30
jmp 0x6d2f9
leaq -0x30(%rbp), %rdi
callq 0x52e58
leaq -0x31(%rbp), %rdi
callq 0x527d0
jmp 0x6d380
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x6d330
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x52e58
leaq -0x31(%rbp), %rdi
callq 0x527d0
jmp 0x6d38a
leaq -0x45(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x52ca0
movq -0x58(%rbp), %rdi
movq -0x70(%rbp), %rdx
leaq 0xd2709(%rip), %rsi     # 0x13fa60
callq 0x529e0
jmp 0x6d35e
leaq -0x45(%rbp), %rdi
callq 0x527d0
jmp 0x6d380
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x45(%rbp), %rdi
callq 0x527d0
jmp 0x6d38a
movq -0x50(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
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::StringMaker<std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>>, void>::convert(std::__cxx11::basic_string<wchar_t, std::char_traits<wchar_t>, std::allocator<wchar_t>> const&)
std::string StringMaker<std::wstring>::convert(const std::wstring& wstr) {
    std::string s;
    s.reserve(wstr.size());
    for (auto c : wstr) {
        s += (c <= 0xff) ? static_cast<char>(c) : '?';
    }
    return ::Catch::Detail::stringify(s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x52a00
movq -0x10(%rbp), %rdi
callq 0x52560
movq -0x68(%rbp), %rdi
movq %rax, %rsi
callq 0x52ae0
jmp 0x6d3e2
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x52880
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rdi
callq 0x52230
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x937b0
testb $0x1, %al
jne 0x6d417
jmp 0x6d472
leaq -0x50(%rbp), %rdi
callq 0x937f0
movl (%rax), %eax
movl %eax, -0x5c(%rbp)
cmpl $0xff, -0x5c(%rbp)
jg 0x6d436
movl -0x5c(%rbp), %eax
movb %al, -0x79(%rbp)
jmp 0x6d43d
movb $0x3f, %al
movb %al, -0x79(%rbp)
jmp 0x6d43d
movb -0x79(%rbp), %al
movsbl %al, %esi
leaq -0x30(%rbp), %rdi
callq 0x52470
jmp 0x6d44e
jmp 0x6d450
leaq -0x50(%rbp), %rdi
callq 0x93810
jmp 0x6d404
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x52e58
jmp 0x6d497
movq -0x78(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x8ea30
jmp 0x6d481
leaq -0x30(%rbp), %rdi
callq 0x52e58
movq -0x70(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x52c90
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::StringMaker<wchar_t const*, void>::convert[abi:cxx11](wchar_t const*)
std::string StringMaker<wchar_t const*>::convert(wchar_t const * str) {
    if (str) {
        return ::Catch::Detail::stringify(std::wstring{ str });
    } else {
        return{ "{null string}" };
    }
}

// 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)
cmpq $0x0, -0x10(%rbp)
je 0x6d53b
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x52370
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x522a0
jmp 0x6d4ea
movq -0x58(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x93830
jmp 0x6d4f9
leaq -0x30(%rbp), %rdi
callq 0x52b90
leaq -0x31(%rbp), %rdi
callq 0x52cb0
jmp 0x6d580
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x6d530
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x52b90
leaq -0x31(%rbp), %rdi
callq 0x52cb0
jmp 0x6d58a
leaq -0x45(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x52ca0
movq -0x58(%rbp), %rdi
movq -0x70(%rbp), %rdx
leaq 0xd2509(%rip), %rsi     # 0x13fa60
callq 0x529e0
jmp 0x6d55e
leaq -0x45(%rbp), %rdi
callq 0x527d0
jmp 0x6d580
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x45(%rbp), %rdi
callq 0x527d0
jmp 0x6d58a
movq -0x50(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
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::StringMaker<wchar_t*, void>::convert[abi:cxx11](wchar_t*)
std::string StringMaker<wchar_t *>::convert(wchar_t * str) {
    if (str) {
        return ::Catch::Detail::stringify(std::wstring{ str });
    } else {
        return{ "{null string}" };
    }
}

// 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)
cmpq $0x0, -0x10(%rbp)
je 0x6d63b
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x52370
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x522a0
jmp 0x6d5ea
movq -0x58(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x93830
jmp 0x6d5f9
leaq -0x30(%rbp), %rdi
callq 0x52b90
leaq -0x31(%rbp), %rdi
callq 0x52cb0
jmp 0x6d680
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x6d630
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x52b90
leaq -0x31(%rbp), %rdi
callq 0x52cb0
jmp 0x6d68a
leaq -0x45(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x52ca0
movq -0x58(%rbp), %rdi
movq -0x70(%rbp), %rdx
leaq 0xd2409(%rip), %rsi     # 0x13fa60
callq 0x529e0
jmp 0x6d65e
leaq -0x45(%rbp), %rdi
callq 0x527d0
jmp 0x6d680
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x45(%rbp), %rdi
callq 0x527d0
jmp 0x6d68a
movq -0x50(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
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::StringMaker<long long, void>::convert[abi:cxx11](long long)
std::string StringMaker<long long>::convert(long long value) {
    ReusableStringStream rss;
    rss << value;
    if (value > Detail::hexThreshold) {
        rss << " (0x" << std::hex << value << ')';
    }
    return rss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x67d90
movq -0x40(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x93890
jmp 0x6d757
cmpq $0xff, -0x10(%rbp)
jle 0x6d7cc
leaq 0xd2306(%rip), %rsi     # 0x13fa6e
leaq -0x28(%rbp), %rdi
callq 0x8e6a0
movq %rax, -0x58(%rbp)
jmp 0x6d777
movq -0x58(%rbp), %rdi
leaq 0x25e3e(%rip), %rsi     # 0x935c0
callq 0x93590
movq %rax, -0x60(%rbp)
jmp 0x6d78d
movq -0x60(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x93890
movq %rax, -0x68(%rbp)
jmp 0x6d7a0
movq -0x68(%rbp), %rdi
movb $0x29, -0x35(%rbp)
leaq -0x35(%rbp), %rsi
callq 0x8ac70
jmp 0x6d7b3
jmp 0x6d7cc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x67e50
jmp 0x6d7ee
movq -0x50(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x53b70
jmp 0x6d7db
leaq -0x28(%rbp), %rdi
callq 0x67e50
movq -0x48(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x52c90
nopw (%rax,%rax)
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::StringMaker<unsigned long long, void>::convert[abi:cxx11](unsigned long long)
std::string StringMaker<unsigned long long>::convert(unsigned long long value) {
    ReusableStringStream rss;
    rss << value;
    if (value > Detail::hexThreshold) {
        rss << " (0x" << std::hex << value << ')';
    }
    return rss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x28(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x67d90
movq -0x40(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x93900
jmp 0x6d8a7
cmpq $0xff, -0x10(%rbp)
jbe 0x6d91c
leaq 0xd21b6(%rip), %rsi     # 0x13fa6e
leaq -0x28(%rbp), %rdi
callq 0x8e6a0
movq %rax, -0x58(%rbp)
jmp 0x6d8c7
movq -0x58(%rbp), %rdi
leaq 0x25cee(%rip), %rsi     # 0x935c0
callq 0x93590
movq %rax, -0x60(%rbp)
jmp 0x6d8dd
movq -0x60(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x93900
movq %rax, -0x68(%rbp)
jmp 0x6d8f0
movq -0x68(%rbp), %rdi
movb $0x29, -0x35(%rbp)
leaq -0x35(%rbp), %rsi
callq 0x8ac70
jmp 0x6d903
jmp 0x6d91c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x67e50
jmp 0x6d93e
movq -0x50(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x53b70
jmp 0x6d92b
leaq -0x28(%rbp), %rdi
callq 0x67e50
movq -0x48(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x52c90
nopw (%rax,%rax)
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::WildcardPattern::WildcardPattern(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::CaseSensitive::Choice)
WildcardPattern::WildcardPattern( std::string const& pattern,
                                      CaseSensitive::Choice caseSensitivity )
    :   m_caseSensitivity( caseSensitivity ),
        m_pattern( normaliseString( pattern ) )
    {
        if( startsWith( m_pattern, '*' ) ) {
            m_pattern = m_pattern.substr( 1 );
            m_wildcard = WildcardAtStart;
        }
        if( endsWith( m_pattern, '*' ) ) {
            m_pattern = m_pattern.substr( 0, m_pattern.size()-1 );
            m_wildcard = static_cast<WildcardPosition>( m_wildcard | WildcardAtEnd );
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x70(%rbp)
leaq 0x14f17b(%rip), %rax    # 0x1bd360
addq $0x10, %rax
movq %rax, (%rsi)
movl -0x14(%rbp), %eax
movl %eax, 0x8(%rsi)
movl $0x0, 0xc(%rsi)
movq %rsi, %rdi
addq $0x10, %rdi
movq %rdi, -0x78(%rbp)
movq -0x10(%rbp), %rdx
callq 0x6e300
movq -0x70(%rbp), %rdi
addq $0x10, %rdi
movl $0x2a, %esi
callq 0x5e0c0
testb $0x1, %al
jne 0x6e225
jmp 0x6e282
movq -0x70(%rbp), %rsi
addq $0x10, %rsi
leaq -0x38(%rbp), %rdi
movl $0x1, %edx
movq $-0x1, %rcx
callq 0x52780
jmp 0x6e244
movq -0x70(%rbp), %rdi
addq $0x10, %rdi
leaq -0x38(%rbp), %rsi
callq 0x528a0
leaq -0x38(%rbp), %rdi
callq 0x52e58
movq -0x70(%rbp), %rax
movl $0x1, 0xc(%rax)
jmp 0x6e282
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x52e58
jmp 0x6e2f4
movq -0x70(%rbp), %rdi
addq $0x10, %rdi
movl $0x2a, %esi
callq 0x67f40
testb $0x1, %al
jne 0x6e29a
jmp 0x6e2eb
movq -0x70(%rbp), %rdi
addq $0x10, %rdi
movq %rdi, -0x80(%rbp)
callq 0x52500
movq -0x80(%rbp), %rsi
movq %rax, %rcx
decq %rcx
xorl %eax, %eax
movl %eax, %edx
leaq -0x68(%rbp), %rdi
callq 0x52780
jmp 0x6e2c4
movq -0x70(%rbp), %rdi
addq $0x10, %rdi
leaq -0x68(%rbp), %rsi
callq 0x528a0
leaq -0x68(%rbp), %rdi
callq 0x52e58
movq -0x70(%rbp), %rax
movl 0xc(%rax), %ecx
orl $0x2, %ecx
movl %ecx, 0xc(%rax)
addq $0x80, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x52c90
nopl (%rax)
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::(anonymous namespace)::hexEscapeChar(std::ostream&, unsigned char)
void hexEscapeChar(std::ostream& os, unsigned char c) {
        std::ios_base::fmtflags f(os.flags());
        os << "\\x"
            << std::uppercase << std::hex << std::setfill('0') << std::setw(2)
            << static_cast<int>(c);
        os.flags(f);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0xb46e0
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq 0xd2749(%rip), %rsi     # 0x140ec9
callq 0x52710
movq %rax, %rdi
leaq 0x45f71(%rip), %rsi     # 0xb4700
callq 0x52220
movq %rax, %rdi
leaq 0x24e22(%rip), %rsi     # 0x935c0
callq 0x52220
movq %rax, -0x28(%rbp)
movl $0x30, %edi
callq 0x93570
movq -0x28(%rbp), %rdi
movb %al, -0x11(%rbp)
movzbl -0x11(%rbp), %esi
callq 0x52af0
movq %rax, -0x20(%rbp)
movl $0x2, %edi
callq 0x8db30
movq -0x20(%rbp), %rdi
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %esi
callq 0x52850
movq %rax, %rdi
movzbl -0x9(%rbp), %esi
callq 0x52c50
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
movl -0x10(%rbp), %esi
callq 0xb4730
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::(anonymous namespace)::trailingBytes(unsigned char)
size_t trailingBytes(unsigned char c) {
        if ((c & 0xE0) == 0xC0) {
            return 2;
        }
        if ((c & 0xF0) == 0xE0) {
            return 3;
        }
        if ((c & 0xF8) == 0xF0) {
            return 4;
        }
        CATCH_INTERNAL_ERROR("Invalid multibyte utf-8 start byte encountered");
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movb %dil, %al
movb %al, -0x9(%rbp)
movzbl -0x9(%rbp), %eax
andl $0xe0, %eax
cmpl $0xc0, %eax
jne 0x6e83e
movq $0x2, -0x8(%rbp)
jmp 0x6e931
movzbl -0x9(%rbp), %eax
andl $0xf0, %eax
cmpl $0xe0, %eax
jne 0x6e85b
movq $0x3, -0x8(%rbp)
jmp 0x6e931
movzbl -0x9(%rbp), %eax
andl $0xf8, %eax
cmpl $0xf0, %eax
jne 0x6e878
movq $0x4, -0x8(%rbp)
jmp 0x6e931
leaq -0x48(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x67d90
leaq 0xd0745(%rip), %rsi     # 0x13efd1
leaq -0x58(%rbp), %rdi
movq %rdi, -0x78(%rbp)
movl $0x3c60, %edx           # imm = 0x3C60
callq 0x8e600
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0x8e5d0
movq %rax, -0x70(%rbp)
jmp 0x6e8b1
movq -0x70(%rbp), %rdi
leaq 0xd09ea(%rip), %rsi     # 0x13f2a6
callq 0x8ace0
movq %rax, -0x88(%rbp)
jmp 0x6e8ca
movq -0x88(%rbp), %rdi
leaq 0xd25f4(%rip), %rsi     # 0x140ecc
callq 0xb4780
movq %rax, -0x90(%rbp)
jmp 0x6e8e6
movq -0x90(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x53b70
jmp 0x6e8f8
leaq -0x30(%rbp), %rdi
callq 0x5b700
jmp 0x6e903
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x6e926
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x52e58
leaq -0x48(%rbp), %rdi
callq 0x67e50
jmp 0x6e93e
movq -0x8(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x52c90
nopw (%rax,%rax)
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::(anonymous namespace)::headerValue(unsigned char)
uint32_t headerValue(unsigned char c) {
        if ((c & 0xE0) == 0xC0) {
            return c & 0x1F;
        }
        if ((c & 0xF0) == 0xE0) {
            return c & 0x0F;
        }
        if ((c & 0xF8) == 0xF0) {
            return c & 0x07;
        }
        CATCH_INTERNAL_ERROR("Invalid multibyte utf-8 start byte encountered");
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movb %dil, %al
movb %al, -0x5(%rbp)
movzbl -0x5(%rbp), %eax
andl $0xe0, %eax
cmpl $0xc0, %eax
jne 0x6e980
movzbl -0x5(%rbp), %eax
andl $0x1f, %eax
movl %eax, -0x4(%rbp)
jmp 0x6ea71
movzbl -0x5(%rbp), %eax
andl $0xf0, %eax
cmpl $0xe0, %eax
jne 0x6e99f
movzbl -0x5(%rbp), %eax
andl $0xf, %eax
movl %eax, -0x4(%rbp)
jmp 0x6ea71
movzbl -0x5(%rbp), %eax
andl $0xf8, %eax
cmpl $0xf0, %eax
jne 0x6e9be
movzbl -0x5(%rbp), %eax
andl $0x7, %eax
movl %eax, -0x4(%rbp)
jmp 0x6ea71
leaq -0x40(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x67d90
leaq 0xd05ff(%rip), %rsi     # 0x13efd1
leaq -0x50(%rbp), %rdi
movq %rdi, -0x70(%rbp)
movl $0x3c6d, %edx           # imm = 0x3C6D
callq 0x8e600
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x8e5d0
movq %rax, -0x68(%rbp)
jmp 0x6e9f7
movq -0x68(%rbp), %rdi
leaq 0xd08a4(%rip), %rsi     # 0x13f2a6
callq 0x8ace0
movq %rax, -0x80(%rbp)
jmp 0x6ea0d
movq -0x80(%rbp), %rdi
leaq 0xd24b4(%rip), %rsi     # 0x140ecc
callq 0xb4780
movq %rax, -0x88(%rbp)
jmp 0x6ea26
movq -0x88(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x53b70
jmp 0x6ea38
leaq -0x28(%rbp), %rdi
callq 0x5b700
jmp 0x6ea43
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x6ea66
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x52e58
leaq -0x40(%rbp), %rdi
callq 0x67e50
jmp 0x6ea7d
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x52c90
nopw %cs:(%rax,%rax)
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::XmlWriter::ScopedElement::operator=(Catch::XmlWriter::ScopedElement&&)
XmlWriter::ScopedElement& XmlWriter::ScopedElement::operator=( ScopedElement&& other ) noexcept {
        if ( m_writer ) {
            m_writer->endElement();
        }
        m_writer = other.m_writer;
        other.m_writer = nullptr;
        m_fmt = other.m_fmt;
        other.m_fmt = XmlFormatting::None;
        return *this;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, (%rax)
je 0x6eb77
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movl $0x2, %edi
movl $0x1, %esi
callq 0x6e390
movq -0x20(%rbp), %rdi
movl %eax, %esi
callq 0x6ebc0
jmp 0x6eb75
jmp 0x6eb77
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq $0x0, (%rcx)
movq -0x10(%rbp), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movl $0x0, 0x8(%rcx)
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x8c060
nopw %cs:(%rax,%rax)
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::XmlWriter::endElement(Catch::XmlFormatting)
XmlWriter& XmlWriter::endElement(XmlFormatting fmt) {
        m_indent = m_indent.substr(0, m_indent.size() - 2);

        if( m_tagIsOpen ) {
            m_os << "/>";
            m_tagIsOpen = false;
        } else {
            newlineIfNecessary();
            if (shouldIndent(fmt)) {
                m_os << m_indent;
            }
            m_os << "</" << m_tags.back() << ">";
        }
        m_os << std::flush;
        applyFormatting(fmt);
        m_tags.pop_back();
        return *this;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
addq $0x20, %rax
movq %rax, -0x40(%rbp)
addq $0x20, %rdi
callq 0x52500
movq -0x40(%rbp), %rsi
movq %rax, %rcx
subq $0x2, %rcx
leaq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
callq 0x52780
movq -0x38(%rbp), %rdi
addq $0x20, %rdi
leaq -0x30(%rbp), %rsi
callq 0x528a0
leaq -0x30(%rbp), %rdi
callq 0x52e58
movq -0x38(%rbp), %rax
testb $0x1, (%rax)
je 0x6ec43
movq -0x38(%rbp), %rax
movq 0x40(%rax), %rdi
leaq 0xd0e87(%rip), %rsi     # 0x13fabc
callq 0x52710
movq -0x38(%rbp), %rax
movb $0x0, (%rax)
jmp 0x6ecab
movq -0x38(%rbp), %rdi
callq 0x6ef70
movl -0xc(%rbp), %edi
callq 0x6f0b0
testb $0x1, %al
jne 0x6ec5a
jmp 0x6ec6b
movq -0x38(%rbp), %rsi
movq 0x40(%rsi), %rdi
addq $0x20, %rsi
callq 0x52670
movq -0x38(%rbp), %rax
movq 0x40(%rax), %rdi
leaq 0xd0e45(%rip), %rsi     # 0x13fabf
callq 0x52710
movq -0x38(%rbp), %rdi
movq %rax, -0x48(%rbp)
addq $0x8, %rdi
callq 0x93df0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
callq 0x52670
movq %rax, %rdi
leaq 0xd0e23(%rip), %rsi     # 0x13fac9
callq 0x52710
movq -0x38(%rbp), %rax
movq 0x40(%rax), %rdi
movq 0x1522e6(%rip), %rsi    # 0x1c0fa0
callq 0x527a0
movq -0x38(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x6f0e0
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
callq 0x93e30
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::XmlWriter::writeText(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::XmlFormatting)
XmlWriter& XmlWriter::writeText( std::string const& text, XmlFormatting fmt) {
        if( !text.empty() ){
            bool tagWasOpen = m_tagIsOpen;
            ensureTagClosed();
            if (tagWasOpen && shouldIndent(fmt)) {
                m_os << m_indent;
            }
            m_os << XmlEncode( text );
            applyFormatting(fmt);
        }
        return *this;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0x52bb0
testb $0x1, %al
jne 0x6ee2d
movq -0x58(%rbp), %rdi
movb (%rdi), %al
andb $0x1, %al
movb %al, -0x15(%rbp)
callq 0x6f060
testb $0x1, -0x15(%rbp)
je 0x6edd1
movl -0x14(%rbp), %edi
callq 0x6f0b0
testb $0x1, %al
jne 0x6edc0
jmp 0x6edd1
movq -0x58(%rbp), %rsi
movq 0x40(%rsi), %rdi
addq $0x20, %rsi
callq 0x52670
movq -0x58(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x60(%rbp)
xorl %edx, %edx
callq 0x6e3d0
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x6ea90
jmp 0x6edff
leaq -0x40(%rbp), %rdi
callq 0x93e60
movq -0x58(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x6f0e0
jmp 0x6ee2d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x93e60
jmp 0x6ee37
movq -0x58(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x52c90
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::XmlWriter::startElement(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::XmlFormatting)
XmlWriter& XmlWriter::startElement( std::string const& name, XmlFormatting fmt ) {
        ensureTagClosed();
        newlineIfNecessary();
        if (shouldIndent(fmt)) {
            m_os << m_indent;
            m_indent += "  ";
        }
        m_os << '<' << name;
        m_tags.push_back( name );
        m_tagIsOpen = true;
        applyFormatting(fmt);
        return *this;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x6f060
movq -0x20(%rbp), %rdi
callq 0x6ef70
movl -0x14(%rbp), %edi
callq 0x6f0b0
testb $0x1, %al
jne 0x6efe7
jmp 0x6f00c
movq -0x20(%rbp), %rsi
movq 0x40(%rsi), %rdi
addq $0x20, %rsi
callq 0x52670
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
leaq 0xd9a05(%rip), %rsi     # 0x148a0c
callq 0x526e0
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rdi
movl $0x3c, %esi
callq 0x52870
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x52670
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
callq 0x91260
movq -0x20(%rbp), %rdi
movb $0x1, (%rdi)
movl -0x14(%rbp), %esi
callq 0x6f0e0
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::XmlWriter::ensureTagClosed()
void XmlWriter::ensureTagClosed() {
        if( m_tagIsOpen ) {
            m_os << '>' << std::flush;
            newlineIfNecessary();
            m_tagIsOpen = false;
        }
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
testb $0x1, (%rax)
je 0x6f0aa
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdi
movl $0x3e, %esi
callq 0x52870
movq %rax, %rdi
movq 0x151f0b(%rip), %rsi    # 0x1c0fa0
callq 0x527a0
movq -0x10(%rbp), %rdi
callq 0x6ef70
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
addq $0x10, %rsp
popq %rbp
retq
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::XmlWriter::writeComment(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, Catch::XmlFormatting)
XmlWriter& XmlWriter::writeComment( std::string const& text, XmlFormatting fmt) {
        ensureTagClosed();
        if (shouldIndent(fmt)) {
            m_os << m_indent;
        }
        m_os << "<!--" << text << "-->";
        applyFormatting(fmt);
        return *this;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x6f060
movl -0x14(%rbp), %edi
callq 0x6f0b0
testb $0x1, %al
jne 0x6f33e
jmp 0x6f34f
movq -0x20(%rbp), %rsi
movq 0x40(%rsi), %rdi
addq $0x20, %rsi
callq 0x52670
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rdi
leaq 0xd0764(%rip), %rsi     # 0x13fac2
callq 0x52710
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x52670
movq %rax, %rdi
leaq 0xd074e(%rip), %rsi     # 0x13fac7
callq 0x52710
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x6f0e0
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::getFormattedDuration[abi:cxx11](double)
std::string getFormattedDuration( double duration ) {
        // Max exponent + 1 is required to represent the whole part
        // + 1 for decimal point
        // + 3 for the 3 decimal places
        // + 1 for null terminator
        const std::size_t maxDoubleSize = DBL_MAX_10_EXP + 1 + 1 + 3 + 1;
        char buffer[maxDoubleSize];

        // Save previous errno, to prevent sprintf from overwriting it
        ErrnoGuard guard;
#ifdef _MSC_VER
        sprintf_s(buffer, "%.3f", duration);
#else
        std::sprintf(buffer, "%.3f", duration);
#endif
        return std::string(buffer);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rdi, -0x190(%rbp)
movq %rdi, %rax
movq %rax, -0x198(%rbp)
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq $0x13a, -0x18(%rbp)     # imm = 0x13A
leaq -0x164(%rbp), %rdi
callq 0x5c080
movsd -0x10(%rbp), %xmm0
leaq 0xd0646(%rip), %rsi     # 0x13fb1b
leaq -0x160(%rbp), %rdi
movq %rdi, -0x188(%rbp)
movb $0x1, %al
callq 0x52140
leaq -0x165(%rbp), %rdi
movq %rdi, -0x180(%rbp)
callq 0x52ca0
movq -0x190(%rbp), %rdi
movq -0x188(%rbp), %rsi
movq -0x180(%rbp), %rdx
callq 0x529e0
jmp 0x6f519
leaq -0x165(%rbp), %rdi
callq 0x527d0
leaq -0x164(%rbp), %rdi
callq 0x5c0b0
movq -0x198(%rbp), %rax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x170(%rbp)
movl %eax, -0x174(%rbp)
leaq -0x165(%rbp), %rdi
callq 0x527d0
leaq -0x164(%rbp), %rdi
callq 0x5c0b0
movq -0x170(%rbp), %rdi
callq 0x52c90
nopw (%rax,%rax)
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::shouldShowDuration(Catch::IConfig const&, double)
bool shouldShowDuration( IConfig const& config, double duration ) {
        if ( config.showDurations() == ShowDurations::Always ) {
            return true;
        }
        if ( config.showDurations() == ShowDurations::Never ) {
            return false;
        }
        const double min = config.minDuration();
        return min >= 0 && duration >= min;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x58(%rax)
cmpl $0x1, %eax
jne 0x6f5a6
movb $0x1, -0x1(%rbp)
jmp 0x6f5f5
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x58(%rax)
cmpl $0x2, %eax
jne 0x6f5bb
movb $0x0, -0x1(%rbp)
jmp 0x6f5f5
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
callq *0x60(%rax)
movsd %xmm0, -0x20(%rbp)
movsd -0x20(%rbp), %xmm0
xorl %eax, %eax
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movb %al, -0x21(%rbp)
jb 0x6f5ed
movsd -0x18(%rbp), %xmm0
ucomisd -0x20(%rbp), %xmm0
setae %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::serializeFilters(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
std::string serializeFilters( std::vector<std::string> const& container ) {
        ReusableStringStream oss;
        bool first = true;
        for (auto&& filter : container)
        {
            if (!first)
                oss << ' ';
            else
                first = false;

            oss << filter;
        }
        return oss.str();
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x67d90
movb $0x1, -0x29(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x8d7e0
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x8d810
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x8d840
testb $0x1, %al
jne 0x6f660
jmp 0x6f6bf
leaq -0x40(%rbp), %rdi
callq 0x8d880
movq %rax, -0x50(%rbp)
testb $0x1, -0x29(%rbp)
jne 0x6f69f
movb $0x20, -0x51(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x51(%rbp), %rsi
callq 0x8ac70
jmp 0x6f686
jmp 0x6f6a3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x67e50
jmp 0x6f6e4
movb $0x0, -0x29(%rbp)
movq -0x50(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x8ab30
jmp 0x6f6b2
jmp 0x6f6b4
leaq -0x40(%rbp), %rdi
callq 0x8da50
jmp 0x6f64d
movq -0x78(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x53b70
jmp 0x6f6ce
leaq -0x28(%rbp), %rdi
callq 0x67e50
movq -0x70(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x52c90
nopl (%rax)
// File: xelia-it[P]mustache/third-party/catch2/single_include/catch2/catch.hpp
// Function: Catch::ConsoleReporter::ConsoleReporter(Catch::ReporterConfig const&)
ConsoleReporter::ConsoleReporter(ReporterConfig const& config)
    : StreamingReporterBase(config),
    m_tablePrinter(new TablePrinter(config.stream(),
        [&config]() -> std::vector<ColumnInfo> {
        if (config.fullConfig()->benchmarkNoAnalysis())
        {
            return{
                { "benchmark name", CATCH_CONFIG_CONSOLE_WIDTH - 43, ColumnInfo::Left },
                { "     samples", 14, ColumnInfo::Right },
                { "  iterations", 14, ColumnInfo::Right },
                { "        mean", 14, ColumnInfo::Right }
            };
        }
        else
        {
            return{
                { "benchmark name", CATCH_CONFIG_CONSOLE_WIDTH - 43, ColumnInfo::Left },
                { "samples      mean       std dev", 14, ColumnInfo::Right },
                { "iterations   low mean   low std dev", 14, ColumnInfo::Right },
                { "estimated    high mean  high std dev", 14, ColumnInfo::Right }
            };
        }
    }())) {}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
movq -0x10(%rbp), %rsi
callq 0x94310
movq -0x60(%rbp), %rax
leaq 0x14c21c(%rip), %rcx    # 0x1bd428
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x168, %rax            # imm = 0x168
movq %rax, -0x58(%rbp)
movl $0x1a0, %edi            # imm = 0x1A0
callq 0x52720
movq %rax, -0x50(%rbp)
jmp 0x7122d
movb $0x1, -0x41(%rbp)
movq -0x10(%rbp), %rdi
callq 0x5cab0
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x712f0
jmp 0x71255
movq -0x68(%rbp), %rsi
movq -0x50(%rbp), %rdi
leaq -0x38(%rbp), %rdx
callq 0x71a90
jmp 0x71268
movq -0x50(%rbp), %rsi
movq -0x58(%rbp), %rdi
movb $0x0, -0x41(%rbp)
callq 0x945a0
leaq -0x38(%rbp), %rdi
callq 0x71b20
movq -0x60(%rbp), %rax
movb $0x0, 0x170(%rax)
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x712d7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x712c4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x71b20
testb $0x1, -0x41(%rbp)
jne 0x712cc
jmp 0x712d5
movq -0x50(%rbp), %rdi
callq 0x526b0
jmp 0x712d7
movq -0x60(%rbp), %rdi
callq 0xb4f00
movq -0x18(%rbp), %rdi
callq 0x52c90
nopl (%rax)