LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/bioseq_col.c
// Function: gt_bioseq_col_get_md5_fingerprint
static const char* gt_bioseq_col_get_md5_fingerprint(const GtSeqCol *sc,
                                                     GtUword filenum,
                                                     GtUword seqnum)
{
  GtBioseqCol *bsc;
  bsc = gt_bioseq_col_cast(sc);
  gt_assert(bsc && filenum < bsc->num_of_seqfiles);
  return gt_bioseq_get_md5_fingerprint(bsc->bioseqs[filenum], seqnum);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0xbb8c3
movq %rax, %rdi
movq %r15, %rsi
callq 0xd7a8e
testq %rax, %rax
je 0xbc20e
cmpq %r14, 0x10(%rax)
jbe 0xbc20e
movq 0x8(%rax), %rax
movq (%rax,%r14,8), %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xbb251
callq 0x29689
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/bioseq_col.c
// Function: gt_bioseq_col_get_sequence
static char* gt_bioseq_col_get_sequence(const GtSeqCol *sc,
                                        GtUword filenum,
                                        GtUword seqnum,
                                        GtUword start,
                                        GtUword end)
{
  GtBioseqCol *bsc;
  bsc = gt_bioseq_col_cast(sc);
  gt_assert(bsc && filenum < bsc->num_of_seqfiles);
  return gt_bioseq_get_sequence_range(bsc->bioseqs[filenum], seqnum, start,
                                      end);
}

// 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
callq 0xbb8c3
movq %rax, %rdi
movq %r13, %rsi
callq 0xd7a8e
testq %rax, %rax
je 0xbc265
cmpq %r12, 0x10(%rax)
jbe 0xbc265
movq 0x8(%rax), %rax
movq (%rax,%r12,8), %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xbaff4
callq 0x296c2
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/bioseq_col.c
// Function: gt_bioseq_col_get_description
static char* gt_bioseq_col_get_description(const GtSeqCol *sc,
                                           GtUword filenum,
                                           GtUword seqnum)
{
  GtBioseqCol *bsc;
  bsc = gt_bioseq_col_cast(sc);
  gt_assert(bsc && filenum < bsc->num_of_seqfiles);
  return gt_cstr_dup(gt_bioseq_get_description(bsc->bioseqs[filenum], seqnum));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0xbb8c3
movq %rax, %rdi
movq %r15, %rsi
callq 0xd7a8e
testq %rax, %rax
je 0xbc2b0
cmpq %r14, 0x10(%rax)
jbe 0xbc2b0
movq 0x8(%rax), %rax
movq (%rax,%r14,8), %rdi
movq %rbx, %rsi
callq 0xbaea2
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x722dc
callq 0x296fb
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/bioseq_col.c
// Function: gt_bioseq_col_get_sequence_length
static GtUword gt_bioseq_col_get_sequence_length(const GtSeqCol *sc,
                                                       GtUword filenum,
                                                       GtUword seqnum)
{
  GtBioseqCol *bsc;
  bsc = gt_bioseq_col_cast(sc);
  gt_assert(bsc && filenum < bsc->num_of_seqfiles);
  return gt_bioseq_get_sequence_length(bsc->bioseqs[filenum], seqnum);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0xbb8c3
movq %rax, %rdi
movq %r15, %rsi
callq 0xd7a8e
testq %rax, %rax
je 0xbc2f3
cmpq %r14, 0x10(%rax)
jbe 0xbc2f3
movq 0x8(%rax), %rax
movq (%rax,%r14,8), %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xbae8e
callq 0x29734
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/bioseq_col.c
// Function: gt_bioseq_col_new
GtSeqCol* gt_bioseq_col_new(GtStrArray *sequence_files, GtError *err)
{
  GtSeqCol *sc;
  GtBioseqCol *bsc;
  GtUword i;
  int had_err = 0;
  gt_error_check(err);
  gt_assert(sequence_files);
  gt_assert(gt_str_array_size(sequence_files));
  sc = gt_seq_col_create(gt_bioseq_col_class());
  bsc = gt_bioseq_col_cast(sc);
  bsc->duplicates = NULL;
  bsc->num_of_seqfiles = gt_str_array_size(sequence_files);
  bsc->bioseqs = gt_calloc(bsc->num_of_seqfiles, sizeof (GtBioseq*));
  for (i = 0; !had_err && i < bsc->num_of_seqfiles; i++) {
    bsc->bioseqs[i] = gt_bioseq_new(gt_str_array_get(sequence_files, i), err);
    if (!bsc->bioseqs[i])
      had_err = -1;
  }
  if (had_err) {
    gt_bioseq_col_delete(sc);
    return NULL;
  }
  bsc->matchdescstart = false;
  return sc;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
testq %rsi, %rsi
je 0xbc31c
movq %rbx, %rdi
callq 0x3566a
testb %al, %al
jne 0xbc3ef
testq %r14, %r14
je 0xbc3e5
movq %r14, %rdi
callq 0x3d560
testq %rax, %rax
je 0xbc3ea
callq 0xbb8c3
movq %rax, %rdi
callq 0xd7a22
movq %rax, %r15
callq 0xbb8c3
movq %rax, %rdi
movq %r15, %rsi
callq 0xd7a8e
movq %rax, %r12
movq $0x0, 0x20(%rax)
movq %r14, %rdi
callq 0x3d560
movq %rax, 0x10(%r12)
leaq 0x4579e(%rip), %rdx     # 0x101b13
movl $0x8, %esi
movq %rax, %rdi
movl $0x1ab, %ecx            # imm = 0x1AB
callq 0x3601f
movq %rax, 0x8(%r12)
xorl %r13d, %r13d
cmpq 0x10(%r12), %r13
jae 0xbc3d2
movq %r14, %rdi
movq %r13, %rsi
callq 0x3d3e2
movq %rax, %rdi
movq %rbx, %rsi
callq 0xba6a0
movq 0x8(%r12), %rcx
movq %rax, (%rcx,%r13,8)
movq 0x8(%r12), %rax
cmpq $0x0, (%rax,%r13,8)
leaq 0x1(%r13), %r13
jne 0xbc38f
movq %r15, %rdi
callq 0xbbade
xorl %r15d, %r15d
jmp 0xbc3d8
movb $0x0, 0x28(%r12)
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x297df
callq 0x297a6
callq 0x2976d
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/bsearch.c
// Function: cmp
static int cmp(const void *a_ptr, const void *b_ptr, GT_UNUSED void *unused)
{
  int a, b;
  gt_assert(a_ptr && b_ptr);
  a = *(int*) a_ptr;
  b = *(int*) b_ptr;
  if (a == b)
    return 0;
  if (a < b)
    return -1;
  return 1;
}

// Assembly:
testq %rdi, %rdi
je 0xbdc65
testq %rsi, %rsi
je 0xbdc65
movl (%rdi), %eax
xorl %ecx, %ecx
xorl %edx, %edx
cmpl (%rsi), %eax
setge %dl
leal -0x1(%rdx,%rdx), %eax
cmovel %ecx, %eax
retq
pushq %rax
callq 0x29999
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/disc_distri.c
// Function: gt_disc_distri_add_multi
void gt_disc_distri_add_multi(GtDiscDistri *d, GtUword key,
                              GtUint64 occurrences)
{
  GtUint64 *valueptr;
  gt_assert(d);

  if (!d->hashdist)
    d->hashdist = ul_ull_gt_hashmap_new();

  valueptr = ul_ull_gt_hashmap_get(d->hashdist, key);
  if (!valueptr) {
    ul_ull_gt_hashmap_add(d->hashdist, key, occurrences);
  }
  else
    (*valueptr) += occurrences;

  d->num_of_occurrences += occurrences;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
testq %rdi, %rdi
je 0xbe360
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
cmpq $0x0, (%rdi)
jne 0xbe311
movups 0x94483(%rip), %xmm0    # 0x152770
movups %xmm0, 0x20(%rsp)
movups 0x94467(%rip), %xmm0    # 0x152760
movups %xmm0, 0x10(%rsp)
movups 0x9444b(%rip), %xmm0    # 0x152750
movups %xmm0, (%rsp)
callq 0x777ac
movq %rax, (%r14)
movq (%r14), %rdi
leaq 0x40(%rsp), %rsi
movq %r15, (%rsi)
callq 0x77906
testq %rax, %rax
je 0xbe32c
addq %rbx, 0x8(%rax)
jmp 0xbe352
movq (%r14), %rdi
leaq 0x40(%rsp), %rsi
movq %r15, (%rsi)
movq %rbx, 0x8(%rsi)
leaq 0x38(%rsp), %rdx
callq 0x77c2e
testl %eax, %eax
jne 0xbe352
movq 0x38(%rsp), %rax
movq %rbx, 0x8(%rax)
addq %rbx, 0x8(%r14)
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x29b59
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/disc_distri.c
// Function: gt_disc_distri_get
GtUint64 gt_disc_distri_get(const GtDiscDistri *d, GtUword key)
{
  GtUint64 *valueptr;
  gt_assert(d);
  if (!d->hashdist || !(valueptr = ul_ull_gt_hashmap_get(d->hashdist, key)))
    return 0;
  return *valueptr;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0xbe390
movq (%rdi), %rdi
testq %rdi, %rdi
je 0xbe38c
movq %rsp, %rax
movq %rsi, (%rax)
movq %rax, %rsi
callq 0x77906
testq %rax, %rax
je 0xbe38c
movq 0x8(%rax), %rax
jmp 0xbe38e
xorl %eax, %eax
popq %rcx
retq
callq 0x29b90
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/disc_distri.c
// Function: gt_disc_distri_show
void gt_disc_distri_show(const GtDiscDistri *d, GtFile *outfp)
{
  GtShowValueInfo showvalueinfo;
  GT_UNUSED int rval;

  gt_assert(d);

  if (d->hashdist != NULL) {
    showvalueinfo.cumulative_probability = 0.0;
    showvalueinfo.num_of_occurrences = d->num_of_occurrences;
    showvalueinfo.outfp = outfp;
    rval = ul_ull_gt_hashmap_foreach_in_default_order(d->hashdist, showvalue,
                                                      &showvalueinfo, NULL);
    gt_assert(!rval); /* showvalue() is sane */
  }
}

// Assembly:
subq $0x38, %rsp
testq %rdi, %rdi
je 0xbe3ed
movq %rdi, %rax
movq (%rdi), %rdi
testq %rdi, %rdi
je 0xbe3e8
xorl %ecx, %ecx
leaq 0x8(%rsp), %r8
movq %rcx, (%r8)
movq 0x8(%rax), %rax
movq %rax, 0x8(%r8)
movq %rsi, 0x10(%r8)
leaq 0x20(%rsp), %rdx
movq %r8, (%rdx)
leaq 0x29(%rip), %rax        # 0xbe3f7
movq %rax, 0x8(%rdx)
movq %rcx, 0x10(%rdx)
leaq 0x505(%rip), %rsi       # 0xbe8e2
xorl %ecx, %ecx
callq 0x77e36
testl %eax, %eax
jne 0xbe3f2
addq $0x38, %rsp
retq
callq 0x29bfe
callq 0x29bc7
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/disc_distri.c
// Function: showvalue
static enum iterator_op
showvalue(GtUword key, GtUint64 occurrences,
          void *data, GT_UNUSED GtError *err)
{
  double probability;
  GtShowValueInfo *info;

  gt_error_check(err);
  gt_assert(data && occurrences);
  info = (GtShowValueInfo*) data;

  probability = (double) ((double) occurrences / info->num_of_occurrences);
  info->cumulative_probability += probability;
  gt_file_xprintf(info->outfp, GT_WU": "GT_LLU" (prob=%.4f,cumulative=%.4f)\n",
                  key, occurrences, probability, info->cumulative_probability);
  return CONTINUE_ITERATION;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
testq %rcx, %rcx
je 0xbe41a
movq %rcx, %rdi
callq 0x3566a
testb %al, %al
jne 0xbe49e
testq %rbx, %rbx
je 0xbe499
testq %r15, %r15
je 0xbe499
movq %rbx, %xmm1
movq 0x2304f(%rip), %xmm2    # 0xe1480
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x23053(%rip), %xmm3    # 0xe1490
subpd %xmm3, %xmm1
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
movq 0x8(%r15), %xmm1
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
subpd %xmm3, %xmm1
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
divsd %xmm2, %xmm0
movsd (%r15), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, (%r15)
movq 0x10(%r15), %rdi
leaq 0x44206(%rip), %rsi     # 0x10268a
movq %r14, %rdx
movq %rbx, %rcx
movb $0x2, %al
callq 0x757a1
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x29c6c
callq 0x29c35
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/disc_distri.c
// Function: gt_disc_distri_foreach_generic
static
void gt_disc_distri_foreach_generic(const GtDiscDistri *d,
                                    GtDiscDistriIterFunc func,
                                    void *data,
                                    ul_ull_gt_hashmap_KeyCmp cmp)
{
  DiscDistriForeachInfo info;
  GT_UNUSED int rval;
  gt_assert(d);
  if (d->hashdist != NULL) {
    info.func = func;
    info.data = data;
    if (cmp != NULL)
      rval = ul_ull_gt_hashmap_foreach_ordered(d->hashdist,
                                               disc_distri_foreach_iterfunc,
                                               &info, cmp, NULL);
    else
      rval = ul_ull_gt_hashmap_foreach_in_default_order(d->hashdist,
                                               disc_distri_foreach_iterfunc,
                                               &info, NULL);
    gt_assert(!rval); /* disc_distri_foreach_iterfunc() is sane */
  }
}

// Assembly:
subq $0x28, %rsp
testq %rdi, %rdi
je 0xbe525
movq (%rdi), %rdi
testq %rdi, %rdi
je 0xbe520
movq %rsi, (%rsp)
movq %rdx, 0x8(%rsp)
movq %rsp, %rax
leaq 0x10(%rsp), %rdx
testq %rcx, %rcx
je 0xbe4f8
movq %rax, (%rdx)
leaq 0x421(%rip), %rax       # 0xbe8f9
movq %rax, 0x8(%rdx)
movq %rcx, 0x10(%rdx)
leaq 0x3fb(%rip), %rsi       # 0xbe8e2
leaq 0x44d(%rip), %rcx       # 0xbe93b
xorl %r8d, %r8d
callq 0x77e42
jmp 0xbe51c
movq %rax, (%rdx)
leaq 0x3f7(%rip), %rax       # 0xbe8f9
movq %rax, 0x8(%rdx)
movq $0x0, 0x10(%rdx)
leaq 0x3cd(%rip), %rsi       # 0xbe8e2
xorl %ecx, %ecx
callq 0x77e36
testl %eax, %eax
jne 0xbe52a
addq $0x28, %rsp
retq
callq 0x29cdc
callq 0x29ca3
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/disc_distri.c
// Function: foreachtester
static void foreachtester(GtUword key,
                          GtUint64 value, void *data)
{
  struct ForeachTesterData *tdata = data;
  int had_err = *(tdata->had_err);
  GtError *err = tdata->err;
  tdata->counter++;
  gt_ensure(tdata->counter < DISC_DISTRI_FOREACHTESTSIZE);
  gt_ensure((GtUword) tdata->expkeys[tdata->counter] == key);
  gt_ensure((GtUint64) tdata->expvalues[tdata->counter] == value);
  *(tdata->had_err) = had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
movq 0x20(%rdx), %rax
movl (%rax), %eax
movq 0x28(%rdx), %r14
movl (%rdx), %ecx
leal 0x1(%rcx), %edx
movl %edx, (%rbx)
testl %eax, %eax
jne 0xbe820
xorl %eax, %eax
cmpl $0x2, %ecx
jl 0xbe820
leaq 0x24983(%rip), %rsi     # 0xe3179
leaq 0x43ef0(%rip), %rdx     # 0x1026ed
leaq 0x43f16(%rip), %rcx     # 0x10271a
leaq 0x43d65(%rip), %r8      # 0x102570
movq %r14, %rdi
movl $0xc9, %r9d
xorl %eax, %eax
callq 0x3559f
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %eax, %eax
jne 0xbe864
movslq (%rbx), %rax
movslq 0x4(%rbx,%rax,4), %rcx
xorl %eax, %eax
cmpq %r12, %rcx
je 0xbe864
leaq 0x2493f(%rip), %rsi     # 0xe3179
leaq 0x43ee7(%rip), %rdx     # 0x102728
leaq 0x43ed2(%rip), %rcx     # 0x10271a
leaq 0x43d21(%rip), %r8      # 0x102570
movq %r14, %rdi
movl $0xca, %r9d
xorl %eax, %eax
callq 0x3559f
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %eax, %eax
jne 0xbe8a8
movslq (%rbx), %rax
movslq 0x10(%rbx,%rax,4), %rcx
xorl %eax, %eax
cmpq %r15, %rcx
je 0xbe8a8
leaq 0x248fb(%rip), %rsi     # 0xe3179
leaq 0x43ed3(%rip), %rdx     # 0x102758
leaq 0x43e8e(%rip), %rcx     # 0x10271a
leaq 0x43cdd(%rip), %r8      # 0x102570
movq %r14, %rdi
movl $0xcb, %r9d
xorl %eax, %eax
callq 0x3559f
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movq 0x20(%rbx), %rcx
movl %eax, (%rcx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/disc_distri.c
// Function: disc_distri_foreach_iterfunc
static enum iterator_op
disc_distri_foreach_iterfunc(GtUword key, GtUint64 occurrences,
                             void *data, GT_UNUSED GtError *err)
{
  DiscDistriForeachInfo *info;
  gt_error_check(err);
  gt_assert(data);
  info = (DiscDistriForeachInfo*) data;
  info->func(key, occurrences, info->data);
  return CONTINUE_ITERATION;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rcx, %rcx
je 0xbe918
movq %rcx, %rdi
callq 0x3566a
testb %al, %al
jne 0xbe936
testq %rbx, %rbx
je 0xbe931
movq 0x8(%rbx), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq *(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x29d87
callq 0x29d4e
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_plainseq2bytecode
void gt_encseq_plainseq2bytecode(GtUchar *bytecode,
                                 const GtUchar *seq,
                                 GtUword len)
{
  GtUword j;
  const GtUchar *seqptr;

  for (seqptr=seq, j=0; seqptr < seq + len - 3; seqptr+=4, j++) {
    bytecode[j] = (seqptr[0] << 6) |
                  (seqptr[1] << 4) |
                  (seqptr[2] << 2) |
                   seqptr[3];
  }
  switch (GT_MOD4(len)) {
    case 1UL:
      bytecode[j] = seqptr[0] << 6;
      break;
    case 2UL:
      bytecode[j] = (seqptr[0] << 6) | (seqptr[1] << 4);
      break;
    case 3UL:
      bytecode[j] = (seqptr[0] << 6) | (seqptr[1] << 4) | (seqptr[2] << 2);
      break;
  }
}

// Assembly:
leaq (%rsi,%rdx), %rcx
addq $-0x3, %rcx
xorl %eax, %eax
cmpq %rsi, %rcx
jbe 0xbe990
movb (%rsi), %r8b
movb 0x1(%rsi), %r9b
shlb $0x6, %r8b
shlb $0x4, %r9b
orb %r8b, %r9b
movb 0x2(%rsi), %r8b
shlb $0x2, %r8b
orb %r9b, %r8b
orb 0x3(%rsi), %r8b
movb %r8b, (%rdi,%rax)
addq $0x4, %rsi
incq %rax
cmpq %rcx, %rsi
jb 0xbe95f
andl $0x3, %edx
leaq 0x43df6(%rip), %rcx     # 0x102790
movslq (%rcx,%rdx,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
movb (%rsi), %cl
shlb $0x6, %cl
jmp 0xbe9cc
movb (%rsi), %dl
movb 0x1(%rsi), %cl
shlb $0x6, %dl
shlb $0x4, %cl
jmp 0xbe9ca
movb (%rsi), %cl
movb 0x1(%rsi), %dl
shlb $0x6, %cl
shlb $0x4, %dl
orb %cl, %dl
movb 0x2(%rsi), %cl
shlb $0x2, %cl
orb %dl, %cl
movb %cl, (%rdi,%rax)
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/encseq.c
// Function: issinglepositioninspecialrangeViaequallength
static bool issinglepositioninspecialrangeViaequallength(const GtEncseq *encseq,
                                                         GtUword pos)
{
  gt_assert(encseq != NULL);
  gt_assert(encseq->equallength.defined);
  gt_assert(pos <= encseq->totallength);
  if (pos < encseq->equallength.valueunsignedlong ||
      (pos - encseq->equallength.valueunsignedlong) %
      (encseq->equallength.valueunsignedlong + 1) > 0) {
    return false;
  }
  return true;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0xbf198
cmpb $0x0, 0x1e8(%rdi)
je 0xbf19d
cmpq %rsi, 0x30(%rdi)
jb 0xbf1a2
movq 0x1f0(%rdi), %rcx
subq %rcx, %rsi
jae 0xbf185
xorl %eax, %eax
jmp 0xbf196
incq %rcx
movq %rsi, %rax
xorl %edx, %edx
divq %rcx
testq %rdx, %rdx
sete %al
popq %rcx
retq
callq 0x2a292
callq 0x2a220
callq 0x2a259
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/encseq.c
// Function: delivercharViabytecompress
static GtUchar delivercharViabytecompress(const GtEncseq *encseq,
                                          GtUword pos)
{
  uint32_t cc;

  cc = bitpackarray_get_uint32(encseq->bitpackarray, (BitOffset) pos);
  if (cc < (uint32_t) encseq->numofchars)
    return (GtUchar) cc;
  if (cc == (uint32_t) encseq->numofchars)
    return (GtUchar) GT_WILDCARD;
  if (cc == (uint32_t) (encseq->numofchars+1))
    return (GtUchar) GT_SEPARATOR;
  fprintf(stderr, "delivercharViabytecompress: cc="GT_WU" not possible\n",
                  (GtUword) cc);
  exit(GT_EXIT_PROGRAMMING_ERROR);
}

// Assembly:
pushq %rbx
movq 0x2a0(%rdi), %rax
testq %rax, %rax
je 0xbf1f0
cmpq %rsi, 0x8(%rax)
jbe 0xbf1f0
movl 0x10(%rax), %edx
cmpq $0x21, %rdx
jae 0xbf1f0
movq %rdi, %rbx
movq (%rax), %rdi
imulq %rdx, %rsi
callq 0xdda90
movl 0x2a8(%rbx), %edx
cmpl %edx, %eax
jae 0xbf1e0
movl %eax, %ecx
jmp 0xbf1ec
movb $-0x2, %cl
je 0xbf1ec
incl %edx
movb $-0x1, %cl
cmpl %edx, %eax
jne 0xbf1f5
movl %ecx, %eax
popq %rbx
retq
callq 0x2a2f1
movl %eax, %edi
callq 0x2a2cb
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_get_encoded_char_nospecial
GtUchar gt_encseq_get_encoded_char_nospecial(const GtEncseq *encseq,
                                             GtUword pos,
                                             GtReadmode readmode)
{
  gt_assert(encseq != NULL && pos < encseq->logicaltotallength);
  /* translate into forward coords */
  if (GT_ISDIRREVERSE(readmode))
    pos = GT_REVERSEPOS(encseq->logicaltotallength, pos);
  /* handle virtual coordinates */
  if (encseq->hasmirror) {
    if (pos > encseq->totallength) {
      /* invert coordinates and readmode */
      gt_readmode_invert(readmode);
      pos = GT_REVERSEPOS(encseq->totallength, pos - encseq->totallength - 1);
    } else if (pos == encseq->totallength) {
      return (GtUchar) GT_SEPARATOR;
    }
  }
  gt_assert(pos < encseq->totallength);
  if (encseq->twobitencoding != NULL) {
    GtUword twobits;

    twobits = EXTRACTENCODEDCHAR(encseq->twobitencoding, pos);
    return GT_ISDIRCOMPLEMENT(readmode)
             ? GT_COMPLEMENTBASE((GtUchar) twobits)
             : (GtUchar) twobits;
  }
  if (encseq->sat == GT_ACCESS_TYPE_BYTECOMPRESS) {
    gt_assert(!GT_ISDIRCOMPLEMENT(readmode));
    return delivercharViabytecompress(encseq, pos);
  }
  else {
    GtUchar cc;
    gt_assert(encseq->sat == GT_ACCESS_TYPE_DIRECTACCESS);
    cc = encseq->plainseq[pos];
    gt_assert(GT_ISNOTSPECIAL(cc));
    return GT_ISDIRCOMPLEMENT(readmode)
           ? GT_COMPLEMENTBASE(cc)
           : cc;
  }
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0xbf455
movq 0x38(%rdi), %rcx
cmpq %rsi, %rcx
jbe 0xbf455
movl %edx, %eax
andl $-0x3, %eax
movq %rsi, %r8
notq %r8
addq %r8, %rcx
cmpl $0x1, %eax
cmovneq %rsi, %rcx
cmpb $0x1, 0x3a8(%rdi)
jne 0xbf3dd
movq 0x30(%rdi), %rax
cmpq %rax, %rcx
jbe 0xbf3d9
movl $0x3, %esi
subl %edx, %esi
addq %rax, %rax
subq %rcx, %rax
movl %esi, %edx
movq %rax, %rcx
jmp 0xbf3dd
movb $-0x1, %al
je 0xbf453
cmpq 0x30(%rdi), %rcx
jae 0xbf45a
movq 0x280(%rdi), %rax
testq %rax, %rax
je 0xbf416
movq %rcx, %rsi
shrq $0x5, %rsi
movq (%rax,%rsi,8), %rax
notl %ecx
addl %ecx, %ecx
shrq %cl, %rax
andl $-0x2, %edx
andb $0x3, %al
movzbl %al, %ecx
xorb $0x3, %al
cmpl $0x2, %edx
movzbl %al, %eax
cmovnel %ecx, %eax
jmp 0xbf453
movl (%rdi), %eax
testl %eax, %eax
je 0xbf432
cmpl $0x1, %eax
jne 0xbf45f
andl $-0x2, %edx
cmpl $0x2, %edx
je 0xbf464
movq %rcx, %rsi
popq %rax
jmp 0xbf1a7
movq 0x290(%rdi), %rax
movb (%rax,%rcx), %al
cmpb $-0x2, %al
jae 0xbf469
andl $-0x2, %edx
movb $0x3, %cl
subb %al, %cl
cmpl $0x2, %edx
movzbl %cl, %ecx
movzbl %al, %eax
cmovel %ecx, %eax
popq %rcx
retq
callq 0x2a4ee
callq 0x2a40a
callq 0x2a4b5
callq 0x2a47c
callq 0x2a443
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_position_is_wildcard
bool gt_encseq_position_is_wildcard(const GtEncseq *encseq,
                                    GtUword pos,
                                    GtReadmode readmode)
{
  gt_assert(encseq != NULL && pos < encseq->logicaltotallength);
  /* translate into forward coords */
  if (GT_ISDIRREVERSE(readmode))
    pos = GT_REVERSEPOS(encseq->logicaltotallength, pos);
  /* handle virtual coordinates */
  if (encseq->hasmirror) {
    if (pos > encseq->totallength) {
      /* invert coordinates and readmode */
      gt_readmode_invert(readmode);
      pos = GT_REVERSEPOS(encseq->totallength, pos - encseq->totallength - 1);
    }
    else {
      if (pos == encseq->totallength)
        return true;
    }
  }
  if (encseq->numofdbsequences == 1UL)
    return false;
  gt_assert(encseq->issinglepositioninwildcardrange != NULL);
  return encseq->issinglepositioninwildcardrange(encseq, pos);
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0xbf4ce
movq %rsi, %rax
movq 0x38(%rdi), %rsi
cmpq %rax, %rsi
jbe 0xbf4ce
andl $-0x3, %edx
movq %rax, %rcx
notq %rcx
addq %rcx, %rsi
cmpl $0x1, %edx
cmovneq %rax, %rsi
cmpb $0x1, 0x3a8(%rdi)
jne 0xbf4b4
movq 0x30(%rdi), %rax
cmpq %rax, %rsi
jbe 0xbf4b0
addq %rax, %rax
subq %rsi, %rax
movq %rax, %rsi
jmp 0xbf4b4
movb $0x1, %al
je 0xbf4bd
cmpq $0x1, 0x40(%rdi)
jne 0xbf4bf
xorl %eax, %eax
popq %rcx
retq
movq 0x140(%rdi), %rax
testq %rax, %rax
je 0xbf4d3
popq %rcx
jmpq *%rax
callq 0x2a560
callq 0x2a527
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_position_is_separator
bool gt_encseq_position_is_separator(const GtEncseq *encseq,
                                     GtUword pos,
                                     GtReadmode readmode)
{
  gt_assert(encseq != NULL && pos < encseq->logicaltotallength);
  /* translate into forward coords */
  if (GT_ISDIRREVERSE(readmode))
    pos = GT_REVERSEPOS(encseq->logicaltotallength, pos);
  /* handle virtual coordinates */
  if (encseq->hasmirror) {
    if (pos > encseq->totallength) {
      /* invert coordinates and readmode */
      gt_readmode_invert(readmode);
      pos = GT_REVERSEPOS(encseq->totallength, pos - encseq->totallength - 1);
    }
    else {
      if (pos == encseq->totallength)
        return true;
    }
  }
  if (encseq->numofdbsequences == 1UL)
    return false;
  gt_assert(encseq->issinglepositionseparator != NULL);
  return encseq->issinglepositionseparator(encseq, pos);
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0xbf538
movq %rsi, %rax
movq 0x38(%rdi), %rsi
cmpq %rax, %rsi
jbe 0xbf538
andl $-0x3, %edx
movq %rax, %rcx
notq %rcx
addq %rcx, %rsi
cmpl $0x1, %edx
cmovneq %rax, %rsi
cmpb $0x1, 0x3a8(%rdi)
jne 0xbf51e
movq 0x30(%rdi), %rax
cmpq %rax, %rsi
jbe 0xbf51a
addq %rax, %rax
subq %rsi, %rax
movq %rax, %rsi
jmp 0xbf51e
movb $0x1, %al
je 0xbf527
cmpq $0x1, 0x40(%rdi)
jne 0xbf529
xorl %eax, %eax
popq %rcx
retq
movq 0x160(%rdi), %rax
testq %rax, %rax
je 0xbf53d
popq %rcx
jmpq *%rax
callq 0x2a5d2
callq 0x2a599
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/encseq.c
// Function: singlepositioninseparatorViaequallength_updatestate
static void singlepositioninseparatorViaequallength_updatestate(
                                   GtEncseqReader *esr)
{
  if (!GT_ISDIRREVERSE(esr->readmode))
    esr->nextseparatorpos += (esr->encseq->equallength.valueunsignedlong + 1);
  else {
    if (esr->nextseparatorpos > esr->encseq->equallength.valueunsignedlong) {
      esr->nextseparatorpos -= (esr->encseq->equallength.valueunsignedlong+1);
    }
    else {
      if (esr->nextseparatorpos == esr->encseq->equallength.valueunsignedlong)
        esr->nextseparatorpos = 0;
      else
        gt_assert(esr->nextseparatorpos == 0);
    }
  }
}

// Assembly:
movl 0x8(%rdi), %eax
orl $0x2, %eax
cmpl $0x3, %eax
jne 0xbfe7f
movq (%rdi), %rcx
movq 0x18(%rdi), %rax
movq 0x1f0(%rcx), %rcx
cmpq %rcx, %rax
jbe 0xbfe98
notq %rcx
addq %rcx, %rax
jmp 0xbfe93
movq (%rdi), %rax
movq 0x18(%rdi), %rcx
movq 0x1f0(%rax), %rax
addq %rcx, %rax
incq %rax
movq %rax, 0x18(%rdi)
retq
jne 0xbfea3
movq $0x0, 0x18(%rdi)
retq
testq %rax, %rax
jne 0xbfea9
retq
pushq %rax
callq 0x2a7a3
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_contains_special
bool gt_encseq_contains_special(const GtEncseq *encseq,
                                GtReadmode readmode,
                                GtEncseqReader *esr,
                                GtUword startpos,
                                GtUword len)
{
  gt_assert(len >= 1UL && encseq != NULL &&
            startpos + len <= encseq->logicaltotallength);
  if (encseq->hasmirror) {
    if (startpos > encseq->totallength) {
      gt_readmode_invert(readmode);
      startpos = GT_REVERSEPOS(encseq->totallength,
                               startpos - encseq->totallength - 1);
    } else if (startpos == encseq->totallength) {
        return true;
    }
  }
  return encseq->delivercontainsspecial(encseq, readmode, esr, startpos, len);
}

// Assembly:
testq %rdi, %rdi
je 0xc01b0
testq %r8, %r8
je 0xc01b0
leaq (%r8,%rcx), %rax
cmpq 0x38(%rdi), %rax
ja 0xc01b0
cmpb $0x1, 0x3a8(%rdi)
jne 0xc01a7
movq 0x30(%rdi), %rax
cmpq %rcx, %rax
jae 0xc01a2
movl $0x3, %r9d
subl %esi, %r9d
addq %rax, %rax
subq %rcx, %rax
movl %r9d, %esi
movq %rax, %rcx
jmp 0xc01a7
jne 0xc01a7
movb $0x1, %al
retq
movq 0x120(%rdi), %rax
jmpq *%rax
pushq %rax
callq 0x2aa37
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_extract_encoded_with_reader
void gt_encseq_extract_encoded_with_reader(GtEncseqReader *esr,
                               const GtEncseq *encseq,
                               GtUchar *buffer,
                               GtUword frompos,
                               GtUword topos)
{
  GtUword idx, pos;

  gt_assert(frompos <= topos && encseq != NULL &&
            topos < encseq->logicaltotallength && buffer != NULL);
  gt_encseq_reader_reinit_with_readmode(esr, encseq, GT_READMODE_FORWARD,
                                        frompos);
  for (pos=frompos, idx = 0; pos <= topos; pos++, idx++) {
    buffer[idx] = gt_encseq_reader_next_encoded_char(esr);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0xc020d
movq %r8, %rbx
movq %rcx, %r14
cmpq %r8, %rcx
ja 0xc020d
movq %rdx, %r15
testq %rdx, %rdx
je 0xc020d
cmpq %rbx, 0x38(%rsi)
jbe 0xc020d
movq %rdi, %r12
xorl %edx, %edx
movq %r14, %rcx
callq 0xc0212
cmpq %rbx, %r14
ja 0xc0201
movq %r12, %rdi
callq 0xbf542
movb %al, (%r15)
incq %r14
incq %r15
jmp 0xc01e9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x2aa70
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_extract_encoded
void gt_encseq_extract_encoded(const GtEncseq *encseq,
                               GtUchar *buffer,
                               GtUword frompos,
                               GtUword topos)
{
  GtEncseqReader *esr;
  GtUword idx, pos;

  gt_assert(frompos <= topos && encseq != NULL &&
            topos < encseq->logicaltotallength && buffer != NULL);
  esr = gt_encseq_create_reader_with_readmode(encseq,
                                              GT_READMODE_FORWARD,
                                              frompos);
  for (pos=frompos, idx = 0; pos <= topos; pos++, idx++) {
    buffer[idx] = gt_encseq_reader_next_encoded_char(esr);
  }
  gt_encseq_reader_delete(esr);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0xc04ec
movq %rcx, %rbx
movq %rdx, %r14
cmpq %rcx, %rdx
ja 0xc04ec
movq %rsi, %r15
testq %rsi, %rsi
je 0xc04ec
movq %rdi, %r13
cmpq %rbx, 0x38(%rdi)
jbe 0xc04ec
leaq 0x42595(%rip), %rdx     # 0x102a2a
movl $0x1, %edi
movl $0x38, %esi
movl $0xc5e, %ecx            # imm = 0xC5E
callq 0x3601f
movq %rax, %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rax)
movq %rax, %rdi
movq %r13, %rsi
xorl %edx, %edx
movq %r14, %rcx
callq 0xc0212
cmpq %rbx, %r14
ja 0xc04db
movq %r12, %rdi
callq 0xbf542
movb %al, (%r15)
incq %r14
incq %r15
jmp 0xc04c3
movq %r12, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xc0543
callq 0x2ab8d
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_create_reader_with_readmode
GtEncseqReader* gt_encseq_create_reader_with_readmode(const GtEncseq *encseq,
                                                      GtReadmode readmode,
                                                      GtUword startpos)
{
  GtEncseqReader *esr = gt_calloc((size_t) 1, sizeof (*esr));
  /* the following is implicit by using calloc, but we better initialize
     it for documentation */
  esr->wildcardrangestate = esr->ssptabstate = NULL;
  gt_encseq_reader_reinit_with_readmode(esr, encseq, readmode, startpos);
  return esr;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x42523(%rip), %rdx     # 0x102a2a
movl $0x1, %edi
movl $0x38, %esi
movl $0xc5e, %ecx            # imm = 0xC5E
callq 0x3601f
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rax)
movq %rax, %rdi
movq %r14, %rsi
movl %ebp, %edx
movq %rbx, %rcx
callq 0xc0212
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_reader_delete
void gt_encseq_reader_delete(GtEncseqReader *esr)
{
  if (esr == NULL) return;
  if (esr->encseq != NULL)
    gt_encseq_delete(esr->encseq);
  if (esr->wildcardrangestate != NULL)
   gt_free(esr->wildcardrangestate);
  if (esr->ssptabstate != NULL)
    gt_free(esr->ssptabstate);
  gt_free(esr);
}

// Assembly:
testq %rdi, %rdi
je 0xc05a2
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0xc0559
callq 0xc1690
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0xc0573
leaq 0x424c1(%rip), %rsi     # 0x102a2a
movl $0xc6c, %edx            # imm = 0xC6C
callq 0x362a0
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0xc058d
leaq 0x424a7(%rip), %rsi     # 0x102a2a
movl $0xc6e, %edx            # imm = 0xC6E
callq 0x362a0
leaq 0x42496(%rip), %rsi     # 0x102a2a
movq %rbx, %rdi
movl $0xc6f, %edx            # imm = 0xC6F
popq %rbx
jmp 0x362a0
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_extract_decoded_with_reader
void gt_encseq_extract_decoded_with_reader(GtEncseqReader *esr,
                                           const GtEncseq *encseq,
                                           char *buffer,
                                           GtUword frompos,
                                           GtUword topos)
{
  GtUword idx, pos;

  gt_assert(frompos <= topos && encseq != NULL &&
            topos < encseq->logicaltotallength && buffer != NULL);
  gt_encseq_reader_reinit_with_readmode(esr, encseq, GT_READMODE_FORWARD,
                                        frompos);
  for (pos=frompos, idx = 0; pos <= topos; pos++, idx++) {
    buffer[idx] = gt_encseq_reader_next_decoded_char(esr);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rsi, %rsi
je 0xc05fa
movq %r8, %rbx
movq %rcx, %r14
cmpq %r8, %rcx
ja 0xc05fa
movq %rdx, %r15
testq %rdx, %rdx
je 0xc05fa
cmpq %rbx, 0x38(%rsi)
jbe 0xc05fa
movq %rdi, %r12
xorl %edx, %edx
movq %r14, %rcx
callq 0xc0212
cmpq %rbx, %r14
ja 0xc05ee
movq %r12, %rdi
callq 0xbfeaf
movb %al, (%r15)
incq %r14
incq %r15
jmp 0xc05d6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x2abc6
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_extract_decoded
void gt_encseq_extract_decoded(const GtEncseq *encseq,
                               char *buffer,
                               GtUword frompos,
                               GtUword topos)
{
  GtEncseqReader *esr;
  GtUword idx, pos;

  gt_assert(frompos <= topos && encseq != NULL &&
            topos < encseq->logicaltotallength && buffer != NULL);
  esr = gt_encseq_create_reader_with_readmode(encseq,
                                              GT_READMODE_FORWARD,
                                              frompos);
  for (pos=frompos, idx = 0; pos <= topos; pos++, idx++) {
    buffer[idx] = gt_encseq_reader_next_decoded_char(esr);
  }
  gt_encseq_reader_delete(esr);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0xc0687
movq %rcx, %rbx
movq %rdx, %r14
cmpq %rcx, %rdx
ja 0xc0687
movq %rsi, %r15
testq %rsi, %rsi
je 0xc0687
movq %rdi, %r13
cmpq %rbx, 0x38(%rdi)
jbe 0xc0687
leaq 0x423fa(%rip), %rdx     # 0x102a2a
movl $0x1, %edi
movl $0x38, %esi
movl $0xc5e, %ecx            # imm = 0xC5E
callq 0x3601f
movq %rax, %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rax)
movq %rax, %rdi
movq %r13, %rsi
xorl %edx, %edx
movq %r14, %rcx
callq 0xc0212
cmpq %rbx, %r14
ja 0xc0676
movq %r12, %rdi
callq 0xbfeaf
movb %al, (%r15)
incq %r14
incq %r15
jmp 0xc065e
movq %r12, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xc0543
callq 0x2abff
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_has_twobitencoding
bool gt_encseq_has_twobitencoding(const GtEncseq *encseq)
{
  gt_assert(encseq != NULL);
  return (encseq->accesstype_via_utables ||
          encseq->sat >= GT_ACCESS_TYPE_EQUALLENGTH ||
          encseq->sat == GT_ACCESS_TYPE_BITACCESS) ? true : false;
}

// Assembly:
testq %rdi, %rdi
je 0xc06b5
movb $0x1, %al
cmpb $0x0, 0x3a9(%rdi)
jne 0xc06b4
cmpl $0x2, (%rdi)
setae %al
retq
pushq %rax
callq 0x2ac71
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/encseq.c
// Function: determinelengthofdbfilenames
static GtUword determinelengthofdbfilenames(const GtStrArray *filenametab)
{
  GtUword idx, lengthofdbfilenames = 0;

  for (idx = 0; idx < gt_str_array_size(filenametab); idx++) {
    lengthofdbfilenames
      += gt_str_length(gt_str_array_get_str(filenametab, idx)) + 1;
  }
  return lengthofdbfilenames;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x3d560
xorl %r14d, %r14d
testq %rax, %rax
je 0xc0f70
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3d41d
movq %rax, %rdi
callq 0x3c434
addq %rax, %r14
incq %r14
incq %r15
movq %rbx, %rdi
callq 0x3d560
cmpq %rax, %r15
jb 0xc0f47
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/encseq.c
// Function: alphabet_to_key_values
static void alphabet_to_key_values(const GtAlphabet *alpha,
                                   GtUword *alphatype,
                                   GtUword *lengthofalphadef,
                                   char **alphadef, bool customalphabet)
{
  gt_assert(alpha);
  if (!customalphabet && gt_alphabet_is_dna(alpha)) {
    if (alphatype != NULL)
      *alphatype = 0UL;
    if (alphadef != NULL)
      *alphadef = NULL;
    if (lengthofalphadef != NULL)
      *lengthofalphadef = 0UL;
  } else if (!customalphabet && gt_alphabet_is_protein(alpha)) {
    if (alphatype != NULL)
      *alphatype = 1UL;
    if (alphadef != NULL)
      *alphadef = NULL;
    if (lengthofalphadef != NULL)
      *lengthofalphadef = 0UL;
  } else {
    GtStr *s = gt_str_new();
    if (alphatype != NULL)
      *alphatype = 2UL;
    gt_alphabet_to_str(alpha, s);
    if (alphadef != NULL)
      *alphadef = gt_cstr_dup(gt_str_get(s));
    if (lengthofalphadef != NULL)
      *lengthofalphadef = gt_str_length(s);
    gt_str_delete(s);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xc1064
movl %r8d, %ebp
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
testb %bpl, %bpl
je 0xc0ffe
callq 0x3bfe0
movq %rax, %r13
testq %r15, %r15
je 0xc0fb5
movq $0x2, (%r15)
movq %r12, %rdi
movq %r13, %rsi
callq 0xb9708
testq %r14, %r14
je 0xc0fd8
movq %r13, %rdi
callq 0x3c40b
movq %rax, %rdi
callq 0x722dc
movq %rax, (%r14)
testq %rbx, %rbx
je 0xc0fe8
movq %r13, %rdi
callq 0x3c434
movq %rax, (%rbx)
movq %r13, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3d1eb
movq %r12, %rdi
callq 0xb9c19
testb %al, %al
je 0xc103d
testq %r15, %r15
je 0xc1016
movq $0x0, (%r15)
testq %r14, %r14
je 0xc1022
movq $0x0, (%r14)
testq %rbx, %rbx
je 0xc102e
movq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testb %bpl, %bpl
jne 0xc0fa1
movq %r12, %rdi
callq 0xb9ad2
testb %al, %al
je 0xc0fa1
testq %r15, %r15
je 0xc1016
movq $0x1, (%r15)
jmp 0xc1016
callq 0x2ae00
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/encseq.c
// Function: gt_ssptab_delete
static void gt_ssptab_delete(GtEncseqAccessType satsep, GtSWtable *ssptab)
{
  switch (satsep) {
    case GT_ACCESS_TYPE_UCHARTABLES:
      gt_assert(ssptab->st_uchar.rangelengths == NULL);
      gt_free(ssptab->st_uchar.positions);
      gt_free(ssptab->st_uchar.endidxinpage);
      break;
    case GT_ACCESS_TYPE_USHORTTABLES:
      gt_assert(ssptab->st_uint16.rangelengths == NULL);
      gt_free(ssptab->st_uint16.positions);
      gt_free(ssptab->st_uint16.endidxinpage);
      break;
    case GT_ACCESS_TYPE_UINT32TABLES:
      gt_assert(ssptab->st_uint32.rangelengths == NULL);
      gt_free(ssptab->st_uint32.positions);
      gt_free(ssptab->st_uint32.endidxinpage);
      break;
    default:
      gt_assert(satsep == GT_ACCESS_TYPE_UNDEFINED);
      break;
  }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
addl $-0x4, %edi
cmpl $0x3, %edi
ja 0xc1cbf
movq %rsi, %rbx
leaq 0x40ba6(%rip), %rax     # 0x1027fc
movslq (%rax,%rdi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
cmpq $0x0, 0x8(%rbx)
jne 0xc1cc9
movl $0x77e, %ebp            # imm = 0x77E
movl $0x77d, %edx            # imm = 0x77D
jmp 0xc1c9b
cmpq $0x0, 0x8(%rbx)
jne 0xc1cc4
movl $0x788, %ebp            # imm = 0x788
movl $0x787, %edx            # imm = 0x787
jmp 0xc1c9b
popq %rbx
popq %r14
popq %rbp
retq
cmpq $0x0, 0x8(%rbx)
jne 0xc1cce
movl $0x783, %ebp            # imm = 0x783
movl $0x782, %edx            # imm = 0x782
movq (%rbx), %rdi
leaq 0x40d85(%rip), %r14     # 0x102a2a
movq %r14, %rsi
callq 0x362a0
movq 0x10(%rbx), %rdi
movq %r14, %rsi
movl %ebp, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x362a0
callq 0x2af56
callq 0x2aeab
callq 0x2af1d
callq 0x2aee4
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_ref
GtEncseq* gt_encseq_ref(GtEncseq *encseq)
{
  if (!encseq) return NULL;
  gt_mutex_lock(encseq->refcount_lock);
  encseq->reference_count++;
  gt_mutex_unlock(encseq->refcount_lock);
  return encseq;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0xc1cfd
movq %rdi, %rbx
movq 0x398(%rdi), %rdi
callq 0x3d9b7
incq 0x390(%rbx)
movq 0x398(%rbx), %rdi
callq 0x3d9d2
jmp 0xc1cff
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/encseq.c
// Function: gt_all_sequence_lengths_get
GtUword *gt_all_sequence_lengths_get(const GtEncseq *encseq)
{
  GtUword idx, previousstart = 0,
          *ssptab = gt_all_sequence_separators_get(encseq);
  const GtUword numofsequences = gt_encseq_num_of_sequences(encseq),
                totallength = gt_encseq_total_length(encseq);;

  if (ssptab == NULL)
  {
    return NULL; /* all sequences are of the same length */
  }
  gt_assert(numofsequences > 0);
  for (idx = 0; idx < numofsequences - 1; idx++)
  {
    GtUword nextsep = ssptab[idx];
    gt_assert(previousstart < nextsep);
    ssptab[idx] = nextsep - previousstart;
    previousstart = nextsep + 1;
  }
  gt_assert(previousstart < totallength);
  ssptab[idx] = totallength - previousstart;
  return ssptab;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
callq 0xc1d04
movq %rax, %rbx
movq %r15, %rdi
callq 0xbef6c
movq %rax, %r14
movq %r15, %rdi
callq 0xbef5c
testq %rbx, %rbx
je 0xc1fda
testq %r14, %r14
je 0xc1ff9
decq %r14
je 0xc1fde
xorl %ecx, %ecx
xorl %esi, %esi
movq (%rbx,%rcx,8), %rdx
movq %rdx, %rdi
subq %rsi, %rdi
jbe 0xc1ff4
movq %rdi, (%rbx,%rcx,8)
incq %rdx
incq %rcx
movq %rdx, %rsi
cmpq %rcx, %r14
jne 0xc1fba
jmp 0xc1fe2
xorl %ebx, %ebx
jmp 0xc1feb
xorl %edx, %edx
xorl %ecx, %ecx
subq %rdx, %rax
jbe 0xc1ffe
movq %rax, (%rbx,%rcx,8)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x2b03a
callq 0x2b0ac
callq 0x2b073
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/encseq.c
// Function: gt_specialrangeiterator_new
GtSpecialrangeiterator* gt_specialrangeiterator_new(const GtEncseq *encseq,
                                                    bool moveforward)
{
  GtSpecialrangeiterator *sri;

  gt_assert(encseq->has_specialranges
              || (encseq->hasmirror && encseq->logicalnumofdbsequences == 2UL));
  sri = gt_malloc(sizeof (*sri));
  sri->esr = NULL;
  sri->originalmoveforward = moveforward;
  gt_specialrangeiterator_reinit(sri, encseq, moveforward);
  sri->reflected = false;
  sri->skipnext = false;
  sri->middle_separator_emitted = false;
  gt_assert(sri != NULL);
  return sri;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
cmpb $0x0, 0x28(%rdi)
jne 0xc217c
cmpb $0x1, 0x3a8(%rbx)
jne 0xc21cb
cmpq $0x2, 0x48(%rbx)
jne 0xc21cb
leaq 0x408a7(%rip), %rsi     # 0x102a2a
movl $0x80, %edi
movl $0xd3e, %edx            # imm = 0xD3E
callq 0x35ee2
movq %rax, %r14
movq $0x0, 0x68(%rax)
movb %bpl, 0x64(%rax)
movzbl %bpl, %edx
movq %rax, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0xc2023
movw $0x0, 0x62(%r14)
movb $0x0, 0x65(%r14)
testq %r14, %r14
je 0xc21d0
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
callq 0x2b11e
callq 0x2b157
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_sep2seqnum
GtUword gt_encseq_sep2seqnum(const GtUword *recordseps,
                                   GtUword numofrecords,
                                   GtUword totalwidth,
                                   GtUword position)
{
  GtUword left, mid, right, len;

  gt_assert(numofrecords > 0);
  if (numofrecords == 1UL || position <= recordseps[0])
    return 0;
  if (position > recordseps[numofrecords-2]) {
    if (position < totalwidth)
      return numofrecords - 1;
    fprintf(stderr,
            "gt_encseq_sep2seqnum: cannot find position "GT_WU"\n", position);
    exit(GT_EXIT_PROGRAMMING_ERROR);
  }
  left = 0;
  right = numofrecords - 2;
  while (left<=right) {
    len = right-left;
    mid = left + GT_DIV2(len);
    if (recordseps[mid] < position) {
      if (position <= recordseps[mid+1])
        return mid + 1;
      left = mid + 1;
    }
    else {
      if (recordseps[mid-1] < position)
        return mid;
      right = mid-1;
    }
  }
  fprintf(stderr, "gt_encseq_sep2seqnum: cannot find position "GT_WU"\n",
          position);
  exit(GT_EXIT_PROGRAMMING_ERROR);
}

// Assembly:
pushq %rax
cmpq $0x1, %rsi
je 0xc2819
testq %rsi, %rsi
je 0xc2861
cmpq %rcx, (%rdi)
jae 0xc2819
cmpq %rcx, -0x10(%rdi,%rsi,8)
jae 0xc281d
cmpq %rdx, %rcx
jae 0xc2866
decq %rsi
movq %rsi, %rax
jmp 0xc281b
xorl %eax, %eax
popq %rcx
retq
addq $-0x2, %rsi
xorl %eax, %eax
movq %rsi, %rdx
subq %rax, %rdx
shrq %rdx
addq %rax, %rdx
cmpq %rcx, (%rdi,%rdx,8)
jae 0xc2842
leaq 0x1(%rdx), %rax
cmpq %rcx, 0x8(%rdi,%rdx,8)
jb 0xc284f
jmp 0xc281b
cmpq %rcx, -0x8(%rdi,%rdx,8)
jb 0xc285c
decq %rdx
movq %rdx, %rsi
cmpq %rsi, %rax
jbe 0xc2823
movq %rcx, %rdi
callq 0x2b43c
movq %rdx, %rax
jmp 0xc281b
callq 0x2b403
movq %rcx, %rdi
callq 0x2b460
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_seqnum_ssptab
GtUword gt_encseq_seqnum_ssptab(const GtEncseq *encseq,
                                         GtUword position)
{
  gt_assert(position < encseq->totallength);
  switch (encseq->satsep) {
    case GT_ACCESS_TYPE_UCHARTABLES:
      return gt_encseq_seqnum_uchar(&encseq->ssptab.st_uchar,position);
    case GT_ACCESS_TYPE_USHORTTABLES:
      return gt_encseq_seqnum_uint16(&encseq->ssptab.st_uint16,position);
    case GT_ACCESS_TYPE_UINT32TABLES:
      return gt_encseq_seqnum_uint32(&encseq->ssptab.st_uint32,position);
    default:
      fprintf(stderr, "%s(%d) undefined\n", __func__, (int) encseq->satsep);
      exit(GT_EXIT_PROGRAMMING_ERROR);
  }
}

// Assembly:
pushq %rbx
cmpq %rsi, 0x30(%rdi)
jbe 0xc29c0
movq %rsi, %rdx
movl 0x4(%rdi), %eax
cmpl $0x6, %eax
je 0xc28ec
cmpl $0x5, %eax
je 0xc28c1
cmpl $0x4, %eax
jne 0xc29c5
cmpq $0xff, %rdx
ja 0xc2987
movq 0x250(%rdi), %rax
movq (%rax), %rsi
testq %rsi, %rsi
je 0xc2914
movq 0x240(%rdi), %rdi
incq %rsi
movzbl %dl, %edx
popq %rbx
jmp 0xce469
cmpq $0xffff, %rdx           # imm = 0xFFFF
ja 0xc291b
movq 0x250(%rdi), %rax
movq (%rax), %rsi
testq %rsi, %rsi
je 0xc2914
movq 0x240(%rdi), %rdi
incq %rsi
movzwl %dx, %edx
popq %rbx
jmp 0xce4d1
movq %rdx, %rax
shrq $0x20, %rax
jne 0xc2956
movq 0x250(%rdi), %rax
movq (%rax), %rsi
testq %rsi, %rsi
je 0xc2914
movq 0x240(%rdi), %rdi
incq %rsi
popq %rbx
jmp 0xce53d
xorl %ebx, %ebx
jmp 0xc29bb
movq 0x250(%rdi), %rax
movq %rdx, %rcx
shrq $0x10, %rcx
movq -0x8(%rax,%rcx,8), %rbx
movq (%rax,%rcx,8), %rsi
subq %rbx, %rsi
jbe 0xc29bb
leaq (%rbx,%rbx), %rax
addq 0x240(%rdi), %rax
incq %rsi
movzwl %dx, %edx
movq %rax, %rdi
callq 0xce4d1
jmp 0xc29b8
movq 0x250(%rdi), %rcx
movq -0x8(%rcx,%rax,8), %rbx
movq (%rcx,%rax,8), %rsi
subq %rbx, %rsi
jbe 0xc29bb
leaq (,%rbx,4), %rax
addq 0x240(%rdi), %rax
incq %rsi
movq %rax, %rdi
callq 0xce53d
jmp 0xc29b8
movq 0x250(%rdi), %rax
movq %rdx, %rcx
shrq $0x8, %rcx
movq -0x8(%rax,%rcx,8), %rbx
movq (%rax,%rcx,8), %rsi
subq %rbx, %rsi
jbe 0xc29bb
movq 0x240(%rdi), %rdi
addq %rbx, %rdi
incq %rsi
movzbl %dl, %edx
callq 0xce469
addq %rax, %rbx
movq %rbx, %rax
popq %rbx
retq
callq 0x2b484
movl %eax, %edi
callq 0x2b4bd