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

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xbc97e
movq %rax, %rdi
movq %r14, %rsi
callq 0xd8196
testq %rax, %rax
je 0xbd24c
cmpq %rbx, 0x10(%rax)
jbe 0xbd24c
movq 0x8(%rax), %rax
movq (%rax,%rbx,8), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xbc370
callq 0x2948e
// File: /workspace/github_c_makefile_star2_O3/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 0xbc97e
movq %rax, %rdi
movq %r15, %rsi
callq 0xd8196
testq %rax, %rax
je 0xbd28f
cmpq %r14, 0x10(%rax)
jbe 0xbd28f
movq 0x8(%rax), %rax
movq (%rax,%r14,8), %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xbc30e
callq 0x294c7
// File: /workspace/github_c_makefile_star2_O3/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 0xbc97e
movq %rax, %rdi
movq %r13, %rsi
callq 0xd8196
testq %rax, %rax
je 0xbd2e6
cmpq %r12, 0x10(%rax)
jbe 0xbd2e6
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 0xbc0b1
callq 0x29500
// File: /workspace/github_c_makefile_star2_O3/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 0xbc97e
movq %rax, %rdi
movq %r15, %rsi
callq 0xd8196
testq %rax, %rax
je 0xbd331
cmpq %r14, 0x10(%rax)
jbe 0xbd331
movq 0x8(%rax), %rax
movq (%rax,%r14,8), %rdi
movq %rbx, %rsi
callq 0xbbf5f
movq %rax, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x728c0
callq 0x29539
// File: /workspace/github_c_makefile_star2_O3/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 0xbc97e
movq %rax, %rdi
movq %r15, %rsi
callq 0xd8196
testq %rax, %rax
je 0xbd374
cmpq %r14, 0x10(%rax)
jbe 0xbd374
movq 0x8(%rax), %rax
movq (%rax,%r14,8), %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xbbf4b
callq 0x29572
// File: /workspace/github_c_makefile_star2_O3/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 0xbd39d
movq %rbx, %rdi
callq 0x34fea
testb %al, %al
jne 0xbd470
testq %r14, %r14
je 0xbd466
movq %r14, %rdi
callq 0x3cbed
testq %rax, %rax
je 0xbd46b
callq 0xbc97e
movq %rax, %rdi
callq 0xd812a
movq %rax, %r15
callq 0xbc97e
movq %rax, %rdi
movq %r15, %rsi
callq 0xd8196
movq %rax, %r12
movq $0x0, 0x20(%rax)
movq %r14, %rdi
callq 0x3cbed
movq %rax, 0x10(%r12)
leaq 0x44691(%rip), %rdx     # 0x101a87
movl $0x8, %esi
movq %rax, %rdi
movl $0x1ab, %ecx            # imm = 0x1AB
callq 0x359a6
movq %rax, 0x8(%r12)
xorl %r13d, %r13d
cmpq 0x10(%r12), %r13
jae 0xbd453
movq %r14, %rdi
movq %r13, %rsi
callq 0x3ca6f
movq %rax, %rdi
movq %rbx, %rsi
callq 0xbb730
movq 0x8(%r12), %rcx
movq %rax, (%rcx,%r13,8)
movq 0x8(%r12), %rax
cmpq $0x0, (%rax,%r13,8)
leaq 0x1(%r13), %r13
jne 0xbd410
movq %r15, %rdi
callq 0xbcb7c
xorl %r15d, %r15d
jmp 0xbd459
movb $0x0, 0x28(%r12)
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x2961d
callq 0x295e4
callq 0x295ab
// File: /workspace/github_c_makefile_star2_O3/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 0xbece8
testq %rsi, %rsi
je 0xbece8
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 0x297d7
nop
// File: /workspace/github_c_makefile_star2_O3/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 0xbf3f2
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq (%rdi), %rdi
testq %rdi, %rdi
jne 0xbf3a6
movups 0x933f1(%rip), %xmm0    # 0x152770
movups %xmm0, 0x20(%rsp)
movups 0x933d5(%rip), %xmm0    # 0x152760
movups %xmm0, 0x10(%rsp)
movups 0x933b9(%rip), %xmm0    # 0x152750
movups %xmm0, (%rsp)
callq 0x77ca4
movq %rax, %rdi
movq %rax, (%r14)
leaq 0x40(%rsp), %rsi
movq %r15, (%rsi)
callq 0x77dfe
testq %rax, %rax
je 0xbf3be
addq %rbx, 0x8(%rax)
jmp 0xbf3e4
movq (%r14), %rdi
leaq 0x40(%rsp), %rsi
movq %r15, (%rsi)
movq %rbx, 0x8(%rsi)
leaq 0x38(%rsp), %rdx
callq 0x780fe
testl %eax, %eax
jne 0xbf3e4
movq 0x38(%rsp), %rax
movq %rbx, 0x8(%rax)
addq %rbx, 0x8(%r14)
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x2995e
// File: /workspace/github_c_makefile_star2_O3/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 0xbf422
movq (%rdi), %rdi
testq %rdi, %rdi
je 0xbf41e
movq %rsp, %rax
movq %rsi, (%rax)
movq %rax, %rsi
callq 0x77dfe
testq %rax, %rax
je 0xbf41e
movq 0x8(%rax), %rax
jmp 0xbf420
xorl %eax, %eax
popq %rcx
retq
callq 0x29995
// File: /workspace/github_c_makefile_star2_O3/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 0xbf47f
movq %rdi, %rax
movq (%rdi), %rdi
testq %rdi, %rdi
je 0xbf47a
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        # 0xbf489
movq %rax, 0x8(%rdx)
movq %rcx, 0x10(%rdx)
leaq 0x49c(%rip), %rsi       # 0xbf90b
xorl %ecx, %ecx
callq 0x78316
testl %eax, %eax
jne 0xbf484
addq $0x38, %rsp
retq
callq 0x29a03
callq 0x299cc
// File: /workspace/github_c_makefile_star2_O3/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 0xbf4ac
movq %rcx, %rdi
callq 0x34fea
testb %al, %al
jne 0xbf530
testq %rbx, %rbx
je 0xbf52b
testq %r15, %r15
je 0xbf52b
movq %rbx, %xmm1
movq 0x21fbd(%rip), %xmm2    # 0xe1480
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x21fc1(%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 0x430e4(%rip), %rsi     # 0x1025fa
movq %r14, %rdx
movq %rbx, %rcx
movb $0x2, %al
callq 0x75ce5
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x29a71
callq 0x29a3a
// File: /workspace/github_c_makefile_star2_O3/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 0xbf5b7
movq (%rdi), %rdi
testq %rdi, %rdi
je 0xbf5b2
movq %rsi, (%rsp)
movq %rdx, 0x8(%rsp)
movq %rsp, %rax
leaq 0x10(%rsp), %rdx
testq %rcx, %rcx
je 0xbf58a
movq %rax, (%rdx)
leaq 0x3b8(%rip), %rax       # 0xbf922
movq %rax, 0x8(%rdx)
movq %rcx, 0x10(%rdx)
leaq 0x392(%rip), %rsi       # 0xbf90b
leaq 0x3e4(%rip), %rcx       # 0xbf964
xorl %r8d, %r8d
callq 0x78322
jmp 0xbf5ae
movq %rax, (%rdx)
leaq 0x38e(%rip), %rax       # 0xbf922
movq %rax, 0x8(%rdx)
movq $0x0, 0x10(%rdx)
leaq 0x364(%rip), %rsi       # 0xbf90b
xorl %ecx, %ecx
callq 0x78316
testl %eax, %eax
jne 0xbf5bc
addq $0x28, %rsp
retq
callq 0x29ae1
callq 0x29aa8
// File: /workspace/github_c_makefile_star2_O3/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 %rbx
movq %rdx, %rbx
movq %rdi, %rax
movq 0x20(%rdx), %rcx
movq 0x28(%rdx), %rdi
movl (%rcx), %ecx
movslq (%rdx), %rdx
leal 0x1(%rdx), %r8d
movl %r8d, (%rbx)
testl %ecx, %ecx
jne 0xbf8db
cmpl $0x2, %edx
jge 0xbf889
movslq 0x8(%rbx,%rdx,4), %rcx
cmpq %rax, %rcx
jne 0xbf8ad
movslq 0x14(%rbx,%rdx,4), %rax
xorl %ecx, %ecx
cmpq %rsi, %rax
je 0xbf8db
leaq 0x238ed(%rip), %rsi     # 0xe3159
leaq 0x42e55(%rip), %rdx     # 0x1026c8
leaq 0x42e10(%rip), %rcx     # 0x10268a
leaq 0x42c5f(%rip), %r8      # 0x1024e0
movl $0xcb, %r9d
jmp 0xbf8cf
leaq 0x238c9(%rip), %rsi     # 0xe3159
leaq 0x42dc6(%rip), %rdx     # 0x10265d
leaq 0x42dec(%rip), %rcx     # 0x10268a
leaq 0x42c3b(%rip), %r8      # 0x1024e0
movl $0xc9, %r9d
jmp 0xbf8cf
leaq 0x238a5(%rip), %rsi     # 0xe3159
leaq 0x42ddd(%rip), %rdx     # 0x102698
leaq 0x42dc8(%rip), %rcx     # 0x10268a
leaq 0x42c17(%rip), %r8      # 0x1024e0
movl $0xca, %r9d
xorl %eax, %eax
callq 0x34f1f
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movq 0x20(%rbx), %rax
movl %ecx, (%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xbf941
movq %rcx, %rdi
callq 0x34fea
testb %al, %al
jne 0xbf95f
testq %rbx, %rbx
je 0xbf95a
movq 0x8(%rbx), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq *(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x29b8c
callq 0x29b53
// File: /workspace/github_c_makefile_star2_O3/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 0xbf9b8
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 0xbf987
andl $0x3, %edx
leaq 0x42d3e(%rip), %rcx     # 0x102700
movslq (%rcx,%rdx,4), %rdx
addq %rcx, %rdx
jmpq *%rdx
movb (%rsi), %cl
shlb $0x6, %cl
jmp 0xbf9f4
movb (%rsi), %dl
movb 0x1(%rsi), %cl
shlb $0x6, %dl
shlb $0x4, %cl
jmp 0xbf9f2
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_O3/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 0xc01a0
cmpb $0x0, 0x1e8(%rdi)
je 0xc01a5
cmpq %rsi, 0x30(%rdi)
jb 0xc01aa
movq 0x1f0(%rdi), %rcx
subq %rcx, %rsi
jae 0xc018d
xorl %eax, %eax
jmp 0xc019e
incq %rcx
movq %rsi, %rax
xorl %edx, %edx
divq %rcx
testq %rdx, %rdx
sete %al
popq %rcx
retq
callq 0x2a097
callq 0x2a025
callq 0x2a05e
// File: /workspace/github_c_makefile_star2_O3/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 0xc01f8
cmpq %rsi, 0x8(%rax)
jbe 0xc01f8
movl 0x10(%rax), %edx
cmpq $0x21, %rdx
jae 0xc01f8
movq %rdi, %rbx
movq (%rax), %rdi
imulq %rdx, %rsi
callq 0xde1d4
movl 0x2a8(%rbx), %edx
cmpl %edx, %eax
jae 0xc01e8
movl %eax, %ecx
jmp 0xc01f4
movb $-0x2, %cl
je 0xc01f4
incl %edx
movb $-0x1, %cl
cmpl %edx, %eax
jne 0xc01fd
movl %ecx, %eax
popq %rbx
retq
callq 0x2a0f6
movl %eax, %edi
callq 0x2a0d0
// File: /workspace/github_c_makefile_star2_O3/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 0xc0461
movq 0x38(%rdi), %rcx
cmpq %rsi, %rcx
jbe 0xc0461
movl %edx, %eax
andl $-0x3, %eax
movq %rsi, %r8
notq %r8
addq %r8, %rcx
cmpl $0x1, %eax
cmovneq %rsi, %rcx
movq 0x30(%rdi), %rsi
cmpb $0x1, 0x3a8(%rdi)
jne 0xc03ea
cmpq %rsi, %rcx
jbe 0xc03e6
movl $0x3, %eax
subl %edx, %eax
leaq (%rsi,%rsi), %r8
subq %rcx, %r8
movl %eax, %edx
movq %r8, %rcx
jmp 0xc03ea
movb $-0x1, %al
je 0xc045f
cmpq %rsi, %rcx
jae 0xc0466
movq 0x280(%rdi), %rax
testq %rax, %rax
je 0xc0422
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 0xc045f
movl (%rdi), %eax
testl %eax, %eax
je 0xc043e
cmpl $0x1, %eax
jne 0xc046b
andl $-0x2, %edx
cmpl $0x2, %edx
je 0xc0470
movq %rcx, %rsi
popq %rax
jmp 0xc01af
movq 0x290(%rdi), %rax
movb (%rax,%rcx), %al
cmpb $-0x2, %al
jae 0xc0475
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 0x2a2f3
callq 0x2a20f
callq 0x2a2ba
callq 0x2a281
callq 0x2a248
// File: /workspace/github_c_makefile_star2_O3/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 0xc04da
movq %rsi, %rax
movq 0x38(%rdi), %rsi
cmpq %rax, %rsi
jbe 0xc04da
andl $-0x3, %edx
movq %rax, %rcx
notq %rcx
addq %rcx, %rsi
cmpl $0x1, %edx
cmovneq %rax, %rsi
cmpb $0x1, 0x3a8(%rdi)
jne 0xc04c0
movq 0x30(%rdi), %rax
cmpq %rax, %rsi
jbe 0xc04bc
addq %rax, %rax
subq %rsi, %rax
movq %rax, %rsi
jmp 0xc04c0
movb $0x1, %al
je 0xc04c9
cmpq $0x1, 0x40(%rdi)
jne 0xc04cb
xorl %eax, %eax
popq %rcx
retq
movq 0x140(%rdi), %rax
testq %rax, %rax
je 0xc04df
popq %rcx
jmpq *%rax
callq 0x2a365
callq 0x2a32c
// File: /workspace/github_c_makefile_star2_O3/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 0xc0544
movq %rsi, %rax
movq 0x38(%rdi), %rsi
cmpq %rax, %rsi
jbe 0xc0544
andl $-0x3, %edx
movq %rax, %rcx
notq %rcx
addq %rcx, %rsi
cmpl $0x1, %edx
cmovneq %rax, %rsi
cmpb $0x1, 0x3a8(%rdi)
jne 0xc052a
movq 0x30(%rdi), %rax
cmpq %rax, %rsi
jbe 0xc0526
addq %rax, %rax
subq %rsi, %rax
movq %rax, %rsi
jmp 0xc052a
movb $0x1, %al
je 0xc0533
cmpq $0x1, 0x40(%rdi)
jne 0xc0535
xorl %eax, %eax
popq %rcx
retq
movq 0x160(%rdi), %rax
testq %rax, %rax
je 0xc0549
popq %rcx
jmpq *%rax
callq 0x2a3d7
callq 0x2a39e
// File: /workspace/github_c_makefile_star2_O3/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 0xc0f1d
movq (%rdi), %rcx
movq 0x18(%rdi), %rax
movq 0x1f0(%rcx), %rcx
cmpq %rcx, %rax
jbe 0xc0f36
notq %rcx
addq %rcx, %rax
jmp 0xc0f31
movq (%rdi), %rax
movq 0x18(%rdi), %rcx
movq 0x1f0(%rax), %rax
addq %rcx, %rax
incq %rax
movq %rax, 0x18(%rdi)
retq
jne 0xc0f41
movq $0x0, 0x18(%rdi)
retq
testq %rax, %rax
jne 0xc0f47
retq
pushq %rax
callq 0x2a5a8
// File: /workspace/github_c_makefile_star2_O3/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 0xc1255
testq %r8, %r8
je 0xc1255
leaq (%r8,%rcx), %rax
cmpq 0x38(%rdi), %rax
ja 0xc1255
cmpb $0x1, 0x3a8(%rdi)
jne 0xc124c
movq 0x30(%rdi), %rax
cmpq %rcx, %rax
jae 0xc1247
movl $0x3, %r9d
subl %esi, %r9d
addq %rax, %rax
subq %rcx, %rax
movl %r9d, %esi
movq %rax, %rcx
jmp 0xc124c
jne 0xc124c
movb $0x1, %al
retq
movq 0x120(%rdi), %rax
jmpq *%rax
pushq %rax
callq 0x2a83c
// File: /workspace/github_c_makefile_star2_O3/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 0xc12b0
movq %r8, %rbx
movq %rcx, %r14
cmpq %r8, %rcx
ja 0xc12b0
movq %rdx, %r15
testq %rdx, %rdx
je 0xc12b0
cmpq %rbx, 0x38(%rsi)
jbe 0xc12b0
movq %rdi, %r12
xorl %edx, %edx
movq %r14, %rcx
callq 0xc12b5
movq %r12, %rdi
callq 0xc054e
movb %al, (%r15)
incq %r14
incq %r15
cmpq %rbx, %r14
jbe 0xc128e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x2a875
// File: /workspace/github_c_makefile_star2_O3/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 0xc1575
movq %rcx, %rbx
movq %rdx, %r14
cmpq %rcx, %rdx
ja 0xc1575
movq %rsi, %r15
testq %rsi, %rsi
je 0xc1575
movq %rdi, %r13
cmpq %rbx, 0x38(%rdi)
jbe 0xc1575
leaq 0x413fa(%rip), %rdx     # 0x10291a
movl $0x1, %edi
movl $0x38, %esi
movl $0xc5e, %ecx            # imm = 0xC5E
callq 0x359a6
movq %rax, %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rax)
movq %rax, %rdi
movq %r13, %rsi
xorl %edx, %edx
movq %r14, %rcx
callq 0xc12b5
movq %r12, %rdi
callq 0xc054e
movb %al, (%r15)
incq %r14
incq %r15
cmpq %rbx, %r14
jbe 0xc154e
movq %r12, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xc15cc
callq 0x2a959
// File: /workspace/github_c_makefile_star2_O3/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 0x4138a(%rip), %rdx     # 0x10291a
movl $0x1, %edi
movl $0x38, %esi
movl $0xc5e, %ecx            # imm = 0xC5E
callq 0x359a6
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rax)
movq %rax, %rdi
movq %r14, %rsi
movl %ebp, %edx
movq %rbx, %rcx
callq 0xc12b5
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xc162b
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0xc15e2
callq 0xc273d
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0xc15fc
leaq 0x41328(%rip), %rsi     # 0x10291a
movl $0xc6c, %edx            # imm = 0xC6C
callq 0x35c27
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0xc1616
leaq 0x4130e(%rip), %rsi     # 0x10291a
movl $0xc6e, %edx            # imm = 0xC6E
callq 0x35c27
leaq 0x412fd(%rip), %rsi     # 0x10291a
movq %rbx, %rdi
movl $0xc6f, %edx            # imm = 0xC6F
popq %rbx
jmp 0x35c27
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xc1681
movq %r8, %rbx
movq %rcx, %r14
cmpq %r8, %rcx
ja 0xc1681
movq %rdx, %r15
testq %rdx, %rdx
je 0xc1681
cmpq %rbx, 0x38(%rsi)
jbe 0xc1681
movq %rdi, %r12
xorl %edx, %edx
movq %r14, %rcx
callq 0xc12b5
movq %r12, %rdi
callq 0xc0f4d
movb %al, (%r15)
incq %r14
incq %r15
cmpq %rbx, %r14
jbe 0xc165f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x2a992
// File: /workspace/github_c_makefile_star2_O3/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 0xc170c
movq %rcx, %rbx
movq %rdx, %r14
cmpq %rcx, %rdx
ja 0xc170c
movq %rsi, %r15
testq %rsi, %rsi
je 0xc170c
movq %rdi, %r13
cmpq %rbx, 0x38(%rdi)
jbe 0xc170c
leaq 0x41263(%rip), %rdx     # 0x10291a
movl $0x1, %edi
movl $0x38, %esi
movl $0xc5e, %ecx            # imm = 0xC5E
callq 0x359a6
movq %rax, %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rax)
movq %rax, %rdi
movq %r13, %rsi
xorl %edx, %edx
movq %r14, %rcx
callq 0xc12b5
movq %r12, %rdi
callq 0xc0f4d
movb %al, (%r15)
incq %r14
incq %r15
cmpq %rbx, %r14
jbe 0xc16e5
movq %r12, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0xc15cc
callq 0x2a9cb
// File: /workspace/github_c_makefile_star2_O3/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 0xc173a
movb $0x1, %al
cmpb $0x0, 0x3a9(%rdi)
jne 0xc1739
cmpl $0x2, (%rdi)
setae %al
retq
pushq %rax
callq 0x2aa3d
// File: /workspace/github_c_makefile_star2_O3/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 0x3cbed
xorl %r14d, %r14d
testq %rax, %rax
je 0xc2039
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3caaa
movq %rax, %rdi
callq 0x3bb86
addq %rax, %r14
incq %r14
incq %r15
movq %rbx, %rdi
callq 0x3cbed
cmpq %rax, %r15
jb 0xc2010
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0xc2111
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r13
testb %r8b, %r8b
je 0xc20bd
callq 0x3b728
movq %rax, %r12
testq %r15, %r15
je 0xc2079
movq $0x2, (%r15)
movq %r13, %rdi
movq %r12, %rsi
callq 0xba7f3
testq %r14, %r14
je 0xc209c
movq %r12, %rdi
callq 0x3bb5d
movq %rax, %rdi
callq 0x728c0
movq %rax, (%r14)
testq %rbx, %rbx
je 0xc20ac
movq %r12, %rdi
callq 0x3bb86
movq %rax, (%rbx)
movq %r12, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x3c87b
movq %r13, %rdi
callq 0xbad2d
testb %al, %al
je 0xc20d7
testq %r15, %r15
je 0xc20ef
movq $0x0, (%r15)
jmp 0xc20ef
movq %r13, %rdi
callq 0xbabd9
testb %al, %al
je 0xc2065
testq %r15, %r15
je 0xc20ef
movq $0x1, (%r15)
testq %r14, %r14
je 0xc20fb
movq $0x0, (%r14)
testq %rbx, %rbx
je 0xc2107
movq $0x0, (%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x2abcc
// File: /workspace/github_c_makefile_star2_O3/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 0xc2d72
movq %rsi, %rbx
leaq 0x3fa63(%rip), %rax     # 0x10276c
movslq (%rax,%rdi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
cmpq $0x0, 0x8(%rbx)
jne 0xc2d7c
movl $0x77e, %ebp            # imm = 0x77E
movl $0x77d, %edx            # imm = 0x77D
jmp 0xc2d4e
cmpq $0x0, 0x8(%rbx)
jne 0xc2d77
movl $0x788, %ebp            # imm = 0x788
movl $0x787, %edx            # imm = 0x787
jmp 0xc2d4e
popq %rbx
popq %r14
popq %rbp
retq
cmpq $0x0, 0x8(%rbx)
jne 0xc2d81
movl $0x783, %ebp            # imm = 0x783
movl $0x782, %edx            # imm = 0x782
movq (%rbx), %rdi
leaq 0x3fbc2(%rip), %r14     # 0x10291a
movq %r14, %rsi
callq 0x35c27
movq 0x10(%rbx), %rdi
movq %r14, %rsi
movl %ebp, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x35c27
callq 0x2ad22
callq 0x2ac77
callq 0x2ace9
callq 0x2acb0
// File: /workspace/github_c_makefile_star2_O3/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
movq %rdi, %rbx
testq %rdi, %rdi
je 0xc2dae
movq 0x398(%rbx), %rdi
callq 0x3d043
incq 0x390(%rbx)
movq 0x398(%rbx), %rdi
callq 0x3d05e
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xc2db3
movq %rax, %rbx
movq %r15, %rdi
callq 0xbff74
movq %rax, %r14
movq %r15, %rdi
callq 0xbff64
testq %rbx, %rbx
je 0xc3086
testq %r14, %r14
je 0xc3094
movq %r14, %rcx
decq %rcx
je 0xc307a
xorl %edx, %edx
xorl %edi, %edi
movq (%rbx,%rdx,8), %rsi
movq %rsi, %r8
subq %rdi, %r8
jbe 0xc308f
movq %r8, (%rbx,%rdx,8)
incq %rsi
incq %rdx
movq %rsi, %rdi
cmpq %rdx, %rcx
jne 0xc305a
jmp 0xc307c
xorl %esi, %esi
subq %rsi, %rax
jbe 0xc3099
movq %rax, -0x8(%rbx,%r14,8)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x2ae06
callq 0x2ae78
callq 0x2ae3f
// File: /workspace/github_c_makefile_star2_O3/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 0xc3213
cmpb $0x1, 0x3a8(%rbx)
jne 0xc325d
cmpq $0x2, 0x48(%rbx)
jne 0xc325d
leaq 0x3f700(%rip), %rsi     # 0x10291a
movl $0x80, %edi
movl $0xd3e, %edx            # imm = 0xD3E
callq 0x35862
movq %rax, %r14
movq $0x0, 0x68(%rax)
movb %bpl, 0x64(%rax)
movzbl %bpl, %edx
movq %rax, %rdi
movq %rbx, %rsi
xorl %ecx, %ecx
callq 0xc30b5
movw $0x0, 0x62(%r14)
movb $0x0, 0x65(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
callq 0x2aeea
// File: /workspace/github_c_makefile_star2_O3/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 0xc386a
testq %rsi, %rsi
je 0xc38b2
cmpq %rcx, (%rdi)
jae 0xc386a
cmpq %rcx, -0x10(%rdi,%rsi,8)
jae 0xc386e
cmpq %rdx, %rcx
jae 0xc38b7
decq %rsi
movq %rsi, %rax
jmp 0xc386c
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 0xc3893
leaq 0x1(%rdx), %rax
cmpq %rcx, 0x8(%rdi,%rdx,8)
jb 0xc38a0
jmp 0xc386c
cmpq %rcx, -0x8(%rdi,%rdx,8)
jb 0xc38ad
decq %rdx
movq %rdx, %rsi
cmpq %rsi, %rax
jbe 0xc3874
movq %rcx, %rdi
callq 0x2b1cf
movq %rdx, %rax
jmp 0xc386c
callq 0x2b196
movq %rcx, %rdi
callq 0x2b1f3
// File: /workspace/github_c_makefile_star2_O3/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 0xc3a11
movq %rsi, %rdx
movl 0x4(%rdi), %eax
cmpl $0x6, %eax
je 0xc393d
cmpl $0x5, %eax
je 0xc3912
cmpl $0x4, %eax
jne 0xc3a16
cmpq $0xff, %rdx
ja 0xc39d8
movq 0x250(%rdi), %rax
movq (%rax), %rsi
testq %rsi, %rsi
je 0xc3965
movq 0x240(%rdi), %rdi
incq %rsi
movzbl %dl, %edx
popq %rbx
jmp 0xcf340
cmpq $0xffff, %rdx           # imm = 0xFFFF
ja 0xc396c
movq 0x250(%rdi), %rax
movq (%rax), %rsi
testq %rsi, %rsi
je 0xc3965
movq 0x240(%rdi), %rdi
incq %rsi
movzwl %dx, %edx
popq %rbx
jmp 0xcf3a8
movq %rdx, %rax
shrq $0x20, %rax
jne 0xc39a7
movq 0x250(%rdi), %rax
movq (%rax), %rsi
testq %rsi, %rsi
je 0xc3965
movq 0x240(%rdi), %rdi
incq %rsi
popq %rbx
jmp 0xcf414
xorl %ebx, %ebx
jmp 0xc3a0c
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 0xc3a0c
leaq (%rbx,%rbx), %rax
addq 0x240(%rdi), %rax
incq %rsi
movzwl %dx, %edx
movq %rax, %rdi
callq 0xcf3a8
jmp 0xc3a09
movq 0x250(%rdi), %rcx
movq -0x8(%rcx,%rax,8), %rbx
movq (%rcx,%rax,8), %rsi
subq %rbx, %rsi
jbe 0xc3a0c
leaq (,%rbx,4), %rax
addq 0x240(%rdi), %rax
incq %rsi
movq %rax, %rdi
callq 0xcf414
jmp 0xc3a09
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 0xc3a0c
movq 0x240(%rdi), %rdi
addq %rbx, %rdi
incq %rsi
movzbl %dl, %edx
callq 0xcf340
addq %rax, %rbx
movq %rbx, %rax
popq %rbx
retq
callq 0x2b217
movl %eax, %edi
callq 0x2b250