LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/madler[P]pigz/pigz.c
// Function: cut_short
local void cut_short(int sig) {
    if (sig == SIGINT) {
        Trace(("termination by user"));
    }
    if (g.outd != -1 && g.outd != 1) {
        unlink(g.outf);
        RELEASE(g.outf);
        g.outd = -1;
    }
    log_dump();
    _exit(sig < 0 ? -sig : EINTR);
}

// Assembly:
pushq %rbx
movl %edi, %ebx
movl 0x19228(%rip), %eax     # 0x1d364
cmpl $-0x1, %eax
je 0x4178
cmpl $0x1, %eax
je 0x4178
movq 0x1922b(%rip), %rdi     # 0x1d378
callq 0x3080
movq 0x1921f(%rip), %rdi     # 0x1d378
testq %rdi, %rdi
je 0x416e
callq 0x3050
movq $0x0, 0x1920a(%rip) # 0x1d378
movl $0xffffffff, 0x191ec(%rip) # imm = 0xFFFFFFFF
movl %ebx, %eax
negl %eax
testl %ebx, %ebx
movl $0x4, %edi
cmovsl %eax, %edi
callq 0x30a0
// File: /workspace/github_c_makefile_star2_O3/madler[P]pigz/pigz.c
// Function: zlib_vernum
local long zlib_vernum(void) {
    char const *ver = zlibVersion();
    long num = 0;
    int left = 4;
    int comp = 0;
    do {
        if (*ver >= '0' && *ver <= '9')
            comp = 10 * comp + *ver - '0';
        else {
            num = (num << 4) + (comp > 0xf ? 0xf : comp);
            left--;
            if (*ver != '.')
                break;
            comp = 0;
        }
        ver++;
    } while (left);
    return left < 3 ? num << (left << 2) : -1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
movl $0x4, %r14d
callq 0x3530
movl $0xf, %edx
xorl %esi, %esi
movzbl (%rax), %edi
leal -0x30(%rdi), %ecx
cmpb $0x9, %cl
ja 0x41ca
leal (%rsi,%rsi,4), %ecx
leal (%rdi,%rcx,2), %esi
addl $-0x30, %esi
jmp 0x41eb
movq %rbx, %rcx
shlq $0x4, %rcx
cmpl $0xf, %esi
cmovgel %edx, %esi
movslq %esi, %rbx
addq %rcx, %rbx
leal -0x1(%r14), %ecx
xorl %esi, %esi
cmpl $0x2e, %edi
jne 0x41f5
movl %ecx, %r14d
incq %rax
testl %r14d, %r14d
jne 0x41b4
jmp 0x420a
shll $0x2, %ecx
shlq %cl, %rbx
cmpl $0x4, %r14d
movq $-0x1, %rax
cmovgeq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/madler[P]pigz/pigz.c
// Function: complain
local int complain(char *fmt, ...) {
    g.ret = 1;
    va_list ap;
    va_start(ap, fmt);
    message(fmt, ap);
    va_end(ap);
    return 0;
}

// Assembly:
subq $0xd8, %rsp
testb %al, %al
je 0x47df
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
leaq 0x20(%rsp), %rax
movq %rsi, 0x8(%rax)
movq %rdx, 0x10(%rax)
movq %rcx, 0x18(%rax)
movq %r8, 0x20(%rax)
movq %r9, 0x28(%rax)
movl $0x1, 0x18b4e(%rip)     # 0x1d350
movq %rsp, %rsi
movq %rax, 0x10(%rsi)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rsi)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rsi)
callq 0x66dc
addq $0xd8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/madler[P]pigz/pigz.c
// Function: x2nmodp
local crc_t x2nmodp(size_t n, unsigned k) {
    crc_t p = (crc_t)1 << 31;       // x^0 == 1
    while (n) {
        if (n & 1)
            p = multmodp(x2n_table[k & 31], p);
        n >>= 1;
        k++;
    }
    return p;
}

// Assembly:
testq %rdi, %rdi
je 0x6657
movl $0x3, %ecx
movl $0x80000000, %esi       # imm = 0x80000000
leaq 0xeb98(%rip), %rdx      # 0x15190
testb $0x1, %dil
jne 0x6615
movl %esi, %eax
movq %rdi, %r8
shrq %r8
incl %ecx
movl %eax, %esi
cmpq $0x1, %rdi
movq %r8, %rdi
ja 0x65f8
jmp 0x6656
movl %ecx, %eax
andl $0x1f, %eax
movl (%rdx,%rax,4), %r8d
xorl %eax, %eax
movl $0x80000000, %r9d       # imm = 0x80000000
testl %r8d, %r9d
je 0x6636
xorl %esi, %eax
leal -0x1(%r9), %r10d
testl %r8d, %r10d
je 0x6600
shrl %r9d
movl %esi, %r10d
shrl %r10d
movl %r10d, %r11d
xorl $0xedb88320, %r11d      # imm = 0xEDB88320
testb $0x1, %sil
cmovel %r10d, %r11d
movl %r11d, %esi
jmp 0x6626
retq
movl $0x80000000, %eax       # imm = 0x80000000
retq
// File: /workspace/github_c_makefile_star2_O3/madler[P]pigz/pigz.c
// Function: num
local size_t num(char *arg) {
    char *str = arg;
    size_t val = 0;

    if (*str == 0)
        throw(EINVAL, "internal error: empty parameter");
    do {
        if (*str < '0' || *str > '9' ||
            (val && ((~(size_t)0) - (size_t)(*str - '0')) / val < 10))
            throw(EINVAL, "invalid numeric parameter: %s", arg);
        val = val * 10 + (size_t)(*str - '0');
    } while (*++str);
    return val;
}

// Assembly:
pushq %rax
movq %rdi, %rcx
movb (%rdi), %dil
testb %dil, %dil
je 0x66c7
leaq 0x1(%rcx), %r8
xorl %esi, %esi
leal -0x3a(%rdi), %eax
cmpb $-0xa, %al
jb 0x66af
testq %rsi, %rsi
je 0x668f
movb $0x2f, %al
subb %dil, %al
movsbq %al, %rax
xorl %edx, %edx
divq %rsi
cmpq $0x9, %rax
jbe 0x66af
leaq (%rsi,%rsi,4), %rax
movzbl %dil, %edx
leaq (%rdx,%rax,2), %rsi
addq $-0x30, %rsi
movb (%r8), %dil
incq %r8
testb %dil, %dil
jne 0x666f
movq %rsi, %rax
popq %rcx
retq
leaq 0xf0e8(%rip), %rsi      # 0x1579e
movl $0x16, %edi
movq %rcx, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0xe90d
leaq 0xf0b0(%rip), %rsi      # 0x1577e
movl $0x16, %edi
xorl %edx, %edx
xorl %eax, %eax
callq 0xe90d
// File: /workspace/github_c_makefile_star2_O3/madler[P]pigz/pigz.c
// Function: grumble
local int grumble(char *fmt, ...) {
    va_list ap;
    va_start(ap, fmt);
    message(fmt, ap);
    va_end(ap);
    return 0;
}

