LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/encseq.c
// Function: revgetnexttwobitencodingstopposSW
static GtUword revgetnexttwobitencodingstopposSW(GtEncseqReader *esr,
                                      KindofSWtable kindsw)
{
  if (gt_encseq_has_specialranges(esr->encseq)) {
    GtEncseqAccessType sat = (kindsw == SWtable_ssptab)
                                ? esr->encseq->satsep
                                : esr->encseq->sat;
    switch (sat) {
      case GT_ACCESS_TYPE_UCHARTABLES:
        return revgetnexttwobitencodingstopposSW_uchar(esr, kindsw);
      case GT_ACCESS_TYPE_USHORTTABLES:
        return revgetnexttwobitencodingstopposSW_uint16(esr, kindsw);
      case GT_ACCESS_TYPE_UINT32TABLES:
        return revgetnexttwobitencodingstopposSW_uint32(esr, kindsw);
      default:
       fprintf(stderr, "%s(%d) undefined\n", __func__, (int) sat);
       exit(GT_EXIT_PROGRAMMING_ERROR);
    }
  }
  else {
    return 0;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movq (%rdi), %rax
cmpb $0x1, 0x3a8(%rax)
jne 0xce7a0
cmpb $0x1, 0x28(%rax)
jne 0xce7aa
cmpb $0x1, 0x28(%rax)
jne 0xce8fb
xorl %ecx, %ecx
cmpl $0x1, %ebx
sete %cl
movl (%rax,%rcx,4), %edi
cmpl $0x6, %edi
je 0xce8a3
cmpl $0x5, %edi
je 0xce83f
cmpl $0x4, %edi
jne 0xce90b
xorl %ecx, %ecx
testl %ebx, %ebx
setne %dl
testq %rax, %rax
je 0xce91a
movl 0x8(%r14), %eax
orl $0x2, %eax
cmpl $0x3, %eax
jne 0xce924
movb %dl, %cl
movq 0x28(%r14,%rcx,8), %r15
cmpb $0x1, 0x3a(%r15)
jne 0xce8fb
movq 0x10(%r14), %rcx
movq 0x20(%r15), %rax
cmpq %rax, %rcx
jae 0xce8fd
cmpq 0x18(%r15), %rcx
jae 0xce903
cmpb $0x1, 0x39(%r15)
jne 0xce8fb
movq %r14, %rdi
movl %ebx, %esi
callq 0xcdd1a
cmpb $0x0, 0x3a(%r15)
movl $0x0, %eax
jne 0xce7fe
jmp 0xce8fd
xorl %ecx, %ecx
testl %ebx, %ebx
setne %dl
testq %rax, %rax
je 0xce910
movl 0x8(%r14), %eax
orl $0x2, %eax
cmpl $0x3, %eax
jne 0xce91f
movb %dl, %cl
movq 0x28(%r14,%rcx,8), %r15
cmpb $0x1, 0x3a(%r15)
jne 0xce8fb
movq 0x10(%r14), %rcx
movq 0x20(%r15), %rax
cmpq %rax, %rcx
jae 0xce8fd
cmpq 0x18(%r15), %rcx
jae 0xce903
cmpb $0x1, 0x39(%r15)
jne 0xce8fb
movq %r14, %rdi
movl %ebx, %esi
callq 0xcded7
cmpb $0x0, 0x3a(%r15)
movl $0x0, %eax
jne 0xce871
jmp 0xce8fd
xorl %ecx, %ecx
testl %ebx, %ebx
setne %dl
testq %rax, %rax
je 0xce915
movl 0x8(%r14), %eax
orl $0x2, %eax
cmpl $0x3, %eax
jne 0xce929
movb %dl, %cl
movq 0x28(%r14,%rcx,8), %r15
cmpb $0x1, 0x3a(%r15)
jne 0xce8fb
movq 0x10(%r14), %rcx
movq 0x20(%r15), %rax
cmpq %rax, %rcx
jae 0xce8fd
cmpq 0x18(%r15), %rcx
jae 0xce903
cmpb $0x1, 0x39(%r15)
jne 0xce8fb
movq %r14, %rdi
movl %ebx, %esi
callq 0xce094
cmpb $0x0, 0x3a(%r15)
movl $0x0, %eax
jne 0xce8c9
jmp 0xce8fd
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
incq %rcx
movq %rcx, %rax
jmp 0xce8fd
callq 0x2f04f
callq 0x2efa4
callq 0x2ef32
callq 0x2f016
callq 0x2ef6b
callq 0x2efdd
callq 0x2eef9
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/encseq.c
// Function: fwdextract2bitenc
static GtUword fwdextract2bitenc(GtEndofTwobitencoding *ptbe,
                                       const GtEncseq *encseq,
                                       GtUword currentpos,
                                       GtUword twobitencodingstoppos)
{
  gt_assert(encseq != NULL && currentpos < encseq->totallength);
  if (encseq->sat != GT_ACCESS_TYPE_BITACCESS) {
    if (currentpos < twobitencodingstoppos) {
      if (twobitencodingstoppos - currentpos >
          (GtUword) GT_UNITSIN2BITENC) {
        ptbe->unitsnotspecial = (unsigned int) GT_UNITSIN2BITENC;
      }
      else {
        ptbe->unitsnotspecial
          = (unsigned int) (twobitencodingstoppos - currentpos);
      }
      ptbe->tbe = calctbeforward(encseq->twobitencoding, currentpos);
    }
    else {
      ptbe->unitsnotspecial = 0;
      ptbe->tbe = 0;
    }
  }
  else {
    if (gt_encseq_has_specialranges(encseq)) {
      GtBitsequence spbits;

      spbits = fwdextractspecialbits(encseq->specialbits, currentpos);
      ptbe->unitsnotspecial
        = fwdbitaccessunitsnotspecial(spbits, encseq, currentpos);
    }
    else {
      ptbe->unitsnotspecial
        = fwdbitaccessunitsnotspecial0(encseq, currentpos);
    }
    if (ptbe->unitsnotspecial == 0)
      ptbe->tbe = 0;
    else
      ptbe->tbe = calctbeforward(encseq->twobitencoding, currentpos);
  }
  return currentpos + (GtUword) GT_UNITSIN2BITENC;
}

// Assembly:
testq %rsi, %rsi
je 0xcea7f
movq 0x30(%rsi), %rax
subq %rdx, %rax
jbe 0xcea7f
cmpl $0x3, (%rsi)
jne 0xce984
cmpb $0x1, 0x3a8(%rsi)
jne 0xce958
cmpb $0x1, 0x28(%rsi)
jne 0xce962
cmpb $0x1, 0x28(%rsi)
jne 0xcea29
movq 0x2b0(%rsi), %r9
movl %edx, %ecx
andl $0x3f, %ecx
movq %rdx, %r10
shrq $0x6, %r10
movq (%r9,%r10,8), %r8
cmpq $0x20, %rcx
ja 0xce9aa
shlq %cl, %r8
jmp 0xce9b5
subq %rdx, %rcx
jbe 0xce99e
cmpq $0x20, %rcx
movl $0x20, %eax
cmovbq %rcx, %rax
movl %eax, 0x8(%rdi)
jmp 0xcea3d
movl $0x0, 0x8(%rdi)
jmp 0xcea65
movq 0x8(%r9,%r10,8), %r9
movl %edx, %ecx
shldq %cl, %r9, %r8
movabsq $-0x100000000, %rcx     # imm = 0xFFFFFFFF00000000
andq %r8, %rcx
je 0xcea29
movq %rcx, %rax
shrq %rax
orq %rcx, %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 0x33ed2(%rip), %r8      # 0x1028f0
movl $0x40, %ecx
subl (%r8,%rax,4), %ecx
jmp 0xcea36
cmpq $0x20, %rax
movl $0x20, %ecx
cmovbq %rax, %rcx
movl %ecx, 0x8(%rdi)
testl %ecx, %ecx
je 0xcea65
movq 0x280(%rsi), %rsi
movq %rdx, %rcx
andq $0x1f, %rcx
je 0xcea69
movq %rdx, %r8
shrq $0x5, %r8
addl %ecx, %ecx
movq (%rsi,%r8,8), %rax
movq 0x8(%rsi,%r8,8), %rsi
shldq %cl, %rsi, %rax
jmp 0xcea74
xorl %eax, %eax
jmp 0xcea74
movq %rdx, %rax
shrq $0x2, %rax
movq (%rsi,%rax), %rax
movq %rax, (%rdi)
addq $0x20, %rdx
movq %rdx, %rax
retq
pushq %rax
callq 0x2f079
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/intbits.h
// Function: gt_bitsequence_tostring
static inline void gt_bitsequence_tostring(char *buffer,
                                                        GtBitsequence bs)
{
  unsigned int i;
  GtBitsequence mask;

  for (i=0, mask = (GtBitsequence) GT_FIRSTBIT;
       i < (unsigned int) GT_INTWORDSIZE;
       i++, mask >>= 1) {
    buffer[i] = (bs & mask) ? '1' : '0';
  }
  buffer[GT_INTWORDSIZE] = '\0';
}

// Assembly:
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
xorl %ecx, %ecx
testq %rsi, %rax
sete %dl
xorb $0x31, %dl
movb %dl, (%rdi,%rcx)
incq %rcx
shrq %rax
cmpq $0x40, %rcx
jne 0xcebe7
movb $0x0, 0x40(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/encseq.c
// Function: derefcharboundaries
static GtUword derefcharboundaries(const GtEncseq *encseq,
                                         bool fwd,
                                         bool complement,
                                         GtUword start,
                                         GtUword maxoffset,
                                         GtUword currentoffset,
                                         GtUword totallength)
{
  if (fwd) {
    if (start + currentoffset == totallength) {
      return totallength + GT_COMPAREOFFSET;
    }
    start += currentoffset;
  }
  else {
    if (start < currentoffset) {
      return currentoffset - start + (GtUword) GT_COMPAREOFFSET;
    }
    start -= currentoffset;
  }
  if (currentoffset <= maxoffset) {
    GtUchar cc;
    cc = gt_encseq_get_encoded_char(encseq, start, GT_READMODE_FORWARD);
    if (GT_ISSPECIAL(cc)) {
      return start + GT_COMPAREOFFSET;
    }
    if (complement) {
      cc = GT_COMPLEMENTBASE(cc);
    }
    return (GtUword) cc;
  }
  return start + GT_COMPAREOFFSET;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
testl %esi, %esi
je 0xcf044
movq 0x20(%rsp), %rax
addq %r9, %rcx
movq %rcx, %r14
cmpq %rax, %rcx
jne 0xcf05b
addq $0x100, %rax            # imm = 0x100
jmp 0xcf095
movq %rcx, %r14
subq %r9, %r14
jae 0xcf05b
subq %rcx, %r9
addq $0x100, %r9             # imm = 0x100
movq %r9, %rax
jmp 0xcf095
cmpq %r8, %r9
jbe 0xcf06c
addq $0x100, %r14            # imm = 0x100
movq %r14, %rax
jmp 0xcf095
movq %r14, %rsi
xorl %edx, %edx
callq 0xbef7c
addq $0x100, %r14            # imm = 0x100
movb $0x3, %cl
subb %al, %cl
movzbl %al, %eax
movzbl %cl, %ecx
testb %bl, %bl
cmovel %eax, %ecx
cmpb $-0x2, %al
movzbl %cl, %eax
cmovaeq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/encseq.c
// Function: runscanatpostrial
static void runscanatpostrial(const GtEncseq *encseq,
                              GtEncseqReader *esr,
                              GtReadmode readmode, GtUword startpos)
{
  GtUword pos, totallength;
  GtUchar ccra, ccsr;

  totallength = encseq->logicaltotallength;
  gt_encseq_reader_reinit_with_readmode(esr, encseq, readmode, startpos);
  printf("runscanatpostrial with startpos "GT_WU"\n", startpos);
  for (pos=startpos; pos < totallength; pos++) {
    /* Random access */
    ccra = gt_encseq_get_encoded_char(encseq, pos, readmode);
    ccsr = gt_encseq_reader_next_encoded_char(esr);
    if (ccra != ccsr) {
      fprintf(stderr, "startpos = " GT_WU
                     " access=%s, mode=%s: position="GT_WU
                     ": random access (correct) = %u != %u = "
                     " sequential read (wrong)\n",
                     startpos,
                     gt_encseq_accessname(encseq),
                     gt_readmode_show(readmode),
                     pos,
                     (unsigned int) ccra,
                     (unsigned int) ccsr);
      exit(GT_EXIT_PROGRAMMING_ERROR);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movl %edx, %ebp
movq %rsi, %r12
movq %rdi, %r14
movq 0x38(%rdi), %rbx
movq %rsi, %rdi
movq %r14, %rsi
callq 0xc0212
leaq 0x37e18(%rip), %rdi     # 0x106ee1
movq %r15, %rsi
xorl %eax, %eax
callq 0xb070
movq %r15, (%rsp)
cmpq %r15, %rbx
jbe 0xcf105
movq (%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0xbef7c
movl %eax, %r13d
movq %r12, %rdi
callq 0xbf542
cmpb %al, %r13b
jne 0xcf114
incq %r15
cmpq %r15, %rbx
jne 0xcf0e0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movzbl %al, %ebx
movzbl %r13b, %r13d
movq 0x81e9e(%rip), %rax     # 0x150fc0
movq (%rax), %r12
movq %r14, %rdi
callq 0xc068c
movq %rax, %r14
movl %ebp, %edi
callq 0xd773c
leaq 0x37dc8(%rip), %rsi     # 0x106f06
movq %r12, %rdi
movq (%rsp), %rdx
movq %r14, %rcx
movq %rax, %r8
movq %r15, %r9
xorl %eax, %eax
pushq %rbx
pushq %r13
callq 0xb8d0
addq $0x10, %rsp
movl $0x2, %edi
callq 0xb7b0
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/encseq.c
// Function: updatesumranges
static void updatesumranges(GtUword key, GtUint64 value,
                            void *data)
{
  GtUword distvalue;
  Updatesumrangeinfo *updatesumrangeinfo = (Updatesumrangeinfo *) data;

  gt_assert(value <= (GtUint64) ULONG_MAX);
  distvalue = (GtUword) value;
  updatesumrangeinfo->ranges_uint8_t
     += currentspecialrangevalue(key, distvalue, (GtUword) UCHAR_MAX);
  updatesumrangeinfo->ranges_uint16_t
     += currentspecialrangevalue(key, distvalue, (GtUword) USHRT_MAX);
  updatesumrangeinfo->ranges_uint32_t
     += currentspecialrangevalue(key, distvalue, (GtUword) UINT32_MAX);
  updatesumrangeinfo->realranges += distvalue;
  gt_logger_log(updatesumrangeinfo->logger,
                "%sranges of length " GT_WU "=" GT_WU,
                updatesumrangeinfo->kind, key, distvalue);
}

// Assembly:
movq %rsi, %r8
movq %rdi, %rcx
movq %rsi, %rax
cmpq $0x101, %rdi            # imm = 0x101
jb 0xcf18a
movq %rcx, %rax
shrq $0x8, %rax
testb %cl, %cl
je 0xcf186
incq %rax
imulq %r8, %rax
addq %rax, 0x8(%rdx)
movq %r8, %rax
cmpq $0x10001, %rcx          # imm = 0x10001
jb 0xcf1ad
movq %rcx, %rax
shrq $0x10, %rax
testw %cx, %cx
je 0xcf1a9
incq %rax
imulq %r8, %rax
addq %rax, 0x10(%rdx)
leaq -0x1(%rcx), %rax
shrq $0x20, %rax
jne 0xcf1e8
movdqu 0x18(%rdx), %xmm0
movq %r8, %xmm1
pshufd $0x44, %xmm1, %xmm1     # xmm1 = xmm1[0,1,0,1]
paddq %xmm0, %xmm1
movdqu %xmm1, 0x18(%rdx)
movq (%rdx), %rdi
movq 0x28(%rdx), %rdx
leaq 0x3810e(%rip), %rsi     # 0x1072ef
xorl %eax, %eax
jmp 0x35c9e
pushq %rax
callq 0x2f15d
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/encseq.c
// Function: determineleastprobablecharacter
static unsigned int determineleastprobablecharacter(const GtAlphabet *alpha,
                                                    const GtUword
                                                    *characterdistribution)
{
  unsigned int idx, minidx;
  GtUword mindist;

  gt_assert(gt_alphabet_num_of_chars(alpha) > 0);
  mindist = characterdistribution[0];
  minidx = 0;
  for (idx=1U; idx<gt_alphabet_num_of_chars(alpha); idx++) {
    if (characterdistribution[idx] < mindist) {
      mindist = characterdistribution[idx];
      minidx = idx;
    }
  }
  return minidx;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0xb96b7
testl %eax, %eax
je 0xcf24b
movq (%rbx), %r15
movq %r14, %rdi
callq 0xb96b7
xorl %ebp, %ebp
cmpl $0x2, %eax
jb 0xcf240
xorl %ebp, %ebp
movl $0x1, %r12d
movq (%rbx,%r12,8), %rax
cmpq %r15, %rax
cmovbl %r12d, %ebp
cmovbq %rax, %r15
incq %r12
movq %r14, %rdi
callq 0xb96b7
movl %eax, %eax
cmpq %rax, %r12
jb 0xcf21f
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x2f196
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/encseq.c
// Function: gt_encseq_size_of_exceptiontablemap
static size_t gt_encseq_size_of_exceptiontablemap(GtEncseq *encseq)
{
  GtUword sizeoistab;
  unsigned int bitsforsubalpha;

  sizeoistab = CALLCASTFUNC(uint64_t, unsigned_long,   /* exceptiontables */
                            gt_encseq_sizeofSWtable(encseq->oissat,
                                true,
                                true,
                                encseq->totallength,
                                encseq->specialcharinfo.realexceptionranges));
  sizeoistab += UCHAR_MAX * sizeof (GtUword);    /* classstartpositions */
  sizeoistab += encseq->numofallchars * sizeof (char); /* allchars */
  sizeoistab += UCHAR_MAX * sizeof (char);             /* maxchars */
  sizeoistab += UCHAR_MAX * sizeof (unsigned char);    /* subsymbolmap */
  bitsforsubalpha = gt_determinebitspervalue((GtUword)
                                             encseq->maxsubalphasize-1);
  sizeoistab += sizeofbitarray(bitsforsubalpha,
                              (BitOffset) encseq->
                                          specialcharinfo.exceptioncharacters);
/* exceptions */
  return (size_t) sizeoistab;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x388(%rdi), %edi
movq 0x30(%rbx), %rcx
movq 0x1e0(%rbx), %r8
movl $0x1, %esi
movl $0x1, %edx
callq 0xc3b39
movq %rax, %r14
movzbl 0x360(%rbx), %edi
decq %rdi
addq 0x340(%rbx), %r14
callq 0x7a294
movl %eax, %ecx
imulq 0x1d0(%rbx), %rcx
movq %rcx, %rax
shrq $0x3, %rax
addq %r14, %rax
andl $0x7, %ecx
cmpq $0x1, %rcx
sbbq $-0x1, %rax
addq $0x9f6, %rax            # imm = 0x9F6
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/encseq.c
// Function: containsspecialViadirectaccess
static bool containsspecialViadirectaccess(const GtEncseq *encseq,
                                           GtReadmode readmode,
                                           GT_UNUSED GtEncseqReader *esr,
                                           GtUword startpos,
                                           GtUword len)
{
  GtUword pos;

  gt_assert(encseq != NULL);
  if (!GT_ISDIRREVERSE(readmode)) {
    for (pos = startpos; pos < startpos + len; pos++) {
      if (GT_ISSPECIAL(encseq->plainseq[pos]))
        return true;
    }
  }
  else {
    gt_assert(startpos < encseq->totallength);
    startpos = GT_REVERSEPOS(encseq->totallength, startpos);
    gt_assert (startpos + 1 >= len);
    for (pos = startpos; /* Nothing */; pos--) {
      if (GT_ISSPECIAL(encseq->plainseq[pos]))
        return true;
      if (pos == startpos + 1 - len)
        break;
    }
  }
  return false;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0xcf8f7
andl $-0x3, %esi
cmpl $0x1, %esi
jne 0xcf8c6
movq 0x30(%rdi), %rsi
movq %rsi, %rdx
subq %rcx, %rdx
jbe 0xcf8fc
cmpq %r8, %rdx
jb 0xcf901
notq %rcx
addq %rcx, %rsi
movq 0x290(%rdi), %rdi
movb $0x1, %al
cmpb $-0x3, (%rdi,%rsi)
ja 0xcf8f5
movl $0x1, %ecx
subq %r8, %rcx
addq %rdi, %rdx
addq $-0x2, %rdx
xorl %esi, %esi
cmpq %rsi, %rcx
setne %al
je 0xcf8f5
cmpb $-0x3, (%rdx,%rsi)
leaq -0x1(%rsi), %rsi
jbe 0xcf8b2
jmp 0xcf8f5
leaq (%r8,%rcx), %rax
cmpq %rcx, %rax
jbe 0xcf8f3
decq %r8
addq 0x290(%rdi), %rcx
xorl %edx, %edx
movb (%rcx,%rdx), %al
cmpb $-0x2, %al
setae %al
jae 0xcf8f5
leaq 0x1(%rdx), %rsi
cmpq %rdx, %r8
movq %rsi, %rdx
jne 0xcf8db
jmp 0xcf8f5
xorl %eax, %eax
popq %rcx
retq
callq 0x2f395
callq 0x2f323
callq 0x2f35c
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/encseq.c
// Function: containsspecialViabytecompress
static bool containsspecialViabytecompress(const GtEncseq *encseq,
                                           GtReadmode readmode,
                                           GT_UNUSED GtEncseqReader *esr,
                                           GtUword startpos,
                                           GtUword len)
{
  GtUword pos;
  GtUchar cc;

  if (!GT_ISDIRREVERSE(readmode)) {
    for (pos = startpos; pos < startpos + len; pos++) {
      cc = delivercharViabytecompress(encseq, pos);
      if (GT_ISSPECIAL(cc))
        return true;
    }
  }
  else {
    gt_assert(startpos < encseq->totallength);
    startpos = GT_REVERSEPOS(encseq->totallength, startpos);
    gt_assert (startpos + 1 >= len);
    for (pos = startpos; /* Nothing */; pos--) {
      cc = delivercharViabytecompress(encseq, pos);
      if (GT_ISSPECIAL(cc))
        return true;
      if (pos == startpos + 1 - len)
        break;
    }
  }
  return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r15
movq %rdi, %r14
andl $-0x3, %esi
cmpl $0x1, %esi
jne 0xcfe86
movq 0x30(%r14), %rsi
movq %rsi, %r12
subq %r15, %r12
jbe 0xcfec4
cmpq %rbx, %r12
jb 0xcfec9
notq %r15
addq %r15, %rsi
movq %r14, %rdi
callq 0xbf1a7
movb $0x1, %bpl
cmpb $-0x3, %al
ja 0xcfeb9
decq %rbx
addq $-0x2, %r12
addq $-0x1, %rbx
setb %bpl
jae 0xcfeb9
movq %r14, %rdi
movq %r12, %rsi
callq 0xbf1a7
decq %r12
cmpb $-0x3, %al
jbe 0xcfe68
jmp 0xcfeb9
leaq (%rbx,%r15), %rax
cmpq %r15, %rax
jbe 0xcfeb7
decq %rbx
movq %r14, %rdi
movq %r15, %rsi
callq 0xbf1a7
cmpb $-0x2, %al
setae %bpl
subq $0x1, %rbx
setb %cl
cmpb $-0x3, %al
ja 0xcfeb9
incq %r15
testb %cl, %cl
je 0xcfe92
jmp 0xcfeb9
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x2f592
callq 0x2f5cb
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/encseq.c
// Function: seqdelivercharViaequallength
static GtUchar seqdelivercharViaequallength(GtEncseqReader *esr)
{
  GtUword twobits = EXTRACTENCODEDCHAR(esr->encseq->twobitencoding,
                                             esr->currentpos);

  if (twobits != (GtUword) esr->encseq->leastprobablecharacter ||
      !issinglepositioninseparatorViaequallength(esr) || esr->currentpos == 0)
    return (GtUchar) twobits;
  return (GtUchar) GT_SEPARATOR;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %rdx
movq 0x10(%rdi), %rax
movq 0x280(%rdx), %rcx
movq %rax, %rsi
shrq $0x5, %rsi
movq (%rcx,%rsi,8), %r14
movl %eax, %ecx
notl %ecx
addl %ecx, %ecx
shrq %cl, %r14
andl $0x3, %r14d
movl 0x170(%rdx), %ecx
cmpq %rcx, %r14
jne 0xd038b
movq %rdi, %rbx
cmpq 0x18(%rdi), %rax
jne 0xd038b
movq %rbx, %rdi
callq 0xbfe59
movb $-0x1, %al
cmpq $0x0, 0x10(%rbx)
jne 0xd038e
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/encseq.c
// Function: containsspecialViaequallength
static bool containsspecialViaequallength(const GtEncseq *encseq,
                                          GtReadmode readmode,
                                          GT_UNUSED GtEncseqReader *esr,
                                          GtUword startpos,
                                          GtUword len)
{
  gt_assert(encseq != NULL);
  if (!GT_ISDIRREVERSE(readmode)) {
    gt_assert(startpos + len <= encseq->totallength);
    if (issinglepositioninspecialrangeViaequallength(encseq, startpos) ||
        issinglepositioninspecialrangeViaequallength(encseq, startpos+len-1) ||
        gt_encseq_seqnum_Viaequallength(encseq, startpos) !=
        gt_encseq_seqnum_Viaequallength(encseq, startpos + len - 1)) {
      return true;
    }
  }
  else {
    gt_assert(startpos < encseq->totallength);
    startpos = GT_REVERSEPOS(encseq->totallength, startpos);
    gt_assert (startpos + 1 >= len);
    if (issinglepositioninspecialrangeViaequallength(encseq, startpos) ||
        issinglepositioninspecialrangeViaequallength(encseq, startpos+1-len) ||
        gt_encseq_seqnum_Viaequallength(encseq, startpos) !=
        gt_encseq_seqnum_Viaequallength(encseq, startpos + 1 - len)) {
      return true;
    }
  }
  return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xd0479
movq %r8, %r14
movq %rcx, %r15
movq %rdi, %rbx
andl $-0x3, %esi
cmpl $0x1, %esi
jne 0xd041b
movq 0x30(%rbx), %r13
movq %r13, %r12
subq %r15, %r12
jbe 0xd047e
subq %r14, %r12
jb 0xd0488
notq %r15
addq %r15, %r13
movq %rbx, %rdi
movq %r13, %rsi
callq 0xbf160
movb $0x1, %bpl
testb %al, %al
jne 0xd0468
movq %rbx, %rdi
movq %r12, %rsi
callq 0xbf160
testb %al, %al
jne 0xd0468
movq %rbx, %rdi
movq %r13, %rsi
callq 0xc2a2f
movq %rax, %r14
movq %rbx, %rdi
movq %r12, %rsi
callq 0xc2a2f
cmpq %rax, %r14
je 0xd0466
jmp 0xd0468
addq %r15, %r14
cmpq 0x30(%rbx), %r14
ja 0xd0483
movq %rbx, %rdi
movq %r15, %rsi
callq 0xbf160
movb $0x1, %bpl
testb %al, %al
jne 0xd0468
decq %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xbf160
testb %al, %al
jne 0xd0468
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc2a2f
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc2a2f
cmpq %rax, %r15
jne 0xd0468
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2f83c
callq 0x2f7ca
callq 0x2f791
callq 0x2f803
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/encseq.c
// Function: containsspecialViabitaccess
static bool containsspecialViabitaccess(const GtEncseq *encseq,
                                        GtReadmode readmode,
                                        GT_UNUSED GtEncseqReader *esr,
                                        GtUword startpos,
                                        GtUword len)
{
  GtUword pos;

  gt_assert(encseq != NULL);
  if (GT_ISDIRREVERSE(readmode)) {
    gt_assert(startpos < encseq->totallength);
    startpos = GT_REVERSEPOS(encseq->totallength, startpos);
  }
  if (encseq->specialbits == NULL)
    return false;
  if (!GT_ISDIRREVERSE(readmode)) {
    gt_assert(startpos + len <= encseq->totallength);
    for (pos = startpos; pos < startpos + len; pos++) {
      if (GT_ISIBITSET(encseq->specialbits, pos))
        return true;
    }
  }
  else {
    gt_assert (startpos + 1 >= len);
    for (pos = startpos; /* Nothing */; pos--) {
      if (GT_ISIBITSET(encseq->specialbits, pos))
        return true;
      if (pos == startpos + 1 - len)
        break;
    }
  }
  return false;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0xd0a9b
andl $-0x3, %esi
cmpl $0x1, %esi
jne 0xd09ea
movq 0x30(%rdi), %rax
cmpq %rcx, %rax
jbe 0xd0aa0
notq %rcx
addq %rax, %rcx
movq 0x2b0(%rdi), %rdx
testq %rdx, %rdx
je 0xd0a97
cmpl $0x1, %esi
jne 0xd0a53
leaq 0x1(%rcx), %rax
cmpq %r8, %rax
jb 0xd0aa5
movq %rcx, %rax
shrq $0x6, %rax
movq (%rdx,%rax,8), %rax
shlq %cl, %rax
shrq $0x3f, %rax
movb $0x1, %al
jne 0xd0a99
movabsq $-0x8000000000000000, %rsi # imm = 0x8000000000000000
decq %r8
decq %rcx
addq $-0x1, %r8
setb %al
jae 0xd0a99
movq %rcx, %rdi
movq %rsi, %r9
shrq %cl, %r9
shrq $0x6, %rdi
decq %rcx
testq %r9, (%rdx,%rdi,8)
je 0xd0a32
jmp 0xd0a99
leaq (%rcx,%r8), %rax
cmpq 0x30(%rdi), %rax
ja 0xd0aaa
cmpq %rax, %rcx
jae 0xd0a97
movabsq $-0x8000000000000000, %rsi # imm = 0x8000000000000000
decq %r8
movq %rcx, %rax
shrq $0x6, %rax
movq %rsi, %r9
shrq %cl, %r9
subq $0x1, %r8
setb %dil
testq %r9, (%rdx,%rax,8)
setne %al
jne 0xd0a99
incq %rcx
testb %dil, %dil
je 0xd0a6f
jmp 0xd0a99
xorl %eax, %eax
popq %rcx
retq
callq 0x2fa3b
callq 0x2f990
callq 0x2fa02
callq 0x2f9c9
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/encseq.c
// Function: containsspecialViatables
static bool containsspecialViatables(const GtEncseq *encseq,
                                     GtReadmode readmode,
                                     GtEncseqReader *esr,
                                     GtUword startpos,
                                     GtUword len)
{
  bool cspecial = false;

  gt_encseq_reader_reinit_with_readmode(esr, encseq, readmode, startpos);
  if (encseq->has_wildcardranges) {
    cspecial = containsSWViatables(encseq, esr, startpos, len,
                                   SWtable_wildcardrange);
  }
  if (!cspecial && encseq->numofdbsequences > 1UL) {
    cspecial = containsSWViatables(encseq, esr, startpos, len,
                                   SWtable_ssptab);
  }
  return cspecial;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %edx
movq %rdi, %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0xc0212
cmpb $0x1, 0x29(%r12)
jne 0xd126e
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
xorl %r8d, %r8d
callq 0xd29a3
jmp 0xd1270
xorl %eax, %eax
testb %al, %al
jne 0xd1293
cmpq $0x2, 0x40(%r12)
jb 0xd1293
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
movl $0x1, %r8d
callq 0xd29a3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/encseq.c
// Function: containsSWViatables
static bool containsSWViatables(const GtEncseq *encseq,
                                GtEncseqReader *esr,
                                GtUword startpos,
                                GtUword len,
                                KindofSWtable kindsw)
{
  GtEncseqReaderViatablesinfo *swstate = assignSWstate(esr, kindsw);

  gt_assert(swstate != NULL);
  if (swstate->hasprevious) {
    if (!GT_ISDIRREVERSE(esr->readmode)) {
      gt_assert(startpos + len > 0);
      if (startpos + len - 1 >= swstate->previousrange.start &&
          startpos < swstate->previousrange.end) {
        return true;
      }
    }
    else {
      startpos = GT_REVERSEPOS(encseq->totallength, startpos);
      gt_assert(startpos + 1 >= len);
      if (startpos + 1 - len < swstate->previousrange.end &&
          startpos >= swstate->previousrange.start) {
        return true;
      }
    }
  }
  return false;
}

// Assembly:
pushq %rax
xorl %eax, %eax
testl %r8d, %r8d
setne %al
movq 0x28(%rsi,%rax,8), %r8
testq %r8, %r8
je 0xd2a07
cmpb $0x1, 0x3a(%r8)
jne 0xd2a03
movl 0x8(%rsi), %eax
orl $0x2, %eax
cmpl $0x3, %eax
jne 0xd29ed
movq 0x30(%rdi), %rsi
movq %rsi, %rax
subq %rdx, %rax
subq %rcx, %rax
jb 0xd2a0c
cmpq 0x20(%r8), %rax
jae 0xd2a03
notq %rdx
addq %rdx, %rsi
movb $0x1, %al
cmpq 0x18(%r8), %rsi
jb 0xd2a03
jmp 0xd2a05
addq %rdx, %rcx
je 0xd2a11
decq %rcx
cmpq 0x18(%r8), %rcx
jb 0xd2a03
movb $0x1, %al
cmpq %rdx, 0x20(%r8)
ja 0xd2a05
xorl %eax, %eax
popq %rcx
retq
callq 0x30389
callq 0x30317
callq 0x30350
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/encseq_access_type.c
// Function: gt_encseq_access_type_get
GtEncseqAccessType gt_encseq_access_type_get(const char *str)
{
  size_t i;

  for (i=0; i<sizeof (wpa)/sizeof (wpa[0]); i++)
  {
    gt_assert(i == 0 || wpa[i-1].sat < wpa[i].sat);
    if (strcmp(str,wpa[i].name) == 0)
    {
      return wpa[i].sat;
    }
  }
  return GT_ACCESS_TYPE_UNDEFINED;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
leaq 0x7e124(%rip), %r15     # 0x150c30
testq %r14, %r14
je 0xd2b1c
movl -0x10(%r14,%r15), %eax
cmpl (%r14,%r15), %eax
jae 0xd2b48
movq 0x8(%r14,%r15), %rsi
movq %rbx, %rdi
callq 0xb890
testl %eax, %eax
je 0xd2b3e
addq $0x10, %r14
cmpq $0x70, %r14
jne 0xd2b0c
movl $0x7, %eax
jmp 0xd2b42
movl (%r14,%r15), %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x303f9
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/encseq_col.c
// Function: gt_encseq_col_md5_to_sequence_length
int gt_encseq_col_md5_to_sequence_length(GtSeqCol *sc, GtUword *len,
                                         GtStr *md5_seqid, GtError *err)
{
  GtUword seqnum = GT_UNDEF_UWORD;
  int had_err = 0;
  GtEncseqCol *esc;
  esc = gt_encseq_col_cast(sc);
  gt_error_check(err);
  gt_assert(esc && len && md5_seqid && err);
  gt_assert(gt_md5_seqid_has_prefix(gt_str_get(md5_seqid)));
  seqnum = gt_md5_tab_map(esc->md5_tab, gt_str_get(md5_seqid) +
                                          GT_MD5_SEQID_PREFIX_LEN);
  if (seqnum != GT_UNDEF_UWORD) {
    gt_assert(seqnum < gt_encseq_num_of_sequences(esc->encseq));
    *len = gt_encseq_seqlength(esc->encseq, seqnum);
  } else {
    gt_error_set(err, "sequence %s not found", gt_str_get(md5_seqid));
    had_err = -1;
  }
  return had_err;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r12
callq 0xd2f61
movq %rax, %rdi
movq %r12, %rsi
callq 0xd7a8e
movq %rax, %r12
testq %r14, %r14
je 0xd2ea5
movq %r14, %rdi
callq 0x3566a
testb %al, %al
jne 0xd2f57
testq %r14, %r14
je 0xd2f4d
testq %r15, %r15
je 0xd2f4d
testq %rbx, %rbx
je 0xd2f4d
testq %r12, %r12
je 0xd2f4d
movq %r15, %rdi
callq 0x3c40b
movq %rax, %rdi
callq 0x7a678
testb %al, %al
je 0xd2f52
movq 0x10(%r12), %r13
movq %r15, %rdi
callq 0x3c40b
leaq 0x4(%rax), %rsi
movq %r13, %rdi
callq 0xd7652
cmpq $-0x1, %rax
je 0xd2f22
movq %rax, %r13
movq 0x8(%r12), %rdi
callq 0xbef6c
cmpq %rax, %r13
jae 0xd2f5c
movq 0x8(%r12), %rdi
movq %r13, %rsi
callq 0xc2d57
movq %rax, (%rbx)
xorl %eax, %eax
jmp 0xd2f43
movq %r15, %rdi
callq 0x3c40b
leaq 0x2ece9(%rip), %rsi     # 0x101c1a
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x3559f
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x304a0
callq 0x304d9
callq 0x3054b
callq 0x30512
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/encseq_col.c
// Function: gt_encseq_col_class
const GtSeqColClass* gt_encseq_col_class(void)
{
  static const GtSeqColClass *esc_class = NULL;
  gt_class_alloc_lock_enter();
  if (!esc_class) {
      esc_class = gt_seq_col_class_new(sizeof (GtEncseqCol),
                                       gt_encseq_col_delete,
                                       gt_encseq_col_enable_match_desc_start,
                                       gt_encseq_col_grep_desc,
                                       gt_encseq_col_grep_desc_desc,
                                       gt_encseq_col_grep_desc_md5,
                                       gt_encseq_col_grep_desc_sequence_length,
                                       gt_encseq_col_md5_to_seq,
                                       gt_encseq_col_md5_to_description,
                                       gt_encseq_col_md5_to_sequence_length,
                                       gt_encseq_col_num_of_files,
                                       gt_encseq_col_num_of_seqs,
                                       gt_encseq_col_get_md5_fingerprint,
                                       gt_encseq_col_get_sequence,
                                       gt_encseq_col_get_description,
                                       gt_encseq_col_get_sequence_length);
  }
  gt_class_alloc_lock_leave();
  return esc_class;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
callq 0x71d9b
cmpq $0x0, 0x7fe17(%rip)     # 0x152d90
jne 0xd300d
leaq 0xbb9(%rip), %r14       # 0xd3b3f
leaq 0xb19(%rip), %r15       # 0xd3aa6
leaq 0xa46(%rip), %r12       # 0xd39da
leaq 0x9e3(%rip), %r13       # 0xd397e
leaq 0x904(%rip), %rbp       # 0xd38a6
leaq 0x8d5(%rip), %rax       # 0xd387e
leaq -0x148(%rip), %rbx      # 0xd2e68
leaq 0x742(%rip), %r11       # 0xd36f9
leaq 0x559(%rip), %r10       # 0xd3517
leaq 0x63(%rip), %rsi        # 0xd3028
leaq 0x9f(%rip), %rdx        # 0xd306b
leaq 0x1fb(%rip), %rcx       # 0xd31ce
leaq 0x324(%rip), %r8        # 0xd32fe
movl $0x30, %edi
leaq 0x3e3(%rip), %r9        # 0xd33c9
pushq %r14
pushq %r15
pushq %r12
pushq %r13
pushq %rbp
pushq %rax
pushq %rbx
pushq %r11
pushq %r10
leaq 0x474(%rip), %rax       # 0xd3470
pushq %rax
callq 0xd799c
addq $0x50, %rsp
movq %rax, 0x7fd83(%rip)     # 0x152d90
callq 0x71db1
movq 0x7fd77(%rip), %rax     # 0x152d90
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/encseq_col.c
// Function: gt_encseq_col_delete
static void gt_encseq_col_delete(GtSeqCol *sc)
{
  GtEncseqCol *esc;
  esc = gt_encseq_col_cast(sc);
  if (!esc) return;
  gt_seq_info_cache_delete(esc->grep_cache);
  gt_hashmap_delete(esc->duplicates);
  gt_md5_tab_delete(esc->md5_tab);
  gt_encseq_delete(esc->encseq);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0xd2f61
movq %rax, %rdi
movq %rbx, %rsi
callq 0xd7a8e
testq %rax, %rax
je 0xd3069
movq %rax, %rbx
movq 0x18(%rax), %rdi
callq 0xd7cae
movq 0x20(%rbx), %rdi
callq 0x77675
movq 0x10(%rbx), %rdi
callq 0xd757b
movq 0x8(%rbx), %rdi
popq %rbx
jmp 0xc1690
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/encseq_col.c
// Function: gt_encseq_col_enable_match_desc_start
static void gt_encseq_col_enable_match_desc_start(GtSeqCol *sc)
{
  GtEncseqCol *esc;
  GtUword j;
  GtSeqInfo seq_info;
  GtStr *descbuf = gt_str_new();
  esc = gt_encseq_col_cast(sc);
  esc->matchstart = true;
  /* pre-cache seqids for faster search */
  if (!esc->grep_cache)
    esc->grep_cache = gt_seq_info_cache_new();
  for (j = 0; j < gt_encseq_num_of_sequences(esc->encseq); j++) {
    const char *desc;
    GtUword desc_len;
    desc = gt_encseq_description(esc->encseq, &desc_len, j);
    gt_assert(desc);
    gt_str_reset(descbuf);
    gt_str_append_cstr_nt(descbuf, desc, desc_len);
    seq_info.filenum = gt_encseq_filenum(esc->encseq,
                                         gt_encseq_seqstartpos(esc->encseq, j));
    seq_info.seqnum = j - gt_encseq_filenum_first_seqnum(esc->encseq,
                                                         seq_info.filenum);
    if (!gt_seq_info_cache_get(esc->grep_cache, gt_str_get(descbuf)))
      gt_seq_info_cache_add(esc->grep_cache, gt_str_get(descbuf), &seq_info);
    else {
      if (!esc->duplicates)
        esc->duplicates = gt_hashmap_new(GT_HASH_STRING, NULL, NULL);
      gt_hashmap_add(esc->duplicates, gt_str_get(descbuf), (void*) 1);
    }
  }
  gt_str_delete(descbuf);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
callq 0x3bfe0
movq %rax, %rbx
callq 0xd2f61
movq %rax, %rdi
movq %r14, %rsi
callq 0xd7a8e
movq %rax, %r14
movb $0x1, 0x28(%rax)
cmpq $0x0, 0x18(%rax)
jne 0xd30ab
callq 0xd7c78
movq %rax, 0x18(%r14)
movq 0x8(%r14), %rdi
callq 0xbef6c
testq %rax, %rax
je 0xd31b2
xorl %r15d, %r15d
movq %rsp, %r12
leaq 0x8(%rsp), %r13
movq 0x8(%r14), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0xc3523
testq %rax, %rax
je 0xd31c9
movq %rax, %rbp
movq %rbx, %rdi
callq 0x3c49c
movq (%rsp), %rdx
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x3c185
movq 0x8(%r14), %rbp
movq %rbp, %rdi
movq %r15, %rsi
callq 0xc2a64
movq %rbp, %rdi
movq %rax, %rsi
callq 0xcd8d3
movq %rax, 0x8(%rsp)
movq 0x8(%r14), %rdi
movq %rax, %rsi
callq 0xcd955
movq %r15, %rcx
subq %rax, %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%r14), %rbp
movq %rbx, %rdi
callq 0x3c40b
movq %rbp, %rdi
movq %rax, %rsi
callq 0xd7cd5
testq %rax, %rax
je 0xd3183
cmpq $0x0, 0x20(%r14)
jne 0xd3165
movl $0x1, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x76f28
movq %rax, 0x20(%r14)
movq 0x20(%r14), %rbp
movq %rbx, %rdi
callq 0x3c40b
movl $0x1, %edx
movq %rbp, %rdi
movq %rax, %rsi
callq 0x77144
jmp 0xd319d
movq 0x18(%r14), %rbp
movq %rbx, %rdi
callq 0x3c40b
movq %rbp, %rdi
movq %rax, %rsi
movq %r13, %rdx
callq 0xd7ce8
incq %r15
movq 0x8(%r14), %rdi
callq 0xbef6c
cmpq %rax, %r15
jb 0xd30c8
movq %rbx, %rdi
callq 0x3d1eb
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x30584
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/encseq_col.c
// Function: gt_encseq_col_grep_desc
static int gt_encseq_col_grep_desc(GtSeqCol *sc, char **seq,
                                   GtUword start, GtUword end,
                                   GtStr *seqid, GtError *err)
{
  GtUword filenum = 0, seqnum = 0, seqlength;
  int had_err;
  GtEncseqCol *esc;
  esc = gt_encseq_col_cast(sc);
  gt_error_check(err);
  gt_assert(esc && seq && seqid);
  had_err = gt_encseq_col_do_grep_desc(esc, &filenum, &seqnum, seqid, err);
  if (!had_err) {
    seqlength = gt_encseq_col_get_sequence_length(sc, filenum, seqnum);
    if (start > seqlength - 1 || end > seqlength - 1) {
      had_err = -1;
      gt_error_set(err, "trying to extract range "GT_WU"-"GT_WU" on sequence "
                         "``%s'' which is not covered by that sequence (only "
                         ""GT_WU" characters in size). Has the sequence-region "
                         "to sequence mapping been defined correctly?",
                         start, end, gt_str_get(seqid), seqlength);
    }
  }
  if (!had_err) {
    *seq = gt_seq_col_get_sequence(sc, filenum, seqnum, start, end);
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, %r13
movq %r8, %rbp
movq %rcx, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq %rsi, %rbx
movq %rdi, %r12
xorl %eax, %eax
movq %rax, 0x20(%rsp)
movq %rax, 0x18(%rsp)
callq 0xd2f61
movq %rax, %rdi
movq %r12, %rsi
callq 0xd7a8e
movq %rax, %r14
testq %r13, %r13
je 0xd3226
movq %r13, %rdi
callq 0x3566a
testb %al, %al
jne 0xd32f9
testq %rbp, %rbp
je 0xd32f4
testq %rbx, %rbx
je 0xd32f4
testq %r14, %r14
je 0xd32f4
leaq 0x20(%rsp), %rsi
leaq 0x18(%rsp), %rdx
movq %r14, %rdi
movq %rbp, %rcx
movq %r13, %r8
callq 0xd3c57
movl %eax, %r14d
testl %eax, %eax
jne 0xd32be
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %r12, %rdi
callq 0xd3b3f
movq %rax, %r15
decq %rax
cmpq 0x8(%rsp), %rax
setae %cl
cmpq 0x10(%rsp), %rax
setae %al
xorl %r14d, %r14d
testb %al, %cl
jne 0xd32be
movq %rbp, %rdi
callq 0x3c40b
leaq 0x289b7(%rip), %rsi     # 0xfbc55
movq %r13, %rdi
movq 0x8(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq %rax, %r8
movq %r15, %r9
xorl %eax, %eax
callq 0x3559f
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
testl %r14d, %r14d
jne 0xd32e2
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %r12, %rdi
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %r8
callq 0xd7c1f
movq %rax, (%rbx)
movl %r14d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x305f6
callq 0x305bd
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/encseq_col.c
// Function: gt_encseq_col_grep_desc_desc
static int gt_encseq_col_grep_desc_desc(GtSeqCol *sc, GtStr *desc,
                                        GtStr *seqid, GtError *err)
{
  GtUword filenum = 0, seqnum = 0;
  int had_err;
  GtEncseqCol *esc;
  esc = gt_encseq_col_cast(sc);
  gt_error_check(err);
  gt_assert(esc && desc && seqid);
  had_err = gt_encseq_col_do_grep_desc(esc, &filenum, &seqnum, seqid, err);
  if (!had_err) {
    char *mydesc = gt_seq_col_get_description(sc, filenum, seqnum);
    if (mydesc)
      gt_str_append_cstr(desc, mydesc);
    gt_free(mydesc);
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
xorl %eax, %eax
movq %rax, 0x10(%rsp)
movq %rax, 0x8(%rsp)
callq 0xd2f61
movq %rax, %rdi
movq %r14, %rsi
callq 0xd7a8e
movq %rax, %r13
testq %r15, %r15
je 0xd3348
movq %r15, %rdi
callq 0x3566a
testb %al, %al
jne 0xd33c4
testq %r12, %r12
je 0xd33bf
testq %rbx, %rbx
je 0xd33bf
testq %r13, %r13
je 0xd33bf
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %r13, %rdi
movq %r12, %rcx
movq %r15, %r8
callq 0xd3c57
movl %eax, %ebp
testl %eax, %eax
jne 0xd33ae
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %r14, %rdi
callq 0xd7c3b
movq %rax, %r14
testq %rax, %rax
je 0xd339a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3c067
leaq 0x34d3d(%rip), %rsi     # 0x1080de
movq %r14, %rdi
movl $0xdb, %edx
callq 0x362a0
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x30668
callq 0x3062f
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/encseq_col.c
// Function: gt_encseq_col_grep_desc_md5
static int gt_encseq_col_grep_desc_md5(GtSeqCol *sc, const char **md5,
                                       GtStr *seqid, GtError *err)
{
  GtUword filenum = 0, seqnum = 0;
  int had_err;
  GtEncseqCol *esc;
  esc = gt_encseq_col_cast(sc);
  gt_error_check(err);
  gt_assert(esc && md5 && seqid);
  had_err = gt_encseq_col_do_grep_desc(esc, &filenum, &seqnum, seqid, err);
  if (!had_err)
    *md5 = gt_seq_col_get_md5_fingerprint(sc, filenum, seqnum);
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
xorl %eax, %eax
movq %rax, 0x10(%rsp)
movq %rax, 0x8(%rsp)
callq 0xd2f61
movq %rax, %rdi
movq %r14, %rsi
callq 0xd7a8e
movq %rax, %r13
testq %r15, %r15
je 0xd3413
movq %r15, %rdi
callq 0x3566a
testb %al, %al
jne 0xd346b
testq %r12, %r12
je 0xd3466
testq %rbx, %rbx
je 0xd3466
testq %r13, %r13
je 0xd3466
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %r13, %rdi
movq %r12, %rcx
movq %r15, %r8
callq 0xd3c57
movl %eax, %ebp
testl %eax, %eax
jne 0xd3455
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %r14, %rdi
callq 0xd7c03
movq %rax, (%rbx)
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x306da
callq 0x306a1
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/encseq_col.c
// Function: gt_encseq_col_grep_desc_sequence_length
static int gt_encseq_col_grep_desc_sequence_length(GtSeqCol *sc,
                                                   GtUword *length,
                                                   GtStr *seqid,
                                                   GtError *err)
{
  GtUword filenum = 0, seqnum = 0;
  int had_err;
  GtEncseqCol *esc;
  esc = gt_encseq_col_cast(sc);
  gt_error_check(err);
  gt_assert(esc && length && seqid);
  had_err = gt_encseq_col_do_grep_desc(esc, &filenum, &seqnum, seqid, err);
  if (!had_err)
    *length = gt_seq_col_get_sequence_length(sc, filenum, seqnum);
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
xorl %eax, %eax
movq %rax, 0x10(%rsp)
movq %rax, 0x8(%rsp)
callq 0xd2f61
movq %rax, %rdi
movq %r14, %rsi
callq 0xd7a8e
movq %rax, %r13
testq %r15, %r15
je 0xd34ba
movq %r15, %rdi
callq 0x3566a
testb %al, %al
jne 0xd3512
testq %r12, %r12
je 0xd350d
testq %rbx, %rbx
je 0xd350d
testq %r13, %r13
je 0xd350d
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %r13, %rdi
movq %r12, %rcx
movq %r15, %r8
callq 0xd3c57
movl %eax, %ebp
testl %eax, %eax
jne 0xd34fc
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %r14, %rdi
callq 0xd7c59
movq %rax, (%rbx)
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x3074c
callq 0x30713
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/encseq_col.c
// Function: gt_encseq_col_num_of_files
static GtUword gt_encseq_col_num_of_files(const GtSeqCol *sc)
{
  const GtEncseqCol *esc;
  esc = gt_encseq_col_cast(sc);
  gt_assert(esc);
  return gt_encseq_num_of_files(esc->encseq);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0xd2f61
movq %rax, %rdi
movq %rbx, %rsi
callq 0xd7a8e
testq %rax, %rax
je 0xd38a1
movq 0x8(%rax), %rdi
popq %rbx
jmp 0xc6fb7
callq 0x30914
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/encseq_col.c
// Function: gt_encseq_col_num_of_seqs
static GtUword gt_encseq_col_num_of_seqs(const GtSeqCol *sc,
                                               GtUword filenum)
{
  GtEncseqCol *esc;
  /* XXX cache function evaluated values */
  esc = gt_encseq_col_cast(sc);
  gt_assert(esc && filenum < gt_encseq_num_of_files(esc->encseq));
  if (gt_encseq_num_of_files(esc->encseq) == 1 && filenum == 0)
    return gt_encseq_num_of_sequences(esc->encseq);
  else if (filenum == gt_encseq_num_of_files(esc->encseq) - 1) {
    return (gt_encseq_num_of_sequences(esc->encseq)
              - gt_encseq_filenum_first_seqnum(esc->encseq, filenum));
  } else {
    GtUword firstpos, nextpos;
    gt_assert(filenum < gt_encseq_num_of_files(esc->encseq) - 1);
    firstpos = gt_encseq_filenum_first_seqnum(esc->encseq, filenum);
    nextpos = gt_encseq_filenum_first_seqnum(esc->encseq, filenum + 1);
    return nextpos - firstpos;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0xd2f61
movq %rax, %rdi
movq %r14, %rsi
callq 0xd7a8e
testq %rax, %rax
je 0xd3974
movq %rax, %r14
movq 0x8(%rax), %rdi
callq 0xc6fb7
cmpq %rbx, %rax
jbe 0xd3974
movq 0x8(%r14), %rdi
callq 0xc6fb7
movq 0x8(%r14), %rdi
testq %rbx, %rbx
jne 0xd390a
cmpq $0x1, %rax
jne 0xd390a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xbef6c
callq 0xc6fb7
decq %rax
movq 0x8(%r14), %rdi
cmpq %rbx, %rax
jne 0xd3934
callq 0xbef6c
movq %rax, %r15
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0xcd955
subq %rax, %r15
jmp 0xd3965
callq 0xc6fb7
decq %rax
cmpq %rbx, %rax
jbe 0xd3979
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0xcd955
movq %rax, %r12
movq 0x8(%r14), %rdi
incq %rbx
movq %rbx, %rsi
callq 0xcd955
movq %rax, %r15
subq %r12, %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x30986
callq 0x3094d
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/core/encseq_col.c
// Function: gt_encseq_col_get_md5_fingerprint
static const char* gt_encseq_col_get_md5_fingerprint(const GtSeqCol *sc,
                                                     GtUword filenum,
                                                     GtUword seqnum)
{
  GtEncseqCol *esc;
  esc = gt_encseq_col_cast(sc);
  gt_assert(esc && filenum < gt_encseq_num_of_files(esc->encseq));
  return gt_md5_tab_get(esc->md5_tab,
                        gt_encseq_filenum_first_seqnum(esc->encseq,
                                                       filenum) + seqnum);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0xd2f61
movq %rax, %rdi
movq %r15, %rsi
callq 0xd7a8e
testq %rax, %rax
je 0xd39d5
movq %rax, %r15
movq 0x8(%rax), %rdi
callq 0xc6fb7
cmpq %r14, %rax
jbe 0xd39d5
movq 0x8(%r15), %rdi
movq 0x10(%r15), %r15
movq %r14, %rsi
callq 0xcd955
addq %rax, %rbx
movq %r15, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0xd7623
callq 0x309bf