LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/feature_node.c
// Function: determine_transcripttypes
static int determine_transcripttypes(GtFeatureNode *fn, void *data,
                                     GT_UNUSED GtError *err)
{
  SaveExonAndCDSInfo *info = (SaveExonAndCDSInfo*) data;
  GT_UNUSED int had_err;
  gt_error_check(err);
  gt_assert(fn && info);
  /* reset exon_features and cds_features */
  gt_array_reset(info->exon_features);
  gt_array_reset(info->cds_features);
  /* collect all direct children exons */
  had_err = gt_feature_node_traverse_direct_children(fn, info,
                                                     save_exons_and_cds, NULL);
  gt_assert(!had_err); /* cannot happen, because save_exons_and_cds() is sane */
  /* set transcript feature type, if necessary */
  set_transcript_types(info->exon_features, gt_feature_node_get_strand(fn));
  set_transcript_types(info->cds_features, gt_feature_node_get_strand(fn));
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testq %rdx, %rdx
je 0x40a6a
movq %rdx, %rdi
callq 0x3566a
testb %al, %al
jne 0x40ad4
testq %rbx, %rbx
je 0x40aca
testq %r14, %r14
je 0x40aca
movq (%r14), %rdi
callq 0x6ed13
movq 0x8(%r14), %rdi
callq 0x6ed13
leaq 0xc98(%rip), %rdx       # 0x41724
movq %rbx, %rdi
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x411ba
testl %eax, %eax
jne 0x40acf
movq (%r14), %rdi
movl 0x68(%rbx), %esi
shrl $0x5, %esi
andl $0x7, %esi
callq 0x417a7
movq 0x8(%r14), %rdi
movl 0x68(%rbx), %esi
shrl $0x5, %esi
andl $0x7, %esi
callq 0x417a7
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x101ef
callq 0x10228
callq 0x101b6
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/feature_node.c
// Function: gt_feature_node_set_end
void gt_feature_node_set_end(GtFeatureNode *fn, GtUword end)
{
  gt_assert(fn && fn->range.start <= end);
  fn->range.end = end;
  if (fn->observer && fn->observer->range_changed)
    fn->observer->range_changed(fn, &(fn->range), fn->observer->data);
}

// Assembly:
testq %rdi, %rdi
je 0x40b1d
cmpq %rsi, 0x48(%rdi)
ja 0x40b1d
movq %rsi, 0x50(%rdi)
movq 0x80(%rdi), %rax
testq %rax, %rax
je 0x40b1c
movq 0x38(%rax), %rcx
testq %rcx, %rcx
je 0x40b1c
leaq 0x48(%rdi), %rsi
movq 0x60(%rax), %rdx
jmpq *%rcx
retq
pushq %rax
callq 0x1029a
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/feature_node.c
// Function: gt_feature_node_set_score_p
void gt_feature_node_set_score_p(GtFeatureNode *fn, float* score)
{
  gt_assert(fn);
  fn->bit_field |= 1 << SCORE_IS_DEFINED_OFFSET;
  fn->score = *score;
  if (fn->observer && fn->observer->score_changed)
    fn->observer->score_changed(fn, *score, fn->observer->data);
}

// Assembly:
testq %rdi, %rdi
je 0x40b57
orb $0x20, 0x69(%rdi)
movss (%rsi), %xmm0
movss %xmm0, 0x58(%rdi)
movq 0x80(%rdi), %rax
testq %rax, %rax
je 0x40b56
movq (%rax), %rcx
testq %rcx, %rcx
je 0x40b56
xorps %xmm0, %xmm0
cvtss2sd (%rsi), %xmm0
movq 0x60(%rax), %rsi
jmpq *%rcx
retq
pushq %rax
callq 0x102d3
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/feature_node.c
// Function: gt_feature_node_unset_score
void gt_feature_node_unset_score(GtFeatureNode *fn)
{
  gt_assert(fn);
  fn->bit_field &= ~(1 << SCORE_IS_DEFINED_OFFSET);
  fn->score = GT_UNDEF_FLOAT;
  if (fn->observer && fn->observer->score_changed)
    fn->observer->score_changed(fn, fn->score, fn->observer->data);
}

// Assembly:
testq %rdi, %rdi
je 0x40b90
andb $-0x21, 0x69(%rdi)
movl $0x7f7fffff, 0x58(%rdi) # imm = 0x7F7FFFFF
movq 0x80(%rdi), %rax
testq %rax, %rax
je 0x40b8f
movq (%rax), %rcx
testq %rcx, %rcx
je 0x40b8f
movq 0x60(%rax), %rsi
movsd 0xa3f9b(%rip), %xmm0    # 0xe4b28
jmpq *%rcx
retq
pushq %rax
callq 0x1030c
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/feature_node.c
// Function: gt_feature_node_add_attribute
void gt_feature_node_add_attribute(GtFeatureNode *fn,
                                   const char *attr_name,
                                   const char *attr_value)
{
  gt_assert(fn && attr_name && attr_value);
  gt_assert(strlen(attr_name)); /* attribute name cannot be empty */
  gt_assert(strlen(attr_value)); /* attribute value cannot be empty */
  if (!fn->attributes)
    fn->attributes = gt_tag_value_map_new(attr_name, attr_value);
  else
    gt_tag_value_map_add(&fn->attributes, attr_name, attr_value);
  if (fn->observer && fn->observer->attribute_changed) {
    fn->observer->attribute_changed(fn, true, attr_name, attr_value,
                                    fn->observer->data);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x40c33
movq %rsi, %r14
testq %rsi, %rsi
je 0x40c33
movq %rdx, %rbx
testq %rdx, %rdx
je 0x40c33
cmpb $0x0, (%r14)
je 0x40c38
cmpb $0x0, (%rbx)
je 0x40c3d
movq %rdi, %r15
leaq 0x60(%rdi), %r12
cmpq $0x0, 0x60(%rdi)
je 0x40be4
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x4a62c
jmp 0x40bf3
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4a578
movq %rax, (%r12)
movq 0x80(%r15), %rcx
testq %rcx, %rcx
je 0x40c27
movq 0x28(%rcx), %rax
testq %rax, %rax
je 0x40c27
movq 0x60(%rcx), %r8
movq %r15, %rdi
movl $0x1, %esi
movq %r14, %rdx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmpq *%rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x10345
callq 0x103b7
callq 0x1037e
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/feature_node.c
// Function: gt_feature_node_remove_attribute
void gt_feature_node_remove_attribute(GtFeatureNode *fn,
                                      const char *attr_name)
{
  gt_assert(fn && attr_name);
  gt_assert(strlen(attr_name)); /* attribute name cannot be empty */
  gt_assert(fn->attributes); /* attribute list must exist already */
  if (gt_tag_value_map_size(fn->attributes) == 1) {
    gt_tag_value_map_delete(fn->attributes);
    fn->attributes = NULL;
  } else
    gt_tag_value_map_remove(&fn->attributes, attr_name);
  if (fn->observer && fn->observer->attribute_deleted) {
    fn->observer->attribute_deleted(fn, attr_name, fn->observer->data);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x40cbc
movq %rsi, %rbx
testq %rsi, %rsi
je 0x40cbc
cmpb $0x0, (%rbx)
je 0x40cc1
movq %rdi, %r14
movq 0x60(%rdi), %rdi
testq %rdi, %rdi
je 0x40cc6
leaq 0x60(%r14), %r15
callq 0x4aad2
cmpq $0x1, %rax
jne 0x40c85
movq (%r15), %rdi
callq 0x4acc1
movq $0x0, (%r15)
jmp 0x40c90
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4a7a3
movq 0x80(%r14), %rax
testq %rax, %rax
je 0x40cb6
movq 0x30(%rax), %rcx
testq %rcx, %rcx
je 0x40cb6
movq 0x60(%rax), %rdx
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmpq *%rcx
popq %rbx
popq %r14
popq %r15
retq
callq 0x103f0
callq 0x10462
callq 0x10429
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/feature_node.c
// Function: feature_node_has_gft
static bool feature_node_has_gft(const GtFeatureNode *fn, const char **fnts)
{
  GtFeatureNodeIterator *fni;
  GtFeatureNode *child;
  bool has_gft = false;
  gt_assert(fn && fnts && fnts[0] != NULL);
  fni = gt_feature_node_iterator_new(fn);
  while ((child = gt_feature_node_iterator_next(fni))) {
    GtUword i = 0;
    while (fnts[i] != NULL) {
      if (gt_feature_node_has_type((GtFeatureNode*) child, fnts[i])) {
        has_gft = true;
        break;
      }
      i++;
    }
    if (has_gft)
      break;
  }
  gt_feature_node_iterator_delete(fni);
  return has_gft;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x40d80
movq %rsi, %rbx
testq %rsi, %rsi
je 0x40d80
cmpq $0x0, (%rbx)
je 0x40d80
callq 0x4186c
movq %rax, %r14
leaq 0x8(%rbx), %r12
xorl %ebp, %ebp
movq %r14, %rdi
callq 0x41a02
testq %rax, %rax
je 0x40d63
movq (%rbx), %rsi
testq %rsi, %rsi
je 0x40d5d
movq %rax, %r15
movq %r12, %r13
movq 0x40(%r15), %rdi
testq %rdi, %rdi
je 0x40d4b
callq 0x83114
testl %eax, %eax
je 0x40d5a
movq (%r13), %rsi
addq $0x8, %r13
testq %rsi, %rsi
jne 0x40d39
jmp 0x40d5d
movb $0x1, %bpl
testb $0x1, %bpl
je 0x40d1e
movq %r14, %rdi
callq 0x41a94
andb $0x1, %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x104d4
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/feature_node.c
// Function: gt_feature_node_average_splice_site_prob
double gt_feature_node_average_splice_site_prob(const GtFeatureNode *fn,
                                                GtUword *num_ss)
{
  GtFeatureNodeIterator *fni;
  GtFeatureNode *child;
  GtUword num_of_splice_sites = 0;
  double averagessp = 0.0;
  gt_assert(fn);
  fni = gt_feature_node_iterator_new(fn);
  while ((child = gt_feature_node_iterator_next(fni))) {
    if (gt_feature_node_has_type(child, gt_ft_five_prime_cis_splice_site) ||
        gt_feature_node_has_type(child, gt_ft_five_prime_splice_site) ||
        gt_feature_node_has_type(child, gt_ft_three_prime_cis_splice_site) ||
        gt_feature_node_has_type(child, gt_ft_three_prime_splice_site)) {
      averagessp += gt_feature_node_get_score((GtFeatureNode*) child);
      num_of_splice_sites++;
    }
  }
  gt_feature_node_iterator_delete(fni);
  if (num_of_splice_sites)
    averagessp /= num_of_splice_sites;
  if (num_ss)
    *num_ss = num_of_splice_sites;
  return averagessp;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x40edf
movq %rsi, 0x10(%rsp)
callq 0x4186c
movq %rax, %r14
movq %rax, %rdi
callq 0x41a02
testq %rax, %rax
je 0x40e77
movq %rax, %rbx
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
xorl %r15d, %r15d
leaq 0xa4449(%rip), %r12     # 0xe5225
leaq 0xa442b(%rip), %r13     # 0xe520e
leaq 0xa4409(%rip), %rbp     # 0xe51f3
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x40dff
movq %rbp, %rsi
callq 0x83114
testl %eax, %eax
je 0x40e42
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x40e14
movq %r13, %rsi
callq 0x83114
testl %eax, %eax
je 0x40e42
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x40e29
movq %r12, %rsi
callq 0x83114
testl %eax, %eax
je 0x40e42
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x40e61
leaq 0xa4408(%rip), %rsi     # 0xe5241
callq 0x83114
testl %eax, %eax
jne 0x40e61
movq %rbx, %rdi
callq 0x405b4
cvtss2sd %xmm0, %xmm0
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
incq %r15
movq %r14, %rdi
callq 0x41a02
movq %rax, %rbx
testq %rax, %rax
jne 0x40dea
jmp 0x40e83
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
xorl %r15d, %r15d
movq %r14, %rdi
callq 0x41a94
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x40e98
movq %r15, (%rax)
testq %r15, %r15
je 0x40eca
movq %r15, %xmm0
punpckldq 0xa05d6(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0xa05de(%rip), %xmm0    # 0xe1490
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
divsd %xmm1, %xmm0
jmp 0x40ed0
movsd 0x8(%rsp), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1050d
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/feature_node.c
// Function: gt_feature_node_is_similar
bool gt_feature_node_is_similar(const GtFeatureNode *fn_a,
                                const GtFeatureNode *fn_b)
{
  GtRange range_a, range_b;
  gt_assert(fn_a && fn_b);
  range_a = feature_node_get_range((GtGenomeNode*) fn_a);
  range_b = feature_node_get_range((GtGenomeNode*) fn_b);
  if (!gt_str_cmp(gt_genome_node_get_seqid((GtGenomeNode*) fn_a),
                  gt_genome_node_get_seqid((GtGenomeNode*) fn_b)) &&
      (gt_feature_node_get_type(fn_a) == gt_feature_node_get_type(fn_b)) &&
      (!gt_range_compare(&range_a, &range_b)) &&
      (gt_feature_node_get_strand(fn_a) ==
       gt_feature_node_get_strand(fn_b)) &&
      (gt_feature_node_get_phase(fn_a) ==
       gt_feature_node_get_phase(fn_b))) {
    return true;
  }
  return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
testq %rdi, %rdi
je 0x40f95
movq %rsi, %rbx
testq %rsi, %rsi
je 0x40f95
movq %rdi, %r14
callq 0x3f9be
movq %rax, %rdi
movq %r14, %rsi
callq 0x41edd
movups 0x48(%rax), %xmm0
movaps %xmm0, 0x10(%rsp)
callq 0x3f9be
movq %rax, %rdi
movq %rbx, %rsi
callq 0x41edd
movups 0x48(%rax), %xmm0
movaps %xmm0, (%rsp)
movq %r14, %rdi
callq 0x41f3f
movq %rax, %r15
movq %rbx, %rdi
callq 0x41f3f
movq %r15, %rdi
movq %rax, %rsi
callq 0x3c4b0
testl %eax, %eax
jne 0x40f85
movq 0x40(%r14), %rax
cmpq 0x40(%rbx), %rax
jne 0x40f85
leaq 0x10(%rsp), %rdi
movq %rsp, %rsi
callq 0x7df58
testl %eax, %eax
jne 0x40f85
movl 0x68(%r14), %eax
xorl 0x68(%rbx), %eax
testb $-0x20, %al
jne 0x40f85
testl $0x300, %eax            # imm = 0x300
je 0x40f91
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movb $0x1, %al
jmp 0x40f87
callq 0x10546
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/feature_node.c
// Function: gt_feature_node_unit_test
int gt_feature_node_unit_test(GtError *err)
{
  GtGenomeNode *fn;
  GtStr *seqid;
  int had_err = 0;

  gt_error_check(err);

  seqid = gt_str_new_cstr("seqid");
  fn = gt_feature_node_new(seqid, gt_ft_gene, 1, 1000, GT_STRAND_FORWARD);

  gt_ensure(!gt_feature_node_score_is_defined((GtFeatureNode*) fn));

  gt_genome_node_delete(fn);
  gt_str_delete(seqid);

  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
je 0x40fb9
movq %rbx, %rdi
callq 0x3566a
testb %al, %al
jne 0x41043
leaq 0xc0dc0(%rip), %rdi     # 0x101d80
callq 0x3c03d
movq %rax, %r14
leaq 0xcb8d1(%rip), %rsi     # 0x10c8a0
xorl %ebp, %ebp
movl $0x1, %edx
movl $0x3e8, %ecx            # imm = 0x3E8
movq %rax, %rdi
xorl %r8d, %r8d
callq 0x3fbf0
movq %rax, %r15
movq %rax, %rdi
callq 0x402b9
testb %al, %al
je 0x41026
leaq 0xa217d(%rip), %rsi     # 0xe3179
leaq 0xa42c1(%rip), %rdx     # 0xe52c4
leaq 0xa42a0(%rip), %rcx     # 0xe52aa
leaq 0xa3b47(%rip), %r8      # 0xe4b58
movq %rbx, %rdi
movl $0x338, %r9d            # imm = 0x338
xorl %eax, %eax
callq 0x3559f
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movq %r15, %rdi
callq 0x42ade
movq %r14, %rdi
callq 0x3d1eb
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x1057f
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/feature_node.c
// Function: gt_feature_node_traverse_children_top
int gt_feature_node_traverse_children_top(GtFeatureNode *feature_node,
                                          void *data,
                                          GtFeatureNodeTraverseFunc traverse,
                                          GtError *err)
{
  GtArray *toplist;
  int had_err = 0;

  if (!feature_node)
    return 0;

  /* this is the first traversal */
  gt_assert(feature_node_get_dfs_status(feature_node) == DFS_WHITE);

  /* initialization */
  toplist = gt_array_new(sizeof (GtFeatureNode*));

  /* process queue */
  dfs_visit(feature_node, toplist);

  /* process topologically sorted feature node list */
  if (traverse) {
    while (gt_array_size(toplist)) {
      GtFeatureNode *fn = *(GtFeatureNode**) gt_array_pop(toplist);
      if ((had_err = traverse(fn, data, err)))
        break;
    }
  }

  /* free */
  gt_array_delete(toplist);

  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x410e9
movq %rdi, %r13
testb $0x3, 0x6a(%rdi)
jne 0x410fc
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movl $0x8, %edi
callq 0x6e93c
movq %rax, %r12
movq %r13, %rdi
movq %rax, %rsi
callq 0x41101
xorl %ebp, %ebp
testq %r14, %r14
je 0x410df
movq %r12, %rdi
callq 0x6ecda
testq %rax, %rax
je 0x410df
movq %r12, %rdi
callq 0x6ea35
movq (%rax), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq *%r14
movl %eax, %ebp
testl %eax, %eax
je 0x410b8
movq %r12, %rdi
callq 0x6f134
jmp 0x410eb
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1062a
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/feature_node.c
// Function: dfs_visit
static void dfs_visit(GtFeatureNode *u, GtArray *toplist)
{
  GtDlistelem *dlistelem;
  gt_assert(u && toplist);
  feature_node_set_dfs_status(u, DFS_GRAY);
  if (u->children) {
    for (dlistelem = gt_dlist_last(u->children);
         dlistelem != NULL;
         dlistelem = gt_dlistelem_previous(dlistelem)) {
      GtFeatureNode *v = (GtFeatureNode*) gt_dlistelem_get_data(dlistelem);
      if (feature_node_get_dfs_status(v) == DFS_WHITE)
        dfs_visit(v, toplist);
    }
  }
  feature_node_set_dfs_status(u, DFS_BLACK);
  if (!gt_feature_node_is_pseudo(u))
    gt_array_add(toplist, u);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, 0x8(%rsp)
testq %rdi, %rdi
je 0x411b5
movq %rsi, %rbx
testq %rsi, %rsi
je 0x411b5
movl $0xfffcffff, %eax       # imm = 0xFFFCFFFF
andl 0x68(%rdi), %eax
orl $0x10000, %eax          # imm = 0x10000
movl %eax, 0x68(%rdi)
movq 0x70(%rdi), %rdi
testq %rdi, %rdi
je 0x4117c
callq 0x72d40
testq %rax, %rax
je 0x4117c
movq %rax, %r14
movq %r14, %rdi
callq 0x72dac
movq %rax, %r15
movq %rax, %rdi
callq 0x41048
testl %eax, %eax
jne 0x4116c
movq %r15, %rdi
movq %rbx, %rsi
callq 0x41101
movq %r14, %rdi
callq 0x73b87
movq %rax, %r14
testq %rax, %rax
jne 0x4114a
movq 0x8(%rsp), %rdi
movl $0x2, %esi
callq 0x4105b
movq 0x8(%rsp), %rdi
callq 0x40459
testb %al, %al
jne 0x411ab
leaq 0x8(%rsp), %rsi
movl $0x8, %edx
movq %rbx, %rdi
callq 0x6ec0e
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x10663
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/feature_node.c
// Function: gt_feature_node_traverse_direct_children
int gt_feature_node_traverse_direct_children(GtFeatureNode *fn,
                                             void *traverse_func_data,
                                             GtFeatureNodeTraverseFunc traverse,
                                             GtError *err)
{
  GtDlistelem *dlistelem;
  int had_err = 0;
  gt_error_check(err);
  if (!fn || !traverse)
    return 0;
  if (fn->children) {
    for (dlistelem = gt_dlist_first(fn->children); dlistelem != NULL;
         dlistelem = gt_dlistelem_next(dlistelem)) {
      had_err = traverse((GtFeatureNode*) gt_dlistelem_get_data(dlistelem),
                          traverse_func_data, err);
      if (had_err)
        break;
    }
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
testq %rcx, %rcx
je 0x411df
movq %rbx, %rdi
callq 0x3566a
testb %al, %al
jne 0x4123f
testq %r12, %r12
sete %al
testq %r14, %r14
sete %cl
xorl %ebp, %ebp
orb %al, %cl
jne 0x41234
movq 0x70(%r12), %rdi
testq %rdi, %rdi
je 0x41234
callq 0x72d30
testq %rax, %rax
je 0x41234
movq %rax, %r12
movq %r12, %rdi
callq 0x72dac
movq %rax, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq *%r14
testl %eax, %eax
jne 0x41232
movq %r12, %rdi
callq 0x72dbc
movq %rax, %r12
testq %rax, %rax
jne 0x41208
jmp 0x41234
movl %eax, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x1069c
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/feature_node.c
// Function: gt_feature_node_number_of_children_of_type
GtUword gt_feature_node_number_of_children_of_type(const GtFeatureNode
                                                         *parent,
                                                         const GtFeatureNode
                                                         *node)
{
  GT_UNUSED int had_err = 0;
  GtTypeTraverseInfo traverseinfo;
  gt_assert(parent && node);
  traverseinfo.type = gt_feature_node_get_type(node);
  traverseinfo.number = 0;
  had_err = gt_feature_node_traverse_direct_children((GtFeatureNode*) parent,
                                                     &traverseinfo, count_types,
                                                     NULL);
  return traverseinfo.number;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x41294
testq %rsi, %rsi
je 0x41294
movq 0x40(%rsi), %rax
movq %rsp, %rbx
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
leaq 0x19(%rip), %rdx        # 0x41299
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0x411ba
movq 0x8(%rbx), %rax
addq $0x10, %rsp
popq %rbx
retq
callq 0x1070e
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/feature_node.c
// Function: count_types
static int count_types(GtFeatureNode *fn, void *data, GT_UNUSED GtError *err)
{
  int had_err = 0;
  GtTypeTraverseInfo *traverseinfo = (GtTypeTraverseInfo*) data;
  gt_error_check(err);
  if (strcmp(traverseinfo->type, gt_feature_node_get_type(fn)) == 0)
    traverseinfo->number++;
  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0x412b5
movq %rdx, %rdi
callq 0x3566a
testb %al, %al
jne 0x412db
movq (%rbx), %r15
movq %r14, %rdi
callq 0x40276
movq %r15, %rdi
movq %rax, %rsi
callq 0xb890
testl %eax, %eax
jne 0x412d3
incq 0x8(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x10747
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/feature_node.c
// Function: gt_feature_node_remove_leaf
void gt_feature_node_remove_leaf(GtFeatureNode *tree, GtFeatureNode *leafn)
{
  GT_UNUSED int had_err;
  GtFeatureNodeLeafDeleteInfo info;
  gt_assert(tree && leafn);

  info.leaf = leafn;
  info.parent = tree;
  info.deleted = false;

  /* ref child node to enable traversal */
  gt_genome_node_ref((GtGenomeNode*) leafn);
  gt_assert(gt_feature_node_number_of_children(leafn) == 0);
  had_err = gt_feature_node_traverse_children(tree, &info, remove_leaf, true,
                                              NULL);
  /* unref child node, traversal done */
  gt_genome_node_delete((GtGenomeNode*) leafn);

  if (info.deleted)
    set_tree_status(&tree->bit_field, TREE_STATUS_UNDETERMINED);

  gt_assert(!had_err); /* cannot happen, remove_leaf() is sane */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x4135f
movq %rsi, %r14
testq %rsi, %rsi
je 0x4135f
movq %rdi, %rbx
movq %r14, (%rsp)
movq %rdi, 0x8(%rsp)
movb $0x0, 0x10(%rsp)
movq %r14, %rdi
callq 0x41ca0
movq 0x70(%r14), %rdi
callq 0x72dcc
testq %rax, %rax
jne 0x41364
leaq 0x49(%rip), %rdx        # 0x4136e
movq %rsp, %r15
movq %rbx, %rdi
movq %r15, %rsi
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x4068e
movl %eax, %ebp
movq %r14, %rdi
callq 0x42ade
cmpb $0x1, 0x10(%r15)
jne 0x41350
andb $-0x19, 0x68(%rbx)
testl %ebp, %ebp
jne 0x41369
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x10780
callq 0x107b9
callq 0x107f2
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/feature_node.c
// Function: remove_leaf
static int remove_leaf(GtFeatureNode *node, void *data, GT_UNUSED GtError *err)
{
  GtFeatureNode *child;
  GtFeatureNodeLeafDeleteInfo* info = (GtFeatureNodeLeafDeleteInfo*) data;
  GtDlistelem *dlistelem;
  gt_error_check(err);
  if (node != info->leaf && node->children) {
    for (dlistelem = gt_dlist_first(node->children); dlistelem != NULL;
         dlistelem = gt_dlistelem_next(dlistelem)) {
      child = (GtFeatureNode*) gt_dlistelem_get_data(dlistelem);
      if (child == info->leaf) {
        gt_dlist_remove(node->children, dlistelem);
        gt_genome_node_delete((GtGenomeNode*) child);
        info->deleted = true;
        break;
      }
    }
  }
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0x4138d
movq %rdx, %rdi
callq 0x3566a
testb %al, %al
jne 0x413f0
cmpq %r14, (%rbx)
je 0x413e2
movq 0x70(%r14), %rdi
testq %rdi, %rdi
je 0x413e2
callq 0x72d30
testq %rax, %rax
je 0x413e2
movq %rax, %r15
movq %r15, %rdi
callq 0x72dac
cmpq (%rbx), %rax
je 0x413c7
movq %r15, %rdi
callq 0x72dbc
movq %rax, %r15
testq %rax, %rax
jne 0x413a8
jmp 0x413e2
movq %rax, %r12
movq 0x70(%r14), %rdi
movq %r15, %rsi
callq 0x72f25
movq %r12, %rdi
callq 0x42ade
movb $0x1, 0x10(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x1082b
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/feature_node.c
// Function: gt_feature_node_mark
void gt_feature_node_mark(GtFeatureNode *fn)
{
  gt_assert(fn);
  fn->bit_field |= 1;
  if (fn->observer && fn->observer->mark_changed)
    fn->observer->mark_changed(fn, true, fn->observer->data);
}

// Assembly:
testq %rdi, %rdi
je 0x4141f
orb $0x1, 0x68(%rdi)
movq 0x80(%rdi), %rax
testq %rax, %rax
je 0x4141e
movq 0x48(%rax), %rcx
testq %rcx, %rcx
je 0x4141e
movq 0x60(%rax), %rdx
movl $0x1, %esi
jmpq *%rcx
retq
pushq %rax
callq 0x10864
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/feature_node.c
// Function: gt_feature_node_unmark
void gt_feature_node_unmark(GtFeatureNode *fn)
{
  gt_assert(fn);
  if (gt_feature_node_is_marked(fn))
    fn->bit_field &= ~(1);
  if (fn->observer && fn->observer->mark_changed)
    fn->observer->mark_changed(fn, false, fn->observer->data);
}

// Assembly:
testq %rdi, %rdi
je 0x41455
movl 0x68(%rdi), %eax
testb $0x1, %al
je 0x41437
andl $-0x2, %eax
movl %eax, 0x68(%rdi)
movq 0x80(%rdi), %rax
testq %rax, %rax
je 0x41454
movq 0x48(%rax), %rcx
testq %rcx, %rcx
je 0x41454
movq 0x60(%rax), %rdx
xorl %esi, %esi
jmpq *%rcx
retq
pushq %rax
callq 0x1089d
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/feature_node.c
// Function: gt_feature_node_contains_marked
bool gt_feature_node_contains_marked(GtFeatureNode *fn)
{
  bool contains_marked = false;
  GT_UNUSED int rval;
  gt_assert(fn);
  rval = gt_feature_node_traverse_children(fn, &contains_marked,
                                           check_marked_status, true, NULL);
  gt_assert(!rval); /* check_marked_status() is sane */
  return contains_marked;
}

// Assembly:
pushq %rax
movb $0x0, 0x7(%rsp)
testq %rdi, %rdi
je 0x4149a
leaq 0x26(%rip), %rdx        # 0x414a4
leaq 0x7(%rsp), %rsi
movl $0x1, %ecx
xorl %r8d, %r8d
callq 0x4068e
testl %eax, %eax
jne 0x4149f
movb 0x7(%rsp), %al
popq %rcx
retq
callq 0x10948
callq 0x1090f
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/feature_node.c
// Function: gt_feature_node_direct_children_do_not_overlap_generic
bool gt_feature_node_direct_children_do_not_overlap_generic(GtFeatureNode
                                                            *parent,
                                                            GtFeatureNode
                                                            *child)
{
  GtArray *children_ranges;
  GtDlistelem *dlistelem;
  GtFeatureNode *child_fn;
  GtRange range;
  bool rval;

  gt_assert(parent);

  if (!parent->children)
    return true;

  /* get children ranges */
  children_ranges = gt_array_new(sizeof (GtRange));
  gt_assert(parent->children);
  for (dlistelem = gt_dlist_first(parent->children); dlistelem != NULL;
       dlistelem = gt_dlistelem_next(dlistelem)) {
    if (!child ||
        ((child_fn =
            gt_feature_node_try_cast(gt_dlistelem_get_data(dlistelem))) &&
         gt_feature_node_get_type(child) ==
         gt_feature_node_get_type(child_fn))) {
      range = gt_genome_node_get_range((GtGenomeNode*)
                                    gt_dlistelem_get_data(dlistelem));
      gt_array_add(children_ranges, range);
    }
  }

  gt_ranges_sort(children_ranges);
  gt_assert(gt_ranges_are_sorted(children_ranges));
  rval = gt_ranges_do_not_overlap(children_ranges);

  gt_array_delete(children_ranges);

  return rval;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x415b1
movq %rdi, %r15
cmpq $0x0, 0x70(%rdi)
je 0x4159d
movq %rsi, %r14
movl $0x10, %edi
callq 0x6e93c
movq 0x70(%r15), %rdi
testq %rdi, %rdi
je 0x415b6
movq %rax, %rbx
callq 0x72d30
testq %rax, %rax
je 0x41575
movq %rax, %r15
leaq 0x8(%rsp), %r12
testq %r14, %r14
je 0x4153b
movq %r15, %rdi
callq 0x72dac
movq %rax, %r13
callq 0x3f9be
movq %rax, %rdi
movq %r13, %rsi
callq 0x41ef6
testq %rax, %rax
je 0x41565
movq 0x40(%r14), %rcx
cmpq 0x40(%rax), %rcx
jne 0x41565
movq %r15, %rdi
callq 0x72dac
movq %rax, %rdi
callq 0x41f83
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movl $0x10, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x6ec0e
movq %r15, %rdi
callq 0x72dbc
movq %rax, %r15
testq %rax, %rax
jne 0x4150c
movq %rbx, %rdi
callq 0x7e92e
movq %rbx, %rdi
callq 0x7e9ac
testb %al, %al
je 0x415bb
movq %rbx, %rdi
callq 0x7ea4e
movl %eax, %ebp
movq %rbx, %rdi
callq 0x6f134
jmp 0x415a0
movb $0x1, %bpl
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x109f3
callq 0x109ba
callq 0x10981
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/feature_node.c
// Function: gt_feature_node_overlaps_nodes_mark
bool gt_feature_node_overlaps_nodes_mark(GtFeatureNode *fn, GtArray *nodes,
                                         GtBittab *b)
{
  GtUword i;
  GtGenomeNode *node;
  GtRange fn_range, node_range;
  bool rval = false;
#ifndef NDEBUG
  GtStr *fn_id;
  gt_assert(fn && nodes);
  gt_assert(!b || gt_bittab_size(b) == gt_array_size(nodes));
  fn_id = gt_genome_node_get_idstr((GtGenomeNode*) fn);
#endif
  fn_range = gt_genome_node_get_range((GtGenomeNode*) fn);

  for (i = 0; i < gt_array_size(nodes); i++) {
    node = *(GtGenomeNode**) gt_array_get(nodes, i);
    gt_assert(!gt_str_cmp(fn_id, gt_genome_node_get_idstr(node)));
    node_range = gt_genome_node_get_range(node);
    if (gt_range_overlap(&fn_range, &node_range)) {
      rval = true;
      if (b)
        gt_bittab_set_bit(b, i);
      else
        break;
    }
  }
  return rval;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
testq %rdi, %rdi
je 0x4171a
movq %rsi, %r14
testq %rsi, %rsi
je 0x4171a
movq %rdx, %rbx
movq %rdi, %r12
testq %rdx, %rdx
je 0x4165b
movq %rbx, %rdi
callq 0x70bd9
movq %rax, %r15
movq %r14, %rdi
callq 0x6ecda
cmpq %rax, %r15
jne 0x4171f
movq %r12, %rdi
callq 0x41f60
movq %rax, %r15
movq %r12, %rdi
callq 0x41f83
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movq %r14, %rdi
callq 0x6ecda
testq %rax, %rax
je 0x416f9
xorl %r12d, %r12d
xorl %ebp, %ebp
movq %r14, %rdi
movq %r12, %rsi
callq 0x6e9fa
movq (%rax), %r13
movq %r13, %rdi
callq 0x41f60
movq %r15, %rdi
movq %rax, %rsi
callq 0x3c4b0
testl %eax, %eax
jne 0x41715
movq %r13, %rdi
callq 0x41f83
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x7e06e
testb %al, %al
je 0x416e7
testq %rbx, %rbx
je 0x416fd
movq %rbx, %rdi
movq %r12, %rsi
callq 0x70790
movb $0x1, %bpl
incq %r12
movq %r14, %rdi
callq 0x6ecda
cmpq %rax, %r12
jb 0x4168a
jmp 0x41700
xorl %ebp, %ebp
jmp 0x41700
movb $0x1, %bpl
andb $0x1, %bpl
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x10b10
callq 0x10a9e
callq 0x10ad7
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/feature_node.c
// Function: save_exons_and_cds
static int save_exons_and_cds(GtFeatureNode *fn, void *data,
                              GT_UNUSED GtError *err)
{
  SaveExonAndCDSInfo *info = (SaveExonAndCDSInfo*) data;
  gt_error_check(err);
  gt_assert(fn && info);
  if (gt_feature_node_has_type(fn, gt_ft_exon))
    gt_array_add(info->exon_features, fn);
  else if (gt_feature_node_has_type(fn, gt_ft_CDS))
    gt_array_add(info->cds_features, fn);
  return 0;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, 0x8(%rsp)
testq %rdx, %rdx
je 0x41742
movq %rdx, %rdi
callq 0x3566a
testb %al, %al
jne 0x417a2
testq %rbx, %rbx
je 0x4179d
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0x4179d
movq 0x40(%rax), %rdi
testq %rdi, %rdi
je 0x4176a
leaq 0xbb221(%rip), %rsi     # 0xfc982
callq 0x83114
testl %eax, %eax
je 0x41783
movq 0x8(%rsp), %rdi
leaq 0xa3a79(%rip), %rsi     # 0xe51ef
callq 0x40409
testb %al, %al
je 0x41795
addq $0x8, %rbx
movq (%rbx), %rdi
leaq 0x8(%rsp), %rsi
movl $0x8, %edx
callq 0x6ec0e
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
callq 0x10b82
callq 0x10b49
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/feature_node.c
// Function: set_transcript_types
static void set_transcript_types(GtArray *features, GtStrand parent_strand)
{
  GtFeatureNode *fn;
  GtUword i;
  gt_assert(features);
  if (gt_array_size(features)) {
    if (gt_array_size(features) == 1) {
      fn = *(GtFeatureNode**) gt_array_get_first(features);
      set_transcriptfeaturetype(fn, TRANSCRIPT_FEATURE_TYPE_SINGLE);
    }
    else {
      fn = *(GtFeatureNode**) gt_array_get_first(features);
      set_transcriptfeaturetype(fn, parent_strand != GT_STRAND_REVERSE
                                    ? TRANSCRIPT_FEATURE_TYPE_INITIAL
                                    : TRANSCRIPT_FEATURE_TYPE_TERMINAL);
      for (i = 1; i < gt_array_size(features) - 1; i++) {
        fn = *(GtFeatureNode**) gt_array_get(features, i);
        set_transcriptfeaturetype(fn, TRANSCRIPT_FEATURE_TYPE_INTERNAL);
      }
      fn = *(GtFeatureNode**) gt_array_get_last(features);
      set_transcriptfeaturetype(fn, parent_strand != GT_STRAND_REVERSE
                                    ? TRANSCRIPT_FEATURE_TYPE_TERMINAL
                                    : TRANSCRIPT_FEATURE_TYPE_INITIAL);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x41865
movl %esi, %ebp
movq %rdi, %rbx
callq 0x6ecda
testq %rax, %rax
je 0x417e3
movq %rbx, %rdi
callq 0x6ecda
movq %rax, %r14
movq %rbx, %rdi
callq 0x6ea17
movq (%rax), %rdi
cmpq $0x1, %r14
jne 0x417e8
xorl %esi, %esi
jmp 0x4185c
popq %rbx
popq %r14
popq %rbp
retq
xorl %eax, %eax
cmpl $0x1, %ebp
sete %al
leal 0x1(,%rax,2), %esi
callq 0x3fcee
movq %rbx, %rdi
callq 0x6ecda
addq $-0x3, %rax
cmpq $-0x3, %rax
ja 0x4183f
movl $0x1, %r14d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6e9fa
movq (%rax), %rdi
movl $0x2, %esi
callq 0x3fcee
incq %r14
movq %rbx, %rdi
callq 0x6ecda
decq %rax
cmpq %rax, %r14
jb 0x41814
xorl %r14d, %r14d
cmpl $0x1, %ebp
setne %r14b
movq %rbx, %rdi
callq 0x6ea1e
movq (%rax), %rdi
leal 0x1(,%r14,2), %esi
popq %rbx
popq %r14
popq %rbp
jmp 0x3fcee
callq 0x10bbb
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/feature_node_iterator.c
// Function: gt_feature_node_iterator_new
GtFeatureNodeIterator* gt_feature_node_iterator_new(const GtFeatureNode *fn)
{
  GtFeatureNodeIterator *fni;
  GtFeatureNode *child_feature;
  GtDlistelem *dlistelem;
  gt_assert(fn);
  fni = feature_node_iterator_new_base(fn);
  if (gt_feature_node_is_pseudo((GtFeatureNode*) fn)) {
    /* add the children backwards to traverse in order */
    for (dlistelem = gt_dlist_last(fn->children); dlistelem != NULL;
         dlistelem = gt_dlistelem_previous(dlistelem)) {
      child_feature = (GtFeatureNode*) gt_dlistelem_get_data(dlistelem);
      gt_array_add(fni->feature_stack, child_feature);
    }
  }
  else
    gt_array_add(fni->feature_stack, fni->fn);
  gt_assert(gt_array_size(fni->feature_stack));
  fni->direct = false;
  return fni;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x4190b
movq %rdi, %r14
callq 0x41915
movq %rax, %rbx
movq %r14, %rdi
callq 0x40459
testb %al, %al
je 0x418db
movq 0x70(%r14), %rdi
callq 0x72d40
testq %rax, %rax
je 0x418ec
movq %rax, %r14
leaq 0x8(%rsp), %r15
movq %r14, %rdi
callq 0x72dac
movq %rax, 0x8(%rsp)
movq 0x8(%rbx), %rdi
movl $0x8, %edx
movq %r15, %rsi
callq 0x6ec0e
movq %r14, %rdi
callq 0x73b87
movq %rax, %r14
testq %rax, %rax
jne 0x418ab
jmp 0x418ec
movq 0x8(%rbx), %rdi
movl $0x8, %edx
movq %rbx, %rsi
callq 0x6ec0e
movq 0x8(%rbx), %rdi
callq 0x6ecda
testq %rax, %rax
je 0x41910
movb $0x0, 0x10(%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x10c2b
callq 0x10bf4
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/feature_node_iterator.c
// Function: feature_node_iterator_new_base
static GtFeatureNodeIterator* feature_node_iterator_new_base(const GtFeatureNode
                                                             *fn)
{
  GtFeatureNodeIterator *fni;
  gt_assert(fn);
  fni = gt_malloc(sizeof *fni);
  fni->fn = (GtFeatureNode*) gt_genome_node_ref((GtGenomeNode*) fn);
  fni->feature_stack = gt_array_new(sizeof (GtFeatureNode*));
  return fni;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xa3f12(%rip), %rsi     # 0xe5835
movl $0x18, %edi
movl $0x23, %edx
callq 0x35ee2
movq %rax, %r14
movq %rbx, %rdi
callq 0x41ca0
movq %rax, (%r14)
movl $0x8, %edi
callq 0x6e93c
movq %rax, 0x8(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/feature_node_iterator.c
// Function: gt_feature_node_iterator_new_direct
GtFeatureNodeIterator* gt_feature_node_iterator_new_direct(const GtFeatureNode
                                                           *fn)
{
  GtFeatureNodeIterator *fni;
  gt_assert(fn);
  fni = feature_node_iterator_new_base(fn);
  if (fn->children)
    add_children_to_stack(fni->feature_stack, fn);
  fni->direct = true;
  return fni;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x41990
movq %rdi, %rbx
callq 0x41915
movq %rax, %r14
cmpq $0x0, 0x70(%rbx)
je 0x41980
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x41995
movb $0x1, 0x10(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x10c62
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/feature_node_iterator.c
// Function: add_children_to_stack
static void add_children_to_stack(GtArray *feature_stack,
                                  const GtFeatureNode *fn)
{
  GtFeatureNode *child;
  GtDlistelem *dlistelem;
  gt_assert(feature_stack && fn && fn->children);
  /* add the children backwards to traverse in order */
  for (dlistelem = gt_dlist_last(fn->children); dlistelem != NULL;
       dlistelem = gt_dlistelem_previous(dlistelem)) {
    child = gt_dlistelem_get_data(dlistelem);
    gt_array_add(feature_stack, child);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x419fd
testq %rsi, %rsi
je 0x419fd
movq %rdi, %rbx
movq 0x70(%rsi), %rdi
testq %rdi, %rdi
je 0x419fd
callq 0x72d40
testq %rax, %rax
je 0x419f3
movq %rax, %r14
leaq 0x8(%rsp), %r15
movq %r14, %rdi
callq 0x72dac
movq %rax, 0x8(%rsp)
movl $0x8, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6ec0e
movq %r14, %rdi
callq 0x73b87
movq %rax, %r14
testq %rax, %rax
jne 0x419c6
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x10c99
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/feature_node_iterator.c
// Function: gt_feature_node_iterator_next
GtFeatureNode* gt_feature_node_iterator_next(GtFeatureNodeIterator *fni)
{
  GtFeatureNode *fn;
  gt_assert(fni);
  if (!gt_array_size(fni->feature_stack))
    return NULL;
  /* pop */
  fn = *(GtFeatureNode**) gt_array_pop(fni->feature_stack);
  /* push children on stack */
  if (!fni->direct && fn->children)
    add_children_to_stack(fni->feature_stack, fn);
  return fn;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x41a51
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x6ecda
testq %rax, %rax
je 0x41a43
movq 0x8(%rbx), %rdi
callq 0x6ea35
movq (%rax), %r14
cmpb $0x0, 0x10(%rbx)
jne 0x41a46
cmpq $0x0, 0x70(%r14)
je 0x41a46
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x41995
jmp 0x41a46
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x10cd0
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/feature_node_iterator.c
// Function: gt_feature_node_iterator_example
int gt_feature_node_iterator_example(GT_UNUSED GtError *err)
{
  GtFeatureNodeIterator *fni;
  GtFeatureNode *fn, *node;
  fn = (GtFeatureNode*) gt_feature_node_new_standard_gene();

  /* an example genome node iterator use case */
  fni = gt_feature_node_iterator_new(fn);
  while ((node = gt_feature_node_iterator_next(fni))) {
    /* do something with <node> */
  }
  gt_feature_node_iterator_delete(fni);

  gt_genome_node_delete((GtGenomeNode*) fn);
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x3fde7
movq %rax, %rbx
movq %rax, %rdi
callq 0x4186c
movq %rax, %r14
movq %r14, %rdi
callq 0x41a02
testq %rax, %rax
jne 0x41a6d
movq %r14, %rdi
callq 0x41a94
movq %rbx, %rdi
callq 0x42ade
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/feature_node_iterator.c
// Function: gt_feature_node_iterator_delete
void gt_feature_node_iterator_delete(GtFeatureNodeIterator *fni)
{
  if (!fni) return;
  gt_genome_node_delete((GtGenomeNode*) fni->fn);
  gt_array_delete(fni->feature_stack);
  gt_free(fni);
}

// Assembly:
testq %rdi, %rdi
je 0x41ac3
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x42ade
movq 0x8(%rbx), %rdi
callq 0x6f134
leaq 0xa3d80(%rip), %rsi     # 0xe5835
movq %rbx, %rdi
movl $0x7d, %edx
popq %rbx
jmp 0x362a0
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/feature_node_observer.c
// Function: gt_feature_node_observer_delete
void gt_feature_node_observer_delete(GtFeatureNodeObserver *o)
{
  if (!o) return;
  if (o->reference_count) {
    o->reference_count--;
    return;
  }
  if (o->data)
    gt_free(o->data);
  gt_free(o);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x41b0b
movq %rdi, %rbx
movq 0x68(%rdi), %rax
testq %rax, %rax
je 0x41b0d
decq %rax
movq %rax, 0x68(%rbx)
popq %rbx
retq
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x41b27
leaq 0xa3ddf(%rip), %rsi     # 0xe58fc
movl $0x2a, %edx
callq 0x362a0
leaq 0xa3dce(%rip), %rsi     # 0xe58fc
movq %rbx, %rdi
movl $0x2b, %edx
popq %rbx
jmp 0x362a0
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/feature_visitor.c
// Function: gt_feature_visitor_class
const GtNodeVisitorClass* gt_feature_visitor_class()
{
  static const GtNodeVisitorClass *gvc = NULL;
  gt_class_alloc_lock_enter();
  if (!gvc) {
    gvc = gt_node_visitor_class_new(sizeof (GtFeatureVisitor),
                                    feature_visitor_free,
                                    NULL,
                                    feature_visitor_feature_node,
                                    feature_visitor_region_node,
                                    NULL,
                                    NULL);
  }
  gt_class_alloc_lock_leave();
  return gvc;
}

// Assembly:
pushq %rax
callq 0x71d9b
cmpq $0x0, 0x110fee(%rip)    # 0x152b38
jne 0x41b7f
movq $0x0, (%rsp)
leaq 0x32(%rip), %rsi        # 0x41b8d
leaq 0x53(%rip), %rcx        # 0x41bb5
leaq 0x97(%rip), %r8         # 0x41c00
movl $0x18, %edi
xorl %edx, %edx
xorl %r9d, %r9d
callq 0x49b7c
movq %rax, 0x110fb9(%rip)    # 0x152b38
callq 0x71db1
movq 0x110fad(%rip), %rax    # 0x152b38
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/feature_visitor.c
// Function: feature_visitor_feature_node
static int feature_visitor_feature_node(GtNodeVisitor *gv, GtFeatureNode *fn,
                                        GtError *err)
{
  GtFeatureVisitor *v = feature_visitor_cast(gv);
  int rval = 0;
  gt_error_check(err);
  rval = gt_feature_index_add_feature_node(v->feature_index, fn, err);
  return rval;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x41b3c
movq %rax, %rdi
movq %r15, %rsi
callq 0x49c1d
movq %rax, %r15
testq %rbx, %rbx
je 0x41be7
movq %rbx, %rdi
callq 0x3566a
testb %al, %al
jne 0x41bfb
movq 0x10(%r15), %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x3e116
callq 0x10d75
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/feature_visitor.c
// Function: gt_feature_visitor_new
GtNodeVisitor* gt_feature_visitor_new(GtFeatureIndex *fi)
{
  GtNodeVisitor *gv;
  GtFeatureVisitor *feature_visitor;
  gt_assert(fi != NULL);
  gv = gt_node_visitor_create(gt_feature_visitor_class());
  feature_visitor = feature_visitor_cast(gv);
  feature_visitor->feature_index = gt_feature_index_ref(fi);
  gt_assert(feature_visitor != NULL);
  return gv;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x41c95
movq %rdi, %rbx
callq 0x41b3c
movq %rax, %rdi
callq 0x49bec
movq %rax, %r14
callq 0x41b3c
movq %rax, %rdi
movq %r14, %rsi
callq 0x49c1d
movq %rax, %r15
movq %rbx, %rdi
callq 0x3dfe7
movq %rax, 0x10(%r15)
testq %r15, %r15
je 0x41c9a
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x10e1a
callq 0x10de3
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/genome_node.c
// Function: gt_genome_node_ref
GtGenomeNode* gt_genome_node_ref(GtGenomeNode *gn)
{
  gt_assert(gn);
  gt_rwlock_wrlock(gn->lock);
  gn->reference_count++;
  gt_rwlock_unlock(gn->lock);
  return gn;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x41cc3
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x3d934
incl 0x24(%rbx)
movq 0x18(%rbx), %rdi
callq 0x3d94f
movq %rbx, %rax
popq %rbx
retq
callq 0x10e51
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/genome_node.c
// Function: gt_genome_node_class_new
const GtGenomeNodeClass*
gt_genome_node_class_new(size_t size,
                         GtGenomeNodeFreeFunc free,
                         GtGenomeNodeSetSeqidFunc get_seqid,
                         GtGenomeNodeGetIdstrFunc get_idstr,
                         GtGenomeNodeGetRangeFunc get_range,
                         GtGenomeNodeSetRangeFunc set_range,
                         GtGenomeNodeChangeSeqidFunc change_seqid,
                         GtGenomeNodeAcceptFunc accept)
{
  GtGenomeNodeClass *c_class;
  gt_assert(size);
  c_class = gt_class_alloc(sizeof *c_class);
  c_class->size = size;
  c_class->free = free;
  c_class->get_seqid = get_seqid;
  c_class->get_idstr = get_idstr;
  c_class->get_range = get_range;
  c_class->set_range = set_range;
  c_class->change_seqid = change_seqid;
  c_class->accept = accept;
  return c_class;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x41d2c
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
movl $0x40, %edi
callq 0x71ca4
movq %rbp, (%rax)
movq %r13, 0x8(%rax)
movq %r12, 0x10(%rax)
movq %r15, 0x18(%rax)
movq %r14, 0x20(%rax)
movq %rbx, 0x28(%rax)
movq 0x40(%rsp), %rcx
movq %rcx, 0x30(%rax)
movq 0x48(%rsp), %rcx
movq %rcx, 0x38(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x10e88