// File: /workspace/github_cpp_makefile_star2_O1/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 $0x368, %rsp            # imm = 0x368
movq %rdi, %rbx
movq 0x1b083(%rip), %r15     # 0x263b8
movq (%rdi), %rax
movq %rax, 0x1b079(%rip)     # 0x263b8
movb $0x1, 0x1b06f(%rip)     # 0x263b5
movq (%rdi), %rax
movb 0x77(%rax), %cl
movb %cl, %fs:-0x38
xorps %xmm0, %xmm0
movups %xmm0, 0x98(%rax)
movups %xmm0, 0x88(%rax)
leaq 0x158(%rsp), %rdi
callq 0x5430
movq (%rbx), %rsi
cmpq $0x0, (%rsi)
jne 0xb3e1
cmpb $0x1, 0x71(%rsi)
jne 0xb38a
leaq 0x1b0b0(%rip), %rax     # 0x26438
jmp 0xb3b8
movzbl 0x3f(%rsi), %eax
testb %al, %al
jns 0xb397
movl 0x30(%rsi), %ecx
jmp 0xb3a3
movl %eax, %edx
andl $0x1f, %edx
movl $0x17, %ecx
subl %edx, %ecx
testl %ecx, %ecx
je 0xb3b1
testb %al, %al
jns 0xb3bd
movq 0x28(%rsi), %rsi
jmp 0xb3c1
movq 0x1ac10(%rip), %rax     # 0x25fc8
movq %rax, (%rsi)
jmp 0xb3e1
addq $0x28, %rsi
leaq 0x158(%rsp), %rdi
movl $0x10, %edx
callq 0x5330
leaq 0x168(%rsp), %rax
movq (%rbx), %rcx
movq %rax, (%rcx)
movq 0x1b038(%rip), %rdi     # 0x26420
callq 0x5030
movq %rax, 0x1b5c4(%rip)     # 0x269b8
movq (%rbx), %rax
movq 0x10b8(%rax), %r14
movq 0xc0(%r14), %rax
cmpq 0xc8(%r14), %rax
jne 0xb454
leaq 0x60(%rsp), %rdi
movl $0x7, %esi
callq 0x640c
addq $0xc0, %r14
movl $0x656c6f73, 0x3(%rax)  # imm = 0x656C6F73
movl $0x736e6f63, (%rax)     # imm = 0x736E6F63
leaq 0x60(%rsp), %rsi
movq %r14, %rdi
callq 0x17e38
cmpb $0x0, 0x77(%rsp)
jns 0xb454
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0xb454
callq 0x5480
movq %r15, 0x58(%rsp)
callq 0xc14b
movq 0x1b573(%rip), %r14     # 0x269d8
leaq 0x1b55c(%rip), %r13     # 0x269c8
cmpq %r13, %r14
je 0xb4dd
movl $0xc0, %ebp
leaq 0x60(%rsp), %r15
cmpb $0x0, 0x3f(%r14)
jns 0xb488
movq 0x28(%r14), %rdi
jmp 0xb48c
leaq 0x28(%r14), %rdi
movq (%rbx), %r12
movq 0x10b8(%r12), %rsi
addq %rbp, %rsi
movzbl 0x6d(%r12), %ecx
xorl %edx, %edx
callq 0x7f96
testb %al, %al
je 0xb4cd
movq 0x1af06(%rip), %rdi     # 0x263b8
callq *0x40(%r14)
addq $0x10d0, %r12           # imm = 0x10D0
movq %rax, 0x60(%rsp)
movq %r12, %rdi
movq %r15, %rsi
callq 0x18846
movq %r14, %rdi
callq 0x5280
movq %rax, %r14
cmpq %r13, %rax
jne 0xb47b
callq 0xc161
movq 0x1b527(%rip), %r14     # 0x26a10
leaq 0x1b510(%rip), %rbp     # 0x26a00
cmpq %rbp, %r14
je 0xb53a
leaq 0x60(%rsp), %r15
movq (%rbx), %r12
movq 0x10d0(%r12), %r13
movq 0x1aeac(%rip), %rdi     # 0x263b8
callq *0x40(%r14)
addq $0x10d0, %r12           # imm = 0x10D0
movq %rax, 0x60(%rsp)
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x189b2
movq %r14, %rdi
callq 0x5280
movq %rax, %r14
cmpq %rbp, %rax
jne 0xb4fa
movq (%rbx), %rax
cmpb $0x0, 0x74(%rax)
jne 0xb562
cmpb $0x0, 0x82(%rax)
jne 0xb562
cmpb $0x0, 0x81(%rax)
jne 0xb562
cmpb $0x1, 0x86(%rax)
jne 0xb663
movq 0x1ae4f(%rip), %rax     # 0x263b8
movq 0x10d0(%rax), %r15
movq 0x10d8(%rax), %r12
cmpq %r12, %r15
je 0xb5a6
leaq 0x60(%rsp), %r14
movq (%r15), %rdi
xorps %xmm0, %xmm0
movaps %xmm0, 0x60(%rsp)
movq $0x0, 0x70(%rsp)
movq (%rdi), %rax
movq %r14, %rsi
callq *(%rax)
addq $0x8, %r15
cmpq %r12, %r15
jne 0xb581
movq 0x1b40b(%rip), %rdi     # 0x269b8
testq %rdi, %rdi
je 0xb5b7
callq 0x5480
leaq 0x1d8(%rsp), %rdi
callq 0x50c0
testb %al, %al
movq 0x58(%rsp), %r14
je 0xb5da
leaq 0x158(%rsp), %rdi
callq 0x5060
movq %r14, 0x1add7(%rip)     # 0x263b8
movb $0x0, 0x1adcd(%rip)     # 0x263b5
movq (%rbx), %rax
movq 0x10d0(%rax), %r14
movq 0x10d8(%rax), %r15
cmpq %r15, %r14
je 0xb612
movq (%r14), %rdi
testq %rdi, %rdi
je 0xb60c
movq (%rdi), %rax
callq *0x68(%rax)
addq $0x8, %r14
jmp 0xb5f9
movq (%rbx), %rax
movq 0x10d0(%rax), %rcx
cmpq %rcx, 0x10d8(%rax)
je 0xb62c
movq %rcx, 0x10d8(%rax)
cmpl $0x0, 0x94(%rax)
je 0xb640
movl $0x1, %ebx
cmpb $0x1, 0x73(%rax)
jne 0xb642
xorl %ebx, %ebx
leaq 0x158(%rsp), %rdi
callq 0x50b0
movl %ebx, %eax
addq $0x368, %rsp            # imm = 0x368
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 0x86d4
movq 0x1ad80(%rip), %r14     # 0x26400
leaq 0x1ad69(%rip), %r13     # 0x263f0
cmpq %r13, %r14
je 0xb6ba
leaq 0x20(%rsp), %r15
leaq 0x60(%rsp), %r12
leaq 0x20(%r14), %rax
movq %rax, 0x60(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x18a3c
movq %r14, %rdi
callq 0x5420
movq %rax, %r14
cmpq %r13, %rax
jne 0xb696
movq 0x20(%rsp), %r15
movq 0x28(%rsp), %r14
movq %r14, %rax
subq %r15, %rax
shrq $0x3, %rax
movq (%rbx), %r13
movl %eax, 0x88(%r13)
cmpq %r15, %r14
je 0xb7b3
leaq 0x40(%r13), %r12
leaq 0x1002c(%rip), %rsi     # 0x1b718
movq %r12, %rdi
movl $0x1, %edx
callq 0x67ac
testl %eax, %eax
je 0xb78f
leaq 0x107ae(%rip), %rsi     # 0x1beb6
movq %r12, %rdi
movl $0x1, %edx
callq 0x67ac
testl %eax, %eax
je 0xb798
leaq 0x107a0(%rip), %rsi     # 0x1bec0
movq %r12, %rdi
movl $0x1, %edx
callq 0x67ac
testl %eax, %eax
je 0xb7a1
leaq 0x10461(%rip), %rsi     # 0x1bb99
movq %r12, %rdi
movl $0x1, %edx
callq 0x67ac
testl %eax, %eax
jne 0xb7b3
movl 0x58(%r13), %edi
callq 0x5380
movq 0x20(%rsp), %r14
movq 0x28(%rsp), %r15
subq %r14, %r15
sarq $0x3, %r15
cmpq $0x1, %r15
je 0xb7b3
callq 0x50e0
cltq
xorl %edx, %edx
divq %r15
movq -0x8(%r14,%r15,8), %rax
movslq %edx, %rcx
movq (%r14,%rcx,8), %rdx
movq %rdx, -0x8(%r14,%r15,8)
movq %rax, (%r14,%rcx,8)
decq %r15
jmp 0xb763
leaq 0x9e1(%rip), %rdx       # 0xc177
jmp 0xb7a8
leaq 0xa26(%rip), %rdx       # 0xc1c5
jmp 0xb7a8
leaq 0xa55(%rip), %rdx       # 0xc1fd
movq %r15, %rdi
movq %r14, %rsi
callq 0x16465
leaq 0x130(%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 (%rbx), %rax
movb $0x1, 0xf(%rsp)
cmpb $0x0, 0x83(%rax)
jne 0xb7f7
cmpb $0x0, 0x84(%rax)
jne 0xb7f7
movb 0x85(%rax), %al
movb %al, 0xf(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
movq $0x0, 0x50(%rsp)
cmpb $0x0, 0xf(%rsp)
je 0xbf15
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rcx, 0xf8(%rsp)
cmpq %rcx, %rax
je 0xbe9c
movq %rbx, 0x18(%rsp)
movq (%rax), %rcx
cmpb $0x1, 0x38(%rcx)
movq %rax, 0x108(%rsp)
jne 0xb851
movq (%rbx), %rax
movb 0x7a(%rax), %r15b
xorb $0x1, %r15b
jmp 0xb854
xorl %r15d, %r15d
cmpb $0x0, 0x17(%rcx)
movq %rcx, %r14
jns 0xb860
movq (%rcx), %r14
movq %rcx, %rbx
movq 0x18(%rsp), %rax
movq (%rax), %r12
movq 0x10b8(%r12), %rbp
movzbl 0x6d(%r12), %r13d
movq %r14, %rdi
movq %rbp, %rsi
movl $0x1, %edx
movl %r13d, %ecx
callq 0x7f96
movzbl %r15b, %r15d
testb %al, %al
movl $0x1, %eax
cmovel %eax, %r15d
leaq 0x18(%rbp), %rsi
movq %r14, %rdi
xorl %edx, %edx
movl %r13d, %ecx
callq 0x7f96
testb %al, %al
movl $0x1, %eax
cmovnel %eax, %r15d
movq 0x28(%rbx), %r14
leaq 0x30(%rbp), %rsi
movq %r14, %rdi
movl $0x1, %edx
movl %r13d, %ecx
callq 0x7f96
testb %al, %al
movl $0x1, %eax
cmovel %eax, %r15d
leaq 0x48(%rbp), %rsi
movq %r14, 0x100(%rsp)
movq %r14, %rdi
xorl %edx, %edx
movl %r13d, %ecx
callq 0x7f96
testb %al, %al
movl $0x1, %eax
cmovnel %eax, %r15d
movq %rbx, 0x10(%rsp)
movq 0x20(%rbx), %r14
leaq 0x60(%rbp), %rsi
movq %r14, %rdi
movl $0x1, %edx
movl %r13d, %ecx
callq 0x7f96
testb %al, %al
movl $0x1, %eax
cmovel %eax, %r15d
movl $0x1, %ebx
addq $0x78, %rbp
movq %r14, %rdi
movq %rbp, %rsi
xorl %edx, %edx
movl %r13d, %ecx
callq 0x7f96
testb %al, %al
cmovnel %ebx, %r15d
testb $0x1, %r15b
jne 0xb953
incl 0x8c(%r12)
movl 0x60(%r12), %ecx
movl 0x8c(%r12), %eax
cmpl %eax, %ecx
jae 0xb96b
cmpl %ecx, 0x5c(%r12)
jbe 0xb972
cmpl %eax, 0x5c(%r12)
jbe 0xb975
movb $0x1, %r15b
testb $0x1, %r15b
movq 0x18(%rsp), %rbx
movl $0x10, %ebp
je 0xb9cd
cmpb $0x0, 0xf(%rsp)
jne 0xbe7c
movq 0x1aa21(%rip), %rax     # 0x263b8
movq 0x10d0(%rax), %r14
movq 0x10d8(%rax), %r15
cmpq %r15, %r14
je 0xbe7c
movq 0x10(%rsp), %r12
movq (%r14), %rdi
movq (%rdi), %rax
movq %r12, %rsi
callq *0x58(%rax)
addq $0x8, %r14
cmpq %r15, %r14
jne 0xb9b3
jmp 0xbe7c
cmpb $0x0, 0x83(%r12)
jne 0xbe7c
cmpb $0x1, 0x84(%r12)
leaq 0x60(%rsp), %rsi
jne 0xba05
movq 0x10(%rsp), %rax
movq %rax, 0x60(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x19070
jmp 0xbe7c
cmpb $0x1, 0x85(%r12)
jne 0xba8a
movq 0x100(%rsp), %rbx
movq %rbx, %rdi
callq 0x5170
movq %rax, %r13
leaq 0x60(%rsp), %r14
movq %r14, %rdi
movl %r13d, %esi
callq 0x640c
movl %r13d, %edx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x5300
leaq 0x128(%rsp), %rdi
movq %r14, %rsi
callq 0x191dc
movq 0x10(%rsp), %rbx
leaq 0x130(%rsp), %rcx
cmpq %rcx, %rax
je 0xbdfc
cmpb $0x0, 0x77(%rsp)
jns 0xbe77
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0xbe77
callq 0x5480
jmp 0xbe77
movq 0x10(%rsp), %rax
movq %rax, 0x20(%r12)
movl $0x0, 0xb0(%r12)
movq $0x0, 0xa8(%r12)
xorl %eax, %eax
xorl %ecx, %ecx
xchgl %ecx, 0x8b8(%r12,%rax)
addq $0x40, %rax
cmpq $0x800, %rax            # imm = 0x800
jne 0xbaae
movq (%rbx), %rax
xorl %ecx, %ecx
xorl %edx, %edx
xchgl %edx, 0xb8(%rax,%rcx)
addq $0x40, %rcx
cmpq $0x800, %rcx            # imm = 0x800
jne 0xbac9
movq (%rbx), %rdi
movl $0x1128, %eax           # imm = 0x1128
addq %rax, %rdi
callq 0x19410
movq 0x1a8c2(%rip), %rax     # 0x263b8
movq 0x10d0(%rax), %r14
movq 0x10d8(%rax), %r15
cmpq %r15, %r14
movl $0x0, %r13d
movq 0x10(%rsp), %r12
je 0xbb29
movq (%r14), %rdi
movq (%rdi), %rax
movq %r12, %rsi
callq *0x18(%rax)
addq $0x8, %r14
cmpq %r15, %r14
jne 0xbb14
movq (%rbx), %r14
leaq 0x60(%rsp), %rdi
xorl %esi, %esi
callq 0x5580
imulq $0xf4240, 0x60(%rsp), %rax # imm = 0xF4240
addq 0x68(%rsp), %rax
movq %rax, 0x10f0(%r14)
movb $0x1, %bpl
movq (%rbx), %rdi
movb $0x0, 0x115c(%rdi)
movl %r13d, 0x1158(%rdi)
movq 0x1110(%rdi), %rsi
addq $0x1110, %rdi           # imm = 0x1110
callq 0x187fc
movq (%rbx), %rax
movb $0x1, %cl
xchgb %cl, 0x115d(%rax)
movq (%rbx), %rdi
movq 0x10f8(%rdi), %rsi
addq $0x10f8, %rdi           # imm = 0x10F8
callq 0x18476
movb $0x1, 0x1ae94(%rip)     # 0x26a30
movq 0x1ae15(%rip), %rax     # 0x269b8
movq %rax, 0x110(%rsp)
movq 0x1a86e(%rip), %rax     # 0x26420
movq %rax, 0x120(%rsp)
movl %r13d, 0x118(%rsp)
leaq 0x110(%rsp), %rdi
leaq 0x1ae67(%rip), %rsi     # 0x26a38
callq 0x5680
movl $0x98, %edx
leaq 0x60(%rsp), %r13
movq %r13, %rdi
xorl %esi, %esi
callq 0x51f0
leaq 0x220f(%rip), %rax      # 0xde00
movq %rax, 0x60(%rsp)
movl $0x8000000, 0xe8(%rsp) # imm = 0x8000000
leaq 0x1ae48(%rip), %r14     # 0x26a50
xorl %r15d, %r15d
leaq 0x19c4e(%rip), %r12     # 0x25860
movl (%r15,%r12), %edi
movq %r13, %rsi
movq %r14, %rdx
callq 0x5460
addq $0x10, %r15
addq $0x98, %r14
cmpq $0x60, %r15
jne 0xbc12
movq 0x10(%rsp), %r12
callq *0x50(%r12)
callq 0xc232
callq 0xc232
xorl %r13d, %r13d
movq (%rbx), %rax
cmpl $0x0, 0x64(%rax)
jle 0xbc85
movl 0x9c(%rax), %edx
xorl %ecx, %ecx
xorl %esi, %esi
movl 0x8b8(%rax,%rsi), %edi
addl %edi, %ecx
addq $0x40, %rsi
cmpq $0x800, %rsi            # imm = 0x800
jne 0xbc5c
addl %edx, %ecx
movq (%rbx), %rax
cmpl 0x64(%rax), %ecx
jl 0xbc85
orb $0x8, 0xb0(%rax)
xorl %ebp, %ebp
movq (%rbx), %rax
cmpb $0x1, 0x115c(%rax)
jne 0xbcc3
testb $0x1, %bpl
je 0xbcc3
movq 0x1a71a(%rip), %rax     # 0x263b8
movq 0x10d0(%rax), %r14
movq 0x10d8(%rax), %r15
cmpq %r15, %r14
je 0xbcc3
movq (%r14), %rdi
movq (%rdi), %rax
movq %r12, %rsi
callq *0x20(%rax)
addq $0x8, %r14
jmp 0xbcac
movq (%rbx), %rdi
cmpb $0x0, 0x115c(%rdi)
movzbl %bpl, %ebp
cmovel %r13d, %ebp
testb $0x1, %bpl
jne 0xbb50
jmp 0xbd95
movq %rdx, %r14
movq %rax, %r13
callq 0xc232
movq %r13, %rdi
callq 0x5160
cmpl $0x2, %r14d
jne 0xbd1e
movq 0x18(%rsp), %rbx
movq (%rbx), %rax
orl $0x1, 0xb0(%rax)
callq 0x55a0
xorl %r13d, %r13d
movq 0x10(%rsp), %r12
jmp 0xbc49
movq 0x1a693(%rip), %rax     # 0x263b8
movq 0x10d0(%rax), %r15
movq 0x10d8(%rax), %r12
cmpq %r12, %r15
je 0xbd74
movq (%r15), %r14
leaq 0x60(%rsp), %rdi
callq 0x8c33
movb $0x0, 0x78(%rsp)
movq (%r14), %rax
movq %r14, %rdi
leaq 0x60(%rsp), %rsi
callq *0x30(%rax)
cmpb $0x0, 0x77(%rsp)
jns 0xbd6e
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0xbd6e
callq 0x5480
addq $0x8, %r15
jmp 0xbd33
movq 0x18(%rsp), %rbx
movq (%rbx), %rax
orl $0x2, 0xb0(%rax)
callq 0x55a0
xorl %r13d, %r13d
movq 0x10(%rsp), %r12
jmp 0xbc49
callq 0x164ac
movq 0x1a617(%rip), %rax     # 0x263b8
movq 0x10d0(%rax), %r14
movq 0x10d8(%rax), %r15
cmpq %r15, %r14
je 0xbdd2
movq (%r14), %rdi
movq 0x1a5fa(%rip), %rsi     # 0x263b8
movl $0xa0, %eax
addq %rax, %rsi
movq (%rdi), %rax
callq *0x28(%rax)
addq $0x8, %r14
jmp 0xbdaf
movq (%rbx), %rax
movq $0x0, 0x20(%rax)
movl 0x64(%rax), %ecx
testl %ecx, %ecx
jle 0xbdf5
movl $0xf, %ebp
cmpl %ecx, 0x9c(%rax)
jge 0xbe7c
xorl %ebp, %ebp
jmp 0xbe7c
movq 0x28(%rbx), %rax
movb (%rax), %r14b
cmpb $0x0, 0x77(%rsp)
jns 0xbe19
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0xbe19
callq 0x5480
testb %r14b, %r14b
je 0xbe77
movq %rbx, 0x60(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x60(%rsp), %r14
movq %r14, %rsi
callq 0x19070
movq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0x64b2
leaq 0x128(%rsp), %rdi
movq %r14, %rsi
callq 0x19282
movq 0x18(%rsp), %rbx
cmpb $0x0, 0x77(%rsp)
jns 0xbe6c
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0xbe6c
callq 0x5480
movq (%rbx), %rax
incl 0x90(%rax)
jmp 0xbe7c
movq 0x18(%rsp), %rbx
testb $0xf, %bpl
movq 0x108(%rsp), %rax
jne 0xbe9c
addq $0x8, %rax
cmpq 0xf8(%rsp), %rax
jne 0xb833
cmpb $0x0, 0xf(%rsp)
je 0xbf42
xorps %xmm0, %xmm0
movaps %xmm0, 0x60(%rsp)
movq 0x1a502(%rip), %rax     # 0x263b8
leaq 0x88(%rax), %rcx
testq %rax, %rax
cmoveq %rax, %rcx
movq %rcx, 0x60(%rsp)
movq 0x40(%rsp), %rcx
movq 0x48(%rsp), %rdx
movq %rcx, 0x68(%rsp)
subq %rcx, %rdx
shrq $0x3, %rdx
movl %edx, 0x70(%rsp)
movq 0x10d0(%rax), %r15
movq 0x10d8(%rax), %r12
cmpq %r12, %r15
je 0xbf7e
leaq 0x60(%rsp), %r14
movq (%r15), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *(%rax)
addq $0x8, %r15
cmpq %r12, %r15
jne 0xbeff
jmp 0xbf7e
movq 0x1a49c(%rip), %rax     # 0x263b8
movq 0x10d0(%rax), %r14
movq 0x10d8(%rax), %r15
cmpq %r15, %r14
je 0xb813
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
addq $0x8, %r14
jmp 0xbf2a
movq 0x1a46f(%rip), %rax     # 0x263b8
movq 0x10d0(%rax), %r14
movq 0x10d8(%rax), %r15
cmpq %r15, %r14
je 0xbf7e
movl $0x88, %r12d
movq (%r14), %rdi
movq 0x1a44c(%rip), %rsi     # 0x263b8
addq %r12, %rsi
movq (%rdi), %rax
callq *0x10(%rax)
addq $0x8, %r14
cmpq %r15, %r14
jne 0xbf62
movq 0x1aa33(%rip), %rdi     # 0x269b8
testq %rdi, %rdi
je 0xbf8f
callq 0x5480
leaq 0x1d8(%rsp), %rdi
callq 0x50c0
testb %al, %al
movq 0x58(%rsp), %r14
je 0xbfb2
leaq 0x158(%rsp), %rdi
callq 0x5060
movq %r14, 0x1a3ff(%rip)     # 0x263b8
movb $0x0, 0x1a3f5(%rip)     # 0x263b5
movq (%rbx), %rax
movq 0x10d0(%rax), %r14
movq 0x10d8(%rax), %r15
cmpq %r15, %r14
je 0xbfea
movq (%r14), %rdi
testq %rdi, %rdi
je 0xbfe4
movq (%rdi), %rax
callq *0x68(%rax)
addq $0x8, %r14
jmp 0xbfd1
movq (%rbx), %rax
movq 0x10d0(%rax), %rcx
cmpq %rcx, 0x10d8(%rax)
je 0xc004
movq %rcx, 0x10d8(%rax)
cmpl $0x0, 0x94(%rax)
je 0xc018
movl $0x1, %ebx
cmpb $0x1, 0x73(%rax)
jne 0xc01a
xorl %ebx, %ebx
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0xc031
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x53d0
leaq 0x128(%rsp), %rdi
callq 0x16d2e
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0xb642
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x53d0
jmp 0xb642
jmp 0xc0ef
movq %rax, %rbx
cmpb $0x0, 0x77(%rsp)
jns 0xc081
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0xc081
callq 0x5480
jmp 0xc081
movq %rax, %rbx
callq 0x55a0
jmp 0xc0f2
movq %rax, %rdi
callq 0x161ef
jmp 0xc0ef
jmp 0xc09c
jmp 0xc0ef
jmp 0xc0ef
jmp 0xc0e8
jmp 0xc0ef
movq %rax, %rbx
cmpb $0x0, 0x77(%rsp)
jns 0xc0f2
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0xc0f2
callq 0x5480
jmp 0xc0f2
jmp 0xc0ef
jmp 0xc0ef
jmp 0xc0ef
movq %rax, %rbx
cmpb $0x0, 0x77(%rsp)
jns 0xc136
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0xc136
callq 0x5480
jmp 0xc136
jmp 0xc133
jmp 0xc133
jmp 0xc0ef
jmp 0xc0ef
jmp 0xc0ef
jmp 0xc0ef
jmp 0xc0ef
jmp 0xc133
movq %rax, %rbx
jmp 0xc116
jmp 0xc0ef
movq %rax, %rbx
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0xc109
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x53d0
leaq 0x128(%rsp), %rdi
callq 0x16d2e
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0xc136
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x53d0
jmp 0xc136
jmp 0xc133
jmp 0xc133
movq %rax, %rbx
leaq 0x158(%rsp), %rdi
callq 0x50b0
movq %rbx, %rdi
callq 0x5620