LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x112a6e
movq 0xa159b(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x4b61f(%rip), %rsi     # 0x15e066
leaq 0x74d07(%rip), %rdx     # 0x187755
leaq 0x727e3(%rip), %rcx     # 0x185238
leaq 0x727ac(%rip), %r8      # 0x185208
movl $0x4a, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x112a70
movq 0x18(%rsp), %rax
cmpq $0x0, (%rax)
je 0x112a98
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x112970
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
jne 0x112aa3
movq $0x0, 0x20(%rsp)
jmp 0x112ab0
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x112b0e
movq 0xa14fb(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x4b57f(%rip), %rsi     # 0x15e066
leaq 0x74c67(%rip), %rdx     # 0x187755
leaq 0x72756(%rip), %rcx     # 0x18524b
leaq 0x7270c(%rip), %r8      # 0x185208
movl $0x6d, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x112b10
movq 0x30(%rsp), %rax
cmpq $0x0, (%rax)
je 0x112ba4
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq (%rax), %rdi
leaq 0xc1(%rip), %rsi        # 0x112c10
leaq 0x10(%rsp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x112bb0
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
je 0x112ba0
movq 0xa1469(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x4b4ed(%rip), %rsi     # 0x15e066
leaq 0x4bef9(%rip), %rdx     # 0x15ea79
leaq 0x726c4(%rip), %rcx     # 0x18524b
leaq 0x7267a(%rip), %r8      # 0x185208
movl $0x75, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x112ba2
jmp 0x112ba4
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x112c78
movq 0x18(%rsp), %rdi
callq 0xc270
testb $0x1, %al
jne 0x112c40
jmp 0x112c78
movq 0xa1391(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x4b415(%rip), %rsi     # 0x15e066
leaq 0x4b9f0(%rip), %rdx     # 0x15e648
leaq 0x726a5(%rip), %rcx     # 0x185304
leaq 0x725a2(%rip), %r8      # 0x185208
movl $0x5d, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x112c7a
jmp 0x112c7c
cmpq $0x0, 0x20(%rsp)
je 0x112c8c
cmpq $0x0, 0x28(%rsp)
jne 0x112cc4
movq 0xa1345(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x4b3c9(%rip), %rsi     # 0x15e066
leaq 0x7266a(%rip), %rdx     # 0x18530e
leaq 0x72659(%rip), %rcx     # 0x185304
leaq 0x72556(%rip), %r8      # 0x185208
movl $0x5e, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x112cc6
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %xmm0
movaps 0x4b7a3(%rip), %xmm3    # 0x15e480
punpckldq %xmm3, %xmm0    # xmm0 = xmm0[0],xmm3[0],xmm0[1],xmm3[1]
movapd 0x4b7a7(%rip), %xmm2    # 0x15e490
subpd %xmm2, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movq 0x8(%rsp), %rax
movq 0x8(%rax), %xmm1
punpckldq %xmm3, %xmm1    # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
movq 0x8(%rsp), %rax
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rcx
movsd 0x10(%rsp), %xmm0
movq 0x8(%rsp), %rax
movsd (%rax), %xmm1
leaq 0x725c7(%rip), %rsi     # 0x185322
movb $0x2, %al
callq 0x837b0
xorl %eax, %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x112df8
movq 0xa1211(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x4b295(%rip), %rsi     # 0x15e066
leaq 0x7497d(%rip), %rdx     # 0x187755
leaq 0x7256a(%rip), %rcx     # 0x185349
leaq 0x72422(%rip), %r8      # 0x185208
movl $0x92, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x112dfa
movq 0x30(%rsp), %rax
cmpq $0x0, (%rax)
je 0x112eb4
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x112e4e
movq 0x30(%rsp), %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rcx
leaq 0x667(%rip), %rsi       # 0x1134a0
leaq 0x8(%rsp), %rdx
xorl %eax, %eax
movl %eax, %r8d
callq 0x113430
movl %eax, 0x4(%rsp)
jmp 0x112e6f
movq 0x30(%rsp), %rax
movq (%rax), %rdi
leaq 0x643(%rip), %rsi       # 0x1134a0
leaq 0x8(%rsp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x112bb0
movl %eax, 0x4(%rsp)
jmp 0x112e71
cmpl $0x0, 0x4(%rsp)
je 0x112eb0
movq 0xa1159(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x4b1dd(%rip), %rsi     # 0x15e066
leaq 0x4bbe9(%rip), %rdx     # 0x15ea79
leaq 0x724b2(%rip), %rcx     # 0x185349
leaq 0x7236a(%rip), %r8      # 0x185208
movl $0x9e, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x112eb2
jmp 0x112eb4
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rax
movl (%rax), %eax
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
cmpl $0x0, 0x14(%rsp)
jne 0x1132af
movq 0x18(%rsp), %rax
cmpl $0x3, (%rax)
jl 0x1132ad
movq 0x8(%rsp), %rdi
leaq 0x4cef4(%rip), %rsi     # 0x160177
leaq 0x720fb(%rip), %rdx     # 0x185385
leaq 0x72121(%rip), %rcx     # 0x1853b2
leaq 0x71f70(%rip), %r8      # 0x185208
movl $0xc9, %r9d
movb $0x0, %al
callq 0xc0d0
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
jmp 0x1132af
jmp 0x1132b1
jmp 0x1132b3
cmpl $0x0, 0x14(%rsp)
jne 0x11330b
movq 0x18(%rsp), %rax
movq 0x18(%rsp), %rcx
movslq (%rcx), %rcx
movslq 0x4(%rax,%rcx,4), %rax
cmpq 0x30(%rsp), %rax
je 0x113309
movq 0x8(%rsp), %rdi
leaq 0x4ce98(%rip), %rsi     # 0x160177
leaq 0x720da(%rip), %rdx     # 0x1853c0
leaq 0x720c5(%rip), %rcx     # 0x1853b2
leaq 0x71f14(%rip), %r8      # 0x185208
movl $0xca, %r9d
movb $0x0, %al
callq 0xc0d0
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
jmp 0x11330b
jmp 0x11330d
jmp 0x11330f
cmpl $0x0, 0x14(%rsp)
jne 0x113367
movq 0x18(%rsp), %rax
movq 0x18(%rsp), %rcx
movslq (%rcx), %rcx
movslq 0x10(%rax,%rcx,4), %rax
cmpq 0x28(%rsp), %rax
je 0x113365
movq 0x8(%rsp), %rdi
leaq 0x4ce3c(%rip), %rsi     # 0x160177
leaq 0x720ae(%rip), %rdx     # 0x1853f0
leaq 0x72069(%rip), %rcx     # 0x1853b2
leaq 0x71eb8(%rip), %r8      # 0x185208
movl $0xcb, %r9d
movb $0x0, %al
callq 0xc0d0
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
jmp 0x113367
jmp 0x113369
movl 0x14(%rsp), %ecx
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rax
movl %ecx, (%rax)
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x113508
movq 0x8(%rsp), %rdi
callq 0xc270
testb $0x1, %al
jne 0x1134d0
jmp 0x113508
movq 0xa0b01(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x4ab85(%rip), %rsi     # 0x15e066
leaq 0x4b160(%rip), %rdx     # 0x15e648
leaq 0x71e79(%rip), %rcx     # 0x185368
leaq 0x71d12(%rip), %r8      # 0x185208
movl $0x83, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x11350a
jmp 0x11350c
cmpq $0x0, 0x10(%rsp)
jne 0x11354c
movq 0xa0abd(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x4ab41(%rip), %rsi     # 0x15e066
leaq 0x4b206(%rip), %rdx     # 0x15e732
leaq 0x71e35(%rip), %rcx     # 0x185368
leaq 0x71cce(%rip), %r8      # 0x185208
movl $0x84, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x11354e
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq (%rax), %rax
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq (%rsp), %rcx
movq 0x8(%rcx), %rdx
callq *%rax
xorl %eax, %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x28(%rsp)
movq $0x0, -0x20(%rsp)
movq -0x28(%rsp), %rax
movq -0x10(%rsp), %rcx
addq -0x18(%rsp), %rcx
addq $-0x3, %rcx
cmpq %rcx, %rax
jae 0x113679
movq -0x28(%rsp), %rax
movzbl (%rax), %eax
shll $0x6, %eax
movq -0x28(%rsp), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x4, %ecx
orl %ecx, %eax
movq -0x28(%rsp), %rcx
movzbl 0x2(%rcx), %ecx
shll $0x2, %ecx
orl %ecx, %eax
movq -0x28(%rsp), %rcx
movzbl 0x3(%rcx), %ecx
orl %ecx, %eax
movb %al, %dl
movq -0x8(%rsp), %rax
movq -0x20(%rsp), %rcx
movb %dl, (%rax,%rcx)
movq -0x28(%rsp), %rax
addq $0x4, %rax
movq %rax, -0x28(%rsp)
movq -0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rsp)
jmp 0x113602
movq -0x18(%rsp), %rax
andl $0x3, %eax
movq %rax, -0x30(%rsp)
subq $0x1, %rax
je 0x1136a8
jmp 0x11368e
movq -0x30(%rsp), %rax
subq $0x2, %rax
je 0x1136c4
jmp 0x11369b
movq -0x30(%rsp), %rax
subq $0x3, %rax
je 0x1136ee
jmp 0x113724
movq -0x28(%rsp), %rax
movzbl (%rax), %eax
shll $0x6, %eax
movb %al, %dl
movq -0x8(%rsp), %rax
movq -0x20(%rsp), %rcx
movb %dl, (%rax,%rcx)
jmp 0x113724
movq -0x28(%rsp), %rax
movzbl (%rax), %eax
shll $0x6, %eax
movq -0x28(%rsp), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x4, %ecx
orl %ecx, %eax
movb %al, %dl
movq -0x8(%rsp), %rax
movq -0x20(%rsp), %rcx
movb %dl, (%rax,%rcx)
jmp 0x113724
movq -0x28(%rsp), %rax
movzbl (%rax), %eax
shll $0x6, %eax
movq -0x28(%rsp), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x4, %ecx
orl %ecx, %eax
movq -0x28(%rsp), %rcx
movzbl 0x2(%rcx), %ecx
shll $0x2, %ecx
orl %ecx, %eax
movb %al, %dl
movq -0x8(%rsp), %rax
movq -0x20(%rsp), %rcx
movb %dl, (%rax,%rcx)
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x1144ed
movq 0x9fb1c(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x49ba0(%rip), %rsi     # 0x15e066
leaq 0x718c7(%rip), %rdx     # 0x185d94
leaq 0x74794(%rip), %rcx     # 0x188c68
leaq 0x71183(%rip), %r8      # 0x18565e
movl $0xa59, %r9d            # imm = 0xA59
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x1144ef
jmp 0x1144f1
movq 0x8(%rsp), %rax
testb $0x1, 0x1e8(%rax)
jne 0x114537
movq 0x9fad2(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x49b56(%rip), %rsi     # 0x15e066
leaq 0x72879(%rip), %rdx     # 0x186d90
leaq 0x7474a(%rip), %rcx     # 0x188c68
leaq 0x71139(%rip), %r8      # 0x18565e
movl $0xa5a, %r9d            # imm = 0xA5A
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x114539
jmp 0x11453b
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq 0x30(%rcx), %rax
jbe 0x114582
movq 0x9fa87(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x49b0b(%rip), %rsi     # 0x15e066
leaq 0x71878(%rip), %rdx     # 0x185dda
leaq 0x746ff(%rip), %rcx     # 0x188c68
leaq 0x710ee(%rip), %r8      # 0x18565e
movl $0xa5b, %r9d            # imm = 0xA5B
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x114584
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq 0x1f0(%rcx), %rax
jb 0x1145c1
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
subq 0x1f0(%rcx), %rax
movq 0x8(%rsp), %rcx
movq 0x1f0(%rcx), %rcx
addq $0x1, %rcx
xorl %edx, %edx
divq %rcx
cmpq $0x0, %rdx
jbe 0x1145c8
movb $0x0, 0x17(%rsp)
jmp 0x1145cd
movb $0x1, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq 0x2a0(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x114930
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl 0x2a8(%rcx), %eax
jae 0x114623
movl 0xc(%rsp), %eax
movb %al, 0x27(%rsp)
jmp 0x114680
movl 0xc(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl 0x2a8(%rcx), %eax
jne 0x11463b
movb $-0x2, 0x27(%rsp)
jmp 0x114680
movl 0xc(%rsp), %eax
movq 0x18(%rsp), %rcx
movl 0x2a8(%rcx), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jne 0x114658
movb $-0x1, 0x27(%rsp)
jmp 0x114680
movq 0x9f979(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
movl 0xc(%rsp), %eax
movl %eax, %edx
leaq 0x745c8(%rip), %rsi     # 0x188c37
movb $0x0, %al
callq 0xb890
movl $0x2, %edi
callq 0xb780
movb 0x27(%rsp), %al
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/bitpackarray.h
// Function: bitpackarray_get_uint32
static inline uint32_t
bitpackarray_get_uint32(const BitPackArray *array, BitOffset index)
{
  gt_assert(array && index < array->numElems
            && array->bitsPerElem <= sizeof (uint32_t)*CHAR_BIT);
  return gt_bsGetUInt32(array->store, array->bitsPerElem * index,
                        array->bitsPerElem);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x114964
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x114964
movq 0x10(%rsp), %rax
movl 0x10(%rax), %eax
cmpq $0x20, %rax
jbe 0x11499c
movq 0x9f66d(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x496f1(%rip), %rsi     # 0x15e066
leaq 0x74011(%rip), %rdx     # 0x18898d
leaq 0x7405f(%rip), %rcx     # 0x1889e2
leaq 0x74070(%rip), %r8      # 0x1889fa
movl $0x7e, %r9d
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x11499e
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rax
movl 0x10(%rax), %eax
movl %eax, %esi
imulq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rax
movl 0x10(%rax), %edx
callq 0x156b90
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x114d1a
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x38(%rcx), %rax
jb 0x114d52
movq 0x9f2b7(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x4933b(%rip), %rsi     # 0x15e066
leaq 0x70984(%rip), %rdx     # 0x1856b6
leaq 0x70ad6(%rip), %rcx     # 0x18580f
leaq 0x7091e(%rip), %r8      # 0x18565e
movl $0x1a7, %r9d            # imm = 0x1A7
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x114d54
cmpl $0x1, 0xc(%rsp)
je 0x114d62
cmpl $0x3, 0xc(%rsp)
jne 0x114d79
movq 0x18(%rsp), %rax
movq 0x38(%rax), %rax
subq $0x1, %rax
subq 0x10(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
testb $0x1, 0x3a8(%rax)
je 0x114deb
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x30(%rcx), %rax
jbe 0x114dcd
movl $0x3, %eax
subl 0xc(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rax
movq 0x30(%rax), %rax
subq $0x1, %rax
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rdx
subq 0x30(%rdx), %rcx
subq $0x1, %rcx
subq %rcx, %rax
movq %rax, 0x10(%rsp)
jmp 0x114de9
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x30(%rcx), %rax
jne 0x114de7
movb $0x1, 0x27(%rsp)
jmp 0x114e67
jmp 0x114de9
jmp 0x114deb
movq 0x18(%rsp), %rax
cmpq $0x1, 0x40(%rax)
jne 0x114dfe
movb $0x0, 0x27(%rsp)
jmp 0x114e67
jmp 0x114e00
movq 0x18(%rsp), %rax
cmpq $0x0, 0x140(%rax)
jne 0x114e47
movq 0x9f1c2(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x49246(%rip), %rsi     # 0x15e066
leaq 0x70a07(%rip), %rdx     # 0x18582e
leaq 0x709e1(%rip), %rcx     # 0x18580f
leaq 0x70829(%rip), %r8      # 0x18565e
movl $0x1b9, %r9d            # imm = 0x1B9
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x114e49
movq 0x18(%rsp), %rax
movq 0x140(%rax), %rax
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq *%rax
andb $0x1, %al
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x114eaa
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x38(%rcx), %rax
jb 0x114ee2
movq 0x9f127(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x491ab(%rip), %rsi     # 0x15e066
leaq 0x707f4(%rip), %rdx     # 0x1856b6
leaq 0x70995(%rip), %rcx     # 0x18585e
leaq 0x7078e(%rip), %r8      # 0x18565e
movl $0x1c1, %r9d            # imm = 0x1C1
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x114ee4
cmpl $0x1, 0xc(%rsp)
je 0x114ef2
cmpl $0x3, 0xc(%rsp)
jne 0x114f09
movq 0x18(%rsp), %rax
movq 0x38(%rax), %rax
subq $0x1, %rax
subq 0x10(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
testb $0x1, 0x3a8(%rax)
je 0x114f7b
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x30(%rcx), %rax
jbe 0x114f5d
movl $0x3, %eax
subl 0xc(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rax
movq 0x30(%rax), %rax
subq $0x1, %rax
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rdx
subq 0x30(%rdx), %rcx
subq $0x1, %rcx
subq %rcx, %rax
movq %rax, 0x10(%rsp)
jmp 0x114f79
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x30(%rcx), %rax
jne 0x114f77
movb $0x1, 0x27(%rsp)
jmp 0x114ff7
jmp 0x114f79
jmp 0x114f7b
movq 0x18(%rsp), %rax
cmpq $0x1, 0x40(%rax)
jne 0x114f8e
movb $0x0, 0x27(%rsp)
jmp 0x114ff7
jmp 0x114f90
movq 0x18(%rsp), %rax
cmpq $0x0, 0x160(%rax)
jne 0x114fd7
movq 0x9f032(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x490b6(%rip), %rsi     # 0x15e066
leaq 0x708c7(%rip), %rdx     # 0x18587e
leaq 0x708a0(%rip), %rcx     # 0x18585e
leaq 0x70699(%rip), %r8      # 0x18565e
movl $0x1d3, %r9d            # imm = 0x1D3
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x114fd9
movq 0x18(%rsp), %rax
movq 0x160(%rax), %rax
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq *%rax
andb $0x1, %al
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: binpreparenextrangeGtEncseqReader
static void binpreparenextrangeGtEncseqReader(GtEncseqReader *esr,
                                              KindofSWtable kindsw)
{
  GtEncseqAccessType sat = (kindsw == SWtable_ssptab) ? esr->encseq->satsep
                                                         : esr->encseq->sat;
  switch (sat) {
    case GT_ACCESS_TYPE_UCHARTABLES:
      binpreparenextrangeGtEncseqReader_uchar(esr, kindsw);
      break;
    case GT_ACCESS_TYPE_USHORTTABLES:
      binpreparenextrangeGtEncseqReader_uint16(esr, kindsw);
      break;
    case GT_ACCESS_TYPE_UINT32TABLES:
      binpreparenextrangeGtEncseqReader_uint32(esr, kindsw);
      break;
    default: fprintf(stderr, "binpreparenextrangeGtEncseqReader(sat = %s "
                            "is undefined)\n",
                     gt_encseq_access_type_str(sat));
             exit(GT_EXIT_PROGRAMMING_ERROR);
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
cmpl $0x1, 0x1c(%rsp)
jne 0x115475
movq 0x20(%rsp), %rax
movq (%rax), %rax
movl 0x4(%rax), %eax
movl %eax, 0x14(%rsp)
jmp 0x115483
movq 0x20(%rsp), %rax
movq (%rax), %rax
movl (%rax), %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl %eax, 0x18(%rsp)
movl 0x18(%rsp), %eax
movl %eax, 0x10(%rsp)
subl $0x4, %eax
je 0x1154b0
jmp 0x11549a
movl 0x10(%rsp), %eax
subl $0x5, %eax
je 0x1154c0
jmp 0x1154a5
movl 0x10(%rsp), %eax
subl $0x6, %eax
je 0x1154d0
jmp 0x1154e0
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x12eeb0
jmp 0x115518
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x12f3e0
jmp 0x115518
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x12f910
jmp 0x115518
movq 0x9eaf1(%rip), %rax     # 0x1b3fd8
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movl 0x18(%rsp), %edi
callq 0x13e7e0
movq 0x8(%rsp), %rdi
movq %rax, %rdx
leaq 0x73994(%rip), %rsi     # 0x188e9b
movb $0x0, %al
callq 0xb890
movl $0x2, %edi
callq 0xb780
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: advancerangeGtEncseqReader
static void advancerangeGtEncseqReader(GtEncseqReader *esr,
                                       KindofSWtable kindsw)
{
  GtEncseqAccessType sat = (kindsw == SWtable_ssptab) ? esr->encseq->satsep
                                                         : esr->encseq->sat;
  switch (sat) {
    case GT_ACCESS_TYPE_UCHARTABLES:
      advancerangeGtEncseqReader_uchar(esr, kindsw);
      break;
    case GT_ACCESS_TYPE_USHORTTABLES:
      advancerangeGtEncseqReader_uint16(esr, kindsw);
      break;
    case GT_ACCESS_TYPE_UINT32TABLES:
      advancerangeGtEncseqReader_uint32(esr, kindsw);
      break;
    default:
      fprintf(stderr, "advancerangeGtEncseqReader(sat = %s is undefined)\n",
              gt_encseq_access_type_str(sat));
      exit(GT_EXIT_PROGRAMMING_ERROR);
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
cmpl $0x1, 0x1c(%rsp)
jne 0x115545
movq 0x20(%rsp), %rax
movq (%rax), %rax
movl 0x4(%rax), %eax
movl %eax, 0x14(%rsp)
jmp 0x115553
movq 0x20(%rsp), %rax
movq (%rax), %rax
movl (%rax), %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl %eax, 0x18(%rsp)
movl 0x18(%rsp), %eax
movl %eax, 0x10(%rsp)
subl $0x4, %eax
je 0x115580
jmp 0x11556a
movl 0x10(%rsp), %eax
subl $0x5, %eax
je 0x115590
jmp 0x115575
movl 0x10(%rsp), %eax
subl $0x6, %eax
je 0x1155a0
jmp 0x1155b0
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x12de30
jmp 0x1155e8
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x12e1a0
jmp 0x1155e8
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x12e510
jmp 0x1155e8
movq 0x9ea21(%rip), %rax     # 0x1b3fd8
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movl 0x18(%rsp), %edi
callq 0x13e7e0
movq 0x8(%rsp), %rdi
movq %rax, %rdx
leaq 0x7370d(%rip), %rsi     # 0x188ce4
movb $0x0, %al
callq 0xb890
movl $0x2, %edi
callq 0xb780
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
cmpl $0x1, 0x8(%rax)
je 0x11562c
movq (%rsp), %rax
cmpl $0x3, 0x8(%rax)
je 0x11562c
movq (%rsp), %rax
movq (%rax), %rax
movq 0x1f0(%rax), %rcx
addq $0x1, %rcx
movq (%rsp), %rax
addq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
jmp 0x1156da
movq (%rsp), %rax
movq 0x18(%rax), %rax
movq (%rsp), %rcx
movq (%rcx), %rcx
cmpq 0x1f0(%rcx), %rax
jbe 0x115667
movq (%rsp), %rax
movq (%rax), %rax
movq 0x1f0(%rax), %rdx
addq $0x1, %rdx
movq (%rsp), %rax
movq 0x18(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x18(%rax)
jmp 0x1156d8
movq (%rsp), %rax
movq 0x18(%rax), %rax
movq (%rsp), %rcx
movq (%rcx), %rcx
cmpq 0x1f0(%rcx), %rax
jne 0x11568d
movq (%rsp), %rax
movq $0x0, 0x18(%rax)
jmp 0x1156d6
jmp 0x11568f
movq (%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x1156d2
movq 0x9e937(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x489bb(%rip), %rsi     # 0x15e066
leaq 0x735e3(%rip), %rdx     # 0x188c95
leaq 0x735f7(%rip), %rcx     # 0x188cb0
leaq 0x6ff9e(%rip), %r8      # 0x18565e
movl $0xa71, %r9d            # imm = 0xA71
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x1156d4
jmp 0x1156d6
jmp 0x1156d8
jmp 0x1156da
popq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_indexname
const char* gt_encseq_indexname(const GtEncseq *encseq)
{
  gt_assert(encseq);
  if (encseq->indexname != NULL)
    return encseq->indexname;
  else
    return "generated";
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x115d39
movq 0x9e2d0(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x48354(%rip), %rsi     # 0x15e066
leaq 0x65fbd(%rip), %rdx     # 0x17bcd6
leaq 0x6fd55(%rip), %rcx     # 0x185a75
leaq 0x6f937(%rip), %r8      # 0x18565e
movl $0x2a9, %r9d            # imm = 0x2A9
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x115d3b
movq 0x8(%rsp), %rax
cmpq $0x0, 0x68(%rax)
je 0x115d57
movq 0x8(%rsp), %rax
movq 0x68(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x115d63
leaq 0x762ea(%rip), %rax     # 0x18c048
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq %r8, 0x8(%rsp)
cmpq $0x1, 0x8(%rsp)
jb 0x115db1
cmpq $0x0, 0x28(%rsp)
je 0x115db1
movq 0x10(%rsp), %rax
addq 0x8(%rsp), %rax
movq 0x28(%rsp), %rcx
cmpq 0x38(%rcx), %rax
jbe 0x115de9
movq 0x9e220(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x482a4(%rip), %rsi     # 0x15e066
leaq 0x6fcc0(%rip), %rdx     # 0x185a89
leaq 0x6fd06(%rip), %rcx     # 0x185ad6
leaq 0x6f887(%rip), %r8      # 0x18565e
movl $0x2b9, %r9d            # imm = 0x2B9
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x115deb
movq 0x28(%rsp), %rax
testb $0x1, 0x3a8(%rax)
je 0x115e5a
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rcx
cmpq 0x30(%rcx), %rax
jbe 0x115e3f
movl $0x3, %eax
subl 0x24(%rsp), %eax
movl %eax, 0x24(%rsp)
movq 0x28(%rsp), %rax
movq 0x30(%rax), %rax
subq $0x1, %rax
movq 0x10(%rsp), %rcx
movq 0x28(%rsp), %rdx
subq 0x30(%rdx), %rcx
subq $0x1, %rcx
subq %rcx, %rax
movq %rax, 0x10(%rsp)
jmp 0x115e58
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rcx
cmpq 0x30(%rcx), %rax
jne 0x115e56
movb $0x1, 0x37(%rsp)
jmp 0x115e86
jmp 0x115e58
jmp 0x115e5a
movq 0x28(%rsp), %rax
movq 0x120(%rax), %rax
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %r8
callq *%rax
andb $0x1, %al
movb %al, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
ja 0x115ee9
cmpq $0x0, 0x28(%rsp)
je 0x115ee9
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rcx
cmpq 0x38(%rcx), %rax
jae 0x115ee9
cmpq $0x0, 0x20(%rsp)
jne 0x115f21
movq 0x9e0e8(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x4816c(%rip), %rsi     # 0x15e066
leaq 0x6fbf0(%rip), %rdx     # 0x185af1
leaq 0x6fc44(%rip), %rcx     # 0x185b4c
leaq 0x6f74f(%rip), %r8      # 0x18565e
movl $0x2d9, %r9d            # imm = 0x2D9
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x115f23
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x18(%rsp), %rcx
xorl %edx, %edx
callq 0x115f90
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq $0x0, 0x8(%rsp)
movq (%rsp), %rax
cmpq 0x10(%rsp), %rax
ja 0x115f8b
movq 0x30(%rsp), %rdi
callq 0x115010
movb %al, %dl
movq 0x20(%rsp), %rax
movq 0x8(%rsp), %rcx
movb %dl, (%rax,%rcx)
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x115f4b
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x18(%rsp), %rax
ja 0x1164a4
cmpq $0x0, 0x30(%rsp)
je 0x1164a4
movq 0x18(%rsp), %rax
movq 0x30(%rsp), %rcx
cmpq 0x38(%rcx), %rax
jae 0x1164a4
cmpq $0x0, 0x28(%rsp)
jne 0x1164dc
movq 0x9db2d(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x47bb1(%rip), %rsi     # 0x15e066
leaq 0x6f635(%rip), %rdx     # 0x185af1
leaq 0x6f6af(%rip), %rcx     # 0x185b72
leaq 0x6f194(%rip), %r8      # 0x18565e
movl $0x2ea, %r9d            # imm = 0x2EA
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x1164de
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rdx
xorl %esi, %esi
callq 0x116560
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq $0x0, 0x8(%rsp)
movq (%rsp), %rax
cmpq 0x18(%rsp), %rax
ja 0x116546
movq 0x10(%rsp), %rdi
callq 0x115010
movb %al, %dl
movq 0x28(%rsp), %rax
movq 0x8(%rsp), %rcx
movb %dl, (%rax,%rcx)
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x116506
movq 0x10(%rsp), %rdi
callq 0x1165d0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movl $0x1, %edi
movl $0x38, %esi
leaq 0x6f0db(%rip), %rdx     # 0x18565e
movl $0xc5e, %ecx            # imm = 0xC5E
callq 0xd5b0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq $0x0, 0x30(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x28(%rax)
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl 0x1c(%rsp), %edx
movq 0x10(%rsp), %rcx
callq 0x115f90
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x1165de
jmp 0x116651
movq (%rsp), %rax
cmpq $0x0, (%rax)
je 0x1165f4
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x118250
movq (%rsp), %rax
cmpq $0x0, 0x28(%rax)
je 0x116618
movq (%rsp), %rax
movq 0x28(%rax), %rdi
leaq 0x6f050(%rip), %rsi     # 0x18565e
movl $0xc6c, %edx            # imm = 0xC6C
callq 0xdab0
movq (%rsp), %rax
cmpq $0x0, 0x30(%rax)
je 0x11663c
movq (%rsp), %rax
movq 0x30(%rax), %rdi
leaq 0x6f02c(%rip), %rsi     # 0x18565e
movl $0xc6e, %edx            # imm = 0xC6E
callq 0xdab0
movq (%rsp), %rdi
leaq 0x6f017(%rip), %rsi     # 0x18565e
movl $0xc6f, %edx            # imm = 0xC6F
callq 0xdab0
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
ja 0x1166a9
cmpq $0x0, 0x28(%rsp)
je 0x1166a9
movq 0x10(%rsp), %rax
movq 0x28(%rsp), %rcx
cmpq 0x38(%rcx), %rax
jae 0x1166a9
cmpq $0x0, 0x20(%rsp)
jne 0x1166e1
movq 0x9d928(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x479ac(%rip), %rsi     # 0x15e066
leaq 0x6f430(%rip), %rdx     # 0x185af1
leaq 0x6f4c4(%rip), %rcx     # 0x185b8c
leaq 0x6ef8f(%rip), %r8      # 0x18565e
movl $0x2fd, %r9d            # imm = 0x2FD
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x1166e3
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x18(%rsp), %rcx
xorl %edx, %edx
callq 0x115f90
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq $0x0, 0x8(%rsp)
movq (%rsp), %rax
cmpq 0x10(%rsp), %rax
ja 0x11674b
movq 0x30(%rsp), %rdi
callq 0x1156e0
movb %al, %dl
movq 0x20(%rsp), %rax
movq 0x8(%rsp), %rcx
movb %dl, (%rax,%rcx)
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x11670b
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x18(%rsp), %rax
ja 0x116794
cmpq $0x0, 0x30(%rsp)
je 0x116794
movq 0x18(%rsp), %rax
movq 0x30(%rsp), %rcx
cmpq 0x38(%rcx), %rax
jae 0x116794
cmpq $0x0, 0x28(%rsp)
jne 0x1167cc
movq 0x9d83d(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x478c1(%rip), %rsi     # 0x15e066
leaq 0x6f345(%rip), %rdx     # 0x185af1
leaq 0x6f3ff(%rip), %rcx     # 0x185bb2
leaq 0x6eea4(%rip), %r8      # 0x18565e
movl $0x30e, %r9d            # imm = 0x30E
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x1167ce
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rdx
xorl %esi, %esi
callq 0x116560
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq $0x0, 0x8(%rsp)
movq (%rsp), %rax
cmpq 0x18(%rsp), %rax
ja 0x116836
movq 0x10(%rsp), %rdi
callq 0x1156e0
movb %al, %dl
movq 0x28(%rsp), %rax
movq 0x8(%rsp), %rcx
movb %dl, (%rax,%rcx)
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x1167f6
movq 0x10(%rsp), %rdi
callq 0x1165d0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x1168f9
movq 0x9d710(%rip), %rax     # 0x1b3fd8
movq (%rax), %rdi
leaq 0x47794(%rip), %rsi     # 0x15e066
leaq 0x6f4bb(%rip), %rdx     # 0x185d94
leaq 0x6f301(%rip), %rcx     # 0x185be1
leaq 0x6ed77(%rip), %r8      # 0x18565e
movl $0x333, %r9d            # imm = 0x333
movb $0x0, %al
callq 0xb890
callq 0xb2e0
jmp 0x1168fb
movq 0x10(%rsp), %rcx
movb $0x1, %al
testb $0x1, 0x3a9(%rcx)
movb %al, 0xf(%rsp)
jne 0x11692e
movq 0x10(%rsp), %rcx
movb $0x1, %al
cmpl $0x2, (%rcx)
movb %al, 0xf(%rsp)
jae 0x11692e
movq 0x10(%rsp), %rax
cmpl $0x3, (%rax)
sete %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %dl
xorl %eax, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq $0x0, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x1b720
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x117bd1
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x1b3c0
movq %rax, %rdi
callq 0x19a00
addq $0x1, %rax
addq 0x10(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x117b7b
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/intbits.h
// Function: gt_unitsoftwobitencoding
static inline GtUword gt_unitsoftwobitencoding(GtUword
                                                            totallength)
{
  uint64_t unitsoftwobitencoding;

  if (totallength < (GtUword) GT_UNITSIN2BITENC) {
    return 2UL;
  }
  unitsoftwobitencoding = (uint64_t) (2 +
                          GT_DIVBYUNITSIN2BITENC(totallength - 1));
  return CALLCASTFUNC(uint64_t,unsigned_long,unitsoftwobitencoding);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
cmpq $0x20, 0x8(%rsp)
jae 0x117bfc
movq $0x2, 0x10(%rsp)
jmp 0x117c2b
movq 0x8(%rsp), %rax
subq $0x1, %rax
shrq $0x5, %rax
addq $0x2, %rax
movq %rax, (%rsp)
movq (%rsp), %rdx
leaq 0x70e36(%rip), %rdi     # 0x188a52
movl $0xcc, %esi
callq 0x12d160
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)