LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/encdesc_header_io.c
// Function: encdesc_header_io_basics
static inline int encdesc_header_io_basics(GtEncdesc *encdesc,
                                           FILE *fp,
                                           GtIOFunc io_func,
                                           GtError *err)
{
  int had_err = 0;
  had_err = GT_ENCDESC_IO_ONE((encdesc->num_of_descs));
  gt_log_log("num of descs: " GT_WU, encdesc->num_of_descs);
  if (!had_err)
    had_err = GT_ENCDESC_IO_ONE((encdesc->num_of_fields));
  gt_log_log("num of fields: " GT_WU, encdesc->num_of_fields);
  if (!had_err)
    had_err = GT_ENCDESC_IO_ONE((encdesc->num_of_fields_is_const));
  if (encdesc->num_of_fields_is_const)
    gt_log_log("num of fields is a constant");
  else
    gt_log_log("num of fields is variable");
  if (!had_err)
    had_err = GT_ENCDESC_IO_ONE((encdesc->bits_per_field));
  gt_log_log("num of bits per field: %u", encdesc->bits_per_field);
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x38(%rdi), %rdi
pushq $0x8
popq %rsi
pushq $0x1
popq %rdx
movq %r12, %rcx
movq %r15, %r8
callq *%r14
movl %eax, %ebp
movq 0x38(%rbx), %rsi
leaq 0x2483d3(%rip), %rdi    # 0x31cc7d
xorl %eax, %eax
callq 0x92a82
testl %ebp, %ebp
jne 0xd48ca
leaq 0x40(%rbx), %rdi
pushq $0x8
popq %rsi
pushq $0x1
popq %rdx
movq %r12, %rcx
movq %r15, %r8
callq *%r14
movl %eax, %ebp
movq 0x40(%rbx), %rsi
leaq 0x2483ba(%rip), %rdi    # 0x31cc8f
xorl %eax, %eax
callq 0x92a82
testl %ebp, %ebp
jne 0xd48f5
leaq 0x6c(%rbx), %rdi
pushq $0x1
popq %rdx
movq %rdx, %rsi
movq %r12, %rcx
movq %r15, %r8
callq *%r14
movl %eax, %ebp
leaq 0x2483a6(%rip), %rax    # 0x31cca2
leaq 0x2483bb(%rip), %rdi    # 0x31ccbe
cmpb $0x0, 0x6c(%rbx)
cmovneq %rax, %rdi
xorl %eax, %eax
callq 0x92a82
testl %ebp, %ebp
jne 0xd492b
leaq 0x68(%rbx), %rdi
pushq $0x4
popq %rsi
pushq $0x1
popq %rdx
movq %r12, %rcx
movq %r15, %r8
callq *%r14
movl %eax, %ebp
movl 0x68(%rbx), %esi
leaq 0x2483a3(%rip), %rdi    # 0x31ccd8
xorl %eax, %eax
callq 0x92a82
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/encdesc_header_io.c
// Function: io_cons_field_header
static int io_cons_field_header(DescField *field,
                                FILE *fp,
                                GtIOFunc io_func,
                                GtError *err)
{
  int had_err = 0;
  had_err = GT_ENCDESC_IO_ONE(field->len);

  if (!had_err) {
    field->data = gt_realloc(field->data,
                             (size_t) (field->len + 1) * sizeof (char));
    field->data[field->len] = '\0';
    had_err = io_func(field->data, sizeof (char), (size_t) field->len, fp, err);
  }
  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %rax
movq %rsi, %r14
movq %rdi, %r15
leaq 0x50(%rdi), %rdi
pushq $0x8
popq %rsi
pushq $0x1
popq %rdx
movq %r14, %rcx
movq %rbx, %r8
movq %rax, %r12
callq *%rax
testl %eax, %eax
je 0xd4980
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x40(%r15), %rdi
movq 0x50(%r15), %rsi
incq %rsi
leaq 0x2482a2(%rip), %rdx    # 0x31cc34
pushq $0x4c
popq %rcx
callq 0x93472
movq %rax, 0x40(%r15)
movq 0x50(%r15), %rcx
movb $0x0, (%rax,%rcx)
movq 0x40(%r15), %rdi
movq 0x50(%r15), %rdx
pushq $0x1
popq %rsi
movq %r14, %rcx
movq %rbx, %r8
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmpq *%rax
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x8
popq %rsi
pushq $0x1
popq %rdx
movq %rax, %rdi
movq %rbx, %r8
callq 0xf3eb0
testl %eax, %eax
je 0xd57a5
pushq $0x1
popq %rax
jmp 0xd57c4
movq (%r14), %rcx
leaq 0x8(%rsp), %rdi
pushq $0x8
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %r8
callq 0xf3eb0
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_O2/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 0xd583a
movq %rdx, %rbx
incq 0x8(%rdx)
movq (%rdx), %rcx
movq 0x18(%rdx), %r8
leaq 0x8(%rsp), %rdi
pushq $0x8
popq %rsi
pushq $0x1
popq %rdx
callq 0xf3eb0
movl %eax, 0x20(%rbx)
testl %eax, %eax
jne 0xd583a
movq (%rbx), %rcx
movq 0x18(%rbx), %r8
movq %rsp, %rdi
pushq $0x8
popq %rsi
pushq $0x1
popq %rdx
callq 0xf3eb0
movl %eax, 0x20(%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xd6620
movq %rsi, %rbx
callq 0x12bfb9
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
jmp 0xd6d33
movq 0x361941(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x20e9e2(%rip), %rsi    # 0x2e5013
leaq 0x22413c(%rip), %rdx    # 0x2fa774
leaq 0x246cdb(%rip), %rcx    # 0x31d31a
leaq 0x246cae(%rip), %r8     # 0x31d2f4
pushq $0x2f
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x69e97
cmpq $0x0, 0x367012(%rip)    # 0x43d6c0
jne 0xd66da
andq $0x0, (%rsp)
leaq 0x2c(%rip), %rsi        # 0xd66e8
leaq 0x7e(%rip), %rcx        # 0xd6741
pushq $0x48
popq %rdi
xorl %edx, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x102cd0
movq %rax, 0x366fe6(%rip)    # 0x43d6c0
callq 0x69ede
movq 0x366fda(%rip), %rax    # 0x43d6c0
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xd6cb8
movl %ecx, %r15d
movl %edx, %r12d
movq %rsi, %rbx
movq %rdi, %r14
callq 0xd66a0
movq %rax, %rdi
callq 0x102da0
movq %rax, %r13
callq 0xd66a0
movq %rax, %rdi
movq %r13, %rsi
callq 0x102dfe
movq %rax, %rbp
movq %rbx, %rdi
callq 0xaed4b
movq %rax, 0x10(%rbp)
movb %r12b, 0x20(%rbp)
movb %r15b, 0x21(%rbp)
movl (%rsp), %eax
movb %al, 0x22(%rbp)
andq $0x0, 0x18(%rbp)
movl 0x4(%rsp), %eax
movb %al, 0x23(%rbp)
movb $0x0, 0x24(%rbp)
andq $0x0, 0x28(%rbp)
movq %r14, 0x38(%rbp)
movq 0x40(%rsp), %rax
movq %rax, 0x30(%rbp)
movq 0x48(%rsp), %rax
movq %rax, 0x40(%rbp)
leaq 0x246716(%rip), %rdi    # 0x31d3b0
callq 0x17900
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
movq 0x3612a9(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x20e34a(%rip), %rsi    # 0x2e5013
leaq 0x25cf9b(%rip), %rdx    # 0x333c6b
leaq 0x246693(%rip), %rcx    # 0x31d36a
leaq 0x2466ab(%rip), %r8     # 0x31d389
movl $0xc1, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/feature_in_stream.c
// Function: feature_in_stream_init
void feature_in_stream_init(GtFeatureInStream *stream)
{
  GtError *error;
  GtStrArray *seqids;
  GtUword i;

  error = gt_error_new();
  seqids = gt_feature_index_get_seqids(stream->fi, error);

  /* Load all region nodes into the cache */
  for (i = 0; i < gt_str_array_size(seqids); i++)
  {
    GtRange seqrange;
    GtGenomeNode *rn;
    GtStr *seqstr;
    const char *seqid;

    seqid = gt_str_array_get(seqids, i);
    if (stream->useorig)
    {
      gt_feature_index_get_orig_range_for_seqid(stream->fi, &seqrange, seqid,
                                                error);
    }
    else
    {
      gt_feature_index_get_range_for_seqid(stream->fi, &seqrange, seqid, error);
    }

    seqstr = gt_str_new_cstr(seqid);
    rn = gt_region_node_new(seqstr, seqrange.start, seqrange.end);
    gt_queue_add(stream->cache, rn);
    gt_str_delete(seqstr);
  }

  /* Load all feature nodes into the cache */
  for (i = 0; i < gt_str_array_size(seqids); i++)
  {
    GtArray *features;
    const char *seqid;

    seqid = gt_str_array_get(seqids, i);
    features = gt_feature_index_get_features_for_seqid(stream->fi, seqid,error);
    if (gt_array_size(features) > 0)
    {
      gt_array_sort(features, (GtCompare)gt_genome_node_compare);
      gt_array_reverse(features);
      while (gt_array_size(features) > 0)
      {
        GtGenomeNode **fn = gt_array_pop(features);
        gt_queue_add(stream->cache, *fn);
      }
    }
    gt_array_delete(features);
  }

  gt_error_delete(error);
  gt_str_array_delete(seqids);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0x89da4
movq %rax, %r14
movq 0x10(%rbx), %rdi
movq %rax, %rsi
callq 0xd7e9b
movq %rax, %r15
xorl %r12d, %r12d
leaq 0x8(%rsp), %r13
movq %r15, %rdi
callq 0xae61c
cmpq %rax, %r12
jae 0xd6e65
movq %r15, %rdi
movq %r12, %rsi
callq 0xae386
movq %rax, %rbp
movq 0x10(%rbx), %rdi
cmpb $0x1, 0x20(%rbx)
jne 0xd6e21
movq %r13, %rsi
movq %rbp, %rdx
movq %r14, %rcx
callq 0xd7fb6
jmp 0xd6e2f
movq %r13, %rsi
movq %rbp, %rdx
movq %r14, %rcx
callq 0xd7f1c
movq %rbp, %rdi
callq 0xacbd1
movq %rax, %rbp
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rax, %rdi
callq 0x1110cc
movq 0x18(%rbx), %rdi
movq %rax, %rsi
callq 0x9e2d1
movq %rbp, %rdi
callq 0xae103
incq %r12
jmp 0xd6dec
xorl %r12d, %r12d
leaq 0x65dd(%rip), %r13      # 0xdd44c
movq %r15, %rdi
callq 0xae61c
cmpq %rax, %r12
jae 0xd6ee9
movq %r15, %rdi
movq %r12, %rsi
callq 0xae386
movq 0x10(%rbx), %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0xd7bc7
movq %rax, %rbp
movq %rax, %rdi
callq 0x586a4
testq %rax, %rax
je 0xd6edc
movq %rbp, %rdi
movq %r13, %rsi
callq 0x587b0
movq %rbp, %rdi
callq 0x583f9
movq %rbp, %rdi
callq 0x586a4
testq %rax, %rax
je 0xd6edc
movq %rbp, %rdi
callq 0x58247
movq 0x18(%rbx), %rdi
movq (%rax), %rsi
callq 0x9e2d1
jmp 0xd6eb9
movq %rbp, %rdi
callq 0x58eb9
incq %r12
jmp 0xd6e6f
movq %r14, %rdi
callq 0x8a045
movq %r15, %rdi
callq 0xae662
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/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 0x69e97
cmpq $0x0, 0x3667b2(%rip)    # 0x43d6c8
jne 0xd6f35
leaq 0x24(%rip), %rsi        # 0xd6f43
leaq 0x5b(%rip), %rdx        # 0xd6f81
pushq $0x28
popq %rdi
callq 0x102838
movq %rax, 0x366793(%rip)    # 0x43d6c8
callq 0x69ede
movq 0x366787(%rip), %rax    # 0x43d6c8
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xd6f08
movq %rax, %rdi
movq %rbx, %rsi
callq 0x102c81
movq %rax, %rbx
movq 0x18(%rbx), %rdi
callq 0x9e48b
movq 0x18(%rbx), %rdi
testq %rax, %rax
je 0xd6f7b
callq 0x9e411
movq %rax, %rdi
callq 0xde013
jmp 0xd6f5a
popq %rbx
jmp 0x9e9dd
// File: /workspace/github_c_makefile_star2_O2/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 0xd6f08
movq %rax, %rdi
movq %r14, %rsi
callq 0x102c81
movq %rax, %r14
testq %r15, %r15
je 0xd6fb3
movq %r15, %rdi
callq 0x89eb7
testb %al, %al
jne 0xd7006
cmpb $0x0, 0x21(%r14)
jne 0xd6fc7
movq %r14, %rdi
callq 0xd6dbc
movb $0x1, 0x21(%r14)
movq 0x18(%r14), %rdi
callq 0x9e48b
testq %rax, %rax
je 0xd6ff8
movq 0x18(%r14), %rdi
callq 0x9e411
movq %rax, %r14
movq %rax, %rdi
callq 0xdc2f0
testq %rax, %rax
je 0xd6ffb
movq %r14, %rdi
callq 0xdccf8
jmp 0xd6ffb
xorl %r14d, %r14d
movq %r14, (%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0x360f5b(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x20dffc(%rip), %rsi    # 0x2e5013
leaq 0x2465c5(%rip), %rdx    # 0x31d5e3
leaq 0x2465e0(%rip), %rcx    # 0x31d605
leaq 0x2464fc(%rip), %r8     # 0x31d528
pushq $0x66
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0xd7090
movq %rdi, %rbx
callq 0xd6f08
pushq $0x1
popq %rsi
movq %rax, %rdi
callq 0x10289f
movq %rax, %r14
callq 0xd6f08
movq %rax, %rdi
movq %r14, %rsi
callq 0x102c81
movq %rax, %r15
movq %rbx, 0x10(%rax)
callq 0x9e2bc
movq %rax, 0x18(%r15)
andw $0x0, 0x20(%r15)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x360ed1(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x20df72(%rip), %rsi    # 0x2e5013
leaq 0x25cb8f(%rip), %rdx    # 0x333c37
leaq 0x246460(%rip), %rcx    # 0x31d50f
leaq 0x246472(%rip), %r8     # 0x31d528
movl $0x9e, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x69e97
cmpq $0x0, 0x35dbe2(%rip)    # 0x43d6f8
jne 0xdfb35
leaq 0x24(%rip), %rsi        # 0xdfb43
leaq 0xa8(%rip), %rdx        # 0xdfbce
pushq $0x58
popq %rdi
callq 0x102838
movq %rax, 0x35dbc3(%rip)    # 0x43d6f8
callq 0x69ede
movq 0x35dbb7(%rip), %rax    # 0x43d6f8
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xdfbcd
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xdfb08
movq %rax, %rdi
movq %rbx, %rsi
callq 0x102c81
movq %rax, %rbx
xorl %r14d, %r14d
movq 0x18(%rbx), %rdi
callq 0x586a4
cmpq %rax, %r14
jae 0xdfb90
movq 0x18(%rbx), %rdi
movq %r14, %rsi
callq 0x581aa
movq (%rax), %rdi
callq 0xde013
incq %r14
jmp 0xdfb69
movq 0x10(%rbx), %rdi
callq 0x10297b
movq 0x28(%rbx), %rdi
callq 0xae103
movq 0x40(%rbx), %rdi
callq 0xae103
movq 0x38(%rbx), %rdi
callq 0x10327a
movq 0x30(%rbx), %rdi
callq 0xab666
movq 0x18(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x58eb9
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xdfe1b
movq %rsi, %r14
movq %rdi, %r15
callq 0xdfb08
pushq $0x1
popq %rsi
movq %rax, %rdi
callq 0x10289f
movq %rax, %rbx
callq 0xdfb08
movq %rax, %rdi
movq %rbx, %rsi
callq 0x102c81
movq %rax, %r12
pushq $0x8
popq %rdi
callq 0x5809c
movq %rax, 0x18(%r12)
movq %r15, %rdi
callq 0x102934
movq %rax, 0x10(%r12)
movq %r14, 0x20(%r12)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%r12)
andq $0x0, 0x50(%r12)
callq 0xab2f4
movq %rax, 0x30(%r12)
callq 0xacb84
movq %rax, 0x28(%r12)
movq %rax, %rdi
callq 0xe655e
movq %rax, 0x38(%r12)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x358146(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2051e7(%rip), %rsi    # 0x2e5013
leaq 0x20f560(%rip), %rdx    # 0x2ef393
leaq 0x23fc74(%rip), %rcx    # 0x31faae
leaq 0x23fc8f(%rip), %r8     # 0x31fad0
movl $0x11f, %r9d            # imm = 0x11F
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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), %rbp
pushq $0x9
popq %rsi
movq %rbp, %rdi
callq 0x17260
movq %rax, %r13
subq %rbp, %r13
jbe 0xe038d
movq %rax, (%rsp)
movq %r14, 0x8(%rsp)
movq (%r14), %r12
pushq $0x9
popq %rsi
movq %r12, %rdi
callq 0x17260
movq %rax, %r15
subq %r12, %r15
jbe 0xe03b7
movq %rax, %r14
movl $0x1fff, %r12d          # imm = 0x1FFF
cmpq %r12, %r15
cmovaeq %r12, %r15
cmpq %r12, %r13
cmovbq %r13, %r12
movq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq 0x17350
movq 0x8(%rsp), %r13
movq (%r13), %rsi
movq 0x18(%rsp), %rbp
movq %rbp, %rdi
movq %r15, %rdx
callq 0x17350
xorl %eax, %eax
movb %al, (%rbx,%r12)
movb %al, (%rbp,%r15)
movq (%rsp), %rcx
incq %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
incq %r14
movq %r14, (%r13)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x357bd4(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x204c75(%rip), %rsi    # 0x2e5013
leaq 0x23f824(%rip), %rdx    # 0x31fbc9
leaq 0x23f836(%rip), %rcx    # 0x31fbe2
leaq 0x23f71d(%rip), %r8     # 0x31fad0
pushq $0x46
jmp 0xe03df
movq 0x357baa(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x204c4b(%rip), %rsi    # 0x2e5013
leaq 0x23f836(%rip), %rdx    # 0x31fc05
leaq 0x23f80c(%rip), %rcx    # 0x31fbe2
leaq 0x23f6f3(%rip), %r8     # 0x31fad0
pushq $0x48
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 0x69e97
cmpq $0x0, 0x35d302(%rip)    # 0x43d700
jne 0xe041d
leaq 0x24(%rip), %rsi        # 0xe042b
leaq 0x59(%rip), %rdx        # 0xe0467
pushq $0x30
popq %rdi
callq 0x102838
movq %rax, 0x35d2e3(%rip)    # 0x43d700
callq 0x69ede
movq 0x35d2d7(%rip), %rax    # 0x43d700
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xe03f0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x102c81
movq %rax, %rbx
movq 0x10(%rax), %rdi
callq 0x10297b
movq 0x28(%rbx), %rdi
callq 0x10327a
movq 0x18(%rbx), %rdi
callq 0x58eb9
movq 0x20(%rbx), %rdi
popq %rbx
jmp 0x9e9dd
// File: /workspace/github_c_makefile_star2_O2/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, %r15
callq 0xe03f0
movq %rax, %rdi
xorl %esi, %esi
callq 0x10289f
movq %rax, %r14
callq 0xe03f0
movq %rax, %rdi
movq %r14, %rsi
callq 0x102c81
movq %rax, %r12
movq %r15, %rdi
callq 0x102934
movq %rax, 0x10(%r12)
pushq $0x8
popq %rdi
callq 0x5809c
movq %rax, 0x18(%r12)
andq $0x0, 0x20(%r12)
movq %rbx, %rdi
callq 0xe64a1
movq %rax, 0x28(%r12)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xe7003
movq %rdi, %r14
leaq 0x23b312(%rip), %rsi    # 0x322299
pushq $0x18
popq %rdi
pushq $0x33
popq %rdx
callq 0x93160
movq %rax, %rbx
movq %r14, %xmm1
punpckldq 0x20093e(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x200946(%rip), %xmm1   # 0x2e78f0
movq %r14, (%rax)
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
callq 0x175e0
divsd 0x23b2b2(%rip), %xmm0   # 0x322278
callq 0x170f0
cvttsd2si %xmm0, %rax
movq %rax, %rdx
subsd 0x200d45(%rip), %xmm0   # 0x2e7d20
cvttsd2si %xmm0, %rcx
sarq $0x3f, %rdx
andq %rdx, %rcx
orq %rax, %rcx
pushq $0x1
popq %rax
shlq %cl, %rax
movq %rcx, 0x8(%rbx)
movq %rax, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x350f5e(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1fdfff(%rip), %rsi    # 0x2e5013
leaq 0x23b265(%rip), %rdx    # 0x322280
leaq 0x23b269(%rip), %rcx    # 0x32228b
leaq 0x23b270(%rip), %r8     # 0x322299
pushq $0x32
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rax
testq %rdi, %rdi
je 0xe7181
movq %rdi, %r14
movq (%rdi), %rcx
movq 0x8(%rdi), %rdi
movq %rsi, %rax
xorl %edx, %edx
divq %rcx
movq %rax, %rbx
testq %rdi, %rdi
je 0xe7103
movq %rdx, %r12
movq 0x10(%r14), %rax
subq %rcx, %rax
leaq 0x1(%rbx), %rcx
cmpq %rax, %rdx
movq %rcx, (%rsp)
jae 0xe7139
addq %rbx, %rdi
callq 0x5e0b0
movq %rax, %r15
movq 0x8(%r14), %rax
leal -0x2(%rax), %ecx
pushq $0x1
popq %rbp
shlq %cl, %rbp
xorl %r13d, %r13d
leaq -0x1(%rax), %rcx
cmpq %rcx, %r13
jae 0xe710f
testq %r12, %rbp
je 0xe70fb
movq (%rsp), %rax
leaq (%rax,%r13), %rsi
movq %r15, %rdi
callq 0x5e143
movq 0x8(%r14), %rax
shrq %rbp
incq %r13
jmp 0xe70d9
leaq 0x2(%rbx), %rdi
callq 0x5e0b0
movq %rax, %r15
xorl %r14d, %r14d
cmpq %rbx, %r14
jae 0xe7127
movq %r15, %rdi
movq %r14, %rsi
callq 0x5e143
incq %r14
jmp 0xe7112
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
addq %rcx, %rdi
callq 0x5e0b0
movq %rax, %r15
addq 0x10(%r14), %r12
subq (%r14), %r12
movq 0x8(%r14), %rax
leal -0x1(%rax), %ecx
pushq $0x1
popq %rbp
shlq %cl, %rbp
xorl %r13d, %r13d
cmpq %rax, %r13
jae 0xe710f
testq %r12, %rbp
je 0xe7179
movq (%rsp), %rax
leaq (%rax,%r13), %rsi
movq %r15, %rdi
callq 0x5e143
movq 0x8(%r14), %rax
shrq %rbp
incq %r13
jmp 0xe715b
movq 0x350de0(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1fde81(%rip), %rsi    # 0x2e5013
leaq 0x23b116(%rip), %rdx    # 0x3222af
leaq 0x23b126(%rip), %rcx    # 0x3222c6
leaq 0x23b0f2(%rip), %r8     # 0x322299
pushq $0x47
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0xe71f2
movq %rdi, %rbx
leaq 0x23b0d2(%rip), %rsi    # 0x322299
pushq $0x38
popq %rdi
pushq $0x74
popq %rdx
callq 0x93160
movq (%rbx), %rcx
movq %rcx, (%rax)
andl $0x0, 0x30(%rax)
xorps %xmm0, %xmm0
andq $0x0, 0x18(%rax)
movups %xmm0, 0x8(%rax)
movups 0x8(%rbx), %xmm0
movups %xmm0, 0x20(%rax)
popq %rbx
retq
movq 0x350d6f(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1fde10(%rip), %rsi    # 0x2e5013
leaq 0x23b0a5(%rip), %rdx    # 0x3222af
leaq 0x23b0c6(%rip), %rcx    # 0x3222d7
leaq 0x23b081(%rip), %r8     # 0x322299
pushq $0x73
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0xe72e9
movl 0x30(%rdi), %eax
cmpl $0x1, %eax
je 0xe724b
testl %eax, %eax
jne 0xe7293
testb %sil, %sil
je 0xe7297
incq 0x10(%rdi)
jmp 0xe72e5
movq 0x8(%rdi), %r9
movq 0x18(%rdi), %rax
movzbl %sil, %ecx
leaq (%rcx,%rax,2), %r8
movq %r8, 0x18(%rdi)
leaq 0x8(%rdi), %rsi
leaq 0x1(%r9), %rcx
movq %rcx, 0x8(%rdi)
movq 0x20(%rdi), %rax
testq %rax, %rax
je 0xe72a0
leaq -0x2(%rax), %r10
cmpq %r10, %r9
jne 0xe72b0
pushq $0x1
popq %r9
movl %eax, %ecx
shlq %cl, %r9
movq (%rdi), %rax
subq %rax, %r9
cmpq %r9, %r8
jb 0xe72a3
jmp 0xe72e5
pushq $-0x1
jmp 0xe72e7
movl $0x1, 0x30(%rdi)
jmp 0xe72e5
movq (%rdi), %rax
imulq 0x10(%rdi), %rax
addq %r8, %rax
movq %rax, (%rdx)
jmp 0xe72d3
cmpq %rax, %rcx
jne 0xe72e5
pushq $-0x1
popq %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)
andl $0x0, 0x30(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rsi)
andq $0x0, 0x10(%rsi)
xorl %eax, %eax
retq
pushq $0x1
popq %rax
retq
pushq %rax
movq 0x350c77(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1fdd18(%rip), %rsi    # 0x2e5013
leaq 0x23aff3(%rip), %rdx    # 0x3222f5
leaq 0x23aff1(%rip), %rcx    # 0x3222fa
leaq 0x23af89(%rip), %r8     # 0x322299
movl $0x82, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x69e97
cmpq $0x0, 0x355fe6(%rip)    # 0x43d718
jne 0xe7751
leaq 0x24(%rip), %rsi        # 0xe775f
leaq 0x77(%rip), %rdx        # 0xe77b9
pushq $0x30
popq %rdi
callq 0x102838
movq %rax, 0x355fc7(%rip)    # 0x43d718
callq 0x69ede
movq 0x355fbb(%rip), %rax    # 0x43d718
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xe7724
movq %rax, %rdi
movq %rbx, %rsi
callq 0x102c81
movq %rax, %rbx
movq 0x20(%rax), %rdi
leaq 0x23ac43(%rip), %rsi    # 0x3223c4
pushq $0x6a
popq %rdx
callq 0x936f9
movq 0x18(%rbx), %rdi
callq 0x12a832
movq 0x10(%rbx), %rdi
callq 0x9e48b
movq 0x10(%rbx), %rdi
testq %rax, %rax
je 0xe77b3
callq 0x9e411
movq %rax, %rdi
callq 0xde013
jmp 0xe7792
popq %rbx
jmp 0x9e9dd
// File: /workspace/github_c_makefile_star2_O2/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 0xe77e2
movq %r15, %rdi
callq 0x89eb7
testb %al, %al
jne 0xe78ed
callq 0xe7724
movq %rax, %rdi
movq %r14, %rsi
callq 0x102c81
movq %rax, %r14
cmpb $0x0, 0x28(%rax)
jne 0xe78b2
testq %r15, %r15
je 0xe7814
movq %r15, %rdi
callq 0x89eb7
testb %al, %al
jne 0xe7917
movq 0x18(%r14), %rdi
callq 0xe7a18
movq %rax, %r12
movq 0x20(%r14), %rdi
testq %rdi, %rdi
je 0xe784a
leaq 0x2135fd(%rip), %rsi    # 0x2fae2d
movq %r15, %rdx
callq 0x8ce05
testq %rax, %rax
je 0xe7893
movq %rax, %r13
movq %rbx, (%rsp)
movq 0x20(%r14), %rax
jmp 0xe7853
movq %rbx, (%rsp)
xorl %eax, %eax
xorl %r13d, %r13d
testq %rax, %rax
leaq 0x1fe6a4(%rip), %rdi    # 0x2e5f01
cmovneq %rax, %rdi
callq 0xacbd1
movq %rax, %rbx
movq 0x10(%r14), %rsi
movzbl 0x29(%r14), %r8d
movq %r12, %rdi
movq %rax, %rdx
movq %r13, %rcx
movq %r15, %r9
callq 0xe7ab8
movl %eax, %ebp
movq %rbx, %rdi
callq 0xae103
movq (%rsp), %rbx
jmp 0xe7899
pushq $-0x1
popq %rbp
xorl %r13d, %r13d
movq %r13, %rdi
callq 0x8da06
movq %r12, %rdi
callq 0xe8e02
movb $0x1, 0x28(%r14)
testl %ebp, %ebp
jne 0xe78dc
movq 0x10(%r14), %rdi
callq 0x9e48b
movq 0x10(%r14), %rdi
testq %rax, %rax
je 0xe78cb
callq 0x9e411
jmp 0xe78d7
callq 0x9e48b
testq %rax, %rax
jne 0xe7941
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
movq 0x350674(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1fd715(%rip), %rsi    # 0x2e5013
leaq 0x1fd8ba(%rip), %rdx    # 0x2e51bf
leaq 0x23aad5(%rip), %rcx    # 0x3223e1
leaq 0x23aab1(%rip), %r8     # 0x3223c4
pushq $0x54
jmp 0xe7969
movq 0x35064a(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1fd6eb(%rip), %rsi    # 0x2e5013
leaq 0x1fd890(%rip), %rdx    # 0x2e51bf
leaq 0x23aabe(%rip), %rcx    # 0x3223f4
leaq 0x23aa87(%rip), %r8     # 0x3223c4
pushq $0x30
jmp 0xe7969
movq 0x350620(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1fd6c1(%rip), %rsi    # 0x2e5013
leaq 0x230015(%rip), %rdx    # 0x31796e
leaq 0x23aa81(%rip), %rcx    # 0x3223e1
leaq 0x23aa5d(%rip), %r8     # 0x3223c4
pushq $0x61
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0xe7724
xorl %r14d, %r14d
movq %rax, %rdi
xorl %esi, %esi
callq 0x10289f
movq %rax, %rbx
callq 0xe7724
movq %rax, %rdi
movq %rbx, %rsi
callq 0x102c81
movq %rax, %r12
callq 0x9e2bc
movq %rax, 0x10(%r12)
xorl %eax, %eax
callq 0x12aa85
movq %rax, 0x18(%r12)
testq %r15, %r15
je 0xe79d0
movq %r15, %rdi
callq 0x6c2be
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_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x23a9f6(%rip), %rsi    # 0x322420
pushq $0x38
popq %rdi
pushq $0x62
popq %rdx
callq 0x93160
movq %rax, %r14
leaq -0x54200(%rip), %r15    # 0x9383f
leaq -0x58113(%rip), %rdx    # 0x8f933
pushq $0x1
popq %rbp
movl %ebp, %edi
movq %r15, %rsi
callq 0x8f330
movq %rax, (%r14)
leaq -0x3995a(%rip), %r12    # 0xae103
movl %ebp, %edi
xorl %esi, %esi
movq %r12, %rdx
callq 0x8f330
movq %rax, 0x8(%r14)
movl %ebp, %edi
xorl %esi, %esi
movq %r12, %rdx
callq 0x8f330
movq %rax, 0x10(%r14)
movl %ebp, %edi
movq %r15, %rsi
movq %r15, %rdx
callq 0x8f330
movq %rax, 0x18(%r14)
movl %ebp, %edi
movq %r15, %rsi
movq %r15, %rdx
callq 0x8f330
movq %rax, 0x20(%r14)
callq 0x1112c4
movq %rax, 0x28(%r14)
movq %rbx, 0x30(%r14)
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xe8d9c
testq %rsi, %rsi
je 0xe8d9c
leaq 0x5cd(%rip), %rax       # 0xe9354
movq %rsi, %rdi
movq %rax, %rsi
xorl %edx, %edx
callq 0x8f56e
testl %eax, %eax
jne 0xe8dca
xorl %eax, %eax
popq %rcx
retq
movq 0x34f1c5(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1fc266(%rip), %rsi    # 0x2e5013
leaq 0x27d8b2(%rip), %rdx    # 0x366666
leaq 0x239b60(%rip), %rcx    # 0x32291b
leaq 0x23965e(%rip), %r8     # 0x322420
movl $0x177, %r9d            # imm = 0x177
jmp 0xe8df6
movq 0x34f197(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1fc238(%rip), %rsi    # 0x2e5013
leaq 0x1fc89d(%rip), %rdx    # 0x2e567f
leaq 0x239b32(%rip), %rcx    # 0x32291b
leaq 0x239630(%rip), %r8     # 0x322420
movl $0x179, %r9d            # imm = 0x179
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0xe8e55
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
callq 0x1112f4
movq (%rbx), %rdi
callq 0x8f933
movq 0x8(%rbx), %rdi
callq 0x8f933
movq 0x10(%rbx), %rdi
callq 0x8f933
movq 0x20(%rbx), %rdi
callq 0x8f933
movq 0x18(%rbx), %rdi
callq 0x8f933
leaq 0x2395d9(%rip), %rsi    # 0x322420
movq %rbx, %rdi
movl $0x316, %edx            # imm = 0x316
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xe9397
movq %rsi, %rbx
testq %rsi, %rsi
je 0xe9397
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0x586a4
cmpq %rax, %r14
jae 0xe938d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x581aa
movq (%rax), %rdi
callq 0xde013
incq %r14
jmp 0xe9368
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x34ebca(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1fbc6b(%rip), %rsi    # 0x2e5013
leaq 0x27d2b7(%rip), %rdx    # 0x366666
leaq 0x239572(%rip), %rcx    # 0x322928
leaq 0x239063(%rip), %r8     # 0x322420
movl $0x113, %r9d            # imm = 0x113
xorl %eax, %eax
callq 0x17a50
callq 0x17390
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x69e97
cmpq $0x0, 0x354342(%rip)    # 0x43d720
jne 0xe940f
andq $0x0, (%rsp)
leaq 0x31(%rip), %rsi        # 0xe941d
leaq 0x8f(%rip), %rdx        # 0xe9482
leaq 0x113(%rip), %rcx       # 0xe950d
pushq $0x38
popq %rdi
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x102cd0
movq %rax, 0x354311(%rip)    # 0x43d720
callq 0x69ede
movq 0x354305(%rip), %rax    # 0x43d720
popq %rcx
retq