LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/eis-mrangealphabet.c
// Function: gt_MRAEncAddSymbolToRange
MRAEnc *
gt_MRAEncAddSymbolToRange(MRAEnc *mralpha, Symbol sym, AlphabetRangeID range)
{
  Symbol insertPos, numSyms;
  gt_assert(mralpha && range < mralpha->numRanges);
  insertPos = mralpha->rangeEndIndices[range];
  numSyms = mralpha->rangeEndIndices[mralpha->numRanges - 1];
  switch (mralpha->encType)
  {
  case sourceUInt8:
    {
      MRAEncUInt8 *ui8alpha;
      ui8alpha = MRAEnc2MRAEncUInt8(mralpha);
      gt_assert(ui8alpha->mappings[sym] == UNDEF_UCHAR);
      /* first move all old mappings accordingly */
      {
        Symbol i;
        for (i = numSyms; i > insertPos; --i)
        {
          Symbol origSym = ui8alpha->revMappings[i - 1];
          ui8alpha->revMappings[i] = origSym;
          ui8alpha->mappings[origSym] += 1;
        }
      }
      /* do actual insertion */
      ui8alpha->mappings[sym] = insertPos;
      ui8alpha->revMappings[insertPos] = sym;
      /* adjust ranges */
      mralpha->symbolsPerRange[range] += 1;
      {
        AlphabetRangeID i;
        for (i = range; i < mralpha->numRanges; ++i)
        {
          mralpha->rangeEndIndices[i] += 1;
        }
      }
    }
    break;
  default:
    abort();
    break;
  }
  return mralpha;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x19e273
movl 0x4(%rdi), %eax
cmpl %edx, %eax
jbe 0x19e273
cmpl $0x1, (%rdi)
jne 0x19e278
movzbl %sil, %r8d
cmpb $-0x1, 0x18(%rdi,%r8)
jne 0x19e27d
movq 0x8(%rdi), %rcx
movl %edx, %edx
movzwl (%rcx,%rdx,2), %r9d
movzbl %r9b, %r10d
leal -0x1(%rax), %r11d
movzwl (%rcx,%r11,2), %r11d
movzbl %r11b, %r15d
cmpw %r15w, %r10w
jae 0x19e249
leaq (%r15,%rdi), %rbx
addq $0x118, %rbx            # imm = 0x118
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
addq %r15, %r14
movl %r14d, %r15d
movzbl 0x118(%rdi,%r15), %r15d
movb %r15b, (%rbx)
incb 0x18(%rdi,%r15)
decb %r11b
decq %rbx
decq %r14
cmpb %r10b, %r11b
ja 0x19e227
movb %r9b, 0x18(%rdi,%r8)
movb %sil, 0x118(%rdi,%r10)
movq 0x10(%rdi), %rsi
incw (%rsi,%rdx,2)
incw (%rcx,%rdx,2)
incq %rdx
cmpq %rdx, %rax
jne 0x19e25e
movq %rdi, %rax
popq %rbx
popq %r14
popq %r15
retq
callq 0x6031e
callq 0x173b0
callq 0x602e5
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/eis-mrangealphabet.c
// Function: gt_MRAEncReadAndTransform
size_t
gt_MRAEncReadAndTransform(const MRAEnc *mralpha, FILE *fp,
                       size_t numSyms, Symbol *dest)
{
  int retval = 0;
  switch (mralpha->encType)
  {
  case sourceUInt8:
    {
      const MRAEncUInt8 *ui8alpha;
      size_t i;
      ui8alpha = constMRAEnc2MRAEncUInt8(mralpha);
      for (i = 0; i < numSyms; ++i)
      {
        int c = getc(fp);
        if (c != EOF)
          dest[i] = ui8alpha->mappings[c];
        else
          break;
      }
      retval = i;
    }
    break;
  default:
    abort();
    break;
  }
  return retval;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
cmpl $0x1, (%rdi)
jne 0x19e2d8
movq %rdx, %rbx
testq %rdx, %rdx
je 0x19e2cc
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %r12
xorl %r13d, %r13d
movq %r15, %rdi
callq 0x171f0
cmpl $-0x1, %eax
je 0x19e2c7
cltq
movb 0x18(%r12,%rax), %al
movb %al, (%r14,%r13)
incq %r13
cmpq %r13, %rbx
jne 0x19e2a4
movq %rbx, %r13
movslq %r13d, %rax
jmp 0x19e2ce
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x173b0
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/eis-mrangealphabet.c
// Function: gt_MRAEncSymbolIsInSelectedRanges
int
gt_MRAEncSymbolIsInSelectedRanges(const MRAEnc *mralpha, Symbol sym,
                               int selection, const int *rangeSel)
{
  AlphabetRangeID range = 0;
  gt_assert(mralpha && rangeSel);
  while (range < mralpha->numRanges
         && sym >= mralpha->rangeEndIndices[range])
    ++range;
  if (range < mralpha->numRanges)
  {
    if (rangeSel[range] == selection
       && sym >= (mralpha->rangeEndIndices[range]
                  - mralpha->symbolsPerRange[range])
       /* implicitely: && sym < mralpha->rangeEndIndices[range] */)
      return 1;
    else
      return 0;
  }
  else
    return -1;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x19e384
testq %rcx, %rcx
je 0x19e384
movl 0x4(%rdi), %r8d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testq %r8, %r8
je 0x19e382
movq 0x8(%rdi), %r9
movzbl %sil, %esi
xorl %r10d, %r10d
cmpw %si, (%r9,%r10,2)
ja 0x19e361
incq %r10
cmpq %r10, %r8
jne 0x19e350
jmp 0x19e382
cmpl %edx, (%rcx,%r10,4)
jne 0x19e380
movzwl (%r9,%r10,2), %ecx
movq 0x10(%rdi), %rax
movzwl (%rax,%r10,2), %eax
subl %eax, %ecx
movl $0x1, %eax
cmpl %esi, %ecx
jle 0x19e382
xorl %eax, %eax
popq %rcx
retq
callq 0x60357
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/eis-sa-common.c
// Function: gt_translateSuftab2BWT
size_t gt_translateSuftab2BWT(void *translator,
                              void *voiddest,
                              const GtUword *src,
                              size_t len)
{
  struct encSeqTrState *trState = (struct encSeqTrState *) translator;
  GtUchar *dest = (GtUchar *) voiddest;
  size_t idx;

  gt_assert(trState);
  for (idx = 0; idx < len; ++idx)
  {
    dest[idx] = sfxIdx2BWTSym(src[idx], trState->encseq,
                              trState->readmode);
  }
  return len * sizeof (GtUchar);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x19e409
movq %rcx, %rbx
testq %rcx, %rcx
je 0x19e3fc
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
xorl %r13d, %r13d
movq (%r14,%r13,8), %rsi
testq %rsi, %rsi
je 0x19e3ee
movl 0x8(%r12), %edx
movq (%r12), %rdi
decq %rsi
callq 0xe7bbc
jmp 0x19e3f0
movb $-0x2, %al
movb %al, (%r15,%r13)
incq %r13
cmpq %r13, %rbx
jne 0x19e3d2
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x603c9
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/eis-sa-common.c
// Function: gt_translateSuftab2BWTSuffixsortspace
size_t gt_translateSuftab2BWTSuffixsortspace(
                                       void *translator,
                                       void *voiddest,
                                       const GtSuffixsortspace *suffixsortspace,
                                       GtUword offset,
                                       size_t len)
{
  struct encSeqTrState *trState = (struct encSeqTrState *) translator;
  GtUchar *dest = (GtUchar *) voiddest;
  size_t idx;

  gt_assert(trState);
  for (idx = 0; idx < len; ++idx)
  {
    dest[idx]
      = sfxIdx2BWTSym(gt_suffixsortspace_getdirect(suffixsortspace,offset+idx),
                      trState->encseq, trState->readmode);
  }
  return len * sizeof (GtUchar);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x19e47a
movq %r8, %rbx
testq %r8, %r8
je 0x19e468
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
xorl %ebp, %ebp
leaq (%r14,%rbp), %rsi
movq %r15, %rdi
callq 0x1fc7ed
testq %rax, %rax
je 0x19e45a
movl 0x8(%r13), %edx
movq (%r13), %rdi
decq %rax
movq %rax, %rsi
callq 0xe7bbc
jmp 0x19e45c
movb $-0x2, %al
movb %al, (%r12,%rbp)
incq %rbp
cmpq %rbp, %rbx
jne 0x19e434
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x60400
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/eis-sa-common.c
// Function: gt_destructSATaggedXltorStateList
void
gt_destructSATaggedXltorStateList(
  struct saTaggedXltorStateList *saXltorStateList)
{
  struct saTaggedXltorStateLE *next;
  gt_assert(saXltorStateList);
  next = saXltorStateList->stateList;
  while (next)
  {
    struct saTaggedXltorStateLE *prev = next;
    next = next->next;
    gt_free(prev);
  }
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x19e4bf
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x19e4b7
leaq 0x2053ff(%rip), %rbx    # 0x3a389e
movq (%rdi), %r14
movq %rbx, %rsi
movl $0x56, %edx
callq 0x1045eb
movq %r14, %rdi
testq %r14, %r14
jne 0x19e49f
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x60437
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/eis-sa-common.c
// Function: gt_addSuffixarrayXltor
struct saTaggedXltorState *
gt_addSuffixarrayXltor(struct saTaggedXltorStateList *saXltorStateList,
                    enum sfxDataRequest request,
                    struct encSeqTrState state)
{
  struct saTaggedXltorStateLE *newSAXltorState;
  newSAXltorState = gt_malloc(sizeof (*newSAXltorState));
  newSAXltorState->state.typeTag = request;
  newSAXltorState->state.state = state;
  newSAXltorState->next = saXltorStateList->stateList;
  saXltorStateList->stateList = newSAXltorState;
  ++(saXltorStateList->numXltors);
  return &newSAXltorState->state;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
leaq 0x2053c2(%rip), %rsi    # 0x3a389e
movl $0x20, %edi
movl $0x60, %edx
callq 0x104226
leaq 0x8(%rax), %rcx
movl %ebp, 0x8(%rax)
movq %r14, 0x10(%rax)
movl %ebx, 0x18(%rax)
movq 0x8(%r15), %rdx
movq %rdx, (%rax)
movq %rax, 0x8(%r15)
incq (%r15)
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/eis-sequencemultiread.c
// Function: gt_destructSeqReaderSet
void
gt_destructSeqReaderSet(SeqReaderSet *readerSet)
{
  gt_assert(readerSet);
  ListDo(struct seqReaderState, readerSet->consumerList, gt_free(p));
  if (readerSet->autoConsumerList)
    gt_free(readerSet->autoConsumerList);
  if (readerSet->seqDataBacklog)
    gt_free(readerSet->seqDataBacklog);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x19e5fb
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x19e5bc
leaq 0x20538f(%rip), %r14    # 0x3a3933
movq (%rdi), %r15
movq %r14, %rsi
movl $0x73, %edx
callq 0x1045eb
movq %r15, %rdi
testq %r15, %r15
jne 0x19e5a4
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x19e5d6
leaq 0x205367(%rip), %rsi    # 0x3a3933
movl $0x75, %edx
callq 0x1045eb
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x19e5f5
leaq 0x20534d(%rip), %rsi    # 0x3a3933
movl $0x77, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x1045eb
popq %rbx
popq %r14
popq %r15
retq
callq 0x6046e
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/eis-sequencemultiread.c
// Function: gt_seqReaderSetRegisterConsumer
SeqDataReader
gt_seqReaderSetRegisterConsumer(SeqReaderSet *readerSet, int tag,
                             SeqDataTranslator xltor)
{
  int availId = readerSet->numConsumers++;
  SeqDataReader reader;
  struct seqReaderState *state;
  gt_assert(readerSet);
  state = gt_malloc(sizeof (*state));
  state->readerSet = readerSet;
  state->id = availId;
  state->xltor = xltor;
  state->nextReadPos = 0;
  state->tag = tag;
  state->next = readerSet->consumerList;
  readerSet->consumerList = state;

  readerSet->tagSuperSet |= tag;

  reader.src = state;
  reader.readData = seqReaderSetRead;
  return reader;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl (%rdi), %r15d
leal 0x1(%r15), %eax
movl %eax, (%rdi)
leaq 0x205319(%rip), %rsi    # 0x3a3933
movl $0x48, %edi
movl $0x82, %edx
callq 0x104226
movq %r14, 0x18(%rax)
movl %r15d, 0x20(%rax)
movaps 0x20(%rsp), %xmm0
movups %xmm0, 0x30(%rax)
movq 0x30(%rsp), %rcx
movq %rcx, 0x40(%rax)
movq $0x0, 0x8(%rax)
movl %ebx, 0x10(%rax)
movq 0x10(%r14), %rcx
movq %rcx, (%rax)
movq %rax, 0x10(%r14)
orl %ebx, 0x8(%r14)
leaq 0x6(%rip), %rdx         # 0x19e66a
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/eis-specialsrank.c
// Function: specialsRankFromSampleTable
static GtUword
specialsRankFromSampleTable(const SpecialsRankLookup *ranker, GtUword pos)
{
  const SpecialsRankTable *rankTable = &ranker->implementationData.sampleTable;
  GtUword rankCount, samplePos, encSeqLen;
  gt_assert(ranker);
  encSeqLen = gt_encseq_total_length(ranker->encseq);
  gt_assert(pos <= encSeqLen + 1);
  samplePos = pos & ~(rankTable->sampleInterval - 1);
  {
    size_t sampleIdx = pos >> rankTable->sampleIntervalLog2;
    rankCount = rankTable->rankSumSamples[sampleIdx];
  }
  {
    const GtEncseq *encseq = ranker->encseq;
    GtEncseqReader *esr = rankTable->scanState;
    GtReadmode readmode = rankTable->readmode;
    GtUword encseqQueryMax = GT_MIN(pos, encSeqLen);
    if (samplePos < encseqQueryMax)
    {
      gt_encseq_reader_reinit_with_readmode(esr, encseq, readmode, samplePos);
      do {
        samplePos++;
        if (GT_ISSPECIAL(gt_encseq_reader_next_encoded_char(esr)))
          ++rankCount;
      } while (samplePos < encseqQueryMax);
    }
    if (pos == encSeqLen + 1)
      ++rankCount;
  }
  return rankCount;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x19ec87
movq %rsi, %rbx
movq %rdi, %r15
movq 0x8(%rdi), %rdi
callq 0xe7b9c
leaq 0x1(%rax), %r13
cmpq %rbx, %r13
jb 0x19ec8c
movq %rax, %r14
xorl %eax, %eax
subq 0x28(%r15), %rax
movb 0x34(%r15), %cl
movq %rbx, %rdx
shrq %cl, %rdx
andq %rbx, %rax
movq 0x18(%r15), %rcx
movq (%rcx,%rdx,8), %rbp
cmpq %rbx, %r14
cmovaeq %rbx, %r14
subq %rax, %r14
jbe 0x19ec6d
movq 0x10(%r15), %r12
movl 0x30(%r15), %edx
movq 0x8(%r15), %rsi
movq %r12, %rdi
movq %rax, %rcx
callq 0xe8eed
movq %r12, %rdi
callq 0xe8186
cmpb $-0x2, %al
sbbq $-0x1, %rbp
decq %r14
jne 0x19ec5a
xorl %eax, %eax
cmpq %rbx, %r13
sete %al
addq %rbp, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x60701
callq 0x606c8
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/eis-suffixarray-interface.c
// Function: gt_initSuffixarrayFileInterface
void
gt_initSuffixarrayFileInterface(SuffixarrayFileInterface *sai,
                             GtUword seqLen, Suffixarray *sa)
{
  {
    RandomSeqAccessor origSeqAccess = { gt_SAIGetOrigSeq, sai };
    initSASeqSrc(&sai->baseClass, seqLen, NULL, SAIBaseMakeReader,
                 SAIBaseGetRot0Pos, NULL,
                 origSeqAccess, gt_deleteSuffixarrayFileInterfaceBase,
                 gt_SAIBaseNewMRAEnc,
                 SAIGenerate, sai);
  }
  sai->sa = sa;
  sai->numBWTFileReaders = 0;
  gt_initSATaggedXltorStateList(&sai->xltorStates);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x19ed74
movq %rdx, %r14
movq %rdi, %rbx
movq %rsi, (%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
leaq 0xf6(%rip), %rcx        # 0x19ede2
movq %rcx, 0x8(%rdi)
leaq 0xf0(%rip), %rcx        # 0x19ede7
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
leaq 0x73(%rip), %rcx        # 0x19ed79
movq %rcx, 0x28(%rdi)
movq %rdi, 0x30(%rdi)
leaq 0xd7(%rip), %rcx        # 0x19edec
movq %rcx, 0x38(%rdi)
leaq -0x70(%rip), %rcx       # 0x19ecb0
movq %rcx, 0x40(%rdi)
movq %rax, 0x48(%rdi)
addq $0x50, %rdi
leaq 0xd7(%rip), %r8         # 0x19ee0a
movl $0x8, %ecx
xorl %esi, %esi
xorl %edx, %edx
movq %rbx, %r9
callq 0x19e55c
leaq 0xb0(%rbx), %rdi
callq 0x19e47f
movq %r14, 0xd0(%rbx)
movb $0x0, 0xd8(%rbx)
addq $0xc0, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x19e47f
callq 0x60773
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/eis-suffixarray-interface.c
// Function: gt_SAIGetOrigSeq
size_t
gt_SAIGetOrigSeq(const void *state, Symbol *dest, GtUword pos, size_t len)
{
  const SuffixarrayFileInterface *sai;
  gt_assert(state);
  sai = state;
  return EncSeqGetSubSeq(sai->sa->encseq, sai->sa->readmode, pos, len, dest);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x19edd8
movq 0xd0(%rdi), %rax
movq (%rax), %r12
testq %r12, %r12
je 0x19eddd
movq %rcx, %rbx
testq %rcx, %rcx
je 0x19edc6
movq %rdx, %r14
movq %rsi, %r15
movl 0x48(%rax), %ebp
xorl %r13d, %r13d
leaq (%r14,%r13), %rsi
movq %r12, %rdi
movl %ebp, %edx
callq 0xe7bbc
movb %al, (%r15,%r13)
incq %r13
cmpq %r13, %rbx
jne 0x19edac
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x607e1
callq 0x607aa
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/eis-suffixarray-interface.c
// Function: SAIGenerate
static size_t
SAIGenerate(void *generatorState, void *backlogState,
            move2BacklogFunc move2Backlog, void *output,
            GtUword generateStart, size_t len,
            SeqDataTranslator xltor)
{
  size_t idx;
  SuffixarrayFileInterface *sai = generatorState;
  Suffixarray *sa;
  GtUword buf[len];

  gt_assert(sai);
  sa = sai->sa;
  for (idx = 0; idx < len; ++idx)
  {
    if (gt_readnextfromstream_GtUword(buf + idx,&sa->suftabstream_GtUword) != 1)
    {
      break;
    }
  }
  move2Backlog(backlogState, buf, generateStart, idx);
  SDRTranslate(xltor, output, buf, idx);
  return idx;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsp, %r14
leaq 0xf(,%r9,8), %rax
andq $-0x10, %rax
subq %rax, %r14
movq %r14, %rsp
testq %rdi, %rdi
je 0x19ef44
movq %r9, %r15
movq %rcx, %r12
movq %rsi, -0x38(%rbp)
movq %r8, -0x40(%rbp)
movq %rdx, -0x48(%rbp)
testq %r9, %r9
je 0x19eeea
movq %r12, -0x30(%rbp)
movq 0xd0(%rdi), %rbx
movl 0xa0(%rbx), %r12d
movl 0xa4(%rbx), %eax
movq 0xa8(%rbx), %rdi
xorl %r13d, %r13d
cmpl %r12d, %eax
jb 0x19eec7
movq 0xb0(%rbx), %rcx
movl $0x8, %esi
movl $0x1000, %edx           # imm = 0x1000
callq 0x17b40
movq %rax, %r12
movl %r12d, 0xa0(%rbx)
movq 0xb0(%rbx), %rdi
callq 0x17f00
testl %eax, %eax
jne 0x19ef3f
movl $0x0, 0xa4(%rbx)
testl %r12d, %r12d
je 0x19eee4
movq 0xa8(%rbx), %rdi
xorl %eax, %eax
movl %eax, %ecx
incl %eax
movl %eax, 0xa4(%rbx)
movq (%rdi,%rcx,8), %rcx
movq %rcx, (%r14,%r13,8)
incq %r13
cmpq %r13, %r15
jne 0x19ee76
movq %r15, %r13
movq -0x30(%rbp), %r12
jmp 0x19eeed
xorl %r13d, %r13d
leaq 0x10(%rbp), %rbx
movq -0x38(%rbp), %rdi
movq %r14, %rsi
movq -0x40(%rbp), %rdx
movq %r13, %rcx
callq *-0x48(%rbp)
movq (%rbx), %rdx
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x19ef1e
movq %rdx, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %r13, %rcx
callq *%rax
jmp 0x19ef2d
imulq %r13, %rdx
movq %r12, %rdi
movq %r14, %rsi
callq 0x17660
movq %r13, %rax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x6081a
callq 0x60842
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/eis-suffixarray-interface.c
// Function: gt_SAIMakeBWTReader
struct seqDataReader
gt_SAIMakeBWTReader(SuffixarrayFileInterface *sai)
{
  struct seqDataReader reader = { NULL, NULL};
  if (!sai->sa->bwttabstream.fp || sai->numBWTFileReaders > 0)
  {
    if (sai->sa->encseq)
    {
      struct encSeqTrState bwtReadState = {
        .readmode = sai->sa->readmode,
        .encseq = sai->sa->encseq
      };
      struct saTaggedXltorState *stateStore
        = gt_addSuffixarrayXltor(&sai->xltorStates,
                              SFX_REQUEST_BWTTAB, bwtReadState);
      struct seqDataTranslator xltor = {
        { .ref = &stateStore->state },
        gt_translateSuftab2BWT,
        gt_translateSuftab2BWTSuffixsortspace
      };

      reader = gt_seqReaderSetRegisterConsumer(&sai->baseClass.readerSet,
                                            SFX_REQUEST_BWTTAB, xltor);
    }
    else
    {
      fputs("error: bwt data not available for given project.\n", stderr);
    }
  }
  else
  {
    /* a .bwt file is available for reading */
    reader.readData = (seqDataReadFunc)SAIReadBWT;
    reader.src = sai;
    ++sai->numBWTFileReaders;
  }
  return reader;
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0xd0(%rdi), %rax
cmpq $0x0, 0xc8(%rax)
je 0x19effc
movb 0xd8(%rbx), %cl
testb %cl, %cl
jle 0x19f05d
movq (%rax), %rdx
testq %rdx, %rdx
je 0x19f075
movl 0x48(%rax), %ecx
leaq 0xc0(%rbx), %rdi
movl $0x2, %esi
callq 0x19e4c4
addq $0x8, %rax
movq %rax, 0x18(%rsp)
leaq -0xc78(%rip), %rax      # 0x19e3b0
movq %rax, 0x20(%rsp)
leaq -0xc26(%rip), %rax      # 0x19e40e
movq %rax, 0x28(%rsp)
addq $0x50, %rbx
movq %rax, 0x10(%rsp)
movups 0x18(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
movl $0x2, %esi
callq 0x19e600
movq %rax, %rbx
jmp 0x19f06c
incb %cl
movb %cl, 0xd8(%rbx)
leaq 0x14(%rip), %rdx        # 0x19f080
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
retq
callq 0x6087b
xorl %edx, %edx
xorl %ebx, %ebx
jmp 0x19f06c
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/eis-suffixarray-interface.c
// Function: gt_SANewMRAEnc
MRAEnc *
gt_SANewMRAEnc(const GtAlphabet *gtalphabet)
{
  MRAEnc *alphabet;
  gt_assert(gtalphabet != NULL);
  alphabet = gt_MRAEncGTAlphaNew(gtalphabet);
  gt_MRAEncAddSymbolToRange(alphabet, GT_SEPARATOR, 1);
  return alphabet;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x19f14d
callq 0x19d94c
movq %rax, %rbx
movq %rax, %rdi
movl $0xff, %esi
movl $0x1, %edx
callq 0x19e1bf
movq %rbx, %rax
popq %rbx
retq
callq 0x60949
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/eis-suffixerator-interface.c
// Function: gt_SfxIGetOrigSeq
size_t
gt_SfxIGetOrigSeq(const void *state, Symbol *dest, GtUword pos,
                  size_t len)
{
  const struct sfxInterface *sfxi;
  gt_assert(state);
  sfxi = state;
  return EncSeqGetSubSeq(sfxi->encseq, sfxi->readmode, pos, len, dest);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x19f523
movq 0xe0(%rdi), %r12
testq %r12, %r12
je 0x19f528
movq %rcx, %rbx
testq %rcx, %rcx
je 0x19f511
movq %rdx, %r14
movq %rsi, %r15
movl 0xc0(%rdi), %ebp
xorl %r13d, %r13d
leaq (%r14,%r13), %rsi
movq %r12, %rdi
movl %ebp, %edx
callq 0xe7bbc
movb %al, (%r15,%r13)
incq %r13
cmpq %r13, %rbx
jne 0x19f4f7
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x60a5a
callq 0x60a23
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/eis-suffixerator-interface.c
// Function: gt_deleteSfxInterface
void
gt_deleteSfxInterface(sfxInterface *sfxi)
{
  destructSASeqSrc(&sfxi->baseClass);
  (void) gt_Sfxiterator_delete(sfxi->sfi,NULL);
  sfxi->sfi = NULL;
  deleteSeqStats(sfxi->stats);
  gt_free(sfxi);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x48(%rdi), %rdi
testq %rdi, %rdi
je 0x19f7b6
callq 0x19e389
leaq 0xb0(%rbx), %rdi
callq 0x19e486
leaq 0x50(%rbx), %rdi
callq 0x19e587
movq 0xf0(%rbx), %rdi
xorl %esi, %esi
callq 0x1f68c4
movq $0x0, 0xf0(%rbx)
movq 0xe8(%rbx), %rdi
leaq 0x2044d4(%rip), %r14    # 0x3a3cc6
movq %r14, %rsi
movl $0xd4, %edx
callq 0x1045eb
movq %rbx, %rdi
movq %r14, %rsi
movl $0x127, %edx            # imm = 0x127
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1045eb
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/eis-suffixerator-interface.c
// Function: gt_SfxINewMRAEnc
MRAEnc *
gt_SfxINewMRAEnc(const sfxInterface *si)
{
  MRAEnc *alphabet;
  gt_assert(si);
  alphabet = gt_MRAEncGTAlphaNew(gt_SfxIGetAlphabet(si));
  gt_MRAEncAddSymbolToRange(alphabet, GT_SEPARATOR, 1);
  return alphabet;
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x19f84a
movq 0xd8(%rdi), %rdi
callq 0x19d94c
movq %rax, %rbx
movq %rax, %rdi
movl $0xff, %esi
movl $0x1, %edx
callq 0x19e1bf
movq %rbx, %rax
popq %rbx
retq
callq 0x60b05
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/eis-voiditf.c
// Function: gt_bwtseqfirstmatch
GtUword gt_bwtseqfirstmatch(const FMindex *fmindex,
                                  GtUword bound)
{
  struct extBitsRetrieval extBits;
  GtUword pos;

  initExtBitsRetrieval(&extBits);
  pos = gt_BWTSeqLocateMatch((const BWTSeq *) fmindex,bound,&extBits);
  destructExtBitsRetrieval(&extBits);
  return pos;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, 0x20(%r14)
movaps %xmm0, 0x10(%r14)
movaps %xmm0, (%r14)
movq $0x0, 0x30(%r14)
movq %r14, %rdx
callq 0x19ae8c
movq %rax, %rbx
movl 0x30(%r14), %eax
testb $0x1, %al
je 0x19f945
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x19f945
leaq 0x202add(%rip), %rsi    # 0x3a2414
movl $0x87, %edx
callq 0x1045eb
movl 0x30(%rsp), %eax
testb $0x4, %al
je 0x19f964
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x19f964
leaq 0x202aba(%rip), %rsi    # 0x3a2414
movl $0x89, %edx
callq 0x1045eb
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/eis-voiditf.c
// Function: gt_Bwtseqpositioniterator_new
Bwtseqpositioniterator *gt_Bwtseqpositioniterator_new(const FMindex *fmindex,
                                                      GtUword lowerbound,
                                                      GtUword upperbound)
{
  Bwtseqpositioniterator *bspi;

  bspi = gt_malloc(sizeof (*bspi));
  initExtBitsRetrieval(&bspi->extBits);
  bspi->bwtseq = (const BWTSeq *) fmindex;
  bspi->currentbound = lowerbound;
  bspi->upperbound = upperbound;
  return bspi;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x204426(%rip), %rsi    # 0x3a3daa
movl $0x50, %edi
movl $0x37, %edx
callq 0x104226
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movq $0x0, 0x30(%rax)
movq %r15, 0x38(%rax)
movq %r14, 0x40(%rax)
movq %rbx, 0x48(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/eis-voiditf.c
// Function: gt_Bwtseqpositioniterator_next
bool gt_Bwtseqpositioniterator_next(GtUword *pos,
                                    Bwtseqpositioniterator *bspi)
{
  if (bspi->currentbound < bspi->upperbound)
  {
    *pos = gt_BWTSeqLocateMatch(bspi->bwtseq,bspi->currentbound,&bspi->extBits);
    bspi->currentbound++;
    return true;
  }
  return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x40(%rsi), %rbx
movq 0x48(%rsi), %r12
cmpq %r12, %rbx
jae 0x19f9ec
movq %rsi, %r14
movq %rdi, %r15
movq 0x38(%rsi), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x19ae8c
movq %rax, (%r15)
incq 0x40(%r14)
cmpq %r12, %rbx
setb %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/eis-voiditf.c
// Function: gt_BwtseqpositionwithoutSEPiterator_next
bool gt_BwtseqpositionwithoutSEPiterator_next(GtUword *pos,
                                              Bwtseqpositioniterator *bspi)
{
  while (bspi->currentbound < bspi->upperbound)
  {
    GtUchar cc;

    if (bspi->currentbound != BWTSeqTerminatorPos(bspi->bwtseq))
    {
      cc = BWTSeqGetSym(bspi->bwtseq, bspi->currentbound);
    } else
    {
      cc = GT_SEPARATOR;
    }
    if (cc != GT_SEPARATOR)
    {
      *pos = gt_BWTSeqLocateMatch(bspi->bwtseq,
                                  bspi->currentbound,
                                  &bspi->extBits);
      bspi->currentbound++;
      return true;
    }
    bspi->currentbound++;
  }
  return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq 0x40(%rsi), %rsi
movq 0x48(%rbx), %rax
cmpq %rax, %rsi
jae 0x19fa63
movq %rdi, %r14
movq 0x38(%rbx), %rcx
cmpq 0x30(%rcx), %rsi
je 0x19fa57
movq (%rcx), %rdi
testq %rdi, %rdi
je 0x19fa82
movq 0x18(%rcx), %rdx
testq %rdx, %rdx
je 0x19fa82
movq (%rdi), %rax
movq 0x8(%rdi), %r15
callq *0x30(%rax)
cmpl $0x1, (%r15)
jne 0x19fa87
movzbl %al, %eax
cmpb $-0x1, 0x118(%r15,%rax)
movq 0x40(%rbx), %rsi
jne 0x19fa6b
movq 0x48(%rbx), %rax
incq %rsi
movq %rsi, 0x40(%rbx)
cmpq %rax, %rsi
jb 0x19fa16
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq 0x38(%rbx), %rdi
movq %rbx, %rdx
callq 0x19ae8c
movq %rax, (%r14)
incq 0x40(%rbx)
movb $0x1, %al
jmp 0x19fa65
callq 0x60b99
callq 0x173b0
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/eis-voiditf.c
// Function: gt_newBwtSeqpositionextractor
BwtSeqpositionextractor *gt_newBwtSeqpositionextractor(
                                                     const FMindex *voidbwtseq,
                                                     GtUword upperbound)
{
  BwtSeqpositionextractor *bspex;

  bspex = gt_malloc(sizeof (*bspex));
  initExtBitsRetrieval(&bspex->extBits);
  bspex->bwtseq = (const BWTSeq *) voidbwtseq;
  bspex->upperbound = upperbound;
  return bspex;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x2042b2(%rip), %rsi    # 0x3a3daa
movl $0x48, %edi
movl $0x79, %edx
callq 0x104226
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movq $0x0, 0x30(%rax)
movq %r14, 0x38(%rax)
movq %rbx, 0x40(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/eis-voiditf.c
// Function: gt_Bwtseqcontextiterator_new
Bwtseqcontextiterator *gt_Bwtseqcontextiterator_new(const FMindex *fmindex,
                                                    GtUword bound)
{
  Bwtseqcontextiterator *bsci;

  bsci = gt_malloc(sizeof (*bsci));
  initExtBitsRetrieval(&bsci->extBits);
  bsci->bwtseq = (const BWTSeq *) fmindex;
  bsci->bound = bound;
  return bsci;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x2041f9(%rip), %rsi    # 0x3a3daa
movl $0x48, %edi
movl $0x9c, %edx
callq 0x104226
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movq $0x0, 0x30(%rax)
movq %r14, 0x38(%rax)
movq %rbx, 0x40(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/eis-voiditf.c
// Function: gt_loadvoidBWTSeqForSA
FMindex *gt_loadvoidBWTSeqForSA(const char *indexname,
                                bool withpckbt,
                                GtError *err)
{
  BWTSeq *bwtseq = NULL;
  bool haserr = false;
  GtEncseqMetadata *emd;
  GtAlphabet *alphabet;

  emd = gt_encseq_metadata_new(indexname, err);
  if (emd == NULL) {
    gt_assert(gt_error_is_set(err));
    haserr = true;
  }
  if (!haserr) {
    alphabet = gt_encseq_metadata_alphabet(emd);
    if (alphabet == NULL)
    {
      gt_assert(gt_error_is_set(err));
      haserr = true;
    }
  }
  if (!haserr)
  {
    bwtseq = gt_loadBWTSeqForSA(indexname,
                                BWT_ON_BLOCK_ENC,
                                BWTDEFOPT_MULTI_QUERY,
                                alphabet,
                                err);
    if (bwtseq == NULL)
    {
      gt_assert(gt_error_is_set(err));
      haserr = true;
    }
  }
  if (!haserr)
  {
    if (withpckbt && gt_pckbuckettable_exists(indexname))
    {
      unsigned int numofchars = gt_alphabet_num_of_chars(alphabet);
      bwtseq->pckbuckettable = gt_pckbuckettable_map(indexname,numofchars,err);
      if (bwtseq->pckbuckettable == NULL)
      {
        gt_assert(gt_error_is_set(err));
        haserr = true;
      }
    } else
    {
      bwtseq->pckbuckettable = NULL;
    }
  }
  gt_encseq_metadata_delete(emd);
  if (haserr && bwtseq != NULL)
  {
    gt_deletevoidBWTSeq((FMindex *) bwtseq);
    bwtseq = NULL;
  }
  return haserr ? NULL : (FMindex *) bwtseq;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %r12
movq %rdx, %rsi
callq 0xfb8bc
movq %rax, %rbx
testq %rax, %rax
je 0x19ffd6
movq %rbx, %rdi
callq 0xfbec4
testq %rax, %rax
je 0x19ffe7
movq %rax, %r13
movq %r12, %rdi
movl $0x2, %esi
movl $0x2, %edx
movq %rax, %rcx
movq %r15, %r8
callq 0x1990b6
testq %rax, %rax
je 0x1a0002
movq %rax, %r14
testb %bpl, %bpl
je 0x19fff8
movq %r12, %rdi
callq 0x1b8775
testb %al, %al
je 0x19fff8
movq %r13, %rdi
callq 0xd11be
movq %r12, %rdi
movl %eax, %esi
movq %r15, %rdx
callq 0x1b87b2
movq %rax, 0x50(%r14)
testq %rax, %rax
jne 0x1a0011
movq %r15, %rdi
callq 0xfcc32
testb %al, %al
je 0x1a0030
movq %rbx, %rdi
callq 0xfbf9f
movq %r14, %rdi
callq 0x1a0035
xorl %r14d, %r14d
jmp 0x1a0019
movq %r15, %rdi
callq 0xfcc32
testb %al, %al
jne 0x1a000e
callq 0x60f9d
movq %r15, %rdi
callq 0xfcc32
testb %al, %al
jne 0x1a000e
callq 0x60f64
movq $0x0, 0x50(%r14)
jmp 0x1a0011
movq %r15, %rdi
callq 0xfcc32
testb %al, %al
je 0x1a002b
xorl %r14d, %r14d
movq %rbx, %rdi
callq 0xfbf9f
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x60f2b
callq 0x60ef2
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/eis-voiditf.c
// Function: gt_deletevoidBWTSeq
void gt_deletevoidBWTSeq(FMindex *fmindex)
{
  BWTSeq *bwtseq = (BWTSeq *) fmindex;

  if (bwtseq->pckbuckettable != NULL)
  {
    gt_pckbuckettable_delete(bwtseq->pckbuckettable);
    bwtseq->pckbuckettable = NULL;
  }
  gt_deleteBWTSeq(bwtseq);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x50(%rdi), %rdi
testq %rdi, %rdi
je 0x1a004f
callq 0x1b8124
movq $0x0, 0x50(%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0x19bd88
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/eis-voiditf.c
// Function: gt_bwtrangesplitwithoutspecial
void gt_bwtrangesplitwithoutspecial(GtArrayBoundswithchar *bwci,
                                    GtUword *rangeOccs,
                                    const FMindex *fmindex,
                                    GtUword lbound,
                                    GtUword ubound)
{
  const BWTSeq *bwtseq = (const BWTSeq *) fmindex;
  AlphabetRangeSize idx, rangesize;

  rangesize = MRAEncGetRangeSize(EISGetAlphabet(bwtseq->seqIdx),0);
  bwci->nextfreeBoundswithchar = 0;
  BWTSeqPosPairRangeOcc(bwtseq, 0, lbound, ubound,rangeOccs);
  for (idx = 0; idx < rangesize; idx++)
  {
    if (rangeOccs[idx] < rangeOccs[rangesize+idx])
    {
      bwci->spaceBoundswithchar[bwci->nextfreeBoundswithchar].inchar = idx;
      bwci->spaceBoundswithchar[bwci->nextfreeBoundswithchar].lbound
        = bwtseq->count[idx] + rangeOccs[idx];
      bwci->spaceBoundswithchar[bwci->nextfreeBoundswithchar++].rbound
        = bwtseq->count[idx] + rangeOccs[rangesize+idx];
    }
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq (%rdx), %rax
testq %rax, %rax
je 0x1a0159
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x1a015e
cmpl $0x0, 0x4(%rax)
je 0x1a0163
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x10(%rax), %rax
movzwl (%rax), %r12d
movq $0x0, 0x10(%rdi)
movq %rdx, %rdi
xorl %esi, %esi
movq %rcx, %rdx
movq %r8, %rcx
movq %r14, %r8
callq 0x1a0178
testq %r12, %r12
je 0x1a014d
leaq (%r14,%r12,8), %rax
xorl %ecx, %ecx
movq (%r14,%rcx,8), %rdx
cmpq (%rax,%rcx,8), %rdx
jae 0x1a0145
movq (%r15), %rsi
movq 0x10(%r15), %rdi
leaq (%rdi,%rdi,2), %r8
movb %cl, 0x10(%rsi,%r8,8)
movq 0x38(%rbx), %r9
addq (%r9,%rcx,8), %rdx
movq %rdx, (%rsi,%r8,8)
movq (%rax,%rcx,8), %rdx
addq (%r9,%rcx,8), %rdx
incq %rdi
movq %rdi, 0x10(%r15)
movq %rdx, 0x8(%rsi,%r8,8)
incq %rcx
cmpq %rcx, %r12
jne 0x1a010b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x610ef
callq 0x610b8
callq 0x61081
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/eis-bwtseq-siop.h
// Function: BWTSeqPosPairRangeOcc
static inline void
BWTSeqPosPairRangeOcc(const BWTSeq *bwtSeq, AlphabetRangeID range,
                      GtUword posA, GtUword posB,
                      GtUword *rangeOccs)
{
  gt_assert(bwtSeq && rangeOccs);
  gt_assert(posA <= posB);
  gt_assert(range < MRAEncGetNumRanges(BWTSeqGetAlphabet(bwtSeq)));
  EISPosPairRangeRank(bwtSeq->seqIdx, range, posA, posB, rangeOccs,
                      bwtSeq->hint);
  if (range == bwtSeq->bwtTerminatorFallbackRange)
  {
    const MRAEnc *alphabet = BWTSeqGetAlphabet(bwtSeq);
    AlphabetRangeSize rSize = MRAEncGetRangeSize(alphabet, range),
      termIdx = MRAEncMapSymbol(alphabet, bwtTerminatorSym)
      - MRAEncGetRangeBase(alphabet, range),
      fbIdx = bwtSeq->bwtTerminatorFallback
      - MRAEncGetRangeBase(alphabet, range);
    memmove(rangeOccs + termIdx + 1, rangeOccs + termIdx,
            sizeof (rangeOccs[0]) * (rSize - 1));
    rangeOccs[termIdx] = rangeOccs[termIdx + rSize] = 0;
    if (posB > BWTSeqTerminatorPos(bwtSeq))
    {
      rangeOccs[termIdx + rSize] = 1;
      --(rangeOccs[fbIdx + rSize]);
      if (posA > BWTSeqTerminatorPos(bwtSeq))
      {
        rangeOccs[termIdx] = 1;
        --(rangeOccs[fbIdx]);
      }
      else
        rangeOccs[termIdx] = 0;
    }
    else
      rangeOccs[rSize + termIdx] = rangeOccs[termIdx] = 0;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
testq %rdi, %rdi
je 0x1a02d9
movq %r8, %rbx
testq %r8, %r8
je 0x1a02d9
movq %rcx, %r12
movq %rdx, %rbp
cmpq %rcx, %rdx
ja 0x1a02de
movl %esi, %r13d
movq %rdi, %r15
movq 0x8(%rdi), %rax
cmpl %esi, 0x4(%rax)
jbe 0x1a02e3
movq (%r15), %rdi
movq 0x18(%r15), %r9
movq (%rdi), %rax
movl %r13d, %esi
movq %rbp, %rdx
movq %r12, %rcx
movq %rbx, %r8
callq *0x20(%rax)
cmpl %r13d, 0x28(%r15)
jne 0x1a02ca
movq 0x8(%r15), %rcx
testq %rcx, %rcx
je 0x1a02e8
cmpl %r13d, 0x4(%rcx)
jbe 0x1a02ed
cmpl $0x1, (%rcx)
jne 0x1a02f2
movq 0x10(%rcx), %rax
movl %r13d, %edx
movzwl (%rax,%rdx,2), %r14d
movzbl 0x114(%rcx), %eax
testl %r13d, %r13d
movq %rbp, 0x10(%rsp)
je 0x1a0233
movq 0x8(%rcx), %rcx
decl %r13d
movzbl (%rcx,%r13,2), %ecx
movzwl %ax, %eax
movl %ecx, (%rsp)
subl %ecx, %eax
jmp 0x1a023a
movl $0x0, (%rsp)
movzbl 0x24(%r15), %ecx
movl %ecx, 0x4(%rsp)
movzwl %ax, %r13d
leaq (%rbx,%r13,8), %rsi
leaq (%rbx,%r13,8), %rbp
addq $0x8, %rbp
leaq -0x8(,%r14,8), %rdx
movq %rbp, %rdi
movq %rsi, 0x8(%rsp)
callq 0x17cd0
addl %r14d, %r13d
xorl %eax, %eax
movq %rax, (%rbx,%r13,8)
movq %rax, -0x8(%rbp)
cmpq %r12, 0x30(%r15)
jae 0x1a02b4
movzwl (%rsp), %eax
movl 0x4(%rsp), %ecx
subl %eax, %ecx
movq $0x1, (%rbx,%r13,8)
movzwl %cx, %eax
addl %eax, %r14d
decq (%rbx,%r14,8)
movq 0x10(%rsp), %rcx
cmpq %rcx, 0x30(%r15)
jae 0x1a02be
movq 0x8(%rsp), %rcx
movq $0x1, (%rcx)
decq (%rbx,%rax,8)
jmp 0x1a02ca
movq $0x0, (%rbx,%r13,8)
jmp 0x1a02ca
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x6115d
callq 0x6123d
callq 0x61196
callq 0x61206
callq 0x611cf
callq 0x173b0
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/eis-voiditf.c
// Function: gt_bwtrangesplitallwithoutspecial
GtUword gt_bwtrangesplitallwithoutspecial(Mbtab *mbtab,
                                                GtUword *rangeOccs,
                                                const FMindex *fmindex,
                                                GtUword lbound,
                                                GtUword ubound)
{
  const BWTSeq *bwtseq = (const BWTSeq *) fmindex;
  AlphabetRangeSize idx, rangesize
    = MRAEncGetRangeSize(EISGetAlphabet(bwtseq->seqIdx),0);

  gt_assert(sizeof (AlphabetRangeSize) <= sizeof (GtUword));
  BWTSeqPosPairRangeOcc(bwtseq, 0, lbound, ubound,rangeOccs);
  for (idx = 0; idx < rangesize; idx++)
  {
    if (rangeOccs[idx] < rangeOccs[rangesize+idx])
    {
      mbtab[idx].lowerbound = bwtseq->count[idx] + rangeOccs[idx];
      mbtab[idx].upperbound = bwtseq->count[idx] + rangeOccs[rangesize+idx];
    } else
    {
      mbtab[idx].lowerbound = mbtab[idx].upperbound = 0;
    }
  }
  return (GtUword) rangesize;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq (%rdx), %rax
testq %rax, %rax
je 0x1a03a3
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x1a03a8
cmpl $0x0, 0x4(%rax)
je 0x1a03ad
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x10(%rax), %rax
movzwl (%rax), %r12d
movq %rdx, %rdi
xorl %esi, %esi
movq %rcx, %rdx
movq %r8, %rcx
movq %r14, %r8
callq 0x1a0178
testq %r12, %r12
je 0x1a0391
leal (,%r12,8), %eax
leaq (%r14,%rax), %rcx
xorl %edx, %edx
xorps %xmm0, %xmm0
movq (%r14,%rdx), %rsi
cmpq (%rcx,%rdx), %rsi
jae 0x1a0381
movq 0x38(%rbx), %rdi
addq (%rdi,%rdx), %rsi
movq %rsi, (%r15,%rdx,2)
movq (%rcx,%rdx), %rsi
addq (%rdi,%rdx), %rsi
movq %rsi, 0x8(%r15,%rdx,2)
jmp 0x1a0386
movups %xmm0, (%r15,%rdx,2)
addq $0x8, %rdx
cmpq %rdx, %rax
jne 0x1a035c
jmp 0x1a0394
xorl %r12d, %r12d
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x612e4
callq 0x612ad
callq 0x61276
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/eis-voiditf.c
// Function: gt_bwtrangesplitallwithspecial
GtUword gt_bwtrangesplitallwithspecial(Mbtab *mbtab,
                                             GtUword *rangeOccs,
                                             const FMindex *voidBwtSeq,
                                             GtUword lbound,
                                             GtUword ubound)
{
  GtUword char_idx, range_idx, rangebase;
  const BWTSeq *bwtseq = (const BWTSeq *) voidBwtSeq;
  const MRAEnc *alphabet = BWTSeqGetAlphabet(bwtseq);
  AlphabetRangeID numofranges = MRAEncGetNumRanges(alphabet);
  AlphabetRangeSize rangesize = 0, totalrange = 0;

  for (range_idx = 0; range_idx < (GtUword) numofranges; range_idx++)
  {
    GtUword rangeOcc_idx = 0;
    rangesize = MRAEncGetRangeSize(alphabet, range_idx);
    totalrange += rangesize;
    BWTSeqPosPairRangeOcc(bwtseq, range_idx, lbound, ubound,rangeOccs);
    rangebase = (GtUword) MRAEncGetRangeBase(alphabet, range_idx);
    for (char_idx = rangebase;
         char_idx < rangebase + rangesize; char_idx++)
    {
      if (rangeOccs[rangeOcc_idx] < rangeOccs[rangesize+rangeOcc_idx])
      {
        mbtab[char_idx].lowerbound = bwtseq->count[char_idx] +
                                     rangeOccs[rangeOcc_idx];
        mbtab[char_idx].upperbound = bwtseq->count[char_idx] +
                                     rangeOccs[rangesize+rangeOcc_idx];
      } else
      {
        mbtab[char_idx].lowerbound = mbtab[char_idx].upperbound = 0;
      }
      rangeOcc_idx++;
    }
  }
  return totalrange;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
movq 0x8(%rdx), %rax
movq %rax, (%rsp)
movl 0x4(%rax), %r13d
testq %r13, %r13
je 0x1a04b7
movq %rdx, %r15
movq %rsi, %r12
xorl %ecx, %ecx
movl %r13d, %eax
xorl %ebp, %ebp
movq (%rsp), %r14
movq %rcx, 0x20(%rsp)
cmpl %ebp, %eax
jbe 0x1a04cd
movq 0x10(%r14), %rax
movzwl (%rax,%rbp,2), %ebx
movq %r15, %rdi
movl %ebp, %esi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq %r12, %r8
callq 0x1a0178
movl 0x4(%r14), %eax
cmpl %ebp, %eax
jbe 0x1a04c8
testq %rbp, %rbp
je 0x1a0443
movq (%rsp), %rcx
movq 0x8(%rcx), %rcx
leal -0x1(%rbp), %edx
movzbl (%rcx,%rdx,2), %ecx
jmp 0x1a0445
xorl %ecx, %ecx
xorps %xmm0, %xmm0
testq %rbx, %rbx
je 0x1a049f
leaq (%rcx,%rbx), %rdx
leaq (%r12,%rbx,8), %rsi
movl %ecx, %edi
shll $0x4, %edi
addq 0x8(%rsp), %rdi
movl $0x4, %r8d
movq -0x4(%r12,%r8), %r9
cmpq -0x4(%rsi,%r8), %r9
jae 0x1a048d
movq 0x38(%r15), %r10
addq (%r10,%rcx,8), %r9
movq %r9, -0x8(%rdi,%r8,2)
movq -0x4(%rsi,%r8), %r9
addq (%r10,%rcx,8), %r9
movq %r9, (%rdi,%r8,2)
jmp 0x1a0493
movups %xmm0, -0x8(%rdi,%r8,2)
incq %rcx
addq $0x8, %r8
cmpq %rdx, %rcx
jb 0x1a0465
movq 0x20(%rsp), %rcx
addl %ebx, %ecx
incq %rbp
cmpq %r13, %rbp
jne 0x1a03f5
movzwl %cx, %eax
jmp 0x1a04b9
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x61352
callq 0x6131b
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/eis-voiditf.c
// Function: gt_voidpackedfindfirstmatchconvert
GtUword gt_voidpackedfindfirstmatchconvert(const FMindex *fmindex,
                                                 GtUword witnessbound,
                                                 GtUword matchlength)
{
  const BWTSeq *bwtseq = (const BWTSeq *) fmindex;
  GtUword startpos;

  startpos = gt_bwtseqfirstmatch(fmindex,witnessbound);
  gt_assert((bwtseq->seqIdx->seqLen-1) >= (startpos + matchlength));
  return (bwtseq->seqIdx->seqLen - 1) - (startpos + matchlength);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
callq 0x19f8f0
movq %rax, %rcx
movq (%r14), %rax
movq 0x10(%rax), %rax
decq %rax
addq %rbx, %rcx
subq %rcx, %rax
jb 0x1a050b
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x61389
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/eis-voiditf.c
// Function: gt_voidpackedindexmstatsforward
GtUword gt_voidpackedindexmstatsforward(const void *fmindex,
                                              GT_UNUSED GtUword offset,
                                              GT_UNUSED GtUword left,
                                              GT_UNUSED GtUword right,
                                              GtUword *witnessposition,
                                              const GtUchar *qstart,
                                              const GtUchar *qend)
{
  const BWTSeq *bwtseq = (const BWTSeq *) fmindex;
  GtUword matchlength;

  matchlength = gt_packedindexmstatsforward(bwtseq,witnessposition,qstart,qend);
  if (matchlength > 0 && witnessposition != NULL)
  {
    *witnessposition = gt_voidpackedfindfirstmatchconvert(fmindex,
                                                          *witnessposition,
                                                          matchlength);
  }
  return matchlength;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %r9, %rdx
movq %r8, %rbx
movq %rdi, %r14
movq 0x20(%rsp), %rcx
movq %r8, %rsi
callq 0x19bf05
movq %rax, %r15
testq %rax, %rax
sete %al
testq %rbx, %rbx
sete %cl
orb %al, %cl
jne 0x1a054f
movq (%rbx), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x1a04df
movq %rax, (%rbx)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/eis-voiditf.c
// Function: gt_pck_exactpatternmatching
bool gt_pck_exactpatternmatching(const FMindex *fmindex,
                                 const GtUchar *pattern,
                                 GtUword patternlength,
                                 GtUword totallength,
                                 const GtUchar *dbsubstring,
                                 ProcessIdxMatch processmatch,
                                 void *processmatchinfo)
{
  BWTSeqExactMatchesIterator *bsemi;
  GtUword dbstartpos, numofmatches;
  GtIdxMatch match;

  bsemi = gt_newEMIterator((const BWTSeq *) fmindex,
                           pattern,(size_t) patternlength, true);
  gt_assert(bsemi != NULL);
  numofmatches = gt_EMINumMatchesTotal(bsemi);
  match.dbabsolute = true;
  match.dblen = patternlength;
  match.dbsubstring = dbsubstring;
  match.querystartpos = 0;
  match.querylen = patternlength;
  match.distance = 0;
  match.alignment = NULL;
  while (EMIGetNextMatch(bsemi,&dbstartpos,(const BWTSeq *) fmindex))
  {
    gt_assert(totallength >= (dbstartpos + patternlength));
    match.dbstartpos = totallength - (dbstartpos + patternlength);
    processmatch(processmatchinfo,&match);
  }
  if (bsemi != NULL)
  {
    gt_deleteEMIterator(bsemi);
    bsemi = NULL;
  }
  return numofmatches > 0 ? true : false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r9, %rbx
movq %r8, %rbp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %r12
movl $0x1, %ecx
callq 0x19c2b7
testq %rax, %rax
je 0x1a062b
movq %rax, %r13
movq %rax, %rdi
callq 0x19c3a8
movq %rax, 0x8(%rsp)
movb $0x1, 0x10(%rsp)
movq %r15, 0x28(%rsp)
movq %rbp, 0x30(%rsp)
movq $0x0, 0x38(%rsp)
movq %r15, 0x40(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%rsp)
movq 0x10(%r13), %rsi
cmpq 0x8(%r13), %rsi
jae 0x1a0606
movq %r13, %rbp
addq $0x18, %rbp
movq %r12, %rdi
movq %rbp, %rdx
callq 0x19ae8c
incq 0x10(%r13)
addq %r15, %rax
movq %r14, %rcx
subq %rax, %rcx
jb 0x1a0626
movq %rcx, 0x20(%rsp)
movq 0x90(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq *%rbx
movq 0x10(%r13), %rsi
cmpq 0x8(%r13), %rsi
jb 0x1a05ce
movq %r13, %rdi
callq 0x19c397
cmpq $0x0, 0x8(%rsp)
setne %al
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x613c2
callq 0x613fb