LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/gff3_parser.c
// Function: gt_gff3_parser_build_target_str
void gt_gff3_parser_build_target_str(GtStr *target, GtStrArray *target_ids,
                                     GtArray *target_ranges,
                                     GtArray *target_strands)
{
  GtUword i;
  gt_assert(target && target_ids && target_ranges && target_strands);
  for (i = 0; i < gt_str_array_size(target_ids); i++) {
    GtRange *range;
    GtStrand *strand;
    range = gt_array_get(target_ranges, i);
    strand = gt_array_get(target_strands, i);
    if (i)
      gt_str_append_char(target, ',');
    gt_str_append_cstr(target, gt_str_array_get(target_ids, i));
    gt_str_append_char(target, ' ');
    gt_str_append_uword(target, range->start);
    gt_str_append_char(target, ' ');
    gt_str_append_uword(target, range->end);
    if (*strand != GT_NUM_OF_STRAND_TYPES) {
      gt_str_append_char(target, ' ');
      gt_str_append_char(target, GT_STRAND_CHARS[*strand]);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %xmm0
movq %rdi, %xmm1
punpcklqdq %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0]
movq %rcx, 0x10(%rsp)
movq %rcx, %xmm0
movq %rdx, 0x8(%rsp)
movq %rdx, %xmm2
punpcklqdq %xmm0, %xmm2    # xmm2 = xmm2[0],xmm0[0]
pxor %xmm0, %xmm0
pcmpeqd %xmm0, %xmm2
pcmpeqd %xmm0, %xmm1
movdqa %xmm1, %xmm0
shufps $0xdd, %xmm2, %xmm0     # xmm0 = xmm0[1,3],xmm2[1,3]
shufps $0x88, %xmm2, %xmm1     # xmm1 = xmm1[0,2],xmm2[0,2]
andps %xmm0, %xmm1
movmskps %xmm1, %eax
testl %eax, %eax
jne 0x1f075
movq %rsi, %r15
movq %rdi, %r12
xorl %r13d, %r13d
pushq $0x20
popq %rbp
movq %r15, %rdi
callq 0x157f4
cmpq %rax, %r13
jae 0x1f066
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x4b48e
movq %rax, %r14
movq 0x10(%rsp), %rdi
movq %r13, %rsi
callq 0x4b48e
movq %rax, %rbx
testq %r13, %r13
je 0x1eff9
movq %r12, %rdi
pushq $0x2c
popq %rsi
callq 0x140b1
movq %r15, %rdi
movq %r13, %rsi
callq 0x1555e
movq %r12, %rdi
movq %rax, %rsi
callq 0x13dd3
movq %r12, %rdi
movl %ebp, %esi
callq 0x140b1
movq (%r14), %rsi
movq %r12, %rdi
callq 0x13ffe
movq %r12, %rdi
movl %ebp, %esi
callq 0x140b1
movq 0x8(%r14), %rsi
movq %r12, %rdi
callq 0x13ffe
cmpl $0x4, (%rbx)
je 0x1f05e
movq %r12, %rdi
movl %ebp, %esi
callq 0x140b1
movl (%rbx), %eax
leaq 0xacaf2(%rip), %rcx     # 0xcbb44
movsbl (%rax,%rcx), %esi
movq %r12, %rdi
callq 0x140b1
incq %r13
jmp 0x1efb8
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x10ef3c(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xaafe0(%rip), %rsi     # 0xca066
leaq 0xb05ee(%rip), %rdx     # 0xcf67b
leaq 0xb061f(%rip), %rcx     # 0xcf6b3
leaq 0xb03f5(%rip), %r8      # 0xcf490
movl $0x481, %r9d            # imm = 0x481
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/gff3_parser.c
// Function: chomp_seqid
void chomp_seqid(char *seqid, const char *filename, unsigned int line_number)
{
  GtUword len;
  if (!seqid) return;
  len = strlen(seqid);
  if (len > 0) {
    if (seqid[len-1] == ' ') {
      gt_warning("seqid \"%s\" on line %u in file \"%s\" ends with a blank, "
                 "removing it", seqid, line_number, filename);
      (void) gt_cstr_rtrim(seqid, ' ');
    }
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1f0f4
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
callq 0xb260
testq %rax, %rax
je 0x1f0f4
cmpb $0x20, -0x1(%rbx,%rax)
jne 0x1f0f4
leaq 0xb05fd(%rip), %rdi     # 0xcf6d3
movq %rbx, %rsi
movl %ebp, %edx
movq %r14, %rcx
xorl %eax, %eax
callq 0x161b0
pushq $0x20
popq %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x4fab8
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/gff3_parser.c
// Function: gt_gff3_parser_reset
void gt_gff3_parser_reset(GtGFF3Parser *parser)
{
  gt_assert(parser);
  parser->fasta_parsing = false;
  parser->eof_emitted = false;
  gt_feature_info_reset(parser->feature_info);
  gt_hashmap_reset(parser->seqid_to_ssr_mapping);
  gt_hashmap_reset(parser->source_to_str_mapping);
  gt_orphanage_reset(parser->orphanage);
  parser->last_terminator = 0;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x2265c
movq %rdi, %rbx
andw $0x0, 0x1d(%rdi)
movq (%rdi), %rdi
callq 0x64636
movq 0x8(%rbx), %rdi
callq 0x56030
movq 0x10(%rbx), %rdi
callq 0x56030
movq 0x38(%rbx), %rdi
callq 0x265b0
andl $0x0, 0x50(%rbx)
popq %rbx
retq
movq 0x10b955(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa79f9(%rip), %rsi     # 0xca066
leaq 0xae2e0(%rip), %rdx     # 0xd0954
leaq 0xad131(%rip), %rcx     # 0xcf7ac
leaq 0xace0e(%rip), %r8      # 0xcf490
movl $0x8b6, %r9d            # imm = 0x8B6
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/gff3_parser.c
// Function: gt_gff3_parser_delete
void gt_gff3_parser_delete(GtGFF3Parser *parser)
{
  if (!parser) return;
  gt_feature_info_delete(parser->feature_info);
  gt_hashmap_delete(parser->seqid_to_ssr_mapping);
  gt_hashmap_delete(parser->source_to_str_mapping);
  gt_mapping_delete(parser->offset_mapping);
  gt_orphanage_delete(parser->orphanage);
  gt_type_checker_delete(parser->type_checker);
  gt_xrf_checker_delete(parser->xrf_checker);
  gt_free(parser);
}

// Assembly:
testq %rdi, %rdi
je 0x226f0
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x64608
movq 0x8(%rbx), %rdi
callq 0x563a7
movq 0x10(%rbx), %rdi
callq 0x563a7
movq 0x30(%rbx), %rdi
callq 0x24ec0
movq 0x38(%rbx), %rdi
callq 0x2655d
movq 0x40(%rbx), %rdi
callq 0x294fe
movq 0x48(%rbx), %rdi
callq 0x29b87
leaq 0xacdae(%rip), %rsi     # 0xcf490
movq %rbx, %rdi
movl $0x8ca, %edx            # imm = 0x8CA
popq %rbx
jmp 0xd249
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2288e
movq %r14, %rdi
callq 0xc103
testb %al, %al
jne 0x22912
movq 0x28(%r13), %rsi
movq %rsi, %rax
negq %rax
jno 0x228d4
movq 0x30(%r13), %rdi
testq %rdi, %rdi
je 0x22901
movq %rsp, %rsi
movq %rbp, %rdx
movq %r14, %rcx
callq 0x2553d
testl %eax, %eax
jne 0x22903
movq (%rsp), %rsi
movq %rbx, %rdi
movq %r12, %rdx
movl %r15d, %ecx
movq %r14, %r8
callq 0x2299b
testl %eax, %eax
jne 0x228e9
movq (%rsp), %rsi
jmp 0x228f2
movq %rbx, %rdi
movq %r12, %rdx
movl %r15d, %ecx
movq %r14, %r8
callq 0x2299b
testl %eax, %eax
je 0x228ee
pushq $-0x1
popq %rax
jmp 0x22903
movq 0x28(%r13), %rsi
movq %rbx, %rdi
callq 0x5d2c9
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
movq 0x10b69f(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa7743(%rip), %rsi     # 0xca066
leaq 0xa7d2f(%rip), %rdx     # 0xca659
leaq 0xad55f(%rip), %rcx     # 0xcfe90
leaq 0xacb58(%rip), %r8      # 0xcf490
movl $0xd5, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0xacb2b(%rip), %rdx     # 0xcf490
pushq $0x1
popq %rdi
pushq $0x20
popq %rsi
pushq $0x55
popq %rcx
callq 0xce9a
movq %rax, %r13
movq %r12, %rdi
callq 0x13da9
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_O2/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 0x229c2
movq %r14, %rdi
callq 0xc103
testb %al, %al
jne 0x22a19
xorl %eax, %eax
testq %r15, %r15
jns 0x22a10
movq (%r12), %rcx
movq %rcx, %rdx
addq %r15, %rdx
je 0x229e3
cmpq %rcx, %rdx
jbe 0x22a10
leaq 0xad533(%rip), %rsi     # 0xcff14
jmp 0x229fb
leaq 0xb7e10(%rip), %rsi     # 0xda7fa
movq %r14, %rdi
xorl %eax, %eax
callq 0xc007
leaq 0xad4bd(%rip), %rsi     # 0xcfeb8
movq %r14, %rdi
movq %r15, %rdx
movl %ebp, %ecx
movq %rbx, %r8
xorl %eax, %eax
callq 0xc007
pushq $-0x1
popq %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x10b598(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa763c(%rip), %rsi     # 0xca066
leaq 0xa7c28(%rip), %rdx     # 0xca659
leaq 0xad470(%rip), %rcx     # 0xcfea8
leaq 0xaca51(%rip), %r8      # 0xcf490
movl $0xbb, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x22ab8
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
callq 0x19959
testb %al, %al
je 0x22ab8
movq %r15, %rdi
callq 0x19959
testb %al, %al
jne 0x22ae9
testq %r14, %r14
je 0x22b17
movq %rbx, %rdi
movq %r15, %rsi
callq 0x19245
leaq 0xadc7f(%rip), %rsi     # 0xd0713
movq %r15, %rdi
callq 0x18818
testq %rax, %rax
je 0x22b45
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x647cc
movq 0x10b4f9(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa759d(%rip), %rsi     # 0xca066
leaq 0xadfbc(%rip), %rdx     # 0xd0a8c
leaq 0xadffc(%rip), %rcx     # 0xd0ad3
leaq 0xac9b2(%rip), %r8      # 0xcf490
movl $0x1fc, %r9d            # imm = 0x1FC
jmp 0x22b71
movq 0x10b4c8(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa756c(%rip), %rsi     # 0xca066
leaq 0xadff6(%rip), %rdx     # 0xd0af7
leaq 0xadfcb(%rip), %rcx     # 0xd0ad3
leaq 0xac981(%rip), %r8      # 0xcf490
movl $0x1fd, %r9d            # imm = 0x1FD
jmp 0x22b71
movq 0x10b49a(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa753e(%rip), %rsi     # 0xca066
leaq 0xae603(%rip), %rdx     # 0xd1132
leaq 0xadf9d(%rip), %rcx     # 0xd0ad3
leaq 0xac953(%rip), %r8      # 0xcf490
movl $0x1fe, %r9d            # imm = 0x1FE
jmp 0x22b71
movq 0x10b46c(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa7510(%rip), %rsi     # 0xca066
leaq 0xbab26(%rip), %rdx     # 0xdd683
leaq 0xadf6f(%rip), %rcx     # 0xd0ad3
leaq 0xac925(%rip), %r8      # 0xcf490
movl $0x201, %r9d            # imm = 0x201
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x22bb0
leaq 0x8(%rsp), %rax
movq %rdi, (%rax)
movq %rsi, 0x8(%rax)
leaq 0x18e(%rip), %rsi       # 0x22d27
movq %rdx, %rdi
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x5b5f9
cmpl $0x1, %eax
jne 0x22bde
addq $0x18, %rsp
retq
movq 0x10b401(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa74a5(%rip), %rsi     # 0xca066
leaq 0xadf6b(%rip), %rdx     # 0xd0b33
leaq 0xadf96(%rip), %rcx     # 0xd0b65
leaq 0xac8ba(%rip), %r8      # 0xcf490
movl $0x1d9, %r9d            # imm = 0x1D9
jmp 0x22c0a
movq 0x10b3d3(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa7477(%rip), %rsi     # 0xca066
leaq 0xadf7c(%rip), %rdx     # 0xd0b72
leaq 0xadf68(%rip), %rcx     # 0xd0b65
leaq 0xac88c(%rip), %r8      # 0xcf490
movl $0x1e0, %r9d            # imm = 0x1E0
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x22c93
movq %rsi, %r14
movq %rdi, %rbx
callq 0x19959
testb %al, %al
je 0x22cc1
movq %r14, %rdi
callq 0x19959
testb %al, %al
jne 0x22cef
movq %rbx, %rdi
callq 0x1c3c4
leaq 0x20(%rsp), %r15
movq %rax, (%r15)
movq %rdx, 0x8(%r15)
movq %r14, %rdi
callq 0x1c3c4
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
movq %r15, %rdi
callq 0x5d269
movq %rsp, %rsi
movq %rax, (%rsi)
movq %rdx, 0x8(%rsi)
movq %rbx, %rdi
callq 0x1c48b
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x10b31e(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa73c2(%rip), %rsi     # 0xca066
leaq 0xadef3(%rip), %rdx     # 0xd0b9e
leaq 0xadf08(%rip), %rcx     # 0xd0bba
leaq 0xac7d7(%rip), %r8      # 0xcf490
movl $0x1ed, %r9d            # imm = 0x1ED
jmp 0x22d1b
movq 0x10b2f0(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa7394(%rip), %rsi     # 0xca066
leaq 0xadefa(%rip), %rdx     # 0xd0bd3
leaq 0xadeda(%rip), %rcx     # 0xd0bba
leaq 0xac7a9(%rip), %r8      # 0xcf490
movl $0x1ee, %r9d            # imm = 0x1EE
jmp 0x22d1b
movq 0x10b2c2(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa7366(%rip), %rsi     # 0xca066
leaq 0xadef3(%rip), %rdx     # 0xd0bfa
leaq 0xadeac(%rip), %rcx     # 0xd0bba
leaq 0xac77b(%rip), %r8      # 0xcf490
movl $0x1ef, %r9d            # imm = 0x1EF
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x22d42
movq %rdx, %rdi
callq 0xc103
testb %al, %al
jne 0x22d96
testq %rbx, %rbx
je 0x22d68
testq %r14, %r14
je 0x22d68
movq (%rbx), %rcx
xorl %eax, %eax
cmpq (%r14), %rcx
jne 0x22d60
movq 0x8(%r14), %rax
movq %rax, (%rbx)
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x10b249(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa72ed(%rip), %rsi     # 0xca066
leaq 0xade09(%rip), %rdx     # 0xd0b89
leaq 0xaddf5(%rip), %rcx     # 0xd0b7c
leaq 0xac702(%rip), %r8      # 0xcf490
movl $0x1cc, %r9d            # imm = 0x1CC
jmp 0x22dc2
movq 0x10b21b(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa72bf(%rip), %rsi     # 0xca066
leaq 0xa78ab(%rip), %rdx     # 0xca659
leaq 0xaddc7(%rip), %rcx     # 0xd0b7c
leaq 0xac6d4(%rip), %r8      # 0xcf490
movl $0x1cb, %r9d            # imm = 0x1CB
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x19959
testb %al, %al
je 0x2386c
movq %r15, %rdi
callq 0x19959
testb %al, %al
jne 0x2389a
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x22a51
movq %r14, %rdi
movq %r15, %rsi
callq 0x5b2c5
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x10a745(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa67e9(%rip), %rsi     # 0xca066
leaq 0xad208(%rip), %rdx     # 0xd0a8c
leaq 0xadd84(%rip), %rcx     # 0xd160f
leaq 0xabbfe(%rip), %r8      # 0xcf490
movl $0x28c, %r9d            # imm = 0x28C
jmp 0x238c6
movq 0x10a717(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa67bb(%rip), %rsi     # 0xca066
leaq 0xadd75(%rip), %rdx     # 0xd1627
leaq 0xadd56(%rip), %rcx     # 0xd160f
leaq 0xabbd0(%rip), %r8      # 0xcf490
movl $0x28e, %r9d            # imm = 0x28E
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x10c265(%rip), %rax    # 0x12fb40
testq %rax, %rax
je 0x238e1
retq
pushq %rax
leaq 0x62f(%rip), %rax       # 0x23f18
movq %rax, (%rsp)
leaq 0x46(%rip), %rsi        # 0x2393a
leaq 0xc8(%rip), %rdx        # 0x239c3
leaq 0x1c4(%rip), %rcx       # 0x23ac6
leaq 0x30a(%rip), %r8        # 0x23c13
leaq 0x4ac(%rip), %r9        # 0x23dbc
pushq $0x50
popq %rdi
callq 0x25f10
movq %rax, 0x10c221(%rip)    # 0x12fb40
leaq 0x68f(%rip), %rsi       # 0x23fb5
movq %rax, %rdi
callq 0x25f9f
movq 0x10c20b(%rip), %rax    # 0x12fb40
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x238d4
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2603e
testq %rax, %rax
je 0x2398d
movq %rax, %rbx
movq 0x18(%rax), %rdi
callq 0x6209b
movq 0x20(%rbx), %rdi
callq 0x563a7
movq 0x28(%rbx), %rdi
callq 0x563a7
movq 0x48(%rbx), %rdi
callq 0x5055b
movq 0x40(%rbx), %rdi
callq 0x152db
movq 0x38(%rbx), %rdi
popq %rbx
jmp 0x548ae
movq 0x10a624(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa66c8(%rip), %rsi     # 0xca066
leaq 0xadee9(%rip), %rdx     # 0xd188e
leaq 0xade68(%rip), %rcx     # 0xd1814
leaq 0xade01(%rip), %r8      # 0xd17b4
pushq $0x57
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x239e3
movq %rdx, %rdi
callq 0xc103
testb %al, %al
jne 0x23a90
callq 0x238d4
movq %rax, %rdi
movq %r15, %rsi
callq 0x2603e
testq %r15, %r15
je 0x23a66
testq %rbx, %rbx
je 0x23a66
movq %rax, %r14
movq %r15, %rdi
callq 0x24334
movq 0x40(%r14), %rdi
testq %rdi, %rdi
je 0x23a3e
pushq $0x23
popq %rsi
callq 0x140b1
movq 0x40(%r14), %r15
movq %rbx, %rdi
callq 0x643d4
movq %r15, %rdi
movq %rax, %rsi
callq 0x13dd3
movq 0x40(%r14), %rdi
pushq $0xa
popq %rsi
callq 0x140b1
jmp 0x23a5e
movq 0x38(%r14), %r14
movq %rbx, %rdi
callq 0x643d4
leaq 0xadfcc(%rip), %rsi     # 0xd1a1d
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x542da
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0x10a54b(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa65ef(%rip), %rsi     # 0xca066
leaq 0xaddc2(%rip), %rdx     # 0xd1840
leaq 0xadda1(%rip), %rcx     # 0xd1826
leaq 0xadd28(%rip), %r8      # 0xd17b4
pushq $0x66
jmp 0x23ab8
movq 0x10a521(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa65c5(%rip), %rsi     # 0xca066
leaq 0xa6bb1(%rip), %rdx     # 0xca659
leaq 0xadd77(%rip), %rcx     # 0xd1826
leaq 0xadcfe(%rip), %r8      # 0xd17b4
pushq $0x64
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x23de0
movq %rdx, %rdi
callq 0xc103
testb %al, %al
jne 0x23ee0
callq 0x238d4
movq %rax, %rdi
movq %r15, %rsi
callq 0x2603e
testq %r15, %r15
je 0x23eb2
testq %rbx, %rbx
je 0x23eb2
movq %rax, %r14
movq %r15, %rdi
callq 0x24334
cmpb $0x0, 0x12(%r14)
jne 0x23e55
movq 0x40(%r14), %rdi
testq %rdi, %rdi
je 0x23e37
leaq 0xabd68(%rip), %rsi     # 0xcfb8c
callq 0x13dd3
movq 0x40(%r14), %rdi
pushq $0xa
popq %rsi
callq 0x140b1
jmp 0x23e50
movq 0x38(%r14), %rdi
leaq 0xa8eee(%rip), %rsi     # 0xccd30
leaq 0xabd43(%rip), %rdx     # 0xcfb8c
xorl %eax, %eax
callq 0x542da
movb $0x1, 0x12(%r14)
movq 0x40(%r14), %r13
movq %rbx, %rdi
callq 0x26e43
movq %rax, %r15
movq %rbx, %rdi
callq 0x26e88
movq %rax, %r12
movq %rbx, %rdi
callq 0x26ecd
movq 0x30(%r14), %rcx
testq %r13, %r13
je 0x23e94
movq 0x40(%r14), %r8
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x53805
jmp 0x23ea6
movq 0x38(%r14), %r8
movq %r15, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x537a0
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x10a0ff(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa61a3(%rip), %rsi     # 0xca066
leaq 0xadb01(%rip), %rdx     # 0xd19cb
leaq 0xadadf(%rip), %rcx     # 0xd19b0
leaq 0xad8dc(%rip), %r8      # 0xd17b4
movl $0x1d6, %r9d            # imm = 0x1D6
jmp 0x23f0c
movq 0x10a0d1(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa6175(%rip), %rsi     # 0xca066
leaq 0xa6761(%rip), %rdx     # 0xca659
leaq 0xadab1(%rip), %rcx     # 0xd19b0
leaq 0xad8ae(%rip), %r8      # 0xd17b4
movl $0x1d4, %r9d            # imm = 0x1D4
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x23f33
movq %rdx, %rdi
callq 0xc103
testb %al, %al
jne 0x23f7d
testq %rbx, %rbx
je 0x23f4f
testq %r14, %r14
je 0x23f4f
movq %rbx, %rdi
callq 0x24334
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x10a062(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa6106(%rip), %rsi     # 0xca066
leaq 0xada83(%rip), %rdx     # 0xd19ea
leaq 0xada66(%rip), %rcx     # 0xd19d4
leaq 0xad83f(%rip), %r8      # 0xd17b4
movl $0x1f3, %r9d            # imm = 0x1F3
jmp 0x23fa9
movq 0x10a034(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa60d8(%rip), %rsi     # 0xca066
leaq 0xa66c4(%rip), %rdx     # 0xca659
leaq 0xada38(%rip), %rcx     # 0xd19d4
leaq 0xad811(%rip), %r8      # 0xd17b4
movl $0x1f2, %r9d            # imm = 0x1F2
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x238d4
movq %rax, %rdi
callq 0x25fe0
movq %rax, %r14
callq 0x238d4
movq %rax, %rdi
movq %r14, %rsi
callq 0x2603e
movq %rax, %r15
movq %rax, %rdi
callq 0x241ae
movq %rbx, %rdi
callq 0x53f1b
movq %rax, 0x38(%r15)
andq $0x0, 0x40(%r15)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x61c68
movq %rax, 0x18(%rbx)
leaq 0x27fcd(%rip), %rdx     # 0x4c19d
xorl %edi, %edi
xorl %esi, %esi
callq 0x55da4
movq %rax, 0x20(%rbx)
leaq -0xef09(%rip), %rdx     # 0x152db
xorl %edi, %edi
xorl %esi, %esi
callq 0x55da4
movq %rax, 0x28(%rbx)
andq $0x0, 0x30(%rbx)
callq 0x5005c
movq %rax, 0x48(%rbx)
leaq 0xad81c(%rip), %rdi     # 0xd1a22
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_O2/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 0x238d4
movq %rax, %rdi
callq 0x25fe0
movq %rax, %r14
callq 0x238d4
movq %rax, %rdi
movq %r14, %rsi
callq 0x2603e
movq %rax, %r15
movq %rax, %rdi
callq 0x241ae
andq $0x0, 0x38(%r15)
movq %rbx, %rdi
callq 0x146aa
movq %rax, 0x40(%r15)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x238d4
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2603e
testq %rax, %rax
je 0x243b7
movq %rax, %rbx
cmpb $0x0, 0x10(%rax)
jne 0x243b5
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x24395
leaq 0xab629(%rip), %rsi     # 0xcf98f
callq 0x13dd3
movq 0x40(%rbx), %rdi
leaq 0xc366f(%rip), %rsi     # 0xe79e5
callq 0x13dd3
movq 0x40(%rbx), %rdi
pushq $0x3
popq %rsi
callq 0x14329
movq 0x40(%rbx), %rdi
pushq $0xa
popq %rsi
callq 0x140b1
jmp 0x243b1
movq 0x38(%rbx), %rdi
leaq 0xad4bd(%rip), %rsi     # 0xd185d
leaq 0xab5e8(%rip), %rdx     # 0xcf98f
pushq $0x3
popq %rcx
xorl %eax, %eax
callq 0x542da
movb $0x1, 0x10(%rbx)
popq %rbx
retq
movq 0x109bfa(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa5c9e(%rip), %rsi     # 0xca066
leaq 0xad4bf(%rip), %rdx     # 0xd188e
leaq 0xad473(%rip), %rcx     # 0xd1849
leaq 0xad3d7(%rip), %r8      # 0xd17b4
pushq $0x45
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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, %r13
movq %rdi, %r14
leaq 0xabe88(%rip), %rsi     # 0xd0713
movq %r13, %rdi
callq 0x18818
movq %rax, %rdi
callq 0x13da9
movq %rax, %r15
cmpb $0x0, 0x13(%r14)
jne 0x24982
movq 0x48(%r14), %r12
movq %r15, %rdi
callq 0x143d2
movq %r12, %rdi
movq %rax, %rsi
callq 0x5018a
testq %rax, %rax
je 0x2496b
movq %r13, (%rsp)
pushq $0x1
popq %r13
callq 0x13d5c
movq %rax, %r12
movq 0x48(%r14), %rbx
leaq 0x1(%r13), %rbp
movq %r12, %rdi
callq 0x1452f
movq %r12, %rdi
movq %r15, %rsi
callq 0x13eeb
movq %r12, %rdi
pushq $0x2e
popq %rsi
callq 0x140b1
movq %r12, %rdi
movq %r13, %rsi
callq 0x13ffe
movq %r12, %rdi
callq 0x143d2
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5018a
movq %rbp, %r13
testq %rax, %rax
jne 0x248d9
movq %r15, %rdi
callq 0x143d2
movq %rax, %rbx
movq %r12, %rdi
callq 0x143d2
leaq 0xacf5c(%rip), %rdi     # 0xd189b
movq %rbx, %rsi
movq %rax, %rdx
xorl %eax, %eax
callq 0x161b0
movq %r12, %rdi
callq 0x143d2
movq %r15, %rdi
movq %rax, %rsi
callq 0x13e63
movq %r12, %rdi
callq 0x152db
movq (%rsp), %r13
movq 0x48(%r14), %rbx
movq %r15, %rdi
callq 0x143d2
movq %rbx, %rdi
movq %rax, %rsi
callq 0x500bc
movq 0x28(%r14), %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x55f31
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_O2/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 0x24a0d
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x19528
movq %rax, %r15
movq 0x18(%r14), %rdi
movq %rax, %rsi
callq 0x61cbb
movq %r15, %rdi
callq 0x13da9
movq %rax, %r12
movq 0x18(%r14), %rdi
movq %r15, %rsi
callq 0x61e0a
movq %r12, %rdi
movq %rax, %rsi
callq 0x13ffe
movq 0x28(%r14), %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x55f31
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x1095a4(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa5648(%rip), %rsi     # 0xca066
leaq 0xacea1(%rip), %rdx     # 0xd18c6
leaq 0xacead(%rip), %rcx     # 0xd18d9
leaq 0xacd81(%rip), %r8      # 0xd17b4
movl $0xf5, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x24a68
movq %rdx, %rdi
callq 0xc103
testb %al, %al
jne 0x24b00
testq %rbx, %rbx
je 0x24aca
testq %r14, %r14
je 0x24aca
movq (%r14), %rdi
testq %rdi, %rdi
je 0x24aca
cmpq $0x0, 0x8(%r14)
je 0x24aca
leaq 0x8(%r14), %r15
movq %rbx, %rsi
callq 0x55ef6
movq %rax, %r12
testq %rax, %rax
jne 0x24aae
pushq $0x8
popq %rdi
callq 0x4b380
movq %rax, %r12
movq (%r14), %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x55f31
pushq $0x8
popq %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0x4b801
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x1094e7(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa558b(%rip), %rsi     # 0xca066
leaq 0xace0f(%rip), %rdx     # 0xd18f1
leaq 0xace01(%rip), %rcx     # 0xd18ea
leaq 0xaccc4(%rip), %r8      # 0xd17b4
pushq $0x78
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
movq 0x1094b1(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa5555(%rip), %rsi     # 0xca066
leaq 0xa5b41(%rip), %rdx     # 0xca659
leaq 0xacdcb(%rip), %rcx     # 0xd18ea
leaq 0xacc8e(%rip), %r8      # 0xd17b4
pushq $0x77
jmp 0x24af2
// File: /workspace/github_c_makefile_star2_O2/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 0x24bf6
movq %rsi, %rbx
testq %rsi, %rsi
je 0x24bf6
movq %rdx, %r14
testq %rdx, %rdx
je 0x24bf6
movq %rdi, %r15
cmpb $0x49, (%rdi)
jne 0x24b66
cmpb $0x44, 0x1(%r15)
jne 0x24b66
cmpb $0x0, 0x2(%r15)
je 0x24b94
leaq 0xabba9(%rip), %rsi     # 0xd0716
movq %r15, %rdi
callq 0xb880
testl %eax, %eax
je 0x24b94
movq (%r14), %rax
cmpb $0x1, (%rax)
jne 0x24b9a
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x24b9f
pushq $0x3b
popq %rsi
callq 0x140b1
jmp 0x24bab
popq %rbx
popq %r14
popq %r15
retq
movb $0x1, (%rax)
jmp 0x24bab
movq 0x8(%r14), %rsi
pushq $0x3b
popq %rdi
callq 0x54619
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x24bd9
movq %r15, %rsi
callq 0x13dd3
movq 0x10(%r14), %rdi
pushq $0x3d
popq %rsi
callq 0x140b1
movq 0x10(%r14), %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x13dd3
movq 0x8(%r14), %rdi
leaq 0xacd60(%rip), %rsi     # 0xd1944
movq %r15, %rdx
movq %rbx, %rcx
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x542da
movq 0x1093bb(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa545f(%rip), %rsi     # 0xca066
leaq 0xacd40(%rip), %rdx     # 0xd194e
leaq 0xacd59(%rip), %rcx     # 0xd196e
leaq 0xacb98(%rip), %r8      # 0xd17b4
movl $0x86, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x24f09
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x152db
movq 0x8(%rbx), %rdi
leaq 0xacb62(%rip), %rsi     # 0xd1a3e
movl $0xe2, %edx
callq 0xd249
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x24ef4
callq 0x3a8f3
leaq 0xacb43(%rip), %rsi     # 0xd1a3e
movq %rbx, %rdi
movl $0xe4, %edx
popq %rbx
jmp 0xd249
retq
// File: /workspace/github_c_makefile_star2_O2/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
andq $0x0, (%rsp)
testq %rdx, %rdx
je 0x24f31
movq %rbx, %rdi
callq 0xc103
testb %al, %al
jne 0x24f57
movq %rsp, %r12
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
movq %r14, %rcx
movq %rbx, %r8
callq 0x24f8f
movq (%r12), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x10905a(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa50fe(%rip), %rsi     # 0xca066
leaq 0xa56ea(%rip), %rdx     # 0xca659
leaq 0xacba5(%rip), %rcx     # 0xd1b1b
leaq 0xacac1(%rip), %r8      # 0xd1a3e
movl $0xd2, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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:
subq $0x18, %rsp
callq 0x4f21f
cmpq $0x0, 0x10a57f(%rip)    # 0x12fb48
jne 0x25605
andq $0x0, (%rsp)
leaq 0xcc(%rip), %rax        # 0x256a3
movq %rax, 0x8(%rsp)
leaq 0x33(%rip), %rsi        # 0x25616
leaq 0x6d(%rip), %rcx        # 0x25657
leaq 0xad(%rip), %r8         # 0x2569e
pushq $0x48
popq %rdi
xorl %edx, %edx
xorl %r9d, %r9d
callq 0x1bf21
movq %rax, 0x10a543(%rip)    # 0x12fb48
callq 0x4f266
movq 0x10a537(%rip), %rax    # 0x12fb48
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/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
callq 0x257b7
movq %rax, %rbx
movq 0x30(%rax), %rdi
leaq 0xac6bd(%rip), %r14     # 0xd1cea
pushq $0x25
popq %rdx
movq %r14, %rsi
callq 0xd249
movq 0x38(%rbx), %rdi
pushq $0x26
popq %rdx
movq %r14, %rsi
callq 0xd249
movq 0x40(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x152db
// File: /workspace/github_c_makefile_star2_O2/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 %rax
testq %rdi, %rdi
je 0x25668
callq 0x257b7
movq 0x40(%rax), %rax
popq %rcx
retq
movq 0x108949(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa49ed(%rip), %rsi     # 0xca066
leaq 0xb9155(%rip), %rdx     # 0xde7d5
leaq 0xac6c4(%rip), %rcx     # 0xd1d4b
leaq 0xac65c(%rip), %r8      # 0xd1cea
pushq $0x2d
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x256c2
movq %rbx, %rdi
callq 0xc103
testb %al, %al
jne 0x256dd
movq %r15, %rdi
callq 0x257b7
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x261ec
movq 0x1088d4(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa4978(%rip), %rsi     # 0xca066
leaq 0xa4f64(%rip), %rdx     # 0xca659
leaq 0xac663(%rip), %rcx     # 0xd1d5f
leaq 0xac5e7(%rip), %r8      # 0xd1cea
pushq $0x3d
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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, %r15
movq %rdi, %r12
callq 0x255b8
movq %rax, %rdi
callq 0x1c0f3
movq %rax, %rbx
movq %rax, %rdi
callq 0x257b7
testq %r12, %r12
je 0x25781
movq %rax, %r14
movq %r12, %rdi
callq 0x4f8ae
movq %rax, 0x30(%r14)
testq %r15, %r15
je 0x2575c
movq %r15, %rdi
callq 0x4f8ae
jmp 0x2575e
xorl %eax, %eax
movq %rax, 0x38(%r14)
leaq 0xb2376(%rip), %rdi     # 0xd7adf
callq 0x13da9
movq %rax, 0x40(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x108830(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xa48d4(%rip), %rsi     # 0xca066
leaq 0xac572(%rip), %rdx     # 0xd1d0b
leaq 0xac539(%rip), %rcx     # 0xd1cd9
leaq 0xac543(%rip), %r8      # 0xd1cea
pushq $0x59
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300