// File: /workspace/github_cpp_makefile_star2_O2/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 $0x398, %rsp            # imm = 0x398
movq %rdi, %rbp
movq 0x1a873(%rip), %rax     # 0x243d8
movq %rax, 0x80(%rsp)
movq (%rdi), %rax
movq %rax, 0x1a861(%rip)     # 0x243d8
movb $0x1, 0x1a857(%rip)     # 0x243d5
movb 0x77(%rax), %cl
movb %cl, %fs:-0x38
xorps %xmm0, %xmm0
movups %xmm0, 0x98(%rax)
movups %xmm0, 0x88(%rax)
leaq 0x188(%rsp), %r14
movq %r14, %rdi
callq 0x5460
movq (%rbp), %r15
cmpq $0x0, (%r15)
jne 0x9c1a
cmpb $0x1, 0x71(%r15)
jne 0x9bc4
leaq 0x1a896(%rip), %rax     # 0x24458
jmp 0x9c17
movzbl 0x3f(%r15), %eax
testb %al, %al
jns 0x9bd3
movl 0x30(%r15), %ecx
jmp 0x9bdd
movl %eax, %edx
andl $0x1f, %edx
pushq $0x17
popq %rcx
subl %edx, %ecx
testl %ecx, %ecx
je 0x9beb
testb %al, %al
jns 0x9bf4
movq 0x28(%r15), %r15
jmp 0x9bf8
movq 0x1a3ce(%rip), %rax     # 0x23fc0
jmp 0x9c17
addq $0x28, %r15
leaq 0x188(%rsp), %rdi
pushq $0x10
popq %rdx
movq %r15, %rsi
callq 0x5370
leaq 0x198(%rsp), %rax
movq (%rbp), %r15
movq %rax, (%r15)
movq 0x1a81f(%rip), %rdi     # 0x24440
callq 0x5030
movq %rax, 0x1adab(%rip)     # 0x249d8
movq %r14, 0x88(%rsp)
leaq 0x80(%rsp), %rax
movq %rax, 0x90(%rsp)
movq %rbp, 0x98(%rsp)
movq 0x10b8(%r15), %r14
movq 0xc0(%r14), %rax
cmpq 0xc8(%r14), %rax
jne 0x9c9c
leaq 0xd9c1(%rip), %rsi      # 0x1762c
leaq 0xa0(%rsp), %rdi
callq 0x5eaa
addq $0xc0, %r14
leaq 0xa0(%rsp), %rsi
movq %r14, %rdi
callq 0x13f12
leaq 0xa0(%rsp), %rdi
callq 0x5e96
callq 0xa72a
movq 0x1ad50(%rip), %r14     # 0x249f8
leaq 0x1ad39(%rip), %rbx     # 0x249e8
movl $0xc0, %r13d
leaq 0xa0(%rsp), %r15
cmpq %rbx, %r14
je 0x9d25
cmpb $0x0, 0x3f(%r14)
jns 0x9ccf
movq 0x28(%r14), %rdi
jmp 0x9cd3
leaq 0x28(%r14), %rdi
movq (%rbp), %r12
movq 0x10b8(%r12), %rsi
addq %r13, %rsi
movzbl 0x6d(%r12), %ecx
xorl %edx, %edx
callq 0x714e
testb %al, %al
je 0x9d18
movq 0x1a6de(%rip), %rdi     # 0x243d8
callq *0x40(%r14)
addq $0x10d0, %r12           # imm = 0x10D0
movq %rax, 0xa0(%rsp)
movq %r12, %rdi
movq %r15, %rsi
callq 0x146fc
movq %r14, %rdi
callq 0x52a0
movq %rax, %r14
jmp 0x9cbd
callq 0xa79a
movq 0x1acff(%rip), %r15     # 0x24a30
leaq 0x1ace8(%rip), %rbx     # 0x24a20
leaq 0xa0(%rsp), %r14
movq (%rbp), %r12
cmpq %rbx, %r15
je 0x9d86
movq 0x10d0(%r12), %r13
movq 0x1a680(%rip), %rdi     # 0x243d8
callq *0x40(%r15)
addq $0x10d0, %r12           # imm = 0x10D0
movq %rax, 0xa0(%rsp)
movq %r12, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x14878
movq %r15, %rdi
callq 0x52a0
movq %rax, %r15
jmp 0x9d40
cmpb $0x0, 0x74(%r12)
jne 0x9daf
cmpb $0x0, 0x82(%r12)
jne 0x9daf
cmpb $0x0, 0x81(%r12)
jne 0x9daf
cmpb $0x1, 0x86(%r12)
jne 0x9e26
movq 0x1a622(%rip), %rax     # 0x243d8
movq 0x10d0(%rax), %r14
movq 0x10d8(%rax), %r15
leaq 0xa0(%rsp), %rbx
cmpq %r15, %r14
je 0x9df6
movq (%r14), %rdi
xorps %xmm0, %xmm0
movaps %xmm0, 0xa0(%rsp)
andq $0x0, 0xb0(%rsp)
movq (%rdi), %rax
movq %rbx, %rsi
callq *(%rax)
addq $0x8, %r14
jmp 0x9dcc
leaq 0x88(%rsp), %rdi
callq 0xa80a
movl %eax, %ebx
leaq 0x188(%rsp), %rdi
callq 0x50c0
movl %ebx, %eax
addq $0x398, %rsp            # imm = 0x398
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorps %xmm0, %xmm0
leaq 0x50(%rsp), %r14
movaps %xmm0, (%r14)
andq $0x0, 0x10(%r14)
callq 0x7655
movq 0x1a5dd(%rip), %r12     # 0x24420
leaq 0x1a5c6(%rip), %rbx     # 0x24410
leaq 0xa0(%rsp), %r15
cmpq %rbx, %r12
je 0x9e7c
leaq 0x20(%r12), %rax
movq %rax, 0xa0(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x14948
movq %r12, %rdi
callq 0x5440
movq %rax, %r12
jmp 0x9e52
movq 0x50(%rsp), %r15
movq 0x58(%rsp), %r14
movq %r14, %rax
subq %r15, %rax
shrq $0x3, %rax
movq (%rbp), %rbx
movl %eax, 0x88(%rbx)
cmpq %r15, %r14
je 0x9f6c
leaq 0x40(%rbx), %r12
leaq 0xd883(%rip), %rsi      # 0x17731
pushq $0x1
popq %rdx
movq %r12, %rdi
callq 0x615a
testl %eax, %eax
je 0x9f48
leaq 0xe03a(%rip), %rsi      # 0x17f02
pushq $0x1
popq %rdx
movq %r12, %rdi
callq 0x615a
testl %eax, %eax
je 0x9f51
leaq 0xe02e(%rip), %rsi      # 0x17f0c
pushq $0x1
popq %rdx
movq %r12, %rdi
callq 0x615a
testl %eax, %eax
je 0x9f5a
leaq 0xdcc0(%rip), %rsi      # 0x17bb4
pushq $0x1
popq %rdx
movq %r12, %rdi
callq 0x615a
testl %eax, %eax
jne 0x9f6c
movl 0x58(%rbx), %edi
callq 0x53c0
movq 0x50(%rsp), %rbx
movq 0x58(%rsp), %r14
subq %rbx, %r14
sarq $0x3, %r14
cmpq $0x1, %r14
je 0x9f6c
callq 0x5110
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 0x9f1c
leaq 0x968(%rip), %rdx       # 0xa8b7
jmp 0x9f61
leaq 0x999(%rip), %rdx       # 0xa8f1
jmp 0x9f61
leaq 0x9c5(%rip), %rdx       # 0xa926
movq %r15, %rdi
movq %r14, %rsi
callq 0x14ac3
leaq 0x160(%rsp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
movq (%rbp), %rax
cmpb $0x0, 0x83(%rax)
jne 0x9fa3
cmpb $0x1, 0x84(%rax)
jne 0xa61d
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
andq $0x0, 0x40(%rsp)
movb $0x1, %al
movl %eax, 0xc(%rsp)
movq 0x50(%rsp), %r12
movq 0x58(%rsp), %rax
movq %rax, 0x70(%rsp)
movq %rbp, 0x10(%rsp)
cmpq 0x70(%rsp), %r12
je 0xa54c
movq (%r12), %r13
movq (%rbp), %rax
cmpb $0x1, 0x38(%r13)
jne 0x9ff1
movb 0x7a(%rax), %cl
xorb $0x1, %cl
movl %ecx, 0x24(%rsp)
jmp 0x9ff9
movl $0x0, 0x24(%rsp)
movq %r12, 0x28(%rsp)
cmpb $0x0, 0x17(%r13)
movq %r13, %r15
jns 0xa00c
movq (%r13), %r15
movq 0x10b8(%rax), %r12
movzbl 0x6d(%rax), %ebp
movq %r15, %rdi
movq %r12, %rsi
pushq $0x1
popq %r14
movl %r14d, %edx
movl %ebp, %ecx
movq %rax, 0x78(%rsp)
callq 0x714e
movb %al, 0x18(%rsp)
leaq 0x18(%r12), %rsi
movq %r15, %rdi
xorl %edx, %edx
movl %ebp, %ecx
callq 0x714e
movb %al, 0xb(%rsp)
movq 0x28(%r13), %rbx
leaq 0x30(%r12), %rsi
movq %rbx, %rdi
movl %r14d, %edx
movl %ebp, %ecx
callq 0x714e
movl %eax, %r15d
leaq 0x48(%r12), %rsi
movq %rbx, 0x68(%rsp)
movq %rbx, %rdi
xorl %edx, %edx
movl %ebp, %ecx
callq 0x714e
movl %eax, %ebx
andb 0x18(%rsp), %r15b
xorb $0x1, %r15b
movq %r13, 0x18(%rsp)
movq 0x20(%r13), %r13
leaq 0x60(%r12), %rsi
movq %r13, %rdi
movl %r14d, %edx
movl %ebp, %ecx
callq 0x714e
movl %eax, %r14d
orb 0xb(%rsp), %bl
addq $0x78, %r12
movq %r13, %rdi
movq %r12, %rsi
xorl %edx, %edx
movl %ebp, %ecx
callq 0x714e
movq 0x78(%rsp), %rdi
xorb $0x1, %r14b
orb %bl, %r14b
orb %r15b, %r14b
orb 0x24(%rsp), %al
orb %r14b, %al
movl 0x8c(%rdi), %ecx
testb $0x1, %al
jne 0xa0e0
incl %ecx
movl %ecx, 0x8c(%rdi)
movq 0x10(%rsp), %rbp
movq 0x28(%rsp), %r12
leaq 0xa0(%rsp), %r13
movl 0x5c(%rdi), %edx
movl 0x60(%rdi), %esi
cmpl %ecx, %esi
setb %r8b
cmpl %esi, %edx
setbe %sil
andb %r8b, %sil
cmpl %ecx, %edx
seta %cl
orb %sil, %cl
orb %al, %cl
testb $0x1, %cl
movq 0x18(%rsp), %r15
je 0xa156
cmpb $0x0, 0xc(%rsp)
jne 0xa543
movq 0x1a2ab(%rip), %rax     # 0x243d8
movq 0x10d0(%rax), %rbx
movq 0x10d8(%rax), %r14
cmpq %r14, %rbx
je 0xa543
movq (%rbx), %rdi
movq (%rdi), %rax
movq %r15, %rsi
callq *0x58(%rax)
addq $0x8, %rbx
jmp 0xa13b
cmpb $0x0, 0x83(%rdi)
jne 0xa543
cmpb $0x1, 0x84(%rdi)
jne 0xa186
movq %r15, 0xa0(%rsp)
leaq 0x30(%rsp), %rdi
movq %r13, %rsi
callq 0x150a2
jmp 0xa543
cmpb $0x1, 0x85(%rdi)
jne 0xa1c2
movq %r13, %rdi
movq 0x68(%rsp), %rsi
callq 0x5eaa
leaq 0x158(%rsp), %rdi
movq %r13, %rsi
callq 0x12556
testq %rax, %rax
je 0xa4ee
movq %r13, %rdi
callq 0x5e96
jmp 0xa543
movq %r15, 0x20(%rdi)
andl $0x0, 0xb0(%rdi)
andq $0x0, 0xa8(%rdi)
addq $0x8b8, %rdi            # imm = 0x8B8
xorl %esi, %esi
callq 0x12570
movq (%rbp), %rdi
movl $0xb8, %eax
addq %rax, %rdi
xorl %esi, %esi
callq 0x12570
movq (%rbp), %rdi
movl $0x1128, %eax           # imm = 0x1128
addq %rax, %rdi
callq 0x15434
movq 0x1a1ca(%rip), %rax     # 0x243d8
movq 0x10d0(%rax), %rbx
movq 0x10d8(%rax), %r14
cmpq %r14, %rbx
je 0xa233
movq (%rbx), %rdi
movq (%rdi), %rax
movq %r15, %rsi
callq *0x18(%rax)
addq $0x8, %rbx
jmp 0xa21c
movq (%rbp), %rbx
callq 0x5de0
movq %rax, 0x10f0(%rbx)
movq (%rbp), %rdi
movb $0x1, %bpl
movb $0x0, 0x115c(%rdi)
andl $0x0, 0x1158(%rdi)
addq $0x1110, %rdi           # imm = 0x1110
callq 0x1258c
movq 0x10(%rsp), %rdx
movq (%rdx), %rax
movb $0x1, %cl
xchgb %cl, 0x115d(%rax)
movq (%rdx), %rdi
movl $0x10f8, %eax           # imm = 0x10F8
addq %rax, %rdi
callq 0x124b6
movb $0x1, 0x1a7c5(%rip)     # 0x24a50
movq 0x1a746(%rip), %rax     # 0x249d8
movq %rax, 0x140(%rsp)
movq 0x1a19f(%rip), %rax     # 0x24440
movq %rax, 0x150(%rsp)
andl $0x0, 0x148(%rsp)
leaq 0x140(%rsp), %rdi
leaq 0x1a798(%rip), %rsi     # 0x24a58
callq 0x56c0
movl $0x90, %edx
leaq 0xa8(%rsp), %rdi
xorl %esi, %esi
callq 0x5220
leaq 0x1bda(%rip), %rax      # 0xbeba
movq %rax, 0xa0(%rsp)
movl $0x8000000, 0x128(%rsp) # imm = 0x8000000
xorl %ebx, %ebx
leaq 0x1a774(%rip), %r15     # 0x24a70
cmpq $0x60, %rbx
je 0xa324
leaq 0x19547(%rip), %rax     # 0x23850
movl (%rbx,%rax), %edi
movq %r13, %rsi
movq %r15, %rdx
callq 0x5490
addq $0x98, %r15
addq $0x10, %rbx
jmp 0xa2fc
movq 0x18(%rsp), %r15
callq *0x50(%r15)
callq 0xa95c
callq 0xa95c
movq 0x10(%rsp), %r14
movq (%r14), %rdi
cmpl $0x0, 0x64(%rdi)
jle 0xa36a
movl 0x9c(%rdi), %ebx
addq $0x8b8, %rdi            # imm = 0x8B8
callq 0x122c2
addl %ebx, %eax
movq (%r14), %rdi
cmpl 0x64(%rdi), %eax
jl 0xa36a
orb $0x8, 0xb0(%rdi)
xorl %ebp, %ebp
cmpb $0x1, 0x115c(%rdi)
jne 0xa491
testb $0x1, %bpl
je 0xa3be
movq 0x1a054(%rip), %rax     # 0x243d8
movq 0x10d0(%rax), %rbx
movq 0x10d8(%rax), %r14
cmpq %r14, %rbx
je 0xa3a9
movq (%rbx), %rdi
movq (%rdi), %rax
movq %r15, %rsi
callq *0x20(%rax)
addq $0x8, %rbx
jmp 0xa392
movq 0x10(%rsp), %rax
movq (%rax), %rdi
testb $0x1, 0x115c(%rdi)
je 0xa491
testb $0x1, %bpl
jne 0xa24a
jmp 0xa491
movq %rdx, %rbx
movq %rax, %r14
callq 0xa95c
movq %r14, %rdi
callq 0x5180
cmpl $0x2, %ebx
jne 0xa410
movq 0x10(%rsp), %rax
movq (%rax), %rax
orl $0x1, 0xb0(%rax)
callq 0x55f0
movq 0x28(%rsp), %r12
leaq 0xa0(%rsp), %r13
movq 0x18(%rsp), %r15
jmp 0xa337
movq 0x19fc1(%rip), %rax     # 0x243d8
movq 0x10d0(%rax), %rbx
movq 0x10d8(%rax), %r14
cmpq %r14, %rbx
je 0xa466
movq (%rbx), %r15
leaq 0xa0(%rsp), %rdi
callq 0x7b00
movb $0x0, 0xb8(%rsp)
movq (%r15), %rax
movq %r15, %rdi
leaq 0xa0(%rsp), %rsi
callq *0x30(%rax)
leaq 0xa0(%rsp), %rdi
callq 0x5e96
addq $0x8, %rbx
jmp 0xa425
movq 0x10(%rsp), %rax
movq (%rax), %rax
orl $0x2, 0xb0(%rax)
callq 0x55f0
movq 0x28(%rsp), %r12
leaq 0xa0(%rsp), %r13
movq 0x18(%rsp), %r15
jmp 0xa337
callq 0x12594
movq 0x19f3b(%rip), %rax     # 0x243d8
movq 0x10d0(%rax), %rbx
movq 0x10d8(%rax), %r14
movq 0x10(%rsp), %rbp
movl $0xa0, %r15d
cmpq %r14, %rbx
je 0xa4d4
movq (%rbx), %rdi
movq 0x19f13(%rip), %rsi     # 0x243d8
addq %r15, %rsi
movq (%rdi), %rax
callq *0x28(%rax)
addq $0x8, %rbx
jmp 0xa4b6
movq (%rbp), %rax
andq $0x0, 0x20(%rax)
movl 0x64(%rax), %ecx
testl %ecx, %ecx
jle 0xa543
cmpl %ecx, 0x9c(%rax)
jl 0xa543
jmp 0xa54c
movq 0x28(%r15), %rax
movb (%rax), %bl
movq %r13, %rdi
callq 0x5e96
testb %bl, %bl
je 0xa543
movq %r15, 0xa0(%rsp)
leaq 0x30(%rsp), %rdi
movq %r13, %rsi
callq 0x150a2
movq 0x28(%r15), %rsi
movq %r13, %rdi
callq 0x5eaa
leaq 0x158(%rsp), %rdi
movq %r13, %rsi
callq 0x15294
movq %r13, %rdi
callq 0x5e96
movq (%rbp), %rax
incl 0x90(%rax)
addq $0x8, %r12
jmp 0x9fcb
cmpb $0x0, 0xc(%rsp)
je 0xa5af
movq 0x19e7e(%rip), %rax     # 0x243d8
leaq 0x88(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
leaq 0xa0(%rsp), %rbx
movq %rcx, (%rbx)
movq 0x30(%rsp), %rcx
movq 0x38(%rsp), %rdx
movq %rcx, 0x8(%rbx)
subq %rcx, %rdx
shrq $0x3, %rdx
movl %edx, 0x10(%rbx)
movq 0x10d0(%rax), %r14
movq 0x10d8(%rax), %r15
cmpq %r15, %r14
je 0xa5e8
movq (%r14), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *(%rax)
addq $0x8, %r14
jmp 0xa599
movq 0x19e22(%rip), %rax     # 0x243d8
movq 0x10d0(%rax), %rbx
movq 0x10d8(%rax), %r14
movl $0x88, %r15d
cmpq %r14, %rbx
je 0xa5e8
movq (%rbx), %rdi
movq 0x19dff(%rip), %rsi     # 0x243d8
addq %r15, %rsi
movq (%rdi), %rax
callq *0x10(%rax)
addq $0x8, %rbx
jmp 0xa5ca
leaq 0x88(%rsp), %rdi
callq 0xa80a
movl %eax, %ebx
leaq 0x30(%rsp), %rdi
callq 0x1506e
leaq 0x158(%rsp), %rdi
callq 0x12f2c
leaq 0x50(%rsp), %rdi
callq 0x14914
jmp 0x9e05
movb 0x85(%rax), %al
andq $0x0, 0x40(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movb $0x1, %cl
movl %ecx, 0xc(%rsp)
testb %al, %al
jne 0x9fb7
movq 0x19d92(%rip), %rax     # 0x243d8
movq 0x10d0(%rax), %rbx
movq 0x10d8(%rax), %r14
cmpq %r14, %rbx
je 0xa668
movq (%rbx), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %rbx
jmp 0xa654
movl $0x0, 0xc(%rsp)
jmp 0x9fb7
jmp 0xa6e8
movq %rax, %rbx
leaq 0xa0(%rsp), %rdi
callq 0x5e96
jmp 0xa68c
movq %rax, %rbx
callq 0x55f0
jmp 0xa6eb
movq %rax, %rdi
callq 0x122b7
jmp 0xa6e8
jmp 0xa6a7
jmp 0xa6e8
jmp 0xa6e8
jmp 0xa6dd
jmp 0xa6e8
movq %rax, %rbx
leaq 0xa0(%rsp), %rdi
callq 0x5e96
jmp 0xa6eb
jmp 0xa6e8
jmp 0xa6e8
jmp 0xa6e8
jmp 0xa6e8
movq %rax, %rbx
leaq 0xa0(%rsp), %rdi
callq 0x5e96
jmp 0xa715
jmp 0xa712
jmp 0xa712
jmp 0xa6e8
jmp 0xa6e8
jmp 0xa712
movq %rax, %rbx
jmp 0xa702
jmp 0xa6e8
jmp 0xa6e8
jmp 0xa6e8
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x1506e
leaq 0x158(%rsp), %rdi
callq 0x12f2c
leaq 0x50(%rsp), %rdi
callq 0x14914
jmp 0xa715
jmp 0xa712
jmp 0xa712
movq %rax, %rbx
leaq 0x188(%rsp), %rdi
callq 0x50c0
movq %rbx, %rdi
callq 0x5670