LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_seqnum_ssptab
GtUword gt_encseq_seqnum_ssptab(const GtEncseq *encseq,
                                         GtUword position)
{
  gt_assert(position < encseq->totallength);
  switch (encseq->satsep) {
    case GT_ACCESS_TYPE_UCHARTABLES:
      return gt_encseq_seqnum_uchar(&encseq->ssptab.st_uchar,position);
    case GT_ACCESS_TYPE_USHORTTABLES:
      return gt_encseq_seqnum_uint16(&encseq->ssptab.st_uint16,position);
    case GT_ACCESS_TYPE_UINT32TABLES:
      return gt_encseq_seqnum_uint32(&encseq->ssptab.st_uint32,position);
    default:
      fprintf(stderr, "%s(%d) undefined\n", __func__, (int) encseq->satsep);
      exit(GT_EXIT_PROGRAMMING_ERROR);
  }
}

// Assembly:
pushq %rbx
cmpq %rsi, 0x30(%rdi)
jbe 0xa662a
movq %rsi, %rdx
movl 0x4(%rdi), %ecx
cmpl $0x6, %ecx
je 0xa6556
cmpl $0x5, %ecx
je 0xa652b
cmpl $0x4, %ecx
jne 0xa6662
cmpq $0xff, %rdx
ja 0xa65f1
movq 0x250(%rdi), %rax
movq (%rax), %rsi
testq %rsi, %rsi
je 0xa657e
movq 0x240(%rdi), %rdi
incq %rsi
movzbl %dl, %edx
popq %rbx
jmp 0xb4492
cmpq $0xffff, %rdx           # imm = 0xFFFF
ja 0xa6585
movq 0x250(%rdi), %rax
movq (%rax), %rsi
testq %rsi, %rsi
je 0xa657e
movq 0x240(%rdi), %rdi
incq %rsi
movzwl %dx, %edx
popq %rbx
jmp 0xb4541
movq %rdx, %rax
shrq $0x20, %rax
jne 0xa65c0
movq 0x250(%rdi), %rax
movq (%rax), %rsi
testq %rsi, %rsi
je 0xa657e
movq 0x240(%rdi), %rdi
incq %rsi
popq %rbx
jmp 0xb45f5
xorl %ebx, %ebx
jmp 0xa6625
movq 0x250(%rdi), %rax
movq %rdx, %rcx
shrq $0x10, %rcx
movq -0x8(%rax,%rcx,8), %rbx
movq (%rax,%rcx,8), %rsi
subq %rbx, %rsi
jbe 0xa6625
leaq (%rbx,%rbx), %rax
addq 0x240(%rdi), %rax
incq %rsi
movzwl %dx, %edx
movq %rax, %rdi
callq 0xb4541
jmp 0xa6622
movq 0x250(%rdi), %rcx
movq -0x8(%rcx,%rax,8), %rbx
movq (%rcx,%rax,8), %rsi
subq %rbx, %rsi
jbe 0xa6625
leaq (,%rbx,4), %rax
addq 0x240(%rdi), %rax
incq %rsi
movq %rax, %rdi
callq 0xb45f5
jmp 0xa6622
movq 0x250(%rdi), %rax
movq %rdx, %rcx
shrq $0x8, %rcx
movq -0x8(%rax,%rcx,8), %rbx
movq (%rax,%rcx,8), %rsi
subq %rbx, %rsi
jbe 0xa6625
movq 0x240(%rdi), %rdi
addq %rbx, %rdi
incq %rsi
movzbl %dl, %edx
callq 0xb4492
addq %rax, %rbx
movq %rbx, %rax
popq %rbx
retq
movq 0x87987(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x23a2b(%rip), %rsi     # 0xca066
leaq 0x4a610(%rip), %rdx     # 0xf0c52
leaq 0x45ee6(%rip), %rcx     # 0xec52f
leaq 0x4554a(%rip), %r8      # 0xebb9a
movl $0xf48, %r9d            # imm = 0xF48
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
movq 0x8794f(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x45ed4(%rip), %rsi     # 0xec547
leaq 0x45eb5(%rip), %rdx     # 0xec52f
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_seqnum
GtUword gt_encseq_seqnum(const GtEncseq *encseq,
                               GtUword position)
{
  GtUword num;
  bool wasmirrored = false;
  if (encseq->hasmirror && position >= encseq->totallength) {
    position = encseq->logicaltotallength - 1 - position;
    wasmirrored = true;
  }
  gt_assert(position < encseq->totallength);
  if (encseq->sat != GT_ACCESS_TYPE_EQUALLENGTH) {
    if (encseq->numofdbsequences == 1UL) {
      num = 0;
    }
    else {
      num = gt_encseq_seqnum_ssptab(encseq, position);
    }
  }
  else {
    num = gt_encseq_seqnum_Viaequallength(encseq, position);
  }
  if (wasmirrored) {
    num = encseq->logicalnumofdbsequences - 1 - num;
  }
  return num;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x30(%rdi), %rax
cmpq %rsi, %rax
setbe %bpl
andb 0x3a8(%rdi), %bpl
cmpb $0x1, %bpl
jne 0xa66ae
notq %rsi
addq 0x38(%rbx), %rsi
cmpq %rax, %rsi
jae 0xa66e8
cmpl $0x2, (%rbx)
jne 0xa66c2
movq %rbx, %rdi
callq 0xa6720
jmp 0xa66d5
cmpq $0x1, 0x40(%rbx)
jne 0xa66cd
xorl %eax, %eax
jmp 0xa66d5
movq %rbx, %rdi
callq 0xa64d8
testb %bpl, %bpl
je 0xa66e1
notq %rax
addq 0x48(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x878c9(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2396d(%rip), %rsi     # 0xca066
leaq 0x4a552(%rip), %rdx     # 0xf0c52
leaq 0x45e52(%rip), %rcx     # 0xec559
leaq 0x4548c(%rip), %r8      # 0xebb9a
movl $0xf5f, %r9d            # imm = 0xF5F
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_seqstartpos_viautables
static GtUword gt_encseq_seqstartpos_viautables(const GtEncseq *encseq,
                                                      GtUword seqnum)
{
  switch (encseq->satsep) {
    case GT_ACCESS_TYPE_UCHARTABLES:
      return gt_encseq_seqstartposSW_uchar(&encseq->ssptab.st_uchar,
                                           seqnum);
    case GT_ACCESS_TYPE_USHORTTABLES:
      return gt_encseq_seqstartposSW_uint16(&encseq->ssptab.st_uint16,
                                            seqnum);
    case GT_ACCESS_TYPE_UINT32TABLES:
      return gt_encseq_seqstartposSW_uint32(&encseq->ssptab.st_uint32,
                                            seqnum);
    default:
      fprintf(stderr, "%s(%d) undefined\n", __func__, (int) encseq->satsep);
      exit(GT_EXIT_PROGRAMMING_ERROR);
  }
}

// Assembly:
pushq %rax
movl 0x4(%rdi), %ecx
cmpl $0x6, %ecx
je 0xa6a15
cmpl $0x5, %ecx
je 0xa69ba
cmpl $0x4, %ecx
jne 0xa6aea
testq %rsi, %rsi
je 0xa6a68
decq %rsi
movq 0x250(%rdi), %rcx
movq 0x260(%rdi), %rax
leaq (%rcx,%rax,8), %rdx
addq $-0x8, %rdx
xorl %eax, %eax
movq %rcx, %r8
cmpq %rdx, %r8
ja 0xa6abf
movq %rdx, %r9
subq %r8, %r9
sarq %r9
andq $-0x8, %r9
cmpq %rsi, (%r8,%r9)
ja 0xa69b0
leaq (%r8,%r9), %rax
addq %r9, %r8
addq $0x8, %r8
jmp 0xa6987
leaq (%r8,%r9), %rdx
addq $-0x8, %rdx
jmp 0xa6987
testq %rsi, %rsi
je 0xa6a68
leaq -0x1(%rsi), %rdx
movq 0x250(%rdi), %rcx
movq 0x260(%rdi), %rax
leaq (%rcx,%rax,8), %r8
addq $-0x8, %r8
xorl %eax, %eax
movq %rcx, %r9
cmpq %r8, %r9
ja 0xa6a6c
movq %r8, %r10
subq %r9, %r10
sarq %r10
andq $-0x8, %r10
cmpq %rdx, (%r9,%r10)
ja 0xa6a0b
leaq (%r9,%r10), %rax
addq %r10, %r9
addq $0x8, %r9
jmp 0xa69e2
leaq (%r9,%r10), %r8
addq $-0x8, %r8
jmp 0xa69e2
testq %rsi, %rsi
je 0xa6a68
leaq -0x1(%rsi), %rdx
movq 0x250(%rdi), %rcx
movq 0x260(%rdi), %rax
leaq (%rcx,%rax,8), %r8
addq $-0x8, %r8
xorl %eax, %eax
movq %rcx, %r9
cmpq %r8, %r9
ja 0xa6a8e
movq %r8, %r10
subq %r9, %r10
sarq %r10
andq $-0x8, %r10
cmpq %rdx, (%r9,%r10)
ja 0xa6a5e
leaq (%r9,%r10), %rax
addq %r10, %r9
addq $0x8, %r9
jmp 0xa6a39
leaq (%r9,%r10), %r8
addq $-0x8, %r8
jmp 0xa6a39
xorl %eax, %eax
jmp 0xa6ae8
movq %rax, %rdx
subq %rcx, %rdx
shlq $0xd, %rdx
addq $0x10001, %rdx          # imm = 0x10001
testq %rax, %rax
movq 0x240(%rdi), %rax
movzwl -0x2(%rax,%rsi,2), %ecx
jmp 0xa6ade
movq %rax, %rdx
subq %rcx, %rdx
shlq $0x1d, %rdx
movabsq $0x100000001, %rcx      # imm = 0x100000001
addq %rdx, %rcx
testq %rax, %rax
movq 0x240(%rdi), %rax
movl -0x4(%rax,%rsi,4), %edx
pushq $0x1
popq %rax
cmovneq %rcx, %rax
addq %rdx, %rax
jmp 0xa6ae8
movq %rax, %rdx
subq %rcx, %rdx
shlq $0x5, %rdx
addq $0x101, %rdx            # imm = 0x101
testq %rax, %rax
movq 0x240(%rdi), %rax
movzbl (%rax,%rsi), %ecx
pushq $0x1
popq %rax
cmovneq %rdx, %rax
addq %rcx, %rax
popq %rcx
retq
movq 0x874c7(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x45a4c(%rip), %rsi     # 0xec547
leaq 0x48c72(%rip), %rdx     # 0xef774
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_seqlength
GtUword gt_encseq_seqlength(const GtEncseq *encseq, GtUword seqnum)
{
  gt_assert(encseq != NULL && seqnum < encseq->logicalnumofdbsequences);
  if (encseq->hasmirror && seqnum >= encseq->numofdbsequences) {
    seqnum = GT_REVERSEPOS(encseq->logicalnumofdbsequences, seqnum);
  }
  if (encseq->sat != GT_ACCESS_TYPE_EQUALLENGTH) {
    if (seqnum == 0) {
      if (encseq->numofdbsequences == 1UL)
        return encseq->totallength;
      else
        return gt_encseq_seqstartpos_viautables(encseq, 1UL) - 1;
    }
    else {
      GtUword startpos = gt_encseq_seqstartpos(encseq, seqnum);
      if (seqnum == encseq->numofdbsequences - 1)
        return encseq->totallength - startpos;
      else {
        return gt_encseq_seqstartpos_viautables(encseq, seqnum + 1UL)
                 - 1 - startpos;
      }
    }
  }
  else
    return encseq->equallength.valueunsignedlong;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xa6c05
movq %rsi, %r14
movq %rdi, %rbx
movq 0x48(%rdi), %rax
cmpq %rsi, %rax
jbe 0xa6c05
cmpb $0x1, 0x3a8(%rbx)
jne 0xa6b95
cmpq %r14, 0x40(%rbx)
ja 0xa6b95
notq %r14
addq %rax, %r14
cmpl $0x2, (%rbx)
jne 0xa6ba3
movq 0x1f0(%rbx), %rax
jmp 0xa6bff
testq %r14, %r14
je 0xa6bcb
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa6788
movq %rax, %r15
movq 0x40(%rbx), %rax
decq %rax
cmpq %rax, %r14
jne 0xa6bd8
movq 0x30(%rbx), %rax
subq %r15, %rax
jmp 0xa6bff
cmpq $0x1, 0x40(%rbx)
jne 0xa6bf1
movq 0x30(%rbx), %rax
jmp 0xa6bff
incq %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa6945
notq %r15
addq %rax, %r15
movq %r15, %rax
jmp 0xa6bff
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0xa6945
decq %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x873ac(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x23450(%rip), %rsi     # 0xca066
leaq 0x4594d(%rip), %rdx     # 0xec56a
leaq 0x459df(%rip), %rcx     # 0xec603
leaq 0x44f6f(%rip), %r8      # 0xebb9a
movl $0xfa0, %r9d            # imm = 0xFA0
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/encseq.c
// Function: gt_specialcharinfo_read
int gt_specialcharinfo_read(GtSpecialcharinfo *specialcharinfo,
                            const char *indexname, GtError *err)
{
  GtEncseqMetadata *emd = gt_encseq_metadata_new(indexname, err);
  if (emd == NULL)
    return -1;
  *specialcharinfo = gt_encseq_metadata_specialcharinfo(emd);
  gt_encseq_metadata_delete(emd);
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
movq %rsi, %rdi
movq %rdx, %rsi
callq 0xbafdc
testq %rax, %rax
je 0xa6e66
movq %rax, %r14
movq %rsp, %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0xbb995
pushq $0xe
popq %rcx
movq %rbx, %rdi
movq %r15, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %r14, %rdi
callq 0xbb9e1
xorl %eax, %eax
jmp 0xa6e69
pushq $-0x1
popq %rax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_charcount
GtUword gt_encseq_charcount(const GtEncseq *encseq, GtUchar cc)
{
  gt_assert(encseq != NULL &&
            (unsigned int) cc < gt_alphabet_num_of_chars(encseq->alpha));
  if (encseq->hasmirror) {
    return encseq->headerptr.characterdistribution[cc]
             + encseq->headerptr.characterdistribution[GT_COMPLEMENTBASE(cc)];
  } else return encseq->headerptr.characterdistribution[cc];
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xa6f33
movq %rdi, %rbx
movzbl %sil, %r14d
movq 0x220(%rdi), %rdi
callq 0x9b59a
cmpl %r14d, %eax
jbe 0xa6f33
movq 0xf8(%rbx), %rcx
movq (%rcx,%r14,8), %rax
cmpb $0x1, 0x3a8(%rbx)
jne 0xa6f2b
pushq $0x3
popq %rdx
subl %r14d, %edx
movslq %edx, %rdx
addq (%rcx,%rdx,8), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x8707e(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x23122(%rip), %rsi     # 0xca066
leaq 0x45717(%rip), %rdx     # 0xec662
leaq 0x4575e(%rip), %rcx     # 0xec6b0
leaq 0x44c41(%rip), %r8      # 0xebb9a
movl $0x10ac, %r9d           # imm = 0x10AC
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/encseq.c
// Function: determineoptimalsssptablerep
static GtEncseqAccessType determineoptimalsssptablerep(
                                  GtUword totallength,
                                  GtUword numofseparators)
{
  uint64_t sepsizemin, sepsize;
  GtEncseqAccessType satmin;

  gt_assert (numofseparators > 0);
  sepsizemin = gt_encseq_sizeofSWtable(GT_ACCESS_TYPE_UCHARTABLES, false, false,
                                       totallength, numofseparators);
  satmin = GT_ACCESS_TYPE_UCHARTABLES;
  sepsize = gt_encseq_sizeofSWtable(GT_ACCESS_TYPE_USHORTTABLES, false, false,
                                    totallength, numofseparators);
  if (sepsize < sepsizemin) {
    sepsizemin = sepsize;
    satmin = GT_ACCESS_TYPE_USHORTTABLES;
  }
  sepsize = gt_encseq_sizeofSWtable(GT_ACCESS_TYPE_UINT32TABLES, false, false,
                                    totallength, numofseparators);
  if (sepsize < sepsizemin)
    satmin = GT_ACCESS_TYPE_UINT32TABLES;
  return satmin;
}

// Assembly:
testq %rsi, %rsi
je 0xa71d9
xorl %ecx, %ecx
movl $0xff, %r8d
movq %rdi, %rax
xorl %edx, %edx
divq %r8
leaq (%rsi,%rax,8), %r8
addq $0x8, %r8
leaq (%rsi,%rsi), %r9
movl $0xffff, %r10d          # imm = 0xFFFF
movq %rdi, %rax
xorl %edx, %edx
divq %r10
leaq (%r9,%rax,8), %rax
addq $0x8, %rax
cmpq %r8, %rax
cmovbq %rax, %r8
adcl $0x4, %ecx
shlq $0x2, %rsi
movl $0xffffffff, %r9d       # imm = 0xFFFFFFFF
movq %rdi, %rax
xorl %edx, %edx
divq %r9
leaq (%rsi,%rax,8), %rax
addq $0x8, %rax
cmpq %r8, %rax
pushq $0x6
popq %rax
cmovael %ecx, %eax
retq
pushq %rax
movq 0x86dd7(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x22e7b(%rip), %rsi     # 0xca066
leaq 0x486e5(%rip), %rdx     # 0xef8d7
leaq 0x486f2(%rip), %rcx     # 0xef8eb
leaq 0x4499a(%rip), %r8      # 0xebb9a
movl $0x6ba, %r9d            # imm = 0x6BA
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/encseq.c
// Function: ssptaboutinfo_processseppos
static void ssptaboutinfo_processseppos(Gtssptaboutinfo *ssptaboutinfo,
                                        GtUword seppos)
{
  if (ssptaboutinfo != NULL) {
    switch (ssptaboutinfo->satsep) {
      case GT_ACCESS_TYPE_UCHARTABLES:
        ssptaboutinfo->ssptabptr->st_uchar.positions[ssptaboutinfo->fillpos++]
          = (GtUchar) (seppos &
                       ssptaboutinfo->ssptabptr->st_uchar.maxrangevalue);
        break;
      case GT_ACCESS_TYPE_USHORTTABLES:
        ssptaboutinfo->ssptabptr->st_uint16.positions[ssptaboutinfo->fillpos++]
          = (uint16_t) (seppos &
                        ssptaboutinfo->ssptabptr->st_uint16.maxrangevalue);
        break;
      case GT_ACCESS_TYPE_UINT32TABLES:
        ssptaboutinfo->ssptabptr->st_uint32.positions[ssptaboutinfo->fillpos++]
          = (uint32_t) (seppos &
                        ssptaboutinfo->ssptabptr->st_uint32.maxrangevalue);
        break;
      default:
        fprintf(stderr, "ssptaboutinfo_processseppos(sat = %d is undefined)\n",
                       (int) ssptaboutinfo->satsep);
        exit(GT_EXIT_PROGRAMMING_ERROR);
    }
  }
}

// Assembly:
testq %rdi, %rdi
je 0xa7399
movl 0x8(%rdi), %edx
cmpl $0x6, %edx
je 0xa739a
cmpl $0x5, %edx
je 0xa7380
cmpl $0x4, %edx
jne 0xa73b3
movq (%rdi), %rax
movq 0x28(%rdi), %rcx
andl 0x30(%rax), %esi
movq (%rax), %rax
leaq 0x1(%rcx), %rdx
movq %rdx, 0x28(%rdi)
movb %sil, (%rax,%rcx)
retq
movq (%rdi), %rax
movq 0x28(%rdi), %rcx
andl 0x30(%rax), %esi
movq (%rax), %rax
leaq 0x1(%rcx), %rdx
movq %rdx, 0x28(%rdi)
movw %si, (%rax,%rcx,2)
retq
movq (%rdi), %rax
movq 0x28(%rdi), %rcx
andl 0x30(%rax), %esi
movq (%rax), %rax
leaq 0x1(%rcx), %rdx
movq %rdx, 0x28(%rdi)
movl %esi, (%rax,%rcx,4)
retq
pushq %rax
movq 0x86bfd(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x48567(%rip), %rsi     # 0xef92c
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: flushssptab2file
static int flushssptab2file(const char *indexname,
                            Gtssptransferinfo *ssptransferinfo,
                            GtError *err)
{
  FILE *fp;
  bool haserr = false;

  gt_error_check(err);
  fp = gt_fa_fopen_with_suffix(indexname, GT_SSPTABFILESUFFIX, "wb", err);
  if (fp == NULL)
    haserr = true;
  if (!haserr) {
    GtUword sizessptab;

    sizessptab = CALLCASTFUNC(uint64_t, unsigned_long,
                              gt_encseq_sizeofSWtable(ssptransferinfo->satsep,
                                                      false,
                                                      false,
                                                      ssptransferinfo->
                                                        totallength,
                                                      ssptransferinfo->
                                                        numofdbsequences-1));
    if (gt_mapspec_write(assignssptabmapspecification, fp, ssptransferinfo,
                         sizessptab,
                         err) != 0) {
      haserr = true;
    }
  }
  gt_fa_xfclose(fp);
  return haserr ? -1 : 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
testq %rdx, %rdx
je 0xa7450
movq %rbx, %rdi
callq 0xc103
testb %al, %al
jne 0xa74d8
leaq 0x43882(%rip), %rsi     # 0xeacd9
leaq 0x42fc4(%rip), %rdx     # 0xea422
leaq 0x44735(%rip), %rcx     # 0xebb9a
movq %r15, %rdi
movl $0x3c0, %r8d            # imm = 0x3C0
movq %rbx, %r9
callq 0x51b2d
movq %rax, %r15
testq %rax, %rax
je 0xa74c0
sete %bpl
movl 0x10(%r14), %edi
movq (%r14), %rcx
movq 0x8(%r14), %r8
decq %r8
xorl %esi, %esi
xorl %edx, %edx
callq 0xa7df3
leaq 0xd24b(%rip), %rdi      # 0xb46eb
movq %r15, %rsi
movq %r14, %rdx
movq %rax, %rcx
movq %rbx, %r8
callq 0xbd84e
testl %eax, %eax
setne %al
orb %bpl, %al
movzbl %al, %ebx
negl %ebx
jmp 0xa74c3
pushq $-0x1
popq %rbx
movq %r15, %rdi
callq 0x51cc9
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x86ad9(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x22b7d(%rip), %rsi     # 0xca066
leaq 0x23169(%rip), %rdx     # 0xca659
leaq 0x48499(%rip), %rcx     # 0xef990
leaq 0x4469c(%rip), %r8      # 0xebb9a
movl $0x3bf, %r9d            # imm = 0x3BF
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_max_desc_length
GtUword gt_encseq_max_desc_length(const GtEncseq *encseq)
{
  gt_assert(encseq && encseq->destab);
  /* decides whether destab contains max desc length as a separate field */
  if (encseq->destab[encseq->destablength - 1] == '\n') {
    GtUword i,
                  maxlen = 0;
    for (i = 0; i < gt_encseq_num_of_sequences(encseq); i++) {
      GtUword len;
      (void) gt_encseq_description(encseq, &len, i);
      if (len > maxlen)
        maxlen = len;
    }
    return maxlen;
  } else {
    void *ptr;
    ptr = encseq->destab + encseq->destablength - 2 * (sizeof (GtUword));
    return *(GtUword*) ptr;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xa76ef
movq %rdi, %rbx
movq 0x200(%rdi), %rax
testq %rax, %rax
je 0xa76ef
movq 0x210(%rbx), %rcx
cmpb $0xa, -0x1(%rax,%rcx)
jne 0xa76db
xorl %r15d, %r15d
movq %rsp, %r12
xorl %r14d, %r14d
cmpq 0x48(%rbx), %r15
jae 0xa76e0
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0xa7510
movq (%rsp), %rax
cmpq %r14, %rax
cmovaq %rax, %r14
incq %r15
jmp 0xa76b7
movq -0x10(%rax,%rcx), %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x868c2(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x22966(%rip), %rsi     # 0xca066
leaq 0x450c2(%rip), %rdx     # 0xec7c9
leaq 0x450d4(%rip), %rcx     # 0xec7e2
leaq 0x44485(%rip), %r8      # 0xebb9a
movl $0x1302, %r9d           # imm = 0x1302
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_check_descriptions
void gt_encseq_check_descriptions(const GtEncseq *encseq)
{
  GtUword desclen, seqnum, totaldesclength, offset = 0;
  const char *desptr;
  char *copydestab;

  gt_assert(encseq != NULL);
  totaldesclength = encseq->numofdbsequences; /* for each new line */
  for (seqnum = 0; seqnum < encseq->numofdbsequences; seqnum++) {
    (void) gt_encseq_description(encseq, &desclen, seqnum);
    totaldesclength += desclen;
  }
  copydestab = gt_malloc(sizeof (*copydestab) * totaldesclength);
  for (seqnum = 0; seqnum < encseq->numofdbsequences; seqnum++) {
    desptr = gt_encseq_description(encseq, &desclen, seqnum);
    strncpy(copydestab + offset, desptr, (size_t) desclen);
    copydestab[offset+desclen] = '\n';
    offset += (desclen+1);
  }
  gt_assert(encseq->destab != NULL);
  if (strncmp(copydestab, encseq->destab, (size_t) totaldesclength) != 0) {
    fprintf(stderr, "different descriptions\n");
    exit(GT_EXIT_PROGRAMMING_ERROR);
  }
  gt_free(copydestab);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0xa785e
movq %rdi, %rbx
movq 0x40(%rdi), %rax
xorl %r15d, %r15d
leaq 0x8(%rsp), %r12
movq %rax, %r14
cmpq %rax, %r15
jae 0xa77b7
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0xa7510
addq 0x8(%rsp), %r14
incq %r15
movq 0x40(%rbx), %rax
jmp 0xa7796
leaq 0x443dc(%rip), %rsi     # 0xebb9a
movq %r14, %rdi
movl $0x1327, %edx           # imm = 0x1327
callq 0xccb0
movq %rax, 0x10(%rsp)
xorl %r15d, %r15d
xorl %r13d, %r13d
cmpq 0x40(%rbx), %r13
jae 0xa7818
movq %rbx, %rdi
leaq 0x8(%rsp), %rsi
movq %r13, %rdx
callq 0xa7510
movq 0x10(%rsp), %rcx
leaq (%rcx,%r15), %rbp
movq 0x8(%rsp), %r12
movq %rbp, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0xb2d0
movb $0xa, (%r12,%rbp)
addq %r12, %r15
incq %r15
incq %r13
jmp 0xa77d6
movq 0x200(%rbx), %rsi
testq %rsi, %rsi
je 0xa788c
movq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rdx
callq 0xb2a0
testl %eax, %eax
jne 0xa78c4
leaq 0x44357(%rip), %rsi     # 0xebb9a
movq %rbx, %rdi
movl $0x1333, %edx           # imm = 0x1333
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xd249
movq 0x86753(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x227f7(%rip), %rsi     # 0xca066
leaq 0x44a5a(%rip), %rdx     # 0xec2d0
leaq 0x44f93(%rip), %rcx     # 0xec810
leaq 0x44316(%rip), %r8      # 0xebb9a
movl $0x1321, %r9d           # imm = 0x1321
jmp 0xa78b8
movq 0x86725(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x227c9(%rip), %rsi     # 0xca066
leaq 0x44ebe(%rip), %rdx     # 0xec762
leaq 0x44f65(%rip), %rcx     # 0xec810
leaq 0x442e8(%rip), %r8      # 0xebb9a
movl $0x132e, %r9d           # imm = 0x132E
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
movq 0x866ed(%rip), %rax     # 0x12dfb8
movq (%rax), %rcx
leaq 0x44f58(%rip), %rdi     # 0xec82d
pushq $0x17
popq %rsi
pushq $0x1
popq %rdx
callq 0xbca0
pushq $0x2
popq %rdi
callq 0xb7b0
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_has_multiseq_support
bool gt_encseq_has_multiseq_support(const GtEncseq *encseq)
{
  bool ret =  encseq->sat == GT_ACCESS_TYPE_EQUALLENGTH ||
              encseq->has_ssptab ||
              encseq->accesstype_via_utables;
  return ret;
}

// Assembly:
movb $0x1, %al
cmpl $0x2, (%rdi)
je 0xa7a85
cmpb $0x0, 0x2a(%rdi)
jne 0xa7a85
movb 0x3a9(%rdi), %al
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_has_description_support
bool gt_encseq_has_description_support(const GtEncseq *encseq)
{
  bool ret = (encseq->destab != NULL
                && (encseq->numofdbsequences == 1UL
                      || encseq->sdstab != NULL));
  return ret;
}

// Assembly:
cmpq $0x0, 0x200(%rdi)
je 0xa7aa5
movb $0x1, %al
cmpq $0x1, 0x40(%rdi)
je 0xa7aa4
cmpq $0x0, 0x218(%rdi)
setne %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_specialranges
GtUword gt_encseq_specialranges(const GtEncseq *encseq)
{
  gt_assert(encseq != NULL);
  if (encseq->hasmirror) {
    /* check whether central specialranges can be merged */
    if (gt_encseq_get_encoded_char(encseq, encseq->totallength-1,
                               GT_READMODE_FORWARD) == (GtUchar) GT_WILDCARD) {
      return (encseq->specialcharinfo.specialranges*2)-1;
    } else {
      return (encseq->specialcharinfo.specialranges*2)+1;
    }
  }
  return encseq->specialcharinfo.specialranges;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0xa7b08
movq %rdi, %rbx
cmpb $0x1, 0x3a8(%rdi)
jne 0xa7af9
movq 0x30(%rbx), %rsi
decq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0xa1fd0
movl %eax, %ecx
movq 0x180(%rbx), %rax
addq %rax, %rax
cmpb $-0x2, %cl
jne 0xa7b02
decq %rax
jmp 0xa7b06
movq 0x180(%rbx), %rax
jmp 0xa7b06
orq $0x1, %rax
popq %rbx
retq
movq 0x864a9(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2254d(%rip), %rsi     # 0xca066
leaq 0x447b0(%rip), %rdx     # 0xec2d0
leaq 0x44e26(%rip), %rcx     # 0xec94d
leaq 0x4406c(%rip), %r8      # 0xebb9a
movl $0x1371, %r9d           # imm = 0x1371
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_realspecialranges
GtUword gt_encseq_realspecialranges(const GtEncseq *encseq)
{
  if (encseq->hasmirror) {
    /* check whether central specialranges can be merged */
    if (gt_encseq_get_encoded_char(encseq, encseq->totallength-1,
                               GT_READMODE_FORWARD) == (GtUchar) GT_WILDCARD) {
      return (encseq->specialcharinfo.realspecialranges*2)-1;
    } else {
      return (encseq->specialcharinfo.realspecialranges*2)+1;
    }
  }
  return encseq->specialcharinfo.realspecialranges;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x3a8(%rdi)
jne 0xa7c58
movq 0x30(%rbx), %rsi
decq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0xa1fd0
movl %eax, %ecx
movq 0x188(%rbx), %rax
addq %rax, %rax
cmpb $-0x2, %cl
jne 0xa7c61
decq %rax
jmp 0xa7c65
movq 0x188(%rbx), %rax
jmp 0xa7c65
orq $0x1, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_sizeofSWtable
static uint64_t gt_encseq_sizeofSWtable(GtEncseqAccessType sat,
                                        bool withrangelength,
                                        bool withmappositions,
                                        GtUword totallength,
                                        GtUword items)
{
  if (items == 0)
    return 0;
  switch (sat) {
    case GT_ACCESS_TYPE_UCHARTABLES:
      return SIZEOFSWTABLE(GtUchar, UCHAR_MAX);
    case GT_ACCESS_TYPE_USHORTTABLES:
      return SIZEOFSWTABLE(uint16_t, USHRT_MAX);
    case GT_ACCESS_TYPE_UINT32TABLES:
      return SIZEOFSWTABLE(uint32_t, UINT32_MAX);
    default:
      fprintf(stderr, "gt_encseq_sizeofSWtable(sat=%d) is undefined\n",
              (int) sat);
      exit(GT_EXIT_PROGRAMMING_ERROR);
  }
}

// Assembly:
testq %r8, %r8
je 0xa7e20
movq %rcx, %rax
movl %edx, %r9d
movl %edi, %edx
cmpl $0x6, %edi
je 0xa7e35
cmpl $0x5, %edx
je 0xa7e23
cmpl $0x4, %edx
jne 0xa7e65
movq %r8, %rdi
movl %esi, %ecx
shlq %cl, %rdi
xorl %ecx, %ecx
movl $0xff, %esi
jmp 0xa7e49
xorl %eax, %eax
retq
leaq (%r8,%r8), %rdi
movl %esi, %ecx
shlq %cl, %rdi
xorl %ecx, %ecx
movl $0xffff, %esi           # imm = 0xFFFF
jmp 0xa7e49
leaq (,%r8,4), %rdi
movl %esi, %ecx
shlq %cl, %rdi
xorl %ecx, %ecx
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %edx, %edx
divq %rsi
leaq (%rdi,%rax,8), %rax
shlq $0x3, %r8
testb %r9b, %r9b
cmoveq %rcx, %r8
addq %r8, %rax
addq $0x8, %rax
retq
pushq %rax
movq 0x8614b(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x47b2a(%rip), %rsi     # 0xef9a1
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_GtSpecialcharinfo_check
void gt_GtSpecialcharinfo_check(const GtSpecialcharinfo *specialcharinfo,
                                GtUword numofseparatorpositions)
{
  gt_assert(specialcharinfo->wildcards + numofseparatorpositions ==
            specialcharinfo->specialcharacters);
  gt_assert(specialcharinfo->lengthofspecialprefix <=
            specialcharinfo->specialcharacters);
  gt_assert(specialcharinfo->lengthofwildcardprefix <=
            specialcharinfo->wildcards);
  gt_assert(specialcharinfo->lengthofwildcardprefix <=
            specialcharinfo->lengthofspecialprefix);
  gt_assert(specialcharinfo->lengthofwildcardsuffix <=
            specialcharinfo->lengthofspecialsuffix);
}

// Assembly:
pushq %rax
movq 0x28(%rdi), %rax
addq %rax, %rsi
cmpq (%rdi), %rsi
jne 0xa7ebe
movq 0x18(%rdi), %rcx
cmpq %rsi, %rcx
ja 0xa7eef
movq 0x40(%rdi), %rdx
cmpq %rax, %rdx
ja 0xa7f20
cmpq %rcx, %rdx
ja 0xa7f4e
movq 0x48(%rdi), %rax
cmpq 0x20(%rdi), %rax
ja 0xa7f7c
popq %rax
retq
movq 0x860f3(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x22197(%rip), %rsi     # 0xca066
leaq 0x44b36(%rip), %rdx     # 0xeca0c
leaq 0x44b8a(%rip), %rcx     # 0xeca67
leaq 0x43cb6(%rip), %r8      # 0xebb9a
movl $0x1498, %r9d           # imm = 0x1498
jmp 0xa7fa8
movq 0x860c2(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x22166(%rip), %rsi     # 0xca066
leaq 0x44b7b(%rip), %rdx     # 0xeca82
leaq 0x44b59(%rip), %rcx     # 0xeca67
leaq 0x43c85(%rip), %r8      # 0xebb9a
movl $0x149a, %r9d           # imm = 0x149A
jmp 0xa7fa8
movq 0x86091(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x22135(%rip), %rsi     # 0xca066
leaq 0x44b97(%rip), %rdx     # 0xecacf
leaq 0x44b28(%rip), %rcx     # 0xeca67
leaq 0x43c54(%rip), %r8      # 0xebb9a
movl $0x149c, %r9d           # imm = 0x149C
jmp 0xa7fa8
movq 0x86063(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x22107(%rip), %rsi     # 0xca066
leaq 0x44baf(%rip), %rdx     # 0xecb15
leaq 0x44afa(%rip), %rcx     # 0xeca67
leaq 0x43c26(%rip), %r8      # 0xebb9a
movl $0x149e, %r9d           # imm = 0x149E
jmp 0xa7fa8
movq 0x86035(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x220d9(%rip), %rsi     # 0xca066
leaq 0x44bd3(%rip), %rdx     # 0xecb67
leaq 0x44acc(%rip), %rcx     # 0xeca67
leaq 0x43bf8(%rip), %r8      # 0xebb9a
movl $0x14a0, %r9d           # imm = 0x14A0
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/encseq.c
// Function: gt_getnexttwobitencodingstoppos
GtUword gt_getnexttwobitencodingstoppos(GT_UNUSED bool fwd,
                                        GtEncseqReader *esr)
{
  GtUword rawstoppos;

  if (esr->currentpos == esr->encseq->totallength) {
    return esr->currentpos + (GT_ISDIRREVERSE(esr->originalreadmode) ? 1 : 0);
  }
  rawstoppos = (!GT_ISDIRREVERSE(esr->readmode)
                                      ? fwdgetnexttwobitencodingstoppos
                                      : revgetnexttwobitencodingstoppos) (esr);

  if (GT_ISDIRREVERSE(esr->readmode) != GT_ISDIRREVERSE(esr->originalreadmode))
    rawstoppos = GT_REVERSEPOS(esr->encseq->logicaltotallength, rawstoppos) + 1;

  return rawstoppos;
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
movq (%rsi), %rcx
movq 0x10(%rsi), %rax
cmpq 0x30(%rcx), %rax
jne 0xa80af
movl 0xc(%rbx), %ecx
andl $-0x3, %ecx
xorl %edx, %edx
cmpl $0x1, %ecx
sete %dl
addq %rdx, %rax
jmp 0xa80f8
movl 0x8(%rbx), %eax
andl $-0x3, %eax
cmpl $0x1, %eax
leaq 0xd6(%rip), %rax        # 0xa8195
leaq 0x34(%rip), %rcx        # 0xa80fa
cmoveq %rax, %rcx
movq %rbx, %rdi
callq *%rcx
movl 0x8(%rbx), %ecx
movl 0xc(%rbx), %edx
andl $-0x3, %ecx
cmpl $0x1, %ecx
sete %cl
andl $-0x3, %edx
cmpl $0x1, %edx
setne %dl
xorb %cl, %dl
jne 0xa80f8
movq (%rbx), %rcx
movq 0x38(%rcx), %rcx
subq %rax, %rcx
movq %rcx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/encseq.c
// Function: fwdgetnexttwobitencodingstoppos
static GtUword fwdgetnexttwobitencodingstoppos(GtEncseqReader *esr)
{
  if (gt_encseq_has_specialranges(esr->encseq)) {
    if (esr->encseq->sat == GT_ACCESS_TYPE_EQUALLENGTH) {
      return fwdgetnexttwobitencodingstopposViaequallength(esr->encseq,
                                                           esr->currentpos);
    }
    else {
      GtUword stopposwildcard, stopposssptab;

      if (esr->encseq->has_wildcardranges) {
        stopposwildcard = fwdgetnexttwobitencodingstopposSW(esr,
                                                     SWtable_wildcardrange);
      }
      else {
        stopposwildcard = esr->encseq->totallength;
      }
      if (esr->encseq->numofdbsequences > 1UL) {
        stopposssptab = fwdgetnexttwobitencodingstopposSW(esr,
                                                          SWtable_ssptab);
      }
      else {
        stopposssptab = esr->encseq->totallength;
      }
      return GT_MIN(stopposwildcard, stopposssptab);
    }
  }
  else {
    return esr->encseq->totallength;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq (%rdi), %rbx
cmpb $0x0, 0x3a8(%rbx)
jne 0xa811d
testb $0x1, 0x28(%rbx)
jne 0xa811d
movq 0x30(%rbx), %r14
movq %r14, %rax
jmp 0xa818f
cmpl $0x2, (%rbx)
jne 0xa8154
movq 0x10(%r14), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa228c
testb %al, %al
jne 0xa8118
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa6720
movq 0x1f0(%rbx), %rcx
leaq 0x1(%rcx), %r14
imulq %rax, %r14
addq %rcx, %r14
jmp 0xa8118
cmpb $0x1, 0x29(%rbx)
jne 0xa816c
movq %r14, %rdi
xorl %esi, %esi
callq 0xb4702
movq %rax, %r15
movq (%r14), %rbx
jmp 0xa8170
movq 0x30(%rbx), %r15
cmpq $0x2, 0x40(%rbx)
jb 0xa8184
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0xb4702
jmp 0xa8188
movq 0x30(%rbx), %rax
cmpq %rax, %r15
cmovbq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/encseq.c
// Function: revgetnexttwobitencodingstoppos
static GtUword revgetnexttwobitencodingstoppos(GtEncseqReader *esr)
{
  if (gt_encseq_has_specialranges(esr->encseq)) {
    if (esr->encseq->sat == GT_ACCESS_TYPE_EQUALLENGTH) {
      return revgetnexttwobitencodingstopposViaequallength(esr->encseq,
                                                           esr->currentpos);
    }
    else {
      GtUword stopposwildcard, stopposssptab;

      if (esr->encseq->has_wildcardranges) {
        stopposwildcard = revgetnexttwobitencodingstopposSW(esr,
                                                        SWtable_wildcardrange);
      }
      else {
        stopposwildcard = 0;
      }
      if (esr->encseq->numofdbsequences > 1UL) {
        stopposssptab = revgetnexttwobitencodingstopposSW(esr,
                                                          SWtable_ssptab);
      }
      else {
        stopposssptab = 0;
      }
      return GT_MAX(stopposwildcard, stopposssptab);
    }
  }
  else {
    return 0;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq (%rdi), %rbx
cmpb $0x0, 0x3a8(%rbx)
jne 0xa81b7
testb $0x1, 0x28(%rbx)
jne 0xa81b7
xorl %r14d, %r14d
movq %r14, %rax
jmp 0xa8227
cmpl $0x2, (%rbx)
jne 0xa81d4
movq 0x10(%r14), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa228c
testb %al, %al
je 0xa81ec
incq %r14
jmp 0xa81b2
cmpb $0x1, 0x29(%rbx)
jne 0xa8207
movq %r14, %rdi
xorl %esi, %esi
callq 0xb48e1
movq %rax, %r15
movq (%r14), %rbx
jmp 0xa820a
movq %rbx, %rdi
movq %r14, %rsi
callq 0xa6720
movq 0x1f0(%rbx), %r14
incq %r14
imulq %rax, %r14
jmp 0xa81b2
xorl %r15d, %r15d
cmpq $0x2, 0x40(%rbx)
jb 0xa821e
pushq $0x1
popq %rsi
movq %r14, %rdi
callq 0xb48e1
jmp 0xa8220
xorl %eax, %eax
cmpq %rax, %r15
cmovaq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_extract2bitencwithtwobitencodingstoppos
GtUword gt_encseq_extract2bitencwithtwobitencodingstoppos(
                                         GtEndofTwobitencoding *ptbe,
                                         GtEncseqReader *esr,
                                         const GtEncseq *encseq,
                                         GtReadmode readmode,
                                         GtUword pos)
{
  GtUword twobitencodingstoppos, ret;
  bool fwd;

  gt_assert(pos < encseq->logicaltotallength);
  fwd = GT_ISDIRREVERSE(readmode) ? false : true;
  gt_encseq_reader_reinit_with_readmode(esr, encseq, readmode, pos);
  if (gt_encseq_has_twobitencoding_stoppos_support(encseq)) {
    twobitencodingstoppos = gt_getnexttwobitencodingstoppos(fwd, esr);
  }
  else {
    twobitencodingstoppos = GT_TWOBITENCODINGSTOPPOSUNDEF(encseq);
  }
  if (GT_ISDIRREVERSE(readmode)) {
    pos = GT_REVERSEPOS(encseq->logicaltotallength, pos);
  }
  ret = gt_encseq_extract2bitenc(ptbe, encseq, fwd, pos, twobitencodingstoppos);

  /* XXX: may be less efficient, but just assigning ret to esr->currentpos may
     not reflect the real reading direction! */
  if (ret < encseq->logicaltotallength) {
    gt_encseq_reader_reinit_with_readmode(esr, encseq, readmode, ret);
  }
  return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpq %r8, 0x38(%rdx)
jbe 0xa82da
movq %r8, %r12
movl %ecx, %ebx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r13
movl %ecx, %ebp
andl $-0x3, %ebp
movq %rsi, %rdi
movq %rdx, %rsi
movl %ecx, %edx
movq %r8, %rcx
callq 0xa3924
movq %r14, %rdi
callq 0xa3eb4
testb %al, %al
je 0xa8280
xorl %edi, %edi
movq %r15, %rsi
callq 0xa808b
movq %rax, %r8
jmp 0xa828d
movzbl 0x3a8(%r14), %eax
movq 0x30(%r14,%rax,8), %r8
cmpl $0x1, %ebp
jne 0xa8299
notq %r12
addq 0x38(%r14), %r12
xorl %edx, %edx
cmpl $0x1, %ebp
setne %dl
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rcx
callq 0xa8312
movq %rax, %r12
cmpq 0x38(%r14), %rax
jae 0xa82c8
movq %r15, %rdi
movq %r14, %rsi
movl %ebx, %edx
movq %r12, %rcx
callq 0xa3924
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x85cd7(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x21d7b(%rip), %rsi     # 0xca066
leaq 0x43912(%rip), %rdx     # 0xebc04
leaq 0x448f0(%rip), %rcx     # 0xecbe9
leaq 0x4389a(%rip), %r8      # 0xebb9a
movl $0x185f, %r9d           # imm = 0x185F
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/encseq.c
// Function: requiredUIntBits
static inline int requiredUIntBits(GtBitsequence v)
{
  int r;
  static const int MultiplyDeBruijnBitPosition[64] = {
    1, 2, 3, 57, 4, 33, 58, 47, 30, 5, 21, 34, 8, 59, 12, 48,
    63, 31, 19, 6, 17, 22, 35, 24, 54, 9, 60, 37, 26, 13, 49, 40,
    64, 56, 32, 46, 29, 20, 7, 11, 62, 18, 16, 23, 53, 36, 25, 39,
    55, 45, 28, 10, 61, 15, 52, 38, 44, 27, 14, 51, 43, 50, 42, 41
  };
  v |= v >> 1; /* first round down to power of 2 */
  v |= v >> 2;
  v |= v >> 4;
  v |= v >> 8;
  v |= v >> 16;
  v |= v >> 32;
  v = (v >> 1) + 1;
  r = MultiplyDeBruijnBitPosition[(v * (GtBitsequence) 0x26752B916FC7B0DULL)
                                  >> 58];
  return r;
}

// Assembly:
movq %rdi, %rax
shrq %rax
orq %rdi, %rax
movq %rax, %rcx
shrq $0x2, %rcx
orq %rax, %rcx
movq %rcx, %rax
shrq $0x4, %rax
orq %rcx, %rax
movq %rax, %rcx
shrq $0x8, %rcx
orq %rax, %rcx
movq %rcx, %rax
shrq $0x10, %rax
orq %rcx, %rax
movq %rax, %rcx
shrq $0x21, %rcx
shrq %rax
orq %rcx, %rax
movabsq $0x26752b916fc7b0d, %rcx # imm = 0x26752B916FC7B0D
imulq %rcx, %rax
addq %rcx, %rax
shrq $0x3a, %rax
leaq 0x4320b(%rip), %rcx     # 0xeba60
movl (%rcx,%rax,4), %eax
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/encseq.c
// Function: prefixofdifferenttwobitencodings
static int prefixofdifferenttwobitencodings(bool complement,
                                            GtCommonunits *commonunits,
                                            GtTwobitencoding tbe1,
                                            GtTwobitencoding tbe2)
{
  gt_assert((tbe1 ^ tbe2) > 0);
  commonunits->common = (unsigned int) GT_DIV2(GT_MULT2(GT_UNITSIN2BITENC) -
                                               requiredUIntBits(tbe1 ^ tbe2));
  gt_assert(commonunits->common < (unsigned int) GT_UNITSIN2BITENC);
  commonunits->leftspecial = commonunits->rightspecial = false;
  if (complement) {
    return GT_COMPLEMENTBASE(EXTRACTENCODEDCHARSCALARFROMLEFT(tbe1,
                                                   commonunits->common)) <
           GT_COMPLEMENTBASE(EXTRACTENCODEDCHARSCALARFROMLEFT(tbe2,
                                                   commonunits->common))
           ? -1 : 1;
  }
  return tbe1 < tbe2 ? -1 : 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpq %rcx, %rdx
je 0xa88f0
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %ebp
movq %rcx, %rdi
xorq %rdx, %rdi
callq 0xa87fb
pushq $0x40
popq %rdx
subl %eax, %edx
movl %edx, %eax
sarl %eax
movl %eax, (%r15)
cmpl $0x20, %eax
jae 0xa891e
andw $0x0, 0x4(%r15)
testb %bpl, %bpl
je 0xa88d7
andb $-0x2, %dl
movb $0x3e, %cl
subb %dl, %cl
shrq %cl, %r14
notl %r14d
andl $0x3, %r14d
shrq %cl, %rbx
notl %ebx
andl $0x3, %ebx
cmpl %ebx, %r14d
jmp 0xa88da
cmpq %rbx, %r14
setb %al
movzbl %al, %eax
negl %eax
orl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x856c1(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x21765(%rip), %rsi     # 0xca066
leaq 0x443b3(%rip), %rdx     # 0xeccbb
leaq 0x472ec(%rip), %rcx     # 0xefbfb
leaq 0x43284(%rip), %r8      # 0xebb9a
movl $0x18ff, %r9d           # imm = 0x18FF
jmp 0xa894a
movq 0x85693(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x21737(%rip), %rsi     # 0xca066
leaq 0x472e6(%rip), %rdx     # 0xefc1c
leaq 0x472be(%rip), %rcx     # 0xefbfb
leaq 0x43256(%rip), %r8      # 0xebb9a
movl $0x1902, %r9d           # imm = 0x1902
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/encseq.c
// Function: suffixofdifferenttwobitencodings
static int suffixofdifferenttwobitencodings(bool complement,
                                            GtCommonunits *commonunits,
                                            GtTwobitencoding tbe1,
                                            GtTwobitencoding tbe2)
{
  unsigned int tmplcsvalue = 0;

  gt_assert((tbe1 ^ tbe2) > 0);
  tmplcsvalue = GT_DIV2(numberoftrailingzeros(tbe1 ^ tbe2));
  gt_assert(tmplcsvalue < (unsigned int) GT_UNITSIN2BITENC);
  gt_assert(commonunits != NULL);
  commonunits->common = tmplcsvalue;
  commonunits->leftspecial = commonunits->rightspecial = false;
  if (complement) {
    return GT_COMPLEMENTBASE(EXTRACTENCODEDCHARSCALARFROMRIGHT(tbe1,
                                                               tmplcsvalue)) <
           GT_COMPLEMENTBASE(EXTRACTENCODEDCHARSCALARFROMRIGHT(tbe2,
                                                               tmplcsvalue))
           ? -1 : 1;
  }
  return EXTRACTENCODEDCHARSCALARFROMRIGHT(tbe1, tmplcsvalue) <
         EXTRACTENCODEDCHARSCALARFROMRIGHT(tbe2, tmplcsvalue)
         ? -1 : 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpq %rcx, %rdx
je 0xa89cc
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %ebp
movq %rcx, %rdi
xorq %rdx, %rdi
callq 0xb4e2b
cmpl $0x40, %eax
jae 0xa89fa
testq %r15, %r15
je 0xa8a28
movl %eax, %ecx
shrl %eax
movl %eax, (%r15)
andw $0x0, 0x4(%r15)
andl $0x3e, %ecx
shrq %cl, %r14
andl $0x3, %r14d
testb %bpl, %bpl
je 0xa89ad
xorl $0x3, %r14d
shrq %cl, %rbx
notl %ebx
jmp 0xa89b0
shrq %cl, %rbx
andl $0x3, %ebx
cmpl %ebx, %r14d
setb %al
movzbl %al, %eax
negl %eax
orl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x855e5(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x21689(%rip), %rsi     # 0xca066
leaq 0x442d7(%rip), %rdx     # 0xeccbb
leaq 0x47268(%rip), %rcx     # 0xefc53
leaq 0x431a8(%rip), %r8      # 0xebb9a
movl $0x191d, %r9d           # imm = 0x191D
jmp 0xa8a54
movq 0x855b7(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2165b(%rip), %rsi     # 0xca066
leaq 0x47262(%rip), %rdx     # 0xefc74
leaq 0x4723a(%rip), %rcx     # 0xefc53
leaq 0x4317a(%rip), %r8      # 0xebb9a
movl $0x191f, %r9d           # imm = 0x191F
jmp 0xa8a54
movq 0x85589(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2162d(%rip), %rsi     # 0xca066
leaq 0x442f2(%rip), %rdx     # 0xecd32
leaq 0x4720c(%rip), %rcx     # 0xefc53
leaq 0x4314c(%rip), %r8      # 0xebb9a
movl $0x1920, %r9d           # imm = 0x1920
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/encseq.c
// Function: gt_Viatwobitkeyvalues_reinit_without_stoppos
static void gt_Viatwobitkeyvalues_reinit_without_stoppos(
                                         GtViatwobitkeyvalues *vtk,
                                         const GtEncseq *encseq,
                                         GtReadmode readmode,
                                         GtEncseqReader *esr,
                                         GtUword pos,
                                         GtUword depth,
                                         GtUword maxdepth)
{
  if (maxdepth == 0) {
    vtk->endpos = encseq->logicaltotallength;
  }
  else {
    gt_assert(depth < maxdepth);
    vtk->endpos = pos + maxdepth;
    if (vtk->endpos > encseq->logicaltotallength) {
      vtk->endpos = encseq->logicaltotallength;
    }
  }
  vtk->pos = pos + depth;
  /* to have a defined value: */
  vtk->twobitcurrentpos = encseq->logicaltotallength;
  /* to have a defined value: */
  vtk->twobitencodingstoppos = GT_TWOBITENCODINGSTOPPOSUNDEF(encseq);
  if (vtk->pos < vtk->endpos) {
    bool fwd = GT_ISDIRREVERSE(readmode) ? false : true;

    if (esr != NULL && gt_encseq_has_twobitencoding_stoppos_support(encseq)) {
      gt_encseq_reader_reinit_with_readmode(esr, encseq, readmode, vtk->pos);
      vtk->twobitencodingstoppos = gt_getnexttwobitencodingstoppos(fwd, esr);
    }
    vtk->twobitcurrentpos
      = fwd ? vtk->pos : GT_REVERSEPOS(encseq->logicaltotallength, vtk->pos);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x30(%rsp), %rax
testq %rax, %rax
je 0xa8da8
cmpq %rax, %r9
jae 0xa8e2b
addq %r8, %rax
movq 0x38(%r14), %rcx
cmpq %rcx, %rax
cmovaeq %rcx, %rax
movq %rax, 0x10(%rbx)
movq 0x38(%r14), %rcx
jmp 0xa8db3
movq 0x38(%r14), %rax
movq %rax, 0x10(%rbx)
movq %rax, %rcx
addq %r8, %r9
movq %r9, (%rbx)
movq %rcx, 0x8(%rbx)
movzbl 0x3a8(%r14), %ecx
movq 0x30(%r14,%rcx,8), %rcx
movq %rcx, 0x18(%rbx)
cmpq %rax, %r9
jae 0xa8e22
movl %ebp, %r12d
andl $-0x3, %r12d
testq %r15, %r15
je 0xa8e09
movq %r14, %rdi
callq 0xa3eb4
testb %al, %al
je 0xa8e09
movq (%rbx), %rcx
movq %r15, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0xa3924
xorl %edi, %edi
movq %r15, %rsi
callq 0xa808b
movq %rax, 0x18(%rbx)
cmpl $0x1, %r12d
jne 0xa8e1b
movq (%rbx), %rax
notq %rax
addq 0x38(%r14), %rax
jmp 0xa8e1e
movq (%rbx), %rax
movq %rax, 0x8(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x85186(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x2122a(%rip), %rsi     # 0xca066
leaq 0x46e60(%rip), %rdx     # 0xefca3
leaq 0x46e6a(%rip), %rcx     # 0xefcb4
leaq 0x42d49(%rip), %r8      # 0xebb9a
movl $0x19b1, %r9d           # imm = 0x19B1
xorl %eax, %eax
callq 0xb8c0
callq 0xb300
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_sequence_mapoffset
size_t gt_encseq_sequence_mapoffset(const GtEncseq *encseq)
{
  gt_assert(encseq != NULL && encseq->sat != GT_ACCESS_TYPE_UNDEFINED);
  if (gt_encseq_has_twobitencoding(encseq)) {
    return (size_t) ((unsigned char *) encseq->twobitencoding -
                     (unsigned char *) encseq->mappedptr);
  }
  else {
    if (encseq->sat == GT_ACCESS_TYPE_DIRECTACCESS) {
      return (size_t) ((unsigned char *) encseq->plainseq -
                       (unsigned char *) encseq->mappedptr);
    }
    else {
      return (size_t) ((unsigned char *) encseq->bitpackarray -
                       (unsigned char *) encseq->mappedptr);
    }
  }
}

// Assembly:
testq %rdi, %rdi
je 0xa914f
movl (%rdi), %eax
cmpl $0x7, %eax
je 0xa914f
cmpl $0x1, %eax
ja 0xa9138
cmpb $0x0, 0x3a9(%rdi)
jne 0xa9138
movq 0x10(%rdi), %rcx
testl %eax, %eax
je 0xa9144
movq 0x2a0(%rdi), %rax
jmp 0xa914b
movq 0x280(%rdi), %rax
subq 0x10(%rdi), %rax
retq
movq 0x290(%rdi), %rax
subq %rcx, %rax
retq
pushq %rax
movq 0x84e61(%rip), %rax     # 0x12dfb8
movq (%rax), %rdi
leaq 0x20f05(%rip), %rsi     # 0xca066
leaq 0x42fd2(%rip), %rdx     # 0xec13a
leaq 0x43d15(%rip), %rcx     # 0xece84
leaq 0x42a24(%rip), %r8      # 0xebb9a
movl $0x1a31, %r9d           # imm = 0x1A31
xorl %eax, %eax
callq 0xb8c0
callq 0xb300