LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/feature_index_memory.c
// Function: gt_feature_index_memory_class
const GtFeatureIndexClass* gt_feature_index_memory_class(void)
{
  static const GtFeatureIndexClass *fic = NULL;
  gt_class_alloc_lock_enter();
  if (!fic) {
    fic = gt_feature_index_class_new(sizeof (GtFeatureIndexMemory),
                     gt_feature_index_memory_add_region_node,
                     gt_feature_index_memory_add_feature_node,
                     gt_feature_index_memory_remove_node,
                     gt_feature_index_memory_get_features_for_seqid,
                     gt_feature_index_memory_get_features_for_range,
                     gt_feature_index_memory_get_first_seqid,
                     NULL,
                     gt_feature_index_memory_get_seqids,
                     gt_feature_index_memory_get_range_for_seqid,
                     gt_feature_index_memory_get_orig_range_for_seqid,
                     gt_feature_index_memory_has_seqid,
                     gt_feature_index_memory_delete);
  }
  gt_class_alloc_lock_leave();
  return fic;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
callq 0x71d9b
cmpq $0x0, 0x113c13(%rip)    # 0x152b28
jne 0x3ef89
subq $0x8, %rsp
leaq 0x643(%rip), %rax       # 0x3f565
leaq 0x5fa(%rip), %r10       # 0x3f523
leaq 0x58e(%rip), %r11       # 0x3f4be
leaq 0x50c(%rip), %rbx       # 0x3f443
leaq 0x45f(%rip), %r14       # 0x3f39d
leaq 0x427(%rip), %r15       # 0x3f36c
leaq -0x124(%rip), %rsi      # 0x3ee28
leaq 0x48(%rip), %rdx        # 0x3ef9b
leaq 0x180(%rip), %rcx       # 0x3f0da
leaq 0x268(%rip), %r8        # 0x3f1c9
leaq 0x2fa(%rip), %r9        # 0x3f262
movl $0x48, %edi
pushq %rax
pushq %r10
pushq %r11
pushq %rbx
pushq %r14
pushq $0x0
pushq %r15
callq 0x3df0c
addq $0x40, %rsp
movq %rax, 0x113b9f(%rip)    # 0x152b28
callq 0x71db1
movq 0x113b93(%rip), %rax    # 0x152b28
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/feature_index_memory.c
// Function: gt_feature_index_memory_remove_node
int gt_feature_index_memory_remove_node(GtFeatureIndex *gfi,
                                        GtFeatureNode *gn,
                                        GT_UNUSED GtError *err)
{
  char* seqid;
  GtFeatureIndexMemory *fi;
  GtRange node_range;
  GtFeatureIndexMemoryByPtrExtractInfo info;
  RegionInfo *rinfo;
  gt_assert(gfi && gn);

  fi = gt_feature_index_memory_cast(gfi);
  node_range = gt_genome_node_get_range((GtGenomeNode*) gn);
  if (!gt_hashmap_get(fi->nodes_in_index, gn))
    return 0;
  seqid = gt_str_get(gt_genome_node_get_seqid((GtGenomeNode*) gn));
  rinfo = (RegionInfo*) gt_hashmap_get(fi->regions, seqid);
  if (!rinfo)
    return 0;
  info.genome_node = (GtGenomeNode*) gn;
  info.node = NULL;

  gt_interval_tree_iterate_overlapping(rinfo->features,
                                   gt_feature_index_memory_get_itreenode_by_ptr,
                                   node_range.start,
                                   node_range.end,
                                   &info);

  if (info.node)
    gt_interval_tree_remove(rinfo->features, info.node);
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x3f1a0
movq %rsi, %rbx
testq %rsi, %rsi
je 0x3f1a0
movq %rdi, %r14
callq 0x3ef03
movq %rax, %rdi
movq %r14, %rsi
callq 0x3e678
movq %rax, %r12
movq %rbx, %rdi
callq 0x41f83
movq %rax, %r14
movq %rdx, %r15
movq 0x18(%r12), %rdi
movq %rbx, %rsi
callq 0x77109
testq %rax, %rax
je 0x3f190
movq %rbx, %rdi
callq 0x41f3f
movq %rax, %rdi
callq 0x3c40b
movq 0x10(%r12), %rdi
movq %rax, %rsi
callq 0x77109
testq %rax, %rax
je 0x3f190
movq %rax, %r12
movq %rsp, %r13
movq %rbx, 0x8(%r13)
movq $0x0, (%r13)
movq (%rax), %rdi
leaq 0x35(%rip), %rsi        # 0x3f1a5
movq %r14, %rdx
movq %r15, %rcx
movq %r13, %r8
callq 0x79024
movq (%r13), %rsi
testq %rsi, %rsi
je 0x3f190
movq (%r12), %rdi
callq 0x79271
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0xf294
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/feature_index_memory.c
// Function: gt_feature_index_memory_get_features_for_seqid
GtArray* gt_feature_index_memory_get_features_for_seqid(GtFeatureIndex *gfi,
                                                        const char *seqid,
                                                        GT_UNUSED GtError *err)
{
  RegionInfo *ri;
  GT_UNUSED int had_err = 0;
  GtArray *a;
  GtFeatureIndexMemory *fi;
  gt_assert(gfi && seqid);
  fi = gt_feature_index_memory_cast(gfi);
  a = gt_array_new(sizeof (GtFeatureNode*));
  ri = (RegionInfo*) gt_hashmap_get(fi->regions, seqid);
  if (ri) {
    had_err = gt_interval_tree_traverse(ri->features,
                                        collect_features_from_itree,
                                        a);
  }
  gt_assert(!had_err);   /* collect_features_from_itree() is sane */
  return a;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x3f22e
movq %rsi, %rbx
testq %rsi, %rsi
je 0x3f22e
movq %rdi, %r14
callq 0x3ef03
movq %rax, %rdi
movq %r14, %rsi
callq 0x3e678
movq %rax, %r15
movl $0x8, %edi
callq 0x6e93c
movq %rax, %r14
movq 0x10(%r15), %rdi
movq %rbx, %rsi
callq 0x77109
testq %rax, %rax
je 0x3f225
movq (%rax), %rdi
leaq 0x1f(%rip), %rsi        # 0x3f238
movq %r14, %rdx
callq 0x78eec
testl %eax, %eax
jne 0x3f233
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0xf2cd
callq 0xf306
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/feature_index_memory.c
// Function: collect_features_from_itree
static int collect_features_from_itree(GtIntervalTreeNode *node, void *data)
{
  GtArray *a = (GtArray*) data;
  GtGenomeNode *gn = (GtGenomeNode*) gt_interval_tree_node_get_data(node);
  gt_array_add(a, gn);
  return 0;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
callq 0x78e63
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movl $0x8, %edx
movq %rbx, %rdi
callq 0x6ec0e
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/feature_index_memory.c
// Function: gt_feature_index_memory_get_features_for_range
int gt_feature_index_memory_get_features_for_range(GtFeatureIndex *gfi,
                                                   GtArray *results,
                                                   const char *seqid,
                                                   const GtRange *qry_range,
                                                   GtError *err)
{
  RegionInfo *ri;
  GtFeatureIndexMemory *fi;
  gt_error_check(err);
  gt_assert(gfi && results);

  fi = gt_feature_index_memory_cast(gfi);
  ri = (RegionInfo*) gt_hashmap_get(fi->regions, seqid);
  if (!ri) {
    gt_error_set(err, "feature index does not contain the given sequence id");
    return -1;
  }
  gt_interval_tree_find_all_overlapping(ri->features, qry_range->start,
                                        qry_range->end, results);
  gt_array_sort(results, gt_genome_node_cmp_range_start);
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r13
testq %r8, %r8
je 0x3f28b
movq %r14, %rdi
callq 0x3566a
testb %al, %al
jne 0x3f300
testq %r13, %r13
je 0x3f2fb
testq %rbx, %rbx
je 0x3f2fb
callq 0x3ef03
movq %rax, %rdi
movq %r13, %rsi
callq 0x3e678
movq 0x10(%rax), %rdi
movq %r12, %rsi
callq 0x77109
testq %rax, %rax
je 0x3f2db
movq (%rax), %rdi
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rcx
callq 0x78f5f
leaq 0x36(%rip), %rsi        # 0x3f305
movq %rbx, %rdi
callq 0x6ed27
xorl %eax, %eax
jmp 0x3f2f1
leaq 0xa5629(%rip), %rsi     # 0xe490b
movq %r14, %rdi
xorl %eax, %eax
callq 0x3559f
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0xf378
callq 0xf33f
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/feature_index_memory.c
// Function: gt_feature_index_memory_get_node_by_ptr
GtFeatureNode*  gt_feature_index_memory_get_node_by_ptr(GtFeatureIndexMemory
                                                                          *fim,
                                                        GtFeatureNode *ptr,
                                                        GtError *err)
{
  GtFeatureNode *retnode;
  gt_assert(fim);

  if (!(retnode = gt_hashmap_get(fim->nodes_in_index, ptr))) {
    gt_error_set(err, "feature index does not contain a node with address %p",
                 ptr);
  }
  return retnode;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x3f367
movq %rdx, %r14
movq %rsi, %rbx
movq 0x18(%rdi), %rdi
callq 0x77109
movq %rax, %r15
testq %rax, %rax
jne 0x3f35e
leaq 0xa561b(%rip), %rsi     # 0xe496c
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x3559f
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0xf3b1
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/feature_index_memory.c
// Function: gt_feature_index_memory_get_first_seqid
char* gt_feature_index_memory_get_first_seqid(const GtFeatureIndex *gfi,
                                              GT_UNUSED GtError *err)
{
  GtFeatureIndexMemory *fi;
  gt_assert(gfi);

  fi = gt_feature_index_memory_cast((GtFeatureIndex*) gfi);
  return fi->firstseqid ? gt_cstr_dup(fi->firstseqid) : NULL;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x3f398
movq %rdi, %rbx
callq 0x3ef03
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3e678
movq 0x28(%rax), %rdi
testq %rdi, %rdi
je 0x3f394
popq %rbx
jmp 0x722dc
xorl %eax, %eax
popq %rbx
retq
callq 0xf3ea
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/extended/feature_index_memory.c
// Function: gt_feature_index_memory_get_seqids
GtStrArray* gt_feature_index_memory_get_seqids(const GtFeatureIndex *gfi,
                                               GT_UNUSED GtError *err)
{
  GtCstrTable* seqids;
  GtStrArray *ret;
  GT_UNUSED int rval;
  GtFeatureIndexMemory *fi;
  gt_assert(gfi);

  fi = gt_feature_index_memory_cast((GtFeatureIndex*) gfi);
  seqids = gt_cstr_table_new();
  rval = gt_hashmap_foreach_in_key_order(fi->regions, store_seqid, seqids,
                                         NULL);
  gt_assert(!rval); /* store_seqid() is sane */
  ret = gt_cstr_table_get_all(seqids);
  gt_cstr_table_delete(seqids);
  return ret;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3f3fb
movq %rdi, %rbx
callq 0x3ef03
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3e678
movq %rax, %r14
callq 0x72918
movq %rax, %rbx
movq 0x10(%r14), %rdi
leaq 0x36(%rip), %rsi        # 0x3f405
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x7721f
testl %eax, %eax
jne 0x3f400
movq %rbx, %rdi
callq 0x72a0a
movq %rax, %r14
movq %rbx, %rdi
callq 0x72c9c
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0xf45c
callq 0xf423
// File: /workspace/github_c_makefile_star2_O1/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 0x3f43e
movq %rdx, %r14
testq %rdx, %rdx
je 0x3f43e
movq %rdi, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x729dd
testq %rax, %rax
jne 0x3f434
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7297e
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0xf495
// File: /workspace/github_c_makefile_star2_O1/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 0x3f4b4
movq %rsi, %rbx
testq %rsi, %rsi
je 0x3f4b4
movq %rdx, %r14
testq %rdx, %rdx
je 0x3f4b4
movq %rdi, %r15
callq 0x3ef03
movq %rax, %rdi
movq %r15, %rsi
callq 0x3e678
movq 0x10(%rax), %rdi
movq %r14, %rsi
callq 0x77109
testq %rax, %rax
je 0x3f4b9
movq %rax, %rcx
movq 0x10(%rax), %rax
cmpq $-0x1, %rax
je 0x3f497
movq 0x18(%rcx), %rdx
testq %rdx, %rdx
jne 0x3f4a5
movq 0x8(%rcx), %rdi
testq %rdi, %rdi
je 0x3f4ac
callq 0x41f83
movq %rax, (%rbx)
movq %rdx, 0x8(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0xf4ce
callq 0xf507
// File: /workspace/github_c_makefile_star2_O1/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 0x3f519
movq %rsi, %rbx
testq %rsi, %rsi
je 0x3f519
movq %rdx, %r14
testq %rdx, %rdx
je 0x3f519
movq %rdi, %r15
callq 0x3ef03
movq %rax, %rdi
movq %r15, %rsi
callq 0x3e678
movq 0x10(%rax), %rdi
movq %r14, %rsi
callq 0x77109
testq %rax, %rax
je 0x3f51e
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0x3f511
callq 0x41f83
movq %rax, (%rbx)
movq %rdx, 0x8(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0xf540
callq 0xf579
// File: /workspace/github_c_makefile_star2_O1/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 0x3f560
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
callq 0x3ef03
movq %rax, %rdi
movq %r15, %rsi
callq 0x3e678
movq 0x10(%rax), %rdi
movq %r14, %rsi
callq 0x77109
testq %rax, %rax
setne (%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0xf5b2
// File: /workspace/github_c_makefile_star2_O1/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 0x3f594
pushq %rbx
movq %rdi, %rbx
callq 0x3ef03
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3e678
movq %rax, %rbx
movq 0x10(%rax), %rdi
callq 0x77675
movq 0x18(%rbx), %rdi
popq %rbx
jmp 0x77675
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3ef03
movq %rax, %rdi
callq 0x3df7d
movq %rax, %rbx
callq 0x3ef03
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3e678
movq %rax, %r14
movq $0x0, 0x40(%rax)
leaq 0x2a(%rip), %rdx        # 0x3f5f5
movl $0x1, %edi
xorl %esi, %esi
callq 0x76f28
movq %rax, 0x10(%r14)
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x76f28
movq %rax, 0x18(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x791e5
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x3f60f
callq 0x42ade
leaq 0xa51f6(%rip), %rsi     # 0xe480c
movq %rbx, %rdi
movl $0x40, %edx
popq %rbx
jmp 0x362a0
// File: /workspace/github_c_makefile_star2_O1/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 0x3d23c
movq %rax, %rbx
movq 0x60(%r14), %rdi
testq %rdi, %rdi
je 0x3f887
leaq 0x13(%rip), %rsi        # 0x3f892
movq %rbx, %rdx
callq 0x4ab01
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x3f913
movq %rsi, %rbx
testq %rsi, %rsi
je 0x3f913
movq %rdi, %r14
movq 0x38(%rdi), %rdi
testq %rdi, %rdi
je 0x3f8d7
callq 0x3d1eb
movq %rbx, %rdi
callq 0x3c561
movq %rax, 0x38(%r14)
movq 0x80(%r14), %rax
testq %rax, %rax
je 0x3f90b
movq 0x20(%rax), %rcx
testq %rcx, %rcx
je 0x3f90b
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
callq 0xf65b
// File: /workspace/github_c_makefile_star2_O1/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 0x3f94b
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 0x3f94a
movq 0x8(%rax), %rcx
testq %rcx, %rcx
je 0x3f94a
movq 0x60(%rax), %rdx
jmpq *%rcx
retq
pushq %rax
callq 0xf694
// File: /workspace/github_c_makefile_star2_O1/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 0x3f98d
movq %rsi, %r14
testq %rsi, %rsi
je 0x3f98d
movq %rdi, %rbx
movq 0x80(%rdi), %rdi
testq %rdi, %rdi
je 0x3f976
callq 0x41af2
movq %r14, %rdi
callq 0x41adf
movq %rax, 0x80(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0xf6cd
// File: /workspace/github_c_makefile_star2_O1/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 0x3f9b9
movq %rdi, %rbx
movq 0x80(%rdi), %rdi
testq %rdi, %rdi
je 0x3f9ac
callq 0x41af2
movq $0x0, 0x80(%rbx)
popq %rbx
retq
callq 0xf706
// File: /workspace/github_c_makefile_star2_O1/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 0x71d9b
cmpq $0x0, 0x113164(%rip)    # 0x152b30
jne 0x3fa13
leaq 0x1d4(%rip), %rax       # 0x3fba9
leaq 0x184(%rip), %r10       # 0x3fb60
leaq 0x3e(%rip), %rsi        # 0x3fa21
leaq 0xe5(%rip), %rcx        # 0x3facf
leaq 0xf8(%rip), %r8         # 0x3fae9
leaq 0x112(%rip), %r9        # 0x3fb0a
movl $0x88, %edi
movq %rcx, %rdx
pushq %rax
pushq %r10
callq 0x41cc8
addq $0x10, %rsp
movq %rax, 0x11311d(%rip)    # 0x152b30
callq 0x71db1
movq 0x113111(%rip), %rax    # 0x152b30
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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
movq %rdi, %rbx
callq 0x3f9be
movq %rax, %rdi
movq %rbx, %rsi
callq 0x41edd
movq %rax, %rbx
movq 0x30(%rax), %rdi
callq 0x3d1eb
movq 0x38(%rbx), %rdi
callq 0x3d1eb
movq 0x60(%rbx), %rdi
callq 0x4acc1
movq 0x70(%rbx), %rdi
testq %rdi, %rdi
je 0x3fa8c
callq 0x72d30
testq %rax, %rax
je 0x3fa8c
movq %rax, %r14
movq %r14, %rdi
callq 0x72dac
movq %rax, %rdi
callq 0x42ade
movq %r14, %rdi
callq 0x72dbc
movq %rax, %r14
testq %rax, %rax
jne 0x3fa6c
movq 0x70(%rbx), %rdi
callq 0x73029
movq 0x80(%rbx), %rax
testq %rax, %rax
je 0x3fab3
movq 0x58(%rax), %rcx
testq %rcx, %rcx
je 0x3fab3
movq 0x60(%rax), %rsi
movq %rbx, %rdi
callq *%rcx
movq 0x80(%rbx), %rdi
addq $0x8, %rsp
testq %rdi, %rdi
je 0x3facb
popq %rbx
popq %r14
jmp 0x41af2
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x3f9be
movq %rax, %rdi
movq %r14, %rsi
callq 0x41edd
movups (%rbx), %xmm0
movups %xmm0, 0x48(%rax)
movq 0x80(%rax), %rcx
testq %rcx, %rcx
je 0x3fb58
movq 0x38(%rcx), %r8
testq %r8, %r8
je 0x3fb58
movq %rax, %rsi
addq $0x48, %rsi
movq 0x60(%rcx), %rdx
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *%r8
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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
movq %rdi, %r14
callq 0x3f9be
movq %rax, %rdi
movq %r14, %rsi
callq 0x41edd
testq %rbx, %rbx
je 0x3fba4
movq %rax, %r14
testq %rax, %rax
je 0x3fba4
movq 0x30(%r14), %rdi
callq 0x3d1eb
movq %rbx, %rdi
callq 0x3c561
movq %rax, 0x30(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0xf73f
// File: /workspace/github_c_makefile_star2_O1/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 0x3fbc8
movq %rbx, %rdi
callq 0x3566a
testb %al, %al
jne 0x3fbeb
callq 0x3f9be
movq %rax, %rdi
movq %r15, %rsi
callq 0x41edd
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x49c92
callq 0xf778
// File: /workspace/github_c_makefile_star2_O1/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 0x3fccf
movq %rsi, %r13
testq %rsi, %rsi
je 0x3fccf
movq %rcx, %r15
movq %rdx, %r12
cmpq %rcx, %rdx
ja 0x3fcd4
movl %r8d, %ebx
movq %rdi, %r14
callq 0x3f9be
movq %rax, %rdi
callq 0x41e44
movq %rax, %rbp
movq %rax, (%rsp)
callq 0x3f9be
movq %rax, %rdi
movq %rbp, %rsi
callq 0x41edd
movq %rax, %rbp
movq %r14, %rdi
callq 0x3c561
movq %rax, 0x30(%rbp)
xorl %r14d, %r14d
movq %r14, 0x38(%rbp)
movq %r13, %rdi
callq 0x3d6af
movq %rax, 0x40(%rbp)
movl $0x7f7fffff, 0x58(%rbp) # imm = 0x7F7FFFFF
movq %r12, 0x48(%rbp)
movq %r15, 0x50(%rbp)
movq %r14, 0x60(%rbp)
shll $0x5, %ebx
movl %ebx, 0x68(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, 0x70(%rbp)
movq %r14, 0x80(%rbp)
movq %rbp, %rdi
movl $0x3, %esi
callq 0x3f918
movq %rbp, %rdi
movl $0x4, %esi
callq 0x3fcee
movl 0x68(%rbp), %eax
andl $-0x19, %eax
orl $0x8, %eax
movl %eax, 0x68(%rbp)
movq %r14, 0x78(%rbp)
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0xf7b1
callq 0xf7ea
// File: /workspace/github_c_makefile_star2_O1/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 0x3fd04
movl $0xffffe3ff, %eax       # imm = 0xFFFFE3FF
andl 0x68(%rdi), %eax
shll $0xa, %esi
orl %eax, %esi
movl %esi, 0x68(%rdi)
retq
pushq %rax
callq 0xf823
// File: /workspace/github_c_makefile_star2_O1/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 0x3fd4e
movl %ecx, %r8d
movq %rdx, %rcx
movq %rsi, %rdx
cmpq %rcx, %rsi
ja 0x3fd53
leaq 0xa508f(%rip), %rsi     # 0xe4db4
callq 0x3fbf0
movq %rax, %rbx
callq 0x3f9be
movq %rax, %rdi
movq %rbx, %rsi
callq 0x41edd
movq $0x0, 0x40(%rax)
orb $-0x80, 0x69(%rax)
movq %rbx, %rax
popq %rbx
retq
callq 0xf895
callq 0xf85c
// File: /workspace/github_c_makefile_star2_O1/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 0x3fdcd
movq %rdi, %rbx
callq 0x3f9be
movq %rax, %rdi
movq %rbx, %rsi
callq 0x41edd
movq 0x48(%rax), %r14
movq 0x50(%rax), %r15
callq 0x3f9be
movq %rax, %rdi
movq %rbx, %rsi
callq 0x41edd
movq 0x30(%rax), %rdi
movl 0x68(%rbx), %ecx
shrl $0x5, %ecx
andl $0x7, %ecx
movq %r14, %rsi
movq %r15, %rdx
callq 0x3fd0a
movq %rax, %r14
callq 0x3f9be
movq %rax, %rdi
movq %r14, %rsi
callq 0x41edd
movq 0x38(%rbx), %rsi
movq %rax, %rdi
callq 0x3f8b5
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0xf8ce
// File: /workspace/github_c_makefile_star2_O1/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 0x40124
movq %rsi, %rbx
testq %rsi, %rsi
je 0x40124
movq %rdi, %r14
callq 0x41f3f
movq %rax, %r15
movq %rbx, %rdi
callq 0x41f3f
movq %r15, %rdi
movq %rax, %rsi
callq 0x3c4b0
testl %eax, %eax
jne 0x40129
movq %rbx, %rdi
callq 0x40459
testb %al, %al
jne 0x4012e
cmpq $0x0, 0x70(%r14)
jne 0x400c2
leaq 0x1c78(%rip), %rdi      # 0x41d31
callq 0x72cc4
movq %rax, 0x70(%r14)
movq 0x70(%r14), %rdi
movq %rbx, %rsi
callq 0x72dd9
andb $-0x19, 0x68(%r14)
movl 0x68(%rbx), %eax
movl %eax, %ecx
shrl %ecx
andl $0x3, %ecx
je 0x400eb
cmpl $0x1, %ecx
jne 0x400f8
movl $0x4, %ecx
jmp 0x400f0
movl $0x2, %ecx
andl $-0x7, %eax
orl %ecx, %eax
movl %eax, 0x68(%rbx)
movq 0x80(%r14), %rax
testq %rax, %rax
je 0x4011e
movq 0x50(%rax), %rcx
testq %rcx, %rcx
je 0x4011e
movq 0x60(%rax), %rdx
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmpq *%rcx
popq %rbx
popq %r14
popq %r15
retq
callq 0xf940
callq 0xf979
callq 0xf9b2
// File: /workspace/github_c_makefile_star2_O1/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 0x4024c
movq %rdi, %rbx
movq 0x70(%rdi), %rdi
testq %rdi, %rdi
je 0x4015f
callq 0x72dcc
testq %rax, %rax
jne 0x4024c
movq %rbx, %rdi
callq 0x41f3f
movq %rax, %r14
movq 0x40(%rbx), %r15
movq %rbx, %rdi
callq 0x41f7e
movq %rax, %r12
movq %rbx, %rdi
callq 0x41fa1
movl 0x68(%rbx), %r8d
shrl $0x5, %r8d
andl $0x7, %r8d
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rax, %rcx
callq 0x3fbf0
movq %rax, %r14
movq 0x8(%rbx), %rsi
movl 0x20(%rbx), %edx
movq %rax, %rdi
callq 0x41e9e
movq %rbx, %rdi
callq 0x40286
testb %al, %al
je 0x401c8
movq 0x38(%rbx), %rsi
movq %r14, %rdi
callq 0x3f8b5
testb $0x20, 0x69(%rbx)
je 0x401db
movss 0x58(%rbx), %xmm0
movq %r14, %rdi
callq 0x402cd
movq %rbx, %rdi
callq 0x3f860
movq %rax, %r15
movq %rax, %rdi
callq 0x3d560
testq %rax, %rax
je 0x40237
xorl %r12d, %r12d
movq %r15, %rdi
movq %r12, %rsi
callq 0x3d3e2
movq %rax, %r13
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x4021a
movq %r13, %rsi
callq 0x4aab6
movq %rax, %rdx
jmp 0x4021c
xorl %edx, %edx
movq %r14, %rdi
movq %r13, %rsi
callq 0x40300
incq %r12
movq %r15, %rdi
callq 0x3d560
cmpq %rax, %r12
jb 0x401f6
movq %r15, %rdi
callq 0x3d573
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0xf9eb
// File: /workspace/github_c_makefile_star2_O1/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 0x402fa
orb $0x20, 0x69(%rdi)
movss %xmm0, 0x58(%rdi)
movq 0x80(%rdi), %rax
testq %rax, %rax
je 0x402f9
movq (%rax), %rcx
testq %rcx, %rcx
je 0x402f9
cvtss2sd %xmm0, %xmm0
movq 0x60(%rax), %rsi
jmpq *%rcx
retq
pushq %rax
callq 0xfb08
// File: /workspace/github_c_makefile_star2_O1/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 0x40396
movq %rsi, %r14
testq %rsi, %rsi
je 0x40396
movq %rdx, %rbx
testq %rdx, %rdx
je 0x40396
cmpb $0x0, (%r14)
je 0x4039b
cmpb $0x0, (%rbx)
je 0x403a0
movq %rdi, %r15
leaq 0x60(%rdi), %r12
cmpq $0x0, 0x60(%rdi)
je 0x4034a
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x4a8cd
jmp 0x40359
movq %r14, %rdi
movq %rbx, %rsi
callq 0x4a578
movq %rax, (%r12)
movq 0x80(%r15), %rcx
testq %rcx, %rcx
je 0x4038a
movq 0x28(%rcx), %rax
testq %rax, %rax
je 0x4038a
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
callq 0xfb41
callq 0xfbb3
callq 0xfb7a
// File: /workspace/github_c_makefile_star2_O1/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 0x40404
testq %rsi, %rsi
je 0x40404
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x3d6af
movq %rax, 0x40(%rbx)
movq 0x80(%rbx), %rcx
testq %rcx, %rcx
je 0x40402
movq 0x18(%rcx), %r8
testq %r8, %r8
je 0x40402
movq 0x60(%rcx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
jmpq *%r8
popq %rbx
retq
callq 0xfc25
// File: /workspace/github_c_makefile_star2_O1/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 0x4042d
testq %rsi, %rsi
je 0x4042d
movq 0x40(%rdi), %rdi
testq %rdi, %rdi
je 0x40429
callq 0x83114
testl %eax, %eax
sete %al
jmp 0x4042b
xorl %eax, %eax
popq %rcx
retq
callq 0xfc5e
// File: /workspace/github_c_makefile_star2_O1/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 0x4044f
movl 0x68(%rdi), %eax
movl %eax, %ecx
notl %ecx
testl $0xc000, %ecx           # imm = 0xC000
je 0x40454
shrl $0xe, %eax
andl $0x1, %eax
popq %rcx
retq
callq 0xfcd0
callq 0xfc97
// File: /workspace/github_c_makefile_star2_O1/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 0x40476
movl 0x68(%rdi), %eax
movl %eax, %ecx
notl %ecx
testl $0xc000, %ecx           # imm = 0xC000
je 0x4047b
movzwl %ax, %eax
shrl $0xf, %eax
popq %rcx
retq
callq 0xfd42
callq 0xfd09
// File: /workspace/github_c_makefile_star2_O1/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 0x404d9
movq %rdi, %rbx
orb $0x40, 0x69(%rdi)
movq 0x80(%rdi), %rax
testq %rax, %rax
je 0x404d1
movq 0x40(%rax), %rax
testq %rax, %rax
je 0x404d1
movq %rbx, %rdi
movq %rax, %r14
callq 0x40432
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
callq 0xfd7b
// File: /workspace/github_c_makefile_star2_O1/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 0x40554
movq %rsi, %r14
testq %rsi, %rsi
je 0x4054f
movq %rdi, %rbx
movq %r14, %rdi
callq 0x40432
testb %al, %al
je 0x4054f
orb $0x40, 0x69(%rbx)
movq %r14, 0x78(%rbx)
movq 0x80(%rbx), %rax
testq %rax, %rax
je 0x40547
movq 0x40(%rax), %rax
testq %rax, %rax
je 0x40547
movq %rbx, %rdi
movq %rax, %r14
callq 0x40432
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
callq 0xfdb4
callq 0xfded
// File: /workspace/github_c_makefile_star2_O1/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 0x405aa
movq %rdi, %rbx
callq 0x40432
testb %al, %al
je 0x405aa
movq %rbx, %rdi
callq 0x40459
testb %al, %al
jne 0x405aa
movq 0x78(%rbx), %rdi
testq %rdi, %rdi
je 0x405a5
callq 0x40432
testb %al, %al
je 0x405af
movq 0x78(%rbx), %rbx
movq %rbx, %rax
popq %rbx
retq
callq 0xfe98
callq 0xfe5f
// File: /workspace/github_c_makefile_star2_O1/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 0x40625
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 0x40624
movq 0x10(%rax), %rcx
testq %rcx, %rcx
je 0x40624
movq 0x60(%rax), %rdx
jmpq *%rcx
retq
pushq %rax
callq 0xffb5
// File: /workspace/github_c_makefile_star2_O1/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 0x40684
movq %rsi, %rbx
testq %rsi, %rsi
je 0x40684
movq %rdi, %r14
movq %rbx, %rdi
callq 0x6ecda
testq %rax, %rax
jne 0x40684
leaq 0x30d(%rip), %rdx       # 0x40975
movq %r14, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x4068e
testl %eax, %eax
jne 0x40689
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x10027
callq 0x10060
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, 0x8(%rsp)
testq %rdx, %rdx
je 0x40993
movq %rdx, %rdi
callq 0x3566a
testb %al, %al
jne 0x409da
testq %rbx, %rbx
je 0x409d5
movq 0x8(%rsp), %rax
testq %rax, %rax
je 0x409d5
movq 0x40(%rax), %rdi
testq %rdi, %rdi
je 0x409cd
leaq 0xbbfd0(%rip), %rsi     # 0xfc982
callq 0x83114
testl %eax, %eax
jne 0x409cd
leaq 0x8(%rsp), %rsi
movl $0x8, %edx
movq %rbx, %rdi
callq 0x6ec0e
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
callq 0x1010b
callq 0x100d2
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x40a45
movq %rdi, %rbx
movl $0x8, %edi
callq 0x6e93c
leaq 0x8(%rsp), %r14
movq %rax, (%r14)
movl $0x8, %edi
callq 0x6e93c
movq %rax, 0x8(%r14)
leaq 0x3a(%rip), %rdx        # 0x40a4f
movq %rbx, %rdi
movq %r14, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x4068e
testl %eax, %eax
jne 0x40a4a
movq 0x8(%rsp), %rdi
callq 0x6f134
movq 0x10(%rsp), %rdi
callq 0x6f134
addq $0x18, %rsp
popq %rbx
popq %r14
retq
callq 0x1017d
callq 0x10144