LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/zhjw1998[P]Merkle-Tree/src/../include/picosha2.h
// Function: picosha2::hash256_one_by_one::finish()
void finish() {
        byte_t temp[64];
        std::fill(temp, temp + 64, 0);
        std::size_t remains = buffer_.size();
        std::copy(buffer_.begin(), buffer_.end(), temp);
        temp[remains] = 0x80;

        if (remains > 55) {
            std::fill(temp + remains + 1, temp + 64, 0);
            detail::hash256_block(h_, temp, temp + 64);
            std::fill(temp, temp + 64 - 4, 0);
        } else {
            std::fill(temp + remains + 1, temp + 64 - 4, 0);
        }

        write_data_bit_length(&(temp[56]));
        detail::hash256_block(h_, temp, temp + 64);
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
xorl %eax, %eax
cmpq $0x40, %rax
je 0x349d
movb $0x0, (%rsp,%rax)
incq %rax
jmp 0x348e
movq (%rbx), %rsi
movq 0x8(%rbx), %r15
subq %rsi, %r15
je 0x34b4
movq %rsp, %rdi
movq %r15, %rdx
callq 0x22d0
leaq 0x40(%rsp), %r14
movb $-0x80, (%rsp,%r15)
cmpq $0x37, %r15
jbe 0x34d5
cmpq $0x3f, %r15
je 0x34e6
movb $0x0, 0x1(%rsp,%r15)
incq %r15
jmp 0x34c4
cmpq $0x3b, %r15
je 0x3506
movb $0x0, 0x1(%rsp,%r15)
incq %r15
jmp 0x34d5
leaq 0x38(%rbx), %rdi
movq %rsp, %rsi
movq %r14, %rdx
callq 0x3a7e
xorl %eax, %eax
cmpq $0x3c, %rax
je 0x3506
movb $0x0, (%rsp,%rax)
incq %rax
jmp 0x34f7
leaq 0x38(%rsp), %rsi
movq %rbx, %rdi
callq 0x3c42
addq $0x38, %rbx
movq %rsp, %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x3a7e
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/zhjw1998[P]Merkle-Tree/src/../include/picosha2.h
// Function: void picosha2::hash256_one_by_one::get_hash_bytes<unsigned char*>(unsigned char*, unsigned char*) const
void get_hash_bytes(OutIter first, OutIter last) const {
        for (const word_t* iter = h_; iter != h_ + 8; ++iter) {
            for (std::size_t i = 0; i < 4 && first != last; ++i) {
                *(first++) = detail::mask_8bit(
                    static_cast<byte_t>((*iter >> (24 - 8 * i))));
            }
        }
    }

// Assembly:
pushq $0x38
popq %rax
pushq $0x18
popq %r8
cmpq $0x78, %rax
je 0x356e
movq %r8, %rcx
xorl %r9d, %r9d
leaq (%rsi,%r9), %r10
cmpq $0x3, %r9
ja 0x3565
cmpq %rdx, %r10
je 0x3565
movq (%rdi,%rax), %r11
shrq %cl, %r11
movb %r11b, (%r10)
incq %r9
addq $-0x8, %rcx
jmp 0x3543
addq $0x8, %rax
movq %r10, %rsi
jmp 0x3537
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/zhjw1998[P]Merkle-Tree/src/../include/picosha2.h
// Function: picosha2::hash256_one_by_one::add_to_data_length(unsigned long)
void add_to_data_length(word_t n) {
        word_t carry = 0;
        data_length_digits_[0] += n;
        for (std::size_t i = 0; i < 4; ++i) {
            data_length_digits_[i] += carry;
            if (data_length_digits_[i] >= 65536u) {
                carry = data_length_digits_[i] >> 16;
                data_length_digits_[i] &= 65535u;
            } else {
                break;
            }
        }
    }

// Assembly:
addq %rsi, 0x18(%rdi)
xorl %ecx, %ecx
xorl %eax, %eax
cmpq $0x4, %rax
je 0x361c
addq 0x18(%rdi,%rax,8), %rcx
movq %rcx, 0x18(%rdi,%rax,8)
cmpq $0x10000, %rcx          # imm = 0x10000
jb 0x361c
movzwl %cx, %edx
shrq $0x10, %rcx
movq %rdx, 0x18(%rdi,%rax,8)
incq %rax
jmp 0x35f2
retq
// File: /workspace/github_cpp_makefile_star2_O2/ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::detail::rawMemoryToString(void const*, unsigned int)
String rawMemoryToString(const void* object, unsigned 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 const char* bytes = static_cast<unsigned const char*>(object);
        std::ostream*        oss   = tlssPush();
        *oss << "0x" << std::setfill('0') << std::hex;
        for(; i != end; i += inc)
            *oss << std::setw(2) << static_cast<unsigned>(bytes[i]);
        return tlssPop();
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x5cb1
movq %rax, %r15
leaq 0x116aa(%rip), %rsi     # 0x172f0
movq %rax, %rdi
callq 0x53d0
pushq $0x30
popq %rsi
movq %rax, %rdi
callq 0x55a0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %edx
andl $-0x4b, %edx
orl $0x8, %edx
movl %edx, 0x18(%rax,%rcx)
movslq %ebp, %rax
movq %rax, %r12
subq $0x1, %r12
jb 0x5c9d
movq (%r15), %rcx
movq -0x18(%rcx), %rcx
movq $0x2, 0x10(%r15,%rcx)
movzbl -0x1(%r14,%rax), %esi
movq %r15, %rdi
callq 0x5280
movq %r12, %rax
jmp 0x5c74
movq %rbx, %rdi
callq 0x5cfb
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::String::allocate(unsigned int)
char* String::allocate(unsigned sz) {
    if (sz <= last) {
        buf[sz] = '\0';
        setLast(last - sz);
        return buf;
    } else {
        setOnHeap();
        data.size = sz;
        data.capacity = data.size + 1;
        data.ptr = new char[data.capacity];
        data.ptr[sz] = '\0';
        return data.ptr;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
cmpl $0x17, %esi
ja 0x5e24
movl %r14d, %eax
movb $0x0, (%rbx,%rax)
movb $0x17, %al
subb %r14b, %al
movb %al, 0x17(%rbx)
jmp 0x5e45
movb $-0x80, 0x17(%rbx)
movl %r14d, 0x8(%rbx)
leal 0x1(%r14), %edi
movl %edi, 0xc(%rbx)
callq 0x5030
movq %rax, (%rbx)
movl %r14d, %ecx
movb $0x0, (%rax,%rcx)
movq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::String::copy(doctest::String const&)
void String::copy(const String& other) {
    if(other.isOnStack()) {
        memcpy(buf, other.buf, len);
    } else {
        memcpy(allocate(other.data.size), other.data.ptr, other.data.size);
    }
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
cmpb $0x0, 0x17(%rsi)
js 0x5e76
movq 0x10(%rbx), %rax
movq %rax, 0x10(%rdi)
movups (%rbx), %xmm0
movups %xmm0, (%rdi)
popq %rbx
retq
movl 0x8(%rbx), %esi
callq 0x5e04
movq (%rbx), %rsi
movl 0x8(%rbx), %edx
movq %rax, %rdi
popq %rbx
jmp 0x5330
nop
// File: /workspace/github_cpp_makefile_star2_O2/ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::String::operator=(doctest::String const&)
String& String::operator=(const String& other) {
    if(this != &other) {
        if(!isOnStack())
            delete[] data.ptr;

        copy(other);
    }

    return *this;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x5f59
movq %rsi, %r14
cmpb $0x0, 0x17(%rbx)
jns 0x5f4e
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x5f4e
callq 0x54b0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5e5c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::String::operator=(doctest::String&&)
String& String::operator=(String&& other) {
    if(this != &other) {
        if(!isOnStack())
            delete[] data.ptr;
        memcpy(buf, other.buf, len);
        other.buf[0] = '\0';
        other.setLast();
    }
    return *this;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x611e
movq %rsi, %r14
cmpb $0x0, 0x17(%rbx)
jns 0x6106
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x6106
callq 0x54b0
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
movups (%r14), %xmm0
movups %xmm0, (%rbx)
movb $0x0, (%r14)
movb $0x17, 0x17(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::detail::checkIfShouldThrow(doctest::assertType::Enum)
bool checkIfShouldThrow(assertType::Enum at) {
        if(at & assertType::is_require) //!OCLINT bitwise operator in conditional
            return true;

        if((at & assertType::is_check) //!OCLINT bitwise operator in conditional
           && getContextOptions()->abort_after > 0 &&
           (g_cs->numAssertsFailed + g_cs->numAssertsFailedCurrentTest_atomic) >=
                   getContextOptions()->abort_after)
            return true;

        return false;
    }

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movb $0x1, %bl
testb $0x4, %dil
jne 0x6fc0
testb $0x2, %dil
je 0x6fbe
movq 0x1d440(%rip), %rdi     # 0x243d8
cmpl $0x0, 0x64(%rdi)
jle 0x6fbe
movl 0x9c(%rdi), %ebp
addq $0x8b8, %rdi            # imm = 0x8B8
callq 0x122c2
addl %ebp, %eax
movq 0x1d41f(%rip), %rcx     # 0x243d8
cmpl 0x64(%rcx), %eax
jge 0x6fc0
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::detail::Subcase::Subcase(doctest::String const&, char const*, int)
Subcase::Subcase(const String& name, const char* file, int line)
            : m_signature({name, file, line}) {
        auto* s = g_cs;

        // check subcase filters
        if(s->subcasesStack.size() < size_t(s->subcase_filter_levels)) {
            if(!matchesAny(m_signature.m_name.c_str(), s->filters[6], true, s->case_sensitive))
                return;
            if(matchesAny(m_signature.m_name.c_str(), s->filters[7], false, s->case_sensitive))
                return;
        }
        
        // if a Subcase on the same level has already been entered
        if(s->subcasesStack.size() < size_t(s->subcasesCurrentMaxLevel)) {
            s->should_reenter = true;
            return;
        }

        // push the current signature to the stack so we can check if the
        // current stack + the current new subcase have been traversed
        s->subcasesStack.push_back(m_signature);
        if(s->subcasesPassed.count(s->subcasesStack) != 0) {
            // pop - revert to previous stack since we've already passed this
            s->subcasesStack.pop_back();
            return;
        }

        s->subcasesCurrentMaxLevel = s->subcasesStack.size();
        m_entered = true;

        DOCTEST_ITERATE_THROUGH_REPORTERS(subcase_start, m_signature);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r14
movq %rdi, %rbx
callq 0x5e5c
movq %r14, 0x18(%rbx)
movl %ebp, 0x20(%rbx)
movb $0x0, 0x28(%rbx)
movq 0x1d3bc(%rip), %r13     # 0x243d8
movq 0x1118(%r13), %rax
subq 0x1110(%r13), %rax
pushq $0x28
popq %rcx
cqto
idivq %rcx
movq %rax, %r14
movslq 0x68(%r13), %rax
cmpq %rax, %r14
jae 0x7089
cmpb $0x0, 0x17(%rbx)
movq %rbx, %r15
jns 0x704a
movq (%rbx), %r15
movq 0x10b8(%r13), %r12
leaq 0x90(%r12), %rsi
movzbl 0x6d(%r13), %ebp
pushq $0x1
popq %rdx
movq %r15, %rdi
movl %ebp, %ecx
callq 0x714e
testb %al, %al
je 0x709d
addq $0xa8, %r12
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
movl %ebp, %ecx
callq 0x714e
testb %al, %al
jne 0x709d
movslq 0x1158(%r13), %rax
cmpq %rax, %r14
jae 0x70ac
movb $0x1, 0x115c(%r13)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1110(%r13), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x122ca
leaq 0x1128(%r13), %rdi
movq %r14, %rsi
callq 0x122f6
testq %rax, %rax
je 0x70e8
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x12310
movq 0x1118(%r13), %rax
subq 0x1110(%r13), %rax
cqto
pushq $0x28
popq %rcx
idivq %rcx
movl %eax, 0x1158(%r13)
movb $0x1, 0x28(%rbx)
movq 0x1d2c8(%rip), %rax     # 0x243d8
movq 0x10d0(%rax), %r14
movq 0x10d8(%rax), %r15
cmpq %r15, %r14
je 0x709d
movq (%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x38(%rax)
addq $0x8, %r14
jmp 0x711e
jmp 0x713b
movq %rax, %r14
movq %rbx, %rdi
callq 0x5e96
movq %r14, %rdi
callq 0x5670
// File: /workspace/github_cpp_makefile_star2_O2/ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::(anonymous namespace)::matchesAny(char const*, std::vector<doctest::String, std::allocator<doctest::String>> const&, bool, bool)
bool matchesAny(const char* name, const std::vector<String>& filters, bool matchEmpty,
                    bool caseSensitive) {
        if(filters.empty() && matchEmpty)
            return true;
        for(auto& curr : filters)
            if(wildcmp(name, curr.c_str(), caseSensitive))
                return true;
        return false;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebp
movq %rdi, 0x8(%rsp)
movq (%rsi), %rdi
movq 0x8(%rsi), %rsi
cmpq %rsi, %rdi
sete %cl
movb $0x1, %al
testb %dl, %cl
jne 0x72a8
movl %ebp, 0x4(%rsp)
movq %rsi, 0x18(%rsp)
cmpq %rsi, %rdi
je 0x72b7
cmpb $0x0, 0x17(%rdi)
movq %rdi, %r14
jns 0x7198
movq (%rdi), %r14
movq %rdi, 0x20(%rsp)
movq 0x8(%rsp), %rbx
movq %r14, 0x10(%rsp)
movsbl (%rbx), %r15d
testl %r15d, %r15d
je 0x71ff
movsbl (%r14), %r12d
cmpl $0x2a, %r12d
je 0x71ff
testb %bpl, %bpl
je 0x71d5
cmpb %r15b, %r12b
sete %al
cmpb $0x3f, %r12b
sete %cl
orb %al, %cl
jne 0x71f7
jmp 0x7293
movl %r12d, %edi
callq 0x5540
movl %eax, %r13d
movl %r15d, %edi
callq 0x5540
cmpb $0x3f, %r12b
je 0x71f7
cmpl %eax, %r13d
jne 0x7293
incq %r14
incq %rbx
jmp 0x71a7
movq 0x8(%rsp), %rbp
testb %r15b, %r15b
je 0x727d
movsbl (%r14), %r12d
cmpl $0x2a, %r12d
jne 0x722c
cmpb $0x0, 0x1(%r14)
je 0x72a6
incq %r14
leaq 0x1(%rbx), %rbp
movq %r14, 0x10(%rsp)
jmp 0x7278
cmpb $0x0, 0x4(%rsp)
je 0x7246
cmpb %r15b, %r12b
sete %al
cmpb $0x3f, %r12b
sete %cl
orb %al, %cl
je 0x7265
jmp 0x7272
movl %r12d, %edi
callq 0x5540
movl %eax, %r13d
movsbl %r15b, %edi
callq 0x5540
cmpb $0x3f, %r12b
je 0x7272
cmpl %eax, %r13d
je 0x7272
movq %rbp, %rbx
incq %rbp
movq 0x10(%rsp), %r14
jmp 0x7278
incq %r14
incq %rbx
movb (%rbx), %r15b
jmp 0x7204
movzbl (%r14), %eax
incq %r14
cmpl $0x2a, %eax
je 0x727d
testl %eax, %eax
movb $0x1, %al
movl 0x4(%rsp), %ebp
je 0x72a8
movq 0x20(%rsp), %rdi
addq $0x18, %rdi
movq 0x18(%rsp), %rsi
jmp 0x7183
movb $0x1, %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0x72a8
nop
// File: /workspace/github_cpp_makefile_star2_O2/ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::detail::Subcase::~Subcase()
Subcase::~Subcase() {
        if(m_entered) {
            // only mark the subcase stack as passed if no subcases have been skipped
            if(g_cs->should_reenter == false)
                g_cs->subcasesPassed.insert(g_cs->subcasesStack);
            g_cs->subcasesStack.pop_back();

#if defined(__cpp_lib_uncaught_exceptions) && __cpp_lib_uncaught_exceptions >= 201411L && (!defined(__MAC_OS_X_VERSION_MIN_REQUIRED) || __MAC_OS_X_VERSION_MIN_REQUIRED >= 101200)
            if(std::uncaught_exceptions() > 0
#else
            if(std::uncaught_exception()
#endif
            && g_cs->shouldLogCurrentException) {
                DOCTEST_ITERATE_THROUGH_REPORTERS(
                        test_case_exception, {"exception thrown in subcase - will translate later "
                                              "when the whole test case has been exited (cannot "
                                              "translate while there is an active exception)",
                                              false});
                g_cs->shouldLogCurrentException = false;
            }
            DOCTEST_ITERATE_THROUGH_REPORTERS(subcase_end, DOCTEST_EMPTY);
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
cmpb $0x1, 0x28(%rdi)
jne 0x73b0
movq 0x1d0fa(%rip), %rsi     # 0x243d8
cmpb $0x0, 0x115c(%rsi)
jne 0x7301
leaq 0x1128(%rsi), %rdi
addq $0x1110, %rsi           # imm = 0x1110
callq 0x136c6
movq 0x1d0d7(%rip), %rsi     # 0x243d8
addq $0x1110, %rsi           # imm = 0x1110
movq %rsi, %rdi
callq 0x12310
callq 0x5470
movq 0x1d0bc(%rip), %rcx     # 0x243d8
testl %eax, %eax
jle 0x738e
movb 0x115d(%rcx), %al
movq 0x1d0ab(%rip), %rcx     # 0x243d8
testb $0x1, %al
je 0x738e
movq 0x10d0(%rcx), %r13
movq 0x10d8(%rcx), %rbp
leaq 0x1022c(%rip), %r14     # 0x17572
leaq 0x8(%rsp), %r15
cmpq %rbp, %r13
je 0x737f
movq (%r13), %r12
movq %r15, %rdi
movq %r14, %rsi
callq 0x5eaa
movb $0x0, 0x20(%rsp)
movq (%r12), %rax
movq %r12, %rdi
movq %r15, %rsi
callq *0x30(%rax)
movq %r15, %rdi
callq 0x5e96
addq $0x8, %r13
jmp 0x734b
movq 0x1d052(%rip), %rcx     # 0x243d8
xorl %eax, %eax
xchgb %al, 0x115d(%rcx)
movq 0x10d0(%rcx), %r14
movq 0x10d8(%rcx), %r15
cmpq %r15, %r14
je 0x73b0
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
addq $0x8, %r14
jmp 0x739c
movq %rbx, %rdi
callq 0x5e96
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x73cb
jmp 0x73cb
movq %rax, %rdi
callq 0x122b7
nop
// File: /workspace/github_cpp_makefile_star2_O2/ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::detail::TestCase::TestCase(void (*)(), char const*, unsigned int, doctest::detail::TestSuite const&, char const*, int)
TestCase::TestCase(funcType test, const char* file, unsigned line, const TestSuite& test_suite,
                       const char* type, int template_id) {
        m_file              = file;
        m_line              = line;
        m_name              = nullptr; // will be later overridden in operator*
        m_test_suite        = test_suite.m_test_suite;
        m_description       = test_suite.m_description;
        m_skip              = test_suite.m_skip;
        m_no_breaks         = test_suite.m_no_breaks;
        m_no_output         = test_suite.m_no_output;
        m_may_fail          = test_suite.m_may_fail;
        m_should_fail       = test_suite.m_should_fail;
        m_expected_failures = test_suite.m_expected_failures;
        m_timeout           = test_suite.m_timeout;

        m_test        = test;
        m_type        = type;
        m_template_id = template_id;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %r14
movq %r8, %r15
movl %ecx, %ebp
movq %rsi, %r12
movq %rdi, %rbx
xorl %eax, %eax
movb %al, (%rdi)
movb $0x17, %cl
movb %cl, 0x17(%rdi)
leaq 0x68(%rdi), %r13
movb %al, 0x68(%rdi)
movb %cl, 0x7f(%rdi)
movq %rsp, %rdi
movq %rdx, %rsi
callq 0x5eaa
movq %rsp, %r13
movq %rbx, %rdi
movq %r13, %rsi
callq 0x60e4
movq %r13, %rdi
callq 0x5e96
movl %ebp, 0x18(%rbx)
andq $0x0, 0x20(%rbx)
movups (%r15), %xmm0
movups %xmm0, 0x28(%rbx)
movl 0x10(%r15), %eax
movl %eax, 0x38(%rbx)
movb 0x14(%r15), %al
movb %al, 0x3c(%rbx)
movl 0x18(%r15), %eax
movl %eax, 0x40(%rbx)
movsd 0x20(%r15), %xmm0
movsd %xmm0, 0x48(%rbx)
movq %r12, 0x50(%rbx)
movq %r14, 0x58(%rbx)
movl 0x50(%rsp), %eax
movl %eax, 0x60(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %r13, %rdi
callq 0x5e96
movq %rbx, %rdi
callq 0x5e96
movq %r14, %rdi
callq 0x5670
nop
// File: /workspace/github_cpp_makefile_star2_O2/ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::detail::TestCase::operator=(doctest::detail::TestCase const&)
TestCase& TestCase::operator=(const TestCase& other) {
        static_cast<TestCaseData&>(*this) = static_cast<const TestCaseData&>(other);

        m_test        = other.m_test;
        m_type        = other.m_type;
        m_template_id = other.m_template_id;
        m_full_name   = other.m_full_name;

        if(m_template_id != -1)
            m_name = m_full_name.c_str();
        return *this;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
callq 0x12324
movups 0x50(%r15), %xmm0
movups %xmm0, 0x50(%rbx)
movl 0x60(%r15), %eax
movl %eax, 0x60(%rbx)
addq $0x68, %r15
leaq 0x68(%rbx), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x5f2c
cmpl $-0x1, 0x60(%rbx)
je 0x7541
cmpb $0x0, 0x7f(%rbx)
jns 0x753d
movq 0x68(%rbx), %r14
movq %r14, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::detail::TestCase::operator<(doctest::detail::TestCase const&) const
bool TestCase::operator<(const TestCase& other) const {
        // this will be used only to differentiate between test cases - not relevant for sorting
        if(m_line != other.m_line)
            return m_line < other.m_line;
        const int name_cmp = strcmp(m_name, other.m_name);
        if(name_cmp != 0)
            return name_cmp < 0;
        const int file_cmp = m_file.compare(other.m_file);
        if(file_cmp != 0)
            return file_cmp < 0;
        return m_template_id < other.m_template_id;
    }

// Assembly:
movl 0x18(%rsi), %eax
cmpl %eax, 0x18(%rdi)
jne 0x7624
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rdi), %rdi
movq 0x20(%rsi), %rsi
callq 0x5510
testl %eax, %eax
je 0x7628
shrl $0x1f, %eax
jmp 0x764d
setb %al
retq
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x61c0
movl %eax, %ecx
movl 0x60(%r14), %edx
xorl %eax, %eax
cmpl 0x60(%rbx), %edx
setl %al
xorl %edx, %edx
testl %ecx, %ecx
sets %dl
cmovnel %edx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::detail::ContextScopeBase::ContextScopeBase(doctest::detail::ContextScopeBase&&)
ContextScopeBase::ContextScopeBase(ContextScopeBase&& other) {
        if (other.need_to_destroy) {
            other.destroy();
        }
        other.need_to_destroy = false;
        g_infoContexts.push_back(this);
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1c1dd(%rip), %rax     # 0x23b20
movq %rax, (%rdi)
movb $0x1, 0x8(%rdi)
cmpb $0x1, 0x8(%rsi)
jne 0x7958
movq %r14, %rdi
callq 0x7986
movb $0x0, 0x8(%r14)
callq 0x121f3
movq %fs:0x0, %rax
leaq -0x30(%rax), %rdi
movq %rsp, %rsi
movq %rbx, (%rsi)
callq 0x13d96
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::detail::ResultBuilder::ResultBuilder(doctest::assertType::Enum, char const*, int, char const*, char const*, char const*)
ResultBuilder::ResultBuilder(assertType::Enum at, const char* file, int line, const char* expr,
                                 const char* exception_type, const char* exception_string) {
        m_test_case        = g_cs->currentTest;
        m_at               = at;
        m_file             = file;
        m_line             = line;
        m_expr             = expr;
        m_failed           = true;
        m_threw            = false;
        m_threw_as         = false;
        m_exception_type   = exception_type;
        m_exception_string = exception_string;
#if DOCTEST_MSVC
        if(m_expr[0] == ' ') // this happens when variadic macros are disabled under MSVC
            ++m_expr;
#endif // MSVC
    }

// Assembly:
movq 0x8(%rsp), %rax
xorl %r10d, %r10d
movb %r10b, 0x30(%rdi)
movw $0x17, 0x47(%rdi)
movb $0x17, 0x5f(%rdi)
movq 0x1c961(%rip), %r11     # 0x243d8
movq 0x20(%r11), %r11
movq %r11, (%rdi)
movl %esi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movl %ecx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movw $0x1, 0x28(%rdi)
movb %r10b, 0x60(%rdi)
movq %r9, 0x68(%rdi)
movq %rax, 0x70(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::(anonymous namespace)::translateActiveException()
String translateActiveException() {
#ifndef DOCTEST_CONFIG_NO_EXCEPTIONS
        String res;
        auto&  translators = getExceptionTranslators();
        for(auto& curr : translators)
            if(curr->translate(res))
                return res;
        // clang-format off
        DOCTEST_GCC_SUPPRESS_WARNING_WITH_PUSH("-Wcatch-value")
        try {
            throw;
        } catch(std::exception& ex) {
            return ex.what();
        } catch(std::string& msg) {
            return msg.c_str();
        } catch(const char* msg) {
            return msg;
        } catch(...) {
            return "unknown exception";
        }
        DOCTEST_GCC_SUPPRESS_WARNING_POP
// clang-format on
#else  // DOCTEST_CONFIG_NO_EXCEPTIONS
        return "";
#endif // DOCTEST_CONFIG_NO_EXCEPTIONS
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movb $0x0, (%r14)
movb $0x17, 0x17(%r14)
callq 0x7831
movq 0x1ce92(%rip), %r15     # 0x249b8
movq 0x1ce93(%rip), %r12     # 0x249c0
cmpq %r12, %r15
je 0x7b76
movq (%r15), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x10(%rax)
addq $0x8, %r15
testb %al, %al
je 0x7b2d
movq 0x10(%rsp), %rax
movq %rax, 0x10(%rbx)
movups (%rsp), %xmm0
movups %xmm0, (%rbx)
movb $0x0, (%rsp)
movb $0x17, 0x17(%rsp)
movq %rsp, %rdi
callq 0x5e96
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x5550
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5e96
movq %rbx, %rdi
callq 0x5670
movq %rdx, %r14
movq %rax, %rdi
cmpl $0x4, %r14d
jne 0x7bba
callq 0x5180
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5eaa
callq 0x55f0
jmp 0x7b5f
cmpl $0x3, %r14d
jne 0x7bd7
callq 0x5180
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x5eaa
callq 0x55f0
jmp 0x7b5f
callq 0x5180
cmpl $0x2, %r14d
jne 0x7bf7
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5eaa
callq 0x55f0
jmp 0x7b5f
leaq 0x100dd(%rip), %rsi     # 0x17cdb
movq %rbx, %rdi
callq 0x5eaa
callq 0x55f0
jmp 0x7b5f
jmp 0x7b7b
movq %rax, %rbx
callq 0x55f0
jmp 0x7b7e
movq %rax, %rbx
callq 0x55f0
jmp 0x7b7e
jmp 0x7b7b
movq %rax, %rbx
callq 0x55f0
jmp 0x7b7e
jmp 0x7b7b
movq %rax, %rbx
callq 0x55f0
jmp 0x7b7e
movq %rax, %rdi
callq 0x122b7
nop
// File: /workspace/github_cpp_makefile_star2_O2/ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::detail::decomp_assert(doctest::assertType::Enum, char const*, int, char const*, doctest::detail::Result)
bool decomp_assert(assertType::Enum at, const char* file, int line, const char* expr,
                       Result result) {
        bool failed = !result.m_passed;

        // ###################################################################################
        // IF THE DEBUGGER BREAKS HERE - GO 1 LEVEL UP IN THE CALLSTACK FOR THE FAILING ASSERT
        // THIS IS THE EFFECT OF HAVING 'DOCTEST_CONFIG_SUPER_FAST_ASSERTS' DEFINED
        // ###################################################################################
        DOCTEST_ASSERT_OUT_OF_TESTS(result.m_decomp);
        DOCTEST_ASSERT_IN_TESTS(result.m_decomp);
        // NOLINTNEXTLINE(clang-analyzer-cplusplus.NewDeleteLeaks)
        return !failed;
    }

// Assembly:
pushq %rbp
pushq %rbx
subq $0x78, %rsp
movl %edi, %ebp
movb (%r8), %bl
movl %ebx, %eax
xorb $0x1, %al
cmpb $0x0, 0x1c515(%rip)     # 0x243d5
je 0x7f61
xorl %r9d, %r9d
movb %r9b, 0x30(%rsp)
movw $0x17, 0x47(%rsp)
movb $0x17, 0x5f(%rsp)
movq 0x1c4f7(%rip), %rdi     # 0x243d8
movq 0x20(%rdi), %r10
movq %r10, (%rsp)
movl %ebp, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
movl %edx, 0x18(%rsp)
movq %rcx, 0x20(%rsp)
movb %r9b, 0x29(%rsp)
movb %r9b, 0x60(%rsp)
leaq 0xf715(%rip), %rcx      # 0x17621
movq %rcx, 0x68(%rsp)
movq %rcx, 0x70(%rsp)
movb %al, 0x28(%rsp)
testb %bl, %bl
je 0x7f24
cmpb $0x1, 0x6c(%rdi)
jne 0x7f35
leaq 0x48(%rsp), %rdi
addq $0x8, %r8
movq %r8, %rsi
callq 0x5f2c
movq %rsp, %rdi
callq 0x7c5c
testb %al, %al
je 0x7f42
int3
cmpb $0x1, 0x28(%rsp)
jne 0x7fec
movl %ebp, %edi
callq 0x6f80
testb %al, %al
je 0x7fec
callq 0x6fc9
testb %bl, %bl
jne 0x7ff4
xorl %r9d, %r9d
leaq 0x48(%rsp), %rdi
movb %r9b, -0x18(%rdi)
movw $0x17, -0x1(%rdi)
movb $0x17, 0x17(%rdi)
movq 0x1c452(%rip), %r10     # 0x243d8
movq 0x20(%r10), %r10
movq %r10, -0x48(%rdi)
movl %ebp, -0x40(%rdi)
movq %rsi, -0x38(%rdi)
movl %edx, -0x30(%rdi)
movq %rcx, -0x28(%rdi)
movb %r9b, -0x1f(%rdi)
movb %r9b, 0x18(%rdi)
leaq 0xf676(%rip), %rcx      # 0x17621
movq %rcx, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
movb %al, -0x20(%rdi)
addq $0x8, %r8
movq %r8, %rsi
callq 0x5f2c
movq %rsp, %rdi
callq 0x7e74
callq 0x76ec
testb %al, %al
je 0x7fe1
movq 0x1c3fe(%rip), %rax     # 0x243d8
cmpb $0x0, 0x79(%rax)
jne 0x7fe1
int3
movl %ebp, %edi
callq 0x6f80
testb %al, %al
jne 0x7ffd
movq %rsp, %rdi
callq 0x123a4
movl %ebx, %eax
addq $0x78, %rsp
popq %rbx
popq %rbp
retq
callq 0x6fc9
jmp 0x8004
movq %rax, %rbx
movq %rsp, %rdi
callq 0x123a4
movq %rbx, %rdi
callq 0x5670
nop
// File: /workspace/github_cpp_makefile_star2_O2/ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::detail::MessageBuilder::MessageBuilder(char const*, int, doctest::assertType::Enum)
MessageBuilder::MessageBuilder(const char* file, int line, assertType::Enum severity) {
        m_stream   = tlssPush();
        m_file     = file;
        m_line     = line;
        m_severity = severity;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
xorl %eax, %eax
movb %al, (%rdi)
movb $0x17, 0x17(%rdi)
movb %al, 0x30(%rdi)
callq 0x5cb1
movq %rax, 0x28(%rbx)
movq %r15, 0x18(%rbx)
movl %r14d, 0x20(%rbx)
movl %ebp, 0x24(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x5e96
movq %r14, %rdi
callq 0x5670
nop
// File: /workspace/github_cpp_makefile_star2_O2/ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::detail::MessageBuilder::log()
bool MessageBuilder::log() {
        if (!logged) {
            m_string = tlssPop();
            logged = true;
        }
        
        DOCTEST_ITERATE_THROUGH_REPORTERS(log_message, *this);

        const bool isWarn = m_severity & assertType::is_warn;

        // warn is just a message in this context so we don't treat it as an assert
        if(!isWarn) {
            addAssert(m_severity);
            addFailedAssert(m_severity);
        }

        return isDebuggerActive() && !getContextOptions()->no_breaks && !isWarn &&
            (g_cs->currentTest == nullptr || !g_cs->currentTest->m_no_breaks); // break into debugger
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
cmpb $0x0, 0x30(%rdi)
jne 0x80e5
movq %rsp, %r14
movq %r14, %rdi
callq 0x5cfb
movq %rbx, %rdi
movq %r14, %rsi
callq 0x60e4
movq %r14, %rdi
callq 0x5e96
movb $0x1, 0x30(%rbx)
movq 0x1c2ec(%rip), %rax     # 0x243d8
movq 0x10d0(%rax), %r14
movq 0x10d8(%rax), %r15
cmpq %r15, %r14
je 0x8111
movq (%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x50(%rax)
addq $0x8, %r14
jmp 0x80fa
movl 0x24(%rbx), %ebp
testb $0x1, %bpl
jne 0x8129
movl %ebp, %edi
callq 0x7e34
movl 0x24(%rbx), %edi
callq 0x7e54
callq 0x76ec
testb %al, %al
je 0x8157
xorl %eax, %eax
testb $0x1, %bpl
jne 0x8159
movq 0x1c297(%rip), %rcx     # 0x243d8
cmpb $0x0, 0x79(%rcx)
jne 0x8159
movq 0x20(%rcx), %rax
testq %rax, %rax
je 0x8164
movb 0x39(%rax), %al
xorb $0x1, %al
jmp 0x8159
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, %al
jmp 0x8159
// File: /workspace/github_cpp_makefile_star2_O2/ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::(anonymous namespace)::parseOption(int, char const* const*, char const*, doctest::String*, doctest::String const&)
bool parseOption(int argc, const char* const* argv, const char* pattern, String* value = nullptr,
                     const String& defaultVal = String()) {
        if(value)
            *value = defaultVal;
#ifndef DOCTEST_CONFIG_NO_UNPREFIXED_OPTIONS
        // offset (normally 3 for "dt-") to skip prefix
        if(parseOptionImpl(argc, argv, pattern + strlen(DOCTEST_CONFIG_OPTIONS_PREFIX), value))
            return true;
#endif // DOCTEST_CONFIG_NO_UNPREFIXED_OPTIONS
        return parseOptionImpl(argc, argv, pattern, value);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %ebp
testq %rcx, %rcx
je 0x9766
movq %rbx, %rdi
movq %r8, %rsi
callq 0x5f2c
leaq 0x3(%r14), %rdx
movl %ebp, %edi
movq %r15, %rsi
movq %rbx, %rcx
callq 0xbdd6
testb %al, %al
je 0x9788
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %ebp, %edi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xbdd6
// File: /workspace/github_cpp_makefile_star2_O2/ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::(anonymous namespace)::parseIntOption(int, char const* const*, char const*, doctest::(anonymous namespace)::optionType, int&)
bool parseIntOption(int argc, const char* const* argv, const char* pattern, optionType type,
                        int& res) {
        String parsedValue;
        if(!parseOption(argc, argv, pattern, &parsedValue))
            return false;

        if(type == 0) {
            // boolean
            const char positive[][5] = {"1", "true", "on", "yes"};  // 5 - strlen("true") + 1
            const char negative[][6] = {"0", "false", "off", "no"}; // 6 - strlen("false") + 1

            // if the value matches any of the positive/negative possibilities
            for(unsigned i = 0; i < 4; i++) {
                if(parsedValue.compare(positive[i], true) == 0) {
                    res = 1; //!OCLINT parameter reassignment
                    return true;
                }
                if(parsedValue.compare(negative[i], true) == 0) {
                    res = 0; //!OCLINT parameter reassignment
                    return true;
                }
            }
        } else {
            // integer
            // TODO: change this to use std::stoi or something else! currently it uses undefined behavior - assumes '0' on failed parse...
            int theInt = std::atoi(parsedValue.c_str()); // NOLINT
            if(theInt != 0) {
                res = theInt; //!OCLINT parameter reassignment
                return true;
            }
        }
        return false;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %rbx
movl %ecx, %ebp
xorl %eax, %eax
leaq 0x8(%rsp), %r14
movb %al, (%r14)
movb $0x17, %cl
movb %cl, 0x17(%r14)
leaq 0x20(%rsp), %r8
movb %al, (%r8)
movb %cl, 0x17(%r8)
movq %r14, %rcx
callq 0x9744
movl %eax, %r15d
leaq 0x20(%rsp), %rdi
callq 0x5e96
testb %r15b, %r15b
je 0x9809
testl %ebp, %ebp
je 0x980d
cmpb $0x0, 0x1f(%rsp)
jns 0x97fb
movq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x5590
movl %eax, %ebp
testl %eax, %eax
jne 0x9867
xorl %ebx, %ebx
jmp 0x986b
movq %rbx, (%rsp)
leaq 0xd888(%rip), %r14      # 0x170a0
xorl %r12d, %r12d
leaq 0x8(%rsp), %r15
pushq $0x1
popq %rbp
leaq 0xd896(%rip), %r13      # 0x170c0
leaq 0x6(%r12), %rbx
cmpq $0x1e, %rbx
je 0x9809
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x615a
testl %eax, %eax
je 0x9863
addq $0x5, %r14
addq %r13, %r12
movq %r15, %rdi
movq %r12, %rsi
movl %ebp, %edx
callq 0x615a
movq %rbx, %r12
testl %eax, %eax
jne 0x982a
xorl %ebp, %ebp
movq (%rsp), %rbx
movl %ebp, (%rbx)
movb $0x1, %bl
leaq 0x8(%rsp), %rdi
callq 0x5e96
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x5e96
leaq 0x8(%rsp), %rdi
callq 0x5e96
movq %rbx, %rdi
callq 0x5670
// File: /workspace/github_cpp_makefile_star2_O2/ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::(anonymous namespace)::fileOrderComparator(doctest::detail::TestCase const*, doctest::detail::TestCase const*)
bool fileOrderComparator(const TestCase* lhs, const TestCase* rhs) {
        // this is needed because MSVC gives different case for drive letters
        // for __FILE__ when evaluated in a header and a source file
        const int res = lhs->m_file.compare(rhs->m_file, bool(DOCTEST_MSVC));
        if(res != 0)
            return res < 0;
        if(lhs->m_line != rhs->m_line)
            return lhs->m_line < rhs->m_line;
        return lhs->m_template_id < rhs->m_template_id;
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %edx, %edx
callq 0x61c0
testl %eax, %eax
je 0xa8d1
shrl $0x1f, %eax
jmp 0xa8e9
movl 0x18(%rbx), %eax
cmpl %eax, 0x18(%r14)
jne 0xa8e6
movl 0x60(%r14), %eax
cmpl 0x60(%rbx), %eax
setl %al
jmp 0xa8e9
setb %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::(anonymous namespace)::suiteOrderComparator(doctest::detail::TestCase const*, doctest::detail::TestCase const*)
bool suiteOrderComparator(const TestCase* lhs, const TestCase* rhs) {
        const int res = std::strcmp(lhs->m_test_suite, rhs->m_test_suite);
        if(res != 0)
            return res < 0;
        return fileOrderComparator(lhs, rhs);
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x28(%rdi), %rdi
movq 0x28(%rsi), %rsi
callq 0x5510
testl %eax, %eax
je 0xa917
shrl $0x1f, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xa8b7
// File: /workspace/github_cpp_makefile_star2_O2/ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::(anonymous namespace)::nameOrderComparator(doctest::detail::TestCase const*, doctest::detail::TestCase const*)
bool nameOrderComparator(const TestCase* lhs, const TestCase* rhs) {
        const int res = std::strcmp(lhs->m_name, rhs->m_name);
        if(res != 0)
            return res < 0;
        return suiteOrderComparator(lhs, rhs);
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rdi), %rdi
movq 0x20(%rsi), %rsi
callq 0x5510
testl %eax, %eax
je 0xa94c
shrl $0x1f, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xa8f1
nop
// File: /workspace/github_cpp_makefile_star2_O2/ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::(anonymous namespace)::FatalConditionHandler::reset()
static void reset() {
            if(isSet) {
                // Set signals back to previous values -- hopefully nobody overwrote them in the meantime
                for(std::size_t i = 0; i < DOCTEST_COUNTOF(signalDefs); ++i) {
                    sigaction(signalDefs[i].id, &oldSigActions[i], nullptr);
                }
                // Return the old stack
                sigaltstack(&oldSigStack, nullptr);
                isSet = false;
            }
        }

// Assembly:
cmpb $0x1, 0x1a0ed(%rip)     # 0x24a50
jne 0xa9b6
pushq %r15
pushq %r14
pushq %rbx
leaq 0x1a0ff(%rip), %rbx     # 0x24a70
xorl %r14d, %r14d
leaq 0x18ed5(%rip), %r15     # 0x23850
cmpq $0x60, %r14
je 0xa99c
movl (%r14,%r15), %edi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x5490
addq $0x10, %r14
addq $0x98, %rbx
jmp 0xa97b
leaq 0x1a0b5(%rip), %rdi     # 0x24a58
xorl %esi, %esi
callq 0x56c0
movb $0x0, 0x1a09f(%rip)     # 0x24a50
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::detail::registerReporterImpl(char const*, int, doctest::IReporter* (*)(doctest::ContextOptions const&), bool)
void registerReporterImpl(const char* name, int priority, reporterCreatorFunc c, bool isReporter) {
        if(isReporter)
            getReporters().insert(reporterMap::value_type(reporterMap::key_type(priority, name), c));
        else
            getListeners().insert(reporterMap::value_type(reporterMap::key_type(priority, name), c));
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r15
testl %ecx, %ecx
je 0xaaac
callq 0xa72a
leaq 0x30(%rsp), %r14
movl %ebp, -0x8(%r14)
movq %r14, %rdi
movq %r15, %rsi
callq 0x5eaa
movl -0x8(%r14), %eax
leaq 0x8(%rsp), %r15
movl %eax, -0x8(%r15)
movups (%r14), %xmm0
movups %xmm0, (%r15)
movq 0x10(%r14), %rax
movq %rax, 0x10(%r15)
movb $0x0, (%r14)
movb $0x17, 0x17(%r14)
movq %rbx, 0x18(%r15)
leaq 0x19f3e(%rip), %rdi     # 0x249e0
movq %rsp, %rsi
callq 0x15462
jmp 0xaafe
callq 0xa79a
leaq 0x30(%rsp), %r14
movl %ebp, -0x8(%r14)
movq %r14, %rdi
movq %r15, %rsi
callq 0x5eaa
movl -0x8(%r14), %eax
leaq 0x8(%rsp), %r15
movl %eax, -0x8(%r15)
movups (%r14), %xmm0
movups %xmm0, (%r15)
movq 0x10(%r14), %rax
movq %rax, 0x10(%r15)
movb $0x0, (%r14)
movb $0x17, 0x17(%r14)
movq %rbx, 0x18(%r15)
leaq 0x19f22(%rip), %rdi     # 0x24a18
movq %rsp, %rsi
callq 0x15462
movq %r15, %rdi
callq 0x5e96
movq %r14, %rdi
callq 0x5e96
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0xab1b
movq %rax, %rbx
movq %r15, %rdi
callq 0x5e96
movq %r14, %rdi
callq 0x5e96
movq %rbx, %rdi
callq 0x5670
// File: /workspace/github_cpp_makefile_star2_O2/ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::(anonymous namespace)::parseOptionImpl(int, char const* const*, char const*, doctest::String*)
bool parseOptionImpl(int argc, const char* const* argv, const char* pattern, String* value) {
        // going from the end to the beginning and stopping on the first occurrence from the end
        for(int i = argc; i > 0; --i) {
            auto index = i - 1;
            auto temp = std::strstr(argv[index], pattern);
            if(temp && (value || strlen(temp) == strlen(pattern))) { //!OCLINT prefer early exits and continue
                // eliminate matches in which the chars before the option are not '-'
                bool noBadCharsFound = true;
                auto curr            = argv[index];
                while(curr != temp) {
                    if(*curr++ != '-') {
                        noBadCharsFound = false;
                        break;
                    }
                }
                if(noBadCharsFound && argv[index][0] == '-') {
                    if(value) {
                        // parsing the value of an option
                        temp += strlen(pattern);
                        const unsigned len = strlen(temp);
                        if(len) {
                            *value = temp;
                            return true;
                        }
                    } else {
                        // just a flag - no value
                        return true;
                    }
                }
            }
        }
        return false;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, 0x8(%rsp)
movl %edi, %r15d
movq %rcx, (%rsp)
testl %r15d, %r15d
setg %bpl
jle 0xbe7b
movq 0x8(%rsp), %rax
movq -0x8(%rax,%r15,8), %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x50b0
testq %rax, %rax
je 0xbe73
movq %rax, %r12
testq %rbx, %rbx
jne 0xbe3d
movq %r12, %rdi
callq 0x5190
movq %rax, %rbx
movq %r14, %rdi
callq 0x5190
cmpq %rax, %rbx
movq (%rsp), %rbx
jne 0xbe73
movq %r13, %rax
cmpq %r12, %rax
je 0xbe50
cmpb $0x2d, (%rax)
leaq 0x1(%rax), %rax
je 0xbe40
jmp 0xbe73
cmpb $0x2d, (%r13)
jne 0xbe73
testq %rbx, %rbx
je 0xbe7d
movq %r14, %rdi
callq 0x5190
addq %rax, %r12
movq %r12, %rdi
callq 0x5190
testl %eax, %eax
jne 0xbe8e
decq %r15
jmp 0xbdf6
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %r14
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x5eaa
movq %r14, %rdi
movq %rbx, %rsi
callq 0x60e4
movq %rbx, %rdi
callq 0x5e96
movb $0x1, %bpl
jmp 0xbe7d
nop
// File: /workspace/github_cpp_makefile_star2_O2/ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::(anonymous namespace)::FatalConditionHandler::handleSignal(int)
static void handleSignal(int sig) {
            const char* name = "<unknown signal>";
            for(std::size_t i = 0; i < DOCTEST_COUNTOF(signalDefs); ++i) {
                SignalDefs& def = signalDefs[i];
                if(sig == def.id) {
                    name = def.name;
                    break;
                }
            }
            reset();
            reportFatal(name);
            raise(sig);
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movl %edi, %ebx
xorl %eax, %eax
leaq 0xbe76(%rip), %r14      # 0x17d48
leaq 0x17977(%rip), %rcx     # 0x23850
leaq 0x10(%rax), %rdx
cmpq $0x70, %rdx
je 0xbef0
cmpl %ebx, (%rax,%rcx)
movq %rdx, %rax
jne 0xbed9
movq -0x8(%rdx,%rcx), %r14
callq 0xa95c
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %r14, %rsi
callq 0x12d1a
movq 0x184ca(%rip), %rax     # 0x243d8
orl $0x4, 0xb0(%rax)
movq 0x10d0(%rax), %r12
movq 0x10d8(%rax), %r13
leaq 0x30(%rsp), %r14
cmpq %r13, %r12
je 0xbf92
movq (%r12), %r15
movq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x5eaa
movb $0x1, 0x48(%rsp)
movq (%r15), %rax
movq %r15, %rdi
movq %r14, %rsi
callq *0x30(%rax)
movq %r14, %rdi
callq 0x5e96
addq $0x8, %r12
jmp 0xbf28
addq $0x1110, %rdi           # imm = 0x1110
callq 0x12310
movq 0x18468(%rip), %rax     # 0x243d8
movq 0x10d0(%rax), %r14
movq 0x10d8(%rax), %r15
cmpq %r15, %r14
je 0xbf92
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
addq $0x8, %r14
jmp 0xbf7e
movq 0x1843f(%rip), %rdi     # 0x243d8
movq 0x1118(%rdi), %rax
cmpq 0x1110(%rdi), %rax
jne 0xbf5d
callq 0x12594
movq 0x18423(%rip), %rax     # 0x243d8
movq 0x10d0(%rax), %r14
movq 0x10d8(%rax), %r15
movl $0xa0, %r12d
cmpq %r15, %r14
je 0xbfe7
movq (%r14), %rdi
movq 0x18400(%rip), %rsi     # 0x243d8
addq %r12, %rsi
movq (%rdi), %rax
callq *0x28(%rax)
addq $0x8, %r14
jmp 0xbfc9
movq 0x183ea(%rip), %rax     # 0x243d8
movq 0x10d0(%rax), %r14
movq 0x10d8(%rax), %r15
movl $0x88, %r12d
cmpq %r15, %r14
je 0xc020
movq (%r14), %rdi
movq 0x183c7(%rip), %rsi     # 0x243d8
addq %r12, %rsi
movq (%rdi), %rax
callq *0x10(%rax)
addq $0x8, %r14
jmp 0xc002
leaq 0x10(%rsp), %rdi
callq 0x51a0
movl %ebx, %edi
callq 0x53f0
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0xc056
jmp 0xc056
jmp 0xc056
jmp 0xc056
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x5e96
jmp 0xc059
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x51a0
movq %rbx, %rdi
callq 0x5670
nop
// File: /workspace/github_cpp_makefile_star2_O2/ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::(anonymous namespace)::XmlReporter::test_case_end(doctest::CurrentTestCaseStats const&)
void test_case_end(const CurrentTestCaseStats& st) override {
            xml.startElement("OverallResultsAsserts")
                    .writeAttribute("successes",
                                    st.numAssertsCurrentTest - st.numAssertsFailedCurrentTest)
                    .writeAttribute("failures", st.numAssertsFailedCurrentTest)
                    .writeAttribute("test_case_success", st.testCaseSuccess);
            if(opt.duration)
                xml.writeAttribute("duration", st.seconds);
            if(tc->m_expected_failures)
                xml.writeAttribute("expected_failures", tc->m_expected_failures);
            xml.endElement();

            xml.endElement();
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq 0xaf6f(%rip), %rsi      # 0x17ff6
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x12d1a
leaq 0x8(%r14), %rbx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xdd82
leaq 0xaf5e(%rip), %rsi      # 0x1800c
leaq 0x30(%rsp), %rdi
leaq 0x6(%rsp), %rdx
callq 0x12d1a
movl (%r15), %eax
subl 0x4(%r15), %eax
leaq 0x2c(%rsp), %rdx
movl %eax, (%rdx)
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
callq 0xde28
leaq 0xaf7b(%rip), %rsi      # 0x1805a
leaq 0x70(%rsp), %rdi
leaq 0x5(%rsp), %rdx
callq 0x12d1a
leaq 0x4(%r15), %rdx
leaq 0x70(%rsp), %rsi
movq %rbx, %rdi
callq 0xde28
leaq 0xaf39(%rip), %rsi      # 0x1803f
leaq 0x50(%rsp), %rdi
leaq 0x4(%rsp), %rdx
callq 0x12d1a
movzbl 0x14(%r15), %edx
leaq 0x50(%rsp), %rsi
movq %rbx, %rdi
callq 0xe430
leaq 0x50(%rsp), %rdi
callq 0x51a0
leaq 0x70(%rsp), %rdi
callq 0x51a0
leaq 0x30(%rsp), %rdi
callq 0x51a0
leaq 0x8(%rsp), %rdi
callq 0x51a0
movq 0x78(%r14), %rax
cmpb $0x1, 0x6f(%rax)
jne 0xd18d
leaq 0xa6d1(%rip), %rsi      # 0x17831
leaq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0x12d1a
addq $0x8, %r15
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0xe7a8
leaq 0x8(%rsp), %rdi
callq 0x51a0
movq 0x80(%r14), %rax
cmpl $0x0, 0x40(%rax)
je 0xd1d2
leaq 0xaeb0(%rip), %rsi      # 0x18051
leaq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0x12d1a
movq 0x80(%r14), %rdx
addq $0x40, %rdx
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xde28
leaq 0x8(%rsp), %rdi
callq 0x51a0
movq %rbx, %rdi
callq 0xdcd2
movq %rbx, %rdi
callq 0xdcd2
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0xd22a
jmp 0xd239
jmp 0xd22a
jmp 0xd239
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x51a0
jmp 0xd20b
jmp 0xd208
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x51a0
jmp 0xd21c
jmp 0xd219
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x51a0
jmp 0xd22d
jmp 0xd22a
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x51a0
jmp 0xd23c
movq %rax, %rbx
movq %rbx, %rdi
callq 0x5670