LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/gff3_parser.c
// Function: invalid_uppercase_gff3_attribute
static bool invalid_uppercase_gff3_attribute(const char *attr_tag)
{
  return (strcmp(attr_tag, GT_GFF_ID) &&
          strcmp(attr_tag, GT_GFF_NAME) &&
          strcmp(attr_tag, GT_GFF_ALIAS) &&
          strcmp(attr_tag, GT_GFF_PARENT) &&
          strcmp(attr_tag, GT_GFF_TARGET) &&
          strcmp(attr_tag, GT_GFF_GAP) &&
          strcmp(attr_tag, GT_GFF_DERIVES_FROM) &&
          strcmp(attr_tag, GT_GFF_NOTE) &&
          strcmp(attr_tag, GT_GFF_DBXREF) &&
          strcmp(attr_tag, GT_GFF_ONTOLOGY_TERM) &&
          strcmp(attr_tag, GT_GFF_START_RANGE) &&
          strcmp(attr_tag, GT_GFF_END_RANGE) &&
          strcmp(attr_tag, GT_GFF_IS_CIRCULAR));
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0xa0422(%rip), %rsi     # 0xe7775
callq 0xb890
testl %eax, %eax
je 0x4745b
leaq 0xa0529(%rip), %rsi     # 0xe7890
movq %rbx, %rdi
callq 0xb890
testl %eax, %eax
je 0x4745b
leaq 0xa0517(%rip), %rsi     # 0xe7895
movq %rbx, %rdi
callq 0xb890
testl %eax, %eax
je 0x4745b
leaq 0xa03e3(%rip), %rsi     # 0xe7778
movq %rbx, %rdi
callq 0xb890
testl %eax, %eax
je 0x4745b
leaq 0xa043a(%rip), %rsi     # 0xe77e6
movq %rbx, %rdi
callq 0xb890
testl %eax, %eax
je 0x4745b
leaq 0xa043f(%rip), %rsi     # 0xe7802
movq %rbx, %rdi
callq 0xb890
testl %eax, %eax
je 0x4745b
leaq 0xa04c1(%rip), %rsi     # 0xe789b
movq %rbx, %rdi
callq 0xb890
testl %eax, %eax
je 0x4745b
leaq 0xa04bb(%rip), %rsi     # 0xe78a8
movq %rbx, %rdi
callq 0xb890
testl %eax, %eax
je 0x4745b
leaq 0xa03ed(%rip), %rsi     # 0xe77ed
movq %rbx, %rdi
callq 0xb890
testl %eax, %eax
je 0x4745b
leaq 0xa03e1(%rip), %rsi     # 0xe77f4
movq %rbx, %rdi
callq 0xb890
testl %eax, %eax
je 0x4745b
leaq 0xa0487(%rip), %rsi     # 0xe78ad
movq %rbx, %rdi
callq 0xb890
testl %eax, %eax
je 0x4745b
leaq 0xa0480(%rip), %rsi     # 0xe78b9
movq %rbx, %rdi
callq 0xb890
testl %eax, %eax
je 0x4745b
leaq 0xa0333(%rip), %rsi     # 0xe777f
movq %rbx, %rdi
callq 0xb890
testl %eax, %eax
setne %al
jmp 0x4745d
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/gff3_parser.c
// Function: feature_node_is_part_of_pseudo_node
static void feature_node_is_part_of_pseudo_node(GtFeatureNode *pseudo_node,
                                                GtFeatureNode *child,
                                                GtFeatureInfo *feature_info)
{
  const char *id;
  gt_assert(pseudo_node &&
            gt_feature_node_is_pseudo((GtFeatureNode*) pseudo_node));
  gt_assert(child && !gt_feature_node_is_pseudo((GtFeatureNode*) child));
  gt_assert(feature_info);
  gt_feature_node_add_child(pseudo_node, child);
  id = gt_feature_node_get_attribute(child, GT_GFF_ID);
  gt_assert(id);
  gt_feature_info_add_pseudo_parent(feature_info, id, pseudo_node);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x474be
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x40459
testb %al, %al
je 0x474be
movq %r15, %rdi
callq 0x40459
testb %al, %al
jne 0x474c3
testq %r14, %r14
je 0x474c8
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4005b
leaq 0xa02d7(%rip), %rsi     # 0xe7775
movq %r15, %rdi
callq 0x3f850
testq %rax, %rax
je 0x474cd
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x85171
callq 0x12b21
callq 0x12ae8
callq 0x12aaf
callq 0x12a76
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/gff3_parser.c
// Function: replace_node
static void replace_node(GtFeatureNode *node_to_replace,
                         GtFeatureNode *replacing_node, GtQueue *genome_nodes)
{
  ReplaceInfo replace_info;
  GT_UNUSED int rval;
  gt_assert(node_to_replace && replacing_node && genome_nodes);
  replace_info.node_to_replace = node_to_replace;
  replace_info.replacing_node = replacing_node;
  /* we go backwards in both cases, because we expect that the <node_to_replace>
     is near the end of the queue */
  rval = gt_queue_iterate_reverse(genome_nodes, replace_func, &replace_info,
                                  NULL);
  gt_assert(rval == 1);
}

// Assembly:
subq $0x18, %rsp
testq %rsi, %rsi
je 0x47505
leaq 0x8(%rsp), %rax
movq %rdi, (%rax)
movq %rsi, 0x8(%rax)
leaq 0xa5(%rip), %rsi        # 0x47593
movq %rdx, %rdi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x7c503
cmpl $0x1, %eax
jne 0x4750a
addq $0x18, %rsp
retq
callq 0x12b93
callq 0x12b5a
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/gff3_parser.c
// Function: update_pseudo_node_range
static void update_pseudo_node_range(GtFeatureNode *pseudo_node,
                                     GtFeatureNode *feature_node)
{
  GtRange pseudo_range, feature_range, joined_range;
  gt_assert(pseudo_node && feature_node);
  gt_assert(gt_feature_node_is_pseudo(pseudo_node));
  gt_assert(!gt_feature_node_is_pseudo(feature_node));
  pseudo_range = gt_genome_node_get_range((GtGenomeNode*) pseudo_node);
  feature_range = gt_genome_node_get_range((GtGenomeNode*) feature_node);
  joined_range = gt_range_join(&pseudo_range, &feature_range);
  gt_genome_node_set_range((GtGenomeNode*) pseudo_node, &joined_range);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
testq %rdi, %rdi
je 0x47584
movq %rsi, %r14
movq %rdi, %rbx
callq 0x40459
testb %al, %al
je 0x47589
movq %r14, %rdi
callq 0x40459
testb %al, %al
jne 0x4758e
movq %rbx, %rdi
callq 0x41f83
leaq 0x20(%rsp), %r15
movq %rax, (%r15)
movq %rdx, 0x8(%r15)
movq %r14, %rdi
callq 0x41f83
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
movq %r15, %rdi
callq 0x7e16b
movq %rsp, %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
movq %rbx, %rdi
callq 0x41fe4
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x12c3e
callq 0x12bcc
callq 0x12c05
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/gff3_parser.c
// Function: replace_func
static int replace_func(void **elem, void *info, GT_UNUSED GtError *err)
{
  ReplaceInfo *replace_info = info;
  GtGenomeNode **node = (GtGenomeNode**) elem;
  gt_error_check(err);
  gt_assert(node && replace_info);
  if (*node == (GtGenomeNode*) replace_info->node_to_replace) {
    *node = (GtGenomeNode*) replace_info->replacing_node;
    return 1;
  }
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testq %rdx, %rdx
je 0x475ae
movq %rdx, %rdi
callq 0x3566a
testb %al, %al
jne 0x475db
testq %rbx, %rbx
je 0x475d6
testq %r14, %r14
je 0x475d6
movq (%rbx), %rcx
xorl %eax, %eax
cmpq (%r14), %rcx
jne 0x475ce
movq 0x8(%r14), %rax
movq %rax, (%rbx)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x12cb0
callq 0x12c77
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/gff3_parser.c
// Function: check_missing_attributes
static int check_missing_attributes(GtGenomeNode *this_feature,
                                    GtStrArray *this_attributes,
                                    GtFeatureNode *other_feature,
                                    const char *id, const char *filename,
                                    GtError *err)
{
  GtUword i;
  int had_err = 0;
  gt_error_check(err);
  gt_assert(this_feature && this_attributes && other_feature);
  for (i = 0; !had_err && i < gt_str_array_size(this_attributes); i++) {
    const char *attrkey = gt_str_array_get(this_attributes, i);
    if (strcmp(attrkey, "ID") != 0 && strcmp(attrkey, "Parent"))
      continue;

    if (!gt_feature_node_get_attribute(other_feature, attrkey)) {
      gt_error_set(err, "the multi-feature with %s \"%s\" on line %u in file "
                   "\"%s\" does not have a '%s' attribute which is present in "
                   "its counterpart on line %u", GT_GFF_ID, id,
                   gt_genome_node_get_line_number((GtGenomeNode*)
                                                  other_feature),
                   filename, attrkey,
                   gt_genome_node_get_line_number(this_feature));
      had_err = -1;
      break;
    }
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %rbx
movq %r8, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, 0x10(%rsp)
testq %r9, %r9
je 0x4761b
movq %rbx, %rdi
callq 0x3566a
testb %al, %al
jne 0x4770e
movq %rbx, 0x8(%rsp)
testq %r13, %r13
je 0x47709
xorl %r14d, %r14d
leaq 0xa0142(%rip), %rbx     # 0xe7775
movq %r12, (%rsp)
movq %r13, %rdi
callq 0x3d560
cmpq %rax, %r14
jae 0x476f8
movq %r13, %rdi
movq %r14, %rsi
callq 0x3d3e2
movq %rax, %rbp
movq %rax, %rdi
movq %rbx, %rsi
callq 0xb890
testl %eax, %eax
je 0x47678
movq %rbp, %rdi
leaq 0xa0109(%rip), %rsi     # 0xe7778
callq 0xb890
testl %eax, %eax
jne 0x47688
movq %r12, %rdi
movq %rbp, %rsi
callq 0x3f850
testq %rax, %rax
je 0x47691
xorl %eax, %eax
movb $0x1, %r15b
xorl %ecx, %ecx
jmp 0x476e1
movq %r12, %rdi
callq 0x41f30
movl %eax, %r12d
movq 0x10(%rsp), %rdi
callq 0x41f30
movl %eax, %r10d
xorl %r15d, %r15d
movq 0x8(%rsp), %rdi
leaq 0xa0860(%rip), %rsi     # 0xe7f18
movq %rbx, %rdx
movq 0x18(%rsp), %rcx
movl %r12d, %r8d
movq (%rsp), %r12
movq 0x20(%rsp), %r9
xorl %eax, %eax
pushq %r10
pushq %rbp
callq 0x3559f
addq $0x10, %rsp
movb $0x1, %cl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testb %cl, %cl
jne 0x476fa
incq %r14
testb %r15b, %r15b
jne 0x47637
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x476fa
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x12d22
callq 0x12ce9
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/gff3_parser.c
// Function: add_node_to_pseudo_node
static GtFeatureNode* add_node_to_pseudo_node(GtFeatureNode *pseudo_node,
                                              GtFeatureNode *normal_node,
                                              GtFeatureInfo *feature_info,
                                              GtQueue *genome_nodes)
{
  gt_assert(pseudo_node &&
         gt_feature_node_is_pseudo((GtFeatureNode*) pseudo_node));
  gt_assert(normal_node &&
         !gt_feature_node_is_pseudo((GtFeatureNode*) normal_node));
  gt_assert(feature_info && genome_nodes);
  feature_node_is_part_of_pseudo_node(pseudo_node, normal_node, feature_info);
  remove_node((GtGenomeNode*) normal_node, genome_nodes);
  return pseudo_node;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
callq 0x40459
testb %al, %al
je 0x47f03
movq %r15, %rdi
callq 0x40459
testb %al, %al
jne 0x47f08
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x4745f
movq %r14, %rdi
movq %r15, %rsi
callq 0x7c1fa
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x12fce
callq 0x13007
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/gff3_visitor.c
// Function: gt_gff3_visitor_class
const GtNodeVisitorClass* gt_gff3_visitor_class()
{
  static GtNodeVisitorClass *nvc = NULL;
  if (!nvc) {
    nvc = gt_node_visitor_class_new(sizeof (GtGFF3Visitor),
                                    gff3_visitor_free,
                                    gff3_visitor_comment_node,
                                    gff3_visitor_feature_node,
                                    gff3_visitor_region_node,
                                    gff3_visitor_sequence_node,
                                    gff3_visitor_eof_node);
    gt_node_visitor_class_set_meta_node_func(nvc, gff3_visitor_meta_node);
  }
  return nvc;
}

// Assembly:
cmpq $0x0, 0x10ac38(%rip)    # 0x152b50
jne 0x47f6d
pushq %rax
leaq 0x4cd(%rip), %rax       # 0x483ef
movq %rax, (%rsp)
leaq 0x48(%rip), %rsi        # 0x47f75
leaq 0x99(%rip), %rdx        # 0x47fcd
leaq 0x143(%rip), %rcx       # 0x4807e
leaq 0x256(%rip), %r8        # 0x48198
leaq 0x3a4(%rip), %r9        # 0x482ed
movl $0x50, %edi
callq 0x49b7c
movq %rax, 0x10abf6(%rip)    # 0x152b50
leaq 0x4cf(%rip), %rsi       # 0x48430
movq %rax, %rdi
callq 0x49bdc
addq $0x8, %rsp
movq 0x10abdc(%rip), %rax    # 0x152b50
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/gff3_visitor.c
// Function: gff3_visitor_free
static void gff3_visitor_free(GtNodeVisitor *nv)
{
  GtGFF3Visitor *gff3_visitor = gff3_visitor_cast(nv);
  gt_assert(gff3_visitor);
  gt_string_distri_delete(gff3_visitor->id_counter);
  gt_hashmap_delete(gff3_visitor->feature_node_to_id_array);
  gt_hashmap_delete(gff3_visitor->feature_node_to_unique_id_str);
  gt_cstr_table_delete(gff3_visitor->used_ids);
  gt_str_delete(gff3_visitor->outstr);
  gt_file_delete(gff3_visitor->outfp);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x47f10
movq %rax, %rdi
movq %rbx, %rsi
callq 0x49c1d
testq %rax, %rax
je 0x47fc8
movq %rax, %rbx
movq 0x18(%rax), %rdi
callq 0x83447
movq 0x20(%rbx), %rdi
callq 0x77675
movq 0x28(%rbx), %rdi
callq 0x77675
movq 0x48(%rbx), %rdi
callq 0x72c9c
movq 0x40(%rbx), %rdi
callq 0x3d1eb
movq 0x38(%rbx), %rdi
popq %rbx
jmp 0x75b7c
callq 0x13040
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/gff3_visitor.c
// Function: gff3_visitor_comment_node
static int gff3_visitor_comment_node(GtNodeVisitor *nv, GtCommentNode *cn,
                                     GT_UNUSED GtError *err)
{
  GtGFF3Visitor *gff3_visitor;
  gt_error_check(err);
  gff3_visitor = gff3_visitor_cast(nv);
  gt_assert(nv && cn);
  gff3_version_string(nv);
  if (!gff3_visitor->outstr) {
    gt_file_xprintf(gff3_visitor->outfp, "#%s\n",
                    gt_comment_node_get_comment(cn));
  } else  {
    gt_str_append_char(gff3_visitor->outstr, '#');
    gt_str_append_cstr(gff3_visitor->outstr, gt_comment_node_get_comment(cn));
    gt_str_append_char(gff3_visitor->outstr, '\n');
  }
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
testq %rdx, %rdx
je 0x47fed
movq %rdx, %rdi
callq 0x3566a
testb %al, %al
jne 0x48079
callq 0x47f10
movq %rax, %rdi
movq %r15, %rsi
callq 0x49c1d
testq %r15, %r15
je 0x48074
testq %rbx, %rbx
je 0x48074
movq %rax, %r14
movq %r15, %rdi
callq 0x486cb
movq 0x40(%r14), %rdi
testq %rdi, %rdi
je 0x4804c
movl $0x23, %esi
callq 0x3c28d
movq 0x40(%r14), %r15
movq %rbx, %rdi
callq 0x84eb7
movq %r15, %rdi
movq %rax, %rsi
callq 0x3c067
movq 0x40(%r14), %rdi
movl $0xa, %esi
callq 0x3c28d
jmp 0x4806c
movq 0x38(%r14), %r14
movq %rbx, %rdi
callq 0x84eb7
leaq 0xa0a20(%rip), %rsi     # 0xe8a7f
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x757a1
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x130ae
callq 0x13077
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/gff3_visitor.c
// Function: gff3_visitor_feature_node
static int gff3_visitor_feature_node(GtNodeVisitor *nv, GtFeatureNode *fn,
                                     GtError *err)
{
  GtGFF3Visitor *gff3_visitor;
  int had_err;
  gt_error_check(err);
  gff3_visitor = gff3_visitor_cast(nv);

  gff3_version_string(nv);

  had_err = gt_feature_node_traverse_children(fn, gff3_visitor, store_ids, true,
                                              err);
  if (!had_err) {
    if (gt_feature_node_is_tree(fn)) {
      had_err = gt_feature_node_traverse_children(fn, gff3_visitor,
                                                  gff3_show_feature_node, true,
                                                  err);
    }
    else {
      /* got a DAG -> traverse in topologically sorted depth first fashion to
         make sure that the 'Parent' attributes are shown in correct order */
      had_err =
        gt_feature_node_traverse_children_top(fn, gff3_visitor,
                                              gff3_show_feature_node, err);
    }
  }

  /* reset hashmaps */
  gt_hashmap_reset(gff3_visitor->feature_node_to_id_array);
  gt_hashmap_reset(gff3_visitor->feature_node_to_unique_id_str);

  /* show terminator, if the feature has children (otherwise it is clear that
     the feature is complete, because no ID attribute has been shown) */
  if (gt_feature_node_has_children(fn) ||
      (gff3_visitor->retain_ids && gt_feature_node_get_attribute(fn, "ID"))) {
    if (!gff3_visitor->outstr)
      gt_file_xprintf(gff3_visitor->outfp, "%s\n", GT_GFF_TERMINATOR);
    else {
      gt_str_append_cstr(gff3_visitor->outstr, GT_GFF_TERMINATOR);
      gt_str_append_char(gff3_visitor->outstr, '\n');
    }
  }

  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r12
testq %rdx, %rdx
je 0x480a4
movq %r15, %rdi
callq 0x3566a
testb %al, %al
jne 0x48193
callq 0x47f10
movq %rax, %rdi
movq %r12, %rsi
callq 0x49c1d
movq %rax, %r14
movq %r12, %rdi
callq 0x486cb
leaq 0x693(%rip), %rdx       # 0x48759
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %ecx
movq %r15, %r8
callq 0x4068e
movl %eax, %ebp
testl %eax, %eax
jne 0x48111
movq %rbx, %rdi
callq 0x415e1
leaq 0x7cd(%rip), %rdx       # 0x488bb
movq %rbx, %rdi
movq %r14, %rsi
testb %al, %al
je 0x48107
movl $0x1, %ecx
movq %r15, %r8
callq 0x4068e
jmp 0x4810f
movq %r15, %rcx
callq 0x41077
movl %eax, %ebp
movq 0x20(%r14), %rdi
callq 0x77249
movq 0x28(%r14), %rdi
callq 0x77249
movq %rbx, %rdi
callq 0x40251
testb %al, %al
jne 0x4814a
cmpb $0x1, 0x11(%r14)
jne 0x48188
leaq 0x9f638(%rip), %rsi     # 0xe7775
movq %rbx, %rdi
callq 0x3f850
testq %rax, %rax
je 0x48188
movq 0x40(%r14), %rdi
testq %rdi, %rdi
je 0x4816f
leaq 0x9ebe3(%rip), %rsi     # 0xe6d3d
callq 0x3c067
movq 0x40(%r14), %rdi
movl $0xa, %esi
callq 0x3c28d
jmp 0x48188
movq 0x38(%r14), %rdi
leaq 0x9bbda(%rip), %rsi     # 0xe3d54
leaq 0x9ebbc(%rip), %rdx     # 0xe6d3d
xorl %eax, %eax
callq 0x757a1
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x130e5
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/gff3_visitor.c
// Function: gff3_visitor_region_node
static int gff3_visitor_region_node(GtNodeVisitor *nv, GtRegionNode *rn,
                                    GT_UNUSED GtError *err)
{
  GtGFF3Visitor *gff3_visitor;
  gt_error_check(err);
  gff3_visitor = gff3_visitor_cast(nv);
  gt_assert(nv && rn);
  gff3_version_string(nv);
  if (!gff3_visitor->outstr) {
    gt_file_xprintf(gff3_visitor->outfp, "%s   %s "GT_WU" "GT_WU"\n",
                    GT_GFF_SEQUENCE_REGION,
                    gt_str_get(gt_genome_node_get_seqid((GtGenomeNode*) rn)),
                    gt_genome_node_get_start((GtGenomeNode*) rn),
                    gt_genome_node_get_end((GtGenomeNode*) rn));
  } else {
    gt_str_append_cstr(gff3_visitor->outstr, GT_GFF_SEQUENCE_REGION);
    gt_str_append_cstr(gff3_visitor->outstr, "   ");
    gt_str_append_cstr(gff3_visitor->outstr,
                      gt_str_get(gt_genome_node_get_seqid((GtGenomeNode*) rn)));
    gt_str_append_char(gff3_visitor->outstr, ' ');
    gt_str_append_uword(gff3_visitor->outstr,
                                  gt_genome_node_get_start((GtGenomeNode*) rn));
    gt_str_append_char(gff3_visitor->outstr, ' ');
    gt_str_append_uword(gff3_visitor->outstr,
                                  gt_genome_node_get_end((GtGenomeNode*) rn));
    gt_str_append_char(gff3_visitor->outstr, '\n');
  }
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
testq %rdx, %rdx
je 0x481bb
movq %rdx, %rdi
callq 0x3566a
testb %al, %al
jne 0x482e8
callq 0x47f10
movq %rax, %rdi
movq %r15, %rsi
callq 0x49c1d
testq %r15, %r15
je 0x482e3
testq %rbx, %rbx
je 0x482e3
movq %rax, %r14
movq %r15, %rdi
callq 0x486cb
movq 0x40(%r14), %rdi
testq %rdi, %rdi
je 0x4828a
leaq 0x9e9fa(%rip), %rsi     # 0xe6bf6
callq 0x3c067
movq 0x40(%r14), %rdi
leaq 0xb65d2(%rip), %rsi     # 0xfe7de
callq 0x3c067
movq 0x40(%r14), %r15
movq %rbx, %rdi
callq 0x41f3f
movq %rax, %rdi
callq 0x3c40b
movq %r15, %rdi
movq %rax, %rsi
callq 0x3c067
movq 0x40(%r14), %rdi
movl $0x20, %esi
callq 0x3c28d
movq 0x40(%r14), %r15
movq %rbx, %rdi
callq 0x41f7e
movq %r15, %rdi
movq %rax, %rsi
callq 0x3c1dc
movq 0x40(%r14), %rdi
movl $0x20, %esi
callq 0x3c28d
movq 0x40(%r14), %r15
movq %rbx, %rdi
callq 0x41fa1
movq %r15, %rdi
movq %rax, %rsi
callq 0x3c1dc
movq 0x40(%r14), %rdi
movl $0xa, %esi
callq 0x3c28d
jmp 0x482d5
movq 0x38(%r14), %r14
movq %rbx, %rdi
callq 0x41f3f
movq %rax, %rdi
callq 0x3c40b
movq %rax, %r15
movq %rbx, %rdi
callq 0x41f7e
movq %rax, %r12
movq %rbx, %rdi
callq 0x41fa1
leaq 0xa0746(%rip), %rsi     # 0xe8a01
leaq 0x9e934(%rip), %rdx     # 0xe6bf6
movq %r14, %rdi
movq %r15, %rcx
movq %r12, %r8
movq %rax, %r9
xorl %eax, %eax
callq 0x757a1
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x13157
callq 0x1311e
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/gff3_visitor.c
// Function: gff3_visitor_sequence_node
static int gff3_visitor_sequence_node(GtNodeVisitor *nv, GtSequenceNode *sn,
                                      GT_UNUSED GtError *err)
{
  GtGFF3Visitor *gff3_visitor;
  gt_error_check(err);
  gff3_visitor = gff3_visitor_cast(nv);
  gt_assert(nv && sn);
  gff3_version_string(nv);
  if (!gff3_visitor->fasta_directive_shown) {
    if (!gff3_visitor->outstr)
      gt_file_xprintf(gff3_visitor->outfp, "%s\n", GT_GFF_FASTA_DIRECTIVE);
    else {
      gt_str_append_cstr(gff3_visitor->outstr, GT_GFF_FASTA_DIRECTIVE);
      gt_str_append_char(gff3_visitor->outstr, '\n');
    }
    gff3_visitor->fasta_directive_shown = true;
  }
  if (!gff3_visitor->outstr) {
    gt_fasta_show_entry(gt_sequence_node_get_description(sn),
                        gt_sequence_node_get_sequence(sn),
                        gt_sequence_node_get_sequence_length(sn),
                        gff3_visitor->fasta_width, gff3_visitor->outfp);
  } else {
    gt_fasta_show_entry_str(gt_sequence_node_get_description(sn),
                            gt_sequence_node_get_sequence(sn),
                            gt_sequence_node_get_sequence_length(sn),
                            gff3_visitor->fasta_width, gff3_visitor->outstr);
  }
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
testq %rdx, %rdx
je 0x48311
movq %rdx, %rdi
callq 0x3566a
testb %al, %al
jne 0x483ea
callq 0x47f10
movq %rax, %rdi
movq %r15, %rsi
callq 0x49c1d
testq %r15, %r15
je 0x483e5
testq %rbx, %rbx
je 0x483e5
movq %rax, %r14
movq %r15, %rdi
callq 0x486cb
cmpb $0x0, 0x12(%r14)
jne 0x48388
movq 0x40(%r14), %rdi
testq %rdi, %rdi
je 0x4836a
leaq 0x9e899(%rip), %rsi     # 0xe6bee
callq 0x3c067
movq 0x40(%r14), %rdi
movl $0xa, %esi
callq 0x3c28d
jmp 0x48383
movq 0x38(%r14), %rdi
leaq 0x9b9df(%rip), %rsi     # 0xe3d54
leaq 0x9e872(%rip), %rdx     # 0xe6bee
xorl %eax, %eax
callq 0x757a1
movb $0x1, 0x12(%r14)
movq 0x40(%r14), %r13
movq %rbx, %rdi
callq 0x4a526
movq %rax, %r15
movq %rbx, %rdi
callq 0x4a53a
movq %rax, %r12
movq %rbx, %rdi
callq 0x4a54e
movq 0x30(%r14), %rcx
testq %r13, %r13
je 0x483c7
movq 0x40(%r14), %r8
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x74fc1
jmp 0x483d9
movq 0x38(%r14), %r8
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x74f5c
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x131c9
callq 0x13190
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/gff3_visitor.c
// Function: gff3_visitor_eof_node
static int gff3_visitor_eof_node(GtNodeVisitor *nv, GT_UNUSED GtEOFNode *en,
                                 GT_UNUSED GtError *err)
{
  gt_error_check(err);
  gt_assert(nv && en);
  gff3_version_string(nv);
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testq %rdx, %rdx
je 0x4840a
movq %rdx, %rdi
callq 0x3566a
testb %al, %al
jne 0x4842b
testq %rbx, %rbx
je 0x48426
testq %r14, %r14
je 0x48426
movq %rbx, %rdi
callq 0x486cb
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x1323b
callq 0x13202
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/gff3_visitor.c
// Function: gff3_visitor_meta_node
static int gff3_visitor_meta_node(GtNodeVisitor *nv, GtMetaNode *mn,
                                  GT_UNUSED GtError *err)
{
  GtGFF3Visitor *gff3_visitor;
  const char *data;
  gt_error_check(err);
  gff3_visitor = gff3_visitor_cast(nv);
  gt_assert(nv && mn);
  if (!gff3_visitor->version_string_shown) {
    if (strncmp(gt_meta_node_get_directive(mn), GT_GFF_VERSION_DIRECTIVE,
                strlen(GT_GFF_VERSION_DIRECTIVE)) == 0
          || strncmp(gt_meta_node_get_directive(mn), GT_GVF_VERSION_DIRECTIVE,
                     strlen(GT_GVF_VERSION_DIRECTIVE)) == 0) {
      gff3_visitor->version_string_shown = true;
    } else {
      gff3_version_string(nv);
    }
  }
  data = gt_meta_node_get_data(mn);
  if (!gff3_visitor->outstr) {
    if (data) {
      gt_file_xprintf(gff3_visitor->outfp, "##%s %s\n",
                      gt_meta_node_get_directive(mn), data);
    } else {
      gt_file_xprintf(gff3_visitor->outfp, "##%s\n",
                      gt_meta_node_get_directive(mn));
    }
  } else {
    gt_str_append_cstr(gff3_visitor->outstr, "##");
    gt_str_append_cstr(gff3_visitor->outstr, gt_meta_node_get_directive(mn));
    if (data) {
      gt_str_append_char(gff3_visitor->outstr, ' ');
      gt_str_append_cstr(gff3_visitor->outstr, data);
    }
    gt_str_append_char(gff3_visitor->outstr, '\n');
  }
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
testq %rdx, %rdx
je 0x48453
movq %rdx, %rdi
callq 0x3566a
testb %al, %al
jne 0x48583
callq 0x47f10
movq %rax, %rdi
movq %r15, %rsi
callq 0x49c1d
testq %r15, %r15
je 0x4857e
testq %r14, %r14
je 0x4857e
movq %rax, %rbx
cmpb $0x0, 0x10(%rax)
jne 0x484cc
movq %r14, %rdi
callq 0x496e2
leaq 0x9e554(%rip), %rsi     # 0xe69e1
movl $0xb, %edx
movq %rax, %rdi
callq 0xb2a0
testl %eax, %eax
je 0x484c8
movq %r14, %rdi
callq 0x496e2
leaq 0x9e542(%rip), %rsi     # 0xe69ef
movl $0xb, %edx
movq %rax, %rdi
callq 0xb2a0
testl %eax, %eax
je 0x484c8
movq %r15, %rdi
callq 0x486cb
jmp 0x484cc
movb $0x1, 0x10(%rbx)
movq %r14, %rdi
callq 0x496f7
movq %rax, %r15
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x48532
leaq 0x9e857(%rip), %rsi     # 0xe6d3e
callq 0x3c067
movq 0x40(%rbx), %r12
movq %r14, %rdi
callq 0x496e2
movq %r12, %rdi
movq %rax, %rsi
callq 0x3c067
testq %r15, %r15
je 0x48522
movq 0x40(%rbx), %rdi
movl $0x20, %esi
callq 0x3c28d
movq 0x40(%rbx), %rdi
movq %r15, %rsi
callq 0x3c067
movq 0x40(%rbx), %rdi
movl $0xa, %esi
callq 0x3c28d
jmp 0x48570
movq 0x38(%rbx), %rbx
movq %r14, %rdi
callq 0x496e2
testq %r15, %r15
je 0x4855c
leaq 0xa052b(%rip), %rsi     # 0xe8a75
movq %rbx, %rdi
movq %rax, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x757a1
jmp 0x48570
leaq 0xa051b(%rip), %rsi     # 0xe8a7e
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x757a1
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x132ad
callq 0x13274
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/gff3_visitor.c
// Function: gt_gff3_visitor_new
GtNodeVisitor* gt_gff3_visitor_new(GtFile *outfp)
{
  GtNodeVisitor *nv = gt_node_visitor_create(gt_gff3_visitor_class());
  GtGFF3Visitor *gff3_visitor = gff3_visitor_cast(nv);
  gt_gff3_visitor_init(gff3_visitor);
  gff3_visitor->outfp = gt_file_ref(outfp);
  gff3_visitor->outstr = NULL;
  return nv;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x47f10
movq %rax, %rdi
callq 0x49bec
movq %rax, %r14
callq 0x47f10
movq %rax, %rdi
movq %r14, %rsi
callq 0x49c1d
movq %rax, %r15
movq %rax, %rdi
callq 0x485d8
movq %rbx, %rdi
callq 0x75556
movq %rax, 0x38(%r15)
movq $0x0, 0x40(%r15)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/gff3_visitor.c
// Function: gt_gff3_visitor_init
static void gt_gff3_visitor_init(GtGFF3Visitor *gff3_visitor)
{
  gff3_visitor->version_string_shown = false;
  gff3_visitor->fasta_directive_shown = false;
  gff3_visitor->id_counter = gt_string_distri_new();
  gff3_visitor->feature_node_to_id_array =
    gt_hashmap_new(GT_HASH_DIRECT, NULL, (GtFree) gt_array_delete);
  gff3_visitor->feature_node_to_unique_id_str =
    gt_hashmap_new(GT_HASH_DIRECT, NULL, (GtFree) gt_str_delete);
  gff3_visitor->fasta_width = 0;
  gff3_visitor->used_ids = gt_cstr_table_new();
  /* XXX */
  gff3_visitor->retain_ids = getenv("GT_RETAINIDS") ? true : false;
  gff3_visitor->allow_nonunique_ids = false;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
movb %r14b, 0x10(%rdi)
movb %r14b, 0x12(%rdi)
callq 0x8314c
movq %rax, 0x18(%rbx)
leaq 0x26b3a(%rip), %rdx     # 0x6f134
xorl %edi, %edi
xorl %esi, %esi
callq 0x76f28
movq %rax, 0x20(%rbx)
leaq -0xb423(%rip), %rdx     # 0x3d1eb
xorl %edi, %edi
xorl %esi, %esi
callq 0x76f28
movq %rax, 0x28(%rbx)
movq $0x0, 0x30(%rbx)
callq 0x72918
movq %rax, 0x48(%rbx)
leaq 0xa0451(%rip), %rdi     # 0xe8a84
callq 0xb7c0
testq %rax, %rax
setne 0x11(%rbx)
movb %r14b, 0x13(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/gff3_visitor.c
// Function: gt_gff3_visitor_new_to_str
GtNodeVisitor* gt_gff3_visitor_new_to_str(GtStr *outstr)
{
  GtNodeVisitor *nv = gt_node_visitor_create(gt_gff3_visitor_class());
  GtGFF3Visitor *gff3_visitor = gff3_visitor_cast(nv);
  gt_gff3_visitor_init(gff3_visitor);
  gff3_visitor->outfp = NULL;
  gff3_visitor->outstr = gt_str_ref(outstr);
  return nv;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x47f10
movq %rax, %rdi
callq 0x49bec
movq %rax, %r14
callq 0x47f10
movq %rax, %rdi
movq %r14, %rsi
callq 0x49c1d
movq %rax, %r15
movq %rax, %rdi
callq 0x485d8
movq $0x0, 0x38(%r15)
movq %rbx, %rdi
callq 0x3c561
movq %rax, 0x40(%r15)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/gff3_visitor.c
// Function: gff3_version_string
static void gff3_version_string(GtNodeVisitor *nv)
{
  GtGFF3Visitor *gff3_visitor = gff3_visitor_cast(nv);
  gt_assert(gff3_visitor);
  if (!gff3_visitor->version_string_shown) {
    if (!gff3_visitor->outstr) {
      gt_file_xprintf(gff3_visitor->outfp, "%s %u\n", GT_GFF_VERSION_PREFIX,
                      GT_GFF_VERSION);
    } else {
      gt_str_append_cstr(gff3_visitor->outstr, GT_GFF_VERSION_PREFIX);
      gt_str_append_cstr(gff3_visitor->outstr, " ");
      gt_str_append_uint(gff3_visitor->outstr, GT_GFF_VERSION);
      gt_str_append_char(gff3_visitor->outstr, '\n');
    }
    gff3_visitor->version_string_shown = true;
  }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x47f10
movq %rax, %rdi
movq %rbx, %rsi
callq 0x49c1d
testq %rax, %rax
je 0x48754
movq %rax, %rbx
cmpb $0x0, 0x10(%rax)
jne 0x48752
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x48730
leaq 0x9e2e2(%rip), %rsi     # 0xe69df
callq 0x3c067
movq 0x40(%rbx), %rdi
leaq 0xb60d3(%rip), %rsi     # 0xfe7e0
callq 0x3c067
movq 0x40(%rbx), %rdi
movl $0x3, %esi
callq 0x3c3be
movq 0x40(%rbx), %rdi
movl $0xa, %esi
callq 0x3c28d
jmp 0x4874e
movq 0x38(%rbx), %rdi
leaq 0xa0184(%rip), %rsi     # 0xe88bf
leaq 0x9e29d(%rip), %rdx     # 0xe69df
movl $0x3, %ecx
xorl %eax, %eax
callq 0x757a1
movb $0x1, 0x10(%rbx)
popq %rbx
retq
callq 0x13391
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/gff3_visitor.c
// Function: make_id_unique
static GtStr* make_id_unique(GtGFF3Visitor *gff3_visitor, GtFeatureNode *fn)
{
  GtUword i = 1;
  GtStr *id = gt_str_new_cstr(gt_feature_node_get_attribute(fn, "ID"));

  if (!gff3_visitor->allow_nonunique_ids) {
    if (gt_cstr_table_get(gff3_visitor->used_ids, gt_str_get(id))) {
      GtStr *buf = gt_str_new();
      while (!id_string_is_unique(id, buf, gff3_visitor->used_ids, i++));
      gt_warning("feature ID \"%s\" not unique: changing to %s", gt_str_get(id),
                                                               gt_str_get(buf));
      gt_str_set(id, gt_str_get(buf));
      gt_str_delete(buf);
    }
    /* update table with the new id */
    gt_cstr_table_add(gff3_visitor->used_ids, gt_str_get(id));
  }

  /* store (unique) id */
  gt_hashmap_add(gff3_visitor->feature_node_to_unique_id_str, fn, id);

  return id;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x9ec1c(%rip), %rsi     # 0xe7775
movq %rbx, %rdi
callq 0x3f850
movq %rax, %rdi
callq 0x3c03d
movq %rax, %r15
cmpb $0x0, 0x13(%r14)
jne 0x48c54
movq 0x48(%r14), %r12
movq %r15, %rdi
callq 0x3c40b
movq %r12, %rdi
movq %rax, %rsi
callq 0x729dd
testq %rax, %rax
je 0x48c3d
movq %rbx, (%rsp)
movl $0x1, %r13d
callq 0x3bfe0
movq %rax, %r12
movq 0x48(%r14), %rbp
leaq 0x1(%r13), %rbx
movq %r12, %rdi
callq 0x3c49c
movq %r12, %rdi
movq %r15, %rsi
callq 0x3c12b
movq %r12, %rdi
movl $0x2e, %esi
callq 0x3c28d
movq %r12, %rdi
movq %r13, %rsi
callq 0x3c1dc
movq %r12, %rdi
callq 0x3c40b
movq %rbp, %rdi
movq %rax, %rsi
callq 0x729dd
movq %rbx, %r13
testq %rax, %rax
jne 0x48ba9
movq %r15, %rdi
callq 0x3c40b
movq %rax, %r13
movq %r12, %rdi
callq 0x3c40b
leaq 0x9fcec(%rip), %rdi     # 0xe88fd
movq %r13, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x3da84
movq %r12, %rdi
callq 0x3c40b
movq %r15, %rdi
movq %rax, %rsi
callq 0x3c0cc
movq %r12, %rdi
callq 0x3d1eb
movq (%rsp), %rbx
movq 0x48(%r14), %r12
movq %r15, %rdi
callq 0x3c40b
movq %r12, %rdi
movq %rax, %rsi
callq 0x7297e
movq 0x28(%r14), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x77144
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/gff3_visitor.c
// Function: create_unique_id
static GtStr* create_unique_id(GtGFF3Visitor *gff3_visitor, GtFeatureNode *fn)
{
  const char *type;
  GtStr *id;
  gt_assert(gff3_visitor && fn);
  type = gt_feature_node_get_type(fn);

  /* increase id counter */
  gt_string_distri_add(gff3_visitor->id_counter, type);

  /* build id string */
  id = gt_str_new_cstr(type);
  gt_str_append_uword(id, gt_string_distri_get(gff3_visitor->id_counter, type));

  /* store (unique) id */
  gt_hashmap_add(gff3_visitor->feature_node_to_unique_id_str, fn, id);

  return id;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0x48cdf
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x40276
movq %rax, %r15
movq 0x18(%r14), %rdi
movq %rax, %rsi
callq 0x831a6
movq %r15, %rdi
callq 0x3c03d
movq %rax, %r12
movq 0x18(%r14), %rdi
movq %r15, %rsi
callq 0x83298
movq %r12, %rdi
movq %rax, %rsi
callq 0x3c1dc
movq 0x28(%r14), %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x77144
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x134ac
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/gff3_visitor.c
// Function: add_id
static int add_id(GtFeatureNode *fn, void *data, GT_UNUSED GtError *err)
{
  AddIDInfo *info = (AddIDInfo*) data;
  GtArray *parent_features = NULL;
  gt_error_check(err);
  gt_assert(fn && info && info->gt_feature_node_to_id_array && info->id);
  parent_features = gt_hashmap_get(info->gt_feature_node_to_id_array, fn);
  if (!parent_features) {
    parent_features = gt_array_new(sizeof (char*));
    gt_hashmap_add(info->gt_feature_node_to_id_array, fn, parent_features);
  }
  gt_array_add(parent_features, info->id);
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testq %rdx, %rdx
je 0x48d03
movq %rdx, %rdi
callq 0x3566a
testb %al, %al
jne 0x48d6e
testq %rbx, %rbx
je 0x48d69
testq %r14, %r14
je 0x48d69
movq (%r14), %rdi
testq %rdi, %rdi
je 0x48d69
cmpq $0x0, 0x8(%r14)
je 0x48d69
leaq 0x8(%r14), %r15
movq %rbx, %rsi
callq 0x77109
movq %rax, %r12
testq %rax, %rax
jne 0x48d4b
movl $0x8, %edi
callq 0x6e93c
movq %rax, %r12
movq (%r14), %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x77144
movl $0x8, %edx
movq %r12, %rdi
movq %r15, %rsi
callq 0x6ec0e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x1351c
callq 0x134e5
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/gff3_visitor.c
// Function: show_attribute
static void show_attribute(const char *attr_name, const char *attr_value,
                           void *data)
{
  ShowAttributeInfo *info = (ShowAttributeInfo*) data;
  gt_assert(attr_name && attr_value && info);
  if (strcmp(attr_name, GT_GFF_ID) && strcmp(attr_name, GT_GFF_PARENT)) {
    if (*info->attribute_shown) {
      if (!info->outstr)
        gt_file_xfputc(';', info->outfp);
      else
        gt_str_append_char(info->outstr, ';');
    } else
      *info->attribute_shown = true;
    if (!info->outstr)
      gt_file_xprintf(info->outfp, "%s=%s", attr_name, attr_value);
    else {
      gt_str_append_cstr(info->outstr, attr_name);
      gt_str_append_char(info->outstr, '=');
      gt_str_append_cstr(info->outstr, attr_value);
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x48e42
movq %rsi, %rbx
testq %rsi, %rsi
je 0x48e42
movq %rdx, %r14
testq %rdx, %rdx
je 0x48e42
movq %rdi, %r15
leaq 0x9e9d2(%rip), %rsi     # 0xe7775
callq 0xb890
testl %eax, %eax
je 0x48ddc
leaq 0x9e9c5(%rip), %rsi     # 0xe7778
movq %r15, %rdi
callq 0xb890
testl %eax, %eax
je 0x48ddc
movq (%r14), %rax
cmpb $0x1, (%rax)
jne 0x48de2
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x48de7
movl $0x3b, %esi
callq 0x3c28d
jmp 0x48df5
popq %rbx
popq %r14
popq %r15
retq
movb $0x1, (%rax)
jmp 0x48df5
movq 0x8(%r14), %rsi
movl $0x3b, %edi
callq 0x759ff
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x48e25
movq %r15, %rsi
callq 0x3c067
movq 0x10(%r14), %rdi
movl $0x3d, %esi
callq 0x3c28d
movq 0x10(%r14), %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x3c067
movq 0x8(%r14), %rdi
leaq 0x9fb76(%rip), %rsi     # 0xe89a6
movq %r15, %rdx
movq %rbx, %rcx
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x757a1
callq 0x13553
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/mapping.c
// Function: gt_mapping_delete
void gt_mapping_delete(GtMapping *m)
{
  if (!m) return;
  gt_str_delete(m->mapping_file);
  gt_free(m->global);
  if (m->L) lua_close(m->L);
  gt_free(m);
}

// Assembly:
testq %rdi, %rdi
je 0x490a3
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x3d1eb
movq 0x8(%rbx), %rdi
leaq 0x9fa2a(%rip), %rsi     # 0xe8aa0
movl $0xe2, %edx
callq 0x362a0
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x4908e
callq 0x5ac59
leaq 0x9fa0b(%rip), %rsi     # 0xe8aa0
movq %rbx, %rdi
movl $0xe4, %edx
popq %rbx
jmp 0x362a0
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/mapping.c
// Function: gt_mapping_map_string
GtStr* gt_mapping_map_string(GtMapping *m, const char *input, GtError *err)
{
  GtStr *output = NULL;
  gt_error_check(err);
  map_generic(m, &output, NULL, input, err);
  return output;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq $0x0, (%rsp)
testq %rdx, %rdx
je 0x490ce
movq %rbx, %rdi
callq 0x3566a
testb %al, %al
jne 0x490f4
movq %rsp, %r12
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
movq %r14, %rcx
movq %rbx, %r8
callq 0x490f9
movq (%r12), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x13668
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/meta_node.c
// Function: gt_meta_node_class
const GtGenomeNodeClass* gt_meta_node_class()
{
  static const GtGenomeNodeClass *gnc = NULL;
  gt_class_alloc_lock_enter();
  if (!gnc) {
    gnc = gt_genome_node_class_new(sizeof (GtMetaNode),
                                   meta_node_free,
                                   NULL,
                                   meta_node_get_idstr,
                                   meta_node_get_range,
                                   NULL,
                                   NULL,
                                   meta_node_accept);
  }
  gt_class_alloc_lock_leave();
  return gnc;
}

// Assembly:
pushq %rax
callq 0x71d9b
cmpq $0x0, 0x109612(%rip)    # 0x152b58
jne 0x49581
leaq 0xbc(%rip), %rax        # 0x4960b
leaq 0x39(%rip), %rsi        # 0x4958f
leaq 0x85(%rip), %rcx        # 0x495e2
leaq 0xa2(%rip), %r8         # 0x49606
movl $0x48, %edi
xorl %edx, %edx
xorl %r9d, %r9d
pushq %rax
pushq $0x0
callq 0x41cc8
addq $0x10, %rsp
movq %rax, 0x1095d7(%rip)    # 0x152b58
callq 0x71db1
movq 0x1095cb(%rip), %rax    # 0x152b58
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/meta_node.c
// Function: meta_node_free
static void meta_node_free(GtGenomeNode *gn)
{
  GtMetaNode *m = gt_meta_node_cast(gn);
  gt_free(m->meta_directive);
  gt_free(m->meta_data);
  gt_str_delete(m->meta_str);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x49538
movq %rax, %rdi
movq %rbx, %rsi
callq 0x41edd
movq %rax, %rbx
movq 0x30(%rax), %rdi
leaq 0x9f798(%rip), %r14     # 0xe8d4c
movq %r14, %rsi
movl $0x25, %edx
callq 0x362a0
movq 0x38(%rbx), %rdi
movq %r14, %rsi
movl $0x26, %edx
callq 0x362a0
movq 0x40(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3d1eb
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/meta_node.c
// Function: meta_node_get_idstr
static GtStr* meta_node_get_idstr(GtGenomeNode *gn)
{
  GtMetaNode *m;
  gt_assert(gn);
  m = gt_meta_node_cast(gn);
  return m->meta_str;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x49601
movq %rdi, %rbx
callq 0x49538
movq %rax, %rdi
movq %rbx, %rsi
callq 0x41edd
movq 0x40(%rax), %rax
popq %rbx
retq
callq 0x13947
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/meta_node.c
// Function: meta_node_accept
static int meta_node_accept(GtGenomeNode *gn, GtNodeVisitor *nv, GtError *err)
{
  GtMetaNode *m;
  gt_error_check(err);
  m = gt_meta_node_cast(gn);
  return gt_node_visitor_visit_meta_node(nv, m, err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rdx, %rdx
je 0x4962a
movq %rbx, %rdi
callq 0x3566a
testb %al, %al
jne 0x4964d
callq 0x49538
movq %rax, %rdi
movq %r15, %rsi
callq 0x41edd
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x49cee
callq 0x1397e
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/meta_node.c
// Function: gt_meta_node_new
GtGenomeNode* gt_meta_node_new(const char *meta_directive,
                               const char *meta_data)
{
  GtGenomeNode *gn = gt_genome_node_create(gt_meta_node_class());
  GtMetaNode *m = gt_meta_node_cast(gn);
  gt_assert(meta_directive);
  m->meta_directive = gt_cstr_dup(meta_directive);
  if (meta_data)
    m->meta_data = gt_cstr_dup(meta_data);
  else
    m->meta_data = NULL;
  m->meta_str = gt_str_new_cstr("");
  return gn;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r12
callq 0x49538
movq %rax, %rdi
callq 0x41e44
movq %rax, %rbx
callq 0x49538
movq %rax, %rdi
movq %rbx, %rsi
callq 0x41edd
testq %r12, %r12
je 0x496c8
movq %rax, %r15
movq %r12, %rdi
callq 0x722dc
movq %rax, 0x30(%r15)
testq %r14, %r14
je 0x496a3
movq %r14, %rdi
callq 0x722dc
jmp 0x496a5
xorl %eax, %eax
movq %rax, 0x38(%r15)
leaq 0xa54cf(%rip), %rdi     # 0xeeb7f
callq 0x3c03d
movq %rax, 0x40(%r15)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x139b5
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/multi_sanitizer_visitor.c
// Function: msv_feature_node
static int msv_feature_node(GtNodeVisitor *nv, GtFeatureNode *fn,
                            GtError *err)
{
  GtMultiSanitizerVisitor *msv;
  int had_err = 0;
  gt_error_check(err);
  msv = msv_cast(nv);

  gt_hashmap_reset(msv->first_elems);
  had_err = gt_feature_node_traverse_children(fn, msv,
                                              msv_fixup_representatives,
                                              true, err);
  gt_assert(!had_err);   /* msv_fixup_representatives() is sane */

  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rdx, %rdx
je 0x497a9
movq %rbx, %rdi
callq 0x3566a
testb %al, %al
jne 0x497f0
callq 0x4971c
movq %rax, %rdi
movq %r15, %rsi
callq 0x49c1d
movq %rax, %r15
movq 0x10(%rax), %rdi
callq 0x77249
leaq 0x6a(%rip), %rdx        # 0x49836
movq %r14, %rdi
movq %r15, %rsi
movl $0x1, %ecx
movq %rbx, %r8
callq 0x4068e
testl %eax, %eax
jne 0x497eb
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x13ac8
callq 0x13a91
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/multi_sanitizer_visitor.c
// Function: gt_multi_sanitizer_visitor_new
GtNodeVisitor* gt_multi_sanitizer_visitor_new()
{
  GtNodeVisitor *nv =
                     gt_node_visitor_create(gt_multi_sanitizer_visitor_class());
  GtMultiSanitizerVisitor *msv = msv_cast(nv);
  msv->first_elems = gt_hashmap_new(GT_HASH_DIRECT, NULL, NULL);

  return nv;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x4971c
movq %rax, %rdi
callq 0x49bec
movq %rax, %rbx
callq 0x4971c
movq %rax, %rdi
movq %rbx, %rsi
callq 0x49c1d
movq %rax, %r14
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x76f28
movq %rax, 0x10(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/multi_sanitizer_visitor.c
// Function: msv_fixup_representatives
static int msv_fixup_representatives(GtFeatureNode *fn, void *data,
                                     GT_UNUSED GtError *err)
{
  int had_err = 0;
  GtMultiSanitizerVisitor *msv = (GtMultiSanitizerVisitor*) data;

  if (gt_feature_node_is_multi(fn)) {
    GtFeatureNode *rep = NULL;
    if (!(rep = gt_hashmap_get(msv->first_elems,
                               gt_feature_node_get_multi_representative(fn)))) {
      gt_hashmap_add(msv->first_elems,
                     gt_feature_node_get_multi_representative(fn),
                     fn);
      gt_feature_node_unset_multi(fn);
      gt_feature_node_make_multi_representative(fn);
    } else {
      gt_assert(rep);
      gt_feature_node_unset_multi(fn);
      gt_feature_node_set_multi_representative(fn, rep);
    }
  }
  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
callq 0x40432
testb %al, %al
je 0x498a8
movq 0x10(%r14), %r15
movq %rbx, %rdi
callq 0x40571
movq %r15, %rdi
movq %rax, %rsi
callq 0x77109
testq %rax, %rax
je 0x4987e
movq %rax, %r15
movq %rbx, %rdi
callq 0x40559
movq %rbx, %rdi
movq %r15, %rsi
callq 0x404de
jmp 0x498a8
movq 0x10(%r14), %r14
movq %rbx, %rdi
callq 0x40571
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x77144
movq %rbx, %rdi
callq 0x40559
movq %rbx, %rdi
callq 0x40480
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/node_stream.c
// Function: gt_node_stream_class_new
const GtNodeStreamClass*
gt_node_stream_class_new(size_t size, GtNodeStreamFreeFunc free,
                         GtNodeStreamNextFunc next)
{
  GtNodeStreamClass *c_class;
  gt_assert(size && next);
  c_class = gt_class_alloc(sizeof *c_class);
  c_class->size = size;
  c_class->free = free;
  c_class->next = next;
  return c_class;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x498e3
movq %rdx, %rbx
testq %rdx, %rdx
je 0x498e3
movq %rsi, %r14
movq %rdi, %r15
movl $0x18, %edi
callq 0x71ca4
movq %r15, (%rax)
movq %r14, 0x8(%rax)
movq %rbx, 0x10(%rax)
popq %rbx
popq %r14
popq %r15
retq
callq 0x13aff