// File: /workspace/github_cpp_makefile_star2_O2/davmac314[P]dinit/src/dinitctl.cc
// Function: enable_disable_service(int, cpbuffer<1024u>&, service_dir_opt&, char const*, char const*, bool, bool, unsigned short)
static int enable_disable_service(int socknum, cpbuffer_t &rbuffer, service_dir_opt &service_dir_opts,
        const char *from, const char *to, bool enable, bool verbose, uint16_t proto_version)
{
    using std::cout;
    using std::cerr;
    using std::string;

    service_state_t from_state = service_state_t::STARTED;
    handle_t from_handle;

    handle_t to_handle;

    std::vector<string> service_dir_paths;

    string service_file_path;
    string to_service_file_path;
    dio::istream service_file;
    fd_holder parent_dir_fd;

    if (strchr(from, '@') != nullptr) {
        cerr << "dinitctl: cannot enable/disable from a service with argument (service@arg).\n";
        return 1;
    }

    if (socknum >= 0) {
        if (!load_service(socknum, rbuffer, from, &from_handle, &from_state)
                || !load_service(socknum, rbuffer, to, &to_handle, nullptr)) {
            return 1;
        }

        try {
            service_dir_paths = get_service_description_dirs(socknum, rbuffer);
        }
        catch (dinit_protocol_error &) {
            cerr << "dinitctl: unknown configuration or protocol error, unable to load service descriptions\n";
        }

        to_service_file_path = get_service_descr_filename(socknum, rbuffer, to_handle, to);

        std::string from_sdf_dir = get_service_description_dir(socknum, rbuffer, from_handle);
        if (from_sdf_dir.empty())
            throw dinit_protocol_error();

        auto sdf_fds = open_with_dir(from_sdf_dir.c_str(), from);
        if (sdf_fds.first == -1) {
            cerr << "dinitctl: could not open service description file '"
                    << service_file_path << "': " << strerror(sdf_fds.second) << "\n";
            return EXIT_FAILURE;
        }

        parent_dir_fd = sdf_fds.first;
        service_file.set_fd(sdf_fds.second);

        service_file_path = from_sdf_dir;
        if (*service_file_path.rbegin() != '/') service_file_path += '/';
        service_file_path += from;
    }
    else {
        // offline case
        const auto &path_list = service_dir_opts.get_paths();
        for (auto &path : path_list) {
            service_dir_paths.emplace_back(path.get_dir());
        }

        auto sdf_fds = find_service_desc(from, service_dir_paths, service_file_path);
        if (sdf_fds.first == -1) {
            if (sdf_fds.second == ENOENT) {
                cerr << "dinitctl: could not locate service file for service '" << from << "'\n";
            }
            else {
                cerr << "dinitctl: could not open service description file '"
                        << service_file_path << "': " << strerror(sdf_fds.second)
                        << "\n";
            }
            return EXIT_FAILURE;
        }

        parent_dir_fd = sdf_fds.first;
        service_file.set_fd(sdf_fds.second);

        auto to_sdf_fds = find_service_desc(to, service_dir_paths, to_service_file_path);
        if (to_sdf_fds.first == -1 && to_sdf_fds.second == ENOENT) {
            cerr << "dinitctl: could not locate service file for target service '" << to << "'\n";
            return EXIT_FAILURE;
        }

        if (to_sdf_fds.first != -1) {
            close(to_sdf_fds.first);
            close(to_sdf_fds.second);
        }
    }

    // We now need to read the service file, identify the waits-for.d directory (bail out if more than one),
    // make sure the service is not listed as a dependency individually.

    string waits_for_d;
    fd_holder waits_for_d_fd;

    file_input_stack input_stack;
    input_stack.push(service_file_path, std::move(service_file), parent_dir_fd.release());

    try {
        auto resolve_var = [](const std::string &name) {
            return (char *)nullptr; // FIXME
        };

        auto is_setting = [](const std::string &setting, dinit_load::setting_id_t setting_id) {
            return (setting == dinit_load::all_settings[(size_t)setting_id].setting_str);
        };

        process_service_file(from, input_stack, [&](string &line, file_pos_ref fpr,
                string &setting, dinit_load::setting_op_t op,
                dinit_load::string_iterator i, dinit_load::string_iterator end) -> void {
                    using namespace dinit_load;

                    if (is_setting(setting, setting_id_t::WAITS_FOR)
                            || is_setting(setting, setting_id_t::DEPENDS_ON)
                            || is_setting(setting, setting_id_t::DEPENDS_MS)) {
                        string dname = dinit_load::read_setting_value(fpr, i, end);
                        if (dname == to) {
                            // There is already a dependency
                            cerr << "dinitctl: there is a fixed dependency to service '" << to
                                    << "' in the service description of '" << from << "'.\n";
                            throw service_op_cancel();
                        }
                    }
                    else if (is_setting(setting, setting_id_t::WAITS_FOR_D)) {
                        string dname = dinit_load::read_setting_value(fpr, i, end);
                        if (! waits_for_d.empty()) {
                            cerr << "dinitctl: service '" << from << "' has multiple waits-for.d directories "
                                    << "specified in service description\n";
                            throw service_op_cancel();
                        }
                        waits_for_d = std::move(dname);
                    }
                },
                nullptr /* service arg */, resolve_var);
    }
    catch (const service_op_cancel &cexc) {
        return 1;
    }
    catch (std::system_error &err) {
        cerr << "dinitctl: " << input_stack.current_file_name() << ": " << strerror(errno) << "\n";
        return 1;
    }

    // If the from service has no waits-for.d specified, we can't continue
    if (waits_for_d.empty()) {
        cerr << "dinitctl: service '" << from << "' has no waits-for.d directory specified" << "\n";
        return 1;
    }

    // The waits-for.d path is relative to the service file path, combine:
    // XXX should use parent dir fd
    string waits_for_d_full = combine_paths(parent_path(service_file_path), waits_for_d.c_str());

    // check if dependency already exists
    string dep_link_path = combine_paths(waits_for_d_full, to);
    struct stat stat_buf;
    if (lstat(dep_link_path.c_str(), &stat_buf) == -1) {
        if (errno != ENOENT) {
            cerr << "dinitctl: checking for existing dependency link: " << dep_link_path << ": "
                    << strerror(errno) << "\n";
            return 1;
        }
    }
    else {
        // dependency already exists
        if (enable) {
            cerr << "dinitctl: service already enabled.\n";
            return 1;
        }
    }

    if (socknum >= 0) {
        // warn if 'from' service is not started
        if (enable && from_state != service_state_t::STARTED) {
            cerr << "dinitctl: warning: enabling dependency for non-started service\n";
        }

        // add/remove dependency
        constexpr int enable_pktsize = 2 + sizeof(handle_t) * 2;
        char cmdbuf[enable_pktsize] = { char(enable ? cp_cmd::ENABLESERVICE : cp_cmd::REM_DEP),
                char(dependency_type::WAITS_FOR)};
        memcpy(cmdbuf + 2, &from_handle, sizeof(from_handle));
        memcpy(cmdbuf + 2 + sizeof(from_handle), &to_handle, sizeof(to_handle));
        write_all_x(socknum, cmdbuf, enable_pktsize);

        wait_for_reply(rbuffer, socknum);

        // check reply
        if (rbuffer[0] == (char)cp_rply::NAK) {
            if (enable) {
                cerr << "dinitctl: could not enable service: possible circular dependency\n";
            }
            else {
                cerr << "dinitctl: service not currently enabled\n";
            }
            return 1;
        }
        if (rbuffer[0] != (char)cp_rply::ACK) {
            cerr << "dinitctl: control socket protocol error\n";
            return 1;
        }
        rbuffer.consume(1);
    }

    // create link
    if (enable) {
        // Guess a relative path to use as the symlink target. Note that if either the waits-for.d directory
        // path, or the "to" service description file path, contains symbolic links or path segments with
        // ".." or ".", this may not produce the "correct" result. We do a "reasonable effort". If the
        // result isn't correct, the only consequence is that the link may be broken or point to the wrong
        // file; Dinit itself won't be affected by this.
        string symlink_target;
        auto spos = waits_for_d_full.rfind('/');
        if (spos != std::string::npos) {
            if (strncmp(waits_for_d_full.c_str(), to_service_file_path.c_str(), spos) == 0) {
                symlink_target = "../";
                symlink_target.append(to_service_file_path, spos + 1, std::string::npos);
            }
        }
        if (symlink_target.empty()) {
            // not yet determined: try full path or just "../(to)"
            if (to_service_file_path[0] == '/') {
                symlink_target = to_service_file_path;
            }
            else {
                symlink_target = "../";
                symlink_target.append(to);
            }
        }

        if (symlink(symlink_target.c_str(), dep_link_path.c_str()) == -1) {
            cerr << "dinitctl: could not create symlink at " << dep_link_path << ": " << strerror(errno);
            if (socknum >= 0) {
                cerr << "\n" "dinitctl: note: service was enabled for now; persistent enable failed.";
            }
            cerr << "\n";
            return 1;
        }
    }
    else {
        if (unlink(dep_link_path.c_str()) == -1) {
            cerr << "dinitctl: could not unlink dependency entry " << dep_link_path << ": "
                    << strerror(errno);
            if (socknum >= 0) {
                cerr << "\n" "dinitctl: note: service was disabled for now; persistent disable failed.";
            }
            cerr << "\n";
            return 1;
        }
    }

    if (socknum >= 0) {
        if (verbose) {
            cout << "Service '" << to << "' has been " << (enable ? "enabled" : "disabled") << ".\n";
        }

        char cmd_pkt = (char)(proto_version < 5 ? cp_cmd::SERVICESTATUS : cp_cmd::SERVICESTATUS5);

        // Check status of the service now
        auto m = membuf()
                .append(cmd_pkt)
                .append(to_handle);
        write_all_x(socknum, m);

        int statussize = proto_version < 5 ? STATUS_BUFFER_SIZE : STATUS_BUFFER5_SIZE;

        // For an enable, we want to wait until the service has started so we can report any
        // failure. But, if the service is already started, we won't get any service events, so we
        // have to request status via SERVICESTATUS to catch that case. However, we may get
        // a service event before the reply to SERVICESTATUS and in that case should use it to
        // report status.
        if (enable) {
            int r = rbuffer.fill_to(socknum, 2);
            while (r > 0 && rbuffer[0] >= 100) {
                unsigned pktlen = (unsigned char) rbuffer[1];
                fill_buffer_to(rbuffer, socknum, pktlen);

                if (value(rbuffer[0]).is_in((char)cp_info::SERVICEEVENT, (char)cp_info::SERVICEEVENT5)) {
                    int ret = process_service_event(rbuffer, pktlen, to_handle, to,
                            false /* start */, verbose);
                    if (ret >= 0) {
                        // Consume the outstanding reply packet before returning.
                        wait_for_reply(rbuffer, socknum);
                        if (rbuffer[0] != (char)cp_rply::SERVICESTATUS) {
                            cerr << "dinitctl: protocol error.\n";
                            return 1;
                        }
                        // +2 is 1 byte packet type, 1 byte reserved
                        fill_buffer_to(rbuffer, socknum, statussize + 2);
                        rbuffer.consume(statussize + 2);
                        return ret;
                    }
                }
                else {
                    rbuffer.consume(pktlen);
                }

                r = rbuffer.fill_to(socknum, 2);
            }
            if (r == -1) {
                throw cp_read_exception(errno);
            }
            if (r == 0) {
                cerr << "dinitctl: protocol error.\n";
                return 1;
            }
        }
        else {
            wait_for_reply(rbuffer, socknum);
        }

        if (rbuffer[0] != (char)cp_rply::SERVICESTATUS) {
            cerr << "dinitctl: protocol error.\n";
            return 1;
        }
        rbuffer.consume(1);

        fill_buffer_to(rbuffer, socknum, statussize + 1 /* reserved */);
        rbuffer.consume(1);
        service_state_t current = static_cast<service_state_t>(rbuffer[0]);
        service_state_t target = static_cast<service_state_t>(rbuffer[1]);
        rbuffer.consume(statussize);

        if (enable) {
            if (current != service_state_t::STARTED) {
                wait_service_state(socknum, rbuffer, to_handle, to, false /* start */, verbose);
            }
        }
        else {
            if (target != service_state_t::STOPPED) {
                std::cerr << "dinitctl: note: disabled service may have other dependents\n";
            }
        }
    }
    else {
        if (verbose) {
            cout << "Service '" << to << "' has been " << (enable ? "enabled" : "disabled") << ".\n";
        }
    }

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x338, %rsp            # imm = 0x338
movl %r9d, %r12d
movq %r8, %r14
movq %rcx, %r13
movq %rdx, %rbx
movq %rsi, %r15
andq $0x0, 0x230(%rsp)
leaq 0x130(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movl %edi, %ebp
xorl %ecx, %ecx
movb %cl, (%rax)
leaq 0x298(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x2, 0xf(%rsp)
orl $-0x1, 0x238(%rsp)
xorps %xmm0, %xmm0
andq $0x0, 0x240(%rsp)
movaps %xmm0, 0x220(%rsp)
andq $0x0, 0x246(%rsp)
movb %cl, (%rax)
orl $-0x1, 0x2c(%rsp)
pushq $0x40
popq %rsi
movq %r13, %rdi
callq 0x4110
testq %rax, %rax
je 0x7dc1
movq 0x13292(%rip), %rdi     # 0x1aff0
leaq 0xac77(%rip), %rsi      # 0x129dc
callq 0x42f0
pushq $0x1
popq %r13
leaq 0x2c(%rsp), %rdi
callq 0xc0fa
leaq 0x238(%rsp), %rdi
callq 0xffb6
leaq 0x288(%rsp), %rdi
callq 0x4150
leaq 0x120(%rsp), %rdi
callq 0x4150
leaq 0x220(%rsp), %rdi
callq 0xbcf4
movl %r13d, %eax
addq $0x338, %rsp            # imm = 0x338
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r13, 0x68(%rsp)
movq %r12, 0x60(%rsp)
movq %r15, 0x10(%rsp)
movq %r14, 0x20(%rsp)
testl %ebp, %ebp
movl %ebp, 0x8(%rsp)
js 0x7ed0
leaq 0xe4(%rsp), %rcx
leaq 0xf(%rsp), %r8
pushq $0x1
popq %r13
movl %ebp, %edi
movq 0x10(%rsp), %rsi
movq 0x68(%rsp), %rdx
movl %r13d, %r9d
callq 0xa139
testb %al, %al
je 0x7d6e
leaq 0x34(%rsp), %rcx
pushq $0x1
popq %r13
movl 0x8(%rsp), %edi
movq 0x10(%rsp), %rsi
movq 0x20(%rsp), %rdx
xorl %r8d, %r8d
movl %r13d, %r9d
callq 0xa139
testb %al, %al
je 0x7d6e
leaq 0x190(%rsp), %rdi
movl 0x8(%rsp), %esi
movq 0x10(%rsp), %rdx
callq 0xbad4
leaq 0x220(%rsp), %rdi
leaq 0x190(%rsp), %rbx
movq %rbx, %rsi
callq 0xc48c
movq %rbx, %rdi
callq 0xbcf4
movl 0x34(%rsp), %ecx
leaq 0x190(%rsp), %rdi
movl 0x8(%rsp), %esi
movq 0x10(%rsp), %rdx
callq 0xa8e4
movq 0x198(%rsp), %rax
testq %rax, %rax
je 0x9b72
movq 0x190(%rsp), %rcx
cmpb $0x2f, -0x1(%rcx,%rax)
je 0x7ebb
leaq 0x190(%rsp), %rdi
pushq $0x1
popq %rsi
pushq $0x2f
popq %rdx
callq 0x4330
movq 0x20(%rsp), %rdx
movzbl (%rdx), %eax
testb $-0x41, %al
je 0x7fa4
incq %rdx
jmp 0x7ec0
movq 0x18(%rbx), %r15
movq 0x20(%rbx), %r12
leaq 0x220(%rsp), %rbx
leaq 0x190(%rsp), %r14
pushq $0x1
popq %r13
cmpq %r12, %r15
je 0x7f0d
movq (%r15), %rax
movq %rax, 0x190(%rsp)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xbf20
addq $0x10, %r15
jmp 0x7eec
leaq 0x220(%rsp), %rsi
leaq 0x120(%rsp), %rdx
movq 0x68(%rsp), %rdi
callq 0xaa2f
movq %rax, %rbx
movl %ebx, %esi
shrq $0x20, %rbx
cmpl $-0x1, %esi
je 0x8099
leaq 0x2c(%rsp), %rdi
callq 0xbf00
leaq 0x238(%rsp), %rdi
movl %ebx, %esi
callq 0xf066
leaq 0x220(%rsp), %rsi
leaq 0x288(%rsp), %rdx
movq 0x20(%rsp), %rdi
callq 0xaa2f
movq %rax, %rbx
movl %ebx, %edi
shrq $0x20, %rbx
cmpl $-0x1, %edi
setne %al
cmpq $0x2, %rbx
setne %cl
orb %al, %cl
je 0x80ca
cmpl $-0x1, %edi
je 0x81c6
callq 0x4590
movl %ebx, %edi
callq 0x4590
jmp 0x81c6
leaq 0x190(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xc522
leaq 0x288(%rsp), %rdi
leaq 0x190(%rsp), %rbx
movq %rbx, %rsi
callq 0x43b0
movq %rbx, %rdi
callq 0x4150
movl 0xe4(%rsp), %ecx
leaq 0x190(%rsp), %rdi
movl 0x8(%rsp), %esi
movq 0x10(%rsp), %rdx
callq 0xa8e4
cmpq $0x0, 0x198(%rsp)
je 0x9b8b
movq 0x190(%rsp), %rdi
pushq $-0x64
popq %rdx
movq 0x68(%rsp), %rsi
callq 0xbd15
movq %rax, %rbx
movq %rax, %r14
shrq $0x20, %r14
cmpl $-0x1, %ebx
je 0x8159
leaq 0x2c(%rsp), %rdi
movl %ebx, %esi
callq 0xbf00
leaq 0x238(%rsp), %rdi
movl %r14d, %esi
callq 0xf066
leaq 0x120(%rsp), %rdi
leaq 0x190(%rsp), %rsi
callq 0x41d0
movq 0x120(%rsp), %rax
movq 0x128(%rsp), %rcx
cmpb $0x2f, -0x1(%rax,%rcx)
je 0x8082
leaq 0x120(%rsp), %rdi
pushq $0x2f
popq %rsi
callq 0x42b0
leaq 0x120(%rsp), %rdi
movq 0x68(%rsp), %rsi
callq 0x4550
jmp 0x81b0
cmpl $0x2, %ebx
jne 0x80fe
movq 0x12f4b(%rip), %rdi     # 0x1aff0
leaq 0xaa0d(%rip), %rsi      # 0x12ab9
callq 0x42f0
movq %rax, %rdi
movq 0x68(%rsp), %rsi
callq 0x42f0
leaq 0xaa2a(%rip), %rsi      # 0x12aef
jmp 0x814c
movq 0x12f1f(%rip), %rdi     # 0x1aff0
leaq 0xaa1a(%rip), %rsi      # 0x12af2
callq 0x42f0
movq %rax, %rdi
movq 0x20(%rsp), %rsi
callq 0x42f0
leaq 0xa9fe(%rip), %rsi      # 0x12aef
movq %rax, %rdi
callq 0x42f0
jmp 0x7d6e
movq 0x12eeb(%rip), %rdi     # 0x1aff0
leaq 0xa975(%rip), %rsi      # 0x12a81
callq 0x42f0
leaq 0x120(%rsp), %rsi
movq %rax, %rdi
callq 0x42d0
leaq 0xa98d(%rip), %rsi      # 0x12ab5
movq %rax, %rdi
callq 0x42f0
movq %rax, %r14
movl %ebx, %edi
callq 0x40e0
movq %r14, %rdi
movq %rax, %rsi
callq 0x42f0
leaq 0xa9a4(%rip), %rsi      # 0x12af0
movq %rax, %rdi
callq 0x42f0
jmp 0x7d6e
movq 0x12e90(%rip), %rdi     # 0x1aff0
leaq 0xa91a(%rip), %rsi      # 0x12a81
callq 0x42f0
leaq 0x120(%rsp), %rsi
movq %rax, %rdi
callq 0x42d0
leaq 0xa932(%rip), %rsi      # 0x12ab5
movq %rax, %rdi
callq 0x42f0
movq %rax, %r15
movl %r14d, %edi
callq 0x40e0
movq %r15, %rdi
movq %rax, %rsi
callq 0x42f0
leaq 0xa948(%rip), %rsi      # 0x12af0
movq %rax, %rdi
callq 0x42f0
leaq 0x190(%rsp), %rdi
callq 0x4150
cmpl $-0x1, %ebx
je 0x7d6e
leaq 0x2d8(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
orl $-0x1, 0xe0(%rsp)
leaq 0x140(%rsp), %rdi
callq 0xcc6c
leaq 0x318(%rsp), %rdi
leaq 0x120(%rsp), %rsi
callq 0x4420
movq 0x68(%rsp), %rbx
movl 0x2c(%rsp), %ecx
orl $-0x1, 0x2c(%rsp)
leaq 0x140(%rsp), %rdi
leaq 0x318(%rsp), %rsi
leaq 0x238(%rsp), %rdx
callq 0xbf5a
leaq 0x318(%rsp), %rdi
callq 0x4150
leaq 0x2a8(%rsp), %rdi
leaq 0xb7(%rsp), %rdx
movq %rbx, %rsi
callq 0xb124
leaq 0xc8(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movzwl 0x378(%rsp), %r15d
movb $0x0, (%rax)
leaq 0x190(%rsp), %r12
leaq 0x78(%rsp), %rbp
leaq 0x2f8(%rsp), %r13
leaq 0x140(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
callq 0xd21c
testb %al, %al
je 0x8caa
movq 0x170(%rsp), %rax
cmpq 0x178(%rsp), %rax
jne 0x82c9
movq 0x188(%rsp), %rax
movq -0x8(%rax), %rax
movl $0x200, %ecx            # imm = 0x200
addq %rcx, %rax
movl -0x8(%rax), %eax
movl %eax, 0x30(%rsp)
movq 0xc0(%rsp), %rax
testq %rax, %rax
je 0x8286
movq 0xb8(%rsp), %rdi
leaq (%rdi,%rax), %rbx
cmpb $0x5c, -0x1(%rdi,%rax)
jne 0x83a0
movb $0x1, %cl
movq %rax, %rdx
cmpq $0x1, %rdx
je 0x8310
cmpb $0x5c, -0x2(%rdi,%rdx)
jne 0x830e
xorb $0x1, %cl
decq %rdx
jmp 0x82f9
movl %ecx, %eax
testb $0x1, %al
je 0x83a0
leaq 0x1a0(%rsp), %rax
movq %rax, 0x190(%rsp)
andq $0x0, 0x198(%rsp)
movb $0x0, 0x1a0(%rsp)
movb $0xa, -0x1(%rbx)
leaq 0x140(%rsp), %rdi
movq %r12, %rsi
callq 0xd29a
testb %al, %al
je 0x9771
movq 0x190(%rsp), %rdi
movq 0x198(%rsp), %rsi
addq %rdi, %rsi
callq 0xd340
cmpq 0x190(%rsp), %rax
je 0x9739
leaq 0xb8(%rsp), %rdi
movq %r12, %rsi
callq 0x4580
movq %r12, %rdi
callq 0x4150
movq 0xc0(%rsp), %rax
jmp 0x82dd
movq %rdi, 0x38(%rsp)
movq %rbx, %rsi
leaq 0x30(%rsp), %rdx
callq 0xd37c
movq %rax, 0x38(%rsp)
cmpq %rbx, %rax
je 0x8286
movzbl (%rax), %ecx
cmpl $0x23, %ecx
je 0x8286
cmpl $0x40, %ecx
jne 0x897f
incq %rax
movq %rax, 0x38(%rsp)
leaq 0x250(%rsp), %r14
movq %r14, %rdi
leaq 0x38(%rsp), %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0xd3cf
movq %r14, %rdi
leaq 0xaab6(%rip), %rsi      # 0x12eba
callq 0xd548
movb %al, 0x1f(%rsp)
testb %al, %al
jne 0x842d
leaq 0x250(%rsp), %rdi
leaq 0xaaa6(%rip), %rsi      # 0x12ec6
callq 0xd548
testb %al, %al
je 0x9a1d
movq 0x170(%rsp), %rcx
cmpq 0x178(%rsp), %rcx
jne 0x8453
movq 0x188(%rsp), %rax
movq -0x8(%rax), %rcx
movl $0x200, %eax            # imm = 0x200
addq %rax, %rcx
addq $-0x28, %rcx
movl 0x30(%rsp), %edx
leaq 0xf8(%rsp), %rax
movq %rax, 0xe8(%rsp)
andq $0x0, 0xf0(%rsp)
movl %edx, 0x2e8(%rsp)
movq %rcx, 0x2f0(%rsp)
movb $0x0, 0xf8(%rsp)
leaq 0x270(%rsp), %rax
movq %rax, 0x278(%rsp)
movq %rax, 0x270(%rsp)
andq $0x0, 0x280(%rsp)
leaq 0xe8(%rsp), %rdi
xorl %esi, %esi
leaq 0x38(%rsp), %r8
movq %rbx, %r9
pushq $0x20
pushq %rax
callq 0xd746
popq %rax
popq %rcx
cmpq $0x1, 0x280(%rsp)
jne 0x990c
leaq 0x108(%rsp), %rdi
movq %rdi, 0x110(%rsp)
movq %rdi, 0x108(%rsp)
andq $0x0, 0x118(%rsp)
andl $0x0, 0x78(%rsp)
movq 0xf0(%rsp), %rax
movq %rax, 0x190(%rsp)
movq %rbp, %rsi
movq %r12, %rdx
callq 0xda5c
movq 0x250(%rsp), %rax
movq %rax, 0x98(%rsp)
leaq 0xe8(%rsp), %rdi
pushq $0x24
popq %rsi
xorl %edx, %edx
callq 0x43e0
cmpq $-0x1, %rax
je 0x8b25
movq %rax, %rbx
movq 0xf0(%rsp), %rax
shrq $0x1f, %rax
jne 0x99ed
movq %r12, %r15
leaq 0x1a0(%rsp), %rax
movq %rax, 0x190(%rsp)
andq $0x0, 0x198(%rsp)
movq 0x108(%rsp), %rbp
movb $0x0, 0x1a0(%rsp)
xorl %r13d, %r13d
xorl %r12d, %r12d
leaq 0x108(%rsp), %rax
cmpq %rax, %rbp
je 0x8ae0
addl %r13d, 0x10(%rbp)
xorl %r14d, %r14d
movl $0x0, 0x74(%rsp)
movl 0x14(%rbp), %eax
cmpq %rax, %rbx
jae 0x892e
movl %r12d, %edx
movq %rbx, %rcx
subq %rdx, %rcx
movq %r15, %r12
movq %r15, %rdi
leaq 0xe8(%rsp), %rsi
callq 0x4440
movq 0xe8(%rsp), %rax
movb 0x1(%rax,%rbx), %sil
cmpb $0x24, %sil
jne 0x85fc
movq %r12, %rdi
pushq $0x24
popq %rsi
callq 0x42b0
addl $0x2, %ebx
decl %r13d
jmp 0x8911
leaq 0x1(%rbx), %rcx
movl 0x14(%rbp), %r14d
addq %rax, %r14
leaq 0x2(%rbx), %rdx
movb %sil, 0xa0(%rsp)
cmpb $0x2f, %sil
cmovneq %rcx, %rdx
leaq (%rax,%rdx), %rcx
movb (%rax,%rdx), %r15b
xorl %eax, %eax
cmpb $0x7b, %r15b
sete %al
addq %rcx, %rax
movq %rax, 0xd8(%rsp)
movb $0x0, 0xe(%rsp)
leaq 0x78(%rsp), %rdi
leaq 0xd8(%rsp), %rsi
movq %r14, %rdx
pushq $0x1
popq %rcx
leaq 0xe(%rsp), %r8
callq 0xd3cf
cmpq $0x0, 0x80(%rsp)
je 0x95a4
cmpb $0x1, 0xe(%rsp)
jne 0x8688
leaq 0x78(%rsp), %rdi
leaq 0x983d(%rip), %rsi      # 0x11eb8
callq 0xdcb9
testb %al, %al
jne 0x9697
movq 0xd8(%rsp), %r12
cmpb $0x7b, %r15b
jne 0x8704
movb (%r12), %al
movq %r12, %rsi
cmpb $0x3a, %al
jne 0x86c5
leaq 0x1(%r12), %rax
movq %rax, %rsi
movq %rax, 0xd8(%rsp)
movzbl 0x1(%r12), %eax
cmpl $0x2b, %eax
je 0x86c5
cmpl $0x2d, %eax
jne 0x9865
cmpb $0x2d, %al
je 0x86d3
movzbl %al, %edx
xorl %ecx, %ecx
cmpl $0x2b, %edx
jne 0x871d
movq %rsi, %r12
incq %rsi
movq %rsi, %rdi
movq %rsi, %rcx
movq %rsi, 0xd8(%rsp)
movb (%rsi), %dl
incq %rsi
incq %r12
cmpq %r14, %rcx
je 0x86f9
cmpb $0x7d, %dl
jne 0x86dc
movsbl %al, %ecx
movq %rdi, %r14
decq %rsi
jmp 0x8722
movq 0x198(%rsp), %rax
movq %rax, 0xa8(%rsp)
movb 0xa0(%rsp), %cl
jmp 0x8771
movl %eax, %edx
movq %r12, %r14
cmpb $0x7d, %dl
jne 0x96e8
incq %rsi
movq %rsi, %rax
movq %rsi, 0xd8(%rsp)
movq 0x198(%rsp), %rdx
movq %rdx, 0xa8(%rsp)
cmpl $0x2b, %ecx
je 0x875f
cmpl $0x2d, %ecx
movb 0xa0(%rsp), %cl
jne 0x876e
subq %r14, %r12
jmp 0x8785
xorl %r12d, %r12d
xorl %r14d, %r14d
movb 0xa0(%rsp), %cl
jmp 0x8785
movq %rax, %r12
cmpb $0x1, 0xe(%rsp)
je 0x9646
movq %r12, %rax
xorl %r12d, %r12d
xorl %r14d, %r14d
subl 0xe8(%rsp), %eax
movq %rax, 0xa0(%rsp)
subl %eax, %ebx
addl %ebx, %r13d
cmpb $0x2f, %cl
jne 0x887c
addq %r14, %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0xdcc3
cmpq %r12, %rax
je 0x88af
movq %rax, %rbx
movq %rax, %rdx
subq %r14, %rdx
je 0x87d4
leaq 0x190(%rsp), %rdi
movq %r14, %rsi
callq 0x4070
movl 0x10(%rbp), %eax
movl 0x14(%rbp), %r15d
movq 0x198(%rsp), %r14
cmpq %rax, %r14
jne 0x87ef
testb $0x1, 0x74(%rsp)
je 0x8861
movl %r14d, 0x14(%rbp)
leaq 0x190(%rsp), %rdi
pushq $0x20
popq %rsi
callq 0x42b0
incq %r14
testq $-0x80000000, %r14      # imm = 0x80000000
jne 0x9493
movq %rbp, %rdi
pushq $0x1
popq %rsi
callq 0xdcff
movl 0x198(%rsp), %ecx
movl %ecx, 0x40(%rsp)
movl %r15d, 0x44(%rsp)
leaq 0x108(%rsp), %rdi
movq %rax, %rsi
leaq 0x40(%rsp), %rdx
callq 0xdd68
movq %rax, %rbp
subl 0xa8(%rsp), %r13d
addl %r14d, %r13d
movq 0x198(%rsp), %rax
movq %rax, 0xa8(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0xdd1d
movq %rax, %r14
movl $0x0, 0x74(%rsp)
jmp 0x87a5
movb $0x1, %al
movl %eax, 0x74(%rsp)
testq %r12, %r12
je 0x88d5
leaq 0x190(%rsp), %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x4070
movq 0xa0(%rsp), %rbx
xorl %r14d, %r14d
leaq 0x190(%rsp), %r15
jmp 0x88e8
cmpq %r12, %r14
je 0x88ca
subq %r14, %r12
leaq 0x190(%rsp), %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x4070
movl 0x74(%rsp), %r14d
xorb $0x1, %r14b
jmp 0x88d8
xorl %r14d, %r14d
leaq 0x190(%rsp), %r15
movq 0xa0(%rsp), %rbx
movq 0x198(%rsp), %rax
testq $-0x80000000, %rax      # imm = 0x80000000
jne 0x95f5
subl 0xa8(%rsp), %r13d
addl %eax, %r13d
leaq 0x78(%rsp), %rdi
callq 0x4150
movq %rbx, %r12
movl %ebx, %edx
leaq 0xe8(%rsp), %rdi
pushq $0x24
popq %rsi
callq 0x43e0
movq %rax, %rbx
jmp 0x85ab
addl %r13d, %eax
movl %eax, 0x14(%rbp)
testb $0x1, %r14b
je 0x8979
cmpl %eax, 0x10(%rbp)
jne 0x8979
leaq 0x108(%rsp), %rdi
movq %rbp, %rsi
callq 0xdd5a
movq %rax, %rbp
leaq 0x108(%rsp), %rax
cmpq %rax, %rbp
je 0x858b
movl 0x14(%rbp), %eax
cmpq %rax, %rbx
jbe 0x858b
addl %r13d, 0x10(%rbp)
addl %r13d, %eax
movl %eax, 0x14(%rbp)
movq (%rbp), %rbp
jmp 0x8952
movq %rbp, %rdi
leaq 0x38(%rsp), %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0xd3cf
movq 0x38(%rsp), %rdi
movq %rbx, %rsi
leaq 0x30(%rsp), %rdx
callq 0xd37c
movq %rax, 0x38(%rsp)
cmpq $0x0, 0x80(%rsp)
leaq 0x12995(%rip), %r13     # 0x1b350
je 0x98b1
movzbl (%rax), %ecx
cmpl $0x3d, %ecx
je 0x89f1
cmpl $0x3a, %ecx
je 0x89f1
cmpl $0x2b, %ecx
jne 0x98b1
incq %rax
movq %rax, 0x38(%rsp)
cmpq %rbx, %rax
je 0x98b1
cmpb $0x3d, (%rax)
jne 0x98b1
incq %rax
movq %rax, 0x38(%rsp)
movq %rax, %rdi
movq %rbx, %rsi
leaq 0x30(%rsp), %rdx
callq 0xd37c
movq %rax, 0x38(%rsp)
movq 0x170(%rsp), %r14
cmpq 0x178(%rsp), %r14
jne 0x8a34
movq 0x188(%rsp), %rcx
movq -0x8(%rcx), %r14
movl $0x200, %ecx            # imm = 0x200
addq %rcx, %r14
addq $-0x28, %r14
movl 0x30(%rsp), %ebp
movq %rax, 0x40(%rsp)
movq 0xc0(%r13), %rsi
leaq 0x78(%rsp), %r13
movq %r13, %rdi
callq 0xd548
testb %al, %al
jne 0x8a91
leaq 0x128f0(%rip), %rax     # 0x1b350
movq 0xa0(%rax), %rsi
movq %r13, %rdi
callq 0xd548
testb %al, %al
jne 0x8a91
leaq 0x128d6(%rip), %rax     # 0x1b350
movq 0xb0(%rax), %rsi
movq %r13, %rdi
callq 0xd548
testb %al, %al
je 0x8c48
movq %r12, %rdi
movl %ebp, %esi
movq %r14, %rdx
leaq 0x40(%rsp), %rcx
movq %rbx, %r8
xorl %r9d, %r9d
callq 0xde34
leaq 0x2f8(%rsp), %r13
movq %r12, %rdi
movq 0x20(%rsp), %rsi
callq 0xd548
testb %al, %al
jne 0x9984
movq %r12, %rdi
callq 0x4150
leaq 0x78(%rsp), %rbp
movq %rbp, %rdi
callq 0x4150
jmp 0x8286
movl %r12d, %edx
movq %r15, %r12
movq %r15, %rdi
leaq 0xe8(%rsp), %rbx
movq %rbx, %rsi
pushq $-0x1
popq %rcx
callq 0x4440
movq %rbx, %rdi
movq %r12, %rsi
callq 0x43b0
movq %r12, %rdi
callq 0x4150
leaq 0x78(%rsp), %rbp
leaq 0x2f8(%rsp), %r13
movzwl 0x378(%rsp), %r15d
leaq 0x108(%rsp), %rdi
callq 0xdb14
leaq 0x270(%rsp), %rdi
callq 0xdb14
movq 0xe8(%rsp), %rdi
callq 0xc6b9
movq 0xe8(%rsp), %rcx
pushq $-0x1
popq %rbx
leaq 0x9f93(%rip), %rdi      # 0x12af1
cmpq %rcx, %rax
je 0x8b83
leaq 0x1(%rcx), %rdx
leaq 0xa101(%rip), %rdi      # 0x12c6f
cmpq %rdx, %rax
je 0x8b83
movq %rcx, %rbx
notq %rbx
addq %rax, %rbx
movb $0x0, (%rcx,%rbx)
movq %rcx, %rdi
movq 0x170(%rsp), %rcx
cmpq 0x178(%rsp), %rcx
jne 0x8ba9
movq 0x188(%rsp), %rcx
movq -0x8(%rcx), %rcx
movl $0x200, %edx            # imm = 0x200
addq %rdx, %rcx
movl -0x4(%rcx), %edx
movq %rax, %rsi
callq 0xbd15
movq %rax, %r14
cmpq $-0x1, %rbx
je 0x8bc9
movq 0xe8(%rsp), %rax
movb $0x2f, (%rax,%rbx)
movq %r14, %rbx
shrq $0x20, %rbx
cmpl $-0x1, %r14d
je 0x8c18
movq %r12, %rdi
movl %ebx, %esi
callq 0xd5e8
movq %r13, %rdi
leaq 0xe8(%rsp), %rsi
callq 0x4420
leaq 0x140(%rsp), %rdi
movq %r13, %rsi
movq %r12, %rdx
movl %r14d, %ecx
callq 0xbf5a
movq %r13, %rdi
callq 0x4150
movq %r12, %rdi
callq 0xffb6
jmp 0x8c29
cmpq $0x2, %rbx
sete %al
testb %al, 0x1f(%rsp)
je 0x9aff
leaq 0xe8(%rsp), %rdi
callq 0x4150
leaq 0x250(%rsp), %rdi
callq 0x4150
jmp 0x8286
leaq 0x12701(%rip), %rax     # 0x1b350
movq 0xd0(%rax), %rsi
movq %r13, %rdi
callq 0xd548
testb %al, %al
leaq 0x2f8(%rsp), %r13
je 0x8ace
movq %r12, %rdi
movl %ebp, %esi
movq %r14, %rdx
leaq 0x40(%rsp), %rcx
movq %rbx, %r8
xorl %r9d, %r9d
callq 0xde34
cmpq $0x0, 0x2d0(%rsp)
jne 0x9ba6
leaq 0x2c8(%rsp), %rdi
movq %r12, %rsi
callq 0x43b0
jmp 0x8ac6
leaq 0xb8(%rsp), %rdi
callq 0x4150
leaq 0x2a8(%rsp), %rdi
callq 0x4150
cmpq $0x0, 0x2d0(%rsp)
je 0x8d4a
movq 0x120(%rsp), %rdi
movq 0x128(%rsp), %rsi
callq 0xc0a2
movq 0x2c8(%rsp), %rcx
leaq 0x78(%rsp), %rdi
movq %rax, %rsi
callq 0xbfb1
movq 0x78(%rsp), %rsi
movq 0x80(%rsp), %rdx
leaq 0x40(%rsp), %rdi
movq 0x20(%rsp), %rcx
callq 0xbfb1
pushq $0x1
popq %r13
movq 0x40(%rsp), %rdi
leaq 0x190(%rsp), %rsi
callq 0x4570
cmpl $-0x1, %eax
je 0x8d91
cmpb $0x0, 0x60(%rsp)
je 0x8d9f
leaq 0x9e60(%rip), %r14      # 0x12b9e
movq 0x122ab(%rip), %rbx     # 0x1aff0
jmp 0x8ea9
movq 0x1229f(%rip), %rdi     # 0x1aff0
leaq 0x9dd7(%rip), %rsi      # 0x12b2f
callq 0x42f0
movq 0x68(%rsp), %rsi
movq %rax, %rdi
callq 0x42f0
leaq 0x9dd2(%rip), %rsi      # 0x12b43
movq %rax, %rdi
callq 0x42f0
leaq 0x9d70(%rip), %rsi      # 0x12af0
movq %rax, %rdi
callq 0x42f0
pushq $0x1
popq %r13
jmp 0x9513
callq 0x4040
cmpl $0x2, (%rax)
jne 0x8e58
cmpl $0x0, 0x8(%rsp)
js 0x8ec4
cmpb $0x0, 0x60(%rsp)
je 0x8dcb
cmpb $0x2, 0xf(%rsp)
je 0x8dcb
movq 0x12231(%rip), %rdi     # 0x1aff0
leaq 0x9dfc(%rip), %rsi      # 0x12bc2
callq 0x42f0
movq 0x60(%rsp), %rax
addl %eax, %eax
orb $0xc, %al
leaq 0xb8(%rsp), %rsi
movb %al, (%rsi)
movb $0x2, 0x1(%rsi)
movl 0xe4(%rsp), %eax
movl %eax, 0x2(%rsi)
movl 0x34(%rsp), %eax
movl %eax, 0x6(%rsi)
pushq $0xa
popq %rdx
movl 0x8(%rsp), %ebx
movl %ebx, %edi
callq 0xb277
movq 0x10(%rsp), %r14
movq %r14, %rdi
movl %ebx, %esi
callq 0xb2a9
movl 0x400(%r14), %eax
leal -0x400(%rax), %ecx
cmpl $0x400, %eax            # imm = 0x400
cmovbl %eax, %ecx
movzbl (%r14,%rcx), %eax
cmpl $0x32, %eax
je 0x8eb9
cmpl $0x33, %eax
jne 0x901a
leaq 0x9dbf(%rip), %rax      # 0x12c02
leaq 0x9dfa(%rip), %rsi      # 0x12c44
cmpb $0x0, 0x60(%rsp)
cmovneq %rax, %rsi
jmp 0x9021
movq %rax, %rbx
movq 0x1218e(%rip), %rdi     # 0x1aff0
leaq 0x9d03(%rip), %rsi      # 0x12b6c
callq 0x42f0
leaq 0x40(%rsp), %rsi
movq %rax, %rdi
callq 0x42d0
leaq 0x9c34(%rip), %rsi      # 0x12ab6
movq %rax, %rdi
callq 0x42f0
movq %rax, %r14
movl (%rbx), %edi
callq 0x40e0
movq %r14, %rdi
movq %rax, %rsi
callq 0x42f0
movq %rax, %rbx
leaq 0x9c47(%rip), %r14      # 0x12af0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x42f0
jmp 0x94ff
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0xb41c
cmpb $0x0, 0x60(%rsp)
je 0x8f8e
leaq 0xc8(%rsp), %rax
movq %rax, 0xb8(%rsp)
andq $0x0, 0xc0(%rsp)
movb $0x0, 0xc8(%rsp)
leaq 0x78(%rsp), %rdi
pushq $0x2f
popq %rsi
pushq $-0x1
popq %rdx
callq 0x45a0
cmpq $-0x1, %rax
je 0x8f54
movq %rax, %rbx
movq 0x78(%rsp), %rdi
movq 0x288(%rsp), %rsi
movq %rax, %rdx
callq 0x4170
testl %eax, %eax
jne 0x8f54
leaq 0x9d44(%rip), %rsi      # 0x12c6d
leaq 0xb8(%rsp), %rdi
callq 0x4560
incq %rbx
leaq 0xb8(%rsp), %rdi
leaq 0x288(%rsp), %rsi
pushq $-0x1
popq %rcx
movq %rbx, %rdx
callq 0x4440
cmpq $0x0, 0xc0(%rsp)
jne 0x9058
movq 0x288(%rsp), %rax
cmpb $0x2f, (%rax)
jne 0x9032
leaq 0xb8(%rsp), %rdi
leaq 0x288(%rsp), %rsi
callq 0x41d0
jmp 0x9058
movq 0x40(%rsp), %rdi
callq 0x4160
cmpl $-0x1, %eax
jne 0x9080
movq 0x12048(%rip), %rbx     # 0x1aff0
leaq 0x9d31(%rip), %rsi      # 0x12ce0
movq %rbx, %rdi
callq 0x42f0
leaq 0x40(%rsp), %rsi
movq %rax, %rdi
callq 0x42d0
leaq 0x9aeb(%rip), %rsi      # 0x12ab6
movq %rax, %rdi
callq 0x42f0
movq %rax, %r14
callq 0x4040
movl (%rax), %edi
callq 0x40e0
movq %r14, %rdi
movq %rax, %rsi
callq 0x42f0
leaq 0x9afc(%rip), %r14      # 0x12af0
cmpl $0x0, 0x8(%rsp)
js 0x8ea9
movq 0x11fea(%rip), %rbx     # 0x1aff0
leaq 0x9d00(%rip), %rsi      # 0x12d0d
movq %rbx, %rdi
callq 0x42f0
jmp 0x8ea9
leaq 0x96f8(%rip), %rsi      # 0x12719
movq 0x11fc8(%rip), %rdi     # 0x1aff0
callq 0x42f0
jmp 0x94ff
leaq 0x9c34(%rip), %rsi      # 0x12c6d
leaq 0xb8(%rsp), %rdi
callq 0x4560
leaq 0xb8(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x4550
movq 0xb8(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x4050
cmpl $-0x1, %eax
je 0x92de
leaq 0xb8(%rsp), %rdi
callq 0x4150
cmpl $0x0, 0x8(%rsp)
js 0x9253
cmpb $0x0, 0x370(%rsp)
je 0x90f2
movq 0x11f0c(%rip), %rdi     # 0x1afa8
leaq 0x8fca(%rip), %rsi      # 0x1206d
callq 0x42f0
movq %rax, %rdi
movq 0x20(%rsp), %rsi
callq 0x42f0
leaq 0x9c9b(%rip), %rsi      # 0x12d57
movq %rax, %rdi
callq 0x42f0
leaq 0x9c98(%rip), %rcx      # 0x12d63
leaq 0x9c99(%rip), %rsi      # 0x12d6b
cmpb $0x0, 0x60(%rsp)
cmovneq %rcx, %rsi
movq %rax, %rdi
callq 0x42f0
leaq 0x90ab(%rip), %rsi      # 0x12195
movq %rax, %rdi
callq 0x42f0
movl 0x34(%rsp), %eax
movl %eax, %ecx
shll $0x8, %ecx
xorl %edx, %edx
cmpw $0x5, %r15w
setae %dl
leal (%rcx,%rdx,8), %ecx
addl $0x12, %ecx
shrl $0x18, %eax
leaq 0x250(%rsp), %rsi
movb %al, 0x4(%rsi)
movl %ecx, (%rsi)
movl 0x8(%rsp), %edi
callq 0xba4c
xorl %eax, %eax
cmpw $0x5, %r15w
setae %al
leal 0xa(,%rax,4), %r12d
movzbl 0x370(%rsp), %ebp
cmpb $0x0, 0x60(%rsp)
movq 0x20(%rsp), %r13
movq 0x10(%rsp), %rdi
je 0x92c6
movl %r12d, 0xa8(%rsp)
pushq $0x2
popq %r14
movl 0x8(%rsp), %esi
movl %r14d, %edx
callq 0xb49c
leaq 0xb8(%rsp), %r15
leaq 0xe8(%rsp), %r12
testl %eax, %eax
movq 0x10(%rsp), %rbx
jle 0x9366
movl 0x400(%rbx), %ecx
leal -0x400(%rcx), %edx
cmpl $0x400, %ecx            # imm = 0x400
cmovbl %ecx, %edx
cmpb $0x64, (%rbx,%rdx)
jl 0x9366
leal 0x1(%rcx), %eax
addl $0xfffffc01, %ecx       # imm = 0xFFFFFC01
cmpl $0x400, %eax            # imm = 0x400
cmovbl %eax, %ecx
movzbl (%rbx,%rcx), %r13d
movq %rbx, %rdi
movl 0x8(%rsp), %esi
movl %r13d, %edx
callq 0xb33a
movl 0x400(%rbx), %eax
leal -0x400(%rax), %ecx
cmpl $0x400, %eax            # imm = 0x400
cmovbl %eax, %ecx
movb (%rbx,%rcx), %al
andb $-0x2, %al
cmpb $0x64, %al
jne 0x922f
movl 0x34(%rsp), %ebx
movq %r15, %rdi
movq 0x20(%rsp), %rsi
movq %r12, %rdx
callq 0xb124
movq 0x10(%rsp), %rdi
movl %r13d, %esi
movl %ebx, %edx
movq %r15, %rcx
xorl %r8d, %r8d
movl %ebp, %r9d
callq 0xa56a
movl %eax, %r13d
movq %r15, %rdi
callq 0x4150
testl %r13d, %r13d
movq 0x10(%rsp), %rbx
js 0x923a
jmp 0x953f
movq %rbx, %rdi
movl %r13d, %esi
callq 0xb41c
movq %rbx, %rdi
movl 0x8(%rsp), %esi
movl %r14d, %edx
callq 0xb49c
movq 0x20(%rsp), %r13
jmp 0x917b
xorl %r13d, %r13d
cmpb $0x0, 0x370(%rsp)
je 0x94ff
movq 0x11d3d(%rip), %rdi     # 0x1afa8
leaq 0x8dfb(%rip), %rsi      # 0x1206d
callq 0x42f0
movq %rax, %rdi
movq 0x20(%rsp), %rsi
callq 0x42f0
leaq 0x9acc(%rip), %rsi      # 0x12d57
movq %rax, %rdi
callq 0x42f0
leaq 0x9ac9(%rip), %rcx      # 0x12d63
leaq 0x9aca(%rip), %rsi      # 0x12d6b
cmpb $0x0, 0x60(%rsp)
cmovneq %rcx, %rsi
movq %rax, %rdi
callq 0x42f0
leaq 0x8edc(%rip), %rsi      # 0x12195
movq %rax, %rdi
callq 0x42f0
jmp 0x94ff
movq 0x10(%rsp), %rdi
movl 0x8(%rsp), %esi
callq 0xb2a9
movq 0x10(%rsp), %rbx
jmp 0x937f
movq 0x11d0b(%rip), %rdi     # 0x1aff0
leaq 0x9985(%rip), %rsi      # 0x12c71
callq 0x42f0
leaq 0x40(%rsp), %rsi
movq %rax, %rdi
callq 0x42d0
leaq 0x97b1(%rip), %rsi      # 0x12ab6
movq %rax, %rdi
callq 0x42f0
movq %rax, %rbx
callq 0x4040
movl (%rax), %edi
callq 0x40e0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x42f0
cmpl $0x0, 0x8(%rsp)
js 0x9341
movq 0x11cbb(%rip), %rdi     # 0x1aff0
leaq 0x995c(%rip), %rsi      # 0x12c98
callq 0x42f0
movq 0x11ca8(%rip), %rdi     # 0x1aff0
leaq 0x97a1(%rip), %rsi      # 0x12af0
callq 0x42f0
leaq 0xb8(%rsp), %rdi
callq 0x4150
jmp 0x94ff
testl %eax, %eax
je 0x947a
cmpl $-0x1, %eax
movl 0xa8(%rsp), %r12d
je 0x9bfd
movl 0x400(%rbx), %eax
leal -0x400(%rax), %ecx
cmpl $0x400, %eax            # imm = 0x400
cmovbl %eax, %ecx
cmpb $0x46, (%rbx,%rcx)
jne 0x9465
pushq $0x1
popq %rsi
movq 0x10(%rsp), %rdi
callq 0xb41c
movl %r12d, %edx
orl $0x1, %edx
movq 0x10(%rsp), %rdi
movl 0x8(%rsp), %esi
callq 0xb33a
movq 0x10(%rsp), %r15
pushq $0x1
popq %rsi
movq %r15, %rdi
callq 0xb41c
movl 0x400(%r15), %eax
leal -0x400(%rax), %ecx
movl $0x400, %edx            # imm = 0x400
cmpl %edx, %eax
cmovbl %eax, %ecx
movb (%r15,%rcx), %bl
leal 0x1(%rax), %ecx
addl $0xfffffc01, %eax       # imm = 0xFFFFFC01
cmpl %edx, %ecx
cmovbl %ecx, %eax
movb (%r15,%rax), %r14b
movq %r15, %rdi
movl %r12d, %esi
callq 0xb41c
cmpb $0x0, 0x60(%rsp)
je 0x94e4
cmpb $0x2, %bl
je 0x94fc
movl 0x34(%rsp), %ebx
leaq 0xb8(%rsp), %rdi
leaq 0xe8(%rsp), %rdx
movq %r13, %rsi
callq 0xb124
leaq 0xb8(%rsp), %rcx
movl 0x8(%rsp), %edi
movq 0x10(%rsp), %rsi
movl %ebx, %edx
xorl %r8d, %r8d
movl %ebp, %r9d
callq 0xa184
leaq 0xb8(%rsp), %rdi
callq 0x4150
jmp 0x94fc
movq 0x11b84(%rip), %rdi     # 0x1aff0
leaq 0x8cda(%rip), %rsi      # 0x1214d
callq 0x42f0
jmp 0x948d
movq 0x11b6f(%rip), %rdi     # 0x1aff0
leaq 0x8cc5(%rip), %rsi      # 0x1214d
callq 0x42f0
pushq $0x1
popq %r13
jmp 0x94ff
pushq $0x70
popq %rdi
callq 0x4190
movq %rax, %r15
leaq 0x9bb9(%rip), %rsi      # 0x1305e
leaq 0x40(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xb124
leaq 0x40(%rsp), %rdx
movq %r15, %rdi
movq 0x98(%rsp), %rsi
callq 0xdc84
leaq 0x11840(%rip), %rsi     # 0x1ad10
leaq 0x3e53(%rip), %rdx      # 0xd32a
movq %r15, %rdi
callq 0x44f0
jmp 0x98b1
testb %r14b, %r14b
je 0x94fc
movq 0x11b00(%rip), %rdi     # 0x1aff0
leaq 0x987d(%rip), %rsi      # 0x12d74
callq 0x42f0
xorl %r13d, %r13d
leaq 0x40(%rsp), %rdi
callq 0x4150
leaq 0x78(%rsp), %rdi
callq 0x4150
leaq 0x140(%rsp), %rdi
callq 0xe018
leaq 0xe0(%rsp), %rdi
callq 0xc0fa
leaq 0x2c8(%rsp), %rdi
callq 0x4150
jmp 0x7d6e
movq %rbx, %rdi
movl 0x8(%rsp), %esi
callq 0xb2a9
movl 0xa8(%rsp), %ebp
movl 0x400(%rbx), %eax
leal -0x400(%rax), %ecx
cmpl $0x400, %eax            # imm = 0x400
cmovbl %eax, %ecx
cmpb $0x46, (%rbx,%rcx)
jne 0x958c
addl $0x2, %ebp
movq %rbx, %rdi
movl 0x8(%rsp), %esi
movl %ebp, %edx
callq 0xb33a
movq %rbx, %rdi
movl %ebp, %esi
callq 0xb41c
jmp 0x94ff
movq 0x11a5d(%rip), %rdi     # 0x1aff0
leaq 0x8bb3(%rip), %rsi      # 0x1214d
callq 0x42f0
jmp 0x948d
pushq $0x70
popq %rdi
callq 0x4190
movq %rax, %r15
leaq 0x99e1(%rip), %rsi      # 0x12f97
leaq 0x40(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xb124
leaq 0x40(%rsp), %rdx
movq %r15, %rdi
movq 0x98(%rsp), %rsi
callq 0xdc84
leaq 0x1172f(%rip), %rsi     # 0x1ad10
leaq 0x3d42(%rip), %rdx      # 0xd32a
movq %r15, %rdi
callq 0x44f0
jmp 0x98b1
pushq $0x70
popq %rdi
callq 0x4190
movq %rax, %r15
leaq 0x9a57(%rip), %rsi      # 0x1305e
leaq 0x40(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xb124
leaq 0x40(%rsp), %rdx
movq %r15, %rdi
movq 0x98(%rsp), %rsi
callq 0xdc84
leaq 0x116de(%rip), %rsi     # 0x1ad10
leaq 0x3cf1(%rip), %rdx      # 0xd32a
movq %r15, %rdi
callq 0x44f0
jmp 0x98b1
pushq $0x70
popq %rdi
callq 0x4190
movq %rax, %r15
leaq 0x99df(%rip), %rsi      # 0x13037
leaq 0x40(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xb124
leaq 0x40(%rsp), %rdx
movq %r15, %rdi
movq 0x98(%rsp), %rsi
callq 0xdc84
leaq 0x1168d(%rip), %rsi     # 0x1ad10
leaq 0x3ca0(%rip), %rdx      # 0xd32a
movq %r15, %rdi
callq 0x44f0
jmp 0x98b1
pushq $0x70
popq %rdi
callq 0x4190
movq %rax, %r15
leaq 0x9916(%rip), %rsi      # 0x12fbf
leaq 0x40(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xb124
leaq 0x40(%rsp), %rdx
movq %r15, %rdi
movq 0x98(%rsp), %rsi
callq 0xdc84
leaq 0x1163c(%rip), %rsi     # 0x1ad10
leaq 0x3c4f(%rip), %rdx      # 0xd32a
movq %r15, %rdi
callq 0x44f0
jmp 0x98b1
pushq $0x70
popq %rdi
callq 0x4190
movq %rax, %r15
leaq 0x9916(%rip), %rsi      # 0x13010
leaq 0x40(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xb124
leaq 0x40(%rsp), %rdx
movq %r15, %rdi
movq 0x98(%rsp), %rsi
callq 0xdc84
leaq 0x115eb(%rip), %rsi     # 0x1ad10
leaq 0x3bfe(%rip), %rdx      # 0xd32a
movq %r15, %rdi
callq 0x44f0
jmp 0x98b1
pushq $0x70
popq %rdi
callq 0x4190
movq %rax, %r15
movq 0x170(%rsp), %rax
cmpq 0x178(%rsp), %rax
jne 0x97a9
movq 0x188(%rsp), %rax
movq -0x8(%rax), %rax
leaq 0x1f8(%rax), %rcx
addq $0x200, %rax            # imm = 0x200
jmp 0x97ad
pushq $0x70
popq %rdi
callq 0x4190
movq %rax, %r15
movq 0x170(%rsp), %rax
cmpq 0x178(%rsp), %rax
jne 0x9807
movq 0x188(%rsp), %rax
movq -0x8(%rax), %rax
leaq 0x1f8(%rax), %rcx
addq $0x200, %rax            # imm = 0x200
jmp 0x980b
leaq -0x8(%rax), %rcx
movl (%rcx), %ecx
movl %ecx, 0x40(%rsp)
addq $-0x28, %rax
movq %rax, 0x48(%rsp)
leaq 0x969d(%rip), %rsi      # 0x12e60
leaq 0x78(%rsp), %rdi
leaq 0x250(%rsp), %rdx
callq 0xb124
movb $0x1, %bpl
leaq 0x40(%rsp), %rsi
leaq 0x78(%rsp), %rdx
movq %r15, %rdi
callq 0xd2ec
xorl %ebp, %ebp
leaq 0x1151d(%rip), %rsi     # 0x1ad10
leaq 0x3b30(%rip), %rdx      # 0xd32a
movq %r15, %rdi
callq 0x44f0
jmp 0x9b72
leaq -0x8(%rax), %rcx
movl (%rcx), %ecx
movl %ecx, 0x40(%rsp)
addq $-0x28, %rax
movq %rax, 0x48(%rsp)
leaq 0x960a(%rip), %rsi      # 0x12e2b
leaq 0x78(%rsp), %rdi
leaq 0x250(%rsp), %rdx
callq 0xb124
movb $0x1, %bpl
leaq 0x40(%rsp), %rsi
leaq 0x78(%rsp), %rdx
movq %r15, %rdi
callq 0xd2ec
xorl %ebp, %ebp
leaq 0x114bf(%rip), %rsi     # 0x1ad10
leaq 0x3ad2(%rip), %rdx      # 0xd32a
movq %r15, %rdi
callq 0x44f0
jmp 0x9b72
pushq $0x70
popq %rdi
callq 0x4190
movq %rax, %r15
leaq 0x9771(%rip), %rsi      # 0x12fe8
leaq 0x40(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xb124
leaq 0x40(%rsp), %rdx
movq %r15, %rdi
movq 0x98(%rsp), %rsi
callq 0xdc84
leaq 0x1146e(%rip), %rsi     # 0x1ad10
leaq 0x3a81(%rip), %rdx      # 0xd32a
movq %r15, %rdi
callq 0x44f0
pushq $0x70
popq %rdi
callq 0x4190
movq %rax, %r15
leaq 0x962c(%rip), %rsi      # 0x12eef
leaq 0x190(%rsp), %rdi
leaq 0x250(%rsp), %rdx
callq 0xb124
movq 0x170(%rsp), %rax
cmpq 0x178(%rsp), %rax
jne 0x9ab5
movq 0x188(%rsp), %rax
movq -0x8(%rax), %rax
leaq 0x1f8(%rax), %rcx
addq $0x200, %rax            # imm = 0x200
jmp 0x9ab9
pushq $0x70
popq %rdi
callq 0x4190
movq %rax, %r15
leaq 0x95e4(%rip), %rsi      # 0x12f02
leaq 0x78(%rsp), %rdi
leaq 0x250(%rsp), %rdx
callq 0xd9e6
leaq 0x95ce(%rip), %rdx      # 0x12f05
leaq 0x190(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0xd555
movb $0x1, %bpl
leaq 0x2a8(%rsp), %rsi
leaq 0x190(%rsp), %rdx
leaq 0x2e8(%rsp), %rcx
movq %r15, %rdi
callq 0xd63c
xorl %ebp, %ebp
leaq 0x1139b(%rip), %rsi     # 0x1ad10
leaq 0x39ae(%rip), %rdx      # 0xd32a
movq %r15, %rdi
callq 0x44f0
movq 0x11665(%rip), %rdi     # 0x1aff0
leaq 0x96f0(%rip), %rsi      # 0x13082
callq 0x42f0
movq %rax, %rdi
movq 0x20(%rsp), %rsi
callq 0x42f0
leaq 0x970a(%rip), %rsi      # 0x130b5
movq %rax, %rdi
callq 0x42f0
movq %rax, %rdi
movq 0x68(%rsp), %rsi
callq 0x42f0
leaq 0x87cd(%rip), %rsi      # 0x12194
movq %rax, %rdi
callq 0x42f0
pushq $0x1
popq %rdi
callq 0x4190
leaq 0x112fa(%rip), %rsi     # 0x1acd8
movq %rax, %rdi
xorl %edx, %edx
callq 0x44f0
jmp 0x9bfd
pushq $0x10
popq %rdi
callq 0x4190
movq %rax, %r15
leaq 0x9588(%rip), %rsi      # 0x12f87
movq %rax, %rdi
callq 0x4350
movq 0x115ba(%rip), %rsi     # 0x1afc8
movq 0x1158b(%rip), %rdx     # 0x1afa0
movq %r15, %rdi
callq 0x44f0
movq 0x170(%rsp), %rax
cmpq 0x178(%rsp), %rax
jne 0x9a40
movq 0x188(%rsp), %rcx
movl $0x200, %eax            # imm = 0x200
addq -0x8(%rcx), %rax
addq $-0x28, %rax
movl 0x30(%rsp), %ecx
movl %ecx, 0x78(%rsp)
movq %rax, 0x80(%rsp)
pushq $0x70
popq %rdi
callq 0x4190
movq %rax, %r15
leaq 0x9478(%rip), %rsi      # 0x12ede
leaq 0x190(%rsp), %rdi
leaq 0x40(%rsp), %rdx
callq 0xb124
movb $0x1, %bpl
leaq 0x2a8(%rsp), %rsi
leaq 0x190(%rsp), %rdx
leaq 0x78(%rsp), %rcx
movq %r15, %rdi
callq 0xd63c
xorl %ebp, %ebp
leaq 0x1126f(%rip), %rsi     # 0x1ad10
leaq 0x3882(%rip), %rdx      # 0xd32a
movq %r15, %rdi
callq 0x44f0
jmp 0x9b72
leaq -0x8(%rax), %rcx
movl (%rcx), %edx
leaq 0x40(%rsp), %rcx
movl %edx, (%rcx)
addq $-0x28, %rax
movq %rax, 0x8(%rcx)
movb $0x1, %bpl
leaq 0x2a8(%rsp), %rsi
leaq 0x190(%rsp), %rdx
movq %r15, %rdi
callq 0xd63c
xorl %ebp, %ebp
leaq 0x11222(%rip), %rsi     # 0x1ad10
leaq 0x3835(%rip), %rdx      # 0xd32a
movq %r15, %rdi
callq 0x44f0
jmp 0x9b72
pushq $0x40
popq %rdi
callq 0x4190
movq %rax, %r15
leaq 0x93bd(%rip), %rdx      # 0x12ece
leaq 0x78(%rsp), %rdi
leaq 0xe8(%rsp), %rsi
callq 0xd574
movl %ebx, %edi
callq 0x40e0
leaq 0x190(%rsp), %rdi
leaq 0x78(%rsp), %rsi
movq %rax, %rdx
callq 0xd555
movb $0x1, %bpl
leaq 0x2a8(%rsp), %rsi
leaq 0x190(%rsp), %rdx
movq %r15, %rdi
callq 0xd5ac
xorl %ebp, %ebp
leaq 0x1119d(%rip), %rsi     # 0x1ad00
leaq 0x3a68(%rip), %rdx      # 0xd5d2
movq %r15, %rdi
callq 0x44f0
pushq $0x1
popq %rdi
callq 0x4190
leaq 0x10f7f(%rip), %rsi     # 0x1ab00
movq %rax, %rdi
xorl %edx, %edx
callq 0x44f0
pushq $0x1
popq %rdi
callq 0x4190
leaq 0x10f66(%rip), %rsi     # 0x1ab00
movq %rax, %rdi
xorl %edx, %edx
callq 0x44f0
jmp 0x9c22
movq 0x11443(%rip), %rdi     # 0x1aff0
leaq 0x8f7b(%rip), %rsi      # 0x12b2f
callq 0x42f0
movq %rax, %rdi
movq 0x68(%rsp), %rsi
callq 0x42f0
leaq 0x950a(%rip), %rsi      # 0x130d7
movq %rax, %rdi
callq 0x42f0
leaq 0x9523(%rip), %rsi      # 0x130ff
movq %rax, %rdi
callq 0x42f0
pushq $0x1
popq %rdi
callq 0x4190
leaq 0x110e5(%rip), %rsi     # 0x1acd8
movq %rax, %rdi
xorl %edx, %edx
callq 0x44f0
pushq $0x4
popq %rdi
callq 0x4190
movq %rax, %rbx
callq 0x4040
movl (%rax), %eax
movl %eax, (%rbx)
leaq 0x10f28(%rip), %rsi     # 0x1ab40
movq %rbx, %rdi
xorl %edx, %edx
callq 0x44f0
jmp 0x9c4e
jmp 0x9db9
jmp 0x9db9
jmp 0x9db9
jmp 0x9db9
jmp 0x9db9
jmp 0x9db9
jmp 0x9c4e
jmp 0x9db9
jmp 0x9e50
movq %rax, %rbx
leaq 0xb8(%rsp), %rdi
callq 0x4150
jmp 0x9dbc
movq %rdx, %r14
movq %rax, %rbx
leaq 0x190(%rsp), %rdi
callq 0x4150
jmp 0x9c81
movq %rdx, %r14
movq %rax, %rbx
movb $0x1, %bpl
leaq 0x78(%rsp), %rdi
callq 0x4150
testb %bpl, %bpl
jne 0x9cb2
jmp 0x9feb
jmp 0x9db9
jmp 0x9db9
movq %rax, %rbx
jmp 0x9dc6
jmp 0x9e17
movq %rdx, %r14
movq %rax, %rbx
movq %r15, %rdi
callq 0x4250
jmp 0x9feb
jmp 0x9e3e
jmp 0x9ec6
jmp 0x9e3e
jmp 0x9ec6
movq %rax, %rbx
cmpl $0x1, %edx
jne 0x9ec9
movq %rbx, %rdi
callq 0x4120
movq 0x11302(%rip), %rdi     # 0x1aff0
leaq 0x8d34(%rip), %rsi      # 0x12a29
callq 0x42f0
callq 0x44e0
jmp 0x7e6e
jmp 0x9ec6
movq %rax, %rbx
callq 0x44e0
jmp 0x9ec9
movq %rdx, %r14
movq %rax, %rbx
leaq 0x190(%rsp), %rdi
callq 0x4150
jmp 0x9d34
movq %rdx, %r14
movq %rax, %rbx
movb $0x1, %bpl
leaq 0x78(%rsp), %rdi
callq 0x4150
testb %bpl, %bpl
jne 0x9dd8
jmp 0x9fde
movq %rdx, %r14
movq %rax, %rbx
leaq 0x190(%rsp), %rdi
callq 0x4150
testb %bpl, %bpl
jne 0x9d6f
jmp 0x9ff8
movq %rdx, %r14
movq %rax, %rbx
movq %r15, %rdi
callq 0x4250
jmp 0x9ff8
movq %rdx, %r14
movq %rax, %rbx
jmp 0xa01f
movq %rax, %rbx
leaq 0x318(%rsp), %rdi
jmp 0x9dcb
movq %rax, %rbx
jmp 0x9e27
jmp 0x9e3e
jmp 0x9e6f
movq %rdx, %r14
movq %rax, %rbx
movq %r15, %rdi
callq 0x4250
jmp 0x9fd1
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x4150
leaq 0x78(%rsp), %rdi
callq 0x4150
jmp 0x9e1a
movq %rdx, %r14
movq %rax, %rbx
movq %r15, %rdi
callq 0x4250
jmp 0x9fde
jmp 0x9f84
movq %rdx, %r14
movq %rax, %rbx
leaq 0x2f8(%rsp), %rdi
callq 0x4150
jmp 0x9e05
movq %rdx, %r14
movq %rax, %rbx
leaq 0x190(%rsp), %rdi
callq 0xffb6
jmp 0x9feb
movq %rax, %rbx
leaq 0x140(%rsp), %rdi
callq 0xe018
leaq 0xe0(%rsp), %rdi
callq 0xc0fa
leaq 0x2c8(%rsp), %rdi
jmp 0x9e49
movq %rax, %rbx
leaq 0x190(%rsp), %rdi
callq 0x4150
jmp 0x9ec9
movq %rdx, %r14
movq %rax, %rbx
leaq 0x190(%rsp), %rdi
callq 0x4150
jmp 0x9ead
jmp 0x9ec6
movq %rdx, %r14
movq %rax, %rbx
jmp 0x9ead
movq %rdx, %r14
movq %rax, %rbx
jmp 0x9fd1
movq %rdx, %r14
movq %rax, %rbx
jmp 0x9fde
movq %rdx, %r14
movq %rax, %rbx
leaq 0x190(%rsp), %rdi
callq 0x4150
testb %bpl, %bpl
jne 0x9ea5
jmp 0x9ead
movq %rdx, %r14
movq %rax, %rbx
movq %r15, %rdi
callq 0x4250
leaq 0x78(%rsp), %rdi
jmp 0xa000
jmp 0x9ec6
jmp 0x9ec6
movq %rdx, %r14
movq %rax, %rbx
jmp 0xa005
movq %rax, %rbx
leaq 0x2c(%rsp), %rdi
callq 0xc0fa
leaq 0x238(%rsp), %rdi
callq 0xffb6
leaq 0x288(%rsp), %rdi
callq 0x4150
leaq 0x120(%rsp), %rdi
callq 0x4150
leaq 0x220(%rsp), %rdi
callq 0xbcf4
movq %rbx, %rdi
callq 0x4510
jmp 0x9f8c
jmp 0x9f9e
movq %rdx, %r14
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0x4150
testb %bpl, %bpl
jne 0x9f33
jmp 0x9f7a
movq %rdx, %r14
movq %rax, %rbx
jmp 0x9f52
movq %rdx, %r14
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0x4150
testb %bpl, %bpl
je 0x9f7a
jmp 0x9f52
movq %rdx, %r14
movq %rax, %rbx
movq %r15, %rdi
callq 0x4250
jmp 0x9f7a
jmp 0x9f8c
jmp 0x9f9e
jmp 0x9f8c
jmp 0x9f9e
jmp 0x9fb4
jmp 0x9fb4
jmp 0x9f8c
jmp 0x9f9e
jmp 0x9f8c
jmp 0x9f9e
jmp 0x9f8c
jmp 0x9f9e
movq %rdx, %r14
movq %rax, %rbx
leaq 0x190(%rsp), %rdi
jmp 0xa000
movq %rdx, %r14
movq %rax, %rbx
jmp 0x9fc4
movq %rdx, %r14
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x4150
jmp 0x9fba
movq %rdx, %r14
movq %rax, %rbx
movq %r15, %rdi
callq 0x4250
jmp 0x9fba
jmp 0x9fb4
jmp 0x9fb4
jmp 0x9fb4
movq %rdx, %r14
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0x4150
leaq 0x190(%rsp), %rdi
callq 0x4150
leaq 0x108(%rsp), %rdi
callq 0xdb14
leaq 0x270(%rsp), %rdi
callq 0xdb14
leaq 0xe8(%rsp), %rdi
callq 0x4150
leaq 0x250(%rsp), %rdi
callq 0x4150
leaq 0xb8(%rsp), %rdi
callq 0x4150
leaq 0x2a8(%rsp), %rdi
callq 0x4150
cmpl $0x3, %r14d
jne 0xa037
movq %rbx, %rdi
callq 0x4120
callq 0x44e0
jmp 0x8d88
cmpl $0x2, %r14d
jne 0x9e1a
movq %rbx, %rdi
callq 0x4120
movq 0x10fa0(%rip), %rdi     # 0x1aff0
leaq 0x929b(%rip), %rsi      # 0x132f2
callq 0x42f0
movq 0x170(%rsp), %rsi
cmpq 0x178(%rsp), %rsi
jne 0xa07f
movq 0x188(%rsp), %rcx
movl $0x200, %esi            # imm = 0x200
addq -0x8(%rcx), %rsi
addq $-0x28, %rsi
movq %rax, %rdi
callq 0x42d0
leaq 0x8a24(%rip), %rsi      # 0x12ab6
movq %rax, %rdi
callq 0x42f0
movq %rax, %rbx
callq 0x4040
movl (%rax), %edi
callq 0x40e0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x42f0
leaq 0x8a35(%rip), %rsi      # 0x12af0
movq %rax, %rdi
callq 0x42f0
callq 0x44e0
jmp 0x8d88
jmp 0x9e17
jmp 0x9e17
movq %rax, %rbx
callq 0x44e0
jmp 0x9e1a
movq %rax, %rdi
callq 0xac53