// File: /workspace/github_c_makefile_star2_O1/madler[P]pigz/pigz.c
// Function: process
local void process(char *path) {
    volatile int method = -1;       // get_header() return value
    size_t len;                     // length of base name (minus suffix)
    struct stat st;                 // to get file type and mod time
    ball_t err;                     // error information from throw()
    // all compressed suffixes for decoding search, in length order
    static char *sufs[] = {".z", "-z", "_z", ".Z", ".gz", "-gz", ".zz", "-zz",
                           ".zip", ".ZIP", ".tgz", NULL};

    // open input file with name in, descriptor ind -- set name and mtime
    if (path == NULL) {
        vstrcpy(&g.inf, &g.inz, 0, "<stdin>");
        g.ind = 0;
        g.name = NULL;
        g.mtime = (g.headis & 2) && fstat(g.ind, &st) == 0 &&
                  S_ISREG(st.st_mode) ? st.st_mtime : 0;
        len = 0;
    }
    else {
        // set input file name (already set if recursed here)
        if (path != g.inf)
            vstrcpy(&g.inf, &g.inz, 0, path);
        len = strlen(g.inf);

        // try to stat input file -- if not there and decoding, look for that
        // name with compressed suffixes
        if (lstat(g.inf, &st)) {
            if (errno == ENOENT && (g.list || g.decode)) {
                char **sufx = sufs;
                do {
                    if (*sufx == NULL)
                        break;
                    vstrcpy(&g.inf, &g.inz, len, *sufx++);
                    errno = 0;
                } while (lstat(g.inf, &st) && errno == ENOENT);
            }
#if defined(EOVERFLOW) && defined(EFBIG)
            if (errno == EOVERFLOW || errno == EFBIG)
                throw(EDOM, "%s too large -- "
                      "not compiled with large file support", g.inf);
#endif
            if (errno) {
                g.inf[len] = 0;
                complain("skipping: %s does not exist", g.inf);
                return;
            }
            len = strlen(g.inf);
        }

        // only process regular files or named pipes, but allow symbolic links
        // if -f, recurse into directory if -r
        if ((st.st_mode & S_IFMT) != S_IFREG &&
            (st.st_mode & S_IFMT) != S_IFIFO &&
            (st.st_mode & S_IFMT) != S_IFLNK &&
            (st.st_mode & S_IFMT) != S_IFDIR) {
            complain("skipping: %s is a special file or device", g.inf);
            return;
        }
        if ((st.st_mode & S_IFMT) == S_IFLNK && !g.force && !g.pipeout) {
            complain("skipping: %s is a symbolic link", g.inf);
            return;
        }
        if ((st.st_mode & S_IFMT) == S_IFDIR && !g.recurse) {
            complain("skipping: %s is a directory", g.inf);
            return;
        }

        // recurse into directory (assumes Unix)
        if ((st.st_mode & S_IFMT) == S_IFDIR) {
            char *roll = NULL;
            size_t size = 0, off = 0, base;
            DIR *here;
            struct dirent *next;

            // accumulate list of entries (need to do this, since readdir()
            // behavior not defined if directory modified between calls)
            here = opendir(g.inf);
            if (here == NULL)
                return;
            while ((next = readdir(here)) != NULL) {
                if (next->d_name[0] == 0 ||
                    (next->d_name[0] == '.' && (next->d_name[1] == 0 ||
                     (next->d_name[1] == '.' && next->d_name[2] == 0))))
                    continue;
                off = vstrcpy(&roll, &size, off, next->d_name);
            }
            closedir(here);
            vstrcpy(&roll, &size, off, "");

            // run process() for each entry in the directory
            base = len && g.inf[len - 1] != (unsigned char)'/' ?
                   vstrcpy(&g.inf, &g.inz, len, "/") - 1 : len;
            for (off = 0; roll[off]; off += strlen(roll + off) + 1) {
                vstrcpy(&g.inf, &g.inz, base, roll + off);
                process(g.inf);
            }
            g.inf[len] = 0;

            // release list of entries
            FREE(roll);
            return;
        }

        // don't compress .gz (or provided suffix) files, unless -f
        if (!(g.force || g.list || g.decode) && len >= strlen(g.sufx) &&
                strcmp(g.inf + len - strlen(g.sufx), g.sufx) == 0) {
            grumble("skipping: %s ends with %s", g.inf, g.sufx);
            return;
        }

        // create output file only if input file has compressed suffix
        if (g.decode == 1 && !g.pipeout && !g.list) {
            size_t suf = compressed_suffix(g.inf);
            if (suf == 0) {
                complain("skipping: %s does not have compressed suffix",
                         g.inf);
                return;
            }
            len -= suf;
        }

        // open input file
        g.ind = open(g.inf, O_RDONLY, 0);
        if (g.ind < 0)
            throw(errno, "read error on %s (%s)", g.inf, strerror(errno));

        // prepare gzip header information for compression
        g.name = g.headis & 1 ? justname(g.inf) : NULL;
        g.mtime = g.headis & 2 ? st.st_mtime : 0;
    }
    SET_BINARY_MODE(g.ind);

    // if requested, just list information about the input file
    if (g.list && g.decode != 2) {
        list_info();
        load_end();
        return;
    }

    // if decoding or testing, try to read gzip header
    if (g.decode) {
        in_init();
        method = get_header(1);
        if (method != 8 && method != 257 &&
                // gzip -cdf acts like cat on uncompressed input
                !((method == -1 || method == -2) && g.force && g.pipeout &&
                  g.decode != 2 && !g.list)) {
            load_end();
            complain(method == -6 ? "skipping: %s corrupt: header crc error" :
                     method == -1 ? "skipping: %s empty" :
                     method < 0 ? "skipping: %s unrecognized format" :
                     "skipping: %s unknown compression method", g.inf);
            return;
        }

        // if requested, test input file (possibly a test list)
        if (g.decode == 2) {
            try {
                if (method == 8)
                    infchk();
                else {
                    unlzw();
                    if (g.list) {
                        g.in_tot -= 3;
                        show_info(method, 0, g.out_tot, 0);
                    }
                }
            }
            catch (err) {
                if (err.code != EDOM)
                    punt(err);
                complain("skipping: %s", err.why);
                drop(err);
                outb(NULL, NULL, 0);
            }
            load_end();
            return;
        }
    }

    // create output file out, descriptor outd
    if (path == NULL || g.pipeout) {
        // write to stdout
        g.outf = alloc(NULL, strlen("<stdout>") + 1);
        strcpy(g.outf, "<stdout>");
        g.outd = 1;
        if (!g.decode && !g.force && isatty(g.outd))
            throw(EINVAL, "trying to write compressed data to a terminal"
                          " (use -f to force)");
    }
    else {
        char *to = g.inf, *sufx = "";
        size_t pre = 0;

        // select parts of the output file name
        if (g.decode) {
            // for -dN or -dNT, use the path from the input file and the name
            // from the header, stripping any path in the header name
            if ((g.headis & 1) != 0 && g.hname != NULL) {
                pre = (size_t)(justname(g.inf) - g.inf);
                to = justname(g.hname);
                len = strlen(to);
            }
            // for -d or -dNn, replace abbreviated suffixes
            else if (strcmp(to + len, ".tgz") == 0)
                sufx = ".tar";
        }
        else
            // add appropriate suffix when compressing
            sufx = g.sufx;

        // create output file and open to write, overwriting any existing file
        // of the same name only if requested with --force or -f
        g.outf = alloc(NULL, pre + len + strlen(sufx) + 1);
        memcpy(g.outf, g.inf, pre);
        memcpy(g.outf + pre, to, len);
        strcpy(g.outf + pre + len, sufx);
        g.outd = open(g.outf, O_CREAT | O_TRUNC | O_WRONLY |
                              (g.force ? 0 : O_EXCL), 0600);

        // if it exists and wasn't forced, give the user a chance to overwrite
        if (g.outd < 0 && errno == EEXIST) {
            int overwrite = 0;
            if (isatty(0) && g.verbosity) {
                // get a response from the user -- the first non-blank
                // character has to be a "y" or a "Y" to permit an overwrite
                fprintf(stderr, "%s exists -- overwrite (y/n)? ", g.outf);
                fflush(stderr);
                int ch, first = 1;
                do {
                    ch = getchar();
                    if (first == 1) {
                        if (ch == ' ' || ch == '\t')
                            continue;
                        if (ch == 'y' || ch == 'Y')
                            overwrite = 1;
                        first = 0;
                    }
                } while (ch != EOF && ch != '\n' && ch != '\r');
            }
            if (!overwrite) {
                complain("skipping: %s exists", g.outf);
                RELEASE(g.outf);
                load_end();
                return;
            }
            g.outd = open(g.outf, O_CREAT | O_TRUNC | O_WRONLY, 0600);
        }

        // if some other error, give up
        if (g.outd < 0)
            throw(errno, "write error on %s (%s)", g.outf, strerror(errno));
    }
    SET_BINARY_MODE(g.outd);

    // process ind to outd
    if (g.verbosity > 1)
        fprintf(stderr, "%s to %s ", g.inf, g.outf);
    if (g.decode) {
        try {
            if (method == 8)
                infchk();
            else if (method == 257)
                unlzw();
            else
                cat();
        }
        catch (err) {
            if (err.code != EDOM)
                punt(err);
            complain("skipping: %s", err.why);
            drop(err);
            outb(NULL, NULL, 0);
            if (g.outd != -1 && g.outd != 1) {
                close(g.outd);
                g.outd = -1;
                unlink(g.outf);
                RELEASE(g.outf);
            }
        }
    }
#ifndef NOTHREAD
    else if (g.procs > 1)
        parallel_compress();
#endif
    else
        single_compress(0);
    if (g.verbosity > 1) {
        putc('\n', stderr);
        fflush(stderr);
    }

    // finish up, copy attributes, set times, delete original
    load_end();
    if (g.outd != -1 && g.outd != 1) {
        if (g.sync)
            out_push();         // push to permanent storage
        if (close(g.outd))
            throw(errno, "write error on %s (%s)", g.outf, strerror(errno));
        g.outd = -1;            // now prevent deletion on interrupt
        if (g.ind != 0) {
            copymeta(g.inf, g.outf);
            if (!g.keep) {
                if (st.st_nlink > 1 && !g.force)
                    complain("%s has hard links -- not unlinking", g.inf);
                else
                    unlink(g.inf);
            }
        }
        if (g.decode && (g.headis & 2) != 0 && g.stamp)
            touch(g.outf, g.stamp);
    }
    RELEASE(g.outf);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rdi, %r13
movl $0xffffffff, (%rsp)     # imm = 0xFFFFFFFF
testq %rdi, %rdi
je 0x4ac5
movq 0x18b30(%rip), %r15     # 0x1d358
cmpq %r13, %r15
je 0x4903
movq %r13, %rdi
callq 0x31a0
movq %rax, %r14
incq %r14
cmpq 0x18b1a(%rip), %r14     # 0x1d360
jbe 0x48f1
movq %r14, %rax
shrq $0x2, %rax
addq %r14, %rax
movl $0x3, %edx
movq %rax, %rcx
cmpq $0x8, %rax
jb 0x4881
movl $0x3, %esi
movq %rax, %rdi
movq %rdi, %r8
shrq %rdi
incq %rsi
movq %rsi, %rdx
movq %rdi, %rcx
cmpq $0xf, %r8
ja 0x486c
movq %rcx, %rsi
movl %edx, %ecx
movl $0x1, %edx
shlq %cl, %rdx
cmpq $0x7, %rsi
cmoveq %rdx, %rax
cmpq $0x11, %rax
movl $0x10, %ecx
cmovaeq %rax, %rcx
cmpq %r14, %rcx
movq $-0x1, %r12
cmovaq %rcx, %r12
testq %r15, %r15
je 0x48c9
movq %r15, %rdi
callq 0x3050
movq $0x0, 0x18a8f(%rip) # 0x1d358
movq $0x0, 0x18a8c(%rip) # 0x1d360
movq 0x18a7d(%rip), %rdi     # 0x1d358
movq %r12, %rsi
callq 0x9af2
movq %rax, 0x18a6e(%rip)     # 0x1d358
movq %r12, 0x18a6f(%rip)     # 0x1d360
movq 0x18a60(%rip), %rdi     # 0x1d358
movq %r13, %rsi
movq %r14, %rdx
callq 0x3360
movq 0x18a4e(%rip), %r15     # 0x1d358
movq %r15, %rdi
callq 0x31a0
movq %rax, %r14
movq %rax, %rbp
leaq 0x198(%rsp), %rsi
movq %r15, %rdi
callq 0x3160
testl %eax, %eax
je 0x4b56
movq %r13, 0x88(%rsp)
callq 0x3070
movq %rax, %r15
cmpl $0x2, (%rax)
jne 0x4a8a
movl 0x18a79(%rip), %eax     # 0x1d3c8
orl 0x18a6b(%rip), %eax     # 0x1d3c0
je 0x4a8a
leaq 0x183fe(%rip), %rbx     # 0x1cd60
movq %rbp, 0x78(%rsp)
movq (%rbx), %r12
testq %r12, %r12
je 0x4a8a
movq %r12, %rdi
callq 0x31a0
movq %rax, %r13
incq %r13
movq %r13, %rax
addq %r14, %rax
jb 0x63de
cmpq 0x189cc(%rip), %rax     # 0x1d360
jbe 0x4a48
movq %rax, %rbp
shrq $0x2, %rbp
addq %rax, %rbp
movl $0x3, %ecx
movq %rbp, %rsi
cmpq $0x8, %rbp
jb 0x49cf
movl $0x3, %edi
movq %rbp, %r8
movq %r8, %r9
shrq %r8
incq %rdi
movq %rdi, %rcx
movq %r8, %rsi
cmpq $0xf, %r9
ja 0x49ba
movl $0x1, %edi
shlq %cl, %rdi
cmpq $0x7, %rsi
cmoveq %rdi, %rbp
cmpq $0x11, %rbp
movl $0x10, %ecx
cmovbq %rcx, %rbp
cmpq %rax, %rbp
movq $-0x1, %rax
cmovbeq %rax, %rbp
testq %r14, %r14
jne 0x4a26
movq 0x18952(%rip), %rdi     # 0x1d358
testq %rdi, %rdi
je 0x4a1b
callq 0x3050
movq $0x0, 0x1893d(%rip) # 0x1d358
movq $0x0, 0x1893a(%rip) # 0x1d360
movq 0x1892b(%rip), %rdi     # 0x1d358
movq %rbp, %rsi
callq 0x9af2
movq %rax, 0x1891c(%rip)     # 0x1d358
movq %rbp, 0x1891d(%rip)     # 0x1d360
movq 0x78(%rsp), %rbp
movq 0x18909(%rip), %rdi     # 0x1d358
addq %rbp, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x3360
movl $0x0, (%r15)
movq 0x188ed(%rip), %rdi     # 0x1d358
leaq 0x198(%rsp), %rsi
callq 0x3160
testl %eax, %eax
je 0x4a8a
addq $0x8, %rbx
cmpl $0x2, (%r15)
je 0x4967
movl (%r15), %eax
testl %eax, %eax
je 0x4b5b
cmpl $0x4b, %eax
je 0x63f3
cmpl $0x1b, %eax
je 0x63f3
movq 0x188aa(%rip), %rax     # 0x1d358
movb $0x0, (%rax,%rbp)
movq 0x1889f(%rip), %rsi     # 0x1d358
leaq 0x11789(%rip), %rdi     # 0x16249
jmp 0x6281
cmpq $0x7, 0x18893(%rip)     # 0x1d360
ja 0x4b19
movq 0x18882(%rip), %rdi     # 0x1d358
testq %rdi, %rdi
je 0x4aeb
callq 0x3050
movq $0x0, 0x1886d(%rip) # 0x1d358
movq $0x0, 0x1886a(%rip) # 0x1d360
movq 0x1885b(%rip), %rdi     # 0x1d358
movl $0x10, %esi
callq 0x9af2
movq %rax, 0x1884a(%rip)     # 0x1d358
movq $0x10, 0x18847(%rip) # 0x1d360
movq 0x18838(%rip), %rax     # 0x1d358
movabsq $0x3e6e696474733c, %rcx # imm = 0x3E6E696474733C
movq %rcx, (%rax)
movl $0x0, 0x18819(%rip)     # 0x1d350
movq $0x0, 0x1885e(%rip) # 0x1d3a0
testb $0x2, 0x1882b(%rip)     # 0x1d374
jne 0x4be9
xorl %eax, %eax
jmp 0x4c04
movq %rbp, %rax
jmp 0x4b6f
movq 0x187f6(%rip), %rdi     # 0x1d358
callq 0x31a0
movq 0x88(%rsp), %r13
movq %rax, %rsi
movl $0xf000, %eax           # imm = 0xF000
andl 0x1b0(%rsp), %eax
movl %eax, %ecx
addl $0xfffff000, %ecx       # imm = 0xFFFFF000
shrl $0xc, %ecx
cmpl $0x9, %ecx
ja 0x4fe1
movl $0x289, %edx            # imm = 0x289
btl %ecx, %edx
jae 0x4fe1
movl %eax, %edx
xorl $0xa000, %edx           # imm = 0xA000
movl 0x187d2(%rip), %ecx     # 0x1d380
orl %ecx, %edx
movl 0x187c2(%rip), %ebx     # 0x1d378
orl %ebx, %edx
je 0x4dbf
cmpl $0x4000, %eax           # imm = 0x4000
jne 0x4e60
cmpl $0x0, 0x187c0(%rip)     # 0x1d390
jne 0x4e60
movq 0x1877b(%rip), %rsi     # 0x1d358
leaq 0x116ca(%rip), %rdi     # 0x162ae
jmp 0x6281
xorl %ebp, %ebp
leaq 0x198(%rsp), %rsi
movl %ebp, %edi
callq 0x3570
testl %eax, %eax
je 0x502a
movl %ebp, %eax
movq %rax, %r14
movq %rax, 0x187aa(%rip)     # 0x1d3b8
cmpl $0x0, 0x187ab(%rip)     # 0x1d3c0
setne %cl
movl 0x187aa(%rip), %eax     # 0x1d3c8
cmpl $0x2, %eax
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x4c9e
xorps %xmm0, %xmm0
movups %xmm0, 0x2083b(%rip)    # 0x25470
movq $0x0, 0x20840(%rip) # 0x25480
movl $0xffffffff, 0x28886(%rip) # imm = 0xFFFFFFFF
movl $0x1, %edi
callq 0x6a9b
movl %eax, %ebp
testl %eax, %eax
js 0x4ff4
movl %ebp, %ebx
callq 0xa8dc
movl 0x1871d(%rip), %eax     # 0x1d388
cmpl $0x2, %eax
jl 0x50bc
callq 0xa930
movq 0x187a8(%rip), %rax     # 0x1d428
movq %rax, 0x207f9(%rip)     # 0x25480
movq 0x18792(%rip), %rsi     # 0x1d420
movq 0x1879b(%rip), %rdx     # 0x1d430
movl %ebx, %edi
xorl %ecx, %ecx
jmp 0x5445
testl %eax, %eax
je 0x4dd2
xorps %xmm0, %xmm0
movups %xmm0, 0x207c0(%rip)    # 0x25470
movq $0x0, 0x207c5(%rip) # 0x25480
movl $0xffffffff, 0x2880b(%rip) # imm = 0xFFFFFFFF
movl $0x1, %edi
callq 0x6a9b
movl %eax, (%rsp)
movl (%rsp), %eax
cmpl $0x8, %eax
je 0x4d2c
movl (%rsp), %eax
cmpl $0x101, %eax            # imm = 0x101
je 0x4d2c
movl (%rsp), %eax
cmpl $-0x1, %eax
je 0x4cf8
movl (%rsp), %eax
cmpl $-0x2, %eax
jne 0x51ee
cmpl $0x0, 0x18681(%rip)     # 0x1d380
je 0x51ee
cmpl $0x0, 0x1866c(%rip)     # 0x1d378
je 0x51ee
cmpl $0x2, 0x186af(%rip)     # 0x1d3c8
je 0x51ee
cmpl $0x0, 0x1869a(%rip)     # 0x1d3c0
jne 0x51ee
cmpl $0x2, 0x18695(%rip)     # 0x1d3c8
jne 0x4dd2
movl $0x1, 0x90(%rsp)
xorl %eax, %eax
leaq 0xb0(%rsp), %rbx
movq %rax, 0xc8(%rbx)
movl $0x0, 0xd0(%rbx)
movq %rax, 0xd8(%rbx)
callq 0xe508
leaq 0x38902(%rip), %r14     # 0x3d674
movl (%r14), %edi
callq 0x3110
movq %rax, 0xe0(%rbx)
movl (%r14), %edi
movq %rbx, %rsi
callq 0x3600
testl %eax, %eax
jne 0x644f
leaq 0xb0(%rsp), %rdi
callq 0x32f0
testl %eax, %eax
jne 0x555f
movl (%rsp), %eax
cmpl $0x8, %eax
jne 0x5536
callq 0x7e55
jmp 0x555f
movq 0x18592(%rip), %rsi     # 0x1d358
leaq 0x114c1(%rip), %rdi     # 0x1628e
jmp 0x6281
testq %r13, %r13
je 0x5053
cmpl $0x0, 0x18596(%rip)     # 0x1d378
jne 0x5053
movq 0x18569(%rip), %r13     # 0x1d358
cmpl $0x0, 0x185d2(%rip)     # 0x1d3c8
je 0x51e0
movq 0x1860d(%rip), %r15     # 0x1d410
testq %r15, %r15
setne %al
andb 0x18565(%rip), %al      # 0x1d374
cmpb $0x1, %al
jne 0x520b
movl $0x2f, %ebp
movq %r13, %rdi
movl %ebp, %esi
callq 0x3210
leaq 0x1(%rax), %r12
testq %rax, %rax
cmoveq %r13, %r12
subq %r13, %r12
movq %r15, %rdi
movl %ebp, %esi
callq 0x3210
leaq 0x1(%rax), %r13
testq %rax, %rax
cmoveq %r15, %r13
movq %r13, %rdi
callq 0x31a0
movq %rax, %r14
leaq 0x1205e(%rip), %rbx     # 0x16eb9
jmp 0x5237
cmpl $0x4000, %eax           # imm = 0x4000
movq %rsi, 0x8(%rsp)
jne 0x5126
movq 0x184e1(%rip), %rdi     # 0x1d358
callq 0x3180
testq %rax, %rax
je 0x6288
movq %rax, %rbx
movq %rax, %rdi
callq 0x34a0
testq %rax, %rax
je 0x547e
xorl %ecx, %ecx
movq %rcx, %rdx
movq %rcx, %rdi
movq %rax, %rcx
movq %rdi, %r14
movq %rdx, 0x20(%rsp)
movq %r14, %rbp
movq %rdi, %r15
movq %rcx, %r12
movzbl 0x13(%r12), %eax
testl %eax, %eax
je 0x4edb
cmpl $0x2e, %eax
jne 0x4ef0
movzbl 0x14(%r12), %eax
testl %eax, %eax
je 0x4edb
cmpl $0x2e, %eax
jne 0x4ef0
cmpb $0x0, 0x15(%r12)
jne 0x4ef0
movq %rbx, %rdi
callq 0x34a0
movq %rax, %r12
testq %rax, %rax
jne 0x4eb5
jmp 0x5358
movq %r12, %r14
addq $0x13, %r14
movq %r14, %rdi
callq 0x31a0
movq %rax, %r12
incq %r12
movq %r12, %r13
addq %r15, %r13
jb 0x63de
cmpq %rbp, %r13
movq %r15, 0x70(%rsp)
jbe 0x4f95
movq %r13, %rbp
shrq $0x2, %rbp
addq %r13, %rbp
movl $0x3, %ecx
movq %rbp, %rdx
cmpq $0x8, %rbp
jb 0x4f50
movl $0x3, %esi
movq %rbp, %rdi
movq %rdi, %r8
shrq %rdi
incq %rsi
movq %rsi, %rcx
movq %rdi, %rdx
cmpq $0xf, %r8
ja 0x4f3b
movl $0x1, %esi
shlq %cl, %rsi
cmpq $0x7, %rdx
cmoveq %rsi, %rbp
cmpq $0x11, %rbp
movl $0x10, %eax
cmovbq %rax, %rbp
cmpq %r13, %rbp
movq $-0x1, %rax
cmovbeq %rax, %rbp
testq %r15, %r15
jne 0x4f9c
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x4fa1
callq 0x3050
xorl %eax, %eax
movl %eax, %edi
jmp 0x4fa1
movq 0x20(%rsp), %r15
jmp 0x4fac
movq 0x20(%rsp), %rdi
movq %rbp, %rsi
callq 0x9af2
movq %rax, %r15
movq 0x70(%rsp), %rdi
addq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x3360
movq %rbx, %rdi
callq 0x34a0
movq %rax, %rcx
movq %r13, %rdi
movq %rbp, %r14
movq %r15, %rdx
testq %rax, %rax
jne 0x4ea7
jmp 0x5489
movq 0x18370(%rip), %rsi     # 0x1d358
leaq 0x11276(%rip), %rdi     # 0x16265
jmp 0x6281
cmpl $-0x1, %ebp
leaq 0x11352(%rip), %rax     # 0x16350
leaq 0x1135e(%rip), %rcx     # 0x16363
cmoveq %rax, %rcx
cmpl $-0x6, %ebp
leaq 0x11316(%rip), %rdi     # 0x16329
cmovneq %rcx, %rdi
movq 0x1833a(%rip), %rsi     # 0x1d358
xorl %eax, %eax
callq 0x476b
jmp 0x544a
movl $0xf000, %eax           # imm = 0xF000
andl 0x1b0(%rsp), %eax
cmpl $0x8000, %eax           # imm = 0x8000
jne 0x4b4f
movq 0x1f0(%rsp), %rax
xorl %ecx, %ecx
movl %ecx, %r14d
jmp 0x4c07
xorl %eax, %eax
movl %eax, %edi
movl $0x9, %esi
callq 0x9af2
movq %rax, 0x18300(%rip)     # 0x1d368
movabsq $0x3e74756f6474733c, %rcx # imm = 0x3E74756F6474733C
movq %rcx, (%rax)
movb $0x0, 0x8(%rax)
movl $0x1, 0x182d1(%rip)     # 0x1d354
movl 0x182f7(%rip), %eax     # 0x1d380
orl 0x18339(%rip), %eax     # 0x1d3c8
jne 0x5839
movl $0x1, %edi
callq 0x30f0
testl %eax, %eax
je 0x5839
leaq 0x11351(%rip), %rsi     # 0x163ff
xorl %eax, %eax
movl %eax, %edx
movl $0x16, %edi
callq 0xe575
cmpl $0x1, %eax
jne 0x518e
movl 0x18285(%rip), %edi     # 0x1d350
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x3560
cmpq $-0x1, %rax
je 0x53a7
movq %rax, 0x20396(%rip)     # 0x25480
movl 0x18260(%rip), %edi     # 0x1d350
movq $-0x4, %rsi
movl $0x2, %edx
callq 0x3560
movl 0x18249(%rip), %edi     # 0x1d350
leaq 0xb0(%rsp), %r14
movl $0x4, %edx
movq %r14, %rsi
callq 0xaf4f
movl (%r14), %eax
bswapl %eax
jmp 0x5435
movl 0x18294(%rip), %ebp     # 0x1d3c0
orl %ebp, %ecx
movl 0x18293(%rip), %r14d    # 0x1d3c8
orl %r14d, %ecx
jne 0x5176
movq 0x18257(%rip), %r15     # 0x1d398
movq %r15, %rdi
callq 0x31a0
movq 0x8(%rsp), %rsi
cmpq %rax, %rsi
jb 0x5176
movq 0x181fe(%rip), %r12     # 0x1d358
leaq (%r12,%rsi), %rdi
subq %rax, %rdi
movq %r15, %rsi
callq 0x3320
movq 0x8(%rsp), %rsi
testl %eax, %eax
je 0x629a
xorl $0x1, %r14d
orl %ebx, %r14d
orl %ebp, %r14d
je 0x5330
movq %rsi, %rbx
jmp 0x5603
cmpl $0x101, %ebp            # imm = 0x101
jne 0x5365
movl 0x181b0(%rip), %edi     # 0x1d350
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x3560
cmpq $-0x1, %rax
je 0x51bd
movq %rax, 0x202c5(%rip)     # 0x25480
jmp 0x51c7
callq 0xadbc
testq %rax, %rax
jne 0x51bd
addq $-0x3, 0x202b1(%rip)    # 0x25480
xorl %ecx, %ecx
movl %ecx, %edx
movl $0x101, %edi            # imm = 0x101
movq %rdx, %rsi
jmp 0x5445
movq 0x181b1(%rip), %rbx     # 0x1d398
xorl %ecx, %ecx
movl %ecx, %r12d
jmp 0x5237
callq 0x69a6
movl (%rsp), %eax
cmpl $-0x6, %eax
jne 0x5454
leaq 0x11123(%rip), %rdi     # 0x16329
jmp 0x627a
leaq (%r14,%r13), %rdi
leaq 0x10ff9(%rip), %rsi     # 0x1620f
callq 0x3320
testl %eax, %eax
leaq 0x1121b(%rip), %rax     # 0x1643f
leaq 0x11c8e(%rip), %rcx     # 0x16eb9
cmoveq %rax, %rcx
xorl %eax, %eax
movl %eax, %r12d
movq %rcx, %rbx
movq %rbx, %rdi
callq 0x31a0
leaq (%r12,%r14), %rcx
leaq (%rax,%rcx), %rsi
incq %rsi
xorl %ebp, %ebp
movl %ebp, %edi
callq 0x9af2
movq %rax, %r15
movq %rax, 0x1810b(%rip)     # 0x1d368
movq 0x180f4(%rip), %rsi     # 0x1d358
movq %rax, %rdi
movq %r12, %rdx
callq 0x3360
addq %r15, %r12
movq %r12, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x3360
addq %r14, %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x30b0
xorl %eax, %eax
cmpl $0x0, 0x180e9(%rip)     # 0x1d380
sete %cl
movb %cl, %al
shll $0x7, %eax
movl %eax, %esi
orl $0x241, %esi            # imm = 0x241
movl %ebp, %eax
movq %r15, %rdi
movl $0x180, %edx            # imm = 0x180
callq 0x3480
movl %eax, 0x18098(%rip)     # 0x1d354
testl %eax, %eax
jns 0x582c
callq 0x3070
cmpl $0x11, (%rax)
jne 0x582c
xorl %edi, %edi
callq 0x30f0
movb $0x1, %bl
testl %eax, %eax
je 0x52ec
cmpl $0x0, 0x1808a(%rip)     # 0x1d370
jne 0x63c7
movq 0x18075(%rip), %rsi     # 0x1d368
testb $0x1, %bl
je 0x5809
leaq 0x11160(%rip), %rdi     # 0x16463
xorl %eax, %eax
callq 0x476b
movq 0x18057(%rip), %rdi     # 0x1d368
testq %rdi, %rdi
je 0x5326
callq 0x3050
movq $0x0, 0x18042(%rip) # 0x1d368
callq 0x69a6
jmp 0x5823
movq 0x18021(%rip), %r12     # 0x1d358
movq %r12, %rdi
callq 0x6867
movq %rax, %r15
testq %rax, %rax
je 0x55e1
movq 0x8(%rsp), %rax
subq %r15, %rax
jmp 0x55f7
movq %r15, %r13
movq 0x20(%rsp), %r15
jmp 0x5489
cmpl $0x0, 0x20110(%rip)     # 0x2547c
je 0x61ad
movq 0x200f7(%rip), %rax     # 0x25470
cmpq $0x7, %rax
jbe 0x639d
leaq -0x8(%rax), %rcx
movq %rcx, 0x200f2(%rip)     # 0x25480
movq 0x200d3(%rip), %rcx     # 0x25468
movq -0x8(%rcx,%rax), %rax
movq %rax, 0xb0(%rsp)
jmp 0x6393
xorl %eax, %eax
movl %eax, %edx
movl $0x4, %r14d
movl $0x1, %r15d
movq 0x200b2(%rip), %rcx     # 0x25470
cmpq $0x4, %rcx
movq %r14, %rax
cmovbq %rcx, %rax
movq %rcx, %rdi
subq %rax, %rdi
movq 0x20092(%rip), %rsi     # 0x25468
addq %rsi, %rdi
movq %rdi, 0x20088(%rip)     # 0x25468
testq %rcx, %rcx
je 0x5422
movq %r15, %rdi
subq %rax, %rdi
movq %rsi, %rax
addq %rcx, %rax
movq %rdi, %rcx
leaq (%rax,%rcx), %rsi
shlq $0x8, %rdx
movq %rsi, 0x20065(%rip)     # 0x25468
movzbl -0x1(%rax,%rcx), %esi
orq %rdx, %rsi
movq %rcx, %rdi
incq %rdi
movq %rdi, %rcx
movq %rsi, %r12
movq %rsi, %rdx
cmpq $0x1, %rdi
jne 0x53f4
jmp 0x5425
movq %rdx, %r12
callq 0xadbc
movq %r12, %rdx
testq %rax, %rax
jne 0x53b7
movl %r12d, %eax
movl %eax, %esi
addq $-0x6, 0x20041(%rip)    # 0x25480
xorl %ecx, %ecx
movl %ecx, %edx
movl %ebx, %edi
callq 0x952d
callq 0x69a6
jmp 0x6288
movl (%rsp), %eax
cmpl $-0x1, %eax
je 0x6273
cmpl $0x0, (%rsp)
leaq 0x10ef8(%rip), %rax     # 0x16363
leaq 0x10f12(%rip), %rcx     # 0x16384
cmovsq %rax, %rcx
movq %rcx, %rdi
jmp 0x627a
xorl %eax, %eax
movl %eax, %r15d
movq %r15, %rbp
movq %r15, %r13
movq %rbx, %rdi
callq 0x3290
movq %r13, %rax
incq %rax
je 0x63de
cmpq %rbp, %rax
jbe 0x552e
movq %rax, %rdx
shrq $0x2, %rdx
addq %rax, %rdx
movl $0x3, %esi
movq %rdx, %rcx
cmpq $0x8, %rdx
jb 0x54db
movl $0x3, %edi
movq %rdx, %r8
movq %r8, %r9
shrq %r8
incq %rdi
movq %rdi, %rsi
movq %r8, %rcx
cmpq $0xf, %r9
ja 0x54c6
movq %rcx, %rdi
movl %esi, %ecx
movl $0x1, %esi
shlq %cl, %rsi
cmpq $0x7, %rdi
cmoveq %rsi, %rdx
cmpq $0x11, %rdx
movl $0x10, %ecx
cmovaeq %rdx, %rcx
cmpq %rax, %rcx
movq $-0x1, %rbx
cmovaq %rcx, %rbx
testq %r13, %r13
jne 0x5676
testq %r15, %r15
je 0x5676
movq %r15, %rdi
callq 0x3050
xorl %eax, %eax
movl %eax, %edi
jmp 0x5679
movq %r15, %rbx
jmp 0x5684
callq 0x8fd9
cmpl $0x0, 0x17e7e(%rip)     # 0x1d3c0
je 0x555f
addq $-0x3, 0x1ff34(%rip)    # 0x25480
movl (%rsp), %edi
movq 0x1ff32(%rip), %rdx     # 0x25488
xorl %ecx, %ecx
movl %ecx, %esi
callq 0x952d
cmpl $0x0, 0x90(%rsp)
je 0x558c
movl (%r14), %edi
movq 0x190(%rsp), %rsi
callq 0x3600
testl %eax, %eax
jne 0x64d2
movl $0x0, 0x90(%rsp)
movl 0x17c(%rsp), %r15d
testl %r15d, %r15d
je 0x544a
movl 0x180(%rsp), %ebp
movq 0x188(%rsp), %rbx
cmpl $0x21, %r15d
jne 0x6512
leaq 0x10e2c(%rip), %rdi     # 0x163e9
xorl %eax, %eax
movq %rbx, %rsi
callq 0x476b
testl %ebp, %ebp
je 0x55d3
movq %rbx, %rdi
callq 0x3050
xorl %edx, %edx
movl %edx, %esi
callq 0x98cc
jmp 0x544a
leaq 0x10cfe(%rip), %rdi     # 0x162e6
xorl %eax, %eax
movq %r12, %rsi
callq 0x476b
movq 0x8(%rsp), %rax
movq %rax, %rbx
testq %r15, %r15
je 0x6288
movq 0x17d4e(%rip), %rdi     # 0x1d358
xorl %edx, %edx
movl %edx, %eax
movl %edx, %esi
callq 0x3480
movl %eax, 0x17d35(%rip)     # 0x1d350
testl %eax, %eax
js 0x64f1
movl 0x17d4b(%rip), %ebp     # 0x1d374
testb $0x1, %bpl
jne 0x5633
xorl %eax, %eax
jmp 0x5655
movq 0x17d1e(%rip), %r14     # 0x1d358
movq %r14, %rdi
movl $0x2f, %esi
callq 0x3210
leaq 0x1(%rax), %rcx
testq %rax, %rax
cmoveq %r14, %rcx
movq %rcx, %rax
movq %rax, 0x17d44(%rip)     # 0x1d3a0
testb $0x2, %bpl
je 0x566c
movq 0x1f0(%rsp), %rax
jmp 0x566e
xorl %eax, %eax
movq %rbx, %r14
jmp 0x4c07
movq %r15, %rdi
movq %rbx, %rsi
callq 0x9af2
movq %rax, %rbx
movq 0x8(%rsp), %rdx
movb $0x0, (%rbx,%r13)
movq %rdx, %rbp
testq %rdx, %rdx
je 0x56c7
movq 0x17cbb(%rip), %rax     # 0x1d358
cmpb $0x2f, -0x1(%rax,%rdx)
movq %rdx, %rbp
je 0x56c7
leaq 0x17caa(%rip), %rdi     # 0x1d358
leaq 0x17cab(%rip), %rsi     # 0x1d360
leaq 0x10c0e(%rip), %rcx     # 0x162ca
callq 0x66d0
decq %rax
movq %rax, %rbp
cmpb $0x0, (%rbx)
je 0x57ec
xorl %eax, %eax
movl %eax, %r14d
movq %rbx, %r15
movq %r15, %rdi
callq 0x31a0
movq %rax, %r12
incq %r12
movq %r12, %rax
addq %rbp, %rax
jb 0x63de
cmpq 0x17c67(%rip), %rax     # 0x1d360
jbe 0x57a8
movq %rax, %r13
shrq $0x2, %r13
addq %rax, %r13
movl $0x3, %ecx
movq %r13, %rsi
cmpq $0x8, %r13
jb 0x5734
movl $0x3, %edi
movq %r13, %r8
movq %r8, %r9
shrq %r8
incq %rdi
movq %rdi, %rcx
movq %r8, %rsi
cmpq $0xf, %r9
ja 0x571f
movl $0x1, %edi
shlq %cl, %rdi
cmpq $0x7, %rsi
cmoveq %rdi, %r13
cmpq $0x11, %r13
movl $0x10, %ecx
cmovbq %rcx, %r13
cmpq %rax, %r13
movq $-0x1, %rax
cmovbeq %rax, %r13
testq %rbp, %rbp
jne 0x578b
movq 0x17bed(%rip), %rdi     # 0x1d358
testq %rdi, %rdi
je 0x5780
callq 0x3050
movq $0x0, 0x17bd8(%rip) # 0x1d358
movq $0x0, 0x17bd5(%rip) # 0x1d360
movq 0x17bc6(%rip), %rdi     # 0x1d358
movq %r13, %rsi
callq 0x9af2
movq %rax, 0x17bb7(%rip)     # 0x1d358
movq %r13, 0x17bb8(%rip)     # 0x1d360
movq 0x17ba9(%rip), %rdi     # 0x1d358
addq %rbp, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x3360
movq 0x17b94(%rip), %rdi     # 0x1d358
callq 0x47fd
movq %r15, %rdi
callq 0x31a0
leaq (%r14,%rax), %rcx
addq %rax, %r14
incq %r14
leaq (%rbx,%rcx), %r15
incq %r15
cmpb $0x0, (%r15)
jne 0x56d8
movq 0x17b65(%rip), %rax     # 0x1d358
movq 0x8(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq %rbx, %rdi
callq 0x3050
jmp 0x6288
xorl %eax, %eax
movq %rsi, %rdi
movl $0x241, %esi            # imm = 0x241
movl $0x180, %edx            # imm = 0x180
callq 0x3480
movl %eax, 0x17b31(%rip)     # 0x1d354
testb $0x1, %bl
jne 0x6288
cmpl $0x0, 0x17b21(%rip)     # 0x1d354
js 0x640f
cmpl $0x2, 0x17b30(%rip)     # 0x1d370
jge 0x5f91
cmpl $0x0, 0x17b7b(%rip)     # 0x1d3c8
je 0x58d9
movl $0x1, 0x90(%rsp)
xorl %eax, %eax
leaq 0xb0(%rsp), %rbx
movq %rax, 0xc8(%rbx)
movl $0x0, 0xd0(%rbx)
movq %rax, 0xd8(%rbx)
callq 0xe508
leaq 0x37de8(%rip), %r14     # 0x3d674
movl (%r14), %edi
callq 0x3110
movq %rax, 0xe0(%rbx)
movl (%r14), %edi
movq %rbx, %rsi
callq 0x3600
testl %eax, %eax
jne 0x6430
leaq 0xb0(%rsp), %rdi
callq 0x32f0
testl %eax, %eax
jne 0x5fa0
movl (%rsp), %eax
cmpl $0x8, %eax
jne 0x5f80
callq 0x7e55
jmp 0x5fa0
cmpl $0x2, 0x17b10(%rip)     # 0x1d3f0
jl 0x5f47
cmpq $0x0, 0x37c82(%rip)     # 0x3d570
jne 0x5a43
leaq 0xfa05(%rip), %r14      # 0x15300
xorl %eax, %eax
movl %eax, %ebx
movl $0x64a, %edx            # imm = 0x64A
movq %rbx, %rdi
movq %r14, %rsi
callq 0xddaf
movq %rax, 0x37c5a(%rip)     # 0x3d570
movq %rbx, 0x37c63(%rip)     # 0x3d580
leaq 0x37c5c(%rip), %rax     # 0x3d580
movq %rax, 0x37c4d(%rip)     # 0x3d578
movq $-0x1, %rdi
movl $0x64d, %edx            # imm = 0x64D
movq %r14, %rsi
callq 0xddaf
movq %rax, 0x37c42(%rip)     # 0x3d588
movq %rbx, 0x37c43(%rip)     # 0x3d590
movq 0x17aa4(%rip), %r12     # 0x1d3f8
movl 0x17a96(%rip), %eax     # 0x1d3f0
leal 0x3(%rax,%rax), %ebp
movl $0x5b2, %r15d           # imm = 0x5B2
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xddaf
movq %rax, 0x37baf(%rip)     # 0x3d528
movq %rbx, 0x37bb0(%rip)     # 0x3d530
movq %r12, 0x37bb1(%rip)     # 0x3d538
movl %ebp, 0x37bb3(%rip)     # 0x3d540
movl $0x0, 0x37bad(%rip)     # 0x3d544
movq 0x17a5a(%rip), %rax     # 0x1d3f8
movq %rax, %rcx
shrq $0x4, %rax
movl $0x8000, %r12d          # imm = 0x8000
addq %r12, %rcx
movq %rcx, %r13
addq %rax, %r13
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xddaf
movq %rax, 0x37bcf(%rip)     # 0x3d598
movq %rbx, 0x37bd0(%rip)     # 0x3d5a0
movq %r13, 0x37bd1(%rip)     # 0x3d5a8
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
movq %r13, 0x37bcc(%rip)     # 0x3d5b0
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xddaf
movq %rax, 0x37b4f(%rip)     # 0x3d548
movq %rbx, 0x37b50(%rip)     # 0x3d550
movq %r12, 0x37b51(%rip)     # 0x3d558
movq %r13, 0x37b52(%rip)     # 0x3d560
movq 0x179e3(%rip), %r12     # 0x1d3f8
shrq $0xb, %r12
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xddaf
movq %rax, 0x37b8a(%rip)     # 0x3d5b8
movq %rbx, 0x37b8b(%rip)     # 0x3d5c0
movq %r12, 0x37b8c(%rip)     # 0x3d5c8
movq %r13, 0x37b8d(%rip)     # 0x3d5d0
leaq 0x66ae(%rip), %rdi      # 0xc0f8
leaq 0xf8af(%rip), %rbp      # 0x15300
xorl %eax, %eax
movl %eax, %r14d
movl $0x82d, %ecx            # imm = 0x82D
movq %r14, %rsi
movq %rbp, %rdx
callq 0xe100
movq %rax, 0x37ab3(%rip)     # 0x3d520
leaq 0x37ab4(%rip), %rdi     # 0x3d528
callq 0xc4c5
movq %rax, %r15
movq %rax, %r12
movl 0x178cb(%rip), %edi     # 0x1d350
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
callq 0xaf4f
movq %rax, 0x18(%r15)
movq 0x8(%r15), %r15
movl $0x7ff, %esi            # imm = 0x7FF
movq %r14, %rax
movq %r14, %rbx
movq %r12, %rcx
movq %r14, %rdx
movq %r14, %r13
movl %esi, 0x4(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x18(%rsp)
movq %rbx, 0x80(%rsp)
movq %rax, %r12
xorl %eax, %eax
movl %eax, %r14d
movq %r14, %rdi
movl $0x40, %esi
callq 0x9af2
movq %rax, %rbx
movq %r14, %rdi
movq %rbp, %rsi
movl $0x83c, %edx            # imm = 0x83C
callq 0xddaf
movq %rbx, 0x38(%rsp)
movq %rax, 0x30(%rbx)
movq %r12, %rbx
testq %r12, %r12
jne 0x5b26
leaq 0x37a24(%rip), %rdi     # 0x3d528
callq 0xc4c5
movq %rax, %r14
movq %rax, %rbx
movl 0x1783b(%rip), %edi     # 0x1d350
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
callq 0xaf4f
movq %rax, 0x18(%r14)
movq %rbx, %r9
movq 0x38(%rsp), %r12
movq $0x0, 0x20(%r12)
cmpl $0x0, 0x178ae(%rip)     # 0x1d3ec
je 0x5b6e
movq 0x18(%rsp), %r8
movq 0x18(%r8), %r14
testq %r14, %r14
movl $0x0, %eax
je 0x5b70
testq %r13, %r13
movq %r9, 0x10(%rsp)
je 0x5b7f
xorl %ebx, %ebx
movl 0x4(%rsp), %edx
movq %r15, %rcx
movq %r13, %rax
jmp 0x5bfb
xorl %eax, %eax
movq %r9, %rbx
movl 0x4(%rsp), %ebp
movq %r13, %r14
jmp 0x5cf7
xorl %ebx, %ebx
movq 0x8(%r8), %rax
addq %rax, %r14
cmpq %r14, %r15
jae 0x5bdb
leaq 0x1(%r15), %r13
movq %r15, %rdx
movl 0x4(%rsp), %edi
movq %rdx, %r15
addl %edi, %edi
movzbl (%rdx), %ecx
incq %r15
movl %edi, %ebp
andl $0xffe, %ebp            # imm = 0xFFE
xorl %ecx, %ebp
cmpl $0x7ff, %ebp            # imm = 0x7FF
jne 0x5bc6
movq %r13, %rsi
subq %rax, %rsi
movq %r12, %rdi
callq 0xc601
movq %r15, %rax
incq %r13
movq %rax, %rcx
movq %r15, %rdx
movl %ebp, %edi
movq %r15, %rsi
cmpq %r14, %r15
jb 0x5b98
jmp 0x5be5
movl 0x4(%rsp), %ebp
movq %r15, %rsi
movq %rax, %rcx
subq %rcx, %rsi
movq 0x10(%rsp), %r9
movq 0x8(%r9), %rcx
movl %ebp, %edx
movq %rsi, %rax
movq 0x18(%rsp), %r8
movq 0x18(%r9), %rsi
movq 0x10(%r8), %rdi
subq 0x18(%r8), %rdi
cmpq %rsi, %rdi
movq %rdi, %r14
cmovaeq %rsi, %r14
movq 0x8(%r9), %rsi
addq %rsi, %r14
cmpq %r14, %rcx
jae 0x5c78
leaq 0x1(%rcx), %r13
movq %rcx, %rdi
movl %edx, %r9d
movl %r9d, %ebp
movq %rdi, %r15
movq %rsi, %rcx
addl %r9d, %ebp
movzbl (%rdi), %edx
incq %r15
andl $0xffe, %ebp            # imm = 0xFFE
xorl %edx, %ebp
cmpl $0x7ff, %ebp            # imm = 0x7FF
jne 0x5c5f
subq %rcx, %rax
movq %rax, %rsi
addq %r13, %rsi
movq %r12, %rdi
callq 0xc601
movl %ebx, %eax
movq %r15, %rcx
movq %rcx, %rsi
incq %r13
movq %rax, %rdx
movq %r15, %rdi
movl %ebp, %r9d
movq %r15, %r8
cmpq %r14, %r15
jb 0x5c27
jmp 0x5c83
movl %edx, %ebp
movq %rcx, %r8
movq %rsi, %rcx
movq %rax, %rdx
movq %rdx, %r14
movq %rcx, %r15
movq %r8, %r13
xorl %eax, %eax
movl %eax, %esi
movq %r12, %rdi
callq 0xc601
movq 0x20(%r12), %rax
movq 0x18(%rax), %rax
cmpq $0x1, %rax
cmoveq %r13, %r15
movq 0x10(%rsp), %rbx
movq 0x8(%rbx), %rsi
subq %rsi, %r15
je 0x5eab
movq 0x18(%rsp), %r14
movq 0x8(%r14), %rdi
addq 0x18(%r14), %rdi
movq %r15, %rdx
callq 0x3360
addq %r15, 0x18(%r14)
movq 0x8(%rbx), %rdi
movq 0x18(%rbx), %rdx
leaq (%rdi,%r15), %rsi
subq %r15, %rdx
callq 0x3490
subq %r15, 0x18(%rbx)
subq %r15, %r13
xorl %eax, %eax
movq %rax, %r14
movq %r13, %r15
movq %r14, %rsi
movq %rbx, %rdx
movq %rax, %r13
movq 0x18(%rsp), %rbx
movq %rbx, 0x10(%r12)
movq 0x18(%rdx), %r14
xorl %eax, %eax
testq %r14, %r14
setne %cl
movb %cl, %al
movl %eax, 0x8(%r12)
movq 0x80(%rsp), %rcx
movq %rcx, 0x18(%r12)
movq %rsi, 0x68(%rsp)
movq %r15, 0x60(%rsp)
movl %ebp, 0x34(%rsp)
movq %rdx, 0x58(%rsp)
je 0x5d74
cmpl $0x0, 0x176ae(%rip)     # 0x1d3f4
movq 0x28(%rsp), %r15
je 0x5d6f
cmpq $0x8000, 0x18(%rbx)     # imm = 0x8000
setae %al
testq %rcx, %rcx
sete %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x5d7e
movq %rbx, %rdi
callq 0xc746
jmp 0x5de4
movq %rcx, %rbx
jmp 0x5de4
movq %rcx, %rbx
movq 0x28(%rsp), %r15
jmp 0x5de4
leaq 0x377c3(%rip), %rdi     # 0x3d548
callq 0xc4c5
movq %rax, %r15
movq %rax, 0x48(%rsp)
movq %rbx, %rbp
movl $0x8000, %ebx           # imm = 0x8000
subq 0x18(%rbp), %rbx
movq 0x8(%rax), %rdi
movq 0x18(%r12), %rax
movq 0x18(%rax), %rcx
subq %rbx, %rcx
movq %rcx, %rsi
addq 0x8(%rax), %rsi
movq %rbx, %rdx
callq 0x3360
addq 0x8(%r15), %rbx
movq 0x8(%rbp), %rsi
movq 0x18(%rbp), %rdx
movq %rbx, %rdi
callq 0x3360
movl $0x8000, %eax           # imm = 0x8000
movq %rax, 0x18(%r15)
movq 0x28(%rsp), %r15
movq 0x48(%rsp), %rbx
movq %r15, (%r12)
movslq 0x37779(%rip), %rax     # 0x3d568
cmpq %rax, %r15
leaq 0xf507(%rip), %rbp      # 0x15300
jl 0x5e28
cmpl 0x175ef(%rip), %eax     # 0x1d3f0
jge 0x5e28
xorl %eax, %eax
movl %eax, %esi
leaq 0x699c(%rip), %rdi      # 0xc7aa
movq %rbp, %rdx
movl $0x8b5, %ecx            # imm = 0x8B5
callq 0xe100
leaq 0xf4de(%rip), %rbp      # 0x15300
incl 0x37740(%rip)           # 0x3d568
incq %r15
movq 0x3773e(%rip), %rdi     # 0x3d570
movq %rbp, %rsi
movl $0x8ba, %edx            # imm = 0x8BA
callq 0xdf23
movq 0x38(%rsp), %rax
addq $0x38, %rax
movq $0x0, 0x38(%r12)
movq 0x37720(%rip), %rcx     # 0x3d578
movq %r12, (%rcx)
movq %rax, 0x37716(%rip)     # 0x3d578
movq 0x37707(%rip), %rdi     # 0x3d570
movl $0x1, %esi
movl $0x1, %edx
movq %rbp, %rcx
movl $0x8be, %r8d            # imm = 0x8BE
callq 0xdf81
movq %r13, %rax
movq 0x58(%rsp), %rdi
movq %rdi, %rcx
movq %r15, %rdx
movl 0x34(%rsp), %esi
movq 0x60(%rsp), %r15
movq 0x68(%rsp), %r13
testq %r14, %r14
jne 0x5aae
jmp 0x5f53
xorl %ecx, %ecx
movq %rcx, %rdx
cmpq $0x1, %rax
je 0x5f25
testq %r14, %r14
movl %ebp, %esi
je 0x5f19
movq 0x10(%rsp), %rbp
cmpq $0x0, 0x18(%rbp)
je 0x5f38
leaq 0x37658(%rip), %rdi     # 0x3d528
movl %esi, 0x30(%rsp)
callq 0xc4c5
movq %rax, %r15
movq %rax, 0x40(%rsp)
movq 0x8(%rax), %rdi
movq 0x18(%rsp), %rbx
movq 0x18(%rbx), %rax
subq %r14, %rax
movq %rax, %rsi
addq 0x8(%rbx), %rsi
movq %r14, %rdx
callq 0x3360
movq %r14, 0x18(%r15)
subq %r14, 0x18(%rbx)
movq %rbp, %rax
movq 0x40(%rsp), %rbx
movl 0x30(%rsp), %ebp
jmp 0x5cf4
movq %rdx, %rax
movq 0x10(%rsp), %rbx
movl %esi, %ebp
jmp 0x5f2d
movq %rdx, %rax
movq 0x10(%rsp), %rbx
movq %r13, %r15
movq %rcx, %r14
jmp 0x5cf7
xorl %eax, %eax
movq %rax, %r14
movq %rbp, %rbx
movl %esi, %ebp
jmp 0x5cf4
xorl %edi, %edi
callq 0x9b82
jmp 0x6064
callq 0xd224
movq 0x375c1(%rip), %rdi     # 0x3d520
leaq 0xf39a(%rip), %rsi      # 0x15300
movl $0x8c4, %edx            # imm = 0x8C4
callq 0xe280
movq $0x0, 0x375a5(%rip) # 0x3d520
jmp 0x6064
movl (%rsp), %eax
cmpl $0x101, %eax            # imm = 0x101
jne 0x5f9b
callq 0x8fd9
jmp 0x5fa0
callq 0x36f5
jmp 0x5846
callq 0x9b14
cmpl $0x0, 0x90(%rsp)
je 0x5fcd
movl (%r14), %edi
movq 0x190(%rsp), %rsi
callq 0x3600
testl %eax, %eax
jne 0x646e
movl $0x0, 0x90(%rsp)
movl 0x17c(%rsp), %r15d
testl %r15d, %r15d
je 0x6064
movl 0x180(%rsp), %ebp
movq 0x188(%rsp), %rbx
cmpl $0x21, %r15d
jne 0x648d
leaq 0x103eb(%rip), %rdi     # 0x163e9
xorl %eax, %eax
movq %rbx, %rsi
callq 0x476b
testl %ebp, %ebp
je 0x6014
movq %rbx, %rdi
callq 0x3050
xorl %edx, %edx
movl %edx, %esi
callq 0x98cc
movl 0x17331(%rip), %edi     # 0x1d354
cmpl $-0x1, %edi
je 0x6064
cmpl $0x1, %edi
je 0x6064
callq 0x3270
movl $0xffffffff, 0x17318(%rip) # imm = 0xFFFFFFFF
movq 0x17325(%rip), %rdi     # 0x1d368
callq 0x3080
movq 0x17319(%rip), %rdi     # 0x1d368
testq %rdi, %rdi
je 0x6064
callq 0x3050
movq $0x0, 0x17304(%rip) # 0x1d368
cmpl $0x2, 0x17305(%rip)     # 0x1d370
jl 0x6089
movq 0x16f7c(%rip), %rbx     # 0x1cff0
movq (%rbx), %rsi
movl $0xa, %edi
callq 0x3310
movq (%rbx), %rdi
callq 0x33e0
callq 0x69a6
movl 0x172c0(%rip), %edi     # 0x1d354
cmpl $-0x1, %edi
je 0x6255
cmpl $0x1, %edi
je 0x6255
cmpl $-0x1, %edi
je 0x60c2
cmpl $0x0, 0x172d2(%rip)     # 0x1d384
je 0x60c2
callq 0x34c0
cmpl $-0x1, %eax
je 0x6592
movl 0x1728c(%rip), %edi     # 0x1d354
callq 0x3270
testl %eax, %eax
jne 0x640f
movl $0xffffffff, 0x17275(%rip) # imm = 0xFFFFFFFF
cmpl $0x0, 0x1726a(%rip)     # 0x1d350
je 0x620b
movq 0x17265(%rip), %rdi     # 0x1d358
movq 0x1726e(%rip), %rbx     # 0x1d368
leaq 0xb0(%rsp), %rsi
callq 0x31b0
testl %eax, %eax
jne 0x6175
movl 0xc8(%rsp), %esi
movl %esi, %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x8000, %eax           # imm = 0x8000
jne 0x6175
andl $0xfff, %esi            # imm = 0xFFF
movq %rbx, %rdi
callq 0x3450
movl 0xcc(%rsp), %esi
movl 0xd0(%rsp), %edx
movq %rbx, %rdi
callq 0x3420
movq 0xf8(%rsp), %rax
movq 0x108(%rsp), %rcx
leaq 0x90(%rsp), %rsi
movq %rax, (%rsi)
xorl %eax, %eax
movq %rax, 0x8(%rsi)
movq %rcx, 0x10(%rsi)
movq %rax, 0x18(%rsi)
movq %rbx, %rdi
callq 0x3300
cmpl $0x0, 0x17200(%rip)     # 0x1d37c
jne 0x620b
cmpq $0x2, 0x1a8(%rsp)
movq 0x171c6(%rip), %rsi     # 0x1d358
jb 0x6203
cmpl $0x0, 0x171e5(%rip)     # 0x1d380
jne 0x6203
leaq 0x102f4(%rip), %rdi     # 0x16498
xorl %eax, %eax
callq 0x476b
jmp 0x620b
movl 0x1719d(%rip), %edi     # 0x1d350
movq $-0x8, %rsi
movl $0x2, %edx
callq 0x3560
movq 0x1f2b5(%rip), %r13     # 0x25480
cmpq $-0x1, %rax
je 0x62a9
subq %r13, %rax
addq 0x1f291(%rip), %rax     # 0x25470
movq %rax, 0x1f29a(%rip)     # 0x25480
movl 0x17164(%rip), %edi     # 0x1d350
leaq 0xb0(%rsp), %rsi
movl $0x8, %edx
callq 0xaf4f
jmp 0x6393
movq %rsi, %rdi
callq 0x3080
cmpl $0x0, 0x171b6(%rip)     # 0x1d3c8
je 0x6255
movb 0x1715a(%rip), %cl      # 0x1d374
shrb %cl
movq 0x171e5(%rip), %rax     # 0x1d408
testq %rax, %rax
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x6255
movq 0x17131(%rip), %rdi     # 0x1d368
leaq 0xb0(%rsp), %rsi
movq %rax, (%rsi)
xorl %ecx, %ecx
movq %rcx, 0x8(%rsi)
movq %rax, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
callq 0x3300
movq 0x1710c(%rip), %rdi     # 0x1d368
testq %rdi, %rdi
je 0x6288
callq 0x3050
movq $0x0, 0x170f7(%rip) # 0x1d368
jmp 0x6288
leaq 0x100d6(%rip), %rdi     # 0x16350
movq 0x170d7(%rip), %rsi     # 0x1d358
xorl %eax, %eax
callq 0x476b
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
movq %r12, %rsi
movq %r15, %rdx
callq 0x67d8
jmp 0x6288
movq 0x1f1c0(%rip), %rax     # 0x25470
movq %rax, 0x50(%rsp)
movl $0x8, %ebp
leaq 0xb0(%rsp), %r14
movq 0x1f1a7(%rip), %rax     # 0x25470
cmpq $0x8, %rax
movq %rbp, %r12
cmovbq %rax, %r12
subq %r12, %rax
movq %rax, %rsi
addq 0x1f187(%rip), %rsi     # 0x25468
movq %r14, %rdi
movq %r12, %rdx
callq 0x3360
callq 0xadbc
movq 0x1f178(%rip), %r15     # 0x25470
cmpq $0x8000, %r15           # imm = 0x8000
je 0x62c2
cmpq $0x7, %r15
ja 0x6362
leaq (%r15,%r12), %rax
cmpq $0x7, %rax
jbe 0x639d
testq %r15, %r15
je 0x6376
cmpq $0x8, %rax
je 0x6347
leaq (%rsp,%r12), %rax
addq $0xb0, %rax
movl $0x8, %edx
subq %r15, %rdx
leaq (%r15,%rax), %rsi
addq $-0x8, %rsi
leaq 0xb0(%rsp), %rdi
callq 0x3360
subq %r15, %r14
addq $0x8, %r14
movq 0x1f113(%rip), %rsi     # 0x25468
movq %r14, %rdi
movq %r15, %rdx
callq 0x3360
jmp 0x6376
movq 0x1f0ff(%rip), %rax     # 0x25468
movq -0x8(%rax,%r15), %rax
movq %rax, 0xb0(%rsp)
movq 0x1f103(%rip), %rax     # 0x25480
movq 0x50(%rsp), %rcx
subq %r13, %rcx
addq %rcx, %rax
addq $-0x8, %rax
movq %rax, 0x1f0ed(%rip)     # 0x25480
cmpq $0x1, 0x1f0e5(%rip)     # 0x25480
ja 0x63b0
movq 0x16fb4(%rip), %rsi     # 0x1d358
leaq 0x10119(%rip), %rdi     # 0x164c4
jmp 0x501e
movl 0xb0(%rsp), %eax
movl 0xb4(%rsp), %ecx
movl %eax, %esi
movl %ecx, %edx
jmp 0x4c95
leaq 0xb0(%rsp), %rbx
movq %rbx, %rdi
callq 0x3670
movb (%rbx), %bl
jmp 0x52ec
leaq 0x100d6(%rip), %rsi     # 0x164bb
xorl %eax, %eax
movl %eax, %edx
movl $0x22, %edi
callq 0xe575
movq 0x16f5e(%rip), %rdx     # 0x1d358
leaq 0xfe13(%rip), %rsi      # 0x16214
xorl %eax, %eax
movl %eax, %ecx
movl $0x21, %edi
callq 0xe575
callq 0x3070
movl (%rax), %ebx
movq 0x16f4b(%rip), %r14     # 0x1d368
movl %ebx, %edi
callq 0x35a0
leaq 0x1004c(%rip), %rsi     # 0x16477
jmp 0x65ae
leaq 0xee99(%rip), %rdi      # 0x152d0
leaq 0xeec2(%rip), %rsi      # 0x15300
leaq 0xff67(%rip), %rcx      # 0x163ac
movl $0x104d, %edx           # imm = 0x104D
callq 0x3220
leaq 0xee7a(%rip), %rdi      # 0x152d0
leaq 0xeea3(%rip), %rsi      # 0x15300
leaq 0xff48(%rip), %rcx      # 0x163ac
movl $0xfe7, %edx            # imm = 0xFE7
callq 0x3220
leaq 0xee5b(%rip), %rdi      # 0x152d0
leaq 0xee84(%rip), %rsi      # 0x15300
leaq 0xff29(%rip), %rcx      # 0x163ac
movl $0x1055, %edx           # imm = 0x1055
callq 0x3220
movl 0x178(%rsp), %r13d
movl 0x184(%rsp), %r12d
callq 0xe508
movl (%r14), %edi
callq 0x3110
testq %rax, %rax
jne 0x6553
leaq 0xff07(%rip), %rdi      # 0x163c1
leaq 0xee3f(%rip), %rsi      # 0x15300
leaq 0xfee4(%rip), %rcx      # 0x163ac
movl $0x1057, %edx           # imm = 0x1057
callq 0x3220
leaq 0xedf7(%rip), %rdi      # 0x152d0
leaq 0xee20(%rip), %rsi      # 0x15300
leaq 0xfec5(%rip), %rcx      # 0x163ac
movl $0xff2, %edx            # imm = 0xFF2
callq 0x3220
callq 0x3070
movl (%rax), %ebx
movq 0x16e59(%rip), %r14     # 0x1d358
movl %ebx, %edi
callq 0x35a0
leaq 0xfe06(%rip), %rsi      # 0x16313
jmp 0x65ae
movl 0x178(%rsp), %r13d
movl 0x184(%rsp), %r12d
callq 0xe508
movl (%r14), %edi
callq 0x3110
testq %rax, %rax
jne 0x6553
leaq 0xfe86(%rip), %rdi      # 0x163c1
leaq 0xedbe(%rip), %rsi      # 0x15300
leaq 0xfe63(%rip), %rcx      # 0x163ac
movl $0xff4, %edx            # imm = 0xFF4
callq 0x3220
movl (%r14), %edi
callq 0x3110
movl %r13d, 0xc8(%rax)
movl %r15d, 0xcc(%rax)
movl %ebp, 0xd0(%rax)
movl %r12d, 0xd4(%rax)
movq %rbx, 0xd8(%rax)
movl (%r14), %edi
callq 0x3110
movq %rax, %rdi
movl $0x1, %esi
callq 0x3470
callq 0x3070
movl (%rax), %ebx
movq 0x16dc8(%rip), %r14     # 0x1d368
movl %ebx, %edi
callq 0x35a0
leaq 0x104f9(%rip), %rsi     # 0x16aa7
xorl %ecx, %ecx
movl %ecx, %r8d
movl %ecx, %r9d
movl %ebx, %edi
movq %r14, %rdx
movq %rax, %rcx
movl %r9d, %eax
callq 0xe575