// File: /workspace/github_c_makefile_star2_O1/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
cmpq $0x0, 0x1ab2a(%rip)     # 0x25470
je 0xa967
decq 0x1ab21(%rip)           # 0x25470
movq 0x1ab12(%rip), %rax     # 0x25468
leaq 0x1(%rax), %rcx
movq %rcx, 0x1ab07(%rip)     # 0x25468
movzbl (%rax), %r14d
jmp 0xa977
cmpl $0x0, 0x1ab0a(%rip)     # 0x25478
je 0xad70
xorl %r14d, %r14d
cmpq $0x0, 0x1aaf1(%rip)     # 0x25470
je 0xa9a2
decq 0x1aae8(%rip)           # 0x25470
movq 0x1aad9(%rip), %rax     # 0x25468
leaq 0x1(%rax), %rcx
movq %rcx, 0x1aace(%rip)     # 0x25468
movzbl (%rax), %ebx
shll $0x8, %ebx
jmp 0xa9b1
cmpl $0x0, 0x1aacf(%rip)     # 0x25478
je 0xad83
xorl %ebx, %ebx
cmpq $0x0, 0x1aab7(%rip)     # 0x25470
je 0xa9da
decq 0x1aaae(%rip)           # 0x25470
movq 0x1aa9f(%rip), %rax     # 0x25468
leaq 0x1(%rax), %rcx
movq %rcx, 0x1aa94(%rip)     # 0x25468
movzbl (%rax), %r15d
jmp 0xa9ea
cmpl $0x0, 0x1aa97(%rip)     # 0x25478
je 0xad96
xorl %r15d, %r15d
orq %r14, %rbx
cmpq $0x0, 0x1aa7b(%rip)     # 0x25470
je 0xaa18
decq 0x1aa72(%rip)           # 0x25470
movq 0x1aa63(%rip), %rax     # 0x25468
leaq 0x1(%rax), %rcx
movq %rcx, 0x1aa58(%rip)     # 0x25468
movzbl (%rax), %eax
shll $0x8, %eax
jmp 0xaa27
cmpl $0x0, 0x1aa59(%rip)     # 0x25478
je 0xada9
xorl %eax, %eax
orl %r15d, %eax
shll $0x10, %eax
orq %rbx, %rax
cmpl $0x0, 0x1aa41(%rip)     # 0x25478
sete %cl
cmpq $0x4034b50, %rax        # imm = 0x4034B50
sete %dl
andb %cl, %dl
movzbl %dl, %r12d
cmpl $0x0, 0x12970(%rip)     # 0x1d3c0
je 0xad5c
cmpl $0x2, 0x12913(%rip)     # 0x1d370
jl 0xad5c
xorl %r15d, %r15d
cmpq $0x2014b50, %rax        # imm = 0x2014B50
sete %r15b
shll $0x2, %r15d
leaq 0xc09d(%rip), %rbx      # 0x16b18
movl %r12d, 0x4(%rsp)
movl %r15d, %r14d
cmpq $0x0, 0x1a9e5(%rip)     # 0x25470
jne 0xaa9b
callq 0xadbc
testq %rax, %rax
je 0xad5c
testl %r14d, %r14d
je 0xaad7
cmpl $0x3, %r14d
jg 0xab35
movq 0x1a9b7(%rip), %rax     # 0x25468
movb (%rax), %cl
movl %r14d, %edx
xorl %r15d, %r15d
cmpb (%rdx,%rbx), %cl
jne 0xaa80
incl %r14d
incq %rax
movq %rax, 0x1a99d(%rip)     # 0x25468
decq 0x1a99e(%rip)           # 0x25470
movl %r14d, %r15d
jmp 0xaa80
movq 0x1a98a(%rip), %r15     # 0x25468
movq 0x1a98b(%rip), %r14     # 0x25470
movq %r15, %rdi
movl $0x50, %esi
movq %r14, %rdx
callq 0x32b0
testq %rax, %rax
je 0xab22
movq %rax, %rcx
notq %rcx
addq %r15, %r14
addq %rcx, %r14
movq %r14, 0x1a963(%rip)     # 0x25470
incq %rax
movq %rax, 0x1a951(%rip)     # 0x25468
movl $0x1, %r15d
jmp 0xaa80
movq $0x0, 0x1a943(%rip) # 0x25470
xorl %r15d, %r15d
jmp 0xaa80
movq 0x1a934(%rip), %r14     # 0x25470
cmpq $0x29, %r14
ja 0xab7a
movq 0x1a91f(%rip), %rsi     # 0x25468
leaq 0x10(%rsp), %rdi
movq %r14, %rdx
callq 0x3360
movq $0x0, 0x1a90f(%rip) # 0x25470
callq 0xadbc
testq %rax, %rax
je 0xabf1
movl $0x2a, %r15d
subq %r14, %r15
jmp 0xab83
movl $0x2a, %r15d
xorl %r14d, %r14d
leaq 0x3a(%rsp), %rdi
subq %r15, %rdi
movq 0x1a8d6(%rip), %r12     # 0x25468
movq %r12, %rsi
movq %r15, %rdx
callq 0x3360
movl 0x1c(%rsp), %eax
cmpq 0x1a8e8(%rip), %rax     # 0x25490
jne 0xabb1
cmpl $0x0, 0x36(%rsp)
je 0xac0b
movb $0x1, %r13b
xorl %r15d, %r15d
testq %r14, %r14
je 0xabea
leaq (%r12,%r14), %rdi
movq 0x1a8a9(%rip), %rdx     # 0x25470
movq %r12, %rsi
callq 0x3490
movq 0x1a892(%rip), %rdi     # 0x25468
leaq 0x10(%rsp), %rsi
movq %r14, %rdx
callq 0x3360
addq %r14, 0x1a886(%rip)     # 0x25470
movl 0x4(%rsp), %r12d
jmp 0xabfd
movl $0x4, %r15d
xorl %r13d, %r13d
movl %r12d, %ebp
testb %r13b, %r13b
jne 0xaa80
jmp 0xad5f
addq %r15, %r12
movq %r12, 0x1a853(%rip)     # 0x25468
subq %r15, 0x1a854(%rip)     # 0x25470
movzwl 0x2c(%rsp), %eax
movl $0x4, %r15d
testq %rax, %rax
je 0xac5f
movq %rax, 0x8(%rsp)
movzwl 0x28(%rsp), %eax
movzwl 0x2a(%rsp), %r14d
addq %rax, %r14
movq %r14, %r12
movq 0x1a827(%rip), %r13     # 0x25470
subq %r13, %r14
jbe 0xac69
callq 0xadbc
testq %rax, %rax
jne 0xac3f
movl $0xfffffffd, %ebp       # imm = 0xFFFFFFFD
jmp 0xac7d
xorl %r13d, %r13d
movl 0x4(%rsp), %r12d
jmp 0xabfa
movq %r13, %rax
subq %r12, %rax
movq %rax, 0x1a7fa(%rip)     # 0x25470
addq %r12, 0x1a7eb(%rip)     # 0x25468
cmpq %r13, %r12
jbe 0xac8a
xorl %r13d, %r13d
jmp 0xabea
movq 0x8(%rsp), %r13
leaq 0x1(%r13), %rsi
xorl %edi, %edi
callq 0x9af2
movq %rax, 0x12777(%rip)     # 0x1d418
movq %r13, %r14
movl 0x4(%rsp), %r12d
movq 0x1a7c0(%rip), %rdx     # 0x25470
movq 0x12761(%rip), %rdi     # 0x1d418
addq %r13, %rdi
subq %r14, %rdi
movq 0x1a7a4(%rip), %rsi     # 0x25468
cmpq %rdx, %r14
jbe 0xad0f
callq 0x3360
subq 0x1a79b(%rip), %r14     # 0x25470
movq $0x0, 0x1a790(%rip) # 0x25470
callq 0xadbc
testq %rax, %rax
jne 0xaca9
movq 0x12727(%rip), %rdi     # 0x1d418
testq %rdi, %rdi
je 0xabf7
callq 0x3050
movq $0x0, 0x1270e(%rip) # 0x1d418
jmp 0xabf7
movq %r14, %rdx
callq 0x3360
addq %r14, 0x1a74a(%rip)     # 0x25468
subq %r14, 0x1a74b(%rip)     # 0x25470
cmpq $0x1, %r13
movq %r13, %rax
adcq $0x0, %rax
xorl %ecx, %ecx
movq 0x126df(%rip), %rdx     # 0x1d418
cmpb $0x0, (%rdx,%rcx)
jne 0xad43
movb $0x20, (%rdx,%rcx)
incq %rcx
cmpq %rcx, %rax
jne 0xad32
movq 0x126c6(%rip), %rax     # 0x1d418
movb $0x0, (%rax,%r13)
jmp 0xabf7
movl %r12d, %ebp
movl %ebp, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0xadbc
testq %rax, %rax
jne 0xa948
jmp 0xa974
callq 0xadbc
testq %rax, %rax
jne 0xa981
jmp 0xa9af
callq 0xadbc
testq %rax, %rax
jne 0xa9bb
jmp 0xa9e7
callq 0xadbc
testq %rax, %rax
jne 0xa9f7
jmp 0xaa25