LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/encdesc.c
// Function: gt_encdesc_decode
int gt_encdesc_decode(GtEncdesc *encdesc,
                      GtUword num,
                      GtStr *desc,
                      GtError *err)
{
  int had_err = 0;
  GtUword descs2read = 0,
          nearestsample = 0,
          idx;
  size_t startofnearestsample = 0;

  gt_assert(encdesc);
  gt_assert(desc);
  gt_assert(num < encdesc->num_of_descs);

  if (encdesc->cur_desc == num) {
    return encdesc_next_desc(encdesc, desc, err);
  }

  if (encdesc->sampling != NULL) {
    (void) gt_sampling_get_page(encdesc->sampling,
                                num,
                                &nearestsample,
                                &startofnearestsample);
    /* nearestsample <= cur_read < readnum: current sample is the right one */
    if (nearestsample <= encdesc->cur_desc && encdesc->cur_desc <= num)
      descs2read = num - encdesc->cur_desc;
    else { /* reset decoder to new sample */
      gt_bitinstream_reinit(encdesc->bitinstream,
                            startofnearestsample);
      encdesc->cur_desc = nearestsample;
      descs2read = num - nearestsample;
    }
  }
  else {
    if (encdesc->cur_desc <= num)
      descs2read = num - encdesc->cur_desc;
    else {
      gt_bitinstream_reinit(encdesc->bitinstream,
                            (size_t) encdesc->start_of_encoding);
      descs2read = num;
      encdesc->cur_desc = 0;
    }
  }

  /* decode all description until the requested */
  for (idx = 0; !had_err && idx < descs2read; idx++) {
    had_err = encdesc_next_desc(encdesc, NULL, err);
  }

  /* decode the requested description */
  if (!had_err) {
    had_err = encdesc_next_desc(encdesc, desc, err);
  }
  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
xorl %eax, %eax
movq %rax, 0x8(%rsp)
movq %rax, (%rsp)
testq %rdi, %rdi
je 0x143157
movq %rdx, %r14
testq %rdx, %rdx
je 0x14315c
movq %rsi, %r12
movq %rdi, %r15
cmpq %rsi, 0x38(%rdi)
jbe 0x143161
movq %rcx, %rbx
movq 0x48(%r15), %rax
cmpq %rax, %r12
je 0x14313b
movq 0x28(%r15), %rdi
testq %rdi, %rdi
je 0x1430e5
leaq 0x8(%rsp), %r13
movq %rsp, %rcx
movq %r12, %rsi
movq %r13, %rdx
callq 0x17941b
movq 0x48(%r15), %rax
cmpq %rax, (%r13)
seta %cl
movq %r12, %r13
subq %rax, %r13
setb %al
orb %cl, %al
je 0x143105
movq 0x20(%r15), %rdi
movq (%rsp), %rsi
callq 0x304a0f
movq 0x8(%rsp), %rax
movq %rax, 0x48(%r15)
subq %rax, %r12
jmp 0x143102
movq %r12, %r13
subq %rax, %r13
jae 0x143105
movq 0x20(%r15), %rdi
movq 0x60(%r15), %rsi
callq 0x304a0f
movq $0x0, 0x48(%r15)
movq %r12, %r13
testq %r13, %r13
je 0x143133
movl $0x1, %r12d
movq %r15, %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x143166
testl %eax, %eax
sete %cl
jne 0x143137
leaq 0x1(%r12), %rdx
cmpq %r13, %r12
movq %rdx, %r12
jb 0x143110
jmp 0x143137
movb $0x1, %cl
xorl %eax, %eax
testb %cl, %cl
je 0x143149
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x143166
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x4144c
callq 0x41413
callq 0x413da
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/encdesc.c
// Function: encdesc_hashmap_distr_add
static int encdesc_hashmap_distr_add(GtHashtable *hm_distri, GtWord key)
{
  GtUint64 *valueptr;
  gt_assert(hm_distri != NULL);
  valueptr = li_ull_gt_hashmap_get(hm_distri, key);
  if (!valueptr) {
    li_ull_gt_hashmap_add(hm_distri, key, (GtUint64) 1);
    return 1;
  }
  else {
    (*valueptr) += 1;
    return 0;
  }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x143cf6
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
movq %r14, (%rsi)
callq 0x10620e
testq %rax, %rax
je 0x143cbe
incq 0x8(%rax)
xorl %eax, %eax
jmp 0x143cee
leaq 0x8(%rsp), %rsi
movq %r14, (%rsi)
movq $0x1, 0x8(%rsi)
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x106536
testl %eax, %eax
jne 0x143ce9
movq (%rsp), %rax
movq $0x1, 0x8(%rax)
movl $0x1, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
callq 0x416bd
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/encdesc.c
// Function: encdesc_digits_per_value
static unsigned encdesc_digits_per_value(GtUword value,
                                         GtUword base)
{
  if (value > 0) {
    double log_val, log_base;
    log_val = log((double) value);
    log_base = log((double) base);
    return (unsigned) (floor(log_val / log_base )) + 1U;
  }
  else
    return 1U;
}

// Assembly:
testq %rdi, %rdi
je 0x143d61
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %xmm1
punpckldq 0x20cbcb(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x20cbd3(%rip), %xmm1   # 0x3508f0
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
callq 0x17610
movsd %xmm0, 0x8(%rsp)
xorps %xmm0, %xmm0
cvtsi2sd %rbx, %xmm0
callq 0x17610
movsd 0x8(%rsp), %xmm1
divsd %xmm0, %xmm1
movapd %xmm1, %xmm0
callq 0x17d40
cvttsd2si %xmm0, %rax
incl %eax
addq $0x10, %rsp
popq %rbx
retq
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/encdesc.c
// Function: encdesc_hashmap_distr_get_corrected
static GtUint64 encdesc_hashmap_distr_get_corrected(const void *data,
                                                    GtUword key)
{
  EncdescHuffDist *dist = (EncdescHuffDist*) data;
  GtUint64 *valueptr;
  /* function will be called with 0-based keys, we have to correct this, so a
     0-key maps to the smalles key within the distribution */
  GtWord corrected_key = (GtWord) key + dist->correction_base;
  gt_assert(dist->li_ull_hashmap);
  if (!(valueptr = li_ull_gt_hashmap_get(dist->li_ull_hashmap,
                                         corrected_key)))
    return 0;
  return *valueptr;
}

// Assembly:
pushq %rax
movq %rdi, %rax
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x143d95
addq 0x8(%rax), %rsi
movq %rsp, %rax
movq %rsi, (%rax)
movq %rax, %rsi
callq 0x10620e
testq %rax, %rax
je 0x143d91
movq 0x8(%rax), %rax
jmp 0x143d93
xorl %eax, %eax
popq %rcx
retq
callq 0x416f6
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/encdesc.c
// Function: encdesc_hashmap_distr_get
static GtUint64 encdesc_hashmap_distr_get(const void *hm_distri,
                                          GtUword key)
{
  GtHashtable *hashmap = (GtHashtable*) hm_distri;
  GtUint64 *valueptr;
  gt_assert(hashmap != NULL);
  if (!(valueptr = li_ull_gt_hashmap_get(hashmap, (GtWord) key)))
    return 0;
  return *valueptr;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x143dc2
movq %rsp, %rax
movq %rsi, (%rax)
movq %rax, %rsi
callq 0x10620e
testq %rax, %rax
je 0x143dbe
movq 0x8(%rax), %rax
jmp 0x143dc0
xorl %eax, %eax
popq %rcx
retq
callq 0x4172f
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/encdesc_header_io.c
// Function: io_hashmap_distri
static inline GtHashtable *io_hashmap_distri(GtHashtable *h_table,
                                             GtUword size,
                                             EncsecDistriData *data,
                                             GtError *err)
{
  if (h_table != NULL) {
    h_table = write_hashmap_distri(h_table, size, data, err);
  }
  else {
    h_table = read_hashmap_distri(h_table, size, data->fp, err);
  }
  return h_table;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rcx, %rbp
movq %rdx, %r12
movq %rsi, %r14
testq %rdi, %rdi
je 0x145c70
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x8(%r12)
leaq 0x60(%rsp), %rdx
movq %r12, (%rdx)
leaq 0x17d(%rip), %rcx       # 0x145dc6
movq %rcx, 0x8(%rdx)
movq %rax, 0x10(%rdx)
leaq 0x1da(%rip), %rsi       # 0x145e32
movq %rbp, %rcx
callq 0x106adc
testl %eax, %eax
je 0x145d7c
movq %rbx, %rdi
jmp 0x145da8
movq (%r12), %r12
movups 0x37f4fd(%rip), %xmm0   # 0x4c5178
movups %xmm0, 0x20(%rsp)
movups 0x37f4e1(%rip), %xmm0   # 0x4c5168
movups %xmm0, 0x10(%rsp)
movups 0x37f4c5(%rip), %xmm0   # 0x4c5158
movups %xmm0, (%rsp)
callq 0x1060b4
movq %rax, %rbx
testq %r14, %r14
je 0x145daf
movq %rbx, 0x38(%rsp)
movl $0x1, %r13d
movq %rbp, 0x48(%rsp)
movl $0x8, %esi
movl $0x1, %edx
leaq 0x40(%rsp), %rdi
movq %r12, %rcx
movq %rbp, %r8
callq 0x15e8b7
testl %eax, %eax
je 0x145cdb
xorl %r15d, %r15d
jmp 0x145cfb
movl $0x8, %esi
movl $0x1, %edx
leaq 0x50(%rsp), %rdi
movq %r12, %rcx
movq %rbp, %r8
callq 0x15e8b7
testl %eax, %eax
sete %r15b
testb %r15b, %r15b
leaq 0x60(%rsp), %rbx
je 0x145d5e
movq 0x40(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x38(%rsp), %rbp
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x10620e
testq %rax, %rax
jne 0x145dc1
movq %rbp, %rdi
movq 0x40(%rsp), %rax
movq 0x50(%rsp), %rbp
movq %rax, 0x60(%rsp)
movq %rbp, 0x68(%rsp)
movq %rbx, %rsi
leaq 0x58(%rsp), %rdx
callq 0x106536
testl %eax, %eax
jne 0x145d59
movq 0x58(%rsp), %rax
movq %rbp, 0x8(%rax)
movq 0x48(%rsp), %rbp
cmpq %r14, %r13
setb %al
incq %r13
testb %al, %r15b
jne 0x145cb8
testb %r15b, %r15b
je 0x145da3
movq 0x38(%rsp), %rbx
jmp 0x145daf
movq 0x8(%r12), %rdx
cmpq %r14, %rdx
je 0x145d97
leaq 0x26684e(%rip), %rdi    # 0x3ac5db
movq %r14, %rsi
xorl %eax, %eax
callq 0x108e02
cmpq %r14, 0x8(%r12)
je 0x145daf
callq 0x41e76
movq 0x38(%rsp), %rdi
callq 0x106d10
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x41eaf
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/encdesc_header_io.c
// Function: encdesc_li_ull_hashmap_iter_write
static enum iterator_op encdesc_li_ull_hashmap_iter_write(
                                                          GtWord key,
                                                          GtUint64 value,
                                                          void *data,
                                                          GtError *err)
{
  int had_err = 0;
  EncsecDistriData *this_data = (EncsecDistriData*) data;
  this_data->written_elems++;
  had_err = gt_io_error_fwrite_one(key, this_data->fp, err);
  if (!had_err)
    had_err = gt_io_error_fwrite_one(value, this_data->fp, err);
  if (!had_err)
    return CONTINUE_ITERATION;
  return STOP_ITERATION;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r14
leaq 0x10(%rsp), %rax
movq %rdi, (%rax)
movq %rsi, 0x8(%rsp)
incq 0x8(%rdx)
movq (%rdx), %rcx
movl $0x8, %esi
movl $0x1, %edx
movq %rax, %rdi
movq %rbx, %r8
callq 0x15e878
movl %eax, %ecx
movl $0x1, %eax
testl %ecx, %ecx
jne 0x145e2a
movq (%r14), %rcx
leaq 0x8(%rsp), %rdi
movl $0x8, %esi
movl $0x1, %edx
movq %rbx, %r8
callq 0x15e878
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
setne %al
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/encdesc_header_io.c
// Function: encdesc_distri_iter_write
static void encdesc_distri_iter_write(GtUword symbol,
                                      GtUint64 freq,
                                      void *data)
{
  EncsecDistriData *this_data = (EncsecDistriData*) data;
  if (!this_data->had_err) {
    this_data->written_elems++;
    this_data->had_err = gt_io_error_fwrite_one(symbol, this_data->fp,
                                                this_data->err);
    if (!this_data->had_err)
      this_data->had_err = gt_io_error_fwrite_one(freq, this_data->fp,
                                                  this_data->err);
  }
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
cmpl $0x0, 0x20(%rdx)
jne 0x145ea8
movq %rdx, %rbx
incq 0x8(%rdx)
movq (%rdx), %rcx
movq 0x18(%rdx), %r8
leaq 0x8(%rsp), %rdi
movl $0x8, %esi
movl $0x1, %edx
callq 0x15e878
movl %eax, 0x20(%rbx)
testl %eax, %eax
jne 0x145ea8
movq (%rbx), %rcx
movq 0x18(%rbx), %r8
movq %rsp, %rdi
movl $0x8, %esi
movl $0x1, %edx
callq 0x15e878
movl %eax, 0x20(%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/extract_feature_stream.c
// Function: gt_extract_feature_stream_set_trans_table
void gt_extract_feature_stream_set_trans_table(GtExtractFeatureStream *es,
                                               GtTransTable *table)
{
  gt_assert(es);
  gt_extract_feature_visitor_set_trans_table((GtExtractFeatureVisitor*)
                         gt_visitor_stream_get_visitor((GtVisitorStream*) es),
                         table);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x146a4f
movq %rsi, %rbx
callq 0x18c977
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
jmp 0x147012
callq 0x42221
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/extract_feature_visitor.c
// Function: gt_extract_feature_visitor_class
const GtNodeVisitorClass* gt_extract_feature_visitor_class()
{
  static const GtNodeVisitorClass *nvc = NULL;
  gt_class_alloc_lock_enter();
  if (!nvc) {
    nvc = gt_node_visitor_class_new(sizeof (GtExtractFeatureVisitor),
                                    extract_feature_visitor_free,
                                    NULL,
                                    extract_feature_visitor_feature_node,
                                    NULL,
                                    NULL,
                                    NULL);
  }
  gt_class_alloc_lock_leave();
  return nvc;
}

// Assembly:
pushq %rax
callq 0xe6a03
cmpq $0x0, 0x382c92(%rip)    # 0x4c9710
jne 0x146aaf
movq $0x0, (%rsp)
leaq 0x2e(%rip), %rsi        # 0x146abd
leaq 0x4f(%rip), %rcx        # 0x146ae5
movl $0x48, %edi
xorl %edx, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x16ae80
movq %rax, 0x382c61(%rip)    # 0x4c9710
callq 0xe6a19
movq 0x382c55(%rip), %rax    # 0x4c9710
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/extract_feature_visitor.c
// Function: gt_extract_feature_visitor_new
GtNodeVisitor* gt_extract_feature_visitor_new(GtRegionMapping *rm,
                                              const char *type, bool join,
                                              bool translate, bool seqid,
                                              bool target, GtUword width,
                                              GtFile *outfp)
{
  GtNodeVisitor *nv;
  GtExtractFeatureVisitor *efv;
  gt_assert(rm);
  nv = gt_node_visitor_create(gt_extract_feature_visitor_class());
  efv= gt_extract_feature_visitor_cast(nv);
  efv->type = gt_symbol(type);
  efv->join = join;
  efv->translate = translate;
  efv->seqid = seqid;
  efv->ttable = NULL;
  efv->target = target;
  efv->coords = false;
  efv->fastaseq_counter = 0;
  efv->region_mapping = rm;
  efv->width = width;
  efv->outfp = outfp;
  /* XXX */
  efv->retain_ids = getenv("GT_RETAINIDS") ? true : false;
  return nv;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, 0x4(%rsp)
movl %r8d, (%rsp)
testq %rdi, %rdi
je 0x146ffd
movl %ecx, %r15d
movl %edx, %r12d
movq %rsi, %rbx
movq %rdi, %r14
callq 0x146a70
movq %rax, %rdi
callq 0x16aef0
movq %rax, %r13
callq 0x146a70
movq %rax, %rdi
movq %r13, %rsi
callq 0x16af21
movq %rax, %rbp
movq %rbx, %rdi
callq 0x12234f
movq %rax, 0x10(%rbp)
movb %r12b, 0x20(%rbp)
movb %r15b, 0x21(%rbp)
movl (%rsp), %eax
movb %al, 0x22(%rbp)
xorl %eax, %eax
movq %rax, 0x18(%rbp)
movl 0x4(%rsp), %ecx
movb %cl, 0x23(%rbp)
movb $0x0, 0x24(%rbp)
movq %rax, 0x28(%rbp)
movq %r14, 0x38(%rbp)
movq 0x40(%rsp), %rax
movq %rax, 0x30(%rbp)
movq 0x48(%rsp), %rax
movq %rax, 0x40(%rbp)
leaq 0x23f339(%rip), %rdi    # 0x386318
callq 0x17950
testq %rax, %rax
setne 0x25(%rbp)
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x423a4
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/feature_in_stream.c
// Function: gt_feature_in_stream_class
const GtNodeStreamClass *gt_feature_in_stream_class(void)
{
  static const GtNodeStreamClass *nsc = NULL;
  gt_class_alloc_lock_enter();
  if (!nsc)
  {
    nsc = gt_node_stream_class_new(sizeof (GtFeatureInStream),
                                   feature_in_stream_free,
                                   feature_in_stream_next);
  }
  gt_class_alloc_lock_leave();
  return nsc;
}

// Assembly:
pushq %rax
callq 0xe6a03
cmpq $0x0, 0x382570(%rip)    # 0x4c9718
jne 0x1471c9
leaq 0x26(%rip), %rsi        # 0x1471d7
leaq 0x65(%rip), %rdx        # 0x14721d
movl $0x28, %edi
callq 0x16abb4
movq %rax, 0x38254f(%rip)    # 0x4c9718
callq 0xe6a19
movq 0x382543(%rip), %rax    # 0x4c9718
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/feature_in_stream.c
// Function: feature_in_stream_free
static void feature_in_stream_free(GtNodeStream *ns)
{
  GtFeatureInStream *stream = feature_in_stream_cast(ns);
  while (gt_queue_size(stream->cache) > 0)
  {
    GtGenomeNode *gn = gt_queue_get(stream->cache);
    gt_genome_node_delete(gn);
  }
  gt_queue_delete(stream->cache);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x14719a
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16ae64
movq %rax, %rbx
movq 0x18(%rax), %rdi
callq 0x112a74
testq %rax, %rax
je 0x147213
movq 0x18(%rbx), %rdi
callq 0x112a12
movq %rax, %rdi
callq 0x14c43a
movq 0x18(%rbx), %rdi
jmp 0x1471f2
movq 0x18(%rbx), %rdi
popq %rbx
jmp 0x112f03
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/feature_in_stream.c
// Function: feature_in_stream_next
static int feature_in_stream_next(GtNodeStream *ns, GtGenomeNode **gn,
                                  GT_UNUSED GtError *error)
{
  GtFeatureInStream *stream = feature_in_stream_cast(ns);
  gt_error_check(error);

  if (!stream->init)
  {
    feature_in_stream_init(stream);
    stream->init = true;
  }

  if (gt_queue_size(stream->cache) > 0)
  {
    GtGenomeNode *node = gt_queue_get(stream->cache);
    GtFeatureNode *fn = gt_feature_node_try_cast(node);
    if (fn)
      gt_genome_node_ref(node);
    *gn = node;
    return 0;
  }

  *gn = NULL;
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
callq 0x14719a
movq %rax, %rdi
movq %r14, %rsi
callq 0x16ae64
movq %rax, %r14
testq %r15, %r15
je 0x14724f
movq %r15, %rdi
callq 0x101a9a
testb %al, %al
jne 0x1472a2
cmpb $0x0, 0x21(%r14)
jne 0x147263
movq %r14, %rdi
callq 0x147034
movb $0x1, 0x21(%r14)
movq 0x18(%r14), %rdi
callq 0x112a74
testq %rax, %rax
je 0x147294
movq 0x18(%r14), %rdi
callq 0x112a12
movq %rax, %r14
movq %rax, %rdi
callq 0x14aefc
testq %rax, %rax
je 0x147297
movq %r14, %rdi
callq 0x14b5fc
jmp 0x147297
xorl %r14d, %r14d
movq %r14, (%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x42488
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/feature_in_stream.c
// Function: gt_feature_in_stream_new
GtNodeStream* gt_feature_in_stream_new(GtFeatureIndex *fi)
{
  GtNodeStream *ns;
  GtFeatureInStream *stream;
  gt_assert(fi);

  ns = gt_node_stream_create(gt_feature_in_stream_class(), true);
  stream = feature_in_stream_cast(ns);
  stream->fi = fi;
  stream->cache = gt_queue_new();
  stream->useorig = false;
  stream->init = false;
  return ns;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1472fe
movq %rdi, %rbx
callq 0x14719a
movq %rax, %rdi
movl $0x1, %esi
callq 0x16abec
movq %rax, %r14
callq 0x14719a
movq %rax, %rdi
movq %r14, %rsi
callq 0x16ae64
movq %rax, %r15
movq %rbx, 0x10(%rax)
callq 0x112908
movq %rax, 0x18(%r15)
movw $0x0, 0x20(%r15)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x424bf
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/gff3_linesorted_out_stream.c
// Function: gt_gff3_linesorted_out_stream_class
const GtNodeStreamClass* gt_gff3_linesorted_out_stream_class(void)
{
  static const GtNodeStreamClass *nsc = NULL;
  gt_class_alloc_lock_enter();
  if (!nsc) {
    nsc = gt_node_stream_class_new(sizeof (GtGFF3LinesortedOutStream),
                                   gff3_linesorted_out_stream_free,
                                   gff3_linesorted_out_stream_next);
  }
  gt_class_alloc_lock_leave();
  return nsc;
}

// Assembly:
pushq %rax
callq 0xe6a03
cmpq $0x0, 0x37be7e(%rip)    # 0x4c9748
jne 0x14d8eb
leaq 0x26(%rip), %rsi        # 0x14d8f9
leaq 0xb6(%rip), %rdx        # 0x14d990
movl $0x58, %edi
callq 0x16abb4
movq %rax, 0x37be5d(%rip)    # 0x4c9748
callq 0xe6a19
movq 0x37be51(%rip), %rax    # 0x4c9748
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x14d98f
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x14d8bc
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16ae64
movq %rax, %rbx
movq 0x18(%rax), %rdi
callq 0xd4a9a
testq %rax, %rax
je 0x14d952
xorl %r14d, %r14d
movq 0x18(%rbx), %rdi
movq %r14, %rsi
callq 0xd47ba
movq (%rax), %rdi
callq 0x14c43a
incq %r14
movq 0x18(%rbx), %rdi
callq 0xd4a9a
cmpq %rax, %r14
jb 0x14d92d
movq 0x10(%rbx), %rdi
callq 0x16ac6e
movq 0x28(%rbx), %rdi
callq 0x121b03
movq 0x40(%rbx), %rdi
callq 0x121b03
movq 0x38(%rbx), %rdi
callq 0x16b162
movq 0x30(%rbx), %rdi
callq 0x11f2f4
movq 0x18(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd4ef4
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x14dbd3
movq %rsi, %r14
movq %rdi, %r15
callq 0x14d8bc
movq %rax, %rdi
movl $0x1, %esi
callq 0x16abec
movq %rax, %rbx
callq 0x14d8bc
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16ae64
movq %rax, %r12
movl $0x8, %edi
callq 0xd46fc
movq %rax, 0x18(%r12)
movq %r15, %rdi
callq 0x16ac58
movq %rax, 0x10(%r12)
movq %r14, 0x20(%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%r12)
movq $0x0, 0x50(%r12)
callq 0x11f0ac
movq %rax, 0x30(%r12)
callq 0x1208f8
movq %rax, 0x28(%r12)
movq %rax, %rdi
callq 0x15317f
movq %rax, 0x38(%r12)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x454cc
// File: /workspace/github_c_makefile_star2_O1/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, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rsi, %rbx
movq %rdi, %rbp
movq (%rdi), %r15
movq %r15, %rdi
movl $0x9, %esi
callq 0x17280
cmpq %r15, %rax
jbe 0x14dfd9
movq %rax, %r13
movq (%rbx), %r12
movq %r12, %rdi
movl $0x9, %esi
callq 0x17280
cmpq %r12, %rax
jbe 0x14dfde
movq %rax, %r14
movq %rbp, 0x10(%rsp)
movq %r13, %rax
subq %r15, %rax
je 0x14dfe3
movq %rbx, 0x8(%rsp)
movq %r14, %rbp
subq %r12, %rbp
je 0x14dfe8
movl $0x1fff, %r12d          # imm = 0x1FFF
cmpq %r12, %rbp
cmovaeq %r12, %rbp
cmpq %r12, %rax
cmovbq %rax, %r12
movq 0x18(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x17370
movq 0x8(%rsp), %rax
movq (%rax), %rsi
movq 0x20(%rsp), %r15
movq %r15, %rdi
movq %rbp, %rdx
callq 0x17370
xorl %eax, %eax
movb %al, (%rbx,%r12)
movb %al, (%r15,%rbp)
incq %r13
movq 0x10(%rsp), %rax
movq %r13, (%rax)
incq %r14
movq 0x8(%rsp), %rax
movq %r14, (%rax)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x45690
callq 0x456c7
callq 0x45735
callq 0x456fe
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0xe6a03
cmpq $0x0, 0x37b752(%rip)    # 0x4c9750
jne 0x14e01f
leaq 0x26(%rip), %rsi        # 0x14e02d
leaq 0x5b(%rip), %rdx        # 0x14e069
movl $0x30, %edi
callq 0x16abb4
movq %rax, 0x37b731(%rip)    # 0x4c9750
callq 0xe6a19
movq 0x37b725(%rip), %rax    # 0x4c9750
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x14dff0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16ae64
movq %rax, %rbx
movq 0x10(%rax), %rdi
callq 0x16ac6e
movq 0x28(%rbx), %rdi
callq 0x16b162
movq 0x18(%rbx), %rdi
callq 0xd4ef4
movq 0x20(%rbx), %rdi
popq %rbx
jmp 0x112f03
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
testq %rdx, %rdx
je 0x14e090
movq %r14, %rdi
callq 0x101a9a
testb %al, %al
jne 0x14e195
callq 0x14dff0
movq %rax, %rdi
movq %r15, %rsi
callq 0x16ae64
movq %rax, %r15
xorl %r12d, %r12d
cmpq $0x0, 0x20(%rax)
jne 0x14e0e5
callq 0x112908
movq %rax, 0x20(%r15)
movq 0x10(%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x16ace8
testl %eax, %eax
jne 0x14e0e2
cmpq $0x0, (%rbx)
je 0x14e143
movq 0x18(%r15), %rdi
movl $0x8, %edx
movq %rbx, %rsi
callq 0xd49ce
jmp 0x14e0b6
movl %eax, %r12d
movq 0x20(%r15), %rdi
testq %rdi, %rdi
sete %al
testl %r12d, %r12d
setne %cl
orb %al, %cl
jne 0x14e136
callq 0x112a74
testq %rax, %rax
je 0x14e133
movq 0x20(%r15), %rdi
callq 0x112a12
testq %rax, %rax
je 0x14e19a
movq %rax, %r13
movq 0x28(%r15), %rsi
movq %rax, %rdi
movq %r14, %rdx
callq 0x14b992
movl %eax, %r12d
testl %eax, %eax
jne 0x14e136
movq %r13, (%rbx)
jmp 0x14e136
xorl %r12d, %r12d
movl %r12d, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x18(%r15), %rdi
leaq -0x275b(%rip), %rsi     # 0x14b9f3
callq 0x14bb66
movq 0x18(%r15), %rdi
callq 0xd4a9a
testq %rax, %rax
je 0x14e0e5
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x18(%r15), %rdi
movq %r13, %rsi
callq 0xd47ba
movq (%rax), %rsi
movq 0x20(%r15), %rdi
callq 0x112923
incq %r13
movq 0x18(%r15), %rdi
callq 0xd4a9a
cmpq %rax, %r13
jb 0x14e167
jmp 0x14e0e5
callq 0x4576c
callq 0x457a3
// File: /workspace/github_c_makefile_star2_O1/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 0x14dff0
movq %rax, %rdi
xorl %esi, %esi
callq 0x16abec
movq %rax, %r15
callq 0x14dff0
movq %rax, %rdi
movq %r15, %rsi
callq 0x16ae64
movq %rax, %r12
movq %r14, %rdi
callq 0x16ac58
movq %rax, 0x10(%r12)
movl $0x8, %edi
callq 0xd46fc
movq %rax, 0x18(%r12)
movq $0x0, 0x20(%r12)
movq %rbx, %rdi
callq 0x1530bc
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_O1/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 0x153a15
movq %rdi, %r14
leaq 0x2378ac(%rip), %rsi    # 0x38b23f
movl $0x18, %edi
movl $0x33, %edx
callq 0x1092b2
movq %rax, %rbx
movq %r14, %xmm1
punpckldq 0x1fcf2e(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x1fcf36(%rip), %xmm1   # 0x3508f0
movq %r14, (%rax)
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
callq 0x17610
divsd 0x221612(%rip), %xmm0   # 0x374fe8
callq 0x17100
cvttsd2si %xmm0, %rax
movq %rax, %rdx
subsd 0x1fd335(%rip), %xmm0   # 0x350d20
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 0x472b1
// File: /workspace/github_c_makefile_star2_O1/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 0x153b66
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 0x153acf
movq %rdx, %r13
movq 0x10(%r15), %rax
subq %rbp, %rax
leaq 0x1(%rbx), %rcx
cmpq %rax, %rdx
movq %rcx, 0x10(%rsp)
jae 0x153add
addq %rbx, %rdi
callq 0xd90d0
movq %rax, %r12
movq 0x8(%r15), %rcx
cmpq $0x1, %rcx
je 0x153b39
movq %rbp, (%rsp)
movq %r14, 0x8(%rsp)
addb $-0x2, %cl
movl $0x1, %ebp
shlq %cl, %rbp
xorl %r14d, %r14d
testq %r13, %rbp
je 0x153abb
movq 0x10(%rsp), %rax
leaq (%rax,%r14), %rsi
movq %r12, %rdi
callq 0xd913c
shrq %rbp
incq %r14
movq 0x8(%r15), %rax
decq %rax
cmpq %rax, %r14
jb 0x153aa5
jmp 0x153b30
leaq 0x2(%rbx), %rdi
callq 0xd90d0
movq %rax, %r12
jmp 0x153b39
addq %rcx, %rdi
callq 0xd90d0
movq %rax, %r12
movq 0x8(%r15), %rcx
testq %rcx, %rcx
je 0x153b39
movq %rbp, (%rsp)
movq %r14, 0x8(%rsp)
addq 0x10(%r15), %r13
subq (%r15), %r13
decb %cl
movl $0x1, %ebp
shlq %cl, %rbp
xorl %r14d, %r14d
testq %r13, %rbp
je 0x153b24
movq 0x10(%rsp), %rax
leaq (%r14,%rax), %rsi
movq %r12, %rdi
callq 0xd913c
shrq %rbp
incq %r14
cmpq 0x8(%r15), %r14
jb 0x153b0e
movq 0x8(%rsp), %r14
movq (%rsp), %rbp
cmpq %r14, %rbp
ja 0x153b54
xorl %r14d, %r14d
movq %r12, %rdi
movq %r14, %rsi
callq 0xd913c
incq %r14
cmpq %rbx, %r14
jb 0x153b41
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x4731f
// File: /workspace/github_c_makefile_star2_O1/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 0x153bb0
movq %rdi, %rbx
leaq 0x2376c4(%rip), %rsi    # 0x38b23f
movl $0x38, %edi
movl $0x74, %edx
callq 0x1092b2
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 0x47356
// File: /workspace/github_c_makefile_star2_O1/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 0x153c8d
movl 0x30(%rdi), %ecx
cmpl $0x1, %ecx
je 0x153bde
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0x153c8c
testb %sil, %sil
je 0x153c2b
incq 0x10(%rdi)
jmp 0x153c32
movq 0x8(%rdi), %rax
movq 0x18(%rdi), %rcx
movzbl %sil, %esi
leaq (%rsi,%rcx,2), %r8
movq %r8, 0x18(%rdi)
leaq 0x8(%rdi), %rsi
leaq 0x1(%rax), %r9
movq %r9, 0x8(%rdi)
movq 0x20(%rdi), %rcx
testq %rcx, %rcx
je 0x153c38
leaq -0x2(%rcx), %r10
cmpq %r10, %rax
jne 0x153c48
movl $0x1, %r9d
shlq %cl, %r9
movq (%rdi), %rcx
subq %rcx, %r9
movl $0x1, %eax
cmpq %r9, %r8
jb 0x153c69
jmp 0x153c8c
movl $0x1, 0x30(%rdi)
movl $0x1, %eax
retq
movq (%rdi), %rax
imulq 0x10(%rdi), %rax
addq %r8, %rax
movq %rax, (%rdx)
jmp 0x153c74
movl $0x1, %eax
cmpq %rcx, %r9
jne 0x153c8c
movq $-0x1, %rax
shlq %cl, %rax
movq (%rdi), %rcx
addq %rcx, %r8
addq %rax, %r8
movq %r8, 0x18(%rdi)
imulq 0x10(%rdi), %rcx
addq %r8, %rcx
movq %rcx, (%rdx)
movl $0x0, 0x30(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
xorl %eax, %eax
retq
retq
pushq %rax
callq 0x4738d
// File: /workspace/github_c_makefile_star2_O1/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 0xe6a03
cmpq $0x0, 0x3756c2(%rip)    # 0x4c9768
jne 0x1540c7
leaq 0x26(%rip), %rsi        # 0x1540d5
leaq 0x7f(%rip), %rdx        # 0x154135
movl $0x30, %edi
callq 0x16abb4
movq %rax, 0x3756a1(%rip)    # 0x4c9768
callq 0xe6a19
movq 0x375695(%rip), %rax    # 0x4c9768
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x154098
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16ae64
movq %rax, %rbx
movq 0x20(%rax), %rdi
leaq 0x237273(%rip), %rsi    # 0x38b36a
movl $0x6a, %edx
callq 0x109670
movq 0x18(%rbx), %rdi
callq 0x18b883
movq 0x10(%rbx), %rdi
callq 0x112a74
testq %rax, %rax
je 0x15412b
movq 0x10(%rbx), %rdi
callq 0x112a12
movq %rax, %rdi
callq 0x14c43a
jmp 0x15410a
movq 0x10(%rbx), %rdi
popq %rbx
jmp 0x112f03
// File: /workspace/github_c_makefile_star2_O1/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 0x15415e
movq %r15, %rdi
callq 0x101a9a
testb %al, %al
jne 0x154272
callq 0x154098
movq %rax, %rdi
movq %r14, %rsi
callq 0x16ae64
movq %rax, %r14
xorl %ebp, %ebp
cmpb $0x0, 0x28(%rax)
jne 0x154233
testq %r15, %r15
je 0x154192
movq %r15, %rdi
callq 0x101a9a
testb %al, %al
jne 0x15427c
testq %r14, %r14
je 0x154277
movq 0x18(%r14), %rdi
callq 0x154328
movq %rax, %r12
movq 0x20(%r14), %rdi
testq %rdi, %rdi
je 0x1541ca
leaq 0x20fd12(%rip), %rsi    # 0x363ec9
movq %r15, %rdx
callq 0x103957
movq %rax, %r13
testq %rax, %rax
setne %al
jmp 0x1541cf
movb $0x1, %al
xorl %r13d, %r13d
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testb %al, %al
je 0x15421e
movq 0x20(%r14), %rax
testq %rax, %rax
leaq 0x1fad1b(%rip), %rdi    # 0x34ef01
cmovneq %rax, %rdi
callq 0x120955
movq %rbx, (%rsp)
movq %rax, %rbx
movq 0x10(%r14), %rsi
movzbl 0x29(%r14), %r8d
movq %r12, %rdi
movq %rax, %rdx
movq %r13, %rcx
movq %r15, %r9
callq 0x1543db
movl %eax, %ebp
movq %rbx, %rdi
movq (%rsp), %rbx
callq 0x121b03
movq %r13, %rdi
callq 0x1040fc
movq %r12, %rdi
callq 0x1556ba
movb $0x1, 0x28(%r14)
testl %ebp, %ebp
jne 0x154261
movq 0x10(%r14), %rdi
callq 0x112a74
movq 0x10(%r14), %rdi
testq %rax, %rax
je 0x154252
callq 0x112a12
xorl %ebp, %ebp
jmp 0x15425e
callq 0x112a74
testq %rax, %rax
jne 0x154281
xorl %eax, %eax
movq %rax, (%rbx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x47434
callq 0x474a2
callq 0x4746b
callq 0x474d9
// File: /workspace/github_c_makefile_star2_O1/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 0x154098
xorl %r14d, %r14d
movq %rax, %rdi
xorl %esi, %esi
callq 0x16abec
movq %rax, %rbx
callq 0x154098
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16ae64
movq %rax, %r12
callq 0x112908
movq %rax, 0x10(%r12)
xorl %eax, %eax
callq 0x18b990
movq %rax, 0x18(%r12)
testq %r15, %r15
je 0x1542df
movq %r15, %rdi
callq 0xe8760
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_O1/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 0x23709a(%rip), %rsi    # 0x38b3d4
movl $0x38, %edi
movl $0x62, %edx
callq 0x1092b2
movq %rax, %r14
leaq -0x4ac24(%rip), %r15    # 0x10972f
leaq -0x4e3dd(%rip), %rdx    # 0x105f7d
movl $0x1, %edi
movq %r15, %rsi
callq 0x105830
movq %rax, (%r14)
leaq -0x3286e(%rip), %r12    # 0x121b03
movl $0x1, %edi
xorl %esi, %esi
movq %r12, %rdx
callq 0x105830
movq %rax, 0x8(%r14)
movl $0x1, %edi
xorl %esi, %esi
movq %r12, %rdx
callq 0x105830
movq %rax, 0x10(%r14)
movl $0x1, %edi
movq %r15, %rsi
movq %r15, %rdx
callq 0x105830
movq %rax, 0x18(%r14)
movl $0x1, %edi
movq %r15, %rsi
movq %r15, %rdx
callq 0x105830
movq %rax, 0x20(%r14)
callq 0x176cd4
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_O1/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 0x1556b0
testq %rsi, %rsi
je 0x1556b0
leaq 0x605(%rip), %rax       # 0x155ca0
movq %rsi, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x105afd
testl %eax, %eax
jne 0x1556b5
xorl %eax, %eax
popq %rcx
retq
callq 0x47b18
callq 0x47b51
// File: /workspace/github_c_makefile_star2_O1/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 0x15570d
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
callq 0x176d0a
movq (%rbx), %rdi
callq 0x105f7d
movq 0x8(%rbx), %rdi
callq 0x105f7d
movq 0x10(%rbx), %rdi
callq 0x105f7d
movq 0x20(%rbx), %rdi
callq 0x105f7d
movq 0x18(%rbx), %rdi
callq 0x105f7d
leaq 0x235cd5(%rip), %rsi    # 0x38b3d4
movq %rbx, %rdi
movl $0x316, %edx            # imm = 0x316
popq %rbx
jmp 0x109670
retq