LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/feature_index_memory.c
// Function: store_seqid
static int store_seqid(void *key, GT_UNUSED void *value, void *data,
                       GT_UNUSED GtError *err)
{
  GtCstrTable *seqids = (GtCstrTable*) data;
  const char *seqid = (const char*) key;
  gt_assert(seqids && seqid);
  if (!gt_cstr_table_get(seqids, seqid)) {
    gt_cstr_table_add(seqids, seqid);
  }
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x182cf
movq %rdx, %r14
testq %rdx, %rdx
je 0x182cf
movq %rdi, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5018a
testq %rax, %rax
jne 0x182c5
movq %r14, %rdi
movq %rbx, %rsi
callq 0x500bc
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x115ce2(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb1d86(%rip), %rsi     # 0xca066
leaq 0xb5805(%rip), %rdx     # 0xcdaec
leaq 0xb580e(%rip), %rcx     # 0xcdafc
leaq 0xb54f7(%rip), %r8      # 0xcd7ec
movl $0x114, %r9d            # imm = 0x114
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/feature_index_memory.c
// Function: gt_feature_index_memory_get_range_for_seqid
int gt_feature_index_memory_get_range_for_seqid(GtFeatureIndex *gfi,
                                                GtRange *range,
                                                const char *seqid,
                                                GT_UNUSED GtError *err)
{
  RegionInfo *info;
  GtFeatureIndexMemory *fi;
  gt_assert(gfi && range && seqid);
  fi = gt_feature_index_memory_cast(gfi);
  info = (RegionInfo*) gt_hashmap_get(fi->regions, seqid);
  gt_assert(info);

  if (info->dyn_range.start != ~0UL && info->dyn_range.end != 0) {
    range->start = info->dyn_range.start;
    range->end = info->dyn_range.end;
  }
  else if (info->region)
    *range = gt_genome_node_get_range((GtGenomeNode*) info->region);
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x18378
movq %rsi, %rbx
testq %rsi, %rsi
je 0x18378
movq %rdx, %r14
testq %rdx, %rdx
je 0x18378
movq %rdi, %r15
callq 0x17bc8
movq %rax, %rdi
movq %r15, %rsi
callq 0x172d5
movq 0x10(%rax), %rdi
movq %r14, %rsi
callq 0x55ef6
testq %rax, %rax
je 0x183a6
movq %rax, %rcx
movq 0x10(%rax), %rax
cmpq $-0x1, %rax
je 0x1835b
movq 0x18(%rcx), %rdx
testq %rdx, %rdx
jne 0x18369
movq 0x8(%rcx), %rdi
testq %rdi, %rdi
je 0x18370
callq 0x1c3c4
movq %rax, (%rbx)
movq %rdx, 0x8(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0x115c39(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb1cdd(%rip), %rsi     # 0xca066
leaq 0xb5641(%rip), %rdx     # 0xcd9d1
leaq 0xb5650(%rip), %rcx     # 0xcd9e7
leaq 0xb544e(%rip), %r8      # 0xcd7ec
movl $0x135, %r9d            # imm = 0x135
jmp 0x183d2
movq 0x115c0b(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb1caf(%rip), %rsi     # 0xca066
leaq 0xb95ab(%rip), %rdx     # 0xd1969
leaq 0xb5622(%rip), %rcx     # 0xcd9e7
leaq 0xb5420(%rip), %r8      # 0xcd7ec
movl $0x138, %r9d            # imm = 0x138
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/feature_index_memory.c
// Function: gt_feature_index_memory_get_orig_range_for_seqid
int gt_feature_index_memory_get_orig_range_for_seqid(GtFeatureIndex *gfi,
                                                     GtRange *range,
                                                     const char *seqid,
                                                     GT_UNUSED GtError *err)
{
  RegionInfo *info;
  GtFeatureIndexMemory *fi;
  gt_assert(gfi && range && seqid);
  fi = gt_feature_index_memory_cast(gfi);
  info = (RegionInfo*) gt_hashmap_get(fi->regions, seqid);
  gt_assert(info);

  if (info->region)
    *range = gt_genome_node_get_range((GtGenomeNode*) info->region);

  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x18439
movq %rsi, %rbx
testq %rsi, %rsi
je 0x18439
movq %rdx, %r14
testq %rdx, %rdx
je 0x18439
movq %rdi, %r15
callq 0x17bc8
movq %rax, %rdi
movq %r15, %rsi
callq 0x172d5
movq 0x10(%rax), %rdi
movq %r14, %rsi
callq 0x55ef6
testq %rax, %rax
je 0x18467
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0x18431
callq 0x1c3c4
movq %rax, (%rbx)
movq %rdx, 0x8(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0x115b78(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb1c1c(%rip), %rsi     # 0xca066
leaq 0xb5580(%rip), %rdx     # 0xcd9d1
leaq 0xb55bb(%rip), %rcx     # 0xcda13
leaq 0xb538d(%rip), %r8      # 0xcd7ec
movl $0x14a, %r9d            # imm = 0x14A
jmp 0x18493
movq 0x115b4a(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb1bee(%rip), %rsi     # 0xca066
leaq 0xb94ea(%rip), %rdx     # 0xd1969
leaq 0xb558d(%rip), %rcx     # 0xcda13
leaq 0xb535f(%rip), %r8      # 0xcd7ec
movl $0x14d, %r9d            # imm = 0x14D
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/feature_index_memory.c
// Function: gt_feature_index_memory_has_seqid
int gt_feature_index_memory_has_seqid(const GtFeatureIndex *gfi,
                                      bool *has_seqid,
                                      const char *seqid,
                                      GT_UNUSED GtError *err)
{
  GtFeatureIndexMemory *fi;
  gt_assert(gfi);

  fi = gt_feature_index_memory_cast((GtFeatureIndex*) gfi);
  *has_seqid = (gt_hashmap_get(fi->regions, seqid) != NULL);
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x184dc
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
callq 0x17bc8
movq %rax, %rdi
movq %r15, %rsi
callq 0x172d5
movq 0x10(%rax), %rdi
movq %r14, %rsi
callq 0x55ef6
testq %rax, %rax
setne (%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0x115ad5(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb1b79(%rip), %rsi     # 0xca066
leaq 0xb548e(%rip), %rdx     # 0xcd982
leaq 0xb5549(%rip), %rcx     # 0xcda44
leaq 0xb52ea(%rip), %r8      # 0xcd7ec
movl $0x15b, %r9d            # imm = 0x15B
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/feature_index_memory.c
// Function: gt_feature_index_memory_delete
void gt_feature_index_memory_delete(GtFeatureIndex *gfi)
{
  GtFeatureIndexMemory *fi;
  if (!gfi) return;
  fi = gt_feature_index_memory_cast(gfi);
  gt_hashmap_delete(fi->regions);
  gt_hashmap_delete(fi->nodes_in_index);
}

// Assembly:
testq %rdi, %rdi
je 0x18543
pushq %rbx
movq %rdi, %rbx
callq 0x17bc8
movq %rax, %rdi
movq %rbx, %rsi
callq 0x172d5
movq %rax, %rbx
movq 0x10(%rax), %rdi
callq 0x563a7
movq 0x18(%rbx), %rdi
popq %rbx
jmp 0x563a7
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/feature_index_memory.c
// Function: gt_feature_index_memory_new
GtFeatureIndex* gt_feature_index_memory_new(void)
{
  GtFeatureIndexMemory *fim;
  GtFeatureIndex *fi;
  fi = gt_feature_index_create(gt_feature_index_memory_class());
  fim = gt_feature_index_memory_cast(fi);
  fim->nof_nodes = 0;
  fim->regions = gt_hashmap_new(GT_HASH_STRING, NULL,
                                (GtFree) region_info_delete);
  fim->nodes_in_index = gt_hashmap_new(GT_HASH_DIRECT, NULL, NULL);
  return fi;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x17bc8
movq %rax, %rdi
callq 0x16867
movq %rax, %rbx
callq 0x17bc8
movq %rax, %rdi
movq %rbx, %rsi
callq 0x172d5
movq %rax, %r14
andq $0x0, 0x40(%rax)
leaq 0x28(%rip), %rdx        # 0x1859f
pushq $0x1
popq %rdi
xorl %esi, %esi
callq 0x55da4
movq %rax, 0x10(%r14)
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x55da4
movq %rax, 0x18(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/feature_index_memory.c
// Function: region_info_delete
static void region_info_delete(RegionInfo *info)
{
  gt_interval_tree_delete(info->features);
  if (info->region)
    gt_genome_node_delete((GtGenomeNode*)info->region);
  gt_free(info);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x580d2
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x185b9
callq 0x1d1e3
leaq 0xb522c(%rip), %rsi     # 0xcd7ec
pushq $0x40
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0xd249
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/feature_node.c
// Function: gt_feature_node_get_attribute_list
GtStrArray* gt_feature_node_get_attribute_list(const GtFeatureNode *fn)
{
  GtStrArray *list = gt_str_array_new();
  if (fn->attributes)
    gt_tag_value_map_foreach(fn->attributes, store_attribute, list);
  return list;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x1532c
movq %rax, %rbx
movq 0x60(%r14), %rdi
testq %rdi, %rdi
je 0x1884f
leaq 0x13(%rip), %rsi        # 0x1885a
movq %rbx, %rdx
callq 0x27777
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/feature_node.c
// Function: gt_feature_node_set_source
void gt_feature_node_set_source(GtFeatureNode *fn, GtStr *source)
{
  gt_assert(fn && source);
  if (fn->source)
    gt_str_delete(fn->source);
  fn->source = gt_str_ref(source);
  if (fn->observer && fn->observer->source_changed)
    fn->observer->source_changed(fn, source, fn->observer->data);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1890c
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1890c
movq %rdi, %r14
movq 0x38(%rdi), %rdi
testq %rdi, %rdi
je 0x188d0
callq 0x152db
movq %rbx, %rdi
callq 0x146aa
movq %rax, 0x38(%r14)
movq 0x80(%r14), %rax
testq %rax, %rax
je 0x18904
movq 0x20(%rax), %rcx
testq %rcx, %rcx
je 0x18904
movq 0x60(%rax), %rdx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rcx
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x1156a5(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb1749(%rip), %rsi     # 0xca066
leaq 0xb51ec(%rip), %rdx     # 0xcdb10
leaq 0xb51f2(%rip), %rcx     # 0xcdb1d
leaq 0xb5206(%rip), %r8      # 0xcdb38
movl $0x9f, %r9d
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_phase
void gt_feature_node_set_phase(GtFeatureNode *fn, GtPhase phase)
{
  gt_assert(fn);
  fn->bit_field &= ~(PHASE_MASK << PHASE_OFFSET);
  fn->bit_field |= phase << PHASE_OFFSET;
  if (fn->observer && fn->observer->phase_changed)
    fn->observer->phase_changed(fn, phase, fn->observer->data);
}

// Assembly:
testq %rdi, %rdi
je 0x18977
movl $0xfffffcff, %eax       # imm = 0xFFFFFCFF
andl 0x68(%rdi), %eax
movl %esi, %ecx
shll $0x8, %ecx
orl %eax, %ecx
movl %ecx, 0x68(%rdi)
movq 0x80(%rdi), %rax
testq %rax, %rax
je 0x18976
movq 0x8(%rax), %rcx
testq %rcx, %rcx
je 0x18976
movq 0x60(%rax), %rdx
jmpq *%rcx
retq
pushq %rax
movq 0x115639(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb16dd(%rip), %rsi     # 0xca066
leaq 0xc4d16(%rip), %rdx     # 0xdd6a6
leaq 0xb51bd(%rip), %rcx     # 0xcdb54
leaq 0xb519a(%rip), %r8      # 0xcdb38
movl $0xa9, %r9d
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_observer
void gt_feature_node_set_observer(GtFeatureNode *fn, GtFeatureNodeObserver *o)
{
  gt_assert(fn && o);
  if (fn->observer)
    gt_feature_node_observer_delete(fn->observer);
  fn->observer = gt_feature_node_observer_ref(o);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x189ec
movq %rsi, %r14
testq %rsi, %rsi
je 0x189ec
movq %rdi, %rbx
movq 0x80(%rdi), %rdi
testq %rdi, %rdi
je 0x189d5
callq 0x1bc69
movq %r14, %rdi
callq 0x1bc25
movq %rax, 0x80(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x1155c5(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb1669(%rip), %rsi     # 0xca066
leaq 0xb516a(%rip), %rdx     # 0xcdb6e
leaq 0xb516b(%rip), %rcx     # 0xcdb76
leaq 0xb5126(%rip), %r8      # 0xcdb38
movl $0xbb, %r9d
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_observer
void gt_feature_node_unset_observer(GtFeatureNode *fn)
{
  gt_assert(fn);
  if (fn->observer)
    gt_feature_node_observer_delete(fn->observer);
  fn->observer = NULL;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x18a48
movq %rdi, %rbx
movq 0x80(%rdi), %rdi
testq %rdi, %rdi
je 0x18a3e
callq 0x1bc69
andq $0x0, 0x80(%rbx)
popq %rbx
retq
movq 0x115569(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb160d(%rip), %rsi     # 0xca066
leaq 0xc4c46(%rip), %rdx     # 0xdd6a6
leaq 0xb512c(%rip), %rcx     # 0xcdb93
leaq 0xb50ca(%rip), %r8      # 0xcdb38
movl $0xc3, %r9d
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_class
const GtGenomeNodeClass* gt_feature_node_class()
{
  static const GtGenomeNodeClass *gnc = NULL;
  gt_class_alloc_lock_enter();
  if (!gnc) {
    gnc = gt_genome_node_class_new(sizeof (GtFeatureNode),
                                   feature_node_free,
                                   feature_node_get_seqid,
                                   feature_node_get_seqid,
                                   feature_node_get_range,
                                   feature_node_set_range,
                                   feature_node_change_seqid,
                                   feature_node_accept);
  }
  gt_class_alloc_lock_leave();
  return gnc;
}

// Assembly:
pushq %rax
callq 0x4f21f
cmpq $0x0, 0x117092(%rip)    # 0x12fb20
jne 0x18ad3
leaq 0x1b2(%rip), %rax       # 0x18c49
leaq 0x13d(%rip), %r10       # 0x18bdb
leaq 0x3c(%rip), %rsi        # 0x18ae1
leaq 0xd7(%rip), %rcx        # 0x18b83
leaq 0xdc(%rip), %r8         # 0x18b8f
leaq 0xe8(%rip), %r9         # 0x18ba2
movl $0x88, %edi
movq %rcx, %rdx
pushq %rax
pushq %r10
callq 0x1bf21
popq %rcx
popq %rdx
movq %rax, 0x11704d(%rip)    # 0x12fb20
callq 0x4f266
movq 0x117041(%rip), %rax    # 0x12fb20
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/feature_node.c
// Function: feature_node_free
static void feature_node_free(GtGenomeNode *gn)
{
  GtFeatureNode *fn = gt_feature_node_cast(gn);
  gt_str_delete(fn->seqid);
  gt_str_delete(fn->source);
  gt_tag_value_map_delete(fn->attributes);
  if (fn->children) {
    GtDlistelem *dlistelem;
    for (dlistelem = gt_dlist_first(fn->children);
         dlistelem != NULL;
         dlistelem = gt_dlistelem_next(dlistelem)) {
      gt_genome_node_delete(gt_dlistelem_get_data(dlistelem));
    }
  }
  gt_dlist_delete(fn->children);
  if (fn->observer && fn->observer->deleted)
    fn->observer->deleted(fn, fn->observer->data);
  if (fn->observer)
    gt_feature_node_observer_delete(fn->observer);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x18df7
movq %rax, %rbx
movq 0x30(%rax), %rdi
callq 0x152db
movq 0x38(%rbx), %rdi
callq 0x152db
movq 0x60(%rbx), %rdi
callq 0x27a73
movq 0x70(%rbx), %rdi
testq %rdi, %rdi
je 0x18b3e
callq 0x505e0
movq %rax, %r14
testq %rax, %rax
je 0x18b38
movq %r14, %rdi
callq 0x506e7
movq %rax, %rdi
callq 0x1d1e3
movq %r14, %rdi
callq 0x5072a
jmp 0x18b16
movq 0x70(%rbx), %rdi
jmp 0x18b40
xorl %edi, %edi
callq 0x50c04
movq 0x80(%rbx), %rdi
testq %rdi, %rdi
je 0x18b7b
movq 0x58(%rdi), %rax
testq %rax, %rax
je 0x18b6f
movq 0x60(%rdi), %rsi
movq %rbx, %rdi
callq *%rax
movq 0x80(%rbx), %rdi
testq %rdi, %rdi
je 0x18b7b
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1bc69
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/feature_node.c
// Function: feature_node_set_range
static void feature_node_set_range(GtGenomeNode *gn, const GtRange *range)
{
  GtFeatureNode *fn = gt_feature_node_cast(gn);
  fn->range = *range;
  if (fn->observer && fn->observer->range_changed)
    fn->observer->range_changed(fn, &(fn->range), fn->observer->data);
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
callq 0x18df7
movups (%rbx), %xmm0
movups %xmm0, 0x48(%rax)
movq 0x80(%rax), %rcx
testq %rcx, %rcx
je 0x18bd9
movq 0x38(%rcx), %r8
testq %r8, %r8
je 0x18bd9
movq %rax, %rsi
addq $0x48, %rsi
movq 0x60(%rcx), %rdx
movq %rax, %rdi
popq %rbx
jmpq *%r8
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/feature_node.c
// Function: feature_node_change_seqid
static void feature_node_change_seqid(GtGenomeNode *gn, GtStr *seqid)
{
  GtFeatureNode *fn = gt_feature_node_cast(gn);
  gt_assert(fn && seqid);
  gt_str_delete(fn->seqid);
  fn->seqid = gt_str_ref(seqid);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
callq 0x18df7
testq %rbx, %rbx
je 0x18c11
movq %rax, %r14
testq %rax, %rax
je 0x18c11
movq 0x30(%r14), %rdi
callq 0x152db
movq %rbx, %rdi
callq 0x146aa
movq %rax, 0x30(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x1153a0(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb1444(%rip), %rsi     # 0xca066
leaq 0xb5ac7(%rip), %rdx     # 0xce6f0
leaq 0xb5acc(%rip), %rcx     # 0xce6fc
leaq 0xb4f01(%rip), %r8      # 0xcdb38
movl $0x98, %r9d
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_accept
static int feature_node_accept(GtGenomeNode *gn, GtNodeVisitor *nv,
                               GtError *err)
{
  GtFeatureNode *fn;
  gt_error_check(err);
  fn = gt_feature_node_cast(gn);
  return gt_node_visitor_visit_feature_node(nv, fn, err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rdx, %rdx
je 0x18c68
movq %rbx, %rdi
callq 0xc103
testb %al, %al
jne 0x18c83
movq %r15, %rdi
callq 0x18df7
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x2613a
movq 0x11532e(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb13d2(%rip), %rsi     # 0xca066
leaq 0xb19be(%rip), %rdx     # 0xca659
leaq 0xb5a74(%rip), %rcx     # 0xce716
leaq 0xb4e8f(%rip), %r8      # 0xcdb38
movl $0xb4, %r9d
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_new
GtGenomeNode* gt_feature_node_new(GtStr *seqid, const char *type,
                                  GtUword start, GtUword end,
                                  GtStrand strand)
{
  GtGenomeNode *gn;
  GtFeatureNode *fn;
  gt_assert(seqid && type);
  gt_assert(start <= end);
  gn = gt_genome_node_create(gt_feature_node_class());
  fn = gt_feature_node_cast(gn);
  fn->seqid       = gt_str_ref(seqid);
  fn->source      = NULL;
  fn->type        = gt_symbol(type);
  fn->score       = GT_UNDEF_FLOAT;
  fn->range.start = start;
  fn->range.end   = end;
  fn->representative = NULL;
  fn->attributes  = NULL;
  fn->bit_field   = 0;
  fn->bit_field  |= strand << STRAND_OFFSET;
  fn->children    = NULL; /* the children list is create on demand */
  fn->observer    = NULL;
  gt_feature_node_set_phase(fn, GT_PHASE_UNDEFINED);
  set_transcriptfeaturetype(fn, TRANSCRIPT_FEATURE_TYPE_UNDETERMINED);
  set_tree_status(&fn->bit_field, IS_TREE);
  /* the DFS status is set to DFS_WHITE already */
  fn->representative = NULL;
  return gn;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x18d91
movq %rsi, %rbp
testq %rsi, %rsi
je 0x18d91
movq %rcx, %r15
movq %rdx, %r12
cmpq %rcx, %rdx
ja 0x18dbf
movl %r8d, %ebx
movq %rdi, %r14
callq 0x18a80
movq %rax, %rdi
callq 0x1c0f3
movq %rax, (%rsp)
movq %rax, %rdi
callq 0x18df7
movq %rax, %r13
movq %r14, %rdi
callq 0x146aa
movq %rax, 0x30(%r13)
andq $0x0, 0x38(%r13)
movq %rbp, %rdi
callq 0x15a03
movq %rax, 0x40(%r13)
movl $0x7f7fffff, 0x58(%r13) # imm = 0x7F7FFFFF
movq %r12, 0x48(%r13)
movq %r15, 0x50(%r13)
andq $0x0, 0x60(%r13)
shll $0x5, %ebx
movl %ebx, 0x68(%r13)
xorps %xmm0, %xmm0
movups %xmm0, 0x70(%r13)
andq $0x0, 0x80(%r13)
pushq $0x3
popq %rsi
movq %r13, %rdi
callq 0x18944
pushq $0x4
popq %rsi
movq %r13, %rdi
callq 0x18e0c
movl 0x68(%r13), %eax
andl $-0x19, %eax
orl $0x8, %eax
movl %eax, 0x68(%r13)
andq $0x0, 0x78(%r13)
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x115220(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb12c4(%rip), %rsi     # 0xca066
leaq 0xb4e09(%rip), %rdx     # 0xcdbb2
leaq 0xb4e10(%rip), %rcx     # 0xcdbc0
leaq 0xb4d81(%rip), %r8      # 0xcdb38
movl $0xf0, %r9d
jmp 0x18deb
movq 0x1151f2(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb1296(%rip), %rsi     # 0xca066
leaq 0xc18c7(%rip), %rdx     # 0xda69e
leaq 0xb4de2(%rip), %rcx     # 0xcdbc0
leaq 0xb4d53(%rip), %r8      # 0xcdb38
movl $0xf1, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/feature_node.c
// Function: set_transcriptfeaturetype
static void set_transcriptfeaturetype(GtFeatureNode *fn,
                                      GtTranscriptFeatureType tft)
{
  gt_assert(fn);
  fn->bit_field &= ~(TRANSCRIPT_FEATURE_TYPE_MASK <<
                     TRANSCRIPT_FEATURE_TYPE_OFFSET);
  fn->bit_field |= tft << TRANSCRIPT_FEATURE_TYPE_OFFSET;
}

// Assembly:
testq %rdi, %rdi
je 0x18e22
movl $0xffffe3ff, %eax       # imm = 0xFFFFE3FF
andl 0x68(%rdi), %eax
shll $0xa, %esi
orl %eax, %esi
movl %esi, 0x68(%rdi)
retq
pushq %rax
movq 0x11518e(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb1232(%rip), %rsi     # 0xca066
leaq 0xc486b(%rip), %rdx     # 0xdd6a6
leaq 0xb58e8(%rip), %rcx     # 0xce72a
leaq 0xb4cef(%rip), %r8      # 0xcdb38
movl $0xde, %r9d
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_new_pseudo
GtGenomeNode* gt_feature_node_new_pseudo(GtStr *seqid, GtUword start,
                                         GtUword end, GtStrand strand)
{
  GtFeatureNode *pf;
  GtGenomeNode *pn;
  gt_assert(seqid);
  gt_assert(start <= end);
  pn = gt_feature_node_new(seqid, "pseudo", start, end, strand);
  pf = gt_feature_node_cast(pn);
  pf->type = NULL; /* pseudo features do not have a type */
  pf->bit_field |= 1 << PSEUDO_FEATURE_OFFSET;
  return pn;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x18e94
movl %ecx, %r8d
movq %rdx, %rcx
movq %rsi, %rdx
cmpq %rcx, %rsi
ja 0x18ec2
leaq 0xb4f1e(%rip), %rsi     # 0xcdd94
callq 0x18cbb
movq %rax, %rbx
movq %rax, %rdi
callq 0x18df7
andq $0x0, 0x40(%rax)
orb $-0x80, 0x69(%rax)
movq %rbx, %rax
popq %rbx
retq
movq 0x11511d(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb11c1(%rip), %rsi     # 0xca066
leaq 0xd20c4(%rip), %rdx     # 0xeaf70
leaq 0xb4d21(%rip), %rcx     # 0xcdbd4
leaq 0xb4c7e(%rip), %r8      # 0xcdb38
movl $0x10d, %r9d            # imm = 0x10D
jmp 0x18eee
movq 0x1150ef(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb1193(%rip), %rsi     # 0xca066
leaq 0xc17c4(%rip), %rdx     # 0xda69e
leaq 0xb4cf3(%rip), %rcx     # 0xcdbd4
leaq 0xb4c50(%rip), %r8      # 0xcdb38
movl $0x10e, %r9d            # imm = 0x10E
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_new_pseudo_template
GtGenomeNode* gt_feature_node_new_pseudo_template(GtFeatureNode *fn)
{
  GtFeatureNode *pf;
  GtGenomeNode *pn;
  GtRange range;
  gt_assert(fn);
  range = feature_node_get_range((GtGenomeNode*) fn),
  pn = gt_feature_node_new_pseudo(feature_node_get_seqid((GtGenomeNode*) fn),
                                  range.start, range.end,
                                  gt_feature_node_get_strand(fn));
  pf = gt_feature_node_cast(pn);
  gt_feature_node_set_source(pf, fn->source);
  return pn;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x18f51
movq %rdi, %rbx
callq 0x18b8f
movq %rax, %r14
movq %rdx, %r15
movq %rbx, %rdi
callq 0x18b83
movl 0x68(%rbx), %ecx
shrl $0x5, %ecx
andl $0x7, %ecx
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x18e5b
movq %rax, %r14
movq %rax, %rdi
callq 0x18df7
movq 0x38(%rbx), %rsi
movq %rax, %rdi
callq 0x188ae
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x115060(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb1104(%rip), %rsi     # 0xca066
leaq 0xc473d(%rip), %rdx     # 0xdd6a6
leaq 0xb4c7f(%rip), %rcx     # 0xcdbef
leaq 0xb4bc1(%rip), %r8      # 0xcdb38
movl $0x11b, %r9d            # imm = 0x11B
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_child
void gt_feature_node_add_child(GtFeatureNode *parent, GtFeatureNode *child)
{
  gt_assert(parent && child);
  /* <parent> and <child> have the same seqid */
  gt_assert(!gt_str_cmp(gt_genome_node_get_seqid((GtGenomeNode*) parent),
                        gt_genome_node_get_seqid((GtGenomeNode*) child)));
  /* pseudo-features have to be top-level */
  gt_assert(!gt_feature_node_is_pseudo((GtFeatureNode*) child));
  /* create children list on demand */
  if (!parent->children)
    parent->children = gt_dlist_new((GtCompare) gt_genome_node_cmp);
  gt_dlist_add(parent->children, child); /* XXX: check for cycles */
  /* update tree status of <parent> */
  set_tree_status(&parent->bit_field, TREE_STATUS_UNDETERMINED);
  /* update parent info of <child> */
  add_parent(&child->bit_field);
  if (parent->observer && parent->observer->child_added)
    parent->observer->child_added(parent, child, parent->observer->data);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1930a
movq %rsi, %rbx
testq %rsi, %rsi
je 0x1930a
movq %rdi, %r14
callq 0x1c31a
movq %rax, %r15
movq %rbx, %rdi
callq 0x1c31a
movq %r15, %rdi
movq %rax, %rsi
callq 0x14573
testl %eax, %eax
jne 0x19338
movq %rbx, %rdi
callq 0x19959
testb %al, %al
jne 0x19366
movq 0x70(%r14), %rdi
testq %rdi, %rdi
jne 0x192b1
leaq 0x2d14(%rip), %rdi      # 0x1bfb9
callq 0x50580
movq %rax, %rdi
movq %rax, 0x70(%r14)
movq %rbx, %rsi
callq 0x5077a
andb $-0x19, 0x68(%r14)
movl 0x68(%rbx), %eax
movl %eax, %ecx
shrl %ecx
andl $0x3, %ecx
je 0x192d3
cmpl $0x1, %ecx
jne 0x192de
pushq $0x4
jmp 0x192d5
pushq $0x2
popq %rcx
andl $-0x7, %eax
orl %ecx, %eax
movl %eax, 0x68(%rbx)
movq 0x80(%r14), %rax
testq %rax, %rax
je 0x19304
movq 0x50(%rax), %rcx
testq %rcx, %rcx
je 0x19304
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 0x114ca7(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb0d4b(%rip), %rsi     # 0xca066
leaq 0xb5110(%rip), %rdx     # 0xce432
leaq 0xb5119(%rip), %rcx     # 0xce442
leaq 0xb4808(%rip), %r8      # 0xcdb38
movl $0x448, %r9d            # imm = 0x448
jmp 0x19392
movq 0x114c79(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb0d1d(%rip), %rsi     # 0xca066
leaq 0xb510c(%rip), %rdx     # 0xce45c
leaq 0xb50eb(%rip), %rcx     # 0xce442
leaq 0xb47da(%rip), %r8      # 0xcdb38
movl $0x44b, %r9d            # imm = 0x44B
jmp 0x19392
movq 0x114c4b(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb0cef(%rip), %rsi     # 0xca066
leaq 0xb7782(%rip), %rdx     # 0xd0b00
leaq 0xb50bd(%rip), %rcx     # 0xce442
leaq 0xb47ac(%rip), %r8      # 0xcdb38
movl $0x44d, %r9d            # imm = 0x44D
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_clone
GtFeatureNode* gt_feature_node_clone(const GtFeatureNode *template)
{
  GtFeatureNode *fn;
  GtStr *seqid;
  const char *type;
  GtUword i, start, end;
  GtStrand strand;
  GtStrArray *attributes;
  gt_assert(template && !gt_feature_node_has_children(template));
  seqid = gt_genome_node_get_seqid((GtGenomeNode*) template);
  type = gt_feature_node_get_type(template);
  start = gt_genome_node_get_start((GtGenomeNode*) template);
  end = gt_genome_node_get_end((GtGenomeNode*) template);
  strand = gt_feature_node_get_strand(template);
  fn = (GtFeatureNode*) gt_feature_node_new(seqid, type, start, end, strand);
  gt_genome_node_set_origin((GtGenomeNode*) fn,
                            template->parent_instance.filename,
                            template->parent_instance.line_number);
  if (gt_feature_node_has_source(template))
    gt_feature_node_set_source(fn, template->source);
  if (gt_feature_node_score_is_defined(template))
    gt_feature_node_set_score(fn, template->score);
  attributes = gt_feature_node_get_attribute_list(template);
  for (i = 0; i < gt_str_array_size(attributes); i++) {
    const char *tag, *value;
    tag = gt_str_array_get(attributes, i);
    value = gt_feature_node_get_attribute(template, tag);
    gt_feature_node_set_attribute(fn, tag, value);
  }
  gt_str_array_delete(attributes);
  return fn;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x19498
movq %rdi, %rbx
callq 0x194d0
testb %al, %al
jne 0x19498
movq %rbx, %rdi
callq 0x1c31a
movq %rax, %r14
movq 0x40(%rbx), %r15
movq %rbx, %rdi
callq 0x1c3bf
movq %rax, %r12
movq %rbx, %rdi
callq 0x1c415
movl 0x68(%rbx), %r8d
shrl $0x5, %r8d
andl $0x7, %r8d
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rax, %rcx
callq 0x18cbb
movq %rax, %r14
movq 0x8(%rbx), %rsi
movl 0x20(%rbx), %edx
movq %rax, %rdi
callq 0x1c17a
movq %rbx, %rdi
callq 0x1956b
testb %al, %al
je 0x19429
movq 0x38(%rbx), %rsi
movq %r14, %rdi
callq 0x188ae
testb $0x20, 0x69(%rbx)
je 0x1943c
movss 0x58(%rbx), %xmm0
movq %r14, %rdi
callq 0x19615
movq %rbx, %rdi
callq 0x18828
movq %rax, %r15
xorl %r12d, %r12d
movq %r15, %rdi
callq 0x157f4
cmpq %rax, %r12
jae 0x19483
movq %r15, %rdi
movq %r12, %rsi
callq 0x1555e
movq %rax, %r13
movq %rbx, %rdi
movq %rax, %rsi
callq 0x18818
movq %r14, %rdi
movq %r13, %rsi
movq %rax, %rdx
callq 0x1967b
incq %r12
jmp 0x1944a
movq %r15, %rdi
callq 0x1583a
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x114b19(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb0bbd(%rip), %rsi     # 0xca066
leaq 0xb477f(%rip), %rdx     # 0xcdc2f
leaq 0xb47ac(%rip), %rcx     # 0xcdc63
leaq 0xb467a(%rip), %r8      # 0xcdb38
movl $0x161, %r9d            # imm = 0x161
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
void gt_feature_node_set_score(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 0x19642
orb $0x20, 0x69(%rdi)
movss %xmm0, 0x58(%rdi)
movq 0x80(%rdi), %rax
testq %rax, %rax
je 0x19641
movq (%rax), %rcx
testq %rcx, %rcx
je 0x19641
cvtss2sd %xmm0, %xmm0
movq 0x60(%rax), %rsi
jmpq *%rcx
retq
pushq %rax
movq 0x11496e(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb0a12(%rip), %rsi     # 0xca066
leaq 0xc404b(%rip), %rdx     # 0xdd6a6
leaq 0xb4a2b(%rip), %rcx     # 0xce08d
leaq 0xb44cf(%rip), %r8      # 0xcdb38
movl $0x281, %r9d            # imm = 0x281
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_attribute
void gt_feature_node_set_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_set(&fn->attributes, attr_name, attr_value);
  if (fn->observer && fn->observer->attribute_changed) {
    fn->observer->attribute_changed(fn, false, attr_name, attr_value,
                                    fn->observer->data);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1971d
movq %rsi, %r14
testq %rsi, %rsi
je 0x1971d
movq %rdx, %rbx
testq %rdx, %rdx
je 0x1971d
cmpb $0x0, (%r14)
je 0x1974b
cmpb $0x0, (%rbx)
je 0x19779
movq %rdi, %r15
leaq 0x60(%rdi), %r12
cmpq $0x0, 0x60(%rdi)
je 0x196d1
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x27410
jmp 0x196e0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x26f28
movq %rax, (%r12)
movq 0x80(%r15), %rcx
testq %rcx, %rcx
je 0x19711
movq 0x28(%rcx), %rax
testq %rax, %rax
je 0x19711
movq 0x60(%rcx), %r8
movq %r15, %rdi
xorl %esi, %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
movq 0x114894(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb0938(%rip), %rsi     # 0xca066
leaq 0xb49aa(%rip), %rdx     # 0xce0df
leaq 0xb4a04(%rip), %rcx     # 0xce140
leaq 0xb43f5(%rip), %r8      # 0xcdb38
movl $0x2af, %r9d            # imm = 0x2AF
jmp 0x197a5
movq 0x114866(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb090a(%rip), %rsi     # 0xca066
leaq 0xb49b8(%rip), %rdx     # 0xce11b
leaq 0xb49d6(%rip), %rcx     # 0xce140
leaq 0xb43c7(%rip), %r8      # 0xcdb38
movl $0x2b0, %r9d            # imm = 0x2B0
jmp 0x197a5
movq 0x114838(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb08dc(%rip), %rsi     # 0xca066
leaq 0xb499c(%rip), %rdx     # 0xce12d
leaq 0xb49a8(%rip), %rcx     # 0xce140
leaq 0xb4399(%rip), %r8      # 0xcdb38
movl $0x2b1, %r9d            # imm = 0x2B1
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_type
void gt_feature_node_set_type(GtFeatureNode *fn, const char *type)
{
  gt_assert(fn && type);
  fn->type = gt_symbol(type);
  if (fn->observer && fn->observer->type_changed)
    fn->observer->type_changed(fn, fn->type, fn->observer->data);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x19843
testq %rsi, %rsi
je 0x19843
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x15a03
movq %rax, 0x40(%rbx)
movq 0x80(%rbx), %rcx
testq %rcx, %rcx
je 0x19841
movq 0x18(%rcx), %r8
testq %r8, %r8
je 0x19841
movq 0x60(%rcx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
jmpq *%r8
popq %rbx
retq
movq 0x11476e(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb0812(%rip), %rsi     # 0xca066
leaq 0xb446d(%rip), %rdx     # 0xcdcc8
leaq 0xb4471(%rip), %rcx     # 0xcdcd3
leaq 0xb42cf(%rip), %r8      # 0xcdb38
movl $0x190, %r9d            # imm = 0x190
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_has_type
bool gt_feature_node_has_type(GtFeatureNode *fn, const char *type)
{
  gt_assert(fn && type);
  if (!fn->type) /* <fn> is pseudo-node */
    return false;
  return gt_strcmp(fn->type, type) ? false : true;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x1989f
testq %rsi, %rsi
je 0x1989f
movq 0x40(%rdi), %rdi
testq %rdi, %rdi
je 0x1989b
callq 0x61bcc
testl %eax, %eax
sete %al
jmp 0x1989d
xorl %eax, %eax
popq %rcx
retq
movq 0x114712(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb07b6(%rip), %rsi     # 0xca066
leaq 0xb4411(%rip), %rdx     # 0xcdcc8
leaq 0xb442e(%rip), %rcx     # 0xcdcec
leaq 0xb4273(%rip), %r8      # 0xcdb38
movl $0x198, %r9d            # imm = 0x198
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_multi
bool gt_feature_node_is_multi(const GtFeatureNode *fn)
{
  gt_assert(fn);
  if ((fn->bit_field >> MULTI_FEATURE_OFFSET) & MULTI_FEATURE_MASK) {
    gt_assert(!((fn->bit_field >> PSEUDO_FEATURE_OFFSET) &
                   PSEUDO_FEATURE_MASK));
    return true;
  }
  return false;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x198f3
movl 0x68(%rdi), %eax
movl %eax, %ecx
notl %ecx
testw $0xc000, %cx            # imm = 0xC000
je 0x19921
shrl $0xe, %eax
andl $0x1, %eax
popq %rcx
retq
movq 0x1146be(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb0762(%rip), %rsi     # 0xca066
leaq 0xc3d9b(%rip), %rdx     # 0xdd6a6
leaq 0xb4414(%rip), %rcx     # 0xcdd26
leaq 0xb421f(%rip), %r8      # 0xcdb38
movl $0x1a8, %r9d            # imm = 0x1A8
jmp 0x1994d
movq 0x114690(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb0734(%rip), %rsi     # 0xca066
leaq 0xb4406(%rip), %rdx     # 0xcdd3f
leaq 0xb43e6(%rip), %rcx     # 0xcdd26
leaq 0xb41f1(%rip), %r8      # 0xcdb38
movl $0x1ab, %r9d            # imm = 0x1AB
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_pseudo
bool gt_feature_node_is_pseudo(const GtFeatureNode *fn)
{
  gt_assert(fn);
  if ((fn->bit_field >> PSEUDO_FEATURE_OFFSET) & PSEUDO_FEATURE_MASK) {
    gt_assert(!((fn->bit_field >> MULTI_FEATURE_OFFSET) & MULTI_FEATURE_MASK));
    return true;
  }
  return false;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x19975
movl 0x68(%rdi), %eax
movl %eax, %ecx
notl %ecx
testw $0xc000, %cx            # imm = 0xC000
je 0x199a3
movzwl %ax, %eax
shrl $0xf, %eax
popq %rcx
retq
movq 0x11463c(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb06e0(%rip), %rsi     # 0xca066
leaq 0xc3d19(%rip), %rdx     # 0xdd6a6
leaq 0xb43ed(%rip), %rcx     # 0xcdd81
leaq 0xb419d(%rip), %r8      # 0xcdb38
movl $0x1b3, %r9d            # imm = 0x1B3
jmp 0x199cf
movq 0x11460e(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb06b2(%rip), %rsi     # 0xca066
leaq 0xb43e0(%rip), %rdx     # 0xcdd9b
leaq 0xb43bf(%rip), %rcx     # 0xcdd81
leaq 0xb416f(%rip), %r8      # 0xcdb38
movl $0x1b5, %r9d            # imm = 0x1B5
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_make_multi_representative
void gt_feature_node_make_multi_representative(GtFeatureNode *fn)
{
  gt_assert(fn);
  feature_node_set_multi(fn);
  if (fn->observer && fn->observer->multi_changed) {
    fn->observer->multi_changed(fn, gt_feature_node_is_multi(fn),
                                fn->representative, fn->observer->data);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x19a34
movq %rdi, %rbx
orb $0x40, 0x69(%rdi)
movq 0x80(%rdi), %rax
testq %rax, %rax
je 0x19a2c
movq 0x40(%rax), %rax
testq %rax, %rax
je 0x19a2c
movq %rbx, %rdi
movq %rax, %r14
callq 0x198d7
movq 0x78(%rbx), %rdx
movq 0x80(%rbx), %rcx
movq 0x60(%rcx), %rcx
movzbl %al, %esi
movq %rbx, %rdi
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x11457d(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb0621(%rip), %rsi     # 0xca066
leaq 0xc3c5a(%rip), %rdx     # 0xdd6a6
leaq 0xb4388(%rip), %rcx     # 0xcdddb
leaq 0xb40de(%rip), %r8      # 0xcdb38
movl $0x1c3, %r9d            # imm = 0x1C3
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_multi_representative
void gt_feature_node_set_multi_representative(GtFeatureNode *fn,
                                              GtFeatureNode *rep)
{
  gt_assert(fn);
  gt_assert(rep && gt_feature_node_is_multi(rep));
  feature_node_set_multi(fn);
  fn->representative = rep;
  if (fn->observer && fn->observer->multi_changed) {
    fn->observer->multi_changed(fn, gt_feature_node_is_multi(fn),
                                fn->representative, fn->observer->data);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x19b0f
movq %rsi, %r14
testq %rsi, %rsi
je 0x19ae1
movq %rdi, %rbx
movq %r14, %rdi
callq 0x198d7
testb %al, %al
je 0x19ae1
orb $0x40, 0x69(%rbx)
movq %r14, 0x78(%rbx)
movq 0x80(%rbx), %rax
testq %rax, %rax
je 0x19ad9
movq 0x40(%rax), %rax
testq %rax, %rax
je 0x19ad9
movq %rbx, %rdi
movq %rax, %r14
callq 0x198d7
movq 0x78(%rbx), %rdx
movq 0x80(%rbx), %rcx
movq 0x60(%rcx), %rcx
movzbl %al, %esi
movq %rbx, %rdi
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x1144d0(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb0574(%rip), %rsi     # 0xca066
leaq 0xb4335(%rip), %rdx     # 0xcde2e
leaq 0xb4305(%rip), %rcx     # 0xcde05
leaq 0xb4031(%rip), %r8      # 0xcdb38
movl $0x1cf, %r9d            # imm = 0x1CF
jmp 0x19b3b
movq 0x1144a2(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb0546(%rip), %rsi     # 0xca066
leaq 0xc3b7f(%rip), %rdx     # 0xdd6a6
leaq 0xb42d7(%rip), %rcx     # 0xcde05
leaq 0xb4003(%rip), %r8      # 0xcdb38
movl $0x1ce, %r9d            # imm = 0x1CE
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_get_multi_representative
GtFeatureNode* gt_feature_node_get_multi_representative(GtFeatureNode *fn)
{
  gt_assert(fn && gt_feature_node_is_multi(fn) &&
            !gt_feature_node_is_pseudo(fn));
  if (fn->representative) {
    gt_assert(gt_feature_node_is_multi(fn->representative));
    return fn->representative;
  }
  return fn; /* is itself the representative */
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x19bc8
movq %rdi, %rbx
callq 0x198d7
testb %al, %al
je 0x19bc8
movq %rbx, %rdi
callq 0x19959
testb %al, %al
jne 0x19bc8
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0x19bc3
callq 0x198d7
testb %al, %al
je 0x19c00
movq 0x78(%rbx), %rbx
movq %rbx, %rax
popq %rbx
retq
movq 0x1143e9(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb048d(%rip), %rsi     # 0xca066
leaq 0xb428f(%rip), %rdx     # 0xcde6f
leaq 0xb42cd(%rip), %rcx     # 0xcdeb4
leaq 0xb3f4a(%rip), %r8      # 0xcdb38
movl $0x1e2, %r9d            # imm = 0x1E2
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
movq 0x1143b1(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb0455(%rip), %rsi     # 0xca066
leaq 0xb42c5(%rip), %rdx     # 0xcdedd
leaq 0xb4295(%rip), %rcx     # 0xcdeb4
leaq 0xb3f12(%rip), %r8      # 0xcdb38
movl $0x1e4, %r9d            # imm = 0x1E4
jmp 0x19bf4
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/feature_node.c
// Function: gt_feature_node_set_strand
void gt_feature_node_set_strand(GtFeatureNode *fn, GtStrand strand)
{
  gt_assert(fn);
  fn->bit_field &= ~(STRAND_MASK << STRAND_OFFSET);
  fn->bit_field |= strand << STRAND_OFFSET;
  if (fn->observer && fn->observer->strand_changed)
    fn->observer->strand_changed(fn, strand, fn->observer->data);
}

// Assembly:
testq %rdi, %rdi
je 0x19d57
movl $0xffffff1f, %eax       # imm = 0xFFFFFF1F
andl 0x68(%rdi), %eax
movl %esi, %ecx
shll $0x5, %ecx
orl %eax, %ecx
movl %ecx, 0x68(%rdi)
movq 0x80(%rdi), %rax
testq %rax, %rax
je 0x19d56
movq 0x10(%rax), %rcx
testq %rcx, %rcx
je 0x19d56
movq 0x60(%rax), %rdx
jmpq *%rcx
retq
pushq %rax
movq 0x114259(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb02fd(%rip), %rsi     # 0xca066
leaq 0xc3936(%rip), %rdx     # 0xdd6a6
leaq 0xb4209(%rip), %rcx     # 0xcdf80
leaq 0xb3dba(%rip), %r8      # 0xcdb38
movl $0x200, %r9d            # imm = 0x200
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_get_exons
void gt_feature_node_get_exons(GtFeatureNode *fn, GtArray *exon_features)
{
  GT_UNUSED int had_err;
  gt_assert(fn && exon_features && !gt_array_size(exon_features));
  had_err = gt_feature_node_traverse_children(fn, exon_features,
                                              feature_node_save_exon, false,
                                              NULL);
  gt_assert(!had_err); /* feature_node_save_exon() is sane */
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x19e1c
movq %rsi, %rbx
testq %rsi, %rsi
je 0x19e1c
movq %rdi, %r14
movq %rbx, %rdi
callq 0x4b988
testq %rax, %rax
jne 0x19e1c
leaq 0x35d(%rip), %rdx       # 0x1a15d
movq %r14, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x19e82
testl %eax, %eax
jne 0x19e4a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x114195(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb0239(%rip), %rsi     # 0xca066
leaq 0xb4181(%rip), %rdx     # 0xcdfb5
leaq 0xb41af(%rip), %rcx     # 0xcdfea
leaq 0xb3cf6(%rip), %r8      # 0xcdb38
movl $0x21c, %r9d            # imm = 0x21C
jmp 0x19e76
movq 0x114167(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xb020b(%rip), %rsi     # 0xca066
leaq 0xb07b1(%rip), %rdx     # 0xca613
leaq 0xb4181(%rip), %rcx     # 0xcdfea
leaq 0xb3cc8(%rip), %r8      # 0xcdb38
movl $0x220, %r9d            # imm = 0x220
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_save_exon
static int feature_node_save_exon(GtFeatureNode *fn, void *data,
                                  GT_UNUSED GtError *err)
{
  GtArray *exon_features = (GtArray*) data;
  gt_error_check(err);
  gt_assert(fn && exon_features);
  if (gt_feature_node_has_type(fn, gt_ft_exon)) {
    gt_array_add(exon_features, fn);
  }
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rdi, (%rsp)
testq %rdx, %rdx
je 0x1a17c
movq %rdx, %rdi
callq 0xc103
testb %al, %al
jne 0x1a1df
testq %rbx, %rbx
je 0x1a1b1
testq %r14, %r14
je 0x1a1b1
leaq 0xcba91(%rip), %rsi     # 0xe5c1e
movq %r14, %rdi
callq 0x1987b
testb %al, %al
je 0x1a1a7
movq %rsp, %rsi
pushq $0x8
popq %rdx
movq %rbx, %rdi
callq 0x4b801
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x113e00(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xafea4(%rip), %rsi     # 0xca066
leaq 0xb4592(%rip), %rdx     # 0xce75b
leaq 0xb4574(%rip), %rcx     # 0xce744
leaq 0xb3961(%rip), %r8      # 0xcdb38
movl $0x212, %r9d            # imm = 0x212
jmp 0x1a20b
movq 0x113dd2(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xafe76(%rip), %rsi     # 0xca066
leaq 0xb0462(%rip), %rdx     # 0xca659
leaq 0xb4546(%rip), %rcx     # 0xce744
leaq 0xb3933(%rip), %r8      # 0xcdb38
movl $0x211, %r9d            # imm = 0x211
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_determine_transcripttypes
void gt_feature_node_determine_transcripttypes(GtFeatureNode *fn)
{
  SaveExonAndCDSInfo info;
  GT_UNUSED int had_err;
  gt_assert(fn);
  info.exon_features = gt_array_new(sizeof (GtFeatureNode*));
  info.cds_features = gt_array_new(sizeof (GtFeatureNode*));
  had_err = gt_feature_node_traverse_children(fn, &info,
                                              determine_transcripttypes, false,
                                              NULL);
  gt_assert(!had_err); /* cannot happen, because determine_transcripttypes() is
                          sane */
  gt_array_delete(info.exon_features);
  gt_array_delete(info.cds_features);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x1a27e
movq %rdi, %rbx
pushq $0x8
popq %r14
movq %r14, %rdi
callq 0x4b380
movq %rsp, %r15
movq %rax, (%r15)
movq %r14, %rdi
callq 0x4b380
movq %rax, 0x8(%r15)
leaq 0x97(%rip), %rdx        # 0x1a2e4
movq %rbx, %rdi
movq %r15, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x19e82
testl %eax, %eax
jne 0x1a2ac
movq (%rsp), %rdi
callq 0x4c19d
movq 0x8(%rsp), %rdi
callq 0x4c19d
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x113d33(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xafdd7(%rip), %rsi     # 0xca066
leaq 0xc3410(%rip), %rdx     # 0xdd6a6
leaq 0xb3d67(%rip), %rcx     # 0xce004
leaq 0xb3894(%rip), %r8      # 0xcdb38
movl $0x263, %r9d            # imm = 0x263
jmp 0x1a2d8
movq 0x113d05(%rip), %rax    # 0x12dfb8
movq (%rax), %rdi
leaq 0xafda9(%rip), %rsi     # 0xca066
leaq 0xb034f(%rip), %rdx     # 0xca613
leaq 0xb3d39(%rip), %rcx     # 0xce004
leaq 0xb3866(%rip), %r8      # 0xcdb38
movl $0x269, %r9d            # imm = 0x269
xorl %eax, %eax
callq 0xb8c0
callq 0xb300