// File: /workspace/github_c_makefile_star2_O2/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 $0x238, %rsp            # imm = 0x238
movq %rdi, %r13
movl $0xffffffff, 0x4(%rsp)  # imm = 0xFFFFFFFF
testq %rdi, %rdi
je 0x45b7
movq 0x17e81(%rip), %rax     # 0x1c358
movq %rax, %r15
cmpq %r13, %rax
je 0x4500
leaq 0x17e72(%rip), %rdi     # 0x1c358
leaq 0x17e73(%rip), %rsi     # 0x1c360
xorl %eax, %eax
movl %eax, %edx
movq %r13, %rcx
callq 0x5e46
movq 0x17e58(%rip), %r15     # 0x1c358
movq %r15, %rdi
callq 0x31a0
movq %rax, %r14
leaq 0x1a8(%rsp), %rsi
movq %r15, %rdi
callq 0x3160
testl %eax, %eax
je 0x49e9
movq %r13, 0x98(%rsp)
callq 0x3070
movl (%rax), %edx
movl %edx, %ecx
cmpl $0x2, %edx
jne 0x499d
movl 0x17e85(%rip), %ecx     # 0x1c3c8
orl 0x17e77(%rip), %ecx     # 0x1c3c0
je 0x49b3
movq %rax, %rbp
leaq 0x17807(%rip), %rbx     # 0x1bd60
leaq 0x17df8(%rip), %r15     # 0x1c358
leaq 0x17df9(%rip), %r12     # 0x1c360
leaq 0x1a8(%rsp), %r13
movq (%rbx), %rcx
testq %rcx, %rcx
je 0x49b3
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x5e46
andl $0x0, (%rbp)
movq 0x17dc4(%rip), %rdi     # 0x1c358
movq %r13, %rsi
callq 0x3160
movl (%rbp), %edx
testl %eax, %eax
je 0x499b
addq $0x8, %rbx
movl %edx, %ecx
cmpl $0x2, %edx
je 0x456f
jmp 0x499d
leaq 0x17d9a(%rip), %rdi     # 0x1c358
leaq 0x17d9b(%rip), %rsi     # 0x1c360
leaq 0x10c48(%rip), %rcx     # 0x15214
xorl %eax, %eax
movl %eax, %r14d
movq %r14, %rdx
callq 0x5e46
andl $0x0, 0x17d70(%rip)     # 0x1c350
andq $0x0, 0x17db8(%rip)     # 0x1c3a0
testb $0x2, 0x17d85(%rip)     # 0x1c374
movq %r14, %rax
je 0x4634
xorl %ebp, %ebp
leaq 0x1a8(%rsp), %rsi
movl %ebp, %edi
callq 0x3570
testl %eax, %eax
je 0x460d
movl %ebp, %eax
jmp 0x4631
movl $0xf000, %eax           # imm = 0xF000
andl 0x1c0(%rsp), %eax
cmpl $0x8000, %eax           # imm = 0x8000
jne 0x462f
movq 0x200(%rsp), %rax
xorl %ecx, %ecx
movl %ecx, %r14d
jmp 0x4634
xorl %eax, %eax
movq %rax, %r14
movq %rax, 0x17d7d(%rip)     # 0x1c3b8
cmpl $0x0, 0x17d7e(%rip)     # 0x1c3c0
setne %cl
movl 0x17d7d(%rip), %eax     # 0x1c3c8
cmpl $0x2, %eax
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x46c5
pxor %xmm0, %xmm0
andq $0x0, 0x1fe1c(%rip)     # 0x24480
movdqu %xmm0, 0x1fe04(%rip)    # 0x24470
orl $-0x1, 0x27e5d(%rip)    # 0x2c4d0
pushq $0x1
popq %rdi
callq 0x6127
movl %eax, %ebp
testl %eax, %eax
js 0x47e4
movl %ebp, %ebx
callq 0xab8a
movl 0x17cf6(%rip), %eax     # 0x1c388
cmpl $0x2, %eax
jl 0x48eb
callq 0xabde
movq 0x17d81(%rip), %rax     # 0x1c428
movq %rax, 0x1fdd2(%rip)     # 0x24480
movq 0x17d6b(%rip), %rsi     # 0x1c420
movq 0x17d74(%rip), %rdx     # 0x1c430
movl %ebx, %edi
xorl %ecx, %ecx
jmp 0x54b8
testl %eax, %eax
je 0x481a
pxor %xmm0, %xmm0
andq $0x0, 0x1fda7(%rip)     # 0x24480
movdqu %xmm0, 0x1fd8f(%rip)    # 0x24470
orl $-0x1, 0x27de8(%rip)    # 0x2c4d0
pushq $0x1
popq %rdi
callq 0x6127
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl $0x8, %eax
je 0x4752
movl 0x4(%rsp), %eax
cmpl $0x101, %eax            # imm = 0x101
je 0x4752
movl 0x4(%rsp), %eax
cmpl $-0x1, %eax
je 0x471e
movl 0x4(%rsp), %eax
cmpl $-0x2, %eax
jne 0x4b64
cmpl $0x0, 0x17c5b(%rip)     # 0x1c380
je 0x4b64
cmpl $0x0, 0x17c46(%rip)     # 0x1c378
je 0x4b64
cmpl $0x2, 0x17c89(%rip)     # 0x1c3c8
je 0x4b64
cmpl $0x0, 0x17c74(%rip)     # 0x1c3c0
jne 0x4b64
movl 0x17c70(%rip), %ecx     # 0x1c3c8
movl %ecx, %eax
cmpl $0x2, %ecx
jne 0x481c
movl $0x1, 0x30(%rsp)
leaq 0xc0(%rsp), %rbx
andq $0x0, 0xc8(%rbx)
andl $0x0, 0xd0(%rbx)
andq $0x0, 0xd8(%rbx)
callq 0xdcdc
leaq 0x37ede(%rip), %r14     # 0x3c674
movl (%r14), %edi
callq 0x3110
movq %rax, 0xe0(%rbx)
movl (%r14), %edi
movq %rbx, %rsi
callq 0x3600
testl %eax, %eax
jne 0x5b8a
leaq 0xc0(%rsp), %rdi
callq 0x32f0
testl %eax, %eax
jne 0x551d
movl 0x4(%rsp), %eax
cmpl $0x8, %eax
jne 0x54f3
callq 0x8090
jmp 0x551d
cmpl $-0x1, %ebp
leaq 0x10b6a(%rip), %rax     # 0x15358
leaq 0x10b76(%rip), %rcx     # 0x1536b
cmoveq %rax, %rcx
cmpl $-0x6, %ebp
leaq 0x10b2e(%rip), %rdi     # 0x15331
cmovneq %rcx, %rdi
movq 0x17b4a(%rip), %rsi     # 0x1c358
xorl %eax, %eax
callq 0x4419
jmp 0x54bd
xorl %eax, %eax
testq %r13, %r13
je 0x4888
cmpl $0x0, 0x17b50(%rip)     # 0x1c378
jne 0x4888
movq 0x17b27(%rip), %r13     # 0x1c358
testl %eax, %eax
je 0x4b53
movq 0x17bd0(%rip), %rax     # 0x1c410
testq %rax, %rax
setne %cl
andb 0x17b28(%rip), %cl      # 0x1c374
cmpb $0x1, %cl
jne 0x4bed
movq %rax, %r14
movq %r13, %rdi
callq 0x6028
movq %rax, %r12
subq %r13, %r12
movq %r14, %rdi
callq 0x6028
movq %rax, %r13
movq %rax, %rdi
callq 0x31a0
movq %rax, %r14
leaq 0x1167e(%rip), %rbx     # 0x15f01
jmp 0x4c19
xorl %eax, %eax
movl %eax, %edi
pushq $0x9
popq %rsi
callq 0x9db6
movq %rax, 0x17acd(%rip)     # 0x1c368
movabsq $0x3e74756f6474733c, %rcx # imm = 0x3E74756F6474733C
movq %rcx, (%rax)
movb $0x0, 0x8(%rax)
movl $0x1, 0x17a9e(%rip)     # 0x1c354
movl 0x17ac4(%rip), %eax     # 0x1c380
orl 0x17b06(%rip), %eax     # 0x1c3c8
jne 0x4ca6
pushq $0x1
popq %rdi
callq 0x30f0
testl %eax, %eax
je 0x4ca6
leaq 0x10b28(%rip), %rsi     # 0x15407
xorl %eax, %eax
movl %eax, %edx
pushq $0x16
popq %rdi
callq 0xdd45
cmpl $0x1, %eax
jne 0x4947
movl 0x17a5a(%rip), %edi     # 0x1c350
xorl %eax, %eax
movl %eax, %esi
pushq $0x2
popq %rdx
callq 0x3560
cmpq $-0x1, %rax
je 0x543d
movq %rax, 0x1fb6d(%rip)     # 0x24480
movl 0x17a37(%rip), %edi     # 0x1c350
pushq $-0x4
popq %rsi
pushq $0x2
popq %rdx
callq 0x3560
movl 0x17a26(%rip), %edi     # 0x1c350
leaq 0xc0(%rsp), %r14
pushq $0x4
popq %rdx
movq %r14, %rsi
callq 0xb1a7
movl (%r14), %eax
bswapl %eax
jmp 0x54a8
cmpl $0x101, %ebp            # imm = 0x101
jne 0x53b3
movl 0x179f7(%rip), %edi     # 0x1c350
xorl %eax, %eax
movl %eax, %esi
pushq $0x2
popq %rdx
callq 0x3560
movq %rax, %rcx
cmpq $-0x1, %rax
jne 0x497f
callq 0xb020
testq %rax, %rax
jne 0x496e
movq 0x1fb01(%rip), %rcx     # 0x24480
addq $-0x3, %rcx
movq %rcx, 0x1faf6(%rip)     # 0x24480
xorl %ecx, %ecx
movl %ecx, %edx
movl $0x101, %edi            # imm = 0x101
movq %rdx, %rsi
jmp 0x54b8
movl %edx, %ecx
testl %ecx, %ecx
je 0x49d2
cmpl $0x4b, %ecx
je 0x5b51
cmpl $0x1b, %ecx
je 0x5b51
movq 0x1799e(%rip), %rax     # 0x1c358
movb $0x0, (%rax,%r14)
movq 0x17992(%rip), %rsi     # 0x1c358
leaq 0x10884(%rip), %rdi     # 0x15251
jmp 0x58d3
movq 0x1797f(%rip), %rdi     # 0x1c358
callq 0x31a0
movq %rax, %r14
movq 0x98(%rsp), %r13
movl $0xf000, %eax           # imm = 0xF000
andl 0x1c0(%rsp), %eax
movl %eax, %ecx
addl $0xfffff000, %ecx       # imm = 0xFFFFF000
shrl $0xc, %ecx
cmpl $0x9, %ecx
ja 0x4afb
movl $0x289, %edx            # imm = 0x289
btl %ecx, %edx
jae 0x4afb
movl %eax, %ecx
xorl $0xa000, %ecx           # imm = 0xA000
movl 0x1795b(%rip), %edx     # 0x1c380
movl %ecx, %esi
orl %edx, %esi
movl 0x17949(%rip), %ecx     # 0x1c378
orl %ecx, %esi
je 0x4a56
cmpl $0x4000, %eax           # imm = 0x4000
jne 0x4a69
cmpl $0x0, 0x1794f(%rip)     # 0x1c390
jne 0x4a69
movq 0x1790e(%rip), %rsi     # 0x1c358
leaq 0x10865(%rip), %rdi     # 0x152b6
jmp 0x58d3
movq 0x178fb(%rip), %rsi     # 0x1c358
leaq 0x10832(%rip), %rdi     # 0x15296
jmp 0x58d3
cmpl $0x4000, %eax           # imm = 0x4000
jne 0x4b0e
andq $0x0, 0xc0(%rsp)
andq $0x0, 0x30(%rsp)
movq 0x178ce(%rip), %rdi     # 0x1c358
callq 0x3180
testq %rax, %rax
je 0x58da
movq %rax, %rbx
xorl %eax, %eax
movl %eax, %r12d
leaq 0xc0(%rsp), %r15
leaq 0x30(%rsp), %r13
movq %rbx, %rdi
callq 0x34a0
testq %rax, %rax
je 0x4b82
movzbl 0x13(%rax), %edx
testl %edx, %edx
je 0x4aad
cmpl $0x2e, %edx
jne 0x4ae1
movq %rax, %rcx
movzbl 0x14(%rax), %edx
testl %edx, %edx
je 0x4aad
cmpl $0x2e, %edx
jne 0x4ae1
cmpb $0x0, 0x15(%rcx)
je 0x4aad
movq %rax, %rcx
addq $0x13, %rcx
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x5e46
movq %rax, %r12
jmp 0x4aad
movq 0x17856(%rip), %rsi     # 0x1c358
leaq 0x10764(%rip), %rdi     # 0x1526d
jmp 0x58d3
movl 0x178ac(%rip), %eax     # 0x1c3c0
movl %edx, %esi
orl %eax, %esi
movl 0x178aa(%rip), %edx     # 0x1c3c8
orl %edx, %esi
movq 0x17831(%rip), %r15     # 0x1c358
je 0x535d
xorl $0x1, %edx
orl %ecx, %edx
orl %eax, %edx
jne 0x5388
movq %r15, %rdi
callq 0x5f11
testq %rax, %rax
je 0x5959
subq %rax, %r14
jmp 0x5388
movq 0x1783e(%rip), %rbx     # 0x1c398
xorl %ecx, %ecx
movl %ecx, %r12d
jmp 0x4c19
callq 0x6044
movl 0x4(%rsp), %eax
cmpl $-0x6, %eax
jne 0x54c7
leaq 0x107b4(%rip), %rdi     # 0x15331
jmp 0x58cc
movq %rbx, %rdi
callq 0x3290
leaq 0x11370(%rip), %rcx     # 0x15f01
leaq 0xc0(%rsp), %rdi
leaq 0x30(%rsp), %rsi
movq %r12, %rdx
callq 0x5e46
testq %r14, %r14
je 0x55ad
movq 0x177a2(%rip), %rax     # 0x1c358
cmpb $0x2f, -0x1(%rax,%r14)
movq %r14, %r15
je 0x55b2
leaq 0x1778c(%rip), %rdi     # 0x1c358
leaq 0x1778d(%rip), %rsi     # 0x1c360
leaq 0x106f8(%rip), %rcx     # 0x152d2
movq %r14, %rdx
callq 0x5e46
movq %rax, %r15
decq %r15
jmp 0x55b2
leaq (%r14,%r13), %rdi
leaq 0x10617(%rip), %rsi     # 0x1520f
callq 0x3320
testl %eax, %eax
leaq 0x10841(%rip), %rax     # 0x15447
leaq 0x112f4(%rip), %rcx     # 0x15f01
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 0x9db6
movq %rax, %r15
movq %rax, 0x17729(%rip)     # 0x1c368
movq 0x17712(%rip), %rsi     # 0x1c358
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, 0x17707(%rip)     # 0x1c380
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, 0x176b6(%rip)     # 0x1c354
testl %eax, %eax
js 0x52f1
cmpl $0x2, 0x176c3(%rip)     # 0x1c370
jge 0x562d
cmpl $0x0, 0x1770e(%rip)     # 0x1c3c8
je 0x4d41
movl $0x1, 0x30(%rsp)
leaq 0xc0(%rsp), %rbx
andq $0x0, 0xc8(%rbx)
andl $0x0, 0xd0(%rbx)
andq $0x0, 0xd8(%rbx)
callq 0xdcdc
leaq 0x37981(%rip), %r14     # 0x3c674
movl (%r14), %edi
callq 0x3110
movq %rax, 0xe0(%rbx)
movl (%r14), %edi
movq %rbx, %rsi
callq 0x3600
testl %eax, %eax
jne 0x5b6b
leaq 0xc0(%rsp), %rdi
callq 0x32f0
testl %eax, %eax
jne 0x565d
movl 0x4(%rsp), %eax
cmpl $0x8, %eax
jne 0x5424
callq 0x8090
jmp 0x565d
cmpl $0x2, 0x176a8(%rip)     # 0x1c3f0
jl 0x5351
cmpq $0x0, 0x3781a(%rip)     # 0x3c570
jne 0x4e26
leaq 0xf59d(%rip), %rbx      # 0x14300
xorl %eax, %eax
movl %eax, %edi
movl $0x64a, %edx            # imm = 0x64A
movq %rbx, %rsi
callq 0xd5df
andq $0x0, 0x37804(%rip)     # 0x3c580
movq %rax, 0x377ed(%rip)     # 0x3c570
leaq 0x377f6(%rip), %rax     # 0x3c580
movq %rax, 0x377e7(%rip)     # 0x3c578
pushq $-0x1
popq %rdi
movl $0x64d, %edx            # imm = 0x64D
movq %rbx, %rsi
callq 0xd5df
movq %rax, 0x377e0(%rip)     # 0x3c588
andq $0x0, 0x377e0(%rip)     # 0x3c590
movq 0x17641(%rip), %rsi     # 0x1c3f8
movl 0x17633(%rip), %eax     # 0x1c3f0
leal 0x3(,%rax,2), %edx
leaq 0x3775d(%rip), %rdi     # 0x3c528
callq 0xca3d
movq 0x17621(%rip), %rax     # 0x1c3f8
movq %rax, %rcx
shrq $0x4, %rcx
leaq (%rax,%rcx), %rsi
addq $0x8000, %rsi           # imm = 0x8000
leaq 0x377a8(%rip), %rdi     # 0x3c598
pushq $-0x1
popq %rbx
movl %ebx, %edx
callq 0xca3d
leaq 0x37747(%rip), %rdi     # 0x3c548
movl $0x8000, %esi           # imm = 0x8000
movl %ebx, %edx
callq 0xca3d
movq 0x175e4(%rip), %rsi     # 0x1c3f8
shrq $0xb, %rsi
leaq 0x37799(%rip), %rdi     # 0x3c5b8
movl %ebx, %edx
callq 0xca3d
leaq 0x6b70(%rip), %rdi      # 0xb99d
leaq 0xf4cc(%rip), %r13      # 0x14300
xorl %eax, %eax
movl %eax, %r14d
movl $0x82d, %ecx            # imm = 0x82D
movq %r14, %rsi
movq %r13, %rdx
callq 0xd940
movq %rax, 0x376d0(%rip)     # 0x3c520
leaq 0x376d1(%rip), %rdi     # 0x3c528
callq 0xbd62
movq %rax, %r15
movq %rax, %rbx
movl 0x174e8(%rip), %edi     # 0x1c350
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
callq 0xb1a7
movq %rax, 0x18(%r15)
movq 0x8(%r15), %r8
movl $0x7ff, %edi            # imm = 0x7FF
movq %r14, %rax
movq %r14, %rcx
movq %rbx, %rdx
movq %r14, %rsi
movq %r8, %rbx
movq %r14, %r15
movl %edi, %ebp
movq %rsi, 0x18(%rsp)
movq %rdx, 0x8(%rsp)
movq %rcx, 0x90(%rsp)
movq %rax, %r12
xorl %eax, %eax
movl %eax, %r14d
movq %r14, %rdi
pushq $0x40
popq %rsi
callq 0x9db6
movq %r13, %rsi
movq %rax, %r13
movq %r14, %rdi
movl $0x83c, %edx            # imm = 0x83C
callq 0xd5df
movq %r13, 0x28(%rsp)
movq %rax, 0x30(%r13)
movq %r12, %rax
testq %r12, %r12
jne 0x4f0b
leaq 0x37642(%rip), %rdi     # 0x3c528
callq 0xbd62
movq %rax, %r14
movq %rax, %r12
movl 0x17459(%rip), %edi     # 0x1c350
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
callq 0xb1a7
movq %rax, 0x18(%r14)
movq %r12, %rax
movq 0x28(%rsp), %r12
andq $0x0, 0x20(%r12)
movq %rax, %rdi
cmpl $0x0, 0x174cc(%rip)     # 0x1c3ec
je 0x4f4b
movq 0x8(%rsp), %r13
movq 0x18(%r13), %rax
testq %rax, %rax
movl $0x0, %ecx
je 0x4f55
testq %r15, %r15
movq %rdi, 0x10(%rsp)
je 0x4f5f
movq 0x8(%rdi), %rdx
movq %r15, %r14
jmp 0x4fcb
xorl %eax, %eax
movq %rdi, %rcx
jmp 0x511f
movl %ecx, %eax
movq %rdi, %rcx
jmp 0x5124
movq 0x8(%r13), %rcx
movq %rax, %r14
addq %rcx, %r14
movq %rbx, %rax
movq %rcx, %rbx
movq %rax, %rcx
subq %rbx, %rax
movl %ebp, %edx
movq %rcx, %rbx
movl %edx, %ecx
movq %rax, %rsi
cmpq %r14, %rbx
jae 0x4fbb
addl %ecx, %ecx
movzbl (%rbx), %eax
incq %rbx
movl %ecx, %ebp
andl $0xffe, %ebp            # imm = 0xFFE
xorl %eax, %ebp
incq %rsi
movq %rsi, %rax
movl %ebp, %edx
movq %rbx, %rcx
cmpl $0x7ff, %ebp            # imm = 0x7FF
jne 0x4f77
movq %r12, %rdi
callq 0xbe8a
movq 0x10(%rsp), %rdi
movq %rbx, %rax
jmp 0x4f6f
movq 0x8(%rdi), %rdx
movq 0x18(%r13), %rax
movq %rdx, %rbx
movl %ecx, %ebp
movq %rsi, %r14
movq 0x10(%r13), %rcx
subq %rax, %rcx
movq 0x18(%rdi), %rax
cmpq %rax, %rcx
movq %rcx, %r15
cmovaeq %rax, %r15
addq %rdx, %r15
movq %rbx, %rax
movq %rdx, %r13
movq %rax, %rdx
addq %r14, %rax
subq %r13, %rax
movl %ebp, %ecx
movq %rdx, %rbx
movl %ecx, %ebp
cmpq %r15, %rdx
jae 0x5039
movq %rax, %rsi
addl %ebp, %ebp
movzbl (%rbx), %eax
incq %rbx
andl $0xffe, %ebp            # imm = 0xFFE
xorl %eax, %ebp
incq %rsi
movq %rsi, %rax
movl %ebp, %ecx
movq %rbx, %rdx
cmpl $0x7ff, %ebp            # imm = 0x7FF
jne 0x4ff4
movq %r12, %rdi
callq 0xbe8a
xorl %eax, %eax
movl %eax, %r14d
movq %rbx, %rax
movq %rbx, %r13
jmp 0x4fe9
xorl %eax, %eax
movl %eax, %esi
movq %r12, %rdi
callq 0xbe8a
movq 0x10(%rsp), %rdx
movq 0x20(%r12), %rax
movq 0x18(%rax), %rax
cmpq $0x1, %rax
cmoveq %rbx, %r13
movq 0x8(%rdx), %rsi
movq %r13, %r15
subq %rsi, %r15
je 0x50ab
movq 0x8(%rsp), %r14
movq %rdx, %r13
movq 0x8(%r14), %rdi
addq 0x18(%r14), %rdi
movq %r15, %rdx
callq 0x3360
addq %r15, 0x18(%r14)
movq 0x8(%r13), %rdi
movq 0x18(%r13), %rdx
leaq (%rdi,%r15), %rsi
subq %r15, %rdx
callq 0x3490
subq %r15, 0x18(%r13)
subq %r15, %rbx
xorl %eax, %eax
movq %rax, %r15
movq %r13, %rcx
movq %r14, %r13
jmp 0x5124
xorl %ecx, %ecx
movl %ecx, %r15d
movq %r15, %rcx
cmpq $0x1, %rax
je 0x5112
testq %r14, %r14
je 0x5112
cmpq $0x0, 0x18(%rdx)
je 0x5117
leaq 0x3745c(%rip), %rdi     # 0x3c528
callq 0xbd62
movq %rax, %r13
movq %rax, 0x58(%rsp)
movq 0x8(%rax), %rdi
movq 0x8(%rsp), %r15
movq 0x18(%r15), %rax
subq %r14, %rax
movq %rax, %rsi
addq 0x8(%r15), %rsi
movq %r14, %rdx
callq 0x3360
movq %r14, 0x18(%r13)
subq %r14, 0x18(%r15)
movq 0x10(%rsp), %rax
movq 0x58(%rsp), %rcx
movq %r15, %r13
movq %r14, %r15
jmp 0x5124
movq %rcx, %rax
jmp 0x511c
xorl %eax, %eax
movq %rax, %r15
movq %rdx, %rcx
movq 0x8(%rsp), %r13
movq %rbx, %rsi
movl %ebp, %edi
movq %rcx, %r14
movq %rax, %r8
movq %r13, 0x10(%r12)
movq 0x18(%rcx), %rbp
xorl %eax, %eax
testq %rbp, %rbp
setne %cl
movb %cl, %al
movl %eax, 0x8(%r12)
movq 0x90(%rsp), %rbx
movq %rbx, 0x18(%r12)
movq %r15, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movl %edi, 0x24(%rsp)
movq %r8, 0x70(%rsp)
je 0x51a3
cmpl $0x0, 0x17281(%rip)     # 0x1c3f4
movq 0x18(%rsp), %r15
je 0x520d
cmpq $0x8000, 0x18(%r13)     # imm = 0x8000
setae %al
testq %rbx, %rbx
sete %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x51aa
movq %r13, %rdi
callq 0xbfd0
movq %r13, %rbx
jmp 0x520d
movq 0x18(%rsp), %r15
jmp 0x520d
leaq 0x37397(%rip), %rdi     # 0x3c548
callq 0xbd62
movq %rax, %r15
movq %rax, 0x60(%rsp)
movl $0x8000, %ebx           # imm = 0x8000
subq 0x18(%r13), %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(%r13), %rsi
movq 0x18(%r13), %rdx
movq %rbx, %rdi
callq 0x3360
movl $0x8000, %eax           # imm = 0x8000
movq %rax, 0x18(%r15)
movq 0x18(%rsp), %r15
movq 0x60(%rsp), %rbx
leaq 0xf0ec(%rip), %r13      # 0x14300
movq %r15, (%r12)
movslq 0x37349(%rip), %rax     # 0x3c568
cmpq %rax, %r15
jl 0x524a
cmpl 0x171c6(%rip), %eax     # 0x1c3f0
jge 0x524a
xorl %eax, %eax
movl %eax, %esi
leaq 0x6df9(%rip), %rdi      # 0xc030
movq %r13, %rdx
movl $0x8b5, %ecx            # imm = 0x8B5
callq 0xd940
incl 0x3731e(%rip)           # 0x3c568
incq %r15
movq 0x3731c(%rip), %rdi     # 0x3c570
movq %r13, %rsi
movl $0x8ba, %edx            # imm = 0x8BA
callq 0xd763
movq 0x28(%rsp), %rax
addq $0x38, %rax
andq $0x0, 0x38(%r12)
movq 0x37301(%rip), %rcx     # 0x3c578
movq %r12, (%rcx)
movq %rax, 0x372f7(%rip)     # 0x3c578
movq 0x372e8(%rip), %rdi     # 0x3c570
pushq $0x1
popq %rsi
pushq $0x1
popq %rdx
movq %r13, %rcx
movl $0x8be, %r8d            # imm = 0x8BE
callq 0xd7c1
movq 0x70(%rsp), %rax
movq %rbx, %rcx
movq %r14, %rdx
movq %r15, %rsi
movl 0x24(%rsp), %edi
movq 0x78(%rsp), %rbx
movq 0x80(%rsp), %r15
testq %rbp, %rbp
jne 0x4e94
movq %r14, %rdi
callq 0xc97f
movq 0x3724d(%rip), %rdi     # 0x3c520
leaq 0xf026(%rip), %rsi      # 0x14300
movl $0x8c4, %edx            # imm = 0x8C4
callq 0xda9f
andq $0x0, 0x37234(%rip)     # 0x3c520
jmp 0x5729
callq 0x3070
movq %rax, %rbx
cmpl $0x11, (%rax)
jne 0x5ae9
xorl %edi, %edi
callq 0x30f0
testl %eax, %eax
je 0x531a
cmpl $0x0, 0x1705c(%rip)     # 0x1c370
jne 0x5a3a
movq 0x17047(%rip), %rsi     # 0x1c368
leaq 0x10143(%rip), %rdi     # 0x1546b
xorl %eax, %eax
callq 0x4419
movq 0x17032(%rip), %rdi     # 0x1c368
testq %rdi, %rdi
je 0x54bd
callq 0x3050
andq $0x0, 0x1701c(%rip)     # 0x1c368
jmp 0x54bd
xorl %edi, %edi
callq 0x9e3f
jmp 0x5729
movq 0x17034(%rip), %r12     # 0x1c398
movq %r12, %rdi
callq 0x31a0
cmpq %rax, %r14
jb 0x5388
leaq (%r15,%r14), %rdi
subq %rax, %rdi
movq %r12, %rsi
callq 0x3320
testl %eax, %eax
je 0x596a
xorl %edx, %edx
movl %edx, %eax
movl %edx, %esi
movq %r15, %rdi
callq 0x3480
movl %eax, 0x16fb4(%rip)     # 0x1c350
testl %eax, %eax
js 0x5c3d
movl 0x16fca(%rip), %ebx     # 0x1c374
testb $0x1, %bl
jne 0x53f8
xorl %eax, %eax
jmp 0x5404
cmpl $0x0, 0x1f0c2(%rip)     # 0x2447c
je 0x5870
movq 0x1f0a9(%rip), %rax     # 0x24470
cmpq $0x7, %rax
jbe 0x5b27
leaq -0x8(%rax), %rcx
movq %rcx, 0x1f0a4(%rip)     # 0x24480
movq 0x1f085(%rip), %rdx     # 0x24468
movq -0x8(%rdx,%rax), %rax
movq %rax, 0xc0(%rsp)
movq %rcx, %rax
jmp 0x5b21
movq 0x16f59(%rip), %rdi     # 0x1c358
callq 0x6028
movq %rax, 0x16f95(%rip)     # 0x1c3a0
testb $0x2, %bl
je 0x541d
movq 0x200(%rsp), %rax
jmp 0x4634
xorl %eax, %eax
jmp 0x4634
movl 0x4(%rsp), %eax
cmpl $0x101, %eax            # imm = 0x101
jne 0x5658
callq 0x9272
jmp 0x565d
xorl %eax, %eax
movl %eax, %ecx
pushq $0x4
popq %r14
movq %rcx, %r15
movq 0x1f021(%rip), %rax     # 0x24470
cmpq $0x4, %rax
movq %r14, %rdx
cmovbq %rax, %rdx
subq %rdx, %rax
movq 0x1f004(%rip), %rcx     # 0x24468
leaq (%rcx,%rax), %rsi
movq %rsi, 0x1eff9(%rip)     # 0x24468
addq %rax, %rcx
incq %rcx
movq %rdx, %rax
subq $0x1, %rax
jb 0x5498
shlq $0x8, %r15
movq %rcx, 0x1efdf(%rip)     # 0x24468
movzbl -0x1(%rcx), %edx
orq %r15, %rdx
incq %rcx
movq %rdx, %r15
jmp 0x5478
callq 0xb020
movq %r15, %rcx
testq %rax, %rax
jne 0x5445
movl %r15d, %eax
movl %eax, %esi
addq $-0x6, 0x1efce(%rip)    # 0x24480
xorl %ecx, %ecx
movl %ecx, %edx
movl %ebx, %edi
callq 0x9806
callq 0x6044
jmp 0x58da
movl 0x4(%rsp), %eax
cmpl $-0x1, %eax
je 0x58c5
cmpl $0x0, 0x4(%rsp)
leaq 0xfe8b(%rip), %rax      # 0x1536b
leaq 0xfea5(%rip), %rcx      # 0x1538c
cmovsq %rax, %rcx
movq %rcx, %rdi
jmp 0x58cc
callq 0x9272
cmpl $0x0, 0x16ec1(%rip)     # 0x1c3c0
je 0x551d
addq $-0x3, 0x1ef77(%rip)    # 0x24480
movl 0x4(%rsp), %edi
movq 0x1ef74(%rip), %rdx     # 0x24488
xorl %ecx, %ecx
movl %ecx, %esi
callq 0x9806
cmpl $0x0, 0x30(%rsp)
je 0x5544
movl (%r14), %edi
movq 0x1a0(%rsp), %rsi
callq 0x3600
testl %eax, %eax
jne 0x5c1e
movl $0x0, 0x30(%rsp)
movl 0x18c(%rsp), %eax
testl %eax, %eax
je 0x54bd
movups 0x188(%rsp), %xmm0
movaps %xmm0, 0xb0(%rsp)
movq 0x198(%rsp), %rbx
cmpl $0x21, %eax
jne 0x5c5b
leaq 0xfe76(%rip), %rdi      # 0x153f1
xorl %eax, %eax
movq %rbx, %rsi
callq 0x4419
pshufd $0xee, 0xb0(%rsp), %xmm0 # xmm0 = mem[2,3,2,3]
movd %xmm0, %eax
testl %eax, %eax
je 0x559f
movq %rbx, %rdi
callq 0x3050
xorl %edx, %edx
movl %edx, %esi
callq 0x9b93
jmp 0x54bd
xorl %eax, %eax
movl %eax, %r15d
movq %r14, 0x88(%rsp)
movq 0xc0(%rsp), %rbx
xorl %eax, %eax
movl %eax, %r14d
leaq 0x16d8a(%rip), %r12     # 0x1c358
leaq 0x16d8b(%rip), %r13     # 0x1c360
cmpb $0x0, (%rbx,%r14)
je 0x560d
leaq (%rbx,%r14), %rbp
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %rbp, %rcx
callq 0x5e46
movq 0x16d60(%rip), %rdi     # 0x1c358
callq 0x44ab
movq %rbp, %rdi
callq 0x31a0
addq %rax, %r14
incq %r14
jmp 0x55d5
movq 0x16d44(%rip), %rax     # 0x1c358
movq 0x88(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq %rbx, %rdi
callq 0x3050
jmp 0x58da
movq 0x169bc(%rip), %rax     # 0x1bff0
movq (%rax), %rdi
movq 0x16d1a(%rip), %rdx     # 0x1c358
movq 0x16d23(%rip), %rcx     # 0x1c368
leaq 0xfe4a(%rip), %rsi      # 0x15496
xorl %eax, %eax
callq 0x3340
jmp 0x4cb3
callq 0x9dd6
cmpl $0x0, 0x30(%rsp)
je 0x5684
movl (%r14), %edi
movq 0x1a0(%rsp), %rsi
callq 0x3600
testl %eax, %eax
jne 0x5ba9
movl $0x0, 0x30(%rsp)
movl 0x18c(%rsp), %eax
testl %eax, %eax
je 0x5729
movups 0x188(%rsp), %xmm0
movaps %xmm0, 0xa0(%rsp)
movq 0x198(%rsp), %rbx
cmpl $0x21, %eax
jne 0x5be9
leaq 0xfd36(%rip), %rdi      # 0x153f1
xorl %eax, %eax
movq %rbx, %rsi
callq 0x4419
pshufd $0xee, 0xa0(%rsp), %xmm0 # xmm0 = mem[2,3,2,3]
movd %xmm0, %eax
testl %eax, %eax
je 0x56df
movq %rbx, %rdi
callq 0x3050
xorl %edx, %edx
movl %edx, %esi
callq 0x9b93
movl 0x16c66(%rip), %edi     # 0x1c354
cmpl $-0x1, %edi
je 0x5729
cmpl $0x1, %edi
je 0x5729
callq 0x3270
orl $-0x1, 0x16c50(%rip)    # 0x1c354
movq 0x16c5d(%rip), %rdi     # 0x1c368
callq 0x3080
movq 0x16c51(%rip), %rdi     # 0x1c368
testq %rdi, %rdi
je 0x5729
callq 0x3050
andq $0x0, 0x16c3f(%rip)     # 0x1c368
cmpl $0x2, 0x16c40(%rip)     # 0x1c370
jl 0x574c
movq 0x168b7(%rip), %rbx     # 0x1bff0
movq (%rbx), %rsi
pushq $0xa
popq %rdi
callq 0x3310
movq (%rbx), %rdi
callq 0x33e0
callq 0x6044
movl 0x16bfd(%rip), %edi     # 0x1c354
cmpl $-0x1, %edi
je 0x593e
cmpl $0x1, %edi
je 0x593e
cmpl $0x0, 0x16c14(%rip)     # 0x1c384
je 0x5786
callq 0x34c0
cmpl $-0x1, %eax
je 0x5c8c
movl 0x16bce(%rip), %edi     # 0x1c354
callq 0x3270
testl %eax, %eax
jne 0x5bc8
orl $-0x1, 0x16bba(%rip)    # 0x1c354
cmpl $0x0, 0x16baf(%rip)     # 0x1c350
je 0x58f4
movq 0x16baa(%rip), %rdi     # 0x1c358
movq 0x16bb3(%rip), %rbx     # 0x1c368
leaq 0xc0(%rsp), %rsi
callq 0x31b0
testl %eax, %eax
jne 0x582d
movl 0xd8(%rsp), %esi
movl %esi, %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x8000, %eax           # imm = 0x8000
jne 0x582d
andl $0xfff, %esi            # imm = 0xFFF
movq %rbx, %rdi
callq 0x3450
movl 0xdc(%rsp), %esi
movl 0xe0(%rsp), %edx
movq %rbx, %rdi
callq 0x3420
movq 0x108(%rsp), %rax
movq 0x118(%rsp), %rcx
leaq 0x30(%rsp), %rsi
movq %rax, (%rsi)
andq $0x0, 0x8(%rsi)
movq %rcx, 0x10(%rsi)
andq $0x0, 0x18(%rsi)
movq %rbx, %rdi
callq 0x3300
cmpl $0x0, 0x16b48(%rip)     # 0x1c37c
jne 0x58f4
cmpq $0x2, 0x1b8(%rsp)
movq 0x16b0e(%rip), %rsi     # 0x1c358
jb 0x58ec
cmpl $0x0, 0x16b29(%rip)     # 0x1c380
jne 0x58ec
leaq 0xfc3c(%rip), %rdi      # 0x154a0
xorl %eax, %eax
callq 0x4419
jmp 0x58f4
movl 0x16ada(%rip), %edi     # 0x1c350
pushq $-0x8
popq %rsi
pushq $0x2
popq %rdx
callq 0x3560
movq 0x1ebf8(%rip), %r13     # 0x24480
cmpq $-0x1, %rax
je 0x597c
subq %r13, %rax
addq 0x1ebd4(%rip), %rax     # 0x24470
movq %rax, 0x1ebdd(%rip)     # 0x24480
movl 0x16aa7(%rip), %edi     # 0x1c350
leaq 0xc0(%rsp), %rsi
pushq $0x8
popq %rdx
callq 0xb1a7
movq 0x1ebc0(%rip), %rax     # 0x24480
jmp 0x5b21
leaq 0xfa8c(%rip), %rdi      # 0x15358
movq 0x16a85(%rip), %rsi     # 0x1c358
xorl %eax, %eax
callq 0x4419
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rsi, %rdi
callq 0x3080
cmpl $0x0, 0x16acd(%rip)     # 0x1c3c8
je 0x593e
movb 0x16a71(%rip), %cl      # 0x1c374
shrb %cl
movq 0x16afc(%rip), %rax     # 0x1c408
testq %rax, %rax
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x593e
movq 0x16a48(%rip), %rdi     # 0x1c368
leaq 0xc0(%rsp), %rsi
movq %rax, (%rsi)
andq $0x0, 0x8(%rsi)
movq %rax, 0x10(%rsi)
andq $0x0, 0x18(%rsi)
callq 0x3300
movq 0x16a23(%rip), %rdi     # 0x1c368
testq %rdi, %rdi
je 0x58da
callq 0x3050
andq $0x0, 0x16a11(%rip)     # 0x1c368
jmp 0x58da
leaq 0xf98e(%rip), %rdi      # 0x152ee
xorl %eax, %eax
movq %r15, %rsi
jmp 0x58d5
xorl %eax, %eax
movq %r15, %rsi
movq %r12, %rdx
callq 0x5e82
jmp 0x58da
movq 0x1eaed(%rip), %rax     # 0x24470
pushq $0x8
popq %rbp
leaq 0xc0(%rsp), %r14
movq %rax, 0x68(%rsp)
cmpq $0x8, %rax
movq %rbp, %r12
cmovbq %rax, %r12
subq %r12, %rax
movq %rax, %rsi
addq 0x1eabd(%rip), %rsi     # 0x24468
movq %r14, %rdi
movq %r12, %rdx
callq 0x3360
callq 0xb020
movq 0x1eaae(%rip), %r15     # 0x24470
movl $0x8000, %eax           # imm = 0x8000
cmpq $0x8000, %r15           # imm = 0x8000
je 0x5993
cmpq $0x7, %r15
ja 0x5af0
leaq (%r15,%r12), %rax
cmpq $0x7, %rax
jbe 0x5b27
testq %r15, %r15
je 0x5b04
cmpq $0x8, %rax
je 0x5a1c
leaq (%rsp,%r12), %rax
addq $0xc0, %rax
subq %r15, %rbp
leaq (%r15,%rax), %rsi
addq $-0x8, %rsi
leaq 0xc0(%rsp), %rdi
movq %rbp, %rdx
callq 0x3360
subq %r15, %r14
addq $0x8, %r14
movq 0x1ea3e(%rip), %rsi     # 0x24468
movq %r14, %rdi
movq %r15, %rdx
callq 0x3360
jmp 0x5b04
pushq $0x1
popq %rbp
movq 0x165ac(%rip), %r15     # 0x1bff0
movq (%r15), %rdi
movq 0x1691a(%rip), %rdx     # 0x1c368
leaq 0xf9f7(%rip), %rsi      # 0x1544c
xorl %r14d, %r14d
movl %r14d, %eax
callq 0x3340
movq (%r15), %rdi
callq 0x33e0
movl $0x4801, %r15d          # imm = 0x4801
movl %r14d, %r12d
movl %ebp, %esi
movl %esi, %r13d
callq 0x3330
cmpl $0x1, %r13d
jne 0x5a9e
cmpl $0x9, %eax
je 0x5a8b
cmpl $0x20, %eax
jne 0x5a92
movl %r12d, %ecx
movl %ebp, %edx
jmp 0x5aa4
movl %eax, %ecx
andl $-0x21, %ecx
cmpl $0x59, %ecx
cmovel %ebp, %r12d
movl %r12d, %ecx
movl %r14d, %edx
incl %eax
movl %ecx, %r12d
movl %edx, %esi
cmpl $0xe, %eax
ja 0x5a73
btl %eax, %r15d
movl %ecx, %r12d
movl %edx, %esi
jae 0x5a73
testl %ecx, %ecx
je 0x531a
movq 0x1689e(%rip), %rdi     # 0x1c368
xorl %eax, %eax
movl $0x241, %esi            # imm = 0x241
movl $0x180, %edx            # imm = 0x180
callq 0x3480
movl %eax, 0x16873(%rip)     # 0x1c354
testl %eax, %eax
jns 0x4ca6
movl (%rbx), %ebx
jmp 0x5bcf
movq 0x1e971(%rip), %rax     # 0x24468
movq -0x8(%rax,%r15), %rax
movq %rax, 0xc0(%rsp)
movq 0x1e975(%rip), %rax     # 0x24480
movq 0x68(%rsp), %rcx
subq %r13, %rcx
addq %rcx, %rax
addq $-0x8, %rax
movq %rax, 0x1e95f(%rip)     # 0x24480
cmpq $0x1, %rax
ja 0x5b3a
movq 0x1682a(%rip), %rsi     # 0x1c358
leaq 0xf997(%rip), %rdi      # 0x154cc
jmp 0x480e
movl 0xc0(%rsp), %eax
movl 0xc4(%rsp), %ecx
movl %eax, %esi
movl %ecx, %edx
jmp 0x46bc
movq 0x16800(%rip), %rdx     # 0x1c358
leaq 0xf6bd(%rip), %rsi      # 0x1521c
xorl %eax, %eax
movl %eax, %ecx
pushq $0x21
popq %rdi
callq 0xdd45
leaq 0xe75e(%rip), %rdi      # 0x142d0
leaq 0xe787(%rip), %rsi      # 0x14300
leaq 0xf834(%rip), %rcx      # 0x153b4
movl $0x104d, %edx           # imm = 0x104D
callq 0x3220
leaq 0xe73f(%rip), %rdi      # 0x142d0
leaq 0xe768(%rip), %rsi      # 0x14300
leaq 0xf815(%rip), %rcx      # 0x153b4
movl $0xfe7, %edx            # imm = 0xFE7
callq 0x3220
leaq 0xe720(%rip), %rdi      # 0x142d0
leaq 0xe749(%rip), %rsi      # 0x14300
leaq 0xf7f6(%rip), %rcx      # 0x153b4
movl $0x1055, %edx           # imm = 0x1055
callq 0x3220
callq 0x3070
movl (%rax), %ebx
movq 0x16792(%rip), %r14     # 0x1c368
movl %ebx, %edi
callq 0x35a0
leaq 0xf89b(%rip), %rsi      # 0x1547f
jmp 0x5ca8
callq 0xdcdc
movl (%r14), %edi
callq 0x3110
testq %rax, %rax
jne 0x5cc0
leaq 0xf7c3(%rip), %rdi      # 0x153c9
leaq 0xe6f3(%rip), %rsi      # 0x14300
leaq 0xf7a0(%rip), %rcx      # 0x153b4
movl $0x1057, %edx           # imm = 0x1057
callq 0x3220
leaq 0xe6ab(%rip), %rdi      # 0x142d0
leaq 0xe6d4(%rip), %rsi      # 0x14300
leaq 0xf781(%rip), %rcx      # 0x153b4
movl $0xff2, %edx            # imm = 0xFF2
callq 0x3220
callq 0x3070
movl (%rax), %ebx
movq 0x1670d(%rip), %r14     # 0x1c358
movl %ebx, %edi
callq 0x35a0
leaq 0xf6c2(%rip), %rsi      # 0x1531b
jmp 0x5ca8
callq 0xdcdc
movl (%r14), %edi
callq 0x3110
testq %rax, %rax
jne 0x5cd2
leaq 0xf755(%rip), %rdi      # 0x153c9
leaq 0xe685(%rip), %rsi      # 0x14300
leaq 0xf732(%rip), %rcx      # 0x153b4
movl $0xff4, %edx            # imm = 0xFF4
callq 0x3220
callq 0x3070
movl (%rax), %ebx
movq 0x166ce(%rip), %r14     # 0x1c368
movl %ebx, %edi
callq 0x35a0
leaq 0xfe07(%rip), %rsi      # 0x15aaf
xorl %ecx, %ecx
movl %ecx, %r8d
movl %ecx, %r9d
movl %ebx, %edi
movq %r14, %rdx
movq %rax, %rcx
movl %r9d, %eax
callq 0xdd45
movl (%r14), %edi
callq 0x3110
movaps 0xa0(%rsp), %xmm0
jmp 0x5ce2
movl (%r14), %edi
callq 0x3110
movaps 0xb0(%rsp), %xmm0
movups %xmm0, 0xc8(%rax)
movq %rbx, 0xd8(%rax)
movl (%r14), %edi
callq 0x3110
pushq $0x1
popq %rsi
movq %rax, %rdi
callq 0x3470