// File: /workspace/github_cpp_makefile_star2_O1/davmac314[P]dinit/src/dinit-monitor.cc
// Function: dinit_monitor_main(int, char**)
int dinit_monitor_main(int argc, char **argv)
{
    bool show_help = argc < 2;
    std::string control_socket_str;
    const char *control_socket_path = nullptr;
    bool user_dinit = (getuid() != 0);  // communicate with user daemon
    bool issue_init = false;  // request initial service state
    bool use_environ = false;  // listening on activation environment changes
    bool exit_after = false;  // exit after first issued command
    const char *str_started = "started";
    const char *str_stopped = "stopped";
    const char *str_failed = "failed";
    const char *str_set = "set";
    const char *str_unset = "unset";

    const char *command_str = nullptr;
    std::vector<const char *> services;

    for (int i = 1; i < argc; i++) {
        if (argv[i][0] == '-') {
            if (strcmp(argv[i], "--help") == 0) {
                show_help = true;
                break;
            }
            else if (strcmp(argv[i], "--version") == 0) {
                std::cout << "Dinit version " << DINIT_VERSION << ".\n";
                return 0;
            }
            else if (strcmp(argv[i], "--exit") == 0 || strcmp(argv[i], "-e") == 0) {
                exit_after = true;
            }
            else if (strcmp(argv[i], "--env") == 0 || strcmp(argv[i], "-E") == 0) {
                use_environ = true;
            }
            else if (strcmp(argv[i], "--system") == 0 || strcmp(argv[i], "-s") == 0) {
                user_dinit = false;
            }
            else if (strcmp(argv[i], "--user") == 0 || strcmp(argv[i], "-u") == 0) {
                user_dinit = true;
            }
            else if (strcmp(argv[i], "--initial") == 0 || strcmp(argv[i], "-i") == 0) {
                issue_init = true;
            }
            else if (strcmp(argv[i], "--socket-path") == 0 || strcmp(argv[i], "-p") == 0) {
                ++i;
                if (i == argc) {
                    std::cerr << "dinit-monitor: --socket-path/-p should be followed by socket path\n";
                    return 1;
                }
                control_socket_str = argv[i];
            }
            else if (strcmp(argv[i], "--str-started") == 0) {
                ++i;
                if (i == argc) {
                    std::cerr << "dinit-monitor: --str-started should be followed by an argument\n";
                    return 1;
                }
                str_started = argv[i];
            }
            else if (strcmp(argv[i], "--str-stopped") == 0) {
                ++i;
                if (i == argc) {
                    std::cerr << "dinit-monitor: --str-stopped should be followed by an argument\n";
                    return 1;
                }
                str_stopped = argv[i];
            }
            else if (strcmp(argv[i], "--str-failed") == 0) {
                ++i;
                if (i == argc) {
                    std::cerr << "dinit-monitor: --str-failed should be followed by an argument\n";
                    return 1;
                }
                str_failed = argv[i];
            }
            else if (strcmp(argv[i], "--str-set") == 0) {
                ++i;
                if (i == argc) {
                    std::cerr << "dinit-monitor: --str-set should be followed by an argument\n";
                    return 1;
                }
                str_set = argv[i];
            }
            else if (strcmp(argv[i], "--str-unset") == 0) {
                ++i;
                if (i == argc) {
                    std::cerr << "dinit-monitor: --str-unset should be followed by an argument\n";
                    return 1;
                }
                str_unset = argv[i];
            }
            else if (strcmp(argv[i], "-c") == 0 || strcmp(argv[i], "--command") == 0) {
                ++i;
                if (i == argc) {
                    std::cerr << "dinit-monitor: --command/-c should be followed by command\n";
                    return 1;
                }
                command_str = argv[i];
            }
        }
        else {
            services.emplace_back(argv[i]);
        }
    }

    if (show_help) {
        std::cout << "dinit-monitor:   monitor Dinit services\n"
                "\n"
                "Usage:\n"
                "    dinit-monitor [options] <service-names|environ-names...>\n"
                "\n"
                "Options:\n"
                "  --help           : show this help\n"
                "  -e, --exit       : exit after the first issued command\n"
                "  -E, --env        : monitor activation environment changes\n"
                "  -s, --system     : monitor system daemon (default if run as root)\n"
                "  -u, --user       : monitor user daemon\n"
                "  -i, --initial    : also execute command for initial service state\n"
                "  --str-started <started-text>\n"
                "                   : specify text describing status when service starts\n"
                "  --str-stopped <stopped-text>\n"
                "                   : specify text describing status when service stops\n"
                "  --str-failed <failed-text>\n"
                "                   : specify text describing status when service fails\n"
                "  --socket-path <path>, -p <path>\n"
                "                   : specify socket for communication with daemon\n"
                "  -c, --command    : specify command to execute on service status change\n"
                "                     (%n for service name, %s for status)\n";
        return 1;
    }

    if (services.empty() && !use_environ) {
        std::cerr << "dinit-monitor: specify at least one service name\n";
        return 1;
    }

    if (command_str == nullptr) {
        std::cerr << "dinit-monitor: command must specified\n";
        return 1;
    }

    std::vector<stringview> command_parts = split_command(command_str);
    if (command_parts.size() == 0) {
        std::cerr << "dinit-monitor: specified command is empty\n";
        return 1;
    }

    // Ignore SIGPIPE to avoid dying due to it, and set up a SIGCHLD handler (but mask it)
    sigset_t signal_mask;
    sigprocmask(SIG_SETMASK, nullptr, &signal_mask);
    sigaddset(&signal_mask, SIGCHLD);
    sigprocmask(SIG_SETMASK, &signal_mask, nullptr);
    signal(SIGPIPE, SIG_IGN);
    signal(SIGCHLD, sigchld_handler);

    // Locate control socket
    if (! control_socket_str.empty()) {
        control_socket_path = control_socket_str.c_str();
    }
    else {
        control_socket_path = get_default_socket_path(control_socket_str, user_dinit);
        if (control_socket_path == nullptr) {
            std::cerr << "dinit-monitor: cannot locate user home directory (set XDG_RUNTIME_DIR, "
                    "HOME, check /etc/passwd file, or specify socket path via -p)\n";
            return 1;
        }
    }

    try {
        int socknum = connect_to_daemon(control_socket_path);

        // Start by querying protocol version:
        cpbuffer_t rbuffer;
        uint16_t protocol_ver = check_protocol_version(min_cp_version, max_cp_version, rbuffer, socknum);

        // Load all services
        std::unordered_map<handle_t, const char *> service_map;
        std::unordered_set<std::string> environ_set;
        std::vector<std::pair<const char *, service_state_t>> service_init_state;
        std::string env_value;

        for (const char *service_name : services) {

            handle_t hndl;
            service_state_t state;

            if (use_environ) {
                environ_set.emplace(service_name);
                continue;
            }

            if (!load_service(socknum, rbuffer, service_name, &hndl, &state)) {
                std::cerr << "dinit-monitor: cannot load service: " << service_name << "\n";
                return 1;
            }

            service_map.emplace(hndl, service_name);
            service_init_state.push_back(std::make_pair(service_name, state));
        }

        if (use_environ) {
            // Request listening on environ events
            request_environ(socknum, rbuffer, protocol_ver);
            if (issue_init) {
                // Get the whole block and see if it's already set
                auto envsz = get_allenv(socknum, rbuffer);
                while (envsz > 0) {
                    bool issued;
                    envsz = read_var_and_issue(socknum, rbuffer, envsz, environ_set, env_value, command_parts, issued, str_set, str_unset);
                    if (issued && exit_after) {
                        return 0;
                    }
                }
            }
        }
        else if (issue_init) {
            // Issue initial status commands if requested
            for (auto state : service_init_state ) {
                if (state.second == service_state_t::STARTED) {
                    issue_command(state.first, nullptr, str_started, command_parts);
                    if (exit_after) {
                        return 0;
                    }
                }
                else if (state.second == service_state_t::STOPPED) {
                    issue_command(state.first, nullptr, str_stopped, command_parts);
                    if (exit_after) {
                        return 0;
                    }
                }
            }
        }

        // Watch information packets; execute notification

        int r = rbuffer.fill_to(socknum, 2);
        while (r > 0) {
            if (rbuffer[0] >= 100) {
                int pktlen = (unsigned char) rbuffer[1];
                fill_buffer_to(rbuffer, socknum, pktlen);

                if (use_environ && rbuffer[0] == (char)cp_info::ENVEVENT) {
                    envvar_len_t envln;
                    rbuffer.extract((char *) &envln, 3, sizeof(envln));
                    rbuffer.consume(pktlen);
                    // this will return 0, we don't want to consume after this
                    bool issued;
                    pktlen = read_var_and_issue(socknum, rbuffer, envln, environ_set, env_value, command_parts, issued, str_set, str_unset);
                    if (issued && exit_after) {
                        return 0;
                    }
                }
                else if (!use_environ && rbuffer[0] == (char)cp_info::SERVICEEVENT) {
                    handle_t ev_handle;
                    rbuffer.extract((char *) &ev_handle, 2, sizeof(ev_handle));
                    service_event_t event = static_cast<service_event_t>(rbuffer[2 + sizeof(ev_handle)]);

                    const char *service_name = service_map.at(ev_handle);
                    const char *event_str;

                    if (event == service_event_t::STARTED) {
                        event_str = str_started;
                    }
                    else if (event == service_event_t::STOPPED) {
                        event_str = str_stopped;
                    }
                    else if (event == service_event_t::FAILEDSTART) {
                        event_str = str_failed;
                    }
                    else {
                        goto consume_packet;
                    }
                    issue_command(service_name, nullptr, event_str, command_parts);
                    if (exit_after) {
                        return 0;
                    }
                }

                consume_packet:

                rbuffer.consume(pktlen);
                r = rbuffer.fill_to(socknum, 2);
            }
            else {
                // Not an information packet?
                std::cerr << "dinit-monitor: protocol error\n";
                return 1;
            }
        }

        if (r == -1) {
            perror("dinit-monitor: read");
        }
        else {
            std::cerr << "dinit-monitor: connection closed by server\n";
        }
        return 1;
    }
    catch (cp_old_client_exception &e) {
        std::cerr << "dinit-monitor: too old (server reports newer protocol version)\n";
    }
    catch (cp_old_server_exception &e) {
        std::cerr << "dinit-monitor: server too old or protocol error\n";
    }
    catch (cp_read_exception &e) {
        std::cerr << "dinit-monitor: control socket read failure or protocol error\n";
    }
    catch (cp_write_exception &e) {
        std::cerr << "dinit-monitor: control socket write error: " << std::strerror(e.errcode) << "\n";
    }
    catch (dinit_protocol_error &e) {
        std::cerr << "dinit-monitor: protocol error\n";
    }
    catch (general_error &ge) {
        std::cerr << "dinit-monitor";
        if (ge.get_action() != nullptr) {
            std::cerr << ": " << ge.get_action();
            std::string &arg = ge.get_arg();
            if (!arg.empty()) {
                std::cerr << " " << arg;
            }
        }
        if (ge.get_err() != 0) {
            std::cerr << ": " << strerror(ge.get_err());
        }
        std::cerr << '\n';
    }

    return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x618, %rsp            # imm = 0x618
movq %rsi, %r15
movl %edi, %ebp
leaq 0x48(%rsp), %r14
movq %r14, -0x10(%r14)
xorl %r13d, %r13d
movq %r13, -0x8(%r14)
movb $0x0, (%r14)
callq 0x2110
testl %eax, %eax
setne %al
movl %eax, 0x8(%rsp)
movq %r13, 0xf0(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0xe0(%rsp)
cmpl $0x2, %ebp
setl %r12b
jl 0x2975
movb %r12b, (%rsp)
movl $0x1, %ebx
leaq 0x3bf1(%rip), %rax      # 0x61e5
movq %rax, 0xa0(%rsp)
leaq 0x3b9c(%rip), %rax      # 0x619f
movq %rax, 0xa8(%rsp)
leaq 0x3b41(%rip), %rax      # 0x6153
movq %rax, 0xd8(%rsp)
leaq 0x3ae4(%rip), %rax      # 0x6105
movq %rax, 0x90(%rsp)
leaq 0x3a87(%rip), %rax      # 0x60b7
movq %rax, 0x98(%rsp)
movq $0x0, 0x60(%rsp)
leaq 0xe0(%rsp), %r12
movq $0x0, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
xorl %r13d, %r13d
movslq %ebx, %rax
movq (%r15,%rax,8), %r14
cmpb $0x2d, (%r14)
jne 0x2861
movq %r14, %rdi
leaq 0x398b(%rip), %rsi      # 0x6004
callq 0x22e0
testl %eax, %eax
je 0x2ba0
movq %r14, %rdi
leaq 0x397b(%rip), %rsi      # 0x600b
callq 0x22e0
testl %eax, %eax
je 0x2bb0
movq %r14, %rdi
leaq 0x3980(%rip), %rsi      # 0x6027
callq 0x22e0
testl %eax, %eax
je 0x286f
movq %r14, %rdi
leaq 0x3970(%rip), %rsi      # 0x602e
callq 0x22e0
testl %eax, %eax
je 0x286f
movq %r14, %rdi
leaq 0x395c(%rip), %rsi      # 0x6031
callq 0x22e0
testl %eax, %eax
je 0x2878
movq %r14, %rdi
leaq 0x394b(%rip), %rsi      # 0x6037
callq 0x22e0
testl %eax, %eax
je 0x2878
movq %r14, %rdi
leaq 0x3937(%rip), %rsi      # 0x603a
callq 0x22e0
testl %eax, %eax
je 0x2881
movq %r14, %rdi
leaq 0x3929(%rip), %rsi      # 0x6043
callq 0x22e0
testl %eax, %eax
je 0x2881
movq %r14, %rdi
leaq 0x3915(%rip), %rsi      # 0x6046
callq 0x22e0
testl %eax, %eax
je 0x288b
movq %r14, %rdi
leaq 0x3905(%rip), %rsi      # 0x604d
callq 0x22e0
testl %eax, %eax
je 0x288b
movq %r14, %rdi
leaq 0x38f1(%rip), %rsi      # 0x6050
callq 0x22e0
testl %eax, %eax
je 0x2893
movq %r14, %rdi
leaq 0x38e4(%rip), %rsi      # 0x605a
callq 0x22e0
testl %eax, %eax
je 0x2893
movq %r14, %rdi
leaq 0x38d0(%rip), %rsi      # 0x605d
callq 0x22e0
testl %eax, %eax
je 0x289c
movq %r14, %rdi
leaq 0x38c7(%rip), %rsi      # 0x606b
callq 0x22e0
testl %eax, %eax
je 0x289c
movq %r14, %rdi
leaq 0x38f6(%rip), %rsi      # 0x60b1
callq 0x22e0
testl %eax, %eax
je 0x28eb
movq %r14, %rdi
leaq 0x392d(%rip), %rsi      # 0x60ff
callq 0x22e0
testl %eax, %eax
je 0x2906
movq %r14, %rdi
leaq 0x3964(%rip), %rsi      # 0x614d
callq 0x22e0
testl %eax, %eax
je 0x2921
movq %r14, %rdi
leaq 0x3999(%rip), %rsi      # 0x6199
callq 0x22e0
testl %eax, %eax
je 0x293c
movq %r14, %rdi
leaq 0x39c8(%rip), %rsi      # 0x61df
callq 0x22e0
testl %eax, %eax
je 0x2957
movq %r14, %rdi
leaq 0x39fb(%rip), %rsi      # 0x6229
callq 0x22e0
testl %eax, %eax
je 0x284e
movq %r14, %rdi
leaq 0x39eb(%rip), %rsi      # 0x622c
callq 0x22e0
testl %eax, %eax
jne 0x28dc
incl %ebx
cmpl %ebp, %ebx
je 0x36b4
movslq %ebx, %rax
movq (%r15,%rax,8), %r13
jmp 0x28dc
leaq (%r15,%rax,8), %rsi
movq %r12, %rdi
callq 0x4526
jmp 0x28dc
movb $0x1, %al
movq %rax, 0x10(%rsp)
jmp 0x28dc
movb $0x1, %al
movq %rax, 0x18(%rsp)
jmp 0x28dc
movl $0x0, 0x8(%rsp)
jmp 0x28dc
movb $0x1, %al
movl %eax, 0x8(%rsp)
jmp 0x28dc
movb $0x1, %al
movq %rax, 0x60(%rsp)
jmp 0x28dc
incl %ebx
cmpl %ebp, %ebx
je 0x364d
movslq %ebx, %rax
movq (%r15,%rax,8), %r14
movq 0x40(%rsp), %rax
movq %rax, 0xd0(%rsp)
movq %r14, %rdi
callq 0x20e0
leaq 0x38(%rsp), %rdi
xorl %esi, %esi
movq 0xd0(%rsp), %rdx
movq %r14, %rcx
movq %rax, %r8
callq 0x2340
incl %ebx
cmpl %ebp, %ebx
jl 0x265e
jmp 0x29dd
incl %ebx
cmpl %ebp, %ebx
je 0x367c
movslq %ebx, %rax
movq (%r15,%rax,8), %rax
movq %rax, 0x98(%rsp)
jmp 0x28dc
incl %ebx
cmpl %ebp, %ebx
je 0x368a
movslq %ebx, %rax
movq (%r15,%rax,8), %rax
movq %rax, 0x90(%rsp)
jmp 0x28dc
incl %ebx
cmpl %ebp, %ebx
je 0x3698
movslq %ebx, %rax
movq (%r15,%rax,8), %rax
movq %rax, 0xd8(%rsp)
jmp 0x28dc
incl %ebx
cmpl %ebp, %ebx
je 0x36a6
movslq %ebx, %rax
movq (%r15,%rax,8), %rax
movq %rax, 0xa8(%rsp)
jmp 0x28dc
incl %ebx
cmpl %ebp, %ebx
je 0x36c2
movslq %ebx, %rax
movq (%r15,%rax,8), %rax
movq %rax, 0xa0(%rsp)
jmp 0x28dc
leaq 0x373b(%rip), %rax      # 0x60b7
movq %rax, 0x98(%rsp)
leaq 0x377a(%rip), %rax      # 0x6105
movq %rax, 0x90(%rsp)
leaq 0x37b9(%rip), %rax      # 0x6153
movq %rax, 0xd8(%rsp)
leaq 0x37f6(%rip), %rax      # 0x619f
movq %rax, 0xa8(%rsp)
leaq 0x382d(%rip), %rax      # 0x61e5
movq %rax, 0xa0(%rsp)
movq $0x0, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq $0x0, 0x60(%rsp)
jmp 0x29e6
leaq 0x48(%rsp), %r14
movb (%rsp), %r12b
movb $0x1, %bpl
testb %bpl, %bpl
je 0x2c57
testb %r12b, %r12b
je 0x2a0f
movl $0x3d9, %edx            # imm = 0x3D9
leaq 0x386e(%rip), %rsi      # 0x6271
movq 0x75c6(%rip), %rdi      # 0x9fd0
jmp 0x2c4d
movq 0xe0(%rsp), %rax
cmpq 0xe8(%rsp), %rax
jne 0x2a2c
testb $0x1, 0x18(%rsp)
je 0x2c3a
testq %r13, %r13
je 0x2c0a
movl %ebx, (%rsp)
callq 0x22d0
movq %rax, %rbx
xorps %xmm0, %xmm0
leaq 0x70(%rsp), %r14
movaps %xmm0, (%r14)
movq $0x0, 0x10(%r14)
leaq 0x190(%rsp), %r15
movb (%r13), %bpl
movq %r13, %r12
testb %bpl, %bpl
je 0x2a89
movq %rbx, %rdi
callq 0x20d0
movq 0x30(%rax), %rax
movzbl %bpl, %ecx
testb $0x20, 0x1(%rax,%rcx,2)
je 0x2a89
movb 0x1(%r12), %bpl
incq %r12
jmp 0x2a63
movb (%r12), %bpl
testb %bpl, %bpl
je 0x2b22
movq %r12, %r13
movq %rbx, %rdi
callq 0x20d0
movq 0x30(%rax), %rax
movzbl %bpl, %ecx
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x2ad4
cmpb $0x22, (%r13)
jne 0x2ac8
movzbl 0x1(%r13), %eax
incq %r13
testl %eax, %eax
je 0x2ac8
cmpl $0x22, %eax
jne 0x2ab7
movb 0x1(%r13), %bpl
incq %r13
testb %bpl, %bpl
jne 0x2a99
movq %r13, %rax
subq %r12, %rax
movq %r12, 0x190(%rsp)
movq %rax, 0x198(%rsp)
movq 0x78(%rsp), %rsi
cmpq 0x80(%rsp), %rsi
je 0x2b0c
movups 0x190(%rsp), %xmm0
movups %xmm0, (%rsi)
addq $0x10, 0x78(%rsp)
jmp 0x2b17
movq %r14, %rdi
movq %r15, %rdx
callq 0x5350
cmpb $0x0, (%r13)
jne 0x2a5c
movq 0x78(%rsp), %rax
cmpq 0x70(%rsp), %rax
leaq 0x48(%rsp), %r14
je 0x2c18
leaq 0x598(%rsp), %rbx
movl $0x2, %edi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x20f0
movq %rbx, %rdi
movl $0x11, %esi
callq 0x2320
movl $0x2, %edi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x20f0
movl $0x1, %esi
movl $0xd, %edi
callq 0x2250
leaq 0xfbc(%rip), %rsi       # 0x3b3c
movl $0x11, %edi
callq 0x2250
cmpq $0x0, 0x40(%rsp)
je 0x2c9f
movq 0x38(%rsp), %rdi
jmp 0x2cbd
movb $0x1, %bpl
movb $0x1, %r12b
leaq 0x48(%rsp), %r14
jmp 0x29e9
movq 0x7419(%rip), %rdi      # 0x9fd0
leaq 0x3457(%rip), %rsi      # 0x6015
movl $0xe, %edx
leaq 0x48(%rsp), %r14
callq 0x2230
movb (%rsp), %r12b
movq 0x73f8(%rip), %rdi      # 0x9fd0
leaq 0x3e4e(%rip), %rsi      # 0x6a2d
movl $0x9, %edx
callq 0x2230
xorl %ebp, %ebp
movq 0x73de(%rip), %rdi      # 0x9fd0
leaq 0x342b(%rip), %rsi      # 0x6024
movl $0x2, %edx
callq 0x2230
xorl %ebx, %ebx
jmp 0x29e9
movl $0x26, %edx
leaq 0x3a67(%rip), %rsi      # 0x667d
jmp 0x2c46
movl $0x1, %ebx
movq 0x73cc(%rip), %rdi      # 0x9ff0
leaq 0x3a79(%rip), %rsi      # 0x66a4
movl $0x2a, %edx
callq 0x2230
jmp 0x362a
movl $0x31, %edx
leaq 0x3a05(%rip), %rsi      # 0x664b
movq 0x73a3(%rip), %rdi      # 0x9ff0
movl $0x1, %ebx
callq 0x2230
movq 0xe0(%rsp), %rdi
testq %rdi, %rdi
je 0x2c74
movq 0xf0(%rsp), %rsi
subq %rdi, %rsi
callq 0x2200
movq 0x38(%rsp), %rdi
cmpq %r14, %rdi
je 0x2c8b
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x2200
movl %ebx, %eax
addq $0x618, %rsp            # imm = 0x618
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movzbl 0x8(%rsp), %esi
andl $0x1, %esi
leaq 0x38(%rsp), %rdi
callq 0x4556
movq %rax, %rdi
testq %rax, %rax
je 0x31ec
callq 0x464c
movl %eax, %r15d
leaq 0x190(%rsp), %rdx
movq $0x0, 0x400(%rdx)
movl $0x1, %edi
movl $0x5, %esi
movl %eax, %ecx
callq 0x4841
movw %ax, 0x26(%rsp)
leaq 0x188(%rsp), %rax
movq %rax, -0x30(%rax)
movl $0x1, %ecx
movq %rcx, -0x28(%rax)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%rax)
movl $0x3f800000, %edx       # imm = 0x3F800000
movl %edx, -0x10(%rax)
movups %xmm0, -0x8(%rax)
leaq 0x150(%rsp), %rax
movq %rax, -0x30(%rax)
movq %rcx, -0x28(%rax)
movups %xmm0, -0x20(%rax)
movl %edx, -0x10(%rax)
movups %xmm0, -0x8(%rax)
xorl %eax, %eax
movq %rax, 0xc0(%rsp)
movaps %xmm0, 0xb0(%rsp)
leaq 0x110(%rsp), %rcx
movq %rcx, -0x10(%rcx)
movq %rax, -0x8(%rcx)
movb $0x0, (%rcx)
movq 0xe0(%rsp), %rax
movq 0xe8(%rsp), %rcx
movq %rcx, 0xd0(%rsp)
cmpq %rcx, %rax
sete %r13b
je 0x30a1
movq %rax, 0x8(%rsp)
movq (%rax), %rbx
movq %rbx, 0x58(%rsp)
testb $0x1, 0x18(%rsp)
je 0x2dab
movl $0x6, %ebx
leaq 0x120(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x56d8
jmp 0x307d
movq %rbx, %rdi
callq 0x20e0
movq %rax, %rbp
movzwl %bp, %r12d
addl $0x3, %r12d
movq %r12, %rdi
callq 0x2030
movq %rax, %r14
movb %r13b, 0x7(%rsp)
movb $0x2, (%rax)
movw %bp, 0x1(%rax)
movq %rax, %rdi
addq $0x3, %rdi
movzwl %bp, %edx
movq %rbx, %rsi
callq 0x2180
xorl %ebp, %ebp
movq %r14, %rbx
movl %r12d, %edx
movl %r15d, %edi
movq %rbx, %rsi
callq 0x20a0
cmpl $-0x1, %eax
je 0x2e0e
addl %eax, %ebp
movslq %eax, %rcx
addq %rcx, %rbx
subl %eax, %r12d
xorl %ecx, %ecx
jmp 0x2e2e
callq 0x2040
movl $0x2, %ecx
cmpl $0x4, (%rax)
je 0x2e2e
testl %ebp, %ebp
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
cmovgl %ebp, %r13d
movl $0x1, %ecx
testb $0x1, %cl
jne 0x2e3a
testl %r12d, %r12d
jg 0x2dec
jmp 0x2e3d
movl %r13d, %ebp
cmpl $-0x1, %ebp
je 0x3759
movq %r14, %rdi
callq 0x2290
leaq 0x190(%rsp), %rdi
movl %r15d, %esi
callq 0x4c62
movb 0x7(%rsp), %r13b
movl 0x590(%rsp), %eax
leal -0x400(%rax), %ecx
cmpl $0x400, %eax            # imm = 0x400
cmovbl %eax, %ecx
movzbl 0x190(%rsp,%rcx), %eax
cmpl $0x3c, %eax
je 0x2f43
cmpl $0x3b, %eax
jne 0x3780
leaq 0x190(%rsp), %r12
movl $0x1, %ebp
cmpl $0x5, 0x594(%rsp)
ja 0x2ebd
movq %r12, %rdi
movl %r15d, %esi
callq 0x55a8
testl %eax, %eax
cmovlel %eax, %ebx
movl %ebx, %ebp
jg 0x2e9a
cmpl $-0x1, %ebp
je 0x2ecb
testl %ebp, %ebp
jne 0x2ed9
jmp 0x3701
callq 0x2040
cmpl $0x4, (%rax)
jne 0x3737
cmpl $-0x1, %ebp
je 0x2e9a
movl 0x590(%rsp), %ebx
leal 0x2(%rbx), %eax
addl $0xfffffc02, %ebx       # imm = 0xFFFFFC02
cmpl $0x400, %eax            # imm = 0x400
cmovbl %eax, %ebx
leal -0x3fd(%rbx), %ecx
movl %ebx, %eax
cmpl $0xfffffbfe, %ecx       # imm = 0xFFFFFBFE
ja 0x2f47
movl $0x400, %r14d           # imm = 0x400
subl %ebx, %r14d
leaq (%rsp,%rax), %rsi
addq $0x190, %rsi            # imm = 0x190
leaq 0x6c(%rsp), %rbp
movq %rbp, %rdi
movq %r14, %rdx
callq 0x2180
addq %rbp, %r14
addl $0xfffffc04, %ebx       # imm = 0xFFFFFC04
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x2180
jmp 0x2f52
xorl %eax, %eax
jmp 0x2f95
movl 0x190(%rsp,%rax), %eax
movl %eax, 0x6c(%rsp)
movl 0x590(%rsp), %eax
leal 0x1(%rax), %ecx
leal -0x3ff(%rax), %edx
movl $0x400, %esi            # imm = 0x400
cmpl %esi, %ecx
cmovbl %ecx, %edx
movb 0x190(%rsp,%rdx), %cl
movb %cl, 0x6(%rsp)
leal 0x7(%rax), %ecx
addl $0xfffffc07, %eax       # imm = 0xFFFFFC07
cmpl %esi, %ecx
cmovbl %ecx, %eax
movl %eax, 0x590(%rsp)
addl $-0x7, 0x594(%rsp)
movb $0x1, %al
testb %al, %al
je 0x2fe7
leaq 0x158(%rsp), %rdi
leaq 0x6c(%rsp), %rsi
leaq 0x58(%rsp), %rdx
callq 0x5a10
movq 0x58(%rsp), %rax
movq %rax, 0x28(%rsp)
movb 0x6(%rsp), %al
movb %al, 0x30(%rsp)
movq 0xb8(%rsp), %rsi
cmpq 0xc0(%rsp), %rsi
je 0x3025
movups 0x28(%rsp), %xmm0
movups %xmm0, (%rsi)
addq $0x10, 0xb8(%rsp)
jmp 0x3037
movl $0x24, %edx
movq 0x6ffd(%rip), %rdi      # 0x9ff0
leaq 0x375a(%rip), %rsi      # 0x6754
callq 0x2230
movq 0x58(%rsp), %rbx
testq %rbx, %rbx
je 0x303b
movq %rbx, %rdi
callq 0x20e0
movq 0x6fd8(%rip), %rdi      # 0x9ff0
movq %rbx, %rsi
movq %rax, %rdx
callq 0x2230
jmp 0x3059
leaq 0xb0(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x5cfc
xorl %ebx, %ebx
jmp 0x307d
movq 0x6fae(%rip), %rcx      # 0x9ff0
movq (%rcx), %rax
movq -0x18(%rax), %rax
leaq (%rcx,%rax), %rdi
movl 0x20(%rcx,%rax), %esi
orl $0x1, %esi
callq 0x2380
movl $0x1, %ebx
movl $0x1, %edx
movq 0x6f86(%rip), %rdi      # 0x9ff0
leaq 0x384e(%rip), %rsi      # 0x68bf
callq 0x2230
movl $0x1, (%rsp)
cmpl $0x6, %ebx
je 0x3086
testl %ebx, %ebx
jne 0x30a1
movq 0x8(%rsp), %rax
addq $0x8, %rax
cmpq 0xd0(%rsp), %rax
sete %r13b
jne 0x2d7b
testb $0x1, %r13b
je 0x35c6
testb $0x1, 0x18(%rsp)
je 0x315f
movzwl 0x26(%rsp), %edx
leaq 0x190(%rsp), %rsi
movl %r15d, %edi
callq 0x3b3d
testb $0x1, 0x60(%rsp)
je 0x321e
leaq 0x190(%rsp), %rsi
movl %r15d, %edi
callq 0x3c62
leaq 0x120(%rsp), %r14
leaq 0x100(%rsp), %r12
leaq 0x70(%rsp), %r13
xorl %ebp, %ebp
movq %rax, %rbx
testq %rax, %rax
je 0x3151
subq $0x8, %rsp
movl %r15d, %edi
leaq 0x198(%rsp), %rsi
movq %rbx, %rdx
movq %r14, %rcx
movq %r12, %r8
movq %r13, %r9
pushq 0xa8(%rsp)
pushq 0xb8(%rsp)
leaq 0x40(%rsp), %rax
pushq %rax
callq 0x3e10
addq $0x20, %rsp
movq 0x10(%rsp), %rcx
testb %cl, 0x28(%rsp)
movl (%rsp), %ecx
cmovnel %ebp, %ecx
movl %ecx, (%rsp)
je 0x30fd
testq %rbx, %rbx
jne 0x35c6
jmp 0x321e
testb $0x1, 0x60(%rsp)
je 0x321e
movq 0xb0(%rsp), %r14
movq 0xb8(%rsp), %r12
cmpq %r12, %r14
sete %bpl
je 0x320e
leaq 0x70(%rsp), %rbx
movq (%r14), %rdi
movzbl 0x8(%r14), %eax
testl %eax, %eax
je 0x31b1
cmpl $0x2, %eax
jne 0x31d1
xorl %esi, %esi
movq 0x98(%rsp), %rdx
movq %rbx, %rcx
callq 0x419f
jmp 0x31c3
xorl %esi, %esi
movq 0x90(%rsp), %rdx
movq %rbx, %rcx
callq 0x419f
xorl %ecx, %ecx
movl $0x0, %eax
testb $0x1, 0x10(%rsp)
jne 0x31d6
movb $0x1, %cl
movl (%rsp), %eax
testb %cl, %cl
je 0x3211
addq $0x10, %r14
movl %eax, (%rsp)
cmpq %r12, %r14
sete %bpl
jne 0x318c
jmp 0x3211
movl $0x1, %ebx
movq 0x6df8(%rip), %rdi      # 0x9ff0
leaq 0x34d0(%rip), %rsi      # 0x66cf
movl $0x84, %edx
callq 0x2230
jmp 0x362a
movl (%rsp), %eax
movl %eax, (%rsp)
testb $0x1, %bpl
je 0x35c6
leaq 0x190(%rsp), %rbx
cmpl $0x1, 0x594(%rsp)
ja 0x3245
movq %rbx, %rdi
movl %r15d, %esi
callq 0x55a8
testl %eax, %eax
cmovlel %eax, %r12d
jg 0x3226
jmp 0x324b
movl $0x1, %r12d
movq 0x10(%rsp), %rax
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x8(%rsp)
leaq 0x190(%rsp), %r14
testl %r12d, %r12d
jle 0x358f
movl 0x590(%rsp), %eax
leal -0x400(%rax), %ecx
cmpl $0x400, %eax            # imm = 0x400
cmovbl %eax, %ecx
cmpb $0x64, 0x190(%rsp,%rcx)
jl 0x35a7
leal 0x1(%rax), %ecx
addl $0xfffffc01, %eax       # imm = 0xFFFFFC01
cmpl $0x400, %ecx            # imm = 0x400
cmovbl %ecx, %eax
movzbl 0x190(%rsp,%rax), %ebx
movl $0x1, %ebp
cmpl %ebx, 0x594(%rsp)
jae 0x32ca
movq %r14, %rdi
movl %r15d, %esi
callq 0x55a8
testl %eax, %eax
cmovlel %eax, %r13d
movl %r13d, %ebp
jg 0x32a6
cmpl $-0x1, %ebp
je 0x32d8
testl %ebp, %ebp
jne 0x32e6
jmp 0x36ef
callq 0x2040
cmpl $0x4, (%rax)
jne 0x3713
cmpl $-0x1, %ebp
je 0x32a6
movl 0x590(%rsp), %r13d
leal -0x400(%r13), %eax
cmpl $0x400, %r13d           # imm = 0x400
cmovbl %r13d, %eax
movb 0x190(%rsp,%rax), %al
testb $0x1, 0x18(%rsp)
je 0x3387
cmpb $0x66, %al
jne 0x3536
leal 0x3(%r13), %eax
addl $0xfffffc03, %r13d      # imm = 0xFFFFFC03
cmpl $0x400, %eax            # imm = 0x400
cmovbl %eax, %r13d
leal -0x3ff(%r13), %ecx
movl %r13d, %eax
cmpl $0xfffffbfe, %ecx       # imm = 0xFFFFFBFE
ja 0x33fb
movl $0x400, %ebp            # imm = 0x400
subl %r13d, %ebp
leaq (%rsp,%rax), %rsi
addq $0x190, %rsi            # imm = 0x190
leaq 0x28(%rsp), %rdi
movq %rbp, %rdx
callq 0x2180
leaq 0x28(%rsp), %rax
addq %rax, %rbp
addl $0xfffffc02, %r13d      # imm = 0xFFFFFC02
movq %rbp, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x2180
jmp 0x3408
cmpb $0x64, %al
jne 0x3536
leal 0x2(%r13), %eax
addl $0xfffffc02, %r13d      # imm = 0xFFFFFC02
cmpl $0x400, %eax            # imm = 0x400
cmovbl %eax, %r13d
leal -0x3fd(%r13), %ecx
movl %r13d, %eax
cmpl $0xfffffbfe, %ecx       # imm = 0xFFFFFBFE
ja 0x349b
movl $0x400, %ebp            # imm = 0x400
subl %r13d, %ebp
leaq (%rsp,%rax), %rsi
addq $0x190, %rsi            # imm = 0x190
leaq 0x28(%rsp), %rdi
movq %rbp, %rdx
callq 0x2180
leaq 0x28(%rsp), %rax
addq %rax, %rbp
addl $0xfffffc04, %r13d      # imm = 0xFFFFFC04
movq %rbp, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x2180
jmp 0x34a6
movzwl 0x190(%rsp,%rax), %eax
movw %ax, 0x28(%rsp)
movl 0x590(%rsp), %eax
leal (%rax,%rbx), %ecx
cmpl $0x400, %ecx            # imm = 0x400
leal -0x400(%rax,%rbx), %eax
cmovbl %ecx, %eax
movl %eax, 0x590(%rsp)
subl %ebx, 0x594(%rsp)
movzwl 0x28(%rsp), %edx
subq $0x8, %rsp
movl %r15d, %edi
movq %r14, %rsi
leaq 0x128(%rsp), %rcx
leaq 0x108(%rsp), %r8
leaq 0x78(%rsp), %r9
pushq 0xa8(%rsp)
pushq 0xb8(%rsp)
leaq 0x70(%rsp), %rax
pushq %rax
callq 0x3e10
addq $0x20, %rsp
movq %rax, %rbx
movl $0x1, %ebp
movq 0x10(%rsp), %rax
testb %al, 0x58(%rsp)
movl (%rsp), %eax
movl $0x0, %ecx
cmovnel %ecx, %eax
movl %eax, (%rsp)
je 0x3536
jmp 0x3585
movl 0x190(%rsp,%rax), %eax
movl %eax, 0x28(%rsp)
leaq 0x28(%rsp), %rsi
movl 0x590(%rsp), %eax
leal 0x6(%rax), %ecx
addl $0xfffffc06, %eax       # imm = 0xFFFFFC06
cmpl $0x400, %ecx            # imm = 0x400
cmovbl %ecx, %eax
movzbl 0x190(%rsp,%rax), %r13d
leaq 0x158(%rsp), %rdi
callq 0x5e3c
movq (%rax), %rdi
movq 0x98(%rsp), %rdx
testl %r13d, %r13d
je 0x350a
movq 0x90(%rsp), %rdx
cmpl $0x1, %r13d
je 0x350a
movl $0xd, %ebp
cmpl $0x2, %r13d
jne 0x352d
movq 0xd8(%rsp), %rdx
xorl %esi, %esi
leaq 0x70(%rsp), %rcx
callq 0x419f
testb $0x1, 0x10(%rsp)
movl (%rsp), %eax
movl $0x0, %ecx
cmovnel %ecx, %eax
movl %eax, (%rsp)
movl 0x8(%rsp), %ebp
testl %ebp, %ebp
je 0x3536
cmpl $0xd, %ebp
jne 0x3585
movl 0x590(%rsp), %eax
leal (%rax,%rbx), %ecx
cmpl $0x400, %ecx            # imm = 0x400
leal -0x400(%rax,%rbx), %eax
cmovbl %ecx, %eax
movl %eax, 0x590(%rsp)
subl %ebx, 0x594(%rsp)
xorl %ebp, %ebp
cmpl $0x1, 0x594(%rsp)
ja 0x357f
movq %r14, %rdi
movl %r15d, %esi
callq 0x55a8
testl %eax, %eax
cmovlel %eax, %r12d
jg 0x355e
jmp 0x3585
movl $0x1, %r12d
testl %ebp, %ebp
je 0x3261
jmp 0x35c6
cmpl $-0x1, %r12d
je 0x3664
movl $0x2b, %edx
leaq 0x3207(%rip), %rsi      # 0x67ac
jmp 0x35b3
movl $0x1e, %edx
leaq 0x31c6(%rip), %rsi      # 0x6779
movl $0x1, (%rsp)
movq 0x6a2f(%rip), %rdi      # 0x9ff0
callq 0x2230
movq 0x100(%rsp), %rdi
leaq 0x110(%rsp), %rax
cmpq %rax, %rdi
je 0x35eb
movq 0x110(%rsp), %rsi
incq %rsi
callq 0x2200
movq 0xb0(%rsp), %rdi
testq %rdi, %rdi
leaq 0x48(%rsp), %r14
je 0x360d
movq 0xc0(%rsp), %rsi
subq %rdi, %rsi
callq 0x2200
leaq 0x120(%rsp), %rdi
callq 0x4e12
leaq 0x158(%rsp), %rdi
callq 0x4eb0
movl (%rsp), %ebx
movq 0x70(%rsp), %rdi
testq %rdi, %rdi
je 0x2c57
movq 0x80(%rsp), %rsi
subq %rdi, %rsi
callq 0x2200
jmp 0x2c57
movl $0x42, %edx
leaq 0x48(%rsp), %r14
movb (%rsp), %r12b
leaq 0x2a0c(%rip), %rsi      # 0x606e
jmp 0x36d7
leaq 0x312d(%rip), %rdi      # 0x6798
callq 0x21a0
movl $0x1, (%rsp)
jmp 0x35c6
movl $0x3f, %edx
leaq 0x2a37(%rip), %rsi      # 0x60bf
jmp 0x36ce
movl $0x3f, %edx
leaq 0x2a77(%rip), %rsi      # 0x610d
jmp 0x36ce
movl $0x3e, %edx
leaq 0x2ab6(%rip), %rsi      # 0x615a
jmp 0x36ce
movl $0x3b, %edx
leaq 0x2af1(%rip), %rsi      # 0x61a3
jmp 0x36ce
movl $0x3a, %edx
leaq 0x2b76(%rip), %rsi      # 0x6236
jmp 0x36ce
movl $0x3d, %edx
leaq 0x2b1d(%rip), %rsi      # 0x61eb
leaq 0x48(%rsp), %r14
movb (%rsp), %r12b
movq 0x6912(%rip), %rdi      # 0x9ff0
callq 0x2230
movl $0x1, %ebx
xorl %ebp, %ebp
jmp 0x29e9
movl $0x4, %edi
callq 0x2100
movl $0x0, (%rax)
jmp 0x3726
movl $0x4, %edi
callq 0x2100
movl $0x0, (%rax)
jmp 0x3748
movq %rax, %r13
movl $0x4, %edi
callq 0x2100
movl (%r13), %ecx
movl %ecx, (%rax)
leaq 0x663b(%rip), %rsi      # 0x9d68
movq %rax, %rdi
xorl %edx, %edx
callq 0x2390
movq %rax, %rbx
movl $0x4, %edi
callq 0x2100
movl (%rbx), %ecx
movl %ecx, (%rax)
leaq 0x6619(%rip), %rsi      # 0x9d68
movq %rax, %rdi
xorl %edx, %edx
callq 0x2390
movl $0x4, %edi
callq 0x2100
movq %rax, %rbx
callq 0x2040
movl (%rax), %eax
movl %eax, (%rbx)
leaq 0x6602(%rip), %rsi      # 0x9d78
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2390
movl $0x1, %edi
callq 0x2100
leaq 0x6597(%rip), %rsi      # 0x9d28
movq %rax, %rdi
xorl %edx, %edx
callq 0x2390
jmp 0x37dd
jmp 0x37dd
jmp 0x37dd
jmp 0x3ade
jmp 0x37dd
jmp 0x3ade
jmp 0x37dd
jmp 0x37dd
jmp 0x37dd
jmp 0x37b5
movq %rdx, %rbx
movq %rax, %r15
jmp 0x384f
jmp 0x37dd
jmp 0x37d5
jmp 0x37dd
jmp 0x37d5
jmp 0x37d5
jmp 0x37e5
jmp 0x3ade
jmp 0x37dd
jmp 0x37dd
movq %rax, %r15
jmp 0x3afb
movq %rdx, %rbx
movq %rax, %r15
jmp 0x37f3
movq %rdx, %rbx
movq %rax, %r15
movq %r14, %rdi
callq 0x2290
movq 0x100(%rsp), %rdi
leaq 0x110(%rsp), %rax
cmpq %rax, %rdi
je 0x3818
movq 0x110(%rsp), %rsi
incq %rsi
callq 0x2200
movq 0xb0(%rsp), %rdi
testq %rdi, %rdi
je 0x3835
movq 0xc0(%rsp), %rsi
subq %rdi, %rsi
callq 0x2200
leaq 0x120(%rsp), %rdi
callq 0x4e12
leaq 0x158(%rsp), %rdi
callq 0x4eb0
cmpl $0x6, %ebx
jne 0x3888
movq %r15, %rdi
callq 0x20c0
movq 0x678d(%rip), %rdi      # 0x9ff0
leaq 0x3017(%rip), %rsi      # 0x6881
movl $0x3f, %edx
callq 0x2230
movl $0x1, %ebx
leaq 0x48(%rsp), %r14
callq 0x2370
jmp 0x362a
cmpl $0x5, %ebx
jne 0x38c1
movq %r15, %rdi
callq 0x20c0
movq 0x6754(%rip), %rdi      # 0x9ff0
leaq 0x2fad(%rip), %rsi      # 0x6850
movl $0x30, %edx
callq 0x2230
movl $0x1, %ebx
leaq 0x48(%rsp), %r14
callq 0x2370
jmp 0x362a
cmpl $0x4, %ebx
jne 0x38fa
movq %r15, %rdi
callq 0x20c0
movq 0x671b(%rip), %rdi      # 0x9ff0
leaq 0x2f36(%rip), %rsi      # 0x6812
movl $0x3d, %edx
callq 0x2230
movl $0x1, %ebx
leaq 0x48(%rsp), %r14
callq 0x2370
jmp 0x362a
cmpl $0x3, %ebx
jne 0x3960
movq %r15, %rdi
callq 0x20c0
movq %rax, %rbx
movq 0x66df(%rip), %rdi      # 0x9ff0
leaq 0x2ece(%rip), %rsi      # 0x67e6
movl $0x2b, %edx
callq 0x2230
movl (%rbx), %edi
callq 0x2090
movq 0x66c0(%rip), %rdi      # 0x9ff0
movq %rax, %rsi
callq 0x21e0
leaq 0x2f80(%rip), %rsi      # 0x68bf
movl $0x1, %edx
movq %rax, %rdi
callq 0x2230
movl $0x1, %ebx
leaq 0x48(%rsp), %r14
callq 0x2370
jmp 0x362a
cmpl $0x2, %ebx
jne 0x3999
movq %r15, %rdi
callq 0x20c0
movq 0x667c(%rip), %rdi      # 0x9ff0
leaq 0x2dfe(%rip), %rsi      # 0x6779
movl $0x1e, %edx
callq 0x2230
movl $0x1, %ebx
leaq 0x48(%rsp), %r14
callq 0x2370
jmp 0x362a
cmpl $0x1, %ebx
jne 0x3ae1
movq %r15, %rdi
callq 0x20c0
movq %rax, %rbx
movq 0x663c(%rip), %rdi      # 0x9ff0
leaq 0x2e1d(%rip), %rsi      # 0x67d8
movl $0xd, %edx
callq 0x2230
cmpq $0x0, 0x8(%rbx)
je 0x3a27
movq 0x661d(%rip), %rdi      # 0x9ff0
leaq 0x2d9c(%rip), %rsi      # 0x6776
movl $0x2, %edx
callq 0x2230
movq 0x8(%rbx), %rsi
movq 0x6601(%rip), %rdi      # 0x9ff0
callq 0x21e0
cmpq $0x0, 0x18(%rbx)
je 0x3a27
movq 0x65ee(%rip), %rdi      # 0x9ff0
leaq 0x2d6e(%rip), %rsi      # 0x6777
movl $0x1, %edx
callq 0x2230
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rdx
movq 0x65ce(%rip), %rdi      # 0x9ff0
callq 0x2230
cmpl $0x0, (%rbx)
je 0x3a5a
movq 0x65bd(%rip), %rdi      # 0x9ff0
leaq 0x2d3c(%rip), %rsi      # 0x6776
movl $0x2, %edx
callq 0x2230
movl (%rbx), %edi
callq 0x2090
movq 0x659e(%rip), %rdi      # 0x9ff0
movq %rax, %rsi
callq 0x21e0
leaq 0x190(%rsp), %rsi
movb $0xa, (%rsi)
movq 0x6584(%rip), %rdi      # 0x9ff0
movl $0x1, %edx
callq 0x2230
movl $0x1, %ebx
leaq 0x48(%rsp), %r14
callq 0x2370
jmp 0x362a
jmp 0x3aa8
jmp 0x3ade
jmp 0x3ade
movq %rax, %r15
callq 0x2370
jmp 0x3ae1
jmp 0x3ade
jmp 0x3ade
movq %rax, %r15
callq 0x2370
jmp 0x3ae1
movq %rax, %r15
callq 0x2370
jmp 0x3ae1
movq %rax, %r15
callq 0x2370
jmp 0x3ae1
jmp 0x3ade
movq %rax, %r15
callq 0x2370
jmp 0x3ae1
jmp 0x3ade
movq %rax, %r15
callq 0x2370
jmp 0x3ae1
movq %rax, %rdi
callq 0x4add
jmp 0x3ade
movq %rax, %r15
movq 0x70(%rsp), %rdi
testq %rdi, %rdi
je 0x3afb
movq 0x80(%rsp), %rsi
subq %rdi, %rsi
callq 0x2200
movq 0xe0(%rsp), %rdi
testq %rdi, %rdi
je 0x3b18
movq 0xf0(%rsp), %rsi
subq %rdi, %rsi
callq 0x2200
movq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rax
cmpq %rax, %rdi
je 0x3b34
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x2200
movq %r15, %rdi
callq 0x23b0