LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0xcf912
movq 0x30(%rsi), %rax
subq %rdx, %rax
jbe 0xcf912
cmpl $0x3, (%rsi)
jne 0xcf817
cmpb $0x0, 0x3a8(%rsi)
jne 0xcf7f5
testb $0x1, 0x28(%rsi)
je 0xcf8bc
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 0xcf83d
shlq %cl, %r8
jmp 0xcf848
subq %rdx, %rcx
jbe 0xcf831
cmpq $0x20, %rcx
movl $0x20, %eax
cmovbq %rcx, %rax
movl %eax, 0x8(%rdi)
jmp 0xcf8d0
movl $0x0, 0x8(%rdi)
jmp 0xcf8f8
movq 0x8(%r9,%r10,8), %r9
movl %edx, %ecx
shldq %cl, %r9, %r8
movabsq $-0x100000000, %rcx     # imm = 0xFFFFFFFF00000000
andq %r8, %rcx
je 0xcf8bc
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 0x32f2f(%rip), %r8      # 0x1027e0
movl $0x40, %ecx
subl (%r8,%rax,4), %ecx
jmp 0xcf8c9
cmpq $0x20, %rax
movl $0x20, %ecx
cmovbq %rax, %rcx
movl %ecx, 0x8(%rdi)
testl %ecx, %ecx
je 0xcf8f8
movq 0x280(%rsi), %rsi
movq %rdx, %rcx
andq $0x1f, %rcx
je 0xcf8fc
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 0xcf907
xorl %eax, %eax
jmp 0xcf907
movq %rdx, %rax
shrq $0x2, %rax
movq (%rsi,%rax), %rax
movq %rax, (%rdi)
addq $0x20, %rdx
movq %rdx, %rax
retq
pushq %rax
callq 0x2ea7c
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/encseq.c
// Function: revextract2bitenc
static GtUword revextract2bitenc(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 (currentpos - twobitencodingstoppos + 1 >
          (GtUword) GT_UNITSIN2BITENC) {
        ptbe->unitsnotspecial = (unsigned int) GT_UNITSIN2BITENC;
      }
      else {
        ptbe->unitsnotspecial
          = (unsigned int) (currentpos - twobitencodingstoppos + 1);
      }
      ptbe->tbe = calctbereverse(encseq->twobitencoding, currentpos);
    }
    else {
      ptbe->unitsnotspecial = 0;
      ptbe->tbe = 0;
    }
  }
  else {
    if (gt_encseq_has_specialranges(encseq)) {
      GtBitsequence spbits;

      spbits = revextractspecialbits(encseq->specialbits, currentpos);
      ptbe->unitsnotspecial = revbitaccessunitsnotspecial(spbits, currentpos);
    }
    else {
      ptbe->unitsnotspecial = revbitaccessunitsnotspecial0(currentpos);
    }
    if (ptbe->unitsnotspecial == 0) {
      ptbe->tbe = 0;
    }
    else {
      ptbe->tbe = calctbereverse(encseq->twobitencoding, currentpos);
    }
  }
  if (currentpos > (GtUword) GT_UNITSIN2BITENC) {
    return currentpos - (GtUword) GT_UNITSIN2BITENC;
  }
  else {
    return 0;
  }
}

