// File: /workspace/github_cpp_makefile_star2_O2/davmac314[P]dinit/src/dinitcheck.cc
// Function: main
int main(int argc, char **argv)
{
    using namespace std;

    service_dir_opt service_dir_opts;
    bool user_dinit = (getuid() != 0);  // use user instance defaults/daemon instance
    std::string control_socket_str;
    const char * control_socket_path = nullptr;
    std::string env_file;

    std::vector<std::string> services_to_check;

    // Process command line
    if (argc > 1) {
        for (int i = 1; i < argc; i++) {
            if (argv[i][0] == '-') {
                // An option...
                if (strcmp(argv[i], "--services-dir") == 0 || strcmp(argv[i], "-d") == 0) {
                    if (++i < argc && argv[i][0] != '\0') {
                        service_dir_opts.set_specified_service_dir(argv[i]);
                    }
                    else {
                        cerr << "dinitcheck: '--services-dir' (-d) requires an argument" << endl;
                        return 1;
                    }
                }
                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], "--socket-path") == 0 || strcmp(argv[i], "-p") == 0) {
                    ++i;
                    if (i == argc || argv[i][0] == '\0') {
                        cerr << "dinitcheck: --socket-path/-p should be followed by socket path\n";
                        return 1;
                    }
                    control_socket_str = argv[i];
                }
                else if (strcmp(argv[i], "--online") == 0 || strcmp(argv[i], "-n") == 0) {
                    offline_operation = false;
                }
                else if (strcmp(argv[i], "--env-file") == 0 || strcmp(argv[i], "-e") == 0) {
                    ++i;
                    if (i == argc || argv[i][0] == '\0') {
                        cerr << "dinitcheck: --env-file/-e should be followed by environment file path\n";
                        return 1;
                    }
                    env_file = argv[i];
                }
                else if (strcmp(argv[i], "--help") == 0) {
                    cout << "dinitcheck: check dinit service descriptions\n"
                            " --help                       display help\n"
                            " --services-dir <dir>, -d <dir>\n"
                            "                              set base directory for service description\n"
                            "                              files, can be specified multiple times\n"
                            " --online, -n                 use service dirs and environment from running\n"
                            "                              dinit instance\n"
                            " --socket-path <path>, -p <path>\n"
                            "                              use specified socket to connect to daemon (online\n"
                            "                              mode)\n"
                            " --env-file, -e <file>        read environment from specified file\n"
                            " --system, -s                 use defaults for system manager mode\n"
                            " --user, -u                   use defaults for user mode\n"
                            " <service-name>               check service with name <service-name>\n";
                    return EXIT_SUCCESS;
                }
                else {
                    std::cerr << "dinitcheck: Unrecognized option: '" << argv[i] << "' (use '--help' for help)\n";
                    return EXIT_FAILURE;
                }
            }
            else {
                services_to_check.push_back(argv[i]);
            }
        }
    }

    int socknum = -1;
    cpbuffer_t rbuffer;
    signal(SIGPIPE, SIG_IGN);

    service_dir_pathlist service_dir_paths;
    std::vector<std::string> service_dir_strs; // storage if needed for service_dir_paths

    if (offline_operation) {
        service_dir_opts.build_paths(!user_dinit);
        service_dir_paths = std::move(service_dir_opts.get_paths());
        if (env_file.empty()) {
            if (!user_dinit) {
                env_file = "/etc/dinit/environment";
            }
        }
        if (!env_file.empty()) {
            auto log_inv_env_setting = [&](int line_num) {
                std::cerr << "dinitcheck: warning: Invalid environment variable setting in environment file "
                        << env_file << " (line " << std::to_string(line_num) << ")\n";
            };
            auto log_bad_env_command = [&](int line_num) {
                std::cerr << "dinitcheck: warning: Bad command in environment file "
                        << env_file << " (line " << std::to_string(line_num) << ")\n";
            };

            try {
                read_env_file_inline(env_file.c_str(), true, menv, false, log_inv_env_setting, log_bad_env_command);
            }
            catch (std::system_error &err) {
                std::cerr << "dinitcheck: error read environment file " << env_file << ": "
                        << err.code().message() << "\n";
                return EXIT_FAILURE;
            }
        }
    }
    else {
        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) {
                cerr << "dinitcheck: cannot locate user home directory (set XDG_RUNTIME_DIR, HOME, check /etc/passwd file, or "
                        "specify socket path via -p)" << endl;
                return EXIT_FAILURE;
            }
        }

        try {
            socknum = connect_to_daemon(control_socket_path);

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

            // Read service directories
            service_dir_strs = get_service_description_dirs(socknum, rbuffer);
            for (const std::string &service_dir : service_dir_strs) {
                service_dir_paths.emplace_back(dir_entry(service_dir.c_str(), false));
            }

            menv.clear_no_inherit();
            get_remote_env(socknum, rbuffer);
        }
        catch (cp_old_client_exception &e) {
            std::cerr << "dinitcheck: too old (daemon reports newer protocol version)" << std::endl;
            return EXIT_FAILURE;
        }
        catch (cp_old_server_exception &e) {
            std::cerr << "dinitcheck: daemon too old or protocol error" << std::endl;
            return EXIT_FAILURE;
        }
        catch (cp_read_exception &e) {
            cerr << "dinitcheck: control socket read failure or protocol error" << endl;
            return EXIT_FAILURE;
        }
        catch (cp_write_exception &e) {
            cerr << "dinitcheck: control socket write error: " << std::strerror(e.errcode) << endl;
            return EXIT_FAILURE;
        }
        catch (dinit_protocol_error &e) {
            cerr << "dinitcheck: protocol error" << endl;
            return EXIT_FAILURE;
        }
        catch (general_error &ge) {
            std::cerr << "dinitcheck";
            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 EXIT_FAILURE;
        }
    }

    if (services_to_check.empty()) {
        services_to_check.push_back("boot");
    }

    size_t num_services_to_check = services_to_check.size();

    // Load named service(s)
    // - load the service, store dependencies as strings
    // - recurse

    std::map<std::string, service_record *> service_set;

    for (size_t i = 0; i < services_to_check.size(); ++i) {
        const std::string &name = services_to_check[i];
        std::cout << "Checking service: " << name << "...\n";
        try {
            service_record *sr = load_service(service_set, name, service_dir_paths);
            service_set[name] = sr;
            // add dependencies to services_to_check
            for (auto &dep : sr->dependencies) {
                if (service_set.count(dep.name) == 0 && !contains(services_to_check, dep.name)) {
                    services_to_check.push_back(dep.name);
                }
            }
            // add chain_to to services_to_check
            if (!sr->chain_to.empty() && !contains(services_to_check, sr->chain_to)) {
                if (!contains(services_to_check, sr->chain_to)) {
                    services_to_check.push_back(sr->chain_to);
                }
            }
            // add before_svcs and after_svcs to services_to_check
            for (const std::string &before_name : sr->before_svcs) {
                if (!contains(services_to_check, before_name)) {
                    services_to_check.push_back(before_name);
                }
            }
            for (const std::string &after_name : sr->after_svcs) {
                if (!contains(services_to_check, after_name)) {
                    services_to_check.push_back(after_name);
                }
            }
            // add consumed service (if any) to services to check
            if (!sr->consumer_of_name.empty()) {
                services_to_check.push_back(sr->consumer_of_name);
            }
        }
        catch (service_load_exc &exc) {
            std::cerr << "Unable to load service '" << name << "': " << exc.exc_description << "\n";
            errors_found = true;
        }
    }

    std::cout << "Performing secondary checks...\n";

    for (const auto &svc_name_record : service_set) {
        if (!svc_name_record.second->consumer_of_name.empty()) {
            auto consumer_of_it = service_set.find(svc_name_record.second->consumer_of_name);
            if (consumer_of_it != service_set.end()) {
                if (consumer_of_it->second->log_type != log_type_id::PIPE) {
                    std::cerr << "Service '" << svc_name_record.first << "': specified as consumer of service '"
                            << consumer_of_it->first << "' which has log-type that is not 'pipe'.\n";
                    errors_found = true;
                }
                else if (!value(consumer_of_it->second->service_type).is_in(service_type_t::PROCESS,
                        service_type_t::BGPROCESS, service_type_t::SCRIPTED)) {
                    std::cerr << "Service '" << svc_name_record.first << "': specified as consumer of service '"
                            << consumer_of_it->first << "' which is not a process-based service.\n";
                    errors_found = true;
                }
            }
            else {
                std::cerr << "Warning: Service '" << svc_name_record.first << "' specified as consumer of service '"
                        << consumer_of_it->first << "' which was not found.\n";
            }
        }

        // "before" ordering links are like reverse-dependencies: set up dependencies in the forwards direction
        // (from the dependent). Similarly for "after" links set up a dependency. These dependencies allow cycle
        // checking.
        for (const std::string &before_name : svc_name_record.second->before_svcs) {
            auto before_svc_it = service_set.find(before_name);
            if (before_svc_it != service_set.end()) {
                before_svc_it->second->dependencies.emplace_back(svc_name_record.first,
                        dependency_type::BEFORE);
            }
        }
        for (const std::string &after_name : svc_name_record.second->after_svcs) {
        	auto after_svc_it = service_set.find(after_name);
        	if (after_svc_it != service_set.end()) {
        		svc_name_record.second->dependencies.emplace_back(after_svc_it->first,
        				dependency_type::AFTER);
        	}
        }
    }

    // Check for circular dependencies
    std::vector<std::tuple<service_record *, size_t>> service_chain;

    for (size_t i = 0; i < num_services_to_check; ++i) {
        service_record *root = service_set[services_to_check[i]];
        if (! root) continue;
        if (root->visited) continue;

        // invariant: service_chain is empty
        service_chain.emplace_back(root, 0);

        // Depth first traversal. If we find a link (dependency) on a service already visited (but not
        // marked as cycle-free), we know then that we've found a cycle.
        while (true) {
            auto n = service_chain.size() - 1;
            auto &last = service_chain[n];
            service_record *last_record = std::get<0>(last);
            size_t &index = std::get<1>(last);
            if (index >= last_record->dependencies.size()) {
                // Processed all dependencies, go back up:
                last_record->cycle_free = true;
                service_chain.pop_back();
                if (n == 0) break;
                size_t &prev_index = std::get<1>(service_chain[n - 1]);
                ++prev_index;
                continue;
            }
            // Down the tree:
            auto dep_it = std::next(last_record->dependencies.begin(), index);
            service_record *next_link = service_set[dep_it->name];
            if (next_link == nullptr) {
                ++index;
                continue;
            }
            if (next_link->visited) {
                if (! next_link->cycle_free) {
                    // We've found a cycle. Clear entries before the beginning of the cycle, then
                    // exit the loop.
                    auto first = std::find_if(service_chain.begin(), service_chain.end(),
                            [next_link](std::tuple<service_record *, size_t> &a) -> bool {
                       return std::get<0>(a) == next_link;
                    });
                    service_chain.erase(service_chain.begin(), first);
                    break;
                }
            }
            next_link->visited = true;
            service_chain.emplace_back(next_link, 0);
        }

        // Report only one cycle; otherwise difficult to avoid reporting duplicates or overlapping
        // cycles.
        if (!service_chain.empty()) break;
    }

    if (!service_chain.empty()) {
        errors_found = true;
        std::cerr << "Found dependency cycle:\n";
        for (auto chain_link : service_chain) {
            service_record *svc = std::get<0>(chain_link);
            size_t dep_index = std::get<1>(chain_link);
            std::cerr << "    " << svc->name << " ->";
            auto dep_it = std::next(svc->dependencies.begin(), dep_index);
            if (dep_it->dep_type == dependency_type::BEFORE) {
                std::cerr << " (via 'before')";
            }
            if (dep_it->dep_type == dependency_type::AFTER) {
            	std::cerr << " (via 'after')";
            }
            std::cerr << "\n";
        }
        std::cerr << "    " << std::get<0>(service_chain[0])->name << ".\n";
    }

    std::cerr << "Secondary checks complete.\n";

    if (! errors_found) {
        std::cout << "No problems found.\n";
    }
    else {
        std::cout << "One or more errors/warnings issued.\n";
    }

    return errors_found ? EXIT_FAILURE : EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x808, %rsp            # imm = 0x808
