// File: /workspace/github_cpp_makefile_star2_O3/ahupowerdns[P]mcounter/./ext/doctest.h
// Function: doctest::Context::run()
int Context::run() {
    using namespace detail;

    // save the old context state in case such was setup - for using asserts out of a testing context
    auto old_cs = g_cs;
    // this is the current contest
    g_cs               = p;
    is_running_in_test = true;

    g_no_colors = p->no_colors;
    p->resetRunData();

    std::fstream fstr;
    if(p->cout == nullptr) {
        if(p->quiet) {
            p->cout = &discardOut;
        } else if(p->out.size()) {
            // to a file if specified
            fstr.open(p->out.c_str(), std::fstream::out);
            p->cout = &fstr;
        } else {
            // stdout by default
            p->cout = &std::cout;
        }
    }

    FatalConditionHandler::allocateAltStackMem();

    auto cleanup_and_return = [&]() {
        FatalConditionHandler::freeAltStackMem();

        if(fstr.is_open())
            fstr.close();

        // restore context
        g_cs               = old_cs;
        is_running_in_test = false;

        // we have to free the reporters which were allocated when the run started
        for(auto& curr : p->reporters_currently_used)
            delete curr;
        p->reporters_currently_used.clear();

        if(p->numTestCasesFailed && !p->no_exitcode)
            return EXIT_FAILURE;
        return EXIT_SUCCESS;
    };

    // setup default reporter if none is given through the command line
    if(p->filters[8].empty())
        p->filters[8].push_back("console");

    // check to see if any of the registered reporters has been selected
    for(auto& curr : getReporters()) {
        if(matchesAny(curr.first.second.c_str(), p->filters[8], false, p->case_sensitive))
            p->reporters_currently_used.push_back(curr.second(*g_cs));
    }

    // TODO: check if there is nothing in reporters_currently_used

    // prepend all listeners
    for(auto& curr : getListeners())
        p->reporters_currently_used.insert(p->reporters_currently_used.begin(), curr.second(*g_cs));

#ifdef DOCTEST_PLATFORM_WINDOWS
    if(isDebuggerActive() && p->no_debug_output == false)
        p->reporters_currently_used.push_back(new DebugOutputWindowReporter(*g_cs));
#endif // DOCTEST_PLATFORM_WINDOWS

    // handle version, help and no_run
    if(p->no_run || p->version || p->help || p->list_reporters) {
        DOCTEST_ITERATE_THROUGH_REPORTERS(report_query, QueryData());

        return cleanup_and_return();
    }

    std::vector<const TestCase*> testArray;
    for(auto& curr : getRegisteredTests())
        testArray.push_back(&curr);
    p->numTestCases = testArray.size();

    // sort the collected records
    if(!testArray.empty()) {
        if(p->order_by.compare("file", true) == 0) {
            std::sort(testArray.begin(), testArray.end(), fileOrderComparator);
        } else if(p->order_by.compare("suite", true) == 0) {
            std::sort(testArray.begin(), testArray.end(), suiteOrderComparator);
        } else if(p->order_by.compare("name", true) == 0) {
            std::sort(testArray.begin(), testArray.end(), nameOrderComparator);
        } else if(p->order_by.compare("rand", true) == 0) {
            std::srand(p->rand_seed);

            // random_shuffle implementation
            const auto first = &testArray[0];
            for(size_t i = testArray.size() - 1; i > 0; --i) {
                int idxToSwap = std::rand() % (i + 1); // NOLINT

                const auto temp = first[i];

                first[i]         = first[idxToSwap];
                first[idxToSwap] = temp;
            }
        } else if(p->order_by.compare("none", true) == 0) {
            // means no sorting - beneficial for death tests which call into the executable
            // with a specific test case in mind - we don't want to slow down the startup times
        }
    }

    std::set<String> testSuitesPassingFilt;

    bool                             query_mode = p->count || p->list_test_cases || p->list_test_suites;
    std::vector<const TestCaseData*> queryResults;

    if(!query_mode)
        DOCTEST_ITERATE_THROUGH_REPORTERS(test_run_start, DOCTEST_EMPTY);

    // invoke the registered functions if they match the filter criteria (or just count them)
    for(auto& curr : testArray) {
        const auto& tc = *curr;

        bool skip_me = false;
        if(tc.m_skip && !p->no_skip)
            skip_me = true;

        if(!matchesAny(tc.m_file.c_str(), p->filters[0], true, p->case_sensitive))
            skip_me = true;
        if(matchesAny(tc.m_file.c_str(), p->filters[1], false, p->case_sensitive))
            skip_me = true;
        if(!matchesAny(tc.m_test_suite, p->filters[2], true, p->case_sensitive))
            skip_me = true;
        if(matchesAny(tc.m_test_suite, p->filters[3], false, p->case_sensitive))
            skip_me = true;
        if(!matchesAny(tc.m_name, p->filters[4], true, p->case_sensitive))
            skip_me = true;
        if(matchesAny(tc.m_name, p->filters[5], false, p->case_sensitive))
            skip_me = true;

        if(!skip_me)
            p->numTestCasesPassingFilters++;

        // skip the test if it is not in the execution range
        if((p->last < p->numTestCasesPassingFilters && p->first <= p->last) ||
           (p->first > p->numTestCasesPassingFilters))
            skip_me = true;

        if(skip_me) {
            if(!query_mode)
                DOCTEST_ITERATE_THROUGH_REPORTERS(test_case_skipped, tc);
            continue;
        }

        // do not execute the test if we are to only count the number of filter passing tests
        if(p->count)
            continue;

        // print the name of the test and don't execute it
        if(p->list_test_cases) {
            queryResults.push_back(&tc);
            continue;
        }

        // print the name of the test suite if not done already and don't execute it
        if(p->list_test_suites) {
            if((testSuitesPassingFilt.count(tc.m_test_suite) == 0) && tc.m_test_suite[0] != '\0') {
                queryResults.push_back(&tc);
                testSuitesPassingFilt.insert(tc.m_test_suite);
                p->numTestSuitesPassingFilters++;
            }
            continue;
        }

        // execute the test if it passes all the filtering
        {
            p->currentTest = &tc;

            p->failure_flags = TestCaseFailureReason::None;
            p->seconds       = 0;

            // reset atomic counters
            p->numAssertsFailedCurrentTest_atomic = 0;
            p->numAssertsCurrentTest_atomic       = 0;

            p->subcasesPassed.clear();

            DOCTEST_ITERATE_THROUGH_REPORTERS(test_case_start, tc);

            p->timer.start();
            
            bool run_test = true;

            do {
                // reset some of the fields for subcases (except for the set of fully passed ones)
                p->should_reenter          = false;
                p->subcasesCurrentMaxLevel = 0;
                p->subcasesStack.clear();

                p->shouldLogCurrentException = true;

                // reset stuff for logging with INFO()
                p->stringifiedContexts.clear();

#ifndef DOCTEST_CONFIG_NO_EXCEPTIONS
                try {
#endif // DOCTEST_CONFIG_NO_EXCEPTIONS
// MSVC 2015 diagnoses fatalConditionHandler as unused (because reset() is a static method)
DOCTEST_MSVC_SUPPRESS_WARNING_WITH_PUSH(4101) // unreferenced local variable
                    FatalConditionHandler fatalConditionHandler; // Handle signals
                    // execute the test
                    tc.m_test();
                    fatalConditionHandler.reset();
DOCTEST_MSVC_SUPPRESS_WARNING_POP
#ifndef DOCTEST_CONFIG_NO_EXCEPTIONS
                } catch(const TestFailureException&) {
                    p->failure_flags |= TestCaseFailureReason::AssertFailure;
                } catch(...) {
                    DOCTEST_ITERATE_THROUGH_REPORTERS(test_case_exception,
                                                      {translateActiveException(), false});
                    p->failure_flags |= TestCaseFailureReason::Exception;
                }
#endif // DOCTEST_CONFIG_NO_EXCEPTIONS

                // exit this loop if enough assertions have failed - even if there are more subcases
                if(p->abort_after > 0 &&
                   p->numAssertsFailed + p->numAssertsFailedCurrentTest_atomic >= p->abort_after) {
                    run_test = false;
                    p->failure_flags |= TestCaseFailureReason::TooManyFailedAsserts;
                }
                
                if(p->should_reenter && run_test)
                    DOCTEST_ITERATE_THROUGH_REPORTERS(test_case_reenter, tc);
                if(!p->should_reenter)
                    run_test = false;
            } while(run_test);

            p->finalizeTestCaseData();

            DOCTEST_ITERATE_THROUGH_REPORTERS(test_case_end, *g_cs);

            p->currentTest = nullptr;

            // stop executing tests if enough assertions have failed
            if(p->abort_after > 0 && p->numAssertsFailed >= p->abort_after)
                break;
        }
    }

    if(!query_mode) {
        DOCTEST_ITERATE_THROUGH_REPORTERS(test_run_end, *g_cs);
    } else {
        QueryData qdata;
        qdata.run_stats = g_cs;
        qdata.data      = queryResults.data();
        qdata.num_data  = unsigned(queryResults.size());
        DOCTEST_ITERATE_THROUGH_REPORTERS(report_query, qdata);
    }

    return cleanup_and_return();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x388, %rsp            # imm = 0x388
movq %rdi, %rbp
movq 0x1b27b(%rip), %r15     # 0x263b8
movq (%rdi), %rax
movq %rax, 0x1b271(%rip)     # 0x263b8
movb $0x1, 0x1b267(%rip)     # 0x263b5
movb 0x77(%rax), %cl
movb %cl, %fs:-0x38
xorps %xmm0, %xmm0
movups %xmm0, 0x98(%rax)
movups %xmm0, 0x88(%rax)
leaq 0x178(%rsp), %rdi
callq 0x5430
movq (%rbp), %r14
cmpq $0x0, (%r14)
jne 0xb1eb
cmpb $0x1, 0x71(%r14)
jne 0xb191
leaq 0x1b2a9(%rip), %rax     # 0x26438
jmp 0xb1e8
movzbl 0x3f(%r14), %eax
testb %al, %al
jns 0xb1a0
movl 0x30(%r14), %ecx
jmp 0xb1ac
movl %eax, %edx
andl $0x1f, %edx
movl $0x17, %ecx
subl %edx, %ecx
testl %ecx, %ecx
je 0xb1ba
testb %al, %al
jns 0xb1c3
movq 0x28(%r14), %r14
jmp 0xb1c7
movq 0x1ae07(%rip), %rax     # 0x25fc8
jmp 0xb1e8
addq $0x28, %r14
leaq 0x178(%rsp), %rdi
movq %r14, %rsi
movl $0x10, %edx
callq 0x5330
leaq 0x188(%rsp), %rax
movq (%rbp), %r14
movq %rax, (%r14)
movq 0x1b22e(%rip), %rdi     # 0x26420
callq 0x5030
movq %rax, 0x1b7ba(%rip)     # 0x269b8
movq 0x10b8(%r14), %rbx
movq 0xc0(%rbx), %rax
cmpq 0xc8(%rbx), %rax
jne 0xb267
leaq 0x80(%rsp), %rdi
movl $0x7, %esi
callq 0x62e4
addq $0xc0, %rbx
movl $0x656c6f73, 0x3(%rax)  # imm = 0x656C6F73
movl $0x736e6f63, (%rax)     # imm = 0x736E6F63
leaq 0x80(%rsp), %rsi
movq %rbx, %rdi
callq 0x17e0c
cmpb $0x0, 0x97(%rsp)
jns 0xb267
movq 0x80(%rsp), %rdi
testq %rdi, %rdi
je 0xb267
callq 0x5480
movq %r15, 0x70(%rsp)
callq 0xbfcf
movq 0x1b760(%rip), %r14     # 0x269d8
leaq 0x1b749(%rip), %rbx     # 0x269c8
cmpq %rbx, %r14
je 0xb2fd
leaq 0x80(%rsp), %r15
cmpb $0x0, 0x3f(%r14)
jns 0xb299
movq 0x28(%r14), %rdi
jmp 0xb29d
leaq 0x28(%r14), %rdi
movq (%rbp), %r12
movq 0x10b8(%r12), %rax
movzbl 0x6d(%r12), %r8d
movq 0xc0(%rax), %rsi
movq 0xc8(%rax), %rdx
xorl %ecx, %ecx
callq 0x7e2f
testb %al, %al
je 0xb2ed
movq 0x1b0e9(%rip), %rdi     # 0x263b8
callq *0x40(%r14)
addq $0x10d0, %r12           # imm = 0x10D0
movq %rax, 0x80(%rsp)
movq %r12, %rdi
movq %r15, %rsi
callq 0x18840
movq %r14, %rdi
callq 0x5280
movq %rax, %r14
cmpq %rbx, %rax
jne 0xb28c
callq 0xbfe5
movq 0x1b707(%rip), %r14     # 0x26a10
leaq 0x1b6f0(%rip), %r13     # 0x26a00
cmpq %r13, %r14
je 0xb360
leaq 0x80(%rsp), %r15
movq (%rbp), %rbx
movq 0x10d0(%rbx), %r12
movq 0x1b089(%rip), %rdi     # 0x263b8
callq *0x40(%r14)
addq $0x10d0, %rbx           # imm = 0x10D0
movq %rax, 0x80(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x189b4
movq %r14, %rdi
callq 0x5280
movq %rax, %r14
cmpq %r13, %rax
jne 0xb31d
movq (%rbp), %rax
cmpb $0x0, 0x74(%rax)
jne 0xb389
cmpb $0x0, 0x82(%rax)
jne 0xb389
cmpb $0x0, 0x81(%rax)
jne 0xb389
cmpb $0x1, 0x86(%rax)
jne 0xb498
movq 0x1b028(%rip), %rax     # 0x263b8
movq 0x10d0(%rax), %r14
movq 0x10d8(%rax), %r15
cmpq %r15, %r14
je 0xb3d6
leaq 0x80(%rsp), %rbx
movq (%r14), %rdi
xorps %xmm0, %xmm0
movaps %xmm0, 0x80(%rsp)
movq $0x0, 0x90(%rsp)
movq (%rdi), %rax
movq %rbx, %rsi
callq *(%rax)
addq $0x8, %r14
cmpq %r15, %r14
jne 0xb3ab
movq 0x1b5db(%rip), %rdi     # 0x269b8
testq %rdi, %rdi
je 0xb3e7
callq 0x5480
leaq 0x1f8(%rsp), %rdi
callq 0x50c0
testb %al, %al
movq 0x70(%rsp), %rbx
je 0xb40a
leaq 0x178(%rsp), %rdi
callq 0x5060
movq %rbx, 0x1afa7(%rip)     # 0x263b8
movb $0x0, 0x1af9d(%rip)     # 0x263b5
movq (%rbp), %rax
movq 0x10d0(%rax), %rbx
movq 0x10d8(%rax), %r14
cmpq %r14, %rbx
je 0xb461
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xb43d
movq (%rdi), %rax
callq *0x68(%rax)
addq $0x8, %rbx
cmpq %r14, %rbx
jne 0xb42f
movq (%rbp), %rax
movq 0x10d0(%rax), %rcx
cmpq %rcx, 0x10d8(%rax)
je 0xb461
movq %rcx, 0x10d8(%rax)
cmpl $0x0, 0x94(%rax)
je 0xb475
movl $0x1, %ebx
cmpb $0x1, 0x73(%rax)
jne 0xb477
xorl %ebx, %ebx
leaq 0x178(%rsp), %rdi
callq 0x50b0
movl %ebx, %eax
addq $0x388, %rsp            # imm = 0x388
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movq $0x0, 0x30(%rsp)
callq 0x851a
movq 0x1af4b(%rip), %rbx     # 0x26400
leaq 0x1af34(%rip), %r12     # 0x263f0
cmpq %r12, %rbx
je 0xb4f5
leaq 0x20(%rsp), %r14
leaq 0x80(%rsp), %r15
leaq 0x20(%rbx), %rax
movq %rax, 0x80(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x18a3e
movq %rbx, %rdi
callq 0x5420
movq %rax, %rbx
cmpq %r12, %rax
jne 0xb4ce
movq 0x20(%rsp), %r15
movq 0x28(%rsp), %r14
movq %r14, %rax
subq %r15, %rax
shrq $0x3, %rax
movq (%rbp), %rbx
movl %eax, 0x88(%rbx)
cmpq %r15, %r14
je 0xb5ed
leaq 0x40(%rbx), %r12
leaq 0x10201(%rip), %rsi     # 0x1b728
movq %r12, %rdi
movl $0x1, %edx
callq 0x6696
testl %eax, %eax
je 0xb5c9
leaq 0x10983(%rip), %rsi     # 0x1bec6
movq %r12, %rdi
movl $0x1, %edx
callq 0x6696
testl %eax, %eax
je 0xb5d2
leaq 0x10975(%rip), %rsi     # 0x1bed0
movq %r12, %rdi
movl $0x1, %edx
callq 0x6696
testl %eax, %eax
je 0xb5db
leaq 0x10636(%rip), %rsi     # 0x1bba9
movq %r12, %rdi
movl $0x1, %edx
callq 0x6696
testl %eax, %eax
jne 0xb5ed
movl 0x58(%rbx), %edi
callq 0x5380
movq 0x20(%rsp), %rbx
movq 0x28(%rsp), %r14
subq %rbx, %r14
sarq $0x3, %r14
cmpq $0x1, %r14
je 0xb5ed
callq 0x50e0
cltq
xorl %edx, %edx
divq %r14
movq -0x8(%rbx,%r14,8), %rax
movslq %edx, %rcx
movq (%rbx,%rcx,8), %rdx
movq %rdx, -0x8(%rbx,%r14,8)
movq %rax, (%rbx,%rcx,8)
decq %r14
jmp 0xb59d
leaq 0xa2b(%rip), %rdx       # 0xbffb
jmp 0xb5e2
leaq 0xa70(%rip), %rdx       # 0xc049
jmp 0xb5e2
leaq 0xa9f(%rip), %rdx       # 0xc081
movq %r15, %rdi
movq %r14, %rsi
callq 0x163e9
leaq 0x150(%rsp), %rcx
movl $0x0, (%rcx)
xorl %eax, %eax
movq %rax, 0x8(%rcx)
movq %rcx, 0x10(%rcx)
movq %rcx, 0x18(%rcx)
movq %rax, 0x20(%rcx)
movq (%rbp), %rax
cmpb $0x0, 0x83(%rax)
jne 0xb627
cmpb $0x1, 0x84(%rax)
jne 0xbe76
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
movq $0x0, 0x50(%rsp)
movb $0x1, %al
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rcx, 0x68(%rsp)
cmpq %rcx, %rax
je 0xbce0
movq %rbp, 0x10(%rsp)
movq (%rax), %r12
movq (%rbp), %r8
cmpb $0x1, 0x38(%r12)
jne 0xb677
movb 0x7a(%r8), %cl
xorb $0x1, %cl
movl %ecx, 0x1c(%rsp)
jmp 0xb67f
movl $0x0, 0x1c(%rsp)
movq %rax, 0x78(%rsp)
cmpb $0x0, 0x17(%r12)
movq %r12, %rbx
jns 0xb693
movq (%r12), %rbx
movq 0x10b8(%r8), %r15
movzbl 0x6d(%r8), %ebp
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
movl $0x1, %ecx
movq %r8, 0x128(%rsp)
movl %ebp, %r8d
callq 0x7e2f
movl %eax, %r14d
movq 0x18(%r15), %rsi
movq 0x20(%r15), %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
movl %ebp, %r8d
callq 0x7e2f
movb %al, 0xb(%rsp)
movq 0x28(%r12), %rbx
movq 0x30(%r15), %rsi
movq 0x38(%r15), %rdx
movq %rbx, %rdi
movl $0x1, %ecx
movl %ebp, %r8d
callq 0x7e2f
movl %eax, %r13d
movq 0x48(%r15), %rsi
movq 0x50(%r15), %rdx
movq %rbx, 0x120(%rsp)
movq %rbx, %rdi
xorl %ecx, %ecx
movl %ebp, %r8d
callq 0x7e2f
movl %eax, %ebx
andb %r14b, %r13b
xorb $0x1, %r13b
movq %r12, 0x60(%rsp)
movq 0x20(%r12), %r14
movq 0x60(%r15), %rsi
movq 0x68(%r15), %rdx
movq %r14, %rdi
movl $0x1, %ecx
movl %ebp, %r8d
callq 0x7e2f
movl %eax, %r12d
orb 0xb(%rsp), %bl
movq 0x78(%r15), %rsi
movq 0x80(%r15), %rdx
movq %r14, %rdi
xorl %ecx, %ecx
movl %ebp, %r8d
callq 0x7e2f
movq 0x128(%rsp), %r8
xorb $0x1, %r12b
orb %bl, %r12b
orb %r13b, %r12b
orb 0x1c(%rsp), %al
orb %r12b, %al
movl 0x8c(%r8), %ecx
testb $0x1, %al
jne 0xb78e
incl %ecx
movl %ecx, 0x8c(%r8)
movq 0x10(%rsp), %rbp
leaq 0x80(%rsp), %r15
leaq 0x1a0be(%rip), %r12     # 0x25860
movl 0x5c(%r8), %edx
movl 0x60(%r8), %esi
cmpl %ecx, %esi
setb %dil
cmpl %esi, %edx
setbe %sil
andb %dil, %sil
cmpl %ecx, %edx
seta %cl
orb %sil, %cl
orb %al, %cl
testb $0x1, %cl
movq 0x60(%rsp), %r13
je 0xb800
cmpb $0x0, 0xc(%rsp)
jne 0xb829
movq 0x1abdd(%rip), %rax     # 0x263b8
movq 0x10d0(%rax), %rbx
movq 0x10d8(%rax), %r14
cmpq %r14, %rbx
je 0xb829
movq (%rbx), %rdi
movq (%rdi), %rax
movq %r13, %rsi
callq *0x58(%rax)
addq $0x8, %rbx
jmp 0xb7e9
cmpb $0x0, 0x83(%r8)
jne 0xb829
cmpb $0x1, 0x84(%r8)
jne 0xb842
movq %r13, 0x80(%rsp)
leaq 0x40(%rsp), %rdi
movq %r15, %rsi
callq 0x19058
movq 0x78(%rsp), %rax
addq $0x8, %rax
cmpq 0x68(%rsp), %rax
jne 0xb65b
jmp 0xbce0
cmpb $0x1, 0x85(%r8)
jne 0xb8bc
movq 0x120(%rsp), %r14
movq %r14, %rdi
callq 0x5170
movq %rax, %rbx
movq %r15, %rdi
movl %ebx, %esi
callq 0x62e4
movl %ebx, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x5300
leaq 0x148(%rsp), %rdi
movq %r15, %rsi
callq 0x191cc
leaq 0x150(%rsp), %rcx
cmpq %rcx, %rax
je 0xbc5a
cmpb $0x0, 0x97(%rsp)
jns 0xb829
movq 0x80(%rsp), %rdi
testq %rdi, %rdi
je 0xb829
callq 0x5480
jmp 0xb829
movq %r13, 0x20(%r8)
movl $0x0, 0xb0(%r8)
movq $0x0, 0xa8(%r8)
xorl %eax, %eax
xorl %ecx, %ecx
xchgl %ecx, 0x8b8(%r8,%rax)
addq $0x40, %rax
cmpq $0x800, %rax            # imm = 0x800
jne 0xb8d8
movq (%rbp), %rax
xorl %ecx, %ecx
xorl %edx, %edx
xchgl %edx, 0xb8(%rax,%rcx)
addq $0x40, %rcx
cmpq $0x800, %rcx            # imm = 0x800
jne 0xb8f4
movq (%rbp), %rdi
movl $0x1128, %eax           # imm = 0x1128
addq %rax, %rdi
callq 0x19408
movq 0x1aa96(%rip), %rax     # 0x263b8
movq 0x10d0(%rax), %rbx
movq 0x10d8(%rax), %r14
cmpq %r14, %rbx
je 0xb947
movq (%rbx), %rdi
movq (%rdi), %rax
movq %r13, %rsi
callq *0x18(%rax)
addq $0x8, %rbx
jmp 0xb930
movq (%rbp), %rbx
movq %r15, %rdi
xorl %esi, %esi
callq 0x5580
imulq $0xf4240, 0x80(%rsp), %rax # imm = 0xF4240
addq 0x88(%rsp), %rax
movq %rax, 0x10f0(%rbx)
movq (%rbp), %rdi
movb $0x1, %bpl
movb $0x0, 0x115c(%rdi)
xorl %ebx, %ebx
movl %ebx, 0x1158(%rdi)
movq 0x1110(%rdi), %rsi
addq $0x1110, %rdi           # imm = 0x1110
callq 0x187f6
movq 0x10(%rsp), %rdx
movq (%rdx), %rax
movb $0x1, %cl
xchgb %cl, 0x115d(%rax)
movq (%rdx), %rdi
movq 0x10f8(%rdi), %rsi
addq $0x10f8, %rdi           # imm = 0x10F8
callq 0x18430
movb $0x1, 0x1b06a(%rip)     # 0x26a30
movq 0x1afeb(%rip), %rax     # 0x269b8
movq %rax, 0x130(%rsp)
movq 0x1aa44(%rip), %rax     # 0x26420
movq %rax, 0x140(%rsp)
movl %ebx, 0x138(%rsp)
leaq 0x130(%rsp), %rdi
leaq 0x1b03e(%rip), %rsi     # 0x26a38
callq 0x5680
movl $0x90, %edx
leaq 0x88(%rsp), %rdi
xorl %esi, %esi
callq 0x51f0
leaq 0x2232(%rip), %rax      # 0xdc4c
movq %rax, 0x80(%rsp)
movl $0x8000000, 0x108(%rsp) # imm = 0x8000000
leaq 0x1b01c(%rip), %rbx     # 0x26a50
xorl %r14d, %r14d
movl (%r14,%r12), %edi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x5460
addq $0x10, %r14
addq $0x98, %rbx
cmpq $0x60, %r14
jne 0xba37
callq *0x50(%r13)
callq 0xc0b6
callq 0xc0b6
movq 0x10(%rsp), %rax
movq (%rax), %rdi
cmpl $0x0, 0x64(%rdi)
jle 0xbaab
movl 0x9c(%rdi), %ecx
xorl %eax, %eax
xorl %edx, %edx
movl 0x8b8(%rdi,%rdx), %esi
addl %esi, %eax
addq $0x40, %rdx
cmpq $0x800, %rdx            # imm = 0x800
jne 0xba7d
addl %ecx, %eax
movq 0x10(%rsp), %rcx
movq (%rcx), %rdi
cmpl 0x64(%rdi), %eax
jl 0xbaab
orb $0x8, 0xb0(%rdi)
xorl %ebp, %ebp
cmpb $0x1, 0x115c(%rdi)
jne 0xbbe8
testb $0x1, %bpl
je 0xbb02
movq 0x1a8f3(%rip), %rax     # 0x263b8
movq 0x10d0(%rax), %rbx
movq 0x10d8(%rax), %r14
cmpq %r14, %rbx
je 0xbb02
movq (%rbx), %rdi
movq (%rdi), %rax
movq %r13, %rsi
callq *0x20(%rax)
addq $0x8, %rbx
cmpq %r14, %rbx
jne 0xbad8
movq 0x10(%rsp), %rax
movq (%rax), %rdi
testb $0x1, 0x115c(%rdi)
je 0xbbe8
testb $0x1, %bpl
jne 0xb977
jmp 0xbbe8
movq %rdx, %rbx
movq %rax, %r14
callq 0xc0b6
movq %r14, %rdi
callq 0x5160
cmpl $0x2, %ebx
jne 0xbb56
movq 0x10(%rsp), %rax
movq (%rax), %rax
orl $0x1, 0xb0(%rax)
callq 0x55a0
leaq 0x80(%rsp), %r15
leaq 0x19d14(%rip), %r12     # 0x25860
movq 0x60(%rsp), %r13
jmp 0xba65
movq 0x1a85b(%rip), %rax     # 0x263b8
movq 0x10d0(%rax), %r14
movq 0x10d8(%rax), %r15
cmpq %r15, %r14
je 0xbbbb
movq (%r14), %rbx
leaq 0x80(%rsp), %rdi
callq 0x8a71
movb $0x0, 0x98(%rsp)
movq (%rbx), %rax
movq %rbx, %rdi
leaq 0x80(%rsp), %rsi
callq *0x30(%rax)
cmpb $0x0, 0x97(%rsp)
jns 0xbbb5
movq 0x80(%rsp), %rdi
testq %rdi, %rdi
je 0xbbb5
callq 0x5480
addq $0x8, %r14
jmp 0xbb6b
movq 0x10(%rsp), %rax
movq (%rax), %rax
orl $0x2, 0xb0(%rax)
callq 0x55a0
leaq 0x80(%rsp), %r15
leaq 0x19c82(%rip), %r12     # 0x25860
movq 0x60(%rsp), %r13
jmp 0xba65
callq 0x16430
movq 0x1a7c4(%rip), %rax     # 0x263b8
movq 0x10d0(%rax), %rbx
movq 0x10d8(%rax), %r14
cmpq %r14, %rbx
movq 0x10(%rsp), %rbp
je 0xbc2d
movq (%rbx), %rdi
movq 0x1a7a2(%rip), %rsi     # 0x263b8
movl $0xa0, %eax
addq %rax, %rsi
movq (%rdi), %rax
callq *0x28(%rax)
addq $0x8, %rbx
cmpq %r14, %rbx
jne 0xbc0c
movq (%rbp), %rax
movq $0x0, 0x20(%rax)
movl 0x64(%rax), %ecx
testl %ecx, %ecx
jle 0xb829
cmpl %ecx, 0x9c(%rax)
movq 0x78(%rsp), %rax
jl 0xb82e
jmp 0xbce0
movq 0x28(%r13), %rax
movb (%rax), %bl
cmpb $0x0, 0x97(%rsp)
jns 0xbc7c
movq 0x80(%rsp), %rdi
testq %rdi, %rdi
je 0xbc7c
callq 0x5480
testb %bl, %bl
je 0xb829
movq %r13, 0x80(%rsp)
leaq 0x40(%rsp), %rdi
movq %r15, %rsi
callq 0x19058
movq 0x28(%r13), %rsi
movq %r15, %rdi
callq 0x638a
leaq 0x148(%rsp), %rdi
movq %r15, %rsi
callq 0x19272
cmpb $0x0, 0x97(%rsp)
jns 0xbcd1
movq 0x80(%rsp), %rdi
testq %rdi, %rdi
je 0xbcd1
callq 0x5480
movq (%rbp), %rax
incl 0x90(%rax)
jmp 0xb829
cmpb $0x0, 0xc(%rsp)
je 0xbd55
movq 0x1a6ca(%rip), %rax     # 0x263b8
leaq 0x88(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
movq %rcx, 0x80(%rsp)
movq 0x40(%rsp), %rcx
movq 0x48(%rsp), %rdx
movq %rcx, 0x88(%rsp)
subq %rcx, %rdx
shrq $0x3, %rdx
movl %edx, 0x90(%rsp)
movq 0x10d0(%rax), %r14
movq 0x10d8(%rax), %r15
cmpq %r15, %r14
je 0xbd91
leaq 0x80(%rsp), %rbx
movq (%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *(%rax)
addq $0x8, %r14
cmpq %r15, %r14
jne 0xbd3f
jmp 0xbd91
movq 0x1a65c(%rip), %rax     # 0x263b8
movq 0x10d0(%rax), %rbx
movq 0x10d8(%rax), %r14
cmpq %r14, %rbx
je 0xbd91
movl $0x88, %r15d
movq (%rbx), %rdi
movq 0x1a639(%rip), %rsi     # 0x263b8
addq %r15, %rsi
movq (%rdi), %rax
callq *0x10(%rax)
addq $0x8, %rbx
cmpq %r14, %rbx
jne 0xbd75
movq 0x1ac20(%rip), %rdi     # 0x269b8
testq %rdi, %rdi
je 0xbda2
callq 0x5480
leaq 0x1f8(%rsp), %rdi
callq 0x50c0
testb %al, %al
movq 0x70(%rsp), %rbx
je 0xbdc5
leaq 0x178(%rsp), %rdi
callq 0x5060
movq %rbx, 0x1a5ec(%rip)     # 0x263b8
movb $0x0, 0x1a5e2(%rip)     # 0x263b5
movq (%rbp), %rax
movq 0x10d0(%rax), %rbx
movq 0x10d8(%rax), %r14
cmpq %r14, %rbx
je 0xbe1c
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xbdf8
movq (%rdi), %rax
callq *0x68(%rax)
addq $0x8, %rbx
cmpq %r14, %rbx
jne 0xbdea
movq (%rbp), %rax
movq 0x10d0(%rax), %rcx
cmpq %rcx, 0x10d8(%rax)
je 0xbe1c
movq %rcx, 0x10d8(%rax)
cmpl $0x0, 0x94(%rax)
je 0xbe30
movl $0x1, %ebx
cmpb $0x1, 0x73(%rax)
jne 0xbe32
xorl %ebx, %ebx
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0xbe49
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x53d0
leaq 0x148(%rsp), %rdi
callq 0x16cd6
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0xb477
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x53d0
jmp 0xb477
cmpb $0x0, 0x85(%rax)
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
movq $0x0, 0x50(%rsp)
movb $0x1, %al
movl %eax, 0xc(%rsp)
jne 0xb63e
movq 0x1a517(%rip), %rax     # 0x263b8
movq 0x10d0(%rax), %rbx
movq 0x10d8(%rax), %r14
cmpq %r14, %rbx
je 0xbec3
movq (%rbx), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %rbx
jmp 0xbeaf
movl $0x0, 0xc(%rsp)
jmp 0xb63e
jmp 0xbf73
movq %rax, %rbx
cmpb $0x0, 0x97(%rsp)
jns 0xbef9
movq 0x80(%rsp), %rdi
testq %rdi, %rdi
je 0xbef9
callq 0x5480
jmp 0xbef9
movq %rax, %rbx
callq 0x55a0
jmp 0xbf76
movq %rax, %rdi
callq 0x16173
jmp 0xbf73
jmp 0xbf14
jmp 0xbf73
jmp 0xbf73
jmp 0xbf68
jmp 0xbf73
movq %rax, %rbx
cmpb $0x0, 0x97(%rsp)
jns 0xbf76
movq 0x80(%rsp), %rdi
testq %rdi, %rdi
je 0xbf76
callq 0x5480
jmp 0xbf76
jmp 0xbf73
jmp 0xbf73
jmp 0xbf73
jmp 0xbf73
movq %rax, %rbx
cmpb $0x0, 0x97(%rsp)
jns 0xbfba
movq 0x80(%rsp), %rdi
testq %rdi, %rdi
je 0xbfba
callq 0x5480
jmp 0xbfba
jmp 0xbfb7
jmp 0xbfb7
jmp 0xbf73
jmp 0xbf73
jmp 0xbfb7
movq %rax, %rbx
jmp 0xbf9a
jmp 0xbf73
jmp 0xbf73
jmp 0xbf73
movq %rax, %rbx
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0xbf8d
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x53d0
leaq 0x148(%rsp), %rdi
callq 0x16cd6
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0xbfba
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x53d0
jmp 0xbfba
jmp 0xbfb7
jmp 0xbfb7
movq %rax, %rbx
leaq 0x178(%rsp), %rdi
callq 0x50b0
movq %rbx, %rdi
callq 0x5620