LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/select_visitor.c
// Function: gt_select_visitor_class
const GtNodeVisitorClass* gt_select_visitor_class()
{
  static GtNodeVisitorClass *nvc = NULL;
  if (!nvc) {
    nvc = gt_node_visitor_class_new(sizeof (GtSelectVisitor),
                                    select_visitor_free,
                                    select_visitor_comment_node,
                                    select_visitor_feature_node,
                                    select_visitor_region_node,
                                    select_visitor_sequence_node,
                                    select_visitor_eof_node);
    gt_node_visitor_class_set_meta_node_func(nvc, select_visitor_meta_node);
  }
  return nvc;
}

// Assembly:
cmpq $0x0, 0x34f350(%rip)    # 0x4c9860
jne 0x17a565
pushq %rax
leaq 0x7b4(%rip), %rax       # 0x17acce
movq %rax, (%rsp)
leaq 0x48(%rip), %rsi        # 0x17a56d
leaq 0xd9(%rip), %rdx        # 0x17a605
leaq 0x118(%rip), %rcx       # 0x17a64b
leaq 0x5f8(%rip), %r8        # 0x17ab32
leaq 0x6f2(%rip), %r9        # 0x17ac33
movl $0xc8, %edi
callq 0x16ae80
movq %rax, 0x34f30e(%rip)    # 0x4c9860
leaq 0x7bb(%rip), %rsi       # 0x17ad14
movq %rax, %rdi
callq 0x16aee0
addq $0x8, %rsp
movq 0x34f2f4(%rip), %rax    # 0x4c9860
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/select_visitor.c
// Function: select_visitor_free
static void select_visitor_free(GtNodeVisitor *nv)
{
  int i;
  GtSelectVisitor *select_visitor = select_visitor_cast(nv);
  gt_str_delete(select_visitor->source);
  gt_str_delete(select_visitor->seqid);
  if (gt_array_size(select_visitor->script_filters) > 0) {
    for (i = 0; i < gt_array_size(select_visitor->script_filters); i++) {
      GtScriptFilter *todelete =
            *(GtScriptFilter**) gt_array_get(select_visitor->script_filters, i);
      gt_script_filter_delete(todelete);
    }
  }
  gt_array_delete(select_visitor->script_filters);
  gt_queue_delete(select_visitor->node_buffer);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x17a508
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16af21
movq %rax, %rbx
movq 0x20(%rax), %rdi
callq 0x121b03
movq 0x18(%rbx), %rdi
callq 0x121b03
movq 0xb0(%rbx), %rdi
callq 0xd4a9a
testq %rax, %rax
je 0x17a5e9
movq 0xb0(%rbx), %rdi
callq 0xd4a9a
testq %rax, %rax
je 0x17a5e9
xorl %r14d, %r14d
movq 0xb0(%rbx), %rdi
movq %r14, %rsi
callq 0xd47ba
movq (%rax), %rdi
callq 0x17a215
incq %r14
movq 0xb0(%rbx), %rdi
callq 0xd4a9a
cmpq %r14, %rax
ja 0x17a5be
movq 0xb0(%rbx), %rdi
callq 0xd4ef4
movq 0x10(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x112f03
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/select_visitor.c
// Function: select_visitor_comment_node
static int select_visitor_comment_node(GtNodeVisitor *nv, GtCommentNode *c,
                                       GT_UNUSED GtError *err)
{
  GtSelectVisitor *select_visitor;
  gt_error_check(err);
  select_visitor = select_visitor_cast(nv);
  gt_queue_add(select_visitor->node_buffer, c);
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0x17a620
movq %rdx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x17a646
callq 0x17a508
movq %rax, %rdi
movq %r14, %rsi
callq 0x16af21
movq 0x10(%rax), %rdi
movq %rbx, %rsi
callq 0x112923
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x5496a
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/select_visitor.c
// Function: select_visitor_region_node
static int select_visitor_region_node(GtNodeVisitor *nv, GtRegionNode *rn,
                                      GT_UNUSED GtError *err)
{
  GtSelectVisitor *select_visitor;
  gt_error_check(err);
  select_visitor = select_visitor_cast(nv);
  if (!gt_str_length(select_visitor->seqid) || /* no seqid was specified */
      !gt_str_cmp(select_visitor->seqid,       /* or seqids are equal */
               gt_genome_node_get_seqid((GtGenomeNode*) rn))) {
    if (select_visitor->contain_range.start != GT_UNDEF_UWORD) {
      GtRange range = gt_genome_node_get_range((GtGenomeNode*) rn);
      if (gt_range_overlap(&range, &select_visitor->contain_range)) {
        /* an overlapping contain range was defined -> update range  */
        range.start = GT_MAX(range.start, select_visitor->contain_range.start);
        range.end = GT_MIN(range.end, select_visitor->contain_range.end);
        gt_genome_node_set_range((GtGenomeNode*) rn, &range);
        gt_queue_add(select_visitor->node_buffer, rn);
      }
      else {
        /* contain range does not overlap with <rn> range -> handle <rn> */
        select_visitor->drophandler((GtGenomeNode*) rn, select_visitor->data,
                                    err);
        gt_genome_node_delete((GtGenomeNode*) rn);
      }
    }
    else
      gt_queue_add(select_visitor->node_buffer, rn);
  }
  else {
    select_visitor->drophandler((GtGenomeNode*) rn, select_visitor->data, err);
    gt_genome_node_delete((GtGenomeNode*) rn);
  }
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
testq %rdx, %rdx
je 0x17ab5b
movq %r14, %rdi
callq 0x101a9a
testb %al, %al
jne 0x17ac2e
callq 0x17a508
movq %rax, %rdi
movq %r15, %rsi
callq 0x16af21
movq %rax, %r15
movq 0x18(%rax), %rdi
callq 0x120d4c
testq %rax, %rax
je 0x17ab97
movq 0x18(%r15), %r12
movq %rbx, %rdi
callq 0x14b89b
movq %r12, %rdi
movq %rax, %rsi
callq 0x120dc8
testl %eax, %eax
jne 0x17ac04
cmpq $-0x1, 0x28(%r15)
je 0x17abf6
movq %r15, %r12
addq $0x28, %r12
movq %rbx, %rdi
callq 0x14b8df
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
movq %rdx, 0x8(%rdi)
movq %r12, %rsi
callq 0x117826
testb %al, %al
je 0x17ac04
movq 0x28(%r15), %rax
leaq 0x8(%rsp), %rsi
movq (%rsi), %rcx
cmpq %rax, %rcx
cmovaq %rcx, %rax
movq 0x8(%rsi), %rcx
movq %rax, (%rsi)
movq 0x30(%r15), %rax
cmpq %rax, %rcx
cmovbq %rcx, %rax
movq %rax, 0x8(%rsi)
movq %rbx, %rdi
callq 0x14b940
movq 0x10(%r15), %rdi
movq %rbx, %rsi
callq 0x112923
jmp 0x17ac20
movq 0xc0(%r15), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq *0xb8(%r15)
movq %rbx, %rdi
callq 0x14c43a
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x54bd7
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/select_visitor.c
// Function: select_visitor_sequence_node
static int select_visitor_sequence_node(GtNodeVisitor *nv, GtSequenceNode *sn,
                                        GT_UNUSED GtError *err)
{
  GtSelectVisitor *select_visitor;
  gt_error_check(err);
  select_visitor = select_visitor_cast(nv);
  if (!gt_str_length(select_visitor->seqid) || /* no seqid was specified */
      !gt_str_cmp(select_visitor->seqid,       /* or seqids are equal */
                  gt_genome_node_get_seqid((GtGenomeNode*) sn))) {
    gt_queue_add(select_visitor->node_buffer, sn);
  }
  else {
    select_visitor->drophandler((GtGenomeNode*) sn, select_visitor->data, err);
    gt_genome_node_delete((GtGenomeNode*) sn);
  }
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
testq %rdx, %rdx
je 0x17ac55
movq %r14, %rdi
callq 0x101a9a
testb %al, %al
jne 0x17acc9
callq 0x17a508
movq %rax, %rdi
movq %r15, %rsi
callq 0x16af21
movq %rax, %r15
movq 0x18(%rax), %rdi
callq 0x120d4c
testq %rax, %rax
je 0x17acaf
movq 0x18(%r15), %r12
movq %rbx, %rdi
callq 0x14b89b
movq %r12, %rdi
movq %rax, %rsi
callq 0x120dc8
testl %eax, %eax
je 0x17acaf
movq 0xc0(%r15), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq *0xb8(%r15)
movq %rbx, %rdi
callq 0x14c43a
jmp 0x17acbb
movq 0x10(%r15), %rdi
movq %rbx, %rsi
callq 0x112923
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x54c10
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/select_visitor.c
// Function: select_visitor_eof_node
static int select_visitor_eof_node(GtNodeVisitor *nv, GtEOFNode *eofn,
                                   GT_UNUSED GtError *err)
{
  GtSelectVisitor *select_visitor;
  gt_error_check(err);
  select_visitor = select_visitor_cast(nv);
  gt_queue_add(select_visitor->node_buffer, eofn);
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0x17ace9
movq %rdx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x17ad0f
callq 0x17a508
movq %rax, %rdi
movq %r14, %rsi
callq 0x16af21
movq 0x10(%rax), %rdi
movq %rbx, %rsi
callq 0x112923
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x54c49
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/select_visitor.c
// Function: select_visitor_meta_node
static int select_visitor_meta_node(GtNodeVisitor *nv, GtMetaNode *mn,
                                    GT_UNUSED GtError *err)
{
  GtSelectVisitor *select_visitor;
  gt_error_check(err);
  select_visitor = select_visitor_cast(nv);
  gt_queue_add(select_visitor->node_buffer, mn);
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0x17ad2f
movq %rdx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x17ad55
callq 0x17a508
movq %rax, %rdi
movq %r14, %rsi
callq 0x16af21
movq 0x10(%rax), %rdi
movq %rbx, %rsi
callq 0x112923
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x54c82
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/seqid2file.c
// Function: gt_seqid2file_info_new
GtSeqid2FileInfo* gt_seqid2file_info_new(void)
{
  GtSeqid2FileInfo *s2fi = gt_calloc(1, sizeof *s2fi);
  s2fi->seqfiles = gt_str_array_new();
  s2fi->seqfile = gt_str_new();
  s2fi->encseq = gt_str_new();
  s2fi->region_mapping = gt_str_new();
  return s2fi;
}

// Assembly:
pushq %rbx
leaq 0x220a69(%rip), %rdx    # 0x39ba91
movl $0x1, %edi
movl $0x28, %esi
movl $0x23, %ecx
callq 0x1093ef
movq %rax, %rbx
callq 0x121b54
movq %rax, (%rbx)
callq 0x1208f8
movq %rax, 0x10(%rbx)
callq 0x1208f8
movq %rax, 0x18(%rbx)
callq 0x1208f8
movq %rax, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/seqid2file.c
// Function: gt_seqid2file_info_delete
void gt_seqid2file_info_delete(GtSeqid2FileInfo *s2fi)
{
  if (!s2fi) return;
  gt_str_delete(s2fi->region_mapping);
  gt_str_delete(s2fi->seqfile);
  gt_str_delete(s2fi->encseq);
  gt_str_array_delete(s2fi->seqfiles);
  gt_free(s2fi);
}

// Assembly:
testq %rdi, %rdi
je 0x17b0a8
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
callq 0x121b03
movq 0x10(%rbx), %rdi
callq 0x121b03
movq 0x18(%rbx), %rdi
callq 0x121b03
movq (%rbx), %rdi
callq 0x121e8b
leaq 0x2209f7(%rip), %rsi    # 0x39ba91
movq %rbx, %rdi
movl $0x32, %edx
popq %rbx
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/seqid2file.c
// Function: seqid2file_check
static int seqid2file_check(void *data, GT_UNUSED GtError *err)
{
  GtSeqid2FileInfo *info = (GtSeqid2FileInfo*) data;
  gt_error_check(err);
  gt_assert(info);
  if (gt_str_length(info->seqfile)) {
    gt_assert(!gt_str_array_size(info->seqfiles));
    gt_str_array_add(info->seqfiles, info->seqfile);
  }
  return 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testq %rsi, %rsi
je 0x17b327
movq %rsi, %rdi
callq 0x101a9a
testb %al, %al
jne 0x17b35c
testq %rbx, %rbx
je 0x17b357
movq 0x10(%rbx), %rdi
callq 0x120d4c
testq %rax, %rax
je 0x17b353
movq (%rbx), %rdi
callq 0x121e78
testq %rax, %rax
jne 0x17b361
movq (%rbx), %rdi
movq 0x10(%rbx), %rsi
callq 0x121cc0
xorl %eax, %eax
popq %rbx
retq
callq 0x54dd0
callq 0x54d62
callq 0x54d99
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/seqid2file.c
// Function: gt_seqid2file_region_mapping_new
GtRegionMapping* gt_seqid2file_region_mapping_new(GtSeqid2FileInfo *s2fi,
                                                  GtError *err)
{
  GtRegionMapping *rm = NULL;
  gt_error_check(err);
  gt_assert(s2fi);

  s2fi->matchdesc = s2fi->matchdesc || s2fi->matchdescstart;
  /* create region mapping */
  if (gt_str_array_size(s2fi->seqfiles)) {
    rm = gt_region_mapping_new_seqfiles(s2fi->seqfiles, s2fi->matchdesc,
                                        s2fi->usedesc);
  } else if (gt_str_length(s2fi->encseq)) {
    GtEncseqLoader *el;
    GtEncseq *encseq;
    el = gt_encseq_loader_new();
    gt_encseq_loader_disable_autosupport(el);
    gt_encseq_loader_require_md5_support(el);
    gt_encseq_loader_require_lossless_support(el);
    gt_encseq_loader_require_description_support(el);
    encseq = gt_encseq_loader_load(el, gt_str_get(s2fi->encseq), err);
    gt_encseq_loader_delete(el);
    if (!encseq)
      rm = NULL;
    else {
      rm = gt_region_mapping_new_encseq(encseq, s2fi->matchdesc,
                                        s2fi->usedesc);
      gt_encseq_delete(encseq);
    }
  } else {
    rm = gt_region_mapping_new_mapping(s2fi->region_mapping, err);
  }
  if (rm && s2fi->matchdescstart)
    gt_region_mapping_enable_match_desc_start(rm);
  gt_assert(rm || gt_error_is_set(err));
  return rm;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0x17b3e0
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x17b4f9
testq %r14, %r14
je 0x17b4f4
movb $0x1, %al
cmpb $0x0, 0x8(%r14)
jne 0x17b3f6
movb 0xa(%r14), %al
movb %al, 0x8(%r14)
movq (%r14), %rdi
callq 0x121e78
testq %rax, %rax
je 0x17b43d
movq (%r14), %rdi
movzbl 0x8(%r14), %esi
movzbl 0x9(%r14), %edx
callq 0x17594d
movq %rax, %r15
testq %r15, %r15
je 0x17b4c0
cmpb $0x1, 0xa(%r14)
jne 0x17b4cc
movq %r15, %rdi
callq 0x175a7b
jmp 0x17b4cc
movq 0x18(%r14), %rdi
callq 0x120d4c
testq %rax, %rax
je 0x17b4db
callq 0xf36ef
movq %rax, %r15
movq %rax, %rdi
callq 0xf69cc
movq %r15, %rdi
callq 0xf69b7
movq %r15, %rdi
callq 0xf69b2
movq %r15, %rdi
callq 0xf6ac6
movq 0x18(%r14), %rdi
callq 0x120d23
movq %r15, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0xf374b
movq %rax, %r12
movq %r15, %rdi
callq 0xf424d
testq %r12, %r12
je 0x17b4ec
movzbl 0x8(%r14), %esi
movzbl 0x9(%r14), %edx
movq %r12, %rdi
callq 0x1759b6
movq %rax, %r15
movq %r12, %rdi
callq 0xee90c
jmp 0x17b41c
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
je 0x17b4fe
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x20(%r14), %rdi
movq %rbx, %rsi
callq 0x175860
jmp 0x17b419
xorl %r15d, %r15d
jmp 0x17b41c
callq 0x54e79
callq 0x54e07
callq 0x54e40
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/seqpos_classifier.c
// Function: gt_seqpos_classifier_new
GtSeqposClassifier *gt_seqpos_classifier_new(const char *filename,
    const char *feature_type)
{
  GtSeqposClassifier *seqpos_classifier;
  seqpos_classifier = gt_malloc(sizeof (GtSeqposClassifier));
  seqpos_classifier->annotation_stream = gt_gff3_in_stream_new_sorted(filename);
  seqpos_classifier->fn = NULL;
  seqpos_classifier->fni = NULL;
  seqpos_classifier->gn = NULL;
  seqpos_classifier->nof_specified_ft_found = 0;
  seqpos_classifier->specified_ft = feature_type;
  return seqpos_classifier;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x2203f7(%rip), %rsi    # 0x39c07d
movl $0x40, %edi
movl $0x2c, %edx
callq 0x1092b2
movq %rax, %r15
movq %r14, %rdi
callq 0x14d0a8
movq %rax, (%r15)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r15)
movups %xmm0, 0x18(%r15)
movq %rbx, 0x38(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/seqpos_classifier.c
// Function: gt_seqpos_classifier_next_specified_ft
static int gt_seqpos_classifier_next_specified_ft(
    GtSeqposClassifier *seqpos_classifier, GtRange *range,
    bool *end_of_annotation, GtError *err)
{
  int had_err = 0;
  GtFeatureNode *cfn;
  bool fni_exhausted = (seqpos_classifier->fni == NULL) ? true : false;
  gt_assert(seqpos_classifier != NULL);
  gt_assert(range != NULL);
  while (true)
  {
    if (fni_exhausted)
    {
      had_err = gt_seqpos_classifier_next_fn(seqpos_classifier, err);
      if (had_err != 0 || seqpos_classifier->fn == NULL)
      {
        *end_of_annotation = true;
        return had_err;
      }
      fni_exhausted = false;
    }
    gt_assert(seqpos_classifier->fni != NULL);
    cfn = gt_feature_node_iterator_next(seqpos_classifier->fni);
    if (cfn == NULL)
    {
      fni_exhausted = true;
    }
    else if (strcmp(gt_feature_node_get_type(cfn),
          seqpos_classifier->specified_ft) == 0)
    {
      seqpos_classifier->nof_specified_ft_found++;
      *range = gt_genome_node_get_range((GtGenomeNode*)cfn);
      gt_assert(range->start > 0);
      gt_assert(range->end > 0);
      range->start--;
      range->end--;
      *end_of_annotation = false;
      return had_err;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x17bf39
movq %rsi, %r14
movq %rdx, (%rsp)
testq %rsi, %rsi
je 0x17bf3e
movq %rcx, %r15
movq %rdi, %r12
cmpq $0x0, 0x18(%rdi)
sete %cl
leaq 0x8(%rdi), %r13
movl %ecx, %ebx
testb $0x1, %cl
je 0x17beb2
movq 0x18(%r12), %rdi
testq %rdi, %rdi
je 0x17be50
callq 0x14b3d0
movq $0x0, 0x18(%r12)
movq (%r13), %rdi
testq %rdi, %rdi
je 0x17be5e
callq 0x14c43a
movq (%r12), %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x16ace8
movl %eax, %ebp
testl %eax, %eax
jne 0x17be9a
movq (%r13), %rdi
testq %rdi, %rdi
je 0x17be9a
callq 0x14aefc
movq %rax, 0x10(%r12)
testq %rax, %rax
je 0x17be50
movq %rax, %rdi
callq 0x14b1a8
movq %rax, 0x18(%r12)
jmp 0x17bea2
xorps %xmm0, %xmm0
movups %xmm0, (%r13)
movb $0x1, %al
testl %ebp, %ebp
jne 0x17bf1d
cmpq $0x0, 0x10(%r12)
je 0x17bf1d
xorl %ebx, %ebx
movq 0x18(%r12), %rdi
testq %rdi, %rdi
je 0x17bf34
callq 0x14b33e
movb $0x1, %cl
testq %rax, %rax
je 0x17be31
movq %rax, %rbp
movq %rax, %rdi
callq 0x149bb2
movq 0x38(%r12), %rsi
movq %rax, %rdi
callq 0x17a40
movl %ebx, %ecx
testl %eax, %eax
jne 0x17be31
incq 0x20(%r12)
movq %rbp, %rdi
callq 0x14b8df
movq %rax, (%r14)
movq %rdx, 0x8(%r14)
testq %rax, %rax
je 0x17bf43
testq %rdx, %rdx
je 0x17bf48
decq %rax
movq %rax, (%r14)
decq %rdx
movq %rdx, 0x8(%r14)
xorl %eax, %eax
xorl %ebp, %ebp
movq (%rsp), %rcx
movb %al, (%rcx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x5531c
callq 0x5538a
callq 0x55353
callq 0x552e5
callq 0x552ae
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/seqpos_classifier.c
// Function: gt_seqpos_classifier_delete
void gt_seqpos_classifier_delete(GtSeqposClassifier *seqpos_classifier)
{
  if (seqpos_classifier != NULL)
  {
    if (seqpos_classifier->fni != NULL)
    {
      gt_feature_node_iterator_delete(seqpos_classifier->fni);
    }
    if (seqpos_classifier->gn != NULL)
    {
      gt_genome_node_delete(seqpos_classifier->gn);
    }
    gt_node_stream_delete(seqpos_classifier->annotation_stream);
    gt_free(seqpos_classifier);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x17bf9f
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x17bf74
callq 0x14b3d0
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x17bf82
callq 0x14c43a
movq (%rbx), %rdi
callq 0x16ac6e
leaq 0x2200ec(%rip), %rsi    # 0x39c07d
movq %rbx, %rdi
movl $0xea, %edx
popq %rbx
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/sequence_node_add_stream.c
// Function: gt_sequence_node_add_stream_class
const GtNodeStreamClass* gt_sequence_node_add_stream_class(void)
{
  static const GtNodeStreamClass *nsc = NULL;
  gt_class_alloc_lock_enter();
  if (!nsc) {
    nsc = gt_node_stream_class_new(sizeof (GtSequenceNodeAddStream),
                                   sequence_node_add_stream_free,
                                   sequence_node_add_stream_next);
  }
  gt_class_alloc_lock_leave();
  return nsc;
}

// Assembly:
pushq %rax
callq 0xe6a03
cmpq $0x0, 0x34d6ba(%rip)    # 0x4c9870
jne 0x17c1d7
leaq 0x26(%rip), %rsi        # 0x17c1e5
leaq 0x5b(%rip), %rdx        # 0x17c221
movl $0x40, %edi
callq 0x16abb4
movq %rax, 0x34d699(%rip)    # 0x4c9870
callq 0xe6a19
movq 0x34d68d(%rip), %rax    # 0x4c9870
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/sequence_node_add_stream.c
// Function: sequence_node_add_stream_free
static void sequence_node_add_stream_free(GtNodeStream *ns)
{
  GtSequenceNodeAddStream *fs = gt_sequence_node_add_stream_cast(ns);
  gt_node_visitor_delete(fs->collect_vis);
  gt_cstr_table_delete(fs->seqid_table);
  gt_str_array_delete(fs->seqids);
  gt_node_stream_delete(fs->in_stream);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x17c1a8
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16ae64
movq %rax, %rbx
movq 0x18(%rax), %rdi
callq 0x16b162
movq 0x20(%rbx), %rdi
callq 0xe9120
movq 0x28(%rbx), %rdi
callq 0x121e8b
movq 0x10(%rbx), %rdi
popq %rbx
jmp 0x16ac6e
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/sequence_node_add_stream.c
// Function: gt_sequence_node_add_stream_new
GtNodeStream* gt_sequence_node_add_stream_new(GtNodeStream *in_stream,
                                              GtRegionMapping *rm,
                                              GT_UNUSED GtError *err)
{
  GtNodeStream *ns = gt_node_stream_create(gt_sequence_node_add_stream_class(),
                                           gt_node_stream_is_sorted(in_stream));
  GtSequenceNodeAddStream *s = gt_sequence_node_add_stream_cast(ns);
  gt_assert(in_stream);
  s->rm = rm;
  s->in_stream = gt_node_stream_ref(in_stream);
  s->seqid_table = gt_cstr_table_new();
  s->seqids = NULL;
  s->cur_seqid = 0;
  s->collect_vis = gt_collect_ids_visitor_new(s->seqid_table);
  return ns;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %r14
callq 0x17c1a8
movq %rax, %rbx
movq %r14, %rdi
callq 0x16ae51
movzbl %al, %esi
movq %rbx, %rdi
callq 0x16abec
movq %rax, %rbx
callq 0x17c1a8
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16ae64
testq %r14, %r14
je 0x17c442
movq %rax, %r12
movq %r15, 0x30(%rax)
movq %r14, %rdi
callq 0x16ac58
movq %rax, 0x10(%r12)
callq 0xe8d9c
movq %rax, 0x20(%r12)
xorl %ecx, %ecx
movq %rcx, 0x28(%r12)
movq %rcx, 0x38(%r12)
movq %rax, %rdi
callq 0x12f1f8
movq %rax, 0x18(%r12)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x555b2
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/sequence_node_out_stream.c
// Function: gt_sequence_node_out_stream_class
const GtNodeStreamClass* gt_sequence_node_out_stream_class(void)
{
  static const GtNodeStreamClass *nsc = NULL;
  gt_class_alloc_lock_enter();
  if (!nsc) {
    nsc = gt_node_stream_class_new(sizeof (GtSequenceNodeOutStream),
                                   sequence_node_out_stream_free,
                                   sequence_node_out_stream_next);
  }
  gt_class_alloc_lock_leave();
  return nsc;
}

// Assembly:
pushq %rax
callq 0xe6a03
cmpq $0x0, 0x34d422(%rip)    # 0x4c9878
jne 0x17c477
leaq 0x26(%rip), %rsi        # 0x17c485
leaq 0x49(%rip), %rdx        # 0x17c4af
movl $0x20, %edi
callq 0x16abb4
movq %rax, 0x34d401(%rip)    # 0x4c9878
callq 0xe6a19
movq 0x34d3f5(%rip), %rax    # 0x4c9878
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/sequence_node_out_stream.c
// Function: sequence_node_out_stream_next
static int sequence_node_out_stream_next(GtNodeStream *ns, GtGenomeNode **gn,
                                         GtError *err)
{
  GtSequenceNodeOutStream *fs;
  int had_err;
  gt_error_check(err);
  fs = gt_sequence_node_out_stream_cast(ns);

  /* we still have nodes in the buffer */
  if (gt_sequence_node_out_visitor_node_buffer_size(
                                               fs->sequence_node_out_visitor)) {
    /* return one of them */
    *gn = gt_sequence_node_out_visitor_get_node(fs->sequence_node_out_visitor);
    return 0;
  }

  /* no nodes in the buffer -> get new nodes */
  while (!(had_err = gt_node_stream_next(fs->in_stream, gn, err)) && *gn) {
    gt_assert(*gn && !had_err);
    had_err = gt_genome_node_accept(*gn, fs->sequence_node_out_visitor, err);
    if (had_err) {
      /* we own the node -> delete it */
      gt_genome_node_delete(*gn);
      *gn = NULL;
      break;
    }
    if (gt_sequence_node_out_visitor_node_buffer_size(
                                               fs->sequence_node_out_visitor)) {
     *gn = gt_sequence_node_out_visitor_get_node(fs->sequence_node_out_visitor);
     return 0;
    }
  }

  /* either we have an error or no new node */
  gt_assert(had_err || !*gn);
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
testq %rdx, %rdx
je 0x17c4d4
movq %r14, %rdi
callq 0x101a9a
testb %al, %al
jne 0x17c569
callq 0x17c448
movq %rax, %rdi
movq %r15, %rsi
callq 0x16ae64
movq %rax, %r15
movq 0x18(%rax), %rdi
callq 0x17c941
testq %rax, %rax
jne 0x17c526
movq 0x10(%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x16ace8
testl %eax, %eax
jne 0x17c541
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x17c545
movq 0x18(%r15), %rsi
movq %r14, %rdx
callq 0x14b992
testl %eax, %eax
jne 0x17c549
movq 0x18(%r15), %rdi
jmp 0x17c4eb
movq 0x18(%r15), %rdi
callq 0x17c95f
movq %rax, (%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %ebp
jmp 0x17c55a
xorl %ebp, %ebp
jmp 0x17c55a
movl %eax, %ebp
movq (%rbx), %rdi
callq 0x14c43a
movq $0x0, (%rbx)
testl %ebp, %ebp
jne 0x17c534
cmpq $0x0, (%rbx)
je 0x17c534
callq 0x55620
callq 0x555e9
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/sequence_node_out_stream.c
// Function: gt_sequence_node_out_stream_new
GtNodeStream* gt_sequence_node_out_stream_new(GtNodeStream *in_stream,
                                              GtFile *outfile,
                                              GT_UNUSED GtError *err)
{
  GtNodeStream *ns = gt_node_stream_create(gt_sequence_node_out_stream_class(),
                                           gt_node_stream_is_sorted(in_stream));
  GtSequenceNodeOutStream *s = gt_sequence_node_out_stream_cast(ns);
  gt_assert(in_stream);
  s->in_stream = gt_node_stream_ref(in_stream);
  s->sequence_node_out_visitor =
    gt_sequence_node_out_visitor_new(outfile);
  if  (!s->sequence_node_out_visitor) {
    gt_node_stream_delete(ns);
    return NULL;
  }
  return ns;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
callq 0x17c448
movq %rax, %r14
movq %r15, %rdi
callq 0x16ae51
movzbl %al, %esi
movq %r14, %rdi
callq 0x16abec
movq %rax, %r14
callq 0x17c448
movq %rax, %rdi
movq %r14, %rsi
callq 0x16ae64
testq %r15, %r15
je 0x17c5eb
movq %rax, %r12
movq %r15, %rdi
callq 0x16ac58
movq %rax, 0x10(%r12)
movq %rbx, %rdi
callq 0x17c8e4
movq %rax, 0x18(%r12)
testq %rax, %rax
jne 0x17c5dc
movq %r14, %rdi
callq 0x16ac6e
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x55657
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/sequence_node_out_visitor.c
// Function: gt_sequence_node_out_visitor_class
const GtNodeVisitorClass* gt_sequence_node_out_visitor_class()
{
  static GtNodeVisitorClass *nvc = NULL;
  gt_class_alloc_lock_enter();
  if (!nvc) {
    nvc = gt_node_visitor_class_new(sizeof (GtSequenceNodeOutVisitor),
                                    sequence_node_out_visitor_free,
                                    sequence_node_out_visitor_comment_node,
                                    sequence_node_out_visitor_feature_node,
                                    sequence_node_out_visitor_region_node,
                                    sequence_node_out_visitor_sequence_node,
                                    sequence_node_out_visitor_eof_node);
    gt_node_visitor_class_set_meta_node_func(nvc,
                                           sequence_node_out_visitor_meta_node);
  }
  gt_class_alloc_lock_leave();
  return nvc;
}

// Assembly:
pushq %rax
callq 0xe6a03
cmpq $0x0, 0x34d282(%rip)    # 0x4c9880
jne 0x17c64e
leaq 0x229(%rip), %rax       # 0x17c830
movq %rax, (%rsp)
leaq 0x4a(%rip), %rsi        # 0x17c65c
leaq 0x61(%rip), %rdx        # 0x17c67a
leaq 0xb4(%rip), %rcx        # 0x17c6d4
leaq 0x107(%rip), %r8        # 0x17c72e
leaq 0x15a(%rip), %r9        # 0x17c788
movl $0x30, %edi
callq 0x16ae80
movq %rax, 0x34d241(%rip)    # 0x4c9880
leaq 0x244(%rip), %rsi       # 0x17c88a
movq %rax, %rdi
callq 0x16aee0
callq 0xe6a19
movq 0x34d226(%rip), %rax    # 0x4c9880
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/sequence_node_out_visitor.c
// Function: sequence_node_out_visitor_comment_node
static int sequence_node_out_visitor_comment_node(GtNodeVisitor *nv,
                                                   GtCommentNode *cn,
                                                   GT_UNUSED GtError *err)
{
  GtSequenceNodeOutVisitor *v = sequence_node_out_visitor_cast(nv);
  int had_err = 0;
  gt_error_check(err);
  gt_assert(v && cn);

  gt_queue_add(v->node_buffer, cn);

  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
callq 0x17c5f0
movq %rax, %rdi
movq %r14, %rsi
callq 0x16af21
movq %rax, %r14
testq %r15, %r15
je 0x17c6ac
movq %r15, %rdi
callq 0x101a9a
testb %al, %al
jne 0x17c6cf
testq %rbx, %rbx
je 0x17c6ca
testq %r14, %r14
je 0x17c6ca
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x112923
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x556c5
callq 0x5568e
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/sequence_node_out_visitor.c
// Function: sequence_node_out_visitor_feature_node
static int sequence_node_out_visitor_feature_node(GtNodeVisitor *nv,
                                                  GtFeatureNode *fn,
                                                  GT_UNUSED GtError *err)
{
  GtSequenceNodeOutVisitor *v = sequence_node_out_visitor_cast(nv);
  int had_err = 0;
  gt_error_check(err);
  gt_assert(v && fn);

  gt_queue_add(v->node_buffer, fn);

  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
callq 0x17c5f0
movq %rax, %rdi
movq %r14, %rsi
callq 0x16af21
movq %rax, %r14
testq %r15, %r15
je 0x17c706
movq %r15, %rdi
callq 0x101a9a
testb %al, %al
jne 0x17c729
testq %rbx, %rbx
je 0x17c724
testq %r14, %r14
je 0x17c724
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x112923
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x55733
callq 0x556fc
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/sequence_node_out_visitor.c
// Function: sequence_node_out_visitor_region_node
static int sequence_node_out_visitor_region_node(GtNodeVisitor *nv,
                                                 GtRegionNode *rn,
                                                 GT_UNUSED GtError *err)
{
  GtSequenceNodeOutVisitor *v = sequence_node_out_visitor_cast(nv);
  int had_err = 0;
  gt_error_check(err);
  gt_assert(v && rn);

  gt_queue_add(v->node_buffer, rn);

  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
callq 0x17c5f0
movq %rax, %rdi
movq %r14, %rsi
callq 0x16af21
movq %rax, %r14
testq %r15, %r15
je 0x17c760
movq %r15, %rdi
callq 0x101a9a
testb %al, %al
jne 0x17c783
testq %rbx, %rbx
je 0x17c77e
testq %r14, %r14
je 0x17c77e
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x112923
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x557a1
callq 0x5576a
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/sequence_node_out_visitor.c
// Function: sequence_node_out_visitor_sequence_node
static int sequence_node_out_visitor_sequence_node(GtNodeVisitor *nv,
                                                   GtSequenceNode *sn,
                                                   GT_UNUSED GtError *err)
{
  GtSequenceNodeOutVisitor *v = sequence_node_out_visitor_cast(nv);
  GT_UNUSED GtFeatureNode *node;
  int had_err = 0;
  gt_error_check(err);
  gt_assert(v && sn);

  gt_fasta_show_entry(gt_sequence_node_get_description(sn),
                      gt_sequence_node_get_sequence(sn),
                      gt_sequence_node_get_sequence_length(sn),
                      v->width, v->outfile);

  if (v->keep_sequence_nodes)
    gt_queue_add(v->node_buffer, sn);
  else
    gt_genome_node_delete((GtGenomeNode*) sn);

  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
callq 0x17c5f0
movq %rax, %rdi
movq %r14, %rsi
callq 0x16af21
movq %rax, %r14
testq %r15, %r15
je 0x17c7bd
movq %r15, %rdi
callq 0x101a9a
testb %al, %al
jne 0x17c82b
testq %rbx, %rbx
je 0x17c826
testq %r14, %r14
je 0x17c826
movq %rbx, %rdi
callq 0x17c156
movq %rax, %r15
movq %rbx, %rdi
callq 0x17c16a
movq %rax, %r12
movq %rbx, %rdi
callq 0x17c17e
movq 0x18(%r14), %r8
movq 0x20(%r14), %rcx
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x102ec0
cmpb $0x1, 0x28(%r14)
jne 0x17c810
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x112923
jmp 0x17c818
movq %rbx, %rdi
callq 0x14c43a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x5580f
callq 0x557d8
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/sequence_node_out_visitor.c
// Function: sequence_node_out_visitor_eof_node
static int sequence_node_out_visitor_eof_node(GtNodeVisitor *nv,
                                              GtEOFNode *en,
                                              GT_UNUSED GtError *err)
{
  GtSequenceNodeOutVisitor *v = sequence_node_out_visitor_cast(nv);
  int had_err = 0;
  gt_error_check(err);
  gt_assert(v && en);

  gt_queue_add(v->node_buffer, en);

  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
callq 0x17c5f0
movq %rax, %rdi
movq %r14, %rsi
callq 0x16af21
movq %rax, %r14
testq %r15, %r15
je 0x17c862
movq %r15, %rdi
callq 0x101a9a
testb %al, %al
jne 0x17c885
testq %rbx, %rbx
je 0x17c880
testq %r14, %r14
je 0x17c880
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x112923
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x5587d
callq 0x55846
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/sequence_node_out_visitor.c
// Function: sequence_node_out_visitor_meta_node
static int sequence_node_out_visitor_meta_node(GtNodeVisitor *nv,
                                               GtMetaNode *mn,
                                               GT_UNUSED GtError *err)
{
  GtSequenceNodeOutVisitor *v = sequence_node_out_visitor_cast(nv);
  int had_err = 0;
  gt_error_check(err);
  gt_assert(v && mn);

  gt_queue_add(v->node_buffer, mn);

  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
callq 0x17c5f0
movq %rax, %rdi
movq %r14, %rsi
callq 0x16af21
movq %rax, %r14
testq %r15, %r15
je 0x17c8bc
movq %r15, %rdi
callq 0x101a9a
testb %al, %al
jne 0x17c8df
testq %rbx, %rbx
je 0x17c8da
testq %r14, %r14
je 0x17c8da
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x112923
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x558ed
callq 0x558b4
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/sequence_node_out_visitor.c
// Function: gt_sequence_node_out_visitor_new
GtNodeVisitor* gt_sequence_node_out_visitor_new(GtFile *outfile)
{
  GtNodeVisitor *nv =
                   gt_node_visitor_create(gt_sequence_node_out_visitor_class());
  GtSequenceNodeOutVisitor *v = sequence_node_out_visitor_cast(nv);
  v->outfile = outfile;
  v->width = 80;
  v->keep_sequence_nodes = false;
  v->node_buffer = gt_queue_new();
  return nv;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x17c5f0
movq %rax, %rdi
callq 0x16aef0
movq %rax, %r14
callq 0x17c5f0
movq %rax, %rdi
movq %r14, %rsi
callq 0x16af21
movq %rax, %r15
movq %rbx, 0x18(%rax)
movq $0x50, 0x20(%rax)
movb $0x0, 0x28(%rax)
callq 0x112908
movq %rax, 0x10(%r15)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/set_source_visitor.c
// Function: gt_set_source_visitor_new
GtNodeVisitor *gt_set_source_visitor_new(GtStr *newsource)
{
  GtNodeVisitor *nv;
  gt_assert(newsource);
  nv = gt_node_visitor_create(gt_set_source_visitor_class());
  GtSetSourceVisitor *ssv = set_source_visitor_cast(nv);
  ssv->newsource = gt_str_ref(newsource);
  return nv;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x17c9c5
movq %rdi, %rbx
callq 0x17c9ca
movq %rax, %rdi
callq 0x16aef0
movq %rax, %r14
callq 0x17c9ca
movq %rax, %rdi
movq %r14, %rsi
callq 0x16af21
movq %rax, %r15
movq %rbx, %rdi
callq 0x120e79
movq %rax, 0x10(%r15)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x5595f
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/set_source_visitor.c
// Function: gt_set_source_visitor_class
const GtNodeVisitorClass *gt_set_source_visitor_class()
{
  static const GtNodeVisitorClass *nvc = NULL;
  gt_class_alloc_lock_enter();
  if (!nvc)
  {
    nvc = gt_node_visitor_class_new(sizeof (GtSetSourceVisitor),
                                    set_source_visitor_free,
                                    NULL,
                                    set_source_visitor_visit_feature_node,
                                    NULL,
                                    NULL,
                                    NULL);
  }
  gt_class_alloc_lock_leave();
  return nvc;
}

// Assembly:
pushq %rax
callq 0xe6a03
cmpq $0x0, 0x34ceb0(%rip)    # 0x4c9888
jne 0x17ca09
movq $0x0, (%rsp)
leaq 0x2e(%rip), %rsi        # 0x17ca17
leaq 0x45(%rip), %rcx        # 0x17ca35
movl $0x18, %edi
xorl %edx, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x16ae80
movq %rax, 0x34ce7f(%rip)    # 0x4c9888
callq 0xe6a19
movq 0x34ce73(%rip), %rax    # 0x4c9888
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/set_source_visitor.c
// Function: set_source_visitor_visit_feature_node
static int set_source_visitor_visit_feature_node(GtNodeVisitor *nv,
                                                 GtFeatureNode *fn,
                                                 GT_UNUSED GtError *error)
{
  GtSetSourceVisitor *ssv;
  gt_error_check(error);
  ssv = set_source_visitor_cast(nv);

  GtFeatureNode *current;
  GtFeatureNodeIterator *iter = gt_feature_node_iterator_new(fn);
  for (current  = gt_feature_node_iterator_next(iter);
       current != NULL;
       current  = gt_feature_node_iterator_next(iter))
  {
    gt_feature_node_set_source(current, ssv->newsource);
  }
  gt_feature_node_iterator_delete(iter);

  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testq %rdx, %rdx
je 0x17ca50
movq %rdx, %rdi
callq 0x101a9a
testb %al, %al
jne 0x17ca9e
callq 0x17c9ca
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16af21
movq %rax, %rbx
movq %r14, %rdi
callq 0x14b1a8
movq %rax, %r14
movq %rax, %rdi
callq 0x14b33e
testq %rax, %rax
je 0x17ca8c
movq 0x10(%rbx), %rsi
movq %rax, %rdi
callq 0x1491f1
movq %r14, %rdi
jmp 0x17ca71
movq %r14, %rdi
callq 0x14b3d0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x55996
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/shredder.c
// Function: gt_shredder_new
GtShredder* gt_shredder_new(GtBioseq *bioseq, GtUword minlength,
                                       GtUword maxlength)
{
  GtShredder *shredder = gt_calloc(1, sizeof *shredder);
  gt_assert(bioseq && minlength && minlength <= maxlength);
  shredder->bioseq = bioseq;
  shredder->minlength = minlength;
  shredder->maxlength = maxlength;
  shredder->sample_probability = 1.0;
  return shredder;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x21fac0(%rip), %rdx    # 0x39c579
movl $0x1, %edi
movl $0x38, %esi
movl $0x23, %ecx
callq 0x1093ef
testq %r15, %r15
je 0x17cafa
leaq -0x1(%r14), %rcx
cmpq %rbx, %rcx
jae 0x17cafa
movq %r15, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
movq %rcx, 0x30(%rax)
popq %rbx
popq %r14
popq %r15
retq
callq 0x559cd
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/shredder.c
// Function: gt_shredder_shred
char* gt_shredder_shred(GtShredder *shredder, GtUword *fragment_offset,
                        GtUword *fragment_length, GtStr *desc)
{
  char *frag;
  gt_assert(shredder && fragment_length);
  while ((frag = generate_fragment(shredder, fragment_offset, fragment_length,
                                   desc))) {
    if (shredder->sample_probability == 1.0 ||
        gt_rand_0_to_1() <= shredder->sample_probability) {
      return frag;
    } else gt_free(frag);
  }
  return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, 0x10(%rsp)
testq %rdi, %rdi
je 0x17ccd4
testq %rdx, %rdx
je 0x17ccd4
movq %rcx, %rbx
movq %rdi, %r12
movq %rdx, 0x8(%rsp)
leaq 0x21f9ed(%rip), %r14    # 0x39c579
movq (%r12), %rdi
movq 0x20(%r12), %r15
callq 0xd75d2
cmpq %rax, %r15
jae 0x17cbc0
movq (%r12), %rdi
movq 0x20(%r12), %rsi
callq 0xd71ae
movq %rax, %r15
movq 0x10(%r12), %rdi
subq 0x8(%r12), %rdi
jne 0x17cbc8
xorl %eax, %eax
jmp 0x17cbcd
xorl %r13d, %r13d
jmp 0x17cc76
callq 0x10ae3c
addq 0x8(%r12), %rax
jb 0x17ccca
movq 0x28(%r12), %rcx
leaq (%rcx,%rax), %rdx
movq %r15, %rbp
subq %rcx, %rbp
cmpq %r15, %rdx
cmovbeq %rax, %rbp
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movq %rbp, (%rax)
movq %rbx, %rdi
callq 0x120db4
movq (%r12), %rdi
movq 0x20(%r12), %rsi
callq 0xd71c2
movq %rbx, %rdi
movq %rax, %rsi
callq 0x12097f
movq 0x28(%r12), %rdx
leaq (%rdx,%rbp), %rcx
cmpq %r15, %rcx
ja 0x17cccf
movq (%r12), %rdi
movq 0x20(%r12), %rsi
decq %rcx
callq 0xd7314
movq %rax, %r13
movq 0x28(%r12), %rcx
leaq (%rcx,%rbp), %rax
cmpq %r15, %rax
jne 0x17cc5c
incq 0x20(%r12)
xorl %eax, %eax
jmp 0x17cc71
movq 0x18(%r12), %rdx
cmpq %rdx, %rbp
jbe 0x17cc6b
subq %rdx, %rax
jmp 0x17cc71
incq %rcx
movq %rcx, %rax
movq %rax, 0x28(%r12)
testq %r13, %r13
je 0x17ccb5
movsd 0x30(%r12), %xmm0
ucomisd 0x1d259e(%rip), %xmm0   # 0x34f228
jne 0x17cc8e
jnp 0x17ccb8
callq 0x10af04
movsd 0x30(%r12), %xmm1
ucomisd %xmm0, %xmm1
jae 0x17ccb8
movq %r13, %rdi
movq %r14, %rsi
movl $0x72, %edx
callq 0x109670
jmp 0x17cb8c
xorl %r13d, %r13d
movq %r13, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x55b17
callq 0x55ae0
callq 0x55aa9
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/snp_annotator_stream.c
// Function: gt_snp_annotator_stream_class
const GtNodeStreamClass* gt_snp_annotator_stream_class(void)
{
  static const GtNodeStreamClass *nsc = NULL;
  gt_class_alloc_lock_enter();
  if (!nsc) {
    nsc = gt_node_stream_class_new(sizeof (GtSNPAnnotatorStream),
                                   snp_annotator_stream_free,
                                   snp_annotator_stream_next);
  }
  gt_class_alloc_lock_leave();
  return nsc;
}

// Assembly:
pushq %rax
callq 0xe6a03
cmpq $0x0, 0x34cba6(%rip)    # 0x4c9890
jne 0x17cd0b
leaq 0x26(%rip), %rsi        # 0x17cd19
leaq 0x12c(%rip), %rdx       # 0x17ce26
movl $0x58, %edi
callq 0x16abb4
movq %rax, 0x34cb85(%rip)    # 0x4c9890
callq 0xe6a19
movq 0x34cb79(%rip), %rax    # 0x4c9890
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/snp_annotator_stream.c
// Function: snp_annotator_stream_free
static void snp_annotator_stream_free(GtNodeStream *ns)
{
  GtUword i;
  GtSNPAnnotatorStream *sas;
  if (!ns) return;
  sas = gt_snp_annotator_stream_cast(ns);
  gt_region_mapping_delete(sas->rmap);
  while (gt_queue_size(sas->snps) > 0) {
    gt_genome_node_delete((GtGenomeNode*) gt_queue_get(sas->snps));
  }
  while (gt_queue_size(sas->outqueue) > 0) {
    gt_genome_node_delete((GtGenomeNode*) gt_queue_get(sas->outqueue));
  }
  for (i = 0; i < gt_array_size(sas->instreams); i++) {
    gt_node_stream_delete(*(GtNodeStream**) gt_array_get(sas->instreams, i));
  }
  for (i = 0; i < gt_array_size(sas->cur_gene_set); i++) {
    gt_genome_node_delete(*(GtGenomeNode**) gt_array_get(sas->cur_gene_set, i));
  }
  gt_array_delete(sas->cur_gene_set);
  gt_node_stream_delete(sas->merge_stream);
  gt_array_delete(sas->instreams);
  gt_queue_delete(sas->snps);
  gt_queue_delete(sas->outqueue);
}

// Assembly:
testq %rdi, %rdi
je 0x17ce25
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x17ccdc
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16ae64
movq %rax, %rbx
movq 0x40(%rax), %rdi
callq 0x1758da
movq 0x48(%rbx), %rdi
callq 0x112a74
testq %rax, %rax
je 0x17cd77
movq 0x48(%rbx), %rdi
callq 0x112a12
movq %rax, %rdi
callq 0x14c43a
jmp 0x17cd45
movq 0x50(%rbx), %rdi
callq 0x112a12
movq %rax, %rdi
callq 0x14c43a
movq 0x50(%rbx), %rdi
callq 0x112a74
testq %rax, %rax
jne 0x17cd66
movq 0x28(%rbx), %rdi
callq 0xd4a9a
testq %rax, %rax
je 0x17cdbb
xorl %r14d, %r14d
movq 0x28(%rbx), %rdi
movq %r14, %rsi
callq 0xd47ba
movq (%rax), %rdi
callq 0x16ac6e
incq %r14
movq 0x28(%rbx), %rdi
callq 0xd4a9a
cmpq %rax, %r14
jb 0x17cd96
movq 0x20(%rbx), %rdi
callq 0xd4a9a
testq %rax, %rax
je 0x17cdf1
xorl %r14d, %r14d
movq 0x20(%rbx), %rdi
movq %r14, %rsi
callq 0xd47ba
movq (%rax), %rdi
callq 0x14c43a
incq %r14
movq 0x20(%rbx), %rdi
callq 0xd4a9a
cmpq %rax, %r14
jb 0x17cdcc
movq 0x20(%rbx), %rdi
callq 0xd4ef4
movq 0x10(%rbx), %rdi
callq 0x16ac6e
movq 0x28(%rbx), %rdi
callq 0xd4ef4
movq 0x48(%rbx), %rdi
callq 0x112f03
movq 0x50(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x112f03
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/snp_annotator_stream.c
// Function: gt_snp_annotator_stream_new
GtNodeStream* gt_snp_annotator_stream_new(GtNodeStream *gvf_stream,
                                          GtNodeStream *gff_stream,
                                          GtTransTable *trans_table,
                                          GtRegionMapping *rmap)
{
  GtSNPAnnotatorStream *sas;
  GtNodeStream *ns;
  gt_assert(gvf_stream && gff_stream && rmap);
  ns = gt_node_stream_create(gt_snp_annotator_stream_class(), true);
  sas = gt_snp_annotator_stream_cast(ns);
  sas->instreams = gt_array_new(sizeof (GtNodeStream*));
  (void) gt_node_stream_ref(gvf_stream);
  gt_array_add(sas->instreams, gvf_stream);
  (void) gt_node_stream_ref(gff_stream);
  gt_array_add(sas->instreams, gff_stream);
  sas->cur_gene_set = gt_array_new(sizeof (GtFeatureNode*));
  sas->merge_stream = gt_merge_stream_new(sas->instreams);
  sas->rmap = gt_region_mapping_ref(rmap);
  sas->cur_gene_range.start =
    sas->cur_gene_range.end = GT_UNDEF_UWORD;
  sas->snps = gt_queue_new();
  sas->outqueue = gt_queue_new();
  sas->tt = trans_table;
  return ns;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
testq %rdi, %rdi
je 0x17d22a
testq %rsi, %rsi
je 0x17d22a
movq %rcx, %r14
testq %rcx, %rcx
je 0x17d22a
movq %rdx, %rbx
callq 0x17ccdc
movq %rax, %rdi
movl $0x1, %esi
callq 0x16abec
movq %rax, %r15
callq 0x17ccdc
movq %rax, %rdi
movq %r15, %rsi
callq 0x16ae64
movq %rax, %r12
movl $0x8, %edi
callq 0xd46fc
movq %rax, 0x28(%r12)
leaq 0x8(%rsp), %r13
movq (%r13), %rdi
callq 0x16ac58
movq 0x28(%r12), %rdi
movl $0x8, %edx
movq %r13, %rsi
callq 0xd49ce
movq %rsp, %r13
movq (%r13), %rdi
callq 0x16ac58
movq 0x28(%r12), %rdi
movl $0x8, %edx
movq %r13, %rsi
callq 0xd49ce
movl $0x8, %edi
callq 0xd46fc
movq %rax, 0x20(%r12)
movq 0x28(%r12), %rdi
callq 0x1694c4
movq %rax, 0x10(%r12)
movq %r14, %rdi
callq 0x175a8b
movq %rax, 0x40(%r12)
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x30(%r12)
callq 0x112908
movq %rax, 0x48(%r12)
callq 0x112908
movq %rax, 0x50(%r12)
movq %rbx, 0x18(%r12)
movq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x55bbe