LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/feature_index.c
// Function: gt_feature_index_get_features_for_range
int gt_feature_index_get_features_for_range(GtFeatureIndex *feature_index,
                                            GtArray *results,
                                            const char *seqid,
                                            const GtRange *range, GtError *err)
{
  int ret;
  gt_assert(feature_index && feature_index->c_class && results && seqid &&
            range);
  gt_assert(gt_range_length(range) > 0);
  gt_rwlock_rdlock(feature_index->pvt->lock);
  ret = feature_index->c_class->get_features_for_range(feature_index, results,
                                                       seqid, range, err);
  gt_rwlock_unlock(feature_index->pvt->lock);
  return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3dacf
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq (%rdi), %xmm0
movq %rsi, %xmm1
punpcklqdq %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0]
movq %rcx, %xmm0
movq %rdx, %xmm2
punpcklqdq %xmm0, %xmm2    # xmm2 = xmm2[0],xmm0[0]
pxor %xmm0, %xmm0
pcmpeqd %xmm0, %xmm2
pcmpeqd %xmm0, %xmm1
movdqa %xmm1, %xmm0
shufps $0xdd, %xmm2, %xmm0     # xmm0 = xmm0[1,3],xmm2[1,3]
shufps $0x88, %xmm2, %xmm1     # xmm1 = xmm1[0,2],xmm2[0,2]
andps %xmm0, %xmm1
movmskps %xmm1, %eax
testl %eax, %eax
jne 0x3dacf
movq %r8, %r14
movq %r15, %rdi
callq 0x7e19f
testq %rax, %rax
je 0x3dad4
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3cfa5
movq (%rbx), %rax
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
callq *0x28(%rax)
movl %eax, %ebp
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3cfdb
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0xef7a
callq 0xef41
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/feature_index.c
// Function: gt_feature_index_get_first_seqid
char* gt_feature_index_get_first_seqid(const GtFeatureIndex
                                             *feature_index,
                                              GtError *err)
{
  const char *str;
  gt_assert(feature_index && feature_index->c_class);
  gt_rwlock_rdlock(feature_index->pvt->lock);
  str = feature_index->c_class->get_first_seqid(feature_index, err);
  gt_rwlock_unlock(feature_index->pvt->lock);
  return (char*) str;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3db22
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x3db22
movq %rsi, %r14
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3cfa5
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *0x30(%rax)
movq %rax, %r14
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3cfdb
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0xefb3
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/feature_index.c
// Function: gt_feature_index_save
int gt_feature_index_save(GtFeatureIndex *feature_index, GtError *err)
{
  int ret;
  gt_assert(feature_index && feature_index->c_class);
  gt_assert(feature_index->c_class->save_func);
  gt_rwlock_wrlock(feature_index->pvt->lock);
  ret = feature_index->c_class->save_func(feature_index, err);
  gt_rwlock_unlock(feature_index->pvt->lock);
  return ret;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x3db74
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x3db74
cmpq $0x0, 0x38(%rax)
je 0x3db79
movq %rsi, %r14
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3cfc0
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *0x38(%rax)
movl %eax, %ebp
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3cfdb
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
callq 0xf025
callq 0xefec
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/feature_index.c
// Function: gt_feature_index_get_seqids
GtStrArray* gt_feature_index_get_seqids(const GtFeatureIndex *feature_index,
                                        GtError *err)
{
  GtStrArray *strarr;
  gt_assert(feature_index && feature_index->c_class);
  gt_rwlock_rdlock(feature_index->pvt->lock);
  strarr = feature_index->c_class->get_seqids(feature_index, err);
  gt_rwlock_unlock(feature_index->pvt->lock);
  return strarr;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3dbc7
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x3dbc7
movq %rsi, %r14
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3cfa5
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *0x40(%rax)
movq %rax, %r14
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3cfdb
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0xf05e
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/feature_index.c
// Function: gt_feature_index_get_range_for_seqid
int  gt_feature_index_get_range_for_seqid(GtFeatureIndex *feature_index,
                                          GtRange *range,
                                          const char *seqid,
                                          GtError *err)
{
  int ret;
  gt_assert(feature_index && feature_index->c_class && range && seqid);
  gt_rwlock_rdlock(feature_index->pvt->lock);
  ret = feature_index->c_class->get_range_for_seqid(feature_index, range,
                                                    seqid, err);
  gt_rwlock_unlock(feature_index->pvt->lock);
  return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x3dc2e
movq %rdx, %r15
testq %rdx, %rdx
je 0x3dc2e
movq %rsi, %r12
testq %rsi, %rsi
je 0x3dc2e
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x3dc2e
movq %rcx, %r14
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3cfa5
movq (%rbx), %rax
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq *0x48(%rax)
movl %eax, %ebp
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3cfdb
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0xf097
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/feature_index.c
// Function: gt_feature_index_has_seqid
int  gt_feature_index_has_seqid(const GtFeatureIndex *feature_index,
                                bool *has_seqid,
                                const char *seqid,
                                GtError *err)
{
  int ret;
  gt_assert(feature_index && feature_index->c_class && seqid);
  gt_rwlock_rdlock(feature_index->pvt->lock);
  ret = feature_index->c_class->has_seqid(feature_index, has_seqid,
                                          seqid, err);
  gt_rwlock_unlock(feature_index->pvt->lock);
  return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x3dcf7
movq %rdx, %r15
testq %rdx, %rdx
je 0x3dcf7
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x3dcf7
movq %rcx, %r14
movq %rsi, %r12
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3cfa5
movq (%rbx), %rax
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq *0x58(%rax)
movl %eax, %ebp
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x3cfdb
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0xf109
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/feature_index.c
// Function: gt_feature_index_unit_test_add
static void* gt_feature_index_unit_test_add(void *data)
{
  GtFeatureNode *feature;
  GtFeatureIndexTestShared *shm = (GtFeatureIndexTestShared*) data;

  while (true) {
    gt_mutex_lock(shm->mutex);
    if (shm->next_node_idx == GT_FI_TEST_FEATURES_PER_THREAD * gt_jobs) {
      gt_mutex_unlock(shm->mutex);
      return NULL;
    }
    gt_assert(shm->next_node_idx < gt_array_size(shm->nodes));
    feature = *(GtFeatureNode**) gt_array_get(shm->nodes, shm->next_node_idx++);
    gt_mutex_unlock(shm->mutex);
    gt_feature_index_add_feature_node(shm->fi, feature, shm->err);
    gt_genome_node_delete((GtGenomeNode*) feature);
  }
  return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
callq 0x3d043
movq 0x20(%rbx), %r14
leaq 0x11349e(%rip), %r15    # 0x1516e4
imull $0x3e8, (%r15), %eax    # imm = 0x3E8
cmpq %rax, %r14
je 0x3e2a7
movq 0x10(%rbx), %rdi
callq 0x6f310
cmpq %rax, %r14
jae 0x3e2b8
movq 0x10(%rbx), %rdi
movq 0x20(%rbx), %rsi
leaq 0x1(%rsi), %rax
movq %rax, 0x20(%rbx)
callq 0x6f037
movq (%rax), %r14
movq 0x18(%rbx), %rdi
callq 0x3d05e
movq (%rbx), %rdi
movq 0x8(%rbx), %rdx
movq %r14, %rsi
callq 0x3d79a
movq %r14, %rdi
callq 0x4210c
movq 0x18(%rbx), %rdi
callq 0x3d043
movq 0x20(%rbx), %r14
jmp 0x3e246
movq 0x18(%rbx), %rdi
callq 0x3d05e
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0xf1b4
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/feature_index_memory.c
// Function: gt_feature_index_memory_add_region_node
int gt_feature_index_memory_add_region_node(GtFeatureIndex *gfi,
                                            GtRegionNode *rn,
                                            GT_UNUSED GtError *err)
{
  char *seqid;
  GtFeatureIndexMemory *fi;
  RegionInfo *info;
  fi = gt_feature_index_memory_cast(gfi);
  gt_assert(fi && rn);
  seqid = gt_str_get(gt_genome_node_get_seqid((GtGenomeNode*) rn));
  if (!gt_hashmap_get(fi->regions, seqid)) {
    info = gt_calloc(1, sizeof (RegionInfo));
    info->region = (GtRegionNode*) gt_genome_node_ref((GtGenomeNode*) rn);
    info->features = gt_interval_tree_new((GtFree)
                                          gt_genome_node_delete);
    info->dyn_range.start = ~0UL;
    info->dyn_range.end   = 0;
    gt_hashmap_add(fi->regions, seqid, info);
    if (fi->nof_region_nodes++ == 0)
      fi->firstseqid = seqid;
  }
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0x3e5ab
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3dcfc
testq %r14, %r14
je 0x3e5a6
movq %rax, %rbx
testq %rax, %rax
je 0x3e5a6
movq %r14, %rdi
callq 0x415a1
movq %rax, %rdi
callq 0x3bb5d
movq %rax, %r15
movq 0x10(%rbx), %rdi
movq %rax, %rsi
callq 0x775ed
testq %rax, %rax
jne 0x3e598
leaq 0xa62be(%rip), %rdx     # 0xe47ec
movl $0x1, %edi
movl $0x20, %esi
movl $0x4e, %ecx
callq 0x359a6
movq %rax, %r12
movq %r14, %rdi
callq 0x4130c
movq %rax, 0x8(%r12)
leaq 0x3bb3(%rip), %rdi      # 0x4210c
callq 0x792c3
movq %rax, (%r12)
movq $-0x1, 0x10(%r12)
movq $0x0, 0x18(%r12)
movq 0x10(%rbx), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x77628
movq 0x30(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x30(%rbx)
testq %rax, %rax
jne 0x3e598
movq %r15, 0x28(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0xf1ed
// File: /workspace/github_c_makefile_star2_O3/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 0x72367
cmpq $0x0, 0x11456b(%rip)    # 0x152b28
jne 0x3e631
subq $0x8, %rsp
leaq 0x643(%rip), %rax       # 0x3ec0d
leaq 0x5fa(%rip), %r10       # 0x3ebcb
leaq 0x58e(%rip), %r11       # 0x3eb66
leaq 0x50c(%rip), %rbx       # 0x3eaeb
leaq 0x45f(%rip), %r14       # 0x3ea45
leaq 0x427(%rip), %r15       # 0x3ea14
leaq -0x124(%rip), %rsi      # 0x3e4d0
leaq 0x48(%rip), %rdx        # 0x3e643
leaq 0x180(%rip), %rcx       # 0x3e782
leaq 0x268(%rip), %r8        # 0x3e871
leaq 0x2fa(%rip), %r9        # 0x3e90a
movl $0x48, %edi
pushq %rax
pushq %r10
pushq %r11
pushq %rbx
pushq %r14
pushq $0x0
pushq %r15
callq 0x3d590
addq $0x40, %rsp
movq %rax, 0x1144f7(%rip)    # 0x152b28
callq 0x7237d
movq 0x1144eb(%rip), %rax    # 0x152b28
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3e848
movq %rsi, %rbx
testq %rsi, %rsi
je 0x3e848
movq %rdi, %r14
callq 0x3e5ab
movq %rax, %rdi
movq %r14, %rsi
callq 0x3dcfc
movq %rax, %r12
movq %rbx, %rdi
callq 0x415e5
movq %rax, %r14
movq %rdx, %r15
movq 0x18(%r12), %rdi
movq %rbx, %rsi
callq 0x775ed
testq %rax, %rax
je 0x3e838
movq %rbx, %rdi
callq 0x415a1
movq %rax, %rdi
callq 0x3bb5d
movq 0x10(%r12), %rdi
movq %rax, %rsi
callq 0x775ed
testq %rax, %rax
je 0x3e838
movq %rax, %r12
movq %rsp, %r13
movq %rbx, 0x8(%r13)
movq $0x0, (%r13)
movq (%rax), %rdi
leaq 0x35(%rip), %rsi        # 0x3e84d
movq %r14, %rdx
movq %r15, %rcx
movq %r13, %r8
callq 0x794cd
movq (%r13), %rsi
testq %rsi, %rsi
je 0x3e838
movq (%r12), %rdi
callq 0x79722
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0xf25b
// File: /workspace/github_c_makefile_star2_O3/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 0x3e8d6
movq %rsi, %rbx
testq %rsi, %rsi
je 0x3e8d6
movq %rdi, %r14
callq 0x3e5ab
movq %rax, %rdi
movq %r14, %rsi
callq 0x3dcfc
movq %rax, %r15
movl $0x8, %edi
callq 0x6ef7c
movq %rax, %r14
movq 0x10(%r15), %rdi
movq %rbx, %rsi
callq 0x775ed
testq %rax, %rax
je 0x3e8cd
movq (%rax), %rdi
leaq 0x1f(%rip), %rsi        # 0x3e8e0
movq %r14, %rdx
callq 0x7938c
testl %eax, %eax
jne 0x3e8db
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0xf294
callq 0xf2cd
// File: /workspace/github_c_makefile_star2_O3/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 0x79303
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movl $0x8, %edx
movq %rbx, %rdi
callq 0x6f240
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3e933
movq %r14, %rdi
callq 0x34fea
testb %al, %al
jne 0x3e9a8
testq %r13, %r13
je 0x3e9a3
testq %rbx, %rbx
je 0x3e9a3
callq 0x3e5ab
movq %rax, %rdi
movq %r13, %rsi
callq 0x3dcfc
movq 0x10(%rax), %rdi
movq %r12, %rsi
callq 0x775ed
testq %rax, %rax
je 0x3e983
movq (%rax), %rdi
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rcx
callq 0x793ff
leaq 0x36(%rip), %rsi        # 0x3e9ad
movq %rbx, %rdi
callq 0x6f35d
xorl %eax, %eax
jmp 0x3e999
leaq 0xa5f61(%rip), %rsi     # 0xe48eb
movq %r14, %rdi
xorl %eax, %eax
callq 0x34f1f
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0xf33f
callq 0xf306
// File: /workspace/github_c_makefile_star2_O3/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 0x3ea0f
movq %rdx, %r14
movq %rsi, %rbx
movq 0x18(%rdi), %rdi
callq 0x775ed
movq %rax, %r15
testq %rax, %rax
jne 0x3ea06
leaq 0xa5f53(%rip), %rsi     # 0xe494c
movq %r14, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x34f1f
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0xf378
// File: /workspace/github_c_makefile_star2_O3/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 0x3ea40
movq %rdi, %rbx
callq 0x3e5ab
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3dcfc
movq 0x28(%rax), %rdi
testq %rdi, %rdi
je 0x3ea3c
popq %rbx
jmp 0x728c0
xorl %eax, %eax
popq %rbx
retq
callq 0xf3b1
// File: /workspace/github_c_makefile_star2_O3/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 0x3eaa3
movq %rdi, %rbx
callq 0x3e5ab
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3dcfc
movq %rax, %r14
callq 0x72f00
movq %rax, %rbx
movq 0x10(%r14), %rdi
leaq 0x36(%rip), %rsi        # 0x3eaad
movq %rax, %rdx
xorl %ecx, %ecx
callq 0x77703
testl %eax, %eax
jne 0x3eaa8
movq %rbx, %rdi
callq 0x72ff2
movq %rax, %r14
movq %rbx, %rdi
callq 0x73273
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0xf423
callq 0xf3ea
// File: /workspace/github_c_makefile_star2_O3/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 0x3eae6
movq %rdx, %r14
testq %rdx, %rdx
je 0x3eae6
movq %rdi, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x72fc5
testq %rax, %rax
jne 0x3eadc
movq %r14, %rdi
movq %rbx, %rsi
callq 0x72f66
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0xf45c
// File: /workspace/github_c_makefile_star2_O3/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 0x3eb5c
movq %rsi, %rbx
testq %rsi, %rsi
je 0x3eb5c
movq %rdx, %r14
testq %rdx, %rdx
je 0x3eb5c
movq %rdi, %r15
callq 0x3e5ab
movq %rax, %rdi
movq %r15, %rsi
callq 0x3dcfc
movq 0x10(%rax), %rdi
movq %r14, %rsi
callq 0x775ed
testq %rax, %rax
je 0x3eb61
movq %rax, %rcx
movq 0x10(%rax), %rax
cmpq $-0x1, %rax
je 0x3eb3f
movq 0x18(%rcx), %rdx
testq %rdx, %rdx
jne 0x3eb4d
movq 0x8(%rcx), %rdi
testq %rdi, %rdi
je 0x3eb54
callq 0x415e5
movq %rax, (%rbx)
movq %rdx, 0x8(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0xf495
callq 0xf4ce
// File: /workspace/github_c_makefile_star2_O3/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 0x3ebc1
movq %rsi, %rbx
testq %rsi, %rsi
je 0x3ebc1
movq %rdx, %r14
testq %rdx, %rdx
je 0x3ebc1
movq %rdi, %r15
callq 0x3e5ab
movq %rax, %rdi
movq %r15, %rsi
callq 0x3dcfc
movq 0x10(%rax), %rdi
movq %r14, %rsi
callq 0x775ed
testq %rax, %rax
je 0x3ebc6
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0x3ebb9
callq 0x415e5
movq %rax, (%rbx)
movq %rdx, 0x8(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0xf507
callq 0xf540
// File: /workspace/github_c_makefile_star2_O3/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 0x3ec08
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
callq 0x3e5ab
movq %rax, %rdi
movq %r15, %rsi
callq 0x3dcfc
movq 0x10(%rax), %rdi
movq %r14, %rsi
callq 0x775ed
testq %rax, %rax
setne (%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0xf579
// File: /workspace/github_c_makefile_star2_O3/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 0x3ec3c
pushq %rbx
movq %rdi, %rbx
callq 0x3e5ab
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3dcfc
movq %rax, %rbx
movq 0x10(%rax), %rdi
callq 0x77bab
movq 0x18(%rbx), %rdi
popq %rbx
jmp 0x77bab
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3e5ab
movq %rax, %rdi
callq 0x3d601
movq %rax, %rbx
callq 0x3e5ab
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3dcfc
movq %rax, %r14
movq $0x0, 0x40(%rax)
leaq 0x2a(%rip), %rdx        # 0x3ec9d
movl $0x1, %edi
xorl %esi, %esi
callq 0x7740c
movq %rax, 0x10(%r14)
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x7740c
movq %rax, 0x18(%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x79696
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x3ecb7
callq 0x4210c
leaq 0xa5b2e(%rip), %rsi     # 0xe47ec
movq %rbx, %rdi
movl $0x40, %edx
popq %rbx
jmp 0x35c27
// File: /workspace/github_c_makefile_star2_O3/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 0x3c8cc
movq %rax, %rbx
movq 0x60(%r14), %rdi
testq %rdi, %rdi
je 0x3ef13
leaq 0x13(%rip), %rsi        # 0x3ef1e
movq %rbx, %rdx
callq 0x49eaf
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3ef9f
movq %rsi, %rbx
testq %rsi, %rsi
je 0x3ef9f
movq %rdi, %r14
movq 0x38(%rdi), %rdi
testq %rdi, %rdi
je 0x3ef63
callq 0x3c87b
movq %rbx, %rdi
callq 0x3bcaf
movq %rax, 0x38(%r14)
movq 0x80(%r14), %rax
testq %rax, %rax
je 0x3ef97
movq 0x20(%rax), %rcx
testq %rcx, %rcx
je 0x3ef97
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 0xf622
// File: /workspace/github_c_makefile_star2_O3/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 0x3efd7
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 0x3efd6
movq 0x8(%rax), %rcx
testq %rcx, %rcx
je 0x3efd6
movq 0x60(%rax), %rdx
jmpq *%rcx
retq
pushq %rax
callq 0xf65b
// File: /workspace/github_c_makefile_star2_O3/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 0x3f019
movq %rsi, %r14
testq %rsi, %rsi
je 0x3f019
movq %rdi, %rbx
movq 0x80(%rdi), %rdi
testq %rdi, %rdi
je 0x3f002
callq 0x41166
movq %r14, %rdi
callq 0x41153
movq %rax, 0x80(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0xf694
// File: /workspace/github_c_makefile_star2_O3/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 0x3f045
movq %rdi, %rbx
movq 0x80(%rdi), %rdi
testq %rdi, %rdi
je 0x3f038
callq 0x41166
movq $0x0, 0x80(%rbx)
popq %rbx
retq
callq 0xf6cd
// File: /workspace/github_c_makefile_star2_O3/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 0x72367
cmpq $0x0, 0x113ad8(%rip)    # 0x152b30
jne 0x3f09f
leaq 0x1d8(%rip), %rax       # 0x3f239
leaq 0x188(%rip), %r10       # 0x3f1f0
leaq 0x3e(%rip), %rsi        # 0x3f0ad
leaq 0xe9(%rip), %rcx        # 0x3f15f
leaq 0xfc(%rip), %r8         # 0x3f179
leaq 0x116(%rip), %r9        # 0x3f19a
movl $0x88, %edi
movq %rcx, %rdx
pushq %rax
pushq %r10
callq 0x41334
addq $0x10, %rsp
movq %rax, 0x113a91(%rip)    # 0x152b30
callq 0x7237d
movq 0x113a85(%rip), %rax    # 0x152b30
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3f04a
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4153f
movq %rax, %rbx
movq 0x30(%rax), %rdi
callq 0x3c87b
movq 0x38(%rbx), %rdi
callq 0x3c87b
movq 0x60(%rbx), %rdi
callq 0x4a06f
movq 0x70(%rbx), %rdi
testq %rdi, %rdi
je 0x3f118
callq 0x73308
testq %rax, %rax
je 0x3f118
movq %rax, %r14
movq %r14, %rdi
callq 0x73384
movq %rax, %rdi
callq 0x4210c
movq %r14, %rdi
callq 0x73394
movq %rax, %r14
testq %rax, %rax
jne 0x3f0f8
movq 0x70(%rbx), %rdi
callq 0x73601
movq 0x80(%rbx), %rdi
testq %rdi, %rdi
je 0x3f157
movq 0x58(%rdi), %rax
testq %rax, %rax
je 0x3f14b
movq 0x60(%rdi), %rsi
movq %rbx, %rdi
callq *%rax
movq 0x80(%rbx), %rdi
testq %rdi, %rdi
je 0x3f157
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x41166
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3f04a
movq %rax, %rdi
movq %r14, %rsi
callq 0x4153f
movups (%rbx), %xmm0
movups %xmm0, 0x48(%rax)
movq 0x80(%rax), %rcx
testq %rcx, %rcx
je 0x3f1e8
movq 0x38(%rcx), %r8
testq %r8, %r8
je 0x3f1e8
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_O3/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 0x3f04a
movq %rax, %rdi
movq %r14, %rsi
callq 0x4153f
testq %rbx, %rbx
je 0x3f234
movq %rax, %r14
testq %rax, %rax
je 0x3f234
movq 0x30(%r14), %rdi
callq 0x3c87b
movq %rbx, %rdi
callq 0x3bcaf
movq %rax, 0x30(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0xf706
// File: /workspace/github_c_makefile_star2_O3/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 0x3f258
movq %rbx, %rdi
callq 0x34fea
testb %al, %al
jne 0x3f27b
callq 0x3f04a
movq %rax, %rdi
movq %r15, %rsi
callq 0x4153f
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x4903a
callq 0xf73f
// File: /workspace/github_c_makefile_star2_O3/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 0x3f35f
movq %rsi, %r13
testq %rsi, %rsi
je 0x3f35f
movq %rcx, %r15
movq %rdx, %r12
cmpq %rcx, %rdx
ja 0x3f364
movl %r8d, %ebx
movq %rdi, %r14
callq 0x3f04a
movq %rax, %rdi
callq 0x414a6
movq %rax, %rbp
movq %rax, (%rsp)
callq 0x3f04a
movq %rax, %rdi
movq %rbp, %rsi
callq 0x4153f
movq %rax, %rbp
movq %r14, %rdi
callq 0x3bcaf
movq %rax, 0x30(%rbp)
xorl %r14d, %r14d
movq %r14, 0x38(%rbp)
movq %r13, %rdi
callq 0x3cd3b
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 0x3efa4
movq %rbp, %rdi
movl $0x4, %esi
callq 0x3f37e
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 0xf778
callq 0xf7b1
// File: /workspace/github_c_makefile_star2_O3/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 0x3f394
movl $0xffffe3ff, %eax       # imm = 0xFFFFE3FF
andl 0x68(%rdi), %eax
shll $0xa, %esi
orl %eax, %esi
movl %esi, 0x68(%rdi)
retq
pushq %rax
callq 0xf7ea
// File: /workspace/github_c_makefile_star2_O3/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 0x3f3de
movl %ecx, %r8d
movq %rdx, %rcx
movq %rsi, %rdx
cmpq %rcx, %rsi
ja 0x3f3e3
leaq 0xa59df(%rip), %rsi     # 0xe4d94
callq 0x3f280
movq %rax, %rbx
callq 0x3f04a
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4153f
movq $0x0, 0x40(%rax)
orb $-0x80, 0x69(%rax)
movq %rbx, %rax
popq %rbx
retq
callq 0xf85c
callq 0xf823
// File: /workspace/github_c_makefile_star2_O3/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 0x3f45d
movq %rdi, %rbx
callq 0x3f04a
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4153f
movq 0x48(%rax), %r14
movq 0x50(%rax), %r15
callq 0x3f04a
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4153f
movq 0x30(%rax), %rdi
movl 0x68(%rbx), %ecx
shrl $0x5, %ecx
andl $0x7, %ecx
movq %r14, %rsi
movq %r15, %rdx
callq 0x3f39a
movq %rax, %r14
callq 0x3f04a
movq %rax, %rdi
movq %r14, %rsi
callq 0x4153f
movq 0x38(%rbx), %rsi
movq %rax, %rdi
callq 0x3ef41
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0xf895
// File: /workspace/github_c_makefile_star2_O3/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 0x3f7b5
movq %rsi, %rbx
testq %rsi, %rsi
je 0x3f7b5
movq %rdi, %r14
callq 0x415a1
movq %rax, %r15
movq %rbx, %rdi
callq 0x415a1
movq %r15, %rdi
movq %rax, %rsi
callq 0x3bc02
testl %eax, %eax
jne 0x3f7ba
movq %rbx, %rdi
callq 0x3faf4
testb %al, %al
jne 0x3f7bf
movq 0x70(%r14), %rdi
testq %rdi, %rdi
jne 0x3f757
leaq 0x1c52(%rip), %rdi      # 0x4139d
callq 0x7329c
movq %rax, %rdi
movq %rax, 0x70(%r14)
movq %rbx, %rsi
callq 0x733b1
andb $-0x19, 0x68(%r14)
movl 0x68(%rbx), %eax
movl %eax, %ecx
shrl %ecx
andl $0x3, %ecx
je 0x3f77c
cmpl $0x1, %ecx
jne 0x3f789
movl $0x4, %ecx
jmp 0x3f781
movl $0x2, %ecx
andl $-0x7, %eax
orl %ecx, %eax
movl %eax, 0x68(%rbx)
movq 0x80(%r14), %rax
testq %rax, %rax
je 0x3f7af
movq 0x50(%rax), %rcx
testq %rcx, %rcx
je 0x3f7af
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 0xf907
callq 0xf940
callq 0xf979
// File: /workspace/github_c_makefile_star2_O3/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 0x3f8ea
movq %rdi, %rbx
movq 0x70(%rdi), %rdi
testq %rdi, %rdi
je 0x3f7f0
callq 0x733a4
testq %rax, %rax
jne 0x3f8ea
movq %rbx, %rdi
callq 0x415a1
movq %rax, %r14
movq 0x40(%rbx), %r15
movq %rbx, %rdi
callq 0x415e0
movq %rax, %r12
movq %rbx, %rdi
callq 0x41603
movl 0x68(%rbx), %r8d
shrl $0x5, %r8d
andl $0x7, %r8d
movq %r14, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %rax, %rcx
callq 0x3f280
movq %rax, %r14
movq 0x8(%rbx), %rsi
movl 0x20(%rbx), %edx
movq %rax, %rdi
callq 0x41500
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x3f866
callq 0x3bb5d
cmpb $0x2e, (%rax)
jne 0x3f85a
cmpb $0x0, 0x1(%rax)
je 0x3f866
movq 0x38(%rbx), %rsi
movq %r14, %rdi
callq 0x3ef41
testb $0x20, 0x69(%rbx)
je 0x3f879
movss 0x58(%rbx), %xmm0
movq %r14, %rdi
callq 0x3f968
movq %rbx, %rdi
callq 0x3eeec
movq %rax, %r15
movq %rax, %rdi
callq 0x3cbed
testq %rax, %rax
je 0x3f8d5
xorl %r12d, %r12d
movq %r15, %rdi
movq %r12, %rsi
callq 0x3ca6f
movq %rax, %r13
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x3f8b8
movq %r13, %rsi
callq 0x49e69
movq %rax, %rdx
jmp 0x3f8ba
xorl %edx, %edx
movq %r14, %rdi
movq %r13, %rsi
callq 0x3f99b
incq %r12
movq %r15, %rdi
callq 0x3cbed
cmpq %rax, %r12
jb 0x3f894
movq %r15, %rdi
callq 0x3cc00
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0xf9b2
// File: /workspace/github_c_makefile_star2_O3/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 0x3f995
orb $0x20, 0x69(%rdi)
movss %xmm0, 0x58(%rdi)
movq 0x80(%rdi), %rax
testq %rax, %rax
je 0x3f994
movq (%rax), %rcx
testq %rcx, %rcx
je 0x3f994
cvtss2sd %xmm0, %xmm0
movq 0x60(%rax), %rsi
jmpq *%rcx
retq
pushq %rax
callq 0xfacf