LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $-0x1
popq %rbp
movl 0x44(%rbx), %eax
testl %eax, %eax
je 0x7ae0a
cmpl $0x2, %eax
je 0x7ade5
cmpl $0x1, %eax
jne 0x7ae1d
jmp 0x7ae39
movl 0x28(%rbx), %eax
addl %eax, %eax
movl %eax, 0xa0(%rbx)
movq 0x38(%rbx), %rax
movq %rax, 0x98(%rbx)
movq %rbx, %rdi
callq 0x7af9f
cmpl $-0x1, %eax
jne 0x7ae1d
jmp 0x7ae35
movq %rbx, %rdi
callq 0x7aa91
cmpl $-0x1, %eax
je 0x7ae35
cmpl $0x0, 0x44(%rbx)
je 0x7ae5e
xorl %eax, %eax
cmpl $0x0, (%rbx)
jne 0x7ae60
cmpl $0x0, 0x50(%rbx)
je 0x7add2
cmpl $0x0, 0x88(%rbx)
jne 0x7add2
jmp 0x7ae60
movl %ebp, %eax
jmp 0x7ae60
movq 0x38(%rbx), %rsi
movl 0x28(%rbx), %edx
addl %edx, %edx
movq %rbx, %rdi
movq %rbx, %rcx
callq 0x7af25
movl %eax, %ecx
movl %ebp, %eax
cmpl $-0x1, %ecx
je 0x7ae60
movq 0x38(%rbx), %rax
movq %rax, 0x8(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
testq %rdi, %rdi
je 0x7ae91
pushq %rbx
movq %rdi, %rbx
cmpl $0x1c4f, 0x18(%rdi)     # imm = 0x1C4F
jne 0x7ae8c
cmpl $0x0, 0x44(%rbx)
jne 0x7ae8c
cmpl $0x0, (%rbx)
jne 0x7ae8c
movq %rbx, %rdi
callq 0x7aa91
movl 0x40(%rbx), %eax
popq %rbx
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
pushq $-0x2
popq %r14
testq %rdi, %rdi
je 0x7af17
movq %rdi, %rbx
cmpl $0x1c4f, 0x18(%rdi)     # imm = 0x1C4F
jne 0x7af17
cmpl $0x0, 0x28(%rbx)
je 0x7aed4
leaq 0x80(%rbx), %rdi
callq 0x8225d
movq 0x38(%rbx), %rdi
callq 0xb790
movq 0x30(%rbx), %rdi
callq 0xb790
xorl %eax, %eax
cmpl $-0x5, 0x74(%rbx)
setne %al
leal (%rax,%rax,4), %r15d
addl $-0x5, %r15d
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x7a532
movq 0x20(%rbx), %rdi
callq 0xb790
movl 0x1c(%rbx), %edi
callq 0xbcc0
movl %eax, %ebp
movq %rbx, %rdi
callq 0xb790
negl %ebp
sbbl %r14d, %r14d
orl %r15d, %r14d
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r14
movl %edx, %ebp
andl $0x0, (%rcx)
movq %rsi, %r15
movq %rdi, %rbx
xorl %eax, %eax
movl $0x40000000, %r12d      # imm = 0x40000000
movl %ebp, %edx
subl %eax, %edx
cmpl %r12d, %edx
cmovael %r12d, %edx
movl 0x1c(%rbx), %edi
movl %eax, %esi
addq %r15, %rsi
callq 0xb8d0
testl %eax, %eax
jle 0x7af6b
addl (%r14), %eax
movl %eax, (%r14)
cmpl %ebp, %eax
jb 0x7af43
jmp 0x7af74
js 0x7af81
movl $0x1, 0x50(%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0xb060
movl (%rax), %edi
callq 0xb1d0
pushq $-0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
movq %rax, %rdx
callq 0x7a532
jmp 0x7af76
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/zlib-1.3.0.1/gzread.c
// Function: gz_decomp
local int gz_decomp(gz_statep state) {
    int ret = Z_OK;
    unsigned had;
    z_streamp strm = &(state->strm);

    /* fill output buffer up to end of deflate stream */
    had = strm->avail_out;
    do {
        /* get more input for inflate() */
        if (strm->avail_in == 0 && gz_avail(state) == -1)
            return -1;
        if (strm->avail_in == 0) {
            gz_error(state, Z_BUF_ERROR, "unexpected end of file");
            break;
        }

        /* decompress and handle errors */
        ret = inflate(strm, Z_NO_FLUSH);
        if (ret == Z_STREAM_ERROR || ret == Z_NEED_DICT) {
            gz_error(state, Z_STREAM_ERROR,
                     "internal error: inflate stream corrupt");
            return -1;
        }
        if (ret == Z_MEM_ERROR) {
            gz_error(state, Z_MEM_ERROR, "out of memory");
            return -1;
        }
        if (ret == Z_DATA_ERROR) {              /* deflate stream invalid */
            gz_error(state, Z_DATA_ERROR,
                     strm->msg == NULL ? "compressed data error" : strm->msg);
            return -1;
        }
    } while (strm->avail_out && ret != Z_STREAM_END);

    /* update available output */
    state->x.have = had - strm->avail_out;
    state->x.next = strm->next_out - state->x.have;

    /* if the gzip stream completed successfully, look for another */
    if (ret == Z_STREAM_END)
        state->how = LOOK;

    /* good decompression */
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x80(%rdi), %r15
movl 0xa0(%rdi), %r12d
xorl %r14d, %r14d
pushq $-0x1
popq %rbp
leaq 0x6612c(%rip), %r13     # 0xe10f4
cmpl $0x0, 0x88(%rbx)
jne 0x7afe7
movq %rbx, %rdi
callq 0x7b09a
cmpl $-0x1, %eax
je 0x7b04f
cmpl $0x0, 0x88(%rbx)
je 0x7b060
movq %r15, %rdi
xorl %esi, %esi
callq 0x80575
movl %eax, %r14d
leal 0x4(%r14), %eax
cmpl $0x6, %eax
ja 0x7b007
movslq (%r13,%rax,4), %rax
addq %r13, %rax
jmpq *%rax
movl 0xa0(%rbx), %eax
cmpl $0x1, %r14d
je 0x7b078
testl %eax, %eax
jne 0x7afc8
jmp 0x7b078
leaq 0x66166(%rip), %rdx     # 0xe1186
pushq $-0x2
jmp 0x7b046
movq 0xb0(%rbx), %rax
testq %rax, %rax
leaq 0x66178(%rip), %rdx     # 0xe11ad
cmovneq %rax, %rdx
pushq $-0x3
jmp 0x7b046
leaq 0x61d46(%rip), %rdx     # 0xdcd8a
pushq $-0x4
popq %rsi
movq %rbx, %rdi
callq 0x7a532
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x66108(%rip), %rdx     # 0xe116f
pushq $-0x5
popq %rsi
movq %rbx, %rdi
callq 0x7a532
movl 0xa0(%rbx), %eax
subl %eax, %r12d
movl %r12d, (%rbx)
movq 0x98(%rbx), %rax
subq %r12, %rax
movq %rax, 0x8(%rbx)
xorl %ebp, %ebp
cmpl $0x1, %r14d
jne 0x7b04f
andl $0x0, 0x44(%rbx)
jmp 0x7b04f
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x74(%rdi), %eax
pushq $-0x1
popq %rbp
testl %eax, %eax
je 0x7b0af
cmpl $-0x5, %eax
jne 0x7b0e6
xorl %eax, %eax
cmpl $0x0, 0x50(%rbx)
jne 0x7b124
movl 0x88(%rbx), %eax
testq %rax, %rax
je 0x7b0ea
movq 0x30(%rbx), %rcx
movq 0x80(%rbx), %rdx
xorl %esi, %esi
movb (%rdx,%rsi), %dil
movb %dil, (%rcx,%rsi)
incq %rsi
cmpl %esi, %eax
jne 0x7b0cf
movl 0x88(%rbx), %eax
jmp 0x7b0ec
movl %ebp, %eax
jmp 0x7b124
xorl %eax, %eax
movl %eax, %esi
addq 0x30(%rbx), %rsi
movl 0x28(%rbx), %edx
subl %eax, %edx
leaq 0x4(%rsp), %rcx
movq %rbx, %rdi
callq 0x7af25
movl %eax, %ecx
movl %ebp, %eax
cmpl $-0x1, %ecx
je 0x7b124
movl 0x4(%rsp), %eax
addl %eax, 0x88(%rbx)
movq 0x30(%rbx), %rax
movq %rax, 0x80(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbx
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x7b162
cmpl $0x79b1, 0x18(%rdi)     # imm = 0x79B1
jne 0x7b162
cmpl $0x0, 0x74(%rdi)
jne 0x7b162
testl %edx, %edx
js 0x7b153
movl %edx, %edx
callq 0x7b166
movq %rax, %rbx
jmp 0x7b162
leaq 0x66078(%rip), %rdx     # 0xe11d2
pushq $-0x3
popq %rsi
callq 0x7a532
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
testq %rcx, %rcx
je 0x7b2b0
cmpl $0x79b1, 0x18(%rcx)     # imm = 0x79B1
jne 0x7b2b0
cmpl $0x0, 0x74(%rcx)
je 0x7b2b3
xorl %eax, %eax
retq
pushq %rbx
movq %rsi, %rbx
movq %rdi, %rsi
movq %rbx, %rax
mulq %rdx
seto %dl
testq %rbx, %rbx
je 0x7b2e0
testb %dl, %dl
je 0x7b2e0
leaq 0x65e5c(%rip), %rdx     # 0xe112f
pushq $-0x2
popq %rsi
movq %rcx, %rdi
callq 0x7a532
jmp 0x7b2f7
testq %rax, %rax
je 0x7b2f7
movq %rcx, %rdi
movq %rax, %rdx
callq 0x7b166
xorl %edx, %edx
divq %rbx
jmp 0x7b2f9
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/zlib-1.3.0.1/gzwrite.c
// Function: gzputc
int ZEXPORT gzputc(gzFile file, int c) {
    unsigned have;
    unsigned char buf[1];
    gz_statep state;
    z_streamp strm;

    /* get internal structure */
    if (file == NULL)
        return -1;
    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)
        return -1;

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

    /* try writing to input buffer for speed (state->size == 0 if buffer not
       initialized) */
    if (state->size) {
        if (strm->avail_in == 0)
            strm->next_in = state->in;
        have = (unsigned)((strm->next_in + strm->avail_in) - state->in);
        if (have < state->size) {
            state->in[have] = (unsigned char)c;
            strm->avail_in++;
            state->x.pos++;
            return c & 0xff;
        }
    }

    /* no room in buffer or not initialized, use gz_write() */
    buf[0] = (unsigned char)c;
    if (gz_write(state, buf, 1) != 1)
        return -1;
    return c & 0xff;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
pushq $-0x1
popq %rbp
testq %rdi, %rdi
je 0x7b3b6
movq %rdi, %r14
cmpl $0x79b1, 0x18(%rdi)     # imm = 0x79B1
jne 0x7b3b6
cmpl $0x0, 0x74(%r14)
jne 0x7b3b6
movl %esi, %ebx
cmpl $0x0, 0x70(%r14)
je 0x7b349
andl $0x0, 0x70(%r14)
movq 0x68(%r14), %rsi
movq %r14, %rdi
callq 0x7b3c1
cmpl $-0x1, %eax
je 0x7b3b6
movl 0x28(%r14), %eax
testl %eax, %eax
je 0x7b397
movl 0x88(%r14), %edx
testq %rdx, %rdx
je 0x7b36a
movq 0x30(%r14), %rcx
movq 0x80(%r14), %rsi
jmp 0x7b378
movq 0x30(%r14), %rcx
movq %rcx, 0x80(%r14)
movq %rcx, %rsi
addq %rdx, %rsi
subq %rcx, %rsi
cmpl %esi, %eax
jbe 0x7b397
movl %esi, %eax
movb %bl, (%rcx,%rax)
incl 0x88(%r14)
incq 0x10(%r14)
movzbl %bl, %ebp
jmp 0x7b3b6
leaq 0xf(%rsp), %rsi
movb %bl, (%rsi)
pushq $0x1
popq %rdx
movq %r14, %rdi
callq 0x7b166
cmpq $0x1, %rax
movzbl %bl, %eax
pushq $-0x1
popq %rbp
cmovel %eax, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpl $0x0, 0x88(%rdi)
pushq $-0x1
popq %rbx
je 0x7b3ea
movq %r15, %rdi
xorl %esi, %esi
callq 0x7b6d0
cmpl $-0x1, %eax
je 0x7b442
xorl %ecx, %ecx
testq %r14, %r14
je 0x7b440
movl 0x28(%r15), %eax
cmpq %rax, %r14
movl %r14d, %ebp
cmovgel %eax, %ebp
movl %ebp, %r12d
testb $0x1, %cl
jne 0x7b414
movq 0x30(%r15), %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0xb2f0
movl %ebp, 0x88(%r15)
movq 0x30(%r15), %rax
movq %rax, 0x80(%r15)
addq %r12, 0x10(%r15)
movq %r15, %rdi
xorl %esi, %esi
callq 0x7b6d0
subq %r12, %r14
movb $0x1, %cl
cmpl $-0x1, %eax
jne 0x7b3ec
jmp 0x7b442
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
pushq $-0x1
popq %rbx
testq %rdi, %rdi
je 0x7b4b2
movq %rdi, %r14
cmpl $0x79b1, 0x18(%rdi)     # imm = 0x79B1
jne 0x7b4b2
cmpl $0x0, 0x74(%r14)
jne 0x7b4b2
movq %rsi, %r15
movq %rsi, %rdi
callq 0xb260
testq $-0x80000000, %rax      # imm = 0x80000000
jne 0x7b4a0
movq %rax, %r12
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x7b166
cmpq %r12, %rax
pushq $-0x1
popq %rbx
cmovael %r12d, %ebx
jmp 0x7b4b2
leaq 0x65d50(%rip), %rdx     # 0xe11f7
pushq $-0x2
popq %rsi
movq %r14, %rdi
callq 0x7a532
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/zlib-1.3.0.1/gzwrite.c
// Function: gz_init
local int gz_init(gz_statep state) {
    int ret;
    z_streamp strm = &(state->strm);

    /* allocate input buffer (double size for gzprintf) */
    state->in = (unsigned char *)malloc(state->want << 1);
    if (state->in == NULL) {
        gz_error(state, Z_MEM_ERROR, "out of memory");
        return -1;
    }

    /* only need output buffer and deflate state if compressing */
    if (!state->direct) {
        /* allocate output buffer */
        state->out = (unsigned char *)malloc(state->want);
        if (state->out == NULL) {
            free(state->in);
            gz_error(state, Z_MEM_ERROR, "out of memory");
            return -1;
        }

        /* allocate deflate memory, set up for gzip compression */
        strm->zalloc = Z_NULL;
        strm->zfree = Z_NULL;
        strm->opaque = Z_NULL;
        ret = deflateInit2(strm, state->level, Z_DEFLATED,
                           MAX_WBITS + 16, DEF_MEM_LEVEL, state->strategy);
        if (ret != Z_OK) {
            free(state->out);
            free(state->in);
            gz_error(state, Z_MEM_ERROR, "out of memory");
            return -1;
        }
        strm->next_in = NULL;
    }

    /* mark state as initialized */
    state->size = state->want;

    /* initialize write buffer if compressing */
    if (!state->direct) {
        strm->avail_out = state->size;
        strm->next_out = state->out;
        state->x.next = strm->next_out;
    }
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl 0x2c(%rdi), %r15d
leal (%r15,%r15), %edi
callq 0xbce8
movq %rax, 0x30(%rbx)
testq %rax, %rax
je 0x7b688
cmpl $0x0, 0x40(%rbx)
je 0x7b61d
movl %r15d, 0x28(%rbx)
xorl %eax, %eax
jmp 0x7b69d
movq %rax, %r14
movq %r15, %rdi
callq 0xbce8
movq %rax, 0x38(%rbx)
testq %rax, %rax
je 0x7b680
leaq 0x80(%rbx), %rdi
andq $0x0, 0xd0(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0xc0(%rbx)
movl 0x58(%rbx), %esi
movl 0x5c(%rbx), %r9d
leaq 0x65b6b(%rip), %rax     # 0xe11c3
pushq $0x1f
popq %rcx
pushq $0x8
popq %rdx
movl %edx, %r8d
pushq $0x70
pushq %rax
callq 0x7baca
addq $0x10, %rsp
testl %eax, %eax
je 0x7b6a3
movq 0x38(%rbx), %rdi
callq 0xb790
movq 0x30(%rbx), %rdi
jmp 0x7b683
movq %r14, %rdi
callq 0xb790
leaq 0x616fb(%rip), %rdx     # 0xdcd8a
pushq $-0x4
popq %rsi
movq %rbx, %rdi
callq 0x7a532
pushq $-0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
andq $0x0, 0x80(%rbx)
movl 0x2c(%rbx), %ecx
movl %ecx, 0x28(%rbx)
xorl %eax, %eax
cmpl $0x0, 0x40(%rbx)
jne 0x7b69d
movl %ecx, 0xa0(%rbx)
movq 0x38(%rbx), %rcx
movq %rcx, 0x98(%rbx)
movq %rcx, 0x8(%rbx)
jmp 0x7b69d
// File: /workspace/github_c_makefile_star2_O2/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:
pushq $-0x2
popq %rax
testq %rdi, %rdi
je 0x7b95a
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x79b1, 0x18(%rdi)     # imm = 0x79B1
jne 0x7b954
movl %esi, %ebp
cmpl $0x4, %esi
ja 0x7b954
cmpl $0x0, 0x74(%rbx)
jne 0x7b954
cmpl $0x0, 0x70(%rbx)
je 0x7b947
andl $0x0, 0x70(%rbx)
movq 0x68(%rbx), %rsi
movq %rbx, %rdi
callq 0x7b3c1
cmpl $-0x1, %eax
je 0x7b951
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7b6d0
movl 0x74(%rbx), %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq $-0x2
popq %rax
testq %rdi, %rdi
je 0x7b9f1
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x79b1, 0x18(%rdi)     # imm = 0x79B1
jne 0x7b9ed
cmpl $0x0, 0x74(%rbx)
jne 0x7b9ed
cmpl $0x0, 0x40(%rbx)
jne 0x7b9ed
movl %edx, %ebp
movl %esi, %r14d
cmpl %esi, 0x58(%rbx)
jne 0x7b994
xorl %eax, %eax
cmpl %ebp, 0x5c(%rbx)
je 0x7b9ed
cmpl $0x0, 0x70(%rbx)
je 0x7b9af
andl $0x0, 0x70(%rbx)
movq 0x68(%rbx), %rsi
movq %rbx, %rdi
callq 0x7b3c1
cmpl $-0x1, %eax
je 0x7b9ea
cmpl $0x0, 0x28(%rbx)
je 0x7b9df
cmpl $0x0, 0x88(%rbx)
je 0x7b9ce
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0x7b6d0
cmpl $-0x1, %eax
je 0x7b9ea
leaq 0x80(%rbx), %rdi
movl %r14d, %esi
movl %ebp, %edx
callq 0x7c510
movl %r14d, 0x58(%rbx)
movl %ebp, 0x5c(%rbx)
xorl %eax, %eax
jmp 0x7b9ed
movl 0x74(%rbx), %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r14
pushq %rbx
pushq %rax
pushq $-0x2
popq %rbx
testq %rdi, %rdi
je 0x7baa1
movq %rdi, %r14
cmpl $0x79b1, 0x18(%rdi)     # imm = 0x79B1
jne 0x7baa1
xorl %ebx, %ebx
cmpl $0x0, 0x70(%r14)
je 0x7ba35
andl $0x0, 0x70(%r14)
movq 0x68(%r14), %rsi
movq %r14, %rdi
callq 0x7b3c1
cmpl $-0x1, %eax
jne 0x7ba35
movl 0x74(%r14), %ebx
pushq $0x4
popq %rsi
movq %r14, %rdi
callq 0x7b6d0
cmpl $-0x1, %eax
jne 0x7ba49
movl 0x74(%r14), %ebx
cmpl $0x0, 0x28(%r14)
je 0x7ba75
cmpl $0x0, 0x40(%r14)
jne 0x7ba6c
leaq 0x80(%r14), %rdi
callq 0x7bd7e
movq 0x38(%r14), %rdi
callq 0xb790
movq 0x30(%r14), %rdi
callq 0xb790
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x7a532
movq 0x20(%r14), %rdi
callq 0xb790
movl 0x1c(%r14), %edi
callq 0xbcc0
cmpl $-0x1, %eax
cmovel %eax, %ebx
movq %r14, %rdi
callq 0xb790
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x7c0ae
testl %eax, %eax
je 0x7bd92
pushq $-0x2
popq %rax
jmp 0x7be0f
movq 0x38(%rbx), %rsi
movl 0x8(%rsi), %ebp
movq 0x10(%rsi), %rax
testq %rax, %rax
je 0x7bdb0
movq 0x50(%rbx), %rdi
movq %rax, %rsi
callq *0x48(%rbx)
movq 0x38(%rbx), %rsi
movq 0x78(%rsi), %rax
testq %rax, %rax
je 0x7bdc7
movq 0x50(%rbx), %rdi
movq %rax, %rsi
callq *0x48(%rbx)
movq 0x38(%rbx), %rsi
movq 0x70(%rsi), %rax
testq %rax, %rax
je 0x7bdde
movq 0x50(%rbx), %rdi
movq %rax, %rsi
callq *0x48(%rbx)
movq 0x38(%rbx), %rsi
movq 0x60(%rsi), %rax
testq %rax, %rax
je 0x7bdf5
movq 0x50(%rbx), %rdi
movq %rax, %rsi
callq *0x48(%rbx)
movq 0x38(%rbx), %rsi
movq 0x50(%rbx), %rdi
callq *0x48(%rbx)
andq $0x0, 0x38(%rbx)
xorl %eax, %eax
cmpl $0x71, %ebp
setne %al
leal (%rax,%rax,2), %eax
addl $-0x3, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x7c36f
movl %eax, %ebx
testl %eax, %eax
jne 0x7bed4
movq 0x38(%r14), %r14
movl 0x50(%r14), %eax
addq %rax, %rax
movq %rax, 0x68(%r14)
movq 0x78(%r14), %rdi
movl 0x84(%r14), %edx
decl %edx
andw $0x0, (%rdi,%rdx,2)
addq %rdx, %rdx
xorl %esi, %esi
callq 0xb2f0
movslq 0xc4(%r14), %rax
shlq $0x4, %rax
leaq 0xb1037(%rip), %rcx     # 0x12cea0
movzwl 0x2(%rax,%rcx), %edx
movl %edx, 0xc0(%r14)
movzwl (%rax,%rcx), %edx
movl %edx, 0xcc(%r14)
movzwl 0x4(%rax,%rcx), %edx
movl %edx, 0xd0(%r14)
movzwl 0x6(%rax,%rcx), %eax
movl %eax, 0xbc(%r14)
andq $0x0, 0x98(%r14)
movabsq $0x200000000, %rax      # imm = 0x200000000
movq %rax, 0xb4(%r14)
andl $0x0, 0x172c(%r14)
movl $0x2, 0xa0(%r14)
andq $0x0, 0xa8(%r14)
andl $0x0, 0x80(%r14)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq $0x1
popq %rax
testq %rdi, %rdi
je 0x7c0d2
cmpq $0x0, 0x40(%rdi)
je 0x7c0d2
cmpq $0x0, 0x48(%rdi)
je 0x7c0d2
movq 0x38(%rdi), %rcx
testq %rcx, %rcx
je 0x7c0d2
cmpq %rdi, (%rcx)
je 0x7c0d3
retq
movl 0x8(%rcx), %ecx
leal -0x39(%rcx), %edx
cmpl $0x38, %edx
ja 0x7c0f1
movabsq $0x100400400011001, %rsi # imm = 0x100400400011001
btq %rdx, %rsi
jae 0x7c0f1
xorl %eax, %eax
retq
cmpl $0x29a, %ecx            # imm = 0x29A
je 0x7c0ee
cmpl $0x2a, %ecx
jne 0x7c0d2
jmp 0x7c0ee
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x7c0ae
testl %eax, %eax
je 0x7c323
pushq $-0x2
popq %rax
jmp 0x7c364
movq 0x38(%r15), %rax
movl 0x50(%rax), %ebp
movl 0xac(%rax), %esi
movl 0xb4(%rax), %ecx
leal (%rcx,%rsi), %edx
cmpl %ebp, %edx
cmovbl %edx, %ebp
testq %r14, %r14
je 0x7c35b
testl %ebp, %ebp
je 0x7c35b
addq 0x60(%rax), %rsi
addq %rcx, %rsi
movl %ebp, %edx
subq %rdx, %rsi
movq %r14, %rdi
callq 0xb520
xorl %eax, %eax
testq %rbx, %rbx
je 0x7c364
movl %ebp, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
callq 0x7c0ae
testl %eax, %eax
je 0x7c44a
pushq $-0x2
popq %rax
jmp 0x7c46c
testq %r15, %r15
je 0x7c459
movq 0x38(%r14), %rax
movl 0x28(%rax), %eax
movl %eax, (%r15)
xorl %eax, %eax
testq %rbx, %rbx
je 0x7c46c
movq 0x38(%r14), %rcx
movl 0x1734(%rcx), %ecx
movl %ecx, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
callq 0x7c0ae
testl %eax, %eax
je 0x7c492
pushq $-0x2
popq %rax
jmp 0x7c501
pushq $-0x5
popq %rax
cmpl $0x10, %ebp
ja 0x7c501
movq 0x38(%r14), %r14
movq 0x20(%r14), %rcx
addq $0x2, %rcx
cmpq %rcx, 0x1700(%r14)
jb 0x7c501
pushq $0x10
popq %r12
pushq $-0x1
popq %r13
movl 0x1734(%r14), %eax
movl %r12d, %r15d
subl %eax, %r15d
cmpl %ebp, %r15d
cmovgel %ebp, %r15d
movl %r13d, %edx
movl %r15d, %ecx
shll %cl, %edx
notl %edx
andl %ebx, %edx
movl %eax, %ecx
shll %cl, %edx
orw %dx, 0x1730(%r14)
addl %r15d, %eax
movl %eax, 0x1734(%r14)
movq %r14, %rdi
callq 0x7ec9e
movl %r15d, %ecx
sarl %cl, %ebx
subl %r15d, %ebp
jne 0x7c4b7
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/zlib-1.3.0.1/deflate.c
// Function: deflateParams
int ZEXPORT deflateParams(z_streamp strm, int level, int strategy) {
    deflate_state *s;
    compress_func func;

    if (deflateStateCheck(strm)) return Z_STREAM_ERROR;
    s = strm->state;

#ifdef FASTEST
    if (level != 0) level = 1;
#else
    if (level == Z_DEFAULT_COMPRESSION) level = 6;
#endif
    if (level < 0 || level > 9 || strategy < 0 || strategy > Z_FIXED) {
        return Z_STREAM_ERROR;
    }
    func = configuration_table[s->level].func;

    if ((strategy != s->strategy || func != configuration_table[level].func) &&
        s->last_flush != -2) {
        /* Flush the last buffer: */
        int err = deflate(strm, Z_BLOCK);
        if (err == Z_STREAM_ERROR)
            return err;
        if (strm->avail_in || (s->strstart - s->block_start) + s->lookahead)
            return Z_BUF_ERROR;
    }
    if (s->level != level) {
        if (s->level == 0 && s->matches != 0) {
            if (s->matches == 1)
                slide_hash(s);
            else
                CLEAR_HASH(s);
            s->matches = 0;
        }
        s->level = level;
        s->max_lazy_match   = configuration_table[level].max_lazy;
        s->good_match       = configuration_table[level].good_length;
        s->nice_match       = configuration_table[level].nice_length;
        s->max_chain_length = configuration_table[level].max_chain;
    }
    s->strategy = strategy;
    return Z_OK;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %r14d
movq %rdi, %r15
callq 0x7c0ae
pushq $-0x2
popq %rbp
testl %eax, %eax
jne 0x7c679
cmpl $-0x1, %r14d
pushq $0x6
popq %r12
cmovnel %r14d, %r12d
cmpl $0xa, %r12d
setae %al
cmpl $0x5, %ebx
setae %cl
orb %al, %cl
jne 0x7c679
movq 0x38(%r15), %r14
leaq 0xb0941(%rip), %rdx     # 0x12cea0
movl %r12d, %r13d
cmpl %ebx, 0xc8(%r14)
jne 0x7c589
movslq 0xc4(%r14), %rax
shlq $0x4, %rax
movq 0x8(%rax,%rdx), %rax
movq %r13, %rcx
shlq $0x4, %rcx
cmpq 0x8(%rcx,%rdx), %rax
je 0x7c590
cmpl $-0x2, 0x4c(%r14)
jne 0x7c5c5
movl 0xc4(%r14), %eax
cmpl %r12d, %eax
je 0x7c670
testl %eax, %eax
jne 0x7c631
movl 0x1728(%r14), %eax
testl %eax, %eax
je 0x7c631
movq %rdx, %r15
cmpl $0x1, %eax
jne 0x7c60a
movq %r14, %rdi
callq 0x7d5d2
jmp 0x7c626
pushq $0x5
popq %rsi
movq %r15, %rdi
callq 0x7c68a
leaq 0xb08c9(%rip), %rdx     # 0x12cea0
cmpl $-0x2, %eax
je 0x7c679
pushq $-0x5
popq %rbp
cmpl $0x0, 0x8(%r15)
jne 0x7c679
movl 0xac(%r14), %eax
movl 0xb4(%r14), %ecx
subq 0x98(%r14), %rax
addq %rax, %rcx
je 0x7c590
jmp 0x7c679
movq 0x78(%r14), %rdi
movl 0x84(%r14), %edx
decl %edx
andw $0x0, (%rdi,%rdx,2)
addq %rdx, %rdx
xorl %esi, %esi
callq 0xb2f0
andl $0x0, 0x1728(%r14)
movq %r15, %rdx
movl %r12d, 0xc4(%r14)
shlq $0x4, %r13
movzwl 0x2(%r13,%rdx), %eax
movl %eax, 0xc0(%r14)
movzwl (%r13,%rdx), %eax
movl %eax, 0xcc(%r14)
movzwl 0x4(%r13,%rdx), %eax
movl %eax, 0xd0(%r14)
movzwl 0x6(%r13,%rdx), %eax
movl %eax, 0xbc(%r14)
movl %ebx, 0xc8(%r14)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movl 0x50(%rdi), %eax
movl 0x84(%rdi), %ecx
movq 0x78(%rdi), %rdx
leaq (%rdx,%rcx,2), %rdx
addq $-0x2, %rdx
xorl %esi, %esi
movzwl (%rdx), %r8d
subl %eax, %r8d
cmovbl %esi, %r8d
movw %r8w, (%rdx)
addq $-0x2, %rdx
decl %ecx
jne 0x7d5e9
movq 0x70(%rdi), %rcx
leaq (%rcx,%rax,2), %rcx
addq $-0x2, %rcx
xorl %edx, %edx
movl %eax, %esi
movzwl (%rcx), %edi
subl %eax, %edi
cmovbl %edx, %edi
movw %di, (%rcx)
addq $-0x2, %rcx
decl %esi
jne 0x7d610
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %r12
callq 0x7c0ae
testl %eax, %eax
je 0x7d648
pushq $-0x2
popq %rax
jmp 0x7d669
movq 0x38(%r12), %rax
movl %r15d, 0xcc(%rax)
movl %r14d, 0xc0(%rax)
movl %ebp, 0xd0(%rax)
movl %ebx, 0xbc(%rax)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x38(%rdi), %rbx
movq %rbx, %rdi
callq 0x7ec9e
movl 0x28(%rbx), %ebp
movl 0x20(%r14), %eax
cmpl %ebp, %eax
cmovbl %eax, %ebp
testl %ebp, %ebp
je 0x7d826
movq 0x18(%r14), %rdi
movq 0x20(%rbx), %rsi
movl %ebp, %r15d
movq %r15, %rdx
callq 0xb520
addq %r15, 0x18(%r14)
addq %r15, 0x20(%rbx)
addq %r15, 0x28(%r14)
subl %ebp, 0x20(%r14)
subq %r15, 0x28(%rbx)
jne 0x7d826
movq 0x10(%rbx), %rax
movq %rax, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/zlib-1.3.0.1/deflate.c
// Function: read_buf
local unsigned read_buf(z_streamp strm, Bytef *buf, unsigned size) {
    unsigned len = strm->avail_in;

    if (len > size) len = size;
    if (len == 0) return 0;

    strm->avail_in  -= len;

    zmemcpy(buf, strm->next_in, len);
    if (strm->state->wrap == 1) {
        strm->adler = adler32(strm->adler, buf, len);
    }
#ifdef GZIP
    else if (strm->state->wrap == 2) {
        strm->adler = crc32(strm->adler, buf, len);
    }
#endif
    strm->next_in  += len;
    strm->total_in += len;

    return len;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movl 0x8(%rdi), %eax
cmpl %edx, %eax
cmovbl %eax, %ebx
testl %ebx, %ebx
je 0x7de9a
movq %rsi, %r12
movq %rdi, %r14
subl %ebx, %eax
movl %eax, 0x8(%rdi)
movq (%rdi), %rsi
movl %ebx, %r15d
movq %r12, %rdi
movq %r15, %rdx
callq 0xb520
movq 0x38(%r14), %rax
movl 0x30(%rax), %eax
cmpl $0x2, %eax
je 0x7de81
cmpl $0x1, %eax
jne 0x7de93
movq 0x60(%r14), %rdi
movq %r12, %rsi
movl %ebx, %edx
callq 0x9a764
jmp 0x7de8f
movq 0x60(%r14), %rdi
movq %r12, %rsi
movl %ebx, %edx
callq 0x9ab51
movq %rax, 0x60(%r14)
addq %r15, (%r14)
addq %r15, 0x10(%r14)
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/zlib-1.3.0.1/trees.c
// Function: init_block
local void init_block(deflate_state *s) {
    int n; /* iterates over tree elements */

    /* Initialize the trees. */
    for (n = 0; n < L_CODES;  n++) s->dyn_ltree[n].Freq = 0;
    for (n = 0; n < D_CODES;  n++) s->dyn_dtree[n].Freq = 0;
    for (n = 0; n < BL_CODES; n++) s->bl_tree[n].Freq = 0;

    s->dyn_ltree[END_BLOCK].Freq = 1;
    s->opt_len = s->static_len = 0L;
    s->sym_next = s->matches = 0;
}

// Assembly:
pushq $0x35
popq %rax
cmpq $0x153, %rax            # imm = 0x153
je 0x7ead6
andw $0x0, (%rdi,%rax,4)
incq %rax
jmp 0x7eac4
xorl %eax, %eax
cmpq $0x1e, %rax
je 0x7eaec
andw $0x0, 0x9c8(%rdi,%rax,4)
incq %rax
jmp 0x7ead8
xorl %eax, %eax
cmpq $0x13, %rax
je 0x7eb02
andw $0x0, 0xabc(%rdi,%rax,4)
incq %rax
jmp 0x7eaee
movw $0x1, 0x4d4(%rdi)
andl $0x0, 0x170c(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x1718(%rdi)
andl $0x0, 0x1728(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/zlib-1.3.0.1/trees.c
// Function: tr_stored_block
void ZLIB_INTERNAL _tr_stored_block(deflate_state *s, charf *buf,
                                    ulg stored_len, int last) {
    send_bits(s, (STORED_BLOCK<<1) + last, 3);  /* send block type */
    bi_windup(s);        /* align on byte boundary */
    put_short(s, (ush)stored_len);
    put_short(s, (ush)~stored_len);
    if (stored_len)
        zmemcpy(s->pending_buf + s->pending, (Bytef *)buf, stored_len);
    s->pending += stored_len;
#ifdef ZLIB_DEBUG
    s->compressed_len = (s->compressed_len + 3 + 7) & (ulg)~7L;
    s->compressed_len += (stored_len + 4) << 3;
    s->bits_sent += 2*16;
    s->bits_sent += stored_len << 3;
#endif
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %ecx, %r8d
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movl 0x1734(%rdi), %eax
cmpl $0xe, %eax
jl 0x7eba1
movzwl %r8w, %edx
movl %eax, %ecx
shll %cl, %r8d
orw 0x1730(%r14), %r8w
movw %r8w, 0x1730(%r14)
movq 0x10(%r14), %rax
movq 0x28(%r14), %rcx
leaq 0x1(%rcx), %rsi
movq %rsi, 0x28(%r14)
movb %r8b, (%rax,%rcx)
movb 0x1731(%r14), %al
movq 0x10(%r14), %rcx
movq 0x28(%r14), %rsi
leaq 0x1(%rsi), %rdi
movq %rdi, 0x28(%r14)
movb %al, (%rcx,%rsi)
movl 0x1734(%r14), %eax
movb $0x10, %cl
subb %al, %cl
shrl %cl, %edx
movw %dx, 0x1730(%r14)
addl $-0xd, %eax
jmp 0x7ebb1
movl %eax, %ecx
shll %cl, %r8d
orw %r8w, 0x1730(%r14)
addl $0x3, %eax
movl %eax, 0x1734(%r14)
movq %r14, %rdi
callq 0x7ec35
movq 0x10(%r14), %rax
movq 0x28(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x28(%r14)
movb %bl, (%rax,%rcx)
movq 0x10(%r14), %rax
movq 0x28(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x28(%r14)
movb %bh, (%rax,%rcx)
movl %ebx, %eax
xorl $0xffff, %eax           # imm = 0xFFFF
movq 0x10(%r14), %rcx
movq 0x28(%r14), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x28(%r14)
movb %al, (%rcx,%rdx)
movq 0x10(%r14), %rcx
movq 0x28(%r14), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x28(%r14)
movb %ah, (%rcx,%rdx)
testq %rbx, %rbx
je 0x7ec2b
movq 0x10(%r14), %rdi
addq 0x28(%r14), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0xb520
addq %rbx, 0x28(%r14)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/zlib-1.3.0.1/trees.c
// Function: bi_windup
local void bi_windup(deflate_state *s) {
    if (s->bi_valid > 8) {
        put_short(s, s->bi_buf);
    } else if (s->bi_valid > 0) {
        put_byte(s, (Byte)s->bi_buf);
    }
    s->bi_buf = 0;
    s->bi_valid = 0;
#ifdef ZLIB_DEBUG
    s->bits_sent = (s->bits_sent + 7) & ~7;
#endif
}

// Assembly:
movl 0x1734(%rdi), %eax
cmpl $0x9, %eax
jl 0x7ec6b
movb 0x1730(%rdi), %dl
leaq 0x10(%rdi), %rcx
leaq 0x28(%rdi), %rax
movq 0x10(%rdi), %rsi
movq 0x28(%rdi), %r8
leaq 0x1(%r8), %r9
movq %r9, 0x28(%rdi)
movb %dl, (%rsi,%r8)
movzbl 0x1731(%rdi), %edx
jmp 0x7ec7e
testl %eax, %eax
jle 0x7ec8e
movzwl 0x1730(%rdi), %edx
leaq 0x10(%rdi), %rcx
leaq 0x28(%rdi), %rax
movq (%rcx), %rcx
movq (%rax), %rsi
leaq 0x1(%rsi), %r8
movq %r8, (%rax)
movb %dl, (%rcx,%rsi)
andw $0x0, 0x1730(%rdi)
andl $0x0, 0x1734(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/zlib-1.3.0.1/trees.c
// Function: bi_flush
local void bi_flush(deflate_state *s) {
    if (s->bi_valid == 16) {
        put_short(s, s->bi_buf);
        s->bi_buf = 0;
        s->bi_valid = 0;
    } else if (s->bi_valid >= 8) {
        put_byte(s, (Byte)s->bi_buf);
        s->bi_buf >>= 8;
        s->bi_valid -= 8;
    }
}

// Assembly:
movl 0x1734(%rdi), %eax
cmpl $0x10, %eax
jne 0x7ece9
movb 0x1730(%rdi), %al
movq 0x10(%rdi), %rcx
movq 0x28(%rdi), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x28(%rdi)
movb %al, (%rcx,%rdx)
movb 0x1731(%rdi), %al
movq 0x10(%rdi), %rcx
movq 0x28(%rdi), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x28(%rdi)
movb %al, (%rcx,%rdx)
andw $0x0, 0x1730(%rdi)
xorl %eax, %eax
jmp 0x7ed1e
cmpl $0x8, %eax
jl 0x7ed24
movb 0x1730(%rdi), %al
movq 0x10(%rdi), %rcx
movq 0x28(%rdi), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x28(%rdi)
movb %al, (%rcx,%rdx)
movzbl 0x1731(%rdi), %eax
movw %ax, 0x1730(%rdi)
movl 0x1734(%rdi), %eax
addl $-0x8, %eax
movl %eax, 0x1734(%rdi)
retq