// Assembly:
testq %rsi, %rsi
je 0xcfa34
cmpq %rdx, 0x30(%rsi)
jbe 0xcfa34
cmpl $0x3, (%rsi)
jne 0xcf96b
cmpb $0x0, 0x3a8(%rsi)
jne 0xcf943
testb $0x1, 0x28(%rsi)
je 0xcf9cb
movq 0x2b0(%rsi), %r9
movl %edx, %eax
andl $0x3f, %eax
movq %rdx, %r10
shrq $0x6, %r10
movq (%r9,%r10,8), %r8
movl %eax, %ecx
notb %cl
shrq %cl, %r8
cmpl $0x20, %eax
jb 0xcf996
movl %r8d, %r8d
jmp 0xcf9af
movq %rdx, %rax
subq %rcx, %rax
jae 0xcf981
movl $0x0, 0x8(%rdi)
xorl %esi, %esi
jmp 0xcfa19
incq %rax
cmpq $0x20, %rax
movl $0x20, %ecx
cmovbq %rax, %rcx
movl %ecx, 0x8(%rdi)
jmp 0xcf9dd
cmpq $0x40, %rdx
jb 0xcf9af
movq -0x8(%r9,%r10,8), %r9
incb %al
movl %eax, %ecx
shlq %cl, %r9
andl $-0x2, %r9d
orq %r9, %r8
testq %r8, %r8
je 0xcf9cb
testl %r8d, %r8d
je 0xcfa27
testl %r8d, %r8d
je 0xcf973
bsfl %r8d, %eax
movl %eax, 0x8(%rdi)
testl %eax, %eax
jne 0xcf9dd
jmp 0xcf97a
cmpq $0x1f, %rdx
movl $0x1f, %eax
cmovbq %rdx, %rax
incl %eax
movl %eax, 0x8(%rdi)
movq 0x280(%rsi), %r8
movl %edx, %eax
andl $0x1f, %eax
movq %rdx, %r9
shrq $0x5, %r9
movq (%r8,%r9,8), %rsi
cmpq $0x1f, %rax
je 0xcfa19
addl %eax, %eax
movl %eax, %ecx
xorb $0x3e, %cl
shrq %cl, %rsi
cmpq $0x20, %rdx
jb 0xcfa19
movq -0x8(%r8,%r9,8), %r8
addb $0x2, %al
movl %eax, %ecx
shlq %cl, %r8
orq %r8, %rsi
movq %rsi, (%rdi)
xorl %eax, %eax
subq $0x20, %rdx
cmovaeq %rdx, %rax
retq
shrq $0x20, %r8
bsfl %r8d, %eax
orl $0x20, %eax
jmp 0xcf9da
pushq %rax
callq 0x2eab5
// File: /workspace/github_c_makefile_star2_O3/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 0xcfa46
movb $0x0, 0x40(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xcfea8
movq 0x20(%rsp), %rax
addq %r9, %rcx
movq %rcx, %r14
cmpq %rax, %rcx
jne 0xcfebf
addq $0x100, %rax            # imm = 0x100
jmp 0xcfef9
movq %rcx, %r14
subq %r9, %r14
jae 0xcfebf
subq %rcx, %r9
addq $0x100, %r9             # imm = 0x100
movq %r9, %rax
jmp 0xcfef9
cmpq %r8, %r9
jbe 0xcfed0
addq $0x100, %r14            # imm = 0x100
movq %r14, %rax
jmp 0xcfef9
movq %r14, %rsi
xorl %edx, %edx
callq 0xbff84
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_O3/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 0xc12b5
leaq 0x36dfd(%rip), %rdi     # 0x106d2a
movq %r15, %rsi
xorl %eax, %eax
callq 0xb070
movq %r15, (%rsp)
cmpq %r15, %rbx
jbe 0xcff69
movq (%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0xbff84
movl %eax, %r13d
movq %r12, %rdi
callq 0xc054e
cmpb %al, %r13b
jne 0xcff78
incq %r15
cmpq %r15, %rbx
jne 0xcff44
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movzbl %al, %ebx
movzbl %r13b, %r13d
movq 0x8103a(%rip), %rax     # 0x150fc0
movq (%rax), %r12
movq %r14, %rdi
callq 0xc1711
movq %rax, %r14
movl %ebp, %edi
callq 0xd7e40
leaq 0x36dad(%rip), %rsi     # 0x106d4f
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_O3/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
cmpq $0x100, %rdi            # imm = 0x100
jbe 0xd000d
movq %rcx, %rax
shrq $0x8, %rax
cmpb $0x1, %cl
sbbq $-0x1, %rax
imulq %r8, %rax
addq %rax, 0x8(%rdx)
cmpq $0x10000, %rcx          # imm = 0x10000
jbe 0xd0028
movq %rcx, %rax
shrq $0x10, %rax
testw %cx, %cx
je 0xd0007
incq %rax
imulq %r8, %rax
jmp 0xd0014
addq %r8, 0x8(%rdx)
movq %r8, %rax
addq %rax, 0x10(%rdx)
leaq -0x1(%rcx), %rax
shrq $0x20, %rax
je 0xd002c
pushq %rax
callq 0x2eb60
addq %r8, 0x10(%rdx)
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 0x370c3(%rip), %rsi     # 0x107115
xorl %eax, %eax
jmp 0x3561d
// File: /workspace/github_c_makefile_star2_O3/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 0xba7a2
testl %eax, %eax
je 0xd00b6
movq (%rbx), %r15
movq %r14, %rdi
callq 0xba7a2
xorl %ebp, %ebp
cmpl $0x2, %eax
jb 0xd00ab
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 0xba7a2
movl %eax, %eax
cmpq %rax, %r12
jb 0xd008a
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x2eb99
// File: /workspace/github_c_makefile_star2_O3/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 0xc4b81
movq %rax, %r14
movzbl 0x360(%rbx), %edi
decq %rdi
addq 0x340(%rbx), %r14
callq 0x7a629
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_O3/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 0xd0758
andl $-0x3, %esi
cmpl $0x1, %esi
jne 0xd0727
movq 0x30(%rdi), %rsi
movq %rsi, %rdx
subq %rcx, %rdx
jbe 0xd075d
cmpq %r8, %rdx
jb 0xd0762
notq %rcx
addq %rcx, %rsi
movq 0x290(%rdi), %rdi
movb $0x1, %al
cmpb $-0x3, (%rdi,%rsi)
ja 0xd0756
movl $0x1, %ecx
subq %r8, %rcx
addq %rdi, %rdx
addq $-0x2, %rdx
xorl %esi, %esi
cmpq %rsi, %rcx
setne %al
je 0xd0756
cmpb $-0x3, (%rdx,%rsi)
leaq -0x1(%rsi), %rsi
jbe 0xd0713
jmp 0xd0756
leaq (%r8,%rcx), %rax
cmpq %rcx, %rax
jbe 0xd0754
decq %r8
addq 0x290(%rdi), %rcx
xorl %edx, %edx
movb (%rcx,%rdx), %al
cmpb $-0x2, %al
setae %al
jae 0xd0756
leaq 0x1(%rdx), %rsi
cmpq %rdx, %r8
movq %rsi, %rdx
jne 0xd073c
jmp 0xd0756
xorl %eax, %eax
popq %rcx
retq
callq 0x2ed98
callq 0x2ed26
callq 0x2ed5f
// File: /workspace/github_c_makefile_star2_O3/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 0xd0ce5
movq 0x30(%r14), %rsi
movq %rsi, %r12
subq %r15, %r12
jbe 0xd0d23
cmpq %rbx, %r12
jb 0xd0d28
notq %r15
addq %r15, %rsi
movq %r14, %rdi
callq 0xc01af
movb $0x1, %bpl
cmpb $-0x3, %al
ja 0xd0d18
decq %rbx
addq $-0x2, %r12
addq $-0x1, %rbx
setb %bpl
jae 0xd0d18
movq %r14, %rdi
movq %r12, %rsi
callq 0xc01af
decq %r12
cmpb $-0x3, %al
jbe 0xd0cc7
jmp 0xd0d18
leaq (%rbx,%r15), %rax
cmpq %r15, %rax
jbe 0xd0d16
decq %rbx
movq %r14, %rdi
movq %r15, %rsi
callq 0xc01af
cmpb $-0x2, %al
setae %bpl
subq $0x1, %rbx
setb %cl
cmpb $-0x3, %al
ja 0xd0d18
incq %r15
testb %cl, %cl
je 0xd0cf1
jmp 0xd0d18
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x2ef95
callq 0x2efce
// File: /workspace/github_c_makefile_star2_O3/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 0xd11e1
movq %rdi, %rbx
cmpq 0x18(%rdi), %rax
jne 0xd11e1
movq %rbx, %rdi
callq 0xc0ef7
movb $-0x1, %al
cmpq $0x0, 0x10(%rbx)
jne 0xd11e4
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xd12cf
movq %r8, %r14
movq %rcx, %r15
movq %rdi, %rbx
andl $-0x3, %esi
cmpl $0x1, %esi
jne 0xd1271
movq 0x30(%rbx), %r13
movq %r13, %r12
subq %r15, %r12
jbe 0xd12d4
subq %r14, %r12
jb 0xd12de
notq %r15
addq %r15, %r13
movq %rbx, %rdi
movq %r13, %rsi
callq 0xc0168
movb $0x1, %bpl
testb %al, %al
jne 0xd12be
movq %rbx, %rdi
movq %r12, %rsi
callq 0xc0168
testb %al, %al
jne 0xd12be
movq %rbx, %rdi
movq %r13, %rsi
callq 0xc3a81
movq %rax, %r14
movq %rbx, %rdi
movq %r12, %rsi
callq 0xc3a81
cmpq %rax, %r14
je 0xd12bc
jmp 0xd12be
addq %r15, %r14
cmpq 0x30(%rbx), %r14
ja 0xd12d9
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc0168
movb $0x1, %bpl
testb %al, %al
jne 0xd12be
decq %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc0168
testb %al, %al
jne 0xd12be
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc3a81
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc3a81
cmpq %rax, %r15
jne 0xd12be
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2f23f
callq 0x2f1cd
callq 0x2f194
callq 0x2f206
// File: /workspace/github_c_makefile_star2_O3/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 0xd18fd
andl $-0x3, %esi
cmpl $0x1, %esi
jne 0xd18a9
movq 0x30(%rdi), %rax
movq %rax, %rdx
subq %rcx, %rdx
jbe 0xd1902
movq 0x2b0(%rdi), %rsi
testq %rsi, %rsi
je 0xd18f9
cmpq %r8, %rdx
jb 0xd190c
notq %rcx
addq %rcx, %rax
movq %rax, %rcx
shrq $0x6, %rcx
movq (%rsi,%rcx,8), %rdi
movl %eax, %ecx
shlq %cl, %rdi
shrq $0x3f, %rdi
movb $0x1, %al
jne 0xd18fb
movabsq $-0x8000000000000000, %rdi # imm = 0x8000000000000000
decq %r8
addq $-0x2, %rdx
addq $-0x1, %r8
setb %al
jae 0xd18fb
movq %rdx, %r9
movq %rdi, %r10
movl %edx, %ecx
shrq %cl, %r10
shrq $0x6, %r9
decq %rdx
testq %r10, (%rsi,%r9,8)
je 0xd1886
jmp 0xd18fb
movq 0x2b0(%rdi), %rdx
testq %rdx, %rdx
je 0xd18f9
leaq (%r8,%rcx), %rax
cmpq 0x30(%rdi), %rax
ja 0xd1907
cmpq %rcx, %rax
jbe 0xd18f9
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 0xd18fb
incq %rcx
testb %dil, %dil
je 0xd18d1
jmp 0xd18fb
xorl %eax, %eax
popq %rcx
retq
callq 0x2f43e
callq 0x2f3cc
callq 0x2f393
callq 0x2f405
// File: /workspace/github_c_makefile_star2_O3/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 0xc12b5
cmpb $0x1, 0x29(%r12)
jne 0xd20b9
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
xorl %r8d, %r8d
callq 0xd37ca
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0xd20e5
cmpq $0x2, 0x40(%r12)
jb 0xd20e3
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
movl $0x1, %r8d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xd37ca
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xd382e
cmpb $0x1, 0x3a(%r8)
jne 0xd382a
movl 0x8(%rsi), %eax
orl $0x2, %eax
cmpl $0x3, %eax
jne 0xd3814
movq 0x30(%rdi), %rsi
movq %rsi, %rax
subq %rdx, %rax
subq %rcx, %rax
jb 0xd3833
cmpq 0x20(%r8), %rax
jae 0xd382a
notq %rdx
addq %rdx, %rsi
movb $0x1, %al
cmpq 0x18(%r8), %rsi
jb 0xd382a
jmp 0xd382c
addq %rdx, %rcx
je 0xd3838
decq %rcx
cmpq 0x18(%r8), %rcx
jb 0xd382a
movb $0x1, %al
cmpq %rdx, 0x20(%r8)
ja 0xd382c
xorl %eax, %eax
popq %rcx
retq
callq 0x2fd8c
callq 0x2fd1a
callq 0x2fd53
// File: /workspace/github_c_makefile_star2_O3/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 0x7d2fc(%rip), %r15     # 0x150c30
testq %r14, %r14
je 0xd3944
movl -0x10(%r14,%r15), %eax
cmpl (%r14,%r15), %eax
jae 0xd3970
movq 0x8(%r14,%r15), %rsi
movq %rbx, %rdi
callq 0xb890
testl %eax, %eax
je 0xd3966
addq $0x10, %r14
cmpq $0x70, %r14
jne 0xd3934
movl $0x7, %eax
jmp 0xd396a
movl (%r14,%r15), %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x2fdfc
// File: /workspace/github_c_makefile_star2_O3/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 0xd3d78
movq %rax, %rdi
movq %r12, %rsi
callq 0xd8196
testq %r14, %r14
je 0xd3d64
movq %rax, %r12
movq %r14, %rdi
callq 0x34fea
testb %al, %al
jne 0xd3d69
testq %r15, %r15
je 0xd3d64
testq %rbx, %rbx
je 0xd3d64
testq %r12, %r12
je 0xd3d64
movq %r15, %rdi
callq 0x3bb5d
movq %rax, %rdi
callq 0x7aa64
testb %al, %al
je 0xd3d6e
movq 0x10(%r12), %r13
movq %r15, %rdi
callq 0x3bb5d
leaq 0x4(%rax), %rsi
movq %r13, %rdi
callq 0xd7d4f
cmpq $-0x1, %rax
je 0xd3d39
movq %rax, %r13
movq 0x8(%r12), %rdi
callq 0xbff74
cmpq %rax, %r13
jae 0xd3d73
movq 0x8(%r12), %rdi
movq %r13, %rsi
callq 0xc3d9a
movq %rax, (%rbx)
xorl %eax, %eax
jmp 0xd3d5a
movq %r15, %rdi
callq 0x3bb5d
leaq 0x2de46(%rip), %rsi     # 0x101b8e
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x34f1f
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x2ff4e
callq 0x2ff15
callq 0x2fea3
callq 0x2fedc
// File: /workspace/github_c_makefile_star2_O3/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 0x72367
cmpq $0x0, 0x7f000(%rip)     # 0x152d90
jne 0xd3e24
leaq 0xb6a(%rip), %r14       # 0xd4907
leaq 0xaca(%rip), %r15       # 0xd486e
leaq 0x9f7(%rip), %r12       # 0xd47a2
leaq 0x994(%rip), %r13       # 0xd4746
leaq 0x8b5(%rip), %rbp       # 0xd466e
leaq 0x886(%rip), %rax       # 0xd4646
leaq -0x143(%rip), %rbx      # 0xd3c84
leaq 0x709(%rip), %r11       # 0xd44d7
leaq 0x542(%rip), %r10       # 0xd4317
leaq 0x63(%rip), %rsi        # 0xd3e3f
leaq 0x9f(%rip), %rdx        # 0xd3e82
leaq 0x1fc(%rip), %rcx       # 0xd3fe6
leaq 0x30d(%rip), %r8        # 0xd40fe
movl $0x30, %edi
leaq 0x3cc(%rip), %r9        # 0xd41c9
pushq %r14
pushq %r15
pushq %r12
pushq %r13
pushq %rbp
pushq %rax
pushq %rbx
pushq %r11
pushq %r10
leaq 0x45d(%rip), %rax       # 0xd4270
pushq %rax
callq 0xd80a4
addq $0x50, %rsp
movq %rax, 0x7ef6c(%rip)     # 0x152d90
callq 0x7237d
movq 0x7ef60(%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_O3/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 0xd3d78
movq %rax, %rdi
movq %rbx, %rsi
callq 0xd8196
testq %rax, %rax
je 0xd3e80
movq %rax, %rbx
movq 0x18(%rax), %rdi
callq 0xd83b6
movq 0x20(%rbx), %rdi
callq 0x77bab
movq 0x10(%rbx), %rdi
callq 0xd7c78
movq 0x8(%rbx), %rdi
popq %rbx
jmp 0xc273d
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3b728
movq %rax, %rbx
callq 0xd3d78
movq %rax, %rdi
movq %r14, %rsi
callq 0xd8196
movq %rax, %r14
movb $0x1, 0x28(%rax)
cmpq $0x0, 0x18(%rax)
jne 0xd3ec2
callq 0xd8380
movq %rax, 0x18(%r14)
movq 0x8(%r14), %rdi
callq 0xbff74
testq %rax, %rax
je 0xd3fca
xorl %r15d, %r15d
movq %rsp, %r12
leaq 0x8(%rsp), %r13
movq 0x8(%r14), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0xc4566
testq %rax, %rax
je 0xd3fe1
movq %rax, %rbp
movq %rbx, %rdi
callq 0x3bbee
movq (%rsp), %rdx
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x3b8d7
movq 0x8(%r14), %rbp
movq %rbp, %rdi
movq %r15, %rsi
callq 0xc3ab6
movq %rbp, %rdi
movq %rax, %rsi
callq 0xce800
movq %rax, 0x8(%rsp)
movq 0x8(%r14), %rdi
movq %rax, %rsi
callq 0xce880
movq %r15, %rcx
subq %rax, %rcx
movq %rcx, 0x10(%rsp)
movq 0x18(%r14), %rbp
movq %rbx, %rdi
callq 0x3bb5d
movq %rbp, %rdi
movq %rax, %rsi
callq 0xd83dd
testq %rax, %rax
je 0xd3f9b
movq 0x20(%r14), %rbp
testq %rbp, %rbp
jne 0xd3f81
movl $0x1, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x7740c
movq %rax, %rbp
movq %rax, 0x20(%r14)
movq %rbx, %rdi
callq 0x3bb5d
movl $0x1, %edx
movq %rbp, %rdi
movq %rax, %rsi
callq 0x77628
jmp 0xd3fb5
movq 0x18(%r14), %rbp
movq %rbx, %rdi
callq 0x3bb5d
movq %rbp, %rdi
movq %rax, %rsi
movq %r13, %rdx
callq 0xd83f0
incq %r15
movq 0x8(%r14), %rdi
callq 0xbff74
cmpq %rax, %r15
jb 0xd3edf
movq %rbx, %rdi
callq 0x3c87b
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2ff87
// File: /workspace/github_c_makefile_star2_O3/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 $0x18, %rsp
movq %r9, %r15
movq %r8, %r13
movq %rcx, 0x10(%rsp)
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbp
xorl %eax, %eax
movq %rax, 0x8(%rsp)
movq %rax, (%rsp)
callq 0xd3d78
movq %rax, %rdi
movq %rbp, %rsi
callq 0xd8196
movq %rax, %rbx
testq %r15, %r15
je 0xd403b
movq %r15, %rdi
callq 0x34fea
testb %al, %al
jne 0xd40f9
testq %r13, %r13
je 0xd40f4
testq %r12, %r12
je 0xd40f4
testq %rbx, %rbx
je 0xd40f4
leaq 0x8(%rsp), %rsi
movq %rsp, %rdx
movq %rbx, %rdi
movq %r13, %rcx
movq %r15, %r8
callq 0xd4a1f
testl %eax, %eax
jne 0xd40e5
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
movq %rbp, %rdi
callq 0xd4907
movq %rax, %rbx
decq %rax
cmpq %r14, %rax
setae %cl
movq 0x10(%rsp), %r8
cmpq %r8, %rax
setae %al
testb %al, %cl
jne 0xd40cb
movq %r13, %rdi
movq %r8, %r12
callq 0x3bb5d
leaq 0x27b17(%rip), %rsi     # 0xfbbc5
movq %r15, %rdi
movq %r14, %rdx
movq %r12, %rcx
movq %rax, %r8
movq %rbx, %r9
xorl %eax, %eax
callq 0x34f1f
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0xd40e5
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
movq %rbp, %rdi
movq %r14, %rcx
callq 0xd8327
movq %rax, (%r12)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x2fff9
callq 0x2ffc0
// File: /workspace/github_c_makefile_star2_O3/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 0xd3d78
movq %rax, %rdi
movq %r14, %rsi
callq 0xd8196
movq %rax, %r13
testq %r15, %r15
je 0xd4148
movq %r15, %rdi
callq 0x34fea
testb %al, %al
jne 0xd41c4
testq %r12, %r12
je 0xd41bf
testq %rbx, %rbx
je 0xd41bf
testq %r13, %r13
je 0xd41bf
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %r13, %rdi
movq %r12, %rcx
movq %r15, %r8
callq 0xd4a1f
movl %eax, %ebp
testl %eax, %eax
jne 0xd41ae
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %r14, %rdi
callq 0xd8343
movq %rax, %r14
testq %rax, %rax
je 0xd419a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3b7af
leaq 0x33d65(%rip), %rsi     # 0x107f06
movq %r14, %rdi
movl $0xdb, %edx
callq 0x35c27
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x3006b
callq 0x30032
// File: /workspace/github_c_makefile_star2_O3/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 0xd3d78
movq %rax, %rdi
movq %r14, %rsi
callq 0xd8196
movq %rax, %r13
testq %r15, %r15
je 0xd4213
movq %r15, %rdi
callq 0x34fea
testb %al, %al
jne 0xd426b
testq %r12, %r12
je 0xd4266
testq %rbx, %rbx
je 0xd4266
testq %r13, %r13
je 0xd4266
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %r13, %rdi
movq %r12, %rcx
movq %r15, %r8
callq 0xd4a1f
movl %eax, %ebp
testl %eax, %eax
jne 0xd4255
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %r14, %rdi
callq 0xd830b
movq %rax, (%rbx)
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x300dd
callq 0x300a4
// File: /workspace/github_c_makefile_star2_O3/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 0xd3d78
movq %rax, %rdi
movq %r14, %rsi
callq 0xd8196
movq %rax, %r13
testq %r15, %r15
je 0xd42ba
movq %r15, %rdi
callq 0x34fea
testb %al, %al
jne 0xd4312
testq %r12, %r12
je 0xd430d
testq %rbx, %rbx
je 0xd430d
testq %r13, %r13
je 0xd430d
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %r13, %rdi
movq %r12, %rcx
movq %r15, %r8
callq 0xd4a1f
movl %eax, %ebp
testl %eax, %eax
jne 0xd42fc
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %r14, %rdi
callq 0xd8361
movq %rax, (%rbx)
movl %ebp, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x3014f
callq 0x30116
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/core/encseq_col.c
// Function: gt_encseq_col_md5_to_description
static int gt_encseq_col_md5_to_description(GtSeqCol *sc, GtStr *desc,
                                            GtStr *md5_seqid, GtError *err)
{
  GtUword seqnum = GT_UNDEF_UWORD;
  char seqid[GT_MD5_SEQID_HASH_LEN + 1];
  int had_err = 0;
  GtEncseqCol *esc;
  esc = gt_encseq_col_cast(sc);
  gt_error_check(err);
  gt_assert(esc && desc && md5_seqid && err);
  gt_assert(gt_md5_seqid_has_prefix(gt_str_get(md5_seqid)));
  if (gt_str_length(md5_seqid) >= GT_MD5_SEQID_TOTAL_LEN) {
    const char *cstrseqid = gt_str_get(md5_seqid);
    if (cstrseqid[GT_MD5_SEQID_TOTAL_LEN-1] != GT_MD5_SEQID_SEPARATOR) {
      gt_error_set(err, "MD5 sequence id %s not terminated with '%c'",
                   gt_str_get(md5_seqid), GT_MD5_SEQID_SEPARATOR);
      had_err = -1;
    }
    if (!had_err) {
      strncpy(seqid, cstrseqid + GT_MD5_SEQID_PREFIX_LEN,
              GT_MD5_SEQID_HASH_LEN);
      seqid[GT_MD5_SEQID_HASH_LEN] = '\0';
    }
  }
  seqnum = gt_md5_tab_map(esc->md5_tab, seqid);
  if (seqnum != GT_UNDEF_UWORD) {
    const char *cdesc;
    GtUword desc_len;
    gt_assert(seqnum < gt_encseq_num_of_sequences(esc->encseq));
    cdesc = gt_encseq_description(esc->encseq, &desc_len, seqnum);
    gt_str_append_cstr_nt(desc, cdesc, desc_len);
  } else {
    gt_error_set(err, "sequence %s not found", gt_str_get(md5_seqid));
    had_err = -1;
  }
  return had_err;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r12
callq 0xd3d78
movq %rax, %rdi
movq %r12, %rsi
callq 0xd8196
testq %r14, %r14
je 0xd4632
movq %rax, %r12
movq %r14, %rdi
callq 0x34fea
testb %al, %al
jne 0xd4637
testq %r15, %r15
je 0xd4632
testq %rbx, %rbx
je 0xd4632
testq %r12, %r12
je 0xd4632
movq %r15, %rdi
callq 0x3bb5d
movq %rax, %rdi
callq 0x7aa64
testb %al, %al
je 0xd463c
movq %r15, %rdi
callq 0x3bb86
xorl %ebp, %ebp
cmpq $0x25, %rax
jb 0xd45b4
movq %r15, %rdi
callq 0x3bb5d
cmpb $0x3a, 0x24(%rax)
jne 0xd458e
addq $0x4, %rax
leaq 0x10(%rsp), %r13
movl $0x20, %edx
movq %r13, %rdi
movq %rax, %rsi
callq 0xb2d0
movb $0x0, 0x20(%r13)
jmp 0xd45b4
movq %r15, %rdi
callq 0x3bb5d
leaq 0x2d5c5(%rip), %rsi     # 0x101b62
movq %r14, %rdi
movq %rax, %rdx
movl $0x3a, %ecx
xorl %eax, %eax
callq 0x34f1f
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movq 0x10(%r12), %rdi
leaq 0x10(%rsp), %rsi
callq 0xd7d4f
cmpq $-0x1, %rax
je 0xd4600
movq %rax, %r13
movq 0x8(%r12), %rdi
callq 0xbff74
cmpq %rax, %r13
jae 0xd4641
movq 0x8(%r12), %rdi
leaq 0x8(%rsp), %r14
movq %r14, %rsi
movq %r13, %rdx
callq 0xc4566
movq (%r14), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3b8d7
jmp 0xd4621
movq %r15, %rdi
callq 0x3bb5d
leaq 0x2d57f(%rip), %rsi     # 0x101b8e
movq %r14, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x34f1f
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x302de
callq 0x302a5
callq 0x30233
callq 0x3026c
// File: /workspace/github_c_makefile_star2_O3/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 0xd3d78
movq %rax, %rdi
movq %rbx, %rsi
callq 0xd8196
testq %rax, %rax
je 0xd4669
movq 0x8(%rax), %rdi
popq %rbx
jmp 0xc7f91
callq 0x30317