LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x1a303
movq %rdx, %rdi
callq 0xc103
testb %al, %al
jne 0x1a3bf
testq %rbx, %rbx
je 0x1a363
testq %r14, %r14
je 0x1a363
movq (%r14), %rdi
callq 0x4ba50
movq 0x8(%r14), %rdi
callq 0x4ba50
leaq 0x13f2(%rip), %rdx      # 0x1b717
movq %rbx, %rdi
movq %r14, %rsi
xorl %ecx, %ecx
callq 0x1ae00
testl %eax, %eax
jne 0x1a391
movq (%r14), %rdi
movl 0x68(%rbx), %esi
shrl $0x5, %esi
andl $0x7, %esi
callq 0x1b7e8
movq 0x8(%r14), %rdi
movl 0x68(%rbx), %esi
shrl $0x5, %esi
andl $0x7, %esi
callq 0x1b7e8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x113c4e(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xafcf2(%rip), %rsi     # 0xca066
leaq 0xb43f4(%rip), %rdx     # 0xce76f
leaq 0xb3c92(%rip), %rcx     # 0xce014
leaq 0xb37af(%rip), %r8      # 0xcdb38
movl $0x251, %r9d            # imm = 0x251
jmp 0x1a3eb
movq 0x113c20(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xafcc4(%rip), %rsi     # 0xca066
leaq 0xb026a(%rip), %rdx     # 0xca613
leaq 0xb3c64(%rip), %rcx     # 0xce014
leaq 0xb3781(%rip), %r8      # 0xcdb38
movl $0x258, %r9d            # imm = 0x258
jmp 0x1a3eb
movq 0x113bf2(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xafc96(%rip), %rsi     # 0xca066
leaq 0xb0282(%rip), %rdx     # 0xca659
leaq 0xb3c36(%rip), %rcx     # 0xce014
leaq 0xb3753(%rip), %r8      # 0xcdb38
movl $0x250, %r9d            # imm = 0x250
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x1a46e
cmpq %rsi, 0x48(%rdi)
ja 0x1a46e
movq %rsi, 0x50(%rdi)
movq 0x80(%rdi), %rax
testq %rax, %rax
je 0x1a46d
movq 0x38(%rax), %rcx
testq %rcx, %rcx
je 0x1a46d
leaq 0x48(%rdi), %rsi
movq 0x60(%rax), %rdx
jmpq *%rcx
retq
pushq %rax
movq 0x113b42(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xafbe6(%rip), %rsi     # 0xca066
leaq 0xb3bd1(%rip), %rdx     # 0xce058
leaq 0xb3be7(%rip), %rcx     # 0xce075
leaq 0xb36a3(%rip), %r8      # 0xcdb38
movl $0x279, %r9d            # imm = 0x279
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x1a4d8
orb $0x20, 0x69(%rdi)
movss (%rsi), %xmm0
movss %xmm0, 0x58(%rdi)
movq 0x80(%rdi), %rax
testq %rax, %rax
je 0x1a4d7
movq (%rax), %rcx
testq %rcx, %rcx
je 0x1a4d7
cvtss2sd %xmm0, %xmm0
movq 0x60(%rax), %rsi
jmpq *%rcx
retq
pushq %rax
movq 0x113ad8(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xafb7c(%rip), %rsi     # 0xca066
leaq 0xc31b5(%rip), %rdx     # 0xdd6a6
leaq 0xb3baf(%rip), %rcx     # 0xce0a7
leaq 0xb3639(%rip), %r8      # 0xcdb38
movl $0x28a, %r9d            # imm = 0x28A
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x1a544
andb $-0x21, 0x69(%rdi)
movl $0x7f7fffff, 0x58(%rdi) # imm = 0x7F7FFFFF
movq 0x80(%rdi), %rax
testq %rax, %rax
je 0x1a543
movq (%rax), %rcx
testq %rcx, %rcx
je 0x1a543
movq 0x60(%rax), %rsi
movsd 0xb35c7(%rip), %xmm0    # 0xcdb08
jmpq *%rcx
retq
pushq %rax
movq 0x113a6c(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xafb10(%rip), %rsi     # 0xca066
leaq 0xc3149(%rip), %rdx     # 0xdd6a6
leaq 0xb3b5f(%rip), %rcx     # 0xce0c3
leaq 0xb35cd(%rip), %r8      # 0xcdb38
movl $0x293, %r9d            # imm = 0x293
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x1a620
movq %rsi, %r14
testq %rsi, %rsi
je 0x1a620
movq %rdx, %rbx
testq %rdx, %rdx
je 0x1a620
cmpb $0x0, (%r14)
je 0x1a64e
cmpb $0x0, (%rbx)
je 0x1a67c
movq %rdi, %r15
leaq 0x60(%rdi), %r12
cmpq $0x0, 0x60(%rdi)
je 0x1a5d3
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x27035
jmp 0x1a5e2
movq %r14, %rdi
movq %rbx, %rsi
callq 0x26f28
movq %rax, (%r12)
movq 0x80(%r15), %rcx
testq %rcx, %rcx
je 0x1a614
movq 0x28(%rcx), %rax
testq %rax, %rax
je 0x1a614
movq 0x60(%rcx), %r8
pushq $0x1
popq %rsi
movq %r15, %rdi
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
movq 0x113991(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xafa35(%rip), %rsi     # 0xca066
leaq 0xb3aa7(%rip), %rdx     # 0xce0df
leaq 0xb3abe(%rip), %rcx     # 0xce0fd
leaq 0xb34f2(%rip), %r8      # 0xcdb38
movl $0x29e, %r9d            # imm = 0x29E
jmp 0x1a6a8
movq 0x113963(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xafa07(%rip), %rsi     # 0xca066
leaq 0xb3ab5(%rip), %rdx     # 0xce11b
leaq 0xb3a90(%rip), %rcx     # 0xce0fd
leaq 0xb34c4(%rip), %r8      # 0xcdb38
movl $0x29f, %r9d            # imm = 0x29F
jmp 0x1a6a8
movq 0x113935(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xaf9d9(%rip), %rsi     # 0xca066
leaq 0xb3a99(%rip), %rdx     # 0xce12d
leaq 0xb3a62(%rip), %rcx     # 0xce0fd
leaq 0xb3496(%rip), %r8      # 0xcdb38
movl $0x2a0, %r9d            # imm = 0x2A0
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x1a733
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1a733
cmpb $0x0, (%rbx)
je 0x1a761
movq %rdi, %r14
movq 0x60(%rdi), %rdi
testq %rdi, %rdi
je 0x1a78f
leaq 0x60(%r14), %r15
callq 0x27735
cmpq $0x1, %rax
jne 0x1a6fc
movq (%r15), %rdi
callq 0x27a73
andq $0x0, (%r15)
jmp 0x1a707
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2721e
movq 0x80(%r14), %rax
testq %rax, %rax
je 0x1a72d
movq 0x30(%rax), %rcx
testq %rcx, %rcx
je 0x1a72d
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
movq 0x11387e(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xaf922(%rip), %rsi     # 0xca066
leaq 0xb3a13(%rip), %rdx     # 0xce15e
leaq 0xb3a1c(%rip), %rcx     # 0xce16e
leaq 0xb33df(%rip), %r8      # 0xcdb38
movl $0x2bf, %r9d            # imm = 0x2BF
jmp 0x1a7bb
movq 0x113850(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xaf8f4(%rip), %rsi     # 0xca066
leaq 0xb39a2(%rip), %rdx     # 0xce11b
leaq 0xb39ee(%rip), %rcx     # 0xce16e
leaq 0xb33b1(%rip), %r8      # 0xcdb38
movl $0x2c0, %r9d            # imm = 0x2C0
jmp 0x1a7bb
movq 0x113822(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xaf8c6(%rip), %rsi     # 0xca066
leaq 0xb39e8(%rip), %rdx     # 0xce18f
leaq 0xb39c0(%rip), %rcx     # 0xce16e
leaq 0xb3383(%rip), %r8      # 0xcdb38
movl $0x2c1, %r9d            # imm = 0x2C1
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1a88c
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1a88c
cmpq $0x0, (%rbx)
je 0x1a88c
callq 0x1b8e0
movq %rax, %r14
movq %r14, %rdi
callq 0x1bb1e
movq %rax, %r15
testq %rax, %rax
je 0x1a870
movq %rbx, %r12
movq (%r12), %rsi
testq %rsi, %rsi
je 0x1a844
movq %r15, %rdi
callq 0x1987b
addq $0x8, %r12
testb %al, %al
je 0x1a857
testq %r15, %r15
setne %bl
movq %r14, %rdi
callq 0x1bbe1
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x113725(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xaf7c9(%rip), %rsi     # 0xca066
leaq 0xb3efe(%rip), %rdx     # 0xce7a2
leaq 0xb3f15(%rip), %rcx     # 0xce7c0
leaq 0xb3286(%rip), %r8      # 0xcdb38
movl $0x2dd, %r9d            # imm = 0x2DD
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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
movq %rsi, 0x10(%rsp)
testq %rdi, %rdi
je 0x1a9ed
callq 0x1b8e0
movq %rax, %r14
xorps %xmm0, %xmm0
movsd %xmm0, (%rsp)
movq $0x0, 0x8(%rsp)
leaq 0xb38c7(%rip), %r15     # 0xce1d3
leaq 0xb38db(%rip), %r12     # 0xce1ee
leaq 0xb38eb(%rip), %r13     # 0xce205
leaq 0xb3900(%rip), %rbp     # 0xce221
movq %r14, %rdi
callq 0x1bb1e
testq %rax, %rax
je 0x1a98e
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
callq 0x1987b
testb %al, %al
jne 0x1a96d
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1987b
testb %al, %al
jne 0x1a96d
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1987b
testb %al, %al
jne 0x1a96d
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x1987b
testb %al, %al
je 0x1a921
movq %rbx, %rdi
callq 0x19c2e
cvtss2sd %xmm0, %xmm0
movsd (%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
incq 0x8(%rsp)
jmp 0x1a921
movq %r14, %rdi
callq 0x1bbe1
movq 0x10(%rsp), %rax
testq %rax, %rax
movq 0x8(%rsp), %rcx
je 0x1a9a8
movq %rcx, (%rax)
testq %rcx, %rcx
je 0x1a9d9
movq %rcx, %xmm0
punpckldq 0xafac6(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0xaface(%rip), %xmm0    # 0xca490
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movsd (%rsp), %xmm0
divsd %xmm1, %xmm0
jmp 0x1a9de
movsd (%rsp), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x1135c4(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xaf668(%rip), %rsi     # 0xca066
leaq 0xc2ca1(%rip), %rdx     # 0xdd6a6
leaq 0xb382d(%rip), %rcx     # 0xce239
leaq 0xb3125(%rip), %r8      # 0xcdb38
movl $0x306, %r9d            # imm = 0x306
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x1aabc
movq %rsi, %r14
testq %rsi, %rsi
je 0x1aabc
movq %rdi, %rbx
callq 0x18b8f
movq %rax, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
movq %r14, %rdi
callq 0x18b8f
movq %rax, (%rsp)
movq %rdx, 0x8(%rsp)
movq %rbx, %rdi
callq 0x1c31a
movq %rax, %r15
movq %r14, %rdi
callq 0x1c31a
movq %r15, %rdi
movq %rax, %rsi
callq 0x14573
testl %eax, %eax
jne 0x1aaac
movq 0x40(%rbx), %rax
cmpq 0x40(%r14), %rax
jne 0x1aaac
leaq 0x10(%rsp), %rdi
movq %rsp, %rsi
callq 0x5cec8
testl %eax, %eax
jne 0x1aaac
movl 0x68(%r14), %eax
xorl 0x68(%rbx), %eax
testw $0x3e0, %ax             # imm = 0x3E0
je 0x1aab8
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movb $0x1, %al
jmp 0x1aaae
movq 0x1134f5(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xaf599(%rip), %rsi     # 0xca066
leaq 0xb378e(%rip), %rdx     # 0xce262
leaq 0xb3794(%rip), %rcx     # 0xce26f
leaq 0xb3056(%rip), %r8      # 0xcdb38
movl $0x31d, %r9d            # imm = 0x31D
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x1ab13
movq %rbx, %rdi
callq 0xc103
testb %al, %al
jne 0x1ab99
leaq 0xd0456(%rip), %rdi     # 0xeaf70
callq 0x13da9
movq %rax, %r14
leaq 0xdae27(%rip), %rsi     # 0xf5950
pushq $0x1
popq %rdx
xorl %ebp, %ebp
movl $0x3e8, %ecx            # imm = 0x3E8
movq %rax, %rdi
xorl %r8d, %r8d
callq 0x18cbb
movq %rax, %r15
movq %rax, %rdi
callq 0x195ce
testb %al, %al
je 0x1ab7c
leaq 0xb1605(%rip), %rsi     # 0xcc159
leaq 0xb3749(%rip), %rdx     # 0xce2a4
leaq 0xb3728(%rip), %rcx     # 0xce28a
leaq 0xb2fcf(%rip), %r8      # 0xcdb38
movq %rbx, %rdi
movl $0x338, %r9d            # imm = 0x338
xorl %eax, %eax
callq 0xc007
pushq $-0x1
popq %rbp
movq %r15, %rdi
callq 0x1d1e3
movq %r14, %rdi
callq 0x152db
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x113418(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xaf4bc(%rip), %rsi     # 0xca066
leaq 0xafaa8(%rip), %rdx     # 0xca659
leaq 0xb36d2(%rip), %rcx     # 0xce28a
leaq 0xb2f79(%rip), %r8      # 0xcdb38
movl $0x333, %r9d            # imm = 0x333
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x1acd6
movq %rdi, %r13
testb $0x3, 0x6a(%rdi)
jne 0x1ace9
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
pushq $0x8
popq %rdi
callq 0x4b380
movq %rax, %r12
movq %r13, %rdi
movq %rax, %rsi
callq 0x1ad21
xorl %ebp, %ebp
testq %r14, %r14
je 0x1accc
movq %r12, %rdi
callq 0x4b988
testq %rax, %rax
je 0x1accc
movq %r12, %rdi
callq 0x4b52b
movq (%rax), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq *%r14
testl %eax, %eax
je 0x1aca5
movl %eax, %ebp
movq %r12, %rdi
callq 0x4c19d
jmp 0x1acd8
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x1132c8(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xaf36c(%rip), %rsi     # 0xca066
leaq 0xb364e(%rip), %rdx     # 0xce34f
leaq 0xb367e(%rip), %rcx     # 0xce386
leaq 0xb2e29(%rip), %r8      # 0xcdb38
movl $0x3f9, %r9d            # imm = 0x3F9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
movq %rdi, (%rsp)
testq %rdi, %rdi
je 0x1adc8
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1adc8
movq %rdi, %r14
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 0x1ad97
callq 0x50621
movq %rax, %r15
testq %rax, %rax
je 0x1ad97
movq %r15, %rdi
callq 0x506e7
movq %rax, %r12
movq %rax, %rdi
callq 0x1abd1
testl %eax, %eax
jne 0x1ad8d
movq %r12, %rdi
movq %rbx, %rsi
callq 0x1ad21
movq %r15, %rdi
callq 0x5165e
jmp 0x1ad63
pushq $0x2
popq %rsi
movq %r14, %rdi
callq 0x1ac17
movq %r14, %rdi
callq 0x19959
testb %al, %al
jne 0x1adbc
movq %rsp, %rsi
pushq $0x8
popq %rdx
movq %rbx, %rdi
callq 0x4b801
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x1131e9(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xaf28d(%rip), %rsi     # 0xca066
leaq 0xb39f5(%rip), %rdx     # 0xce7d5
leaq 0xb39fb(%rip), %rcx     # 0xce7e2
leaq 0xb2d4a(%rip), %r8      # 0xcdb38
movl $0x3d8, %r9d            # imm = 0x3D8
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x1ae25
movq %rbx, %rdi
callq 0xc103
testb %al, %al
jne 0x1ae7d
testq %r12, %r12
sete %al
testq %r14, %r14
sete %cl
xorl %ebp, %ebp
orb %al, %cl
jne 0x1ae72
movq 0x70(%r12), %rdi
testq %rdi, %rdi
je 0x1ae72
callq 0x505e0
movq %rax, %r12
testq %rax, %rax
je 0x1ae72
movq %r12, %rdi
callq 0x506e7
movq %rax, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq *%r14
testl %eax, %eax
jne 0x1ae70
movq %r12, %rdi
callq 0x5072a
jmp 0x1ae46
movl %eax, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x113134(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xaf1d8(%rip), %rsi     # 0xca066
leaq 0xaf7c4(%rip), %rdx     # 0xca659
leaq 0xb3510(%rip), %rcx     # 0xce3ac
leaq 0xb2c95(%rip), %r8      # 0xcdb38
movl $0x421, %r9d            # imm = 0x421
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x1af35
testq %rsi, %rsi
je 0x1af35
movq 0x40(%rsi), %rax
movq %rsp, %rbx
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
leaq 0x4c(%rip), %rdx        # 0x1af6d
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0x1ae00
movq 0x8(%rbx), %rax
addq $0x10, %rsp
popq %rbx
retq
movq 0x11307c(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xaf120(%rip), %rsi     # 0xca066
leaq 0xb34ab(%rip), %rdx     # 0xce3f8
leaq 0xb34b3(%rip), %rcx     # 0xce407
leaq 0xb2bdd(%rip), %r8      # 0xcdb38
movl $0x43d, %r9d            # imm = 0x43D
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x1af89
movq %rdx, %rdi
callq 0xc103
testb %al, %al
jne 0x1afaf
movq (%rbx), %r15
movq %r14, %rdi
callq 0x19528
movq %r15, %rdi
movq %rax, %rsi
callq 0xb880
testl %eax, %eax
jne 0x1afa7
incq 0x8(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0x113002(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xaf0a6(%rip), %rsi     # 0xca066
leaq 0xaf692(%rip), %rdx     # 0xca659
leaq 0xb381e(%rip), %rcx     # 0xce7ec
leaq 0xb2b63(%rip), %r8      # 0xcdb38
movl $0x414, %r9d            # imm = 0x414
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x1b063
movq %rsi, %r14
testq %rsi, %rsi
je 0x1b063
movq %rdi, %rbx
movq %r14, (%rsp)
movq %rdi, 0x8(%rsp)
movb $0x0, 0x10(%rsp)
movq %r14, %rdi
callq 0x1bec8
movq %r14, %rdi
callq 0x1aeb5
testq %rax, %rax
jne 0x1b091
leaq 0xcc(%rip), %rdx        # 0x1b0f7
movq %rsp, %r15
pushq $0x1
popq %rcx
movq %rbx, %rdi
movq %r15, %rsi
xorl %r8d, %r8d
callq 0x19e82
movl %eax, %ebp
movq %r14, %rdi
callq 0x1d1e3
cmpb $0x1, 0x10(%r15)
jne 0x1b054
andb $-0x19, 0x68(%rbx)
testl %ebp, %ebp
jne 0x1b0bf
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x112f4e(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xaeff2(%rip), %rsi     # 0xca066
leaq 0xb3450(%rip), %rdx     # 0xce4cb
leaq 0xb3457(%rip), %rcx     # 0xce4d9
leaq 0xb2aaf(%rip), %r8      # 0xcdb38
movl $0x479, %r9d            # imm = 0x479
jmp 0x1b0eb
movq 0x112f20(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xaefc4(%rip), %rsi     # 0xca066
leaq 0xb344c(%rip), %rdx     # 0xce4f5
leaq 0xb3429(%rip), %rcx     # 0xce4d9
leaq 0xb2a81(%rip), %r8      # 0xcdb38
movl $0x481, %r9d            # imm = 0x481
jmp 0x1b0eb
movq 0x112ef2(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xaef96(%rip), %rsi     # 0xca066
leaq 0xaf53c(%rip), %rdx     # 0xca613
leaq 0xb33fb(%rip), %rcx     # 0xce4d9
leaq 0xb2a53(%rip), %r8      # 0xcdb38
movl $0x48a, %r9d            # imm = 0x48A
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x1b116
movq %rdx, %rdi
callq 0xc103
testb %al, %al
jne 0x1b171
cmpq %r14, (%rbx)
je 0x1b163
movq 0x70(%r14), %rdi
testq %rdi, %rdi
je 0x1b163
callq 0x505e0
movq %rax, %r15
testq %rax, %rax
je 0x1b163
movq %r15, %rdi
callq 0x506e7
cmpq (%rbx), %rax
je 0x1b148
movq %r15, %rdi
callq 0x5072a
jmp 0x1b129
movq %rax, %r12
movq 0x70(%r14), %rdi
movq %r15, %rsi
callq 0x50a5d
movq %r12, %rdi
callq 0x1d1e3
movb $0x1, 0x10(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x112e40(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xaeee4(%rip), %rsi     # 0xca066
leaq 0xaf4d0(%rip), %rdx     # 0xca659
leaq 0xb3359(%rip), %rcx     # 0xce4e9
leaq 0xb29a1(%rip), %r8      # 0xcdb38
movl $0x465, %r9d            # imm = 0x465
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x1b1d1
orb $0x1, 0x68(%rdi)
movq 0x80(%rdi), %rax
testq %rax, %rax
je 0x1b1d0
movq 0x48(%rax), %rcx
testq %rcx, %rcx
je 0x1b1d0
movq 0x60(%rax), %rdx
pushq $0x1
popq %rsi
jmpq *%rcx
retq
pushq %rax
movq 0x112ddf(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xaee83(%rip), %rsi     # 0xca066
leaq 0xc24bc(%rip), %rdx     # 0xdd6a6
leaq 0xb3333(%rip), %rcx     # 0xce524
leaq 0xb2940(%rip), %r8      # 0xcdb38
movl $0x48f, %r9d            # imm = 0x48F
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x1b23a
movl 0x68(%rdi), %eax
testb $0x1, %al
je 0x1b21c
andl $-0x2, %eax
movl %eax, 0x68(%rdi)
movq 0x80(%rdi), %rax
testq %rax, %rax
je 0x1b239
movq 0x48(%rax), %rcx
testq %rcx, %rcx
je 0x1b239
movq 0x60(%rax), %rdx
xorl %esi, %esi
jmpq *%rcx
retq
pushq %rax
movq 0x112d76(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xaee1a(%rip), %rsi     # 0xca066
leaq 0xc2453(%rip), %rdx     # 0xdd6a6
leaq 0xb32df(%rip), %rcx     # 0xce539
leaq 0xb28d7(%rip), %r8      # 0xcdb38
movl $0x497, %r9d            # imm = 0x497
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x1b2e3
leaq 0x80(%rip), %rdx        # 0x1b349
leaq 0x7(%rsp), %rsi
pushq $0x1
popq %rcx
xorl %r8d, %r8d
callq 0x19e82
testl %eax, %eax
jne 0x1b311
movb 0x7(%rsp), %al
popq %rcx
retq
movq 0x112cce(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xaed72(%rip), %rsi     # 0xca066
leaq 0xc23ab(%rip), %rdx     # 0xdd6a6
leaq 0xb3268(%rip), %rcx     # 0xce56a
leaq 0xb282f(%rip), %r8      # 0xcdb38
movl $0x4b1, %r9d            # imm = 0x4B1
jmp 0x1b33d
movq 0x112ca0(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xaed44(%rip), %rsi     # 0xca066
leaq 0xaf7be(%rip), %rdx     # 0xcaae7
leaq 0xb323a(%rip), %rcx     # 0xce56a
leaq 0xb2801(%rip), %r8      # 0xcdb38
movl $0x4b4, %r9d            # imm = 0x4B4
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/feature_node.c
// Function: gt_feature_node_is_tree
bool gt_feature_node_is_tree(GtFeatureNode *fn)
{
  bool status = false;
  gt_assert(fn);
  switch (get_tree_status(fn->bit_field)) {
    case IS_TREE:
      status = true;
      break;
    case IS_NOT_A_TREE:
      status = false;
      break;
    case TREE_STATUS_UNDETERMINED:
      /* not implemented, the tree status must have been determined by a
         previous gt_genome_node_traverse_children() invocation */
    default: gt_assert(0);
  }
  return status;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x1b520
movl 0x68(%rdi), %ecx
shrl $0x3, %ecx
andl $0x3, %ecx
movb $0x1, %al
cmpl $0x1, %ecx
je 0x1b51e
cmpl $0x2, %ecx
jne 0x1b54e
xorl %eax, %eax
popq %rcx
retq
movq 0x112a91(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xaeb35(%rip), %rsi     # 0xca066
leaq 0xc216e(%rip), %rdx     # 0xdd6a6
leaq 0xb30d6(%rip), %rcx     # 0xce615
leaq 0xb25f2(%rip), %r8      # 0xcdb38
movl $0x4f7, %r9d            # imm = 0x4F7
jmp 0x1b57a
movq 0x112a63(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xaeb07(%rip), %rsi     # 0xca066
leaq 0xc00db(%rip), %rdx     # 0xdb641
leaq 0xb30a8(%rip), %rcx     # 0xce615
leaq 0xb25c4(%rip), %r8      # 0xcdb38
movl $0x502, %r9d            # imm = 0x502
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x1b6bb
movq %rsi, %r14
testq %rsi, %rsi
je 0x1b6bb
movq %rdx, %rbx
movq %rdi, %r12
testq %rdx, %rdx
je 0x1b5d7
movq %rbx, %rdi
callq 0x4df60
movq %rax, %r15
movq %r14, %rdi
callq 0x4b988
cmpq %rax, %r15
jne 0x1b6e9
movq %r12, %rdi
callq 0x1c36e
movq %rax, %r15
movq %r12, %rdi
callq 0x1c3c4
leaq 0x18(%rsp), %rcx
movq %rax, (%rcx)
movq %rdx, 0x8(%rcx)
xorl %r13d, %r13d
xorl %ebp, %ebp
movq %r14, %rdi
callq 0x4b988
cmpq %rax, %rbp
jae 0x1b66d
movq %r14, %rdi
movq %rbp, %rsi
callq 0x4b48e
movq (%rax), %r12
movq %r12, %rdi
callq 0x1c36e
movq %r15, %rdi
movq %rax, %rsi
callq 0x14573
testl %eax, %eax
jne 0x1b683
movq %r12, %rdi
callq 0x1c3c4
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x5d0a4
testb %al, %al
je 0x1b665
testq %rbx, %rbx
je 0x1b66a
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x4d737
movb $0x1, %r13b
incq %rbp
jmp 0x1b5fb
movb $0x1, %r13b
andb $0x1, %r13b
movl %r13d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x11292e(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xae9d2(%rip), %rsi     # 0xca066
leaq 0xb2ff2(%rip), %rdx     # 0xce68d
leaq 0xb2f97(%rip), %rcx     # 0xce639
leaq 0xb248f(%rip), %r8      # 0xcdb38
movl $0x51d, %r9d            # imm = 0x51D
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
movq 0x1128f6(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xae99a(%rip), %rsi     # 0xca066
leaq 0xb2f5a(%rip), %rdx     # 0xce62d
leaq 0xb2f5f(%rip), %rcx     # 0xce639
leaq 0xb2457(%rip), %r8      # 0xcdb38
movl $0x515, %r9d            # imm = 0x515
jmp 0x1b6af
movq 0x1128c8(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xae96c(%rip), %rsi     # 0xca066
leaq 0xb2f5c(%rip), %rdx     # 0xce65d
leaq 0xb2f31(%rip), %rcx     # 0xce639
leaq 0xb2429(%rip), %r8      # 0xcdb38
movl $0x516, %r9d            # imm = 0x516
jmp 0x1b6af
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rdi, (%rsp)
testq %rdx, %rdx
je 0x1b736
movq %rdx, %rdi
callq 0xc103
testb %al, %al
jne 0x1b7b0
testq %rbx, %rbx
je 0x1b782
testq %r14, %r14
je 0x1b782
leaq 0xca4d7(%rip), %rsi     # 0xe5c1e
movq %r14, %rdi
callq 0x1987b
testb %al, %al
jne 0x1b76a
leaq 0xb2a75(%rip), %rsi     # 0xce1cf
movq %r14, %rdi
callq 0x1987b
testb %al, %al
je 0x1b778
addq $0x8, %rbx
movq (%rbx), %rdi
movq %rsp, %rsi
pushq $0x8
popq %rdx
callq 0x4b801
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x11282f(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xae8d3(%rip), %rsi     # 0xca066
leaq 0xb2fd5(%rip), %rdx     # 0xce76f
leaq 0xb2fd9(%rip), %rcx     # 0xce77a
leaq 0xb2390(%rip), %r8      # 0xcdb38
movl $0x228, %r9d            # imm = 0x228
jmp 0x1b7dc
movq 0x112801(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xae8a5(%rip), %rsi     # 0xca066
leaq 0xaee91(%rip), %rdx     # 0xca659
leaq 0xb2fab(%rip), %rcx     # 0xce77a
leaq 0xb2362(%rip), %r8      # 0xcdb38
movl $0x227, %r9d            # imm = 0x227
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1b8a5
movl %esi, %ebp
movq %rdi, %rbx
callq 0x4b988
testq %rax, %rax
je 0x1b827
movq %rbx, %rdi
callq 0x4b988
movq %rax, %r14
movq %rbx, %rdi
callq 0x4b4dc
movq (%rax), %rdi
cmpq $0x1, %r14
jne 0x1b832
xorl %esi, %esi
jmp 0x1b896
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
cmpl $0x1, %ebp
sete %al
leal 0x1(,%rax,2), %esi
callq 0x18e0c
pushq $0x1
popq %r14
pushq $0x2
popq %r15
movq %rbx, %rdi
callq 0x4b988
decq %rax
cmpq %rax, %r14
jae 0x1b879
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4b48e
movq (%rax), %rdi
movl %r15d, %esi
callq 0x18e0c
incq %r14
jmp 0x1b84e
xorl %r14d, %r14d
cmpl $0x1, %ebp
setne %r14b
movq %rbx, %rdi
callq 0x4b4e3
movq (%rax), %rdi
leal 0x1(,%r14,2), %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x18e0c
movq 0x11270c(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xae7b0(%rip), %rsi     # 0xca066
leaq 0xca2af(%rip), %rdx     # 0xe5b6c
leaq 0xb2ec9(%rip), %rcx     # 0xce78d
leaq 0xb226d(%rip), %r8      # 0xcdb38
movl $0x234, %r9d            # imm = 0x234
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1b978
movq %rdi, %r14
callq 0x1b9d8
movq %rax, %rbx
movq %r14, %rdi
callq 0x19959
testb %al, %al
je 0x1b948
movq 0x70(%r14), %rdi
callq 0x50621
movq %rax, %r12
movq %rsp, %r14
pushq $0x8
popq %r15
testq %r12, %r12
je 0x1b957
movq %r12, %rdi
callq 0x506e7
movq %rax, (%rsp)
movq 0x8(%rbx), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x4b801
movq %r12, %rdi
callq 0x5165e
movq %rax, %r12
jmp 0x1b91b
movq 0x8(%rbx), %rdi
pushq $0x8
popq %rdx
movq %rbx, %rsi
callq 0x4b801
movq 0x8(%rbx), %rdi
callq 0x4b988
testq %rax, %rax
je 0x1b9a2
movb $0x0, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x112639(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xae6dd(%rip), %rsi     # 0xca066
leaq 0xc1d16(%rip), %rdx     # 0xdd6a6
leaq 0xb2e61(%rip), %rcx     # 0xce7f8
leaq 0xb2e77(%rip), %r8      # 0xce815
pushq $0x2e
jmp 0x1b9ca
movq 0x11260f(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xae6b3(%rip), %rsi     # 0xca066
leaq 0xb2e80(%rip), %rdx     # 0xce83a
leaq 0xb2e37(%rip), %rcx     # 0xce7f8
leaq 0xb2e4d(%rip), %r8      # 0xce815
pushq $0x3a
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0xb2e2f(%rip), %rsi     # 0xce815
pushq $0x18
popq %rdi
pushq $0x23
popq %rdx
callq 0xccb0
movq %rax, %r14
movq %rbx, %rdi
callq 0x1bec8
movq %rax, (%r14)
pushq $0x8
popq %rdi
callq 0x4b380
movq %rax, 0x8(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1ba4d
movq %rdi, %rbx
callq 0x1b9d8
movq %rax, %r14
cmpq $0x0, 0x70(%rbx)
je 0x1ba3d
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x1ba83
movb $0x1, 0x10(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x112564(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xae608(%rip), %rsi     # 0xca066
leaq 0xc1c41(%rip), %rdx     # 0xdd6a6
leaq 0xb2df0(%rip), %rcx     # 0xce85c
leaq 0xb2da2(%rip), %r8      # 0xce815
pushq $0x51
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1bae8
testq %rsi, %rsi
je 0x1bae8
movq %rdi, %rbx
movq 0x70(%rsi), %rdi
testq %rdi, %rdi
je 0x1bae8
callq 0x50621
movq %rax, %r12
movq %rsp, %r14
pushq $0x8
popq %r15
testq %r12, %r12
je 0x1badc
movq %r12, %rdi
callq 0x506e7
movq %rax, (%rsp)
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x4b801
movq %r12, %rdi
callq 0x5165e
movq %rax, %r12
jmp 0x1bab0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x1124c9(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xae56d(%rip), %rsi     # 0xca066
leaq 0xb2da2(%rip), %rdx     # 0xce8a2
leaq 0xb2dbf(%rip), %rcx     # 0xce8c6
leaq 0xb2d07(%rip), %r8      # 0xce815
pushq $0x44
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x1bb6d
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x4b988
testq %rax, %rax
je 0x1bb5f
movq 0x8(%rbx), %rdi
callq 0x4b52b
movq (%rax), %r14
cmpb $0x0, 0x10(%rbx)
jne 0x1bb62
cmpq $0x0, 0x70(%r14)
je 0x1bb62
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x1ba83
jmp 0x1bb62
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x112444(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xae4e8(%rip), %rsi     # 0xca066
leaq 0xb2cfb(%rip), %rdx     # 0xce880
leaq 0xb2cf8(%rip), %rcx     # 0xce884
leaq 0xb2c82(%rip), %r8      # 0xce815
pushq $0x5c
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300