// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0xb0, %rsp
movl 0x113cd(%rip), %eax     # 0x1da7e
movl %eax, -0x34(%rbp)
cmpq $0x0, 0x1f1f4(%rip)     # 0x2b8b0
jne 0xc6dc
cmpl $0x0, 0x1f1f3(%rip)     # 0x2b8b8
jne 0xc6d2
callq 0xcd80
cmpq $0x0, %rax
jne 0xc6dc
xorl %eax, %eax
movl %eax, -0x8c(%rbp)
jmp 0xc70c
movq 0x1f1cd(%rip), %rax     # 0x2b8b0
addq $-0x1, %rax
movq %rax, 0x1f1c2(%rip)     # 0x2b8b0
movq 0x1f1b3(%rip), %rax     # 0x2b8a8
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x1f1a5(%rip)     # 0x2b8a8
movzbl (%rax), %eax
movl %eax, -0x8c(%rbp)
movl -0x8c(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x90(%rbp)
cmpq $0x0, 0x1f18a(%rip)     # 0x2b8b0
jne 0xc746
cmpl $0x0, 0x1f189(%rip)     # 0x2b8b8
jne 0xc73c
callq 0xcd80
cmpq $0x0, %rax
jne 0xc746
xorl %eax, %eax
movl %eax, -0x94(%rbp)
jmp 0xc776
movq 0x1f163(%rip), %rax     # 0x2b8b0
addq $-0x1, %rax
movq %rax, 0x1f158(%rip)     # 0x2b8b0
movq 0x1f149(%rip), %rax     # 0x2b8a8
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x1f13b(%rip)     # 0x2b8a8
movzbl (%rax), %eax
movl %eax, -0x94(%rbp)
movl -0x90(%rbp), %eax
movl -0x94(%rbp), %ecx
shll $0x8, %ecx
addl %ecx, %eax
movl %eax, %eax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0xa0(%rbp)
cmpq $0x0, 0x1f110(%rip)     # 0x2b8b0
jne 0xc7c0
cmpl $0x0, 0x1f10f(%rip)     # 0x2b8b8
jne 0xc7b6
callq 0xcd80
cmpq $0x0, %rax
jne 0xc7c0
xorl %eax, %eax
movl %eax, -0xa4(%rbp)
jmp 0xc7f0
movq 0x1f0e9(%rip), %rax     # 0x2b8b0
addq $-0x1, %rax
movq %rax, 0x1f0de(%rip)     # 0x2b8b0
movq 0x1f0cf(%rip), %rax     # 0x2b8a8
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x1f0c1(%rip)     # 0x2b8a8
movzbl (%rax), %eax
movl %eax, -0xa4(%rbp)
movl -0xa4(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0xa8(%rbp)
cmpq $0x0, 0x1f0a6(%rip)     # 0x2b8b0
jne 0xc82a
cmpl $0x0, 0x1f0a5(%rip)     # 0x2b8b8
jne 0xc820
callq 0xcd80
cmpq $0x0, %rax
jne 0xc82a
xorl %eax, %eax
movl %eax, -0xac(%rbp)
jmp 0xc85a
movq 0x1f07f(%rip), %rax     # 0x2b8b0
addq $-0x1, %rax
movq %rax, 0x1f074(%rip)     # 0x2b8b0
movq 0x1f065(%rip), %rax     # 0x2b8a8
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x1f057(%rip)     # 0x2b8a8
movzbl (%rax), %eax
movl %eax, -0xac(%rbp)
movq -0xa0(%rbp), %rax
movl -0xa8(%rbp), %ecx
movl -0xac(%rbp), %edx
shll $0x8, %edx
addl %edx, %ecx
movl %ecx, %ecx
shlq $0x10, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
xorl %eax, %eax
cmpl $0x0, 0x1f030(%rip)     # 0x2b8b8
movb %al, -0xad(%rbp)
jne 0xc8a1
cmpq $0x4034b50, -0x10(%rbp) # imm = 0x4034B50
sete %al
movb %al, -0xad(%rbp)
movb -0xad(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, 0x16f4a(%rip)     # 0x23800
je 0xc8c1
cmpl $0x2, 0x16ef1(%rip)     # 0x237b0
jge 0xc8cc
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xcd69
movq -0x10(%rbp), %rdx
xorl %eax, %eax
movl $0x4, %ecx
cmpq $0x2014b50, %rdx        # imm = 0x2014B50
cmovel %ecx, %eax
movl %eax, -0x18(%rbp)
cmpq $0x0, 0x1efc4(%rip)     # 0x2b8b0
jne 0xc904
callq 0xcd80
cmpq $0x0, %rax
jne 0xc904
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xcd69
cmpl $0x0, -0x18(%rbp)
jne 0xc979
movq 0x1ef97(%rip), %rdi     # 0x2b8a8
movzbl -0x34(%rbp), %esi
movq 0x1ef94(%rip), %rdx     # 0x2b8b0
callq 0x32b0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xc939
movq $0x0, 0x1ef79(%rip) # 0x2b8b0
jmp 0xc974
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movq 0x1ef5b(%rip), %rax     # 0x2b8a8
subq %rax, %rcx
addq $0x1, %rcx
movq 0x1ef55(%rip), %rax     # 0x2b8b0
subq %rcx, %rax
movq %rax, 0x1ef4b(%rip)     # 0x2b8b0
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, 0x1ef34(%rip)     # 0x2b8a8
jmp 0xcd64
cmpl $0x4, -0x18(%rbp)
jge 0xc9d1
movq 0x1ef22(%rip), %rax     # 0x2b8a8
movzbl (%rax), %eax
movslq -0x18(%rbp), %rcx
movzbl -0x34(%rbp,%rcx), %ecx
cmpl %ecx, %eax
jne 0xc9c5
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
movq 0x1ef02(%rip), %rax     # 0x2b8a8
addq $0x1, %rax
movq %rax, 0x1eef7(%rip)     # 0x2b8a8
movq 0x1eef8(%rip), %rax     # 0x2b8b0
addq $-0x1, %rax
movq %rax, 0x1eeed(%rip)     # 0x2b8b0
jmp 0xc9cc
movl $0x0, -0x18(%rbp)
jmp 0xcd62
movq $0x2a, -0x68(%rbp)
movq $0x0, -0x70(%rbp)
movq -0x68(%rbp), %rax
cmpq 0x1eec4(%rip), %rax     # 0x2b8b0
jbe 0xca4c
movq 0x1eebb(%rip), %rax     # 0x2b8b0
movq %rax, -0x70(%rbp)
leaq -0x60(%rbp), %rdi
addq $0x2a, %rdi
xorl %eax, %eax
subq -0x68(%rbp), %rax
addq %rax, %rdi
movq 0x1ee97(%rip), %rsi     # 0x2b8a8
movq -0x70(%rbp), %rdx
callq 0x3360
movq -0x70(%rbp), %rcx
movq -0x68(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x68(%rbp)
movq $0x0, 0x1ee7c(%rip) # 0x2b8b0
callq 0xcd80
cmpq $0x0, %rax
jne 0xca4a
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xcd69
jmp 0xca4c
leaq -0x60(%rbp), %rdi
addq $0x2a, %rdi
xorl %eax, %eax
subq -0x68(%rbp), %rax
addq %rax, %rdi
movq 0x1ee44(%rip), %rsi     # 0x2b8a8
movq -0x68(%rbp), %rdx
callq 0x3360
movzbl -0x54(%rbp), %eax
movzbl -0x53(%rbp), %ecx
shll $0x8, %ecx
addl %ecx, %eax
movl %eax, %eax
movzbl -0x52(%rbp), %ecx
movzbl -0x51(%rbp), %edx
shll $0x8, %edx
addl %edx, %ecx
movl %ecx, %ecx
shlq $0x10, %rcx
addq %rcx, %rax
cmpq 0x1ee37(%rip), %rax     # 0x2b8d0
jne 0xcd0e
movzbl -0x3a(%rbp), %eax
movzbl -0x39(%rbp), %ecx
shll $0x8, %ecx
addl %ecx, %eax
movl %eax, %eax
movzbl -0x38(%rbp), %ecx
movzbl -0x37(%rbp), %edx
shll $0x8, %edx
addl %edx, %ecx
movl %ecx, %ecx
shlq $0x10, %rcx
addq %rcx, %rax
cmpq $0x0, %rax
jne 0xcd0e
movq -0x68(%rbp), %rax
addq 0x1edcf(%rip), %rax     # 0x2b8a8
movq %rax, 0x1edc8(%rip)     # 0x2b8a8
movq -0x68(%rbp), %rcx
movq 0x1edc5(%rip), %rax     # 0x2b8b0
subq %rcx, %rax
movq %rax, 0x1edbb(%rip)     # 0x2b8b0
movzbl -0x44(%rbp), %eax
movzbl -0x43(%rbp), %ecx
shll $0x8, %ecx
addl %ecx, %eax
movl %eax, %eax
movq %rax, -0x78(%rbp)
cmpq $0x0, -0x78(%rbp)
jne 0xcb1a
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xcd69
jmp 0xcb1c
movzbl -0x48(%rbp), %eax
movzbl -0x47(%rbp), %ecx
shll $0x8, %ecx
addl %ecx, %eax
movl %eax, %eax
movzbl -0x46(%rbp), %ecx
movzbl -0x45(%rbp), %edx
shll $0x8, %edx
addl %edx, %ecx
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x88(%rbp)
movq -0x88(%rbp), %rax
cmpq 0x1ed5e(%rip), %rax     # 0x2b8b0
jbe 0xcb85
movq 0x1ed55(%rip), %rcx     # 0x2b8b0
movq -0x88(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x88(%rbp)
callq 0xcd80
cmpq $0x0, %rax
jne 0xcb83
movl $0xfffffffd, -0x4(%rbp) # imm = 0xFFFFFFFD
jmp 0xcd69
jmp 0xcb44
movq -0x88(%rbp), %rcx
movq 0x1ed1d(%rip), %rax     # 0x2b8b0
subq %rcx, %rax
movq %rax, 0x1ed13(%rip)     # 0x2b8b0
movq -0x88(%rbp), %rax
addq 0x1ecfd(%rip), %rax     # 0x2b8a8
movq %rax, 0x1ecf6(%rip)     # 0x2b8a8
movq -0x78(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x78(%rbp), %rsi
addq $0x1, %rsi
xorl %eax, %eax
movl %eax, %edi
callq 0xac60
movq %rax, 0x16c86(%rip)     # 0x23858
movq -0x68(%rbp), %rax
cmpq 0x1ecd3(%rip), %rax     # 0x2b8b0
jbe 0xcc67
movq 0x16c6e(%rip), %rdi     # 0x23858
addq -0x78(%rbp), %rdi
xorl %eax, %eax
subq -0x68(%rbp), %rax
addq %rax, %rdi
movq 0x1ecaa(%rip), %rsi     # 0x2b8a8
movq 0x1ecab(%rip), %rdx     # 0x2b8b0
callq 0x3360
movq 0x1ec9f(%rip), %rcx     # 0x2b8b0
movq -0x68(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x68(%rbp)
movq $0x0, 0x1ec89(%rip) # 0x2b8b0
callq 0xcd80
cmpq $0x0, %rax
jne 0xcc62
jmp 0xcc34
cmpq $0x0, 0x16c1c(%rip)     # 0x23858
je 0xcc55
movq 0x16c13(%rip), %rdi     # 0x23858
callq 0x3050
movq $0x0, 0x16c03(%rip) # 0x23858
jmp 0xcc57
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xcd69
jmp 0xcbd2
movq 0x16bea(%rip), %rdi     # 0x23858
addq -0x78(%rbp), %rdi
xorl %eax, %eax
subq -0x68(%rbp), %rax
addq %rax, %rdi
movq 0x1ec26(%rip), %rsi     # 0x2b8a8
movq -0x68(%rbp), %rdx
callq 0x3360
movq -0x68(%rbp), %rax
addq 0x1ec12(%rip), %rax     # 0x2b8a8
movq %rax, 0x1ec0b(%rip)     # 0x2b8a8
movq -0x68(%rbp), %rcx
movq 0x1ec08(%rip), %rax     # 0x2b8b0
subq %rcx, %rax
movq %rax, 0x1ebfe(%rip)     # 0x2b8b0
movq $0x0, -0x80(%rbp)
movq -0x80(%rbp), %rax
cmpq -0x78(%rbp), %rax
jae 0xccf7
movq 0x16b8d(%rip), %rax     # 0x23858
movq -0x80(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0xcce7
movq 0x16b79(%rip), %rax     # 0x23858
movq -0x80(%rbp), %rcx
movb $0x20, (%rax,%rcx)
jmp 0xcce9
movq -0x80(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x80(%rbp)
jmp 0xccba
movq 0x16b5a(%rip), %rax     # 0x23858
movq -0x78(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xcd69
cmpq $0x0, -0x70(%rbp)
je 0xcd59
movq 0x1eb8c(%rip), %rdi     # 0x2b8a8
addq -0x70(%rbp), %rdi
movq 0x1eb81(%rip), %rsi     # 0x2b8a8
movq 0x1eb82(%rip), %rdx     # 0x2b8b0
callq 0x3490
movq 0x1eb6e(%rip), %rdi     # 0x2b8a8
leaq -0x60(%rbp), %rsi
movq -0x70(%rbp), %rdx
callq 0x3360
movq -0x70(%rbp), %rax
addq 0x1eb5e(%rip), %rax     # 0x2b8b0
movq %rax, 0x1eb57(%rip)     # 0x2b8b0
movl $0x0, -0x18(%rbp)
jmp 0xcd62
jmp 0xcd64
jmp 0xc8e4
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)