LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/gff3_parser.c
// Function: verify_seqid
static int verify_seqid(const GtStr *seqid, const char *filename,
                        unsigned int line_number, GtError *err)
{
  int had_err = 0;
  gt_error_check(err);
  gt_assert(seqid);
  if (gt_md5_seqid_has_prefix(gt_str_get(seqid))) {
    if (gt_str_length(seqid) < GT_MD5_SEQID_PREFIX_LEN +
                               GT_MD5_SEQID_HASH_LEN) {
      gt_error_set(err, "MD5 sequence ID '%s' on line %u in file \"%s\" is too "
                   "short", gt_str_get(seqid), line_number, filename);
      had_err = -1;
    }
    if (!had_err && gt_str_length(seqid) >= GT_MD5_SEQID_TOTAL_LEN) {
      const char *sid = gt_str_get(seqid);
      if (sid[GT_MD5_SEQID_TOTAL_LEN-1] != GT_MD5_SEQID_SEPARATOR) {
        gt_error_set(err, "MD5 sequence ID '%s' on line %u in file \"%s\" has "
                     "wrong separator '%c' (must be '%c')",
                     gt_str_get(seqid), line_number, filename,
                     sid[GT_MD5_SEQID_TOTAL_LEN-1], GT_MD5_SEQID_SEPARATOR);
        had_err = -1;
      }
    }
    if (!had_err && gt_str_length(seqid) == GT_MD5_SEQID_TOTAL_LEN) {
      gt_error_set(err, "MD5 sequence ID '%s' on line %u in file \"%s\" has "
                   "missing sequence ID after separator '%c'",
                   gt_str_get(seqid), line_number, filename,
                   GT_MD5_SEQID_SEPARATOR);
      had_err = -1;
    }
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r15
testq %rcx, %rcx
je 0x46600
movq %r14, %rdi
callq 0x34fea
testb %al, %al
jne 0x466ee
testq %r15, %r15
je 0x466e9
movq %r15, %rdi
callq 0x3bb5d
movq %rax, %rdi
callq 0x7aa64
xorl %r12d, %r12d
testb %al, %al
je 0x466d7
movq %r15, %rdi
callq 0x3bb86
cmpq $0x23, %rax
jbe 0x4667e
movq %r15, %rdi
callq 0x3bb86
cmpq $0x25, %rax
jb 0x4664e
movq %r15, %rdi
callq 0x3bb5d
cmpb $0x3a, 0x24(%rax)
jne 0x466a1
movq %r15, %rdi
callq 0x3bb86
cmpq $0x25, %rax
jne 0x466d7
movq %r15, %rdi
callq 0x3bb5d
leaq 0xa02b3(%rip), %rsi     # 0xe691e
movq %r14, %rdi
movq %rax, %rdx
movl %ebp, %ecx
movq %rbx, %r8
movl $0x3a, %r9d
jmp 0x466ca
movq %r15, %rdi
callq 0x3bb5d
leaq 0xa0202(%rip), %rsi     # 0xe688f
movq %r14, %rdi
movq %rax, %rdx
movl %ebp, %ecx
movq %rbx, %r8
xorl %eax, %eax
callq 0x34f1f
jmp 0x466d1
movq %rax, %r13
movq %r15, %rdi
callq 0x3bb5d
movsbl 0x24(%r13), %r9d
movl $0x3a, (%rsp)
leaq 0xa020a(%rip), %rsi     # 0xe68c9
movq %r14, %rdi
movq %rax, %rdx
movl %ebp, %ecx
movq %rbx, %r8
xorl %eax, %eax
callq 0x34f1f
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x128b0
callq 0x12877
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/gff3_parser.c
// Function: add_offset_if_necessary
static int add_offset_if_necessary(GtRange *range, GtGFF3Parser *parser,
                                   const char *seqid, const char *filename,
                                   GtUword line_number, GtError *err)
{
  int had_err = 0;
  gt_error_check(err);
  if (parser->offset != GT_UNDEF_WORD) {
    had_err = offset_possible(range, parser->offset, filename, line_number,
                              err);
    if (!had_err)
      *range = gt_range_offset(range, parser->offset);
  }
  else if (parser->offset_mapping) {
    GtWord offset;
    had_err = gt_mapping_map_integer(parser->offset_mapping, &offset, seqid,
                                     err);
    if (!had_err)
      had_err = offset_possible(range, offset, filename, line_number, err);
    if (!had_err)
      *range = gt_range_offset(range, offset);
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %rbp
movq %rsi, %r13
movq %rdi, %rbx
testq %r9, %r9
je 0x46725
movq %r14, %rdi
callq 0x34fea
testb %al, %al
jne 0x467b2
movq 0x28(%r13), %rsi
movq %rsi, %rax
negq %rax
jno 0x46772
movq 0x30(%r13), %rdi
testq %rdi, %rdi
je 0x467a1
movq %rsp, %rsi
movq %rbp, %rdx
movq %r14, %rcx
callq 0x4887a
testl %eax, %eax
jne 0x467a3
movq (%rsp), %rsi
movq %rbx, %rdi
movq %r12, %rdx
movl %r15d, %ecx
movq %r14, %r8
callq 0x4680e
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0x467a3
movq (%rsp), %rsi
jmp 0x46792
movq %rbx, %rdi
movq %r12, %rdx
movl %r15d, %ecx
movq %r14, %r8
callq 0x4680e
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0x467a3
movq 0x28(%r13), %rsi
movq %rbx, %rdi
callq 0x7e2dc
movq %rax, (%rbx)
movq %rdx, 0x8(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x128e9
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/gff3_parser.c
// Function: simple_sequence_region_new
static SimpleSequenceRegion* simple_sequence_region_new(const char *seqid,
                                                        GtRange range,
                                                        unsigned int
                                                        line_number)
{
  SimpleSequenceRegion *ssr = gt_calloc(1, sizeof *ssr);
  ssr->seqid_str = gt_str_new_cstr(seqid);
  ssr->range = range;
  ssr->line_number = line_number;
  return ssr;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x9fcce(%rip), %rdx     # 0xe64a0
movl $0x1, %edi
movl $0x20, %esi
movl $0x55, %ecx
callq 0x359a6
movq %rax, %r13
movq %r12, %rdi
callq 0x3b785
movq %rax, (%r13)
movq %r15, 0x8(%r13)
movq %r14, 0x10(%r13)
movl %ebx, 0x18(%r13)
movq %r13, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/gff3_parser.c
// Function: offset_possible
static int offset_possible(const GtRange *range, GtWord offset,
                           const char *filename, unsigned int line_number,
                           GtError *err)
{
  int had_err = 0;
  gt_error_check(err);
  if (offset < 0) {
    /* check for underflow */
    GtUword result = range->start + offset;
    if (result == 0) {
      gt_error_set(err, "==0");
      gt_error_set(err, "adding offset "GT_WD" to node on line %u in file "
                   "\"%s\" leads to start 0 (GFF3 files are 1-based)",
                   offset, line_number, filename);
      had_err = -1;
    }
    else if (result > range->start) {
      gt_error_set(err, "adding offset "GT_WD" to node on line %u in file "
                   "\"%s\" leads to underflow",
                   offset, line_number, filename);
      had_err = -1;
    }
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %r14
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
testq %r8, %r8
je 0x46835
movq %r14, %rdi
callq 0x34fea
testb %al, %al
jne 0x4688e
xorl %eax, %eax
testq %r15, %r15
jns 0x46885
movq (%r12), %rcx
movq %rcx, %rdx
addq %r15, %rdx
je 0x46856
cmpq %rcx, %rdx
jbe 0x46885
leaq 0xa06d0(%rip), %rsi     # 0xe6f24
jmp 0x4686e
leaq 0xaafed(%rip), %rsi     # 0xf184a
movq %r14, %rdi
xorl %eax, %eax
callq 0x34f1f
leaq 0xa065a(%rip), %rsi     # 0xe6ec8
movq %r14, %rdi
movq %r15, %rdx
movl %ebp, %ecx
movq %rbx, %r8
xorl %eax, %eax
callq 0x34f1f
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x12922
// File: /workspace/github_c_makefile_star2_O3/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 0x468f2
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x3faf4
testb %al, %al
je 0x468f2
movq %r15, %rdi
callq 0x3faf4
testb %al, %al
jne 0x468f7
testq %r14, %r14
je 0x468fc
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3f6eb
leaq 0xa0e51(%rip), %rsi     # 0xe7723
movq %r15, %rdi
callq 0x3eedc
testq %rax, %rax
je 0x46901
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x84cf9
callq 0x12a06
callq 0x129cd
callq 0x12994
callq 0x1295b
// File: /workspace/github_c_makefile_star2_O3/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 0x46939
leaq 0x8(%rsp), %rax
movq %rdi, (%rax)
movq %rsi, 0x8(%rax)
leaq 0xa5(%rip), %rsi        # 0x469c7
movq %rdx, %rdi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x7c927
cmpl $0x1, %eax
jne 0x4693e
addq $0x18, %rsp
retq
callq 0x12a78
callq 0x12a3f
// File: /workspace/github_c_makefile_star2_O3/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 0x469b8
movq %rsi, %r14
movq %rdi, %rbx
callq 0x3faf4
testb %al, %al
je 0x469bd
movq %r14, %rdi
callq 0x3faf4
testb %al, %al
jne 0x469c2
movq %rbx, %rdi
callq 0x415e5
leaq 0x20(%rsp), %r15
movq %rax, (%r15)
movq %rdx, 0x8(%r15)
movq %r14, %rdi
callq 0x415e5
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
movq %r15, %rdi
callq 0x7e2af
movq %rsp, %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
movq %rbx, %rdi
callq 0x41646
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x12b23
callq 0x12ab1
callq 0x12aea
// File: /workspace/github_c_makefile_star2_O3/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 0x469e2
movq %rdx, %rdi
callq 0x34fea
testb %al, %al
jne 0x46a0f
testq %rbx, %rbx
je 0x46a0a
testq %r14, %r14
je 0x46a0a
movq (%rbx), %rcx
xorl %eax, %eax
cmpq (%r14), %rcx
jne 0x46a02
movq 0x8(%r14), %rax
movq %rax, (%rbx)
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x12b95
callq 0x12b5c
// File: /workspace/github_c_makefile_star2_O3/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 $0x18, %rsp
movq %r9, %r15
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %r12
testq %r9, %r9
je 0x46a49
movq %r15, %rdi
callq 0x34fea
testb %al, %al
jne 0x46b24
testq %rbp, %rbp
je 0x46b1f
movq %rbp, %rdi
callq 0x3cbed
testq %rax, %rax
je 0x46ac5
movq %r12, (%rsp)
movq %r14, 0x8(%rsp)
movq %rbx, 0x10(%rsp)
xorl %r14d, %r14d
leaq 0xa0caf(%rip), %r12     # 0xe7726
movq %rbp, %rdi
movq %r14, %rsi
callq 0x3ca6f
movq %rax, %rbx
cmpb $0x49, (%rax)
jne 0x46a96
cmpb $0x44, 0x1(%rbx)
jne 0x46a96
cmpb $0x0, 0x2(%rbx)
je 0x46aa5
movq %rbx, %rdi
movq %r12, %rsi
callq 0xb890
testl %eax, %eax
jne 0x46ab5
movq %r13, %rdi
movq %rbx, %rsi
callq 0x3eedc
testq %rax, %rax
je 0x46ad6
incq %r14
movq %rbp, %rdi
callq 0x3cbed
cmpq %rax, %r14
jb 0x46a77
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r13, %rdi
callq 0x41592
movl %eax, %ebp
movq (%rsp), %rdi
callq 0x41592
movl %eax, %r10d
leaq 0xa13d3(%rip), %rsi     # 0xe7ec6
leaq 0xa0c29(%rip), %rdx     # 0xe7723
movq %r15, %rdi
movq 0x8(%rsp), %rcx
movl %ebp, %r8d
movq 0x10(%rsp), %r9
xorl %eax, %eax
pushq %r10
pushq %rbx
callq 0x34f1f
addq $0x10, %rsp
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x46ac7
callq 0x12c07
callq 0x12bce
// File: /workspace/github_c_makefile_star2_O3/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 0x3faf4
testb %al, %al
je 0x4728f
movq %r15, %rdi
callq 0x3faf4
testb %al, %al
jne 0x47294
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x46893
movq %r14, %rdi
movq %r15, %rsi
callq 0x7c636
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x12eb3
callq 0x12eec
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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:
movq 0x10b8ad(%rip), %rax    # 0x152b50
testq %rax, %rax
je 0x472a9
retq
pushq %rax
leaq 0x4cd(%rip), %rax       # 0x4777e
movq %rax, (%rsp)
leaq 0x48(%rip), %rsi        # 0x47304
leaq 0x99(%rip), %rdx        # 0x4735c
leaq 0x143(%rip), %rcx       # 0x4740d
leaq 0x256(%rip), %r8        # 0x47527
leaq 0x3a4(%rip), %r9        # 0x4767c
movl $0x50, %edi
callq 0x48f24
movq %rax, 0x10b867(%rip)    # 0x152b50
leaq 0x4cf(%rip), %rsi       # 0x477bf
movq %rax, %rdi
callq 0x48f84
movq 0x10b851(%rip), %rax    # 0x152b50
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4729c
movq %rax, %rdi
movq %rbx, %rsi
callq 0x48fc5
testq %rax, %rax
je 0x47357
movq %rax, %rbx
movq 0x18(%rax), %rdi
callq 0x83031
movq 0x20(%rbx), %rdi
callq 0x77bab
movq 0x28(%rbx), %rdi
callq 0x77bab
movq 0x48(%rbx), %rdi
callq 0x73273
movq 0x40(%rbx), %rdi
callq 0x3c87b
movq 0x38(%rbx), %rdi
popq %rbx
jmp 0x760c0
callq 0x12f25
// File: /workspace/github_c_makefile_star2_O3/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 0x4737c
movq %rdx, %rdi
callq 0x34fea
testb %al, %al
jne 0x47408
callq 0x4729c
movq %rax, %rdi
movq %r15, %rsi
callq 0x48fc5
testq %r15, %r15
je 0x47403
testq %rbx, %rbx
je 0x47403
movq %rax, %r14
movq %r15, %rdi
callq 0x47a5a
movq 0x40(%r14), %rdi
testq %rdi, %rdi
je 0x473db
movl $0x23, %esi
callq 0x3b9df
movq 0x40(%r14), %r15
movq %rbx, %rdi
callq 0x84a3f
movq %r15, %rdi
movq %rax, %rsi
callq 0x3b7af
movq 0x40(%r14), %rdi
movl $0xa, %esi
callq 0x3b9df
jmp 0x473fb
movq 0x38(%r14), %r14
movq %rbx, %rdi
callq 0x84a3f
leaq 0xa163f(%rip), %rsi     # 0xe8a2d
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x75ce5
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x12f93
callq 0x12f5c
// File: /workspace/github_c_makefile_star2_O3/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 0x47433
movq %r15, %rdi
callq 0x34fea
testb %al, %al
jne 0x47522
callq 0x4729c
movq %rax, %rdi
movq %r12, %rsi
callq 0x48fc5
movq %rax, %r14
movq %r12, %rdi
callq 0x47a5a
leaq 0x693(%rip), %rdx       # 0x47ae8
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1, %ecx
movq %r15, %r8
callq 0x3fd29
movl %eax, %ebp
testl %eax, %eax
jne 0x474a0
movq %rbx, %rdi
callq 0x40c58
leaq 0x7cd(%rip), %rdx       # 0x47c4a
movq %rbx, %rdi
movq %r14, %rsi
testb %al, %al
je 0x47496
movl $0x1, %ecx
movq %r15, %r8
callq 0x3fd29
jmp 0x4749e
movq %r15, %rcx
callq 0x406f1
movl %eax, %ebp
movq 0x20(%r14), %rdi
callq 0x7772d
movq 0x28(%r14), %rdi
callq 0x7772d
movq %rbx, %rdi
callq 0x3f8ef
testb %al, %al
jne 0x474d9
cmpb $0x1, 0x11(%r14)
jne 0x47517
leaq 0xa0257(%rip), %rsi     # 0xe7723
movq %rbx, %rdi
callq 0x3eedc
testq %rax, %rax
je 0x47517
movq 0x40(%r14), %rdi
testq %rdi, %rdi
je 0x474fe
leaq 0x9f802(%rip), %rsi     # 0xe6ceb
callq 0x3b7af
movq 0x40(%r14), %rdi
movl $0xa, %esi
callq 0x3b9df
jmp 0x47517
movq 0x38(%r14), %rdi
leaq 0x9c827(%rip), %rsi     # 0xe3d30
leaq 0x9f7db(%rip), %rdx     # 0xe6ceb
xorl %eax, %eax
callq 0x75ce5
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x12fca
// File: /workspace/github_c_makefile_star2_O3/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 0x4754a
movq %rdx, %rdi
callq 0x34fea
testb %al, %al
jne 0x47677
callq 0x4729c
movq %rax, %rdi
movq %r15, %rsi
callq 0x48fc5
testq %r15, %r15
je 0x47672
testq %rbx, %rbx
je 0x47672
movq %rax, %r14
movq %r15, %rdi
callq 0x47a5a
movq 0x40(%r14), %rdi
testq %rdi, %rdi
je 0x47619
leaq 0x9f619(%rip), %rsi     # 0xe6ba4
callq 0x3b7af
movq 0x40(%r14), %rdi
leaq 0xb71e3(%rip), %rsi     # 0xfe77e
callq 0x3b7af
movq 0x40(%r14), %r15
movq %rbx, %rdi
callq 0x415a1
movq %rax, %rdi
callq 0x3bb5d
movq %r15, %rdi
movq %rax, %rsi
callq 0x3b7af
movq 0x40(%r14), %rdi
movl $0x20, %esi
callq 0x3b9df
movq 0x40(%r14), %r15
movq %rbx, %rdi
callq 0x415e0
movq %r15, %rdi
movq %rax, %rsi
callq 0x3b92e
movq 0x40(%r14), %rdi
movl $0x20, %esi
callq 0x3b9df
movq 0x40(%r14), %r15
movq %rbx, %rdi
callq 0x41603
movq %r15, %rdi
movq %rax, %rsi
callq 0x3b92e
movq 0x40(%r14), %rdi
movl $0xa, %esi
callq 0x3b9df
jmp 0x47664
movq 0x38(%r14), %r14
movq %rbx, %rdi
callq 0x415a1
movq %rax, %rdi
callq 0x3bb5d
movq %rax, %r15
movq %rbx, %rdi
callq 0x415e0
movq %rax, %r12
movq %rbx, %rdi
callq 0x41603
leaq 0xa1365(%rip), %rsi     # 0xe89af
leaq 0x9f553(%rip), %rdx     # 0xe6ba4
movq %r14, %rdi
movq %r15, %rcx
movq %r12, %r8
movq %rax, %r9
xorl %eax, %eax
callq 0x75ce5
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x1303c
callq 0x13003
// File: /workspace/github_c_makefile_star2_O3/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 0x476a0
movq %rdx, %rdi
callq 0x34fea
testb %al, %al
jne 0x47779
callq 0x4729c
movq %rax, %rdi
movq %r15, %rsi
callq 0x48fc5
testq %r15, %r15
je 0x47774
testq %rbx, %rbx
je 0x47774
movq %rax, %r14
movq %r15, %rdi
callq 0x47a5a
cmpb $0x0, 0x12(%r14)
jne 0x47717
movq 0x40(%r14), %rdi
testq %rdi, %rdi
je 0x476f9
leaq 0x9f4b8(%rip), %rsi     # 0xe6b9c
callq 0x3b7af
movq 0x40(%r14), %rdi
movl $0xa, %esi
callq 0x3b9df
jmp 0x47712
movq 0x38(%r14), %rdi
leaq 0x9c62c(%rip), %rsi     # 0xe3d30
leaq 0x9f491(%rip), %rdx     # 0xe6b9c
xorl %eax, %eax
callq 0x75ce5
movb $0x1, 0x12(%r14)
movq 0x40(%r14), %r13
movq %rbx, %rdi
callq 0x498ce
movq %rax, %r15
movq %rbx, %rdi
callq 0x498e2
movq %rax, %r12
movq %rbx, %rdi
callq 0x498f6
movq 0x30(%r14), %rcx
testq %r13, %r13
je 0x47756
movq 0x40(%r14), %r8
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x75500
jmp 0x47768
movq 0x38(%r14), %r8
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x75498
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x130ae
callq 0x13075
// File: /workspace/github_c_makefile_star2_O3/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 0x47799
movq %rdx, %rdi
callq 0x34fea
testb %al, %al
jne 0x477ba
testq %rbx, %rbx
je 0x477b5
testq %r14, %r14
je 0x477b5
movq %rbx, %rdi
callq 0x47a5a
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x13120
callq 0x130e7
// File: /workspace/github_c_makefile_star2_O3/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 0x477e2
movq %rdx, %rdi
callq 0x34fea
testb %al, %al
jne 0x47912
callq 0x4729c
movq %rax, %rdi
movq %r15, %rsi
callq 0x48fc5
testq %r15, %r15
je 0x4790d
testq %r14, %r14
je 0x4790d
movq %rax, %rbx
cmpb $0x0, 0x10(%rax)
jne 0x4785b
movq %r14, %rdi
callq 0x48a7e
leaq 0x9f185(%rip), %rsi     # 0xe69a1
movl $0xb, %edx
movq %rax, %rdi
callq 0xb2a0
testl %eax, %eax
je 0x47857
movq %r14, %rdi
callq 0x48a7e
leaq 0x9f173(%rip), %rsi     # 0xe69af
movl $0xb, %edx
movq %rax, %rdi
callq 0xb2a0
testl %eax, %eax
je 0x47857
movq %r15, %rdi
callq 0x47a5a
jmp 0x4785b
movb $0x1, 0x10(%rbx)
movq %r14, %rdi
callq 0x48a93
movq %rax, %r15
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x478c1
leaq 0x9f476(%rip), %rsi     # 0xe6cec
callq 0x3b7af
movq 0x40(%rbx), %r12
movq %r14, %rdi
callq 0x48a7e
movq %r12, %rdi
movq %rax, %rsi
callq 0x3b7af
testq %r15, %r15
je 0x478b1
movq 0x40(%rbx), %rdi
movl $0x20, %esi
callq 0x3b9df
movq 0x40(%rbx), %rdi
movq %r15, %rsi
callq 0x3b7af
movq 0x40(%rbx), %rdi
movl $0xa, %esi
callq 0x3b9df
jmp 0x478ff
movq 0x38(%rbx), %rbx
movq %r14, %rdi
callq 0x48a7e
testq %r15, %r15
je 0x478eb
leaq 0xa114a(%rip), %rsi     # 0xe8a23
movq %rbx, %rdi
movq %rax, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x75ce5
jmp 0x478ff
leaq 0xa113a(%rip), %rsi     # 0xe8a2c
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x75ce5
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x13192
callq 0x13159
// File: /workspace/github_c_makefile_star2_O3/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 0x4729c
movq %rax, %rdi
callq 0x48f94
movq %rax, %r14
callq 0x4729c
movq %rax, %rdi
movq %r14, %rsi
callq 0x48fc5
movq %rax, %r15
movq %rax, %rdi
callq 0x47967
movq %rbx, %rdi
callq 0x75a9d
movq %rax, 0x38(%r15)
movq $0x0, 0x40(%r15)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x82d3c
movq %rax, 0x18(%rbx)
leaq 0x27ddf(%rip), %rdx     # 0x6f768
xorl %edi, %edi
xorl %esi, %esi
callq 0x7740c
movq %rax, 0x20(%rbx)
leaq -0xb122(%rip), %rdx     # 0x3c87b
xorl %edi, %edi
xorl %esi, %esi
callq 0x7740c
movq %rax, 0x28(%rbx)
movq $0x0, 0x30(%rbx)
callq 0x72f00
movq %rax, 0x48(%rbx)
leaq 0xa1070(%rip), %rdi     # 0xe8a32
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_O3/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 0x4729c
movq %rax, %rdi
callq 0x48f94
movq %rax, %r14
callq 0x4729c
movq %rax, %rdi
movq %r14, %rsi
callq 0x48fc5
movq %rax, %r15
movq %rax, %rdi
callq 0x47967
movq $0x0, 0x38(%r15)
movq %rbx, %rdi
callq 0x3bcaf
movq %rax, 0x40(%r15)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4729c
movq %rax, %rdi
movq %rbx, %rsi
callq 0x48fc5
testq %rax, %rax
je 0x47ae3
movq %rax, %rbx
cmpb $0x0, 0x10(%rax)
jne 0x47ae1
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x47abf
leaq 0x9ef13(%rip), %rsi     # 0xe699f
callq 0x3b7af
movq 0x40(%rbx), %rdi
leaq 0xb6ce4(%rip), %rsi     # 0xfe780
callq 0x3b7af
movq 0x40(%rbx), %rdi
movl $0x3, %esi
callq 0x3bb10
movq 0x40(%rbx), %rdi
movl $0xa, %esi
callq 0x3b9df
jmp 0x47add
movq 0x38(%rbx), %rdi
leaq 0xa0da3(%rip), %rsi     # 0xe886d
leaq 0x9eece(%rip), %rdx     # 0xe699f
movl $0x3, %ecx
xorl %eax, %eax
callq 0x75ce5
movb $0x1, 0x10(%rbx)
popq %rbx
retq
callq 0x13276
// File: /workspace/github_c_makefile_star2_O3/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 0x9f83d(%rip), %rsi     # 0xe7723
movq %rbx, %rdi
callq 0x3eedc
movq %rax, %rdi
callq 0x3b785
movq %rax, %r15
cmpb $0x0, 0x13(%r14)
jne 0x47fe1
movq 0x48(%r14), %r12
movq %r15, %rdi
callq 0x3bb5d
movq %r12, %rdi
movq %rax, %rsi
callq 0x72fc5
testq %rax, %rax
je 0x47fca
movq %rbx, (%rsp)
movl $0x1, %r13d
callq 0x3b728
movq %rax, %r12
movq 0x48(%r14), %rbp
leaq 0x1(%r13), %rbx
movq %r12, %rdi
callq 0x3bbee
movq %r12, %rdi
movq %r15, %rsi
callq 0x3b87d
movq %r12, %rdi
movl $0x2e, %esi
callq 0x3b9df
movq %r12, %rdi
movq %r13, %rsi
callq 0x3b92e
movq %r12, %rdi
callq 0x3bb5d
movq %rbp, %rdi
movq %rax, %rsi
callq 0x72fc5
movq %rbx, %r13
testq %rax, %rax
jne 0x47f36
movq %r15, %rdi
callq 0x3bb5d
movq %rax, %r13
movq %r12, %rdi
callq 0x3bb5d
leaq 0xa090d(%rip), %rdi     # 0xe88ab
movq %r13, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x3d110
movq %r12, %rdi
callq 0x3bb5d
movq %r15, %rdi
movq %rax, %rsi
callq 0x3b81e
movq %r12, %rdi
callq 0x3c87b
movq (%rsp), %rbx
movq 0x48(%r14), %r12
movq %r15, %rdi
callq 0x3bb5d
movq %r12, %rdi
movq %rax, %rsi
callq 0x72f66
movq 0x28(%r14), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x77628
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_O3/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 0x4806c
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x3f914
movq %rax, %r15
movq 0x18(%r14), %rdi
movq %rax, %rsi
callq 0x82d96
movq %r15, %rdi
callq 0x3b785
movq %rax, %r12
movq 0x18(%r14), %rdi
movq %r15, %rsi
callq 0x82e88
movq %r12, %rdi
movq %rax, %rsi
callq 0x3b92e
movq 0x28(%r14), %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x77628
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x13391
// File: /workspace/github_c_makefile_star2_O3/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 0x48090
movq %rdx, %rdi
callq 0x34fea
testb %al, %al
jne 0x480fb
testq %rbx, %rbx
je 0x480f6
testq %r14, %r14
je 0x480f6
movq (%r14), %rdi
testq %rdi, %rdi
je 0x480f6
cmpq $0x0, 0x8(%r14)
je 0x480f6
leaq 0x8(%r14), %r15
movq %rbx, %rsi
callq 0x775ed
movq %rax, %r12
testq %rax, %rax
jne 0x480d8
movl $0x8, %edi
callq 0x6ef7c
movq %rax, %r12
movq (%r14), %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x77628
movl $0x8, %edx
movq %r12, %rdi
movq %r15, %rsi
callq 0x6f240
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x13401
callq 0x133ca
// File: /workspace/github_c_makefile_star2_O3/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 0x481d2
movq %rsi, %rbx
testq %rsi, %rsi
je 0x481d2
movq %rdx, %r14
testq %rdx, %rdx
je 0x481d2
movq %rdi, %r15
cmpb $0x49, (%rdi)
jne 0x4813c
cmpb $0x44, 0x1(%r15)
jne 0x4813c
cmpb $0x0, 0x2(%r15)
je 0x4816c
leaq 0x9f5e3(%rip), %rsi     # 0xe7726
movq %r15, %rdi
callq 0xb890
testl %eax, %eax
je 0x4816c
movq (%r14), %rax
cmpb $0x1, (%rax)
jne 0x48172
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x48177
movl $0x3b, %esi
callq 0x3b9df
jmp 0x48185
popq %rbx
popq %r14
popq %r15
retq
movb $0x1, (%rax)
jmp 0x48185
movq 0x8(%r14), %rsi
movl $0x3b, %edi
callq 0x75f43
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x481b5
movq %r15, %rsi
callq 0x3b7af
movq 0x10(%r14), %rdi
movl $0x3d, %esi
callq 0x3b9df
movq 0x10(%r14), %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x3b7af
movq 0x8(%r14), %rdi
leaq 0xa0794(%rip), %rsi     # 0xe8954
movq %r15, %rdx
movq %rbx, %rcx
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x75ce5
callq 0x13438
nop
// File: /workspace/github_c_makefile_star2_O3/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 0x4841e
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x3c87b
movq 0x8(%rbx), %rdi
leaq 0xa065d(%rip), %rsi     # 0xe8a4e
movl $0xe2, %edx
callq 0x35c27
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x48409
callq 0x5a089
leaq 0xa063e(%rip), %rsi     # 0xe8a4e
movq %rbx, %rdi
movl $0xe4, %edx
popq %rbx
jmp 0x35c27
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq $0x0, 0x8(%rsp)
testq %rdx, %rdx
je 0x4845d
movq %rdx, %r14
movq %rdx, %rdi
callq 0x34fea
testb %al, %al
jne 0x48481
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
xorl %edx, %edx
movq %rbx, %rcx
movq %r14, %r8
jmp 0x4846d
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
xorl %edx, %edx
movq %rbx, %rcx
xorl %r8d, %r8d
callq 0x48486
movq 0x8(%rsp), %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x1354d
// File: /workspace/github_c_makefile_star2_O3/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 0x72367
cmpq $0x0, 0x10a276(%rip)    # 0x152b58
jne 0x4891d
leaq 0xbc(%rip), %rax        # 0x489a7
leaq 0x39(%rip), %rsi        # 0x4892b
leaq 0x85(%rip), %rcx        # 0x4897e
leaq 0xa2(%rip), %r8         # 0x489a2
movl $0x48, %edi
xorl %edx, %edx
xorl %r9d, %r9d
pushq %rax
pushq $0x0
callq 0x41334
addq $0x10, %rsp
movq %rax, 0x10a23b(%rip)    # 0x152b58
callq 0x7237d
movq 0x10a22f(%rip), %rax    # 0x152b58
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x488d4
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4153f
movq %rax, %rbx
movq 0x30(%rax), %rdi
leaq 0xa03aa(%rip), %r14     # 0xe8cfa
movq %r14, %rsi
movl $0x25, %edx
callq 0x35c27
movq 0x38(%rbx), %rdi
movq %r14, %rsi
movl $0x26, %edx
callq 0x35c27
movq 0x40(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3c87b
// File: /workspace/github_c_makefile_star2_O3/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 0x4899d
movq %rdi, %rbx
callq 0x488d4
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4153f
movq 0x40(%rax), %rax
popq %rbx
retq
callq 0x1382c
// File: /workspace/github_c_makefile_star2_O3/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 0x489c6
movq %rbx, %rdi
callq 0x34fea
testb %al, %al
jne 0x489e9
callq 0x488d4
movq %rax, %rdi
movq %r15, %rsi
callq 0x4153f
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x49096
callq 0x13863