// File: /workspace/github_c_makefile_star2_O3/madler[P]pigz/pigz.c
// Function: more_zip_entries
local int more_zip_entries(void) {
    unsigned long sig;
    int ret, n;
    unsigned char *first;
    unsigned tmp2;              // for macro
    unsigned long tmp4;         // for macro
    unsigned char const central[] = {0x50, 0x4b, 1, 2};

    sig = GET4();
    ret = !g.in_eof && sig == 0x04034b50;   // true if another entry follows
    if (!g.list || g.verbosity < 2)
        return ret;

    // if it was a central file header signature, then already four bytes
    // into a central directory header -- otherwise search for the next one
    n = sig == 0x02014b50 ? 4 : 0;  // number of bytes into central header
    for (;;) {
        // assure that more input is available
        if (g.in_left == 0 && load() == 0)      // never found it!
            return ret;
        if (n == 0) {
            // look for first byte in central signature
            first = memchr(g.in_next, central[0], g.in_left);
            if (first == NULL) {
                // not found -- go get the next buffer and keep looking
                g.in_left = 0;
            }
            else {
                // found -- continue search at next byte
                n++;
                g.in_left -= first - g.in_next + 1;
                g.in_next = first + 1;
            }
        }
        else if (n < 4) {
            // look for the remaining bytes in the central signature
            if (g.in_next[0] == central[n]) {
                n++;
                g.in_next++;
                g.in_left--;
            }
            else
                n = 0;      // mismatch -- restart search with this byte
        }
        else {
            // Now in a suspected central file header, just past the signature.
            // Read the rest of the fixed-length portion of the header.
            unsigned char head[CEN];
            size_t need = CEN, part = 0, len, i;

            if (need > g.in_left) {     // will only need to do this once
                part = g.in_left;
                memcpy(head + CEN - need, g.in_next, part);
                need -= part;
                g.in_left = 0;
                if (load() == 0)                // never found it!
                    return ret;
            }
            memcpy(head + CEN - need, g.in_next, need);

            // Determine to sufficient probability that this is the droid we're
            // looking for, by checking the CRC and the local header offset.
            if (PULL4L(head + 12) == g.out_check && PULL4L(head + 38) == 0) {
                // Update the number of bytes consumed from the current buffer.
                g.in_next += need;
                g.in_left -= need;

                // Get the comment length.
                len = PULL2L(head + 28);
                if (len == 0)                   // no comment
                    return ret;

                // Skip the file name and extra field.
                SKIP(PULL2L(head + 24) + (unsigned long)PULL2L(head + 26));

                // Save the comment field.
                need = len;
                g.hcomm = alloc(NULL, len + 1);
                while (need > g.in_left) {
                    memcpy(g.hcomm + len - need, g.in_next, g.in_left);
                    need -= g.in_left;
                    g.in_left = 0;
                    if (load() == 0) {          // premature EOF
                        RELEASE(g.hcomm);
                        return ret;
                    }
                }
                memcpy(g.hcomm + len - need, g.in_next, need);
                g.in_next += need;
                g.in_left -= need;
                for (i = 0; i < len; i++)
                    if (g.hcomm[i] == 0)
                        g.hcomm[i] = ' ';
                g.hcomm[len] = 0;
                return ret;
            }
            else {
                // Nope, false alarm. Restart the search at the first byte
                // after what we thought was the central file header signature.
                if (part) {
                    // Move buffer data up and insert the part of the header
                    // data read from the previous buffer.
                    memmove(g.in_next + part, g.in_next, g.in_left);
                    memcpy(g.in_next, head, part);
                    g.in_left += part;
                }
                n = 0;
            }
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq 0x1a83a(%rip), %rcx     # 0x25480
testq %rcx, %rcx
je 0xaceb
decq %rcx
movq %rcx, 0x1a827(%rip)     # 0x25480
movq 0x1a818(%rip), %rax     # 0x25478
leaq 0x1(%rax), %rdx
movq %rdx, 0x1a80d(%rip)     # 0x25478
movzbl (%rax), %r15d
testq %rcx, %rcx
je 0xacff
decq %rcx
movq %rcx, 0x1a7fe(%rip)     # 0x25480
movq 0x1a7ef(%rip), %rax     # 0x25478
leaq 0x1(%rax), %rdx
movq %rdx, 0x1a7e4(%rip)     # 0x25478
movzbl (%rax), %ebx
shll $0x8, %ebx
orq %r15, %rbx
testq %rcx, %rcx
je 0xad14
decq %rcx
movq %rcx, 0x1a7d4(%rip)     # 0x25480
movq 0x1a7c5(%rip), %rax     # 0x25478
leaq 0x1(%rax), %rdx
movq %rdx, 0x1a7ba(%rip)     # 0x25478
movzbl (%rax), %r14d
testq %rcx, %rcx
je 0xad26
decq %rcx
movq %rcx, 0x1a7af(%rip)     # 0x25480
movq 0x1a7a0(%rip), %rax     # 0x25478
leaq 0x1(%rax), %rcx
movq %rcx, 0x1a795(%rip)     # 0x25478
movzbl (%rax), %eax
shll $0x8, %eax
jmp 0xad35
cmpl $0x0, 0x1a796(%rip)     # 0x25488
je 0xaef6
xorl %r14d, %r14d
xorl %ebx, %ebx
jmp 0xad33
cmpl $0x0, 0x1a782(%rip)     # 0x25488
je 0xaf65
xorl %r14d, %r14d
movq %r15, %rbx
jmp 0xad33
cmpl $0x0, 0x1a76d(%rip)     # 0x25488
je 0xaf81
xorl %r14d, %r14d
jmp 0xad33
cmpl $0x0, 0x1a75b(%rip)     # 0x25488
je 0xaf9e
xorl %eax, %eax
addq %rax, %r14
shlq $0x10, %r14
orq %rbx, %r14
cmpl $0x0, 0x1a742(%rip)     # 0x25488
sete %al
cmpq $0x4034b50, %r14        # imm = 0x4034B50
sete %cl
andb %al, %cl
movzbl %cl, %eax
cmpl $0x0, 0x12671(%rip)     # 0x1d3d0
je 0xb07d
cmpl $0x2, 0x12614(%rip)     # 0x1d380
jl 0xb07d
movl %eax, 0xc(%rsp)
xorl %eax, %eax
cmpq $0x2014b50, %r14        # imm = 0x2014B50
sete %al
shll $0x2, %eax
leaq 0x3a(%rsp), %rbp
leaq 0xbd87(%rip), %rbx      # 0x16b18
leaq 0x10(%rsp), %r14
movl %eax, %r15d
cmpq $0x0, 0x1a6df(%rip)     # 0x25480
jne 0xadb1
callq 0xb08c
testq %rax, %rax
je 0xb079
testl %r15d, %r15d
je 0xade8
cmpl $0x3, %r15d
jg 0xae36
movq 0x1a6b5(%rip), %rcx     # 0x25478
movb (%rcx), %dl
movl %r15d, %esi
xorl %eax, %eax
cmpb (%rsi,%rbx), %dl
jne 0xad96
incl %r15d
incq %rcx
movq %rcx, 0x1a69c(%rip)     # 0x25478
decq 0x1a69d(%rip)           # 0x25480
movl %r15d, %eax
jmp 0xad96
movq 0x1a689(%rip), %r12     # 0x25478
movq 0x1a68a(%rip), %r15     # 0x25480
movq %r12, %rdi
movl $0x50, %esi
movq %r15, %rdx
callq 0x32b0
testq %rax, %rax
je 0xaee4
movq %rax, %rcx
notq %rcx
addq %r12, %r15
addq %rcx, %r15
movq %r15, 0x1a65e(%rip)     # 0x25480
incq %rax
movq %rax, 0x1a64c(%rip)     # 0x25478
movl $0x1, %eax
jmp 0xad96
movq 0x1a643(%rip), %r15     # 0x25480
movq 0x1a634(%rip), %r12     # 0x25478
cmpq $0x29, %r15
ja 0xae83
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x3370
movq $0x0, 0x1a61d(%rip) # 0x25480
callq 0xb08c
testq %rax, %rax
je 0xb079
movl $0x2a, %r13d
subq %r15, %r13
movq 0x1a5f7(%rip), %r12     # 0x25478
jmp 0xae8c
movl $0x2a, %r13d
xorl %r15d, %r15d
movq %rbp, %rdi
subq %r13, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x3370
movl 0x1c(%rsp), %eax
cmpq 0x1a5f8(%rip), %rax     # 0x254a0
jne 0xaeb1
cmpl $0x0, 0x36(%rsp)
je 0xaf13
testq %r15, %r15
je 0xaeef
leaq (%r12,%r15), %rdi
movq 0x1a5bf(%rip), %rdx     # 0x25480
movq %r12, %rsi
callq 0x34a0
movq 0x1a5a8(%rip), %rdi     # 0x25478
movq %r14, %rsi
movq %r15, %rdx
callq 0x3370
addq %r15, 0x1a59e(%rip)     # 0x25480
jmp 0xaeef
movq $0x0, 0x1a591(%rip) # 0x25480
xorl %eax, %eax
jmp 0xad96
callq 0xb08c
movq 0x1a57e(%rip), %rcx     # 0x25480
testq %rax, %rax
jne 0xac4f
xorl %r15d, %r15d
jmp 0xac6f
addq %r13, %r12
movq %r12, 0x1a55b(%rip)     # 0x25478
subq %r13, 0x1a55c(%rip)     # 0x25480
movzwl 0x2c(%rsp), %ebx
testq %rbx, %rbx
je 0xb079
movzwl 0x28(%rsp), %eax
movzwl 0x2a(%rsp), %ecx
addq %rax, %rcx
movq %rcx, %r14
movq 0x1a537(%rip), %rax     # 0x25480
subq %rax, %r14
jbe 0xafb8
callq 0xb08c
movq %r14, %rcx
testq %rax, %rax
jne 0xaf42
movl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
jmp 0xb07d
callq 0xb08c
movq 0x1a50f(%rip), %rcx     # 0x25480
testq %rax, %rax
jne 0xac78
xorl %ebx, %ebx
jmp 0xac9a
callq 0xb08c
movq 0x1a4f3(%rip), %rcx     # 0x25480
testq %rax, %rax
jne 0xaca2
xorl %r14d, %r14d
jmp 0xacc2
callq 0xb08c
testq %rax, %rax
je 0xad33
movq 0x1a4cd(%rip), %rcx     # 0x25480
jmp 0xacc7
subq %rcx, %rax
movq %rax, 0x1a4be(%rip)     # 0x25480
addq %rcx, 0x1a4af(%rip)     # 0x25478
leaq 0x1(%rbx), %rsi
xorl %edi, %edi
callq 0x9def
movq %rax, 0x1244d(%rip)     # 0x1d428
movq %rbx, %r14
movq 0x1a49b(%rip), %rdx     # 0x25480
movq 0x1243c(%rip), %rdi     # 0x1d428
addq %rbx, %rdi
subq %r14, %rdi
movq 0x1a47f(%rip), %rsi     # 0x25478
cmpq %rdx, %r14
jbe 0xb03d
callq 0x3370
subq 0x1a476(%rip), %r14     # 0x25480
movq $0x0, 0x1a46b(%rip) # 0x25480
callq 0xb08c
testq %rax, %rax
jne 0xafde
movq 0x12402(%rip), %rdi     # 0x1d428
testq %rdi, %rdi
je 0xb079
callq 0x3050
movq $0x0, 0x123ed(%rip) # 0x1d428
jmp 0xb079
movq %r14, %rdx
callq 0x3370
addq %r14, 0x1a42c(%rip)     # 0x25478
subq %r14, 0x1a42d(%rip)     # 0x25480
xorl %eax, %eax
movq 0x123cc(%rip), %rcx     # 0x1d428
cmpb $0x0, (%rcx,%rax)
jne 0xb06d
movb $0x20, (%rcx,%rax)
movq 0x123bb(%rip), %rcx     # 0x1d428
incq %rax
cmpq %rax, %rbx
jne 0xb05c
movb $0x0, (%rcx,%rbx)
movl 0xc(%rsp), %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq