// File: /workspace/github_c_makefile_star2_O3/madler[P]pigz/pigz.c
// Function: infchk
local void infchk(void) {
    int ret, cont, more;
    unsigned long check, len, ktot;
    z_stream strm;
    unsigned tmp2;
    unsigned long tmp4;
    length_t clen, ctot, utot;

    ctot = utot = 0;
    ktot = CHECK(0L, Z_NULL, 0);
    cont = more = 0;
    do {
        // header already read -- set up for decompression
        g.in_tot = g.in_left;       // track compressed data length
        g.out_tot = 0;
        g.out_check = CHECK(0L, Z_NULL, 0);
        strm.zalloc = ZALLOC;
        strm.zfree = ZFREE;
        strm.opaque = OPAQUE;
        ret = inflateBackInit(&strm, 15, out_buf);
        if (ret == Z_MEM_ERROR)
            throw(ENOMEM, "not enough memory");
        if (ret != Z_OK)
            throw(EINVAL, "internal error");

        // decompress, compute lengths and check value
        strm.avail_in = 0;
        strm.next_in = Z_NULL;
        ret = inflateBack(&strm, inb, NULL, outb, NULL);
        inflateBackEnd(&strm);
        g.in_left += strm.avail_in;
        g.in_next = strm.next_in;
        outb(NULL, NULL, 0);        // finish off final write and check
        if (ret == Z_DATA_ERROR)
            throw(EDOM, "%s: corrupted -- invalid deflate data (%s)",
                  g.inf, strm.msg);
        if (ret == Z_BUF_ERROR)
            throw(EDOM, "%s: corrupted -- incomplete deflate data", g.inf);
        if (ret != Z_STREAM_END)
            throw(EINVAL, "internal error");

        // compute compressed data length
        clen = g.in_tot - g.in_left;

        // read and check trailer
        if (g.form > 1) {           // zip local trailer (if any)
            if (g.form == 3) {      // data descriptor follows
                // get data descriptor values, assuming no signature
                g.zip_crc = GET4();
                g.zip_clen = GET4();
                g.zip_ulen = GET4();        // ZIP64 -> high clen, not ulen

                // deduce whether or not a signature precedes the values
                if (g.zip_crc == SIG &&         // might be the signature
                    // if the expected CRC is not SIG, then it's a signature
                    (g.out_check != SIG ||      // assume signature
                     // now we're in a very rare case where CRC == SIG -- the
                     // first four bytes could be the signature or the CRC
                     (g.zip_clen == SIG &&      // if not, then no signature
                      // now we have the first two words are SIG and the
                      // expected CRC is SIG, so it could be a signature and
                      // the CRC, or it could be the CRC and a compressed
                      // length that is *also* SIG (!) -- so check the low 32
                      // bits of the expected compressed length for SIG
                      ((clen & LOW32) != SIG || // assume signature and CRC
                       // now the expected CRC *and* the expected low 32 bits
                       // of the compressed length are SIG -- this is so
                       // incredibly unlikely, clearly someone is messing with
                       // us, but we continue ... if the next four bytes are
                       // not SIG, then there is not a signature -- check those
                       // bytes, currently in g.zip_ulen:
                       (g.zip_ulen == SIG &&    // if not, then no signature
                        // we have three SIGs in a row in the descriptor, and
                        // both the expected CRC and the expected clen are SIG
                        // -- the first one is a signature if we don't expect
                        // the third word to be SIG, which is either the low 32
                        // bits of ulen, or if ZIP64, the high 32 bits of clen:
                        (g.zip64 ? clen >> 32 : g.out_tot) != SIG
                        // if that last compare was equal, then the expected
                        // values for the CRC, the low 32 bits of clen, *and*
                        // the low 32 bits of ulen are all SIG (!!), or in the
                        // case of ZIP64, even crazier, the CRC and *both*
                        // 32-bit halves of clen are all SIG (clen > 500
                        // petabytes!!!) ... we can no longer discriminate the
                        // hypotheses, so we will assume no signature
                        ))))) {
                    // first four bytes were actually the descriptor -- shift
                    // the values down and get another four bytes
                    g.zip_crc = g.zip_clen;
                    g.zip_clen = g.zip_ulen;
                    g.zip_ulen = GET4();
                }

                // if ZIP64, then ulen is really the high word of clen -- get
                // the actual ulen and skip its high word as well (we only
                // compare the low 32 bits of the lengths to verify)
                if (g.zip64) {
                    g.zip_ulen = GET4();
                    (void)GET4();
                }
                if (g.in_eof)
                    throw(EDOM, "%s: corrupted entry -- missing trailer",
                          g.inf);
            }
            check = g.zip_crc;
            if (check != g.out_check)
                throw(EDOM, "%s: corrupted entry -- crc32 mismatch", g.inf);
            if (g.zip_clen != (clen & LOW32) ||
                g.zip_ulen != (g.out_tot & LOW32))
                throw(EDOM, "%s: corrupted entry -- length mismatch",
                      g.inf);
            more = more_zip_entries();  // see if more entries, get comment
        }
        else if (g.form == 1) {     // zlib (big-endian) trailer
            check = (unsigned long)(GET()) << 24;
            check += (unsigned long)(GET()) << 16;
            check += (unsigned)(GET()) << 8;
            check += GET();
            if (g.in_eof)
                throw(EDOM, "%s: corrupted -- missing trailer", g.inf);
            if (check != g.out_check)
                throw(EDOM, "%s: corrupted -- adler32 mismatch", g.inf);
        }
        else {                      // gzip trailer
            check = GET4();
            len = GET4();
            if (g.in_eof)
                throw(EDOM, "%s: corrupted -- missing trailer", g.inf);
            if (check != g.out_check)
                throw(EDOM, "%s: corrupted -- crc32 mismatch", g.inf);
            if (len != (g.out_tot & LOW32))
                throw(EDOM, "%s: corrupted -- length mismatch", g.inf);
        }

        // show file information if requested
        if (g.list) {
            ctot += clen;
            utot += g.out_tot;
            ktot = COMB(ktot, check, g.out_tot);
            g.in_tot = clen;
            show_info(8, check, g.out_tot, cont);
            cont = cont ? 2 : 1;
        }

        // if a gzip entry follows a gzip entry, decompress it (don't replace
        // saved header information from first entry)
    } while (g.form == 0 && (ret = get_header(0)) == 8);

    // show totals if more than one gzip member
    if (cont > 1 && g.verbosity > 0) {
        if (g.verbosity > 1)
            printf("        %08lx                ", ktot);
        printf(
#if __STDC_VERSION__-0 >= 199901L || __GNUC__-0 >= 3
               "%10ju %10ju %6.1f%%  (total)\n",
#else
               "%10lu %10lu %6.1f%%  (total)\n",
#endif
               ctot, utot, 100. * (utot - (double)ctot) / utot);
    }

    // gzip -cdf copies junk after gzip stream directly to output
    if (g.form == 0 && ret == -2 && g.force && g.pipeout && g.decode != 2 &&
        !g.list)
        cat();

    // check for more entries in zip file
    else if (more) {
        complain("warning: %s: entries after the first were ignored", g.inf);
        g.keep = 1;         // don't delete the .zip file
    }

    // check for non-gzip after gzip stream, or anything after zlib stream
    else if ((g.verbosity > 1 && g.form == 0 && ret != -1) ||
             (g.form == 1 && (GET(), !g.in_eof)))
        complain("warning: %s: trailing junk was ignored", g.inf);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
cmpl $0x1, 0x152df(%rip)     # 0x1d398
jne 0x80c8
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x33a0
jmp 0x80d3
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3120
movq %rax, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
leaq 0x28(%rsp), %r12
xorl %ebp, %ebp
movq $0x0, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x1d37f(%rip), %rax     # 0x25480
movq %rax, 0x1d388(%rip)     # 0x25490
movq $0x0, 0x1d385(%rip) # 0x25498
cmpl $0x1, 0x1527e(%rip)     # 0x1d398
jne 0x8129
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x33a0
jmp 0x8134
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3120
movq %rax, 0x1d365(%rip)     # 0x254a0
leaq 0x68(%rsp), %rax
xorpd %xmm0, %xmm0
movupd %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %r12, %rdi
movl $0xf, %esi
leaq 0x253a1(%rip), %rdx     # 0x2d500
leaq 0xe398(%rip), %rcx      # 0x164fe
movl $0x70, %r8d
callq 0x3140
testl %eax, %eax
jne 0x91e6
movl $0x0, 0x30(%rsp)
movq $0x0, 0x28(%rsp)
movq %r12, %rdi
leaq 0x3dba(%rip), %rsi      # 0xbf4e
xorl %edx, %edx
leaq 0x1a2c(%rip), %rcx      # 0x9bc9
xorl %r8d, %r8d
callq 0x3360
movl %eax, %r15d
movq %r12, %rdi
callq 0x3170
movl 0x30(%rsp), %eax
addq %rax, 0x1d2c5(%rip)     # 0x25480
movq 0x28(%rsp), %rax
movq %rax, 0x1d2b1(%rip)     # 0x25478
xorl %esi, %esi
xorl %edx, %edx
callq 0x9bc9
cmpl $0x1, %r15d
jne 0x91b8
movq 0x1d2af(%rip), %rbx     # 0x25490
movq 0x1d298(%rip), %rcx     # 0x25480
subq %rcx, %rbx
movl 0x151a7(%rip), %eax     # 0x1d398
cmpl $0x2, %eax
jl 0x82f5
cmpl $0x3, %eax
jne 0x8e79
testq %rcx, %rcx
je 0x8562
decq %rcx
movq %rcx, 0x1d26a(%rip)     # 0x25480
movq 0x1d25b(%rip), %rax     # 0x25478
leaq 0x1(%rax), %rdx
movq %rdx, 0x1d250(%rip)     # 0x25478
movzbl (%rax), %r14d
testq %rcx, %rcx
je 0x8589
decq %rcx
movq %rcx, 0x1d241(%rip)     # 0x25480
movq 0x1d232(%rip), %rax     # 0x25478
leaq 0x1(%rax), %rdx
movq %rdx, 0x1d227(%rip)     # 0x25478
movzbl (%rax), %eax
shll $0x8, %eax
orq %rax, %r14
testq %rcx, %rcx
je 0x85d7
decq %rcx
movq %rcx, 0x1d213(%rip)     # 0x25480
movq 0x1d204(%rip), %rax     # 0x25478
leaq 0x1(%rax), %rdx
movq %rdx, 0x1d1f9(%rip)     # 0x25478
movzbl (%rax), %r15d
testq %rcx, %rcx
je 0x87ad
decq %rcx
movq %rcx, 0x1d1ea(%rip)     # 0x25480
movq 0x1d1db(%rip), %rax     # 0x25478
leaq 0x1(%rax), %rdx
movq %rdx, 0x1d1d0(%rip)     # 0x25478
movzbl (%rax), %eax
shll $0x8, %eax
orl %r15d, %eax
shll $0x10, %eax
orq %r14, %rax
movq %rax, 0x15172(%rip)     # 0x1d430
testq %rcx, %rcx
je 0x8869
decq %rcx
movq %rcx, 0x1d1af(%rip)     # 0x25480
movq 0x1d1a0(%rip), %rax     # 0x25478
leaq 0x1(%rax), %rdx
movq %rdx, 0x1d195(%rip)     # 0x25478
movzbl (%rax), %r15d
testq %rcx, %rcx
jne 0x8659
jmp 0x85f8
cmpl $0x1, %eax
jne 0x8453
testq %rcx, %rcx
jne 0x8325
cmpl $0x0, 0x1d17e(%rip)     # 0x25488
jne 0x920e
callq 0xb08c
movq 0x1d164(%rip), %rcx     # 0x25480
testq %rax, %rax
je 0x883a
decq %rcx
movq %rcx, 0x1d151(%rip)     # 0x25480
movq 0x1d142(%rip), %rax     # 0x25478
leaq 0x1(%rax), %rdx
movq %rdx, 0x1d137(%rip)     # 0x25478
movzbl (%rax), %r14d
shll $0x18, %r14d
testq %rcx, %rcx
jne 0x8370
cmpl $0x0, 0x1d133(%rip)     # 0x25488
jne 0x920e
callq 0xb08c
movq 0x1d119(%rip), %rcx     # 0x25480
testq %rax, %rax
je 0x8842
decq %rcx
movq %rcx, 0x1d106(%rip)     # 0x25480
movq 0x1d0f7(%rip), %rax     # 0x25478
leaq 0x1(%rax), %rdx
movq %rdx, 0x1d0ec(%rip)     # 0x25478
movzbl (%rax), %r13d
shll $0x10, %r13d
testq %rcx, %rcx
jne 0x83bb
cmpl $0x0, 0x1d0e8(%rip)     # 0x25488
jne 0x920e
callq 0xb08c
movq 0x1d0ce(%rip), %rcx     # 0x25480
testq %rax, %rax
je 0x884a
decq %rcx
movq %rcx, 0x1d0bb(%rip)     # 0x25480
movq 0x1d0ac(%rip), %rax     # 0x25478
leaq 0x1(%rax), %rdx
movq %rdx, 0x1d0a1(%rip)     # 0x25478
movzbl (%rax), %r12d
shll $0x8, %r12d
testq %rcx, %rcx
jne 0x8406
cmpl $0x0, 0x1d09d(%rip)     # 0x25488
jne 0x920e
callq 0xb08c
testq %rax, %rax
je 0x885a
movq 0x1d07a(%rip), %rcx     # 0x25480
decq %rcx
movq %rcx, 0x1d070(%rip)     # 0x25480
movq 0x1d061(%rip), %rax     # 0x25478
leaq 0x1(%rax), %rcx
movq %rcx, 0x1d056(%rip)     # 0x25478
movzbl (%rax), %r15d
cmpl $0x0, 0x1d05b(%rip)     # 0x25488
jne 0x920e
addq %r14, %r13
addq %r12, %r13
orq %r13, %r15
cmpq 0x1d05d(%rip), %r15     # 0x254a0
leaq 0x28(%rsp), %r12
je 0x8eb9
jmp 0x927e
testq %rcx, %rcx
je 0x8574
decq %rcx
movq %rcx, 0x1d01a(%rip)     # 0x25480
movq 0x1d00b(%rip), %rax     # 0x25478
leaq 0x1(%rax), %rdx
movq %rdx, 0x1d000(%rip)     # 0x25478
movzbl (%rax), %r13d
testq %rcx, %rcx
je 0x85ae
decq %rcx
movq %rcx, 0x1cff1(%rip)     # 0x25480
movq 0x1cfe2(%rip), %rax     # 0x25478
leaq 0x1(%rax), %rdx
movq %rdx, 0x1cfd7(%rip)     # 0x25478
movzbl (%rax), %eax
shll $0x8, %eax
orq %rax, %r13
testq %rcx, %rcx
je 0x8680
decq %rcx
movq %rcx, 0x1cfc3(%rip)     # 0x25480
movq 0x1cfb4(%rip), %rax     # 0x25478
leaq 0x1(%rax), %rdx
movq %rdx, 0x1cfa9(%rip)     # 0x25478
movzbl (%rax), %r15d
testq %rcx, %rcx
je 0x87d6
decq %rcx
movq %rcx, 0x1cf9a(%rip)     # 0x25480
movq 0x1cf8b(%rip), %rax     # 0x25478
leaq 0x1(%rax), %rdx
movq %rdx, 0x1cf80(%rip)     # 0x25478
movzbl (%rax), %r12d
shll $0x8, %r12d
testq %rcx, %rcx
jne 0x8527
cmpl $0x0, 0x1cf7c(%rip)     # 0x25488
jne 0x920e
callq 0xb08c
movq 0x1cf62(%rip), %rcx     # 0x25480
testq %rax, %rax
je 0x8b19
decq %rcx
movq %rcx, 0x1cf4f(%rip)     # 0x25480
movq 0x1cf40(%rip), %rax     # 0x25478
leaq 0x1(%rax), %rdx
movq %rdx, 0x1cf35(%rip)     # 0x25478
movzbl (%rax), %r14d
orl %r15d, %r12d
shll $0x10, %r12d
orq %r13, %r12
movq %r12, %r15
testq %rcx, %rcx
jne 0x86b8
jmp 0x869a
cmpl $0x0, 0x1cf1f(%rip)     # 0x25488
je 0x8800
xorl %r14d, %r14d
jmp 0x85e4
cmpl $0x0, 0x1cf0d(%rip)     # 0x25488
je 0x881d
xorl %r13d, %r13d
jmp 0x868d
cmpl $0x0, 0x1cef8(%rip)     # 0x25488
jne 0x85e4
callq 0xb08c
movq 0x1cee2(%rip), %rcx     # 0x25480
testq %rax, %rax
jne 0x8235
xorl %eax, %eax
jmp 0x8257
cmpl $0x0, 0x1ced3(%rip)     # 0x25488
jne 0x868d
callq 0xb08c
movq 0x1ceb9(%rip), %rcx     # 0x25480
testq %rax, %rax
jne 0x8485
xorl %eax, %eax
jmp 0x84a7
cmpl $0x0, 0x1ceaa(%rip)     # 0x25488
je 0x8ac2
xorl %r15d, %r15d
shll $0x10, %r15d
orq %r14, %r15
movq %r15, 0x14e3b(%rip)     # 0x1d430
xorl %r15d, %r15d
cmpl $0x0, 0x1ce89(%rip)     # 0x25488
je 0x8644
xorl %r14d, %r14d
shll $0x10, %r14d
orq %r15, %r14
movq %r14, 0x14e26(%rip)     # 0x1d438
xorl %r15d, %r15d
cmpl $0x0, 0x1ce6c(%rip)     # 0x25488
je 0x8628
xorl %r14d, %r14d
xorl %eax, %eax
jmp 0x8992
callq 0xb08c
movq 0x1ce4c(%rip), %rcx     # 0x25480
testq %rax, %rax
jne 0x8919
xorl %eax, %eax
jmp 0x893b
callq 0xb08c
movq 0x1ce30(%rip), %rcx     # 0x25480
testq %rax, %rax
je 0x887e
decq %rcx
movq %rcx, 0x1ce1d(%rip)     # 0x25480
movq 0x1ce0e(%rip), %rax     # 0x25478
leaq 0x1(%rax), %rdx
movq %rdx, 0x1ce03(%rip)     # 0x25478
movzbl (%rax), %eax
shll $0x8, %eax
jmp 0x8880
cmpl $0x0, 0x1ce01(%rip)     # 0x25488
je 0x8adf
xorl %r15d, %r15d
shll $0x10, %r15d
orq %r13, %r15
xorl %r14d, %r14d
cmpl $0x0, 0x1cde7(%rip)     # 0x25488
jne 0x920e
callq 0xb08c
movq 0x1cdcd(%rip), %rcx     # 0x25480
testq %rax, %rax
je 0x86de
decq %rcx
movq %rcx, 0x1cdbe(%rip)     # 0x25480
movq 0x1cdaf(%rip), %rax     # 0x25478
leaq 0x1(%rax), %rdx
movq %rdx, 0x1cda4(%rip)     # 0x25478
movzbl (%rax), %r13d
shll $0x8, %r13d
jmp 0x86e1
xorl %r13d, %r13d
testq %rcx, %rcx
jne 0x8708
cmpl $0x0, 0x1cd9b(%rip)     # 0x25488
jne 0x920e
callq 0xb08c
movq 0x1cd81(%rip), %rcx     # 0x25480
testq %rax, %rax
je 0x8852
decq %rcx
movq %rcx, 0x1cd6e(%rip)     # 0x25480
movq 0x1cd5f(%rip), %rax     # 0x25478
leaq 0x1(%rax), %rdx
movq %rdx, 0x1cd54(%rip)     # 0x25478
movzbl (%rax), %r12d
testq %rcx, %rcx
jne 0x874f
cmpl $0x0, 0x1cd54(%rip)     # 0x25488
jne 0x920e
callq 0xb08c
testq %rax, %rax
je 0x8862
movq 0x1cd31(%rip), %rcx     # 0x25480
decq %rcx
movq %rcx, 0x1cd27(%rip)     # 0x25480
movq 0x1cd18(%rip), %rax     # 0x25478
leaq 0x1(%rax), %rcx
movq %rcx, 0x1cd0d(%rip)     # 0x25478
movzbl (%rax), %eax
shll $0x8, %eax
cmpl $0x0, 0x1cd10(%rip)     # 0x25488
jne 0x920e
cmpq 0x1cd1b(%rip), %r15     # 0x254a0
jne 0x925e
orq %r14, %r13
orl %r12d, %eax
shll $0x10, %eax
orq %r13, %rax
cmpl 0x1ccfb(%rip), %eax     # 0x25498
leaq 0x28(%rsp), %r12
je 0x8eb9
jmp 0x926e
cmpl $0x0, 0x1ccd4(%rip)     # 0x25488
jne 0x85e7
callq 0xb08c
movq 0x1ccba(%rip), %rcx     # 0x25480
testq %rax, %rax
jne 0x828c
xorl %eax, %eax
jmp 0x82ae
cmpl $0x0, 0x1ccab(%rip)     # 0x25488
jne 0x8690
callq 0xb08c
movq 0x1cc91(%rip), %rcx     # 0x25480
testq %rax, %rax
jne 0x84dc
xorl %r12d, %r12d
jmp 0x8500
callq 0xb08c
movq 0x1cc74(%rip), %rcx     # 0x25480
testq %rax, %rax
jne 0x820c
xorl %r14d, %r14d
jmp 0x822c
callq 0xb08c
movq 0x1cc57(%rip), %rcx     # 0x25480
testq %rax, %rax
jne 0x845c
xorl %r13d, %r13d
jmp 0x847c
xorl %r14d, %r14d
jmp 0x8349
xorl %r13d, %r13d
jmp 0x8394
xorl %r12d, %r12d
jmp 0x83df
xorl %r12d, %r12d
jmp 0x8728
xorl %r15d, %r15d
jmp 0x8426
xorl %eax, %eax
jmp 0x8771
cmpl $0x0, 0x1cc18(%rip)     # 0x25488
je 0x8afc
xorl %r15d, %r15d
jmp 0x8601
xorl %eax, %eax
orq %rax, %r15
testq %rcx, %rcx
je 0x8a0a
decq %rcx
movq %rcx, 0x1cbea(%rip)     # 0x25480
movq 0x1cbdb(%rip), %rax     # 0x25478
leaq 0x1(%rax), %rdx
movq %rdx, 0x1cbd0(%rip)     # 0x25478
movzbl (%rax), %r14d
testq %rcx, %rcx
je 0x8a5e
decq %rcx
movq %rcx, 0x1cbc1(%rip)     # 0x25480
movq 0x1cbb2(%rip), %rax     # 0x25478
leaq 0x1(%rax), %rdx
movq %rdx, 0x1cba7(%rip)     # 0x25478
movzbl (%rax), %eax
shll $0x8, %eax
orl %r14d, %eax
shll $0x10, %eax
orq %r15, %rax
movq %rax, 0x14b51(%rip)     # 0x1d438
testq %rcx, %rcx
je 0x8aae
decq %rcx
movq %rcx, 0x1cb86(%rip)     # 0x25480
movq 0x1cb77(%rip), %rax     # 0x25478
leaq 0x1(%rax), %rdx
movq %rdx, 0x1cb6c(%rip)     # 0x25478
movzbl (%rax), %r15d
testq %rcx, %rcx
je 0x8615
decq %rcx
movq %rcx, 0x1cb5d(%rip)     # 0x25480
movq 0x1cb4e(%rip), %rax     # 0x25478
leaq 0x1(%rax), %rdx
movq %rdx, 0x1cb43(%rip)     # 0x25478
movzbl (%rax), %eax
shll $0x8, %eax
orq %rax, %r15
testq %rcx, %rcx
je 0x8a34
decq %rcx
movq %rcx, 0x1cb2f(%rip)     # 0x25480
movq 0x1cb20(%rip), %rax     # 0x25478
leaq 0x1(%rax), %rdx
movq %rdx, 0x1cb15(%rip)     # 0x25478
movzbl (%rax), %r14d
testq %rcx, %rcx
je 0x8a87
decq %rcx
movq %rcx, 0x1cb06(%rip)     # 0x25480
movq 0x1caf7(%rip), %rax     # 0x25478
leaq 0x1(%rax), %rcx
movq %rcx, 0x1caec(%rip)     # 0x25478
movzbl (%rax), %eax
shll $0x8, %eax
addq %rax, %r14
shlq $0x10, %r14
orq %r15, %r14
movq %r14, 0x14a9d(%rip)     # 0x1d440
cmpq $0x8074b50, 0x14a82(%rip) # imm = 0x8074B50
jne 0x8c76
cmpq $0x8074b50, 0x1cae1(%rip) # imm = 0x8074B50
movq 0x14a72(%rip), %rax     # 0x1d438
jne 0x8b52
cmpq $0x8074b50, %rax        # imm = 0x8074B50
jne 0x8c76
cmpl $0x8074b50, %ebx        # imm = 0x8074B50
jne 0x8b52
cmpq $0x8074b50, %r14        # imm = 0x8074B50
jne 0x8c76
cmpl $0x0, 0x14a50(%rip)     # 0x1d448
jne 0x8b3e
movq 0x1ca93(%rip), %rcx     # 0x25498
jmp 0x8b45
cmpl $0x0, 0x1ca77(%rip)     # 0x25488
jne 0x8601
callq 0xb08c
movq 0x1ca5d(%rip), %rcx     # 0x25480
testq %rax, %rax
jne 0x888c
xorl %r14d, %r14d
jmp 0x88ac
cmpl $0x0, 0x1ca4d(%rip)     # 0x25488
jne 0x861e
callq 0xb08c
movq 0x1ca33(%rip), %rcx     # 0x25480
testq %rax, %rax
jne 0x8947
xorl %r14d, %r14d
jmp 0x8967
cmpl $0x0, 0x1ca23(%rip)     # 0x25488
jne 0x8604
callq 0xb08c
movq 0x1ca09(%rip), %rcx     # 0x25480
testq %rax, %rax
jne 0x88b5
xorl %eax, %eax
jmp 0x88d7
cmpl $0x0, 0x1c9fa(%rip)     # 0x25488
jne 0x8621
callq 0xb08c
testq %rax, %rax
je 0x8621
movq 0x1c9d7(%rip), %rcx     # 0x25480
jmp 0x8970
cmpl $0x0, 0x1c9d3(%rip)     # 0x25488
je 0x8b21
xorl %r14d, %r14d
xorl %r15d, %r15d
jmp 0x8621
callq 0xb08c
movq 0x1c9b2(%rip), %rcx     # 0x25480
testq %rax, %rax
jne 0x8263
xorl %r15d, %r15d
jmp 0x8283
callq 0xb08c
movq 0x1c995(%rip), %rcx     # 0x25480
testq %rax, %rax
jne 0x84b3
xorl %r15d, %r15d
jmp 0x84d3
callq 0xb08c
movq 0x1c978(%rip), %rcx     # 0x25480
testq %rax, %rax
jne 0x82c7
xorl %r15d, %r15d
jmp 0x82e7
xorl %r14d, %r14d
jmp 0x8547
callq 0xb08c
movq 0x1c953(%rip), %rcx     # 0x25480
testq %rax, %rax
jne 0x88f0
xorl %r15d, %r15d
jmp 0x8910
movq %rbx, %rcx
shrq $0x20, %rcx
cmpq $0x8074b50, %rcx        # imm = 0x8074B50
je 0x8c76
movq %rax, 0x148d7(%rip)     # 0x1d430
movq %r14, 0x148d8(%rip)     # 0x1d438
movq 0x1c919(%rip), %rcx     # 0x25480
testq %rcx, %rcx
je 0x8c13
decq %rcx
movq %rcx, 0x1c906(%rip)     # 0x25480
movq 0x1c8f7(%rip), %rax     # 0x25478
leaq 0x1(%rax), %rdx
movq %rdx, 0x1c8ec(%rip)     # 0x25478
movzbl (%rax), %r12d
testq %rcx, %rcx
je 0x8c28
decq %rcx
movq %rcx, 0x1c8dd(%rip)     # 0x25480
movq 0x1c8ce(%rip), %rax     # 0x25478
leaq 0x1(%rax), %rdx
movq %rdx, 0x1c8c3(%rip)     # 0x25478
movzbl (%rax), %r14d
shll $0x8, %r14d
orq %r12, %r14
testq %rcx, %rcx
leaq 0x28(%rsp), %r12
je 0x8c44
decq %rcx
movq %rcx, 0x1c8ac(%rip)     # 0x25480
movq 0x1c89d(%rip), %rax     # 0x25478
leaq 0x1(%rax), %rdx
movq %rdx, 0x1c892(%rip)     # 0x25478
movzbl (%rax), %r15d
testq %rcx, %rcx
je 0x8c56
decq %rcx
movq %rcx, 0x1c887(%rip)     # 0x25480
movq 0x1c878(%rip), %rax     # 0x25478
leaq 0x1(%rax), %rcx
movq %rcx, 0x1c86d(%rip)     # 0x25478
movzbl (%rax), %eax
shll $0x8, %eax
jmp 0x8c65
cmpl $0x0, 0x1c86e(%rip)     # 0x25488
je 0x8faf
xorl %r15d, %r15d
xorl %r14d, %r14d
jmp 0x8c63
cmpl $0x0, 0x1c859(%rip)     # 0x25488
je 0x8fcc
xorl %r15d, %r15d
movq %r12, %r14
xorl %eax, %eax
leaq 0x28(%rsp), %r12
jmp 0x8c65
cmpl $0x0, 0x1c83d(%rip)     # 0x25488
je 0x8fe9
xorl %r15d, %r15d
jmp 0x8c63
cmpl $0x0, 0x1c82b(%rip)     # 0x25488
je 0x9006
xorl %eax, %eax
addq %rax, %r15
shlq $0x10, %r15
orq %r14, %r15
movq %r15, 0x147ca(%rip)     # 0x1d440
cmpl $0x0, 0x147cb(%rip)     # 0x1d448
je 0x8e6c
movq 0x1c7f6(%rip), %rcx     # 0x25480
testq %rcx, %rcx
je 0x8d80
decq %rcx
movq %rcx, 0x1c7e3(%rip)     # 0x25480
movq 0x1c7d4(%rip), %rax     # 0x25478
leaq 0x1(%rax), %rdx
movq %rdx, 0x1c7c9(%rip)     # 0x25478
movzbl (%rax), %r14d
testq %rcx, %rcx
je 0x8d92
decq %rcx
movq %rcx, 0x1c7ba(%rip)     # 0x25480
movq 0x1c7ab(%rip), %rax     # 0x25478
leaq 0x1(%rax), %rdx
movq %rdx, 0x1c7a0(%rip)     # 0x25478
movzbl (%rax), %eax
shll $0x8, %eax
orq %rax, %r14
testq %rcx, %rcx
je 0x8db7
decq %rcx
movq %rcx, 0x1c78c(%rip)     # 0x25480
movq 0x1c77d(%rip), %rax     # 0x25478
leaq 0x1(%rax), %rdx
movq %rdx, 0x1c772(%rip)     # 0x25478
movzbl (%rax), %r15d
testq %rcx, %rcx
je 0x8f4c
decq %rcx
movq %rcx, 0x1c763(%rip)     # 0x25480
movq 0x1c754(%rip), %rax     # 0x25478
leaq 0x1(%rax), %rdx
movq %rdx, 0x1c749(%rip)     # 0x25478
movzbl (%rax), %eax
shll $0x8, %eax
orl %r15d, %eax
shll $0x10, %eax
orq %r14, %rax
movq %rax, 0x146fb(%rip)     # 0x1d440
testq %rcx, %rcx
jne 0x8d68
cmpl $0x0, 0x1c737(%rip)     # 0x25488
jne 0x923e
callq 0xb08c
movq 0x1c71d(%rip), %rcx     # 0x25480
testq %rax, %rax
je 0x8d79
decq %rcx
movq %rcx, 0x1c70e(%rip)     # 0x25480
incq 0x1c6ff(%rip)           # 0x25478
testq %rcx, %rcx
jne 0x8df3
jmp 0x8dd5
cmpl $0x0, 0x1c701(%rip)     # 0x25488
je 0x8f75
xorl %r14d, %r14d
jmp 0x8dc4
cmpl $0x0, 0x1c6ef(%rip)     # 0x25488
jne 0x8dc4
callq 0xb08c
movq 0x1c6d9(%rip), %rcx     # 0x25480
testq %rax, %rax
jne 0x8cbc
xorl %eax, %eax
jmp 0x8cde
cmpl $0x0, 0x1c6ca(%rip)     # 0x25488
je 0x8f92
xorl %r15d, %r15d
shll $0x10, %r15d
orq %r14, %r15
movq %r15, 0x1466b(%rip)     # 0x1d440
cmpl $0x0, 0x1c6ac(%rip)     # 0x25488
jne 0x923e
callq 0xb08c
movq 0x1c692(%rip), %rcx     # 0x25480
testq %rax, %rax
je 0x8e04
decq %rcx
movq %rcx, 0x1c683(%rip)     # 0x25480
incq 0x1c674(%rip)           # 0x25478
testq %rcx, %rcx
jne 0x8e27
cmpl $0x0, 0x1c678(%rip)     # 0x25488
jne 0x923e
callq 0xb08c
movq 0x1c65e(%rip), %rcx     # 0x25480
testq %rax, %rax
je 0x8e38
decq %rcx
movq %rcx, 0x1c64f(%rip)     # 0x25480
incq 0x1c640(%rip)           # 0x25478
testq %rcx, %rcx
jne 0x8e5b
cmpl $0x0, 0x1c644(%rip)     # 0x25488
jne 0x923e
callq 0xb08c
testq %rax, %rax
je 0x8e6c
movq 0x1c625(%rip), %rcx     # 0x25480
decq %rcx
movq %rcx, 0x1c61b(%rip)     # 0x25480
incq 0x1c60c(%rip)           # 0x25478
cmpl $0x0, 0x1c615(%rip)     # 0x25488
jne 0x923e
movq 0x145b0(%rip), %r15     # 0x1d430
cmpq 0x1c619(%rip), %r15     # 0x254a0
jne 0x924e
movl %ebx, %eax
cmpq %rax, 0x145a2(%rip)     # 0x1d438
jne 0x921e
movl 0x1c5f6(%rip), %eax     # 0x25498
cmpq %rax, 0x14597(%rip)     # 0x1d440
jne 0x921e
callq 0xac31
movq %rax, 0x10(%rsp)
cmpl $0x0, 0x14510(%rip)     # 0x1d3d0
movl 0x144d2(%rip), %eax     # 0x1d398
je 0x8f2f
movq 0x1c5c9(%rip), %r13     # 0x25498
cmpl $0x1, %eax
jne 0x8ee6
movq 0x8(%rsp), %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0xbf96
jmp 0x8ef6
movq 0x8(%rsp), %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0xc05f
movq %rax, 0x8(%rsp)
addq %rbx, 0x20(%rsp)
addq %r13, 0x18(%rsp)
movq %rbx, 0x1c584(%rip)     # 0x25490
movl $0x8, %edi
movq %r15, %rsi
movq %r13, %rdx
movl %ebp, %ecx
callq 0x9839
cmpl $0x1, %ebp
movl $0x2, %ebp
sbbl $0x0, %ebp
movl 0x14469(%rip), %eax     # 0x1d398
testl %eax, %eax
jne 0x9020
xorl %edi, %edi
callq 0x6a9b
cmpl $0x8, %eax
je 0x80fa
jmp 0x9028
cmpl $0x0, 0x1c535(%rip)     # 0x25488
jne 0x8dc7
callq 0xb08c
movq 0x1c51b(%rip), %rcx     # 0x25480
testq %rax, %rax
jne 0x8d13
xorl %eax, %eax
jmp 0x8d35
callq 0xb08c
movq 0x1c4ff(%rip), %rcx     # 0x25480
testq %rax, %rax
jne 0x8c93
xorl %r14d, %r14d
jmp 0x8cb3
callq 0xb08c
movq 0x1c4e2(%rip), %rcx     # 0x25480
testq %rax, %rax
jne 0x8cea
xorl %r15d, %r15d
jmp 0x8d0a
callq 0xb08c
movq 0x1c4c5(%rip), %rcx     # 0x25480
testq %rax, %rax
jne 0x8b70
xorl %r12d, %r12d
jmp 0x8b90
callq 0xb08c
movq 0x1c4a8(%rip), %rcx     # 0x25480
testq %rax, %rax
jne 0x8b99
xorl %r14d, %r14d
jmp 0x8bbd
callq 0xb08c
movq 0x1c48b(%rip), %rcx     # 0x25480
testq %rax, %rax
jne 0x8bca
xorl %r15d, %r15d
jmp 0x8bea
callq 0xb08c
testq %rax, %rax
je 0x8c63
movq 0x1c465(%rip), %rcx     # 0x25480
jmp 0x8bef
movl $0x1, %r15d
jmp 0x902b
movl %eax, %r15d
cmpl $0x2, %ebp
setge %cl
movl 0x14349(%rip), %eax     # 0x1d380
testl %eax, %eax
setg %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x90cd
cmpl $0x2, %eax
jb 0x905f
leaq 0xd61f(%rip), %rdi      # 0x16672
movq 0x8(%rsp), %rsi
xorl %eax, %eax
callq 0x31d0
movq 0x18(%rsp), %rdx
movq %rdx, %xmm0
movq 0xbfaf(%rip), %xmm1     # 0x15020
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0xbfb3(%rip), %xmm2     # 0x15030
subpd %xmm2, %xmm0
movapd %xmm0, %xmm3
unpckhpd %xmm0, %xmm3            # xmm3 = xmm3[1],xmm0[1]
addsd %xmm0, %xmm3
movq 0x20(%rsp), %rsi
movq %rsi, %xmm0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
subpd %xmm2, %xmm0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movapd %xmm3, %xmm0
subsd %xmm1, %xmm0
mulsd 0xc20d(%rip), %xmm0     # 0x152c8
divsd %xmm3, %xmm0
leaq 0xd5ca(%rip), %rdi      # 0x16690
movb $0x1, %al
callq 0x31d0
movl 0x142c5(%rip), %eax     # 0x1d398
cmpl $-0x2, %r15d
jne 0x910b
testl %eax, %eax
jne 0x910b
cmpl $0x0, 0x142ac(%rip)     # 0x1d390
je 0x910b
cmpl $0x0, 0x1429b(%rip)     # 0x1d388
je 0x910b
cmpl $0x2, 0x142e2(%rip)     # 0x1d3d8
je 0x910b
cmpl $0x0, 0x142d1(%rip)     # 0x1d3d0
jne 0x910b
callq 0x9e11
jmp 0x9193
cmpl $0x0, 0x10(%rsp)
je 0x9133
movq 0x1424f(%rip), %rsi     # 0x1d368
leaq 0xd58e(%rip), %rdi      # 0x166ae
xorl %eax, %eax
callq 0x479d
movl $0x1, 0x1425b(%rip)     # 0x1d38c
jmp 0x9193
testl %eax, %eax
jne 0x915d
cmpl $-0x1, %r15d
je 0x915d
cmpl $0x1, 0x1423c(%rip)     # 0x1d380
jle 0x915d
movq 0x1421b(%rip), %rsi     # 0x1d368
leaq 0xd58c(%rip), %rdi      # 0x166e0
xorl %eax, %eax
callq 0x479d
jmp 0x9193
cmpl $0x1, %eax
jne 0x9193
movq 0x1c317(%rip), %rax     # 0x25480
testq %rax, %rax
je 0x918a
decq %rax
movq %rax, 0x1c308(%rip)     # 0x25480
incq 0x1c2f9(%rip)           # 0x25478
cmpl $0x0, 0x1c302(%rip)     # 0x25488
jne 0x9193
jmp 0x9146
cmpl $0x0, 0x1c2f7(%rip)     # 0x25488
je 0x91a5
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0xb08c
testq %rax, %rax
je 0x917f
movq 0x1c2ca(%rip), %rax     # 0x25480
jmp 0x916e
cmpl $-0x5, %r15d
je 0x922e
cmpl $-0x3, %r15d
jne 0x91f9
movq 0x1419d(%rip), %rdx     # 0x1d368
movq 0x58(%rsp), %rcx
leaq 0xd34f(%rip), %rsi      # 0x16526
movl $0x21, %edi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0xe90d
cmpl $-0x4, %eax
jne 0x91f9
leaq 0xd313(%rip), %rsi      # 0x16505
movl $0xc, %edi
jmp 0x9205
leaq 0xd317(%rip), %rsi      # 0x16517
movl $0x16, %edi
xorl %edx, %edx
xorl %eax, %eax
callq 0xe90d
movq 0x14153(%rip), %rdx     # 0x1d368
leaq 0xd3d2(%rip), %rsi      # 0x165ee
jmp 0x928c
movq 0x14143(%rip), %rdx     # 0x1d368
leaq 0xd39b(%rip), %rsi      # 0x165c7
jmp 0x928c
movq 0x14133(%rip), %rdx     # 0x1d368
leaq 0xd315(%rip), %rsi      # 0x16551
jmp 0x928c
movq 0x14123(%rip), %rdx     # 0x1d368
leaq 0xd32e(%rip), %rsi      # 0x1657a
jmp 0x928c
movq 0x14113(%rip), %rdx     # 0x1d368
leaq 0xd345(%rip), %rsi      # 0x165a1
jmp 0x928c
movq 0x14103(%rip), %rdx     # 0x1d368
leaq 0xd3c5(%rip), %rsi      # 0x16631
jmp 0x928c
movq 0x140f3(%rip), %rdx     # 0x1d368
leaq 0xd3d5(%rip), %rsi      # 0x16651
jmp 0x928c
movq 0x140e3(%rip), %rdx     # 0x1d368
leaq 0xd383(%rip), %rsi      # 0x1660f
movl $0x21, %edi
xorl %ecx, %ecx
xorl %eax, %eax
callq 0xe90d