// Assembly:
subq $0xd8, %rsp
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x685f
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rsi
movq %rdi, 0x10(%rsi)
leaq 0xe0(%rsp), %rax
movq %rax, 0x8(%rsi)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%rsi)
leaq 0xfa46(%rip), %rdi      # 0x162cc
callq 0x66dc
addq $0xd8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/madler[P]pigz/pigz.c
// Function: compressed_suffix
local size_t compressed_suffix(char *nm) {
    size_t len;

    len = strlen(nm);
    if (len > 4) {
        nm += len - 4;
        len = 4;
        if (strcmp(nm, ".zip") == 0 || strcmp(nm, ".ZIP") == 0 ||
            strcmp(nm, ".tgz") == 0)
            return 4;
    }
    if (len > 3) {
        nm += len - 3;
        len = 3;
        if (strcmp(nm, ".gz") == 0 || strcmp(nm, "-gz") == 0 ||
            strcmp(nm, ".zz") == 0 || strcmp(nm, "-zz") == 0)
            return 3;
    }
    if (len > 2) {
        nm += len - 2;
        if (strcmp(nm, ".z") == 0 || strcmp(nm, "-z") == 0 ||
            strcmp(nm, "_z") == 0 || strcmp(nm, ".Z") == 0)
            return 2;
    }
    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x31a0
cmpq $0x5, %rax
jb 0x68f8
addq %rax, %rbx
addq $-0x4, %rbx
leaq 0xec33(%rip), %rsi      # 0x154e6
movq %rbx, %rdi
callq 0x3330
movl $0x4, %r14d
testl %eax, %eax
je 0x6993
leaq 0xf93a(%rip), %rsi      # 0x1620a
movq %rbx, %rdi
callq 0x3330
testl %eax, %eax
je 0x6993
leaq 0xf928(%rip), %rsi      # 0x1620f
movq %rbx, %rdi
callq 0x3330
testl %eax, %eax
jne 0x6908
jmp 0x6993
cmpq $0x3, %rax
je 0x695d
cmpq $0x4, %rax
jne 0x6990
incq %rbx
leaq 0xeb1b(%rip), %rsi      # 0x1542d
movq %rbx, %rdi
callq 0x3330
movl $0x3, %r14d
testl %eax, %eax
je 0x6993
leaq 0xf8d7(%rip), %rsi      # 0x16202
movq %rbx, %rdi
callq 0x3330
testl %eax, %eax
je 0x6993
leaq 0xec85(%rip), %rsi      # 0x155c3
movq %rbx, %rdi
callq 0x3330
testl %eax, %eax
je 0x6993
leaq 0xf8b5(%rip), %rsi      # 0x16206
movq %rbx, %rdi
callq 0x3330
testl %eax, %eax
je 0x6993
movzbl 0x1(%rbx), %eax
cmpl $0x2d, %eax
je 0x6984
cmpl $0x5f, %eax
je 0x6984
cmpl $0x2e, %eax
jne 0x6990
cmpb $0x7a, 0x2(%rbx)
jne 0x697c
cmpb $0x0, 0x3(%rbx)
je 0x699e
cmpb $0x5a, 0x2(%rbx)
je 0x698a
jmp 0x6990
cmpb $0x7a, 0x2(%rbx)
jne 0x6990
cmpb $0x0, 0x3(%rbx)
je 0x699e
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x2, %r14d
jmp 0x6993
// File: /workspace/github_c_makefile_star2_O3/madler[P]pigz/pigz.c
// Function: load_end
local void load_end(void) {
#ifndef NOTHREAD
    // if the read thread is running, then end it
    if (g.in_which != -1) {
        // wait for the previously requested read to complete and send the
        // thread a message to exit
        possess(g.load_state);
        wait_for(g.load_state, TO_BE, 0);
        twist(g.load_state, TO, 2);

        // join the thread (which has exited or will very shortly) and clean up
        join(g.load_thread);
        free_lock(g.load_state);
        g.in_which = -1;
    }
#endif
    g.in_left = 0;
    g.in_short = 1;
    g.in_eof = 1;
    if (g.ind != 0)
        close(g.ind);
    RELEASE(g.hname);
    RELEASE(g.hcomm);
}

// Assembly:
pushq %rbx
cmpl $-0x1, 0x26b32(%rip)    # 0x2d4e0
je 0x6a36
movq 0x26b2d(%rip), %rdi     # 0x2d4e8
leaq 0xe93e(%rip), %rbx      # 0x15300
movl $0xa4e, %edx            # imm = 0xA4E
movq %rbx, %rsi
callq 0xe2b3
movq 0x26b12(%rip), %rdi     # 0x2d4e8
movl $0xa4f, %r8d            # imm = 0xA4F
xorl %esi, %esi
xorl %edx, %edx
movq %rbx, %rcx
callq 0xe36e
movq 0x26af9(%rip), %rdi     # 0x2d4e8
movl $0x2, %edx
movl $0xa50, %r8d            # imm = 0xA50
xorl %esi, %esi
movq %rbx, %rcx
callq 0xe311
movq 0x26ae5(%rip), %rdi     # 0x2d4f0
movl $0xa53, %edx            # imm = 0xA53
movq %rbx, %rsi
callq 0xe610
movq 0x26ac9(%rip), %rdi     # 0x2d4e8
movl $0xa54, %edx            # imm = 0xA54
movq %rbx, %rsi
callq 0xe433
movl $0xffffffff, 0x26aaa(%rip) # imm = 0xFFFFFFFF
movq $0x0, 0x1ea3f(%rip) # 0x25480
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x1ea36(%rip)     # 0x25488
movl 0x16908(%rip), %edi     # 0x1d360
testl %edi, %edi
je 0x6a61
callq 0x3270
movq 0x169b8(%rip), %rdi     # 0x1d420
testq %rdi, %rdi
je 0x6a7d
callq 0x3050
movq $0x0, 0x169a3(%rip) # 0x1d420
movq 0x169a4(%rip), %rdi     # 0x1d428
testq %rdi, %rdi
je 0x6a99
callq 0x3050
movq $0x0, 0x1698f(%rip) # 0x1d428
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/madler[P]pigz/pigz.c
// Function: alloc
local void *alloc(void *ptr, size_t size) {
    ptr = REALLOC(ptr, size);
    if (ptr == NULL)
        throw(ENOMEM, "not enough memory");
    return ptr;
}

// Assembly:
pushq %rax
callq 0x3440
testq %rax, %rax
je 0x9dfc
popq %rcx
retq
leaq 0xc702(%rip), %rsi      # 0x16505
movl $0xc, %edi
xorl %edx, %edx
xorl %eax, %eax
callq 0xe90d
// File: /workspace/github_c_makefile_star2_O3/madler[P]pigz/pigz.c
// Function: cat
local void cat(void) {
    // copy the first header byte read, if any
    if (g.magic1 != -1) {
        unsigned char buf[1] = {g.magic1};
        g.out_tot += writen(g.outd, buf, 1);
    }

    // copy the remainder of the input to the output
    while (g.in_left) {
        g.out_tot += writen(g.outd, g.in_next, g.in_left);
        g.in_left = 0;
        load();
    }
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl 0x13580(%rip), %eax     # 0x1d39c
cmpl $-0x1, %eax
je 0x9e6d
leaq 0xf(%rsp), %rsi
movb %al, (%rsi)
movl 0x13536(%rip), %edi     # 0x1d364
movl $0x1, %edx
callq 0xc0bf
incq 0x1b659(%rip)           # 0x25498
jmp 0x9e6d
movl 0x1351d(%rip), %edi     # 0x1d364
movq 0x1b62a(%rip), %rsi     # 0x25478
movq %rbx, %rdx
callq 0xc0bf
addq %rbx, 0x1b63b(%rip)     # 0x25498
movq $0x0, 0x1b618(%rip) # 0x25480
callq 0xb08c
movq 0x1b60c(%rip), %rbx     # 0x25480
testq %rbx, %rbx
jne 0x9e41
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/madler[P]pigz/pigz.c
// Function: vmemcpy
local inline size_t vmemcpy(char **mem, size_t *size, size_t off,
                            void *cpy, size_t len) {
    size_t need;

    need = off + len;
    if (need < off)
        throw(ERANGE, "overflow");
    if (need > *size) {
        need = grow(need);
        if (off == 0) {
            RELEASE(*mem);
            *size = 0;
        }
        *mem = alloc(*mem, need);
        *size = need;
    }
    memcpy(*mem + off, cpy, len);
    return off + len;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
addq %rdx, %r14
jb 0xabc8
movq %r8, %rbx
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
cmpq (%rsi), %r14
jbe 0xaba4
movq %rcx, (%rsp)
movq %r14, %rax
shrq $0x2, %rax
addq %r14, %rax
movl $0x3, %ecx
movq %rax, %rdx
cmpq $0x8, %rax
jb 0xab3b
movq %rax, %rsi
movq %rax, %rdx
shrq %rdx
incq %rcx
cmpq $0xf, %rsi
movq %rdx, %rsi
ja 0xab2c
movl $0x1, %esi
shlq %cl, %rsi
cmpq $0x7, %rdx
cmoveq %rsi, %rax
cmpq $0x11, %rax
movl $0x10, %ecx
cmovaeq %rax, %rcx
cmpq %r14, %rcx
movq $-0x1, %r15
cmovaq %rcx, %r15
movq (%rbp), %rdi
testq %r12, %r12
jne 0xab8b
testq %rdi, %rdi
je 0xab81
callq 0x3050
movq $0x0, (%rbp)
movq $0x0, (%r13)
xorl %edi, %edi
movq %r15, %rsi
callq 0x9def
movq %rax, %rdi
movq %rax, (%rbp)
movq %r15, (%r13)
movq (%rsp), %rcx
jmp 0xaba8
movq (%rbp), %rdi
addq %r12, %rdi
movq %rcx, %rsi
movq %rbx, %rdx
callq 0x3370
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0xb8ec(%rip), %rsi      # 0x164bb
movl $0x22, %edi
xorl %edx, %edx
xorl %eax, %eax
callq 0xe90d
// File: /workspace/github_c_makefile_star2_O3/madler[P]pigz/pigz.c
// Function: load_wait
local void load_wait(void) {
    if (g.in_which == -1)
        return;
    possess(g.load_state);
    wait_for(g.load_state, TO_BE, 0);
    release(g.load_state);
}

// Assembly:
cmpl $-0x1, 0x228fc(%rip)    # 0x2d4e0
je 0xac30
pushq %rbx
movq 0x228fa(%rip), %rdi     # 0x2d4e8
leaq 0xa70b(%rip), %rbx      # 0x15300
movl $0x9fd, %edx            # imm = 0x9FD
movq %rbx, %rsi
callq 0xe2b3
movq 0x228df(%rip), %rdi     # 0x2d4e8
movl $0x9fe, %r8d            # imm = 0x9FE
xorl %esi, %esi
xorl %edx, %edx
movq %rbx, %rcx
callq 0xe36e
movq 0x228c6(%rip), %rdi     # 0x2d4e8
movl $0x9ff, %edx            # imm = 0x9FF
movq %rbx, %rsi
popq %rbx
jmp 0xe2e2
retq
// File: /workspace/github_c_makefile_star2_O3/madler[P]pigz/pigz.c
// Function: readn
local size_t readn(int desc, unsigned char *buf, size_t len) {
    ssize_t ret;
    size_t got;

    got = 0;
    while (len) {
        ret = read(desc, buf, len);
        if (ret < 0)
            throw(errno, "read error on %s (%s)", g.inf, strerror(errno));
        if (ret == 0)
            break;
        buf += ret;
        len -= (size_t)ret;
        got += (size_t)ret;
    }
    return got;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdx, %rdx
je 0xb256
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %ebp
xorl %ebx, %ebx
movl %ebp, %edi
movq %r15, %rsi
movq %r14, %rdx
callq 0x32c0
testq %rax, %rax
js 0xb266
je 0xb258
addq %rax, %r15
addq %rax, %rbx
subq %rax, %r14
jne 0xb235
jmp 0xb258
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x3070
movl (%rax), %ebx
movq 0x120f4(%rip), %r14     # 0x1d368
movl %ebx, %edi
callq 0x35b0
leaq 0xb091(%rip), %rsi      # 0x16313
movl %ebx, %edi
movq %r14, %rdx
movq %rax, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0xe90d
// File: /workspace/github_c_makefile_star2_O3/madler[P]pigz/pigz.c
// Function: dos2time
local time_t dos2time(unsigned long dos) {
    struct tm tm;

    if (dos == 0)
        return time(NULL);
    tm.tm_year = ((int)(dos >> 25) & 0x7f) + 80;
    tm.tm_mon  = ((int)(dos >> 21) & 0xf) - 1;
    tm.tm_mday = (int)(dos >> 16) & 0x1f;
    tm.tm_hour = (int)(dos >> 11) & 0x1f;
    tm.tm_min  = (int)(dos >> 5) & 0x3f;
    tm.tm_sec  = (int)(dos << 1) & 0x3e;
    tm.tm_isdst = -1;           // figure out if DST or not
    return mktime(&tm);
}

// Assembly:
testq %rdi, %rdi
je 0xb4f9
subq $0x38, %rsp
movl %edi, %ecx
shrl $0x19, %ecx
addl $0x50, %ecx
movq %rsp, %rax
movl %ecx, 0x14(%rax)
movl %edi, %ecx
shrl $0x15, %ecx
andl $0xf, %ecx
decl %ecx
movl %ecx, 0x10(%rax)
movl %edi, %ecx
shrl $0x10, %ecx
andl $0x1f, %ecx
movl %ecx, 0xc(%rax)
movl %edi, %ecx
shrl $0xb, %ecx
andl $0x1f, %ecx
movl %ecx, 0x8(%rax)
movl %edi, %ecx
shrl $0x5, %ecx
andl $0x3f, %ecx
movl %ecx, 0x4(%rax)
addl %edi, %edi
andl $0x3e, %edi
movl %edi, (%rax)
movl $0xffffffff, 0x20(%rax) # imm = 0xFFFFFFFF
movq %rax, %rdi
callq 0x3410
addq $0x38, %rsp
retq
xorl %edi, %edi
jmp 0x3390
// File: /workspace/github_c_makefile_star2_O3/madler[P]pigz/pigz.c
// Function: inb
local unsigned inb(void *desc, unsigned char **buf) {
    (void)desc;
    if (g.in_left == 0)
        load();
    *buf = g.in_next;
    unsigned len = g.in_left > UINT_MAX ? UINT_MAX : (unsigned)g.in_left;
    g.in_next += len;
    g.in_left -= len;
    return len;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movq 0x19527(%rip), %rcx     # 0x25480
testq %rcx, %rcx
jne 0xbf6a
callq 0xb08c
movq 0x19516(%rip), %rcx     # 0x25480
movq 0x19507(%rip), %rdx     # 0x25478
movq %rdx, (%rbx)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, %rcx
cmovbq %rcx, %rax
addq %rax, %rdx
movq %rdx, 0x194ee(%rip)     # 0x25478
subq %rax, %rcx
movq %rcx, 0x194ec(%rip)     # 0x25480
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/madler[P]pigz/pigz.c
// Function: adler32_comb
local unsigned long adler32_comb(unsigned long adler1, unsigned long adler2,
                                 size_t len2) {
    unsigned long sum1;
    unsigned long sum2;
    unsigned rem;

    // the derivation of this formula is left as an exercise for the reader
    rem = (unsigned)(len2 % BASE);
    sum1 = adler1 & LOW16;
    sum2 = (rem * sum1) % BASE;
    sum1 += (adler2 & LOW16) + BASE - 1;
    sum2 += ((adler1 >> 16) & LOW16) + ((adler2 >> 16) & LOW16) + BASE - rem;
    if (sum1 >= BASE) sum1 -= BASE;
    if (sum1 >= BASE) sum1 -= BASE;
    if (sum2 >= (BASE << 1)) sum2 -= (BASE << 1);
    if (sum2 >= BASE) sum2 -= BASE;
    return sum1 | (sum2 << 16);
}

// Assembly:
movq %rdx, %rcx
movabsq $0xf00e10d2fc5cd, %rdx  # imm = 0xF00E10D2FC5CD
movq %rcx, %rax
mulq %rdx
movq %rcx, %rax
subq %rdx, %rax
shrq %rax
addq %rdx, %rax
shrq $0xf, %rax
imulq $0xfff1, %rax, %rax     # imm = 0xFFF1
subq %rax, %rcx
movl $0xffff, %eax           # imm = 0xFFFF
movq %rdi, %rdx
andq %rax, %rdx
andq %rsi, %rax
shrl $0x10, %edi
shrl $0x10, %esi
addq %rdi, %rsi
subq %rcx, %rsi
imulq %rdx, %rcx
movl $0x80078071, %edi       # imm = 0x80078071
imulq %rcx, %rdi
shrq $0x2f, %rdi
imull $0xfff1, %edi, %edi     # imm = 0xFFF1
subl %edi, %ecx
leaq (%rdx,%rax), %rdi
addl $0xfff0, %edi           # imm = 0xFFF0
addq %rcx, %rsi
movl $0xfff1, %ecx           # imm = 0xFFF1
leaq (%rsi,%rcx), %r8
cmpl $0xfff1, %edi           # imm = 0xFFF1
leaq -0x1(%rdx,%rax), %rax
movl $0xfff0, %edx           # imm = 0xFFF0
cmovaeq %rax, %rdx
movq $-0xfff1, %rax          # imm = 0xFFFF000F
leaq (%rdx,%rax), %rdi
cmpq %rcx, %rdx
cmovbq %rdx, %rdi
addq %rax, %rsi
cmpq $0x1ffe2, %r8           # imm = 0x1FFE2
cmovbq %r8, %rsi
movq %rsi, %rdx
shlq $0x10, %rdx
movabsq $-0xfff10000, %rax      # imm = 0xFFFFFFFF000F0000
addq %rdx, %rax
cmpq %rcx, %rsi
cmovbq %rdx, %rax
orq %rdi, %rax
retq
// File: /workspace/github_c_makefile_star2_O3/madler[P]pigz/pigz.c
// Function: writen
local size_t writen(int desc, void const *buf, size_t len) {
    char const *next = buf;
    size_t left = len;

    while (left) {
        size_t const max = SSIZE_MAX;
        ssize_t ret = write(desc, next, left > max ? max : left);
        if (ret < 1)
            throw(errno, "write error on %s (%s)", g.outf, strerror(errno));
        next += ret;
        left -= (size_t)ret;
    }
    return len;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
testq %rdx, %rdx
je 0xc102
movq %rsi, %r14
movl %edi, %ebp
movabsq $0x7fffffffffffffff, %r15 # imm = 0x7FFFFFFFFFFFFFFF
movq %rbx, %r12
cmpq %r15, %r12
movq %r15, %rdx
cmovbq %r12, %rdx
movl %ebp, %edi
movq %r14, %rsi
callq 0x3130
testq %rax, %rax
jle 0xc10e
addq %rax, %r14
subq %rax, %r12
jne 0xc0e1
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x3070
movl (%rax), %ebx
movq 0x1125c(%rip), %r14     # 0x1d378
movl %ebx, %edi
callq 0x35b0
leaq 0xa34d(%rip), %rsi      # 0x16477
movl %ebx, %edi
movq %r14, %rdx
movq %rax, %rcx
xorl %r8d, %r8d
xorl %eax, %eax
callq 0xe90d
// File: /workspace/github_c_makefile_star2_O3/madler[P]pigz/pigz.c
// Function: outb_write
local void outb_write(void *dummy) {
    size_t len;
    ball_t err;                     // error information from throw()

    (void)dummy;

    Trace(("-- launched decompress write thread"));
    try {
        do {
            possess(outb_write_more);
            wait_for(outb_write_more, TO_BE, 1);
            len = out_len;
            if (len && g.decode == 1)
                writen(g.outd, out_copy, len);
            Trace(("-- decompress wrote %lu bytes", len));
            twist(outb_write_more, TO, 0);
        } while (len);
    }
    catch (err) {
        THREADABORT(err);
    }
    Trace(("-- exited decompress write thread"));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movl $0x1, 0xc(%rsp)
xorl %eax, %eax
leaq 0x10(%rsp), %rbx
movq %rax, 0xc8(%rbx)
movl $0x0, 0xd0(%rbx)
movq %rax, 0xd8(%rbx)
callq 0xe8a0
leaq 0x31504(%rip), %r14     # 0x3d684
movl (%r14), %edi
callq 0x3110
movq %rax, 0xe0(%rbx)
movl (%r14), %edi
movq %rbx, %rsi
callq 0x3610
testl %eax, %eax
jne 0xc2c5
leaq 0x10(%rsp), %rdi
callq 0x32f0
testl %eax, %eax
jne 0xc23f
leaq 0x9145(%rip), %rbx      # 0x15300
xorl %ebp, %ebp
movl $0x1, %r15d
movl $0xd1a, %r12d           # imm = 0xD1A
movl $0xd1f, %r13d           # imm = 0xD1F
movq 0x2933a(%rip), %rdi     # 0x35510
movq %rbx, %rsi
movl $0xd19, %edx            # imm = 0xD19
callq 0xe2b3
movq 0x29326(%rip), %rdi     # 0x35510
movl %ebp, %esi
movq %r15, %rdx
movq %rbx, %rcx
movq %r12, %r8
callq 0xe36e
movq 0x2931f(%rip), %r14     # 0x35520
testq %r14, %r14
je 0xc224
cmpl $0x1, 0x111cb(%rip)     # 0x1d3d8
jne 0xc224
movl 0x1114f(%rip), %edi     # 0x1d364
leaq 0x29314(%rip), %rsi     # 0x35530
movq %r14, %rdx
callq 0xc0bf
movq 0x292e5(%rip), %rdi     # 0x35510
movl %ebp, %edx
movl %ebp, %esi
movq %rbx, %rcx
movq %r13, %r8
callq 0xe311
testq %r14, %r14
jne 0xc1cf
cmpl $0x0, 0xc(%rsp)
je 0xc26c
leaq 0x31437(%rip), %rax     # 0x3d684
movl (%rax), %edi
movq 0xf0(%rsp), %rsi
callq 0x3610
testl %eax, %eax
jne 0xc2e4
movl $0x0, 0xc(%rsp)
movl 0xdc(%rsp), %ebp
testl %ebp, %ebp
jne 0xc289
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl 0xe0(%rsp), %r14d
movq 0xe8(%rsp), %rbx
cmpl $0x20, %ebp
je 0xc2af
leaq 0x9167(%rip), %rdi      # 0x1540c
xorl %eax, %eax
movq %rbx, %rsi
callq 0x479d
testl %r14d, %r14d
je 0xc2bc
movq %rbx, %rdi
callq 0x3050
movl %ebp, %edi
negl %edi
callq 0x4133
leaq 0x9004(%rip), %rdi      # 0x152d0
leaq 0x902d(%rip), %rsi      # 0x15300
leaq 0xa582(%rip), %rcx      # 0x1685c
movl $0xd17, %edx            # imm = 0xD17
callq 0x3220
leaq 0x8fe5(%rip), %rdi      # 0x152d0
leaq 0x900e(%rip), %rsi      # 0x15300
leaq 0xa563(%rip), %rcx      # 0x1685c
movl $0xd22, %edx            # imm = 0xD22
callq 0x3220
// File: /workspace/github_c_makefile_star2_O3/madler[P]pigz/pigz.c
// Function: outb_check
local void outb_check(void *dummy) {
    size_t len;
    ball_t err;                     // error information from throw()

    (void)dummy;

    Trace(("-- launched decompress check thread"));
    try {
        do {
            possess(outb_check_more);
            wait_for(outb_check_more, TO_BE, 1);
            len = out_len;
            g.out_check = CHECK(g.out_check, out_copy, len);
            Trace(("-- decompress checked %lu bytes", len));
            twist(outb_check_more, TO, 0);
        } while (len);
    }
    catch (err) {
        THREADABORT(err);
    }
    Trace(("-- exited decompress check thread"));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movl $0x1, 0xc(%rsp)
xorl %eax, %eax
leaq 0x10(%rsp), %rbx
movq %rax, 0xc8(%rbx)
movl $0x0, 0xd0(%rbx)
movq %rax, 0xd8(%rbx)
callq 0xe8a0
leaq 0x3133d(%rip), %r14     # 0x3d684
movl (%r14), %edi
callq 0x3110
movq %rax, 0xe0(%rbx)
movl (%r14), %edi
movq %rbx, %rsi
callq 0x3610
testl %eax, %eax
jne 0xc49b
leaq 0x10(%rsp), %rdi
callq 0x32f0
testl %eax, %eax
jne 0xc415
leaq 0x8f7e(%rip), %rbx      # 0x15300
xorl %ebp, %ebp
movl $0xd33, %r12d           # imm = 0xD33
leaq 0x2919f(%rip), %r13     # 0x35530
movl $0xd37, %r14d           # imm = 0xD37
movq 0x2917a(%rip), %rdi     # 0x35518
movq %rbx, %rsi
movl $0xd32, %edx            # imm = 0xD32
callq 0xe2b3
movq 0x29166(%rip), %rdi     # 0x35518
movl %ebp, %esi
movl $0x1, %edx
movq %rbx, %rcx
movq %r12, %r8
callq 0xe36e
movq 0x29155(%rip), %r15     # 0x35520
cmpl $0x1, 0x10fc6(%rip)     # 0x1d398
movq 0x190c7(%rip), %rdi     # 0x254a0
jne 0xc3e8
movl %r15d, %edx
movq %r13, %rsi
callq 0x33a0
jmp 0xc3f3
movq %r13, %rsi
movq %r15, %rdx
callq 0xbee2
movq %rax, 0x190a6(%rip)     # 0x254a0
movq 0x29117(%rip), %rdi     # 0x35518
movl %ebp, %edx
movl %ebp, %esi
movq %rbx, %rcx
movq %r14, %r8
callq 0xe311
testq %r15, %r15
jne 0xc397
cmpl $0x0, 0xc(%rsp)
je 0xc442
leaq 0x31261(%rip), %rax     # 0x3d684
movl (%rax), %edi
movq 0xf0(%rsp), %rsi
callq 0x3610
testl %eax, %eax
jne 0xc4ba
movl $0x0, 0xc(%rsp)
movl 0xdc(%rsp), %ebp
testl %ebp, %ebp
jne 0xc45f
addq $0xf8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl 0xe0(%rsp), %r14d
movq 0xe8(%rsp), %rbx
cmpl $0x20, %ebp
je 0xc485
leaq 0x8f91(%rip), %rdi      # 0x1540c
xorl %eax, %eax
movq %rbx, %rsi
callq 0x479d
testl %r14d, %r14d
je 0xc492
movq %rbx, %rdi
callq 0x3050
movl %ebp, %edi
negl %edi
callq 0x4133
leaq 0x8e2e(%rip), %rdi      # 0x152d0
leaq 0x8e57(%rip), %rsi      # 0x15300
leaq 0xa3c4(%rip), %rcx      # 0x16874
movl $0xd30, %edx            # imm = 0xD30
callq 0x3220
leaq 0x8e0f(%rip), %rdi      # 0x152d0
leaq 0x8e38(%rip), %rsi      # 0x15300
leaq 0xa3a5(%rip), %rcx      # 0x16874
movl $0xd3a, %edx            # imm = 0xD3A
callq 0x3220
// File: /workspace/github_c_makefile_star2_O3/madler[P]pigz/pigz.c
// Function: get_space
space *get_space(struct pool *pool) {
    struct space *space;

    // if can't create any more, wait for a space to show up
    possess(pool->have);
    if (pool->limit == 0)
        wait_for(pool->have, NOT_TO_BE, 0);

    // if a space is available, pull it from the list and return it
    if (pool->head != NULL) {
        space = pool->head;
        pool->head = space->next;
        twist(pool->have, BY, -1);      // one less in pool
        possess(space->use);
        twist(space->use, TO, 1);       // initially one user
        space->len = 0;
        return space;
    }

    // nothing available, don't want to wait, make a new space
    assert(pool->limit != 0);
    if (pool->limit > 0)
        pool->limit--;
    pool->made++;
    release(pool->have);
    space = alloc(NULL, sizeof(struct space));
    space->use = new_lock(1);           // initially one user
    space->buf = alloc(NULL, pool->size);
    space->size = pool->size;
    space->len = 0;
    space->pool = pool;                 // remember the pool this belongs to
    return space;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x8a48(%rip), %rsi      # 0x15300
movl $0x5bf, %edx            # imm = 0x5BF
callq 0xe2b3
cmpl $0x0, 0x18(%rbx)
jne 0xc8e4
movq (%rbx), %rdi
leaq 0x8a2e(%rip), %rcx      # 0x15300
movl $0x5c1, %r8d            # imm = 0x5C1
movl $0x1, %esi
xorl %edx, %edx
callq 0xe36e
movq 0x8(%rbx), %r14
testq %r14, %r14
je 0xc94b
movq 0x28(%r14), %rax
movq %rax, 0x8(%rbx)
movq (%rbx), %rdi
leaq 0x8a01(%rip), %rbx      # 0x15300
movl $0x5c7, %r8d            # imm = 0x5C7
movl $0x1, %esi
movq $-0x1, %rdx
movq %rbx, %rcx
callq 0xe311
movq (%r14), %rdi
movl $0x5c8, %edx            # imm = 0x5C8
movq %rbx, %rsi
callq 0xe2b3
movq (%r14), %rdi
movl $0x1, %edx
movl $0x5c9, %r8d            # imm = 0x5C9
xorl %esi, %esi
movq %rbx, %rcx
callq 0xe311
movq $0x0, 0x18(%r14)
jmp 0xc9ba
movl 0x18(%rbx), %eax
testl %eax, %eax
je 0xc9c3
jle 0xc959
decl %eax
movl %eax, 0x18(%rbx)
incl 0x1c(%rbx)
movq (%rbx), %rdi
leaq 0x899a(%rip), %r15      # 0x15300
movl $0x5d3, %edx            # imm = 0x5D3
movq %r15, %rsi
callq 0xe2e2
movl $0x30, %esi
xorl %edi, %edi
callq 0x9def
movq %rax, %r14
movl $0x1, %edi
movl $0x5d5, %edx            # imm = 0x5D5
movq %r15, %rsi
callq 0xe13f
movq %rax, (%r14)
movq 0x10(%rbx), %rsi
xorl %edi, %edi
callq 0x9def
movq %rax, 0x8(%r14)
movq 0x10(%rbx), %rax
movq %rax, 0x10(%r14)
movq $0x0, 0x18(%r14)
movq %rbx, 0x20(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
leaq 0x9f55(%rip), %rdi      # 0x1691f
leaq 0x892f(%rip), %rsi      # 0x15300
leaq 0x9f58(%rip), %rcx      # 0x16930
movl $0x5cf, %edx            # imm = 0x5CF
callq 0x3220
// File: /workspace/github_c_makefile_star2_O3/madler[P]pigz/pigz.c
// Function: append_len
local void append_len(struct job *job, size_t len) {
    struct space *lens;

    assert(len < 539000896UL);
    if (job->lens == NULL)
        job->lens = get_space(&lens_pool);
    lens = job->lens;
    if (lens->size < lens->len + 3)
        grow_space(lens);
    if (len < 64)
        lens->buf[lens->len++] = (unsigned char)(len + 128);
    else if (len < 32832U) {
        len -= 64;
        lens->buf[lens->len++] = (unsigned char)(len >> 8);
        lens->buf[lens->len++] = (unsigned char)len;
    }
    else if (len < 2129984UL) {
        len -= 32832U;
        lens->buf[lens->len++] = (unsigned char)((len >> 16) + 192);
        lens->buf[lens->len++] = (unsigned char)(len >> 8);
        lens->buf[lens->len++] = (unsigned char)len;
    }
    else {
        len -= 2129984UL;
        lens->buf[lens->len++] = (unsigned char)((len >> 24) + 224);
        lens->buf[lens->len++] = (unsigned char)(len >> 16);
        lens->buf[lens->len++] = (unsigned char)(len >> 8);
        lens->buf[lens->len++] = (unsigned char)len;
    }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpq $0x20208040, %rsi       # imm = 0x20208040
jae 0xcb09
movq %rdi, %r14
movq 0x20(%rdi), %rbx
testq %rbx, %rbx
jne 0xca18
leaq 0x30bc2(%rip), %rdi     # 0x3d5c8
movq %rsi, %rbx
callq 0xc8a6
movq %rbx, %rsi
movq %rax, %rbx
movq %rax, 0x20(%r14)
movq 0x18(%rbx), %rax
addq $0x3, %rax
cmpq %rax, 0x10(%rbx)
jae 0xca34
movq %rbx, %rdi
movq %rsi, %r14
callq 0xdf44
movq %r14, %rsi
cmpq $0x3f, %rsi
ja 0xca43
orb $-0x80, %sil
jmp 0xcaed
cmpq $0x803f, %rsi           # imm = 0x803F
ja 0xca65
addq $-0x40, %rsi
movq 0x8(%rbx), %rdi
movq 0x18(%rbx), %rcx
movq %rsi, %rax
leaq 0x1(%rcx), %rdx
movq %rdx, 0x18(%rbx)
jmp 0xcaa5
movq 0x8(%rbx), %rdi
movq 0x18(%rbx), %rcx
movq %rsi, %rax
leaq 0x1(%rcx), %rdx
movq %rdx, 0x18(%rbx)
cmpq $0x20803f, %rsi         # imm = 0x20803F
ja 0xcaaa
addq $-0x8040, %rax          # imm = 0xFFFF7FC0
movl %eax, %edx
shrl $0x10, %edx
addb $-0x40, %dl
movb %dl, (%rdi,%rcx)
movq 0x8(%rbx), %rdi
movq 0x18(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x18(%rbx)
movq %rax, %rsi
movb %ah, (%rdi,%rcx)
jmp 0xcaed
addq $-0x208040, %rax        # imm = 0xFFDF7FC0
movl %eax, %edx
movq %rax, %r8
shrl $0x18, %edx
addb $-0x20, %dl
movb %dl, (%rdi,%rcx)
shrl $0x10, %eax
movq 0x8(%rbx), %rcx
movq 0x18(%rbx), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x18(%rbx)
movb %al, (%rcx,%rdx)
movq 0x8(%rbx), %rax
movq 0x18(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x18(%rbx)
movq %r8, %rdx
movq %r8, %rsi
movb %dh, (%rax,%rcx)
movq 0x8(%rbx), %rax
movq 0x18(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x18(%rbx)
movb %sil, (%rax,%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x9e47(%rip), %rdi      # 0x16957
leaq 0x87e9(%rip), %rsi      # 0x15300
leaq 0x9e4b(%rip), %rcx      # 0x16969
movl $0x7fa, %edx            # imm = 0x7FA
callq 0x3220
// File: /workspace/github_c_makefile_star2_O3/madler[P]pigz/pigz.c
// Function: use_space
local void use_space(struct space *space) {
    long use;

    possess(space->use);
    use = peek_lock(space->use);
    assert(use != 0);
    twist(space->use, BY, +1);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x87ca(%rip), %rsi      # 0x15300
movl $0x5f0, %edx            # imm = 0x5F0
callq 0xe2b3
movq (%rbx), %rdi
callq 0xe42e
testq %rax, %rax
je 0xcb6d
movq (%rbx), %rdi
leaq 0x87a9(%rip), %rcx      # 0x15300
movl $0x1, %edx
movl $0x5f3, %r8d            # imm = 0x5F3
movl $0x1, %esi
popq %rbx
jmp 0xe311
leaq 0x9e1b(%rip), %rdi      # 0x1698f
leaq 0x8785(%rip), %rsi      # 0x15300
leaq 0x9e16(%rip), %rcx      # 0x16998
movl $0x5f2, %edx            # imm = 0x5F2
callq 0x3220
// File: /workspace/github_c_makefile_star2_O3/madler[P]pigz/pigz.c
// Function: drop_space
local void drop_space(struct space *space) {
    long use;
    struct pool *pool;

    if (space == NULL)
        return;
    possess(space->use);
    use = peek_lock(space->use);
    assert(use != 0);
    twist(space->use, BY, -1);
    if (use == 1) {
        pool = space->pool;
        possess(pool->have);
        space->next = pool->head;
        pool->head = space;
        twist(pool->have, BY, +1);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xd662
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x7d26(%rip), %rsi      # 0x15300
movl $0x5fd, %edx            # imm = 0x5FD
callq 0xe2b3
movq (%rbx), %rdi
callq 0xe42e
testq %rax, %rax
je 0xd668
movq %rax, %r14
movq (%rbx), %rdi
leaq 0x7d02(%rip), %rcx      # 0x15300
movl $0x600, %r8d            # imm = 0x600
movl $0x1, %esi
movq $-0x1, %rdx
callq 0xe311
cmpq $0x1, %r14
jne 0xd662
movq 0x20(%rbx), %r15
movq (%r15), %rdi
leaq 0x7cd7(%rip), %r14      # 0x15300
movl $0x603, %edx            # imm = 0x603
movq %r14, %rsi
callq 0xe2b3
movq 0x8(%r15), %rax
movq %rax, 0x28(%rbx)
movq %rbx, 0x8(%r15)
movq (%r15), %rdi
movl $0x1, %edx
movl $0x606, %r8d            # imm = 0x606
movl $0x1, %esi
movq %r14, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0xe311
popq %rbx
popq %r14
popq %r15
retq
leaq 0x9320(%rip), %rdi      # 0x1698f
leaq 0x7c8a(%rip), %rsi      # 0x15300
leaq 0x93e7(%rip), %rcx      # 0x16a64
movl $0x5ff, %edx            # imm = 0x5FF
callq 0x3220
// File: /workspace/github_c_makefile_star2_O3/madler[P]pigz/pigz.c
// Function: time2dos
local unsigned long time2dos(time_t t) {
    struct tm *tm;
    unsigned long dos;

    if (t == 0)
        t = time(NULL);
    tm = localtime(&t);
    if (tm->tm_year < 80 || tm->tm_year > 207)
        return 0;
    dos = (unsigned long)(tm->tm_year - 80) << 25;
    dos += (unsigned long)(tm->tm_mon + 1) << 21;
    dos += (unsigned long)tm->tm_mday << 16;
    dos += (unsigned long)tm->tm_hour << 11;
    dos += (unsigned long)tm->tm_min << 5;
    dos += (unsigned long)(tm->tm_sec + 1) >> 1;    // round to even seconds
    return dos;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
testq %rdi, %rdi
jne 0xdee3
xorl %edi, %edi
callq 0x3390
movq %rax, (%rsp)
movq %rsp, %rdi
callq 0x3060
movl 0x14(%rax), %ecx
leal -0xd0(%rcx), %edx
cmpl $-0x80, %edx
jae 0xdefd
xorl %eax, %eax
jmp 0xdf42
addl $-0x50, %ecx
shlq $0x19, %rcx
movslq 0x10(%rax), %rdx
shlq $0x15, %rdx
movslq 0xc(%rax), %rsi
shlq $0x10, %rsi
addq %rdx, %rsi
addq %rcx, %rsi
movslq 0x8(%rax), %rcx
shlq $0xb, %rcx
movslq 0x4(%rax), %rdx
shlq $0x5, %rdx
addq %rcx, %rdx
addq %rsi, %rdx
movslq (%rax), %rax
incq %rax
shrq %rax
addq %rdx, %rax
addq $0x200000, %rax         # imm = 0x200000
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/madler[P]pigz/pigz.c
// Function: grow_space
local void grow_space(struct space *space) {
    size_t more;

    // compute next size up
    more = grow(space->size);
    if (more == space->size)
        throw(ERANGE, "overflow");

    // reallocate the buffer
    space->buf = alloc(space->buf, more);
    space->size = more;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movq %rax, %rdx
shrq $0x2, %rdx
addq %rax, %rdx
movl $0x3, %ecx
movq %rdx, %rsi
cmpq $0x8, %rdx
jb 0xdf7c
movq %rdx, %rdi
movq %rdx, %rsi
shrq %rsi
incq %rcx
cmpq $0xf, %rdi
movq %rsi, %rdi
ja 0xdf6d
movl $0x1, %edi
shlq %cl, %rdi
cmpq $0x7, %rsi
cmoveq %rdi, %rdx
cmpq $0x11, %rdx
movl $0x10, %ecx
cmovaeq %rdx, %rcx
cmpq %rax, %rcx
movq $-0x1, %r14
cmovaq %rcx, %r14
cmpq %rax, %r14
je 0xdfc8
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x9def
movq %rax, 0x8(%rbx)
movq %r14, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x84ec(%rip), %rsi      # 0x164bb
movl $0x22, %edi
xorl %edx, %edx
xorl %eax, %eax
callq 0xe90d
// File: /workspace/github_c_makefile_star2_O3/madler[P]pigz/pigz.c
// Function: deflate_engine
local void deflate_engine(z_stream *strm, struct space *out, int flush) {
    size_t room;

    do {
        room = out->size - out->len;
        if (room == 0) {
            grow_space(out);
            room = out->size - out->len;
        }
        strm->next_out = out->buf + out->len;
        strm->avail_out = room < UINT_MAX ? (unsigned)room : UINT_MAX;
        (void)deflate(strm, flush);
        out->len = (size_t)(strm->next_out - out->buf);
    } while (strm->avail_out == 0);
    assert(strm->avail_in == 0);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movq 0x18(%rsi), %rax
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
movq 0x10(%r15), %rcx
subq %rax, %rcx
jne 0xe013
movq %r15, %rdi
callq 0xdf44
movq 0x10(%r15), %rcx
movq 0x18(%r15), %rax
subq %rax, %rcx
addq 0x8(%r15), %rax
movq %rax, 0x18(%r14)
cmpq %r12, %rcx
cmovaeq %r12, %rcx
movl %ecx, 0x20(%r14)
movq %r14, %rdi
movl %ebx, %esi
callq 0x3240
movq 0x18(%r14), %rax
subq 0x8(%r15), %rax
movq %rax, 0x18(%r15)
cmpl $0x0, 0x20(%r14)
je 0xdff7
cmpl $0x0, 0x8(%r14)
jne 0xe056
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x89be(%rip), %rdi      # 0x16a1b
leaq 0x729c(%rip), %rsi      # 0x15300
leaq 0x89c4(%rip), %rcx      # 0x16a2f
movl $0x691, %edx            # imm = 0x691
callq 0x3220
// File: /workspace/github_c_makefile_star2_O3/madler[P]pigz/pigz.c
// Function: free_pool
local int free_pool(struct pool *pool) {
    int count;
    struct space *space;

    possess(pool->have);
    count = 0;
    while ((space = pool->head) != NULL) {
        pool->head = space->next;
        FREE(space->buf);
        free_lock(space->use);
        FREE(space);
        count++;
    }
    assert(count == pool->made);
    release(pool->have);
    free_lock(pool->have);
    return count;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x7277(%rip), %rsi      # 0x15300
movl $0x610, %edx            # imm = 0x610
callq 0xe2b3
movq 0x8(%rbx), %r15
xorl %ebp, %ebp
testq %r15, %r15
je 0xe0d9
leaq 0x725b(%rip), %r14      # 0x15300
movq 0x28(%r15), %rax
movq %rax, 0x8(%rbx)
movq 0x8(%r15), %rdi
callq 0x3050
movq (%r15), %rdi
movl $0x615, %edx            # imm = 0x615
movq %r14, %rsi
callq 0xe433
movq %r15, %rdi
callq 0x3050
incl %ebp
movq 0x8(%rbx), %r15
testq %r15, %r15
jne 0xe0a5
cmpl 0x1c(%rbx), %ebp
jne 0xe10f
movq (%rbx), %rdi
leaq 0x7218(%rip), %r14      # 0x15300
movl $0x61a, %edx            # imm = 0x61A
movq %r14, %rsi
callq 0xe2e2
movq (%rbx), %rdi
movl $0x61b, %edx            # imm = 0x61B
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xe433
leaq 0x89d1(%rip), %rdi      # 0x16ae7
leaq 0x71e3(%rip), %rsi      # 0x15300
leaq 0x89d7(%rip), %rcx      # 0x16afb
movl $0x619, %edx            # imm = 0x619
callq 0x3220
nop
// File: /workspace/github_c_makefile_star2_O3/madler[P]pigz/yarn.c
// Function: new_lock_
lock *new_lock_(long initial, char const *file, long line) {
    lock *bolt = my_malloc(sizeof(struct lock_s), file, line);
    int ret = pthread_mutex_init(&(bolt->mutex), NULL);
    if (ret)
        fail(ret, file, line, "mutex_init");
    ret = pthread_cond_init(&(bolt->cond), NULL);
    if (ret)
        fail(ret, file, line, "cond_init");
    bolt->value = initial;
    return bolt;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x60, %edi
callq *0xf1cd(%rip)           # 0x1d328
testq %rax, %rax
je 0xe197
movq %rax, %r12
movq %rax, %rdi
xorl %esi, %esi
callq 0x35e0
testl %eax, %eax
jne 0xe1a5
movq %r12, %rdi
addq $0x28, %rdi
xorl %esi, %esi
callq 0x33b0
testl %eax, %eax
jne 0xe1ae
movq %r15, 0x58(%r12)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x8a43(%rip), %rcx      # 0x16be1
movl $0xc, %edi
jmp 0xe1b7
leaq 0x8985(%rip), %rcx      # 0x16b31
jmp 0xe1b5
leaq 0x8987(%rip), %rcx      # 0x16b3c
movl %eax, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xe1c2
// File: /workspace/github_c_makefile_star2_O3/madler[P]pigz/yarn.c
// Function: fail
local void fail(int err, char const *file, long line, char const *func) {
    fprintf(stderr, "%s: ", yarn_prefix);
    switch (err) {
        case EPERM:
            fputs("already unlocked", stderr);
            break;
        case ESRCH:
            fputs("no such thread", stderr);
            break;
        case EDEADLK:
            fputs("resource deadlock", stderr);
            break;
        case ENOMEM:
            fputs("out of memory", stderr);
            break;
        case EBUSY:
            fputs("can't destroy locked resource", stderr);
            break;
        case EINVAL:
            fputs("invalid request", stderr);
            break;
        case EAGAIN:
            fputs("resource unavailable", stderr);
            break;
        default:
            fprintf(stderr, "internal error %d", err);
    }
    fprintf(stderr, " (%s:%ld:%s)\n", file, line, func);
    if (yarn_abort != NULL)
        yarn_abort(err);
    exit(err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movl %edi, %ebx
movq 0xee13(%rip), %r13      # 0x1cff0
movq (%r13), %rdi
movq 0xf138(%rip), %rdx      # 0x1d320
leaq 0x8002(%rip), %rsi      # 0x161f1
xorl %eax, %eax
callq 0x3350
movq (%r13), %rsi
cmpl $0xb, %ebx
jle 0xe217
cmpl $0x15, %ebx
jg 0xe22f
cmpl $0xc, %ebx
je 0xe263
cmpl $0x10, %ebx
jne 0xe24b
leaq 0x8a05(%rip), %rdi      # 0x16c1a
jmp 0xe27c
cmpl $0x1, %ebx
je 0xe242
cmpl $0x3, %ebx
je 0xe275
cmpl $0xb, %ebx
jne 0xe24b
leaq 0x8a1b(%rip), %rdi      # 0x16c48
jmp 0xe27c
cmpl $0x16, %ebx
je 0xe26c
cmpl $0x23, %ebx
jne 0xe24b
leaq 0x89c8(%rip), %rdi      # 0x16c08
jmp 0xe27c
leaq 0x899f(%rip), %rdi      # 0x16be8
jmp 0xe27c
leaq 0x8a0b(%rip), %rax      # 0x16c5d
movq %rsi, %rdi
movq %rax, %rsi
movl %ebx, %edx
xorl %eax, %eax
callq 0x3350
jmp 0xe281
leaq 0x8ab5(%rip), %rdi      # 0x16d1f
jmp 0xe27c
leaq 0x89c5(%rip), %rdi      # 0x16c38
jmp 0xe27c
leaq 0x897d(%rip), %rdi      # 0x16bf9
callq 0x3230
movq (%r13), %rdi
leaq 0x89e3(%rip), %rsi      # 0x16c6f
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
xorl %eax, %eax
callq 0x3350
movq 0x2f36d(%rip), %rax     # 0x3d610
testq %rax, %rax
je 0xe2ac
movl %ebx, %edi
callq *%rax
movl %ebx, %edi
callq 0x3550
// File: /workspace/github_c_makefile_star2_O3/madler[P]pigz/yarn.c
// Function: twist_
void twist_(lock *bolt, enum twist_op op, long val,
            char const *file, long line) {
    if (op == TO)
        bolt->value = val;
    else if (op == BY)
        bolt->value += val;
    int ret = pthread_cond_broadcast(&(bolt->cond));
    if (ret)
        fail(ret, file, line, "cond_broadcast");
    ret = pthread_mutex_unlock(&(bolt->mutex));
    if (ret)
        fail(ret, file, line, "mutex_unlock");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movq %rdi, %r15
cmpl $0x1, %esi
je 0xe32e
testl %esi, %esi
jne 0xe332
movq %rdx, 0x58(%r15)
jmp 0xe332
addq %rdx, 0x58(%r15)
leaq 0x28(%r15), %rdi
callq 0x30c0
testl %eax, %eax
jne 0xe351
movq %r15, %rdi
callq 0x33d0
testl %eax, %eax
jne 0xe35a
popq %rbx
popq %r14
popq %r15
retq
leaq 0x8806(%rip), %rcx      # 0x16b5e
jmp 0xe361
leaq 0x87f0(%rip), %rcx      # 0x16b51
movl %eax, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xe1c2
// File: /workspace/github_c_makefile_star2_O3/madler[P]pigz/yarn.c
// Function: wait_for_
void wait_for_(lock *bolt, enum wait_op op, long val,
               char const *file, long line) {
    switch (op) {
        case TO_BE:
            until (bolt->value == val) {
                int ret = pthread_cond_wait(&(bolt->cond), &(bolt->mutex));
                if (ret)
                    fail(ret, file, line, "cond_wait");
            }
            break;
        case NOT_TO_BE:
            until (bolt->value != val) {
                int ret = pthread_cond_wait(&(bolt->cond), &(bolt->mutex));
                if (ret)
                    fail(ret, file, line, "cond_wait");
            }
            break;
        case TO_BE_MORE_THAN:
            until (bolt->value > val) {
                int ret = pthread_cond_wait(&(bolt->cond), &(bolt->mutex));
                if (ret)
                    fail(ret, file, line, "cond_wait");
            }
            break;
        case TO_BE_LESS_THAN:
            until (bolt->value < val) {
                int ret = pthread_cond_wait(&(bolt->cond), &(bolt->mutex));
                if (ret)
                    fail(ret, file, line, "cond_wait");
            }
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
cmpl $0x3, %esi
ja 0xe424
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %r12
movl %esi, %eax
leaq 0x8787(%rip), %rcx      # 0x16b1c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x28(%r12), %r13
cmpq %r15, 0x58(%r12)
je 0xe424
movq %r13, %rdi
movq %r12, %rsi
callq 0x3150
testl %eax, %eax
je 0xe3a3
jmp 0xe410
leaq 0x28(%r12), %r13
cmpq %r15, 0x58(%r12)
jg 0xe424
movq %r13, %rdi
movq %r12, %rsi
callq 0x3150
testl %eax, %eax
je 0xe3c0
jmp 0xe410
leaq 0x28(%r12), %r13
cmpq %r15, 0x58(%r12)
jl 0xe424
movq %r13, %rdi
movq %r12, %rsi
callq 0x3150
testl %eax, %eax
je 0xe3dd
jmp 0xe410
leaq 0x28(%r12), %r13
cmpq %r15, 0x58(%r12)
jne 0xe424
movq %r13, %rdi
movq %r12, %rsi
callq 0x3150
testl %eax, %eax
je 0xe3fa
leaq 0x8756(%rip), %rcx      # 0x16b6d
movl %eax, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xe1c2
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/madler[P]pigz/yarn.c
// Function: free_lock_
void free_lock_(lock *bolt, char const *file, long line) {
    if (bolt == NULL)
        return;
    int ret = pthread_cond_destroy(&(bolt->cond));
    if (ret)
        fail(ret, file, line, "cond_destroy");
    ret = pthread_mutex_destroy(&(bolt->mutex));
    if (ret)
        fail(ret, file, line, "mutex_destroy");
    my_free(bolt);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xe46d
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
addq $0x28, %rdi
callq 0x34f0
testl %eax, %eax
jne 0xe473
movq %r15, %rdi
callq 0x31e0
testl %eax, %eax
jne 0xe47c
movq %r15, %rdi
popq %rbx
popq %r14
popq %r15
jmpq *0xeec3(%rip)           # 0x1d330
popq %rbx
popq %r14
popq %r15
retq
leaq 0x86fd(%rip), %rcx      # 0x16b77
jmp 0xe483
leaq 0x8701(%rip), %rcx      # 0x16b84
movl %eax, %edi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xe1c2