LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x12ae09
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x12ae9f
movq %rbx, %rdi
callq 0x8a001
testq %rax, %rax
je 0x12ae75
movq %rax, %r15
callq 0xacb84
movq %rax, %r14
pushq $0x20
popq %rsi
movq %r15, %rdi
callq 0x6c46d
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xacd9e
movq %r14, %rdi
callq 0xad1fa
movq %rax, %rdi
movq %rbx, %rsi
callq 0x8f124
movq %rax, %rbx
testq %rax, %rax
je 0x12ae64
leaq 0x20cd00(%rip), %rsi    # 0x337b5c
movq %rbx, %rdi
callq 0xacbfb
movq %r14, %rdi
callq 0xae103
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x30d0ec(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1ba18d(%rip), %rsi    # 0x2e5013
leaq 0x1d3522(%rip), %rdx    # 0x2fe3af
leaq 0x20ccbb(%rip), %rcx    # 0x337b4f
leaq 0x20c9fa(%rip), %r8     # 0x337895
pushq $0x64
jmp 0x12aec7
movq 0x30d0c2(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1ba163(%rip), %rsi    # 0x2e5013
leaq 0x1ba308(%rip), %rdx    # 0x2e51bf
leaq 0x20cc91(%rip), %rcx    # 0x337b4f
leaq 0x20c9d0(%rip), %r8     # 0x337895
pushq $0x62
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 0x20cc8d(%rip), %rsi    # 0x337b70
pushq $0x38
popq %rdi
pushq $0x7e
popq %rdx
callq 0x93160
movq %rbx, %xmm0
punpckldq 0x1bc9e5(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x1bc9ed(%rip), %xmm0   # 0x2e78f0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
mulsd 0x20cc51(%rip), %xmm1   # 0x337b68
addsd 0x1bb309(%rip), %xmm1   # 0x2e6228
movq %rax, %rbx
cvttsd2si %xmm1, %rax
movq %rax, %rcx
subsd 0x1bcdee(%rip), %xmm1   # 0x2e7d20
cvttsd2si %xmm1, %rdx
sarq $0x3f, %rcx
andq %rcx, %rdx
orq %rax, %rdx
movabsq $0x7fc0002764, %rax     # imm = 0x7FC0002764
xorpd %xmm0, %xmm0
movupd %xmm0, 0x18(%rbx)
movupd %xmm0, 0x21(%rbx)
cmpq %rax, %rdx
jae 0x12b00c
movl $0x100007, %edi         # imm = 0x100007
cmpq $0x100007, %rdx         # imm = 0x100007
jb 0x12afb6
movl $0x97f, %eax            # imm = 0x97F
xorl %esi, %esi
leaq 0x20cf22(%rip), %rcx    # 0x337ea0
movq %rax, %r8
movq %r8, %rdi
subq %rsi, %rdi
jb 0x12afd6
movq %r8, %rax
cmpq $0x1, %rdi
je 0x12afa9
leaq (%rax,%rsi), %r8
shrq %r8
movq (%rcx,%r8,8), %rdi
cmpq %rdx, %rdi
ja 0x12af81
movq %r8, %rsi
jb 0x12af7e
jmp 0x12afb6
movq %rdx, %rdi
cmpq %rdx, (%rcx,%rsi,8)
je 0x12afb6
movq (%rcx,%rax,8), %rdi
movq %rdi, 0x10(%rbx)
leaq 0x20cbaf(%rip), %rdx    # 0x337b70
pushq $0x10
popq %rsi
movl $0x86, %ecx
callq 0x9334a
movq %rax, (%rbx)
movq %rbx, %rax
popq %rbx
retq
movq 0x30cf8b(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1ba02c(%rip), %rsi    # 0x2e5013
leaq 0x1fcf7f(%rip), %rdx    # 0x327f6d
leaq 0x20ce65(%rip), %rcx    # 0x337e5a
leaq 0x20cb74(%rip), %r8     # 0x337b70
pushq $0x3d
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
movq 0x30cf55(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x20cdbe(%rip), %rsi    # 0x337ddb
xorl %eax, %eax
callq 0x17a50
pushq $0x1
popq %rdi
callq 0x178f0
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/extended/uint64hashtable.c
// Function: compareGtUint64hashstoredvalue
static int compareGtUint64hashstoredvalue(const void *a,const void *b,
                                          void *data)
{
  GtUint64hashstoredvalue *hspace = (GtUint64hashstoredvalue *) data;
  uint32_t va = *(const uint32_t *) a;
  uint32_t vb = *(const uint32_t *) b;

  if (hspace[va].key < hspace[vb].key)
  {
    return -1;
  }
  if (hspace[va].key > hspace[vb].key)
  {
    return 1;
  }
  gt_assert(false);
  return 0;
}

// Assembly:
movl (%rdi), %eax
movl (%rsi), %ecx
shlq $0x4, %rax
shlq $0x4, %rcx
movq (%rdx,%rcx), %rcx
cmpq %rcx, (%rdx,%rax)
jae 0x12b70b
pushq $-0x1
jmp 0x12b70f
jbe 0x12b711
pushq $0x1
popq %rax
retq
pushq %rax
movq 0x30c84f(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1b98f0(%rip), %rsi    # 0x2e5013
leaq 0x1fb2c2(%rip), %rdx    # 0x3269ec
leaq 0x20c745(%rip), %rcx    # 0x337e76
leaq 0x20c438(%rip), %r8     # 0x337b70
pushq $0x6b
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/hashtable-siop.h
// Function: gt_uint64_key_mul_hash
static inline uint32_t
gt_uint64_key_mul_hash(uint64_t key)
{
  uint32_t low = key, hi = key >> 32;
  uint32_t x = gt_ht_finalize2_u32(gt_uint32_key_mul_hash(low),
                                gt_uint32_key_mul_hash(hi));
  return x;
}

// Assembly:
movq %rdi, %rax
shrq $0x20, %rax
imull $0x9e3779b1, %eax, %ecx # imm = 0x9E3779B1
movl %ecx, %esi
roll $0xe, %esi
imull $0x9e3779b1, %edi, %edx # imm = 0x9E3779B1
movl %ecx, %eax
subl %esi, %eax
xorl %eax, %edx
movl %eax, %esi
roll $0xb, %esi
subl %esi, %edx
xorl %edx, %ecx
movl %edx, %esi
roll $0x19, %esi
subl %esi, %ecx
movl %ecx, %esi
roll $0x10, %esi
xorl %ecx, %eax
subl %esi, %eax
xorl %eax, %edx
movl %eax, %esi
roll $0x4, %esi
subl %esi, %edx
xorl %edx, %ecx
roll $0xe, %edx
subl %edx, %ecx
xorl %ecx, %eax
roll $0x18, %ecx
subl %ecx, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x69e97
cmpq $0x0, 0x311e4a(%rip)    # 0x43d8a0
jne 0x12ba75
leaq 0x24(%rip), %rsi        # 0x12ba83
leaq 0x50(%rip), %rdx        # 0x12bab6
pushq $0x28
popq %rdi
callq 0x102838
movq %rax, 0x311e2b(%rip)    # 0x43d8a0
callq 0x69ede
movq 0x311e1f(%rip), %rax    # 0x43d8a0
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x12ba48
movq %rax, %rdi
movq %rbx, %rsi
callq 0x102c81
movq %rax, %rbx
movq 0x18(%rax), %rdi
callq 0xde013
movq 0x20(%rbx), %rdi
callq 0xde013
movq 0x10(%rbx), %rdi
popq %rbx
jmp 0x10297b
// File: /workspace/github_c_makefile_star2_O2/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 0x12be07
movq %rdi, %rbx
callq 0x102c3d
testb %al, %al
je 0x12be07
callq 0x12ba48
pushq $0x1
popq %rsi
movq %rax, %rdi
callq 0x10289f
movq %rax, %r14
callq 0x12ba48
movq %rax, %rdi
movq %r14, %rsi
callq 0x102c81
movq %rax, %r15
movq %rbx, %rdi
callq 0x102934
movq %rax, 0x10(%r15)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x30c15a(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1b91fb(%rip), %rsi    # 0x2e5013
leaq 0x210c81(%rip), %rdx    # 0x33caa0
leaq 0x210cab(%rip), %rcx    # 0x33cad1
leaq 0x210cb7(%rip), %r8     # 0x33cae4
movl $0xa5, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
nop
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x12c05d
movq %rdi, %rbx
movq 0x20(%rdi), %rsi
testq %rsi, %rsi
je 0x12c05d
leaq 0x210bad(%rip), %r14    # 0x33cbcd
pushq $0x1
popq %r15
pushq $0x1d
popq %rcx
movq %r15, %rdi
movq %r14, %rdx
callq 0x9334a
movq %rax, %r12
movq %rbx, (%rax)
pushq $0x18
popq %rsi
pushq $0x1f
popq %rcx
movq %r15, %rdi
movq %r14, %rdx
callq 0x9334a
movq %rax, 0x8(%r12)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x30bf04(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1b8fa5(%rip), %rsi    # 0x2e5013
leaq 0x210b2f(%rip), %rdx    # 0x33cba4
leaq 0x210b41(%rip), %rcx    # 0x33cbbd
leaq 0x210b4a(%rip), %r8     # 0x33cbcd
pushq $0x1c
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x12c143
movq (%rdi), %rax
testq %rax, %rax
je 0x12c16d
movq (%rax), %rax
testq %rax, %rax
je 0x12c13e
popq %rcx
jmpq *%rax
pushq $-0x1
popq %rax
popq %rcx
retq
movq 0x30be1e(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1b8ebf(%rip), %rsi    # 0x2e5013
leaq 0x210ad0(%rip), %rdx    # 0x33cc2b
leaq 0x210ad7(%rip), %rcx    # 0x33cc39
leaq 0x210a64(%rip), %r8     # 0x33cbcd
pushq $0x35
jmp 0x12c195
movq 0x30bdf4(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1b8e95(%rip), %rsi    # 0x2e5013
leaq 0x210ac4(%rip), %rdx    # 0x33cc49
leaq 0x210aad(%rip), %rcx    # 0x33cc39
leaq 0x210a3a(%rip), %r8     # 0x33cbcd
pushq $0x36
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x12c1c2
movq (%rdi), %rax
testq %rax, %rax
je 0x12c1ec
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x12c1bd
popq %rcx
jmpq *%rax
pushq $-0x1
popq %rax
popq %rcx
retq
movq 0x30bd9f(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1b8e40(%rip), %rsi    # 0x2e5013
leaq 0x210a51(%rip), %rdx    # 0x33cc2b
leaq 0x210a7f(%rip), %rcx    # 0x33cc60
leaq 0x2109e5(%rip), %r8     # 0x33cbcd
pushq $0x40
jmp 0x12c214
movq 0x30bd75(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1b8e16(%rip), %rsi    # 0x2e5013
leaq 0x210a45(%rip), %rdx    # 0x33cc49
leaq 0x210a55(%rip), %rcx    # 0x33cc60
leaq 0x2109bb(%rip), %r8     # 0x33cbcd
pushq $0x41
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x12c241
movq (%rdi), %rax
testq %rax, %rax
je 0x12c26b
movq 0x18(%rax), %rax
testq %rax, %rax
je 0x12c23c
popq %rcx
jmpq *%rax
pushq $-0x1
popq %rax
popq %rcx
retq
movq 0x30bd20(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1b8dc1(%rip), %rsi    # 0x2e5013
leaq 0x2109d2(%rip), %rdx    # 0x33cc2b
leaq 0x210a0e(%rip), %rcx    # 0x33cc6e
leaq 0x210966(%rip), %r8     # 0x33cbcd
pushq $0x4b
jmp 0x12c293
movq 0x30bcf6(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1b8d97(%rip), %rsi    # 0x2e5013
leaq 0x2109c6(%rip), %rdx    # 0x33cc49
leaq 0x2109e4(%rip), %rcx    # 0x33cc6e
leaq 0x21093c(%rip), %r8     # 0x33cbcd
pushq $0x4c
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x2108fc(%rip), %rsi    # 0x33cbcd
pushq $0x28
popq %rdi
pushq $0x62
popq %rdx
callq 0x93160
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_O2/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 0x12c319
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x12c321
decq %rax
movq %rax, 0x10(%rdi)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq (%rbx), %rax
testq %rax, %rax
je 0x12c362
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x12c33b
movq %rbx, %rdi
callq *%rax
movq 0x8(%rbx), %rdi
leaq 0x21088b(%rip), %r14    # 0x33cbcd
pushq $0x75
popq %rdx
movq %r14, %rsi
callq 0x936f9
pushq $0x76
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x936f9
movq 0x30bbff(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1b8ca0(%rip), %rsi    # 0x2e5013
leaq 0x210904(%rip), %rdx    # 0x33cc7e
leaq 0x21090c(%rip), %rcx    # 0x33cc8d
leaq 0x210845(%rip), %r8     # 0x33cbcd
pushq $0x72
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x12c3fa
movq %rsi, %rbx
movq %rdi, %r14
callq 0x12c432
movq %rax, %rdi
movq %r14, %rsi
callq 0x12c0db
movl 0x58(%rax), %ecx
movzbl %bl, %edx
subl %edx, %ecx
cmpl $0x1, %ecx
je 0x12c3dd
cmpl $0x3, %ecx
je 0x12c3d9
cmpl $0x2, %ecx
jne 0x12c3e7
movq 0x18(%rax), %rdi
movl $0xfe, %esi
jmp 0x12c3ee
movb $-0x3, %al
jmp 0x12c3df
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 0x575cc
movq 0x30bb67(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1b8c08(%rip), %rsi    # 0x2e5013
leaq 0x210819(%rip), %rdx    # 0x33cc2b
leaq 0x210884(%rip), %rcx    # 0x33cc9d
leaq 0x21089b(%rip), %r8     # 0x33ccbb
movl $0x14b, %r9d            # imm = 0x14B
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x311477(%rip), %rax    # 0x43d8b0
testq %rax, %rax
je 0x12c43f
retq
pushq %rax
leaq 0x29(%rip), %rsi        # 0x12c470
leaq 0x224(%rip), %rdx       # 0x12c672
leaq 0x4b3(%rip), %rcx       # 0x12c908
leaq 0x5a1(%rip), %r8        # 0x12c9fd
pushq $0x60
popq %rdi
callq 0x12c2b2
movq %rax, 0x311445(%rip)    # 0x43d8b0
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x12c969
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x12c432
movq %rax, %rdi
movq %r15, %rsi
callq 0x12c0db
movq 0x8(%r15), %rcx
movq (%rcx), %r8
cmpq %r14, %r8
jb 0x12c997
testq %r14, %r14
je 0x12c9c5
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 0x12cdf3
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x30b5f8(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1b8699(%rip), %rsi    # 0x2e5013
leaq 0x2102aa(%rip), %rdx    # 0x33cc2b
leaq 0x210420(%rip), %rcx    # 0x33cda8
leaq 0x21032c(%rip), %r8     # 0x33ccbb
movl $0x11d, %r9d            # imm = 0x11D
jmp 0x12c9f1
movq 0x30b5ca(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1b866b(%rip), %rsi    # 0x2e5013
leaq 0x210410(%rip), %rdx    # 0x33cdbf
leaq 0x2103f2(%rip), %rcx    # 0x33cda8
leaq 0x2102fe(%rip), %r8     # 0x33ccbb
movl $0x120, %r9d            # imm = 0x120
jmp 0x12c9f1
movq 0x30b59c(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1b863d(%rip), %rsi    # 0x2e5013
leaq 0x2103fe(%rip), %rdx    # 0x33cddb
leaq 0x2103c4(%rip), %rcx    # 0x33cda8
leaq 0x2102d0(%rip), %r8     # 0x33ccbb
movl $0x121, %r9d            # imm = 0x121
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x12ca4a
pushq %rbx
movq %rdi, %rbx
callq 0x12c432
movq %rax, %rdi
movq %rbx, %rsi
callq 0x12c0db
movq %rax, %rbx
movq 0x10(%rax), %rdi
callq 0x735fd
movq 0x18(%rbx), %rdi
callq 0x568b5
movq 0x20(%rbx), %rdi
leaq 0x210285(%rip), %rsi    # 0x33ccbb
movl $0x130, %edx            # imm = 0x130
callq 0x936f9
movq 0x38(%rbx), %rdi
popq %rbx
jmp 0xc0517
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x12cf9e
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x12cf6f
movq 0x8(%rbx), %rdi
callq 0x12cf6f
leaq 0x20fd2b(%rip), %rsi    # 0x33ccbb
movq %rbx, %rdi
movl $0x175, %edx            # imm = 0x175
popq %rbx
jmp 0x936f9
retq
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x12e447
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0x9a8ea
movq (%rbx), %rdi
callq 0xae103
leaq 0x20f0dd(%rip), %rsi    # 0x33d518
pushq $0x2a
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x12e4a4
movq %rsi, %r14
testq %rsi, %rsi
je 0x12e4a4
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
jne 0x12e4ce
movq (%rbx), %rdx
leaq 0x20f109(%rip), %rdi    # 0x33d577
leaq 0x20f10b(%rip), %rsi    # 0x33d580
xorl %ecx, %ecx
callq 0x9ad12
movq %rax, %r15
movq %rax, %rdi
callq 0x9b488
movq %r14, %rdi
movq %r15, %rsi
callq 0x97f31
movq %r15, %rdi
callq 0x97db0
movq %rax, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq 0x309abd(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1b6b5e(%rip), %rsi    # 0x2e5013
leaq 0x20f079(%rip), %rdx    # 0x33d535
leaq 0x20f07c(%rip), %rcx    # 0x33d53f
leaq 0x20f04e(%rip), %r8     # 0x33d518
pushq $0x31
jmp 0x12e4f6
movq 0x309a93(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1b6b34(%rip), %rsi    # 0x2e5013
leaq 0x20f07b(%rip), %rdx    # 0x33d561
leaq 0x20f052(%rip), %rcx    # 0x33d53f
leaq 0x20f024(%rip), %r8     # 0x33d518
pushq $0x32
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x12e56d
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x12e682
testq %r15, %r15
je 0x12e62e
movq 0x8(%r15), %rdi
callq 0x9b4cb
testb %al, %al
je 0x12e658
movq (%r15), %rdi
callq 0xad289
testq %rax, %rax
je 0x12e5bd
movq (%r15), %rdi
callq 0xad1fa
movq %rax, %rdi
callq 0x8da98
testb %al, %al
je 0x12e5d6
movq (%r15), %rdi
callq 0xad1fa
movq %rax, %rdi
callq 0xacbd1
movq %rax, %r14
jmp 0x12e600
movq %rbx, %rdi
callq 0x12e6b8
testq %rax, %rax
je 0x12e618
movq %rax, %r14
leaq 0x20f1f4(%rip), %rsi    # 0x33d7c8
jmp 0x12e5f8
movq %rbx, %rdi
callq 0x12e6b8
testq %rax, %rax
je 0x12e618
movq %rax, %r14
movq (%r15), %rsi
movq %rax, %rdi
callq 0xacd13
leaq 0x20f1d2(%rip), %rsi    # 0x33d7ca
movq %r14, %rdi
callq 0xacbfb
movq %r14, %rdi
callq 0xad1fa
movq %rax, %rdi
movq %rbx, %rsi
callq 0x12e245
movq %rax, %rbx
jmp 0x12e61d
xorl %r14d, %r14d
xorl %ebx, %ebx
movq %r14, %rdi
callq 0xae103
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x309933(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1b69d4(%rip), %rsi    # 0x2e5013
leaq 0x20f157(%rip), %rdx    # 0x33d79d
leaq 0x20f12c(%rip), %rcx    # 0x33d779
leaq 0x20eec4(%rip), %r8     # 0x33d518
pushq $0x64
jmp 0x12e6aa
movq 0x309909(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1b69aa(%rip), %rsi    # 0x2e5013
leaq 0x20f131(%rip), %rdx    # 0x33d7a1
leaq 0x20f102(%rip), %rcx    # 0x33d779
leaq 0x20ee9a(%rip), %r8     # 0x33d518
pushq $0x65
jmp 0x12e6aa
movq 0x3098df(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1b6980(%rip), %rsi    # 0x2e5013
leaq 0x1b6b25(%rip), %rdx    # 0x2e51bf
leaq 0x20f0d8(%rip), %rcx    # 0x33d779
leaq 0x20ee70(%rip), %r8     # 0x33d518
pushq $0x63
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x12e6d5
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x12e76b
movq %rbx, %rdi
callq 0x8a001
testq %rax, %rax
je 0x12e741
movq %rax, %r15
callq 0xacb84
movq %rax, %r14
pushq $0x20
popq %rsi
movq %r15, %rdi
callq 0x6c46d
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xacd9e
movq %r14, %rdi
callq 0xad1fa
movq %rax, %rdi
movq %rbx, %rsi
callq 0x8f124
movq %rax, %rbx
testq %rax, %rax
je 0x12e730
leaq 0x20f0b9(%rip), %rsi    # 0x33d7e1
movq %rbx, %rdi
callq 0xacbfb
movq %r14, %rdi
callq 0xae103
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x309820(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1b68c1(%rip), %rsi    # 0x2e5013
leaq 0x1cfc56(%rip), %rdx    # 0x2fe3af
leaq 0x20f074(%rip), %rcx    # 0x33d7d4
leaq 0x20edb1(%rip), %r8     # 0x33d518
pushq $0x52
jmp 0x12e793
movq 0x3097f6(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1b6897(%rip), %rsi    # 0x2e5013
leaq 0x1b6a3c(%rip), %rdx    # 0x2e51bf
leaq 0x20f04a(%rip), %rcx    # 0x33d7d4
leaq 0x20ed87(%rip), %r8     # 0x33d518
pushq $0x50
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 0x20af68(%rip), %rsi    # 0x33e3c9
pushq $0x10
popq %rdi
pushq $0x1f
popq %rdx
callq 0x93160
movq %r14, (%rax)
movq %rbx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1334bb
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 0x20af60(%rip), %rsi    # 0x33e407
pushq $0x1
popq %rdx
movq %r10, %rcx
movq %rax, %r8
movb $0x1, %al
callq 0x8d432
xorl %eax, %eax
popq %rcx
retq
movq 0x304aa6(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1b1b47(%rip), %rsi    # 0x2e5013
leaq 0x20af0e(%rip), %rdx    # 0x33e3e1
leaq 0x20af12(%rip), %rcx    # 0x33e3ec
leaq 0x20aee8(%rip), %r8     # 0x33e3c9
pushq $0x29
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x75173
movq %rax, %r14
movq 0x8(%r13), %rdi
movq %r12, %rsi
callq 0x75173
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 0x20ad72(%rip), %rsi    # 0x33e454
movq (%rsp), %rdx
movq %r12, %rcx
xorl %eax, %eax
pushq $0x0
pushq %rbx
pushq %r10
pushq %r15
pushq %r11
pushq %r14
callq 0x8d432
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x13377c
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
leaq 0x20ad4c(%rip), %rsi    # 0x33e47f
pushq $0x30
popq %rdx
callq 0x936f9
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x133763
leaq 0x28(%rbx), %r14
leaq 0x20ad30(%rip), %rsi    # 0x33e47f
pushq $0x31
popq %rdx
callq 0x936f9
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
andq $0x0, 0x10(%r14)
leaq 0x20ad15(%rip), %rsi    # 0x33e47f
pushq $0x32
popq %rdx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x133f1e
movq %rdi, %r14
cmpq $0x0, 0x38(%rdi)
je 0x133f14
movl %esi, %ebx
leaq 0x20a5a5(%rip), %rsi    # 0x33e47f
pushq $0x20
popq %rdi
movl $0xfc, %edx
callq 0x93160
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 0x133f16
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x304043(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1b10e4(%rip), %rsi    # 0x2e5013
leaq 0x1c1ba7(%rip), %rdx    # 0x2f5add
leaq 0x20a6de(%rip), %rcx    # 0x33e61b
leaq 0x20a53b(%rip), %r8     # 0x33e47f
movl $0xf6, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x133fef
testb %dl, %dl
jne 0x134053
movq (%rdi), %rcx
movq %rcx, %rax
movq 0x8(%rdi), %rdx
addq %rcx, %rdx
cmpq %rdx, %rax
jae 0x134051
movb (%rax), %dl
cmpb $-0x3, %dl
ja 0x133fea
movb $0x3, %cl
subb %dl, %cl
movb %cl, (%rax)
movq (%rdi), %rcx
incq %rax
jmp 0x133fce
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
addq %rax, %rcx
decq %rcx
testb %dl, %dl
je 0x134017
cmpq %rcx, %rax
jae 0x134051
movb (%rax), %dl
movb (%rcx), %sil
movb %sil, (%rax)
movb %dl, (%rcx)
incq %rax
decq %rcx
jmp 0x134000
cmpq %rcx, %rax
ja 0x134051
movzbl (%rax), %edx
movzbl (%rcx), %esi
movb $0x3, %dil
subb %sil, %dil
cmpb $-0x2, %sil
movzbl %dil, %edi
cmovael %esi, %edi
movb $0x3, %sil
subb %dl, %sil
cmpb $-0x2, %dl
movzbl %sil, %esi
cmovael %edx, %esi
movb %dil, (%rax)
movb %sil, (%rcx)
incq %rax
decq %rcx
jmp 0x134017
popq %rax
retq
movq 0x303f0e(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1b0faf(%rip), %rsi    # 0x2e5013
leaq 0x20a5d8(%rip), %rdx    # 0x33e643
leaq 0x20a5d9(%rip), %rcx    # 0x33e64b
leaq 0x20a406(%rip), %r8     # 0x33e47f
movl $0x134, %r9d            # imm = 0x134
xorl %eax, %eax
callq 0x17a50
callq 0x17390
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x1340b7
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x1340a1
movq %rdx, (%rax,%rsi,8)
jmp 0x1340b5
movq %rdx, %rax
shrq $0x20, %rax
jne 0x1340e1
movq (%rdi), %rax
testq %rax, %rax
je 0x13410b
movl %edx, (%rax,%rsi,4)
popq %rax
retq
movq 0x303eaa(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1b0f4b(%rip), %rsi    # 0x2e5013
leaq 0x20a590(%rip), %rdx    # 0x33e65f
leaq 0x20a594(%rip), %rcx    # 0x33e66a
leaq 0x20a5a9(%rip), %r8     # 0x33e686
pushq $0x56
jmp 0x134133
movq 0x303e80(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1b0f21(%rip), %rsi    # 0x2e5013
leaq 0x227a4e(%rip), %rdx    # 0x35bb47
leaq 0x20a56a(%rip), %rcx    # 0x33e66a
leaq 0x20a57f(%rip), %r8     # 0x33e686
pushq $0x5c
jmp 0x134133
movq 0x303e56(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1b0ef7(%rip), %rsi    # 0x2e5013
leaq 0x20a576(%rip), %rdx    # 0x33e699
leaq 0x20a540(%rip), %rcx    # 0x33e66a
leaq 0x20a555(%rip), %r8     # 0x33e686
pushq $0x5d
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x134163
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x134156
movq (%rax,%rsi,8), %rax
jmp 0x134161
movq (%rdi), %rax
testq %rax, %rax
je 0x13418d
movl (%rax,%rsi,4), %eax
popq %rcx
retq
movq 0x303dfe(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1b0e9f(%rip), %rsi    # 0x2e5013
leaq 0x2269f5(%rip), %rdx    # 0x35ab70
leaq 0x20a52e(%rip), %rcx    # 0x33e6b0
leaq 0x20a4fd(%rip), %r8     # 0x33e686
pushq $0x64
jmp 0x1341b5
movq 0x303dd4(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1b0e75(%rip), %rsi    # 0x2e5013
leaq 0x20a524(%rip), %rdx    # 0x33e6c9
leaq 0x20a504(%rip), %rcx    # 0x33e6b0
leaq 0x20a4d3(%rip), %r8     # 0x33e686
pushq $0x69
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x134203
leaq 0x8(%rbx), %rsi
pushq $0x1
popq %rdx
callq 0x19fd17
cmpb $0x1, 0xa1(%rbx)
jne 0x13422e
movq 0xb8(%rbx), %rdi
addq $0x20, %rbx
pushq $0x1
popq %rdx
movq %rbx, %rsi
popq %rbx
jmp 0x19fd17
pushq $0x1
popq %rdx
movq %rbx, %rsi
callq 0x19fe86
cmpb $0x1, 0xa1(%rbx)
jne 0x13422e
movq 0xb8(%rbx), %rdi
addq $0x10, %rbx
pushq $0x1
popq %rdx
movq %rbx, %rsi
popq %rbx
jmp 0x19fe86
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x2
popq %rbp
movl %ebp, %edx
subl %eax, %edx
leaq 0x1db07b(%rip), %rdi    # 0x30f2d2
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x19fc15
movq %rax, 0xb0(%r14)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1a0556
cmpb $0x1, 0xa1(%r14)
jne 0x1342ba
movq 0x60(%r14), %rsi
movzbl 0xa2(%r14), %eax
subl %eax, %ebp
leaq 0x4c(%r14), %r8
leaq 0x20a948(%rip), %rdi    # 0x33ebde
leaq 0x22(%rip), %rcx        # 0x1342bf
movl %ebp, %edx
callq 0x19fc15
movq %rax, 0xb8(%r14)
movq %rbx, %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x1a0556
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
movl %ecx, %ebp
movq %rdx, %r14
movl %esi, %ebx
movl %edi, %r12d
xorl %r13d, %r13d
movl $0x0, %r15d
testl %ecx, %ecx
je 0x13438c
cmpl $0x2, %ebx
jb 0x13437b
leal -0x2(%rbx), %esi
movl %r12d, %edi
callq 0x1649cf
movq %rax, %r15
jmp 0x13437e
xorl %r15d, %r15d
leal -0x1(%rbx), %esi
movl %r12d, %edi
callq 0x95871
movq %rax, %r13
movl %r12d, %edi
movl %ebx, %esi
callq 0x95871
xorl %ecx, %ecx
shrq $0x20, %r14
setne %cl
movzbl %bpl, %r9d
movl %ebx, %edi
movq %rax, %rsi
movq %r13, %rdx
movq %r15, %r8
callq 0x1343dc
movq %rax, %rbx
leaq 0x20a2c9(%rip), %rsi    # 0x33e686
movq %r15, %rdi
movl $0x142, %edx            # imm = 0x142
callq 0x936f9
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq