LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/gff3_linesorted_out_stream.c
// Function: gff3_linesorted_out_stream_free
static void gff3_linesorted_out_stream_free(GtNodeStream *ns)
{
  GtUword i;
  GtGFF3LinesortedOutStream *lsos;
  if (!ns) return;
  lsos = gt_gff3_linesorted_out_stream_cast(ns);
  for (i = 0; i < gt_array_size(lsos->cur_node_set); i++) {
    gt_genome_node_delete(*(GtGenomeNode**)
                                           gt_array_get(lsos->cur_node_set, i));
  }
  gt_node_stream_delete(lsos->in_stream);
  gt_str_delete(lsos->buf);
  gt_str_delete(lsos->last_seqid);
  gt_node_visitor_delete(lsos->gff3vis);
  gt_splitter_delete(lsos->splitter);
  gt_array_delete(lsos->cur_node_set);
}

// Assembly:
testq %rdi, %rdi
je 0x146667
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x146594
movq %rax, %rdi
movq %rbx, %rsi
callq 0x162ff7
movq %rax, %rbx
movq 0x18(%rax), %rdi
callq 0xd24e0
testq %rax, %rax
je 0x14662a
xorl %r14d, %r14d
movq 0x18(%rbx), %rdi
movq %r14, %rsi
callq 0xd2207
movq (%rax), %rdi
callq 0x1451a0
incq %r14
movq 0x18(%rbx), %rdi
callq 0xd24e0
cmpq %rax, %r14
jb 0x146605
movq 0x10(%rbx), %rdi
callq 0x162dee
movq 0x28(%rbx), %rdi
callq 0x11bdbf
movq 0x40(%rbx), %rdi
callq 0x11bdbf
movq 0x38(%rbx), %rdi
callq 0x1632f2
movq 0x30(%rbx), %rdi
callq 0x1196c0
movq 0x18(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd2938
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/gff3_linesorted_out_stream.c
// Function: gt_gff3_linesorted_out_stream_new
GtNodeStream* gt_gff3_linesorted_out_stream_new(GtNodeStream *in_stream,
                                                GtFile *outfp)
{
  GtGFF3LinesortedOutStream *lsos;
  GtNodeStream *ns;
  gt_assert(in_stream);
  ns = gt_node_stream_create(gt_gff3_linesorted_out_stream_class(), true);
  lsos = gt_gff3_linesorted_out_stream_cast(ns);
  lsos->cur_node_set = gt_array_new(sizeof (GtFeatureNode*));
  lsos->in_stream = gt_node_stream_ref(in_stream);
  lsos->outfp = outfp;
  lsos->outstrings = NULL;
  lsos->outstrings_length = 0;
  lsos->last_seqid = NULL;
  lsos->splitter = gt_splitter_new();
  lsos->buf = gt_str_new();
  lsos->gff3vis = gt_gff3_visitor_new_to_str(lsos->buf);
  return ns;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1468ac
movq %rsi, %r14
movq %rdi, %r15
callq 0x146594
movq %rax, %rdi
movl $0x1, %esi
callq 0x162d6c
movq %rax, %rbx
callq 0x146594
movq %rax, %rdi
movq %rbx, %rsi
callq 0x162ff7
movq %rax, %r12
movl $0x8, %edi
callq 0xd214c
movq %rax, 0x18(%r12)
movq %r15, %rdi
callq 0x162dd8
movq %rax, 0x10(%r12)
movq %r14, 0x20(%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%r12)
movq $0x0, 0x50(%r12)
callq 0x119478
movq %rax, 0x30(%r12)
callq 0x11ac6c
movq %rax, 0x28(%r12)
movq %rax, %rdi
callq 0x14bb9e
movq %rax, 0x38(%r12)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x4481d
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/gff3_linesorted_out_stream.c
// Function: gt_linesorted_gff3_next_token_pair
static inline void gt_linesorted_gff3_next_token_pair(const char **s1,
                                                      const char **s2,
                                                      char *buf1, size_t len1,
                                                      char *buf2, size_t len2,
                                                      char sep)
{
  const char *tokend1, *tokend2;
  size_t idlength1, idlength2;

  tokend1 = strchr(*s1, sep);
  gt_assert(tokend1 && tokend1 > *s1);
  tokend2 = strchr(*s2, sep);
  gt_assert(tokend2 && tokend2 > *s2);
  idlength1 = GT_MIN((tokend1 - *s1), len1 - 1);
  gt_assert(idlength1 > 0);
  idlength2 = GT_MIN((tokend2 - *s2), len2 - 1);
  gt_assert(idlength2 > 0);
  (void) strncpy(buf1, *s1, idlength1);
  (void) strncpy(buf2, *s2, idlength2);
  buf1[idlength1] = '\0';
  buf2[idlength2] = '\0';
  *s1 = tokend1 + 1;
  *s2 = tokend2 + 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, %r14
movq %rdi, 0x20(%rsp)
movq (%rdi), %r15
movq %r15, %rdi
movl $0x9, %esi
callq 0x17280
movq %rax, %r13
subq %r15, %r13
jbe 0x146cab
movq %rax, %rbx
movq %r15, 0x8(%rsp)
movq %r14, (%rsp)
movq (%r14), %r12
movq %r12, %rdi
movl $0x9, %esi
callq 0x17280
movq %rax, %rbp
subq %r12, %rbp
jbe 0x146cb0
movq %rax, %r14
movl $0x1fff, %r12d          # imm = 0x1FFF
cmpq %r12, %rbp
cmovaeq %r12, %rbp
cmpq %r12, %r13
cmovbq %r13, %r12
movq 0x10(%rsp), %r15
movq %r15, %rdi
movq 0x8(%rsp), %rsi
movq %r12, %rdx
callq 0x17370
movq (%rsp), %rax
movq (%rax), %rsi
movq 0x18(%rsp), %r13
movq %r13, %rdi
movq %rbp, %rdx
callq 0x17370
xorl %eax, %eax
movb %al, (%r15,%r12)
movb %al, (%r13,%rbp)
incq %rbx
movq 0x20(%rsp), %rax
movq %rbx, (%rax)
incq %r14
movq (%rsp), %rax
movq %r14, (%rax)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x449e1
callq 0x44a18
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/gff3_numsorted_out_stream.c
// Function: gt_gff3_numsorted_out_stream_class
const GtNodeStreamClass* gt_gff3_numsorted_out_stream_class(void)
{
  static const GtNodeStreamClass *nsc = NULL;
  gt_class_alloc_lock_enter();
  if (!nsc) {
    nsc = gt_node_stream_class_new(sizeof (GtGFF3NumsortedOutStream),
                                   gff3_numsorted_out_stream_free,
                                   gff3_numsorted_out_stream_next);
  }
  gt_class_alloc_lock_leave();
  return nsc;
}

// Assembly:
pushq %rax
callq 0xe252f
cmpq $0x0, 0x377a8a(%rip)    # 0x4be750
jne 0x146ce7
leaq 0x26(%rip), %rsi        # 0x146cf5
leaq 0x5b(%rip), %rdx        # 0x146d31
movl $0x30, %edi
callq 0x162d34
movq %rax, 0x377a69(%rip)    # 0x4be750
callq 0xe2545
movq 0x377a5d(%rip), %rax    # 0x4be750
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/gff3_numsorted_out_stream.c
// Function: gff3_numsorted_out_stream_free
static void gff3_numsorted_out_stream_free(GtNodeStream *ns)
{
  GtGFF3NumsortedOutStream *gff3_out_stream =
                                             gff3_numsorted_out_stream_cast(ns);
  gt_node_stream_delete(gff3_out_stream->in_stream);
  gt_node_visitor_delete(gff3_out_stream->gff3_visitor);
  gt_array_delete(gff3_out_stream->buffer);
  gt_queue_delete(gff3_out_stream->outqueue);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x146cb8
movq %rax, %rdi
movq %rbx, %rsi
callq 0x162ff7
movq %rax, %rbx
movq 0x10(%rax), %rdi
callq 0x162dee
movq 0x28(%rbx), %rdi
callq 0x1632f2
movq 0x18(%rbx), %rdi
callq 0xd2938
movq 0x20(%rbx), %rdi
popq %rbx
jmp 0x10dc23
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/gff3_numsorted_out_stream.c
// Function: gff3_numsorted_out_stream_next
static int gff3_numsorted_out_stream_next(GtNodeStream *ns, GtGenomeNode **gn,
                                           GtError *err)
{
  GtGFF3NumsortedOutStream *gff3_out_stream;
  int had_err = 0;
  GtUword i = 0;
  gt_error_check(err);
  gff3_out_stream = gff3_numsorted_out_stream_cast(ns);
  if (!gff3_out_stream->outqueue) {
    gff3_out_stream->outqueue = gt_queue_new();
    while (!(had_err =
                    gt_node_stream_next(gff3_out_stream->in_stream, gn, err))) {
      if (!*gn) break;
      gt_array_add(gff3_out_stream->buffer, *gn);
    }
    if (!had_err) {
      gt_genome_nodes_sort_stable_with_func(gff3_out_stream->buffer,
                             (GtCompare) gt_genome_node_compare_numeric_seqids);
      for (i = 0; !had_err && i < gt_array_size(gff3_out_stream->buffer); i++) {
        GtGenomeNode *mygn = *(GtGenomeNode**)
                                       gt_array_get(gff3_out_stream->buffer, i);
        gt_queue_add(gff3_out_stream->outqueue, mygn);
      }
    }
  }
  if (gff3_out_stream->outqueue && !had_err) {
    if (gt_queue_size(gff3_out_stream->outqueue) > 0) {
      GtGenomeNode *mygn = (GtGenomeNode*)
                                        gt_queue_get(gff3_out_stream->outqueue);
      gt_assert(mygn);
      had_err = gt_genome_node_accept(mygn, gff3_out_stream->gff3_visitor, err);
      if (!had_err)
        *gn = mygn;
    }
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
testq %rdx, %rdx
je 0x146d57
movq %r14, %rdi
callq 0xfcc32
testb %al, %al
jne 0x146e45
callq 0x146cb8
movq %rax, %rdi
movq %r15, %rsi
callq 0x162ff7
movq %rax, %r15
movq 0x20(%rax), %rdi
testq %rdi, %rdi
je 0x146dab
callq 0x10d7ac
xorl %ebp, %ebp
testq %rax, %rax
je 0x146de3
movq 0x20(%r15), %rdi
callq 0x10d74a
testq %rax, %rax
je 0x146e4a
movq %rax, %r12
movq 0x28(%r15), %rsi
movq %rax, %rdi
movq %r14, %rdx
callq 0x14472c
testl %eax, %eax
je 0x146de0
movl %eax, %ebp
jmp 0x146de3
callq 0x10d640
movq %rax, 0x20(%r15)
movq 0x10(%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x162e68
testl %eax, %eax
jne 0x146da7
cmpq $0x0, (%rbx)
movq 0x18(%r15), %rdi
je 0x146dee
movl $0x8, %edx
movq %rbx, %rsi
callq 0xd2410
jmp 0x146db4
movq %r12, (%rbx)
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq -0x2668(%rip), %rsi     # 0x14478d
callq 0x144900
movq 0x18(%r15), %rdi
callq 0xd24e0
testq %rax, %rax
je 0x146e34
xorl %r12d, %r12d
movq 0x18(%r15), %rdi
movq %r12, %rsi
callq 0xd2207
movq (%rax), %rsi
movq 0x20(%r15), %rdi
callq 0x10d65b
incq %r12
movq 0x18(%r15), %rdi
callq 0xd24e0
cmpq %rax, %r12
jb 0x146e0b
movq 0x20(%r15), %rdi
testq %rdi, %rdi
jne 0x146d73
xorl %ebp, %ebp
jmp 0x146de3
callq 0x44a4f
callq 0x44a86
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/gff3_numsorted_out_stream.c
// Function: gt_gff3_numsorted_out_stream_new
GtNodeStream* gt_gff3_numsorted_out_stream_new(GtNodeStream *in_stream,
                                               GtFile *outfp)
{
  GtNodeStream *ns = gt_node_stream_create(gt_gff3_numsorted_out_stream_class(),
                                           false);
  GtGFF3NumsortedOutStream *gff3_out_stream =
                                             gff3_numsorted_out_stream_cast(ns);
  gff3_out_stream->in_stream = gt_node_stream_ref(in_stream);
  gff3_out_stream->buffer = gt_array_new(sizeof (GtGenomeNode*));
  gff3_out_stream->outqueue = NULL;
  gff3_out_stream->gff3_visitor = gt_gff3_visitor_new(outfp);
  return ns;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x146cb8
movq %rax, %rdi
xorl %esi, %esi
callq 0x162d6c
movq %rax, %r15
callq 0x146cb8
movq %rax, %rdi
movq %r15, %rsi
callq 0x162ff7
movq %rax, %r12
movq %r14, %rdi
callq 0x162dd8
movq %rax, 0x10(%r12)
movl $0x8, %edi
callq 0xd214c
movq %rax, 0x18(%r12)
movq $0x0, 0x20(%r12)
movq %rbx, %rdi
callq 0x14badb
movq %rax, 0x28(%r12)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/golomb.c
// Function: gt_golomb_new
GtGolomb* gt_golomb_new(GtUword median)
{
  GtGolomb *golomb;
  gt_assert(median > 0);
  golomb = gt_malloc(sizeof (*golomb));
  golomb->median = median;
  golomb->len = (GtUword) ceil(GT_LOG2((double) golomb->median));
  golomb->two_pow_len = GT_POW2(golomb->len);
  return golomb;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x14c435
movq %rdi, %r14
leaq 0x235ace(%rip), %rsi    # 0x381e81
movl $0x18, %edi
movl $0x33, %edx
callq 0x104226
movq %rax, %rbx
movq %r14, %xmm1
punpckldq 0x1fb50e(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x1fb516(%rip), %xmm1   # 0x3478f0
movq %r14, (%rax)
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
callq 0x17610
divsd 0x21f9a2(%rip), %xmm0   # 0x36bd98
callq 0x17100
cvttsd2si %xmm0, %rax
movq %rax, %rdx
subsd 0x1fb915(%rip), %xmm0   # 0x347d20
cvttsd2si %xmm0, %rcx
sarq $0x3f, %rdx
andq %rdx, %rcx
orq %rax, %rcx
movl $0x1, %eax
shlq %cl, %rax
movq %rcx, 0x8(%rbx)
movq %rax, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x464e9
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/golomb.c
// Function: gt_golomb_encode
GtBittab* gt_golomb_encode(const GtGolomb *golomb, GtUword x)
{
  GtUword quotient,
                remain,
                mask,
                idx_i;
  GtBittab *code;
  gt_assert(golomb);

  quotient = x / golomb->median;
  remain = x - quotient * golomb->median;

  if (golomb->len == 0) {
    code = gt_bittab_new((quotient + 1) + 1);
  }
  else if (remain < golomb->two_pow_len - golomb->median) {
    code = gt_bittab_new((quotient + 1) + (golomb->len - 1));

    mask = 1UL << (golomb->len - 2);
    for (idx_i = 0; idx_i < golomb->len - 1; idx_i++) {
      if (remain & mask)
        gt_bittab_set_bit(code, quotient + 1 + idx_i);
      mask >>= 1;
    }
  }
  else {
    code = gt_bittab_new((quotient + 1) + golomb->len);

    remain = remain + (golomb->two_pow_len) - golomb->median;

    mask = 1UL << (golomb->len - 1);
    for (idx_i = 0; idx_i < golomb->len; idx_i++) {
      if (remain & mask)
        gt_bittab_set_bit(code, quotient + 1 + idx_i);
      mask >>= 1;
    }
  }

  /* write quotient 1s */
  /* for (idx_i = gt_bittab_size(code) - 1;
       idx_i >= gt_bittab_size(code) - quotient;
       idx_i--)
    gt_bittab_set_bit(code, idx_i); */
  for (idx_i = 0; idx_i < quotient; idx_i++)
    gt_bittab_set_bit(code, idx_i);
  return code;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x14c58b
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rbp
movq 0x8(%rdi), %rdi
movq %rsi, %rax
xorl %edx, %edx
divq %rbp
movq %rax, %rbx
testq %rdi, %rdi
je 0x14c4f0
movq %rdx, %r13
movq 0x10(%r15), %rax
subq %rbp, %rax
leaq 0x1(%rbx), %rcx
cmpq %rax, %rdx
movq %rcx, 0x10(%rsp)
jae 0x14c4fe
addq %rbx, %rdi
callq 0xd6a50
movq %rax, %r12
movq 0x8(%r15), %rax
cmpq $0x1, %rax
je 0x14c55e
movq %rbp, (%rsp)
movq %r14, 0x8(%rsp)
leal -0x2(%rax), %ecx
movl $0x1, %ebp
shlq %cl, %rbp
xorl %r14d, %r14d
testq %r13, %rbp
je 0x14c4df
movq 0x10(%rsp), %rax
leaq (%rax,%r14), %rsi
movq %r12, %rdi
callq 0xd6abc
movq 0x8(%r15), %rax
shrq %rbp
incq %r14
leaq -0x1(%rax), %rcx
cmpq %rcx, %r14
jb 0x14c4c5
jmp 0x14c555
leaq 0x2(%rbx), %rdi
callq 0xd6a50
movq %rax, %r12
jmp 0x14c55e
addq %rcx, %rdi
callq 0xd6a50
movq %rax, %r12
movq 0x8(%r15), %rax
testq %rax, %rax
je 0x14c55e
movq %rbp, (%rsp)
movq %r14, 0x8(%rsp)
addq 0x10(%r15), %r13
subq (%r15), %r13
leal -0x1(%rax), %ecx
movl $0x1, %ebp
shlq %cl, %rbp
xorl %r14d, %r14d
testq %r13, %rbp
je 0x14c54a
movq 0x10(%rsp), %rax
leaq (%r14,%rax), %rsi
movq %r12, %rdi
callq 0xd6abc
movq 0x8(%r15), %rax
shrq %rbp
incq %r14
cmpq %rax, %r14
jb 0x14c530
movq 0x8(%rsp), %r14
movq (%rsp), %rbp
cmpq %r14, %rbp
ja 0x14c579
xorl %r14d, %r14d
movq %r12, %rdi
movq %r14, %rsi
callq 0xd6abc
incq %r14
cmpq %rbx, %r14
jb 0x14c566
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x46557
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/golomb.c
// Function: gt_golomb_bitwise_decoder_new
GtGolombBitwiseDecoder *gt_golomb_bitwise_decoder_new(GtGolomb *golomb)
{
  GtGolombBitwiseDecoder *gbwd;
  gt_assert(golomb);
  gbwd = gt_malloc(sizeof (*gbwd));
  gbwd->median = golomb->median;
  gbwd->status = IN_Q;
  gbwd->cur_r_bit = 0;
  gbwd->quotient = 0;
  gbwd->remain = 0;
  gbwd->len = golomb->len;
  gbwd->two_pow_len = golomb->two_pow_len;
  return gbwd;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x14c5d5
movq %rdi, %rbx
leaq 0x2358e1(%rip), %rsi    # 0x381e81
movl $0x38, %edi
movl $0x74, %edx
callq 0x104226
movq (%rbx), %rcx
movq %rcx, (%rax)
movl $0x0, 0x30(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movq $0x0, 0x18(%rax)
movups 0x8(%rbx), %xmm0
movups %xmm0, 0x20(%rax)
popq %rbx
retq
callq 0x4658e
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/golomb.c
// Function: gt_golomb_bitwise_decoder_next
int gt_golomb_bitwise_decoder_next(GtGolombBitwiseDecoder *gbwd,
                                   bool bit, GtUword *x)
{
  gt_assert(gbwd);
  if (gbwd->status == IN_Q) {
    if (bit)
      gbwd->quotient += 1;
    else
      gbwd->status = REMAINDER;
    return 1;
  }
  else if (gbwd->status == REMAINDER) {
    gbwd->remain = gbwd->remain << 1;
    if (bit)
      gbwd->remain = gbwd->remain | 1;
    gbwd->cur_r_bit++;

    if (gbwd->len == 0) {
      *x = gbwd->quotient * gbwd->median + gbwd->remain;
      gbwd->status = IN_Q;
      gbwd->quotient = 0;
      gbwd->remain = 0;
      gbwd->cur_r_bit = 0;
      return 0;
    }
    else if (gbwd->cur_r_bit == gbwd->len - 1) {
      if (gbwd->remain < GT_POW2(gbwd->len) - gbwd->median) {
        *x = gbwd->quotient * gbwd->median + gbwd->remain;
        gbwd->status = IN_Q;
        gbwd->quotient = 0;
        gbwd->remain = 0;
        gbwd->cur_r_bit = 0;
        return 0;
      }
      else
        return 1;
    }
    else if (gbwd->cur_r_bit == gbwd->len) {
      gbwd->remain -= ((GT_POW2(gbwd->len)) - gbwd->median);
      *x = gbwd->quotient * gbwd->median + gbwd->remain;
      gbwd->status = IN_Q;
      gbwd->quotient = 0;
      gbwd->remain = 0;
      gbwd->cur_r_bit = 0;
      return 0;
    }
    return 1;
  }
  return -1;
}

// Assembly:
testq %rdi, %rdi
je 0x14c6b5
movl 0x30(%rdi), %ecx
cmpl $0x1, %ecx
je 0x14c603
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0x14c6b4
testb %sil, %sil
je 0x14c652
incq 0x10(%rdi)
jmp 0x14c659
movq 0x8(%rdi), %rax
movq 0x18(%rdi), %rcx
movzbl %sil, %esi
leaq (%rsi,%rcx,2), %r9
movq %r9, 0x18(%rdi)
leaq 0x8(%rdi), %r8
leaq 0x1(%rax), %rcx
movq %rcx, 0x8(%rdi)
movq 0x20(%rdi), %rsi
testq %rsi, %rsi
je 0x14c65f
leaq -0x2(%rsi), %r10
cmpq %r10, %rax
jne 0x14c66f
movl $0x1, %r10d
movl %esi, %ecx
shlq %cl, %r10
movq (%rdi), %rcx
subq %rcx, %r10
movl $0x1, %eax
cmpq %r10, %r9
jb 0x14c690
jmp 0x14c6b4
movl $0x1, 0x30(%rdi)
movl $0x1, %eax
retq
movq (%rdi), %rax
imulq 0x10(%rdi), %rax
addq %r9, %rax
movq %rax, (%rdx)
jmp 0x14c69b
movl $0x1, %eax
cmpq %rsi, %rcx
jne 0x14c6b4
movq $-0x1, %rax
shlq %cl, %rax
movq (%rdi), %rcx
addq %rcx, %r9
addq %rax, %r9
movq %r9, 0x18(%rdi)
imulq 0x10(%rdi), %rcx
addq %r9, %rcx
movq %rcx, (%rdx)
movl $0x0, 0x30(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%r8)
movq $0x0, 0x10(%r8)
xorl %eax, %eax
retq
retq
pushq %rax
callq 0x465c5
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/gtf_in_stream.c
// Function: gt_gtf_in_stream_class
const GtNodeStreamClass* gt_gtf_in_stream_class(void)
{
  static const GtNodeStreamClass *nsc = NULL;
  gt_class_alloc_lock_enter();
  if (!nsc) {
    nsc = gt_node_stream_class_new(sizeof (GtGTFInStream),
                                   gtf_in_stream_free,
                                   gtf_in_stream_next);
  }
  gt_class_alloc_lock_leave();
  return nsc;
}

// Assembly:
pushq %rax
callq 0xe252f
cmpq $0x0, 0x371ca6(%rip)    # 0x4be768
jne 0x14cae3
leaq 0x26(%rip), %rsi        # 0x14caf1
leaq 0x7f(%rip), %rdx        # 0x14cb51
movl $0x30, %edi
callq 0x162d34
movq %rax, 0x371c85(%rip)    # 0x4be768
callq 0xe2545
movq 0x371c79(%rip), %rax    # 0x4be768
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/gtf_in_stream.c
// Function: gtf_in_stream_free
static void gtf_in_stream_free(GtNodeStream *ns)
{
  GtGTFInStream *gtf_in_stream = gtf_in_stream_cast(ns);
  gt_free(gtf_in_stream->filename);
  gt_type_checker_delete(gtf_in_stream->type_checker);
  while (gt_queue_size(gtf_in_stream->genome_node_buffer))
    gt_genome_node_delete(gt_queue_get(gtf_in_stream->genome_node_buffer));
  gt_queue_delete(gtf_in_stream->genome_node_buffer);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x14cab4
movq %rax, %rdi
movq %rbx, %rsi
callq 0x162ff7
movq %rax, %rbx
movq 0x20(%rax), %rdi
leaq 0x2354a4(%rip), %rsi    # 0x381fb7
movl $0x6a, %edx
callq 0x1045eb
movq 0x18(%rbx), %rdi
callq 0x183173
movq 0x10(%rbx), %rdi
callq 0x10d7ac
testq %rax, %rax
je 0x14cb47
movq 0x10(%rbx), %rdi
callq 0x10d74a
movq %rax, %rdi
callq 0x1451a0
jmp 0x14cb26
movq 0x10(%rbx), %rdi
popq %rbx
jmp 0x10dc23
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/gtf_in_stream.c
// Function: gtf_in_stream_next
static int gtf_in_stream_next(GtNodeStream *ns, GtGenomeNode **gn,
                              GT_UNUSED GtError *err)
{
  GtGTFInStream *is;
  int had_err = 0;
  gt_error_check(err);
  is = gtf_in_stream_cast(ns);
  if (!is->file_processed) {
    had_err = gtf_in_stream_process_file(is, err);
    is->file_processed = true;
  }
  if (!had_err && gt_queue_size(is->genome_node_buffer)) {
    /* we still have a node in the buffer -> serve it from there */
    *gn = gt_queue_get(is->genome_node_buffer);
    return 0;
  }
  if (!had_err) {
    /* the buffer is empty */
    gt_assert(!gt_queue_size(is->genome_node_buffer));
    *gn = NULL;
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0x14cb7a
movq %r15, %rdi
callq 0xfcc32
testb %al, %al
jne 0x14cc87
callq 0x14cab4
movq %rax, %rdi
movq %r14, %rsi
callq 0x162ff7
movq %rax, %r14
cmpb $0x0, 0x28(%rax)
jne 0x14cc4c
testq %r15, %r15
je 0x14cbac
movq %r15, %rdi
callq 0xfcc32
testb %al, %al
jne 0x14cc8c
movq 0x18(%r14), %rdi
callq 0x14cd38
movq %rax, %r12
movq 0x20(%r14), %rdi
testq %rdi, %rdi
je 0x14cbe2
leaq 0x20e28d(%rip), %rsi    # 0x35ae55
movq %r15, %rdx
callq 0xfea8a
testq %rax, %rax
je 0x14cc2b
movq %rax, %r13
movq %rbx, (%rsp)
movq 0x20(%r14), %rax
jmp 0x14cbeb
movq %rbx, (%rsp)
xorl %eax, %eax
xorl %r13d, %r13d
testq %rax, %rax
leaq 0x1f930c(%rip), %rdi    # 0x345f01
cmovneq %rax, %rdi
callq 0x11acc9
movq %rax, %rbx
movq 0x10(%r14), %rsi
movzbl 0x29(%r14), %r8d
movq %r12, %rdi
movq %rax, %rdx
movq %r13, %rcx
movq %r15, %r9
callq 0x14cdeb
movl %eax, %ebp
movq %rbx, %rdi
callq 0x11bdbf
movq (%rsp), %rbx
jmp 0x14cc33
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
xorl %r13d, %r13d
movq %r13, %rdi
callq 0xff22c
movq %r12, %rdi
callq 0x14df1e
movb $0x1, 0x28(%r14)
testl %ebp, %ebp
jne 0x14cc76
movq 0x10(%r14), %rdi
callq 0x10d7ac
movq 0x10(%r14), %rdi
testq %rax, %rax
je 0x14cc65
callq 0x10d74a
jmp 0x14cc71
callq 0x10d7ac
testq %rax, %rax
jne 0x14cc91
xorl %eax, %eax
movq %rax, (%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x4666c
callq 0x466a3
callq 0x466da
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/gtf_in_stream.c
// Function: gt_gtf_in_stream_new
GtNodeStream* gt_gtf_in_stream_new(const char *filename)
{
  GtGTFInStream *gtf_in_stream;
  GtNodeStream *ns = gt_node_stream_create(gt_gtf_in_stream_class(), false);
  gtf_in_stream = gtf_in_stream_cast(ns);
  gtf_in_stream->genome_node_buffer = gt_queue_new();
  gtf_in_stream->type_checker = gt_type_checker_builtin_new();
  gtf_in_stream->filename = filename ? gt_cstr_dup(filename) : NULL;
  return ns;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
callq 0x14cab4
xorl %r14d, %r14d
movq %rax, %rdi
xorl %esi, %esi
callq 0x162d6c
movq %rax, %rbx
callq 0x14cab4
movq %rax, %rdi
movq %rbx, %rsi
callq 0x162ff7
movq %rax, %r12
callq 0x10d640
movq %rax, 0x10(%r12)
xorl %eax, %eax
callq 0x183280
movq %rax, 0x18(%r12)
testq %r15, %r15
je 0x14ccef
movq %r15, %rdi
callq 0xe4290
movq %rax, %r14
movq %r14, 0x20(%r12)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/gtf_parser.c
// Function: gt_gtf_parser_new
GtGTFParser* gt_gtf_parser_new(GtTypeChecker *type_checker)
{
  GtGTFParser *parser = gt_malloc(sizeof (GtGTFParser));
  parser->gene_id_hash = gt_hashmap_new(GT_HASH_STRING, gt_free_func,
                                        (GtFree) gt_hashmap_delete);
  parser->seqid_to_str_mapping = gt_hashmap_new(GT_HASH_STRING, NULL,
                                                (GtFree) gt_str_delete);
  parser->source_to_str_mapping = gt_hashmap_new(GT_HASH_STRING, NULL,
                                                 (GtFree) gt_str_delete);
  parser->gene_id_to_name_mapping = gt_hashmap_new(GT_HASH_STRING, gt_free_func,
                                                   gt_free_func);
  parser->transcript_id_to_name_mapping = gt_hashmap_new(GT_HASH_STRING,
                                                         gt_free_func,
                                                         gt_free_func);
  parser->region_node_builder = gt_region_node_builder_new();
  parser->type_checker = type_checker;
  return parser;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x2352ca(%rip), %rsi    # 0x382014
movl $0x38, %edi
movl $0x62, %edx
callq 0x104226
movq %rax, %r14
leaq -0x486b9(%rip), %r15    # 0x1046aa
leaq -0x4bccf(%rip), %rdx    # 0x10109b
movl $0x1, %edi
movq %r15, %rsi
callq 0x1008fc
movq %rax, (%r14)
leaq -0x30fc2(%rip), %r12    # 0x11bdbf
movl $0x1, %edi
xorl %esi, %esi
movq %r12, %rdx
callq 0x1008fc
movq %rax, 0x8(%r14)
movl $0x1, %edi
xorl %esi, %esi
movq %r12, %rdx
callq 0x1008fc
movq %rax, 0x10(%r14)
movl $0x1, %edi
movq %r15, %rsi
movq %r15, %rdx
callq 0x1008fc
movq %rax, 0x18(%r14)
movl $0x1, %edi
movq %r15, %rsi
movq %r15, %rdx
callq 0x1008fc
movq %rax, 0x20(%r14)
callq 0x16e948
movq %rax, 0x28(%r14)
movq %rbx, 0x30(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/gtf_parser.c
// Function: delete_genes
static int delete_genes(GT_UNUSED void *key, void *value, GT_UNUSED void *data,
                        GT_UNUSED GtError *err)
{
  GtHashmap *transcript_id_hash = (GtHashmap*) value;
  GT_UNUSED int had_err = 0;
  gt_assert(key && value);
  had_err = gt_hashmap_foreach(transcript_id_hash, delete_mRNAs, NULL, err);
  gt_assert(!had_err);
  return had_err;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x14df14
testq %rsi, %rsi
je 0x14df14
leaq 0x506(%rip), %rax       # 0x14e405
movq %rsi, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x100bc9
testl %eax, %eax
jne 0x14df19
xorl %eax, %eax
popq %rcx
retq
callq 0x46cdd
callq 0x46d16
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/gtf_parser.c
// Function: gt_gtf_parser_delete
void gt_gtf_parser_delete(GtGTFParser *parser)
{
  if (!parser) return;
  gt_region_node_builder_delete(parser->region_node_builder);
  gt_hashmap_delete(parser->gene_id_hash);
  gt_hashmap_delete(parser->seqid_to_str_mapping);
  gt_hashmap_delete(parser->source_to_str_mapping);
  gt_hashmap_delete(parser->transcript_id_to_name_mapping);
  gt_hashmap_delete(parser->gene_id_to_name_mapping);
  gt_free(parser);
}

// Assembly:
testq %rdi, %rdi
je 0x14df71
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
callq 0x16e97e
movq (%rbx), %rdi
callq 0x10109b
movq 0x8(%rbx), %rdi
callq 0x10109b
movq 0x10(%rbx), %rdi
callq 0x10109b
movq 0x20(%rbx), %rdi
callq 0x10109b
movq 0x18(%rbx), %rdi
callq 0x10109b
leaq 0x2340b1(%rip), %rsi    # 0x382014
movq %rbx, %rdi
movl $0x316, %edx            # imm = 0x316
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/gtf_parser.c
// Function: delete_mRNAs
static int delete_mRNAs(GT_UNUSED void *key, void *value,
                        GT_UNUSED void *data, GT_UNUSED GtError *err)
{
  GtArray *gt_genome_node_array = (GtArray*) value;
  GtUword i;

  gt_assert(key && value);
  for (i = 0; i < gt_array_size(gt_genome_node_array); i++) {
    GtGenomeNode *gn = *(GtGenomeNode**) gt_array_get(gt_genome_node_array, i);
    gt_genome_node_delete(gn);
  }

  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x14e453
movq %rsi, %rbx
testq %rsi, %rsi
je 0x14e453
movq %rbx, %rdi
callq 0xd24e0
testq %rax, %rax
je 0x14e449
xorl %r14d, %r14d
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd2207
movq (%rax), %rdi
callq 0x1451a0
incq %r14
movq %rbx, %rdi
callq 0xd24e0
cmpq %rax, %r14
jb 0x14e426
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x46dfa
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/gtf_visitor.c
// Function: gt_gtf_visitor_class
const GtNodeVisitorClass* gt_gtf_visitor_class()
{
  static const GtNodeVisitorClass *nvc = NULL;
  gt_class_alloc_lock_enter();
  if (!nvc) {
    nvc = gt_node_visitor_class_new(sizeof (GtGTFVisitor),
                                    gtf_visitor_free,
                                    gtf_visitor_comment_node,
                                    gtf_visitor_feature_node,
                                    NULL,
                                    NULL,
                                    NULL);
  }
  gt_class_alloc_lock_leave();
  return nvc;
}

// Assembly:
pushq %rax
callq 0xe252f
cmpq $0x0, 0x37030a(%rip)    # 0x4be770
jne 0x14e49c
movq $0x0, (%rsp)
leaq 0x33(%rip), %rsi        # 0x14e4aa
leaq 0x60(%rip), %rdx        # 0x14e4de
leaq 0xb3(%rip), %rcx        # 0x14e538
movl $0x38, %edi
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x163010
movq %rax, 0x3702d4(%rip)    # 0x4be770
callq 0xe2545
movq 0x3702c8(%rip), %rax    # 0x4be770
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/gtf_visitor.c
// Function: gtf_visitor_free
static void gtf_visitor_free(GtNodeVisitor *nv)
{
  GtGTFVisitor *gtf_visitor = gtf_visitor_cast(nv);
  gt_assert(gtf_visitor);
  gt_array_delete(gtf_visitor->exon_features);
  gt_array_delete(gtf_visitor->CDS_features);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x14e458
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1630b1
testq %rax, %rax
je 0x14e4d9
movq %rax, %rbx
movq 0x20(%rax), %rdi
callq 0xd2938
movq 0x28(%rbx), %rdi
popq %rbx
jmp 0xd2938
callq 0x46e33
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/gtf_visitor.c
// Function: gtf_visitor_comment_node
static int gtf_visitor_comment_node(GtNodeVisitor *nv, GtCommentNode *c,
                                    GT_UNUSED GtError *err)
{
  GtGTFVisitor *gtf_visitor;
  gt_error_check(err);
  gtf_visitor = gtf_visitor_cast(nv);
  gt_file_xprintf(gtf_visitor->outfp, "#%s\n", gt_comment_node_get_comment(c));
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0x14e4f9
movq %rdx, %rdi
callq 0xfcc32
testb %al, %al
jne 0x14e533
callq 0x14e458
movq %rax, %rdi
movq %r14, %rsi
callq 0x1630b1
movq 0x30(%rax), %r14
movq %rbx, %rdi
callq 0x2fccbf
leaq 0x233947(%rip), %rsi    # 0x381e63
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xfee51
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x46e6a
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/gtf_visitor.c
// Function: gtf_visitor_feature_node
static int gtf_visitor_feature_node(GtNodeVisitor *nv, GtFeatureNode *fn,
                                    GtError *err)
{
  GtGTFVisitor *gtf_visitor;
  int had_err;
  gt_error_check(err);
  gtf_visitor = gtf_visitor_cast(nv);
  had_err = gt_feature_node_traverse_children(fn, gtf_visitor,
                                              gtf_show_feature_node, false,
                                              err);
  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rdx, %rdx
je 0x14e557
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0x14e583
callq 0x14e458
movq %rax, %rdi
movq %r15, %rsi
callq 0x1630b1
leaq 0x76(%rip), %rdx        # 0x14e5e4
movq %r14, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
movq %rbx, %r8
popq %rbx
popq %r14
popq %r15
jmp 0x142d9d
callq 0x46ea1
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/gtf_visitor.c
// Function: gt_gtf_visitor_new
GtNodeVisitor* gt_gtf_visitor_new(GtFile *outfp)
{
  GtNodeVisitor *nv = gt_node_visitor_create(gt_gtf_visitor_class());
  GtGTFVisitor *gtf_visitor = gtf_visitor_cast(nv);
  gtf_visitor->gene_id = 0;
  gtf_visitor->exon_features = gt_array_new(sizeof (GtGenomeNode*));
  gtf_visitor->CDS_features = gt_array_new(sizeof (GtGenomeNode*));
  gtf_visitor->outfp = outfp;
  return nv;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x14e458
movq %rax, %rdi
callq 0x163080
movq %rax, %r14
callq 0x14e458
movq %rax, %rdi
movq %r14, %rsi
callq 0x1630b1
movq %rax, %r15
movq $0x0, 0x10(%rax)
movl $0x8, %edi
callq 0xd214c
movq %rax, 0x20(%r15)
movl $0x8, %edi
callq 0xd214c
movq %rax, 0x28(%r15)
movq %rbx, 0x30(%r15)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/gtf_visitor.c
// Function: gtf_show_feature_node
static int gtf_show_feature_node(GtFeatureNode *fn, void *data, GtError *err)
{
  GtGTFVisitor *gtf_visitor = (GtGTFVisitor*) data;
  int had_err = 0;
  if (gt_feature_node_has_type(fn, gt_ft_gene)) {
      gtf_visitor->gene_id++;
      gtf_visitor->transcript_id = 0;
      had_err = gtf_show_transcript(fn, gtf_visitor, err);
  }
  else if (gt_feature_node_has_type(fn, gt_ft_mRNA)) {
    had_err = gtf_show_transcript(fn, gtf_visitor, err);
  }
  else if (!(gt_feature_node_has_type(fn, gt_ft_CDS) ||
             gt_feature_node_has_type(fn, gt_ft_exon))) {
      gt_warning("skipping GFF3 feature of type \"%s\" (from line %u in file "
                 "\"%s\")",
                 gt_feature_node_get_type(fn),
                 gt_genome_node_get_line_number((GtGenomeNode*) fn),
                 gt_genome_node_get_filename((GtGenomeNode*) fn));
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x28f150(%rip), %rsi    # 0x3dd74b
callq 0x142b18
testb %al, %al
je 0x14e612
incq 0x10(%r15)
movq $0x0, 0x18(%r15)
jmp 0x14e625
leaq 0x22c388(%rip), %rsi    # 0x37a9a1
movq %rbx, %rdi
callq 0x142b18
testb %al, %al
je 0x14e63a
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x14e6a0
leaq 0x233dd8(%rip), %rsi    # 0x382419
movq %rbx, %rdi
callq 0x142b18
testb %al, %al
jne 0x14e693
leaq 0x246143(%rip), %rsi    # 0x394797
movq %rbx, %rdi
callq 0x142b18
testb %al, %al
jne 0x14e693
movq %rbx, %rdi
callq 0x142988
movq %rax, %r14
movq %rbx, %rdi
callq 0x144626
movl %eax, %ebp
movq %rbx, %rdi
callq 0x144606
leaq 0x233f03(%rip), %rdi    # 0x382587
movq %r14, %rsi
movl %ebp, %edx
movq %rax, %rcx
xorl %eax, %eax
callq 0x11f68c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/gtf_visitor.c
// Function: save_exon_node
static int save_exon_node(GtFeatureNode *fn, void *data, GT_UNUSED GtError *err)
{
  GtGTFVisitor *gtf_visitor;
  gt_error_check(err);
  gt_assert(fn && data);
  gtf_visitor = (GtGTFVisitor*) data;
  if (gt_feature_node_has_type(fn, gt_ft_exon))
    gt_array_add(gtf_visitor->exon_features, fn);
  else if (gt_feature_node_has_type(fn, gt_ft_CDS))
    gt_array_add(gtf_visitor->CDS_features, fn);
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rdi, (%rsp)
testq %rdx, %rdx
je 0x14e875
movq %rdx, %rdi
callq 0xfcc32
testb %al, %al
jne 0x14e8cf
testq %rbx, %rbx
je 0x14e8ca
testq %r14, %r14
je 0x14e8ca
leaq 0x245f11(%rip), %rsi    # 0x394797
movq %r14, %rdi
callq 0x142b18
movl $0x20, %ecx
testb %al, %al
jne 0x14e8af
leaq 0x233b7b(%rip), %rsi    # 0x382419
movq %r14, %rdi
callq 0x142b18
movl $0x28, %ecx
testb %al, %al
je 0x14e8c0
movq (%rbx,%rcx), %rdi
movq %rsp, %rsi
movl $0x8, %edx
callq 0xd2410
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x46f7f
callq 0x46f48
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/hcr.c
// Function: gt_hcr_decoder_delete
void gt_hcr_decoder_delete(GtHcrDecoder *hcr_dec)
{
  if (hcr_dec != NULL) {
    hcr_seq_decoder_delete(hcr_dec->seq_dec);
    gt_encdesc_delete(hcr_dec->encdesc);
    gt_free(hcr_dec);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x14ef32
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x15059e
movq (%rbx), %rdi
callq 0x13c44c
leaq 0x233728(%rip), %rsi    # 0x38264c
movq %rbx, %rdi
movl $0x53d, %edx            # imm = 0x53D
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/hcr.c
// Function: reset_data_iterator_to_pos
static void reset_data_iterator_to_pos(HcrHuffDataIterator *data_iter,
                                       size_t pos)
{
  gt_assert(data_iter);
  gt_assert(pos < data_iter->end);
  gt_assert(data_iter->start <= pos);
  gt_fa_xmunmap(data_iter->data);
  data_iter->data = NULL;
  data_iter->pos = pos;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x14f3c8
movq %rsi, %rbx
movq %rdi, %r14
cmpq %rsi, 0x18(%rdi)
jbe 0x14f3cd
cmpq %rbx, 0x10(%r14)
ja 0x14f3d2
movq 0x8(%r14), %rdi
callq 0xfdc54
movq $0x0, 0x8(%r14)
movq %rbx, 0x20(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x47490
callq 0x4741e
callq 0x47457
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/hcr.c
// Function: hcr_base_qual_distr_trim
static void hcr_base_qual_distr_trim(GtBaseQualDistr *bqd)
{
  if (bqd->min_qual != 0) {
    GtUint64 **distr_trimmed;
    unsigned nrows_new,
             i,
             j;

    nrows_new = bqd->max_qual - bqd->min_qual + 1;
    gt_array2dim_calloc(distr_trimmed, (GtUword) nrows_new, bqd->ncols);

    for (i = 0; i < nrows_new; i++)
      for (j = 0; j < bqd->ncols; j++)
        distr_trimmed[i][j] = bqd->distr[i + bqd->min_qual][j];
    gt_array2dim_delete(bqd->distr);
    bqd->distr = distr_trimmed;
    bqd->nrows = nrows_new;
    bqd->qual_offset = bqd->min_qual;
  }
}

// Assembly:
movl 0x1c(%rdi), %eax
testl %eax, %eax
je 0x14fd4e
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x18(%rdi), %r12d
subl %eax, %r12d
incl %r12d
leaq (,%r12,8), %rdi
leaq 0x2329cc(%rip), %r15    # 0x38264c
movq %r15, %rsi
movl $0xa4, %edx
callq 0x104226
movq %rax, %r14
movl 0x10(%rbx), %edi
imulq %r12, %rdi
movl $0x8, %esi
movq %r15, %rdx
movl $0xa4, %ecx
callq 0x10436a
movq %rax, (%r14)
cmpl $0x2, %r12d
jb 0x14fcd3
movl 0x10(%rbx), %eax
shlq $0x3, %rax
movq (%r14), %rcx
addq %rax, %rcx
movl $0x1, %edx
movq %rcx, (%r14,%rdx,8)
incq %rdx
addq %rax, %rcx
cmpq %rdx, %r12
jne 0x14fcc4
testl %r12d, %r12d
je 0x14fd0c
movl 0x10(%rbx), %eax
xorl %ecx, %ecx
testq %rax, %rax
je 0x14fd04
movq (%rbx), %rdx
movl 0x1c(%rbx), %esi
addl %ecx, %esi
movq (%rdx,%rsi,8), %rdx
movq (%r14,%rcx,8), %rsi
xorl %edi, %edi
movq (%rdx,%rdi,8), %r8
movq %r8, (%rsi,%rdi,8)
incq %rdi
cmpq %rdi, %rax
jne 0x14fcf4
incq %rcx
cmpq %r12, %rcx
jne 0x14fcdd
movq (%rbx), %rax
movq (%rax), %rdi
leaq 0x232933(%rip), %r15    # 0x38264c
movq %r15, %rsi
movl $0xa9, %edx
callq 0x1045eb
movq (%rbx), %rdi
movq %r15, %rsi
movl $0xa9, %edx
callq 0x1045eb
movq %r14, (%rbx)
movl %r12d, 0x14(%rbx)
movl 0x1c(%rbx), %eax
movl %eax, 0x28(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/hcr.c
// Function: gt_hcr_encoder_set_sampling_none
void gt_hcr_encoder_set_sampling_none(GtHcrEncoder *hcr_enc)
{
  gt_assert(hcr_enc);
  hcr_enc->page_sampling = hcr_enc->regular_sampling = false;
  if (hcr_enc->encdesc_encoder != NULL)
    gt_encdesc_encoder_set_sampling_none(hcr_enc->encdesc_encoder);
}

// Assembly:
testq %rdi, %rdi
je 0x14fddf
movw $0x0, 0x38(%rdi)
movq (%rdi), %rdi
testq %rdi, %rdi
jne 0x13ad9a
retq
pushq %rax
callq 0x47703
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/hcr.c
// Function: gt_hcr_encoder_set_sampling_regular
void gt_hcr_encoder_set_sampling_regular(GtHcrEncoder *hcr_enc)
{
  gt_assert(hcr_enc);
  hcr_enc->page_sampling = false;
  hcr_enc->regular_sampling = true;
  if (hcr_enc->encdesc_encoder != NULL)
    gt_encdesc_encoder_set_sampling_regular(hcr_enc->encdesc_encoder);
}

// Assembly:
testq %rdi, %rdi
je 0x14fdfd
movw $0x100, 0x38(%rdi)      # imm = 0x100
movq (%rdi), %rdi
testq %rdi, %rdi
jne 0x13adac
retq
pushq %rax
callq 0x4773c
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/hcr.c
// Function: gt_hcr_encoder_set_sampling_page
void gt_hcr_encoder_set_sampling_page(GtHcrEncoder *hcr_enc)
{
  gt_assert(hcr_enc);
  hcr_enc->page_sampling = true;
  hcr_enc->regular_sampling = false;
  if (hcr_enc->encdesc_encoder != NULL)
    gt_encdesc_encoder_set_sampling_page(hcr_enc->encdesc_encoder);
}

// Assembly:
testq %rdi, %rdi
je 0x14fe1b
movw $0x1, 0x38(%rdi)
movq (%rdi), %rdi
testq %rdi, %rdi
jne 0x13adbe
retq
pushq %rax
callq 0x47775
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/hcr.c
// Function: gt_hcr_encoder_set_sampling_rate
void gt_hcr_encoder_set_sampling_rate(GtHcrEncoder *hcr_enc,
                                      GtUword srate)
{
  gt_assert(hcr_enc);
  hcr_enc->sampling_rate = srate;

  if (hcr_enc->encdesc_encoder != NULL)
    gt_encdesc_encoder_set_sampling_rate(hcr_enc->encdesc_encoder, srate);
}

// Assembly:
testq %rdi, %rdi
je 0x14fe37
movq %rsi, 0x28(%rdi)
movq (%rdi), %rdi
testq %rdi, %rdi
jne 0x13adee
retq
pushq %rax
callq 0x477ae
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/hcr.c
// Function: gt_hcr_encoder_delete
void gt_hcr_encoder_delete(GtHcrEncoder *hcr_enc)
{
  if (!hcr_enc)
    return;
  gt_huffman_delete(hcr_enc->seq_encoder->huffman);
  gt_sampling_delete(hcr_enc->seq_encoder->sampling);
  gt_free(hcr_enc->seq_encoder->fileinfos);
  gt_free(hcr_enc->seq_encoder);
  gt_encdesc_encoder_delete(hcr_enc->encdesc_encoder);
  gt_free(hcr_enc);
}

// Assembly:
testq %rdi, %rdi
je 0x15059d
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movq 0x18(%rax), %rdi
callq 0x1543bd
movq 0x8(%rbx), %rax
movq 0x20(%rax), %rdi
callq 0x17132e
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
leaq 0x2320ec(%rip), %r14    # 0x38264c
movq %r14, %rsi
movl $0x532, %edx            # imm = 0x532
callq 0x1045eb
movq 0x8(%rbx), %rdi
movq %r14, %rsi
movl $0x533, %edx            # imm = 0x533
callq 0x1045eb
movq (%rbx), %rdi
callq 0x13cf5a
movq %rbx, %rdi
movq %r14, %rsi
movl $0x535, %edx            # imm = 0x535
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/hcr.c
// Function: hcr_seq_decoder_delete
static void hcr_seq_decoder_delete(GtHcrSeqDecoder *seq_dec)
{
  if (seq_dec != NULL) {
    gt_free(seq_dec->fileinfos);
    gt_huffman_decoder_delete(seq_dec->huff_dec);
    gt_huffman_delete(seq_dec->huffman);
    gt_sampling_delete(seq_dec->sampling);
    gt_rbtree_delete(seq_dec->file_info_rbt);
    gt_str_delete(seq_dec->filename);
    data_iterator_delete(seq_dec->data_iter);
    gt_array_delete(seq_dec->symbols);
    gt_free(seq_dec);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x150637
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0x232093(%rip), %rsi    # 0x38264c
movl $0x2e6, %edx            # imm = 0x2E6
callq 0x1045eb
movq 0x28(%rbx), %rdi
callq 0x154922
movq 0x20(%rbx), %rdi
callq 0x1543bd
movq 0x38(%rbx), %rdi
callq 0x17132e
movq 0x30(%rbx), %rdi
callq 0x165fc5
movq 0x40(%rbx), %rdi
callq 0x11bdbf
movq 0x48(%rbx), %r14
testq %r14, %r14
je 0x150602
movq 0x8(%r14), %rdi
callq 0xfdc54
leaq 0x232043(%rip), %r15    # 0x38264c
movq %r14, %rdi
movq %r15, %rsi
movl $0x2ab, %edx            # imm = 0x2AB
callq 0x1045eb
movq 0x10(%rbx), %rdi
callq 0xd2938
movq %rbx, %rdi
movq %r15, %rsi
movl $0x2ee, %edx            # imm = 0x2EE
popq %rbx
popq %r14
popq %r15
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/hcr.c
// Function: get_next_file_chunk_for_huffman
static int get_next_file_chunk_for_huffman(GtBitsequence **bits,
                                           GtUword *length,
                                           GtUword *offset,
                                           GtUword *pad_length,
                                           void *meminfo)
{
  const int empty = 0,
            success = 1;
  HcrHuffDataIterator *data_iter;
  gt_assert(meminfo);
  gt_assert(bits && length && offset && pad_length);
  data_iter = (HcrHuffDataIterator*) meminfo;

  if (data_iter->pos < data_iter->end) {
    gt_fa_xmunmap(data_iter->data);
    data_iter->data = NULL;
    data_iter->data = gt_fa_xmmap_read_range(data_iter->path,
                                        (size_t) data_iter->blocksize,
                                        data_iter->pos);
    data_iter->pos += data_iter->blocksize;
    if (data_iter->pos > data_iter->end) {
      gt_safe_assign(*length,
                    (data_iter->blocksize - (data_iter->pos - data_iter->end)));
      *length /= sizeof (GtBitsequence);
    }
    else
      *length = data_iter->bitseq_per_chunk;

    *offset = 0;
    *pad_length = 0;
    *bits = data_iter->data;
    return success;
  }
  gt_fa_xmunmap(data_iter->data);
  data_iter->data = NULL;
  *bits = NULL;
  *length = 0;
  *offset = 0;
  *pad_length = 0;
  return empty;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %r8, %r8
je 0x15073f
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r15
movq %rsi, %xmm0
movq %rdi, %xmm1
punpcklqdq %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0]
movq %rcx, (%rsp)
movq %rcx, %xmm0
movq %rdx, %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 0x150744
movq %r8, %r13
movq 0x8(%r8), %rdi
movq 0x20(%r8), %rbp
movq 0x18(%r8), %rbx
callq 0xfdc54
movq $0x0, 0x8(%r13)
cmpq %rbx, %rbp
jae 0x1506ff
movq 0x40(%r13), %rsi
movq (%r13), %rdi
movq 0x20(%r13), %rdx
leaq 0x231f7d(%rip), %rcx    # 0x38264c
movl $0x27e, %r8d            # imm = 0x27E
callq 0xfdbac
movq %rax, 0x8(%r13)
movq 0x18(%r13), %rcx
movq 0x40(%r13), %rdx
movq 0x20(%r13), %rsi
addq %rdx, %rsi
movq %rsi, 0x20(%r13)
subq %rsi, %rcx
jae 0x150714
addq %rdx, %rcx
shrq $0x3, %rcx
jmp 0x150718
xorl %eax, %eax
movq %rax, (%r15)
movq %rax, (%r12)
movq %rax, (%r14)
movq (%rsp), %rcx
movq %rax, (%rcx)
jmp 0x150730
movq 0x30(%r13), %rcx
movq %rcx, (%r12)
xorl %ecx, %ecx
movq %rcx, (%r14)
movq (%rsp), %rdx
movq %rcx, (%rdx)
movq %rax, (%r15)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x479af
callq 0x47976