LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/eis-encidxseq-construct.c
// Function: gt_createEncIdxSeqFromSfxI
EISeq *
gt_createEncIdxSeqFromSfxI(sfxInterface *sfxi,
                        const char *projectName,
                        const struct seqBaseParam *params,
                        size_t numExtHeaders, const uint16_t *headerIDs,
                        const uint32_t *extHeaderSizes,
                        headerWriteFunc *extHeaderCallbacks,
                        void **headerCBData,
                        bitInsertFunc biFunc, BitOffset cwExtBitsPerPos,
                        varExtBitsEstimator biVarBits, void *cbState,
                        GtError *err)
{
  gt_assert(sfxi && projectName && err);
  return gt_createEncIdxSeqFromSASeqSrc(
    gt_SfxI2SASS(sfxi), projectName, params,
    numExtHeaders, headerIDs, extHeaderSizes,
    extHeaderCallbacks, headerCBData, biFunc,
    cwExtBitsPerPos, biVarBits, cbState, err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x1a5609
movq %rsi, %r13
testq %rsi, %rsi
je 0x1a5609
cmpq $0x0, 0x60(%rsp)
je 0x1a5609
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
callq 0x1a789c
movq %rax, %rdi
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
movq %rbx, %r9
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1a54d4
callq 0x61581
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/eis-encidxseq-construct.c
// Function: gt_loadEncIdxSeqForSA
struct encIdxSeq *
gt_loadEncIdxSeqForSA(const GtAlphabet *gtalphabet,
                   const char *projectName,
                   enum seqBaseEncoding encType, int features, GtError *err)
{
  MRAEnc *alphabet;
  EISeq *seqIdx = NULL;
  gt_assert(gtalphabet!=NULL);
  alphabet = gt_SANewMRAEnc(gtalphabet);
  switch (encType)
  {
  case BWT_ON_BLOCK_ENC:
    seqIdx = gt_loadBlockEncIdxSeqGen(alphabet, projectName, features,
                                   err);
    break;
  default:
    gt_error_set(err, "Illegal/unknown/unimplemented encoding requested!");
    break;
  }
  gt_assert(seqIdx != NULL || gt_error_is_set(err));
  return seqIdx;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1a56a0
movq %r8, %rbx
movl %ecx, %ebp
movl %edx, %r15d
movq %rsi, %r14
callq 0x1a7872
cmpl $0x2, %r15d
jne 0x1a566d
movq %rax, %rdi
movq %r14, %rsi
movl %ebp, %edx
movq %rbx, %rcx
callq 0x314774
movq %rax, %r14
jmp 0x1a5681
leaq 0x207345(%rip), %rsi    # 0x3ac9b9
xorl %r14d, %r14d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1019cf
testq %r14, %r14
jne 0x1a5692
movq %rbx, %rdi
callq 0x101a9a
testb %al, %al
je 0x1a56a5
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x615f1
callq 0x615b8
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/eis-encidxseq-construct.c
// Function: gt_loadEncIdxSeq
EISeq *
gt_loadEncIdxSeq(const char *projectName,
                 enum seqBaseEncoding encType, int features,
                 GT_UNUSED GtLogger *verbosity, GtError *err)
{
  struct encIdxSeq *newSeqIdx = NULL;
  GtEncseq *encseq = NULL;
  GtEncseqLoader *el = NULL;
  do
  {
    el = gt_encseq_loader_new();
    gt_encseq_loader_do_not_require_sds_tab(el);
    gt_encseq_loader_do_not_require_des_tab(el);
    gt_encseq_loader_do_not_require_ssp_tab(el);
    encseq = gt_encseq_loader_load(el, projectName, err);
    gt_encseq_loader_delete(el);
    if (encseq == NULL)
      break;
    newSeqIdx = gt_loadEncIdxSeqForSA(gt_encseq_alphabet(encseq),
                                      projectName,
                                      encType, features, err);
    gt_encseq_delete(encseq);
  } while (0);
  return newSeqIdx;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %r15
callq 0xf36ef
movq %rax, %r13
movq %rax, %rdi
callq 0xf6a49
movq %r13, %rdi
callq 0xf69ed
movq %r13, %rdi
callq 0xf6a1a
movq %r13, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0xf374b
movq %rax, %r12
movq %r13, %rdi
callq 0xf424d
testq %r12, %r12
je 0x1a5729
movq %r12, %rdi
callq 0xf02da
movq %rax, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movq %rbx, %r8
callq 0x1a5636
movq %rax, %rbx
movq %r12, %rdi
callq 0xee90c
movq %rbx, %rax
jmp 0x1a572b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/eis-mrangealphabet.c
// Function: gt_MRAEncGetSize
AlphabetRangeSize
gt_MRAEncGetSize(const MRAEnc *mralpha)
{
  AlphabetRangeID range, numRanges = mralpha->numRanges, sumRanges = 0;
  for (range = 0; range < numRanges; ++range)
  {
    sumRanges += mralpha->symbolsPerRange[range];
  }
  return sumRanges;
}

// Assembly:
movl 0x4(%rdi), %ecx
xorl %eax, %eax
testq %rcx, %rcx
je 0x1a67c5
movq 0x10(%rdi), %rdx
xorl %esi, %esi
movzwl (%rdx,%rsi,2), %edi
addl %edi, %eax
incq %rsi
cmpq %rsi, %rcx
jne 0x1a67b7
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/eis-mrangealphabet.c
// Function: gt_MRAEncSecondaryMapping
MRAEnc *
gt_MRAEncSecondaryMapping(const MRAEnc *srcAlpha, int selection,
                       const int *rangeSel, Symbol fallback)
{
  MRAEnc *newAlpha;
  switch (srcAlpha->encType)
  {
  case sourceUInt8:
    {
      GT_UNUSED const MRAEncUInt8 *ui8alpha;
      uint8_t *mappings, destSym;
      AlphabetRangeSize *newRanges, sym;
      AlphabetRangeID range, numRanges = MRAEncGetNumRanges(srcAlpha);
      ui8alpha = constMRAEnc2MRAEncUInt8(srcAlpha);
      mappings = gt_malloc(sizeof (uint8_t) * (UINT8_MAX + 1));
      memset(mappings, UNDEF_UCHAR, UINT8_MAX+1);
      newRanges = gt_malloc(sizeof (newRanges[0]) * numRanges);
      sym = 0;
      destSym = 0;
      for (range = 0; range < numRanges; ++range)
      {
        if (rangeSel[range] == selection)
        {
          for (; sym < srcAlpha->rangeEndIndices[range]; ++sym)
            mappings[sym] = destSym++;
          newRanges[range] = srcAlpha->symbolsPerRange[range];
        }
        else
        {
          for (; sym < srcAlpha->rangeEndIndices[range]; ++sym)
            mappings[sym] = fallback;
          newRanges[range] = 0;
        }
      }
      newAlpha = gt_newMultiRangeAlphabetEncodingUInt8(numRanges, newRanges,
                                                    mappings);
      gt_free(mappings);
      gt_free(newRanges);
    }
    break;
  default:
    abort();
    break;
  }
  return newAlpha;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, (%rsp)
cmpl $0x1, (%rdi)
jne 0x1a68eb
movl %ecx, %ebx
movl %esi, %ebp
movq %rdi, %r15
movl 0x4(%rdi), %r12d
leaq 0x206518(%rip), %r14    # 0x3acd08
movl $0x100, %edi            # imm = 0x100
movq %r14, %rsi
movl $0xbd, %edx
callq 0x1092b2
movq %rax, %r13
movl $0x100, %edx            # imm = 0x100
movq %rax, %rdi
movl $0xff, %esi
callq 0x173a0
leaq (%r12,%r12), %rdi
movq %r14, %rsi
movl $0xbf, %edx
callq 0x1092b2
movq %rax, %r14
testq %r12, %r12
movq (%rsp), %r8
je 0x1a68a1
xorl %eax, %eax
xorl %ecx, %ecx
xorl %edx, %edx
cmpl %ebp, (%r8,%rax,4)
jne 0x1a6870
movq 0x8(%r15), %rsi
cmpw (%rsi,%rax,2), %dx
jae 0x1a6866
movzwl %dx, %esi
movb %cl, (%r13,%rsi)
incb %cl
incq %rsi
movq 0x8(%r15), %rdi
movzwl (%rdi,%rax,2), %edi
incl %edx
cmpq %rdi, %rsi
jb 0x1a684d
movq 0x10(%r15), %rsi
movzwl (%rsi,%rax,2), %esi
jmp 0x1a6894
movq 0x8(%r15), %rsi
cmpw (%rsi,%rax,2), %dx
jae 0x1a6892
movzwl %dx, %edx
movb %bl, (%r13,%rdx)
incq %rdx
movq 0x8(%r15), %rsi
movzwl (%rsi,%rax,2), %esi
cmpq %rsi, %rdx
jb 0x1a687d
xorl %esi, %esi
movw %si, (%r14,%rax,2)
incq %rax
cmpq %r12, %rax
jne 0x1a683a
movl %r12d, %edi
movq %r14, %rsi
movq %r13, %rdx
callq 0x1a5f7c
movq %rax, %rbx
leaq 0x20644f(%rip), %r15    # 0x3acd08
movq %r13, %rdi
movq %r15, %rsi
movl $0xd3, %edx
callq 0x109670
movq %r14, %rdi
movq %r15, %rsi
movl $0xd4, %edx
callq 0x109670
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x173b0
// File: /workspace/github_c_makefile_star2_O1/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 %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1a69b1
movl 0x4(%rdi), %eax
cmpl %edx, %eax
jbe 0x1a69b1
cmpl $0x1, (%rdi)
jne 0x1a69b6
movzbl %sil, %r9d
cmpb $-0x1, 0x18(%rdi,%r9)
jne 0x1a69bb
movq 0x8(%rdi), %rcx
movl %edx, %r8d
movzwl (%rcx,%r8,2), %r10d
movzbl %r10b, %r11d
leal -0x1(%rax), %ebx
movzwl (%rcx,%rbx,2), %ebx
movzbl %bl, %r12d
cmpw %r12w, %r11w
jae 0x1a697b
leaq (%r12,%rdi), %r14
addq $0x118, %r14            # imm = 0x118
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
addq %r12, %r15
movl %r15d, %r12d
movzbl 0x118(%rdi,%r12), %r12d
movb %r12b, (%r14)
incb 0x18(%rdi,%r12)
decb %bl
decq %r14
decq %r15
cmpb %r11b, %bl
ja 0x1a695a
movb %r10b, 0x18(%rdi,%r9)
movb %sil, 0x118(%rdi,%r11)
movq 0x10(%rdi), %rsi
incw (%rsi,%r8,2)
cmpl %edx, %eax
jbe 0x1a69a2
incw (%rcx,%r8,2)
incq %r8
cmpq %r8, %rax
jne 0x1a6995
movq %rdi, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x61800
callq 0x173b0
callq 0x617c7
// File: /workspace/github_c_makefile_star2_O1/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 0x1a6a16
movq %rdx, %rbx
testq %rdx, %rdx
je 0x1a6a0a
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %r12
xorl %r13d, %r13d
movq %r15, %rdi
callq 0x171f0
cmpl $-0x1, %eax
je 0x1a6a05
cltq
movb 0x18(%r12,%rax), %al
movb %al, (%r14,%r13)
incq %r13
cmpq %r13, %rbx
jne 0x1a69e2
movq %rbx, %r13
movslq %r13d, %rax
jmp 0x1a6a0c
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x173b0
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
testq %rdi, %rdi
je 0x1a6ae7
testq %rcx, %rcx
je 0x1a6ae7
movl 0x4(%rdi), %r8d
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %r8d, %r8d
setne %r11b
je 0x1a6ae5
movq 0x8(%rdi), %r10
movzbl %sil, %esi
cmpw %si, (%r10)
jbe 0x1a6a9a
xorl %r9d, %r9d
jmp 0x1a6abb
leal -0x1(%r8), %r11d
xorl %ebx, %ebx
cmpl %ebx, %r11d
je 0x1a6ae5
leaq 0x1(%rbx), %r9
cmpw %si, 0x2(%r10,%rbx,2)
movq %r9, %rbx
jbe 0x1a6aa0
cmpl %r8d, %r9d
setb %r11b
testb %r11b, %r11b
je 0x1a6ae5
cmpl %edx, (%rcx,%r9,4)
jne 0x1a6ae3
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rcx
movzwl (%rax,%r9,2), %edx
movzwl (%rcx,%r9,2), %eax
subl %eax, %edx
movl $0x1, %eax
cmpl %esi, %edx
jle 0x1a6ae5
xorl %eax, %eax
popq %rbx
retq
callq 0x61839
// File: /workspace/github_c_makefile_star2_O1/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 0x1a6b6d
movq %rcx, %rbx
testq %rcx, %rcx
je 0x1a6b60
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
xorl %r13d, %r13d
movq (%r14,%r13,8), %rsi
testq %rsi, %rsi
je 0x1a6b52
movl 0x8(%r12), %edx
movq (%r12), %rdi
decq %rsi
callq 0xec1f8
jmp 0x1a6b54
movb $-0x2, %al
movb %al, (%r15,%r13)
incq %r13
cmpq %r13, %rbx
jne 0x1a6b36
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x618ab
// File: /workspace/github_c_makefile_star2_O1/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 0x1a6bde
movq %r8, %rbx
testq %r8, %r8
je 0x1a6bcc
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
xorl %ebp, %ebp
leaq (%r14,%rbp), %rsi
movq %r15, %rdi
callq 0x205eeb
testq %rax, %rax
je 0x1a6bbe
movl 0x8(%r13), %edx
movq (%r13), %rdi
decq %rax
movq %rax, %rsi
callq 0xec1f8
jmp 0x1a6bc0
movb $-0x2, %al
movb %al, (%r12,%rbp)
incq %rbp
cmpq %rbp, %rbx
jne 0x1a6b98
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x618e2
// File: /workspace/github_c_makefile_star2_O1/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 0x1a6c23
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x1a6c1b
leaq 0x20620c(%rip), %rbx    # 0x3ace0f
movq (%rdi), %r14
movq %rbx, %rsi
movl $0x56, %edx
callq 0x109670
movq %r14, %rdi
testq %r14, %r14
jne 0x1a6c03
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x61919
// File: /workspace/github_c_makefile_star2_O1/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 0x2061cf(%rip), %rsi    # 0x3ace0f
movl $0x20, %edi
movl $0x60, %edx
callq 0x1092b2
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_O1/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 0x1a6d5f
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x1a6d20
leaq 0x20619c(%rip), %r14    # 0x3acea4
movq (%rdi), %r15
movq %r14, %rsi
movl $0x73, %edx
callq 0x109670
movq %r15, %rdi
testq %r15, %r15
jne 0x1a6d08
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x1a6d3a
leaq 0x206174(%rip), %rsi    # 0x3acea4
movl $0x75, %edx
callq 0x109670
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x1a6d59
leaq 0x20615a(%rip), %rsi    # 0x3acea4
movl $0x77, %edx
popq %rbx
popq %r14
popq %r15
jmp 0x109670
popq %rbx
popq %r14
popq %r15
retq
callq 0x61950
// File: /workspace/github_c_makefile_star2_O1/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 0x206126(%rip), %rsi    # 0x3acea4
movl $0x48, %edi
movl $0x82, %edx
callq 0x1092b2
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         # 0x1a6dce
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1a73d6
movq %rsi, %rbx
movq %rdi, %r15
movq 0x8(%rdi), %rdi
callq 0xec1d8
leaq 0x1(%rax), %r13
cmpq %rbx, %r13
jb 0x1a73db
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 0x1a73bc
movq 0x10(%r15), %r12
movl 0x30(%r15), %edx
movq 0x8(%r15), %rsi
movq %r12, %rdi
movq %rax, %rcx
callq 0xed48e
movq %r12, %rdi
callq 0xec7be
cmpb $-0x2, %al
sbbq $-0x1, %rbp
decq %r14
jne 0x1a73a9
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 0x61be3
callq 0x61baa
// File: /workspace/github_c_makefile_star2_O1/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 0x1a74c4
movq %rdx, %r14
movq %rdi, %rbx
movq %rsi, (%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
leaq 0xf6(%rip), %rcx        # 0x1a7532
movq %rcx, 0x8(%rdi)
leaq 0xf0(%rip), %rcx        # 0x1a7537
movq %rcx, 0x18(%rdi)
movq %rax, 0x20(%rdi)
leaq 0x73(%rip), %rcx        # 0x1a74c9
movq %rcx, 0x28(%rdi)
movq %rdi, 0x30(%rdi)
leaq 0xd7(%rip), %rcx        # 0x1a753c
movq %rcx, 0x38(%rdi)
leaq -0x70(%rip), %rcx       # 0x1a7400
movq %rcx, 0x40(%rdi)
movq %rax, 0x48(%rdi)
addq $0x50, %rdi
leaq 0xd7(%rip), %r8         # 0x1a755a
movl $0x8, %ecx
xorl %esi, %esi
xorl %edx, %edx
movq %rbx, %r9
callq 0x1a6cc0
leaq 0xb0(%rbx), %rdi
callq 0x1a6be3
movq %r14, 0xd0(%rbx)
movb $0x0, 0xd8(%rbx)
addq $0xc0, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1a6be3
callq 0x61c55
// File: /workspace/github_c_makefile_star2_O1/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 0x1a7528
movq 0xd0(%rdi), %rax
movq (%rax), %r12
testq %r12, %r12
je 0x1a752d
movq %rcx, %rbx
testq %rcx, %rcx
je 0x1a7516
movq %rdx, %r14
movq %rsi, %r15
movl 0x48(%rax), %ebp
xorl %r13d, %r13d
leaq (%r14,%r13), %rsi
movq %r12, %rdi
movl %ebp, %edx
callq 0xec1f8
movb %al, (%r15,%r13)
incq %r13
cmpq %r13, %rbx
jne 0x1a74fc
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x61cc3
callq 0x61c8c
// File: /workspace/github_c_makefile_star2_O1/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 0x1a768e
movq %r9, %r12
movq %rsi, -0x38(%rbp)
movq %r8, -0x40(%rbp)
movq %rdx, -0x48(%rbp)
movq %rcx, -0x30(%rbp)
testq %r9, %r9
je 0x1a7632
movq 0xd0(%rdi), %rbx
xorl %r15d, %r15d
movl 0xa4(%rbx), %eax
cmpl 0xa0(%rbx), %eax
jb 0x1a7607
movq 0xa8(%rbx), %rdi
movq 0xb0(%rbx), %rcx
movl $0x8, %esi
movl $0x1000, %edx           # imm = 0x1000
callq 0x17b40
movq %rax, %r13
movl %r13d, 0xa0(%rbx)
movq 0xb0(%rbx), %rdi
callq 0x17f00
testl %eax, %eax
jne 0x1a7689
movl $0x0, 0xa4(%rbx)
testl %r13d, %r13d
je 0x1a7635
movq 0xa8(%rbx), %rax
movl 0xa4(%rbx), %ecx
leal 0x1(%rcx), %edx
movl %edx, 0xa4(%rbx)
movq (%rax,%rcx,8), %rax
movq %rax, (%r14,%r15,8)
incq %r15
cmpq %r15, %r12
jne 0x1a75af
movq %r12, %r15
jmp 0x1a7635
xorl %r15d, %r15d
leaq 0x10(%rbp), %rbx
movq -0x38(%rbp), %rdi
movq %r14, %rsi
movq -0x40(%rbp), %rdx
movq %r15, %rcx
callq *-0x48(%rbp)
movq (%rbx), %rdx
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x1a7667
movq %rdx, %rdi
movq -0x30(%rbp), %rsi
movq %r14, %rdx
movq %r15, %rcx
callq *%rax
jmp 0x1a7677
imulq %r15, %rdx
movq -0x30(%rbp), %rdi
movq %r14, %rsi
callq 0x17660
movq %r15, %rax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x61cfc
callq 0x61d24
// File: /workspace/github_c_makefile_star2_O1/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 0x1a7746
movb 0xd8(%rbx), %cl
testb %cl, %cl
jle 0x1a77a7
movq (%rax), %rdx
testq %rdx, %rdx
je 0x1a77bf
movl 0x48(%rax), %ecx
leaq 0xc0(%rbx), %rdi
movl $0x2, %esi
callq 0x1a6c28
addq $0x8, %rax
movq %rax, 0x18(%rsp)
leaq -0xc5e(%rip), %rax      # 0x1a6b14
movq %rax, 0x20(%rsp)
leaq -0xc0c(%rip), %rax      # 0x1a6b72
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 0x1a6d64
movq %rax, %rbx
jmp 0x1a77b6
incb %cl
movb %cl, 0xd8(%rbx)
leaq 0x14(%rip), %rdx        # 0x1a77ca
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
retq
callq 0x61d5d
xorl %edx, %edx
xorl %ebx, %ebx
jmp 0x1a77b6
// File: /workspace/github_c_makefile_star2_O1/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 0x1a7897
callq 0x1a607c
movq %rax, %rbx
movq %rax, %rdi
movl $0xff, %esi
movl $0x1, %edx
callq 0x1a68f0
movq %rbx, %rax
popq %rbx
retq
callq 0x61e2b
// File: /workspace/github_c_makefile_star2_O1/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 0x1a7c73
movq 0xe0(%rdi), %r12
testq %r12, %r12
je 0x1a7c78
movq %rcx, %rbx
testq %rcx, %rcx
je 0x1a7c61
movq %rdx, %r14
movq %rsi, %r15
movl 0xc0(%rdi), %ebp
xorl %r13d, %r13d
leaq (%r14,%r13), %rsi
movq %r12, %rdi
movl %ebp, %edx
callq 0xec1f8
movb %al, (%r15,%r13)
incq %r13
cmpq %r13, %rbx
jne 0x1a7c47
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x61f3c
callq 0x61f05
// File: /workspace/github_c_makefile_star2_O1/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 0x1a7f06
callq 0x1a6aec
leaq 0xb0(%rbx), %rdi
callq 0x1a6bea
leaq 0x50(%rbx), %rdi
callq 0x1a6ceb
movq 0xf0(%rbx), %rdi
xorl %esi, %esi
callq 0x200058
movq $0x0, 0xf0(%rbx)
movq 0xe8(%rbx), %rdi
leaq 0x2052f4(%rip), %r14    # 0x3ad236
movq %r14, %rsi
movl $0xd4, %edx
callq 0x109670
movq %rbx, %rdi
movq %r14, %rsi
movl $0x127, %edx            # imm = 0x127
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x109670
// File: /workspace/github_c_makefile_star2_O1/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 0x1a7f9a
movq 0xd8(%rdi), %rdi
callq 0x1a607c
movq %rax, %rbx
movq %rax, %rdi
movl $0xff, %esi
movl $0x1, %edx
callq 0x1a68f0
movq %rbx, %rax
popq %rbx
retq
callq 0x61fe7
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/eis-suffixerator-interface.c
// Function: SfxIRequest2XltorFunc
static SeqDataTranslator
SfxIRequest2XltorFunc(sfxInterface *sfxi,
                      enum sfxDataRequest rtype)
{
  SeqDataTranslator tr = { { NULL }, NULL };
  switch (rtype)
  {
    struct encSeqTrState readState;
    struct saTaggedXltorState *stateStore;
  case SFX_REQUEST_BWTTAB:
    readState.readmode = sfxi->readmode;
    readState.encseq = sfxi->encseq;
    stateStore = gt_addSuffixarrayXltor(&sfxi->baseClass.xltorStates,
                                        rtype, readState);
    tr.state.ref = &stateStore->state;
    tr.translateData = gt_translateSuftab2BWT;
    tr.translateDataSuffixsortspace = gt_translateSuftab2BWTSuffixsortspace;
    break;
  case SFX_REQUEST_SUFTAB:
    tr.state.elemSize = sizeof (GtUword);
    gt_assert(tr.translateData == NULL);
    break;
  default:
    fprintf(stderr, "error: unimplemented request!\n");
    abort();
    break;
  }
  return tr;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
cmpl $0x1, %edx
je 0x1a802f
cmpl $0x2, %edx
jne 0x1a8042
movl 0xc0(%rsi), %ecx
movq 0xe0(%rsi), %rdx
addq $0xb0, %rsi
movq %rsi, %rdi
movl $0x2, %esi
callq 0x1a6c28
addq $0x8, %rax
movq %rax, (%rbx)
leaq -0x150a(%rip), %rax     # 0x1a6b14
movq %rax, 0x8(%rbx)
leaq -0x14b7(%rip), %rax     # 0x1a6b72
movq %rax, 0x10(%rbx)
jmp 0x1a803d
movq $0x8, (%rbx)
cmpq $0x0, 0x8(%rbx)
jne 0x1a8047
movq %rbx, %rax
popq %rbx
retq
callq 0x62090
callq 0x62059
// File: /workspace/github_c_makefile_star2_O1/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 0x1a3411
movq %rax, %rbx
testb $0x1, 0x30(%r14)
je 0x1a809c
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x1a809c
leaq 0x2038e2(%rip), %rsi    # 0x3ab974
movl $0x87, %edx
callq 0x109670
testb $0x4, 0x30(%rsp)
je 0x1a80be
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x1a80be
leaq 0x2038c0(%rip), %rsi    # 0x3ab974
movl $0x89, %edx
callq 0x109670
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x20526b(%rip), %rsi    # 0x3ad349
movl $0x50, %edi
movl $0x37, %edx
callq 0x1092b2
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_O1/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 0x1a8146
movq %rsi, %r14
movq %rdi, %r15
movq 0x38(%rsi), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x1a3411
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_O1/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x40(%rsi), %rsi
cmpq 0x48(%rbx), %rsi
setb %bpl
jae 0x1a81df
movq %rdi, %r14
movq 0x38(%rbx), %rax
cmpq 0x30(%rax), %rsi
je 0x1a81b1
testq %rax, %rax
je 0x1a81f5
movq (%rax), %rdi
testq %rdi, %rdi
je 0x1a81f0
movq 0x18(%rax), %rdx
testq %rdx, %rdx
je 0x1a81f0
movq (%rdi), %rax
movq 0x8(%rdi), %r15
callq *0x30(%rax)
cmpl $0x1, (%r15)
jne 0x1a81fa
movzbl %al, %eax
cmpb $-0x1, 0x118(%r15,%rax)
jne 0x1a81c8
movq 0x40(%rbx), %rsi
incq %rsi
movq %rsi, 0x40(%rbx)
cmpq 0x48(%rbx), %rsi
setb %bpl
jb 0x1a8173
jmp 0x1a81df
movq 0x38(%rbx), %rdi
movq 0x40(%rbx), %rsi
movq %rbx, %rdx
callq 0x1a3411
movq %rax, (%r14)
incq 0x40(%rbx)
andb $0x1, %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x620b2
callq 0x620e9
callq 0x173b0
// File: /workspace/github_c_makefile_star2_O1/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 0x2050e0(%rip), %rsi    # 0x3ad349
movl $0x48, %edi
movl $0x79, %edx
callq 0x1092b2
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_O1/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 0x205029(%rip), %rsi    # 0x3ad349
movl $0x48, %edi
movl $0x9c, %edx
callq 0x1092b2
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_O1/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, %r14
movl %esi, %r13d
movq %rdi, %r15
movq %rdx, %rsi
callq 0x1000e4
movq %rax, %rbx
testq %rax, %rax
je 0x1a86d2
xorl %ebp, %ebp
jmp 0x1a86e5
movq %r14, %rdi
callq 0x101a9a
movb $0x1, %bpl
testb %al, %al
je 0x1a87e0
testb %bpl, %bpl
je 0x1a86ec
jmp 0x1a8718
movq %rbx, %rdi
callq 0x100d2c
movq %rax, (%rsp)
testq %rax, %rax
jne 0x1a8718
movq %r14, %rdi
callq 0x101a9a
testb %al, %al
je 0x1a87e5
movb $0x1, %bpl
movq $0x0, (%rsp)
testb %bpl, %bpl
jne 0x1a8751
movq %r15, %rdi
movl $0x2, %esi
movl $0x2, %edx
movq (%rsp), %rcx
movq %r14, %r8
callq 0x1a15e9
movq %rax, %r12
testq %rax, %rax
jne 0x1a8754
movq %r14, %rdi
callq 0x101a9a
testb %al, %al
je 0x1a87ea
movb $0x1, %bpl
xorl %r12d, %r12d
testb %bpl, %bpl
jne 0x1a87a7
testb %r13b, %r13b
je 0x1a879e
movq %r15, %rdi
callq 0x1c123b
testb %al, %al
je 0x1a879e
movq (%rsp), %rdi
callq 0xd3713
movq %r15, %rdi
movl %eax, %esi
movq %r14, %rdx
callq 0x1c1278
movq %rax, 0x50(%r12)
testq %rax, %rax
jne 0x1a87a7
movq %r14, %rdi
callq 0x101a9a
movb $0x1, %bpl
testb %al, %al
jne 0x1a87a7
callq 0x62561
movq $0x0, 0x50(%r12)
movq %rbx, %rdi
callq 0x100e07
movl %ebp, %eax
xorb $0x1, %al
testq %r12, %r12
sete %cl
orb %al, %cl
jne 0x1a87c8
movq %r12, %rdi
callq 0x1a87ef
xorl %r12d, %r12d
xorl %eax, %eax
testb %bpl, %bpl
cmoveq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x624b6
callq 0x624ef
callq 0x62528
// File: /workspace/github_c_makefile_star2_O1/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 0x1a8809
callq 0x1c0c0c
movq $0x0, 0x50(%rbx)
movq %rbx, %rdi
popq %rbx
jmp 0x1a430c
// File: /workspace/github_c_makefile_star2_O1/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 0x1a8913
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x1a8918
cmpl $0x0, 0x4(%rax)
je 0x1a891d
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 0x1a8932
testq %r12, %r12
je 0x1a8907
leaq (%r14,%r12,8), %rax
xorl %ecx, %ecx
movq (%r14,%rcx,8), %rdx
cmpq (%rax,%rcx,8), %rdx
jae 0x1a88ff
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 0x1a88c5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x626b3
callq 0x6267c
callq 0x62645
// File: /workspace/github_c_makefile_star2_O1/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 0x1a8b75
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x1a8b7a
cmpl $0x0, 0x4(%rax)
je 0x1a8b7f
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 0x1a8932
testq %r12, %r12
je 0x1a8b66
leal (,%r12,8), %eax
leaq (%r14,%rax), %rcx
xorl %edx, %edx
xorps %xmm0, %xmm0
movq (%r14,%rdx), %rsi
cmpq (%rcx,%rdx), %rsi
jae 0x1a8b58
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 0x1a8b5d
movups %xmm0, (%r15,%rdx,2)
addq $0x8, %rdx
cmpq %rdx, %rax
jne 0x1a8b33
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x628a8
callq 0x62871
callq 0x6283a