LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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:
movl %esi, %eax
movq 0x1700(%rdi), %rcx
movl 0x170c(%rdi), %esi
leal 0x1(%rsi), %r8d
movl %r8d, 0x170c(%rdi)
movb %al, (%rcx,%rsi)
movq 0x1700(%rdi), %rcx
movl 0x170c(%rdi), %esi
leal 0x1(%rsi), %r8d
movl %r8d, 0x170c(%rdi)
movb %ah, (%rcx,%rsi)
movq 0x1700(%rdi), %rcx
movl 0x170c(%rdi), %esi
leal 0x1(%rsi), %r8d
movl %r8d, 0x170c(%rdi)
movb %dl, (%rcx,%rsi)
testl %eax, %eax
je 0x7fbd7
incl 0x1728(%rdi)
movl %edx, %ecx
leaq 0x618f2(%rip), %rdx     # 0xe1490
movzbl (%rcx,%rdx), %ecx
incw 0x4d8(%rdi,%rcx,4)
leal -0x1(%rax), %ecx
movl %ecx, %edx
shrl $0x7, %edx
addl $0x100, %edx            # imm = 0x100
cmpl $0x101, %eax            # imm = 0x101
cmovbl %ecx, %edx
leaq 0x616c9(%rip), %rax     # 0xe1290
movzbl (%rdx,%rax), %eax
leaq (%rdi,%rax,4), %rax
addq $0x9c8, %rax            # imm = 0x9C8
jmp 0x7fbe3
movl %edx, %eax
leaq (%rdi,%rax,4), %rax
addq $0xd4, %rax
incw (%rax)
movl 0x170c(%rdi), %ecx
xorl %eax, %eax
cmpl 0x1710(%rdi), %ecx
sete %al
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/zlib-1.3.0.1/trees.c
// Function: pqdownheap
local void pqdownheap(deflate_state *s, ct_data *tree, int k) {
    int v = s->heap[k];
    int j = k << 1;  /* left son of k */
    while (j <= s->heap_len) {
        /* Set j to the smallest of the two sons: */
        if (j < s->heap_len &&
            smaller(tree, s->heap[j + 1], s->heap[j], s->depth)) {
            j++;
        }
        /* Exit if v is smaller than both sons */
        if (smaller(tree, v, s->heap[j], s->depth)) break;

        /* Exchange v with the smallest son */
        s->heap[k] = s->heap[j];  k = j;

        /* And continue down the tree, setting j to the left son of k */
        j <<= 1;
    }
    s->heap[k] = v;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %eax
movl 0xbc0(%rdi,%rax,4), %eax
movslq %eax, %rcx
movslq %edx, %r8
addl %edx, %edx
cmpl 0x14b4(%rdi), %edx
jg 0x7fc94
jge 0x7fc47
movl %edx, %r10d
orl $0x1, %r10d
movslq %r10d, %r11
movslq 0xbc0(%rdi,%r11,4), %rbx
movslq %edx, %r9
movslq 0xbc0(%rdi,%r9,4), %r14
movzwl (%rsi,%r14,4), %ebp
cmpw %bp, (%rsi,%rbx,4)
jae 0x7fc7f
movq %r11, %r9
movl %r10d, %edx
jmp 0x7fc4a
movslq %edx, %r9
movl 0xbc0(%rdi,%r9,4), %r9d
movslq %r9d, %r10
movzwl (%rsi,%r10,4), %r11d
cmpw %r11w, (%rsi,%rcx,4)
jb 0x7fc94
jne 0x7fc75
movb 0x14bc(%rdi,%rcx), %r11b
cmpb 0x14bc(%rdi,%r10), %r11b
jbe 0x7fc94
movl %r9d, 0xbc0(%rdi,%r8,4)
jmp 0x7fc08
jne 0x7fc4a
movb 0x14bc(%rdi,%rbx), %bl
cmpb 0x14bc(%rdi,%r14), %bl
jbe 0x7fc3f
jmp 0x7fc4a
movl %eax, 0xbc0(%rdi,%r8,4)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/zlib-1.3.0.1/trees.c
// Function: scan_tree
local void scan_tree(deflate_state *s, ct_data *tree, int max_code) {
    int n;                     /* iterates over all tree elements */
    int prevlen = -1;          /* last emitted length */
    int curlen;                /* length of current code */
    int nextlen = tree[0].Len; /* length of next code */
    int count = 0;             /* repeat count of the current code */
    int max_count = 7;         /* max repeat count */
    int min_count = 4;         /* min repeat count */

    if (nextlen == 0) max_count = 138, min_count = 3;
    tree[max_code + 1].Len = (ush)0xffff; /* guard */

    for (n = 0; n <= max_code; n++) {
        curlen = nextlen; nextlen = tree[n + 1].Len;
        if (++count < max_count && curlen == nextlen) {
            continue;
        } else if (count < min_count) {
            s->bl_tree[curlen].Freq += count;
        } else if (curlen != 0) {
            if (curlen != prevlen) s->bl_tree[curlen].Freq++;
            s->bl_tree[REP_3_6].Freq++;
        } else if (count <= 10) {
            s->bl_tree[REPZ_3_10].Freq++;
        } else {
            s->bl_tree[REPZ_11_138].Freq++;
        }
        count = 0; prevlen = curlen;
        if (nextlen == 0) {
            max_count = 138, min_count = 3;
        } else if (curlen == nextlen) {
            max_count = 6, min_count = 3;
        } else {
            max_count = 7, min_count = 4;
        }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movzwl 0x2(%rsi), %ecx
xorl %ebx, %ebx
testl %ecx, %ecx
movl $0x8a, %eax
movl $0x7, %ebp
cmovel %eax, %ebp
setne %bl
addl $0x3, %ebx
movslq %edx, %rdx
orw $-0x1, 0x6(%rsi,%rdx,4)
movl $0xffffffff, %r11d      # imm = 0xFFFFFFFF
xorl %r8d, %r8d
movl $0x4, %r9d
movl $0x3, %r10d
movl %r11d, %r15d
xorl %r14d, %r14d
cmpq %rdx, %r8
jg 0x7fd79
movl %ecx, %r11d
movzwl 0x6(%rsi,%r8,4), %ecx
incq %r8
incl %r14d
cmpl %ebp, %r14d
jge 0x7fd0a
cmpl %ecx, %r11d
je 0x7fce8
movl %r11d, %r12d
cmpl %ebx, %r14d
jge 0x7fd25
addl 0xabc(%rdi,%r12,4), %r14d
movw %r14w, 0xabc(%rdi,%r12,4)
jmp 0x7fd5a
testl %r11d, %r11d
je 0x7fd41
cmpl %r15d, %r11d
je 0x7fd38
incw 0xabc(%rdi,%r12,4)
incw 0xafc(%rdi)
jmp 0x7fd5a
decl %r14d
cmpl $0x9, %r14d
ja 0x7fd53
incw 0xb00(%rdi)
jmp 0x7fd5a
incw 0xb04(%rdi)
xorl %ebp, %ebp
cmpl %ecx, %r11d
sete %bpl
movl %r9d, %ebx
subl %ebp, %ebx
xorl $0x7, %ebp
testl %ecx, %ecx
cmovel %eax, %ebp
cmovel %r10d, %ebx
jmp 0x7fce2
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/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:
pushq %rbx
movq %rdi, %rbx
callq 0x80350
testl %eax, %eax
je 0x802d6
pushq $-0x2
popq %rax
jmp 0x8034e
movq 0x38(%rbx), %rax
andq $0x0, 0x28(%rax)
andq $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rbx)
movl 0x10(%rax), %ecx
testq %rcx, %rcx
je 0x802fa
andl $0x1, %ecx
movq %rcx, 0x60(%rbx)
movq $0x3f34, 0x8(%rax)      # imm = 0x3F34
movabsq $-0x100000000, %rcx     # imm = 0xFFFFFFFF00000000
movq %rcx, 0x14(%rax)
movl $0x8000, 0x1c(%rax)     # imm = 0x8000
andq $0x0, 0x30(%rax)
andq $0x0, 0x50(%rax)
andl $0x0, 0x58(%rax)
leaq 0x558(%rax), %rcx
movq %rcx, 0x90(%rax)
movq %rcx, 0x70(%rax)
movq %rcx, 0x68(%rax)
movabsq $-0xffffffff, %rcx      # imm = 0xFFFFFFFF00000001
movq %rcx, 0x1be8(%rax)
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq $0x1
popq %rax
testq %rdi, %rdi
je 0x80374
cmpq $0x0, 0x40(%rdi)
je 0x80374
cmpq $0x0, 0x48(%rdi)
je 0x80374
movq 0x38(%rdi), %rcx
testq %rcx, %rcx
je 0x80374
cmpq %rdi, (%rcx)
je 0x80375
retq
movl $0xffffc0ac, %edx       # imm = 0xFFFFC0AC
addl 0x8(%rcx), %edx
xorl %eax, %eax
cmpl $-0x20, %edx
setb %al
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbx
movq %rdi, %rbx
callq 0x80350
testl %eax, %eax
je 0x80398
pushq $-0x2
popq %rax
popq %rbx
retq
movq 0x38(%rbx), %rax
andq $0x0, 0x3c(%rax)
andl $0x0, 0x44(%rax)
movq %rbx, %rdi
popq %rbx
jmp 0x802c4
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x80350
testl %eax, %eax
je 0x803d1
pushq $-0x2
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x38(%rbx), %r14
testl %ebp, %ebp
js 0x803f1
movl %ebp, %r15d
shrl $0x4, %r15d
addl $0x5, %r15d
movl %ebp, %eax
andl $0xf, %eax
cmpl $0x30, %ebp
cmovbl %eax, %ebp
jmp 0x803fb
cmpl $-0xf, %ebp
jb 0x803c3
negl %ebp
xorl %r15d, %r15d
cmpl $0xf, %ebp
ja 0x803c3
movl $0xff01, %eax           # imm = 0xFF01
btl %ebp, %eax
jae 0x803c3
movq 0x48(%r14), %rsi
testq %rsi, %rsi
je 0x80425
cmpl %ebp, 0x38(%r14)
je 0x80425
movq 0x50(%rbx), %rdi
callq *0x48(%rbx)
andq $0x0, 0x48(%r14)
movl %r15d, 0x10(%r14)
movl %ebp, 0x38(%r14)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x80386
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
pushq $-0x6
popq %r14
testq %rdx, %rdx
je 0x804f2
cmpl $0x70, %ecx
jne 0x804f2
cmpb $0x31, (%rdx)
jne 0x804f2
movq %rdi, %rbx
testq %rdi, %rdi
je 0x804ea
movl %esi, %ebp
andq $0x0, 0x30(%rbx)
movq 0x40(%rbx), %rax
testq %rax, %rax
jne 0x8048d
leaq -0x1d3(%rip), %rax      # 0x802b1
movq %rax, 0x40(%rbx)
andq $0x0, 0x50(%rbx)
cmpq $0x0, 0x48(%rbx)
jne 0x8049f
leaq -0x1e0(%rip), %rcx      # 0x802bb
movq %rcx, 0x48(%rbx)
movq 0x50(%rbx), %rdi
pushq $0x1
popq %rsi
movl $0x1bf8, %edx           # imm = 0x1BF8
callq *%rax
testq %rax, %rax
je 0x804ee
movq %rax, %r15
movq %rax, 0x38(%rbx)
movq %rbx, (%rax)
andq $0x0, 0x48(%rax)
movl $0x3f34, 0x8(%rax)      # imm = 0x3F34
movq %rbx, %rdi
movl %ebp, %esi
callq 0x803ae
testl %eax, %eax
je 0x80500
movl %eax, %r14d
movq 0x50(%rbx), %rdi
movq %r15, %rsi
callq *0x48(%rbx)
andq $0x0, 0x38(%rbx)
jmp 0x804f2
pushq $-0x2
jmp 0x804f0
pushq $-0x4
popq %r14
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %r14d, %r14d
jmp 0x804f2
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movl %esi, %r14d
movq %rdi, %r15
callq 0x80350
movl %eax, %ecx
pushq $-0x2
popq %rax
testl %ecx, %ecx
jne 0x8056f
testl %r14d, %r14d
je 0x8056d
movq 0x38(%r15), %rsi
js 0x80564
cmpl $0x10, %r14d
ja 0x8056f
movl 0x58(%rsi), %edx
leal (%rdx,%r14), %edi
cmpl $0x20, %edi
ja 0x8056f
pushq $-0x1
popq %rax
movl %r14d, %ecx
shlq %cl, %rax
notl %eax
andl %ebx, %eax
movl %edx, %ecx
shll %cl, %eax
addq %rax, 0x50(%rsi)
movl %edi, 0x58(%rsi)
jmp 0x8056d
andq $0x0, 0x50(%rsi)
andl $0x0, 0x58(%rsi)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/external/zlib-1.3.0.1/inflate.c
// Function: updatewindow
local int updatewindow(z_streamp strm, const Bytef *end, unsigned copy) {
    struct inflate_state FAR *state;
    unsigned dist;

    state = (struct inflate_state FAR *)strm->state;

    /* if it hasn't been done already, allocate space for the window */
    if (state->window == Z_NULL) {
        state->window = (unsigned char FAR *)
                        ZALLOC(strm, 1U << state->wbits,
                               sizeof(unsigned char));
        if (state->window == Z_NULL) return 1;
    }

    /* if window not in use yet, initialize */
    if (state->wsize == 0) {
        state->wsize = 1U << state->wbits;
        state->wnext = 0;
        state->whave = 0;
    }

    /* copy state->wsize or less output bytes into the circular window */
    if (copy >= state->wsize) {
        zmemcpy(state->window, end - state->wsize, state->wsize);
        state->wnext = 0;
        state->whave = state->wsize;
    }
    else {
        dist = state->wsize - state->wnext;
        if (dist > copy) dist = copy;
        zmemcpy(state->window + state->wnext, end - copy, dist);
        copy -= dist;
        if (copy) {
            zmemcpy(state->window, end - copy, copy);
            state->wnext = copy;
            state->whave = state->wsize;
        }
        else {
            state->wnext += dist;
            if (state->wnext == state->wsize) state->wnext = 0;
            if (state->whave < state->wsize) state->whave += dist;
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rsi, %rbx
movq %rdi, %rax
movq 0x38(%rdi), %r12
movq 0x48(%r12), %rdi
pushq $0x1
popq %rbp
testq %rdi, %rdi
jne 0x82194
movq 0x50(%rax), %rdi
movb 0x38(%r12), %cl
movl %ebp, %esi
shll %cl, %esi
movl %ebp, %edx
callq *0x40(%rax)
movq %rax, %rdi
movq %rax, 0x48(%r12)
testq %rax, %rax
je 0x82220
movl 0x3c(%r12), %r13d
testl %r13d, %r13d
jne 0x821b3
movb 0x38(%r12), %cl
shll %cl, %ebp
movl %ebp, 0x3c(%r12)
andq $0x0, 0x40(%r12)
movl %ebp, %r13d
cmpl %r14d, %r13d
jbe 0x82200
movl 0x44(%r12), %eax
subl %eax, %r13d
cmpl %r14d, %r13d
movl %r14d, %r15d
cmovbl %r13d, %r15d
addq %rax, %rdi
movl %r14d, %eax
movq %rbx, %rsi
subq %rax, %rsi
movq %r15, %rdx
callq 0xb520
cmpl %r14d, %r13d
jae 0x82231
subl %r15d, %r14d
movq 0x48(%r12), %rdi
subq %r14, %rbx
movq %rbx, %rsi
movq %r14, %rdx
callq 0xb520
movl %r14d, 0x44(%r12)
jmp 0x82214
movl %r13d, %edx
subq %rdx, %rbx
movq %rbx, %rsi
callq 0xb520
andl $0x0, 0x44(%r12)
movl 0x3c(%r12), %eax
movl %eax, 0x40(%r12)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl 0x44(%r12), %ecx
addl %r15d, %ecx
movl 0x3c(%r12), %edx
movl 0x40(%r12), %eax
xorl %ebp, %ebp
cmpl %edx, %ecx
cmovel %ebp, %ecx
movl %ecx, 0x44(%r12)
cmpl %edx, %eax
jae 0x82220
addl %r15d, %eax
movl %eax, 0x40(%r12)
jmp 0x82220
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbx
movq %rdi, %rbx
callq 0x80350
testl %eax, %eax
je 0x8226f
pushq $-0x2
popq %rax
jmp 0x82298
movq 0x38(%rbx), %rsi
movq 0x48(%rsi), %rax
testq %rax, %rax
je 0x8228a
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
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x80350
testl %eax, %eax
je 0x822b6
pushq $-0x2
popq %rax
jmp 0x82303
movq 0x38(%r15), %r15
movl 0x40(%r15), %edx
testl %edx, %edx
sete %al
testq %r14, %r14
sete %cl
orb %al, %cl
jne 0x822f6
movl 0x44(%r15), %esi
subl %esi, %edx
addq 0x48(%r15), %rsi
movq %r14, %rdi
callq 0xb520
movl 0x40(%r15), %edi
movl 0x44(%r15), %edx
addq %r14, %rdi
subq %rdx, %rdi
movq 0x48(%r15), %rsi
callq 0xb520
xorl %eax, %eax
testq %rbx, %rbx
je 0x82303
movl 0x40(%r15), %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/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
callq 0x80350
movl %eax, %ecx
pushq $-0x2
popq %rax
testl %ecx, %ecx
jne 0x823a6
movq 0x38(%r15), %r12
cmpl $0x0, 0x10(%r12)
movl 0x8(%r12), %ecx
je 0x82348
cmpl $0x3f3e, %ecx           # imm = 0x3F3E
jne 0x823a6
leaq 0x8(%r12), %r13
jmp 0x82355
leaq 0x8(%r12), %r13
cmpl $0x3f3e, %ecx           # imm = 0x3F3E
jne 0x82374
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x9a764
movq %rax, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x9a764
cmpq 0x20(%r12), %rax
jne 0x82396
movl %ebx, %eax
addq %rax, %r14
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x8214c
testl %eax, %eax
je 0x8239b
movl $0x3f52, (%r13)         # imm = 0x3F52
pushq $-0x4
jmp 0x82398
pushq $-0x3
popq %rax
jmp 0x823a6
movl $0x1, 0x14(%r12)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x80350
movl %eax, %ecx
pushq $-0x2
popq %rax
testl %ecx, %ecx
jne 0x823dc
movq 0x38(%r14), %rcx
testb $0x2, 0x10(%rcx)
je 0x823dc
movq %rbx, 0x30(%rcx)
andl $0x0, 0x48(%rbx)
xorl %eax, %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/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:
pushq %rbx
movl (%rdi), %ecx
movl %edx, %edx
xorl %r8d, %r8d
movl $0x4, %r9d
xorl %eax, %eax
cmpq %rdx, %rax
jae 0x82543
cmpl $0x3, %ecx
ja 0x82543
movzbl (%rsi,%rax), %r10d
cmpl $0x2, %ecx
movl $0xff, %r11d
cmovbl %r8d, %r11d
movl %r9d, %ebx
subl %ecx, %ebx
incl %ecx
testl %r10d, %r10d
cmovnel %r8d, %ebx
cmpl %r10d, %r11d
cmovnel %ebx, %ecx
incq %rax
jmp 0x8250e
movl %ecx, (%rdi)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbx
movq %rdi, %rbx
callq 0x80350
testl %eax, %eax
je 0x82559
pushq $-0x2
popq %rax
jmp 0x82571
movq 0x38(%rbx), %rcx
xorl %eax, %eax
cmpl $0x3f41, 0x8(%rcx)      # imm = 0x3F41
jne 0x82571
xorl %eax, %eax
cmpl $0x0, 0x58(%rcx)
sete %al
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbx
movq %rdi, %rbx
callq 0x80350
testl %eax, %eax
je 0x826cd
pushq $-0x2
jmp 0x826dd
movq 0x38(%rbx), %rax
movl $0x1, 0x1be8(%rax)
pushq $-0x3
popq %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x80350
testl %eax, %eax
je 0x826f7
pushq $-0x2
popq %rax
jmp 0x82717
movq 0x38(%r14), %rax
movl 0x10(%rax), %ecx
testl %ebx, %ebx
je 0x8270b
testl %ecx, %ecx
je 0x82710
orl $0x4, %ecx
jmp 0x82712
andl $-0x5, %ecx
jmp 0x82712
xorl %ecx, %ecx
movl %ecx, 0x10(%rax)
xorl %eax, %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/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:
pushq %rbx
movq %rdi, %rbx
callq 0x80350
movl %eax, %ecx
movq $-0x10000, %rax         # imm = 0xFFFF0000
testl %ecx, %ecx
jne 0x8276c
movq 0x38(%rbx), %rcx
movslq 0x1bec(%rcx), %rax
shlq $0x10, %rax
movl 0x8(%rcx), %esi
cmpl $0x3f4c, %esi           # imm = 0x3F4C
je 0x8275e
xorl %edx, %edx
cmpl $0x3f43, %esi           # imm = 0x3F43
jne 0x82767
movl 0x5c(%rcx), %edx
jmp 0x82767
movl 0x1bf0(%rcx), %edx
subl 0x5c(%rcx), %edx
movl %edx, %ecx
addq %rcx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbx
movq %rdi, %rbx
callq 0x80350
testl %eax, %eax
je 0x82780
pushq $-0x1
popq %rax
jmp 0x82798
movq 0x38(%rbx), %rcx
movq 0x90(%rcx), %rax
subq %rcx, %rax
addq $-0x558, %rax           # imm = 0xFAA8
sarq $0x2, %rax
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x830bc
movq %r9, %r15
movq %r8, %rbx
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %rbp
pushq $0x30
popq %rdi
callq 0x4f148
movq %rbp, (%rax)
movq %r13, 0x8(%rax)
movq %r15, 0x28(%rax)
movq %r12, 0x18(%rax)
movq %rbx, 0x20(%rax)
movq %r14, 0x10(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xaaef5(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x46f99(%rip), %rsi     # 0xca066
leaq 0x56721(%rip), %rdx     # 0xd97f5
leaq 0x600e5(%rip), %rcx     # 0xe31c0
leaq 0x600fa(%rip), %r8      # 0xe31dc
pushq $0x2b
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x8314e
movq %rdi, %rbx
movq (%rdi), %rsi
testq %rsi, %rsi
je 0x8314e
leaq 0x600cb(%rip), %r14     # 0xe31dc
pushq $0x1
popq %r15
pushq $0x3a
popq %rcx
movq %r15, %rdi
movq %r14, %rdx
callq 0xce9a
movq %rax, %r12
movq %rbx, (%rax)
pushq $0x20
popq %rsi
pushq $0x3c
popq %rcx
movq %r15, %rdi
movq %r14, %rdx
callq 0xce9a
movq %rax, 0x8(%r12)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0xaae63(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x46f07(%rip), %rsi     # 0xca066
leaq 0x60090(%rip), %rdx     # 0xe31f6
leaq 0x6009a(%rip), %rcx     # 0xe3207
leaq 0x60068(%rip), %r8      # 0xe31dc
pushq $0x39
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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:
testq %rdi, %rdi
je 0x83234
movq (%rdi), %rax
testq %rax, %rax
je 0x83234
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x83231
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
movq 0xaad7c(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x46e20(%rip), %rsi     # 0xca066
leaq 0x6002f(%rip), %rdx     # 0xe327c
leaq 0x6003a(%rip), %rcx     # 0xe328e
leaq 0x5ff81(%rip), %r8      # 0xe31dc
pushq $0x52
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/codon_iterator.c
// Function: gt_codon_iterator_length
GtUword gt_codon_iterator_length(GtCodonIterator *ci)
{
  gt_assert(ci && ci->c_class);
  if (ci->c_class->current_pos)
    return ci->c_class->length(ci);
  return 0;
}

// Assembly:
testq %rdi, %rdi
je 0x83285
movq (%rdi), %rax
testq %rax, %rax
je 0x83285
cmpq $0x0, 0x10(%rax)
je 0x83282
jmpq *0x18(%rax)
xorl %eax, %eax
retq
pushq %rax
movq 0xaad2b(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x46dcf(%rip), %rsi     # 0xca066
leaq 0x5ffde(%rip), %rdx     # 0xe327c
leaq 0x6000c(%rip), %rcx     # 0xe32b1
leaq 0x5ff30(%rip), %r8      # 0xe31dc
pushq $0x5a
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/codon_iterator.c
// Function: gt_codon_iterator_next
GtCodonIteratorStatus gt_codon_iterator_next(GtCodonIterator *ci,
                                             char *n1, char *n2, char *n3,
                                             unsigned int *frame,
                                             GtError *err)
{
  gt_assert(ci && ci->c_class);
  if (ci->c_class->current_pos)
    return ci->c_class->next(ci, n1, n2, n3, frame, err);
  return 0;
}

// Assembly:
testq %rdi, %rdi
je 0x83329
movq (%rdi), %rax
testq %rax, %rax
je 0x83329
cmpq $0x0, 0x10(%rax)
je 0x83326
movq 0x28(%rax), %rax
jmpq *%rax
xorl %eax, %eax
retq
pushq %rax
movq 0xaac87(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x46d2b(%rip), %rsi     # 0xca066
leaq 0x5ff3a(%rip), %rdx     # 0xe327c
leaq 0x5ff9a(%rip), %rcx     # 0xe32e3
leaq 0x5fe8c(%rip), %r8      # 0xe31dc
pushq $0x6c
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/codon_iterator.c
// Function: gt_codon_iterator_delete
void gt_codon_iterator_delete(GtCodonIterator *ci)
{
  if (!ci) return;
  gt_assert(ci->c_class);
  if (ci->c_class->free)
    ci->c_class->free(ci);
  gt_free(ci->pvt);
  gt_free(ci);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x833ad
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x833b5
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x83382
movq %rbx, %rdi
callq *%rax
movq 0x8(%rbx), %rdi
leaq 0x5fe4f(%rip), %r14     # 0xe31dc
pushq $0x78
popq %rdx
movq %r14, %rsi
callq 0xd249
pushq $0x79
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd249
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0xaabfc(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x46ca0(%rip), %rsi     # 0xca066
leaq 0x5feb5(%rip), %rdx     # 0xe3282
leaq 0x5ff26(%rip), %rcx     # 0xe32fa
leaq 0x5fe01(%rip), %r8      # 0xe31dc
pushq $0x75
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
nop
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/codon_iterator_simple.c
// Function: gt_codon_iterator_simple_class
const GtCodonIteratorClass* gt_codon_iterator_simple_class(void)
{
  static const GtCodonIteratorClass *cic = NULL;
  gt_class_alloc_lock_enter();
  if (!cic)
  {
    cic = gt_codon_iterator_class_new(sizeof (GtCodonIteratorSimple),
                                      NULL,
                                      gt_codon_iterator_simple_current_position,
                                      gt_codon_iterator_simple_length,
                                      gt_codon_iterator_simple_rewind,
                                      gt_codon_iterator_simple_next);
  }
  gt_class_alloc_lock_leave();
  return cic;
}

// Assembly:
pushq %rax
callq 0x4f21f
cmpq $0x0, 0xac956(%rip)     # 0x12fd50
jne 0x83429
leaq 0x34(%rip), %rdx        # 0x83437
leaq 0x72(%rip), %rcx        # 0x8347c
leaq 0xaf(%rip), %r8         # 0x834c0
leaq 0xb5(%rip), %r9         # 0x834cd
pushq $0x18
popq %rdi
xorl %esi, %esi
callq 0x8306c
movq %rax, 0xac927(%rip)     # 0x12fd50
callq 0x4f266
movq 0xac91b(%rip), %rax     # 0x12fd50
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/codon_iterator_simple.c
// Function: gt_codon_iterator_simple_next
static GtCodonIteratorStatus gt_codon_iterator_simple_next(GtCodonIterator *ci,
                                                           char *n1,
                                                           char *n2,
                                                           char *n3,
                                                           unsigned int *frame,
                                                           GT_UNUSED GtError
                                                                           *err)
{
  GtCodonIteratorSimple *cis;
  gt_assert(n1 && n2 && n3 && frame);
  gt_error_check(err);
  if (ci->pvt->curpos+2 >= ci->pvt->length)
    return GT_CODON_ITERATOR_END;
  cis = gt_codon_iterator_simple_cast(ci);
  *n1 = *(cis->dnaseq+ci->pvt->curpos);
  *n2 = *(cis->dnaseq+ci->pvt->curpos+1);
  *n3 = *(cis->dnaseq+ci->pvt->curpos+2);
  *frame = ci->pvt->curpos % GT_CODON_LENGTH;
  ci->pvt->curpos++;
  return GT_CODON_ITERATOR_OK;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %xmm0
movq %rsi, %xmm1
punpcklqdq %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0]
movq %r8, %xmm0
movq %rcx, %xmm2
punpcklqdq %xmm0, %xmm2    # xmm2 = xmm2[0],xmm0[0]
pxor %xmm0, %xmm0
pcmpeqd %xmm0, %xmm2
pcmpeqd %xmm0, %xmm1
movdqa %xmm1, %xmm0
shufps $0xdd, %xmm2, %xmm0     # xmm0 = xmm0[1,3],xmm2[1,3]
shufps $0x88, %xmm2, %xmm1     # xmm1 = xmm1[0,2],xmm2[0,2]
andps %xmm0, %xmm1
movmskps %xmm1, %eax
testl %eax, %eax
jne 0x835c7
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r15
testq %r9, %r9
je 0x8353c
movq %r9, %rdi
callq 0xc103
testb %al, %al
jne 0x835f1
movq 0x8(%r15), %rax
movq 0x8(%rax), %rcx
addq $0x2, %rcx
cmpq (%rax), %rcx
jae 0x835b8
callq 0x833ec
movq %rax, %rdi
movq %r15, %rsi
callq 0x83184
movq 0x10(%rax), %rcx
movq 0x8(%r15), %rdx
movq 0x8(%rdx), %rdx
movb (%rcx,%rdx), %cl
movb %cl, (%r13)
movq 0x10(%rax), %rcx
movq 0x8(%r15), %rdx
movq 0x8(%rdx), %rdx
movb 0x1(%rcx,%rdx), %cl
movb %cl, (%r12)
movq 0x10(%rax), %rax
movq 0x8(%r15), %rcx
movq 0x8(%rcx), %rcx
movb 0x2(%rax,%rcx), %al
movb %al, (%r14)
movq 0x8(%r15), %rdi
movq 0x8(%rdi), %rsi
xorl %ecx, %ecx
pushq $0x3
popq %r8
movq %rsi, %rax
xorl %edx, %edx
divq %r8
movl %edx, (%rbx)
incq %rsi
movq %rsi, 0x8(%rdi)
jmp 0x835bb
pushq $-0x1
popq %rcx
movl %ecx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0xaa9ea(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x46a8e(%rip), %rsi     # 0xca066
leaq 0x5fe5a(%rip), %rdx     # 0xe3439
leaq 0x5fe6b(%rip), %rcx     # 0xe3451
leaq 0x5fd64(%rip), %r8      # 0xe3351
pushq $0x2b
jmp 0x83619
movq 0xaa9c0(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x46a64(%rip), %rsi     # 0xca066
leaq 0x47050(%rip), %rdx     # 0xca659
leaq 0x5fe41(%rip), %rcx     # 0xe3451
leaq 0x5fd3a(%rip), %r8      # 0xe3351
pushq $0x2c
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/codon_iterator_simple.c
// Function: gt_codon_iterator_simple_new
GtCodonIterator* gt_codon_iterator_simple_new(const char *seq,
                                              GtUword length,
                                              GT_UNUSED GtError *err)
{
  GtCodonIteratorSimple *cis;
  GtCodonIterator *ci;
  gt_assert(seq && length >= GT_CODON_LENGTH);
  gt_error_check(err);
  ci = gt_codon_iterator_create(gt_codon_iterator_simple_class());
  cis = gt_codon_iterator_simple_cast(ci);
  cis->dnaseq = seq;
  ci->pvt->length = length;
  ci->pvt->curpos = 0;
  ci->pvt->startpos = 0;
  return ci;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x83689
movq %rsi, %rbx
cmpq $0x2, %rsi
jbe 0x83689
movq %rdi, %r14
testq %rdx, %rdx
je 0x8364e
movq %rdx, %rdi
callq 0xc103
testb %al, %al
jne 0x836b3
callq 0x833ec
movq %rax, %rdi
callq 0x830f2
movq %rax, %r15
callq 0x833ec
movq %rax, %rdi
movq %r15, %rsi
callq 0x83184
movq %r14, 0x10(%rax)
movq 0x8(%r15), %rax
movq %rbx, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0xaa928(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x469cc(%rip), %rsi     # 0xca066
leaq 0x5fc72(%rip), %rdx     # 0xe3313
leaq 0x5fc8c(%rip), %rcx     # 0xe3334
leaq 0x5fca2(%rip), %r8      # 0xe3351
pushq $0x61
jmp 0x836db
movq 0xaa8fe(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x469a2(%rip), %rsi     # 0xca066
leaq 0x46f8e(%rip), %rdx     # 0xca659
leaq 0x5fc62(%rip), %rcx     # 0xe3334
leaq 0x5fc78(%rip), %r8      # 0xe3351
pushq $0x62
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/codon_iterator_simple.c
// Function: gt_codon_iterator_simple_unit_test
int gt_codon_iterator_simple_unit_test(GtError *err)
{
  int had_err = 0,
      i;
  const char *testseq = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
  GtCodonIterator *ci;
  char n1, n2, n3;
  unsigned int frame;
  gt_error_check(err);

  ci = gt_codon_iterator_simple_new(testseq, 26, NULL);
  i = 0;
  while (!gt_codon_iterator_next(ci, &n1, &n2, &n3, &frame, NULL)) {
    gt_ensure(n1 == testseq[i]);
    gt_ensure(n2 == testseq[i+1]);
    gt_ensure(n3 == testseq[i+2]);
    i++;
  }
  gt_ensure(i == 24);
  gt_codon_iterator_delete(ci);
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
testq %rdi, %rdi
je 0x8370f
movq %rbx, %rdi
callq 0xc103
testb %al, %al
jne 0x83872
movq %rbx, 0x8(%rsp)
leaq 0x5fc57(%rip), %rdi     # 0xe3372
pushq $0x1a
popq %rsi
xorl %edx, %edx
callq 0x83627
movq %rax, %r14
pushq $0x2
popq %r12
leaq 0x5(%rsp), %rbp
leaq 0x14(%rsp), %rbx
pushq $-0x1
popq %r13
xorl %r15d, %r15d
movq %r14, %rdi
leaq 0x7(%rsp), %rsi
leaq 0x6(%rsp), %rdx
movq %rbp, %rcx
movq %rbx, %r8
xorl %r9d, %r9d
callq 0x8330c
testl %eax, %eax
jne 0x83817
testl %r15d, %r15d
movl %r13d, %r15d
jne 0x8380f
movb 0x7(%rsp), %al
leaq 0x5fbfb(%rip), %rcx     # 0xe3372
cmpb -0x2(%r12,%rcx), %al
jne 0x837bb
movb 0x6(%rsp), %al
cmpb -0x1(%r12,%rcx), %al
jne 0x837e0
movb 0x5(%rsp), %al
xorl %r15d, %r15d
cmpb (%r12,%rcx), %al
je 0x8380f
movq 0x8(%rsp), %rdi
leaq 0x489b7(%rip), %rsi     # 0xcc159
leaq 0x5fc2b(%rip), %rdx     # 0xe33d4
leaq 0x5fbdd(%rip), %rcx     # 0xe338d
leaq 0x5fb9a(%rip), %r8      # 0xe3351
pushq $0x7b
jmp 0x83803
movq 0x8(%rsp), %rdi
leaq 0x48992(%rip), %rsi     # 0xcc159
leaq 0x5fbe2(%rip), %rdx     # 0xe33b0
leaq 0x5fbb8(%rip), %rcx     # 0xe338d
leaq 0x5fb75(%rip), %r8      # 0xe3351
pushq $0x79
jmp 0x83803
movq 0x8(%rsp), %rdi
leaq 0x4896d(%rip), %rsi     # 0xcc159
leaq 0x5fbce(%rip), %rdx     # 0xe33c1
leaq 0x5fb93(%rip), %rcx     # 0xe338d
leaq 0x5fb50(%rip), %r8      # 0xe3351
pushq $0x7a
popq %r9
xorl %eax, %eax
callq 0xc007
movl %r13d, %r15d
incq %r12
jmp 0x8373d
testl %r15d, %r15d
setne %al
cmpq $0x1a, %r12
sete %cl
orb %al, %cl
jne 0x83858
leaq 0x4892a(%rip), %rsi     # 0xcc159
leaq 0x5fbb1(%rip), %rdx     # 0xe33e7
leaq 0x5fb50(%rip), %rcx     # 0xe338d
leaq 0x5fb0d(%rip), %r8      # 0xe3351
pushq $0x7e
popq %r9
movq 0x8(%rsp), %rdi
xorl %eax, %eax
callq 0xc007
pushq $-0x1
popq %r15
movq %r14, %rdi
callq 0x83360
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xaa73f(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x467e3(%rip), %rsi     # 0xca066
leaq 0x46dcf(%rip), %rdx     # 0xca659
leaq 0x5fafc(%rip), %rcx     # 0xe338d
leaq 0x5fab9(%rip), %r8      # 0xe3351
pushq $0x74
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/desc_buffer.c
// Function: gt_desc_buffer_new
GtDescBuffer* gt_desc_buffer_new(void)
{
  GtDescBuffer *db = gt_malloc(sizeof *db);
  db->buf = gt_calloc(GT_DESC_BUFFER_INIT_SIZE, sizeof (char));
  db->length = 0;
  db->maxlength = db->curlength = 0;
  db->allocated = GT_DESC_BUFFER_INIT_SIZE;
  db->finished = false;
  db->dirty = true;
  db->shorten = false;
  db->seen_whitespace = false;
  db->reference_count = 0;
  db->startqueue = gt_queue_new();
  gt_queue_add(db->startqueue, (void*) 0);
  return db;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x5fbac(%rip), %rbx     # 0xe346f
pushq $0x40
popq %rdi
pushq $0x30
popq %rdx
movq %rbx, %rsi
callq 0xccb0
movq %rax, %r14
pushq $0x1
popq %rsi
pushq $0x31
popq %rcx
movl $0x2000, %edi           # imm = 0x2000
movq %rbx, %rdx
callq 0xce9a
movq %rax, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r14)
andq $0x0, 0x18(%r14)
movq $0x2000, 0x20(%r14)     # imm = 0x2000
movl $0x100, 0x28(%r14)      # imm = 0x100
andl $0x0, 0x38(%r14)
callq 0x5b040
movq %rax, 0x30(%r14)
movq %rax, %rdi
xorl %esi, %esi
callq 0x5b055
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/desc_buffer.c
// Function: gt_desc_buffer_append_char
void gt_desc_buffer_append_char(GtDescBuffer *db, char c)
{
  gt_assert(db);
  if (db->shorten) {
    if (db->seen_whitespace)
      return;
    if (isspace(c)) {
      db->seen_whitespace = true;
      return;
    }
  }
  if (db->finished) {
    gt_queue_add(db->startqueue, (void*) (db->length));
    db->finished = false;
  }
  if (db->length + 2 > db->allocated) {
    db->buf = gt_dynalloc(db->buf, &db->allocated,
                          (db->length + 2) * sizeof (char));
  }
  db->curlength++;
  db->buf[db->length++] = c;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x839f8
movl %esi, %ebx
movq %rdi, %r14
cmpb $0x1, 0x2a(%rdi)
jne 0x8399d
cmpb $0x0, 0x2b(%r14)
jne 0x839e9
callq 0xb6e0
movq (%rax), %rax
movsbq %bl, %rcx
testb $0x20, 0x1(%rax,%rcx,2)
jne 0x839f1
cmpb $0x1, 0x28(%r14)
jne 0x839b6
movq 0x8(%r14), %rsi
movq 0x30(%r14), %rdi
callq 0x5b055
movb $0x0, 0x28(%r14)
movq (%r14), %rax
movq 0x8(%r14), %rcx
leaq 0x2(%rcx), %rdx
cmpq 0x20(%r14), %rdx
jbe 0x839da
leaq 0x20(%r14), %rsi
movq %rax, %rdi
callq 0x516a0
movq %rax, (%r14)
movq 0x8(%r14), %rcx
incq 0x18(%r14)
leaq 0x1(%rcx), %rdx
movq %rdx, 0x8(%r14)
movb %bl, (%rax,%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movb $0x1, 0x2b(%r14)
jmp 0x839e9
movq 0xaa5b9(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x4665d(%rip), %rsi     # 0xca066
leaq 0x5885a(%rip), %rdx     # 0xdc26a
leaq 0x5fa95(%rip), %rcx     # 0xe34ac
leaq 0x5fa51(%rip), %r8      # 0xe346f
pushq $0x47
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/desc_buffer.c
// Function: gt_desc_buffer_get_next
const char* gt_desc_buffer_get_next(GtDescBuffer *db)
{
  gt_assert(db);
  GtUword startpos = (GtUword) gt_queue_get(db->startqueue);
  db->dirty = true;
  return db->buf + startpos;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x83a49
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
callq 0x5b195
movb $0x1, 0x29(%rbx)
addq (%rbx), %rax
popq %rbx
retq
movq 0xaa568(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x4660c(%rip), %rsi     # 0xca066
leaq 0x58809(%rip), %rdx     # 0xdc26a
leaq 0x5fa5f(%rip), %rcx     # 0xe34c7
leaq 0x5fa00(%rip), %r8      # 0xe346f
pushq $0x5e
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/desc_buffer.c
// Function: gt_desc_buffer_finish
void gt_desc_buffer_finish(GtDescBuffer *db)
{
  gt_assert(db);
  db->seen_whitespace = false;
  /* XXX: maybe do a gt_cstr_rtrim(..., ' ') equivalent? */
  gt_desc_buffer_append_char(db, '\0');
  if (db->curlength > db->maxlength)
    db->maxlength = db->curlength;
  db->curlength = 0;
  db->finished = true;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x83aac
movq %rdi, %rbx
movb $0x0, 0x2b(%rdi)
xorl %esi, %esi
callq 0x8396b
movq 0x18(%rbx), %rax
cmpq 0x10(%rbx), %rax
jbe 0x83aa1
movq %rax, 0x10(%rbx)
andq $0x0, 0x18(%rbx)
movb $0x1, 0x28(%rbx)
popq %rbx
retq
movq 0xaa505(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x465a9(%rip), %rsi     # 0xca066
leaq 0x587a6(%rip), %rdx     # 0xdc26a
leaq 0x5fa14(%rip), %rcx     # 0xe34df
leaq 0x5f99d(%rip), %r8      # 0xe346f
pushq $0x66
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300