LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/zlib-1.3.0.1/gzread.c
// Function: gzgetc
int ZEXPORT gzgetc(gzFile file) {
    unsigned char buf[1];
    gz_statep state;

    /* get internal structure */
    if (file == NULL)
        return -1;
    state = (gz_statep)file;

    /* check that we're reading and that there's no (serious) error */
    if (state->mode != GZ_READ ||
        (state->err != Z_OK && state->err != Z_BUF_ERROR))
        return -1;

    /* try output buffer (no need to check for skip request) */
    if (state->x.have) {
        state->x.have--;
        state->x.pos++;
        return *(state->x.next)++;
    }

    /* nothing there -- try gz_read() */
    return gz_read(state, buf, 1) < 1 ? -1 : buf[0];
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0xcdb0e
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0xcdbc0
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpl $0x1c4f, 0x18(%rax)     # imm = 0x1C4F
jne 0xcdb3c
movq 0x8(%rsp), %rax
cmpl $0x0, 0x74(%rax)
je 0xcdb46
movq 0x8(%rsp), %rax
cmpl $-0x5, 0x74(%rax)
je 0xcdb46
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0xcdbc0
movq 0x8(%rsp), %rax
cmpl $0x0, (%rax)
je 0xcdb8a
movq 0x8(%rsp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rcx)
movzbl (%rax), %eax
movl %eax, 0x24(%rsp)
jmp 0xcdbc0
movq 0x8(%rsp), %rdi
leaq 0x17(%rsp), %rsi
movl $0x1, %edx
callq 0xcd790
cmpq $0x1, %rax
jae 0xcdbaf
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, 0x4(%rsp)
jmp 0xcdbb8
movzbl 0x17(%rsp), %eax
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/zlib-1.3.0.1/gzread.c
// Function: gz_skip
local int gz_skip(gz_statep state, z_off64_t len) {
    unsigned n;

    /* skip over len bytes or reach end-of-file, whichever comes first */
    while (len)
        /* skip over whatever is in output buffer */
        if (state->x.have) {
            n = GT_OFF(state->x.have) || (z_off64_t)state->x.have > len ?
                (unsigned)len : state->x.have;
            state->x.have -= n;
            state->x.next += n;
            state->x.pos += n;
            len -= n;
        }

        /* output buffer empty -- return if we're at the end of the input */
        else if (state->eof && state->strm.avail_in == 0)
            break;

        /* need more data to skip -- load up output buffer */
        else {
            /* get more output, looking for header if required */
            if (gz_fetch(state) == -1)
                return -1;
        }
    return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0xce20a
movq 0x18(%rsp), %rax
cmpl $0x0, (%rax)
je 0xce1cd
movq 0x18(%rsp), %rax
movl (%rax), %eax
cmpq 0x10(%rsp), %rax
jle 0xce16d
movq 0x10(%rsp), %rax
movl %eax, 0x8(%rsp)
jmp 0xce178
movq 0x18(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %edx
movq 0x18(%rsp), %rax
movl (%rax), %ecx
subl %edx, %ecx
movl %ecx, (%rax)
movl 0xc(%rsp), %edx
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rcx
movl %edx, %edx
addq %rdx, %rcx
movq %rcx, 0x8(%rax)
movl 0xc(%rsp), %eax
movl %eax, %ecx
movq 0x18(%rsp), %rax
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movl 0xc(%rsp), %eax
movl %eax, %ecx
movq 0x10(%rsp), %rax
subq %rcx, %rax
movq %rax, 0x10(%rsp)
jmp 0xce205
movq 0x18(%rsp), %rax
cmpl $0x0, 0x50(%rax)
je 0xce1e8
movq 0x18(%rsp), %rax
cmpl $0x0, 0x88(%rax)
jne 0xce1e8
jmp 0xce20a
movq 0x18(%rsp), %rdi
callq 0xce470
cmpl $-0x1, %eax
jne 0xce201
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0xce212
jmp 0xce203
jmp 0xce205
jmp 0xce13e
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/zlib-1.3.0.1/gzread.c
// Function: gz_fetch
local int gz_fetch(gz_statep state) {
    z_streamp strm = &(state->strm);

    do {
        switch(state->how) {
        case LOOK:      /* -> LOOK, COPY (only if never GZIP), or GZIP */
            if (gz_look(state) == -1)
                return -1;
            if (state->how == LOOK)
                return 0;
            break;
        case COPY:      /* -> COPY */
            if (gz_load(state, state->out, state->size << 1, &(state->x.have))
                    == -1)
                return -1;
            state->x.next = state->out;
            return 0;
        case GZIP:      /* -> GZIP or LOOK (if end of gzip stream) */
            strm->avail_out = state->size << 1;
            strm->next_out = state->out;
            if (gz_decomp(state) == -1)
                return -1;
        }
    } while (state->x.have == 0 && (!state->eof || strm->avail_in));
    return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
addq $0x80, %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movl 0x44(%rax), %eax
movl %eax, 0xc(%rsp)
testl %eax, %eax
je 0xce4b8
jmp 0xce49b
movl 0xc(%rsp), %eax
subl $0x1, %eax
je 0xce4f1
jmp 0xce4a6
movl 0xc(%rsp), %eax
subl $0x2, %eax
je 0xce544
jmp 0xce583
movq 0x18(%rsp), %rdi
callq 0xcde60
cmpl $-0x1, %eax
jne 0xce4d4
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0xce5d2
movq 0x18(%rsp), %rax
cmpl $0x0, 0x44(%rax)
jne 0xce4ec
movl $0x0, 0x24(%rsp)
jmp 0xce5d2
jmp 0xce583
movq 0x18(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x38(%rax), %rsi
movq 0x18(%rsp), %rax
movl 0x28(%rax), %edx
shll %edx
movq 0x18(%rsp), %rcx
callq 0xce750
cmpl $-0x1, %eax
jne 0xce525
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0xce5d2
movq 0x18(%rsp), %rax
movq 0x38(%rax), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, 0x24(%rsp)
jmp 0xce5d2
movq 0x18(%rsp), %rax
movl 0x28(%rax), %ecx
shll %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x20(%rax)
movq 0x18(%rsp), %rax
movq 0x38(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x18(%rsp), %rdi
callq 0xce850
cmpl $-0x1, %eax
jne 0xce581
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0xce5d2
jmp 0xce583
jmp 0xce585
movq 0x18(%rsp), %rcx
xorl %eax, %eax
cmpl $0x0, (%rcx)
movb %al, 0xb(%rsp)
jne 0xce5be
movq 0x18(%rsp), %rcx
movb $0x1, %al
cmpl $0x0, 0x50(%rcx)
movb %al, 0xa(%rsp)
je 0xce5b6
movq 0x10(%rsp), %rax
cmpl $0x0, 0x8(%rax)
setne %al
movb %al, 0xa(%rsp)
movb 0xa(%rsp), %al
movb %al, 0xb(%rsp)
movb 0xb(%rsp), %al
testb $0x1, %al
jne 0xce489
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/zlib-1.3.0.1/gzread.c
// Function: gzdirect
int ZEXPORT gzdirect(gzFile file) {
    gz_statep state;

    /* get internal structure */
    if (file == NULL)
        return 0;
    state = (gz_statep)file;

    /* if the state is not known, but we can find out, then do so (this is
       mainly for right after a gzopen() or gzdopen()) */
    if (state->mode == GZ_READ && state->how == LOOK && state->x.have == 0)
        (void)gz_look(state);

    /* return 1 if transparent, 0 if processing a gzip stream */
    return state->direct;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0xce5fb
movl $0x0, 0x14(%rsp)
jmp 0xce638
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
cmpl $0x1c4f, 0x18(%rax)     # imm = 0x1C4F
jne 0xce62d
movq (%rsp), %rax
cmpl $0x0, 0x44(%rax)
jne 0xce62d
movq (%rsp), %rax
cmpl $0x0, (%rax)
jne 0xce62d
movq (%rsp), %rdi
callq 0xcde60
movq (%rsp), %rax
movl 0x40(%rax), %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/zlib-1.3.0.1/gzread.c
// Function: gzclose_r
int ZEXPORT gzclose_r(gzFile file) {
    int ret, err;
    gz_statep state;

    /* get internal structure */
    if (file == NULL)
        return Z_STREAM_ERROR;
    state = (gz_statep)file;

    /* check that we're reading */
    if (state->mode != GZ_READ)
        return Z_STREAM_ERROR;

    /* free memory and close file */
    if (state->size) {
        inflateEnd(&(state->strm));
        free(state->out);
        free(state->in);
    }
    err = state->err == Z_BUF_ERROR ? Z_BUF_ERROR : Z_OK;
    gz_error(state, Z_OK, NULL);
    free(state->path);
    ret = close(state->fd);
    free(state);
    return ret ? Z_ERRNO : err;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0xce66e
movl $0xfffffffe, 0x24(%rsp) # imm = 0xFFFFFFFE
jmp 0xce73f
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpl $0x1c4f, 0x18(%rax)     # imm = 0x1C4F
je 0xce693
movl $0xfffffffe, 0x24(%rsp) # imm = 0xFFFFFFFE
jmp 0xce73f
movq 0x8(%rsp), %rax
cmpl $0x0, 0x28(%rax)
je 0xce6cb
movq 0x8(%rsp), %rdi
addq $0x80, %rdi
callq 0xddbb0
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rdi
callq 0xb760
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rdi
callq 0xb760
movq 0x8(%rsp), %rax
movl 0x74(%rax), %edx
xorl %eax, %eax
movl $0xfffffffb, %ecx       # imm = 0xFFFFFFFB
cmpl $-0x5, %edx
cmovel %ecx, %eax
movl %eax, 0x10(%rsp)
movq 0x8(%rsp), %rdi
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xcd150
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0xb760
movq 0x8(%rsp), %rax
movl 0x1c(%rax), %edi
callq 0xbc90
movl %eax, 0x14(%rsp)
movq 0x8(%rsp), %rdi
callq 0xb760
cmpl $0x0, 0x14(%rsp)
je 0xce72f
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, 0x4(%rsp)
jmp 0xce737
movl 0x10(%rsp), %eax
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/zlib-1.3.0.1/gzread.c
// Function: gz_load
local int gz_load(gz_statep state, unsigned char *buf, unsigned len,
                  unsigned *have) {
    int ret;
    unsigned get, max = ((unsigned)-1 >> 2) + 1;

    *have = 0;
    do {
        get = len - *have;
        if (get > max)
            get = max;
        ret = read(state->fd, buf + *have, get);
        if (ret <= 0)
            break;
        *have += (unsigned)ret;
    } while (*have < len);
    if (ret < 0) {
        gz_error(state, Z_ERRNO, zstrerror());
        return -1;
    }
    if (ret == 0)
        state->eof = 1;
    return 0;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movl %edx, 0x2c(%rsp)
movq %rcx, 0x20(%rsp)
movl $0x40000000, 0x14(%rsp) # imm = 0x40000000
movq 0x20(%rsp), %rax
movl $0x0, (%rax)
movl 0x2c(%rsp), %eax
movq 0x20(%rsp), %rcx
subl (%rcx), %eax
movl %eax, 0x18(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x14(%rsp), %eax
jbe 0xce79b
movl 0x14(%rsp), %eax
movl %eax, 0x18(%rsp)
movq 0x38(%rsp), %rax
movl 0x1c(%rax), %edi
movq 0x30(%rsp), %rsi
movq 0x20(%rsp), %rax
movl (%rax), %eax
addq %rax, %rsi
movl 0x18(%rsp), %eax
movl %eax, %edx
callq 0xb8a0
movl %eax, 0x1c(%rsp)
cmpl $0x0, 0x1c(%rsp)
jg 0xce7ca
jmp 0xce7e4
movl 0x1c(%rsp), %ecx
movq 0x20(%rsp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movq 0x20(%rsp), %rax
movl (%rax), %eax
cmpl 0x2c(%rsp), %eax
jb 0xce77a
cmpl $0x0, 0x1c(%rsp)
jge 0xce81d
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0xb060
movl (%rax), %edi
callq 0xb1b0
movq 0x8(%rsp), %rdi
movq %rax, %rdx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0xcd150
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0xce838
cmpl $0x0, 0x1c(%rsp)
jne 0xce830
movq 0x38(%rsp), %rax
movl $0x1, 0x50(%rax)
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/zlib-1.3.0.1/gzread.c
// Function: gz_avail
local int gz_avail(gz_statep state) {
    unsigned got;
    z_streamp strm = &(state->strm);

    if (state->err != Z_OK && state->err != Z_BUF_ERROR)
        return -1;
    if (state->eof == 0) {
        if (strm->avail_in) {       /* copy what's there to the start */
            unsigned char *p = state->in;
            unsigned const char *q = strm->next_in;
            unsigned n = strm->avail_in;
            do {
                *p++ = *q++;
            } while (--n);
        }
        if (gz_load(state, state->in + strm->avail_in,
                    state->size - strm->avail_in, &got) == -1)
            return -1;
        strm->avail_in += got;
        strm->next_in = state->in;
    }
    return 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rax
addq $0x80, %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
cmpl $0x0, 0x74(%rax)
je 0xcea5c
movq 0x28(%rsp), %rax
cmpl $-0x5, 0x74(%rax)
je 0xcea5c
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0xceb3f
movq 0x28(%rsp), %rax
cmpl $0x0, 0x50(%rax)
jne 0xceb37
movq 0x18(%rsp), %rax
cmpl $0x0, 0x8(%rax)
je 0xcead5
movq 0x28(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x4(%rsp)
movq 0x8(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rsp)
movb (%rax), %cl
movq 0x10(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x10(%rsp)
movb %cl, (%rax)
movl 0x4(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x4(%rsp)
cmpl $0x0, %eax
jne 0xcea9d
jmp 0xcead5
movq 0x28(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x30(%rax), %rsi
movq 0x18(%rsp), %rax
movl 0x8(%rax), %eax
addq %rax, %rsi
movq 0x28(%rsp), %rax
movl 0x28(%rax), %edx
movq 0x18(%rsp), %rax
subl 0x8(%rax), %edx
leaq 0x24(%rsp), %rcx
callq 0xce750
cmpl $-0x1, %eax
jne 0xceb17
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0xceb3f
movl 0x24(%rsp), %ecx
movq 0x18(%rsp), %rax
addl 0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
movq 0x28(%rsp), %rax
movq 0x30(%rax), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/zlib-1.3.0.1/gzwrite.c
// Function: gzwrite
int ZEXPORT gzwrite(gzFile file, voidpc buf, unsigned len) {
    gz_statep state;

    /* get internal structure */
    if (file == NULL)
        return 0;
    state = (gz_statep)file;

    /* check that we're writing and that there's no error */
    if (state->mode != GZ_WRITE || state->err != Z_OK)
        return 0;

    /* since an int is returned, make sure len fits in one, otherwise return
       with an error (this avoids a flaw in the interface) */
    if ((int)len < 0) {
        gz_error(state, Z_DATA_ERROR, "requested length does not fit in int");
        return 0;
    }

    /* write len bytes from buf (the return value will fit in an int) */
    return (int)gz_write(state, buf, len);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0xceb74
movl $0x0, 0x24(%rsp)
jmp 0xcebdc
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
cmpl $0x79b1, 0x18(%rax)     # imm = 0x79B1
jne 0xceb94
movq (%rsp), %rax
cmpl $0x0, 0x74(%rax)
je 0xceb9e
movl $0x0, 0x24(%rsp)
jmp 0xcebdc
cmpl $0x0, 0xc(%rsp)
jge 0xcebc4
movq (%rsp), %rdi
movl $0xfffffffd, %esi       # imm = 0xFFFFFFFD
leaq 0xa7734(%rip), %rdx     # 0x1762e9
callq 0xcd150
movl $0x0, 0x24(%rsp)
jmp 0xcebdc
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
movl 0xc(%rsp), %eax
movl %eax, %edx
callq 0xcebf0
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/zlib-1.3.0.1/gzwrite.c
// Function: gzfwrite
z_size_t ZEXPORT gzfwrite(voidpc buf, z_size_t size, z_size_t nitems,
                          gzFile file) {
    z_size_t len;
    gz_statep state;

    /* get internal structure */
    if (file == NULL)
        return 0;
    state = (gz_statep)file;

    /* check that we're writing and that there's no error */
    if (state->mode != GZ_WRITE || state->err != Z_OK)
        return 0;

    /* compute bytes to read -- error on overflow */
    len = nitems * size;
    if (size && len / size != nitems) {
        gz_error(state, Z_STREAM_ERROR, "request does not fit in a size_t");
        return 0;
    }

    /* write len bytes to buf, return the number of full items written */
    return len ? gz_write(state, buf, len) / size : 0;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0xceebe
movq $0x0, 0x40(%rsp)
jmp 0xcef7c
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpl $0x79b1, 0x18(%rax)     # imm = 0x79B1
jne 0xceee1
movq 0x10(%rsp), %rax
cmpl $0x0, 0x74(%rax)
je 0xceeef
movq $0x0, 0x40(%rsp)
jmp 0xcef7c
movq 0x28(%rsp), %rax
imulq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0xcef3d
movq 0x18(%rsp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq 0x30(%rsp)
cmpq 0x28(%rsp), %rax
je 0xcef3d
movq 0x10(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0xa7319(%rip), %rdx     # 0x176246
callq 0xcd150
movq $0x0, 0x40(%rsp)
jmp 0xcef7c
cmpq $0x0, 0x18(%rsp)
je 0xcef69
movq 0x10(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0xcebf0
xorl %ecx, %ecx
movl %ecx, %edx
divq 0x30(%rsp)
movq %rax, 0x8(%rsp)
jmp 0xcef72
xorl %eax, %eax
movq %rax, 0x8(%rsp)
jmp 0xcef72
movq 0x8(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/zlib-1.3.0.1/gzwrite.c
// Function: gz_zero
local int gz_zero(gz_statep state, z_off64_t len) {
    int first;
    unsigned n;
    z_streamp strm = &(state->strm);

    /* consume whatever's left in the input buffer */
    if (strm->avail_in && gz_comp(state, Z_NO_FLUSH) == -1)
        return -1;

    /* compress len zeros (len guaranteed > 0) */
    first = 1;
    while (len) {
        n = GT_OFF(state->size) || (z_off64_t)state->size > len ?
            (unsigned)len : state->size;
        if (first) {
            memset(state->in, 0, n);
            first = 0;
        }
        strm->avail_in = n;
        strm->next_in = state->in;
        state->x.pos += n;
        if (gz_comp(state, Z_NO_FLUSH) == -1)
            return -1;
        len -= n;
    }
    return 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
addq $0x80, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpl $0x0, 0x8(%rax)
je 0xcf167
movq 0x28(%rsp), %rdi
xorl %esi, %esi
callq 0xcf7a0
cmpl $-0x1, %eax
jne 0xcf167
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0xcf239
movl $0x1, 0x1c(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0xcf231
movq 0x28(%rsp), %rax
movl 0x28(%rax), %eax
cmpq 0x20(%rsp), %rax
jle 0xcf195
movq 0x20(%rsp), %rax
movl %eax, 0xc(%rsp)
jmp 0xcf1a1
movq 0x28(%rsp), %rax
movl 0x28(%rax), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x18(%rsp)
cmpl $0x0, 0x1c(%rsp)
je 0xcf1ce
movq 0x28(%rsp), %rax
movq 0x30(%rax), %rdi
movl 0x18(%rsp), %eax
movl %eax, %edx
xorl %esi, %esi
callq 0xb2d0
movl $0x0, 0x1c(%rsp)
movl 0x18(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x28(%rsp), %rax
movq 0x30(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movl 0x18(%rsp), %eax
movl %eax, %ecx
movq 0x28(%rsp), %rax
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movq 0x28(%rsp), %rdi
xorl %esi, %esi
callq 0xcf7a0
cmpl $-0x1, %eax
jne 0xcf219
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0xcf239
movl 0x18(%rsp), %eax
movl %eax, %ecx
movq 0x20(%rsp), %rax
subq %rcx, %rax
movq %rax, 0x20(%rsp)
jmp 0xcf16f
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/zlib-1.3.0.1/gzwrite.c
// Function: gzputs
int ZEXPORT gzputs(gzFile file, const char *s) {
    z_size_t len, put;
    gz_statep state;

    /* get internal structure */
    if (file == NULL)
        return -1;
    state = (gz_statep)file;

    /* check that we're writing and that there's no error */
    if (state->mode != GZ_WRITE || state->err != Z_OK)
        return -1;

    /* write string */
    len = strlen(s);
    if ((int)len < 0 || (unsigned)len != len) {
        gz_error(state, Z_STREAM_ERROR, "string length does not fit in int");
        return -1;
    }
    put = gz_write(state, s, len);
    return put < len ? -1 : (int)len;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
cmpq $0x0, 0x28(%rsp)
jne 0xcf273
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0xcf32b
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpl $0x79b1, 0x18(%rax)     # imm = 0x79B1
jne 0xcf296
movq 0x8(%rsp), %rax
cmpl $0x0, 0x74(%rax)
je 0xcf2a3
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0xcf32b
movq 0x20(%rsp), %rdi
callq 0xb240
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpl $0x0, %eax
jl 0xcf2ca
movq 0x18(%rsp), %rax
movl %eax, %eax
cmpq 0x18(%rsp), %rax
je 0xcf2ea
movq 0x8(%rsp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
leaq 0xa7033(%rip), %rdx     # 0x17630e
callq 0xcd150
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0xcf32b
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0xcebf0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x18(%rsp), %rax
jae 0xcf31a
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, 0x4(%rsp)
jmp 0xcf323
movq 0x18(%rsp), %rax
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/zlib-1.3.0.1/gzwrite.c
// Function: gzprintf
int ZEXPORTVA gzprintf(gzFile file, const char *format, ...) {
    va_list va;
    int ret;

    va_start(va, format);
    ret = gzvprintf(file, format, va);
    va_end(va);
    return ret;
}

// Assembly:
subq $0xe8, %rsp
testb %al, %al
je 0xcfb1c
movaps %xmm0, 0x30(%rsp)
movaps %xmm1, 0x40(%rsp)
movaps %xmm2, 0x50(%rsp)
movaps %xmm3, 0x60(%rsp)
movaps %xmm4, 0x70(%rsp)
movaps %xmm5, 0x80(%rsp)
movaps %xmm6, 0x90(%rsp)
movaps %xmm7, 0xa0(%rsp)
movq %r9, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rdi, 0xe0(%rsp)
movq %rsi, 0xd8(%rsp)
movq %rsp, %rax
movq %rax, 0xd0(%rsp)
leaq 0xf0(%rsp), %rax
movq %rax, 0xc8(%rsp)
movl $0x30, 0xc4(%rsp)
movl $0x10, 0xc0(%rsp)
movq 0xe0(%rsp), %rdi
movq 0xd8(%rsp), %rsi
leaq 0xc0(%rsp), %rdx
callq 0xcf340
movl %eax, 0xbc(%rsp)
movl 0xbc(%rsp), %eax
addq $0xe8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/zlib-1.3.0.1/gzwrite.c
// Function: gzflush
int ZEXPORT gzflush(gzFile file, int flush) {
    gz_statep state;

    /* get internal structure */
    if (file == NULL)
        return Z_STREAM_ERROR;
    state = (gz_statep)file;

    /* check that we're writing and that there's no error */
    if (state->mode != GZ_WRITE || state->err != Z_OK)
        return Z_STREAM_ERROR;

    /* check flush parameter */
    if (flush < 0 || flush > Z_FINISH)
        return Z_STREAM_ERROR;

    /* check for seek request */
    if (state->seek) {
        state->seek = 0;
        if (gz_zero(state, state->skip) == -1)
            return state->err;
    }

    /* compress remaining data with requested flush */
    (void)gz_comp(state, flush);
    return state->err;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0xcfbd2
movl $0xfffffffe, 0x24(%rsp) # imm = 0xFFFFFFFE
jmp 0xcfc70
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpl $0x79b1, 0x18(%rax)     # imm = 0x79B1
jne 0xcfbf5
movq 0x8(%rsp), %rax
cmpl $0x0, 0x74(%rax)
je 0xcfbff
movl $0xfffffffe, 0x24(%rsp) # imm = 0xFFFFFFFE
jmp 0xcfc70
cmpl $0x0, 0x14(%rsp)
jl 0xcfc0d
cmpl $0x4, 0x14(%rsp)
jle 0xcfc17
movl $0xfffffffe, 0x24(%rsp) # imm = 0xFFFFFFFE
jmp 0xcfc70
movq 0x8(%rsp), %rax
cmpl $0x0, 0x70(%rax)
je 0xcfc56
movq 0x8(%rsp), %rax
movl $0x0, 0x70(%rax)
movq 0x8(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x68(%rax), %rsi
callq 0xcf120
cmpl $-0x1, %eax
jne 0xcfc54
movq 0x8(%rsp), %rax
movl 0x74(%rax), %eax
movl %eax, 0x24(%rsp)
jmp 0xcfc70
jmp 0xcfc56
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0xcf7a0
movq 0x8(%rsp), %rax
movl 0x74(%rax), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/zlib-1.3.0.1/gzwrite.c
// Function: gzsetparams
int ZEXPORT gzsetparams(gzFile file, int level, int strategy) {
    gz_statep state;
    z_streamp strm;

    /* get internal structure */
    if (file == NULL)
        return Z_STREAM_ERROR;
    state = (gz_statep)file;
    strm = &(state->strm);

    /* check that we're writing and that there's no error */
    if (state->mode != GZ_WRITE || state->err != Z_OK || state->direct)
        return Z_STREAM_ERROR;

    /* if no change is requested, then do nothing */
    if (level == state->level && strategy == state->strategy)
        return Z_OK;

    /* check for seek request */
    if (state->seek) {
        state->seek = 0;
        if (gz_zero(state, state->skip) == -1)
            return state->err;
    }

    /* change compression parameters for subsequent input */
    if (state->size) {
        /* flush previous input with previous parameters before changing */
        if (strm->avail_in && gz_comp(state, Z_BLOCK) == -1)
            return state->err;
        deflateParams(strm, level, strategy);
    }
    state->level = level;
    state->strategy = strategy;
    return Z_OK;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movl %edx, 0x10(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0xcfca6
movl $0xfffffffe, 0x24(%rsp) # imm = 0xFFFFFFFE
jmp 0xcfdc0
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x80, %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
cmpl $0x79b1, 0x18(%rax)     # imm = 0x79B1
jne 0xcfce3
movq 0x8(%rsp), %rax
cmpl $0x0, 0x74(%rax)
jne 0xcfce3
movq 0x8(%rsp), %rax
cmpl $0x0, 0x40(%rax)
je 0xcfcf0
movl $0xfffffffe, 0x24(%rsp) # imm = 0xFFFFFFFE
jmp 0xcfdc0
movl 0x14(%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl 0x58(%rcx), %eax
jne 0xcfd19
movl 0x10(%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl 0x5c(%rcx), %eax
jne 0xcfd19
movl $0x0, 0x24(%rsp)
jmp 0xcfdc0
movq 0x8(%rsp), %rax
cmpl $0x0, 0x70(%rax)
je 0xcfd58
movq 0x8(%rsp), %rax
movl $0x0, 0x70(%rax)
movq 0x8(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x68(%rax), %rsi
callq 0xcf120
cmpl $-0x1, %eax
jne 0xcfd56
movq 0x8(%rsp), %rax
movl 0x74(%rax), %eax
movl %eax, 0x24(%rsp)
jmp 0xcfdc0
jmp 0xcfd58
movq 0x8(%rsp), %rax
cmpl $0x0, 0x28(%rax)
je 0xcfda0
movq (%rsp), %rax
cmpl $0x0, 0x8(%rax)
je 0xcfd8f
movq 0x8(%rsp), %rdi
movl $0x5, %esi
callq 0xcf7a0
cmpl $-0x1, %eax
jne 0xcfd8f
movq 0x8(%rsp), %rax
movl 0x74(%rax), %eax
movl %eax, 0x24(%rsp)
jmp 0xcfdc0
movq (%rsp), %rdi
movl 0x14(%rsp), %esi
movl 0x10(%rsp), %edx
callq 0xd1440
movl 0x14(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x58(%rax)
movl 0x10(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x5c(%rax)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/zlib-1.3.0.1/gzwrite.c
// Function: gzclose_w
int ZEXPORT gzclose_w(gzFile file) {
    int ret = Z_OK;
    gz_statep state;

    /* get internal structure */
    if (file == NULL)
        return Z_STREAM_ERROR;
    state = (gz_statep)file;

    /* check that we're writing */
    if (state->mode != GZ_WRITE)
        return Z_STREAM_ERROR;

    /* check for seek request */
    if (state->seek) {
        state->seek = 0;
        if (gz_zero(state, state->skip) == -1)
            ret = state->err;
    }

    /* flush, free memory, and close file */
    if (gz_comp(state, Z_FINISH) == -1)
        ret = state->err;
    if (state->size) {
        if (!state->direct) {
            (void)deflateEnd(&(state->strm));
            free(state->out);
        }
        free(state->in);
    }
    gz_error(state, Z_OK, NULL);
    free(state->path);
    if (close(state->fd) == -1)
        ret = Z_ERRNO;
    free(state);
    return ret;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0xcfdf6
movl $0xfffffffe, 0x24(%rsp) # imm = 0xFFFFFFFE
jmp 0xcff05
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpl $0x79b1, 0x18(%rax)     # imm = 0x79B1
je 0xcfe1b
movl $0xfffffffe, 0x24(%rsp) # imm = 0xFFFFFFFE
jmp 0xcff05
movq 0x8(%rsp), %rax
cmpl $0x0, 0x70(%rax)
je 0xcfe58
movq 0x8(%rsp), %rax
movl $0x0, 0x70(%rax)
movq 0x8(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x68(%rax), %rsi
callq 0xcf120
cmpl $-0x1, %eax
jne 0xcfe56
movq 0x8(%rsp), %rax
movl 0x74(%rax), %eax
movl %eax, 0x14(%rsp)
jmp 0xcfe58
movq 0x8(%rsp), %rdi
movl $0x4, %esi
callq 0xcf7a0
cmpl $-0x1, %eax
jne 0xcfe78
movq 0x8(%rsp), %rax
movl 0x74(%rax), %eax
movl %eax, 0x14(%rsp)
movq 0x8(%rsp), %rax
cmpl $0x0, 0x28(%rax)
je 0xcfebb
movq 0x8(%rsp), %rax
cmpl $0x0, 0x40(%rax)
jne 0xcfead
movq 0x8(%rsp), %rdi
addq $0x80, %rdi
callq 0xd0400
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rdi
callq 0xb760
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rdi
callq 0xb760
movq 0x8(%rsp), %rdi
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xcd150
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0xb760
movq 0x8(%rsp), %rax
movl 0x1c(%rax), %edi
callq 0xbc90
cmpl $-0x1, %eax
jne 0xcfef3
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
movq 0x8(%rsp), %rdi
callq 0xb760
movl 0x14(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/zlib-1.3.0.1/deflate.c
// Function: deflateEnd
int ZEXPORT deflateEnd(z_streamp strm) {
    int status;

    if (deflateStateCheck(strm)) return Z_STREAM_ERROR;

    status = strm->state->status;

    /* Deallocate in reverse order of allocations: */
    TRY_FREE(strm, strm->state->pending_buf);
    TRY_FREE(strm, strm->state->head);
    TRY_FREE(strm, strm->state->prev);
    TRY_FREE(strm, strm->state->window);

    ZFREE(strm, strm->state);
    strm->state = Z_NULL;

    return status == BUSY_STATE ? Z_DATA_ERROR : Z_OK;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0xd0920
cmpl $0x0, %eax
je 0xd0425
movl $0xfffffffe, 0x14(%rsp) # imm = 0xFFFFFFFE
jmp 0xd0538
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, 0x4(%rsp)
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rax
cmpq $0x0, 0x10(%rax)
je 0xd0466
movq 0x8(%rsp), %rax
movq 0x48(%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x50(%rcx), %rdi
movq 0x8(%rsp), %rcx
movq 0x38(%rcx), %rcx
movq 0x10(%rcx), %rsi
callq *%rax
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rax
cmpq $0x0, 0x78(%rax)
je 0xd0497
movq 0x8(%rsp), %rax
movq 0x48(%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x50(%rcx), %rdi
movq 0x8(%rsp), %rcx
movq 0x38(%rcx), %rcx
movq 0x78(%rcx), %rsi
callq *%rax
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rax
cmpq $0x0, 0x70(%rax)
je 0xd04c8
movq 0x8(%rsp), %rax
movq 0x48(%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x50(%rcx), %rdi
movq 0x8(%rsp), %rcx
movq 0x38(%rcx), %rcx
movq 0x70(%rcx), %rsi
callq *%rax
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rax
cmpq $0x0, 0x60(%rax)
je 0xd04f9
movq 0x8(%rsp), %rax
movq 0x48(%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x50(%rcx), %rdi
movq 0x8(%rsp), %rcx
movq 0x38(%rcx), %rcx
movq 0x60(%rcx), %rsi
callq *%rax
movq 0x8(%rsp), %rax
movq 0x48(%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x50(%rcx), %rdi
movq 0x8(%rsp), %rcx
movq 0x38(%rcx), %rsi
callq *%rax
movq 0x8(%rsp), %rax
movq $0x0, 0x38(%rax)
movl 0x4(%rsp), %edx
xorl %eax, %eax
movl $0xfffffffd, %ecx       # imm = 0xFFFFFFFD
cmpl $0x71, %edx
cmovel %ecx, %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/zlib-1.3.0.1/deflate.c
// Function: deflateReset
int ZEXPORT deflateReset(z_streamp strm) {
    int ret;

    ret = deflateResetKeep(strm);
    if (ret == Z_OK)
        lm_init(strm->state);
    return ret;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0xd0f90
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jne 0xd057c
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rdi
callq 0xd10c0
movl 0xc(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/zlib-1.3.0.1/deflate.c
// Function: deflateStateCheck
local int deflateStateCheck(z_streamp strm) {
    deflate_state *s;
    if (strm == Z_NULL ||
        strm->zalloc == (alloc_func)0 || strm->zfree == (free_func)0)
        return 1;
    s = strm->state;
    if (s == Z_NULL || s->strm != strm || (s->status != INIT_STATE &&
#ifdef GZIP
                                           s->status != GZIP_STATE &&
#endif
                                           s->status != EXTRA_STATE &&
                                           s->status != NAME_STATE &&
                                           s->status != COMMENT_STATE &&
                                           s->status != HCRC_STATE &&
                                           s->status != BUSY_STATE &&
                                           s->status != FINISH_STATE))
        return 1;
    return 0;
}

// Assembly:
movq %rdi, -0x10(%rsp)
cmpq $0x0, -0x10(%rsp)
je 0xd0945
movq -0x10(%rsp), %rax
cmpq $0x0, 0x40(%rax)
je 0xd0945
movq -0x10(%rsp), %rax
cmpq $0x0, 0x48(%rax)
jne 0xd0952
movl $0x1, -0x4(%rsp)
jmp 0xd09e4
movq -0x10(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x18(%rsp)
cmpq $0x0, -0x18(%rsp)
je 0xd09d2
movq -0x18(%rsp), %rax
movq (%rax), %rax
cmpq -0x10(%rsp), %rax
jne 0xd09d2
movq -0x18(%rsp), %rax
cmpl $0x2a, 0x8(%rax)
je 0xd09dc
movq -0x18(%rsp), %rax
cmpl $0x39, 0x8(%rax)
je 0xd09dc
movq -0x18(%rsp), %rax
cmpl $0x45, 0x8(%rax)
je 0xd09dc
movq -0x18(%rsp), %rax
cmpl $0x49, 0x8(%rax)
je 0xd09dc
movq -0x18(%rsp), %rax
cmpl $0x5b, 0x8(%rax)
je 0xd09dc
movq -0x18(%rsp), %rax
cmpl $0x67, 0x8(%rax)
je 0xd09dc
movq -0x18(%rsp), %rax
cmpl $0x71, 0x8(%rax)
je 0xd09dc
movq -0x18(%rsp), %rax
cmpl $0x29a, 0x8(%rax)       # imm = 0x29A
je 0xd09dc
movl $0x1, -0x4(%rsp)
jmp 0xd09e4
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/zlib-1.3.0.1/deflate.c
// Function: deflateGetDictionary
int ZEXPORT deflateGetDictionary(z_streamp strm, Bytef *dictionary,
                                 uInt *dictLength) {
    deflate_state *s;
    uInt len;

    if (deflateStateCheck(strm))
        return Z_STREAM_ERROR;
    s = strm->state;
    len = s->strstart + s->lookahead;
    if (len > s->w_size)
        len = s->w_size;
    if (dictionary != Z_NULL && len)
        zmemcpy(dictionary, s->window + s->strstart + s->lookahead - len, len);
    if (dictLength != Z_NULL)
        *dictLength = len;
    return Z_OK;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rdi
callq 0xd0920
cmpl $0x0, %eax
je 0xd0ecf
movl $0xfffffffe, 0x34(%rsp) # imm = 0xFFFFFFFE
jmp 0xd0f7e
movq 0x28(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movl 0xac(%rax), %eax
movq 0x10(%rsp), %rcx
addl 0xb4(%rcx), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x50(%rcx), %eax
jbe 0xd0f11
movq 0x10(%rsp), %rax
movl 0x50(%rax), %eax
movl %eax, 0xc(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0xd0f63
cmpl $0x0, 0xc(%rsp)
je 0xd0f63
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x60(%rax), %rsi
movq 0x10(%rsp), %rax
movl 0xac(%rax), %eax
addq %rax, %rsi
movq 0x10(%rsp), %rax
movl 0xb4(%rax), %eax
addq %rax, %rsi
movl 0xc(%rsp), %eax
movl %eax, %ecx
xorl %eax, %eax
subq %rcx, %rax
addq %rax, %rsi
movl 0xc(%rsp), %eax
movl %eax, %edx
callq 0xb500
cmpq $0x0, 0x18(%rsp)
je 0xd0f76
movl 0xc(%rsp), %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/zlib-1.3.0.1/deflate.c
// Function: lm_init
local void lm_init(deflate_state *s) {
    s->window_size = (ulg)2L*s->w_size;

    CLEAR_HASH(s);

    /* Set the default configuration parameters:
     */
    s->max_lazy_match   = configuration_table[s->level].max_lazy;
    s->good_match       = configuration_table[s->level].good_length;
    s->nice_match       = configuration_table[s->level].nice_length;
    s->max_chain_length = configuration_table[s->level].max_chain;

    s->strstart = 0;
    s->block_start = 0L;
    s->lookahead = 0;
    s->insert = 0;
    s->match_length = s->prev_length = MIN_MATCH-1;
    s->match_available = 0;
    s->ins_h = 0;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movl 0x50(%rax), %eax
movl %eax, %ecx
shlq %rcx
movq (%rsp), %rax
movq %rcx, 0x68(%rax)
movq (%rsp), %rax
movq 0x78(%rax), %rax
movq (%rsp), %rcx
movl 0x84(%rcx), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movw $0x0, (%rax,%rcx,2)
movq (%rsp), %rax
movq 0x78(%rax), %rdi
movq (%rsp), %rax
movl 0x84(%rax), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %edx
shlq %rdx
xorl %esi, %esi
callq 0xb2d0
movq (%rsp), %rax
movslq 0xc4(%rax), %rcx
leaq 0xe21d5(%rip), %rax     # 0x1b3300
shlq $0x4, %rcx
addq %rcx, %rax
movzwl 0x2(%rax), %ecx
movq (%rsp), %rax
movl %ecx, 0xc0(%rax)
movq (%rsp), %rax
movslq 0xc4(%rax), %rcx
leaq 0xe21ae(%rip), %rax     # 0x1b3300
shlq $0x4, %rcx
addq %rcx, %rax
movzwl (%rax), %ecx
movq (%rsp), %rax
movl %ecx, 0xcc(%rax)
movq (%rsp), %rax
movslq 0xc4(%rax), %rcx
leaq 0xe2188(%rip), %rax     # 0x1b3300
shlq $0x4, %rcx
addq %rcx, %rax
movzwl 0x4(%rax), %ecx
movq (%rsp), %rax
movl %ecx, 0xd0(%rax)
movq (%rsp), %rax
movslq 0xc4(%rax), %rcx
leaq 0xe2161(%rip), %rax     # 0x1b3300
shlq $0x4, %rcx
addq %rcx, %rax
movzwl 0x6(%rax), %ecx
movq (%rsp), %rax
movl %ecx, 0xbc(%rax)
movq (%rsp), %rax
movl $0x0, 0xac(%rax)
movq (%rsp), %rax
movq $0x0, 0x98(%rax)
movq (%rsp), %rax
movl $0x0, 0xb4(%rax)
movq (%rsp), %rax
movl $0x0, 0x172c(%rax)
movq (%rsp), %rax
movl $0x2, 0xb8(%rax)
movq (%rsp), %rax
movl $0x2, 0xa0(%rax)
movq (%rsp), %rax
movl $0x0, 0xa8(%rax)
movq (%rsp), %rax
movl $0x0, 0x80(%rax)
popq %rax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/zlib-1.3.0.1/deflate.c
// Function: deflateSetHeader
int ZEXPORT deflateSetHeader(z_streamp strm, gz_headerp head) {
    if (deflateStateCheck(strm) || strm->state->wrap != 2)
        return Z_STREAM_ERROR;
    strm->state->gzhead = head;
    return Z_OK;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq 0x8(%rsp), %rdi
callq 0xd0920
cmpl $0x0, %eax
jne 0xd125b
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rax
cmpl $0x2, 0x30(%rax)
je 0xd1265
movl $0xfffffffe, 0x14(%rsp) # imm = 0xFFFFFFFE
jmp 0xd127e
movq (%rsp), %rcx
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rax
movq %rcx, 0x38(%rax)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/zlib-1.3.0.1/deflate.c
// Function: deflatePending
int ZEXPORT deflatePending(z_streamp strm, unsigned *pending, int *bits) {
    if (deflateStateCheck(strm)) return Z_STREAM_ERROR;
    if (pending != Z_NULL)
        *pending = strm->state->pending;
    if (bits != Z_NULL)
        *bits = strm->state->bi_valid;
    return Z_OK;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0xd0920
cmpl $0x0, %eax
je 0xd12bc
movl $0xfffffffe, 0x24(%rsp) # imm = 0xFFFFFFFE
jmp 0xd1300
cmpq $0x0, 0x10(%rsp)
je 0xd12da
movq 0x18(%rsp), %rax
movq 0x38(%rax), %rax
movq 0x28(%rax), %rax
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
cmpq $0x0, 0x8(%rsp)
je 0xd12f8
movq 0x18(%rsp), %rax
movq 0x38(%rax), %rax
movl 0x1734(%rax), %ecx
movq 0x8(%rsp), %rax
movl %ecx, (%rax)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/zlib-1.3.0.1/deflate.c
// Function: deflatePrime
int ZEXPORT deflatePrime(z_streamp strm, int bits, int value) {
    deflate_state *s;
    int put;

    if (deflateStateCheck(strm)) return Z_STREAM_ERROR;
    s = strm->state;
#ifdef LIT_MEM
    if (bits < 0 || bits > 16 ||
        (uchf *)s->d_buf < s->pending_out + ((Buf_size + 7) >> 3))
        return Z_BUF_ERROR;
#else
    if (bits < 0 || bits > 16 ||
        s->sym_buf < s->pending_out + ((Buf_size + 7) >> 3))
        return Z_BUF_ERROR;
#endif
    do {
        put = Buf_size - s->bi_valid;
        if (put > bits)
            put = bits;
        s->bi_buf |= (ush)((value & ((1 << put) - 1)) << s->bi_valid);
        s->bi_valid += put;
        _tr_flush_bits(s);
        value >>= put;
        bits -= put;
    } while (bits);
    return Z_OK;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movl %edx, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0xd0920
cmpl $0x0, %eax
je 0xd133d
movl $0xfffffffe, 0x24(%rsp) # imm = 0xFFFFFFFE
jmp 0xd1435
movq 0x18(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, 0x8(%rsp)
cmpl $0x0, 0x14(%rsp)
jl 0xd1377
cmpl $0x10, 0x14(%rsp)
jg 0xd1377
movq 0x8(%rsp), %rax
movq 0x1700(%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x20(%rcx), %rcx
addq $0x2, %rcx
cmpq %rcx, %rax
jae 0xd1384
movl $0xfffffffb, 0x24(%rsp) # imm = 0xFFFFFFFB
jmp 0xd1435
jmp 0xd1386
movq 0x8(%rsp), %rcx
movl $0x10, %eax
subl 0x1734(%rcx), %eax
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x14(%rsp), %eax
jle 0xd13ac
movl 0x14(%rsp), %eax
movl %eax, 0x4(%rsp)
movl 0x10(%rsp), %eax
movl 0x4(%rsp), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
subl $0x1, %ecx
andl %ecx, %eax
movq 0x8(%rsp), %rcx
movl 0x1734(%rcx), %ecx
shll %cl, %eax
movzwl %ax, %edx
movq 0x8(%rsp), %rax
movzwl 0x1730(%rax), %ecx
orl %edx, %ecx
movw %cx, 0x1730(%rax)
movl 0x4(%rsp), %ecx
movq 0x8(%rsp), %rax
addl 0x1734(%rax), %ecx
movl %ecx, 0x1734(%rax)
movq 0x8(%rsp), %rdi
callq 0xd6790
movl 0x4(%rsp), %ecx
movl 0x10(%rsp), %eax
sarl %cl, %eax
movl %eax, 0x10(%rsp)
movl 0x4(%rsp), %ecx
movl 0x14(%rsp), %eax
subl %ecx, %eax
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jne 0xd1386
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/zlib-1.3.0.1/deflate.c
// Function: slide_hash
local void slide_hash(deflate_state *s) {
    unsigned n, m;
    Posf *p;
    uInt wsize = s->w_size;

    n = s->hash_size;
    p = &s->head[n];
    do {
        m = *--p;
        *p = (Pos)(m >= wsize ? m - wsize : NIL);
    } while (--n);
    n = wsize;
#ifndef FASTEST
    p = &s->prev[n];
    do {
        m = *--p;
        *p = (Pos)(m >= wsize ? m - wsize : NIL);
        /* If n is not on any hash chain, prev[n] is garbage but
         * its value will never be used.
         */
    } while (--n);
#endif
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movl 0x50(%rax), %eax
movl %eax, -0x1c(%rsp)
movq -0x8(%rsp), %rax
movl 0x84(%rax), %eax
movl %eax, -0xc(%rsp)
movq -0x8(%rsp), %rax
movq 0x78(%rax), %rax
movl -0xc(%rsp), %ecx
shlq %rcx
addq %rcx, %rax
movq %rax, -0x18(%rsp)
movq -0x18(%rsp), %rax
movq %rax, %rcx
addq $-0x2, %rcx
movq %rcx, -0x18(%rsp)
movzwl -0x2(%rax), %eax
movl %eax, -0x10(%rsp)
movl -0x10(%rsp), %eax
cmpl -0x1c(%rsp), %eax
jb 0xd2b09
movl -0x10(%rsp), %eax
subl -0x1c(%rsp), %eax
movl %eax, -0x20(%rsp)
jmp 0xd2b11
xorl %eax, %eax
movl %eax, -0x20(%rsp)
jmp 0xd2b11
movl -0x20(%rsp), %eax
movw %ax, %cx
movq -0x18(%rsp), %rax
movw %cx, (%rax)
movl -0xc(%rsp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rsp)
cmpl $0x0, %eax
jne 0xd2ad8
movl -0x1c(%rsp), %eax
movl %eax, -0xc(%rsp)
movq -0x8(%rsp), %rax
movq 0x70(%rax), %rax
movl -0xc(%rsp), %ecx
shlq %rcx
addq %rcx, %rax
movq %rax, -0x18(%rsp)
movq -0x18(%rsp), %rax
movq %rax, %rcx
addq $-0x2, %rcx
movq %rcx, -0x18(%rsp)
movzwl -0x2(%rax), %eax
movl %eax, -0x10(%rsp)
movl -0x10(%rsp), %eax
cmpl -0x1c(%rsp), %eax
jb 0xd2b81
movl -0x10(%rsp), %eax
subl -0x1c(%rsp), %eax
movl %eax, -0x24(%rsp)
jmp 0xd2b89
xorl %eax, %eax
movl %eax, -0x24(%rsp)
jmp 0xd2b89
movl -0x24(%rsp), %eax
movw %ax, %cx
movq -0x18(%rsp), %rax
movw %cx, (%rax)
movl -0xc(%rsp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rsp)
cmpl $0x0, %eax
jne 0xd2b50
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/zlib-1.3.0.1/deflate.c
// Function: deflateTune
int ZEXPORT deflateTune(z_streamp strm, int good_length, int max_lazy,
                        int nice_length, int max_chain) {
    deflate_state *s;

    if (deflateStateCheck(strm)) return Z_STREAM_ERROR;
    s = strm->state;
    s->good_match = (uInt)good_length;
    s->max_lazy_match = (uInt)max_lazy;
    s->nice_match = nice_length;
    s->max_chain_length = (uInt)max_chain;
    return Z_OK;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movl %edx, 0x10(%rsp)
movl %ecx, 0xc(%rsp)
movl %r8d, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0xd0920
cmpl $0x0, %eax
je 0xd2be3
movl $0xfffffffe, 0x24(%rsp) # imm = 0xFFFFFFFE
jmp 0xd2c30
movq 0x18(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, (%rsp)
movl 0x14(%rsp), %ecx
movq (%rsp), %rax
movl %ecx, 0xcc(%rax)
movl 0x10(%rsp), %ecx
movq (%rsp), %rax
movl %ecx, 0xc0(%rax)
movl 0xc(%rsp), %ecx
movq (%rsp), %rax
movl %ecx, 0xd0(%rax)
movl 0x8(%rsp), %ecx
movq (%rsp), %rax
movl %ecx, 0xbc(%rax)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/zlib-1.3.0.1/deflate.c
// Function: flush_pending
local void flush_pending(z_streamp strm) {
    unsigned len;
    deflate_state *s = strm->state;

    _tr_flush_bits(s);
    len = s->pending;
    if (len > strm->avail_out) len = strm->avail_out;
    if (len == 0) return;

    zmemcpy(strm->next_out, s->pending_out, len);
    strm->next_out  += len;
    s->pending_out  += len;
    strm->total_out += len;
    strm->avail_out -= len;
    s->pending      -= len;
    if (s->pending == 0) {
        s->pending_out = s->pending_buf;
    }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rdi
callq 0xd6790
movq (%rsp), %rax
movq 0x28(%rax), %rax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl 0x20(%rcx), %eax
jbe 0xd2f45
movq 0x10(%rsp), %rax
movl 0x20(%rax), %eax
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jne 0xd2f51
jmp 0xd2fec
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
movq (%rsp), %rax
movq 0x20(%rax), %rsi
movl 0xc(%rsp), %eax
movl %eax, %edx
callq 0xb500
movl 0xc(%rsp), %edx
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rcx
movl %edx, %edx
addq %rdx, %rcx
movq %rcx, 0x18(%rax)
movl 0xc(%rsp), %edx
movq (%rsp), %rax
movq 0x20(%rax), %rcx
movl %edx, %edx
addq %rdx, %rcx
movq %rcx, 0x20(%rax)
movl 0xc(%rsp), %eax
movl %eax, %ecx
movq 0x10(%rsp), %rax
addq 0x28(%rax), %rcx
movq %rcx, 0x28(%rax)
movl 0xc(%rsp), %edx
movq 0x10(%rsp), %rax
movl 0x20(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x20(%rax)
movl 0xc(%rsp), %eax
movl %eax, %edx
movq (%rsp), %rax
movq 0x28(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x28(%rax)
movq (%rsp), %rax
cmpq $0x0, 0x28(%rax)
jne 0xd2fec
movq (%rsp), %rax
movq 0x10(%rax), %rcx
movq (%rsp), %rax
movq %rcx, 0x20(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)