LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
testb $0x1, 0x30(%rax)
jne 0xbc63
leaq -0x20(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x74b0
movq -0x60(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x7d50
jmp 0xbc36
leaq -0x20(%rbp), %rdi
callq 0x7900
movq -0x60(%rbp), %rax
movb $0x1, 0x30(%rax)
jmp 0xbc63
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x7900
jmp 0xbd65
movq 0x458de(%rip), %rax     # 0x51548
addq $0x10d0, %rax           # imm = 0x10D0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x20f20
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0x20f50
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x20f80
testb $0x1, %al
jne 0xbca1
jmp 0xbcca
leaq -0x40(%rbp), %rdi
callq 0x20fc0
movq -0x60(%rbp), %rsi
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x50(%rax)
leaq -0x40(%rbp), %rdi
callq 0x20fe0
jmp 0xbc8e
movq -0x60(%rbp), %rax
movl 0x24(%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x51(%rbp)
testb $0x1, -0x51(%rbp)
jne 0xbcfd
movq -0x60(%rbp), %rax
movl 0x24(%rax), %edi
callq 0xb7e0
movq -0x60(%rbp), %rax
movl 0x24(%rax), %edi
callq 0xb820
callq 0xa780
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x69(%rbp)
jne 0xbd10
jmp 0xbd5a
callq 0x89c0
movq %rax, %rcx
xorl %eax, %eax
testb $0x1, 0x79(%rcx)
movb %al, -0x69(%rbp)
jne 0xbd5a
xorl %eax, %eax
testb $0x1, -0x51(%rbp)
movb %al, -0x69(%rbp)
jne 0xbd5a
movq 0x45813(%rip), %rcx     # 0x51548
movb $0x1, %al
cmpq $0x0, 0x20(%rcx)
movb %al, -0x6a(%rbp)
je 0xbd54
movq 0x45800(%rip), %rax     # 0x51548
movq 0x20(%rax), %rax
movb 0x39(%rax), %al
xorb $-0x1, %al
movb %al, -0x6a(%rbp)
movb -0x6a(%rbp), %al
movb %al, -0x69(%rbp)
movb -0x69(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x6800
nop
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xe48f
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdi
callq 0x7a50
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
addq $0x3, %rdx
movq -0x20(%rbp), %rcx
callq 0x11720
testb $0x1, %al
jne 0xe4ad
jmp 0xe4b3
movb $0x1, -0x1(%rbp)
jmp 0xe4cc
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x11720
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x7f70
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x10726
cmpl $0x0, -0x1c(%rbp)
setl %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x10764
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x18(%rcx), %eax
je 0x1074e
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x18(%rcx), %eax
setb %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x10764
movq -0x10(%rbp), %rax
movl 0x60(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x60(%rcx), %eax
setl %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rsi
callq 0x6670
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x107ac
cmpl $0x0, -0x1c(%rbp)
setl %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x107be
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x106f0
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x6670
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x1080c
cmpl $0x0, -0x1c(%rbp)
setl %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x1081e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x10770
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::(anonymous namespace)::FatalConditionHandler::FatalConditionHandler()
FatalConditionHandler() {
            isSet = true;
            stack_t sigStack;
            sigStack.ss_sp    = altStackMem;
            sigStack.ss_size  = altStackSize;
            sigStack.ss_flags = 0;
            sigaltstack(&sigStack, &oldSigStack);
            struct sigaction sa = {};
            sa.sa_handler       = handleSignal; // NOLINT
            sa.sa_flags         = SA_ONSTACK;
            for(std::size_t i = 0; i < DOCTEST_COUNTOF(signalDefs); ++i) {
                sigaction(signalDefs[i].id, &sa, &oldSigActions[i]);
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movb $0x1, 0x4137a(%rip)     # 0x51bc0
movq 0x412fb(%rip), %rax     # 0x51b48
movq %rax, -0x20(%rbp)
movq 0x40d58(%rip), %rax     # 0x515b0
movq %rax, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
leaq -0x20(%rbp), %rdi
leaq 0x4135a(%rip), %rsi     # 0x51bc8
callq 0x6890
leaq -0xb8(%rbp), %rdi
xorl %esi, %esi
movl $0x98, %edx
callq 0x6230
leaq 0x1053(%rip), %rax      # 0x118e0
movq %rax, -0xb8(%rbp)
movl $0x8000000, -0x30(%rbp) # imm = 0x8000000
movq $0x0, -0xc0(%rbp)
cmpq $0x6, -0xc0(%rbp)
jae 0x108fc
movq -0xc0(%rbp), %rcx
leaq 0x40be2(%rip), %rax     # 0x514a0
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %edi
leaq 0x41312(%rip), %rdx     # 0x51be0
imulq $0x98, -0xc0(%rbp), %rax
addq %rax, %rdx
leaq -0xb8(%rbp), %rsi
callq 0x65c0
movq -0xc0(%rbp), %rax
addq $0x1, %rax
movq %rax, -0xc0(%rbp)
jmp 0x108a6
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
testb $0x1, 0x412a1(%rip)     # 0x51bc0
je 0x10984
movq $0x0, -0x8(%rbp)
cmpq $0x6, -0x8(%rbp)
jae 0x1096d
movq -0x8(%rbp), %rcx
leaq 0x40b65(%rip), %rax     # 0x514a0
shlq $0x4, %rcx
addq %rcx, %rax
movl (%rax), %edi
leaq 0x41295(%rip), %rsi     # 0x51be0
imulq $0x98, -0x8(%rbp), %rax
addq %rax, %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x65c0
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x10929
leaq 0x41254(%rip), %rdi     # 0x51bc8
xorl %eax, %eax
movl %eax, %esi
callq 0x6890
movb $0x0, 0x4123c(%rip)     # 0x51bc0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movb %cl, %al
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
je 0x10b7f
callq 0x10510
movq %rax, -0xf0(%rbp)
leaq -0x68(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
leaq -0xc(%rbp), %rsi
leaq -0x8(%rbp), %rdx
callq 0x22570
movq -0xe8(%rbp), %rsi
leaq -0x48(%rbp), %rdi
leaq -0x18(%rbp), %rdx
callq 0x225b0
jmp 0x10b01
movq -0xf0(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x22530
movb %dl, -0xf9(%rbp)
movq %rax, -0xf8(%rbp)
jmp 0x10b20
movb -0xf9(%rbp), %al
movq -0xf8(%rbp), %rcx
movq %rcx, -0x88(%rbp)
movb %al, -0x80(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x225f0
leaq -0x68(%rbp), %rdi
callq 0x22610
jmp 0x10c49
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x10b71
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x225f0
leaq -0x68(%rbp), %rdi
callq 0x22610
jmp 0x10c52
callq 0x10570
movq %rax, -0x110(%rbp)
leaq -0xd0(%rbp), %rdi
movq %rdi, -0x108(%rbp)
leaq -0xc(%rbp), %rsi
leaq -0x8(%rbp), %rdx
callq 0x22570
movq -0x108(%rbp), %rsi
leaq -0xb0(%rbp), %rdi
leaq -0x18(%rbp), %rdx
callq 0x225b0
jmp 0x10bbf
movq -0x110(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x22530
movb %dl, -0x119(%rbp)
movq %rax, -0x118(%rbp)
jmp 0x10be1
movb -0x119(%rbp), %al
movq -0x118(%rbp), %rcx
movq %rcx, -0xe0(%rbp)
movb %al, -0xd8(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x225f0
leaq -0xd0(%rbp), %rdi
callq 0x22610
jmp 0x10c49
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
jmp 0x10c3b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x225f0
leaq -0xd0(%rbp), %rdi
callq 0x22610
jmp 0x10c52
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x6800
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl %edi, -0x4(%rbp)
leaq 0x274d3(%rip), %rax     # 0x38dc5
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x6, -0x18(%rbp)
jae 0x11944
movq -0x18(%rbp), %rcx
leaq 0x3fb90(%rip), %rax     # 0x514a0
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movl -0x4(%rbp), %eax
movq -0x20(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x11934
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x11944
jmp 0x11936
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x118fe
callq 0x10910
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x6810
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x25b30
jmp 0x11971
leaq -0x40(%rbp), %rdi
callq 0x119e0
jmp 0x1197c
leaq -0x40(%rbp), %rdi
callq 0x6260
leaq -0x41(%rbp), %rdi
callq 0x64e0
movl -0x4(%rbp), %edi
callq 0x6470
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x119bf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x6260
leaq -0x41(%rbp), %rdi
callq 0x64e0
movq -0x50(%rbp), %rdi
callq 0x6800
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0xc0(%rbp)
addq $0x50, %rsi
leaq -0x18(%rbp), %rdi
callq 0x226b0
movq -0xc0(%rbp), %rax
addq $0x8, %rax
movq %rax, -0xb8(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x6810
movq -0xb0(%rbp), %rdx
leaq 0x22e9e(%rip), %rsi     # 0x391c9
leaq -0x40(%rbp), %rdi
callq 0x25b30
jmp 0x16336
movq -0xb8(%rbp), %rsi
leaq -0x20(%rbp), %rdi
leaq -0x40(%rbp), %rdx
callq 0x17970
jmp 0x1634c
leaq -0x79(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x6810
movq -0xc8(%rbp), %rdx
leaq 0x22e30(%rip), %rsi     # 0x3919a
leaq -0x78(%rbp), %rdi
callq 0x25b30
jmp 0x16375
movq -0x10(%rbp), %rdx
addq $0x18, %rdx
leaq -0x20(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x17b60
movq %rax, -0xd0(%rbp)
jmp 0x16393
movq -0x10(%rbp), %rdi
callq 0x20cd0
movq %rax, -0xd8(%rbp)
jmp 0x163a5
leaq -0xa1(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x6810
movq -0xd8(%rbp), %rsi
movq -0xe0(%rbp), %rdx
leaq -0xa0(%rbp), %rdi
callq 0x25b30
jmp 0x163d4
movq -0xd0(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
movl $0x1, %edx
callq 0x19220
jmp 0x163ee
leaq -0xa0(%rbp), %rdi
callq 0x6260
leaq -0xa1(%rbp), %rdi
callq 0x64e0
leaq -0x78(%rbp), %rdi
callq 0x6260
leaq -0x79(%rbp), %rdi
callq 0x64e0
leaq -0x20(%rbp), %rdi
callq 0x17a70
leaq -0x40(%rbp), %rdi
callq 0x6260
leaq -0x41(%rbp), %rdi
callq 0x64e0
leaq -0x18(%rbp), %rdi
callq 0x227d0
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x164d6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x164cd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x164bb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x164b2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x164a6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x6260
leaq -0xa1(%rbp), %rdi
callq 0x64e0
leaq -0x78(%rbp), %rdi
callq 0x6260
leaq -0x79(%rbp), %rdi
callq 0x64e0
leaq -0x20(%rbp), %rdi
callq 0x17a70
leaq -0x40(%rbp), %rdi
callq 0x6260
leaq -0x41(%rbp), %rdi
callq 0x64e0
leaq -0x18(%rbp), %rdi
callq 0x227d0
movq -0x50(%rbp), %rdi
callq 0x6800
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq 0x78(%rax), %rax
movb 0x7f(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x178be
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x189a0
movq -0x50(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x60(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x6810
movq -0x58(%rbp), %rdx
leaq 0x22af0(%rip), %rsi     # 0x3a33e
leaq -0x30(%rbp), %rdi
callq 0x25b30
jmp 0x17859
movq -0x60(%rbp), %rdi
leaq 0x20d52(%rip), %rdx     # 0x385b6
leaq -0x30(%rbp), %rsi
callq 0x186b0
jmp 0x1786f
leaq -0x30(%rbp), %rdi
callq 0x6260
leaq -0x31(%rbp), %rdi
callq 0x64e0
movq -0x50(%rbp), %rdi
addq $0x8, %rdi
callq 0x17ba0
jmp 0x178be
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x178b3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x6260
leaq -0x31(%rbp), %rdi
callq 0x64e0
jmp 0x178c4
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x6800
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x17da0
movq -0x30(%rbp), %rdi
movq %rdi, %rax
addq $0x20, %rax
movq %rax, -0x38(%rbp)
addq $0x20, %rdi
callq 0x62d0
movq -0x38(%rbp), %rsi
movq %rax, %rcx
subq $0x2, %rcx
leaq -0x28(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
callq 0x64a0
movq -0x30(%rbp), %rdi
addq $0x20, %rdi
leaq -0x28(%rbp), %rsi
callq 0x65a0
leaq -0x28(%rbp), %rdi
callq 0x6260
movq -0x30(%rbp), %rax
testb $0x1, (%rax)
je 0x17c29
movq -0x30(%rbp), %rax
movq 0x40(%rax), %rdi
leaq 0x2148f(%rip), %rsi     # 0x390aa
callq 0x6450
movq -0x30(%rbp), %rax
movb $0x0, (%rax)
jmp 0x17c75
movq -0x30(%rbp), %rsi
movq 0x40(%rsi), %rdi
addq $0x20, %rsi
callq 0x63b0
movq %rax, %rdi
leaq 0x21469(%rip), %rsi     # 0x390ad
callq 0x6450
movq -0x30(%rbp), %rdi
movq %rax, -0x40(%rbp)
addq $0x8, %rdi
callq 0x2ce60
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x63b0
movq %rax, %rdi
leaq 0x2143b(%rip), %rsi     # 0x390ab
callq 0x6450
movq -0x30(%rbp), %rax
movq 0x40(%rax), %rdi
movq 0x3931c(%rip), %rsi     # 0x50fa0
callq 0x64c0
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
callq 0x2cea0
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::(anonymous namespace)::XmlWriter::startElement(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
XmlWriter& XmlWriter::startElement( std::string const& name ) {
        ensureTagClosed();
        newlineIfNecessary();
        m_os << m_indent << '<' << name;
        m_tags.push_back( name );
        m_indent += "  ";
        m_tagIsOpen = true;
        return *this;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x17d50
movq -0x18(%rbp), %rdi
callq 0x17da0
movq -0x18(%rbp), %rsi
movq 0x40(%rsi), %rdi
addq $0x20, %rsi
callq 0x63b0
movq %rax, %rdi
movl $0x3c, %esi
callq 0x6570
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x63b0
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movq -0x10(%rbp), %rsi
callq 0x2c510
movq -0x18(%rbp), %rdi
addq $0x20, %rdi
leaq 0x218d5(%rip), %rsi     # 0x39605
callq 0x6410
movq -0x18(%rbp), %rax
movb $0x1, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::(anonymous namespace)::(anonymous namespace)::trailingBytes(unsigned char)
size_t trailingBytes(unsigned char c) {
        if ((c & 0xE0) == 0xC0) {
            return 2;
        }
        if ((c & 0xF0) == 0xE0) {
            return 3;
        }
        if ((c & 0xF8) == 0xF0) {
            return 4;
        }
        DOCTEST_INTERNAL_ERROR("Invalid multibyte utf-8 start byte encountered");
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movb %dil, %al
movb %al, -0x9(%rbp)
movzbl -0x9(%rbp), %eax
andl $0xe0, %eax
cmpl $0xc0, %eax
jne 0x18478
movq $0x2, -0x8(%rbp)
jmp 0x184e2
movzbl -0x9(%rbp), %eax
andl $0xf0, %eax
cmpl $0xe0, %eax
jne 0x18492
movq $0x3, -0x8(%rbp)
jmp 0x184e2
movzbl -0x9(%rbp), %eax
andl $0xf8, %eax
cmpl $0xf0, %eax
jne 0x184ac
movq $0x4, -0x8(%rbp)
jmp 0x184e2
leaq 0x20b3d(%rip), %rsi     # 0x38ff0
leaq -0x20(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x6690
movq -0x38(%rbp), %rdi
callq 0x113b0
jmp 0x184cb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x6918
jmp 0x184ec
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x6800
nopw %cs:(%rax,%rax)
// File: ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::(anonymous namespace)::(anonymous namespace)::headerValue(unsigned char)
uint32_t headerValue(unsigned char c) {
        if ((c & 0xE0) == 0xC0) {
            return c & 0x1F;
        }
        if ((c & 0xF0) == 0xE0) {
            return c & 0x0F;
        }
        if ((c & 0xF8) == 0xF0) {
            return c & 0x07;
        }
        DOCTEST_INTERNAL_ERROR("Invalid multibyte utf-8 start byte encountered");
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dil, %al
movb %al, -0x5(%rbp)
movzbl -0x5(%rbp), %eax
andl $0xe0, %eax
cmpl $0xc0, %eax
jne 0x1852a
movzbl -0x5(%rbp), %eax
andl $0x1f, %eax
movl %eax, -0x4(%rbp)
jmp 0x18598
movzbl -0x5(%rbp), %eax
andl $0xf0, %eax
cmpl $0xe0, %eax
jne 0x18546
movzbl -0x5(%rbp), %eax
andl $0xf, %eax
movl %eax, -0x4(%rbp)
jmp 0x18598
movzbl -0x5(%rbp), %eax
andl $0xf8, %eax
cmpl $0xf0, %eax
jne 0x18562
movzbl -0x5(%rbp), %eax
andl $0x7, %eax
movl %eax, -0x4(%rbp)
jmp 0x18598
leaq 0x20ae4(%rip), %rsi     # 0x3904d
leaq -0x18(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x6690
movq -0x30(%rbp), %rdi
callq 0x113b0
jmp 0x18581
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x6918
jmp 0x185a1
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x6800
nopw (%rax,%rax)
// File: ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::(anonymous namespace)::XmlWriter::writeText(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
XmlWriter& XmlWriter::writeText( std::string const& text, bool indent ) {
        if( !text.empty() ){
            bool tagWasOpen = m_tagIsOpen;
            ensureTagClosed();
            if( tagWasOpen && indent )
                m_os << m_indent;
            m_os << XmlEncode( text );
            m_needsNewline = true;
        }
        return *this;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6770
testb $0x1, %al
jne 0x19315
movq -0x58(%rbp), %rdi
movb (%rdi), %al
andb $0x1, %al
movb %al, -0x12(%rbp)
callq 0x17d50
testb $0x1, -0x12(%rbp)
je 0x192bd
testb $0x1, -0x11(%rbp)
je 0x192bd
movq -0x58(%rbp), %rsi
movq 0x40(%rsi), %rdi
addq $0x20, %rsi
callq 0x63b0
movq -0x58(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdi
movq %rdi, -0x60(%rbp)
xorl %edx, %edx
callq 0x17ff0
movq -0x68(%rbp), %rdi
movq -0x60(%rbp), %rsi
callq 0x17fc0
jmp 0x192eb
leaq -0x40(%rbp), %rdi
callq 0x18030
movq -0x58(%rbp), %rax
movb $0x1, 0x1(%rax)
jmp 0x19315
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x18030
jmp 0x1931f
movq -0x58(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x6800
nopl (%rax,%rax)
// File: ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::(anonymous namespace)::JUnitReporter::test_case_reenter(doctest::TestCaseData const&)
void test_case_reenter(const TestCaseData& in) override {
            testCaseData.addTime(timer.getElapsedSeconds());
            testCaseData.appendSubcaseNamesToLastTestcase(deepestSubcaseStackNames);
            deepestSubcaseStackNames.clear();

            timer.start();
            testCaseData.add(skipPathFromFilename(in.m_file.c_str()), in.m_name);
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
addq $0x98, %rax
movq %rax, -0x98(%rbp)
addq $0x78, %rdi
callq 0x26790
movq -0x98(%rbp), %rdi
callq 0x1c680
movq -0xa0(%rbp), %rsi
subq $-0x80, %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x2d0c0
movq -0x98(%rbp), %rdi
movq -0x90(%rbp), %rsi
callq 0x1c6f0
jmp 0x1a973
leaq -0x28(%rbp), %rdi
callq 0x24d30
movq -0xa0(%rbp), %rdi
subq $-0x80, %rdi
callq 0x21870
movq -0xa0(%rbp), %rdi
addq $0x78, %rdi
callq 0x22050
movq -0xa0(%rbp), %rax
addq $0x98, %rax
movq %rax, -0xb8(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20cd0
movq %rax, %rdi
callq 0x8940
movq %rax, -0xb0(%rbp)
leaq -0x59(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x6810
movq -0xb0(%rbp), %rsi
movq -0xa8(%rbp), %rdx
leaq -0x58(%rbp), %rdi
callq 0x25b30
jmp 0x1a9f1
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0xc8(%rbp)
leaq -0x81(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x6810
movq -0xc8(%rbp), %rsi
movq -0xc0(%rbp), %rdx
leaq -0x80(%rbp), %rdi
callq 0x25b30
jmp 0x1aa2c
movq -0xb8(%rbp), %rdi
leaq -0x58(%rbp), %rsi
leaq -0x80(%rbp), %rdx
callq 0x1b590
jmp 0x1aa42
leaq -0x80(%rbp), %rdi
callq 0x6260
leaq -0x81(%rbp), %rdi
callq 0x64e0
leaq -0x58(%rbp), %rdi
callq 0x6260
leaq -0x59(%rbp), %rdi
callq 0x64e0
addq $0xd0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x24d30
jmp 0x1aad8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x1aacf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x1aaba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x6260
leaq -0x81(%rbp), %rdi
callq 0x64e0
leaq -0x58(%rbp), %rdi
callq 0x6260
leaq -0x59(%rbp), %rdi
callq 0x64e0
movq -0x30(%rbp), %rdi
callq 0x6800
nopw %cs:(%rax,%rax)
// File: ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::(anonymous namespace)::JUnitReporter::JUnitTestCaseData::getCurrentTimestamp[abi:cxx11]()
static std::string getCurrentTimestamp() {
                // Beware, this is not reentrant because of backward compatibility issues
                // Also, UTC only, again because of backward compatibility (%z is C++11)
                time_t rawtime;
                std::time(&rawtime);
                auto const timeStampSize = sizeof("2017-01-16T17:06:45Z");

                std::tm timeInfo;
#ifdef DOCTEST_PLATFORM_WINDOWS
                gmtime_s(&timeInfo, &rawtime);
#else // DOCTEST_PLATFORM_WINDOWS
                gmtime_r(&rawtime, &timeInfo);
#endif // DOCTEST_PLATFORM_WINDOWS

                char timeStamp[timeStampSize];
                const char* const fmt = "%Y-%m-%dT%H:%M:%SZ";

                std::strftime(timeStamp, timeStampSize, fmt, &timeInfo);
                return std::string(timeStamp);
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xa8(%rbp)
movq %rdi, %rax
movq %rax, -0xc0(%rbp)
movq %rdi, -0x8(%rbp)
leaq -0x10(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x63f0
movq -0xb8(%rbp), %rdi
movq $0x15, -0x18(%rbp)
leaq -0x50(%rbp), %rsi
movq %rsi, -0xb0(%rbp)
callq 0x68e0
movq -0xb0(%rbp), %rcx
leaq 0x1dfc9(%rip), %rdx     # 0x39266
movq %rdx, -0x78(%rbp)
leaq -0x70(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
movl $0x15, %esi
callq 0x6360
leaq -0x79(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x6810
movq -0xa8(%rbp), %rdi
movq -0xa0(%rbp), %rsi
movq -0x98(%rbp), %rdx
callq 0x25b30
jmp 0x1b2e2
leaq -0x79(%rbp), %rdi
callq 0x64e0
movq -0xc0(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x79(%rbp), %rdi
callq 0x64e0
movq -0x88(%rbp), %rdi
callq 0x6800
nopw %cs:(%rax,%rax)
// File: ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::(anonymous namespace)::JUnitReporter::JUnitTestCaseData::addTime(double)
void addTime(double time) {
                if(time < 1e-4)
                    time = 0;
                testcases.back().time = time;
                totalSeconds += time;
            }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movsd 0x1bc47(%rip), %xmm0    # 0x382e8
ucomisd -0x10(%rbp), %xmm0
jbe 0x1c6b0
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
movq -0x18(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x20(%rbp)
callq 0x1b8d0
movsd -0x20(%rbp), %xmm0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movsd %xmm0, 0x40(%rcx)
movsd -0x10(%rbp), %xmm0
addsd 0x18(%rax), %xmm0
movsd %xmm0, 0x18(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::(anonymous namespace)::JUnitReporter::log_contexts(std::__cxx11::basic_ostringstream<char, std::char_traits<char>, std::allocator<char>>&)
void log_contexts(std::ostringstream& s) {
            int num_contexts = get_num_active_contexts();
            if(num_contexts) {
                auto contexts = get_active_contexts();

                s << "  logged: ";
                for(int i = 0; i < num_contexts; ++i) {
                    s << (i == 0 ? "" : "          ");
                    contexts[i]->stringify(&s);
                    s << std::endl;
                }
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x109d0
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x1d99a
callq 0x109f0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x1ba2f(%rip), %rsi     # 0x39361
callq 0x6450
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x1d998
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %ecx
leaq 0x1bca9(%rip), %rsi     # 0x395fd
leaq 0x1ad3e(%rip), %rax     # 0x38699
cmpl $0x0, %ecx
cmoveq %rax, %rsi
callq 0x6450
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x10(%rbp), %rdi
movq 0x33618(%rip), %rsi     # 0x50fa0
callq 0x64c0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1d93e
jmp 0x1d99a
addq $0x30, %rsp
popq %rbp
retq
// File: ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::(anonymous namespace)::ConsoleReporter::test_case_start(doctest::TestCaseData const&)
void test_case_start(const TestCaseData& in) override {
            hasLoggedCurrentTestStart = false;
            tc                        = &in;
            subcasesStack.clear();
            currentSubcaseLevel = 0;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movb $0x0, 0x10(%rdi)
movq -0x10(%rbp), %rax
movq %rax, 0x68(%rdi)
addq $0x18, %rdi
callq 0x22080
movq -0x18(%rbp), %rax
movq $0x0, 0x30(%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::(anonymous namespace)::ConsoleReporter::log_assert(doctest::AssertData const&)
void log_assert(const AssertData& rb) override {
            if((!rb.m_failed && !opt.success) || tc->m_no_output)
                return;

            std::lock_guard<std::mutex> lock(mutex);

            logTestStart();

            file_line_to_stream(rb.m_file, rb.m_line, " ");
            successOrFailColoredStringToStream(!rb.m_failed, rb.m_at);

            fulltext_log_assert_to_stream(s, rb);

            log_contexts();
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0x28(%rax)
jne 0x1ef30
movq -0x30(%rbp), %rax
movq 0x60(%rax), %rax
testb $0x1, 0x6c(%rax)
je 0x1ef3e
movq -0x30(%rbp), %rax
movq 0x68(%rax), %rax
testb $0x1, 0x3a(%rax)
je 0x1ef43
jmp 0x1efcb
movq -0x30(%rbp), %rsi
addq $0x38, %rsi
leaq -0x18(%rbp), %rdi
callq 0x226b0
movq -0x30(%rbp), %rdi
callq 0x20670
jmp 0x1ef5f
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movl 0x18(%rax), %edx
movq (%rdi), %rax
movq 0x70(%rax), %rax
leaq 0x1a68a(%rip), %rcx     # 0x39606
callq *%rax
jmp 0x1ef80
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rcx
movb 0x28(%rcx), %al
notb %al
movl 0x8(%rcx), %edx
movzbl %al, %esi
andl $0x1, %esi
leaq 0x1b5a1(%rip), %rcx     # 0x3a53e
callq 0x209b0
jmp 0x1efa4
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x1d390
jmp 0x1efb7
movq -0x30(%rbp), %rdi
callq 0x20ae0
jmp 0x1efc2
leaq -0x18(%rbp), %rdi
callq 0x227d0
addq $0x30, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x227d0
movq -0x20(%rbp), %rdi
callq 0x6800
nop
// File: ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::(anonymous namespace)::ConsoleReporter::log_message(doctest::MessageData const&)
void log_message(const MessageData& mb) override {
            if(tc->m_no_output)
                return;

            std::lock_guard<std::mutex> lock(mutex);

            logTestStart();

            file_line_to_stream(mb.m_file, mb.m_line, " ");
            s << getSuccessOrFailColor(false, mb.m_severity)
              << getSuccessOrFailString(mb.m_severity & assertType::is_warn, mb.m_severity,
                                        "MESSAGE") << ": ";
            s << Color::None << mb.m_string << "\n";
            log_contexts();
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq 0x68(%rax), %rax
testb $0x1, 0x3a(%rax)
je 0x1f017
jmp 0x1f10d
movq -0x30(%rbp), %rsi
addq $0x38, %rsi
leaq -0x18(%rbp), %rdi
callq 0x226b0
movq -0x30(%rbp), %rdi
callq 0x20670
jmp 0x1f033
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
movl 0x20(%rax), %edx
movq (%rdi), %rax
movq 0x70(%rax), %rax
leaq 0x1a5b6(%rip), %rcx     # 0x39606
callq *%rax
jmp 0x1f054
movq -0x30(%rbp), %rdi
movq 0x8(%rdi), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movl 0x24(%rax), %edx
xorl %esi, %esi
callq 0x20a40
movq -0x40(%rbp), %rdi
movl %eax, %esi
callq 0x81f0
movq %rax, -0x38(%rbp)
jmp 0x1f07f
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movl 0x24(%rax), %edx
movl %edx, %esi
andl $0x1, %esi
leaq 0x1b4e0(%rip), %rcx     # 0x3a576
callq 0x20a90
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x6450
movq %rax, -0x48(%rbp)
jmp 0x1f0ad
movq -0x48(%rbp), %rdi
leaq 0x1b49f(%rip), %rsi     # 0x3a557
callq 0x6450
jmp 0x1f0bf
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
xorl %esi, %esi
callq 0x81f0
movq %rax, -0x50(%rbp)
jmp 0x1f0d4
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x81b0
movq %rax, -0x58(%rbp)
jmp 0x1f0e7
movq -0x58(%rbp), %rdi
leaq 0x1abdf(%rip), %rsi     # 0x39cd1
callq 0x6450
jmp 0x1f0f9
movq -0x30(%rbp), %rdi
callq 0x20ae0
jmp 0x1f104
leaq -0x18(%rbp), %rdi
callq 0x227d0
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x227d0
movq -0x20(%rbp), %rdi
callq 0x6800
nopw %cs:(%rax,%rax)
// File: ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::(anonymous namespace)::ConsoleReporter::printRegisteredReporters()
void printRegisteredReporters() {
            printVersion();
            auto printReporters = [this] (const reporterMap& reporters, const char* type) {
                if(reporters.size()) {
                    s << Color::Cyan << "[doctest] " << Color::None << "listing all registered " << type << "\n";
                    for(auto& curr : reporters)
                        s << "priority: " << std::setw(5) << curr.first.first
                          << " name: " << curr.first.second << "\n";
                }
            };
            printReporters(getListeners(), "listeners");
            printReporters(getReporters(), "reporters");
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x1f2b0
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
callq 0x10570
movq %rax, %rsi
leaq -0x10(%rbp), %rdi
leaq 0x19ec0(%rip), %rdx     # 0x3a274
callq 0x204a0
callq 0x10510
movq %rax, %rsi
leaq -0x10(%rbp), %rdi
leaq 0x1884e(%rip), %rdx     # 0x38c1a
callq 0x204a0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::(anonymous namespace)::ConsoleReporter::printIntro()
void printIntro() {
            if(opt.no_intro == false) {
                printVersion();
                s << Color::Cyan << "[doctest] " << Color::None
                  << "run with \"--" DOCTEST_OPTIONS_PREFIX_DISPLAY "help\" for options\n";
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x60(%rax), %rax
movb 0x75(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x20668
movq -0x10(%rbp), %rdi
callq 0x1f2b0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0x5, %esi
callq 0x81f0
movq %rax, %rdi
leaq 0x19636(%rip), %rsi     # 0x39c80
callq 0x6450
movq %rax, %rdi
xorl %esi, %esi
callq 0x81f0
movq %rax, %rdi
leaq 0x19c97(%rip), %rsi     # 0x3a2fa
callq 0x6450
addq $0x10, %rsp
popq %rbp
retq
nop
// File: ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::(anonymous namespace)::ConsoleReporter::log_contexts()
void log_contexts() {
            int num_contexts = get_num_active_contexts();
            if(num_contexts) {
                auto contexts = get_active_contexts();

                s << Color::None << "  logged: ";
                for(int i = 0; i < num_contexts; ++i) {
                    s << (i == 0 ? "" : "          ");
                    contexts[i]->stringify(&s);
                    s << "\n";
                }
            }

            s << "\n";
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x109d0
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x20b9f
callq 0x109f0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq 0x8(%rax), %rdi
xorl %esi, %esi
callq 0x81f0
movq %rax, %rdi
leaq 0x18836(%rip), %rsi     # 0x39361
callq 0x6450
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x20b9d
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movl -0x1c(%rbp), %ecx
leaq 0x18aac(%rip), %rsi     # 0x395fd
leaq 0x17b41(%rip), %rax     # 0x38699
cmpl $0x0, %ecx
cmoveq %rax, %rsi
callq 0x6450
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
movq (%rcx,%rdx,8), %rdi
movq 0x8(%rax), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x19144(%rip), %rsi     # 0x39cd1
callq 0x6450
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x20b37
jmp 0x20b9f
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
leaq 0x19123(%rip), %rsi     # 0x39cd1
callq 0x6450
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::detail::ContextState::resetRunData()
void resetRunData() {
            numTestCases                = 0;
            numTestCasesPassingFilters  = 0;
            numTestSuitesPassingFilters = 0;
            numTestCasesFailed          = 0;
            numAsserts                  = 0;
            numAssertsFailed            = 0;
            numAssertsCurrentTest       = 0;
            numAssertsFailedCurrentTest = 0;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x88(%rax)
movl $0x0, 0x8c(%rax)
movl $0x0, 0x90(%rax)
movl $0x0, 0x94(%rax)
movl $0x0, 0x98(%rax)
movl $0x0, 0x9c(%rax)
movl $0x0, 0xa0(%rax)
movl $0x0, 0xa4(%rax)
popq %rbp
retq
nop
// File: ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::detail::MultiLaneAtomic<int>::myAtomic()
std::atomic<T>& myAtomic() DOCTEST_NOEXCEPT {
            static std::atomic<size_t> laneCounter;
            DOCTEST_THREAD_LOCAL size_t tlsLaneIdx =
                    laneCounter++ % DOCTEST_MULTI_LANE_ATOMICS_THREAD_LANES;

            return m_atomics[tlsLaneIdx].atomic;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movb %fs:-0x8, %al
cmpb $0x0, %al
jne 0x24383
leaq 0x2dc09(%rip), %rdi     # 0x51f70
xorl %esi, %esi
callq 0x243b0
andl $0x1f, %eax
movq %rax, %fs:-0x10
movb $0x1, %fs:-0x8
movq -0x10(%rbp), %rax
movq %fs:0x0, %rcx
leaq -0x10(%rcx), %rcx
movq (%rcx), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::detail::MultiLaneAtomic<int>::load(std::memory_order) const
T load(std::memory_order order = std::memory_order_seq_cst) const DOCTEST_NOEXCEPT {
            auto result = T();
            for(auto const& c : m_atomics) {
                result += c.atomic.load(order);
            }
            return result;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x20(%rbp)
movl %esi, -0x24(%rbp)
movq -0x20(%rbp), %rax
movl $0x0, -0x28(%rbp)
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
addq $0x800, %rax            # imm = 0x800
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
je 0x28072
movq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rcx
movl -0x24(%rbp), %eax
movq %rcx, -0x8(%rbp)
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movl -0xc(%rbp), %edi
movl $0xffff, %esi           # imm = 0xFFFF
callq 0x23840
movl %eax, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x4c(%rbp)
decl %eax
subl $0x2, %eax
jb 0x28044
jmp 0x2802f
movl -0x4c(%rbp), %eax
subl $0x5, %eax
je 0x2804f
jmp 0x28039
movq -0x58(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
jmp 0x28058
movq -0x58(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
jmp 0x28058
movq -0x58(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addl -0x28(%rbp), %eax
movl %eax, -0x28(%rbp)
movq -0x38(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x38(%rbp)
jmp 0x27fe4
movl -0x28(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::detail::MultiLaneAtomic<int>::store(int, std::memory_order)
void store(T desired, std::memory_order order = std::memory_order_seq_cst) DOCTEST_NOEXCEPT {
            // first value becomes desired", all others become 0.
            for(auto& c : m_atomics) {
                c.atomic.store(desired, order);
                desired = {};
            }
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x20(%rbp)
movl %esi, -0x24(%rbp)
movl %edx, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rax
addq $0x800, %rax            # imm = 0x800
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x40(%rbp), %rax
je 0x31a36
movq -0x38(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdx
movl -0x24(%rbp), %ecx
movl -0x28(%rbp), %eax
movq %rdx, -0x8(%rbp)
movl %ecx, -0xc(%rbp)
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movl -0x10(%rbp), %edi
movl $0xffff, %esi           # imm = 0xFFFF
callq 0x23840
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x4c(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, -0x18(%rbp)
subl $0x3, %eax
je 0x31a0a
jmp 0x319f5
movl -0x4c(%rbp), %eax
subl $0x5, %eax
je 0x31a15
jmp 0x319ff
movq -0x58(%rbp), %rax
movl -0x18(%rbp), %ecx
movl %ecx, (%rax)
jmp 0x31a1e
movq -0x58(%rbp), %rax
movl -0x18(%rbp), %ecx
movl %ecx, (%rax)
jmp 0x31a1e
movq -0x58(%rbp), %rcx
movl -0x18(%rbp), %eax
xchgl %eax, (%rcx)
movl $0x0, -0x24(%rbp)
movq -0x38(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x38(%rbp)
jmp 0x319a0
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: ahupowerdns[P]mcounter/./mcounter.hh
// Function: UnsharedCounterStruct<(anonymous namespace)::mystruct>::UnsharedCounterStruct(UnsharedCounterStruct<(anonymous namespace)::mystruct>&&)
UnsharedCounterStruct(UnsharedCounterStruct&& rhs)
  {
    d_ucp = rhs.d_ucp;
    rhs.d_ucp = nullptr;
    // this works around volatile pain
    memcpy((void*)&d_value, (void*)&rhs.d_value, sizeof(d_value));
    d_ucp->moveChild(&rhs, this);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
xorl %esi, %esi
movl $0x10, %edx
callq 0x6230
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rdx)
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rdx)
movq 0x8(%rax), %rax
movq %rax, 0x8(%rdx)
movq 0x10(%rdx), %rdi
movq -0x10(%rbp), %rsi
callq 0x367b0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)