LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 $0x18, %rsp
testq %rdi, %rdi
je 0xa1455
movq %rdi, %rax
movq (%rdi), %rdi
testq %rdi, %rdi
je 0xa1450
movq %rsp, %rdx
andq $0x0, (%rdx)
movq 0x8(%rax), %rax
movq %rax, 0x8(%rdx)
movq %rsi, 0x10(%rdx)
leaq 0x97(%rip), %rsi        # 0xa14de
callq 0xa14b5
testl %eax, %eax
jne 0xa147f
addq $0x18, %rsp
retq
movq 0x8cb5c(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x28c00(%rip), %rsi     # 0xca066
leaq 0x4c7e6(%rip), %rdx     # 0xedc53
leaq 0x4a32f(%rip), %rcx     # 0xeb7a3
leaq 0x4a2e5(%rip), %r8      # 0xeb760
pushq $0x6d
jmp 0xa14a7
movq 0x8cb32(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x28bd6(%rip), %rsi     # 0xca066
leaq 0x29650(%rip), %rdx     # 0xcaae7
leaq 0x4a305(%rip), %rcx     # 0xeb7a3
leaq 0x4a2bb(%rip), %r8      # 0xeb760
pushq $0x75
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0xa1501
movq %rcx, %rdi
callq 0xc103
testb %al, %al
jne 0xa15aa
testq %rbx, %rbx
je 0xa1580
testq %r15, %r15
je 0xa1580
movq %rbx, %xmm1
movq 0x28f68(%rip), %xmm2    # 0xca480
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x28f6c(%rip), %xmm3    # 0xca490
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 0x4a30f(%rip), %rsi     # 0xeb87a
movq %r14, %rdx
movq %rbx, %rcx
movb $0x2, %al
callq 0x542da
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0x8ca31(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x28ad5(%rip), %rsi     # 0xca066
leaq 0x4a2ce(%rip), %rdx     # 0xeb866
leaq 0x4a2bd(%rip), %rcx     # 0xeb85c
leaq 0x4a1ba(%rip), %r8      # 0xeb760
pushq $0x5e
jmp 0xa15d2
movq 0x8ca07(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x28aab(%rip), %rsi     # 0xca066
leaq 0x29097(%rip), %rdx     # 0xca659
leaq 0x4a293(%rip), %rcx     # 0xeb85c
leaq 0x4a190(%rip), %r8      # 0xeb760
pushq $0x5d
popq %r9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0xa164d
movq (%rdi), %rdi
testq %rdi, %rdi
je 0xa1648
movq %rsi, (%rsp)
movq %rdx, 0x8(%rsp)
testq %rcx, %rcx
je 0xa1635
movq %rsp, %rax
leaq 0x10(%rsp), %rdx
movq %rax, (%rdx)
leaq 0x3f2(%rip), %rax       # 0xa1a07
movq %rax, 0x8(%rdx)
movq %rcx, 0x10(%rdx)
leaq 0x3cc(%rip), %rsi       # 0xa19f0
leaq 0x47a(%rip), %rcx       # 0xa1aa5
xorl %r8d, %r8d
callq 0x56bfb
jmp 0xa1644
leaq 0x3cb(%rip), %rsi       # 0xa1a07
movq %rsp, %rdx
callq 0xa14b5
testl %eax, %eax
jne 0xa167b
addq $0x28, %rsp
retq
movq 0x8c964(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x28a08(%rip), %rsi     # 0xca066
leaq 0x4c5ee(%rip), %rdx     # 0xedc53
leaq 0x4a235(%rip), %rcx     # 0xeb8a1
leaq 0x4a0ed(%rip), %r8      # 0xeb760
movl $0x92, %r9d
jmp 0xa16a7
movq 0x8c936(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x289da(%rip), %rsi     # 0xca066
leaq 0x29454(%rip), %rdx     # 0xcaae7
leaq 0x4a207(%rip), %rcx     # 0xeb8a1
leaq 0x4a0bf(%rip), %r8      # 0xeb760
movl $0x9e, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0xa19c0
cmpl $0x2, %edx
jge 0xa1970
movslq 0x8(%rbx,%rdx,4), %rcx
cmpq %rax, %rcx
jne 0xa1994
movslq 0x14(%rbx,%rdx,4), %rax
xorl %ecx, %ecx
cmpq %rsi, %rax
je 0xa19c0
leaq 0x2a806(%rip), %rsi     # 0xcc159
leaq 0x49fee(%rip), %rdx     # 0xeb948
leaq 0x49fa9(%rip), %rcx     # 0xeb90a
leaq 0x49df8(%rip), %r8      # 0xeb760
movl $0xcb, %r9d
jmp 0xa19b6
leaq 0x2a7e2(%rip), %rsi     # 0xcc159
leaq 0x49f5f(%rip), %rdx     # 0xeb8dd
leaq 0x49f85(%rip), %rcx     # 0xeb90a
leaq 0x49dd4(%rip), %r8      # 0xeb760
movl $0xc9, %r9d
jmp 0xa19b6
leaq 0x2a7be(%rip), %rsi     # 0xcc159
leaq 0x49f76(%rip), %rdx     # 0xeb918
leaq 0x49f61(%rip), %rcx     # 0xeb90a
leaq 0x49db0(%rip), %r8      # 0xeb760
movl $0xca, %r9d
xorl %eax, %eax
callq 0xc007
pushq $-0x1
popq %rcx
movq 0x20(%rbx), %rax
movl %ecx, (%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xa1a26
movq %rcx, %rdi
callq 0xc103
testb %al, %al
jne 0xa1a6d
testq %rbx, %rbx
je 0xa1a3f
movq 0x8(%rbx), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq *(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0x8c572(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x28616(%rip), %rsi     # 0xca066
leaq 0x28cec(%rip), %rdx     # 0xca743
leaq 0x49e62(%rip), %rcx     # 0xeb8c0
leaq 0x49cfb(%rip), %r8      # 0xeb760
movl $0x84, %r9d
jmp 0xa1a99
movq 0x8c544(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x285e8(%rip), %rsi     # 0xca066
leaq 0x28bd4(%rip), %rdx     # 0xca659
leaq 0x49e34(%rip), %rcx     # 0xeb8c0
leaq 0x49ccd(%rip), %r8      # 0xeb760
movl $0x83, %r9d
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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), %rax
addq $-0x3, %rax
cmpq %rax, %rsi
jae 0xa1aec
movb (%rsi), %cl
movb 0x1(%rsi), %r8b
shlb $0x6, %cl
shlb $0x4, %r8b
orb %cl, %r8b
movb 0x2(%rsi), %cl
shlb $0x2, %cl
orb %r8b, %cl
orb 0x3(%rsi), %cl
movb %cl, (%rdi)
addq $0x4, %rsi
incq %rdi
jmp 0xa1ac0
andl $0x3, %edx
leaq 0x49e8a(%rip), %rax     # 0xeb980
movslq (%rax,%rdx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movb (%rsi), %al
shlb $0x6, %al
jmp 0xa1b28
movb (%rsi), %cl
movb 0x1(%rsi), %al
shlb $0x6, %cl
shlb $0x4, %al
jmp 0xa1b26
movb (%rsi), %al
movb 0x1(%rsi), %cl
shlb $0x6, %al
shlb $0x4, %cl
orb %al, %cl
movb 0x2(%rsi), %al
shlb $0x2, %al
orb %cl, %al
movb %al, (%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xa22c4
cmpb $0x0, 0x1e8(%rdi)
je 0xa22f2
cmpq %rsi, 0x30(%rdi)
jb 0xa2320
movq 0x1f0(%rdi), %rcx
subq %rcx, %rsi
jae 0xa22b1
xorl %eax, %eax
jmp 0xa22c2
incq %rcx
movq %rsi, %rax
xorl %edx, %edx
divq %rcx
testq %rdx, %rdx
sete %al
popq %rcx
retq
movq 0x8bced(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x27d91(%rip), %rsi     # 0xca066
leaq 0x49ff4(%rip), %rdx     # 0xec2d0
leaq 0x4ce30(%rip), %rcx     # 0xef113
leaq 0x498b0(%rip), %r8      # 0xebb9a
movl $0xa59, %r9d            # imm = 0xA59
jmp 0xa234c
movq 0x8bcbf(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x27d63(%rip), %rsi     # 0xca066
leaq 0x4af84(%rip), %rdx     # 0xed28e
leaq 0x4ce02(%rip), %rcx     # 0xef113
leaq 0x49882(%rip), %r8      # 0xebb9a
movl $0xa5a, %r9d            # imm = 0xA5A
jmp 0xa234c
movq 0x8bc91(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x27d35(%rip), %rsi     # 0xca066
leaq 0x49fd2(%rip), %rdx     # 0xec30a
leaq 0x4cdd4(%rip), %rcx     # 0xef113
leaq 0x49854(%rip), %r8      # 0xebb9a
movl $0xa5b, %r9d            # imm = 0xA5B
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 %rdi, %rbx
movq 0x2a0(%rdi), %rdi
callq 0xa258b
movl 0x2a8(%rbx), %edx
cmpl %edx, %eax
jae 0xa2376
movl %eax, %ecx
jmp 0xa2382
movb $-0x2, %cl
je 0xa2382
incl %edx
movb $-0x1, %cl
cmpl %edx, %eax
jne 0xa2386
movl %ecx, %eax
popq %rbx
retq
movq 0x8bc2b(%rip), %rcx     # 0x12dfb8
movq (%rcx), %rdi
movl %eax, %edx
leaq 0x4cd49(%rip), %rsi     # 0xef0e2
xorl %eax, %eax
callq 0xb8c0
pushq $0x2
popq %rdi
callq 0xb7b0
// File: /workspace/github_c_makefile_star2_O2/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 0xa2815
movq %rsi, %rax
movq 0x38(%rdi), %rsi
cmpq %rax, %rsi
jbe 0xa2815
andl $-0x3, %edx
movq %rax, %rcx
notq %rcx
addq %rcx, %rsi
cmpl $0x1, %edx
cmovneq %rax, %rsi
cmpb $0x1, 0x3a8(%rdi)
jne 0xa27fb
movq 0x30(%rdi), %rax
cmpq %rax, %rsi
jbe 0xa27f7
addq %rax, %rax
subq %rsi, %rax
movq %rax, %rsi
jmp 0xa27fb
movb $0x1, %al
je 0xa2804
cmpq $0x1, 0x40(%rdi)
jne 0xa2806
xorl %eax, %eax
popq %rcx
retq
movq 0x140(%rdi), %rax
testq %rax, %rax
je 0xa284d
popq %rcx
jmpq *%rax
movq 0x8b79c(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x27840(%rip), %rsi     # 0xca066
leaq 0x493c5(%rip), %rdx     # 0xebbf2
leaq 0x49517(%rip), %rcx     # 0xebd4b
leaq 0x4935f(%rip), %r8      # 0xebb9a
movl $0x1a7, %r9d            # imm = 0x1A7
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
movq 0x8b764(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x27808(%rip), %rsi     # 0xca066
leaq 0x49505(%rip), %rdx     # 0xebd6a
leaq 0x494df(%rip), %rcx     # 0xebd4b
leaq 0x49327(%rip), %r8      # 0xebb9a
movl $0x1b9, %r9d            # imm = 0x1B9
jmp 0xa2841
// File: /workspace/github_c_makefile_star2_O2/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 0xa28db
movq %rsi, %rax
movq 0x38(%rdi), %rsi
cmpq %rax, %rsi
jbe 0xa28db
andl $-0x3, %edx
movq %rax, %rcx
notq %rcx
addq %rcx, %rsi
cmpl $0x1, %edx
cmovneq %rax, %rsi
cmpb $0x1, 0x3a8(%rdi)
jne 0xa28c1
movq 0x30(%rdi), %rax
cmpq %rax, %rsi
jbe 0xa28bd
addq %rax, %rax
subq %rsi, %rax
movq %rax, %rsi
jmp 0xa28c1
movb $0x1, %al
je 0xa28ca
cmpq $0x1, 0x40(%rdi)
jne 0xa28cc
xorl %eax, %eax
popq %rcx
retq
movq 0x160(%rdi), %rax
testq %rax, %rax
je 0xa2913
popq %rcx
jmpq *%rax
movq 0x8b6d6(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2777a(%rip), %rsi     # 0xca066
leaq 0x492ff(%rip), %rdx     # 0xebbf2
leaq 0x494a0(%rip), %rcx     # 0xebd9a
leaq 0x49299(%rip), %r8      # 0xebb9a
movl $0x1c1, %r9d            # imm = 0x1C1
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
movq 0x8b69e(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x27742(%rip), %rsi     # 0xca066
leaq 0x4948f(%rip), %rdx     # 0xebdba
leaq 0x49468(%rip), %rcx     # 0xebd9a
leaq 0x49261(%rip), %r8      # 0xebb9a
movl $0x1d3, %r9d            # imm = 0x1D3
jmp 0xa2907
// File: /workspace/github_c_makefile_star2_O2/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:
xorl %eax, %eax
cmpl $0x1, %esi
sete %al
movq (%rdi), %rcx
movl (%rcx,%rax,4), %eax
cmpl $0x6, %eax
je 0xb3f96
cmpl $0x5, %eax
je 0xb3da7
cmpl $0x4, %eax
jne 0xa3322
jmp 0xb3bb8
pushq %rbx
movq 0x8ac8e(%rip), %rcx     # 0x12dfb8
movq (%rcx), %rbx
movl %eax, %edi
callq 0xb948c
leaq 0x4be54(%rip), %rsi     # 0xef18f
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0xb8c0
pushq $0x2
popq %rdi
callq 0xb7b0
// File: /workspace/github_c_makefile_star2_O2/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 0xa3376
movq (%rdi), %rcx
movq 0x18(%rdi), %rax
movq 0x1f0(%rcx), %rcx
cmpq %rcx, %rax
jbe 0xa338f
notq %rcx
addq %rcx, %rax
jmp 0xa338a
movq (%rdi), %rax
movq 0x18(%rdi), %rcx
movq 0x1f0(%rax), %rax
addq %rcx, %rax
incq %rax
movq %rax, 0x18(%rdi)
retq
jne 0xa3397
andq $0x0, 0x18(%rdi)
retq
testq %rax, %rax
jne 0xa339d
retq
pushq %rax
movq 0x8ac13(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x26cb7(%rip), %rsi     # 0xca066
leaq 0x4bd8a(%rip), %rdx     # 0xef140
leaq 0x4bd9e(%rip), %rcx     # 0xef15b
leaq 0x487d6(%rip), %r8      # 0xebb9a
movl $0xa71, %r9d            # imm = 0xA71
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0xa385c
testq %r8, %r8
je 0xa385c
leaq (%r8,%rcx), %rax
cmpq 0x38(%rdi), %rax
ja 0xa385c
cmpb $0x1, 0x3a8(%rdi)
jne 0xa3853
movq 0x30(%rdi), %rax
cmpq %rcx, %rax
jae 0xa384e
pushq $0x3
popq %r9
subl %esi, %r9d
addq %rax, %rax
subq %rcx, %rax
movl %r9d, %esi
movq %rax, %rcx
jmp 0xa3853
jne 0xa3853
movb $0x1, %al
retq
movq 0x120(%rdi), %rax
jmpq *%rax
pushq %rax
movq 0x8a754(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x267f8(%rip), %rsi     # 0xca066
leaq 0x48750(%rip), %rdx     # 0xebfc5
leaq 0x48796(%rip), %rcx     # 0xec012
leaq 0x48317(%rip), %r8      # 0xebb9a
movl $0x2b9, %r9d            # imm = 0x2B9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0xa38ec
movq %r8, %rbx
movq %rcx, %r14
cmpq %r8, %rcx
ja 0xa38ec
movq %rdx, %r15
testq %rdx, %rdx
je 0xa38ec
cmpq %rbx, 0x38(%rsi)
jbe 0xa38ec
movq %rdi, %r12
xorl %edx, %edx
movq %r14, %rcx
callq 0xa3924
cmpq %rbx, %r14
ja 0xa38e0
movq %r12, %rdi
callq 0xa2941
movb %al, (%r15)
incq %r14
incq %r15
jmp 0xa38c8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x8a6c5(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x26769(%rip), %rsi     # 0xca066
leaq 0x48729(%rip), %rdx     # 0xec02d
leaq 0x4877d(%rip), %rcx     # 0xec088
leaq 0x48288(%rip), %r8      # 0xebb9a
movl $0x2d9, %r9d            # imm = 0x2D9
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xa3c14
movq %rcx, %rbx
movq %rdx, %r14
cmpq %rcx, %rdx
ja 0xa3c14
movq %rsi, %r15
testq %rsi, %rsi
je 0xa3c14
cmpq %rbx, 0x38(%rdi)
jbe 0xa3c14
xorl %esi, %esi
movq %r14, %rdx
callq 0xa3c4c
movq %rax, %r12
cmpq %rbx, %r14
ja 0xa3c01
movq %r12, %rdi
callq 0xa2941
movb %al, (%r15)
incq %r14
incq %r15
jmp 0xa3be9
movq %r12, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xa3c9a
movq 0x8a39d(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x26441(%rip), %rsi     # 0xca066
leaq 0x48401(%rip), %rdx     # 0xec02d
leaq 0x4847b(%rip), %rcx     # 0xec0ae
leaq 0x47f60(%rip), %r8      # 0xebb9a
movl $0x2ea, %r9d            # imm = 0x2EA
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0x47f38(%rip), %rdx     # 0xebb9a
pushq $0x1
popq %rdi
pushq $0x38
popq %rsi
movl $0xc5e, %ecx            # imm = 0xC5E
callq 0xce9a
movq %rax, %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rax)
movq %rax, %rdi
movq %r14, %rsi
movl %ebp, %edx
movq %rbx, %rcx
callq 0xa3924
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xa3cf9
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0xa3cb0
callq 0xa4fe9
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0xa3cca
leaq 0x47eda(%rip), %rsi     # 0xebb9a
movl $0xc6c, %edx            # imm = 0xC6C
callq 0xd249
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0xa3ce4
leaq 0x47ec0(%rip), %rsi     # 0xebb9a
movl $0xc6e, %edx            # imm = 0xC6E
callq 0xd249
leaq 0x47eaf(%rip), %rsi     # 0xebb9a
movq %rbx, %rdi
movl $0xc6f, %edx            # imm = 0xC6F
popq %rbx
jmp 0xd249
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xa3d51
movq %r8, %rbx
movq %rcx, %r14
cmpq %r8, %rcx
ja 0xa3d51
movq %rdx, %r15
testq %rdx, %rdx
je 0xa3d51
cmpq %rbx, 0x38(%rsi)
jbe 0xa3d51
movq %rdi, %r12
xorl %edx, %edx
movq %r14, %rcx
callq 0xa3924
cmpq %rbx, %r14
ja 0xa3d45
movq %r12, %rdi
callq 0xa33d6
movb %al, (%r15)
incq %r14
incq %r15
jmp 0xa3d2d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x8a260(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x26304(%rip), %rsi     # 0xca066
leaq 0x482c4(%rip), %rdx     # 0xec02d
leaq 0x48358(%rip), %rcx     # 0xec0c8
leaq 0x47e23(%rip), %r8      # 0xebb9a
movl $0x2fd, %r9d            # imm = 0x2FD
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xa3de7
movq %rcx, %rbx
movq %rdx, %r14
cmpq %rcx, %rdx
ja 0xa3de7
movq %rsi, %r15
testq %rsi, %rsi
je 0xa3de7
cmpq %rbx, 0x38(%rdi)
jbe 0xa3de7
xorl %esi, %esi
movq %r14, %rdx
callq 0xa3c4c
movq %rax, %r12
cmpq %rbx, %r14
ja 0xa3dd4
movq %r12, %rdi
callq 0xa33d6
movb %al, (%r15)
incq %r14
incq %r15
jmp 0xa3dbc
movq %r12, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xa3c9a
movq 0x8a1ca(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2626e(%rip), %rsi     # 0xca066
leaq 0x4822e(%rip), %rdx     # 0xec02d
leaq 0x482e8(%rip), %rcx     # 0xec0ee
leaq 0x47d8d(%rip), %r8      # 0xebb9a
movl $0x30e, %r9d            # imm = 0x30E
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0xa3e7b
movb $0x1, %al
cmpb $0x0, 0x3a9(%rdi)
jne 0xa3e7a
cmpl $0x2, (%rdi)
setae %al
retq
pushq %rax
movq 0x8a135(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x261d9(%rip), %rsi     # 0xca066
leaq 0x4843c(%rip), %rdx     # 0xec2d0
leaq 0x48282(%rip), %rcx     # 0xec11d
leaq 0x47cf8(%rip), %r8      # 0xebb9a
movl $0x333, %r9d            # imm = 0x333
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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
xorl %r14d, %r14d
xorl %r15d, %r15d
movq %rbx, %rdi
callq 0x157f4
cmpq %rax, %r14
jae 0xa48ad
movq %rbx, %rdi
movq %r14, %rsi
callq 0x155ca
movq %rax, %rdi
callq 0x14461
addq %rax, %r15
incq %r15
incq %r14
jmp 0xa4882
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xa497c
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r13
testb %r8b, %r8b
je 0xa4931
callq 0x13d5c
movq %rax, %r12
testq %r15, %r15
je 0xa48ed
movq $0x2, (%r15)
movq %r13, %rdi
movq %r12, %rsi
callq 0x9b6ea
testq %r14, %r14
je 0xa4910
movq %r12, %rdi
callq 0x143d2
movq %rax, %rdi
callq 0x4f8ae
movq %rax, (%r14)
testq %rbx, %rbx
je 0xa4920
movq %r12, %rdi
callq 0x14461
movq %rax, (%rbx)
movq %r12, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x152db
movq %r13, %rdi
callq 0x9bd27
testb %al, %al
je 0xa4948
testq %r15, %r15
je 0xa4960
andq $0x0, (%r15)
jmp 0xa4960
movq %r13, %rdi
callq 0x9bbe3
testb %al, %al
je 0xa48d9
testq %r15, %r15
je 0xa4960
movq $0x1, (%r15)
testq %r14, %r14
je 0xa4969
andq $0x0, (%r14)
testq %rbx, %rbx
je 0xa4972
andq $0x0, (%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x89635(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x256d9(%rip), %rsi     # 0xca066
leaq 0x41b98(%rip), %rdx     # 0xe652c
leaq 0x4a5b5(%rip), %rcx     # 0xeef50
leaq 0x471f8(%rip), %r8      # 0xebb9a
movl $0x43e, %r9d            # imm = 0x43E
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_equallength_write_twobitencoding_to_file
int gt_encseq_equallength_write_twobitencoding_to_file(const char *indexname,
                                     GtUword totallength,
                                     GtUword lengthofsinglesequence,
                                     GtTwobitencoding *twobitencoding,
                                     GtUword numofsequences,
                                     GtUword numoffiles,
                                     const GtFilelengthvalues *filelengthtab,
                                     const GtStrArray *filenametab,
                                     const GtUword *characterdistribution,
                                     GtError *err)
{
  gt_assert (lengthofsinglesequence > 0);
  return gt_encseq_generic_write_twobitencoding_to_file(indexname,
                                     totallength,
                                     GT_ACCESS_TYPE_EQUALLENGTH,
                                     lengthofsinglesequence,
                                     lengthofsinglesequence,
                                     lengthofsinglesequence,
                                     0,
                                     0,
                                     lengthofsinglesequence,
                                     twobitencoding,
                                     numofsequences,
                                     numoffiles,
                                     filelengthtab,
                                     filenametab,
                                     characterdistribution,
                                     err);
}

// Assembly:
pushq %rbx
subq $0x50, %rsp
testq %rdx, %rdx
je 0xa54ef
movq %rdx, %rax
movq 0x78(%rsp), %rdx
movq 0x70(%rsp), %r10
movq 0x68(%rsp), %r11
movq 0x60(%rsp), %rbx
movq %rdx, 0x48(%rsp)
movq %r10, 0x40(%rsp)
movq %r11, 0x38(%rsp)
movq %rbx, 0x30(%rsp)
movq %r9, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %rax, 0x10(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, (%rsp)
pushq $0x2
popq %rdx
movq %rax, %rcx
movq %rax, %r8
movq %rax, %r9
callq 0xa3f06
addq $0x50, %rsp
popq %rbx
retq
movq 0x88ac2(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x24b66(%rip), %rsi     # 0xca066
leaq 0x46d6c(%rip), %rdx     # 0xec273
leaq 0x46d80(%rip), %rcx     # 0xec28e
leaq 0x46685(%rip), %r8      # 0xebb9a
movl $0x652, %r9d            # imm = 0x652
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0xa55e5
movq %rsi, %rbx
leaq 0x46478(%rip), %rax     # 0xeb9ec
movslq (%rax,%rdi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
cmpq $0x0, 0x8(%rbx)
jne 0xa5644
movl $0x77e, %ebp            # imm = 0x77E
movl $0x77d, %edx            # imm = 0x77D
jmp 0xa55c1
cmpq $0x0, 0x8(%rbx)
jne 0xa5616
movl $0x788, %ebp            # imm = 0x788
movl $0x787, %edx            # imm = 0x787
jmp 0xa55c1
popq %rbx
popq %r14
popq %rbp
retq
cmpq $0x0, 0x8(%rbx)
jne 0xa5672
movl $0x783, %ebp            # imm = 0x783
movl $0x782, %edx            # imm = 0x782
movq (%rbx), %rdi
leaq 0x465cf(%rip), %r14     # 0xebb9a
movq %r14, %rsi
callq 0xd249
movq 0x10(%rbx), %rdi
movq %r14, %rsi
movl %ebp, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0xd249
movq 0x889cc(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x24a70(%rip), %rsi     # 0xca066
leaq 0x49ac2(%rip), %rdx     # 0xef0bf
leaq 0x49a5c(%rip), %rcx     # 0xef060
leaq 0x4658f(%rip), %r8      # 0xebb9a
movl $0x78b, %r9d            # imm = 0x78B
jmp 0xa569e
movq 0x8899b(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x24a3f(%rip), %rsi     # 0xca066
leaq 0x49a6a(%rip), %rdx     # 0xef098
leaq 0x49a2b(%rip), %rcx     # 0xef060
leaq 0x4655e(%rip), %r8      # 0xebb9a
movl $0x786, %r9d            # imm = 0x786
jmp 0xa569e
movq 0x8896d(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x24a11(%rip), %rsi     # 0xca066
leaq 0x499de(%rip), %rdx     # 0xef03a
leaq 0x499fd(%rip), %rcx     # 0xef060
leaq 0x46530(%rip), %r8      # 0xebb9a
movl $0x77c, %r9d            # imm = 0x77C
jmp 0xa569e
movq 0x8893f(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x249e3(%rip), %rsi     # 0xca066
leaq 0x499e7(%rip), %rdx     # 0xef071
leaq 0x499cf(%rip), %rcx     # 0xef060
leaq 0x46502(%rip), %r8      # 0xebb9a
movl $0x781, %r9d            # imm = 0x781
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0xa56d2
movq 0x398(%rbx), %rdi
callq 0x16028
incq 0x390(%rbx)
movq 0x398(%rbx), %rdi
callq 0x1609f
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xa56d7
movq %rax, %rbx
movq %r15, %rdi
callq 0xa1f8d
movq %rax, %r14
movq %r15, %rdi
callq 0xa1f4a
testq %rbx, %rbx
je 0xa59f5
testq %r14, %r14
je 0xa5a36
movq %r14, %rcx
decq %rcx
xorl %esi, %esi
xorl %edx, %edx
cmpq %rdx, %rcx
je 0xa59eb
movq (%rbx,%rdx,8), %rdi
movq %rdi, %r8
subq %rsi, %r8
jbe 0xa59fe
movq %r8, (%rbx,%rdx,8)
incq %rdi
incq %rdx
movq %rdi, %rsi
jmp 0xa59cb
subq %rsi, %rax
jbe 0xa5a64
movq %rax, -0x8(%rbx,%r14,8)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x885b3(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x24657(%rip), %rsi     # 0xca066
leaq 0x4695b(%rip), %rdx     # 0xec371
leaq 0x46938(%rip), %rcx     # 0xec355
leaq 0x46176(%rip), %r8      # 0xebb9a
movl $0xca2, %r9d            # imm = 0xCA2
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
movq 0x8857b(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2461f(%rip), %rsi     # 0xca066
leaq 0x46812(%rip), %rdx     # 0xec260
leaq 0x46900(%rip), %rcx     # 0xec355
leaq 0x4613e(%rip), %r8      # 0xebb9a
movl $0xc9e, %r9d            # imm = 0xC9E
jmp 0xa5a2a
movq 0x8854d(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x245f1(%rip), %rsi     # 0xca066
leaq 0x4690d(%rip), %rdx     # 0xec389
leaq 0x468d2(%rip), %rcx     # 0xec355
leaq 0x46110(%rip), %r8      # 0xebb9a
movl $0xca6, %r9d            # imm = 0xCA6
jmp 0xa5a2a
// File: /workspace/github_c_makefile_star2_O2/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 0xa5bfb
cmpb $0x1, 0x3a8(%rbx)
jne 0xa5c3f
cmpq $0x2, 0x48(%rbx)
jne 0xa5c3f
leaq 0x45f98(%rip), %rsi     # 0xebb9a
movl $0x80, %edi
movl $0xd3e, %edx            # imm = 0xD3E
callq 0xccb0
movq %rax, %r14
andq $0x0, 0x68(%rax)
movb %bpl, 0x64(%rax)
movzbl %bpl, %edx
movq %rax, %rdi
movq %rbx, %rsi
callq 0xa5bd5
andw $0x0, 0x62(%r14)
movb $0x0, 0x65(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq 0x88372(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x24416(%rip), %rsi     # 0xca066
leaq 0x467e7(%rip), %rdx     # 0xec43e
leaq 0x4683b(%rip), %rcx     # 0xec499
leaq 0x45f35(%rip), %r8      # 0xebb9a
movl $0xd3d, %r9d            # imm = 0xD3D
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/encseq.c
// Function: gt_specialrangeiterator_invert_range
static inline void gt_specialrangeiterator_invert_range(GtEncseq *encseq,
                                                        GtRange *range)
{
  gt_assert(encseq && range);
  range->start = GT_REVERSEPOS(encseq->logicaltotallength,
                               range->start);
  range->end = GT_REVERSEPOS(encseq->logicaltotallength,
                             range->end);
  if (range->end <= range->start) {
    GtUword tmp;
    tmp = ++range->end;
    range->end = ++range->start;
    range->start = tmp;
  }
}

// Assembly:
testq %rdi, %rdi
je 0xa5e9d
testq %rsi, %rsi
je 0xa5e9d
movq 0x38(%rdi), %rax
movq (%rsi), %rcx
movq 0x8(%rsi), %rdx
movq %rcx, %rdi
notq %rdi
addq %rax, %rdi
movq %rdi, (%rsi)
movq %rdx, %r8
notq %r8
addq %rax, %r8
movq %r8, 0x8(%rsi)
cmpq %rdi, %r8
ja 0xa5e9c
movq %rax, %rdi
subq %rdx, %rdi
subq %rcx, %rax
movq %rax, 0x8(%rsi)
movq %rdi, (%rsi)
retq
pushq %rax
movq 0x88113(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x241b7(%rip), %rsi     # 0xca066
leaq 0x49547(%rip), %rdx     # 0xef3fd
leaq 0x49550(%rip), %rcx     # 0xef40d
leaq 0x45cd6(%rip), %r8      # 0xebb9a
movl $0xe94, %r9d            # imm = 0xE94
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/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 0xa6442
testq %rsi, %rsi
je 0xa64a0
cmpq %rcx, (%rdi)
jae 0xa6442
cmpq %rcx, -0x10(%rdi,%rsi,8)
jae 0xa6446
cmpq %rdx, %rcx
jae 0xa647d
decq %rsi
movq %rsi, %rax
jmp 0xa6444
xorl %eax, %eax
popq %rcx
retq
addq $-0x2, %rsi
xorl %edx, %edx
movq %rsi, %rax
subq %rdx, %rax
jb 0xa647d
shrq %rax
addq %rdx, %rax
cmpq %rcx, (%rdi,%rax,8)
jb 0xa646d
leaq -0x1(%rax), %rsi
cmpq %rcx, -0x8(%rdi,%rax,8)
jae 0xa644c
jmp 0xa6444
leaq 0x1(%rax), %rdx
cmpq %rcx, 0x8(%rdi,%rax,8)
movq %rdx, %rax
jb 0xa644c
jmp 0xa6444
movq 0x87b34(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x46071(%rip), %rsi     # 0xec4ff
movq %rcx, %rdx
xorl %eax, %eax
callq 0xb8c0
pushq $0x2
popq %rdi
callq 0xb7b0
movq 0x87b11(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x23bb5(%rip), %rsi     # 0xca066
leaq 0x46021(%rip), %rdx     # 0xec4d9
leaq 0x4602b(%rip), %rcx     # 0xec4ea
leaq 0x456d4(%rip), %r8      # 0xebb9a
movl $0xf26, %r9d            # imm = 0xF26
xorl %eax, %eax
callq 0xb8c0
callq 0xb300