LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/kipa00[P]AplusB-mc/compiler/color.cpp
// Function: color_to_int(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int color_to_int(string s) {
	if (s == "white") return 0;
	else if (s == "orange") return 1;
	else if (s == "magenta") return 2;
	else if (s == "light_blue") return 3;
	else if (s == "yellow") return 4;
	else if (s == "lime") return 5;
	else if (s == "pink") return 6;
	else if (s == "gray") return 7;
	else if (s == "light_gray") return 8;
	else if (s == "cyan") return 9;
	else if (s == "purple") return 10;
	else if (s == "blue") return 11;
	else if (s == "brown") return 12;
	else if (s == "green") return 13;
	else if (s == "red") return 14;
	else if (s == "black") return 15;
	return -1;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0xfd1(%rip), %rsi       # 0x8c54
callq 0x2050
testl %eax, %eax
je 0x7dea
leaq 0xfc3(%rip), %rsi       # 0x8c5a
movq %rbx, %rdi
callq 0x2050
testl %eax, %eax
je 0x7dee
leaq 0xfb3(%rip), %rsi       # 0x8c61
movq %rbx, %rdi
callq 0x2050
testl %eax, %eax
je 0x7df5
leaq 0xfa4(%rip), %rsi       # 0x8c69
movq %rbx, %rdi
callq 0x2050
testl %eax, %eax
je 0x7dfc
leaq 0xf98(%rip), %rsi       # 0x8c74
movq %rbx, %rdi
callq 0x2050
testl %eax, %eax
je 0x7e03
leaq 0xf88(%rip), %rsi       # 0x8c7b
movq %rbx, %rdi
callq 0x2050
testl %eax, %eax
je 0x7e0a
leaq 0xf76(%rip), %rsi       # 0x8c80
movq %rbx, %rdi
callq 0x2050
testl %eax, %eax
je 0x7e11
leaq 0xf6a(%rip), %rsi       # 0x8c8b
movq %rbx, %rdi
callq 0x2050
testl %eax, %eax
je 0x7e18
leaq 0xf4d(%rip), %rsi       # 0x8c85
movq %rbx, %rdi
callq 0x2050
testl %eax, %eax
je 0x7e1f
leaq 0xf41(%rip), %rsi       # 0x8c90
movq %rbx, %rdi
callq 0x2050
testl %eax, %eax
je 0x7e26
leaq 0xf2f(%rip), %rsi       # 0x8c95
movq %rbx, %rdi
callq 0x2050
testl %eax, %eax
je 0x7e2d
leaq 0xef2(%rip), %rsi       # 0x8c6f
movq %rbx, %rdi
callq 0x2050
testl %eax, %eax
je 0x7e34
leaq 0xf08(%rip), %rsi       # 0x8c9c
movq %rbx, %rdi
callq 0x2050
testl %eax, %eax
je 0x7e3b
leaq 0xef7(%rip), %rsi       # 0x8ca2
movq %rbx, %rdi
callq 0x2050
testl %eax, %eax
je 0x7e42
leaq 0x730(%rip), %rsi       # 0x84f2
movq %rbx, %rdi
callq 0x2050
testl %eax, %eax
je 0x7e49
leaq 0xed3(%rip), %rsi       # 0x8ca8
movq %rbx, %rdi
callq 0x2050
movl %eax, %ecx
xorl %eax, %eax
negl %ecx
sbbl %eax, %eax
orl $0xf, %eax
jmp 0x7e4e
xorl %eax, %eax
jmp 0x7e4e
movl $0x1, %eax
jmp 0x7e4e
movl $0x2, %eax
jmp 0x7e4e
movl $0x3, %eax
jmp 0x7e4e
movl $0x4, %eax
jmp 0x7e4e
movl $0x5, %eax
jmp 0x7e4e
movl $0x6, %eax
jmp 0x7e4e
movl $0x7, %eax
jmp 0x7e4e
movl $0x8, %eax
jmp 0x7e4e
movl $0x9, %eax
jmp 0x7e4e
movl $0xa, %eax
jmp 0x7e4e
movl $0xb, %eax
jmp 0x7e4e
movl $0xc, %eax
jmp 0x7e4e
movl $0xd, %eax
jmp 0x7e4e
movl $0xe, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/smuething[P]dune-cxx11/17-unique_ptr.cc
// Function: main
int main()
{
  std::shared_ptr<int> p1(new int(3));
  std::shared_ptr<int> p2(std::move(p1));
  assert(*p2 == 3);
  return 0;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl $0x4, %edi
callq 0x1060
movl $0x3, (%rax)
leaq 0x8(%rsp), %rbx
movq %rax, -0x8(%rbx)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x12a2
movq -0x8(%rbx), %rax
movq (%rbx), %rdi
xorps %xmm0, %xmm0
movaps %xmm0, -0x8(%rbx)
cmpl $0x3, (%rax)
jne 0x1209
testq %rdi, %rdi
je 0x1201
callq 0x1228
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x1201
callq 0x1228
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
leaq 0xdf4(%rip), %rdi       # 0x2004
leaq 0xdf6(%rip), %rsi       # 0x200d
leaq 0xe00(%rip), %rcx       # 0x201e
movl $0x8, %edx
callq 0x1050
// File: /workspace/github_cpp_makefile_star2_O3/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 0x613d
movq %rax, %r15
leaq 0x15252(%rip), %rsi     # 0x1b2f8
movl $0x2, %edx
movq %rax, %rdi
callq 0x5410
movq (%r15), %rax
movq -0x18(%rax), %rcx
leaq (%r15,%rcx), %r12
cmpb $0x0, 0xe1(%r15,%rcx)
jne 0x60e2
movq %r12, %rdi
movl $0x20, %esi
callq 0x5390
movb $0x1, 0xe1(%r12)
movq (%r15), %rax
movb $0x30, 0xe0(%r12)
movq -0x18(%rax), %rax
movl 0x18(%r15,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x18(%r15,%rax)
testl %ebp, %ebp
je 0x6129
movslq %ebp, %r12
movq (%r15), %rax
movq -0x18(%rax), %rax
movq $0x2, 0x10(%r15,%rax)
movzbl -0x1(%r14,%r12), %esi
movq %r15, %rdi
callq 0x5250
decq %r12
jne 0x6106
movq %rbx, %rdi
callq 0x61af
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::detail::$_0::~$_0()
DOCTEST_THREAD_LOCAL class
    {
        std::vector<std::streampos> stack;
        std::stringstream           ss;

    public:
        std::ostream* push() {
            stack.push_back(ss.tellp());
            return &ss;
        }

// Assembly:
pushq %rbx
movq %rdi, %rbx
addq $0x18, %rdi
movq 0x1fcf7(%rip), %rsi     # 0x25f90
callq 0x52c0
leaq 0x98(%rbx), %rdi
callq 0x5120
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x62bf
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
popq %rbx
jmp 0x53d0
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6356
movq 0x10(%rbx), %rax
movq %rax, 0x10(%rdi)
movups (%rbx), %xmm0
movups %xmm0, (%rdi)
popq %rbx
retq
movl 0x8(%rbx), %esi
callq 0x62e4
movq (%rbx), %rsi
movl 0x8(%rbx), %edx
movq %rax, %rdi
popq %rbx
jmp 0x5300
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x648d
movq %rsi, %r14
cmpb $0x0, 0x17(%rbx)
jns 0x645a
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x645a
callq 0x5480
cmpb $0x0, 0x17(%r14)
js 0x6472
movq 0x10(%r14), %rax
movq %rax, 0x10(%rbx)
movups (%r14), %xmm0
movups %xmm0, (%rbx)
jmp 0x648d
movl 0x8(%r14), %esi
movq %rbx, %rdi
callq 0x62e4
movq (%r14), %rsi
movl 0x8(%r14), %edx
movq %rax, %rdi
callq 0x5300
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6658
movq %rsi, %r14
cmpb $0x0, 0x17(%rbx)
jns 0x6640
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x6640
callq 0x5480
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_O3/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:
movb $0x1, %al
testb $0x4, %dil
jne 0x7c3a
testb $0x2, %dil
je 0x7c38
movq 0x1e7b6(%rip), %rcx     # 0x263b8
cmpl $0x0, 0x64(%rcx)
jle 0x7c38
movl 0x9c(%rcx), %esi
xorl %edx, %edx
xorl %edi, %edi
movl 0x8b8(%rcx,%rdi), %r8d
addl %r8d, %edx
addq $0x40, %rdi
cmpq $0x800, %rdi            # imm = 0x800
jne 0x7c12
addl %esi, %edx
movq 0x1e785(%rip), %rcx     # 0x263b8
cmpl 0x64(%rcx), %edx
jge 0x7c3a
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x80e5
movq 0x1e3ec(%rip), %r14     # 0x263b8
cmpb $0x0, 0x115c(%r14)
jne 0x7ff3
leaq 0x1128(%r14), %rdi
addq $0x1110, %r14           # imm = 0x1110
movq %r14, %rsi
callq 0x17638
movq 0x1e3c5(%rip), %r14     # 0x263b8
movq 0x1118(%r14), %rcx
leaq -0x28(%rcx), %rax
movq %rax, 0x1118(%r14)
cmpb $0x0, -0x11(%rcx)
jns 0x801f
movq (%rax), %rdi
testq %rdi, %rdi
je 0x801f
callq 0x5480
movq 0x1e399(%rip), %r14     # 0x263b8
callq 0x5440
testl %eax, %eax
jle 0x80c3
movb 0x115d(%r14), %al
movq 0x1e37e(%rip), %r14     # 0x263b8
testb $0x1, %al
je 0x80c3
movq 0x10d0(%r14), %r13
movq 0x10d8(%r14), %rbp
cmpq %rbp, %r13
je 0x80ba
leaq 0x8(%rsp), %r14
leaq 0x13508(%rip), %r15     # 0x1b569
movq (%r13), %r12
movq %r14, %rdi
movl $0x91, %esi
callq 0x62e4
movl $0x91, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x5300
movb $0x0, 0x20(%rsp)
movq (%r12), %rax
movq %r12, %rdi
movq %r14, %rsi
callq *0x30(%rax)
cmpb $0x0, 0x1f(%rsp)
jns 0x80aa
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x80aa
callq 0x5480
addq $0x8, %r13
cmpq %rbp, %r13
jne 0x8061
movq 0x1e2fe(%rip), %r14     # 0x263b8
xorl %eax, %eax
xchgb %al, 0x115d(%r14)
movq 0x10d0(%r14), %r15
movq 0x10d8(%r14), %r14
cmpq %r14, %r15
je 0x80e5
movq (%r15), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
addq $0x8, %r15
jmp 0x80d1
cmpb $0x0, 0x17(%rbx)
jns 0x80f8
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x80f8
callq 0x5480
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x810b
jmp 0x810b
movq %rax, %rdi
callq 0x16173
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x28, %rsp
movq %r9, 0x8(%rsp)
movq %r8, %r15
movl %ecx, %ebp
movq %rdx, %r13
movq %rsi, (%rsp)
movq %rdi, %rbx
xorl %eax, %eax
movb %al, (%rdi)
movb $0x17, %cl
movb %cl, 0x17(%rdi)
movb %al, 0x68(%rdi)
movb %cl, 0x7f(%rdi)
movq %rdx, %rdi
callq 0x5170
movq %rax, %r12
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movl %r12d, %esi
callq 0x62e4
movl %r12d, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x5300
cmpq %rbx, %r14
je 0x81d9
cmpb $0x0, 0x17(%rbx)
jns 0x81c6
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x81c6
callq 0x5480
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rbx)
movups 0x10(%rsp), %xmm0
movups %xmm0, (%rbx)
jmp 0x81ef
cmpb $0x0, 0x27(%rsp)
jns 0x81ef
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x81ef
callq 0x5480
movl %ebp, 0x18(%rbx)
movq $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 (%rsp), %rax
movq %rax, 0x50(%rbx)
movq 0x8(%rsp), %rax
movq %rax, 0x58(%rbx)
movl 0x60(%rsp), %eax
movl %eax, 0x60(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
cmpb $0x0, 0x7f(%rbx)
jns 0x8260
movq 0x68(%rbx), %rdi
testq %rdi, %rdi
je 0x8260
callq 0x5480
cmpb $0x0, 0x17(%rbx)
jns 0x8273
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x8273
callq 0x5480
movq %r14, %rdi
callq 0x5620
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6438
movups 0x18(%r15), %xmm0
movups 0x28(%r15), %xmm1
movups 0x38(%r15), %xmm2
movups %xmm0, 0x18(%rbx)
movups %xmm1, 0x28(%rbx)
movups %xmm2, 0x38(%rbx)
movq 0x48(%r15), %rax
movq %rax, 0x48(%rbx)
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 0x6438
cmpl $-0x1, 0x60(%rbx)
je 0x834e
cmpb $0x0, 0x7f(%rbx)
jns 0x834a
movq 0x68(%rbx), %r14
movq %r14, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x84d8
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rdi), %rdi
movq 0x20(%rsi), %rsi
callq 0x54d0
testl %eax, %eax
je 0x84dc
shrl $0x1f, %eax
jmp 0x8512
setb %al
retq
cmpb $0x0, 0x17(%rbx)
movq %rbx, %rsi
jns 0x84e8
movq (%rbx), %rsi
cmpb $0x0, 0x17(%r14)
movq %r14, %rdi
jns 0x84f5
movq (%r14), %rdi
callq 0x54d0
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_O3/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 0x1d331(%rip), %rax     # 0x25b30
movq %rax, (%rdi)
movb $0x1, 0x8(%rdi)
cmpb $0x1, 0x8(%rsi)
jne 0x8814
movq %r14, %rdi
callq 0x8842
movb $0x0, 0x8(%r14)
callq 0x1615c
movq %fs:0x0, %rax
leaq -0x30(%rax), %rdi
movq %rsp, %rsi
movq %rbx, (%rsi)
callq 0x17c98
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movb $0x0, (%rsp)
movb $0x17, 0x17(%rsp)
callq 0x86f2
movq 0x1df04(%rip), %r15     # 0x26998
movq 0x1df05(%rip), %r12     # 0x269a0
cmpq %r12, %r15
je 0x8abc
movq %rsp, %r14
movq (%r15), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x10(%rax)
testb %al, %al
jne 0x8ac1
addq $0x8, %r15
cmpq %r12, %r15
jne 0x8aa3
callq 0x5510
movq 0x10(%rsp), %rax
movq %rax, 0x10(%rbx)
movups (%rsp), %xmm0
movups %xmm0, (%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
cmpb $0x0, 0x17(%rsp)
jns 0x8af5
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x8af5
callq 0x5480
movq %rbx, %rdi
callq 0x5620
movq %rdx, %r14
movq %rax, %rdi
cmpl $0x4, %r14d
jne 0x8b29
callq 0x5160
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x638a
callq 0x55a0
jmp 0x8b77
cmpl $0x3, %r14d
jne 0x8b46
callq 0x5160
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x638a
callq 0x55a0
jmp 0x8b77
callq 0x5160
cmpl $0x2, %r14d
jne 0x8b63
movq %rbx, %rdi
movq %rax, %rsi
callq 0x638a
callq 0x55a0
jmp 0x8b77
leaq 0x13166(%rip), %rsi     # 0x1bcd0
movq %rbx, %rdi
callq 0x638a
callq 0x55a0
cmpb $0x0, 0x17(%rsp)
jns 0x8ad1
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x8ad1
callq 0x5480
jmp 0x8ad1
jmp 0x8add
movq %rax, %rbx
callq 0x55a0
jmp 0x8ae0
movq %rax, %rbx
callq 0x55a0
jmp 0x8ae0
jmp 0x8add
movq %rax, %rbx
callq 0x55a0
jmp 0x8ae0
jmp 0x8add
movq %rax, %rbx
callq 0x55a0
jmp 0x8ae0
movq %rax, %rdi
callq 0x16173
// File: /workspace/github_cpp_makefile_star2_O3/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, 0x1d403(%rip)     # 0x263b5
je 0x9053
xorl %r9d, %r9d
movb %r9b, 0x30(%rsp)
movw $0x17, 0x47(%rsp)
movb $0x17, 0x5f(%rsp)
movq 0x1d3e5(%rip), %rdi     # 0x263b8
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 0x1261a(%rip), %rcx     # 0x1b618
movq %rcx, 0x68(%rsp)
movq %rcx, 0x70(%rsp)
movb %al, 0x28(%rsp)
testb %bl, %bl
je 0x9016
cmpb $0x1, 0x6c(%rdi)
jne 0x9027
leaq 0x48(%rsp), %rdi
addq $0x8, %r8
movq %r8, %rsi
callq 0x6438
movq %rsp, %rdi
callq 0x8be4
testb %al, %al
je 0x9034
int3
cmpb $0x1, 0x28(%rsp)
jne 0x90ee
movl %ebp, %edi
callq 0x7bed
testb %al, %al
je 0x90ee
callq 0x7c3b
testb %bl, %bl
jne 0x911a
xorl %r9d, %r9d
leaq 0x48(%rsp), %rdi
movb %r9b, -0x18(%rdi)
movw $0x17, -0x1(%rdi)
movb $0x17, 0x17(%rdi)
movq 0x1d340(%rip), %r10     # 0x263b8
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 0x1257b(%rip), %rcx     # 0x1b618
movq %rcx, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
movb %al, -0x20(%rdi)
addq $0x8, %r8
movq %r8, %rsi
callq 0x6438
movq 0x1d2fd(%rip), %rax     # 0x263b8
movq 0x10e8(%rax), %rax
testq %rax, %rax
je 0x9123
movq %rsp, %rdi
callq *%rax
callq 0x8554
testb %al, %al
je 0x90e3
movq 0x1d2dc(%rip), %rax     # 0x263b8
cmpb $0x0, 0x79(%rax)
jne 0x90e3
int3
movl %ebp, %edi
callq 0x7bed
testb %al, %al
jne 0x9128
cmpb $0x0, 0x5f(%rsp)
jns 0x9104
movq 0x48(%rsp), %rdi
testq %rdi, %rdi
je 0x9104
callq 0x5480
cmpb $0x0, 0x47(%rsp)
jns 0x911a
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0x911a
callq 0x5480
movl %ebx, %eax
addq $0x78, %rsp
popq %rbx
popq %rbp
retq
callq 0x5200
callq 0x7c3b
jmp 0x912f
movq %rax, %rbx
movq %rsp, %rdi
callq 0x16226
movq %rbx, %rdi
callq 0x5620
// File: /workspace/github_cpp_makefile_star2_O3/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 0x613d
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
cmpb $0x0, 0x17(%rbx)
jns 0x9194
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x9194
callq 0x5480
movq %r14, %rdi
callq 0x5620
// File: /workspace/github_cpp_makefile_star2_O3/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 0x925d
movq %rsp, %r14
movq %r14, %rdi
callq 0x61af
cmpq %rbx, %r14
je 0x9244
cmpb $0x0, 0x17(%rbx)
jns 0x9232
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x9232
callq 0x5480
movq 0x10(%rsp), %rax
movq %rax, 0x10(%rbx)
movups (%rsp), %xmm0
movups %xmm0, (%rbx)
jmp 0x9259
cmpb $0x0, 0x17(%rsp)
jns 0x9259
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x9259
callq 0x5480
movb $0x1, 0x30(%rbx)
movq 0x1d154(%rip), %rax     # 0x263b8
movq 0x10d0(%rax), %r14
movq 0x10d8(%rax), %r15
cmpq %r15, %r14
je 0x9289
movq (%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x50(%rax)
addq $0x8, %r14
jmp 0x9272
movl 0x24(%rbx), %ebp
testb $0x1, %bpl
jne 0x92e8
movl $0xb8, %eax
addq 0x1d11a(%rip), %rax     # 0x263b8
cmpb $0x0, %fs:-0x8
je 0x9327
movq %fs:-0x10, %rcx
shlq $0x6, %rcx
lock
incl (%rax,%rcx)
testb $0x1, 0x24(%rbx)
jne 0x92e8
movl $0x8b8, %eax            # imm = 0x8B8
addq 0x1d0ec(%rip), %rax     # 0x263b8
cmpb $0x0, %fs:-0x8
je 0x934f
movq %fs:-0x10, %rcx
shlq $0x6, %rcx
lock
incl (%rax,%rcx)
callq 0x8554
testb %al, %al
je 0x9316
xorl %eax, %eax
testb $0x1, %bpl
jne 0x9318
movq 0x1d0b8(%rip), %rcx     # 0x263b8
cmpb $0x0, 0x79(%rcx)
jne 0x9318
movq 0x20(%rcx), %rax
testq %rax, %rax
je 0x9323
movb 0x39(%rax), %al
xorb $0x1, %al
jmp 0x9318
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, %al
jmp 0x9318
movl $0x1, %ecx
lock
xaddq %rcx, 0x1daab(%rip)     # 0x26de0
andl $0x1f, %ecx
movq %rcx, %fs:-0x10
movb $0x1, %fs:-0x8
jmp 0x92b2
movl $0x1, %ecx
lock
xaddq %rcx, 0x1da83(%rip)     # 0x26de0
andl $0x1f, %ecx
movq %rcx, %fs:-0x10
movb $0x1, %fs:-0x8
jmp 0x92e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xac02
movq %rbx, %rdi
movq %r8, %rsi
callq 0x6438
leaq 0x3(%r14), %rdx
movl %ebp, %edi
movq %r15, %rsi
movq %rbx, %rcx
jmp 0xac0d
leaq 0x3(%r14), %rdx
movl %ebp, %edi
movq %r15, %rsi
xorl %ecx, %ecx
callq 0xdb1d
testb %al, %al
je 0xac23
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 0xdb1d
// File: /workspace/github_cpp_makefile_star2_O3/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 0xabd2
movl %eax, %r15d
cmpb $0x0, 0x37(%rsp)
jns 0xac8d
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0xac8d
callq 0x5480
testb %r15b, %r15b
je 0xad04
testl %ebp, %ebp
je 0xacb2
cmpb $0x0, 0x1f(%rsp)
jns 0xaca2
movq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x5550
movl %eax, %ebp
testl %eax, %eax
jne 0xad0a
jmp 0xad04
leaq 0x103e7(%rip), %r14     # 0x1b0a0
xorl %r12d, %r12d
leaq 0x8(%rsp), %r15
leaq 0x103f8(%rip), %r13     # 0x1b0c0
movl $0x1, %ebp
movq %r15, %rdi
movq %r14, %rsi
movl $0x1, %edx
callq 0x6696
testl %eax, %eax
je 0xad0a
leaq (%r12,%r13), %rsi
movq %r15, %rdi
movl $0x1, %edx
callq 0x6696
testl %eax, %eax
je 0xad08
addq $0x5, %r14
addq $0x6, %r12
cmpq $0x18, %r12
jne 0xaccd
xorl %ebx, %ebx
jmp 0xad0e
xorl %ebp, %ebp
movl %ebp, (%rbx)
movb $0x1, %bl
cmpb $0x0, 0x1f(%rsp)
jns 0xad24
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xad24
callq 0x5480
movl %ebx, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
cmpb $0x0, 0x37(%rsp)
jns 0xad4e
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0xad4e
callq 0x5480
cmpb $0x0, 0x1f(%rsp)
jns 0xad64
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xad64
callq 0x5480
movq %rbx, %rdi
callq 0x5620
// File: /workspace/github_cpp_makefile_star2_O3/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
cmpb $0x0, 0x17(%rsi)
jns 0xc00e
movq (%rbx), %rsi
cmpb $0x0, 0x17(%r14)
movq %r14, %rdi
jns 0xc01b
movq (%r14), %rdi
callq 0x54d0
testl %eax, %eax
je 0xc029
shrl $0x1f, %eax
jmp 0xc041
movl 0x18(%rbx), %eax
cmpl %eax, 0x18(%r14)
jne 0xc03e
movl 0x60(%r14), %eax
cmpl 0x60(%rbx), %eax
setl %al
jmp 0xc041
setb %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x54d0
testl %eax, %eax
je 0xc06f
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 0xbffb
// File: /workspace/github_cpp_makefile_star2_O3/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 0x54d0
testl %eax, %eax
je 0xc0a7
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 0xc049
// File: /workspace/github_cpp_makefile_star2_O3/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, 0x1a973(%rip)     # 0x26a30
jne 0xc10e
pushq %r15
pushq %r14
pushq %rbx
leaq 0x1a985(%rip), %rbx     # 0x26a50
xorl %r14d, %r14d
leaq 0x1978b(%rip), %r15     # 0x25860
movl (%r14,%r15), %edi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x5460
addq $0x10, %r14
addq $0x98, %rbx
cmpq $0x60, %r14
jne 0xc0d5
leaq 0x1a93d(%rip), %rdi     # 0x26a38
xorl %esi, %esi
callq 0x5680
movb $0x0, 0x1a927(%rip)     # 0x26a30
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
subq $0x50, %rsp
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
testl %ecx, %ecx
je 0xc231
callq 0xbfcf
leaq 0x10(%rsp), %r15
movl %ebp, -0x8(%r15)
movq %r14, %rdi
callq 0x5170
movq %rax, %r12
movq %r15, %rdi
movl %r12d, %esi
callq 0x62e4
movl %r12d, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x5300
movl -0x8(%r15), %eax
leaq 0x28(%rsp), %rsi
movl %eax, (%rsi)
movups (%r15), %xmm0
movups %xmm0, 0x8(%rsi)
movq 0x10(%r15), %rax
movq %rax, 0x18(%rsi)
movb $0x0, (%r15)
movb $0x17, 0x17(%r15)
movq %rbx, 0x20(%rsi)
leaq 0x1a796(%rip), %rdi     # 0x269c0
callq 0x19436
jmp 0xc297
callq 0xbfe5
leaq 0x10(%rsp), %r15
movl %ebp, -0x8(%r15)
movq %r14, %rdi
callq 0x5170
movq %rax, %r12
movq %r15, %rdi
movl %r12d, %esi
callq 0x62e4
movl %r12d, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x5300
movl -0x8(%r15), %eax
leaq 0x28(%rsp), %rsi
movl %eax, (%rsi)
movups (%r15), %xmm0
movups %xmm0, 0x8(%rsi)
movq 0x10(%r15), %rax
movq %rax, 0x18(%rsi)
movb $0x0, (%r15)
movb $0x17, 0x17(%r15)
movq %rbx, 0x20(%rsi)
leaq 0x1a766(%rip), %rdi     # 0x269f8
callq 0x19436
cmpb $0x0, 0x47(%rsp)
jns 0xc2ad
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0xc2ad
callq 0x5480
cmpb $0x0, 0x27(%rsp)
jns 0xc2c3
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xc2c3
callq 0x5480
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0xc2d2
movq %rax, %rbx
cmpb $0x0, 0x47(%rsp)
jns 0xc2eb
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0xc2eb
callq 0x5480
cmpb $0x0, 0x27(%rsp)
jns 0xc301
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xc301
callq 0x5480
movq %rbx, %rdi
callq 0x5620
// File: /workspace/github_cpp_makefile_star2_O3/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
testl %edi, %edi
jle 0xdbc5
movq %rdx, %r14
movq %rsi, %r15
movq %rcx, 0x8(%rsp)
movl %edi, %ebx
movq -0x8(%r15,%rbx,8), %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x50a0
testq %rax, %rax
je 0xdbb4
movq %rax, %r12
cmpq $0x0, 0x8(%rsp)
jne 0xdb78
movq %r12, %rdi
callq 0x5170
movq %rax, %rbp
movq %r14, %rdi
callq 0x5170
cmpq %rax, %rbp
jne 0xdbb4
movq %r13, %rax
cmpq %r12, %rax
je 0xdb8b
cmpb $0x2d, (%rax)
leaq 0x1(%rax), %rax
je 0xdb7b
jmp 0xdbb4
cmpb $0x2d, (%r13)
jne 0xdbb4
movb $0x1, %bpl
cmpq $0x0, 0x8(%rsp)
je 0xdbc7
movq %r14, %rdi
callq 0x5170
addq %rax, %r12
movq %r12, %rdi
callq 0x5170
testl %eax, %eax
jne 0xdbd8
leaq -0x1(%rbx), %rax
cmpq $0x1, %rbx
movq %rax, %rbx
jg 0xdb40
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r12, %rdi
callq 0x5170
movq %rax, %r14
leaq 0x10(%rsp), %r15
movq %r15, %rdi
movl %r14d, %esi
callq 0x62e4
movl %r14d, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x5300
movq 0x8(%rsp), %rbx
cmpq %rbx, %r15
je 0xdc31
cmpb $0x0, 0x17(%rbx)
jns 0xdc1e
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xdc1e
callq 0x5480
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rbx)
movups 0x10(%rsp), %xmm0
movups %xmm0, (%rbx)
jmp 0xdbc7
cmpb $0x0, 0x27(%rsp)
jns 0xdbc7
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xdbc7
callq 0x5480
jmp 0xdbc7
// File: /workspace/github_cpp_makefile_star2_O3/ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::(anonymous namespace)::XmlReporter::test_case_exception(doctest::TestCaseException const&)
void test_case_exception(const TestCaseException& e) override {
            std::lock_guard<std::mutex> lock(mutex);

            xml.scopedElement("Exception")
                    .writeAttribute("crash", e.is_crash)
                    .writeText(e.error_string.c_str());
        }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rsi, %r14
movq %rdi, %r15
leaq 0x50(%rdi), %rbx
movq %rbx, %rdi
callq 0x5520
testl %eax, %eax
jne 0xf909
leaq 0x40(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xc840(%rip), %rsi      # 0x1c056
leaq 0xc842(%rip), %rdx      # 0x1c05f
leaq 0x30(%rsp), %rdi
callq 0x16a64
addq $0x8, %r15
movq %r15, 0x8(%rsp)
leaq 0x30(%rsp), %rsi
movq %r15, %rdi
callq 0x107d8
leaq 0x20(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0xc7da(%rip), %rsi      # 0x1c027
leaq 0xc7d8(%rip), %rdx      # 0x1c02c
leaq 0x10(%rsp), %rdi
callq 0x16a64
movzbl 0x18(%r14), %edx
leaq 0x10(%rsp), %rsi
movq %r15, %rdi
callq 0x1110a
cmpb $0x0, 0x17(%r14)
jns 0xf87a
movq (%r14), %r14
leaq 0x50(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %r14, %rsi
callq 0x16a26
leaq 0x8(%rsp), %rdi
leaq 0x50(%rsp), %rsi
movl $0x1, %edx
callq 0x116e4
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xf8bb
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x53d0
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0xf8d2
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x53d0
movq 0x8(%rsp), %rdi
callq 0x106a8
movq 0x30(%rsp), %rdi
cmpq %r12, %rdi
je 0xf8f3
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x53d0
movq %rbx, %rdi
callq 0x52d0
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movl %eax, %edi
callq 0x5230
movq %rax, %r14
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xf935
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x53d0
jmp 0xf935
jmp 0xf932
movq %rax, %r14
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0xf951
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x53d0
jmp 0xf951
movq %rax, %r14
movq 0x8(%rsp), %rdi
callq 0x106a8
movq 0x30(%rsp), %rdi
cmpq %r12, %rdi
je 0xf98c
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x53d0
jmp 0xf98c
movq %rax, %r14
movq %r15, %rdi
callq 0x106be
jmp 0xf95b
movq %rax, %rdi
callq 0x16173
movq %rax, %r14
movq %rbx, %rdi
callq 0x52d0
movq %r14, %rdi
callq 0x5620
// File: /workspace/github_cpp_makefile_star2_O3/ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::(anonymous namespace)::XmlReporter::subcase_start(doctest::SubcaseSignature const&)
void subcase_start(const SubcaseSignature& in) override {
            xml.startElement("SubCase")
                    .writeAttribute("name", in.m_name)
                    .writeAttribute("filename", skipPathFromFilename(in.m_file))
                    .writeAttribute("line", line(in.m_line));
            xml.ensureTagClosed();
        }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %r15
leaq 0x8(%rdi), %rbx
leaq 0x78(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0xc666(%rip), %rsi      # 0x1c02d
leaq 0xc666(%rip), %rdx      # 0x1c034
leaq 0x68(%rsp), %r12
movq %r12, %rdi
callq 0x16a64
movq %rbx, %rdi
movq %r12, %rsi
callq 0x107d8
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0xc4da(%rip), %rsi      # 0x1bed0
leaq 0xc4d7(%rip), %rdx      # 0x1bed4
movq %rsp, %rdi
callq 0x16a64
movq %rsp, %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x10df0
leaq 0x58(%rsp), %rbp
movq %rbp, -0x10(%rbp)
leaq 0xc4a9(%rip), %rsi      # 0x1becc
leaq 0xc4aa(%rip), %rdx      # 0x1bed4
leaq 0x48(%rsp), %rdi
callq 0x16a64
movq %r13, %r12
movq 0x18(%r14), %rdi
callq 0x6d92
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
movq %rax, %rdx
callq 0x10ed0
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0xbfa2(%rip), %rsi      # 0x1ba02
leaq 0xbf9f(%rip), %rdx      # 0x1ba06
leaq 0x28(%rsp), %rdi
callq 0x16a64
movq 0x78(%r15), %rcx
xorl %eax, %eax
cmpb $0x0, 0x7d(%rcx)
jne 0xfa81
movl 0x20(%r14), %eax
leaq 0x24(%rsp), %rdx
movl %eax, (%rdx)
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x1102a
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0xfaac
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x53d0
movq 0x48(%rsp), %rdi
cmpq %rbp, %rdi
je 0xfac3
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x53d0
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0xfade
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53d0
movq 0x68(%rsp), %rdi
cmpq %r12, %rdi
je 0xfaf5
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x53d0
movq %rbx, %rdi
callq 0x10858
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0xfb30
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x53d0
jmp 0xfb30
jmp 0xfb2d
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %rbp, %rdi
je 0xfb51
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x53d0
jmp 0xfb51
jmp 0xfb4b
movq %r13, %r12
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0xfb76
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53d0
jmp 0xfb76
jmp 0xfb70
movq %r13, %r12
movq %rax, %rbx
movq 0x68(%rsp), %rdi
cmpq %r12, %rdi
je 0xfb8d
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x53d0
movq %rbx, %rdi
callq 0x5620
nop
// File: /workspace/github_cpp_makefile_star2_O3/ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::(anonymous namespace)::XmlReporter::test_case_skipped(doctest::TestCaseData const&)
void test_case_skipped(const TestCaseData& in) override {
            if(opt.no_skipped_summary == false) {
                test_case_start_impl(in);
                xml.writeAttribute("skipped", "true");
                xml.endElement();
            }
        }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq 0x78(%rdi), %rax
cmpb $0x0, 0x7f(%rax)
jne 0x10643
movq %rdi, %rbx
callq 0x1119a
addq $0x8, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xcbcd(%rip), %rsi      # 0x1d1ce
leaq 0xcbcd(%rip), %rdx      # 0x1d1d5
movq %rsp, %r14
movq %r14, %rdi
callq 0x16a64
leaq 0xaf2c(%rip), %rdx      # 0x1b546
movq %rbx, %rdi
movq %r14, %rsi
callq 0x10ed0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x1063b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53d0
movq %rbx, %rdi
callq 0x106be
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x10666
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53d0
movq %rbx, %rdi
callq 0x5620
// File: /workspace/github_cpp_makefile_star2_O3/ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::(anonymous namespace)::XmlWriter::endElement()
XmlWriter& XmlWriter::endElement() {
        newlineIfNecessary();
        m_indent = m_indent.substr( 0, m_indent.size()-2 );
        if( m_tagIsOpen ) {
            m_os << "/>";
            m_tagIsOpen = false;
        }
        else {
            m_os << m_indent << "</" << m_tags.back() << ">";
        }
        m_os << std::endl;
        m_tags.pop_back();
        return *this;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
callq 0x108ae
leaq 0x20(%rbx), %r14
movq 0x28(%rbx), %rcx
addq $-0x2, %rcx
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x53e0
movq %r14, %rdi
movq %r15, %rsi
callq 0x5450
movq (%r15), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x10710
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x53d0
movq 0x40(%rbx), %rdi
cmpb $0x1, (%rbx)
jne 0x1072f
leaq 0xb817(%rip), %rsi      # 0x1bf37
movl $0x2, %edx
callq 0x5410
movb $0x0, (%rbx)
jmp 0x1077b
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdx
callq 0x5410
movq %rax, %r14
leaq 0xb7f4(%rip), %rsi      # 0x1bf3a
movl $0x2, %edx
movq %rax, %rdi
callq 0x5410
movq 0x10(%rbx), %rax
movq -0x20(%rax), %rsi
movq -0x18(%rax), %rdx
movq %r14, %rdi
callq 0x5410
leaq 0xb7ca(%rip), %rsi      # 0x1bf38
movl $0x1, %edx
movq %rax, %rdi
callq 0x5410
movq 0x40(%rbx), %r14
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x5390
movsbl %al, %esi
movq %r14, %rdi
callq 0x5040
movq %rax, %rdi
callq 0x5260
movq 0x10(%rbx), %rax
leaq -0x20(%rax), %rcx
movq %rcx, 0x10(%rbx)
movq -0x20(%rax), %rdi
addq $-0x10, %rax
cmpq %rax, %rdi
je 0x107ca
movq (%rax), %rsi
incq %rsi
callq 0x53d0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop