// File: /workspace/github_c_makefile_star2_O1/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 $0xa8, %rsp
cmpl $0x1, 0x1551b(%rip)     # 0x1d388
jne 0x7e7c
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3390
jmp 0x7e87
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3120
movq %rax, 0x8(%rsp)
movq $0x0, 0x20(%rsp)
leaq 0x38(%rsp), %r14
movl $0x0, 0x4(%rsp)
xorl %ebp, %ebp
movq $0x0, 0x28(%rsp)
movq 0x1d5bc(%rip), %rax     # 0x25470
movq %rax, 0x1d5c5(%rip)     # 0x25480
movq $0x0, 0x1d5c2(%rip) # 0x25488
cmpl $0x1, 0x154bb(%rip)     # 0x1d388
jne 0x7edc
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3390
jmp 0x7ee7
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3120
movq %rax, 0x1d5a2(%rip)     # 0x25490
leaq 0x78(%rsp), %rax
xorpd %xmm0, %xmm0
movupd %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %r14, %rdi
movl $0xf, %esi
leaq 0x255de(%rip), %rdx     # 0x2d4f0
leaq 0xe5e5(%rip), %rcx      # 0x164fe
movl $0x70, %r8d
callq 0x3140
testl %eax, %eax
jne 0x8f25
movl $0x0, 0x40(%rsp)
movq $0x0, 0x38(%rsp)
movq %r14, %rdi
leaq 0x3c24(%rip), %rsi      # 0xbb6b
xorl %edx, %edx
leaq 0x197c(%rip), %rcx      # 0x98cc
xorl %r8d, %r8d
callq 0x3350
movl %eax, %r15d
movq %r14, %rdi
callq 0x3170
movl 0x40(%rsp), %eax
addq %rax, 0x1d502(%rip)     # 0x25470
movq 0x38(%rsp), %rax
movq %rax, 0x1d4ee(%rip)     # 0x25468
xorl %esi, %esi
xorl %edx, %edx
callq 0x98cc
cmpl $0x1, %r15d
jne 0x8ef7
movq 0x1d4ec(%rip), %rbx     # 0x25480
movq 0x1d4d5(%rip), %rax     # 0x25470
subq %rax, %rbx
movl 0x153e4(%rip), %ecx     # 0x1d388
cmpl $0x2, %ecx
jl 0x7fd6
cmpl $0x3, %ecx
jne 0x8bb1
testq %rax, %rax
je 0x8031
decq 0x1d4b2(%rip)           # 0x25470
movq 0x1d4a3(%rip), %rax     # 0x25468
leaq 0x1(%rax), %rcx
movq %rcx, 0x1d498(%rip)     # 0x25468
movzbl (%rax), %r14d
jmp 0x8041
cmpl $0x1, %ecx
jne 0x8007
testq %rax, %rax
je 0x8075
decq 0x1d485(%rip)           # 0x25470
movq 0x1d476(%rip), %rax     # 0x25468
leaq 0x1(%rax), %rcx
movq %rcx, 0x1d46b(%rip)     # 0x25468
movzbl (%rax), %r14d
shll $0x18, %r14d
jmp 0x8085
testq %rax, %rax
je 0x80b9
decq 0x1d459(%rip)           # 0x25470
movq 0x1d44a(%rip), %rax     # 0x25468
leaq 0x1(%rax), %rcx
movq %rcx, 0x1d43f(%rip)     # 0x25468
movzbl (%rax), %edx
jmp 0x80c8
cmpl $0x0, 0x1d440(%rip)     # 0x25478
je 0x8690
xorl %r14d, %r14d
cmpq $0x0, 0x1d427(%rip)     # 0x25470
je 0x80fc
decq 0x1d41a(%rip)           # 0x25470
movq 0x1d40b(%rip), %rax     # 0x25468
leaq 0x1(%rax), %rcx
movq %rcx, 0x1d400(%rip)     # 0x25468
movzbl (%rax), %r15d
shll $0x8, %r15d
jmp 0x810c
cmpl $0x0, 0x1d3fc(%rip)     # 0x25478
je 0x86a3
xorl %r14d, %r14d
cmpq $0x0, 0x1d3e3(%rip)     # 0x25470
je 0x813c
decq 0x1d3d6(%rip)           # 0x25470
movq 0x1d3c7(%rip), %rax     # 0x25468
leaq 0x1(%rax), %rcx
movq %rcx, 0x1d3bc(%rip)     # 0x25468
movzbl (%rax), %r15d
shll $0x10, %r15d
jmp 0x814c
cmpl $0x0, 0x1d3b8(%rip)     # 0x25478
je 0x86b6
xorl %edx, %edx
cmpq $0x0, 0x1d3a0(%rip)     # 0x25470
je 0x8180
decq 0x1d393(%rip)           # 0x25470
movq 0x1d384(%rip), %rax     # 0x25468
leaq 0x1(%rax), %rcx
movq %rcx, 0x1d379(%rip)     # 0x25468
movzbl (%rax), %r14d
shll $0x8, %r14d
jmp 0x8190
cmpl $0x0, 0x1d375(%rip)     # 0x25478
je 0x86c9
xorl %r15d, %r15d
cmpq $0x0, 0x1d35c(%rip)     # 0x25470
je 0x81bf
decq 0x1d34f(%rip)           # 0x25470
movq 0x1d340(%rip), %rax     # 0x25468
leaq 0x1(%rax), %rcx
movq %rcx, 0x1d335(%rip)     # 0x25468
movzbl (%rax), %r12d
jmp 0x81cf
cmpl $0x0, 0x1d335(%rip)     # 0x25478
je 0x86dc
xorl %r15d, %r15d
cmpq $0x0, 0x1d31c(%rip)     # 0x25470
je 0x8201
decq 0x1d30f(%rip)           # 0x25470
movq 0x1d300(%rip), %rax     # 0x25468
leaq 0x1(%rax), %rcx
movq %rcx, 0x1d2f5(%rip)     # 0x25468
movzbl (%rax), %r12d
shll $0x8, %r12d
jmp 0x8211
cmpl $0x0, 0x1d2f1(%rip)     # 0x25478
je 0x86ef
xorl %r14d, %r14d
cmpq $0x0, 0x1d2d8(%rip)     # 0x25470
je 0x8241
decq 0x1d2cb(%rip)           # 0x25470
movq 0x1d2bc(%rip), %rax     # 0x25468
leaq 0x1(%rax), %rcx
movq %rcx, 0x1d2b1(%rip)     # 0x25468
movzbl (%rax), %esi
jmp 0x8250
cmpl $0x0, 0x1d2b2(%rip)     # 0x25478
je 0x8708
xorl %r12d, %r12d
cmpq $0x0, 0x1d299(%rip)     # 0x25470
je 0x8284
decq 0x1d28c(%rip)           # 0x25470
movq 0x1d27d(%rip), %rax     # 0x25468
leaq 0x1(%rax), %rcx
movq %rcx, 0x1d272(%rip)     # 0x25468
movzbl (%rax), %eax
shll $0x8, %eax
jmp 0x8293
cmpl $0x0, 0x1d270(%rip)     # 0x25478
je 0x871b
xorl %r12d, %r12d
cmpq $0x0, 0x1d257(%rip)     # 0x25470
je 0x82d6
decq 0x1d24a(%rip)           # 0x25470
movq 0x1d23b(%rip), %rax     # 0x25468
leaq 0x1(%rax), %rcx
movq %rcx, 0x1d230(%rip)     # 0x25468
movzbl (%rax), %r13d
jmp 0x82e6
cmpl $0x0, 0x1d230(%rip)     # 0x25478
je 0x872e
xorl %esi, %esi
cmpq $0x0, 0x1d218(%rip)     # 0x25470
je 0x8313
decq 0x1d20b(%rip)           # 0x25470
movq 0x1d1fc(%rip), %rax     # 0x25468
leaq 0x1(%rax), %rcx
movq %rcx, 0x1d1f1(%rip)     # 0x25468
movzbl (%rax), %r13d
shll $0x8, %r13d
jmp 0x8323
cmpl $0x0, 0x1d1ed(%rip)     # 0x25478
je 0x8747
xorl %eax, %eax
orq %r14, %r15
orl %r12d, %eax
shll $0x10, %eax
orq %r15, %rax
movq %rax, 0x1517a(%rip)     # 0x1d420
cmpq $0x0, 0x1d1c2(%rip)     # 0x25470
je 0x834b
decq 0x1d1b5(%rip)           # 0x25470
movq 0x1d1a6(%rip), %rax     # 0x25468
leaq 0x1(%rax), %rcx
movq %rcx, 0x1d19b(%rip)     # 0x25468
movzbl (%rax), %r14d
jmp 0x835b
cmpl $0x0, 0x1d19b(%rip)     # 0x25478
je 0x875a
xorl %r13d, %r13d
cmpl $0x0, 0x1d18b(%rip)     # 0x25478
jne 0x8f6d
addq %r14, %r15
addq %r12, %r15
orq %r15, %r13
cmpq 0x1d18d(%rip), %r13     # 0x25490
leaq 0x38(%rsp), %r14
je 0x8bf1
jmp 0x8fad
cmpl $0x0, 0x1d15e(%rip)     # 0x25478
je 0x876d
xorl %r13d, %r13d
cmpq $0x0, 0x1d145(%rip)     # 0x25470
je 0x8388
decq 0x1d13c(%rip)           # 0x25470
movq 0x1d12d(%rip), %rax     # 0x25468
leaq 0x1(%rax), %rcx
movq %rcx, 0x1d122(%rip)     # 0x25468
movzbl (%rax), %edi
jmp 0x8397
cmpl $0x0, 0x1d126(%rip)     # 0x25478
je 0x878c
xorl %r14d, %r14d
cmpq $0x0, 0x1d10d(%rip)     # 0x25470
je 0x83c5
decq 0x1d104(%rip)           # 0x25470
movq 0x1d0f5(%rip), %rax     # 0x25468
leaq 0x1(%rax), %rcx
movq %rcx, 0x1d0ea(%rip)     # 0x25468
movzbl (%rax), %r15d
shll $0x8, %r15d
jmp 0x83d5
cmpl $0x0, 0x1d0e9(%rip)     # 0x25478
je 0x879f
xorl %edi, %edi
cmpq $0x0, 0x1d0d1(%rip)     # 0x25470
je 0x83fe
movq %rbp, %r15
decq 0x1d0c5(%rip)           # 0x25470
movq 0x1d0b6(%rip), %rax     # 0x25468
leaq 0x1(%rax), %rcx
movq %rcx, 0x1d0ab(%rip)     # 0x25468
movzbl (%rax), %ebp
shll $0x8, %ebp
jmp 0x8410
cmpl $0x0, 0x1d0ac(%rip)     # 0x25478
je 0x87be
xorl %r15d, %r15d
cmpq $0x0, 0x1d093(%rip)     # 0x25470
je 0x8439
decq 0x1d08a(%rip)           # 0x25470
movq 0x1d07b(%rip), %rax     # 0x25468
leaq 0x1(%rax), %rcx
movq %rcx, 0x1d070(%rip)     # 0x25468
movzbl (%rax), %r12d
jmp 0x8449
cmpl $0x0, 0x1d073(%rip)     # 0x25478
je 0x87d1
movq %rbp, %r15
xorl %ebp, %ebp
cmpq $0x0, 0x1d058(%rip)     # 0x25470
je 0x8474
decq 0x1d04f(%rip)           # 0x25470
movq 0x1d040(%rip), %rax     # 0x25468
leaq 0x1(%rax), %rcx
movq %rcx, 0x1d035(%rip)     # 0x25468
movzbl (%rax), %r12d
jmp 0x8484
cmpl $0x0, 0x1d038(%rip)     # 0x25478
je 0x8800
xorl %r12d, %r12d
cmpq $0x0, 0x1d01f(%rip)     # 0x25470
je 0x84af
decq 0x1d016(%rip)           # 0x25470
movq 0x1d007(%rip), %rax     # 0x25468
leaq 0x1(%rax), %rcx
movq %rcx, 0x1cffc(%rip)     # 0x25468
movzbl (%rax), %eax
shll $0x8, %eax
jmp 0x84be
cmpl $0x0, 0x1cffd(%rip)     # 0x25478
je 0x8813
xorl %r12d, %r12d
cmpq $0x0, 0x1cfe4(%rip)     # 0x25470
je 0x84fa
decq 0x1cfdb(%rip)           # 0x25470
movq 0x1cfcc(%rip), %rax     # 0x25468
leaq 0x1(%rax), %rcx
movq %rcx, 0x1cfc1(%rip)     # 0x25468
movzbl (%rax), %eax
shll $0x8, %eax
jmp 0x8509
cmpl $0x0, 0x1cfc2(%rip)     # 0x25478
je 0x8840
xorl %eax, %eax
orq %r14, %r15
orl %r12d, %eax
shll $0x10, %eax
orq %r15, %rax
movq %rax, 0x14f57(%rip)     # 0x1d428
cmpq $0x0, 0x1cf97(%rip)     # 0x25470
je 0x8555
decq 0x1cf8e(%rip)           # 0x25470
movq 0x1cf7f(%rip), %rax     # 0x25468
leaq 0x1(%rax), %rcx
movq %rcx, 0x1cf74(%rip)     # 0x25468
movzbl (%rax), %r14d
jmp 0x8565
cmpl $0x0, 0x1cf77(%rip)     # 0x25478
je 0x8853
xorl %eax, %eax
cmpl $0x0, 0x1cf68(%rip)     # 0x25478
jne 0x8f6d
orq %rdx, %r14
orl %esi, %r13d
shll $0x10, %r13d
orq %r14, %r13
cmpq 0x1cf66(%rip), %r13     # 0x25490
jne 0x8f8d
orq %rdi, %rbp
orl %r12d, %eax
shll $0x10, %eax
orq %rbp, %rax
cmpl 0x1cf46(%rip), %eax     # 0x25488
movq %r15, %rbp
leaq 0x38(%rsp), %r14
je 0x8bf1
jmp 0x8f9d
cmpl $0x0, 0x1cf1c(%rip)     # 0x25478
je 0x8884
xorl %r14d, %r14d
cmpq $0x0, 0x1cf03(%rip)     # 0x25470
je 0x8592
decq 0x1cefa(%rip)           # 0x25470
movq 0x1ceeb(%rip), %rax     # 0x25468
leaq 0x1(%rax), %rcx
movq %rcx, 0x1cee0(%rip)     # 0x25468
movzbl (%rax), %r15d
shll $0x8, %r15d
jmp 0x85a2
cmpl $0x0, 0x1cedf(%rip)     # 0x25478
je 0x8897
xorl %r15d, %r15d
cmpq $0x0, 0x1cec6(%rip)     # 0x25470
je 0x85cb
decq 0x1cebd(%rip)           # 0x25470
movq 0x1ceae(%rip), %rax     # 0x25468
leaq 0x1(%rax), %rcx
movq %rcx, 0x1cea3(%rip)     # 0x25468
movzbl (%rax), %r12d
jmp 0x85db
cmpl $0x0, 0x1cea6(%rip)     # 0x25478
je 0x88aa
xorl %r12d, %r12d
cmpq $0x0, 0x1ce8d(%rip)     # 0x25470
je 0x8606
decq 0x1ce84(%rip)           # 0x25470
movq 0x1ce75(%rip), %rax     # 0x25468
leaq 0x1(%rax), %rcx
movq %rcx, 0x1ce6a(%rip)     # 0x25468
movzbl (%rax), %eax
shll $0x8, %eax
jmp 0x8615
cmpl $0x0, 0x1ce6b(%rip)     # 0x25478
je 0x88bd
xorl %eax, %eax
orq %r14, %r15
orl %r12d, %eax
shll $0x10, %eax
orq %r15, %rax
movq %rax, 0x14e08(%rip)     # 0x1d430
cmpq $0x8074b50, 0x14ded(%rip) # imm = 0x8074B50
leaq 0x38(%rsp), %r14
jne 0x89fa
cmpq $0x8074b50, 0x1ce47(%rip) # imm = 0x8074B50
jne 0x88e4
cmpq $0x8074b50, 0x14dce(%rip) # imm = 0x8074B50
jne 0x89fa
cmpl $0x8074b50, %ebx        # imm = 0x8074B50
jne 0x88e4
cmpl $0x8074b50, %eax        # imm = 0x8074B50
jne 0x89fa
cmpl $0x0, 0x14dba(%rip)     # 0x1d438
jne 0x88d0
movq 0x1cdfd(%rip), %rcx     # 0x25488
jmp 0x88d7
callq 0xadbc
testq %rax, %rax
jne 0x7fb7
jmp 0x803e
callq 0xadbc
testq %rax, %rax
jne 0x7fe4
jmp 0x8082
callq 0xadbc
testq %rax, %rax
jne 0x8010
jmp 0x80c6
callq 0xadbc
testq %rax, %rax
jne 0x804f
jmp 0x8109
callq 0xadbc
testq %rax, %rax
jne 0x8093
jmp 0x8149
movq %rdx, %r14
callq 0xadbc
movq %r14, %rdx
testq %rax, %rax
jne 0x80d6
jmp 0x818d
callq 0xadbc
testq %rax, %rax
jne 0x811a
jmp 0x81cc
callq 0xadbc
testq %rax, %rax
jne 0x815a
jmp 0x820e
movq %rdx, %r15
callq 0xadbc
movq %r15, %rdx
testq %rax, %rax
jne 0x819e
jmp 0x824e
callq 0xadbc
testq %rax, %rax
jne 0x81dd
jmp 0x8291
callq 0xadbc
testq %rax, %rax
jne 0x821f
jmp 0x82e3
movq %rdx, %r15
movq %rsi, %r12
callq 0xadbc
movq %r12, %rsi
movq %r15, %rdx
testq %rax, %rax
jne 0x825e
jmp 0x8320
callq 0xadbc
testq %rax, %rax
jne 0x82b4
jmp 0x8358
movq %rdx, %r15
movq %rsi, %r12
callq 0xadbc
movq %r12, %rsi
movq %r15, %rdx
testq %rax, %rax
jne 0x832d
jmp 0x8395
callq 0xadbc
testq %rax, %rax
jne 0x8365
jmp 0x83d2
movq %rdx, %r15
movq %rsi, %r12
movq %rbp, 0x10(%rsp)
movq %rdi, %rbp
callq 0xadbc
movq %rbp, %rdi
movq 0x10(%rsp), %rbp
movq %r12, %rsi
movq %r15, %rdx
testq %rax, %rax
jne 0x83a1
jmp 0x840b
callq 0xadbc
testq %rax, %rax
jne 0x83df
jmp 0x8446
movq %rdx, 0x10(%rsp)
movq %rsi, %r12
movq %rdi, 0x18(%rsp)
callq 0xadbc
movq 0x18(%rsp), %rdi
movq %r12, %rsi
movq 0x10(%rsp), %rdx
testq %rax, %rax
jne 0x841a
jmp 0x8481
callq 0xadbc
testq %rax, %rax
jne 0x8453
jmp 0x84bc
movq %rdx, 0x10(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdi, 0x18(%rsp)
callq 0xadbc
movq 0x18(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x10(%rsp), %rdx
testq %rax, %rax
jne 0x848e
jmp 0x8507
callq 0xadbc
testq %rax, %rax
jne 0x84db
jmp 0x8562
callq 0xadbc
testq %rax, %rax
jne 0x856f
jmp 0x859f
callq 0xadbc
testq %rax, %rax
jne 0x85ac
jmp 0x85d8
callq 0xadbc
testq %rax, %rax
jne 0x85e5
jmp 0x8613
movq %rbx, %rcx
shrq $0x20, %rcx
cmpq $0x8074b50, %rcx        # imm = 0x8074B50
je 0x89fa
movq 0x14b3d(%rip), %rcx     # 0x1d428
movq %rcx, 0x14b2e(%rip)     # 0x1d420
movq %rax, 0x14b2f(%rip)     # 0x1d428
cmpq $0x0, 0x1cb6f(%rip)     # 0x25470
je 0x8922
decq 0x1cb66(%rip)           # 0x25470
movq 0x1cb57(%rip), %rax     # 0x25468
leaq 0x1(%rax), %rcx
movq %rcx, 0x1cb4c(%rip)     # 0x25468
movzbl (%rax), %r14d
jmp 0x8932
cmpl $0x0, 0x1cb4f(%rip)     # 0x25478
je 0x8d1f
xorl %r14d, %r14d
cmpq $0x0, 0x1cb36(%rip)     # 0x25470
je 0x895f
decq 0x1cb2d(%rip)           # 0x25470
movq 0x1cb1e(%rip), %rax     # 0x25468
leaq 0x1(%rax), %rcx
movq %rcx, 0x1cb13(%rip)     # 0x25468
movzbl (%rax), %r15d
shll $0x8, %r15d
jmp 0x896f
cmpl $0x0, 0x1cb12(%rip)     # 0x25478
je 0x8d32
xorl %r15d, %r15d
cmpq $0x0, 0x1caf9(%rip)     # 0x25470
je 0x8998
decq 0x1caf0(%rip)           # 0x25470
movq 0x1cae1(%rip), %rax     # 0x25468
leaq 0x1(%rax), %rcx
movq %rcx, 0x1cad6(%rip)     # 0x25468
movzbl (%rax), %r12d
jmp 0x89a8
cmpl $0x0, 0x1cad9(%rip)     # 0x25478
je 0x8d45
xorl %r12d, %r12d
cmpq $0x0, 0x1cac0(%rip)     # 0x25470
je 0x89d3
decq 0x1cab7(%rip)           # 0x25470
movq 0x1caa8(%rip), %rax     # 0x25468
leaq 0x1(%rax), %rcx
movq %rcx, 0x1ca9d(%rip)     # 0x25468
movzbl (%rax), %eax
shll $0x8, %eax
jmp 0x89e2
cmpl $0x0, 0x1ca9e(%rip)     # 0x25478
je 0x8d58
xorl %eax, %eax
orq %r14, %r15
orl %r12d, %eax
shll $0x10, %eax
orq %r15, %rax
movq %rax, 0x14a3b(%rip)     # 0x1d430
leaq 0x38(%rsp), %r14
cmpl $0x0, 0x14a37(%rip)     # 0x1d438
je 0x8ba4
cmpq $0x0, 0x1ca61(%rip)     # 0x25470
je 0x8a30
decq 0x1ca58(%rip)           # 0x25470
movq 0x1ca49(%rip), %rax     # 0x25468
leaq 0x1(%rax), %rcx
movq %rcx, 0x1ca3e(%rip)     # 0x25468
movzbl (%rax), %r14d
jmp 0x8a40
cmpl $0x0, 0x1ca41(%rip)     # 0x25478
je 0x8c87
xorl %r14d, %r14d
cmpq $0x0, 0x1ca28(%rip)     # 0x25470
je 0x8a6d
decq 0x1ca1f(%rip)           # 0x25470
movq 0x1ca10(%rip), %rax     # 0x25468
leaq 0x1(%rax), %rcx
movq %rcx, 0x1ca05(%rip)     # 0x25468
movzbl (%rax), %r15d
shll $0x8, %r15d
jmp 0x8a7d
cmpl $0x0, 0x1ca04(%rip)     # 0x25478
je 0x8c9a
xorl %r15d, %r15d
cmpq $0x0, 0x1c9eb(%rip)     # 0x25470
je 0x8aa6
decq 0x1c9e2(%rip)           # 0x25470
movq 0x1c9d3(%rip), %rax     # 0x25468
leaq 0x1(%rax), %rcx
movq %rcx, 0x1c9c8(%rip)     # 0x25468
movzbl (%rax), %r12d
jmp 0x8ab6
cmpl $0x0, 0x1c9cb(%rip)     # 0x25478
je 0x8cad
xorl %r12d, %r12d
cmpq $0x0, 0x1c9b2(%rip)     # 0x25470
je 0x8ae1
decq 0x1c9a9(%rip)           # 0x25470
movq 0x1c99a(%rip), %rax     # 0x25468
leaq 0x1(%rax), %rcx
movq %rcx, 0x1c98f(%rip)     # 0x25468
movzbl (%rax), %eax
shll $0x8, %eax
jmp 0x8af0
cmpl $0x0, 0x1c990(%rip)     # 0x25478
je 0x8cc0
xorl %eax, %eax
orq %r14, %r15
orl %r12d, %eax
shll $0x10, %eax
orq %r15, %rax
movq %rax, 0x1492d(%rip)     # 0x1d430
cmpq $0x0, 0x1c965(%rip)     # 0x25470
je 0x8b1d
decq 0x1c95c(%rip)           # 0x25470
incq 0x1c94d(%rip)           # 0x25468
jmp 0x8b2a
cmpl $0x0, 0x1c954(%rip)     # 0x25478
je 0x8cd3
cmpq $0x0, 0x1c93e(%rip)     # 0x25470
leaq 0x38(%rsp), %r14
je 0x8b49
decq 0x1c930(%rip)           # 0x25470
incq 0x1c921(%rip)           # 0x25468
jmp 0x8b56
cmpl $0x0, 0x1c928(%rip)     # 0x25478
je 0x8ce6
cmpq $0x0, 0x1c912(%rip)     # 0x25470
je 0x8b70
decq 0x1c909(%rip)           # 0x25470
incq 0x1c8fa(%rip)           # 0x25468
jmp 0x8b7d
cmpl $0x0, 0x1c901(%rip)     # 0x25478
je 0x8cf9
cmpq $0x0, 0x1c8eb(%rip)     # 0x25470
je 0x8b97
decq 0x1c8e2(%rip)           # 0x25470
incq 0x1c8d3(%rip)           # 0x25468
jmp 0x8ba4
cmpl $0x0, 0x1c8da(%rip)     # 0x25478
je 0x8d0c
cmpl $0x0, 0x1c8cd(%rip)     # 0x25478
jne 0x8fbd
movq 0x14868(%rip), %r13     # 0x1d420
cmpq 0x1c8d1(%rip), %r13     # 0x25490
jne 0x8f7d
movl %ebx, %eax
cmpq %rax, 0x1485a(%rip)     # 0x1d428
jne 0x8f4d
movl 0x1c8ae(%rip), %eax     # 0x25488
cmpq %rax, 0x1484f(%rip)     # 0x1d430
jne 0x8f4d
callq 0xa930
movq %rax, 0x20(%rsp)
cmpl $0x0, 0x147c8(%rip)     # 0x1d3c0
je 0x8c65
movq 0x1c887(%rip), %r15     # 0x25488
cmpl $0x1, 0x14780(%rip)     # 0x1d388
jne 0x8c1c
movq 0x8(%rsp), %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0xbbae
jmp 0x8c2c
movq 0x8(%rsp), %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0xbc7e
movq %rax, 0x8(%rsp)
addq %rbx, %rbp
addq %r15, 0x28(%rsp)
movq %rbx, 0x1c840(%rip)     # 0x25480
movl $0x8, %edi
movq %r13, %rsi
movq %r15, %rdx
movl 0x4(%rsp), %ebx
movl %ebx, %ecx
callq 0x952d
cmpl $0x1, %ebx
movl $0x2, %eax
sbbl $0x0, %eax
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x1471c(%rip)     # 0x1d388
jne 0x8d6b
xorl %edi, %edi
callq 0x6a9b
cmpl $0x8, %eax
je 0x7ead
jmp 0x8d73
callq 0xadbc
testq %rax, %rax
jne 0x8a11
jmp 0x8a3d
callq 0xadbc
testq %rax, %rax
jne 0x8a4a
jmp 0x8a7a
callq 0xadbc
testq %rax, %rax
jne 0x8a87
jmp 0x8ab3
callq 0xadbc
testq %rax, %rax
jne 0x8ac0
jmp 0x8aee
callq 0xadbc
testq %rax, %rax
jne 0x8b0d
jmp 0x8b2a
callq 0xadbc
testq %rax, %rax
jne 0x8b39
jmp 0x8b56
callq 0xadbc
testq %rax, %rax
jne 0x8b60
jmp 0x8b7d
callq 0xadbc
testq %rax, %rax
jne 0x8b87
jmp 0x8ba4
callq 0xadbc
testq %rax, %rax
jne 0x8903
jmp 0x892f
callq 0xadbc
testq %rax, %rax
jne 0x893c
jmp 0x896c
callq 0xadbc
testq %rax, %rax
jne 0x8979
jmp 0x89a5
callq 0xadbc
testq %rax, %rax
jne 0x89b2
jmp 0x89e0
movl $0x1, %r13d
jmp 0x8d76
movl %eax, %r13d
cmpl $0x2, 0x4(%rsp)
setge %cl
movl 0x145ec(%rip), %eax     # 0x1d370
testl %eax, %eax
setg %dl
andb %cl, %dl
cmpb $0x1, %dl
jne 0x8e18
cmpl $0x2, %eax
jl 0x8dac
leaq 0xd8d2(%rip), %rdi      # 0x16672
movq 0x8(%rsp), %rsi
xorl %eax, %eax
callq 0x31d0
movq 0x28(%rsp), %rdx
movq %rdx, %xmm0
movq 0xc262(%rip), %xmm1     # 0x15020
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0xc266(%rip), %xmm2     # 0x15030
subpd %xmm2, %xmm0
movapd %xmm0, %xmm3
unpckhpd %xmm0, %xmm3            # xmm3 = xmm3[1],xmm0[1]
addsd %xmm0, %xmm3
movq %rbp, %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 0xc4c5(%rip), %xmm0     # 0x152c8
divsd %xmm3, %xmm0
leaq 0xd882(%rip), %rdi      # 0x16690
movq %rbp, %rsi
movb $0x1, %al
callq 0x31d0
movl 0x1456a(%rip), %eax     # 0x1d388
cmpl $-0x2, %r13d
jne 0x8e56
testl %eax, %eax
jne 0x8e56
cmpl $0x0, 0x14551(%rip)     # 0x1d380
je 0x8e56
cmpl $0x0, 0x14540(%rip)     # 0x1d378
je 0x8e56
cmpl $0x2, 0x14587(%rip)     # 0x1d3c8
je 0x8e56
cmpl $0x0, 0x14576(%rip)     # 0x1d3c0
jne 0x8e56
callq 0x9b14
jmp 0x8ed9
cmpl $0x0, 0x20(%rsp)
je 0x8e7e
movq 0x144f4(%rip), %rsi     # 0x1d358
leaq 0xd843(%rip), %rdi      # 0x166ae
xorl %eax, %eax
callq 0x476b
movl $0x1, 0x14500(%rip)     # 0x1d37c
jmp 0x8ed9
testl %eax, %eax
jne 0x8ea8
cmpl $-0x1, %r13d
je 0x8ea8
cmpl $0x1, 0x144e1(%rip)     # 0x1d370
jle 0x8ea8
movq 0x144c0(%rip), %rsi     # 0x1d358
leaq 0xd841(%rip), %rdi      # 0x166e0
xorl %eax, %eax
callq 0x476b
jmp 0x8ed9
cmpl $0x1, %eax
jne 0x8ed9
cmpq $0x0, 0x1c5bb(%rip)     # 0x25470
je 0x8ec7
decq 0x1c5b2(%rip)           # 0x25470
incq 0x1c5a3(%rip)           # 0x25468
jmp 0x8ed0
cmpl $0x0, 0x1c5aa(%rip)     # 0x25478
je 0x8eeb
cmpl $0x0, 0x1c5a1(%rip)     # 0x25478
je 0x8e91
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0xadbc
testq %rax, %rax
jne 0x8eb7
jmp 0x8ed0
cmpl $-0x5, %r15d
je 0x8f5d
cmpl $-0x3, %r15d
jne 0x8f38
movq 0x1444e(%rip), %rdx     # 0x1d358
movq 0x68(%rsp), %rcx
leaq 0xd610(%rip), %rsi      # 0x16526
movl $0x21, %edi
xorl %r8d, %r8d
xorl %eax, %eax
callq 0xe575
cmpl $-0x4, %eax
jne 0x8f38
leaq 0xd5d4(%rip), %rsi      # 0x16505
movl $0xc, %edi
jmp 0x8f44
leaq 0xd5d8(%rip), %rsi      # 0x16517
movl $0x16, %edi
xorl %edx, %edx
xorl %eax, %eax
callq 0xe575
movq 0x14404(%rip), %rdx     # 0x1d358
leaq 0xd66c(%rip), %rsi      # 0x165c7
jmp 0x8fcb
movq 0x143f4(%rip), %rdx     # 0x1d358
leaq 0xd5e6(%rip), %rsi      # 0x16551
jmp 0x8fcb
movq 0x143e4(%rip), %rdx     # 0x1d358
leaq 0xd673(%rip), %rsi      # 0x165ee
jmp 0x8fcb
movq 0x143d4(%rip), %rdx     # 0x1d358
leaq 0xd616(%rip), %rsi      # 0x165a1
jmp 0x8fcb
movq 0x143c4(%rip), %rdx     # 0x1d358
leaq 0xd696(%rip), %rsi      # 0x16631
jmp 0x8fcb
movq 0x143b4(%rip), %rdx     # 0x1d358
leaq 0xd6a6(%rip), %rsi      # 0x16651
jmp 0x8fcb
movq 0x143a4(%rip), %rdx     # 0x1d358
leaq 0xd654(%rip), %rsi      # 0x1660f
jmp 0x8fcb
movq 0x14394(%rip), %rdx     # 0x1d358
leaq 0xd5af(%rip), %rsi      # 0x1657a
movl $0x21, %edi
xorl %ecx, %ecx
xorl %eax, %eax
callq 0xe575