LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
movq 0x18(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
jbe 0xd4940
movl 0xc(%rsp), %eax
movl %eax, 0x8(%rsp)
cmpl $0x0, 0x8(%rsp)
jne 0xd4954
movl $0x0, 0x24(%rsp)
jmp 0xd4a14
movl 0x8(%rsp), %edx
movq 0x18(%rsp), %rax
movl 0x8(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x8(%rax)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movq (%rax), %rsi
movl 0x8(%rsp), %eax
movl %eax, %edx
callq 0xb500
movq 0x18(%rsp), %rax
movq 0x38(%rax), %rax
cmpl $0x1, 0x30(%rax)
jne 0xd49b1
movq 0x18(%rsp), %rax
movq 0x60(%rax), %rdi
movq 0x10(%rsp), %rsi
movl 0x8(%rsp), %edx
callq 0x107d60
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x60(%rax)
jmp 0xd49e5
movq 0x18(%rsp), %rax
movq 0x38(%rax), %rax
cmpl $0x2, 0x30(%rax)
jne 0xd49e3
movq 0x18(%rsp), %rax
movq 0x60(%rax), %rdi
movq 0x10(%rsp), %rsi
movl 0x8(%rsp), %edx
callq 0x108ce0
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x60(%rax)
jmp 0xd49e5
movl 0x8(%rsp), %edx
movq 0x18(%rsp), %rax
movq (%rax), %rcx
movl %edx, %edx
addq %rdx, %rcx
movq %rcx, (%rax)
movl 0x8(%rsp), %eax
movl %eax, %ecx
movq 0x18(%rsp), %rax
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
movl 0x8(%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/trees.c
// Function: tr_init
void ZLIB_INTERNAL _tr_init(deflate_state *s) {
    tr_static_init();

    s->l_desc.dyn_tree = s->dyn_ltree;
    s->l_desc.stat_desc = &static_l_desc;

    s->d_desc.dyn_tree = s->dyn_dtree;
    s->d_desc.stat_desc = &static_d_desc;

    s->bl_desc.dyn_tree = s->bl_tree;
    s->bl_desc.stat_desc = &static_bl_desc;

    s->bi_buf = 0;
    s->bi_valid = 0;
#ifdef ZLIB_DEBUG
    s->compressed_len = 0L;
    s->bits_sent = 0L;
#endif

    /* Initialize the first block of the first file: */
    init_block(s);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
callq 0xd6350
movq (%rsp), %rcx
addq $0xd4, %rcx
movq (%rsp), %rax
movq %rcx, 0xb58(%rax)
movq (%rsp), %rax
leaq 0xdd0d5(%rip), %rcx     # 0x1b33a0
movq %rcx, 0xb68(%rax)
movq (%rsp), %rcx
addq $0x9c8, %rcx            # imm = 0x9C8
movq (%rsp), %rax
movq %rcx, 0xb70(%rax)
movq (%rsp), %rax
leaq 0xdd0cd(%rip), %rcx     # 0x1b33c0
movq %rcx, 0xb80(%rax)
movq (%rsp), %rcx
addq $0xabc, %rcx            # imm = 0xABC
movq (%rsp), %rax
movq %rcx, 0xb88(%rax)
movq (%rsp), %rax
leaq 0xdd0c5(%rip), %rcx     # 0x1b33e0
movq %rcx, 0xb98(%rax)
movq (%rsp), %rax
movw $0x0, 0x1730(%rax)
movq (%rsp), %rax
movl $0x0, 0x1734(%rax)
movq (%rsp), %rdi
callq 0xd6360
popq %rax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
movq %rdi, -0x8(%rsp)
movl $0x0, -0xc(%rsp)
cmpl $0x11e, -0xc(%rsp)      # imm = 0x11E
jge 0xd6398
movq -0x8(%rsp), %rax
movslq -0xc(%rsp), %rcx
movw $0x0, 0xd4(%rax,%rcx,4)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0xd636d
movl $0x0, -0xc(%rsp)
cmpl $0x1e, -0xc(%rsp)
jge 0xd63c8
movq -0x8(%rsp), %rax
movslq -0xc(%rsp), %rcx
movw $0x0, 0x9c8(%rax,%rcx,4)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0xd63a0
movl $0x0, -0xc(%rsp)
cmpl $0x13, -0xc(%rsp)
jge 0xd63f8
movq -0x8(%rsp), %rax
movslq -0xc(%rsp), %rcx
movw $0x0, 0xabc(%rax,%rcx,4)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0xd63d0
movq -0x8(%rsp), %rax
movw $0x1, 0x4d4(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x1720(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x1718(%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0x1728(%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0x170c(%rax)
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
cmpl $0x8, 0x1734(%rax)
jle 0xd6729
movq -0x8(%rsp), %rax
movzwl 0x1730(%rax), %eax
andl $0xff, %eax
movb %al, %dl
movq -0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rsp), %rsi
movq 0x28(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x28(%rsi)
movb %dl, (%rax,%rcx)
movq -0x8(%rsp), %rax
movzwl 0x1730(%rax), %eax
sarl $0x8, %eax
movb %al, %dl
movq -0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rsp), %rsi
movq 0x28(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x28(%rsi)
movb %dl, (%rax,%rcx)
jmp 0xd6767
movq -0x8(%rsp), %rax
cmpl $0x0, 0x1734(%rax)
jle 0xd6765
movq -0x8(%rsp), %rax
movw 0x1730(%rax), %ax
movb %al, %dl
movq -0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rsp), %rsi
movq 0x28(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x28(%rsi)
movb %dl, (%rax,%rcx)
jmp 0xd6767
movq -0x8(%rsp), %rax
movw $0x0, 0x1730(%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0x1734(%rax)
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
cmpl $0x10, 0x1734(%rax)
jne 0xd683a
movq -0x8(%rsp), %rax
movzwl 0x1730(%rax), %eax
andl $0xff, %eax
movb %al, %dl
movq -0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rsp), %rsi
movq 0x28(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x28(%rsi)
movb %dl, (%rax,%rcx)
movq -0x8(%rsp), %rax
movzwl 0x1730(%rax), %eax
sarl $0x8, %eax
movb %al, %dl
movq -0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rsp), %rsi
movq 0x28(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x28(%rsi)
movb %dl, (%rax,%rcx)
movq -0x8(%rsp), %rax
movw $0x0, 0x1730(%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0x1734(%rax)
jmp 0xd68a2
movq -0x8(%rsp), %rax
cmpl $0x8, 0x1734(%rax)
jl 0xd68a0
movq -0x8(%rsp), %rax
movw 0x1730(%rax), %ax
movb %al, %dl
movq -0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rsp), %rsi
movq 0x28(%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, 0x28(%rsi)
movb %dl, (%rax,%rcx)
movq -0x8(%rsp), %rax
movzwl 0x1730(%rax), %ecx
sarl $0x8, %ecx
movw %cx, 0x1730(%rax)
movq -0x8(%rsp), %rax
movl 0x1734(%rax), %ecx
subl $0x8, %ecx
movl %ecx, 0x1734(%rax)
jmp 0xd68a2
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/zlib-1.3.0.1/trees.c
// Function: detect_data_type
local int detect_data_type(deflate_state *s) {
    /* block_mask is the bit mask of block-listed bytes
     * set bits 0..6, 14..25, and 28..31
     * 0xf3ffc07f = binary 11110011111111111100000001111111
     */
    unsigned long block_mask = 0xf3ffc07fUL;
    int n;

    /* Check for non-textual ("block-listed") bytes. */
    for (n = 0; n <= 31; n++, block_mask >>= 1)
        if ((block_mask & 1) && (s->dyn_ltree[n].Freq != 0))
            return Z_BINARY;

    /* Check for textual ("allow-listed") bytes. */
    if (s->dyn_ltree[9].Freq != 0 || s->dyn_ltree[10].Freq != 0
            || s->dyn_ltree[13].Freq != 0)
        return Z_TEXT;
    for (n = 32; n < LITERALS; n++)
        if (s->dyn_ltree[n].Freq != 0)
            return Z_TEXT;

    /* There are no "block-listed" or "allow-listed" bytes:
     * this stream either is empty or has tolerated ("gray-listed") bytes only.
     */
    return Z_BINARY;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movl $0xf3ffc07f, %eax       # imm = 0xF3FFC07F
movq %rax, -0x18(%rsp)
movl $0x0, -0x1c(%rsp)
cmpl $0x1f, -0x1c(%rsp)
jg 0xd700d
movq -0x18(%rsp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0xd6ff1
movq -0x10(%rsp), %rax
movslq -0x1c(%rsp), %rcx
movzwl 0xd4(%rax,%rcx,4), %eax
cmpl $0x0, %eax
je 0xd6ff1
movl $0x0, -0x4(%rsp)
jmp 0xd7094
jmp 0xd6ff3
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
movq -0x18(%rsp), %rax
shrq %rax
movq %rax, -0x18(%rsp)
jmp 0xd6fb7
movq -0x10(%rsp), %rax
movzwl 0xf8(%rax), %eax
cmpl $0x0, %eax
jne 0xd7040
movq -0x10(%rsp), %rax
movzwl 0xfc(%rax), %eax
cmpl $0x0, %eax
jne 0xd7040
movq -0x10(%rsp), %rax
movzwl 0x108(%rax), %eax
cmpl $0x0, %eax
je 0xd704a
movl $0x1, -0x4(%rsp)
jmp 0xd7094
movl $0x20, -0x1c(%rsp)
cmpl $0x100, -0x1c(%rsp)     # imm = 0x100
jge 0xd708c
movq -0x10(%rsp), %rax
movslq -0x1c(%rsp), %rcx
movzwl 0xd4(%rax,%rcx,4), %eax
cmpl $0x0, %eax
je 0xd707d
movl $0x1, -0x4(%rsp)
jmp 0xd7094
jmp 0xd707f
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0xd7052
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/trees.c
// Function: build_bl_tree
local int build_bl_tree(deflate_state *s) {
    int max_blindex;  /* index of last bit length code of non zero freq */

    /* Determine the bit length frequencies for literal and distance trees */
    scan_tree(s, (ct_data *)s->dyn_ltree, s->l_desc.max_code);
    scan_tree(s, (ct_data *)s->dyn_dtree, s->d_desc.max_code);

    /* Build the bit length tree: */
    build_tree(s, (tree_desc *)(&(s->bl_desc)));
    /* opt_len now includes the length of the tree representations, except the
     * lengths of the bit lengths codes and the 5 + 5 + 4 bits for the counts.
     */

    /* Determine the number of bit length codes to send. The pkzip format
     * requires that at least 4 bit length codes be sent. (appnote.txt says
     * 3 but the actual value used is 4.)
     */
    for (max_blindex = BL_CODES-1; max_blindex >= 3; max_blindex--) {
        if (s->bl_tree[bl_order[max_blindex]].Len != 0) break;
    }
    /* Update opt_len to include the bit length tree and counts */
    s->opt_len += 3*((ulg)max_blindex + 1) + 5 + 5 + 4;
    Tracev((stderr, "\ndyn trees: dyn %ld, stat %ld",
            s->opt_len, s->static_len));

    return max_blindex;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rsi
addq $0xd4, %rsi
movq 0x10(%rsp), %rax
movl 0xb60(%rax), %edx
callq 0xd8d90
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rsi
addq $0x9c8, %rsi            # imm = 0x9C8
movq 0x10(%rsp), %rax
movl 0xb78(%rax), %edx
callq 0xd8d90
movq 0x10(%rsp), %rdi
movq 0x10(%rsp), %rsi
addq $0xb88, %rsi            # imm = 0xB88
callq 0xd70a0
movl $0x12, 0xc(%rsp)
cmpl $0x3, 0xc(%rsp)
jl 0xd7563
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rdx
leaq 0x9f7cf(%rip), %rcx     # 0x176d10
movzbl (%rcx,%rdx), %ecx
movzwl 0xabe(%rax,%rcx,4), %eax
cmpl $0x0, %eax
je 0xd7554
jmp 0xd7563
jmp 0xd7556
movl 0xc(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0xd7529
movslq 0xc(%rsp), %rax
addq $0x1, %rax
imulq $0x3, %rax, %rcx
addq $0x5, %rcx
addq $0x5, %rcx
addq $0x4, %rcx
movq 0x10(%rsp), %rax
addq 0x1718(%rax), %rcx
movq %rcx, 0x1718(%rax)
movl 0xc(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/zlib-1.3.0.1/trees.c
// Function: tr_tally
int ZLIB_INTERNAL _tr_tally(deflate_state *s, unsigned dist, unsigned lc) {
#ifdef LIT_MEM
    s->d_buf[s->sym_next] = (ush)dist;
    s->l_buf[s->sym_next++] = (uch)lc;
#else
    s->sym_buf[s->sym_next++] = (uch)dist;
    s->sym_buf[s->sym_next++] = (uch)(dist >> 8);
    s->sym_buf[s->sym_next++] = (uch)lc;
#endif
    if (dist == 0) {
        /* lc is the unmatched char */
        s->dyn_ltree[lc].Freq++;
    } else {
        s->matches++;
        /* Here, lc is the match length - MIN_MATCH */
        dist--;             /* dist = match distance - 1 */
        Assert((ush)dist < (ush)MAX_DIST(s) &&
               (ush)lc <= (ush)(MAX_MATCH-MIN_MATCH) &&
               (ush)d_code(dist) < (ush)D_CODES,  "_tr_tally: bad match");

        s->dyn_ltree[_length_code[lc] + LITERALS + 1].Freq++;
        s->dyn_dtree[d_code(dist)].Freq++;
    }
    return (s->sym_next == s->sym_end);
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl %edx, -0x10(%rsp)
movl -0xc(%rsp), %eax
movb %al, %dl
movq -0x8(%rsp), %rax
movq 0x1700(%rax), %rax
movq -0x8(%rsp), %rsi
movl 0x170c(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x170c(%rsi)
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movl -0xc(%rsp), %eax
shrl $0x8, %eax
movb %al, %dl
movq -0x8(%rsp), %rax
movq 0x1700(%rax), %rax
movq -0x8(%rsp), %rsi
movl 0x170c(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x170c(%rsi)
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movl -0x10(%rsp), %eax
movb %al, %dl
movq -0x8(%rsp), %rax
movq 0x1700(%rax), %rax
movq -0x8(%rsp), %rsi
movl 0x170c(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x170c(%rsi)
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
cmpl $0x0, -0xc(%rsp)
jne 0xd85a0
movq -0x8(%rsp), %rax
movl -0x10(%rsp), %ecx
movw 0xd4(%rax,%rcx,4), %dx
addw $0x1, %dx
movw %dx, 0xd4(%rax,%rcx,4)
jmp 0xd865d
movq -0x8(%rsp), %rax
movl 0x1728(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x1728(%rax)
movl -0xc(%rsp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rsp)
movq -0x8(%rsp), %rax
movl -0x10(%rsp), %ecx
movl %ecx, %edx
leaq 0x9dfef(%rip), %rcx     # 0x1765c0
movzbl (%rcx,%rdx), %ecx
addl $0x100, %ecx            # imm = 0x100
addl $0x1, %ecx
movslq %ecx, %rcx
movw 0xd4(%rax,%rcx,4), %dx
addw $0x1, %dx
movw %dx, 0xd4(%rax,%rcx,4)
movq -0x8(%rsp), %rax
addq $0x9c8, %rax            # imm = 0x9C8
movq %rax, -0x18(%rsp)
cmpl $0x100, -0xc(%rsp)      # imm = 0x100
jae 0xd8626
movl -0xc(%rsp), %eax
movl %eax, %ecx
leaq 0x9dda4(%rip), %rax     # 0x1763c0
movzbl (%rax,%rcx), %eax
movl %eax, -0x1c(%rsp)
jmp 0xd8645
movl -0xc(%rsp), %eax
shrl $0x7, %eax
addl $0x100, %eax            # imm = 0x100
movl %eax, %eax
movl %eax, %ecx
leaq 0x9dd83(%rip), %rax     # 0x1763c0
movzbl (%rax,%rcx), %eax
movl %eax, -0x1c(%rsp)
movq -0x18(%rsp), %rax
movl -0x1c(%rsp), %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,4), %dx
addw $0x1, %dx
movw %dx, (%rax,%rcx,4)
movq -0x8(%rsp), %rax
movl 0x170c(%rax), %eax
movq -0x8(%rsp), %rcx
cmpl 0x1710(%rcx), %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/zlib-1.3.0.1/trees.c
// Function: gen_codes
local void gen_codes(ct_data *tree, int max_code, ushf *bl_count) {
    ush next_code[MAX_BITS+1]; /* next code value for each bit length */
    unsigned code = 0;         /* running code value */
    int bits;                  /* bit index */
    int n;                     /* code index */

    /* The distribution counts are first used to generate the code values
     * without bit reversal.
     */
    for (bits = 1; bits <= MAX_BITS; bits++) {
        code = (code + bl_count[bits - 1]) << 1;
        next_code[bits] = (ush)code;
    }
    /* Check that the bit counts in bl_count are consistent. The last code
     * must be all ones.
     */
    Assert (code + bl_count[MAX_BITS] - 1 == (1 << MAX_BITS) - 1,
            "inconsistent bit counts");
    Tracev((stderr,"\ngen_codes: max_code %d ", max_code));

    for (n = 0;  n <= max_code; n++) {
        int len = tree[n].Len;
        if (len == 0) continue;
        /* Now reverse the bits */
        tree[n].Code = (ush)bi_reverse(next_code[len]++, len);

        Tracecv(tree != static_ltree, (stderr,"\nn %3d %c l %2d c %4x (%x) ",
            n, (isgraph(n) ? n : ' '), len, tree[n].Code, next_code[len] - 1));
    }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq %rdx, 0x30(%rsp)
movl $0x0, 0xc(%rsp)
movl $0x1, 0x8(%rsp)
cmpl $0xf, 0x8(%rsp)
jg 0xd8cc6
movl 0xc(%rsp), %eax
movq 0x30(%rsp), %rcx
movl 0x8(%rsp), %edx
subl $0x1, %edx
movslq %edx, %rdx
movzwl (%rcx,%rdx,2), %ecx
addl %ecx, %eax
shll %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movw %ax, %cx
movslq 0x8(%rsp), %rax
movw %cx, 0x10(%rsp,%rax,2)
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0xd8c82
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x3c(%rsp), %eax
jg 0xd8d30
movq 0x40(%rsp), %rax
movslq 0x4(%rsp), %rcx
movzwl 0x2(%rax,%rcx,4), %eax
movl %eax, (%rsp)
cmpl $0x0, (%rsp)
jne 0xd8cf2
jmp 0xd8d23
movslq (%rsp), %rcx
movw 0x10(%rsp,%rcx,2), %ax
movw %ax, %dx
addw $0x1, %dx
movw %dx, 0x10(%rsp,%rcx,2)
movzwl %ax, %edi
movl (%rsp), %esi
callq 0xd8d40
movw %ax, %dx
movq 0x40(%rsp), %rax
movslq 0x4(%rsp), %rcx
movw %dx, (%rax,%rcx,4)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0xd8cce
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/trees.c
// Function: bi_reverse
local unsigned bi_reverse(unsigned code, int len) {
    register unsigned res = 0;
    do {
        res |= code & 1;
        code >>= 1, res <<= 1;
    } while (--len > 0);
    return res >> 1;
}

// Assembly:
movl %edi, -0x4(%rsp)
movl %esi, -0x8(%rsp)
movl $0x0, -0xc(%rsp)
movl -0x4(%rsp), %eax
andl $0x1, %eax
orl -0xc(%rsp), %eax
movl %eax, -0xc(%rsp)
movl -0x4(%rsp), %eax
shrl %eax
movl %eax, -0x4(%rsp)
movl -0xc(%rsp), %eax
shll %eax
movl %eax, -0xc(%rsp)
movl -0x8(%rsp), %eax
addl $-0x1, %eax
movl %eax, -0x8(%rsp)
cmpl $0x0, %eax
jg 0xd8d50
movl -0xc(%rsp), %eax
shrl %eax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/zlib-1.3.0.1/inflate.c
// Function: inflateResetKeep
int ZEXPORT inflateResetKeep(z_streamp strm) {
    struct inflate_state FAR *state;

    if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
    state = (struct inflate_state FAR *)strm->state;
    strm->total_in = strm->total_out = state->total = 0;
    strm->msg = Z_NULL;
    if (state->wrap)        /* to support ill-conceived Java test suite */
        strm->adler = state->wrap & 1;
    state->mode = HEAD;
    state->last = 0;
    state->havedict = 0;
    state->flags = -1;
    state->dmax = 32768U;
    state->head = Z_NULL;
    state->hold = 0;
    state->bits = 0;
    state->lencode = state->distcode = state->next = state->codes;
    state->sane = 1;
    state->back = -1;
    Tracev((stderr, "inflate: reset\n"));
    return Z_OK;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0xd9d70
cmpl $0x0, %eax
je 0xd9c55
movl $0xfffffffe, 0x14(%rsp) # imm = 0xFFFFFFFE
jmp 0xd9d59
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq $0x0, 0x28(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x28(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x30(%rax)
movq (%rsp), %rax
cmpl $0x0, 0x10(%rax)
je 0xd9cb5
movq (%rsp), %rax
movl 0x10(%rax), %eax
andl $0x1, %eax
movslq %eax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x60(%rax)
movq (%rsp), %rax
movl $0x3f34, 0x8(%rax)      # imm = 0x3F34
movq (%rsp), %rax
movl $0x0, 0xc(%rax)
movq (%rsp), %rax
movl $0x0, 0x14(%rax)
movq (%rsp), %rax
movl $0xffffffff, 0x18(%rax) # imm = 0xFFFFFFFF
movq (%rsp), %rax
movl $0x8000, 0x1c(%rax)     # imm = 0x8000
movq (%rsp), %rax
movq $0x0, 0x30(%rax)
movq (%rsp), %rax
movq $0x0, 0x50(%rax)
movq (%rsp), %rax
movl $0x0, 0x58(%rax)
movq (%rsp), %rcx
addq $0x558, %rcx            # imm = 0x558
movq (%rsp), %rax
movq %rcx, 0x90(%rax)
movq (%rsp), %rax
movq %rcx, 0x70(%rax)
movq (%rsp), %rax
movq %rcx, 0x68(%rax)
movq (%rsp), %rax
movl $0x1, 0x1be8(%rax)
movq (%rsp), %rax
movl $0xffffffff, 0x1bec(%rax) # imm = 0xFFFFFFFF
movl $0x0, 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/inflate.c
// Function: inflateStateCheck
local int inflateStateCheck(z_streamp strm) {
    struct inflate_state FAR *state;
    if (strm == Z_NULL ||
        strm->zalloc == (alloc_func)0 || strm->zfree == (free_func)0)
        return 1;
    state = (struct inflate_state FAR *)strm->state;
    if (state == Z_NULL || state->strm != strm ||
        state->mode < HEAD || state->mode > SYNC)
        return 1;
    return 0;
}

// Assembly:
movq %rdi, -0x10(%rsp)
cmpq $0x0, -0x10(%rsp)
je 0xd9d95
movq -0x10(%rsp), %rax
cmpq $0x0, 0x40(%rax)
je 0xd9d95
movq -0x10(%rsp), %rax
cmpq $0x0, 0x48(%rax)
jne 0xd9d9f
movl $0x1, -0x4(%rsp)
jmp 0xd9df2
movq -0x10(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x18(%rsp)
cmpq $0x0, -0x18(%rsp)
je 0xd9de0
movq -0x18(%rsp), %rax
movq (%rax), %rax
cmpq -0x10(%rsp), %rax
jne 0xd9de0
movq -0x18(%rsp), %rax
cmpl $0x3f34, 0x8(%rax)      # imm = 0x3F34
jb 0xd9de0
movq -0x18(%rsp), %rax
cmpl $0x3f53, 0x8(%rax)      # imm = 0x3F53
jbe 0xd9dea
movl $0x1, -0x4(%rsp)
jmp 0xd9df2
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/zlib-1.3.0.1/inflate.c
// Function: inflateReset
int ZEXPORT inflateReset(z_streamp strm) {
    struct inflate_state FAR *state;

    if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
    state = (struct inflate_state FAR *)strm->state;
    state->wsize = 0;
    state->whave = 0;
    state->wnext = 0;
    return inflateResetKeep(strm);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0xd9d70
cmpl $0x0, %eax
je 0xd9e22
movl $0xfffffffe, 0x14(%rsp) # imm = 0xFFFFFFFE
jmp 0xd9e5e
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movl $0x0, 0x3c(%rax)
movq (%rsp), %rax
movl $0x0, 0x40(%rax)
movq (%rsp), %rax
movl $0x0, 0x44(%rax)
movq 0x8(%rsp), %rdi
callq 0xd9c30
movl %eax, 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/inflate.c
// Function: inflateReset2
int ZEXPORT inflateReset2(z_streamp strm, int windowBits) {
    int wrap;
    struct inflate_state FAR *state;

    /* get the state */
    if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
    state = (struct inflate_state FAR *)strm->state;

    /* extract wrap request from windowBits parameter */
    if (windowBits < 0) {
        if (windowBits < -15)
            return Z_STREAM_ERROR;
        wrap = 0;
        windowBits = -windowBits;
    }
    else {
        wrap = (windowBits >> 4) + 5;
#ifdef GUNZIP
        if (windowBits < 48)
            windowBits &= 15;
#endif
    }

    /* set number of window bits, free window if different */
    if (windowBits && (windowBits < 8 || windowBits > 15))
        return Z_STREAM_ERROR;
    if (state->window != Z_NULL && state->wbits != (unsigned)windowBits) {
        ZFREE(strm, state->window);
        state->window = Z_NULL;
    }

    /* update state and reset the rest of it */
    state->wrap = wrap;
    state->wbits = (unsigned)windowBits;
    return inflateReset(strm);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rdi
callq 0xd9d70
cmpl $0x0, %eax
je 0xd9e99
movl $0xfffffffe, 0x24(%rsp) # imm = 0xFFFFFFFE
jmp 0xd9f81
movq 0x18(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, 0x8(%rsp)
cmpl $0x0, 0x14(%rsp)
jge 0xd9ed6
cmpl $-0xf, 0x14(%rsp)
jge 0xd9ec2
movl $0xfffffffe, 0x24(%rsp) # imm = 0xFFFFFFFE
jmp 0xd9f81
movl $0x0, 0x10(%rsp)
xorl %eax, %eax
subl 0x14(%rsp), %eax
movl %eax, 0x14(%rsp)
jmp 0xd9ef8
movl 0x14(%rsp), %eax
sarl $0x4, %eax
addl $0x5, %eax
movl %eax, 0x10(%rsp)
cmpl $0x30, 0x14(%rsp)
jge 0xd9ef6
movl 0x14(%rsp), %eax
andl $0xf, %eax
movl %eax, 0x14(%rsp)
jmp 0xd9ef8
cmpl $0x0, 0x14(%rsp)
je 0xd9f17
cmpl $0x8, 0x14(%rsp)
jl 0xd9f0d
cmpl $0xf, 0x14(%rsp)
jle 0xd9f17
movl $0xfffffffe, 0x24(%rsp) # imm = 0xFFFFFFFE
jmp 0xd9f81
movq 0x8(%rsp), %rax
cmpq $0x0, 0x48(%rax)
je 0xd9f5b
movq 0x8(%rsp), %rax
movl 0x38(%rax), %eax
cmpl 0x14(%rsp), %eax
je 0xd9f5b
movq 0x18(%rsp), %rax
movq 0x48(%rax), %rax
movq 0x18(%rsp), %rcx
movq 0x50(%rcx), %rdi
movq 0x8(%rsp), %rcx
movq 0x48(%rcx), %rsi
callq *%rax
movq 0x8(%rsp), %rax
movq $0x0, 0x48(%rax)
movl 0x10(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x10(%rax)
movl 0x14(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x38(%rax)
movq 0x18(%rsp), %rdi
callq 0xd9e00
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/zlib-1.3.0.1/inflate.c
// Function: inflateInit2_
int ZEXPORT inflateInit2_(z_streamp strm, int windowBits,
                          const char *version, int stream_size) {
    int ret;
    struct inflate_state FAR *state;

    if (version == Z_NULL || version[0] != ZLIB_VERSION[0] ||
        stream_size != (int)(sizeof(z_stream)))
        return Z_VERSION_ERROR;
    if (strm == Z_NULL) return Z_STREAM_ERROR;
    strm->msg = Z_NULL;                 /* in case we return an error */
    if (strm->zalloc == (alloc_func)0) {
#ifdef Z_SOLO
        return Z_STREAM_ERROR;
#else
        strm->zalloc = zcalloc;
        strm->opaque = (voidpf)0;
#endif
    }
    if (strm->zfree == (free_func)0)
#ifdef Z_SOLO
        return Z_STREAM_ERROR;
#else
        strm->zfree = zcfree;
#endif
    state = (struct inflate_state FAR *)
            ZALLOC(strm, 1, sizeof(struct inflate_state));
    if (state == Z_NULL) return Z_MEM_ERROR;
    Tracev((stderr, "inflate: allocated\n"));
    strm->state = (struct internal_state FAR *)state;
    state->strm = strm;
    state->window = Z_NULL;
    state->mode = HEAD;     /* to pass state test in inflateReset2() */
    ret = inflateReset2(strm, windowBits);
    if (ret != Z_OK) {
        ZFREE(strm, state);
        strm->state = Z_NULL;
    }
    return ret;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq %rdx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0xd9fc8
movq 0x18(%rsp), %rax
movsbl (%rax), %eax
movsbl 0x9c31d(%rip), %ecx     # 0x1762da
cmpl %ecx, %eax
jne 0xd9fc8
cmpl $0x70, 0x14(%rsp)
je 0xd9fd5
movl $0xfffffffa, 0x34(%rsp) # imm = 0xFFFFFFFA
jmp 0xda0ec
cmpq $0x0, 0x28(%rsp)
jne 0xd9fea
movl $0xfffffffe, 0x34(%rsp) # imm = 0xFFFFFFFE
jmp 0xda0ec
movq 0x28(%rsp), %rax
movq $0x0, 0x30(%rax)
movq 0x28(%rsp), %rax
cmpq $0x0, 0x40(%rax)
jne 0xda020
movq 0x28(%rsp), %rax
leaq -0x42f(%rip), %rcx      # 0xd9be0
movq %rcx, 0x40(%rax)
movq 0x28(%rsp), %rax
movq $0x0, 0x50(%rax)
movq 0x28(%rsp), %rax
cmpq $0x0, 0x48(%rax)
jne 0xda03c
movq 0x28(%rsp), %rax
leaq -0x428(%rip), %rcx      # 0xd9c10
movq %rcx, 0x48(%rax)
movq 0x28(%rsp), %rax
movq 0x40(%rax), %rax
movq 0x28(%rsp), %rcx
movq 0x50(%rcx), %rdi
movl $0x1, %esi
movl $0x1bf8, %edx           # imm = 0x1BF8
callq *%rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0xda071
movl $0xfffffffc, 0x34(%rsp) # imm = 0xFFFFFFFC
jmp 0xda0ec
movq 0x8(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x38(%rax)
movq 0x28(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x48(%rax)
movq 0x8(%rsp), %rax
movl $0x3f34, 0x8(%rax)      # imm = 0x3F34
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0xd9e70
movl %eax, 0x10(%rsp)
cmpl $0x0, 0x10(%rsp)
je 0xda0e4
movq 0x28(%rsp), %rax
movq 0x48(%rax), %rax
movq 0x28(%rsp), %rcx
movq 0x50(%rcx), %rdi
movq 0x8(%rsp), %rsi
callq *%rax
movq 0x28(%rsp), %rax
movq $0x0, 0x38(%rax)
movl 0x10(%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/inflate.c
// Function: inflatePrime
int ZEXPORT inflatePrime(z_streamp strm, int bits, int value) {
    struct inflate_state FAR *state;

    if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
    if (bits == 0)
        return Z_OK;
    state = (struct inflate_state FAR *)strm->state;
    if (bits < 0) {
        state->hold = 0;
        state->bits = 0;
        return Z_OK;
    }
    if (bits > 16 || state->bits + (uInt)bits > 32) return Z_STREAM_ERROR;
    value &= (1L << bits) - 1;
    state->hold += (unsigned)value << state->bits;
    state->bits += (uInt)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 0xd9d70
cmpl $0x0, %eax
je 0xda15d
movl $0xfffffffe, 0x24(%rsp) # imm = 0xFFFFFFFE
jmp 0xda222
cmpl $0x0, 0x14(%rsp)
jne 0xda171
movl $0x0, 0x24(%rsp)
jmp 0xda222
movq 0x18(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, 0x8(%rsp)
cmpl $0x0, 0x14(%rsp)
jge 0xda1a9
movq 0x8(%rsp), %rax
movq $0x0, 0x50(%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x58(%rax)
movl $0x0, 0x24(%rsp)
jmp 0xda222
cmpl $0x10, 0x14(%rsp)
jg 0xda1c1
movq 0x8(%rsp), %rax
movl 0x58(%rax), %eax
addl 0x14(%rsp), %eax
cmpl $0x20, %eax
jbe 0xda1cb
movl $0xfffffffe, 0x24(%rsp) # imm = 0xFFFFFFFE
jmp 0xda222
movl 0x14(%rsp), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, %rcx
subq $0x1, %rcx
movslq 0x10(%rsp), %rax
andq %rcx, %rax
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %eax
movq 0x8(%rsp), %rcx
movl 0x58(%rcx), %ecx
shll %cl, %eax
movl %eax, %eax
movl %eax, %ecx
movq 0x8(%rsp), %rax
addq 0x50(%rax), %rcx
movq %rcx, 0x50(%rax)
movl 0x14(%rsp), %ecx
movq 0x8(%rsp), %rax
addl 0x58(%rax), %ecx
movl %ecx, 0x58(%rax)
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/inflate.c
// Function: inflateEnd
int ZEXPORT inflateEnd(z_streamp strm) {
    struct inflate_state FAR *state;
    if (inflateStateCheck(strm))
        return Z_STREAM_ERROR;
    state = (struct inflate_state FAR *)strm->state;
    if (state->window != Z_NULL) ZFREE(strm, state->window);
    ZFREE(strm, strm->state);
    strm->state = Z_NULL;
    Tracev((stderr, "inflate: end\n"));
    return Z_OK;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0xd9d70
cmpl $0x0, %eax
je 0xddbd2
movl $0xfffffffe, 0x14(%rsp) # imm = 0xFFFFFFFE
jmp 0xddc38
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
cmpq $0x0, 0x48(%rax)
je 0xddc06
movq 0x8(%rsp), %rax
movq 0x48(%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x50(%rcx), %rdi
movq (%rsp), %rcx
movq 0x48(%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 $0x0, 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/inflate.c
// Function: inflateGetDictionary
int ZEXPORT inflateGetDictionary(z_streamp strm, Bytef *dictionary,
                                 uInt *dictLength) {
    struct inflate_state FAR *state;

    /* check state */
    if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
    state = (struct inflate_state FAR *)strm->state;

    /* copy dictionary */
    if (state->whave && dictionary != Z_NULL) {
        zmemcpy(dictionary, state->window + state->wnext,
                state->whave - state->wnext);
        zmemcpy(dictionary + state->whave - state->wnext,
                state->window, state->wnext);
    }
    if (dictLength != Z_NULL)
        *dictLength = state->whave;
    return Z_OK;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0xd9d70
cmpl $0x0, %eax
je 0xddc7f
movl $0xfffffffe, 0x24(%rsp) # imm = 0xFFFFFFFE
jmp 0xddd20
movq 0x18(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
cmpl $0x0, 0x40(%rax)
je 0xddd02
cmpq $0x0, 0x10(%rsp)
je 0xddd02
movq 0x10(%rsp), %rdi
movq (%rsp), %rax
movq 0x48(%rax), %rsi
movq (%rsp), %rax
movl 0x44(%rax), %eax
addq %rax, %rsi
movq (%rsp), %rax
movl 0x40(%rax), %eax
movq (%rsp), %rcx
subl 0x44(%rcx), %eax
movl %eax, %eax
movl %eax, %edx
callq 0xb500
movq 0x10(%rsp), %rdi
movq (%rsp), %rax
movl 0x40(%rax), %eax
addq %rax, %rdi
movq (%rsp), %rax
movl 0x44(%rax), %eax
movl %eax, %ecx
xorl %eax, %eax
subq %rcx, %rax
addq %rax, %rdi
movq (%rsp), %rax
movq 0x48(%rax), %rsi
movq (%rsp), %rax
movl 0x44(%rax), %eax
movl %eax, %edx
callq 0xb500
cmpq $0x0, 0x8(%rsp)
je 0xddd18
movq (%rsp), %rax
movl 0x40(%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/inflate.c
// Function: inflateSetDictionary
int ZEXPORT inflateSetDictionary(z_streamp strm, const Bytef *dictionary,
                                 uInt dictLength) {
    struct inflate_state FAR *state;
    unsigned long dictid;
    int ret;

    /* check state */
    if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
    state = (struct inflate_state FAR *)strm->state;
    if (state->wrap != 0 && state->mode != DICT)
        return Z_STREAM_ERROR;

    /* check for correct dictionary identifier */
    if (state->mode == DICT) {
        dictid = adler32(0L, Z_NULL, 0);
        dictid = adler32(dictid, dictionary, dictLength);
        if (dictid != state->check)
            return Z_DATA_ERROR;
    }

    /* copy dictionary to window using updatewindow(), which will amend the
       existing dictionary if appropriate */
    ret = updatewindow(strm, dictionary + dictLength, dictLength);
    if (ret) {
        state->mode = MEM;
        return Z_MEM_ERROR;
    }
    state->havedict = 1;
    Tracev((stderr, "inflate:   dictionary set\n"));
    return Z_OK;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movq 0x28(%rsp), %rdi
callq 0xd9d70
cmpl $0x0, %eax
je 0xddd5e
movl $0xfffffffe, 0x34(%rsp) # imm = 0xFFFFFFFE
jmp 0xdde36
movq 0x28(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpl $0x0, 0x10(%rax)
je 0xddd92
movq 0x10(%rsp), %rax
cmpl $0x3f3e, 0x8(%rax)      # imm = 0x3F3E
je 0xddd92
movl $0xfffffffe, 0x34(%rsp) # imm = 0xFFFFFFFE
jmp 0xdde36
movq 0x10(%rsp), %rax
cmpl $0x3f3e, 0x8(%rax)      # imm = 0x3F3E
jne 0xddde7
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
movq %rsi, %rdi
callq 0x107d60
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl 0x1c(%rsp), %edx
callq 0x107d60
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x20(%rcx), %rax
je 0xddde5
movl $0xfffffffd, 0x34(%rsp) # imm = 0xFFFFFFFD
jmp 0xdde36
jmp 0xddde7
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl 0x1c(%rsp), %eax
addq %rax, %rsi
movl 0x1c(%rsp), %edx
callq 0xdd980
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
je 0xdde22
movq 0x10(%rsp), %rax
movl $0x3f52, 0x8(%rax)      # imm = 0x3F52
movl $0xfffffffc, 0x34(%rsp) # imm = 0xFFFFFFFC
jmp 0xdde36
movq 0x10(%rsp), %rax
movl $0x1, 0x14(%rax)
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/zlib-1.3.0.1/inflate.c
// Function: inflateGetHeader
int ZEXPORT inflateGetHeader(z_streamp strm, gz_headerp head) {
    struct inflate_state FAR *state;

    /* check state */
    if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
    state = (struct inflate_state FAR *)strm->state;
    if ((state->wrap & 2) == 0) return Z_STREAM_ERROR;

    /* save header structure */
    state->head = head;
    head->done = 0;
    return Z_OK;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0xd9d70
cmpl $0x0, %eax
je 0xdde67
movl $0xfffffffe, 0x24(%rsp) # imm = 0xFFFFFFFE
jmp 0xddeb1
movq 0x18(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl 0x10(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
jne 0xdde8f
movl $0xfffffffe, 0x24(%rsp) # imm = 0xFFFFFFFE
jmp 0xddeb1
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x30(%rax)
movq 0x10(%rsp), %rax
movl $0x0, 0x48(%rax)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/zlib-1.3.0.1/inflate.c
// Function: syncsearch
local unsigned syncsearch(unsigned FAR *have, const unsigned char FAR *buf,
                          unsigned len) {
    unsigned got;
    unsigned next;

    got = *have;
    next = 0;
    while (next < len && got < 4) {
        if ((int)(buf[next]) == (got < 2 ? 0 : 0xff))
            got++;
        else if (buf[next])
            got = 0;
        else
            got = 4 - got;
        next++;
    }
    *have = got;
    return next;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movq -0x8(%rsp), %rax
movl (%rax), %eax
movl %eax, -0x18(%rsp)
movl $0x0, -0x1c(%rsp)
movl -0x1c(%rsp), %ecx
xorl %eax, %eax
cmpl -0x14(%rsp), %ecx
movb %al, -0x1d(%rsp)
jae 0xde12d
cmpl $0x4, -0x18(%rsp)
setb %al
movb %al, -0x1d(%rsp)
movb -0x1d(%rsp), %al
testb $0x1, %al
jne 0xde137
jmp 0xde19e
movq -0x10(%rsp), %rax
movl -0x1c(%rsp), %ecx
movzbl (%rax,%rcx), %eax
movl -0x18(%rsp), %esi
movl $0xff, %ecx
xorl %edx, %edx
cmpl $0x2, %esi
cmovbl %edx, %ecx
cmpl %ecx, %eax
jne 0xde166
movl -0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rsp)
jmp 0xde18e
movq -0x10(%rsp), %rax
movl -0x1c(%rsp), %ecx
cmpb $0x0, (%rax,%rcx)
je 0xde17f
movl $0x0, -0x18(%rsp)
jmp 0xde18c
movl $0x4, %eax
subl -0x18(%rsp), %eax
movl %eax, -0x18(%rsp)
jmp 0xde18e
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0xde111
movl -0x18(%rsp), %ecx
movq -0x8(%rsp), %rax
movl %ecx, (%rax)
movl -0x1c(%rsp), %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/zlib-1.3.0.1/inflate.c
// Function: inflateSyncPoint
int ZEXPORT inflateSyncPoint(z_streamp strm) {
    struct inflate_state FAR *state;

    if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
    state = (struct inflate_state FAR *)strm->state;
    return state->mode == STORED && state->bits == 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0xd9d70
cmpl $0x0, %eax
je 0xde1d2
movl $0xfffffffe, 0x24(%rsp) # imm = 0xFFFFFFFE
jmp 0xde211
movq 0x18(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rcx
xorl %eax, %eax
cmpl $0x3f41, 0x8(%rcx)      # imm = 0x3F41
movb %al, 0xf(%rsp)
jne 0xde204
movq 0x10(%rsp), %rax
cmpl $0x0, 0x58(%rax)
sete %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/zlib-1.3.0.1/inflate.c
// Function: inflateUndermine
int ZEXPORT inflateUndermine(z_streamp strm, int subvert) {
    struct inflate_state FAR *state;

    if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
    state = (struct inflate_state FAR *)strm->state;
#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
    state->sane = !subvert;
    return Z_OK;
#else
    (void)subvert;
    state->sane = 1;
    return Z_DATA_ERROR;
#endif
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rdi
callq 0xd9d70
cmpl $0x0, %eax
je 0xde4c6
movl $0xfffffffe, 0x24(%rsp) # imm = 0xFFFFFFFE
jmp 0xde4eb
movq 0x18(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl $0x1, 0x1be8(%rax)
movl $0xfffffffd, 0x24(%rsp) # imm = 0xFFFFFFFD
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/inflate.c
// Function: inflateValidate
int ZEXPORT inflateValidate(z_streamp strm, int check) {
    struct inflate_state FAR *state;

    if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
    state = (struct inflate_state FAR *)strm->state;
    if (check && state->wrap)
        state->wrap |= 4;
    else
        state->wrap &= ~4;
    return Z_OK;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rdi
callq 0xd9d70
cmpl $0x0, %eax
je 0xde526
movl $0xfffffffe, 0x24(%rsp) # imm = 0xFFFFFFFE
jmp 0xde56c
movq 0x18(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, 0x8(%rsp)
cmpl $0x0, 0x14(%rsp)
je 0xde556
movq 0x8(%rsp), %rax
cmpl $0x0, 0x10(%rax)
je 0xde556
movq 0x8(%rsp), %rax
movl 0x10(%rax), %ecx
orl $0x4, %ecx
movl %ecx, 0x10(%rax)
jmp 0xde564
movq 0x8(%rsp), %rax
movl 0x10(%rax), %ecx
andl $-0x5, %ecx
movl %ecx, 0x10(%rax)
movl $0x0, 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/inflate.c
// Function: inflateMark
long ZEXPORT inflateMark(z_streamp strm) {
    struct inflate_state FAR *state;

    if (inflateStateCheck(strm))
        return -(1L << 16);
    state = (struct inflate_state FAR *)strm->state;
    return (long)(((unsigned long)((long)state->back)) << 16) +
        (state->mode == COPY ? state->length :
            (state->mode == MATCH ? state->was - state->length : 0));
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0xd9d70
cmpl $0x0, %eax
je 0xde5a6
movq $-0x10000, 0x20(%rsp)   # imm = 0xFFFF0000
jmp 0xde62c
movq 0x18(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movslq 0x1bec(%rax), %rax
shlq $0x10, %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpl $0x3f43, 0x8(%rax)      # imm = 0x3F43
jne 0xde5e5
movq 0x10(%rsp), %rax
movl 0x5c(%rax), %eax
movl %eax, 0x4(%rsp)
jmp 0xde619
movq 0x10(%rsp), %rax
cmpl $0x3f4c, 0x8(%rax)      # imm = 0x3F4C
jne 0xde60b
movq 0x10(%rsp), %rax
movl 0x1bf0(%rax), %eax
movq 0x10(%rsp), %rcx
subl 0x5c(%rcx), %eax
movl %eax, (%rsp)
jmp 0xde612
xorl %eax, %eax
movl %eax, (%rsp)
jmp 0xde612
movl (%rsp), %eax
movl %eax, 0x4(%rsp)
movq 0x8(%rsp), %rax
movl 0x4(%rsp), %ecx
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
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/inflate.c
// Function: inflateCodesUsed
unsigned long ZEXPORT inflateCodesUsed(z_streamp strm) {
    struct inflate_state FAR *state;
    if (inflateStateCheck(strm)) return (unsigned long)-1;
    state = (struct inflate_state FAR *)strm->state;
    return (unsigned long)(state->next - state->codes);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0xd9d70
cmpl $0x0, %eax
je 0xde663
movq $-0x1, 0x10(%rsp)
jmp 0xde692
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq 0x90(%rax), %rax
movq (%rsp), %rcx
addq $0x558, %rcx            # imm = 0x558
subq %rcx, %rax
sarq $0x2, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/codon_iterator.c
// Function: gt_codon_iterator_class_new
const GtCodonIteratorClass* gt_codon_iterator_class_new(size_t size,
                                        CodonIteratorFreeFunc free,
                                        CodonIteratorCurrentPosFunc current_pos,
                                        CodonIteratorLengthFunc length,
                                        CodonIteratorRewindFunc rewind,
                                        CodonIteratorNextFunc next)
{
  GtCodonIteratorClass *c_class;
  gt_assert(size);
  c_class = gt_class_alloc(sizeof *c_class);
  c_class->size = size;
  c_class->free = free;
  c_class->next = next;
  c_class->length = length;
  c_class->rewind = rewind;
  c_class->current_pos = current_pos;
  return c_class;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq %r9, 0x8(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0xdf922
movq 0xd46e7(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x7e76b(%rip), %rsi     # 0x15e066
leaq 0x8e305(%rip), %rdx     # 0x16dc07
leaq 0x989e7(%rip), %rcx     # 0x1782f0
leaq 0x989fc(%rip), %r8      # 0x17830c
movl $0x2b, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xdf924
movl $0x30, %edi
callq 0x7b610
movq %rax, (%rsp)
movq 0x30(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq 0x28(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x18(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x20(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq (%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/codon_iterator.c
// Function: gt_codon_iterator_create
GtCodonIterator* gt_codon_iterator_create(const GtCodonIteratorClass *cic)
{
  GtCodonIterator *ci;
  gt_assert(cic && cic->size);
  ci = gt_calloc(1, cic->size);
  ci->c_class = cic;
  ci->pvt = gt_calloc(1, sizeof (GtCodonIteratorMembers));
  return ci;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0xdf9ac
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax)
jne 0xdf9e4
movq 0xd4625(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x7e6a9(%rip), %rsi     # 0x15e066
leaq 0x98962(%rip), %rdx     # 0x178326
leaq 0x9896c(%rip), %rcx     # 0x178337
leaq 0x9893a(%rip), %r8      # 0x17830c
movl $0x39, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xdf9e6
movq 0x10(%rsp), %rax
movq (%rax), %rsi
movl $0x1, %edi
leaq 0x98912(%rip), %rdx     # 0x17830c
movl $0x3a, %ecx
callq 0xd5b0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movl $0x1, %edi
movl $0x20, %esi
leaq 0x988e5(%rip), %rdx     # 0x17830c
movl $0x3c, %ecx
callq 0xd5b0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/codon_iterator.c
// Function: gt_codon_iterator_try_cast
void* gt_codon_iterator_try_cast(const GtCodonIteratorClass *cic,
                                 GtCodonIterator *ci)
{
  gt_assert(ci && cic);
  if (ci->c_class == cic)
    return ci;
  return NULL;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
cmpq $0x0, (%rsp)
je 0xdfaec
cmpq $0x0, 0x8(%rsp)
jne 0xdfb24
movq 0xd44e5(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x7e569(%rip), %rsi     # 0x15e066
leaq 0x98883(%rip), %rdx     # 0x178387
leaq 0x98886(%rip), %rcx     # 0x178391
leaq 0x987fa(%rip), %r8      # 0x17830c
movl $0x4a, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xdfb26
movq (%rsp), %rax
movq (%rax), %rax
cmpq 0x8(%rsp), %rax
jne 0xdfb3f
movq (%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0xdfb48
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/codon_iterator.c
// Function: gt_codon_iterator_current_position
GtUword gt_codon_iterator_current_position(GtCodonIterator *ci)
{
  gt_assert(ci && ci->c_class);
  if (ci->c_class->current_pos)
    return ci->c_class->current_pos(ci);
  return 0;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0xdfb7c
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
jne 0xdfbb4
movq 0xd4455(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x7e4d9(%rip), %rsi     # 0x15e066
leaq 0x98818(%rip), %rdx     # 0x1783ac
leaq 0x98823(%rip), %rcx     # 0x1783be
leaq 0x9876a(%rip), %r8      # 0x17830c
movl $0x52, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0xdfbb6
movq 0x8(%rsp), %rax
movq (%rax), %rax
cmpq $0x0, 0x10(%rax)
je 0xdfbdf
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rsp), %rdi
callq *%rax
movq %rax, 0x10(%rsp)
jmp 0xdfbe8
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)