// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x3a0, %rsp            # imm = 0x3A0
movq %rdi, -0x8(%rbp)
movl $0xffffffff, -0xc(%rbp) # imm = 0xFFFFFFFF
cmpq $0x0, -0x8(%rbp)
jne 0x4b42
leaq 0x1ecd8(%rip), %rsi     # 0x23780
movq %rsi, %rdi
addq $0x18, %rdi
addq $0x20, %rsi
xorl %eax, %eax
movl %eax, %edx
leaq 0x186a0(%rip), %rcx     # 0x1d15e
callq 0x6090
movl $0x0, 0x1ecc3(%rip)     # 0x23790
movq $0x0, 0x1ed08(%rip) # 0x237e0
movl 0x1ecd6(%rip), %eax     # 0x237b4
andl $0x2, %eax
cmpl $0x0, %eax
je 0x4b1c
movl 0x1eca4(%rip), %edi     # 0x23790
leaq -0xa8(%rbp), %rsi
callq 0x3560
cmpl $0x0, %eax
jne 0x4b1c
movl -0x90(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x8000, %eax           # imm = 0x8000
jne 0x4b1c
movq -0x50(%rbp), %rax
movq %rax, -0x320(%rbp)
jmp 0x4b27
xorl %eax, %eax
movq %rax, -0x320(%rbp)
jmp 0x4b27
movq -0x320(%rbp), %rax
movq %rax, 0x1ecc3(%rip)     # 0x237f8
movq $0x0, -0x18(%rbp)
jmp 0x51c1
movq -0x8(%rbp), %rax
cmpq 0x1ec4b(%rip), %rax     # 0x23798
je 0x4b6e
movq -0x8(%rbp), %rcx
leaq 0x1ec26(%rip), %rsi     # 0x23780
movq %rsi, %rdi
addq $0x18, %rdi
addq $0x20, %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x6090
movq 0x1ec23(%rip), %rdi     # 0x23798
callq 0x31a0
movq %rax, -0x18(%rbp)
movq 0x1ec13(%rip), %rdi     # 0x23798
leaq -0xa8(%rbp), %rsi
callq 0x3160
cmpl $0x0, %eax
je 0x4cd1
callq 0x3070
cmpl $0x2, (%rax)
jne 0x4c5c
cmpl $0x0, 0x1ec51(%rip)     # 0x23800
jne 0x4bbe
cmpl $0x0, 0x1ec50(%rip)     # 0x23808
je 0x4c5c
leaq 0x1eb2b(%rip), %rax     # 0x236f0
movq %rax, -0xc8(%rbp)
movq -0xc8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x4bdb
jmp 0x4c5a
movq -0x18(%rbp), %rdx
movq -0xc8(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0xc8(%rbp)
movq (%rax), %rcx
leaq 0x1eb82(%rip), %rsi     # 0x23780
movq %rsi, %rdi
addq $0x18, %rdi
addq $0x20, %rsi
callq 0x6090
callq 0x3070
movl $0x0, (%rax)
movq 0x1eb78(%rip), %rdi     # 0x23798
leaq -0xa8(%rbp), %rsi
callq 0x3160
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x321(%rbp)
je 0x4c4c
callq 0x3070
cmpl $0x2, (%rax)
sete %al
movb %al, -0x321(%rbp)
movb -0x321(%rbp), %al
testb $0x1, %al
jne 0x4bcc
jmp 0x4c5c
callq 0x3070
cmpl $0x4b, (%rax)
je 0x4c70
callq 0x3070
cmpl $0x1b, (%rax)
jne 0x4c8e
movq 0x1eb21(%rip), %rdx     # 0x23798
movl $0x21, %edi
leaq 0x184e3(%rip), %rsi     # 0x1d166
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x122d0
callq 0x3070
cmpl $0x0, (%rax)
je 0x4cc1
movq 0x1eaf9(%rip), %rax     # 0x23798
movq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq 0x1eaea(%rip), %rsi     # 0x23798
leaq 0x184e6(%rip), %rdi     # 0x1d19b
movb $0x0, %al
callq 0x49e0
jmp 0x5ddb
movq 0x1ead0(%rip), %rdi     # 0x23798
callq 0x31a0
movq %rax, -0x18(%rbp)
movl -0x90(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x8000, %eax           # imm = 0x8000
je 0x4d33
movl -0x90(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x1000, %eax           # imm = 0x1000
je 0x4d33
movl -0x90(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0xa000, %eax           # imm = 0xA000
je 0x4d33
movl -0x90(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x4000, %eax           # imm = 0x4000
je 0x4d33
movq 0x1ea78(%rip), %rsi     # 0x23798
leaq 0x18490(%rip), %rdi     # 0x1d1b7
movb $0x0, %al
callq 0x49e0
jmp 0x5ddb
movl -0x90(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0xa000, %eax           # imm = 0xA000
jne 0x4d71
cmpl $0x0, 0x1ea74(%rip)     # 0x237c0
jne 0x4d71
cmpl $0x0, 0x1ea63(%rip)     # 0x237b8
jne 0x4d71
movq 0x1ea3a(%rip), %rsi     # 0x23798
leaq 0x1847b(%rip), %rdi     # 0x1d1e0
movb $0x0, %al
callq 0x49e0
jmp 0x5ddb
movl -0x90(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x4000, %eax           # imm = 0x4000
jne 0x4da6
cmpl $0x0, 0x1ea46(%rip)     # 0x237d0
jne 0x4da6
movq 0x1ea05(%rip), %rsi     # 0x23798
leaq 0x18466(%rip), %rdi     # 0x1d200
movb $0x0, %al
callq 0x49e0
jmp 0x5ddb
movl -0x90(%rbp), %eax
andl $0xf000, %eax           # imm = 0xF000
cmpl $0x4000, %eax           # imm = 0x4000
jne 0x4fd3
movq $0x0, -0xd0(%rbp)
movq $0x0, -0xd8(%rbp)
movq $0x0, -0xe0(%rbp)
movq 0x1e9b4(%rip), %rdi     # 0x23798
callq 0x3180
movq %rax, -0xf0(%rbp)
cmpq $0x0, -0xf0(%rbp)
jne 0x4dff
jmp 0x5ddb
jmp 0x4e01
movq -0xf0(%rbp), %rdi
callq 0x34a0
movq %rax, -0xf8(%rbp)
cmpq $0x0, %rax
je 0x4ea1
movq -0xf8(%rbp), %rax
movsbl 0x13(%rax), %eax
cmpl $0x0, %eax
je 0x4e6e
movq -0xf8(%rbp), %rax
movsbl 0x13(%rax), %eax
cmpl $0x2e, %eax
jne 0x4e70
movq -0xf8(%rbp), %rax
movsbl 0x14(%rax), %eax
cmpl $0x0, %eax
je 0x4e6e
movq -0xf8(%rbp), %rax
movsbl 0x14(%rax), %eax
cmpl $0x2e, %eax
jne 0x4e70
movq -0xf8(%rbp), %rax
movsbl 0x15(%rax), %eax
cmpl $0x0, %eax
jne 0x4e70
jmp 0x4e01
movq -0xe0(%rbp), %rdx
movq -0xf8(%rbp), %rcx
addq $0x13, %rcx
leaq -0xd0(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
callq 0x6090
movq %rax, -0xe0(%rbp)
jmp 0x4e01
movq -0xf0(%rbp), %rdi
callq 0x3290
movq -0xe0(%rbp), %rdx
leaq -0xd0(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
leaq 0x190cc(%rip), %rcx     # 0x1df95
callq 0x6090
cmpq $0x0, -0x18(%rbp)
je 0x4f1c
movq 0x1e8bc(%rip), %rax     # 0x23798
movq -0x18(%rbp), %rcx
subq $0x1, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x2f, %eax
je 0x4f1c
movq -0x18(%rbp), %rdx
leaq 0x1e888(%rip), %rsi     # 0x23780
movq %rsi, %rdi
addq $0x18, %rdi
addq $0x20, %rsi
leaq 0x18312(%rip), %rcx     # 0x1d21c
callq 0x6090
subq $0x1, %rax
movq %rax, -0x330(%rbp)
jmp 0x4f27
movq -0x18(%rbp), %rax
movq %rax, -0x330(%rbp)
movq -0x330(%rbp), %rax
movq %rax, -0xe8(%rbp)
movq $0x0, -0xe0(%rbp)
movq -0xd0(%rbp), %rax
movq -0xe0(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x4fb3
movq -0xe8(%rbp), %rdx
movq -0xd0(%rbp), %rcx
addq -0xe0(%rbp), %rcx
leaq 0x1e810(%rip), %rsi     # 0x23780
movq %rsi, %rdi
addq $0x18, %rdi
addq $0x20, %rsi
callq 0x6090
movq 0x1e811(%rip), %rdi     # 0x23798
callq 0x4a80
movq -0xd0(%rbp), %rdi
addq -0xe0(%rbp), %rdi
callq 0x31a0
addq $0x1, %rax
addq -0xe0(%rbp), %rax
movq %rax, -0xe0(%rbp)
jmp 0x4f40
movq 0x1e7de(%rip), %rax     # 0x23798
movq -0x18(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0xd0(%rbp), %rdi
callq 0x3050
jmp 0x5ddb
cmpl $0x0, 0x1e7e6(%rip)     # 0x237c0
jne 0x5082
cmpl $0x0, 0x1e819(%rip)     # 0x23800
jne 0x5082
cmpl $0x0, 0x1e814(%rip)     # 0x23808
jne 0x5082
movq -0x18(%rbp), %rax
movq %rax, -0x338(%rbp)
movq 0x1e7cc(%rip), %rdi     # 0x237d8
callq 0x31a0
movq %rax, %rcx
movq -0x338(%rbp), %rax
cmpq %rcx, %rax
jb 0x5082
movq 0x1e771(%rip), %rax     # 0x23798
addq -0x18(%rbp), %rax
movq %rax, -0x340(%rbp)
movq 0x1e79f(%rip), %rdi     # 0x237d8
callq 0x31a0
movq -0x340(%rbp), %rdi
movq %rax, %rcx
xorl %eax, %eax
subq %rcx, %rax
addq %rax, %rdi
movq 0x1e781(%rip), %rsi     # 0x237d8
callq 0x3320
cmpl $0x0, %eax
jne 0x5082
movq 0x1e730(%rip), %rsi     # 0x23798
movq 0x1e769(%rip), %rdx     # 0x237d8
leaq 0x181a8(%rip), %rdi     # 0x1d21e
movb $0x0, %al
callq 0x6100
jmp 0x5ddb
cmpl $0x1, 0x1e77f(%rip)     # 0x23808
jne 0x50e6
cmpl $0x0, 0x1e726(%rip)     # 0x237b8
jne 0x50e6
cmpl $0x0, 0x1e765(%rip)     # 0x23800
jne 0x50e6
movq 0x1e6f4(%rip), %rdi     # 0x23798
callq 0x61a0
movq %rax, -0x100(%rbp)
cmpq $0x0, -0x100(%rbp)
jne 0x50d4
movq 0x1e6d7(%rip), %rsi     # 0x23798
leaq 0x18170(%rip), %rdi     # 0x1d238
movb $0x0, %al
callq 0x49e0
jmp 0x5ddb
movq -0x100(%rbp), %rcx
movq -0x18(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x18(%rbp)
movq 0x1e6ab(%rip), %rdi     # 0x23798
xorl %edx, %edx
movl %edx, %esi
movb $0x0, %al
callq 0x3480
movl %eax, 0x1e692(%rip)     # 0x23790
cmpl $0x0, 0x1e68b(%rip)     # 0x23790
jge 0x5151
callq 0x3070
movl (%rax), %eax
movl %eax, -0x34c(%rbp)
movq 0x1e67d(%rip), %rax     # 0x23798
movq %rax, -0x348(%rbp)
callq 0x3070
movl (%rax), %edi
callq 0x3590
movl -0x34c(%rbp), %edi
movq -0x348(%rbp), %rdx
movq %rax, %rcx
leaq 0x18120(%rip), %rsi     # 0x1d265
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0x122d0
movl 0x1e65d(%rip), %eax     # 0x237b4
andl $0x1, %eax
cmpl $0x0, %eax
je 0x5174
movq 0x1e632(%rip), %rdi     # 0x23798
callq 0x6340
movq %rax, -0x358(%rbp)
jmp 0x517f
xorl %eax, %eax
movq %rax, -0x358(%rbp)
jmp 0x517f
movq -0x358(%rbp), %rax
movq %rax, 0x1e653(%rip)     # 0x237e0
movl 0x1e621(%rip), %eax     # 0x237b4
andl $0x2, %eax
cmpl $0x0, %eax
je 0x51a8
movq -0x50(%rbp), %rax
movq %rax, -0x360(%rbp)
jmp 0x51b3
xorl %eax, %eax
movq %rax, -0x360(%rbp)
jmp 0x51b3
movq -0x360(%rbp), %rax
movq %rax, 0x1e637(%rip)     # 0x237f8
cmpl $0x0, 0x1e638(%rip)     # 0x23800
je 0x51e2
cmpl $0x2, 0x1e637(%rip)     # 0x23808
je 0x51e2
callq 0x6390
callq 0x68a0
jmp 0x5ddb
cmpl $0x0, 0x1e61f(%rip)     # 0x23808
je 0x556f
callq 0x69d0
movl $0x1, %edi
callq 0x6a10
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl $0x8, %eax
je 0x52cb
movl -0xc(%rbp), %eax
cmpl $0x101, %eax            # imm = 0x101
je 0x52cb
movl -0xc(%rbp), %eax
cmpl $-0x1, %eax
je 0x522b
movl -0xc(%rbp), %eax
cmpl $-0x2, %eax
jne 0x524f
cmpl $0x0, 0x1e58e(%rip)     # 0x237c0
je 0x524f
cmpl $0x0, 0x1e57d(%rip)     # 0x237b8
je 0x524f
cmpl $0x2, 0x1e5c4(%rip)     # 0x23808
je 0x524f
cmpl $0x0, 0x1e5b3(%rip)     # 0x23800
je 0x52cb
callq 0x68a0
movl -0xc(%rbp), %eax
cmpl $-0x6, %eax
jne 0x526c
leaq 0x18018(%rip), %rax     # 0x1d27b
movq %rax, -0x368(%rbp)
jmp 0x52b1
movl -0xc(%rbp), %eax
cmpl $-0x1, %eax
jne 0x5284
leaq 0x18027(%rip), %rax     # 0x1d2a2
movq %rax, -0x370(%rbp)
jmp 0x52a3
movl -0xc(%rbp), %edx
leaq 0x18048(%rip), %rax     # 0x1d2d6
leaq 0x18020(%rip), %rcx     # 0x1d2b5
cmpl $0x0, %edx
cmovlq %rcx, %rax
movq %rax, -0x370(%rbp)
movq -0x370(%rbp), %rax
movq %rax, -0x368(%rbp)
movq -0x368(%rbp), %rdi
movq 0x1e4d9(%rip), %rsi     # 0x23798
movb $0x0, %al
callq 0x49e0
jmp 0x5ddb
cmpl $0x2, 0x1e536(%rip)     # 0x23808
jne 0x556d
jmp 0x52da
movl $0x1, -0x1ec(%rbp)
movl $0x0, -0x120(%rbp)
movl $0x0, -0x11c(%rbp)
movl $0x0, -0x118(%rbp)
movq $0x0, -0x110(%rbp)
callq 0x12220
leaq 0x3e79b(%rip), %rax     # 0x43ab4
movl (%rax), %edi
callq 0x3110
movq %rax, -0x108(%rbp)
leaq 0x3e786(%rip), %rax     # 0x43ab4
movl (%rax), %edi
leaq -0x1e8(%rbp), %rsi
callq 0x35f0
movl %eax, -0x1f0(%rbp)
cmpl $0x0, -0x1f0(%rbp)
jne 0x5355
movb $0x1, %al
testb $0x1, %al
jne 0x5353
jmp 0x5355
jmp 0x5374
leaq 0x16ebe(%rip), %rdi     # 0x1c21a
leaq 0x16ee7(%rip), %rsi     # 0x1c24a
movl $0xfe7, %edx            # imm = 0xFE7
leaq 0x17f8f(%rip), %rcx     # 0x1d2fe
callq 0x3220
jmp 0x5376
leaq -0x1e8(%rbp), %rdi
callq 0x32f0
cmpl $0x0, %eax
jne 0x53d3
jmp 0x5389
movl -0xc(%rbp), %eax
cmpl $0x8, %eax
jne 0x5398
callq 0x8570
jmp 0x53cf
callq 0x9d50
cmpl $0x0, 0x1e45c(%rip)     # 0x23800
je 0x53cd
movq 0x26513(%rip), %rax     # 0x2b8c0
subq $0x3, %rax
movq %rax, 0x26508(%rip)     # 0x2b8c0
movl -0xc(%rbp), %edi
movq 0x26506(%rip), %rdx     # 0x2b8c8
xorl %eax, %eax
movl %eax, %esi
xorl %ecx, %ecx
callq 0xa500
jmp 0x53cf
jmp 0x53d1
jmp 0x53d3
movl -0x1ec(%rbp), %eax
cmpl $0x0, %eax
je 0x5439
jmp 0x53e0
leaq 0x3e6cd(%rip), %rax     # 0x43ab4
movl (%rax), %edi
movq -0x108(%rbp), %rsi
callq 0x35f0
movl %eax, -0x1f4(%rbp)
cmpl $0x0, -0x1f4(%rbp)
jne 0x540e
movb $0x1, %al
testb $0x1, %al
jne 0x540c
jmp 0x540e
jmp 0x542d
leaq 0x16e05(%rip), %rdi     # 0x1c21a
leaq 0x16e2e(%rip), %rsi     # 0x1c24a
movl $0xff2, %edx            # imm = 0xFF2
leaq 0x17ed6(%rip), %rcx     # 0x1d2fe
callq 0x3220
jmp 0x542f
movl $0x0, -0x1ec(%rbp)
movq -0x120(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq -0x118(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x110(%rbp), %rax
movq %rax, -0xb0(%rbp)
cmpl $0x0, -0xbc(%rbp)
je 0x5563
cmpl $0x21, -0xbc(%rbp)
je 0x5514
jmp 0x547f
callq 0x12220
leaq 0x3e629(%rip), %rax     # 0x43ab4
movl (%rax), %edi
callq 0x3110
cmpq $0x0, %rax
je 0x54a2
movb $0x1, %al
testb $0x1, %al
jne 0x54a0
jmp 0x54a2
jmp 0x54c1
leaq 0x17e7a(%rip), %rdi     # 0x1d323
leaq 0x16d9a(%rip), %rsi     # 0x1c24a
movl $0xff4, %edx            # imm = 0xFF4
leaq 0x17e42(%rip), %rcx     # 0x1d2fe
callq 0x3220
leaq 0x3e5ec(%rip), %rax     # 0x43ab4
movl (%rax), %edi
callq 0x3110
movq -0xc0(%rbp), %rcx
movq %rcx, 0xc8(%rax)
movq -0xb8(%rbp), %rcx
movq %rcx, 0xd0(%rax)
movq -0xb0(%rbp), %rcx
movq %rcx, 0xd8(%rax)
leaq 0x3e5b4(%rip), %rax     # 0x43ab4
movl (%rax), %edi
callq 0x3110
movq %rax, %rdi
movl $0x1, %esi
callq 0x3470
movq -0xb0(%rbp), %rsi
leaq 0x17e29(%rip), %rdi     # 0x1d34b
movb $0x0, %al
callq 0x49e0
cmpl $0x0, -0xb8(%rbp)
je 0x5553
movq -0xb0(%rbp), %rdi
callq 0x3050
movl $0x0, -0xb8(%rbp)
movq $0x0, -0xb0(%rbp)
jmp 0x5555
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
movq %rsi, %rdi
callq 0xa9c0
callq 0x68a0
jmp 0x5ddb
jmp 0x556f
cmpq $0x0, -0x8(%rbp)
je 0x557f
cmpl $0x0, 0x1e23b(%rip)     # 0x237b8
je 0x55ef
xorl %eax, %eax
movl %eax, %edi
movl $0x9, %esi
callq 0xac60
movq %rax, 0x1e214(%rip)     # 0x237a8
movq 0x1e20d(%rip), %rdi     # 0x237a8
leaq 0x17db6(%rip), %rsi     # 0x1d358
callq 0x30b0
movl $0x1, 0x1e1e3(%rip)     # 0x23794
cmpl $0x0, 0x1e250(%rip)     # 0x23808
jne 0x55ea
cmpl $0x0, 0x1e1ff(%rip)     # 0x237c0
jne 0x55ea
movl 0x1e1cb(%rip), %edi     # 0x23794
callq 0x30f0
cmpl $0x0, %eax
je 0x55ea
movl $0x16, %edi
leaq 0x17d82(%rip), %rsi     # 0x1d361
xorl %eax, %eax
movl %eax, %edx
movb $0x0, %al
callq 0x122d0
jmp 0x5947
movq 0x1e1a2(%rip), %rax     # 0x23798
movq %rax, -0x200(%rbp)
leaq 0x18991(%rip), %rax     # 0x1df95
movq %rax, -0x208(%rbp)
movq $0x0, -0x210(%rbp)
cmpl $0x0, 0x1e1eb(%rip)     # 0x23808
je 0x56ab
movl 0x1e18b(%rip), %eax     # 0x237b4
andl $0x1, %eax
cmpl $0x0, %eax
je 0x567d
cmpq $0x0, 0x1e217(%rip)     # 0x23850
je 0x567d
movq 0x1e156(%rip), %rdi     # 0x23798
callq 0x6340
movq 0x1e14a(%rip), %rcx     # 0x23798
subq %rcx, %rax
movq %rax, -0x210(%rbp)
movq 0x1e1f1(%rip), %rdi     # 0x23850
callq 0x6340
movq %rax, -0x200(%rbp)
movq -0x200(%rbp), %rdi
callq 0x31a0
movq %rax, -0x18(%rbp)
jmp 0x56a9
movq -0x200(%rbp), %rdi
addq -0x18(%rbp), %rdi
leaq 0x17aca(%rip), %rsi     # 0x1d159
callq 0x3320
cmpl $0x0, %eax
jne 0x56a7
leaq 0x17d01(%rip), %rax     # 0x1d3a1
movq %rax, -0x208(%rbp)
jmp 0x56a9
jmp 0x56b9
movq 0x1e126(%rip), %rax     # 0x237d8
movq %rax, -0x208(%rbp)
movq -0x210(%rbp), %rax
addq -0x18(%rbp), %rax
movq %rax, -0x378(%rbp)
movq -0x208(%rbp), %rdi
callq 0x31a0
movq -0x378(%rbp), %rsi
addq %rax, %rsi
addq $0x1, %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0xac60
movq %rax, 0x1e0b3(%rip)     # 0x237a8
movq 0x1e0ac(%rip), %rdi     # 0x237a8
movq 0x1e095(%rip), %rsi     # 0x23798
movq -0x210(%rbp), %rdx
callq 0x3360
movq 0x1e092(%rip), %rdi     # 0x237a8
addq -0x210(%rbp), %rdi
movq -0x200(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x3360
movq 0x1e074(%rip), %rdi     # 0x237a8
addq -0x210(%rbp), %rdi
addq -0x18(%rbp), %rdi
movq -0x208(%rbp), %rsi
callq 0x30b0
movq 0x1e056(%rip), %rdi     # 0x237a8
movl 0x1e068(%rip), %ecx     # 0x237c0
movl $0x80, %esi
xorl %eax, %eax
cmpl $0x0, %ecx
cmovnel %eax, %esi
orl $0x241, %esi            # imm = 0x241
movl $0x180, %edx            # imm = 0x180
movb $0x0, %al
callq 0x3480
movl %eax, 0x1e017(%rip)     # 0x23794
cmpl $0x0, 0x1e010(%rip)     # 0x23794
jge 0x58f2
callq 0x3070
cmpl $0x11, (%rax)
jne 0x58f2
movl $0x0, -0x214(%rbp)
xorl %edi, %edi
callq 0x30f0
cmpl $0x0, %eax
je 0x5889
cmpl $0x0, 0x1dff7(%rip)     # 0x237b0
je 0x5889
movq 0x1d832(%rip), %rax     # 0x22ff8
movq (%rax), %rdi
movq 0x1dfd8(%rip), %rdx     # 0x237a8
leaq 0x17bcf(%rip), %rsi     # 0x1d3a6
movb $0x0, %al
callq 0x3340
movq 0x1d813(%rip), %rax     # 0x22ff8
movq (%rax), %rdi
callq 0x33e0
movl $0x1, -0x21c(%rbp)
callq 0x3330
movl %eax, -0x218(%rbp)
cmpl $0x1, -0x21c(%rbp)
jne 0x5845
cmpl $0x20, -0x218(%rbp)
je 0x581d
cmpl $0x9, -0x218(%rbp)
jne 0x581f
jmp 0x5847
cmpl $0x79, -0x218(%rbp)
je 0x5831
cmpl $0x59, -0x218(%rbp)
jne 0x583b
movl $0x1, -0x214(%rbp)
movl $0x0, -0x21c(%rbp)
jmp 0x5847
xorl %eax, %eax
cmpl $-0x1, -0x218(%rbp)
movb %al, -0x379(%rbp)
je 0x5879
xorl %eax, %eax
cmpl $0xa, -0x218(%rbp)
movb %al, -0x379(%rbp)
je 0x5879
cmpl $0xd, -0x218(%rbp)
setne %al
movb %al, -0x379(%rbp)
movb -0x379(%rbp), %al
testb $0x1, %al
jne 0x57f7
jmp 0x5889
cmpl $0x0, -0x214(%rbp)
jne 0x58d4
movq 0x1df0f(%rip), %rsi     # 0x237a8
leaq 0x17b25(%rip), %rdi     # 0x1d3c5
movb $0x0, %al
callq 0x49e0
cmpq $0x0, 0x1def9(%rip)     # 0x237a8
je 0x58c8
movq 0x1def0(%rip), %rdi     # 0x237a8
callq 0x3050
movq $0x0, 0x1dee0(%rip) # 0x237a8
jmp 0x58ca
callq 0x68a0
jmp 0x5ddb
movq 0x1decd(%rip), %rdi     # 0x237a8
movl $0x241, %esi            # imm = 0x241
movl $0x180, %edx            # imm = 0x180
movb $0x0, %al
callq 0x3480
movl %eax, 0x1dea2(%rip)     # 0x23794
cmpl $0x0, 0x1de9b(%rip)     # 0x23794
jge 0x5945
callq 0x3070
movl (%rax), %eax
movl %eax, -0x38c(%rbp)
movq 0x1de99(%rip), %rax     # 0x237a8
movq %rax, -0x388(%rbp)
callq 0x3070
movl (%rax), %edi
callq 0x3590
movl -0x38c(%rbp), %edi
movq -0x388(%rbp), %rdx
movq %rax, %rcx
leaq 0x17aa0(%rip), %rsi     # 0x1d3d9
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0x122d0
jmp 0x5947
cmpl $0x1, 0x1de62(%rip)     # 0x237b0
jle 0x5976
movq 0x1d6a1(%rip), %rax     # 0x22ff8
movq (%rax), %rdi
movq 0x1de37(%rip), %rdx     # 0x23798
movq 0x1de40(%rip), %rcx     # 0x237a8
leaq 0x17a81(%rip), %rsi     # 0x1d3f0
movb $0x0, %al
callq 0x3340
cmpl $0x0, 0x1de8b(%rip)     # 0x23808
je 0x5c4b
jmp 0x5985
movl $0x1, -0x30c(%rbp)
movl $0x0, -0x240(%rbp)
movl $0x0, -0x23c(%rbp)
movl $0x0, -0x238(%rbp)
movq $0x0, -0x230(%rbp)
callq 0x12220
leaq 0x3e0f0(%rip), %rax     # 0x43ab4
movl (%rax), %edi
callq 0x3110
movq %rax, -0x228(%rbp)
leaq 0x3e0db(%rip), %rax     # 0x43ab4
movl (%rax), %edi
leaq -0x308(%rbp), %rsi
callq 0x35f0
movl %eax, -0x310(%rbp)
cmpl $0x0, -0x310(%rbp)
jne 0x5a00
movb $0x1, %al
testb $0x1, %al
jne 0x59fe
jmp 0x5a00
jmp 0x5a1f
leaq 0x16813(%rip), %rdi     # 0x1c21a
leaq 0x1683c(%rip), %rsi     # 0x1c24a
movl $0x104d, %edx           # imm = 0x104D
leaq 0x178e4(%rip), %rcx     # 0x1d2fe
callq 0x3220
jmp 0x5a21
leaq -0x308(%rbp), %rdi
callq 0x32f0
cmpl $0x0, %eax
jne 0x5a5f
jmp 0x5a34
movl -0xc(%rbp), %eax
cmpl $0x8, %eax
jne 0x5a43
callq 0x8570
jmp 0x5a5b
movl -0xc(%rbp), %eax
cmpl $0x101, %eax            # imm = 0x101
jne 0x5a54
callq 0x9d50
jmp 0x5a59
callq 0xacb0
jmp 0x5a5b
jmp 0x5a5d
jmp 0x5a5f
movl -0x30c(%rbp), %eax
cmpl $0x0, %eax
je 0x5ac5
jmp 0x5a6c
leaq 0x3e041(%rip), %rax     # 0x43ab4
movl (%rax), %edi
movq -0x228(%rbp), %rsi
callq 0x35f0
movl %eax, -0x314(%rbp)
cmpl $0x0, -0x314(%rbp)
jne 0x5a9a
movb $0x1, %al
testb $0x1, %al
jne 0x5a98
jmp 0x5a9a
jmp 0x5ab9
leaq 0x16779(%rip), %rdi     # 0x1c21a
leaq 0x167a2(%rip), %rsi     # 0x1c24a
movl $0x1055, %edx           # imm = 0x1055
leaq 0x1784a(%rip), %rcx     # 0x1d2fe
callq 0x3220
jmp 0x5abb
movl $0x0, -0x30c(%rbp)
movq -0x240(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq -0x238(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x230(%rbp), %rax
movq %rax, -0xb0(%rbp)
cmpl $0x0, -0xbc(%rbp)
je 0x5c49
cmpl $0x21, -0xbc(%rbp)
je 0x5ba0
jmp 0x5b0b
callq 0x12220
leaq 0x3df9d(%rip), %rax     # 0x43ab4
movl (%rax), %edi
callq 0x3110
cmpq $0x0, %rax
je 0x5b2e
movb $0x1, %al
testb $0x1, %al
jne 0x5b2c
jmp 0x5b2e
jmp 0x5b4d
leaq 0x177ee(%rip), %rdi     # 0x1d323
leaq 0x1670e(%rip), %rsi     # 0x1c24a
movl $0x1057, %edx           # imm = 0x1057
leaq 0x177b6(%rip), %rcx     # 0x1d2fe
callq 0x3220
leaq 0x3df60(%rip), %rax     # 0x43ab4
movl (%rax), %edi
callq 0x3110
movq -0xc0(%rbp), %rcx
movq %rcx, 0xc8(%rax)
movq -0xb8(%rbp), %rcx
movq %rcx, 0xd0(%rax)
movq -0xb0(%rbp), %rcx
movq %rcx, 0xd8(%rax)
leaq 0x3df28(%rip), %rax     # 0x43ab4
movl (%rax), %edi
callq 0x3110
movq %rax, %rdi
movl $0x1, %esi
callq 0x3470
movq -0xb0(%rbp), %rsi
leaq 0x1779d(%rip), %rdi     # 0x1d34b
movb $0x0, %al
callq 0x49e0
cmpl $0x0, -0xb8(%rbp)
je 0x5bdf
movq -0xb0(%rbp), %rdi
callq 0x3050
movl $0x0, -0xb8(%rbp)
movq $0x0, -0xb0(%rbp)
jmp 0x5be1
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
movq %rsi, %rdi
callq 0xa9c0
cmpl $-0x1, 0x1db9e(%rip)    # 0x23794
je 0x5c47
cmpl $0x1, 0x1db95(%rip)     # 0x23794
je 0x5c47
movl 0x1db8d(%rip), %edi     # 0x23794
callq 0x3270
movl $0xffffffff, 0x1db7e(%rip) # imm = 0xFFFFFFFF
movq 0x1db8b(%rip), %rdi     # 0x237a8
callq 0x3080
cmpq $0x0, 0x1db7e(%rip)     # 0x237a8
je 0x5c43
movq 0x1db75(%rip), %rdi     # 0x237a8
callq 0x3050
movq $0x0, 0x1db65(%rip) # 0x237a8
jmp 0x5c45
jmp 0x5c47
jmp 0x5c49
jmp 0x5c64
cmpl $0x1, 0x1dbde(%rip)     # 0x23830
jle 0x5c5b
callq 0xad40
jmp 0x5c62
xorl %edi, %edi
callq 0xb350
jmp 0x5c64
cmpl $0x1, 0x1db45(%rip)     # 0x237b0
jle 0x5c90
movq 0x1d384(%rip), %rax     # 0x22ff8
movq (%rax), %rsi
movl $0xa, %edi
callq 0x3310
movq 0x1d370(%rip), %rax     # 0x22ff8
movq (%rax), %rdi
callq 0x33e0
callq 0x68a0
cmpl $-0x1, 0x1daf8(%rip)    # 0x23794
je 0x5db6
cmpl $0x1, 0x1daeb(%rip)     # 0x23794
je 0x5db6
cmpl $0x0, 0x1db0e(%rip)     # 0x237c4
je 0x5cbd
callq 0xc320
movl 0x1dad1(%rip), %edi     # 0x23794
callq 0x3270
cmpl $0x0, %eax
je 0x5d17
callq 0x3070
movl (%rax), %eax
movl %eax, -0x39c(%rbp)
movq 0x1dac7(%rip), %rax     # 0x237a8
movq %rax, -0x398(%rbp)
callq 0x3070
movl (%rax), %edi
callq 0x3590
movl -0x39c(%rbp), %edi
movq -0x398(%rbp), %rdx
movq %rax, %rcx
leaq 0x176ce(%rip), %rsi     # 0x1d3d9
xorl %eax, %eax
movl %eax, %r8d
movb $0x0, %al
callq 0x122d0
movl $0xffffffff, 0x1da73(%rip) # imm = 0xFFFFFFFF
cmpl $0x0, 0x1da68(%rip)     # 0x23790
je 0x5d80
movq 0x1da67(%rip), %rdi     # 0x23798
movq 0x1da70(%rip), %rsi     # 0x237a8
callq 0xc390
cmpl $0x0, 0x1da78(%rip)     # 0x237bc
jne 0x5d7e
cmpq $0x1, -0x98(%rbp)
jbe 0x5d70
cmpl $0x0, 0x1da69(%rip)     # 0x237c0
jne 0x5d70
movq 0x1da38(%rip), %rsi     # 0x23798
leaq 0x17693(%rip), %rdi     # 0x1d3fa
movb $0x0, %al
callq 0x49e0
jmp 0x5d7c
movq 0x1da21(%rip), %rdi     # 0x23798
callq 0x3080
jmp 0x5d7e
jmp 0x5d80
cmpl $0x0, 0x1da81(%rip)     # 0x23808
je 0x5db4
movl 0x1da25(%rip), %eax     # 0x237b4
andl $0x2, %eax
cmpl $0x0, %eax
je 0x5db4
cmpq $0x0, 0x1daa9(%rip)     # 0x23848
je 0x5db4
movq 0x1da00(%rip), %rdi     # 0x237a8
movq 0x1da99(%rip), %rsi     # 0x23848
callq 0xc470
jmp 0x5db6
jmp 0x5db8
cmpq $0x0, 0x1d9e8(%rip)     # 0x237a8
je 0x5dd9
movq 0x1d9df(%rip), %rdi     # 0x237a8
callq 0x3050
movq $0x0, 0x1d9cf(%rip) # 0x237a8
jmp 0x5ddb
addq $0x3a0, %rsp            # imm = 0x3A0
popq %rbp
retq
nopw %cs:(%rax,%rax)