LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/check_boundaries_visitor.c
// Function: gt_check_boundaries_visitor_class
const GtNodeVisitorClass* gt_check_boundaries_visitor_class()
{
  static GtNodeVisitorClass *nvc = NULL;
  gt_class_alloc_lock_enter();
  if (!nvc) {
    nvc = gt_node_visitor_class_new(sizeof (GtCheckBoundariesVisitor),
                                    NULL,
                                    NULL,
                                    check_boundaries_visitor_feature_node,
                                    NULL,
                                    NULL,
                                    NULL);
  }
  gt_class_alloc_lock_leave();
  return nvc;
}

// Assembly:
pushq %rax
callq 0x69e97
cmpq $0x0, 0x37f0aa(%rip)    # 0x43d680
jne 0xbe5fd
andq $0x0, (%rsp)
leaq 0x27(%rip), %rcx        # 0xbe60b
pushq $0x10
popq %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x102cd0
movq %rax, 0x37f083(%rip)    # 0x43d680
callq 0x69ede
movq 0x37f077(%rip), %rax    # 0x43d680
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/check_boundaries_visitor.c
// Function: check_boundaries_visitor_feature_node
static int check_boundaries_visitor_feature_node(GT_UNUSED GtNodeVisitor *nv,
                                                 GtFeatureNode *fn,
                                                 GT_UNUSED GtError *err)
{
  GtFeatureNodeIterator *fni;
  GtFeatureNode *node;
  int had_err = 0;

  fni = gt_feature_node_iterator_new_direct(fn);
  while (!had_err && (node = gt_feature_node_iterator_next(fni))) {
    had_err = check_boundaries_visitor_check_rec(fn, node, err);
  }
  gt_feature_node_iterator_delete(fni);

  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rsi, %rdi
callq 0xdc826
movq %rax, %r14
movq %r14, %rdi
callq 0xdc92e
testq %rax, %rax
je 0xbe637
movq %rbx, %rdi
movq %rax, %rsi
callq 0xbe658
jmp 0xbe61d
movq %r14, %rdi
callq 0xdc9f1
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/check_boundaries_visitor.c
// Function: check_boundaries_visitor_check_rec
static int check_boundaries_visitor_check_rec(GtFeatureNode *parent,
                                              GtFeatureNode *child,
                                              GtError *err)
{
  GtFeatureNodeIterator *fni;
  GtFeatureNode *node;
  GtRange range,
          p_range;
  int had_err = 0;

  range = gt_genome_node_get_range((GtGenomeNode*) child);
  p_range = gt_genome_node_get_range((GtGenomeNode*) parent);

  if (range.start < p_range.start || range.end > p_range.end) {
    gt_warning("%s child range " GT_WU "-" GT_WU " (file %s, line %u) not "
               "contained in %s parent range " GT_WU "-" GT_WU " (file %s, "
               "line %u)",
               gt_feature_node_get_type(child),
               range.start, range.end,
               gt_genome_node_get_filename((GtGenomeNode*) child),
               gt_genome_node_get_line_number((GtGenomeNode*) child),
               gt_feature_node_get_type(parent),
               p_range.start, p_range.end,
               gt_genome_node_get_filename((GtGenomeNode*) parent),
               gt_genome_node_get_line_number((GtGenomeNode*) parent));
  }

  fni = gt_feature_node_iterator_new_direct(child);
  while ((node = gt_feature_node_iterator_next(fni))) {
    had_err = check_boundaries_visitor_check_rec(child, node, err);
  }
  gt_feature_node_iterator_delete(fni);

  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %rbp
movq %rsi, %rdi
callq 0xdd1f4
movq %rax, %r12
movq %rdx, %r13
movq %rbp, %rdi
callq 0xdd1f4
movq %rax, %r14
cmpq %rax, %r12
setb %al
cmpq %rdx, %r13
seta %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0xbe723
movq %rdx, %r15
movq %rbx, %rdi
callq 0xda338
movq %rax, 0x20(%rsp)
movq %rbx, %rdi
callq 0xdd0b5
movq %rax, 0x10(%rsp)
movq %rbx, %rdi
callq 0xdd108
movl %eax, 0x4(%rsp)
movq %rbp, %rdi
callq 0xda338
movq %rax, 0x18(%rsp)
movq %rbp, %rdi
callq 0xdd0b5
movq %rax, 0x8(%rsp)
movq %rbp, %rdi
callq 0xdd108
movl %eax, %r10d
subq $0x8, %rsp
leaq 0x259dd8(%rip), %rdi    # 0x3184cd
movq 0x28(%rsp), %rsi
movq %r12, %rdx
movq %r13, %rcx
movq 0x18(%rsp), %r8
movl 0xc(%rsp), %r9d
xorl %eax, %eax
pushq %r10
pushq 0x18(%rsp)
pushq %r15
pushq %r14
pushq 0x40(%rsp)
callq 0xb2cd0
addq $0x30, %rsp
movq %rbx, %rdi
callq 0xdc826
movq %rax, %r14
movq %r14, %rdi
callq 0xdc92e
testq %rax, %rax
je 0xbe748
movq %rbx, %rdi
movq %rax, %rsi
callq 0xbe658
jmp 0xbe72e
movq %r14, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xdc9f1
nop
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/chseqids_stream.c
// Function: gt_chseqids_stream_class
const GtNodeStreamClass* gt_chseqids_stream_class(void)
{
  static const GtNodeStreamClass *nsc = NULL;
  gt_class_alloc_lock_enter();
  if (!nsc) {
    nsc = gt_node_stream_class_new(sizeof (GtChseqidsStream),
                                   chseqids_stream_free,
                                   chseqids_stream_next);
  }
  gt_class_alloc_lock_leave();
  return nsc;
}

// Assembly:
pushq %rax
callq 0x69e97
cmpq $0x0, 0x37ef1a(%rip)    # 0x43d688
jne 0xbe78d
leaq 0x24(%rip), %rsi        # 0xbe79b
leaq 0x80(%rip), %rdx        # 0xbe7fe
pushq $0x38
popq %rdi
callq 0x102838
movq %rax, 0x37eefb(%rip)    # 0x43d688
callq 0x69ede
movq 0x37eeef(%rip), %rax    # 0x43d688
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/chseqids_stream.c
// Function: chseqids_stream_free
static void chseqids_stream_free(GtNodeStream *ns)
{
  GtChseqidsStream *cs;
  GtUword i;
  cs = chseqids_stream_cast(ns);
  gt_mapping_delete(cs->chseqids_mapping);
  for (i = cs->buffer_index; i < gt_array_size(cs->node_buffer); i++)
    gt_genome_node_delete(*(GtGenomeNode**) gt_array_get(cs->node_buffer, i));
  gt_array_delete(cs->node_buffer);
  gt_node_stream_delete(cs->in_stream);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xbe760
movq %rax, %rdi
movq %rbx, %rsi
callq 0x102c81
movq %rax, %rbx
movq 0x18(%rax), %rdi
callq 0xfb2ec
movq 0x28(%rbx), %r14
movq 0x20(%rbx), %rdi
callq 0x586a4
movq 0x20(%rbx), %rdi
cmpq %rax, %r14
jae 0xbe7e9
movq %r14, %rsi
callq 0x581aa
movq (%rax), %rdi
callq 0xde013
incq %r14
jmp 0xbe7c2
callq 0x58eb9
movq 0x10(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x10297b
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/chseqids_stream.c
// Function: gt_chseqids_stream_new
GtNodeStream* gt_chseqids_stream_new(GtNodeStream *in_stream,
                                     GtStr *chseqids_file, GtError *err)
{
  GtNodeStream *ns;
  GtChseqidsStream *cs;
  gt_error_check(err);
  gt_assert(in_stream && chseqids_file);
  gt_assert(gt_node_stream_is_sorted(in_stream));
  ns = gt_node_stream_create(gt_chseqids_stream_class(), false);
  cs = chseqids_stream_cast(ns);
  cs->in_stream = gt_node_stream_ref(in_stream);
  cs->chseqids_mapping = gt_mapping_new(chseqids_file, "chseqids",
                                        GT_MAPPINGTYPE_STRING, err);
  if (!cs->chseqids_mapping) {
    gt_node_stream_delete(ns);
    return NULL;
  }
  cs->node_buffer = gt_array_new(sizeof (GtGenomeNode*));
  return ns;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rdx, %rdx
je 0xbebbf
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0xbecb1
testq %r15, %r15
je 0xbec55
testq %r14, %r14
je 0xbec55
movq %r15, %rdi
callq 0x102c3d
testb %al, %al
je 0xbec83
callq 0xbe760
movq %rax, %rdi
xorl %esi, %esi
callq 0x10289f
movq %rax, %r12
callq 0xbe760
movq %rax, %rdi
movq %r12, %rsi
callq 0x102c81
movq %rax, %r13
movq %r15, %rdi
callq 0x102934
movq %rax, 0x10(%r13)
leaq 0x226ab2(%rip), %rsi    # 0x2e56cb
movq %r14, %rdi
xorl %edx, %edx
movq %rbx, %rcx
callq 0xfb05c
movq %rax, 0x18(%r13)
testq %rax, %rax
je 0xbec3d
pushq $0x8
popq %rdi
callq 0x5809c
movq %rax, 0x20(%r13)
jmp 0xbec48
movq %r12, %rdi
callq 0x10297b
xorl %r12d, %r12d
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x37930c(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2263ad(%rip), %rsi    # 0x2e5013
leaq 0x2598fc(%rip), %rdx    # 0x318569
leaq 0x2598bf(%rip), %rcx    # 0x318533
leaq 0x2598cf(%rip), %r8     # 0x31854a
movl $0xb2, %r9d
jmp 0xbecdd
movq 0x3792de(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x22637f(%rip), %rsi    # 0x2e5013
leaq 0x27de12(%rip), %rdx    # 0x33caad
leaq 0x259891(%rip), %rcx    # 0x318533
leaq 0x2598a1(%rip), %r8     # 0x31854a
movl $0xb3, %r9d
jmp 0xbecdd
movq 0x3792b0(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x226351(%rip), %rsi    # 0x2e5013
leaq 0x2264f6(%rip), %rdx    # 0x2e51bf
leaq 0x259863(%rip), %rcx    # 0x318533
leaq 0x259873(%rip), %r8     # 0x31854a
movl $0xb1, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/chseqids_stream.c
// Function: change_sequence_id
static int change_sequence_id(GtFeatureNode *fn, void *data,
                              GT_UNUSED GtError *err)
{
  GtStr *changed_seqid = data;
  gt_error_check(err);
  gt_assert(changed_seqid);
  gt_genome_node_change_seqid((GtGenomeNode*) fn, changed_seqid);
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0xbed04
movq %rdx, %rdi
callq 0x89eb7
testb %al, %al
jne 0xbed48
testq %rbx, %rbx
je 0xbed1e
movq %r14, %rdi
movq %rbx, %rsi
callq 0xdd346
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x379243(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2262e4(%rip), %rsi    # 0x2e5013
leaq 0x259863(%rip), %rdx    # 0x318599
leaq 0x25986a(%rip), %rcx    # 0x3185a7
leaq 0x259806(%rip), %r8     # 0x31854a
pushq $0x2e
jmp 0xbed70
movq 0x379219(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2262ba(%rip), %rsi    # 0x2e5013
leaq 0x22645f(%rip), %rdx    # 0x2e51bf
leaq 0x259840(%rip), %rcx    # 0x3185a7
leaq 0x2597dc(%rip), %r8     # 0x31854a
pushq $0x2d
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
nop
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/collect_ids_visitor.c
// Function: gt_collect_ids_visitor_class
const GtNodeVisitorClass* gt_collect_ids_visitor_class()
{
  static const GtNodeVisitorClass *nvc = NULL;
  gt_class_alloc_lock_enter();
  if (!nvc) {
    nvc = gt_node_visitor_class_new(sizeof (GtCollectIDsVisitor),
                                    NULL,
                                    NULL,
                                    collect_ids_visitor_feature_node,
                                    collect_ids_visitor_region_node,
                                    NULL,
                                    NULL);
  }
  gt_class_alloc_lock_leave();
  return nvc;
}

// Assembly:
pushq %rax
callq 0x69e97
cmpq $0x0, 0x37e902(%rip)    # 0x43d690
jne 0xbedb9
andq $0x0, (%rsp)
leaq 0x2b(%rip), %rcx        # 0xbedc7
leaq 0x7b(%rip), %r8         # 0xbee1e
pushq $0x18
popq %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %r9d, %r9d
callq 0x102cd0
movq %rax, 0x37e8d7(%rip)    # 0x43d690
callq 0x69ede
movq 0x37e8cb(%rip), %rax    # 0x43d690
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/collect_ids_visitor.c
// Function: collect_ids_visitor_feature_node
static int collect_ids_visitor_feature_node(GtNodeVisitor *nv,
                                            GtFeatureNode *fn,
                                            GT_UNUSED GtError *err)
{
  GtCollectIDsVisitor *civ;
  const char *seqid;
  civ = collect_ids_visitor_cast(nv);
  seqid = gt_str_get(gt_genome_node_get_seqid((GtGenomeNode*) fn));
  if (!gt_cstr_table_get(civ->seqids, seqid))
    gt_cstr_table_add(civ->seqids, seqid);
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
callq 0xbed80
movq %rax, %rdi
movq %rbx, %rsi
callq 0x102dfe
movq %rax, %rbx
movq %r14, %rdi
callq 0xdd14a
movq %rax, %rdi
callq 0xad1fa
movq %rax, %r14
movq 0x10(%rbx), %rdi
movq %rax, %rsi
callq 0x6cb9a
testq %rax, %rax
jne 0xbee14
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x6cacc
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/collect_ids_visitor.c
// Function: collect_ids_visitor_region_node
static int collect_ids_visitor_region_node(GtNodeVisitor *nv, GtRegionNode *rn,
                                           GT_UNUSED GtError *err)
{
  GtCollectIDsVisitor *civ;
  const char *seqid;
  int had_err = 0;
  gt_error_check(err);
  civ = collect_ids_visitor_cast(nv);
  seqid = gt_str_get(gt_genome_node_get_seqid((GtGenomeNode*) rn));
  if (!gt_cstr_table_get(civ->seqids, seqid))
    gt_cstr_table_add(civ->seqids, seqid);
  return had_err;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0xbee39
movq %rdx, %rdi
callq 0x89eb7
testb %al, %al
jne 0xbee86
callq 0xbed80
movq %rax, %rdi
movq %r14, %rsi
callq 0x102dfe
movq %rax, %r14
movq %rbx, %rdi
callq 0xdd14a
movq %rax, %rdi
callq 0xad1fa
movq %rax, %rbx
movq 0x10(%r14), %rdi
movq %rax, %rsi
callq 0x6cb9a
testq %rax, %rax
jne 0xbee7c
movq 0x10(%r14), %rdi
movq %rbx, %rsi
callq 0x6cacc
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x3790db(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x22617c(%rip), %rsi    # 0x2e5013
leaq 0x226321(%rip), %rdx    # 0x2e51bf
leaq 0x259715(%rip), %rcx    # 0x3185ba
leaq 0x25972e(%rip), %r8     # 0x3185da
pushq $0x37
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/collect_ids_visitor.c
// Function: gt_collect_ids_visitor_new
GtNodeVisitor* gt_collect_ids_visitor_new(GtCstrTable *cst)
{
  GtNodeVisitor *nv = gt_node_visitor_create(gt_collect_ids_visitor_class());
  GtCollectIDsVisitor *collect_ids_visitor = collect_ids_visitor_cast(nv);
  collect_ids_visitor->seqids = cst;
  return nv;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xbed80
movq %rax, %rdi
callq 0x102da0
movq %rax, %r14
callq 0xbed80
movq %rax, %rdi
movq %r14, %rsi
callq 0x102dfe
movq %rbx, 0x10(%rax)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/compressed_bitsequence.c
// Function: gt_compressed_bitsequence_new_empty
static GtCompressedBitsequence* gt_compressed_bitsequence_new_empty(void)
{
  GtCompressedBitsequence *cbs;

  cbs = gt_calloc((size_t) 1, sizeof (*cbs));
  cbs->blocksize = GT_COMP_BITSEQ_BLOCKSIZE;
  cbs->mmapped = NULL;
  return cbs;
}

// Assembly:
pushq %rax
leaq 0x25947d(%rip), %rdx    # 0x318836
pushq $0x1
popq %rdi
movl $0xf8, %esi
movl $0x192, %ecx            # imm = 0x192
callq 0x9334a
movl $0xf, 0xd8(%rax)
andq $0x0, 0x98(%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/compressed_bitsequence.c
// Function: gt_compressed_bitsequence_access
int gt_compressed_bitsequence_access(GtCompressedBitsequence *cbs,
                                     GtUword position)
{
  int bit;
  unsigned int pos_in_block;
  GtUword block;
  GtCompressedBitsequenceBlockInfo *cbs_bi;

  gt_assert(cbs != NULL);
  gt_assert(position < cbs->num_of_bits);

  pos_in_block = (unsigned int) position % cbs->blocksize;

  gt_compressed_bitsequence_calc_block_info(cbs, position);
  cbs_bi = cbs->cbs_bi;
  if (cbs_bi->class == 0 || cbs_bi->class == cbs->blocksize)
    return cbs_bi->class == 0 ? 0 : 1;

  block = gt_popcount_tab_get(cbs->popcount_tab,
                              cbs_bi->class,
                              cbs_bi->block_offset);

  /* account for shorter blocks at the end */
  block <<= (cbs->blocksize - cbs_bi->block_len);

  bit = (int) ((block >> (cbs->blocksize - pos_in_block - 1)) & 1UL);
  return bit;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xbf461
movq %rdi, %rbx
cmpq %rsi, 0xb0(%rdi)
jbe 0xbf48f
movl %esi, %eax
xorl %edx, %edx
divl 0xd8(%rbx)
movl %edx, %r14d
movq %rbx, %rdi
callq 0xbf4c7
movq 0x90(%rbx), %r15
movl 0x18(%r15), %esi
testl %esi, %esi
je 0xbf425
cmpl 0xd8(%rbx), %esi
jne 0xbf42e
xorl %eax, %eax
testl %esi, %esi
setne %al
jmp 0xbf45b
movq 0x68(%rbx), %rdi
movq (%r15), %rdx
callq 0x104561
movq %rax, %rdx
movl 0xd8(%rbx), %eax
movl %eax, %ecx
subl 0x1c(%r15), %ecx
shlq %cl, %rdx
notl %r14d
addl %eax, %r14d
xorl %eax, %eax
btq %r14, %rdx
setb %al
popq %rbx
popq %r14
popq %r15
retq
movq 0x378b00(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x225ba1(%rip), %rsi    # 0x2e5013
leaq 0x259427(%rip), %rdx    # 0x3188a0
leaq 0x25942c(%rip), %rcx    # 0x3188ac
leaq 0x2593af(%rip), %r8     # 0x318836
movl $0x205, %r9d            # imm = 0x205
jmp 0xbf4bb
movq 0x378ad2(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x225b73(%rip), %rsi    # 0x2e5013
leaq 0x259426(%rip), %rdx    # 0x3188cd
leaq 0x2593fe(%rip), %rcx    # 0x3188ac
leaq 0x259381(%rip), %r8     # 0x318836
movl $0x206, %r9d            # imm = 0x206
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/compressed_bitsequence.c
// Function: gt_compressed_bitsequence_rank_1
GtUword gt_compressed_bitsequence_rank_1(GtCompressedBitsequence *cbs,
                                         GtUword position)
{
  unsigned int pos_in_block;
  GtCompressedBitsequenceBlockInfo *cbs_bi;

  gt_assert(cbs != NULL);
  gt_assert(position < cbs->num_of_bits);

  pos_in_block = (unsigned int) position % cbs->blocksize;

  gt_compressed_bitsequence_calc_block_info(cbs, position);
  cbs_bi = cbs->cbs_bi;

  pos_in_block += cbs->blocksize - cbs_bi->block_len;
  if (cbs_bi->class == 0)
    return cbs_bi->rank_sum;
  if (cbs_bi->class == cbs->blocksize)
    return cbs_bi->rank_sum + pos_in_block + 1;

  return cbs_bi->rank_sum + gt_popcount_tab_rank_1(cbs->popcount_tab,
                                                   cbs_bi->class,
                                                   cbs_bi->block_offset,
                                                   pos_in_block);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xbf692
movq %rdi, %rbx
cmpq %rsi, 0xb0(%rdi)
jbe 0xbf6c0
movl %esi, %eax
xorl %edx, %edx
divl 0xd8(%rbx)
movl %edx, %ebp
movq %rbx, %rdi
callq 0xbf4c7
movq 0x90(%rbx), %rax
movl 0x18(%rax), %esi
testl %esi, %esi
je 0xbf673
movl 0xd8(%rbx), %edx
movl %edx, %ecx
subl 0x1c(%rax), %ecx
addl %ebp, %ecx
movq 0x10(%rax), %r14
cmpl %edx, %esi
jne 0xbf679
movl %ecx, %eax
addq %rax, %r14
incq %r14
jmp 0xbf68a
movq 0x10(%rax), %r14
jmp 0xbf68a
movq 0x68(%rbx), %rdi
movq (%rax), %rdx
callq 0x104896
movl %eax, %eax
addq %rax, %r14
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x3788cf(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x225970(%rip), %rsi    # 0x2e5013
leaq 0x2591f6(%rip), %rdx    # 0x3188a0
leaq 0x259238(%rip), %rcx    # 0x3188e9
leaq 0x25917e(%rip), %r8     # 0x318836
movl $0x220, %r9d            # imm = 0x220
jmp 0xbf6ec
movq 0x3788a1(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x225942(%rip), %rsi    # 0x2e5013
leaq 0x2591f5(%rip), %rdx    # 0x3188cd
leaq 0x25920a(%rip), %rcx    # 0x3188e9
leaq 0x259150(%rip), %r8     # 0x318836
movl $0x221, %r9d            # imm = 0x221
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/compressed_bitsequence.c
// Function: gt_compressed_bitsequence_rank_0
GtUword gt_compressed_bitsequence_rank_0(GtCompressedBitsequence *cbs,
                                         GtUword position)
{
  unsigned int pos_in_block;
  GtUword rank_sum0;
  GtCompressedBitsequenceBlockInfo *cbs_bi;

  gt_assert(cbs != NULL);
  gt_assert(position < cbs->num_of_bits);

  pos_in_block = (unsigned int) position % cbs->blocksize;

  gt_compressed_bitsequence_calc_block_info(cbs, position);
  cbs_bi = cbs->cbs_bi;

  pos_in_block += cbs->blocksize - cbs_bi->block_len;
  rank_sum0 = ((cbs_bi->idx) * cbs->blocksize) - cbs_bi->rank_sum;
  rank_sum0 -= cbs->blocksize - cbs_bi->block_len;
  if (cbs_bi->class == 0)
    return rank_sum0 + pos_in_block + 1;
  if (cbs_bi->class == cbs->blocksize)
    return rank_sum0;
  return rank_sum0 + gt_popcount_tab_rank_0(cbs->popcount_tab,
                                            cbs_bi->class,
                                            cbs_bi->block_offset,
                                            pos_in_block);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xbf778
movq %rdi, %rbx
cmpq %rsi, 0xb0(%rdi)
jbe 0xbf7a6
movl %esi, %eax
xorl %edx, %edx
divl 0xd8(%rbx)
movl %edx, %ebp
movq %rbx, %rdi
callq 0xbf4c7
movq 0x90(%rbx), %rax
movl 0xd8(%rbx), %ecx
movl %ecx, %edx
subl 0x1c(%rax), %edx
addl %edx, %ebp
movq %rcx, %r14
imulq 0x8(%rax), %r14
addq 0x10(%rax), %rdx
subq %rdx, %r14
movl 0x18(%rax), %esi
testl %esi, %esi
je 0xbf768
cmpl %ecx, %esi
je 0xbf770
movq 0x68(%rbx), %rdi
movq (%rax), %rdx
movl %ebp, %ecx
callq 0x104a5a
movl %eax, %eax
addq %rax, %r14
jmp 0xbf770
movl %ebp, %eax
addq %rax, %r14
incq %r14
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x3787e9(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x22588a(%rip), %rsi    # 0x2e5013
leaq 0x259110(%rip), %rdx    # 0x3188a0
leaq 0x259173(%rip), %rcx    # 0x31890a
leaq 0x259098(%rip), %r8     # 0x318836
movl $0x23b, %r9d            # imm = 0x23B
jmp 0xbf7d2
movq 0x3787bb(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x22585c(%rip), %rsi    # 0x2e5013
leaq 0x25910f(%rip), %rdx    # 0x3188cd
leaq 0x259145(%rip), %rcx    # 0x31890a
leaq 0x25906a(%rip), %r8     # 0x318836
movl $0x23c, %r9d            # imm = 0x23C
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/compressed_bitsequence.c
// Function: gt_compressed_bitsequence_get_variable_field
static inline GtBitsequence gt_compressed_bitsequence_get_variable_field(
                                                          GtBitsequence *bitseq,
                                                          GtUword start,
                                                          unsigned int len)
{
  GtBitsequence result = 0;
  gt_assert(len <= (unsigned int) GT_INTWORDSIZE);
  if (len != 0) {
    const unsigned int bit_offset = (unsigned int) GT_MODWORDSIZE(start);
    const GtUword word_offset = GT_DIVWORDSIZE(start);

    result = bitseq[word_offset] << (GtBitsequence) bit_offset;
    if ((unsigned int) bit_offset + len > (unsigned int) GT_INTWORDSIZE)
      result |= bitseq[word_offset + 1] >>
                                  (GtBitsequence) (GT_INTWORDSIZE - bit_offset);
    result >>= (GtBitsequence) (GT_INTWORDSIZE-len);
  }
  return result;
}

// Assembly:
cmpl $0x41, %edx
jae 0xbfb0a
testl %edx, %edx
je 0xbfb07
movq %rsi, %r8
shrq $0x6, %r8
movq (%rdi,%r8,8), %rax
movl %esi, %ecx
shlq %cl, %rax
movl %esi, %ecx
andl $0x3f, %ecx
leal (%rcx,%rdx), %esi
cmpl $0x41, %esi
jb 0xbfaff
movq 0x8(%rdi,%r8,8), %rsi
negb %cl
shrq %cl, %rsi
orq %rsi, %rax
negb %dl
movl %edx, %ecx
shrq %cl, %rax
retq
xorl %eax, %eax
retq
pushq %rax
movq 0x378456(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2254f7(%rip), %rsi    # 0x2e5013
leaq 0x259152(%rip), %rdx    # 0x318c75
leaq 0x259170(%rip), %rcx    # 0x318c9a
leaq 0x258d05(%rip), %r8     # 0x318836
movl $0xbd, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/compressed_bitsequence.c
// Function: gt_compressed_bitsequence_get_class
static inline unsigned int
gt_compressed_bitsequence_get_class(GtCompressedBitsequence *cbs,
                                    GtUword idx)
{
  gt_assert(cbs != NULL);
  gt_assert(cbs->classes != NULL);
  return (unsigned int)
    gt_compressed_bitsequence_get_variable_field(cbs->classes,
                                                 idx * cbs->class_bits,
                                                 cbs->class_bits);
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0xbfb65
movq %rdi, %rax
movq 0x78(%rdi), %rdi
testq %rdi, %rdi
je 0xbfb93
movl 0xdc(%rax), %edx
imulq %rdx, %rsi
popq %rax
jmp 0xbfacc
movq 0x3783fc(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x22549d(%rip), %rsi    # 0x2e5013
leaq 0x258d23(%rip), %rdx    # 0x3188a0
leaq 0x259143(%rip), %rcx    # 0x318cc7
leaq 0x258cab(%rip), %r8     # 0x318836
movl $0xf6, %r9d
jmp 0xbfbbf
movq 0x3783ce(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x22546f(%rip), %rsi    # 0x2e5013
leaq 0x259140(%rip), %rdx    # 0x318ceb
leaq 0x259115(%rip), %rcx    # 0x318cc7
leaq 0x258c7d(%rip), %r8     # 0x318836
movl $0xf7, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/compressed_bitsequence.c
// Function: gt_compressed_bitsequence_file_size
size_t gt_compressed_bitsequence_file_size(const GtCompressedBitsequence *cbs)
{
  size_t size = gt_compressed_bitsequence_header_size(cbs);

  size += sizeof (cbs->c_offsets[0]) * cbs->c_offsets_size;
  size += sizeof (cbs->classes[0]) * cbs->classes_size;
  size += sizeof (cbs->superblockoffsets[0]) * cbs->superblockoffsets_size;
  size += sizeof (cbs->superblockranks[0]) * cbs->superblockranks_size;

  return size;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0xbffad
movq 0xa8(%rbx), %rax
addq 0xa0(%rbx), %rax
addq 0xc8(%rbx), %rax
addq 0xd0(%rbx), %rax
leaq 0x50(,%rax,8), %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/compressed_bitsequence.c
// Function: gt_compressed_bitsequence_size
size_t gt_compressed_bitsequence_size(const GtCompressedBitsequence *cbs)
{
  size_t size =  sizeof (cbs) +
    gt_popcount_tab_calculate_size(cbs->blocksize) +
    sizeof (cbs->cbs_bi) +
    sizeof (cbs->c_offsets[0]) * cbs->c_offsets_size +
    sizeof (cbs->classes[0]) * cbs->classes_size +
    sizeof (cbs->superblockoffsets[0]) * cbs->superblockoffsets_size +
    sizeof (cbs->superblockranks[0]) * cbs->superblockranks_size;

  return size;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0xd8(%rdi), %edi
callq 0x1046b6
movq 0xa8(%rbx), %rcx
addq 0xa0(%rbx), %rcx
addq 0xc8(%rbx), %rcx
addq 0xd0(%rbx), %rcx
leaq (%rax,%rcx,8), %rax
addq $0x10, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/compressed_bitsequence.c
// Function: gt_compressed_bitsequence_write
int gt_compressed_bitsequence_write(GtCompressedBitsequence *cbs,
                                    char *filename,
                                    GtError *err)
{
  int had_err = 0;
  GtUword expectedsize = 0;
  FILE *fp = NULL;

  fp = gt_fa_fopen(filename, "w", err);
  if (fp == NULL)
    had_err = -1;

  if (!had_err) {
    expectedsize = (GtUword) gt_compressed_bitsequence_file_size(cbs);
    had_err = gt_mapspec_write(gt_compressed_bitsequence_data_setup_mapspec,
                               fp, cbs, expectedsize, err);
  }
  if (!had_err) {
    gt_log_log("blocksize: %u\n"
           "class_offsets_size: " GT_WU "\n"
           "class_bits: %u\n"
           "classes_size: " GT_WU "\n"
           "last_block_len: %u\n"
           "num_of_bits: " GT_WU "\n"
           "num_of_blocks: " GT_WU "\n"
           "num_of_superblocks: " GT_WU "\n"
           "superblocksize: %u\n"
           "size: " GT_WU "\n",
           cbs->blocksize,
           cbs->c_offsets_size,
           cbs->class_bits,
           cbs->classes_size,
           cbs->last_block_len,
           cbs->num_of_bits,
           cbs->num_of_blocks,
           cbs->num_of_superblocks,
           cbs->superblocksize,
           expectedsize);
  }
  gt_fa_fclose(fp);

  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdx, %r15
movq %rsi, %rax
movq %rdi, %r14
leaq 0x2738d1(%rip), %rsi    # 0x33390e
leaq 0x2587f2(%rip), %rdx    # 0x318836
movq %rax, %rdi
movl $0x3b3, %ecx            # imm = 0x3B3
movq %r15, %r8
callq 0x8a156
movq %rax, %rbx
testq %rax, %rax
je 0xc00e6
movq %r14, %rdi
callq 0xbff7e
movq %rax, %r12
leaq 0x8e(%rip), %rdi        # 0xc0100
movq %rbx, %rsi
movq %r14, %rdx
movq %rax, %rcx
movq %r15, %r8
callq 0x945a2
movl %eax, %ebp
testl %eax, %eax
jne 0xc00e9
movl 0xd8(%r14), %esi
movl 0xdc(%r14), %ecx
movq 0xa0(%r14), %rdx
movq 0xa8(%r14), %r8
movl 0xe0(%r14), %r9d
movups 0xb0(%r14), %xmm0
movq 0xc0(%r14), %rax
movl 0xec(%r14), %edi
movq %r12, 0x20(%rsp)
movl %edi, 0x18(%rsp)
movq %rax, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0x2588d2(%rip), %rdi    # 0x3189ad
xorl %ebp, %ebp
xorl %eax, %eax
callq 0x92a82
jmp 0xc00e9
pushq $-0x1
popq %rbp
movq %rbx, %rdi
callq 0x8a4fd
movl %ebp, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/compressed_bitsequence.c
// Function: gt_compressed_bitsequence_data_setup_mapspec
static void gt_compressed_bitsequence_data_setup_mapspec(GtMapspec *mapspec,
                                                         void *data,
                                                         GT_UNUSED bool write)
{
  GtCompressedBitsequence *cbs = data;

  /* this makes writing easy, and solves the problem of knowing where the data
     starts within the file/mapped area */
  gt_compressed_bitsequence_header_setup_mapspec(mapspec, data, write);

  gt_mapspec_add_bitsequence(mapspec, cbs->c_offsets, cbs->c_offsets_size);
  gt_mapspec_add_bitsequence(mapspec, cbs->classes, cbs->classes_size);
  gt_mapspec_add_bitsequence(mapspec, cbs->superblockoffsets,
                             cbs->superblockoffsets_size);
  gt_mapspec_add_bitsequence(mapspec, cbs->superblockranks,
                             cbs->superblockranks_size);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xc03a8
leaq 0x70(%rbx), %rsi
movq 0xa0(%rbx), %rdx
movq %r14, %rdi
callq 0x94e19
leaq 0x78(%rbx), %rsi
movq 0xa8(%rbx), %rdx
movq %r14, %rdi
callq 0x94e19
leaq 0x80(%rbx), %rsi
movq 0xc8(%rbx), %rdx
movq %r14, %rdi
callq 0x94e19
movq 0xd0(%rbx), %rdx
addq $0x88, %rbx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x94e19
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/compressed_bitsequence.c
// Function: gt_compressed_bitsequence_delete
void gt_compressed_bitsequence_delete(GtCompressedBitsequence *cbs)
{
  if (cbs != NULL) {
    gt_popcount_tab_delete(cbs->popcount_tab);
    if (cbs->from_file) {
      gt_fa_xmunmap(cbs->mmapped);
    }
    else {
      gt_free(cbs->classes);
      gt_free(cbs->c_offsets);
      gt_free(cbs->superblockranks);
      gt_free(cbs->superblockoffsets);
    }
    gt_free(cbs->cbs_bi);
    gt_free(cbs);
  }
}

// Assembly:
testq %rdi, %rdi
je 0xc0543
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x68(%rdi), %rdi
callq 0x10450b
cmpb $0x1, 0xf0(%rbx)
jne 0xc0544
movq 0x98(%rbx), %rdi
callq 0x8b9fa
jmp 0xc0595
retq
movq 0x78(%rbx), %rdi
leaq 0x2582e7(%rip), %r14    # 0x318836
movq %r14, %rsi
movl $0x429, %edx            # imm = 0x429
callq 0x936f9
movq 0x70(%rbx), %rdi
movq %r14, %rsi
movl $0x42a, %edx            # imm = 0x42A
callq 0x936f9
movq 0x88(%rbx), %rdi
movq %r14, %rsi
movl $0x42b, %edx            # imm = 0x42B
callq 0x936f9
movq 0x80(%rbx), %rdi
movq %r14, %rsi
movl $0x42c, %edx            # imm = 0x42C
callq 0x936f9
movq 0x90(%rbx), %rdi
leaq 0x258293(%rip), %r14    # 0x318836
movq %r14, %rsi
movl $0x42e, %edx            # imm = 0x42E
callq 0x936f9
movq %rbx, %rdi
movq %r14, %rsi
movl $0x42f, %edx            # imm = 0x42F
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x936f9
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/compressed_bitsequence.c
// Function: gt_compressed_bitsequence_set_variable_field
static inline void
gt_compressed_bitsequence_set_variable_field(GtBitsequence *bitseq,
                                             GT_UNUSED GtUword size,
                                             GtUword start,
                                             unsigned int len,
                                             GtBitsequence value)
{
  const unsigned int bit_offset = (unsigned int) GT_MODWORDSIZE(start);
  const GtUword word_offset = GT_DIVWORDSIZE(start);
  const unsigned int bits_left = (unsigned int) (GT_INTWORDSIZE - bit_offset);
  GtBitsequence mask;
  mask = (bits_left == (unsigned int) GT_INTWORDSIZE) ?
    0 :
    ~((GtBitsequence) 0) << (GtBitsequence) bits_left;

  if (len > bits_left) {
    unsigned int overhang = len - bits_left;
    gt_assert(word_offset + 1 < size);

    bitseq[word_offset] &= mask;
    bitseq[word_offset] |= (value >> (GtBitsequence) overhang);

    mask = ~((GtBitsequence) 0) >> (GtBitsequence) overhang;
    bitseq[word_offset + 1] &= mask;
    bitseq[word_offset + 1] |=
      value << (GtBitsequence) (GT_INTWORDSIZE - overhang);
  }
  else {
    gt_assert(word_offset < size);
    if (bit_offset + len != (unsigned int) GT_INTWORDSIZE)
      mask |= ~((GtBitsequence) 0) >> (GtBitsequence) (bit_offset + len);

    bitseq[word_offset] &= mask;
    bitseq[word_offset] |= value << (GtBitsequence) (bits_left - len);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %eax
movl %edx, %r10d
andl $0x3f, %r10d
shrq $0x6, %rdx
pushq $0x40
popq %rbx
movl %r10d, %ecx
negl %ecx
pushq $-0x1
popq %r14
movq %r14, %r9
shlq %cl, %r9
movl %ebx, %ecx
subl %r10d, %ecx
xorl %r11d, %r11d
testl %r10d, %r10d
cmovneq %r9, %r11
movl %ecx, %r9d
subl %eax, %r9d
jae 0xc10e2
leaq 0x1(%rdx), %r9
cmpq %rsi, %r9
jae 0xc1118
subl %ecx, %eax
andq (%rdi,%rdx,8), %r11
movq %r8, %rsi
movl %eax, %ecx
shrq %cl, %rsi
orq %r11, %rsi
movq %rsi, (%rdi,%rdx,8)
movq 0x8(%rdi,%rdx,8), %r11
shlq %cl, %r11
shrq %cl, %r11
leaq (%rdi,%r9,8), %rdx
subl %eax, %ebx
movl %ebx, %r9d
jmp 0xc1104
cmpq %rsi, %rdx
jae 0xc1146
addl %eax, %r10d
movl %r10d, %ecx
shrq %cl, %r14
xorl %eax, %eax
cmpl $0x40, %r10d
cmovneq %r14, %rax
orq %rax, %r11
leaq (%rdi,%rdx,8), %rdx
andq (%rdx), %r11
movl %r9d, %ecx
shlq %cl, %r8
orq %r11, %r8
movq %r8, (%rdx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x376e49(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x223eea(%rip), %rsi    # 0x2e5013
leaq 0x257aee(%rip), %rdx    # 0x318c1e
leaq 0x257afe(%rip), %rcx    # 0x318c35
leaq 0x2576f8(%rip), %r8     # 0x318836
movl $0xde, %r9d
jmp 0xc1172
movq 0x376e1b(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x223ebc(%rip), %rsi    # 0x2e5013
leaq 0x257b04(%rip), %rdx    # 0x318c62
leaq 0x257ad0(%rip), %rcx    # 0x318c35
leaq 0x2576ca(%rip), %r8     # 0x318836
movl $0xe9, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
nop
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/condenseq.c
// Function: gt_condenseq_seqstartpos
GtUword gt_condenseq_seqstartpos(const GtCondenseq *condenseq, GtUword seqnum)
{
  GtUword ret = 0;
  if (seqnum != 0)
    ret = gt_intset_get(condenseq->ssptab, seqnum - 1) + 1;
  return ret;
}

// Assembly:
testq %rsi, %rsi
je 0xc11b0
pushq %rax
movq 0x28(%rdi), %rdi
decq %rsi
callq 0xf363c
incq %rax
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/condenseq.c
// Function: gt_condenseq_description
const char *gt_condenseq_description(const GtCondenseq *condenseq,
                                     GtUword *desclen,
                                     GtUword seqnum)
{
  gt_assert(condenseq != NULL);
  gt_assert(condenseq->orig_num_seq != 0);
  gt_assert(seqnum < condenseq->orig_num_seq);
  if (condenseq->id_len == GT_UNDEF_UWORD) {
    GtUword this = gt_intset_get(condenseq->sdstab, seqnum), previous;
    if (seqnum == 0) {
      *desclen = this;
      return condenseq->orig_ids;
    }
    previous = gt_intset_get(condenseq->sdstab, seqnum - 1);
    *desclen =  this - previous;
    return condenseq->orig_ids + previous;
  }
  else {
    const char *id = condenseq->orig_ids + seqnum * condenseq->id_len;
    *desclen = condenseq->id_len;
    while (id[*desclen - 1] == '\0')
      (*desclen)--;
    return condenseq->orig_ids + seqnum * condenseq->id_len;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xc12a5
movq %rdi, %rbx
movq 0x80(%rdi), %rax
testq %rax, %rax
je 0xc12d3
movq %rdx, %r15
cmpq %rdx, %rax
jbe 0xc1301
movq %rsi, %r14
movq 0x58(%rbx), %rcx
cmpq $-0x1, %rcx
je 0xc1263
movq 0x48(%rbx), %rax
leaq 0x1(%r15), %rdx
imulq %rcx, %rdx
addq %rax, %rdx
decq %rdx
movq %rcx, (%r14)
decq %rcx
cmpb $0x0, (%rdx)
leaq -0x1(%rdx), %rdx
je 0xc124a
imulq 0x58(%rbx), %r15
addq %r15, %rax
jmp 0xc1299
movq 0x20(%rbx), %rdi
movq %r15, %rsi
callq 0xf363c
movq %rax, %r12
testq %r15, %r15
je 0xc1292
movq 0x20(%rbx), %rdi
decq %r15
movq %r15, %rsi
callq 0xf363c
subq %rax, %r12
movq %r12, (%r14)
addq 0x48(%rbx), %rax
jmp 0xc1299
movq %r12, (%r14)
movq 0x48(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x376cbc(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x223d5d(%rip), %rsi    # 0x2e5013
leaq 0x257c8c(%rip), %rdx    # 0x318f49
leaq 0x257c97(%rip), %rcx    # 0x318f5b
leaq 0x257ca9(%rip), %r8     # 0x318f74
movl $0xc7, %r9d
jmp 0xc132d
movq 0x376c8e(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x223d2f(%rip), %rsi    # 0x2e5013
leaq 0x257ca2(%rip), %rdx    # 0x318f8d
leaq 0x257c69(%rip), %rcx    # 0x318f5b
leaq 0x257c7b(%rip), %r8     # 0x318f74
movl $0xc8, %r9d
jmp 0xc132d
movq 0x376c60(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x223d01(%rip), %rsi    # 0x2e5013
leaq 0x257c91(%rip), %rdx    # 0x318faa
leaq 0x257c3b(%rip), %rcx    # 0x318f5b
leaq 0x257c4d(%rip), %r8     # 0x318f74
movl $0xc9, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/condenseq.c
// Function: condenseq_new_empty
static GtCondenseq *condenseq_new_empty(const GtAlphabet *alph)
{
  GtCondenseq *condenseq = gt_malloc(sizeof (*condenseq));
  condenseq->alphabet = gt_alphabet_ref((GtAlphabet *) alph);

  condenseq->buffsize =
    condenseq->lds_allocated =
    condenseq->lds_nelems =
    condenseq->orig_len =
    condenseq->orig_num_seq =
    condenseq->ubuffsize =
    condenseq->uds_allocated =
    condenseq->uds_nelems = 0;

  condenseq->id_len = GT_UNDEF_UWORD;

  condenseq->buffer = NULL;
  condenseq->filename = NULL;
  condenseq->links = NULL;
  condenseq->orig_ids = NULL;
  condenseq->sdstab = NULL;
  condenseq->ssptab = NULL;
  condenseq->ubuffer = NULL;
  condenseq->unique_es = NULL;
  condenseq->uniques = NULL;

  return condenseq;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x257895(%rip), %rsi    # 0x318f74
movl $0xa0, %edi
movl $0xdf, %edx
callq 0x93160
movq %rax, %r14
movq %rbx, %rdi
callq 0x5644e
movq %rax, (%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x68(%r14)
movups %xmm0, 0x78(%r14)
andq $0x0, 0x98(%r14)
movups %xmm0, 0x88(%r14)
orq $-0x1, 0x58(%r14)
movups %xmm0, 0x8(%r14)
movups %xmm0, 0x18(%r14)
movups %xmm0, 0x28(%r14)
movups %xmm0, 0x38(%r14)
movups %xmm0, 0x48(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/condenseq.c
// Function: gt_condenseq_total_link_len
GtUword gt_condenseq_total_link_len(const GtCondenseq *condenseq)
{
  GtUword total = 0,
          i;

  for (i = 0; i < condenseq->lds_nelems; i++) {
    total += condenseq->links[i].len;
  }

  return total;
}

// Assembly:
movq 0x70(%rdi), %rcx
pushq $0x10
popq %rdx
xorl %eax, %eax
subq $0x1, %rcx
jb 0xc176e
movq 0x8(%rdi), %rsi
movl (%rsi,%rdx), %esi
addq %rsi, %rax
addq $0x20, %rdx
jmp 0xc1758
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/condenseq.c
// Function: gt_condenseq_add_link_to_db
void gt_condenseq_add_link_to_db(GtCondenseq *condenseq, GtCondenseqLink link)
{
  condenseq_lds_resize(condenseq);
  gt_assert(condenseq->links != NULL);
  gt_assert(condenseq->lds_nelems == 0 ||
            condenseq->links[condenseq->lds_nelems - 1].orig_startpos +
            condenseq->links[condenseq->lds_nelems - 1].len <=
            link.orig_startpos);
  gt_assert(condenseq->uds_nelems == 0 ||
            condenseq->uniques[condenseq->uds_nelems - 1].orig_startpos +
            condenseq->uniques[condenseq->uds_nelems - 1].len <=
            link.orig_startpos);
  condenseq->links[condenseq->lds_nelems] = link;
  condenseq->lds_nelems++;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x70(%rdi), %rax
cmpq 0x68(%rdi), %rax
jne 0xc1a0d
movq %rax, %xmm0
punpckldq 0x225f3b(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x225f43(%rip), %xmm0   # 0x2e78f0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
mulsd 0x226357(%rip), %xmm1   # 0x2e7d18
cvttsd2si %xmm1, %rcx
movq %rcx, %rdx
sarq $0x3f, %rdx
subsd 0x22634b(%rip), %xmm1   # 0x2e7d20
cvttsd2si %xmm1, %rdi
andq %rdx, %rdi
orq %rcx, %rdi
testq %rax, %rax
pushq $0x64
popq %rsi
cmovneq %rdi, %rsi
movq %rsi, 0x68(%rbx)
movq 0x8(%rbx), %rdi
shlq $0x5, %rsi
leaq 0x257577(%rip), %rdx    # 0x318f74
movl $0x14a, %ecx            # imm = 0x14A
callq 0x93472
movq %rax, 0x8(%rbx)
jmp 0xc1a11
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0xc1a78
leaq 0x10(%rsp), %rdx
movq 0x70(%rbx), %rcx
testq %rcx, %rcx
je 0xc1a3a
movq %rcx, %rsi
shlq $0x5, %rsi
movl -0x10(%rax,%rsi), %edi
addq -0x18(%rax,%rsi), %rdi
cmpq 0x8(%rdx), %rdi
ja 0xc1aa6
movq 0x98(%rbx), %rsi
testq %rsi, %rsi
je 0xc1a5e
movq 0x10(%rbx), %rdi
imulq $0x28, %rsi, %rsi
movl -0x8(%rdi,%rsi), %r8d
addq -0x10(%rdi,%rsi), %r8
cmpq 0x8(%rdx), %r8
ja 0xc1ad4
shlq $0x5, %rcx
movups (%rdx), %xmm0
movups 0x10(%rdx), %xmm1
movups %xmm1, 0x10(%rax,%rcx)
movups %xmm0, (%rax,%rcx)
incq 0x70(%rbx)
popq %rbx
retq
movq 0x3764e9(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x22358a(%rip), %rsi    # 0x2e5013
leaq 0x257692(%rip), %rdx    # 0x319122
leaq 0x2576a4(%rip), %rcx    # 0x31913b
leaq 0x2574d6(%rip), %r8     # 0x318f74
movl $0x16d, %r9d            # imm = 0x16D
jmp 0xc1b00
movq 0x3764bb(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x22355c(%rip), %rsi    # 0x2e5013
leaq 0x257699(%rip), %rdx    # 0x319157
leaq 0x257676(%rip), %rcx    # 0x31913b
leaq 0x2574a8(%rip), %r8     # 0x318f74
movl $0x171, %r9d            # imm = 0x171
jmp 0xc1b00
movq 0x37648d(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x22352e(%rip), %rsi    # 0x2e5013
leaq 0x25770b(%rip), %rdx    # 0x3191f7
leaq 0x257648(%rip), %rcx    # 0x31913b
leaq 0x25747a(%rip), %r8     # 0x318f74
movl $0x175, %r9d            # imm = 0x175
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/condenseq.c
// Function: gt_condenseq_delete
void gt_condenseq_delete(GtCondenseq *condenseq)
{
  if (condenseq != NULL) {
    GtUword i;
    for (i = 0; i < condenseq->lds_nelems; i++) {
      gt_editscript_delete(condenseq->links[i].editscript);
    }
    for (i = 0; i < condenseq->uds_nelems; i++) {
      GT_FREEARRAY(&(condenseq->uniques[i].links), uint32_t);
    }
    gt_alphabet_delete(condenseq->alphabet);
    gt_encseq_delete(condenseq->unique_es);
    gt_free(condenseq->buffer);
    gt_free(condenseq->filename);
    gt_free(condenseq->links);
    gt_free(condenseq->orig_ids);
    gt_free(condenseq->ubuffer);
    gt_free(condenseq->uniques);
    gt_intset_delete(condenseq->sdstab);
    gt_intset_delete(condenseq->ssptab);

    gt_free(condenseq);
  }
}

// Assembly:
testq %rdi, %rdi
je 0xc1c38
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
xorl %r15d, %r15d
cmpq 0x70(%rbx), %r15
jae 0xc1b42
movq 0x8(%rbx), %rax
movq (%rax,%r14), %rdi
callq 0xce497
incq %r15
addq $0x20, %r14
jmp 0xc1b26
xorl %r15d, %r15d
leaq 0x257428(%rip), %r14    # 0x318f74
xorl %r12d, %r12d
cmpq 0x98(%rbx), %r12
jae 0xc1b8d
movq 0x10(%rbx), %rax
movq (%rax,%r15), %rdi
testq %rdi, %rdi
je 0xc1b84
movq %r14, %rsi
movl $0x182, %edx            # imm = 0x182
callq 0x936f9
movq 0x10(%rbx), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rax,%r15)
andq $0x0, 0x10(%rax,%r15)
incq %r12
addq $0x28, %r15
jmp 0xc1b4f
movq (%rbx), %rdi
callq 0x568b5
movq 0x18(%rbx), %rdi
callq 0x735fd
movq 0x38(%rbx), %rdi
leaq 0x2573cb(%rip), %r14    # 0x318f74
movq %r14, %rsi
movl $0x186, %edx            # imm = 0x186
callq 0x936f9
movq 0x40(%rbx), %rdi
movq %r14, %rsi
movl $0x187, %edx            # imm = 0x187
callq 0x936f9
movq 0x8(%rbx), %rdi
movq %r14, %rsi
movl $0x188, %edx            # imm = 0x188
callq 0x936f9
movq 0x48(%rbx), %rdi
movq %r14, %rsi
movl $0x189, %edx            # imm = 0x189
callq 0x936f9
movq 0x30(%rbx), %rdi
movq %r14, %rsi
movl $0x18a, %edx            # imm = 0x18A
callq 0x936f9
movq 0x10(%rbx), %rdi
movq %r14, %rsi
movl $0x18b, %edx            # imm = 0x18B
callq 0x936f9
movq 0x20(%rbx), %rdi
callq 0xf3a29
movq 0x28(%rbx), %rdi
callq 0xf3a29
movq %rbx, %rdi
movq %r14, %rsi
movl $0x18f, %edx            # imm = 0x18F
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/condenseq.c
// Function: gt_condenseq_basefilename
char *gt_condenseq_basefilename(const GtCondenseq *condenseq)
{
  char *basename = NULL,
       *suffix_ptr;
  if (condenseq->filename != NULL) {
    basename = gt_basename(condenseq->filename);
    if (strlen(basename) > (size_t) 1 &&
        (suffix_ptr = strrchr(basename + 1, '.')) != NULL) {
      /* remove suffix */
      *suffix_ptr = '\0';
    }
  }
  return basename;
}

// Assembly:
pushq %rbx
movq 0x40(%rdi), %rdi
testq %rdi, %rdi
je 0xc2415
callq 0x5a384
movq %rax, %rbx
movq %rax, %rdi
callq 0x172d0
cmpq $0x2, %rax
jb 0xc2417
movq %rbx, %rdi
incq %rdi
pushq $0x2e
popq %rsi
callq 0x17830
testq %rax, %rax
je 0xc2417
movb $0x0, (%rax)
jmp 0xc2417
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/condenseq.c
// Function: gt_condenseq_unique_fasta_file
GtStr *gt_condenseq_unique_fasta_file(const GtCondenseq *condenseq)
{
  GtStr *unique = NULL;
  gt_assert(condenseq != NULL);
  if (condenseq->filename != NULL) {
    unique = gt_str_new_cstr(condenseq->filename);
    gt_str_append_cstr(unique, ".fas");
  }
  return unique;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0xc244b
movq 0x40(%rdi), %rdi
testq %rdi, %rdi
je 0xc2444
callq 0xacbd1
movq %rax, %rbx
leaq 0x29dfd8(%rip), %rsi    # 0x360412
movq %rax, %rdi
callq 0xacbfb
jmp 0xc2446
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
movq 0x375b16(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x222bb7(%rip), %rsi    # 0x2e5013
leaq 0x256ae6(%rip), %rdx    # 0x318f49
leaq 0x256f5d(%rip), %rcx    # 0x3193c7
leaq 0x256b03(%rip), %r8     # 0x318f74
movl $0x269, %r9d            # imm = 0x269
xorl %eax, %eax
callq 0x17a50
callq 0x17390