// File: /workspace/github_c_makefile_star2_O3/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 $0x248, %rsp            # imm = 0x248
movq %rdi, %rbx
movl $0xffffffff, 0x4(%rsp)  # imm = 0xFFFFFFFF
testq %rdi, %rdi
je 0x4929
movq 0x18b0d(%rip), %r15     # 0x1d368
cmpq %rbx, %r15
je 0x49c8
movq %rbx, %rdi
callq 0x31a0
movq %rax, %r14
incq %r14
cmpq 0x18af7(%rip), %r14     # 0x1d370
jbe 0x49b3
movq %r14, %rax
shrq $0x2, %rax
addq %r14, %rax
movl $0x3, %edx
movq %rax, %rcx
cmpq $0x8, %rax
jb 0x48b4
movl $0x3, %esi
movq %rax, %rdi
movq %rdi, %r8
shrq %rdi
incq %rsi
movq %rsi, %rdx
movq %rdi, %rcx
cmpq $0xf, %r8
ja 0x489f
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 0x48fc
movq %r15, %rdi
callq 0x3050
movq $0x0, 0x18a6c(%rip) # 0x1d368
movq $0x0, 0x18a69(%rip) # 0x1d370
xorl %eax, %eax
movl %eax, %edi
movq %r12, %rsi
callq 0x9def
movq %rax, 0x18a4e(%rip)     # 0x1d368
movq %r12, 0x18a4f(%rip)     # 0x1d370
movq %rax, %rdi
jmp 0x49b6
cmpq $0x7, 0x18a3f(%rip)     # 0x1d370
movq 0x18a30(%rip), %rdi     # 0x1d368
ja 0x497d
testq %rdi, %rdi
je 0x494f
callq 0x3050
movq $0x0, 0x18a19(%rip) # 0x1d368
movq $0x0, 0x18a16(%rip) # 0x1d370
xorl %eax, %eax
movl %eax, %edi
movl $0x10, %esi
callq 0x9def
movq %rax, 0x189f9(%rip)     # 0x1d368
movq $0x10, 0x189f6(%rip) # 0x1d370
movq %rax, %rdi
movabsq $0x3e6e696474733c, %rax # imm = 0x3E6E696474733C
movq %rax, (%rdi)
movl $0x0, 0x189cc(%rip)     # 0x1d360
movq $0x0, 0x18a11(%rip) # 0x1d3b0
testb $0x2, 0x189de(%rip)     # 0x1d384
jne 0x4b6e
xorl %eax, %eax
jmp 0x4b89
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x3370
movq 0x189a0(%rip), %r15     # 0x1d368
movq %r15, %rdi
callq 0x31a0
movq %rax, %r14
movq %rax, %r12
leaq 0x1b8(%rsp), %rsi
movq %r15, %rdi
callq 0x3160
testl %eax, %eax
je 0x4b66
movq %r12, 0x78(%rsp)
movq %rbx, 0x88(%rsp)
callq 0x3070
movl (%rax), %edx
movl %edx, %ecx
cmpl $0x2, %edx
jne 0x570a
movl 0x189c5(%rip), %ecx     # 0x1d3d8
orl 0x189b7(%rip), %ecx     # 0x1d3d0
je 0x5720
movq %rax, %r15
leaq 0x18337(%rip), %rbx     # 0x1cd60
leaq 0x1b8(%rsp), %rbp
movq (%rbx), %r12
testq %r12, %r12
je 0x5720
movq %r12, %rdi
callq 0x31a0
movq %rax, %r13
incq %r13
movq %r13, %rax
addq %r14, %rax
jb 0x6417
cmpq 0x18912(%rip), %rax     # 0x1d370
jbe 0x4b19
movq %rax, %rbp
shrq $0x2, %rbp
addq %rax, %rbp
movl $0x3, %esi
movq %rbp, %rcx
cmpq $0x8, %rbp
jb 0x4a99
movl $0x3, %edi
movq %rbp, %r8
movq %r8, %r9
shrq %r8
incq %rdi
movq %rdi, %rsi
movq %r8, %rcx
cmpq $0xf, %r9
ja 0x4a84
movq %rcx, %rdi
movl %esi, %ecx
movl $0x1, %esi
shlq %cl, %rsi
cmpq $0x7, %rdi
cmoveq %rsi, %rbp
cmpq $0x11, %rbp
movl $0x10, %ecx
cmovbq %rcx, %rbp
cmpq %rax, %rbp
movq $-0x1, %rax
cmovbeq %rax, %rbp
movq 0x18898(%rip), %rdi     # 0x1d368
testq %r14, %r14
jne 0x4af9
testq %rdi, %rdi
je 0x4aea
callq 0x3050
movq $0x0, 0x1887e(%rip) # 0x1d368
movq $0x0, 0x1887b(%rip) # 0x1d370
xorl %eax, %eax
movl %eax, %edi
movq %rbp, %rsi
callq 0x9def
movq %rax, 0x18860(%rip)     # 0x1d368
movq %rbp, 0x18861(%rip)     # 0x1d370
leaq 0x1b8(%rsp), %rbp
jmp 0x4b20
movq 0x18848(%rip), %rax     # 0x1d368
movq %rax, %rdi
addq %r14, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x3370
movl $0x0, (%r15)
movq 0x18829(%rip), %rdi     # 0x1d368
movq %rbp, %rsi
callq 0x3160
movl (%r15), %edx
testl %eax, %eax
je 0x5708
addq $0x8, %rbx
movl %edx, %ecx
cmpl $0x2, %edx
je 0x4a31
jmp 0x570a
movq %r12, %rax
jmp 0x5757
xorl %ebp, %ebp
leaq 0x1b8(%rsp), %rsi
movl %ebp, %edi
callq 0x3580
testl %eax, %eax
je 0x4da8
movl %ebp, %eax
movq %rax, %r14
movq %rax, 0x18835(%rip)     # 0x1d3c8
cmpl $0x0, 0x18836(%rip)     # 0x1d3d0
setne %cl
movl 0x18835(%rip), %eax     # 0x1d3d8
cmpl $0x2, %eax
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x4c25
pxor %xmm0, %xmm0
movdqu %xmm0, 0x208c4(%rip)    # 0x25480
movq $0x0, 0x208c9(%rip) # 0x25490
movl $0xffffffff, 0x2890f(%rip) # imm = 0xFFFFFFFF
movl $0x1, %edi
callq 0x6a9b
movl %eax, %ebp
testl %eax, %eax
js 0x4d50
movl %ebp, %ebx
callq 0xabdd
movl 0x187a6(%rip), %eax     # 0x1d398
cmpl $0x2, %eax
jl 0x4dd1
callq 0xac31
movq 0x18831(%rip), %rax     # 0x1d438
movq %rax, 0x20882(%rip)     # 0x25490
movq 0x1881b(%rip), %rsi     # 0x1d430
movq 0x18824(%rip), %rdx     # 0x1d440
movl %ebx, %edi
xorl %ecx, %ecx
jmp 0x5b8c
testl %eax, %eax
je 0x4d86
pxor %xmm0, %xmm0
movdqu %xmm0, 0x20847(%rip)    # 0x25480
movq $0x0, 0x2084c(%rip) # 0x25490
movl $0xffffffff, 0x28892(%rip) # imm = 0xFFFFFFFF
movl $0x1, %edi
callq 0x6a9b
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl $0x8, %eax
je 0x4cba
movl 0x4(%rsp), %eax
cmpl $0x101, %eax            # imm = 0x101
je 0x4cba
movl 0x4(%rsp), %eax
cmpl $-0x1, %eax
je 0x4c86
movl 0x4(%rsp), %eax
cmpl $-0x2, %eax
jne 0x5a0d
cmpl $0x0, 0x18703(%rip)     # 0x1d390
je 0x5a0d
cmpl $0x0, 0x186ee(%rip)     # 0x1d388
je 0x5a0d
cmpl $0x2, 0x18731(%rip)     # 0x1d3d8
je 0x5a0d
cmpl $0x0, 0x1871c(%rip)     # 0x1d3d0
jne 0x5a0d
movl 0x18718(%rip), %eax     # 0x1d3d8
cmpl $0x2, %eax
jne 0x4e3b
movl $0x1, 0x90(%rsp)
xorl %eax, %eax
leaq 0xd0(%rsp), %rbx
movq %rax, 0xc8(%rbx)
movl $0x0, 0xd0(%rbx)
movq %rax, 0xd8(%rbx)
callq 0xe8a0
leaq 0x38982(%rip), %r14     # 0x3d684
movl (%r14), %edi
callq 0x3110
movq %rax, 0xe0(%rbx)
movl (%r14), %edi
movq %rbx, %rsi
callq 0x3610
testl %eax, %eax
jne 0x6467
leaq 0xd0(%rsp), %rdi
callq 0x32f0
testl %eax, %eax
jne 0x5bf1
movl 0x4(%rsp), %eax
cmpl $0x8, %eax
jne 0x5bc7
callq 0x80a1
jmp 0x5bf1
cmpl $-0x1, %ebp
leaq 0x115f6(%rip), %rax     # 0x16350
leaq 0x11602(%rip), %rcx     # 0x16363
cmoveq %rax, %rcx
cmpl $-0x6, %ebp
leaq 0x115ba(%rip), %rdi     # 0x16329
cmovneq %rcx, %rdi
movq 0x185ee(%rip), %rsi     # 0x1d368
xorl %eax, %eax
callq 0x479d
jmp 0x5b91
testq %rbx, %rbx
je 0x4eb9
cmpl $0x0, 0x185f2(%rip)     # 0x1d388
jne 0x4eb9
movq 0x185c5(%rip), %r13     # 0x1d368
jmp 0x4f22
movl $0xf000, %eax           # imm = 0xF000
andl 0x1d0(%rsp), %eax
cmpl $0x8000, %eax           # imm = 0x8000
jne 0x49ac
movq 0x210(%rsp), %rax
xorl %ecx, %ecx
movl %ecx, %r14d
jmp 0x4b8c
cmpl $0x1, %eax
jne 0x56b2
movl 0x18580(%rip), %edi     # 0x1d360
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x3570
cmpq $-0x1, %rax
je 0x5aee
movq %rax, 0x20691(%rip)     # 0x25490
movl 0x1855b(%rip), %edi     # 0x1d360
movq $-0x4, %rsi
movl $0x2, %edx
callq 0x3570
movl 0x18544(%rip), %edi     # 0x1d360
leaq 0xd0(%rsp), %r14
movl $0x4, %edx
movq %r14, %rsi
callq 0xb21f
movl (%r14), %eax
bswapl %eax
jmp 0x5b7c
testq %rbx, %rbx
je 0x4eb9
cmpl $0x0, 0x18541(%rip)     # 0x1d388
jne 0x4eb9
movq 0x18518(%rip), %r13     # 0x1d368
testl %eax, %eax
je 0x4f22
movq 0x185c1(%rip), %r15     # 0x1d420
testq %r15, %r15
setne %al
andb 0x18519(%rip), %al      # 0x1d384
cmpb $0x1, %al
jne 0x5d46
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 0x1204a(%rip), %rbx     # 0x16f01
jmp 0x4f2e
xorl %eax, %eax
movl %eax, %edi
movl $0x9, %esi
callq 0x9def
movq %rax, 0x184aa(%rip)     # 0x1d378
movabsq $0x3e74756f6474733c, %rcx # imm = 0x3E74756F6474733C
movq %rcx, (%rax)
movb $0x0, 0x8(%rax)
movl $0x1, 0x1847b(%rip)     # 0x1d364
movl 0x184a1(%rip), %eax     # 0x1d390
orl 0x184e3(%rip), %eax     # 0x1d3d8
jne 0x4fbb
movl $0x1, %edi
callq 0x30f0
testl %eax, %eax
je 0x4fbb
leaq 0x114eb(%rip), %rsi     # 0x163ff
xorl %eax, %eax
movl %eax, %edx
movl $0x16, %edi
callq 0xe90d
movq 0x1847f(%rip), %rbx     # 0x1d3a8
xorl %ecx, %ecx
movl %ecx, %r12d
movq %rbx, %rdi
callq 0x31a0
leaq (%r12,%r14), %rcx
leaq (%rax,%rcx), %rsi
incq %rsi
xorl %ebp, %ebp
movl %ebp, %edi
callq 0x9def
movq %rax, %r15
movq %rax, 0x18424(%rip)     # 0x1d378
movq 0x1840d(%rip), %rsi     # 0x1d368
movq %rax, %rdi
movq %r12, %rdx
callq 0x3370
addq %r15, %r12
movq %r12, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x3370
addq %r14, %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x30b0
xorl %eax, %eax
cmpl $0x0, 0x18402(%rip)     # 0x1d390
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 0x3490
movl %eax, 0x183b1(%rip)     # 0x1d364
testl %eax, %eax
js 0x59aa
cmpl $0x2, 0x183be(%rip)     # 0x1d380
jge 0x5f8e
cmpl $0x0, 0x18409(%rip)     # 0x1d3d8
je 0x505c
movl $0x1, 0x90(%rsp)
xorl %eax, %eax
leaq 0xd0(%rsp), %rbx
movq %rax, 0xc8(%rbx)
movl $0x0, 0xd0(%rbx)
movq %rax, 0xd8(%rbx)
callq 0xe8a0
leaq 0x38676(%rip), %r14     # 0x3d684
movl (%r14), %edi
callq 0x3110
movq %rax, 0xe0(%rbx)
movl (%r14), %edi
movq %rbx, %rsi
callq 0x3610
testl %eax, %eax
jne 0x6448
leaq 0xd0(%rsp), %rdi
callq 0x32f0
testl %eax, %eax
jne 0x5f9d
movl 0x4(%rsp), %eax
cmpl $0x8, %eax
jne 0x5ad5
callq 0x80a1
jmp 0x5f9d
cmpl $0x2, 0x1839d(%rip)     # 0x1d400
jl 0x5a2b
cmpq $0x0, 0x3850f(%rip)     # 0x3d580
jne 0x51c6
leaq 0x10282(%rip), %r14     # 0x15300
xorl %eax, %eax
movl %eax, %ebx
movl $0x64a, %edx            # imm = 0x64A
movq %rbx, %rdi
movq %r14, %rsi
callq 0xe13f
movq %rax, 0x384e7(%rip)     # 0x3d580
movq %rbx, 0x384f0(%rip)     # 0x3d590
leaq 0x384e9(%rip), %rax     # 0x3d590
movq %rax, 0x384da(%rip)     # 0x3d588
movq $-0x1, %rdi
movl $0x64d, %edx            # imm = 0x64D
movq %r14, %rsi
callq 0xe13f
movq %rax, 0x384cf(%rip)     # 0x3d598
movq %rbx, 0x384d0(%rip)     # 0x3d5a0
movq 0x18331(%rip), %r12     # 0x1d408
movl 0x18323(%rip), %eax     # 0x1d400
leal 0x3(%rax,%rax), %ebp
movl $0x5b2, %r15d           # imm = 0x5B2
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xe13f
movq %rax, 0x3843c(%rip)     # 0x3d538
movq %rbx, 0x3843d(%rip)     # 0x3d540
movq %r12, 0x3843e(%rip)     # 0x3d548
movl %ebp, 0x38440(%rip)     # 0x3d550
movl $0x0, 0x3843a(%rip)     # 0x3d554
movq 0x182e7(%rip), %rax     # 0x1d408
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 0xe13f
movq %rax, 0x3845c(%rip)     # 0x3d5a8
movq %rbx, 0x3845d(%rip)     # 0x3d5b0
movq %r13, 0x3845e(%rip)     # 0x3d5b8
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
movq %r13, 0x38459(%rip)     # 0x3d5c0
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xe13f
movq %rax, 0x383dc(%rip)     # 0x3d558
movq %rbx, 0x383dd(%rip)     # 0x3d560
movq %r12, 0x383de(%rip)     # 0x3d568
movq %r13, 0x383df(%rip)     # 0x3d570
movq 0x18270(%rip), %r12     # 0x1d408
shrq $0xb, %r12
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xe13f
movq %rax, 0x38417(%rip)     # 0x3d5c8
movq %rbx, 0x38418(%rip)     # 0x3d5d0
movq %r12, 0x38419(%rip)     # 0x3d5d8
movq %r13, 0x3841a(%rip)     # 0x3d5e0
leaq 0x730c(%rip), %rdi      # 0xc4d9
leaq 0x1012c(%rip), %r13     # 0x15300
xorl %eax, %eax
movl %eax, %r14d
movl $0x82d, %ecx            # imm = 0x82D
movq %r14, %rsi
movq %r13, %rdx
callq 0xe490
movq %rax, 0x38340(%rip)     # 0x3d530
leaq 0x38341(%rip), %rdi     # 0x3d538
callq 0xc8a6
movq %rax, %r15
movq %rax, %r12
movl 0x18158(%rip), %edi     # 0x1d360
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
callq 0xb21f
movq %rax, 0x18(%r15)
movq 0x8(%r15), %r15
movl $0x7ff, %ebp            # imm = 0x7FF
movq %r14, %rax
movq %r14, %rbx
movq %r12, %rcx
movq %r14, %rdx
movq %r14, %rsi
movq %rsi, 0x38(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x8(%rsp)
movq %rbx, 0x80(%rsp)
movq %rax, %r12
xorl %eax, %eax
movl %eax, %r14d
movq %r14, %rdi
movl $0x40, %esi
callq 0x9def
movq %rax, %rbx
movq %r14, %rdi
movq %r13, %rsi
movl $0x83c, %edx            # imm = 0x83C
callq 0xe13f
movq %rbx, 0x40(%rsp)
movq %rax, 0x30(%rbx)
movq %r12, %rbx
testq %r12, %r12
jne 0x52aa
leaq 0x382b0(%rip), %rdi     # 0x3d538
callq 0xc8a6
movq %rax, %r14
movq %rax, %rbx
movl 0x180c7(%rip), %edi     # 0x1d360
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdx
callq 0xb21f
movq %rax, 0x18(%r14)
movq 0x40(%rsp), %r12
movq $0x0, 0x20(%r12)
cmpl $0x0, 0x1813d(%rip)     # 0x1d3fc
je 0x52ea
movq 0x8(%rsp), %r13
movq 0x18(%r13), %rdi
testq %rdi, %rdi
movq 0x38(%rsp), %r14
je 0x52f6
testq %r14, %r14
je 0x52fd
movq 0x8(%rbx), %rsi
movl %ebp, %edx
movq %r15, %rcx
movq %r14, %rax
jmp 0x536f
xorl %eax, %eax
movq 0x38(%rsp), %r14
jmp 0x54d4
xorl %eax, %eax
jmp 0x54d9
movq 0x8(%r13), %rcx
leaq (%rcx,%rdi), %r14
cmpq %r14, %r15
jae 0x5360
leaq 0x1(%r15), %r13
movq %r15, %rdx
movl %ebp, %esi
movl %esi, %ebp
movq %rdx, %r15
movq %rcx, %rax
addl %esi, %ebp
movzbl (%rdx), %ecx
incq %r15
andl $0xffe, %ebp            # imm = 0xFFE
xorl %ecx, %ebp
cmpl $0x7ff, %ebp            # imm = 0x7FF
jne 0x5344
movq %r13, %rsi
subq %rax, %rsi
movq %r12, %rdi
callq 0xc9e2
movq %r15, %rax
incq %r13
movq %rax, %rcx
movq %r15, %rdx
movl %ebp, %esi
cmpq %r14, %r15
jb 0x5313
movq 0x8(%rsp), %r13
movq 0x18(%r13), %rdi
movq %rax, %rcx
subq %rcx, %r15
movq 0x8(%rbx), %rsi
movq %rsi, %rcx
movl %ebp, %edx
movq %r15, %rax
movq 0x10(%r13), %r8
subq %rdi, %r8
movq 0x18(%rbx), %rdi
cmpq %rdi, %r8
movq %r8, %r14
cmovaeq %rdi, %r14
addq %rsi, %r14
cmpq %r14, %rcx
jae 0x53e7
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 0x53ce
subq %rcx, %rax
movq %rax, %rsi
addq %r13, %rsi
movq %r12, %rdi
callq 0xc9e2
xorl %eax, %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 0x5396
jmp 0x53f2
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 0xc9e2
movq 0x20(%r12), %rax
movq 0x18(%rax), %rax
cmpq $0x1, %rax
cmoveq %r13, %r15
movq 0x8(%rbx), %rsi
subq %rsi, %r15
je 0x545f
movq 0x8(%rsp), %r14
movq 0x8(%r14), %rdi
addq 0x18(%r14), %rdi
movq %r15, %rdx
callq 0x3370
addq %r15, 0x18(%r14)
movq 0x8(%rbx), %rdi
movq 0x18(%rbx), %rdx
leaq (%rdi,%r15), %rsi
subq %r15, %rdx
callq 0x34a0
subq %r15, 0x18(%rbx)
subq %r15, %r13
xorl %eax, %eax
movq %rax, %r14
movq %r13, %r15
jmp 0x54d4
xorl %ecx, %ecx
movq %rcx, %rdx
cmpq $0x1, %rax
movl $0x0, %eax
je 0x54cb
testq %r14, %r14
je 0x54cb
cmpq $0x0, 0x18(%rbx)
je 0x5457
leaq 0x380b6(%rip), %rdi     # 0x3d538
callq 0xc8a6
movq %rax, %r15
movq %rax, 0x48(%rsp)
movq 0x8(%rax), %rdi
movq 0x8(%rsp), %rcx
movq 0x18(%rcx), %rax
subq %r14, %rax
movq %rax, %rsi
addq 0x8(%rcx), %rsi
movq %r14, %rdx
callq 0x3370
movq %r14, 0x18(%r15)
movq 0x8(%rsp), %rcx
subq %r14, 0x18(%rcx)
movq %rbx, %rax
movq 0x48(%rsp), %rbx
movq %r13, %r15
movq %rcx, %r13
jmp 0x54d9
movq %rdx, %rax
movq %r13, %r15
movq %rcx, %r14
movq 0x8(%rsp), %r13
movq %r14, %rsi
movq %rbx, %rdx
movq %rax, %r8
movq %r13, 0x10(%r12)
movq 0x18(%rbx), %r14
xorl %eax, %eax
testq %r14, %r14
setne %cl
movb %cl, %al
movl %eax, 0x8(%r12)
movq 0x80(%rsp), %rbx
movq %rbx, 0x18(%r12)
movq %rsi, 0x70(%rsp)
movq %r15, 0x68(%rsp)
movl %ebp, 0x34(%rsp)
movq %r8, 0x60(%rsp)
je 0x5556
cmpl $0x0, 0x17ee1(%rip)     # 0x1d404
movq 0x20(%rsp), %r15
movq %rdx, %rbp
je 0x55c3
cmpq $0x8000, 0x18(%r13)     # imm = 0x8000
setae %al
testq %rbx, %rbx
sete %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x5560
movq %r13, %rdi
callq 0xcb28
movq %r13, %rbx
jmp 0x55c3
movq %rdx, %rbp
movq 0x20(%rsp), %r15
jmp 0x55c3
leaq 0x37ff1(%rip), %rdi     # 0x3d558
callq 0xc8a6
movq %rax, %r15
movq %rax, 0x50(%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 0x3370
addq 0x8(%r15), %rbx
movq 0x8(%r13), %rsi
movq 0x18(%r13), %rdx
movq %rbx, %rdi
callq 0x3370
movl $0x8000, %eax           # imm = 0x8000
movq %rax, 0x18(%r15)
movq 0x20(%rsp), %r15
movq 0x50(%rsp), %rbx
movq %r15, (%r12)
movslq 0x37faa(%rip), %rax     # 0x3d578
cmpq %rax, %r15
leaq 0xfd28(%rip), %r13      # 0x15300
jl 0x5607
cmpl 0x17e20(%rip), %eax     # 0x1d400
jge 0x5607
xorl %eax, %eax
movl %eax, %esi
leaq 0x759f(%rip), %rdi      # 0xcb8c
movq %r13, %rdx
movl $0x8b5, %ecx            # imm = 0x8B5
callq 0xe490
leaq 0xfcff(%rip), %r13      # 0x15300
incl 0x37f71(%rip)           # 0x3d578
incq %r15
movq 0x37f6f(%rip), %rdi     # 0x3d580
movq %r13, %rsi
movl $0x8ba, %edx            # imm = 0x8BA
callq 0xe2b3
movq 0x40(%rsp), %rax
addq $0x38, %rax
movq $0x0, 0x38(%r12)
movq 0x37f51(%rip), %rcx     # 0x3d588
movq %r12, (%rcx)
movq %rax, 0x37f47(%rip)     # 0x3d588
movq 0x37f38(%rip), %rdi     # 0x3d580
movl $0x1, %esi
movl $0x1, %edx
movq %r13, %rcx
movl $0x8be, %r8d            # imm = 0x8BE
callq 0xe311
movq 0x60(%rsp), %rax
movq %rbp, %rdi
movq %rbp, %rcx
movq %r15, %rdx
movl 0x34(%rsp), %ebp
movq 0x68(%rsp), %r15
movq 0x70(%rsp), %rsi
testq %r14, %r14
jne 0x5231
callq 0xd5bf
movq 0x37e9f(%rip), %rdi     # 0x3d530
leaq 0xfc68(%rip), %rsi      # 0x15300
movl $0x8c4, %edx            # imm = 0x8C4
callq 0xe610
movq $0x0, 0x37e83(%rip) # 0x3d530
jmp 0x6075
cmpl $0x101, %ebp            # imm = 0x101
jne 0x5a5a
movl 0x17c9c(%rip), %edi     # 0x1d360
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x3570
movq %rax, %rcx
cmpq $-0x1, %rax
jne 0x56ec
callq 0xb08c
testq %rax, %rax
jne 0x56db
movq 0x1fda4(%rip), %rcx     # 0x25490
addq $-0x3, %rcx
movq %rcx, 0x1fd99(%rip)     # 0x25490
xorl %ecx, %ecx
movl %ecx, %edx
movl $0x101, %edi            # imm = 0x101
movq %rdx, %rsi
jmp 0x5b8c
movl %edx, %ecx
testl %ecx, %ecx
je 0x5743
cmpl $0x4b, %ecx
je 0x642c
cmpl $0x1b, %ecx
je 0x642c
movq 0x17c41(%rip), %rax     # 0x1d368
movq 0x78(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq 0x17c31(%rip), %rsi     # 0x1d368
leaq 0x10b0b(%rip), %rdi     # 0x16249
jmp 0x622f
movq 0x17c1e(%rip), %rdi     # 0x1d368
callq 0x31a0
movq 0x88(%rsp), %rbx
movq %rax, %rbp
movl $0xf000, %eax           # imm = 0xF000
andl 0x1d0(%rsp), %eax
movl %eax, %ecx
addl $0xfffff000, %ecx       # imm = 0xFFFFF000
shrl $0xc, %ecx
cmpl $0x9, %ecx
ja 0x5963
movl $0x289, %edx            # imm = 0x289
btl %ecx, %edx
jae 0x5963
movl %eax, %ecx
xorl $0xa000, %ecx           # imm = 0xA000
movl 0x17bfa(%rip), %edx     # 0x1d390
movl %ecx, %esi
orl %edx, %esi
movl 0x17be8(%rip), %ecx     # 0x1d388
orl %ecx, %esi
je 0x57c7
cmpl $0x4000, %eax           # imm = 0x4000
jne 0x57da
cmpl $0x0, 0x17bee(%rip)     # 0x1d3a0
jne 0x57da
movq 0x17bad(%rip), %rsi     # 0x1d368
leaq 0x10aec(%rip), %rdi     # 0x162ae
jmp 0x622f
movq 0x17b9a(%rip), %rsi     # 0x1d368
leaq 0x10ab9(%rip), %rdi     # 0x1628e
jmp 0x622f
cmpl $0x4000, %eax           # imm = 0x4000
jne 0x5976
movq 0x17b7c(%rip), %rdi     # 0x1d368
callq 0x3180
testq %rax, %rax
je 0x6236
movq %rax, %rbx
movq %rax, %rdi
callq 0x34b0
testq %rax, %rax
movq %rbp, 0x28(%rsp)
je 0x5d2f
xorl %ecx, %ecx
movq %rcx, %rdx
movq %rcx, %r15
movq %rax, %rcx
movq %r15, %rbp
movq %rdx, %r14
movq %r15, 0x18(%rsp)
movq %rcx, %r12
movzbl 0x13(%r12), %eax
testl %eax, %eax
je 0x5852
cmpl $0x2e, %eax
jne 0x5867
movzbl 0x14(%r12), %eax
testl %eax, %eax
je 0x5852
cmpl $0x2e, %eax
jne 0x5867
cmpb $0x0, 0x15(%r12)
jne 0x5867
movq %rbx, %rdi
callq 0x34b0
movq %rax, %r12
testq %rax, %rax
jne 0x582c
jmp 0x5a9f
movq %r14, 0x10(%rsp)
movq %r12, %r15
addq $0x13, %r15
movq %r15, %rdi
callq 0x31a0
movq %rax, %r13
incq %r13
movq %r13, %r14
movq 0x18(%rsp), %r9
addq %r9, %r14
jb 0x6417
cmpq %rbp, %r14
jbe 0x5903
movq %r14, %rbp
shrq $0x2, %rbp
addq %r14, %rbp
movl $0x3, %ecx
movq %rbp, %rdx
cmpq $0x8, %rbp
jb 0x58cc
movl $0x3, %esi
movq %rbp, %rdi
movq %rdi, %r8
shrq %rdi
incq %rsi
movq %rsi, %rcx
movq %rdi, %rdx
cmpq $0xf, %r8
ja 0x58b7
movl $0x1, %esi
shlq %cl, %rsi
cmpq $0x7, %rdx
cmoveq %rsi, %rbp
cmpq $0x11, %rbp
movl $0x10, %eax
cmovbq %rax, %rbp
cmpq %r14, %rbp
movq $-0x1, %rax
cmovbeq %rax, %rbp
testq %r9, %r9
je 0x590a
movq 0x10(%rsp), %rdi
jmp 0x591d
movq 0x10(%rsp), %r12
jmp 0x592d
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x5919
callq 0x3050
xorl %eax, %eax
movl %eax, %edi
movq %rbp, %rsi
callq 0x9def
movq %rax, %r12
movq 0x18(%rsp), %r9
movq %r9, %rdi
addq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x3370
movq %rbx, %rdi
callq 0x34b0
movq %rax, %rcx
movq %r14, %r15
movq %r12, %rdx
movq %r12, %rsi
movq %rbp, %r12
testq %rax, %rax
jne 0x5821
jmp 0x5aaa
movq 0x179fe(%rip), %rsi     # 0x1d368
leaq 0x108f4(%rip), %rdi     # 0x16265
jmp 0x622f
movl 0x17a54(%rip), %eax     # 0x1d3d0
movl %edx, %esi
orl %eax, %esi
movl 0x17a52(%rip), %edx     # 0x1d3d8
orl %edx, %esi
movq 0x179d9(%rip), %r15     # 0x1d368
je 0x5a37
xorl $0x1, %edx
orl %ecx, %edx
orl %eax, %edx
je 0x5c87
movq %rbx, %r13
jmp 0x5a52
callq 0x3070
movq %rax, %rbx
cmpl $0x11, (%rax)
jne 0x63af
xorl %edi, %edi
callq 0x30f0
testl %eax, %eax
je 0x59d3
cmpl $0x0, 0x179b3(%rip)     # 0x1d380
jne 0x6395
movq 0x1799e(%rip), %rsi     # 0x1d378
leaq 0x10a82(%rip), %rdi     # 0x16463
xorl %eax, %eax
callq 0x479d
movq 0x17989(%rip), %rdi     # 0x1d378
testq %rdi, %rdi
je 0x5b91
callq 0x3050
movq $0x0, 0x17970(%rip) # 0x1d378
jmp 0x5b91
callq 0x69a6
movl 0x4(%rsp), %eax
cmpl $-0x6, %eax
jne 0x5b9b
leaq 0x10903(%rip), %rdi     # 0x16329
jmp 0x6228
xorl %edi, %edi
callq 0x9e7f
jmp 0x6075
movq %rbx, %r13
movq 0x17967(%rip), %r12     # 0x1d3a8
movq %r12, %rdi
callq 0x31a0
cmpq %rax, %rbp
jae 0x5ca3
movq %rbp, %rbx
jmp 0x5cbd
cmpl $0x0, 0x1fa2b(%rip)     # 0x2548c
je 0x61c4
movq 0x1fa12(%rip), %rax     # 0x25480
cmpq $0x7, %rax
jbe 0x63ed
leaq -0x8(%rax), %rcx
movq %rcx, 0x1fa0d(%rip)     # 0x25490
movq 0x1f9ee(%rip), %rdx     # 0x25478
movq -0x8(%rdx,%rax), %rax
movq %rax, 0xd0(%rsp)
movq %rcx, %rax
jmp 0x63e7
movq %r14, %rsi
movq %rbp, %r12
movq 0x18(%rsp), %r14
movq %rsi, %r15
movq %rbx, %rdi
callq 0x3290
cmpq $-0x1, %r14
je 0x6417
cmpq %r12, %r14
movq 0x28(%rsp), %rbp
jae 0x5d77
movq %r15, %rbx
jmp 0x5e02
movl 0x4(%rsp), %eax
cmpl $0x101, %eax            # imm = 0x101
jne 0x5f98
callq 0x929a
jmp 0x5f9d
xorl %eax, %eax
movl %eax, %edx
movl $0x4, %r14d
movl $0x1, %r15d
movq 0x1f97b(%rip), %rcx     # 0x25480
cmpq $0x4, %rcx
movq %r14, %rax
cmovbq %rcx, %rax
movq %rcx, %rdi
subq %rax, %rdi
movq 0x1f95b(%rip), %rsi     # 0x25478
addq %rsi, %rdi
movq %rdi, 0x1f951(%rip)     # 0x25478
testq %rcx, %rcx
je 0x5b69
movq %r15, %rdi
subq %rax, %rdi
movq %rsi, %rax
addq %rcx, %rax
movq %rdi, %rcx
leaq (%rax,%rcx), %rsi
shlq $0x8, %rdx
movq %rsi, 0x1f92e(%rip)     # 0x25478
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 0x5b3b
jmp 0x5b6c
movq %rdx, %r12
callq 0xb08c
movq %r12, %rdx
testq %rax, %rax
jne 0x5afe
movl %r12d, %eax
movl %eax, %esi
addq $-0x6, 0x1f90a(%rip)    # 0x25490
xorl %ecx, %ecx
movl %ecx, %edx
movl %ebx, %edi
callq 0x9839
callq 0x69a6
jmp 0x6236
movl 0x4(%rsp), %eax
cmpl $-0x1, %eax
je 0x6221
cmpl $0x0, 0x4(%rsp)
leaq 0x107af(%rip), %rax     # 0x16363
leaq 0x107c9(%rip), %rcx     # 0x16384
cmovsq %rax, %rcx
movq %rcx, %rdi
jmp 0x6228
callq 0x929a
cmpl $0x0, 0x177fd(%rip)     # 0x1d3d0
je 0x5bf1
addq $-0x3, 0x1f8b3(%rip)    # 0x25490
movl 0x4(%rsp), %edi
movq 0x1f8b0(%rip), %rdx     # 0x25498
xorl %ecx, %ecx
movl %ecx, %esi
callq 0x9839
cmpl $0x0, 0x90(%rsp)
je 0x5c1e
movl (%r14), %edi
movq 0x1b0(%rsp), %rsi
callq 0x3610
testl %eax, %eax
jne 0x64fb
movl $0x0, 0x90(%rsp)
movl 0x19c(%rsp), %eax
testl %eax, %eax
je 0x5b91
movups 0x198(%rsp), %xmm0
movaps %xmm0, 0xc0(%rsp)
movq 0x1a8(%rsp), %rbx
cmpl $0x21, %eax
jne 0x6538
leaq 0x10794(%rip), %rdi     # 0x163e9
xorl %eax, %eax
movq %rbx, %rsi
callq 0x479d
pshufd $0xee, 0xc0(%rsp), %xmm0 # xmm0 = mem[2,3,2,3]
movd %xmm0, %eax
testl %eax, %eax
je 0x5c79
movq %rbx, %rdi
callq 0x3050
xorl %edx, %edx
movl %edx, %esi
callq 0x9bc9
jmp 0x5b91
movq %r15, %rdi
callq 0x6893
testq %rax, %rax
je 0x62bb
movq %rbx, %r13
movq %rbp, %rbx
subq %rax, %rbx
jmp 0x5cbd
leaq (%r15,%rbp), %rdi
subq %rax, %rdi
movq %r12, %rsi
callq 0x3330
movq %rbp, %rbx
testl %eax, %eax
je 0x62cc
xorl %edx, %edx
movl %edx, %eax
movl %edx, %esi
movq %r15, %rdi
callq 0x3490
movl %eax, 0x1768f(%rip)     # 0x1d360
testl %eax, %eax
js 0x651a
movl 0x176a5(%rip), %ebp     # 0x1d384
testb $0x1, %bpl
jne 0x5ce9
xorl %eax, %eax
jmp 0x5d0b
movq 0x17678(%rip), %r14     # 0x1d368
movq %r14, %rdi
movl $0x2f, %esi
callq 0x3210
leaq 0x1(%rax), %rcx
testq %rax, %rax
cmoveq %r14, %rcx
movq %rcx, %rax
movq %rax, 0x1769e(%rip)     # 0x1d3b0
testb $0x2, %bpl
je 0x5d22
movq 0x210(%rsp), %rax
jmp 0x5d24
xorl %eax, %eax
movq %rbx, %r14
movq %r13, %rbx
jmp 0x4b8c
movq %rbx, %rdi
callq 0x3290
movl $0x1, %eax
xorl %ecx, %ecx
movq %rcx, %r14
movq %rcx, %rdi
jmp 0x5d7e
leaq (%r14,%r13), %rdi
leaq 0x104be(%rip), %rsi     # 0x1620f
callq 0x3330
testl %eax, %eax
leaq 0x106e0(%rip), %rax     # 0x1643f
leaq 0x1119b(%rip), %rcx     # 0x16f01
cmoveq %rax, %rcx
xorl %eax, %eax
movl %eax, %r12d
movq %rcx, %rbx
jmp 0x4f2e
leaq 0x1(%r14), %rax
movq %r15, %rdi
movq %rax, %rdx
shrq $0x2, %rdx
addq %rax, %rdx
movl $0x3, %esi
movq %rdx, %rcx
cmpq $0x8, %rdx
jb 0x5db4
movl $0x3, %r8d
movq %rdx, %r9
movq %r9, %r10
shrq %r9
incq %r8
movq %r8, %rsi
movq %r9, %rcx
cmpq $0xf, %r10
ja 0x5d9f
movq %rcx, %r8
movl %esi, %ecx
movl $0x1, %esi
shlq %cl, %rsi
cmpq $0x7, %r8
cmoveq %rsi, %rdx
cmpq $0x11, %rdx
movl $0x10, %ecx
cmovaeq %rdx, %rcx
cmpq %rax, %rcx
movq $-0x1, %rbx
cmovaq %rcx, %rbx
testq %r14, %r14
jne 0x5df7
testq %rdi, %rdi
je 0x5df3
callq 0x3050
xorl %eax, %eax
movl %eax, %edi
movq %rbx, %rsi
callq 0x9def
movq %rax, %rbx
movb $0x0, (%rbx,%r14)
testq %rbp, %rbp
je 0x5e41
movq 0x17555(%rip), %rax     # 0x1d368
cmpb $0x2f, -0x1(%rax,%rbp)
je 0x5e45
leaq 0x17547(%rip), %rdi     # 0x1d368
leaq 0x17548(%rip), %rsi     # 0x1d370
leaq 0x1049b(%rip), %rcx     # 0x162ca
movq 0x28(%rsp), %rdx
callq 0x66f1
decq %rax
movq %rax, %rbp
jmp 0x5e45
xorl %eax, %eax
movl %eax, %ebp
cmpb $0x0, (%rbx)
je 0x5f71
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 0x6417
cmpq 0x174f9(%rip), %rax     # 0x1d370
jbe 0x5f2a
movq %rax, %r13
shrq $0x2, %r13
addq %rax, %r13
movl $0x3, %esi
movq %r13, %rcx
cmpq $0x8, %r13
jb 0x5eb2
movl $0x3, %edi
movq %r13, %r8
movq %r8, %r9
shrq %r8
incq %rdi
movq %rdi, %rsi
movq %r8, %rcx
cmpq $0xf, %r9
ja 0x5e9d
movq %rcx, %rdi
movl %esi, %ecx
movl $0x1, %esi
shlq %cl, %rsi
cmpq $0x7, %rdi
cmoveq %rsi, %r13
cmpq $0x11, %r13
movl $0x10, %ecx
cmovbq %rcx, %r13
cmpq %rax, %r13
movq $-0x1, %rax
cmovbeq %rax, %r13
movq 0x1747f(%rip), %rdi     # 0x1d368
testq %rbp, %rbp
jne 0x5f12
testq %rdi, %rdi
je 0x5f03
callq 0x3050
movq $0x0, 0x17465(%rip) # 0x1d368
movq $0x0, 0x17462(%rip) # 0x1d370
xorl %eax, %eax
movl %eax, %edi
movq %r13, %rsi
callq 0x9def
movq %rax, 0x17447(%rip)     # 0x1d368
movq %r13, 0x17448(%rip)     # 0x1d370
jmp 0x5f31
movq 0x17437(%rip), %rax     # 0x1d368
movq %rax, %rdi
addq %rbp, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x3370
movq 0x1741f(%rip), %rdi     # 0x1d368
callq 0x482f
movq %r15, %rdi
callq 0x31a0
leaq (%r14,%rax), %rcx
addq %rax, %r14
incq %r14
leaq (%rbx,%rcx), %r15
incq %r15
cmpb $0x0, (%r15)
jne 0x5e56
movq 0x173f0(%rip), %rax     # 0x1d368
movq 0x28(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq %rbx, %rdi
callq 0x3050
jmp 0x6236
callq 0x3730
jmp 0x4fc8
callq 0x9e11
cmpl $0x0, 0x90(%rsp)
je 0x5fca
movl (%r14), %edi
movq 0x1b0(%rsp), %rsi
callq 0x3610
testl %eax, %eax
jne 0x6486
movl $0x0, 0x90(%rsp)
movl 0x19c(%rsp), %eax
testl %eax, %eax
je 0x6075
movups 0x198(%rsp), %xmm0
movaps %xmm0, 0xb0(%rsp)
movq 0x1a8(%rsp), %rbx
cmpl $0x21, %eax
jne 0x64c6
leaq 0x103e8(%rip), %rdi     # 0x163e9
xorl %eax, %eax
movq %rbx, %rsi
callq 0x479d
pshufd $0xee, 0xb0(%rsp), %xmm0 # xmm0 = mem[2,3,2,3]
movd %xmm0, %eax
testl %eax, %eax
je 0x6025
movq %rbx, %rdi
callq 0x3050
xorl %edx, %edx
movl %edx, %esi
callq 0x9bc9
movl 0x17330(%rip), %edi     # 0x1d364
cmpl $-0x1, %edi
je 0x6075
cmpl $0x1, %edi
je 0x6075
callq 0x3270
movl $0xffffffff, 0x17317(%rip) # imm = 0xFFFFFFFF
movq 0x17324(%rip), %rdi     # 0x1d378
callq 0x3080
movq 0x17318(%rip), %rdi     # 0x1d378
testq %rdi, %rdi
je 0x6075
callq 0x3050
movq $0x0, 0x17303(%rip) # 0x1d378
cmpl $0x2, 0x17304(%rip)     # 0x1d380
jl 0x609a
movq 0x16f6b(%rip), %rbx     # 0x1cff0
movq (%rbx), %rsi
movl $0xa, %edi
callq 0x3320
movq (%rbx), %rdi
callq 0x33f0
callq 0x69a6
movl 0x172bf(%rip), %edi     # 0x1d364
cmpl $-0x1, %edi
je 0x629a
cmpl $0x1, %edi
je 0x629a
cmpl $0x0, 0x172d6(%rip)     # 0x1d394
je 0x60d4
callq 0x34d0
cmpl $-0x1, %eax
je 0x6569
movl 0x17290(%rip), %edi     # 0x1d364
callq 0x3270
testl %eax, %eax
jne 0x64a5
movl $0xffffffff, 0x17279(%rip) # imm = 0xFFFFFFFF
cmpl $0x0, 0x1726e(%rip)     # 0x1d360
je 0x6250
movq 0x17269(%rip), %rdi     # 0x1d368
movq 0x17272(%rip), %rbx     # 0x1d378
leaq 0xd0(%rsp), %rsi
callq 0x31b0
testl %eax, %eax
jne 0x6181
movl 0xe8(%rsp), %esi
movl %esi, %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x8000, %eax           # imm = 0x8000
jne 0x6181
andl $0xfff, %esi            # imm = 0xFFF
movq %rbx, %rdi
callq 0x3460
movl 0xec(%rsp), %esi
movl 0xf0(%rsp), %edx
movq %rbx, %rdi
callq 0x3430
movq 0x118(%rsp), %rax
movq 0x128(%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, 0x17204(%rip)     # 0x1d38c
jne 0x6250
cmpq $0x2, 0x1c8(%rsp)
movq 0x171ca(%rip), %rsi     # 0x1d368
jb 0x6248
cmpl $0x0, 0x171e5(%rip)     # 0x1d390
jne 0x6248
leaq 0x102e0(%rip), %rdi     # 0x16498
xorl %eax, %eax
callq 0x479d
jmp 0x6250
movl 0x17196(%rip), %edi     # 0x1d360
movq $-0x8, %rsi
movl $0x2, %edx
callq 0x3570
movq 0x1f2ae(%rip), %r13     # 0x25490
cmpq $-0x1, %rax
je 0x62de
subq %r13, %rax
addq 0x1f28a(%rip), %rax     # 0x25480
movq %rax, 0x1f293(%rip)     # 0x25490
movl 0x1715d(%rip), %edi     # 0x1d360
leaq 0xd0(%rsp), %rsi
movl $0x8, %edx
callq 0xb21f
movq 0x1f274(%rip), %rax     # 0x25490
jmp 0x63e7
leaq 0x10128(%rip), %rdi     # 0x16350
movq 0x17139(%rip), %rsi     # 0x1d368
xorl %eax, %eax
callq 0x479d
addq $0x248, %rsp            # imm = 0x248
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rsi, %rdi
callq 0x3080
cmpl $0x0, 0x17181(%rip)     # 0x1d3d8
je 0x629a
movb 0x17125(%rip), %cl      # 0x1d384
shrb %cl
movq 0x171b0(%rip), %rax     # 0x1d418
testq %rax, %rax
setne %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x629a
movq 0x170fc(%rip), %rdi     # 0x1d378
leaq 0xd0(%rsp), %rsi
movq %rax, (%rsi)
xorl %ecx, %ecx
movq %rcx, 0x8(%rsi)
movq %rax, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
callq 0x3300
movq 0x170d7(%rip), %rdi     # 0x1d378
testq %rdi, %rdi
je 0x6236
callq 0x3050
movq $0x0, 0x170c2(%rip) # 0x1d378
jmp 0x6236
leaq 0x10024(%rip), %rdi     # 0x162e6
xorl %eax, %eax
movq %r15, %rsi
jmp 0x6231
xorl %eax, %eax
movq %r15, %rsi
movq %r12, %rdx
callq 0x6804
jmp 0x6236
movq 0x1f19b(%rip), %rax     # 0x25480
movl $0x8, %ebp
leaq 0xd0(%rsp), %r14
movq %rax, 0x58(%rsp)
cmpq $0x8, %rax
movq %rbp, %r12
cmovbq %rax, %r12
subq %r12, %rax
movq %rax, %rsi
addq 0x1f169(%rip), %rsi     # 0x25478
movq %r14, %rdi
movq %r12, %rdx
callq 0x3370
callq 0xb08c
movq 0x1f15a(%rip), %r15     # 0x25480
movl $0x8000, %eax           # imm = 0x8000
cmpq $0x8000, %r15           # imm = 0x8000
je 0x62f7
cmpq $0x7, %r15
ja 0x63b6
leaq (%r15,%r12), %rax
cmpq $0x7, %rax
jbe 0x63ed
testq %r15, %r15
je 0x63ca
cmpq $0x8, %rax
je 0x637a
leaq (%rsp,%r12), %rax
addq $0xd0, %rax
movl $0x8, %edx
subq %r15, %rdx
leaq (%r15,%rax), %rsi
addq $-0x8, %rsi
leaq 0xd0(%rsp), %rdi
callq 0x3370
subq %r15, %r14
addq $0x8, %r14
movq 0x1f0f0(%rip), %rsi     # 0x25478
movq %r14, %rdi
movq %r15, %rdx
callq 0x3370
jmp 0x63ca
callq 0x3680
testw %ax, %ax
je 0x59d3
movzwl %ax, %eax
cmpl $0x1, %eax
jne 0x4fbb
movl (%rbx), %ebx
jmp 0x64ac
movq 0x1f0bb(%rip), %rax     # 0x25478
movq -0x8(%rax,%r15), %rax
movq %rax, 0xd0(%rsp)
movq 0x1f0bf(%rip), %rax     # 0x25490
movq 0x58(%rsp), %rcx
subq %r13, %rcx
addq %rcx, %rax
addq $-0x8, %rax
movq %rax, 0x1f0a9(%rip)     # 0x25490
cmpq $0x1, %rax
ja 0x6400
movq 0x16f74(%rip), %rsi     # 0x1d368
leaq 0x100c9(%rip), %rdi     # 0x164c4
jmp 0x4d7a
movl 0xd0(%rsp), %eax
movl 0xd4(%rsp), %ecx
movl %eax, %esi
movl %ecx, %edx
jmp 0x4c1c
leaq 0x1009d(%rip), %rsi     # 0x164bb
xorl %eax, %eax
movl %eax, %edx
movl $0x22, %edi
callq 0xe90d
movq 0x16f35(%rip), %rdx     # 0x1d368
leaq 0xfdda(%rip), %rsi      # 0x16214
xorl %eax, %eax
movl %eax, %ecx
movl $0x21, %edi
callq 0xe90d
leaq 0xee81(%rip), %rdi      # 0x152d0
leaq 0xeeaa(%rip), %rsi      # 0x15300
leaq 0xff4f(%rip), %rcx      # 0x163ac
movl $0x104d, %edx           # imm = 0x104D
callq 0x3220
leaq 0xee62(%rip), %rdi      # 0x152d0
leaq 0xee8b(%rip), %rsi      # 0x15300
leaq 0xff30(%rip), %rcx      # 0x163ac
movl $0xfe7, %edx            # imm = 0xFE7
callq 0x3220
leaq 0xee43(%rip), %rdi      # 0x152d0
leaq 0xee6c(%rip), %rsi      # 0x15300
leaq 0xff11(%rip), %rcx      # 0x163ac
movl $0x1055, %edx           # imm = 0x1055
callq 0x3220
callq 0x3070
movl (%rax), %ebx
movq 0x16ec5(%rip), %r14     # 0x1d378
movl %ebx, %edi
callq 0x35b0
leaq 0xffb6(%rip), %rsi      # 0x16477
jmp 0x6585
callq 0xe8a0
movl (%r14), %edi
callq 0x3110
testq %rax, %rax
jne 0x659d
leaq 0xfede(%rip), %rdi      # 0x163c1
leaq 0xee16(%rip), %rsi      # 0x15300
leaq 0xfebb(%rip), %rcx      # 0x163ac
movl $0x1057, %edx           # imm = 0x1057
callq 0x3220
leaq 0xedce(%rip), %rdi      # 0x152d0
leaq 0xedf7(%rip), %rsi      # 0x15300
leaq 0xfe9c(%rip), %rcx      # 0x163ac
movl $0xff2, %edx            # imm = 0xFF2
callq 0x3220
callq 0x3070
movl (%rax), %ebx
movq 0x16e40(%rip), %r14     # 0x1d368
movl %ebx, %edi
callq 0x35b0
leaq 0xfddd(%rip), %rsi      # 0x16313
jmp 0x6585
callq 0xe8a0
movl (%r14), %edi
callq 0x3110
testq %rax, %rax
jne 0x65af
leaq 0xfe70(%rip), %rdi      # 0x163c1
leaq 0xeda8(%rip), %rsi      # 0x15300
leaq 0xfe4d(%rip), %rcx      # 0x163ac
movl $0xff4, %edx            # imm = 0xFF4
callq 0x3220
callq 0x3070
movl (%rax), %ebx
movq 0x16e01(%rip), %r14     # 0x1d378
movl %ebx, %edi
callq 0x35b0
leaq 0x10522(%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 0xe90d
movl (%r14), %edi
callq 0x3110
movaps 0xb0(%rsp), %xmm0
jmp 0x65bf
movl (%r14), %edi
callq 0x3110
movaps 0xc0(%rsp), %xmm0
movups %xmm0, 0xc8(%rax)
movq %rbx, 0xd8(%rax)
movl (%r14), %edi
callq 0x3110
movq %rax, %rdi
movl $0x1, %esi
callq 0x3480