LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/typecheck_info.c
// Function: get_obo_path
static GtStr* get_obo_path(GtError *err)
{
  const char *progname;
  GtStr *obo_path, *prog;
  gt_error_check(err);
  progname = gt_error_get_progname(err);
  gt_assert(progname != NULL);
  prog = gt_str_new();
  gt_str_append_cstr_nt(prog, progname,
                        gt_cstr_length_up_to_char(progname, ' '));
  obo_path = gt_get_gtdata_path(gt_str_get(prog), err);
  if (obo_path)
    gt_str_append_cstr(obo_path, "/obo_files/");
  gt_str_delete(prog);
  return obo_path;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
je 0x183503
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0x183576
movq %rbx, %rdi
callq 0xfccba
testq %rax, %rax
je 0x183571
movq %rax, %r15
callq 0x11ac6c
movq %rax, %r14
movq %r15, %rdi
movl $0x20, %esi
callq 0xe438c
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x11ae1b
movq %r14, %rdi
callq 0x11b0a1
movq %rax, %rdi
movq %rbx, %rsi
callq 0x100758
movq %rax, %rbx
testq %rax, %rax
je 0x183560
leaq 0x2142ab(%rip), %rsi    # 0x397803
movq %rbx, %rdi
callq 0x11acf3
movq %r14, %rdi
callq 0x11bdbf
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x591c2
callq 0x5918b
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/uint64hashtable.c
// Function: gt_uint64hashtable_new
GtUint64hashtable *gt_uint64hashtable_new(size_t nof_elements)
{
  GtUint64hashtable *table;
  const double loadfactor = 1.30;

  table = gt_malloc(sizeof (*table));
  table->countcollisions = 0;
  table->allentries = 0;
  table->zero_occurs = false;
  table->zero_count = 0;
  table->alloc
    = gt_uint64hashtable_get_size((size_t)(1 + loadfactor *
                                               (double) nof_elements));
  table->hspace = gt_calloc(table->alloc, sizeof (*table->hspace));
  return table;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x214291(%rip), %rsi    # 0x397818
movl $0x38, %edi
movl $0x7e, %edx
callq 0x104226
movq %rbx, %xmm0
punpckldq 0x1c433d(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x1c4345(%rip), %xmm0   # 0x3478f0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
mulsd 0x214251(%rip), %xmm1   # 0x397810
addsd 0x1c2c61(%rip), %xmm1   # 0x346228
movq %rax, %rbx
cvttsd2si %xmm1, %rax
movq %rax, %rcx
subsd 0x1c4746(%rip), %xmm1   # 0x347d20
cvttsd2si %xmm1, %rdi
sarq $0x3f, %rcx
andq %rcx, %rdi
orq %rax, %rdi
movabsq $0x7fc0002764, %rax     # imm = 0x7FC0002764
xorpd %xmm0, %xmm0
movupd %xmm0, 0x18(%rbx)
movupd %xmm0, 0x21(%rbx)
cmpq %rax, %rdi
jae 0x18368e
movl $0x100007, %eax         # imm = 0x100007
cmpq $0x100007, %rdi         # imm = 0x100007
jb 0x183669
movl $0x97f, %ecx            # imm = 0x97F
movl $0x4bf, %r8d            # imm = 0x4BF
xorl %esi, %esi
leaq 0x214514(%rip), %rdx    # 0x397b40
movq %rcx, %rax
subq %rsi, %rax
cmpq $0x1, %rax
je 0x18365c
movq (%rdx,%r8,8), %rax
cmpq %rdi, %rax
jbe 0x183646
movq %r8, %rcx
jmp 0x18364b
movq %r8, %rsi
jae 0x183669
leaq (%rcx,%rsi), %r8
shrq %r8
cmpq %rsi, %rcx
jae 0x18362c
callq 0x591f9
movq %rdi, %rax
cmpq %rdi, (%rdx,%rsi,8)
je 0x183669
movq (%rdx,%rcx,8), %rax
movq %rax, 0x10(%rbx)
leaq 0x2141a4(%rip), %rdx    # 0x397818
movl $0x10, %esi
movq %rax, %rdi
movl $0x86, %ecx
callq 0x10436a
movq %rax, (%rbx)
movq %rbx, %rax
popq %rbx
retq
callq 0x59230
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/uint64hashtable.c
// Function: gt_uint64hashtable_countsum_get
GtUword gt_uint64hashtable_countsum_get(const GtUint64hashtable *table)
{
  size_t idx;
  GtUword sumcount = 0;

  for (idx=0; idx < table->alloc; idx++)
  {
    if (table->hspace[idx].count > 0)
    {
      sumcount += table->hspace[idx].count;
    }
  }
  return sumcount + table->zero_count;
}

// Assembly:
movq 0x10(%rdi), %rcx
testq %rcx, %rcx
je 0x1839bc
movq (%rdi), %rdx
addq $0x8, %rdx
xorl %eax, %eax
addq (%rdx), %rax
addq $0x10, %rdx
decq %rcx
jne 0x1839ae
jmp 0x1839be
xorl %eax, %eax
addq 0x20(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/uint64hashtable.c
// Function: gt_uint64hashtable_partialsums
GtUword gt_uint64hashtable_partialsums(GtUint64hashtable *table,
                                             GtTimer *timer)
{
  size_t idx, next = 0;
  GtUword psum, maxsize = 0;

  table->sortedhspace = gt_malloc((size_t) table->allentries *
                                  sizeof (*table->sortedhspace));
  if (timer != NULL)
  {
    gt_timer_show_progress(timer, "sorting the hashkeys",stdout);
  }
  for (idx = 0; idx < table->alloc; idx++)
  {
    if (table->hspace[idx].count > 0)
    {
      gt_assert(next < (size_t) table->allentries);
      table->sortedhspace[next++] = idx;
      if (maxsize < table->hspace[idx].count)
      {
        maxsize = table->hspace[idx].count;
      }
    }
  }
  gt_qsort_r(table->sortedhspace,next,sizeof (*table->sortedhspace),
             table->hspace,compareGtUint64hashstoredvalue);
  gt_assert(next > 0);
  if (table->zero_occurs)
  {
    table->hspace[table->sortedhspace[0]].count += table->zero_count;
  }
  if (timer != NULL)
  {
    gt_timer_show_progress(timer, "computing partial sums",stdout);
  }
  for (idx = (size_t) 1; idx < next; idx++)
  {
    table->hspace[table->sortedhspace[idx]].count +=
      table->hspace[table->sortedhspace[idx-1]].count;
  }
  psum = table->hspace[table->sortedhspace[next-1]].count;
  gt_free(table->sortedhspace);
  return psum;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
shlq $0x2, %rdi
leaq 0x213e3b(%rip), %rsi    # 0x397818
movl $0x133, %edx            # imm = 0x133
callq 0x104226
movq %rax, 0x8(%rbx)
testq %r14, %r14
je 0x183a09
movq 0x3354e1(%rip), %rax    # 0x4b8ed8
movq (%rax), %rdx
leaq 0x213fef(%rip), %rsi    # 0x3979f0
movq %r14, %rdi
callq 0x11cc90
leaq 0x8(%rbx), %rdi
movq (%rbx), %rcx
movq 0x10(%rbx), %rax
testq %rax, %rax
je 0x183b01
leaq 0x8(%rcx), %rdx
xorl %esi, %esi
xorl %r15d, %r15d
cmpq $0x0, (%rdx)
je 0x183a40
cmpq 0x28(%rbx), %r15
jae 0x183b0e
movq (%rdi), %r8
movl %esi, (%r8,%r15,4)
incq %r15
incq %rsi
addq $0x10, %rdx
cmpq %rsi, %rax
jne 0x183a26
movq (%rdi), %rdi
leaq 0xbd(%rip), %r8         # 0x183b13
movl $0x4, %edx
movq %r15, %rsi
callq 0x10c638
testq %r15, %r15
je 0x183b09
cmpb $0x1, 0x30(%rbx)
jne 0x183a88
movq 0x20(%rbx), %rax
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
movl (%rdx), %edx
shlq $0x4, %rdx
addq %rax, 0x8(%rcx,%rdx)
testq %r14, %r14
je 0x183aa6
movq 0x335444(%rip), %rax    # 0x4b8ed8
movq (%rax), %rdx
leaq 0x213fb1(%rip), %rsi    # 0x397a4f
movq %r14, %rdi
callq 0x11cc90
movq (%rbx), %rax
movq 0x8(%rbx), %rdi
cmpq $0x1, %r15
je 0x183ad9
movl $0x1, %ecx
movl -0x4(%rdi,%rcx,4), %edx
movl (%rdi,%rcx,4), %esi
shlq $0x4, %rdx
movq 0x8(%rax,%rdx), %rdx
shlq $0x4, %rsi
addq %rdx, 0x8(%rax,%rsi)
incq %rcx
cmpq %rcx, %r15
jne 0x183ab8
movl -0x4(%rdi,%r15,4), %ecx
shlq $0x4, %rcx
movq 0x8(%rax,%rcx), %rbx
leaq 0x213d2a(%rip), %rsi    # 0x397818
movl $0x155, %edx            # imm = 0x155
callq 0x1045eb
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rcx, %rsi
callq 0x5956a
callq 0x59581
callq 0x59531
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/uniq_stream.c
// Function: gt_uniq_stream_class
const GtNodeStreamClass* gt_uniq_stream_class(void)
{
  static const GtNodeStreamClass *nsc = NULL;
  gt_class_alloc_lock_enter();
  if (!nsc) {
    nsc = gt_node_stream_class_new(sizeof (GtUniqStream),
                                   uniq_stream_free,
                                   uniq_stream_next);
  }
  gt_class_alloc_lock_leave();
  return nsc;
}

// Assembly:
pushq %rax
callq 0xe252f
cmpq $0x0, 0x33ab22(%rip)    # 0x4be8f0
jne 0x183def
leaq 0x26(%rip), %rsi        # 0x183dfd
leaq 0x52(%rip), %rdx        # 0x183e30
movl $0x28, %edi
callq 0x162d34
movq %rax, 0x33ab01(%rip)    # 0x4be8f0
callq 0xe2545
movq 0x33aaf5(%rip), %rax    # 0x4be8f0
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/uniq_stream.c
// Function: uniq_stream_free
static void uniq_stream_free(GtNodeStream *ns)
{
  GtUniqStream *us = uniq_stream_cast(ns);
  gt_genome_node_delete(us->first_node);
  gt_genome_node_delete(us->second_node);
  gt_node_stream_delete(us->in_stream);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x183dc0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x162ff7
movq %rax, %rbx
movq 0x18(%rax), %rdi
callq 0x1451a0
movq 0x20(%rbx), %rdi
callq 0x1451a0
movq 0x10(%rbx), %rdi
popq %rbx
jmp 0x162dee
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/uniq_stream.c
// Function: gt_uniq_stream_new
GtNodeStream* gt_uniq_stream_new(GtNodeStream *in_stream)
{
  GtNodeStream *ns;
  GtUniqStream *us;
  gt_assert(in_stream && gt_node_stream_is_sorted(in_stream));
  ns = gt_node_stream_create(gt_uniq_stream_class(), true);
  us = uniq_stream_cast(ns);
  us->in_stream = gt_node_stream_ref(in_stream);
  return ns;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1840e2
movq %rdi, %rbx
callq 0x162fe4
testb %al, %al
je 0x1840e2
callq 0x183dc0
movq %rax, %rdi
movl $0x1, %esi
callq 0x162d6c
movq %rax, %r14
callq 0x183dc0
movq %rax, %rdi
movq %r14, %rsi
callq 0x162ff7
movq %rax, %r15
movq %rbx, %rdi
callq 0x162dd8
movq %rax, 0x10(%r15)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x597a2
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/wtree.c
// Function: gt_wtree_create
GtWtree *gt_wtree_create(const GtWtreeClass *wtree_c)
{
  GtWtree *wtree;
  gt_assert(wtree_c && wtree_c->size);
  wtree = gt_calloc((size_t) 1, wtree_c->size);
  wtree->c_class = wtree_c;
  wtree->members = gt_calloc((size_t) 1, sizeof (GtWtreeMembers));
  return wtree;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1842a5
movq %rdi, %rbx
movq 0x20(%rdi), %rsi
testq %rsi, %rsi
je 0x1842a5
leaq 0x218604(%rip), %r14    # 0x39c86d
movl $0x1, %edi
movq %r14, %rdx
movl $0x1d, %ecx
callq 0x10436a
movq %rax, %r15
movq %rbx, (%rax)
movl $0x1, %edi
movl $0x18, %esi
movq %r14, %rdx
movl $0x1f, %ecx
callq 0x10436a
movq %rax, 0x8(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x59849
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/wtree.c
// Function: gt_wtree_access
GtWtreeSymbol gt_wtree_access(GtWtree *wtree,
                              GtUword pos)
{
  gt_assert(wtree != NULL);
  gt_assert(wtree->c_class != NULL);
  if (wtree->c_class->access_func != NULL)
    return wtree->c_class->access_func(wtree, pos);
  return (GtWtreeSymbol) ULONG_MAX;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x1842fc
movq (%rdi), %rax
testq %rax, %rax
je 0x184301
movq (%rax), %rax
testq %rax, %rax
je 0x1842f3
popq %rcx
jmpq *%rax
movq $-0x1, %rax
popq %rcx
retq
callq 0x59925
callq 0x598ee
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/wtree.c
// Function: gt_wtree_rank
GtUword gt_wtree_rank(GtWtree *wtree,
                      GtUword pos,
                      GtWtreeSymbol symbol)
{
  gt_assert(wtree != NULL);
  gt_assert(wtree->c_class != NULL);
  if (wtree->c_class->rank_func != NULL)
    return wtree->c_class->rank_func(wtree, pos, symbol);
  return ULONG_MAX;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x184329
movq (%rdi), %rax
testq %rax, %rax
je 0x18432e
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x184320
popq %rcx
jmpq *%rax
movq $-0x1, %rax
popq %rcx
retq
callq 0x59993
callq 0x5995c
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/wtree.c
// Function: gt_wtree_select
GtUword gt_wtree_select(GtWtree *wtree,
                        GtUword i,
                        GtWtreeSymbol symbol)
{
  gt_assert(wtree != NULL);
  gt_assert(wtree->c_class != NULL);
  if (wtree->c_class->select_func != NULL)
    return wtree->c_class->select_func(wtree, i, symbol);
  return ULONG_MAX;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x184356
movq (%rdi), %rax
testq %rax, %rax
je 0x18435b
movq 0x18(%rax), %rax
testq %rax, %rax
je 0x18434d
popq %rcx
jmpq *%rax
movq $-0x1, %rax
popq %rcx
retq
callq 0x59a01
callq 0x599ca
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/wtree.c
// Function: gt_wtree_class_new
const GtWtreeClass* gt_wtree_class_new(size_t size,
                                       GtWtreeAccessFunc access_func,
                                       GtWtreeRankFunc rank_func,
                                       GtWtreeSelectFunc select_func,
                                       GtWtreeDeleteFunc delete_func)
{
  GtWtreeClass *wtree_c = gt_malloc(sizeof (*wtree_c));
  wtree_c->size = size;
  wtree_c->access_func = access_func;
  wtree_c->rank_func = rank_func;
  wtree_c->select_func = select_func;
  wtree_c-> delete_func = delete_func;
  return wtree_c;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
leaq 0x2184dd(%rip), %rsi    # 0x39c86d
movl $0x28, %edi
movl $0x62, %edx
callq 0x104226
movq %r13, 0x20(%rax)
movq %r12, (%rax)
movq %r15, 0x10(%rax)
movq %r14, 0x18(%rax)
movq %rbx, 0x8(%rax)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/wtree.c
// Function: gt_wtree_delete
void gt_wtree_delete(GtWtree *wtree)
{
  if (wtree != NULL) {
    if (wtree->members->refcount) {
      wtree->members->refcount--;
      return;
    }
    gt_assert(wtree->c_class);
    if (wtree->c_class->delete_func != NULL)
      wtree->c_class->delete_func(wtree);
    gt_free(wtree->members);
    gt_free(wtree);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1843dc
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x1843e4
decq %rax
movq %rax, 0x10(%rdi)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%rbx), %rax
testq %rax, %rax
je 0x184429
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x1843fe
movq %rbx, %rdi
callq *%rax
movq 0x8(%rbx), %rdi
leaq 0x218468(%rip), %r14    # 0x39c86d
movq %r14, %rsi
movl $0x75, %edx
callq 0x1045eb
movq %rbx, %rdi
movq %r14, %rsi
movl $0x76, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1045eb
callq 0x59a38
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/wtree_encseq.c
// Function: gt_wtree_encseq_unmap_decoded
char gt_wtree_encseq_unmap_decoded(GtWtree *wtree,
                                   GtWtreeSymbol symbol)
{
  GtWtreeEncseq *wtree_encseq;
  GtUchar encseq_sym = (GtUchar) symbol;
  gt_assert((symbol & ((GtUchar) 0)) == 0);
  gt_assert(wtree != NULL);
  wtree_encseq = gt_wtree_encseq_cast(wtree);
  switch (wtree_encseq->alpha_size - encseq_sym) {
    case 1:
      return (char) GT_SEPARATOR;
    case 2:
      return gt_alphabet_decode(wtree_encseq->alpha, (GtUchar) GT_WILDCARD);
    case 3:
      return (char) GT_UNDEFCHAR;
    default:
      return gt_alphabet_decode(wtree_encseq->alpha, encseq_sym);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1844ca
movq %rsi, %rbx
movq %rdi, %r14
movq 0x33a4b6(%rip), %rdi    # 0x4be900
testq %rdi, %rdi
jne 0x18447f
leaq 0xb9(%rip), %rsi        # 0x18450f
leaq 0x2ae(%rip), %rdx       # 0x18470b
leaq 0x513(%rip), %rcx       # 0x184977
leaq 0x5b0(%rip), %r8        # 0x184a1b
movl $0x60, %edi
callq 0x184371
movq %rax, %rdi
movq %rax, 0x33a481(%rip)    # 0x4be900
movq %r14, %rsi
callq 0x1842c1
movl 0x58(%rax), %ecx
movzbl %bl, %edx
subl %edx, %ecx
cmpl $0x1, %ecx
je 0x1844ad
cmpl $0x3, %ecx
je 0x1844a9
cmpl $0x2, %ecx
jne 0x1844b7
movq 0x18(%rax), %rdi
movl $0xfe, %esi
jmp 0x1844be
movb $-0x3, %al
jmp 0x1844af
movb $-0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x18(%rax), %rdi
movzbl %bl, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd187b
callq 0x59a6f
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/wtree_encseq.c
// Function: gt_wtree_encseq_class
const GtWtreeClass* gt_wtree_encseq_class(void)
{
  static const GtWtreeClass *this_c = NULL;
  if (this_c == NULL) {
    this_c =
      gt_wtree_class_new(sizeof (GtWtreeEncseq), gt_wtree_encseq_access,
                         gt_wtree_encseq_rank, gt_wtree_encseq_select,
                         gt_wtree_encseq_delete);
  }
  return this_c;
}

// Assembly:
movq 0x33a42a(%rip), %rax    # 0x4be900
testq %rax, %rax
je 0x1844dc
retq
pushq %rax
leaq 0x2b(%rip), %rsi        # 0x18450f
leaq 0x220(%rip), %rdx       # 0x18470b
leaq 0x485(%rip), %rcx       # 0x184977
leaq 0x522(%rip), %r8        # 0x184a1b
movl $0x60, %edi
callq 0x184371
movq %rax, 0x33a3f6(%rip)    # 0x4be900
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/wtree_encseq.c
// Function: gt_wtree_encseq_access
static GtWtreeSymbol gt_wtree_encseq_access(GtWtree *wtree,
                                            GtUword pos)
{
  unsigned int alpha_start = 0,
               alpha_end;
  GtUword node_start = 0,
          node_size;
  GtWtreeEncseq *we;
  gt_assert(wtree != NULL);

  we = gt_wtree_encseq_cast(wtree);
  gt_assert(pos < wtree->members->length);

  alpha_end = we->alpha_size - 1;
  node_size = wtree->members->length;

  return gt_wtree_encseq_access_rec(we, pos, node_start, node_size, alpha_start,
                                    alpha_end);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
testq %rdi, %rdi
je 0x184701
movq %rsi, %rbx
movq %rdi, %r14
movq 0x33a3cd(%rip), %rdi    # 0x4be900
testq %rdi, %rdi
jne 0x184568
leaq -0x30(%rip), %rsi       # 0x18450f
leaq 0x1c5(%rip), %rdx       # 0x18470b
leaq 0x42a(%rip), %rcx       # 0x184977
leaq 0x4c7(%rip), %r8        # 0x184a1b
movl $0x60, %edi
callq 0x184371
movq %rax, %rdi
movq %rax, 0x33a398(%rip)    # 0x4be900
movq %r14, %rsi
callq 0x1842c1
movq 0x8(%r14), %rcx
movq (%rcx), %rbp
cmpq %rbx, %rbp
jbe 0x184706
movq %rax, 0x8(%rsp)
movl 0x58(%rax), %ecx
decl %ecx
xorl %eax, %eax
movl %ecx, %r12d
xorl %r15d, %r15d
movq %r15, %r14
movq %rax, 0x18(%rsp)
cmpl %r12d, %eax
jae 0x1846f0
movl %ecx, %r15d
movq %r12, 0x28(%rsp)
movq 0x8(%rsp), %r12
movq 0x38(%r12), %rdi
addq %r14, %rbx
movq %rbx, 0x30(%rsp)
movq %rbx, %rsi
callq 0x129d03
movl %eax, 0x10(%rsp)
testq %r14, %r14
movq %r14, 0x20(%rsp)
je 0x1845e8
movq 0x38(%r12), %rdi
decq %r14
movq %r14, %rsi
callq 0x12a011
movq %rax, %r13
jmp 0x1845f2
movq $-0x1, %r14
xorl %r13d, %r13d
movl %r15d, %ebx
shrl %ebx
movq 0x38(%r12), %rdi
addq %r14, %rbp
movq %rbp, %rsi
callq 0x12a011
movq %rax, %r15
subq %r13, %r15
cmpl $0x0, 0x10(%rsp)
jne 0x184655
movq 0x38(%r12), %rdi
movq 0x30(%rsp), %rsi
callq 0x12a011
notq %r13
addq %rax, %r13
movq 0x8(%r12), %rax
movq 0x20(%rsp), %r14
addq (%rax), %r14
movq 0x18(%rsp), %rax
leal (%rbx,%rax), %ecx
movl %ebx, %r12d
movq %r15, %rbp
movq %r13, %rbx
cmpq %r15, %r13
jb 0x18459a
jmp 0x1846eb
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x184677
movq 0x8(%rsp), %r13
movq 0x38(%r13), %rdi
movq %r14, %rsi
callq 0x129f92
movq %rax, 0x10(%rsp)
jmp 0x184685
movq $0x0, 0x10(%rsp)
movq 0x8(%rsp), %r13
movq 0x28(%rsp), %r12
movq 0x38(%r13), %rdi
movq 0x30(%rsp), %rsi
callq 0x129f92
movq %r13, %rcx
movq 0x10(%rsp), %r14
movq %r14, %r13
notq %r13
addq %rax, %r13
leal 0x1(%rbx), %eax
movq %rax, 0x18(%rsp)
movq 0x38(%rcx), %rdi
movq %rbp, %rsi
callq 0x129f92
movq %rax, %rbp
subq %r14, %rbp
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
addq 0x20(%rsp), %r15
addq (%rax), %r15
movq 0x18(%rsp), %rax
leal (%rbx,%r12), %ecx
incl %ecx
movq %r13, %rbx
cmpq %rbp, %r13
jb 0x184592
callq 0x59adf
movl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x59b16
callq 0x59aa8
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/wtree_encseq.c
// Function: gt_wtree_encseq_select
static GtUword gt_wtree_encseq_select(GtWtree *wtree,
                                      GtUword i,
                                      GtWtreeSymbol symbol)
{
  unsigned int alpha_start = 0,
               alpha_end;
  GtUword node_start = 0,
          node_size;
  GtWtreeEncseq *we;
  gt_assert(wtree != NULL);

  we = gt_wtree_encseq_cast(wtree);
  gt_assert(i <= wtree->members->length);
  gt_assert(i != 0);

  alpha_end = we->alpha_size - 1;
  node_size = wtree->members->length;

  return gt_wtree_encseq_select_rec(we, i, symbol, node_start, node_size,
                                    alpha_start, alpha_end);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x184a0c
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x339f67(%rip), %rdi    # 0x4be900
testq %rdi, %rdi
jne 0x1849ce
leaq -0x496(%rip), %rsi      # 0x18450f
leaq -0x2a1(%rip), %rdx      # 0x18470b
leaq -0x3c(%rip), %rcx       # 0x184977
leaq 0x61(%rip), %r8         # 0x184a1b
movl $0x60, %edi
callq 0x184371
movq %rax, %rdi
movq %rax, 0x339f32(%rip)    # 0x4be900
movq %r15, %rsi
callq 0x1842c1
movq 0x8(%r15), %rcx
movq (%rcx), %r8
cmpq %r14, %r8
jb 0x184a11
testq %r14, %r14
je 0x184a16
movl 0x58(%rax), %ecx
decl %ecx
movl %ecx, (%rsp)
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
xorl %ecx, %ecx
xorl %r9d, %r9d
callq 0x184e82
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x59c6a
callq 0x59c31
callq 0x59bf8
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/wtree_encseq.c
// Function: gt_wtree_encseq_delete
static void gt_wtree_encseq_delete(GT_UNUSED GtWtree *wtree)
{
  if (wtree != NULL) {
    GtWtreeEncseq *wtree_encseq = gt_wtree_encseq_cast(wtree);
    gt_encseq_delete(wtree_encseq->encseq);
    gt_alphabet_delete(wtree_encseq->alpha);
    gt_free(wtree_encseq->bits);
    gt_compressed_bitsequence_delete(wtree_encseq->c_bits);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x184a9c
pushq %rbx
movq %rdi, %rbx
movq 0x339ed5(%rip), %rdi    # 0x4be900
testq %rdi, %rdi
jne 0x184a60
leaq -0x528(%rip), %rsi      # 0x18450f
leaq -0x333(%rip), %rdx      # 0x18470b
leaq -0xce(%rip), %rcx       # 0x184977
leaq -0x31(%rip), %r8        # 0x184a1b
movl $0x60, %edi
callq 0x184371
movq %rax, %rdi
movq %rax, 0x339ea0(%rip)    # 0x4be900
movq %rbx, %rsi
callq 0x1842c1
movq %rax, %rbx
movq 0x10(%rax), %rdi
callq 0xea375
movq 0x18(%rbx), %rdi
callq 0xd0e1c
movq 0x20(%rbx), %rdi
leaq 0x217ed3(%rip), %rsi    # 0x39c95b
movl $0x130, %edx            # imm = 0x130
callq 0x1045eb
movq 0x38(%rbx), %rdi
popq %rbx
jmp 0x12afc8
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/wtree_encseq.c
// Function: gt_wtree_encseq_fill_offset_delete
static inline void
gt_wtree_encseq_fill_offset_delete(GtWtreeEncseqFillOffset *fo)
{
  if (fo != NULL) {
    gt_wtree_encseq_fill_offset_delete(fo->left);
    gt_wtree_encseq_fill_offset_delete(fo->right);
    gt_free(fo);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x185039
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x18500a
movq 0x8(%rbx), %rdi
callq 0x18500a
leaq 0x217930(%rip), %rsi    # 0x39c95b
movq %rbx, %rdi
movl $0x175, %edx            # imm = 0x175
popq %rbx
jmp 0x1045eb
retq
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/xrfcheck_info.c
// Function: gt_xrfcheck_info_delete
void gt_xrfcheck_info_delete(GtXRFCheckInfo *xci)
{
  if (!xci) return;
  gt_option_delete(xci->xrfcheck_option);
  gt_str_delete(xci->xrfcheck);
  gt_free(xci);
}

// Assembly:
testq %rdi, %rdi
je 0x186083
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x10a16a
movq (%rbx), %rdi
callq 0x11bdbf
leaq 0x217143(%rip), %rsi    # 0x39d1b8
movq %rbx, %rdi
movl $0x2a, %edx
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/xrfcheck_info.c
// Function: gt_xrfcheck_info_register_options
void gt_xrfcheck_info_register_options(GtXRFCheckInfo *xci,
                                        GtOptionParser *op)
{
  GtOption *xrfcheck_option;
  gt_assert(xci && op);
  gt_assert(!xci->xrfcheck_option); /* can only called once */

  /* -xrfcheck */
  xrfcheck_option =
    gt_option_new_string("xrfcheck", "check Dbxref and Ontology_term "
                         "attributes for correct syntax according to a "
                         "abbreviation definition file.\nIf no argument is "
                         "given, the GO.xrf_abbs file from the "
                         "gtdata/xrf_abbr directory is used.\nIf an argument "
                         "is given, it is used as an specific filename for an "
                         "abbreviation file.\nIn the case that such a "
                         "file does not exist, '.xrf_abbr' is added to the "
                         "argument and loading the resulting filename from the "
                         "gtdata/xrf_abbr directory is attempted.",
                         xci->xrfcheck, NULL);
  gt_option_argument_is_optional(xrfcheck_option);
  gt_option_parser_add_option(op, xrfcheck_option);
  xci->xrfcheck_option = gt_option_ref(xrfcheck_option);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1860e0
movq %rsi, %r14
testq %rsi, %rsi
je 0x1860e0
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
jne 0x1860e5
movq (%rbx), %rdx
leaq 0x21716d(%rip), %rdi    # 0x39d217
leaq 0x21716f(%rip), %rsi    # 0x39d220
xorl %ecx, %ecx
callq 0x10a770
movq %rax, %r15
movq %rax, %rdi
callq 0x10ac2f
movq %r14, %rdi
movq %r15, %rsi
callq 0x107cc0
movq %r15, %rdi
callq 0x107bec
movq %rax, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
callq 0x5a339
callq 0x5a370
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/xrfcheck_info.c
// Function: gt_xrfcheck_info_create_xrf_checker
GtXRFChecker* gt_xrfcheck_info_create_xrf_checker(const GtXRFCheckInfo *xci,
                                                  GtError *err)
{
  GtXRFChecker *xrf_checker = NULL;
  int had_err = 0;
  GtStr *xrf_file;
  gt_error_check(err);
  gt_assert(xci);
  gt_assert(gt_option_is_set(xci->xrfcheck_option));
  if (!gt_str_length(xci->xrfcheck)) {
    /* a. */
    if (!(xrf_file = get_xrf_path(err)))
      had_err = -1;
    if (!had_err)
      gt_str_append_cstr(xrf_file, "GO.xrf_abbr");
  }
  else if (gt_file_exists(gt_str_get(xci->xrfcheck))) {
    /* b. */
    xrf_file = gt_str_new_cstr(gt_str_get(xci->xrfcheck));
  }
  else {
    /* c. */
    if (!(xrf_file = get_xrf_path(err)))
      had_err = -1;
    if (!had_err) {
      gt_str_append_str(xrf_file, xci->xrfcheck);
      gt_str_append_cstr(xrf_file, ".xrf_abbr");
    }
  }

  if (!had_err)
    xrf_checker = gt_xrf_checker_new(gt_str_get(xrf_file), err);

  gt_str_delete(xrf_file);
  return xrf_checker;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
testq %rsi, %rsi
je 0x186122
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0x1861ed
testq %r15, %r15
je 0x1861e3
movq 0x8(%r15), %rdi
callq 0x10ac3f
testb %al, %al
je 0x1861e8
movq (%r15), %rdi
callq 0x11b0ca
testq %rax, %rax
je 0x186172
movq (%r15), %rdi
callq 0x11b0a1
movq %rax, %rdi
callq 0xff28c
testb %al, %al
je 0x18618b
movq (%r15), %rdi
callq 0x11b0a1
movq %rax, %rdi
callq 0x11acc9
movq %rax, %r14
jmp 0x1861b5
movq %rbx, %rdi
callq 0x1861f2
testq %rax, %rax
je 0x1861cd
movq %rax, %r14
leaq 0x2172df(%rip), %rsi    # 0x39d468
jmp 0x1861ad
movq %rbx, %rdi
callq 0x1861f2
testq %rax, %rax
je 0x1861cd
movq %rax, %r14
movq (%r15), %rsi
movq %rax, %rdi
callq 0x11adc1
leaq 0x2172bd(%rip), %rsi    # 0x39d46a
movq %r14, %rdi
callq 0x11acf3
movq %r14, %rdi
callq 0x11b0a1
movq %rax, %rdi
movq %rbx, %rsi
callq 0x185ebe
movq %rax, %rbx
jmp 0x1861d2
xorl %r14d, %r14d
xorl %ebx, %ebx
movq %r14, %rdi
callq 0x11bdbf
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x5a44c
callq 0x5a415
callq 0x5a3de
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/extended/xrfcheck_info.c
// Function: get_xrf_path
static GtStr* get_xrf_path(GtError *err)
{
  const char *progname;
  GtStr *xrf_path, *prog;
  gt_error_check(err);
  progname = gt_error_get_progname(err);
  gt_assert(progname != NULL);
  prog = gt_str_new();
  gt_str_append_cstr_nt(prog, progname,
                        gt_cstr_length_up_to_char(progname, ' '));
  xrf_path = gt_get_gtdata_path(gt_str_get(prog), err);
  if (xrf_path)
    gt_str_append_cstr(xrf_path, "/xrf_abbr/");
  gt_str_delete(prog);
  return xrf_path;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
je 0x18620b
movq %rbx, %rdi
callq 0xfcc32
testb %al, %al
jne 0x18627e
movq %rbx, %rdi
callq 0xfccba
testq %rax, %rax
je 0x186279
movq %rax, %r15
callq 0x11ac6c
movq %rax, %r14
movq %r15, %rdi
movl $0x20, %esi
callq 0xe438c
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x11ae1b
movq %r14, %rdi
callq 0x11b0a1
movq %rax, %rdi
movq %rbx, %rsi
callq 0x100758
movq %rax, %rbx
testq %rax, %rax
je 0x186268
leaq 0x217221(%rip), %rsi    # 0x39d481
movq %rbx, %rdi
callq 0x11acf3
movq %r14, %rdi
callq 0x11bdbf
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x5a4ba
callq 0x5a483
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/asqg_writer.c
// Function: gt_asqg_writer_new
GtAsqgWriter* gt_asqg_writer_new(GtFile *file, const GtEncseq *encseq)
{
  GtAsqgWriter *aw;
  aw = gt_malloc(sizeof (*aw));
  aw->file = file;
  aw->encseq = encseq;
  return aw;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x213bc8(%rip), %rsi    # 0x39e069
movl $0x10, %edi
movl $0x1f, %edx
callq 0x104226
movq %r14, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/asqg_writer.c
// Function: gt_asqg_writer_show_header
int gt_asqg_writer_show_header(GtAsqgWriter *aw, float erate,
    GtUword minlen, const char *inputfilename, bool has_containments,
    bool has_transitives, GT_UNUSED GtError *err)
{
  gt_assert(aw != NULL);
  gt_file_xprintf(aw->file,
      "HT\tVN:i:%d\tER:f:%g\tOL:i:"GT_WU"\tIN:Z:%s\tCN:i:%c\tTE:i:%c\n",
      GT_ASQG_VERSION, erate, minlen, inputfilename,
      has_containments ? '1' : '0', has_transitives ? '1' : '0');
  return 0;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x18a501
movq %rdx, %rax
movq %rsi, %r10
movq (%rdi), %rdi
cvtss2sd %xmm0, %xmm0
movzbl %cl, %r9d
orl $0x30, %r9d
movzbl %r8b, %ecx
orl $0x30, %ecx
movl %ecx, (%rsp)
leaq 0x213bbc(%rip), %rsi    # 0x39e0a7
movl $0x1, %edx
movq %r10, %rcx
movq %rax, %r8
movb $0x1, %al
callq 0xfee51
xorl %eax, %eax
popq %rcx
retq
callq 0x5b587
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/asqg_writer.c
// Function: gt_spmproc_show_asqg
void gt_spmproc_show_asqg(GtUword suffix_readnum,
    GtUword prefix_readnum, GtUword length,
    bool suffixseq_direct, bool prefixseq_direct, void *asqg_writer)
{
  GtAsqgWriter *aw = asqg_writer;
  const GtUword sl1 = gt_encseq_seqlength(aw->encseq, suffix_readnum),
                      sl2 = gt_encseq_seqlength(aw->encseq, prefix_readnum);
  gt_asqg_writer_show_edge_line(aw->file, suffix_readnum, prefix_readnum,
      suffixseq_direct ? sl1 - length : 0,
      suffixseq_direct ? sl1 - 1UL : length - 1UL, sl1,
      prefixseq_direct ? 0 : sl2 - length,
      prefixseq_direct ? length - 1UL : sl2 - 1UL, sl2,
      !suffixseq_direct || !prefixseq_direct, 0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r13
movl %r8d, %ebp
movl %ecx, %ebx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rsi
movq %rdi, (%rsp)
movq 0x8(%r9), %rdi
callq 0xeb9d2
movq %rax, %r14
movq 0x8(%r13), %rdi
movq %r12, %rsi
callq 0xeb9d2
movq %rax, %r10
movq (%r13), %rdi
movq %r14, %r8
subq %r15, %r8
leaq -0x1(%r14), %r9
leaq -0x1(%r15), %rax
xorl %ecx, %ecx
testl %ebx, %ebx
cmoveq %rcx, %r8
cmoveq %rax, %r9
movq %r10, %r11
subq %r15, %r11
leaq -0x1(%r10), %r15
testl %ebp, %ebp
cmovneq %rcx, %r11
cmovneq %rax, %r15
andl %ebp, %ebx
xorl $0x31, %ebx
leaq 0x213a12(%rip), %rsi    # 0x39e0f4
movq (%rsp), %rdx
movq %r12, %rcx
xorl %eax, %eax
pushq $0x0
pushq %rbx
pushq %r10
pushq %r15
pushq %r11
pushq %r14
callq 0xfee51
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/bare-encseq.c
// Function: gt_bare_encseq_delete
void gt_bare_encseq_delete(GtBareEncseq *bare_encseq)
{
  if (bare_encseq != NULL)
  {
    gt_free(bare_encseq->charcount);
    GT_FREEARRAY(&bare_encseq->specialranges,GtBareSpecialrange);
    gt_free(bare_encseq);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x18a785
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
leaq 0x2139ec(%rip), %rsi    # 0x39e11f
movl $0x30, %edx
callq 0x1045eb
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x18a76a
leaq 0x28(%rbx), %r14
leaq 0x2139ce(%rip), %rsi    # 0x39e11f
movl $0x31, %edx
callq 0x1045eb
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
leaq 0x2139ae(%rip), %rsi    # 0x39e11f
movq %rbx, %rdi
movl $0x32, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/bare-encseq.c
// Function: gt_bare_encseq_specialrangeiterator_new
GtBareSpecialrangeiterator* gt_bare_encseq_specialrangeiterator_new(
                       const GtBareEncseq *bare_encseq,
                       bool moveforward)
{
  gt_assert(bare_encseq != NULL);
  if (bare_encseq->specialranges.nextfreeGtBareSpecialrange == 0)
  {
    return NULL;
  } else
  {
    GtBareSpecialrangeiterator *sri = gt_malloc(sizeof *sri);

    sri->startptr = bare_encseq->specialranges.spaceGtBareSpecialrange;
    sri->endptr = bare_encseq->specialranges.spaceGtBareSpecialrange +
                  bare_encseq->specialranges.nextfreeGtBareSpecialrange;
    sri->moveforward = moveforward;
    sri->current = moveforward ? sri->startptr : sri->endptr - 1;
    return sri;
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x18acb2
movq %rdi, %r14
cmpq $0x0, 0x38(%rdi)
je 0x18aca8
movl %esi, %ebx
leaq 0x2134b3(%rip), %rsi    # 0x39e11f
movl $0x20, %edi
movl $0xfc, %edx
callq 0x104226
movq 0x28(%r14), %rcx
movq %rcx, (%rax)
movq 0x38(%r14), %rdx
shlq $0x4, %rdx
leaq (%rcx,%rdx), %rsi
movq %rsi, 0x8(%rax)
movb %bl, 0x18(%rax)
addq %rcx, %rdx
addq $-0x10, %rdx
testb %bl, %bl
cmovneq %rcx, %rdx
movq %rdx, 0x10(%rax)
jmp 0x18acaa
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x5b8d4
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/bare-encseq.c
// Function: bare_encseq_convert
void bare_encseq_convert(GtBareEncseq *bare_encseq,bool forward,bool direct)
{
  GtUchar *leftptr, *rightptr;

  if (forward)
  {
    gt_assert(!direct);
    for (leftptr = bare_encseq->sequence;
         leftptr < bare_encseq->sequence + bare_encseq->totallength;
         leftptr++)
    {
      if (GT_ISNOTSPECIAL(*leftptr))
      {
        *leftptr = GT_COMPLEMENTBASE(*leftptr);
      }
    }
  } else
  {
    if (direct)
    {
      for (leftptr = bare_encseq->sequence,
           rightptr = bare_encseq->sequence + bare_encseq->totallength - 1;
           leftptr < rightptr; leftptr++, rightptr--)
      {
        GtUchar tmp = *leftptr;
        *leftptr = *rightptr;
        *rightptr = tmp;
      }
    } else
    {
      for (leftptr = bare_encseq->sequence,
           rightptr = bare_encseq->sequence + bare_encseq->totallength - 1;
           leftptr <= rightptr; leftptr++, rightptr--)
      {
        GtUchar tmp = *leftptr;
        *leftptr = GT_ISSPECIAL(*rightptr) ? *rightptr
                                        : GT_COMPLEMENTBASE(*rightptr);
        *rightptr = GT_ISSPECIAL(tmp) ? tmp
                                   : GT_COMPLEMENTBASE(tmp);
      }
    }
  }
}

// Assembly:
pushq %rax
testl %esi, %esi
je 0x18ad68
testb %dl, %dl
jne 0x18ade6
movq 0x8(%rdi), %rax
testq %rax, %rax
jle 0x18ade4
movq (%rdi), %rdx
movq %rdx, %rcx
movb (%rcx), %sil
cmpb $-0x3, %sil
ja 0x18ad5a
movb $0x3, %al
subb %sil, %al
movb %al, (%rcx)
movq (%rdi), %rdx
movq 0x8(%rdi), %rax
incq %rcx
leaq (%rdx,%rax), %rsi
cmpq %rsi, %rcx
jb 0x18ad43
jmp 0x18ade4
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
addq %rax, %rcx
decq %rcx
testb %dl, %dl
je 0x18ad9e
cmpq %rcx, %rax
jae 0x18ade4
incq %rax
movb -0x1(%rax), %dl
movb (%rcx), %sil
movb %sil, -0x1(%rax)
movb %dl, (%rcx)
decq %rcx
leaq 0x1(%rax), %rdx
cmpq %rcx, %rax
movq %rdx, %rax
jb 0x18ad81
jmp 0x18ade4
cmpq %rcx, %rax
ja 0x18ade4
incq %rax
movzbl -0x1(%rax), %edx
movzbl (%rcx), %esi
movb $0x3, %dil
subb %sil, %dil
cmpb $-0x2, %sil
movzbl %dil, %edi
cmovael %esi, %edi
movb %dil, -0x1(%rax)
movb $0x3, %sil
subb %dl, %sil
cmpb $-0x2, %dl
movzbl %sil, %esi
cmovael %edx, %esi
movb %sil, (%rcx)
decq %rcx
leaq 0x1(%rax), %rdx
cmpq %rcx, %rax
movq %rdx, %rax
jbe 0x18ada6
popq %rax
retq
callq 0x5b90d
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/bcktab.c
// Function: gt_bcktab_leftborder_assign
void gt_bcktab_leftborder_assign(GtLeftborder *lb,GtCodetype code,
                                 GtUword value)
{
  gt_assert(lb != NULL);
  if (lb->ulongbounds != NULL)
  {
    lb->ulongbounds[code] = value;
  } else
  {
    gt_assert(value <= (GtUword) UINT_MAX);
    gt_assert(lb->uintbounds != NULL);
    lb->uintbounds[code] = (uint32_t) value;
  }
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x18ae17
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x18ae01
movq %rdx, (%rax,%rsi,8)
jmp 0x18ae15
movq %rdx, %rax
shrq $0x20, %rax
jne 0x18ae1c
movq (%rdi), %rax
testq %rax, %rax
je 0x18ae21
movl %edx, (%rax,%rsi,4)
popq %rax
retq
callq 0x5b9b4
callq 0x5b946
callq 0x5b97d
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/bcktab.c
// Function: gt_bcktab_get_leftborder
GtUword gt_bcktab_get_leftborder(const GtBcktab *bcktab,GtCodetype code)
{
  gt_assert(bcktab != NULL);
  if (bcktab->leftborder.ulongbounds != NULL)
  {
    return bcktab->leftborder.ulongbounds[code];
  }
  gt_assert(bcktab->leftborder.uintbounds != NULL);
  return (GtUword) bcktab->leftborder.uintbounds[code];
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x18ae48
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x18ae3b
movq (%rax,%rsi,8), %rax
jmp 0x18ae46
movq (%rdi), %rax
testq %rax, %rax
je 0x18ae4d
movl (%rax,%rsi,4), %eax
popq %rcx
retq
callq 0x5ba22
callq 0x5b9eb
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/bcktab.c
// Function: gt_bcktab_storetmp
void gt_bcktab_storetmp(GtBcktab *bcktab)
{
  if (bcktab->useulong) {
    gt_Sfxmappedrange_storetmp_ulong(bcktab->mappedleftborder,
                                     &bcktab->leftborder.ulongbounds,
                                     true);
    if (bcktab->withspecialsuffixes)
    {
      gt_Sfxmappedrange_storetmp_ulong(bcktab->mappedcountspecialcodes,
                                       &bcktab->ulongcountspecialcodes,
                                       true);
    }
  } else {
    gt_Sfxmappedrange_storetmp_uint32(bcktab->mappedleftborder,
                                      &bcktab->leftborder.uintbounds,
                                      true);
    if (bcktab->withspecialsuffixes)
    {
      gt_Sfxmappedrange_storetmp_uint32(bcktab->mappedcountspecialcodes,
                                        &bcktab->uintcountspecialcodes,
                                        true);
    }
  }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0xb0(%rdi), %rdi
cmpb $0x1, 0xa2(%rbx)
jne 0x18ae96
leaq 0x8(%rbx), %rsi
movl $0x1, %edx
callq 0x1eef1f
cmpb $0x1, 0xa1(%rbx)
jne 0x18aec5
movq 0xb8(%rbx), %rdi
addq $0x20, %rbx
movq %rbx, %rsi
movl $0x1, %edx
popq %rbx
jmp 0x1eef1f
movq %rbx, %rsi
movl $0x1, %edx
callq 0x1ef018
cmpb $0x1, 0xa1(%rbx)
jne 0x18aec5
movq 0xb8(%rbx), %rdi
addq $0x10, %rbx
movq %rbx, %rsi
movl $0x1, %edx
popq %rbx
jmp 0x1ef018
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/bcktab.c
// Function: gt_bcktab_maprange_lb_cs
void gt_bcktab_maprange_lb_cs(GtSfxmappedrangelist *sfxmrlist,GtBcktab *bcktab)
{
  bcktab->mappedleftborder
    = gt_Sfxmappedrange_new("leftborder",
                            bcktab->numofallcodes+1,
                            bcktab->useulong
                              ? GtSfxunsignedlong
                              : GtSfxuint32_t,
                            NULL,
                            NULL);
  gt_Sfxmappedrangelist_add(sfxmrlist,bcktab->mappedleftborder);
  if (bcktab->withspecialsuffixes)
  {
    bcktab->mappedcountspecialcodes
      = gt_Sfxmappedrange_new("countspecialcodes",
                              bcktab->numofspecialcodes,
                              bcktab->useulong
                                ? GtSfxunsignedlong
                                : GtSfxuint32_t,
                              gt_bcktab_transform_minmax_code,
                              &bcktab->numofchars);
    gt_Sfxmappedrangelist_add(sfxmrlist,bcktab->mappedcountspecialcodes);
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x58(%rsi), %rsi
incq %rsi
movzbl 0xa2(%r14), %eax
movl $0x2, %ebp
movl $0x2, %edx
subl %eax, %edx
leaq 0x1e40c7(%rip), %rdi    # 0x36efba
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x1eee48
movq %rax, 0xb0(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1ef4a2
cmpb $0x1, 0xa1(%r14)
jne 0x18af56
movq 0x60(%r14), %rsi
movzbl 0xa2(%r14), %eax
subl %eax, %ebp
leaq 0x4c(%r14), %r8
leaq 0x21394c(%rip), %rdi    # 0x39e87e
leaq 0x22(%rip), %rcx        # 0x18af5b
movl %ebp, %edx
callq 0x1eee48
movq %rax, 0xb8(%r14)
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x1ef4a2
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/bcktab.c
// Function: gt_bcktab_sizeoftable
uint64_t gt_bcktab_sizeoftable(unsigned int numofchars,
                               unsigned int prefixlength,
                               GtUword maxvalue,
                               bool withspecialsuffixes)
{
  GtUword numofallcodes, numofspecialcodes;
  uint64_t sizeofbuckettable;
  GtCodetype *basepower;

  if (withspecialsuffixes)
  {
    if (prefixlength >= 2U)
    {
      basepower = gt_initbasepower(numofchars,prefixlength-2);
    } else
    {
      basepower = NULL;
    }
    numofspecialcodes = gt_power_for_small_exponents(numofchars,prefixlength-1);
  } else
  {
    basepower = NULL;
    numofspecialcodes = 0;
  }
  numofallcodes = gt_power_for_small_exponents(numofchars,prefixlength);
  sizeofbuckettable
    = gt_bcktab_sizeoftable_generic(prefixlength,
                                    numofallcodes,
                                    numofspecialcodes,
                                    gt_bcktab_useulong(maxvalue),
                                    basepower,
                                    true,
                                    withspecialsuffixes);
  gt_free(basepower);
  return sizeofbuckettable;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %r15d
movl %edi, %ebp
testl %ecx, %ecx
je 0x18b039
cmpl $0x2, %r15d
jb 0x18b04e
leal -0x2(%r15), %esi
movl %ebp, %edi
callq 0x1b62c7
movq %rax, %r14
jmp 0x18b051
movl %ebp, %edi
movl %r15d, %esi
callq 0x105ed6
movq %rax, %r15
incq %r15
xorl %r14d, %r14d
jmp 0x18b096
xorl %r14d, %r14d
leal -0x1(%r15), %r13d
movl %ebp, %edi
movl %r13d, %esi
callq 0x105ed6
movq %rax, %r12
movl %ebp, %edi
movl %r15d, %esi
callq 0x105ed6
cmpl $0x3, %r15d
jb 0x18b08a
movl %r13d, %edx
movl $0x1, %esi
xorl %ecx, %ecx
addq (%r14,%rsi,8), %rcx
incq %rsi
cmpq %rsi, %rdx
jne 0x18b07c
jmp 0x18b08c
xorl %ecx, %ecx
addq %rax, %r12
leaq (%rcx,%r12), %r15
incq %r15
shrq $0x20, %rbx
setne %cl
orb $0x2, %cl
shlq %cl, %r15
leaq 0x21327c(%rip), %rsi    # 0x39e326
movq %r14, %rdi
movl $0x142, %edx            # imm = 0x142
callq 0x1045eb
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/bcktab.c
// Function: assignbcktabmapspecification
static void assignbcktabmapspecification(GtMapspec *mapspec,
                                         void *data,
                                         bool writemode)
{
  GtBcktab *bcktab = (GtBcktab *) data;

  if (bcktab->useulong)
  {
    gt_mapspec_add_ulong(mapspec, bcktab->leftborder.ulongbounds,
                         (GtUword) (bcktab->numofallcodes+1));
  } else
  {
    gt_mapspec_add_uint32(mapspec, bcktab->leftborder.uintbounds,
                          (GtUword) (bcktab->numofallcodes+1));
  }
  if (bcktab->withspecialsuffixes)
  {
    if (bcktab->useulong)
    {
      gt_mapspec_add_ulong(mapspec, bcktab->ulongcountspecialcodes,
                           (GtUword) bcktab->numofspecialcodes);
    } else
    {
      gt_mapspec_add_uint32(mapspec, bcktab->uintcountspecialcodes,
                            (GtUword) bcktab->numofspecialcodes);
    }
    if (bcktab->numofdistpfxidxcounters > 0)
    {
      if (!writemode)
      {
        if (bcktab->useulong)
        {
          bcktab->ulongdistpfxidx = gt_malloc(sizeof (void *) *
                                              (bcktab->prefixlength-1));
        } else
        {
          bcktab->uintdistpfxidx = gt_malloc(sizeof (void *) *
                                             (bcktab->prefixlength-1));
        }
      }
      if (bcktab->useulong)
      {
        gt_mapspec_add_ulong(mapspec, bcktab->ulongdistpfxidx[0],
                             bcktab->numofdistpfxidxcounters);
      } else
      {
        gt_mapspec_add_uint32(mapspec, bcktab->uintdistpfxidx[0],
                              bcktab->numofdistpfxidxcounters);
      }
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, 0xa2(%rsi)
jne 0x18b777
leaq 0x8(%r14), %rsi
movq 0x58(%r14), %rdx
incq %rdx
movq %rbx, %rdi
callq 0x1053cc
jmp 0x18b789
movq 0x58(%r14), %rdx
incq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x105516
cmpb $0x1, 0xa1(%r14)
jne 0x18b825
movq 0x60(%r14), %rdx
cmpb $0x1, 0xa2(%r14)
jne 0x18b7b3
leaq 0x20(%r14), %rsi
movq %rbx, %rdi
callq 0x1053cc
jmp 0x18b7bf
leaq 0x10(%r14), %rsi
movq %rbx, %rdi
callq 0x105516
cmpq $0x0, 0x40(%r14)
je 0x18b825
testb %bpl, %bpl
jne 0x18b801
movzbl 0xa2(%r14), %r15d
movl 0x48(%r14), %edi
decl %edi
shlq $0x3, %rdi
movl %r15d, %eax
xorb $0x1, %al
movzbl %al, %eax
leal 0x228(,%rax,4), %edx
shll $0x4, %r15d
leaq 0x212b2f(%rip), %rsi    # 0x39e326
callq 0x104226
movq %rax, 0x18(%r15,%r14)
movq 0x40(%r14), %rdx
cmpb $0x1, 0xa2(%r14)
jne 0x18b830
movq 0x28(%r14), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1053cc
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x18(%r14), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x105516