movq %rsi, (%rsp)
movl %edi, %ebp
xorps %xmm0, %xmm0
movaps %xmm0, 0x170(%rsp)
movaps %xmm0, 0x160(%rsp)
movaps %xmm0, 0x150(%rsp)
callq 0x41e0
testl %eax, %eax
setne %r14b
leaq 0x120(%rsp), %rcx
movq %rcx, -0x10(%rcx)
andq $0x0, -0x8(%rcx)
leaq 0xd0(%rsp), %rdx
movq %rdx, -0x10(%rdx)
andq $0x0, -0x8(%rdx)
xorl %esi, %esi
movb %sil, (%rcx)
movb %sil, (%rdx)
xorps %xmm0, %xmm0
movaps %xmm0, 0x50(%rsp)
andq $0x0, 0x60(%rsp)
cmpl $0x2, %ebp
jl 0x4b03
testl %eax, %eax
setne %al
movl %eax, 0x8(%rsp)
pushq $0x1
popq %r14
movq 0x1f6fa(%rip), %rax     # 0x23fe8
movq %rax, 0x10(%rsp)
leaq 0x128cc(%rip), %r15     # 0x171c6
leaq 0x400(%rsp), %rbx
cmpl %ebp, %r14d
jge 0x4afe
movslq %r14d, %r13
movq (%rsp), %rax
movq (%rax,%r13,8), %r12
cmpb $0x2d, (%r12)
jne 0x4a55
movq %r12, %rdi
leaq 0x127e3(%rip), %rsi     # 0x1710e
callq 0x4530
testl %eax, %eax
je 0x4a7f
cmpb $0x64, 0x1(%r12)
jne 0x494c
cmpb $0x0, 0x2(%r12)
je 0x4a7f
movq %r12, %rdi
leaq 0x127fe(%rip), %rsi     # 0x17154
callq 0x4530
testl %eax, %eax
je 0x4aae
cmpb $0x73, 0x1(%r12)
jne 0x4977
cmpb $0x0, 0x2(%r12)
je 0x4aae
movq %r12, %rdi
leaq 0x127dc(%rip), %rsi     # 0x1715d
callq 0x4530
testl %eax, %eax
je 0x4ab8
cmpb $0x75, 0x1(%r12)
jne 0x49a2
cmpb $0x0, 0x2(%r12)
je 0x4ab8
movq %r12, %rdi
leaq 0x127b8(%rip), %rsi     # 0x17164
callq 0x4530
testl %eax, %eax
je 0x4ac0
cmpb $0x70, 0x1(%r12)
jne 0x49cd
cmpb $0x0, 0x2(%r12)
je 0x4ac0
movq %r12, %rdi
leaq 0x127db(%rip), %rsi     # 0x171b2
callq 0x4530
testl %eax, %eax
je 0x4aef
cmpb $0x6e, 0x1(%r12)
jne 0x49f8
cmpb $0x0, 0x2(%r12)
je 0x4aef
movq %r12, %rdi
leaq 0x127b9(%rip), %rsi     # 0x171bb
callq 0x4530
testl %eax, %eax
je 0x4a23
cmpb $0x65, 0x1(%r12)
jne 0x5e05
cmpb $0x0, 0x2(%r12)
jne 0x5e05
incl %r14d
cmpl %ebp, %r14d
je 0x5df3
movslq %r14d, %rax
movq (%rsp), %rcx
movq (%rcx,%rax,8), %rsi
cmpb $0x0, (%rsi)
je 0x5df3
leaq 0xc0(%rsp), %rdi
callq 0x4690
jmp 0x4af6
movq %rbx, %rdi
movq %r12, %rsi
leaq 0x1f8(%rsp), %rdx
callq 0xb9ce
leaq 0x50(%rsp), %rdi
movq %rbx, %rsi
callq 0x1054c
movq %rbx, %rdi
callq 0x41a0
jmp 0x4af6
incl %r14d
cmpl %ebp, %r14d
jge 0x523b
movslq %r14d, %rax
movq (%rsp), %rcx
movq (%rcx,%rax,8), %rsi
cmpb $0x0, (%rsi)
je 0x523b
leaq 0x150(%rsp), %rdi
callq 0xb9bc
jmp 0x4af6
movl $0x0, 0x8(%rsp)
jmp 0x4af6
movb $0x1, %al
movl %eax, 0x8(%rsp)
jmp 0x4af6
incl %r14d
cmpl %ebp, %r14d
je 0x5dec
movslq %r14d, %rax
movq (%rsp), %rcx
movq (%rcx,%rax,8), %rsi
cmpb $0x0, (%rsi)
je 0x5dec
leaq 0x110(%rsp), %rdi
callq 0x4690
jmp 0x4af6
movb $0x1, 0x1fcf2(%rip)     # 0x247e8
incl %r14d
jmp 0x4902
movl 0x8(%rsp), %r14d
pushq $0x1
popq %rax
movl %eax, 0x1c(%rsp)
andq $0x0, 0x800(%rsp)
pushq $0xd
popq %rdi
pushq $0x1
popq %rsi
callq 0x4450
andq $0x0, 0x100(%rsp)
andq $0x0, 0x140(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0xf0(%rsp)
movaps %xmm0, 0x130(%rsp)
cmpb $0x0, 0x1fc9e(%rip)     # 0x247e8
je 0x4b68
cmpq $0x0, 0x118(%rsp)
je 0x50b2
movq 0x110(%rsp), %rdi
jmp 0x50d2
movl %r14d, %eax
notb %al
movzbl %al, %esi
andl $0x1, %esi
leaq 0x150(%rsp), %rdi
callq 0x14580
leaq 0x168(%rsp), %rsi
leaq 0xf0(%rsp), %rdi
callq 0x108aa
movq 0xc8(%rsp), %rax
testq %rax, %rax
setne %cl
orb %r14b, %cl
testb $0x1, %cl
jne 0x4bc7
leaq 0x129b9(%rip), %rsi     # 0x1756b
leaq 0xc0(%rsp), %rdi
callq 0x4690
movq 0xc8(%rsp), %rax
testq %rax, %rax
je 0x545f
leaq 0xc0(%rsp), %rax
movq %rax, 0xb8(%rsp)
movq (%rax), %rsi
leaq 0x1f8(%rsp), %rdi
pushq $0x8
popq %rdx
callq 0x4650
movq 0x1f8(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x218(%rsp,%rax)
jne 0x526c
leaq (%rsp,%rax), %rdi
addq $0x1f8, %rdi            # imm = 0x1F8
pushq $0x1
popq %rsi
callq 0x4120
callq 0x44f0
movq %rax, %r12
leaq 0x80(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq $0x0, 0x10(%rsp)
movq %r12, (%rsp)
leaq 0x1f8(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x40b0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x5262
movq 0x10(%rsp), %rax
incl %eax
movq %rax, 0x10(%rsp)
movq 0x70(%rsp), %rbp
movq 0x78(%rsp), %rax
leaq (%rax,%rbp), %r13
leaq -0x2(%rax), %r14
movq %rbp, %r15
notq %r15
movq %rax, 0x48(%rsp)
addq %rax, %r15
xorl %ebx, %ebx
movq %rbp, 0x108(%rsp)
cmpq %r13, %rbp
je 0x4c49
movsbl (%rbp), %edi
movq %r12, %rsi
callq 0x1096c
testb %al, %al
je 0x4cc7
incq %rbp
decq %r14
decq %rbx
addq $-0x2, %r15
jmp 0x4ca3
movzbl (%rbp), %eax
cmpl $0x21, %eax
je 0x4d42
cmpl $0x23, %eax
je 0x4c49
movq %rbp, 0x8(%rsp)
cmpl $0x3d, %eax
jne 0x4cfe
leaq 0xb8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x8c44
movq (%rsp), %r12
jmp 0x4c49
movq 0x8(%rsp), %r12
movq %r15, %r14
leaq 0x1(%r12), %rcx
cmpq %r13, %rcx
je 0x4ea2
movb (%rcx), %al
cmpb $0x3d, %al
movq %rcx, 0x8(%rsp)
je 0x4ea7
movsbl %al, %edi
movq (%rsp), %rsi
callq 0x1096c
movq %rbx, %rcx
decq %rbx
leaq -0x1(%r14), %r15
testb %al, %al
je 0x4cfe
jmp 0x4eaa
incq %rbp
movq %rbp, %rbx
testq %r14, %r14
je 0x4d64
incq %rbx
movsbl (%rbx), %edi
movq %r12, %rsi
callq 0x1096c
decq %r14
testb %al, %al
je 0x4d48
jmp 0x4d67
movq %r13, %rbx
movq %rbx, %rax
subq %rbp, %rax
movq %rbp, 0xe0(%rsp)
movq %rax, 0xe8(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x90(%rsp)
andq $0x0, 0xa0(%rsp)
leaq 0x1f980(%rip), %rbp     # 0x24718
cmpq %r13, %rbx
je 0x4e05
movq %rbx, %r14
negq %r14
movsbl (%rbx), %edi
movq %r12, %rsi
callq 0x1096c
testb %al, %al
je 0x4dbf
incq %rbx
decq %r14
cmpq %r13, %rbx
jne 0x4da3
jmp 0x4e05
negq %r14
xorl %r12d, %r12d
leaq (%rbx,%r12), %r15
cmpq %r13, %r15
je 0x4de0
movsbl (%r15), %edi
callq 0x4070
testl %eax, %eax
jne 0x4de0
incq %r12
jmp 0x4dc5
movq %r14, 0x20(%rsp)
movq %r12, 0x28(%rsp)
leaq 0x90(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x10baa
movq %r15, %rbx
movq (%rsp), %r12
jmp 0x4d98
leaq 0xe0(%rsp), %rbx
movq %rbx, %rdi
leaq 0x12ded(%rip), %rsi     # 0x17c04
callq 0x1098a
testb %al, %al
je 0x4e3a
movq %rbp, %rdi
callq 0xc000
leaq 0x90(%rsp), %rdi
callq 0x110de
jmp 0x4c49
movq %rbx, %rdi
leaq 0x12dc6(%rip), %rsi     # 0x17c0a
callq 0x1098a
testb %al, %al
leaq 0x30(%rsp), %r15
leaq 0x20(%rsp), %r13
je 0x4f44
movq 0x90(%rsp), %rbx
movq 0x98(%rsp), %r14
cmpq %r14, %rbx
je 0x4e28
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
movq %r15, 0x20(%rsp)
movq %r13, %rdi
callq 0xd86e
movq %rbp, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x109ac
movq %r13, %rdi
callq 0x41a0
addq $0x10, %rbx
jmp 0x4e6b
movq %r13, 0x8(%rsp)
movq %rbx, %rcx
addq 0x8(%rsp), %r14
pushq $0x1
popq %rbx
movq %rbx, %rax
subq 0x48(%rsp), %rax
movq %rax, 0x48(%rsp)
movq %rcx, %r15
cmpq %r15, 0x48(%rsp)
je 0x4f29
movsbl (%r12,%rbx), %edi
movq (%rsp), %rsi
callq 0x1096c
testb %al, %al
je 0x4ee6
incq %rbx
decq %r15
decq %r14
jmp 0x4ec2
cmpb $0x3d, (%r12,%rbx)
jne 0x4f29
cmpq $0x1, %rbx
jne 0x5009
cmpq 0x70(%rsp), %rbp
jne 0x5009
leaq 0x70(%rsp), %rbx
movq %rbx, %rdi
callq 0x46c0
leaq 0x1f802(%rip), %rdi     # 0x24718
movq %rbx, %rsi
xorl %edx, %edx
callq 0xc958
movq (%rsp), %r12
jmp 0x4c49
leaq 0xb8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x8c44
movq (%rsp), %r12
jmp 0x4c49
movq %rbx, %rdi
leaq 0x12cc2(%rip), %rsi     # 0x17c10
callq 0x1098a
testb %al, %al
je 0x4fa0
movq 0x90(%rsp), %rbx
movq 0x98(%rsp), %r14
cmpq %r14, %rbx
je 0x4e28
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
movq %r15, 0x20(%rsp)
movq %r13, %rdi
callq 0xd86e
movq %rbp, %rdi
movq %r13, %rsi
callq 0x10a4e
movq %r13, %rdi
callq 0x41a0
addq $0x10, %rbx
jmp 0x4f67
movq 0x1f041(%rip), %rdi     # 0x23fe8
leaq 0x12cc0(%rip), %rsi     # 0x17c6e
callq 0x4380
movq %rax, %rdi
leaq 0xc0(%rsp), %rsi
callq 0x4350
movq %rax, %rdi
leaq 0x12c99(%rip), %rsi     # 0x17c66
callq 0x4380
movq %rax, %rbx
movq %r13, %rdi
movq 0x10(%rsp), %rsi
callq 0x10ab7
movq %rbx, %rdi
movq %r13, %rsi
callq 0x4350
movq %rax, %rdi
leaq 0x12571(%rip), %rsi     # 0x17568
callq 0x4380
movq %r13, %rdi
callq 0x41a0
jmp 0x4e28
leaq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
andq $0x0, 0x28(%rsp)
movb $0x0, 0x30(%rsp)
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0x45b0
movq (%rsp), %r12
leaq 0x90(%rsp), %rbx
movq 0x8(%rsp), %rcx
subq %rbp, %rcx
subq 0x70(%rsp), %rbp
movq %rbx, %rdi
leaq 0x70(%rsp), %rsi
movq %rbp, %rdx
callq 0x43c0
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4480
movq %rbx, %rdi
callq 0x41a0
movq %r14, %rdi
pushq $0x1
popq %rsi
pushq $0x3d
popq %rdx
callq 0x43f0
movq 0x108(%rsp), %rsi
subq %r15, %rsi
addq $0x2, %rsi
movq %r14, %rdi
movq %r13, %rdx
callq 0x10aa2
leaq 0x1f67d(%rip), %rdi     # 0x24718
movq %r14, %rsi
xorl %edx, %edx
callq 0xc958
movq %r14, %rdi
callq 0x41a0
jmp 0x4c49
movzbl %r14b, %esi
andl $0x1, %esi
leaq 0x110(%rsp), %rdi
callq 0xba14
movq %rax, %rdi
testq %rax, %rax
je 0x5dcf
callq 0xbac2
movl %eax, %ebx
pushq $0x1
popq %rdi
pushq $0x5
popq %rsi
leaq 0x400(%rsp), %rdx
movl %eax, %ecx
callq 0xbc73
leaq 0x1f8(%rsp), %rdi
leaq 0x400(%rsp), %rdx
movl %ebx, %esi
callq 0xbd69
leaq 0x130(%rsp), %r15
leaq 0x1f8(%rsp), %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x110fc
movq %r14, %rdi
callq 0xbf8a
movq (%r15), %r12
movq 0x8(%r15), %r13
leaq 0xf0(%rsp), %r15
cmpq %r13, %r12
je 0x5169
movq (%r12), %rax
movq %rax, 0x1f8(%rsp)
movb $0x0, 0x200(%rsp)
movq %r15, %rdi
movq %r14, %rsi
callq 0xbfac
movq %r14, %rdi
callq 0xbfec
addq $0x20, %r12
jmp 0x5137
leaq 0x1f5a8(%rip), %rdi     # 0x24718
callq 0xc000
leaq 0x70(%rsp), %rsi
movw $0x18, (%rsi)
pushq $0x2
popq %rdx
movl %ebx, %edi
callq 0xd3c5
leaq 0x400(%rsp), %rdi
movl %ebx, %esi
callq 0xd3f7
movl 0x800(%rsp), %eax
leal -0x400(%rax), %ecx
cmpl $0x400, %eax            # imm = 0x400
cmovbl %eax, %ecx
cmpb $0x4e, 0x400(%rsp,%rcx)
jne 0x5e82
leaq 0x400(%rsp), %r14
pushq $0x9
popq %rdx
movq %r14, %rdi
movl %ebx, %esi
callq 0xd5ea
leaq 0x20(%rsp), %r15
pushq $0x1
popq %rdx
pushq $0x8
popq %rcx
movq %r14, %rdi
movq %r15, %rsi
callq 0xd4ee
movl 0x400(%r14), %ecx
movl 0x404(%r14), %eax
leal 0x9(%rcx), %edx
addl $0xfffffc09, %ecx       # imm = 0xFFFFFC09
cmpl $0x400, %edx            # imm = 0x400
cmovbl %edx, %ecx
movl %ecx, 0x400(%r14)
addl $-0x9, %eax
movl %eax, 0x404(%r14)
cmpq $0x0, (%r15)
je 0x545f
testl %eax, %eax
je 0x527e
leaq 0x208(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
jmp 0x52af
movq 0x1eda6(%rip), %rdi     # 0x23fe8
leaq 0x11ed4(%rip), %rsi     # 0x1711d
callq 0x4380
movq %rax, %rdi
callq 0x41c0
pushq $0x1
popq %rax
movl %eax, 0x1c(%rsp)
jmp 0x5d88
leaq 0x70(%rsp), %rdi
callq 0x41a0
leaq 0x1f8(%rsp), %rdi
callq 0x40e0
jmp 0x545f
leaq 0x400(%rsp), %rdi
movl %ebx, %esi
callq 0xd7eb
leaq 0x208(%rsp), %rax
andq $0x0, -0x8(%rax)
movq 0x20(%rsp), %rcx
movq %rax, -0x10(%rax)
movb $0x0, (%rax)
testq %rcx, %rcx
je 0x5452
movl $0xfffffc00, %r13d      # imm = 0xFFFFFC00
leaq 0x400(%rsp), %r14
leaq 0x1f8(%rsp), %r15
movl 0x800(%rsp), %eax
leal (%rax,%r13), %ecx
cmpl $0x400, %eax            # imm = 0x400
cmovbl %eax, %ecx
leaq (%rsp,%rcx), %rsi
addq $0x400, %rsi            # imm = 0x400
movq %r14, %rdi
callq 0xdbce
movl %eax, %ebp
movq 0x20(%rsp), %rax
cmpq %rbp, %rax
cmovbq %rax, %rbp
movl 0x800(%rsp), %eax
leal (%rax,%r13), %ecx
xorl %r12d, %r12d
cmpl %r12d, %ebp
je 0x5330
leal (%rax,%r12), %edx
leal (%rcx,%r12), %esi
cmpl $0x400, %edx            # imm = 0x400
cmovbl %edx, %esi
cmpb $0x0, 0x400(%rsp,%rsi)
je 0x53b4
incq %r12
jmp 0x5307
leal -0x400(%rax), %ecx
cmpl $0x400, %eax            # imm = 0x400
cmovbl %eax, %ecx
leaq 0x400(%rsp,%rcx), %rsi
leaq (%rsi,%rbp), %rdx
movq %r15, %rdi
callq 0xdc0a
movl 0x800(%rsp), %eax
leal (%rax,%rbp), %ecx
cmpl $0x400, %ecx            # imm = 0x400
leal -0x400(%rax,%rbp), %eax
cmovbl %ecx, %eax
movl 0x804(%rsp), %ecx
movl %eax, 0x800(%rsp)
movl %ecx, %eax
subl %ebp, %eax
movl %eax, 0x804(%rsp)
movq 0x20(%rsp), %rax
subq %rbp, %rax
movq %rax, 0x20(%rsp)
je 0x5e69
cmpl %ebp, %ecx
jne 0x5440
movq %r14, %rdi
movl %ebx, %esi
callq 0xd7eb
movq 0x20(%rsp), %rax
jmp 0x5440
leal -0x400(%rax), %ecx
cmpl $0x400, %eax            # imm = 0x400
cmovbl %eax, %ecx
leaq 0x400(%rsp,%rcx), %rsi
leaq (%rsi,%r12), %rdx
movq %r15, %rdi
callq 0xdc0a
movl 0x800(%rsp), %eax
leal (%rax,%r12), %ecx
incl %ecx
cmpl $0x400, %ecx            # imm = 0x400
leal -0x3ff(%rax,%r12), %eax
cmovbl %ecx, %eax
movl %eax, 0x800(%rsp)
movl %r12d, %eax
notl %eax
addl %eax, 0x804(%rsp)
leal 0x1(%r12), %eax
subq %rax, 0x20(%rsp)
leaq 0x1f300(%rip), %rdi     # 0x24718
movq %r15, %rsi
xorl %edx, %edx
callq 0xc958
andq $0x0, 0x200(%rsp)
movq 0x1f8(%rsp), %rax
movb $0x0, (%rax)
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x5452
cmpl %r12d, %ebp
jne 0x52c5
testq %rax, %rax
jne 0x52c5
leaq 0x1f8(%rsp), %rdi
callq 0x41a0
movq 0x50(%rsp), %rdx
movq 0x58(%rsp), %rax
cmpq %rax, %rdx
jne 0x54b0
leaq 0x122a9(%rip), %rsi     # 0x1771e
leaq 0x1f8(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0xb9ce
leaq 0x50(%rsp), %rdi
leaq 0x1f8(%rsp), %rsi
callq 0x1054c
leaq 0x1f8(%rsp), %rdi
callq 0x41a0
movq 0x50(%rsp), %rdx
movq 0x58(%rsp), %rax
movq %rax, %rcx
subq %rdx, %rcx
sarq $0x5, %rcx
movq %rcx, 0x48(%rsp)
leaq 0x200(%rsp), %rcx
andl $0x0, (%rcx)
andq $0x0, 0x8(%rcx)
movq %rcx, 0x10(%rcx)
movq %rcx, 0x18(%rcx)
andq $0x0, 0x20(%rcx)
xorl %ecx, %ecx
leaq 0x50(%rsp), %r14
subq %rdx, %rax
sarq $0x5, %rax
movq %rcx, 0x8(%rsp)
cmpq %rax, %rcx
jae 0x57e3
movq %rdx, %rbx
movq 0x1ea6e(%rip), %rdi     # 0x23f70
leaq 0x1221a(%rip), %rsi     # 0x17723
callq 0x4380
movq 0x8(%rsp), %rcx
shlq $0x5, %rcx
movq %rbx, %rsi
addq %rcx, %rsi
movq %rax, %rdi
movq %rsi, 0x10(%rsp)
callq 0x4350
movq %rax, %rdi
leaq 0x1223a(%rip), %rsi     # 0x1776e
callq 0x4380
leaq 0x1f8(%rsp), %rdi
movq 0x10(%rsp), %rsi
leaq 0xf0(%rsp), %rdx
callq 0x636f
movq %rax, (%rsp)
leaq 0x1f8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xc026
movq (%rsp), %rcx
movq %rcx, (%rax)
leaq 0x48(%rcx), %rbx
movq %rbx, %r12
movq (%r12), %r12
cmpq %rbx, %r12
je 0x55d9
leaq 0x10(%r12), %r13
leaq 0x1f8(%rsp), %rdi
movq %r13, %rsi
callq 0xc08c
testq %rax, %rax
jne 0x5577
leaq 0x1e0(%rsp), %rdi
movq %r14, %rsi
callq 0xc0c2
leaq 0x1e0(%rsp), %r15
movq %r15, %rdi
movq %r13, %rsi
callq 0xc0a6
movl %eax, %ebp
movq %r15, %rdi
callq 0xbf8a
testb %bpl, %bpl
jne 0x5577
movq %r14, %rdi
movq %r13, %rsi
callq 0xc116
jmp 0x5577
movq (%rsp), %rax
cmpq $0x0, 0x30(%rax)
je 0x565b
leaq 0x1c8(%rsp), %rdi
movq %r14, %rsi
callq 0xc0c2
movq (%rsp), %rax
leaq 0x28(%rax), %r15
leaq 0x1c8(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc0a6
movl %eax, %ebp
movq %rbx, %rdi
callq 0xbf8a
testb %bpl, %bpl
jne 0x565b
leaq 0x1b0(%rsp), %rdi
movq %r14, %rsi
callq 0xc0c2
leaq 0x1b0(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc0a6
movl %eax, %ebp
movq %rbx, %rdi
callq 0xbf8a
testb %bpl, %bpl
jne 0x565b
movq %r14, %rdi
movq %r15, %rsi
callq 0xc116
movq (%rsp), %rax
leaq 0x60(%rax), %rbx
movq %rbx, %r12
movq (%r12), %r12
cmpq %rbx, %r12
je 0x56b3
leaq 0x198(%rsp), %rdi
movq %r14, %rsi
callq 0xc0c2
leaq 0x10(%r12), %r13
leaq 0x198(%rsp), %r15
movq %r15, %rdi
movq %r13, %rsi
callq 0xc0a6
movl %eax, %ebp
movq %r15, %rdi
callq 0xbf8a
testb %bpl, %bpl
jne 0x5666
movq %r14, %rdi
movq %r13, %rsi
callq 0xc116
jmp 0x5666
movq (%rsp), %rax
leaq 0x78(%rax), %rbx
movq %rbx, %r12
movq (%r12), %r12
cmpq %rbx, %r12
je 0x570b
leaq 0x180(%rsp), %rdi
movq %r14, %rsi
callq 0xc0c2
leaq 0x10(%r12), %r13
leaq 0x180(%rsp), %r15
movq %r15, %rdi
movq %r13, %rsi
callq 0xc0a6
movl %eax, %ebp
movq %r15, %rdi
callq 0xbf8a
testb %bpl, %bpl
jne 0x56be
movq %r14, %rdi
movq %r13, %rsi
callq 0xc116
jmp 0x56be
movq (%rsp), %rax
cmpq $0x0, 0x98(%rax)
je 0x572c
movq (%rsp), %rsi
addq $0x90, %rsi
movq %r14, %rdi
callq 0xc116
movq 0x8(%rsp), %rcx
incq %rcx
movq 0x50(%rsp), %rdx
movq 0x58(%rsp), %rax
jmp 0x54e3
jmp 0x5745
movq %rdx, %r12
movq %rax, %r13
movq %rbx, %rdi
jmp 0x575f
jmp 0x576a
jmp 0x5756
jmp 0x5756
movq %rdx, %r12
movq %rax, %r13
movq %r15, %rdi
callq 0xbf8a
jmp 0x5770
jmp 0x576a
jmp 0x576a
movq %rdx, %r12
movq %rax, %r13
cmpl $0x8, %r12d
jne 0x630f
movq %r13, %rdi
callq 0x4160
movq %rax, %r12
movq 0x1e85c(%rip), %rdi     # 0x23fe8
leaq 0x11fa3(%rip), %rsi     # 0x17736
callq 0x4380
movq %rax, %rdi
movq 0x10(%rsp), %rsi
callq 0x4350
movq %rax, %rdi
leaq 0x11fa0(%rip), %rsi     # 0x1774f
callq 0x4380
addq $0x20, %r12
movq %rax, %rdi
movq %r12, %rsi
callq 0x4350
movq %rax, %rdi
leaq 0x11d9c(%rip), %rsi     # 0x17569
callq 0x4380
movb $0x1, 0x1f010(%rip)     # 0x247e9
callq 0x4600
jmp 0x572c
movq 0x1e786(%rip), %rdi     # 0x23f70
leaq 0x11f62(%rip), %rsi     # 0x17753
callq 0x4380
leaq 0x1f8(%rsp), %rbx
movq 0x18(%rbx), %r12
leaq 0x20(%rsp), %r14
leaq 0x200(%rsp), %rax
cmpq %rax, %r12
je 0x59ff
leaq 0x20(%r12), %rbp
movq 0x40(%r12), %rsi
cmpq $0x0, 0x98(%rsi)
je 0x5954
addq $0x90, %rsi
movq %rbx, %rdi
callq 0x119e8
movq %rax, %r13
leaq 0x200(%rsp), %rax
cmpq %rax, %r13
je 0x58b9
movq %r13, %rax
addq $0x20, %r13
movq 0x40(%rax), %rax
cmpl $0x3, 0xb0(%rax)
jne 0x5906
movl 0x20(%rax), %eax
decl %eax
cmpl $0x3, %eax
jb 0x5954
movq 0x1e76c(%rip), %rdi     # 0x23fe8
leaq 0x11f72(%rip), %rsi     # 0x177f5
callq 0x4380
movq %rax, %rdi
movq %rbp, %rsi
callq 0x4350
movq %rax, %rdi
leaq 0x11ed6(%rip), %rsi     # 0x17773
callq 0x4380
movq %rax, %rdi
movq %r13, %rsi
callq 0x4350
leaq 0x11f0f(%rip), %rsi     # 0x177c3
jmp 0x5945
movq 0x1e728(%rip), %rdi     # 0x23fe8
leaq 0x11f25(%rip), %rsi     # 0x177ec
callq 0x4380
movq %rax, %rdi
movq %rbp, %rsi
callq 0x4350
movq %rax, %rdi
leaq 0x11f1e(%rip), %rsi     # 0x177ff
callq 0x4380
addq $0x20, %r13
movq %rax, %rdi
movq %r13, %rsi
callq 0x4350
movq %rax, %rdi
leaq 0x11f25(%rip), %rsi     # 0x17824
callq 0x4380
jmp 0x5954
movq 0x1e6db(%rip), %rdi     # 0x23fe8
leaq 0x11ee1(%rip), %rsi     # 0x177f5
callq 0x4380
movq %rax, %rdi
movq %rbp, %rsi
callq 0x4350
movq %rax, %rdi
leaq 0x11e45(%rip), %rsi     # 0x17773
callq 0x4380
movq %rax, %rdi
movq %r13, %rsi
callq 0x4350
leaq 0x11e54(%rip), %rsi     # 0x17799
movq %rax, %rdi
callq 0x4380
movb $0x1, 0x1ee95(%rip)     # 0x247e9
movq 0x40(%r12), %r15
addq $0x60, %r15
movq %r15, %r13
movq (%r13), %r13
cmpq %r15, %r13
je 0x599f
leaq 0x10(%r13), %rsi
movq %rbx, %rdi
callq 0x119e8
leaq 0x200(%rsp), %rcx
cmpq %rcx, %rax
je 0x5960
movq 0x40(%rax), %rdi
addq $0x48, %rdi
movl $0x4, 0x20(%rsp)
movq %rbp, %rsi
movq %r14, %rdx
callq 0xc142
jmp 0x5960
movq 0x40(%r12), %r13
addq $0x78, %r13
movq %r13, %rbp
movq (%rbp), %rbp
cmpq %r13, %rbp
je 0x59ef
leaq 0x10(%rbp), %rsi
movq %rbx, %rdi
callq 0x119e8
leaq 0x200(%rsp), %rcx
cmpq %rcx, %rax
je 0x59ab
movq 0x40(%r12), %rdi
addq $0x48, %rdi
addq $0x20, %rax
movl $0x5, 0x20(%rsp)
movq %rax, %rsi
movq %r14, %rdx
callq 0xc142
jmp 0x59ab
movq %r12, %rdi
callq 0x42b0
movq %rax, %r12
jmp 0x5807
leaq 0x20(%rsp), %rbx
andq $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rbx)
xorl %ebp, %ebp
leaq 0x1f8(%rsp), %r14
leaq 0x90(%rsp), %r12
cmpq 0x48(%rsp), %rbp
je 0x5c10
movq %rbp, %rsi
shlq $0x5, %rsi
addq 0x50(%rsp), %rsi
movq %r14, %rdi
callq 0xc026
movq (%rax), %rax
movq %rax, 0x70(%rsp)
testq %rax, %rax
je 0x5c08
cmpb $0x0, 0xb4(%rax)
jne 0x5c08
andl $0x0, 0x90(%rsp)
movq %rbx, %rdi
leaq 0x70(%rsp), %rsi
movq %r12, %rdx
callq 0xc15e
movq 0x20(%rsp), %r15
movq 0x28(%rsp), %rax
movq %rax, %rcx
subq %r15, %rcx
movq %rcx, %rdx
sarq $0x4, %rdx
decq %rdx
movq %rdx, %r13
shlq $0x4, %r13
movq (%r15,%r13), %rsi
movq 0x8(%r15,%r13), %rdi
cmpq 0x58(%rdi), %rsi
jae 0x5b07
movq 0x48(%rdi), %rdi
callq 0xc19e
addq $0x10, %rax
movq %r14, %rdi
movq %rax, %rsi
callq 0xc026
movq (%rax), %rax
movq %rax, 0x90(%rsp)
testq %rax, %rax
je 0x5b2a
cmpb $0x1, 0xb4(%rax)
jne 0x5ae0
cmpb $0x0, 0xb5(%rax)
je 0x5b35
movb $0x1, 0xb4(%rax)
andl $0x0, 0xe0(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
leaq 0xe0(%rsp), %rdx
callq 0xc15e
jmp 0x5a76
movb $0x1, 0xb5(%rdi)
addq $-0x10, %rax
movq %rax, 0x28(%rsp)
testq %rdx, %rdx
je 0x5c03
incq -0x20(%r15,%rcx)
jmp 0x5a76
addq %r13, %r15
incq (%r15)
jmp 0x5a76
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rcx
movq %rcx, %r8
subq %rsi, %r8
movq %r8, %rdx
sarq $0x6, %rdx
pushq $0x8
popq %r9
xorl %edi, %edi
testq %rdx, %rdx
jle 0x5b7f
cmpq %rax, (%rsi,%r9)
je 0x5ba3
cmpq %rax, 0x10(%rsi,%r9)
je 0x5bab
cmpq %rax, 0x20(%rsi,%r9)
je 0x5bb7
cmpq %rax, 0x30(%rsi,%r9)
je 0x5bc3
decq %rdx
addq $-0x40, %rdi
addq $0x40, %r9
jmp 0x5b52
addq %rdi, %r8
sarq $0x4, %r8
movq %rsi, %rdx
subq %rdi, %rdx
cmpq $0x1, %r8
je 0x5be9
cmpq $0x3, %r8
je 0x5bcf
cmpq $0x2, %r8
je 0x5bdf
movq %rcx, %rdx
jmp 0x5bf1
movq %rsi, %rdx
subq %rdi, %rdx
jmp 0x5bf1
movq %rsi, %rdx
subq %rdi, %rdx
addq $0x10, %rdx
jmp 0x5bf1
movq %rsi, %rdx
subq %rdi, %rdx
addq $0x20, %rdx
jmp 0x5bf1
movq %rsi, %rdx
subq %rdi, %rdx
addq $0x30, %rdx
jmp 0x5bf1
cmpq %rax, (%rsi,%r9)
je 0x5bf1
movq %rsi, %rdx
subq %rdi, %rdx
addq $0x10, %rdx
cmpq %rax, 0x8(%rdx)
je 0x5bf1
addq $0x10, %rdx
cmpq %rax, 0x8(%rdx)
cmovneq %rcx, %rdx
movq %rbx, %rdi
callq 0xc1bc
movq 0x20(%rsp), %r15
movq 0x28(%rsp), %rax
cmpq %rax, %r15
jne 0x5c1a
incq %rbp
jmp 0x5a21
movq 0x20(%rsp), %r15
movq 0x28(%rsp), %rax
cmpq %rax, %r15
je 0x5d14
movb $0x1, 0x1ebbf(%rip)     # 0x247e9
movq 0x1e3b7(%rip), %rdi     # 0x23fe8
leaq 0x11c04(%rip), %rsi     # 0x1783c
callq 0x4380
movq 0x20(%rsp), %r14
movq 0x28(%rsp), %r15
movq 0x1e39a(%rip), %rbx     # 0x23fe8
leaq 0x11914(%rip), %rbp     # 0x17569
cmpq %r15, %r14
je 0x5ce1
movq (%r14), %r12
movq 0x8(%r14), %r13
movq %rbx, %rdi
leaq 0x11be6(%rip), %rsi     # 0x17855
callq 0x4380
movq %rax, %rdi
movq %r13, %rsi
callq 0x4350
movq %rax, %rdi
leaq 0x11bd1(%rip), %rsi     # 0x1785a
callq 0x4380
movq 0x48(%r13), %rdi
movq %r12, %rsi
callq 0xc19e
movq %rax, %r12
movl 0x30(%rax), %eax
cmpl $0x4, %eax
jne 0x5cb9
movq %rbx, %rdi
leaq 0x11baf(%rip), %rsi     # 0x1785e
callq 0x4380
movl 0x30(%r12), %eax
cmpl $0x5, %eax
jne 0x5ccd
movq %rbx, %rdi
leaq 0x11ba6(%rip), %rsi     # 0x1786e
callq 0x4380
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x4380
addq $0x10, %r14
jmp 0x5c55
movq 0x1e300(%rip), %rdi     # 0x23fe8
leaq 0x11b66(%rip), %rsi     # 0x17855
callq 0x4380
movq 0x20(%rsp), %rcx
movq 0x8(%rcx), %rsi
movq %rax, %rdi
callq 0x4350
leaq 0x11ab4(%rip), %rsi     # 0x177c0
movq %rax, %rdi
callq 0x4380
movq 0x1e2cd(%rip), %rdi     # 0x23fe8
leaq 0x11b5b(%rip), %rsi     # 0x1787d
callq 0x4380
leaq 0x11b7f(%rip), %rax     # 0x178ad
leaq 0x11b64(%rip), %rsi     # 0x17899
cmpb $0x0, 0x1eaad(%rip)     # 0x247e9
cmovneq %rax, %rsi
movq 0x1e229(%rip), %rdi     # 0x23f70
callq 0x4380
movzbl 0x1ea96(%rip), %eax     # 0x247e9
movl %eax, 0x1c(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x11aba
leaq 0x1f8(%rsp), %rdi
callq 0xdc4a
leaq 0x130(%rsp), %rdi
callq 0xbf8a
leaq 0xf0(%rsp), %rdi
callq 0xc1c2
leaq 0x50(%rsp), %rdi
callq 0xbf8a
leaq 0xc0(%rsp), %rdi
callq 0x41a0
leaq 0x110(%rsp), %rdi
callq 0x41a0
leaq 0x150(%rsp), %rdi
callq 0xc1e4
movl 0x1c(%rsp), %eax
addq $0x808, %rsp            # imm = 0x808
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x1e212(%rip), %rdi     # 0x23fe8
leaq 0x117ce(%rip), %rsi     # 0x175ab
callq 0x4380
movq %rax, %rdi
callq 0x41c0
jmp 0x5d6e
leaq 0x1137f(%rip), %r15     # 0x17172
movq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x4380
jmp 0x5256
leaq 0x11401(%rip), %rsi     # 0x1720d
movq %r12, %rdi
callq 0x4530
testl %eax, %eax
je 0x5e49
movq 0x1e1c9(%rip), %rdi     # 0x23fe8
leaq 0x11707(%rip), %rsi     # 0x1752d
callq 0x4380
movq (%rsp), %rcx
movq (%rcx,%r13,8), %rsi
movq %rax, %rdi
callq 0x4380
movq %rax, 0x10(%rsp)
leaq 0x11709(%rip), %r15     # 0x17550
jmp 0x5df3
movl $0x0, 0x1c(%rsp)
movq 0x1e118(%rip), %rdi     # 0x23f70
leaq 0x113b5(%rip), %rsi     # 0x17214
callq 0x4380
jmp 0x5d88
pushq $0x1
popq %rdi
callq 0x41d0
leaq 0x1dca8(%rip), %rsi     # 0x23b20
movq %rax, %rdi
xorl %edx, %edx
callq 0x4610
pushq $0x1
popq %rdi
callq 0x41d0
leaq 0x1dc8f(%rip), %rsi     # 0x23b20
movq %rax, %rdi
xorl %edx, %edx
callq 0x4610
jmp 0x630c
movq %rax, %r13
callq 0x4600
jmp 0x630f
jmp 0x5ec6
jmp 0x621f
jmp 0x5f40
jmp 0x5ebb
movq %rdx, %rbx
movq %rax, %r13
jmp 0x622f
movq %rdx, %rbx
movq %rax, %r13
leaq 0x20(%rsp), %rdi
callq 0x41a0
jmp 0x6225
jmp 0x61fb
movq %rdx, %rbx
movq %rax, %r13
jmp 0x623c
jmp 0x621f
movq %rax, %r13
leaq 0x1f8(%rsp), %rdi
callq 0x41a0
jmp 0x631c
jmp 0x5f1d
jmp 0x5f95
jmp 0x5f31
jmp 0x61fb
jmp 0x621f
jmp 0x630c
movq %rax, %r13
jmp 0x631c
jmp 0x62f7
jmp 0x5f40
jmp 0x61fb
movq %rdx, %rbx
movq %rax, %r13
jmp 0x5fbf
jmp 0x5f6b
jmp 0x5f95
movq %rdx, %rbx
movq %rax, %r13
leaq 0x20(%rsp), %rdi
callq 0x41a0
jmp 0x6201
jmp 0x61fb
jmp 0x621f
jmp 0x5f6b
jmp 0x62f7
jmp 0x621f
movq %rdx, %rbx
movq %rax, %r13
leaq 0x1f8(%rsp), %rdi
callq 0x41a0
jmp 0x5fbf
movq %rax, %r13
leaq 0x400(%rsp), %rdi
callq 0x41a0
jmp 0x6336
movq %rax, %r13
jmp 0x6336
jmp 0x62f7
jmp 0x621f
jmp 0x621f
movq %rdx, %rbx
movq %rax, %r13
leaq 0x1f8(%rsp), %rdi
callq 0xbfec
cmpl $0x7, %ebx
jne 0x5ff1
movq %r13, %rdi
callq 0x4160
movq 0x1e015(%rip), %rdi     # 0x23fe8
leaq 0x11708(%rip), %rsi     # 0x176e2
callq 0x4380
movq %rax, %rdi
callq 0x41c0
callq 0x4600
jmp 0x5d6e
cmpl $0x6, %ebx
jne 0x6023
movq %r13, %rdi
callq 0x4160
movq 0x1dfe3(%rip), %rdi     # 0x23fe8
leaq 0x116a9(%rip), %rsi     # 0x176b5
callq 0x4380
movq %rax, %rdi
callq 0x41c0
callq 0x4600
jmp 0x5d6e
cmpl $0x5, %ebx
jne 0x6055
movq %r13, %rdi
callq 0x4160
movq 0x1dfb1(%rip), %rdi     # 0x23fe8
leaq 0x1163d(%rip), %rsi     # 0x1767b
callq 0x4380
movq %rax, %rdi
callq 0x41c0
callq 0x4600
jmp 0x5d6e
cmpl $0x4, %ebx
jne 0x609f
movq %r13, %rdi
callq 0x4160
movq %rax, %rbx
movq 0x1df7c(%rip), %rdi     # 0x23fe8
leaq 0x115df(%rip), %rsi     # 0x17652
callq 0x4380
movq %rax, %r14
movl (%rbx), %edi
callq 0x4130
movq %r14, %rdi
movq %rax, %rsi
callq 0x4380
movq %rax, %rdi
callq 0x41c0
callq 0x4600
jmp 0x5d6e
cmpl $0x3, %ebx
jne 0x60d1
movq %r13, %rdi
callq 0x4160
movq 0x1df35(%rip), %rdi     # 0x23fe8
leaq 0x1157d(%rip), %rsi     # 0x17637
callq 0x4380
movq %rax, %rdi
callq 0x41c0
callq 0x4600
jmp 0x5d6e
cmpl $0x2, %ebx
jne 0x631c
movq %r13, %rdi
callq 0x4160
movq %rax, %rbx
movq 0x1defc(%rip), %rdi     # 0x23fe8
leaq 0x11539(%rip), %rsi     # 0x1762c
callq 0x4380
cmpq $0x0, 0x8(%rbx)
je 0x6147
movq 0x1dee2(%rip), %rdi     # 0x23fe8
leaq 0x11643(%rip), %rsi     # 0x17750
callq 0x4380
movq 0x8(%rbx), %rsi
movq %rax, %rdi
callq 0x4380
cmpq $0x0, 0x18(%rbx)
je 0x6147
movq 0x1debc(%rip), %rdi     # 0x23fe8
leaq 0x11725(%rip), %rsi     # 0x17858
callq 0x4380
movq %rbx, %rsi
addq $0x10, %rsi
movq %rax, %rdi
callq 0x4350
cmpl $0x0, (%rbx)
je 0x6174
movq 0x1de95(%rip), %rdi     # 0x23fe8
leaq 0x115f6(%rip), %rsi     # 0x17750
callq 0x4380
movq %rax, %r14
movl (%rbx), %edi
callq 0x4130
movq %r14, %rdi
movq %rax, %rsi
callq 0x4380
movq 0x1de6d(%rip), %rdi     # 0x23fe8
pushq $0xa
popq %rsi
callq 0x4430
callq 0x4600
jmp 0x5d6e
jmp 0x61b0
jmp 0x5f1d
jmp 0x5f1d
movq %rax, %r13
callq 0x4600
jmp 0x631c
jmp 0x5f1d
jmp 0x5f1d
movq %rax, %r13
callq 0x4600
jmp 0x631c
movq %rax, %r13
callq 0x4600
jmp 0x631c
movq %rax, %r13
callq 0x4600
jmp 0x631c
jmp 0x5f1d
movq %rax, %r13
callq 0x4600
jmp 0x631c
jmp 0x5f1d
movq %rax, %r13
callq 0x4600
jmp 0x631c
movq %rdx, %rbx
movq %rax, %r13
leaq 0x90(%rsp), %rdi
callq 0x110de
jmp 0x6225
jmp 0x62f7
jmp 0x62f7
jmp 0x62f7
movq %rdx, %rbx
movq %rax, %r13
leaq 0x70(%rsp), %rdi
callq 0x41a0
leaq 0x1f8(%rsp), %rdi
callq 0x40e0
cmpl $0x1, %ebx
jne 0x631c
movq %r13, %rdi
callq 0x4160
movq %rax, %rbx
movq 0x1dd91(%rip), %rdi     # 0x23fe8
leaq 0x11324(%rip), %rsi     # 0x17582
callq 0x4380
leaq 0xc0(%rsp), %rsi
movq %rax, %rdi
callq 0x4350
leaq 0x114d6(%rip), %rsi     # 0x17750
movq %rax, %rdi
callq 0x4380
movq %rax, %r14
movq 0x18(%rbx), %rsi
movl 0x10(%rbx), %edx
movq (%rsi), %rax
leaq 0x70(%rsp), %rdi
callq *0x20(%rax)
leaq 0x70(%rsp), %rsi
movq %r14, %rdi
callq 0x4350
leaq 0x112be(%rip), %rsi     # 0x17569
movq %rax, %rdi
callq 0x4380
leaq 0x70(%rsp), %rdi
callq 0x41a0
callq 0x4600
jmp 0x5d6e
jmp 0x5f1d
jmp 0x62dd
movq %rax, %r13
leaq 0x70(%rsp), %rdi
callq 0x41a0
jmp 0x62e0
movq %rax, %r13
callq 0x4600
jmp 0x631c
movq %rax, %rdi
callq 0xba09
jmp 0x630c
jmp 0x630c
jmp 0x62f7
jmp 0x62f7
movq %rax, %r13
leaq 0x20(%rsp), %rdi
callq 0x11aba
jmp 0x630f
jmp 0x630c
jmp 0x630c
jmp 0x630c
movq %rax, %r13
leaq 0x1f8(%rsp), %rdi
callq 0xdc4a
leaq 0x130(%rsp), %rdi
callq 0xbf8a
leaq 0xf0(%rsp), %rdi
callq 0xc1c2
leaq 0x50(%rsp), %rdi
callq 0xbf8a
leaq 0xc0(%rsp), %rdi
callq 0x41a0
leaq 0x110(%rsp), %rdi
callq 0x41a0
leaq 0x150(%rsp), %rdi
callq 0xc1e4
movq %r13, %rdi
callq 0x4620