// File: 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
movq %rsp, %rbp
subq $0xb50, %rsp            # imm = 0xB50
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x13660
callq 0x5230
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x41(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x5700
movq $0x0, -0x70(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x5700
leaq -0xa8(%rbp), %rdi
callq 0x13690
cmpl $0x1, -0x8(%rbp)
jle 0x6072
movl $0x1, -0xac(%rbp)
movl -0xac(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x6070
movq -0x10(%rbp), %rax
movslq -0xac(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x5fa3
movq -0x10(%rbp), %rax
movslq -0xac(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x3355c(%rip), %rsi     # 0x3910b
callq 0x5710
cmpl $0x0, %eax
je 0x5bdd
movq -0x10(%rbp), %rax
movslq -0xac(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x3354b(%rip), %rsi     # 0x3911a
callq 0x5710
cmpl $0x0, %eax
jne 0x5c87
movl -0xac(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xac(%rbp)
cmpl -0x8(%rbp), %eax
jge 0x5c3b
movq -0x10(%rbp), %rax
movslq -0xac(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x5c3b
movq -0x10(%rbp), %rax
movslq -0xac(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq -0x40(%rbp), %rdi
callq 0x136b0
jmp 0x5c22
jmp 0x5c82
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x7e83
movq 0x4b3a6(%rip), %rdi     # 0x50fe8
leaq 0x334d4(%rip), %rsi     # 0x3911d
callq 0x5490
movq %rax, -0x908(%rbp)
jmp 0x5c57
movq -0x908(%rbp), %rdi
movq 0x4b2cb(%rip), %rsi     # 0x50f30
callq 0x54e0
jmp 0x5c6c
movl $0x1, -0x4(%rbp)
movl $0x1, -0xc0(%rbp)
jmp 0x7e4d
jmp 0x5f9e
movq -0x10(%rbp), %rax
movslq -0xac(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x334b7(%rip), %rsi     # 0x39154
callq 0x5710
cmpl $0x0, %eax
je 0x5cc7
movq -0x10(%rbp), %rax
movslq -0xac(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x334a0(%rip), %rsi     # 0x3915d
callq 0x5710
cmpl $0x0, %eax
jne 0x5cd0
movb $0x0, -0x41(%rbp)
jmp 0x5f9c
movq -0x10(%rbp), %rax
movslq -0xac(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x3347a(%rip), %rsi     # 0x39160
callq 0x5710
cmpl $0x0, %eax
je 0x5d10
movq -0x10(%rbp), %rax
movslq -0xac(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x33461(%rip), %rsi     # 0x39167
callq 0x5710
cmpl $0x0, %eax
jne 0x5d19
movb $0x1, -0x41(%rbp)
jmp 0x5f9a
movq -0x10(%rbp), %rax
movslq -0xac(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x3343b(%rip), %rsi     # 0x3916a
callq 0x5710
cmpl $0x0, %eax
je 0x5d59
movq -0x10(%rbp), %rax
movslq -0xac(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x33429(%rip), %rsi     # 0x39178
callq 0x5710
cmpl $0x0, %eax
jne 0x5dd4
movl -0xac(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xac(%rbp)
movl -0xac(%rbp), %eax
cmpl -0x8(%rbp), %eax
je 0x5d8a
movq -0x10(%rbp), %rax
movslq -0xac(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x5db5
movq 0x4b257(%rip), %rdi     # 0x50fe8
leaq 0x333e3(%rip), %rsi     # 0x3917b
callq 0x5490
jmp 0x5d9f
movl $0x1, -0x4(%rbp)
movl $0x1, -0xc0(%rbp)
jmp 0x7e4d
movq -0x10(%rbp), %rax
movslq -0xac(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq -0x68(%rbp), %rdi
callq 0x56d0
jmp 0x5dcf
jmp 0x5f98
movq -0x10(%rbp), %rax
movslq -0xac(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x333d1(%rip), %rsi     # 0x391bb
callq 0x5710
cmpl $0x0, %eax
je 0x5e14
movq -0x10(%rbp), %rax
movslq -0xac(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x333ba(%rip), %rsi     # 0x391c4
callq 0x5710
cmpl $0x0, %eax
jne 0x5e20
movb $0x0, 0x4b6a5(%rip)     # 0x514c0
jmp 0x5f96
movq -0x10(%rbp), %rax
movslq -0xac(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x33391(%rip), %rsi     # 0x391c7
callq 0x5710
cmpl $0x0, %eax
je 0x5e60
movq -0x10(%rbp), %rax
movslq -0xac(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x3337c(%rip), %rsi     # 0x391d2
callq 0x5710
cmpl $0x0, %eax
jne 0x5ede
movl -0xac(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xac(%rbp)
movl -0xac(%rbp), %eax
cmpl -0x8(%rbp), %eax
je 0x5e91
movq -0x10(%rbp), %rax
movslq -0xac(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x5ebc
movq 0x4b150(%rip), %rdi     # 0x50fe8
leaq 0x33336(%rip), %rsi     # 0x391d5
callq 0x5490
jmp 0x5ea6
movl $0x1, -0x4(%rbp)
movl $0x1, -0xc0(%rbp)
jmp 0x7e4d
movq -0x10(%rbp), %rax
movslq -0xac(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq -0x90(%rbp), %rdi
callq 0x56d0
jmp 0x5ed9
jmp 0x5f94
movq -0x10(%rbp), %rax
movslq -0xac(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x33328(%rip), %rsi     # 0x3921c
callq 0x5710
cmpl $0x0, %eax
jne 0x5f29
movq 0x4b06b(%rip), %rdi     # 0x50f70
leaq 0x33317(%rip), %rsi     # 0x39223
callq 0x5490
jmp 0x5f13
movl $0x0, -0x4(%rbp)
movl $0x1, -0xc0(%rbp)
jmp 0x7e4d
movq 0x4b0b8(%rip), %rdi     # 0x50fe8
leaq 0x33605(%rip), %rsi     # 0x3953c
callq 0x5490
movq %rax, -0x910(%rbp)
jmp 0x5f45
movq -0x910(%rbp), %rdi
movq -0x10(%rbp), %rax
movslq -0xac(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x5490
movq %rax, -0x918(%rbp)
jmp 0x5f69
movq -0x918(%rbp), %rdi
leaq 0x335e8(%rip), %rsi     # 0x3955f
callq 0x5490
jmp 0x5f7e
movl $0x1, -0x4(%rbp)
movl $0x1, -0xc0(%rbp)
jmp 0x7e4d
jmp 0x5f96
jmp 0x5f98
jmp 0x5f9a
jmp 0x5f9c
jmp 0x5f9e
jmp 0x605a
movq -0x10(%rbp), %rax
movslq -0xac(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x928(%rbp)
leaq -0xe1(%rbp), %rdi
movq %rdi, -0x920(%rbp)
callq 0x5880
movq -0x928(%rbp), %rsi
movq -0x920(%rbp), %rdx
leaq -0xe0(%rbp), %rdi
callq 0x13710
jmp 0x5fe8
leaq -0xa8(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
callq 0x136e0
jmp 0x5ffd
leaq -0xe0(%rbp), %rdi
callq 0x5320
leaq -0xe1(%rbp), %rdi
callq 0x5520
jmp 0x605a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x6049
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0xe0(%rbp), %rdi
callq 0x5320
leaq -0xe1(%rbp), %rdi
callq 0x5520
jmp 0x7e83
jmp 0x605c
movl -0xac(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xac(%rbp)
jmp 0x5b6f
jmp 0x6072
movl $0xffffffff, -0xe8(%rbp) # imm = 0xFFFFFFFF
leaq -0x4f0(%rbp), %rdi
callq 0x137c0
movl $0xd, %edi
movl $0x1, %esi
callq 0x55c0
leaq -0x508(%rbp), %rdi
callq 0x137f0
leaq -0x520(%rbp), %rdi
callq 0x13690
testb $0x1, 0x4b40a(%rip)     # 0x514c0
je 0x62e2
movb -0x41(%rbp), %al
notb %al
movzbl %al, %esi
andl $0x1, %esi
leaq -0x40(%rbp), %rdi
callq 0x34330
jmp 0x60d2
leaq -0x40(%rbp), %rdi
callq 0x13810
movq %rax, -0x930(%rbp)
jmp 0x60e4
movq -0x930(%rbp), %rsi
leaq -0x508(%rbp), %rdi
callq 0x13830
leaq -0x90(%rbp), %rdi
callq 0x5830
testb $0x1, %al
jne 0x6109
jmp 0x613f
testb $0x1, -0x41(%rbp)
jne 0x613d
leaq 0x33464(%rip), %rsi     # 0x3957a
leaq -0x90(%rbp), %rdi
callq 0x56d0
jmp 0x6124
jmp 0x613d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x7e33
jmp 0x613f
leaq -0x90(%rbp), %rdi
callq 0x5830
testb $0x1, %al
jne 0x62dd
leaq -0x90(%rbp), %rdi
movq %rdi, -0x528(%rbp)
movq %rdi, -0x530(%rbp)
callq 0x51b0
movq %rax, %rdi
leaq 0x4b6f1(%rip), %rdx     # 0x51868
movl $0x1, %esi
xorl %ecx, %ecx
leaq -0x528(%rbp), %r8
leaq -0x530(%rbp), %r9
callq 0x7ed0
jmp 0x6193
jmp 0x62db
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
movl -0xbc(%rbp), %eax
movl $0x7, %ecx
cmpl %ecx, %eax
jne 0x7e33
movq -0xb8(%rbp), %rdi
callq 0x51a0
movq %rax, -0x538(%rbp)
movq 0x4ae11(%rip), %rdi     # 0x50fe8
leaq 0x333b3(%rip), %rsi     # 0x39591
callq 0x5490
movq %rax, -0x938(%rbp)
jmp 0x61ec
movq -0x938(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x5450
movq %rax, -0x940(%rbp)
jmp 0x6208
movq -0x940(%rbp), %rdi
leaq 0x33549(%rip), %rsi     # 0x3975f
callq 0x5490
movq %rax, -0x948(%rbp)
jmp 0x6224
movq -0x538(%rbp), %rdi
callq 0x13860
movq %rax, %rsi
leaq -0x558(%rbp), %rdi
callq 0x13880
jmp 0x6241
movq -0x948(%rbp), %rdi
leaq -0x558(%rbp), %rsi
callq 0x5450
movq %rax, -0x950(%rbp)
jmp 0x625d
movq -0x950(%rbp), %rdi
leaq 0x3330d(%rip), %rsi     # 0x39578
callq 0x5490
jmp 0x6272
leaq -0x558(%rbp), %rdi
callq 0x5320
movl $0x1, -0x4(%rbp)
movl $0x1, -0xc0(%rbp)
callq 0x5810
jmp 0x62ca
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x62cf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0x558(%rbp), %rdi
callq 0x5320
jmp 0x62cf
jmp 0x7e19
callq 0x5810
jmp 0x62d6
jmp 0x7e33
jmp 0x62dd
jmp 0x69c5
leaq -0x68(%rbp), %rdi
callq 0x5830
testb $0x1, %al
jne 0x62fe
leaq -0x68(%rbp), %rdi
callq 0x51b0
movq %rax, -0x70(%rbp)
jmp 0x6372
movzbl -0x41(%rbp), %esi
andl $0x1, %esi
leaq -0x68(%rbp), %rdi
callq 0x138e0
movq %rax, -0x958(%rbp)
jmp 0x6317
movq -0x958(%rbp), %rax
movq %rax, -0x70(%rbp)
cmpq $0x0, -0x70(%rbp)
jne 0x6370
movq 0x4acb8(%rip), %rdi     # 0x50fe8
leaq 0x33283(%rip), %rsi     # 0x395ba
callq 0x5490
movq %rax, -0x960(%rbp)
jmp 0x6345
movq -0x960(%rbp), %rdi
movq 0x4abdd(%rip), %rsi     # 0x50f30
callq 0x54e0
jmp 0x635a
movl $0x1, -0x4(%rbp)
movl $0x1, -0xc0(%rbp)
jmp 0x7e19
jmp 0x6372
movq -0x70(%rbp), %rdi
callq 0x13a10
movl %eax, -0x964(%rbp)
jmp 0x6383
movl -0x964(%rbp), %eax
movl %eax, -0xe8(%rbp)
movl -0xe8(%rbp), %ecx
movl $0x1, %edi
movl $0x5, %esi
leaq -0x4f0(%rbp), %rdx
callq 0x13c90
jmp 0x63ad
movl -0xe8(%rbp), %esi
leaq -0x570(%rbp), %rdi
leaq -0x4f0(%rbp), %rdx
callq 0x13df0
jmp 0x63c8
leaq -0x520(%rbp), %rdi
leaq -0x570(%rbp), %rsi
callq 0x140c0
leaq -0x570(%rbp), %rdi
callq 0x140f0
leaq -0x520(%rbp), %rax
movq %rax, -0x578(%rbp)
movq -0x578(%rbp), %rdi
callq 0x14150
movq %rax, -0x580(%rbp)
movq -0x578(%rbp), %rdi
callq 0x14180
movq %rax, -0x588(%rbp)
leaq -0x580(%rbp), %rdi
leaq -0x588(%rbp), %rsi
callq 0x141b0
testb $0x1, %al
jne 0x6437
jmp 0x682d
leaq -0x580(%rbp), %rdi
callq 0x141f0
movq %rax, -0x590(%rbp)
movq -0x590(%rbp), %rdi
callq 0x51b0
movq %rax, %rsi
leaq -0x5a0(%rbp), %rdi
xorl %edx, %edx
callq 0x14290
jmp 0x6469
leaq -0x508(%rbp), %rdi
leaq -0x5a0(%rbp), %rsi
callq 0x14210
jmp 0x647e
leaq -0x5a0(%rbp), %rdi
callq 0x142c0
leaq -0x580(%rbp), %rdi
callq 0x14300
jmp 0x641b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x64ca
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0x5a0(%rbp), %rdi
callq 0x142c0
movl -0xbc(%rbp), %eax
movl %eax, -0x968(%rbp)
movl $0x6, %ecx
cmpl %ecx, %eax
jne 0x653e
movq -0xb8(%rbp), %rdi
callq 0x51a0
movq %rax, -0x5d8(%rbp)
movq 0x4aaef(%rip), %rdi     # 0x50fe8
leaq 0x331f1(%rip), %rsi     # 0x396f1
callq 0x5490
movq %rax, -0x970(%rbp)
jmp 0x650e
movq -0x970(%rbp), %rdi
movq 0x4aa14(%rip), %rsi     # 0x50f30
callq 0x54e0
jmp 0x6523
movl $0x1, -0x4(%rbp)
movl $0x1, -0xc0(%rbp)
callq 0x5810
jmp 0x69b9
movl -0x968(%rbp), %eax
movl $0x5, %ecx
cmpl %ecx, %eax
jne 0x65ac
movq -0xb8(%rbp), %rdi
callq 0x51a0
movq %rax, -0x5d0(%rbp)
movq 0x4aa81(%rip), %rdi     # 0x50fe8
leaq 0x33156(%rip), %rsi     # 0x396c4
callq 0x5490
movq %rax, -0x978(%rbp)
jmp 0x657c
movq -0x978(%rbp), %rdi
movq 0x4a9a6(%rip), %rsi     # 0x50f30
callq 0x54e0
jmp 0x6591
movl $0x1, -0x4(%rbp)
movl $0x1, -0xc0(%rbp)
callq 0x5810
jmp 0x6996
movl -0x968(%rbp), %eax
movl $0x4, %ecx
cmpl %ecx, %eax
jne 0x661a
movq -0xb8(%rbp), %rdi
callq 0x51a0
movq %rax, -0x5c8(%rbp)
movq 0x4aa13(%rip), %rdi     # 0x50fe8
leaq 0x330ae(%rip), %rsi     # 0x3968a
callq 0x5490
movq %rax, -0x980(%rbp)
jmp 0x65ea
movq -0x980(%rbp), %rdi
movq 0x4a938(%rip), %rsi     # 0x50f30
callq 0x54e0
jmp 0x65ff
movl $0x1, -0x4(%rbp)
movl $0x1, -0xc0(%rbp)
callq 0x5810
jmp 0x6973
movl -0x968(%rbp), %eax
movl $0x3, %ecx
cmpl %ecx, %eax
jne 0x66b2
movq -0xb8(%rbp), %rdi
callq 0x51a0
movq %rax, -0x5c0(%rbp)
movq 0x4a9a1(%rip), %rdi     # 0x50fe8
leaq 0x33013(%rip), %rsi     # 0x39661
callq 0x5490
movq %rax, -0x988(%rbp)
jmp 0x665c
movq -0x5c0(%rbp), %rax
movl (%rax), %edi
callq 0x5160
movq -0x988(%rbp), %rdi
movq %rax, %rsi
callq 0x5490
movq %rax, -0x990(%rbp)
jmp 0x6682
movq -0x990(%rbp), %rdi
movq 0x4a8a0(%rip), %rsi     # 0x50f30
callq 0x54e0
jmp 0x6697
movl $0x1, -0x4(%rbp)
movl $0x1, -0xc0(%rbp)
callq 0x5810
jmp 0x6950
movl -0x968(%rbp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0x6720
movq -0xb8(%rbp), %rdi
callq 0x51a0
movq %rax, -0x5b8(%rbp)
movq 0x4a90d(%rip), %rdi     # 0x50fe8
leaq 0x32f64(%rip), %rsi     # 0x39646
callq 0x5490
movq %rax, -0x998(%rbp)
jmp 0x66f0
movq -0x998(%rbp), %rdi
movq 0x4a832(%rip), %rsi     # 0x50f30
callq 0x54e0
jmp 0x6705
movl $0x1, -0x4(%rbp)
movl $0x1, -0xc0(%rbp)
callq 0x5810
jmp 0x692d
movl -0x968(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x7e33
movq -0xb8(%rbp), %rdi
callq 0x51a0
movq %rax, -0x5a8(%rbp)
movq 0x4a89b(%rip), %rdi     # 0x50fe8
leaq 0x32ee7(%rip), %rsi     # 0x3963b
callq 0x5490
jmp 0x675b
movq -0x5a8(%rbp), %rdi
callq 0x14360
movq %rax, -0x9a0(%rbp)
jmp 0x6770
movq -0x9a0(%rbp), %rax
cmpq $0x0, %rax
je 0x6872
movq 0x4a860(%rip), %rdi     # 0x50fe8
leaq 0x32fd0(%rip), %rsi     # 0x3975f
callq 0x5490
movq %rax, -0x9a8(%rbp)
jmp 0x679d
movq -0x5a8(%rbp), %rdi
callq 0x14360
movq %rax, -0x9b0(%rbp)
jmp 0x67b2
movq -0x9b0(%rbp), %rsi
movq -0x9a8(%rbp), %rdi
callq 0x5490
jmp 0x67c7
movq -0x5a8(%rbp), %rdi
callq 0x14380
movq %rax, -0x9b8(%rbp)
jmp 0x67dc
movq -0x9b8(%rbp), %rax
movq %rax, -0x5b0(%rbp)
movq -0x5b0(%rbp), %rdi
callq 0x5830
testb $0x1, %al
jne 0x6870
movq 0x4a7e7(%rip), %rdi     # 0x50fe8
leaq 0x3305f(%rip), %rsi     # 0x39867
callq 0x5490
movq %rax, -0x9c0(%rbp)
jmp 0x6816
movq -0x9c0(%rbp), %rdi
movq -0x5b0(%rbp), %rsi
callq 0x5450
jmp 0x682b
jmp 0x6870
leaq 0x4b034(%rip), %rdi     # 0x51868
callq 0x14320
jmp 0x683b
movl -0xe8(%rbp), %edi
leaq -0x4f0(%rbp), %rsi
callq 0x8bf0
jmp 0x684f
jmp 0x69c3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
callq 0x5810
jmp 0x690f
jmp 0x6872
movq -0x5a8(%rbp), %rdi
callq 0x143a0
movl %eax, -0x9c4(%rbp)
jmp 0x6886
movl -0x9c4(%rbp), %eax
cmpl $0x0, %eax
je 0x68df
movq 0x4a750(%rip), %rdi     # 0x50fe8
leaq 0x32ec0(%rip), %rsi     # 0x3975f
callq 0x5490
movq %rax, -0x9d0(%rbp)
jmp 0x68ad
movq -0x5a8(%rbp), %rdi
callq 0x143a0
movl %eax, -0x9d4(%rbp)
jmp 0x68c1
movl -0x9d4(%rbp), %edi
callq 0x5160
movq -0x9d0(%rbp), %rdi
movq %rax, %rsi
callq 0x5490
jmp 0x68dd
jmp 0x68df
movq 0x4a702(%rip), %rdi     # 0x50fe8
movl $0xa, %esi
callq 0x55a0
jmp 0x68f2
movl $0x1, -0x4(%rbp)
movl $0x1, -0xc0(%rbp)
callq 0x5810
jmp 0x690a
jmp 0x7e19
jmp 0x7e33
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
callq 0x5810
jmp 0x6932
jmp 0x7e19
jmp 0x7e33
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
callq 0x5810
jmp 0x6955
jmp 0x7e19
jmp 0x7e33
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
callq 0x5810
jmp 0x6978
jmp 0x7e19
jmp 0x7e33
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
callq 0x5810
jmp 0x699b
jmp 0x7e19
jmp 0x7e33
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
callq 0x5810
jmp 0x69be
jmp 0x7e19
jmp 0x7e33
jmp 0x69c5
leaq -0xa8(%rbp), %rdi
callq 0x143b0
testb $0x1, %al
jne 0x69da
jmp 0x6a7b
leaq -0x5f9(%rbp), %rdi
movq %rdi, -0x9e0(%rbp)
callq 0x5880
movq -0x9e0(%rbp), %rdx
leaq 0x32d32(%rip), %rsi     # 0x3972d
leaq -0x5f8(%rbp), %rdi
callq 0x13710
jmp 0x6a09
leaq -0xa8(%rbp), %rdi
leaq -0x5f8(%rbp), %rsi
callq 0x136e0
jmp 0x6a1e
leaq -0x5f8(%rbp), %rdi
callq 0x5320
leaq -0x5f9(%rbp), %rdi
callq 0x5520
jmp 0x6a7b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x6a6a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0x5f8(%rbp), %rdi
callq 0x5320
leaq -0x5f9(%rbp), %rdi
callq 0x5520
jmp 0x7e33
leaq -0xa8(%rbp), %rdi
callq 0x143f0
movq %rax, -0x608(%rbp)
leaq -0x638(%rbp), %rdi
callq 0x14410
movq $0x0, -0x640(%rbp)
movq -0x640(%rbp), %rax
movq %rax, -0x9e8(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x143f0
movq %rax, %rcx
movq -0x9e8(%rbp), %rax
cmpq %rcx, %rax
jae 0x71e9
movq -0x640(%rbp), %rsi
leaq -0xa8(%rbp), %rdi
callq 0x14430
movq %rax, -0x648(%rbp)
movq 0x4a47d(%rip), %rdi     # 0x50f70
leaq 0x32c38(%rip), %rsi     # 0x39732
callq 0x5490
movq %rax, -0x9f0(%rbp)
jmp 0x6b08
movq -0x9f0(%rbp), %rdi
movq -0x648(%rbp), %rsi
callq 0x5450
movq %rax, -0x9f8(%rbp)
jmp 0x6b24
movq -0x9f8(%rbp), %rdi
leaq 0x32c4b(%rip), %rsi     # 0x3977d
callq 0x5490
jmp 0x6b39
movq -0x648(%rbp), %rsi
leaq -0x638(%rbp), %rdi
leaq -0x508(%rbp), %rdx
callq 0x8ed0
movq %rax, -0xa00(%rbp)
jmp 0x6b5c
movq -0xa00(%rbp), %rax
movq %rax, -0x650(%rbp)
movq -0x650(%rbp), %rax
movq %rax, -0xa10(%rbp)
movq -0x648(%rbp), %rsi
leaq -0x638(%rbp), %rdi
callq 0x14450
movq %rax, -0xa08(%rbp)
jmp 0x6b94
movq -0xa08(%rbp), %rax
movq -0xa10(%rbp), %rcx
movq %rcx, (%rax)
movq -0x650(%rbp), %rax
addq $0x48, %rax
movq %rax, -0x658(%rbp)
movq -0x658(%rbp), %rdi
callq 0x14530
movq %rax, -0x660(%rbp)
movq -0x658(%rbp), %rdi
callq 0x14560
movq %rax, -0x668(%rbp)
leaq -0x660(%rbp), %rdi
leaq -0x668(%rbp), %rsi
callq 0x14590
testb $0x1, %al
jne 0x6bf9
jmp 0x6d3e
leaq -0x660(%rbp), %rdi
callq 0x145c0
movq %rax, -0x670(%rbp)
movq -0x670(%rbp), %rsi
movb $0x0, -0x689(%rbp)
leaq -0x638(%rbp), %rdi
callq 0x145e0
movq %rax, -0xa18(%rbp)
jmp 0x6c2f
movq -0xa18(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0xa19(%rbp)
jne 0x6c89
leaq -0x688(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x146b0
jmp 0x6c59
movb $0x1, -0x689(%rbp)
movq -0x670(%rbp), %rsi
leaq -0x688(%rbp), %rdi
callq 0x14640
movb %al, -0xa1a(%rbp)
jmp 0x6c7b
movb -0xa1a(%rbp), %al
xorb $-0x1, %al
movb %al, -0xa19(%rbp)
movb -0xa19(%rbp), %al
movb %al, -0xa1b(%rbp)
testb $0x1, -0x689(%rbp)
jne 0x6ca0
jmp 0x6cac
leaq -0x688(%rbp), %rdi
callq 0x140f0
movb -0xa1b(%rbp), %al
testb $0x1, %al
jne 0x6cb8
jmp 0x6d2b
movq -0x670(%rbp), %rsi
leaq -0xa8(%rbp), %rdi
callq 0x147a0
jmp 0x6ccd
jmp 0x6d2b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x7e0b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
jmp 0x70a9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
testb $0x1, -0x689(%rbp)
jne 0x6d1a
jmp 0x6d26
leaq -0x688(%rbp), %rdi
callq 0x140f0
jmp 0x70a9
jmp 0x6d2d
leaq -0x660(%rbp), %rdi
callq 0x14810
jmp 0x6bdd
movq -0x650(%rbp), %rdi
addq $0x28, %rdi
callq 0x5830
movb %al, %cl
movb $0x0, -0x6a9(%rbp)
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0xa1c(%rbp)
jne 0x6dad
leaq -0x6a8(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x146b0
jmp 0x6d79
movb $0x1, -0x6a9(%rbp)
movq -0x650(%rbp), %rsi
addq $0x28, %rsi
leaq -0x6a8(%rbp), %rdi
callq 0x14640
movb %al, -0xa1d(%rbp)
jmp 0x6d9f
movb -0xa1d(%rbp), %al
xorb $-0x1, %al
movb %al, -0xa1c(%rbp)
movb -0xa1c(%rbp), %al
movb %al, -0xa1e(%rbp)
testb $0x1, -0x6a9(%rbp)
jne 0x6dc4
jmp 0x6dd0
leaq -0x6a8(%rbp), %rdi
callq 0x140f0
movb -0xa1e(%rbp), %al
testb $0x1, %al
jne 0x6ddf
jmp 0x6ea7
leaq -0x6c8(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x146b0
jmp 0x6df4
movq -0x650(%rbp), %rsi
addq $0x28, %rsi
leaq -0x6c8(%rbp), %rdi
callq 0x14640
movb %al, -0xa1f(%rbp)
jmp 0x6e13
movb -0xa1f(%rbp), %al
xorb $-0x1, %al
movb %al, -0xa20(%rbp)
leaq -0x6c8(%rbp), %rdi
callq 0x140f0
movb -0xa20(%rbp), %al
testb $0x1, %al
jne 0x6e39
jmp 0x6ea5
movq -0x650(%rbp), %rsi
addq $0x28, %rsi
leaq -0xa8(%rbp), %rdi
callq 0x147a0
jmp 0x6e52
jmp 0x6ea5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
testb $0x1, -0x6a9(%rbp)
jne 0x6e71
jmp 0x6e7d
leaq -0x6a8(%rbp), %rdi
callq 0x140f0
jmp 0x70a9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0x6c8(%rbp), %rdi
callq 0x140f0
jmp 0x70a9
jmp 0x6ea7
movq -0x650(%rbp), %rax
addq $0x60, %rax
movq %rax, -0x6d0(%rbp)
movq -0x6d0(%rbp), %rdi
callq 0x14830
movq %rax, -0x6d8(%rbp)
movq -0x6d0(%rbp), %rdi
callq 0x14860
movq %rax, -0x6e0(%rbp)
leaq -0x6d8(%rbp), %rdi
leaq -0x6e0(%rbp), %rsi
callq 0x14890
testb $0x1, %al
jne 0x6efb
jmp 0x6fb1
leaq -0x6d8(%rbp), %rdi
callq 0x148c0
movq %rax, -0x6e8(%rbp)
leaq -0x700(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x146b0
jmp 0x6f23
movq -0x6e8(%rbp), %rsi
leaq -0x700(%rbp), %rdi
callq 0x14640
movb %al, -0xa21(%rbp)
jmp 0x6f3e
movb -0xa21(%rbp), %al
xorb $-0x1, %al
movb %al, -0xa22(%rbp)
leaq -0x700(%rbp), %rdi
callq 0x140f0
movb -0xa22(%rbp), %al
testb $0x1, %al
jne 0x6f64
jmp 0x6f9e
movq -0x6e8(%rbp), %rsi
leaq -0xa8(%rbp), %rdi
callq 0x147a0
jmp 0x6f79
jmp 0x6f9e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0x700(%rbp), %rdi
callq 0x140f0
jmp 0x70a9
jmp 0x6fa0
leaq -0x6d8(%rbp), %rdi
callq 0x148e0
jmp 0x6edf
movq -0x650(%rbp), %rax
addq $0x78, %rax
movq %rax, -0x708(%rbp)
movq -0x708(%rbp), %rdi
callq 0x14830
movq %rax, -0x710(%rbp)
movq -0x708(%rbp), %rdi
callq 0x14860
movq %rax, -0x718(%rbp)
leaq -0x710(%rbp), %rdi
leaq -0x718(%rbp), %rsi
callq 0x14890
testb $0x1, %al
jne 0x7005
jmp 0x7194
leaq -0x710(%rbp), %rdi
callq 0x148c0
movq %rax, -0x720(%rbp)
leaq -0x738(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x146b0
jmp 0x702d
movq -0x720(%rbp), %rsi
leaq -0x738(%rbp), %rdi
callq 0x14640
movb %al, -0xa23(%rbp)
jmp 0x7048
movb -0xa23(%rbp), %al
xorb $-0x1, %al
movb %al, -0xa24(%rbp)
leaq -0x738(%rbp), %rdi
callq 0x140f0
movb -0xa24(%rbp), %al
testb $0x1, %al
jne 0x7071
jmp 0x7181
movq -0x720(%rbp), %rsi
leaq -0xa8(%rbp), %rdi
callq 0x147a0
jmp 0x7086
jmp 0x7181
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0x738(%rbp), %rdi
callq 0x140f0
movl -0xbc(%rbp), %eax
movl $0x8, %ecx
cmpl %ecx, %eax
jne 0x7e0b
movq -0xb8(%rbp), %rdi
callq 0x51a0
movq %rax, -0x740(%rbp)
movq 0x49f12(%rip), %rdi     # 0x50fe8
leaq 0x32668(%rip), %rsi     # 0x39745
callq 0x5490
movq %rax, -0xa30(%rbp)
jmp 0x70eb
movq -0xa30(%rbp), %rdi
movq -0x648(%rbp), %rsi
callq 0x5450
movq %rax, -0xa38(%rbp)
jmp 0x7107
movq -0xa38(%rbp), %rdi
leaq 0x32649(%rip), %rsi     # 0x3975e
callq 0x5490
movq %rax, -0xa40(%rbp)
jmp 0x7123
movq -0xa40(%rbp), %rdi
movq -0x740(%rbp), %rsi
addq $0x20, %rsi
callq 0x5450
movq %rax, -0xa48(%rbp)
jmp 0x7143
movq -0xa48(%rbp), %rdi
leaq 0x32427(%rip), %rsi     # 0x39578
callq 0x5490
jmp 0x7158
movb $0x1, 0x4a7d9(%rip)     # 0x51938
callq 0x5810
jmp 0x7166
jmp 0x7168
jmp 0x716a
movq -0x640(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x640(%rbp)
jmp 0x6aa5
jmp 0x7183
leaq -0x710(%rbp), %rdi
callq 0x148e0
jmp 0x6fe9
movq -0x650(%rbp), %rdi
addq $0x90, %rdi
callq 0x5830
testb $0x1, %al
jne 0x71c9
movq -0x650(%rbp), %rsi
addq $0x90, %rsi
leaq -0xa8(%rbp), %rdi
callq 0x147a0
jmp 0x71c7
jmp 0x71c9
jmp 0x7168
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
callq 0x5810
jmp 0x71e4
jmp 0x7e0b
movq 0x49d80(%rip), %rdi     # 0x50f70
leaq 0x3256b(%rip), %rsi     # 0x39762
callq 0x5490
jmp 0x71fe
leaq -0x638(%rbp), %rax
movq %rax, -0x748(%rbp)
movq -0x748(%rbp), %rdi
callq 0x14900
movq %rax, -0x750(%rbp)
movq -0x748(%rbp), %rdi
callq 0x14930
movq %rax, -0x758(%rbp)
leaq -0x750(%rbp), %rdi
leaq -0x758(%rbp), %rsi
callq 0x14960
testb $0x1, %al
jne 0x724e
jmp 0x7784
leaq -0x750(%rbp), %rdi
callq 0x14990
movq %rax, -0x760(%rbp)
movq -0x760(%rbp), %rax
movq 0x20(%rax), %rdi
addq $0x90, %rdi
callq 0x5830
testb $0x1, %al
jne 0x754e
movq -0x760(%rbp), %rax
movq 0x20(%rax), %rsi
addq $0x90, %rsi
leaq -0x638(%rbp), %rdi
callq 0x149b0
movq %rax, -0xa50(%rbp)
jmp 0x72a7
movq -0xa50(%rbp), %rax
movq %rax, -0x768(%rbp)
leaq -0x638(%rbp), %rdi
callq 0x14930
movq %rax, -0x770(%rbp)
leaq -0x768(%rbp), %rdi
leaq -0x770(%rbp), %rsi
callq 0x14960
testb $0x1, %al
jne 0x72e4
jmp 0x74bd
leaq -0x768(%rbp), %rdi
callq 0x149e0
movq 0x20(%rax), %rax
cmpl $0x3, 0xb0(%rax)
je 0x739a
movq 0x49ce0(%rip), %rdi     # 0x50fe8
leaq 0x324f5(%rip), %rsi     # 0x39804
callq 0x5490
movq %rax, -0xa58(%rbp)
jmp 0x731d
movq -0xa58(%rbp), %rdi
movq -0x760(%rbp), %rsi
callq 0x5450
movq %rax, -0xa60(%rbp)
jmp 0x7339
movq -0xa60(%rbp), %rdi
leaq 0x3243b(%rip), %rsi     # 0x39782
callq 0x5490
movq %rax, -0xa68(%rbp)
jmp 0x7355
leaq -0x768(%rbp), %rdi
callq 0x149e0
movq -0xa68(%rbp), %rdi
movq %rax, %rsi
callq 0x5450
movq %rax, -0xa70(%rbp)
jmp 0x7379
movq -0xa70(%rbp), %rdi
leaq 0x32421(%rip), %rsi     # 0x397a8
callq 0x5490
jmp 0x738e
movb $0x1, 0x4a5a3(%rip)     # 0x51938
jmp 0x74b8
leaq -0x768(%rbp), %rdi
callq 0x149e0
movq 0x20(%rax), %rdi
addq $0x20, %rdi
callq 0x14a00
movq %rax, -0xa78(%rbp)
jmp 0x73bc
movq -0xa78(%rbp), %rax
movq %rax, -0x778(%rbp)
movl $0x1, -0x77c(%rbp)
movl $0x2, -0x780(%rbp)
movl $0x3, -0x784(%rbp)
leaq -0x778(%rbp), %rdi
leaq -0x77c(%rbp), %rsi
leaq -0x780(%rbp), %rdx
leaq -0x784(%rbp), %rcx
callq 0x14a30
movb %al, -0xa79(%rbp)
jmp 0x7411
movb -0xa79(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x7422
jmp 0x74b6
movq 0x49bbf(%rip), %rdi     # 0x50fe8
leaq 0x323d4(%rip), %rsi     # 0x39804
callq 0x5490
movq %rax, -0xa88(%rbp)
jmp 0x743e
movq -0xa88(%rbp), %rdi
movq -0x760(%rbp), %rsi
callq 0x5450
movq %rax, -0xa90(%rbp)
jmp 0x745a
movq -0xa90(%rbp), %rdi
leaq 0x3231a(%rip), %rsi     # 0x39782
callq 0x5490
movq %rax, -0xa98(%rbp)
jmp 0x7476
leaq -0x768(%rbp), %rdi
callq 0x149e0
movq -0xa98(%rbp), %rdi
movq %rax, %rsi
callq 0x5450
movq %rax, -0xaa0(%rbp)
jmp 0x749a
movq -0xaa0(%rbp), %rdi
leaq 0x3232a(%rip), %rsi     # 0x397d2
callq 0x5490
jmp 0x74af
movb $0x1, 0x4a482(%rip)     # 0x51938
jmp 0x74b8
jmp 0x754c
movq 0x49b24(%rip), %rdi     # 0x50fe8
leaq 0x32330(%rip), %rsi     # 0x397fb
callq 0x5490
movq %rax, -0xaa8(%rbp)
jmp 0x74d9
movq -0xaa8(%rbp), %rdi
movq -0x760(%rbp), %rsi
callq 0x5450
movq %rax, -0xab0(%rbp)
jmp 0x74f5
movq -0xab0(%rbp), %rdi
leaq 0x3230b(%rip), %rsi     # 0x3980e
callq 0x5490
movq %rax, -0xab8(%rbp)
jmp 0x7511
leaq -0x768(%rbp), %rdi
callq 0x149e0
movq -0xab8(%rbp), %rdi
movq %rax, %rsi
callq 0x5450
movq %rax, -0xac0(%rbp)
jmp 0x7535
movq -0xac0(%rbp), %rdi
leaq 0x322f0(%rip), %rsi     # 0x39833
callq 0x5490
jmp 0x754a
jmp 0x754c
jmp 0x754e
movq -0x760(%rbp), %rax
movq 0x20(%rax), %rax
addq $0x60, %rax
movq %rax, -0x790(%rbp)
movq -0x790(%rbp), %rdi
callq 0x14830
movq %rax, -0x798(%rbp)
movq -0x790(%rbp), %rdi
callq 0x14860
movq %rax, -0x7a0(%rbp)
leaq -0x798(%rbp), %rdi
leaq -0x7a0(%rbp), %rsi
callq 0x14890
testb $0x1, %al
jne 0x75a6
jmp 0x7657
leaq -0x798(%rbp), %rdi
callq 0x148c0
movq %rax, -0x7a8(%rbp)
movq -0x7a8(%rbp), %rsi
leaq -0x638(%rbp), %rdi
callq 0x149b0
movq %rax, -0xac8(%rbp)
jmp 0x75d5
movq -0xac8(%rbp), %rax
movq %rax, -0x7b0(%rbp)
leaq -0x638(%rbp), %rdi
callq 0x14930
movq %rax, -0x7b8(%rbp)
leaq -0x7b0(%rbp), %rdi
leaq -0x7b8(%rbp), %rsi
callq 0x14960
testb $0x1, %al
jne 0x760f
jmp 0x7644
leaq -0x7b0(%rbp), %rdi
callq 0x149e0
movq 0x20(%rax), %rdi
addq $0x48, %rdi
movq -0x760(%rbp), %rsi
movl $0x4, -0x7bc(%rbp)
leaq -0x7bc(%rbp), %rdx
callq 0x14a90
jmp 0x7642
jmp 0x7644
jmp 0x7646
leaq -0x798(%rbp), %rdi
callq 0x148e0
jmp 0x758a
movq -0x760(%rbp), %rax
movq 0x20(%rax), %rax
addq $0x78, %rax
movq %rax, -0x7c8(%rbp)
movq -0x7c8(%rbp), %rdi
callq 0x14830
movq %rax, -0x7d0(%rbp)
movq -0x7c8(%rbp), %rdi
callq 0x14860
movq %rax, -0x7d8(%rbp)
leaq -0x7d0(%rbp), %rdi
leaq -0x7d8(%rbp), %rsi
callq 0x14890
testb $0x1, %al
jne 0x76af
jmp 0x7771
leaq -0x7d0(%rbp), %rdi
callq 0x148c0
movq %rax, -0x7e0(%rbp)
movq -0x7e0(%rbp), %rsi
leaq -0x638(%rbp), %rdi
callq 0x149b0
movq %rax, -0xad0(%rbp)
jmp 0x76de
movq -0xad0(%rbp), %rax
movq %rax, -0x7e8(%rbp)
leaq -0x638(%rbp), %rdi
callq 0x14930
movq %rax, -0x7f0(%rbp)
leaq -0x7e8(%rbp), %rdi
leaq -0x7f0(%rbp), %rsi
callq 0x14960
testb $0x1, %al
jne 0x7718
jmp 0x775e
movq -0x760(%rbp), %rax
movq 0x20(%rax), %rax
addq $0x48, %rax
movq %rax, -0xad8(%rbp)
leaq -0x7e8(%rbp), %rdi
callq 0x149e0
movq -0xad8(%rbp), %rdi
movq %rax, %rsi
movl $0x5, -0x7f4(%rbp)
leaq -0x7f4(%rbp), %rdx
callq 0x14a90
jmp 0x775c
jmp 0x775e
jmp 0x7760
leaq -0x7d0(%rbp), %rdi
callq 0x148e0
jmp 0x7693
jmp 0x7773
leaq -0x750(%rbp), %rdi
callq 0x14ae0
jmp 0x7232
leaq -0x810(%rbp), %rdi
callq 0x14b10
movq $0x0, -0x818(%rbp)
movq -0x818(%rbp), %rax
cmpq -0x608(%rbp), %rax
jae 0x7b51
movq -0x818(%rbp), %rsi
leaq -0xa8(%rbp), %rdi
callq 0x14430
movq %rax, %rsi
leaq -0x638(%rbp), %rdi
callq 0x14450
movq %rax, -0xae0(%rbp)
jmp 0x77da
movq -0xae0(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x820(%rbp)
cmpq $0x0, -0x820(%rbp)
jne 0x781d
jmp 0x7b3a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0x810(%rbp), %rdi
callq 0x14ed0
jmp 0x7e0b
movq -0x820(%rbp), %rax
testb $0x1, 0xb4(%rax)
je 0x7832
jmp 0x7b3a
movl $0x0, -0x824(%rbp)
leaq -0x810(%rbp), %rdi
leaq -0x820(%rbp), %rsi
leaq -0x824(%rbp), %rdx
callq 0x14b30
jmp 0x7858
jmp 0x785a
jmp 0x785c
leaq -0x810(%rbp), %rdi
callq 0x14bb0
subq $0x1, %rax
movq %rax, -0x830(%rbp)
movq -0x830(%rbp), %rsi
leaq -0x810(%rbp), %rdi
callq 0x14bd0
movq %rax, -0x838(%rbp)
movq -0x838(%rbp), %rdi
callq 0x14bf0
movq (%rax), %rax
movq %rax, -0x840(%rbp)
movq -0x838(%rbp), %rdi
callq 0x14c10
movq %rax, -0x848(%rbp)
movq -0x848(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xae8(%rbp)
movq -0x840(%rbp), %rdi
addq $0x48, %rdi
callq 0x14c30
movq %rax, %rcx
movq -0xae8(%rbp), %rax
cmpq %rcx, %rax
jb 0x794b
movq -0x840(%rbp), %rax
movb $0x1, 0xb5(%rax)
leaq -0x810(%rbp), %rdi
callq 0x14c60
cmpq $0x0, -0x830(%rbp)
jne 0x790f
jmp 0x7b26
movq -0x830(%rbp), %rsi
subq $0x1, %rsi
leaq -0x810(%rbp), %rdi
callq 0x14bd0
movq %rax, %rdi
callq 0x14c10
movq %rax, -0x850(%rbp)
movq -0x850(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x785a
movq -0x840(%rbp), %rdi
addq $0x48, %rdi
callq 0x14530
movq %rax, -0x860(%rbp)
movq -0x848(%rbp), %rax
movq (%rax), %rsi
movq -0x860(%rbp), %rdi
callq 0x14c90
movq %rax, -0xaf0(%rbp)
jmp 0x7981
movq -0xaf0(%rbp), %rax
movq %rax, -0x858(%rbp)
leaq -0x858(%rbp), %rdi
callq 0x14cc0
movq %rax, %rsi
leaq -0x638(%rbp), %rdi
callq 0x14450
movq %rax, -0xaf8(%rbp)
jmp 0x79b3
movq -0xaf8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x868(%rbp)
cmpq $0x0, -0x868(%rbp)
jne 0x79e4
movq -0x848(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x785a
movq -0x868(%rbp), %rax
testb $0x1, 0xb4(%rax)
je 0x7aed
movq -0x868(%rbp), %rax
testb $0x1, 0xb5(%rax)
jne 0x7aeb
leaq -0x810(%rbp), %rdi
movq %rdi, -0xb08(%rbp)
callq 0x14ce0
movq -0xb08(%rbp), %rdi
movq %rax, -0x878(%rbp)
callq 0x14d10
movq %rax, -0x880(%rbp)
movq -0x868(%rbp), %rax
movq %rax, -0x888(%rbp)
movq -0x878(%rbp), %rdi
movq -0x880(%rbp), %rsi
movq -0x888(%rbp), %rdx
callq 0xa460
movq %rax, -0xb00(%rbp)
jmp 0x7a6a
movq -0xb00(%rbp), %rax
movq %rax, -0x870(%rbp)
leaq -0x810(%rbp), %rdi
movq %rdi, -0xb18(%rbp)
callq 0x14ce0
movq %rax, -0x898(%rbp)
leaq -0x890(%rbp), %rdi
leaq -0x898(%rbp), %rsi
callq 0x14dd0
leaq -0x8a0(%rbp), %rdi
leaq -0x870(%rbp), %rsi
callq 0x14dd0
movq -0xb18(%rbp), %rdi
movq -0x890(%rbp), %rsi
movq -0x8a0(%rbp), %rdx
callq 0x14d40
movq %rax, -0xb10(%rbp)
jmp 0x7adb
movq -0xb10(%rbp), %rax
movq %rax, -0x8a8(%rbp)
jmp 0x7b26
jmp 0x7aed
movq -0x868(%rbp), %rax
movb $0x1, 0xb4(%rax)
movl $0x0, -0x8ac(%rbp)
leaq -0x810(%rbp), %rdi
leaq -0x868(%rbp), %rsi
leaq -0x8ac(%rbp), %rdx
callq 0x14b30
jmp 0x7b21
jmp 0x785a
leaq -0x810(%rbp), %rdi
callq 0x14e10
testb $0x1, %al
jne 0x7b38
jmp 0x7b51
jmp 0x7b3a
movq -0x818(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x818(%rbp)
jmp 0x779b
leaq -0x810(%rbp), %rdi
callq 0x14e10
testb $0x1, %al
jne 0x7d85
movb $0x1, 0x49dcc(%rip)     # 0x51938
movq 0x49475(%rip), %rdi     # 0x50fe8
leaq 0x31cd1(%rip), %rsi     # 0x3984b
callq 0x5490
jmp 0x7b81
leaq -0x810(%rbp), %rax
movq %rax, -0x8b8(%rbp)
movq -0x8b8(%rbp), %rdi
callq 0x14ce0
movq %rax, -0x8c0(%rbp)
movq -0x8b8(%rbp), %rdi
callq 0x14d10
movq %rax, -0x8c8(%rbp)
leaq -0x8c0(%rbp), %rdi
leaq -0x8c8(%rbp), %rsi
callq 0x14e50
testb $0x1, %al
jne 0x7bd1
jmp 0x7d22
leaq -0x8c0(%rbp), %rdi
callq 0x14e90
movups (%rax), %xmm0
movaps %xmm0, -0x8e0(%rbp)
leaq -0x8e0(%rbp), %rdi
movq %rdi, -0xb28(%rbp)
callq 0x14bf0
movq -0xb28(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x8e8(%rbp)
callq 0x14c10
movq (%rax), %rax
movq %rax, -0x8f0(%rbp)
movq 0x493c7(%rip), %rdi     # 0x50fe8
leaq 0x31c3c(%rip), %rsi     # 0x39864
callq 0x5490
movq %rax, -0xb20(%rbp)
jmp 0x7c36
movq -0xb20(%rbp), %rdi
movq -0x8e8(%rbp), %rsi
callq 0x5450
movq %rax, -0xb30(%rbp)
jmp 0x7c52
movq -0xb30(%rbp), %rdi
leaq 0x31c09(%rip), %rsi     # 0x39869
callq 0x5490
jmp 0x7c67
movq -0x8e8(%rbp), %rdi
addq $0x48, %rdi
callq 0x14530
movq %rax, -0x900(%rbp)
movq -0x8f0(%rbp), %rsi
movq -0x900(%rbp), %rdi
callq 0x14c90
movq %rax, -0xb38(%rbp)
jmp 0x7c9a
movq -0xb38(%rbp), %rax
movq %rax, -0x8f8(%rbp)
leaq -0x8f8(%rbp), %rdi
callq 0x14cc0
cmpl $0x4, 0x20(%rax)
jne 0x7cd1
movq 0x49327(%rip), %rdi     # 0x50fe8
leaq 0x31ba5(%rip), %rsi     # 0x3986d
callq 0x5490
jmp 0x7ccf
jmp 0x7cd1
leaq -0x8f8(%rbp), %rdi
callq 0x14cc0
cmpl $0x5, 0x20(%rax)
jne 0x7cfa
movq 0x492fe(%rip), %rdi     # 0x50fe8
leaq 0x31b8c(%rip), %rsi     # 0x3987d
callq 0x5490
jmp 0x7cf8
jmp 0x7cfa
movq 0x492e7(%rip), %rdi     # 0x50fe8
leaq 0x31870(%rip), %rsi     # 0x39578
callq 0x5490
jmp 0x7d0f
jmp 0x7d11
leaq -0x8c0(%rbp), %rdi
callq 0x14eb0
jmp 0x7bb5
movq 0x492bf(%rip), %rdi     # 0x50fe8
leaq 0x31b34(%rip), %rsi     # 0x39864
callq 0x5490
movq %rax, -0xb40(%rbp)
jmp 0x7d3e
xorl %eax, %eax
movl %eax, %esi
leaq -0x810(%rbp), %rdi
callq 0x14bd0
movq %rax, %rdi
callq 0x14bf0
movq -0xb40(%rbp), %rdi
movq (%rax), %rsi
callq 0x5450
movq %rax, -0xb48(%rbp)
jmp 0x7d6e
movq -0xb48(%rbp), %rdi
leaq 0x31a53(%rip), %rsi     # 0x397cf
callq 0x5490
jmp 0x7d83
jmp 0x7d85
movq 0x4925c(%rip), %rdi     # 0x50fe8
leaq 0x31af9(%rip), %rsi     # 0x3988c
callq 0x5490
jmp 0x7d9a
testb $0x1, 0x49b97(%rip)     # 0x51938
jne 0x7dba
movq 0x491c6(%rip), %rdi     # 0x50f70
leaq 0x31af7(%rip), %rsi     # 0x398a8
callq 0x5490
jmp 0x7db8
jmp 0x7dd1
movq 0x491af(%rip), %rdi     # 0x50f70
leaq 0x31af4(%rip), %rsi     # 0x398bc
callq 0x5490
jmp 0x7dcf
jmp 0x7dd1
movb 0x49b61(%rip), %dl      # 0x51938
xorl %eax, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
movl $0x1, -0xc0(%rbp)
leaq -0x810(%rbp), %rdi
callq 0x14ed0
leaq -0x638(%rbp), %rdi
callq 0x14f30
jmp 0x7e19
leaq -0x638(%rbp), %rdi
callq 0x14f30
jmp 0x7e33
leaq -0x520(%rbp), %rdi
callq 0x140f0
leaq -0x508(%rbp), %rdi
callq 0x14f50
jmp 0x7e4d
leaq -0x520(%rbp), %rdi
callq 0x140f0
leaq -0x508(%rbp), %rdi
callq 0x14f50
jmp 0x7e83
leaq -0xa8(%rbp), %rdi
callq 0x140f0
leaq -0x90(%rbp), %rdi
callq 0x5320
leaq -0x68(%rbp), %rdi
callq 0x5320
leaq -0x40(%rbp), %rdi
callq 0x14fb0
movl -0x4(%rbp), %eax
addq $0xb50, %rsp            # imm = 0xB50
popq %rbp
retq
leaq -0xa8(%rbp), %rdi
callq 0x140f0
leaq -0x90(%rbp), %rdi
callq 0x5320
leaq -0x68(%rbp), %rdi
callq 0x5320
leaq -0x40(%rbp), %rdi
callq 0x14fb0
movq -0xb8(%rbp), %rdi
callq 0x5870
movq %rax, %rdi
callq 0x138d0
nopw %cs:(%rax,%rax)