LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/eis-encidxseq-construct.c
// Function: gt_createEncIdxSeqFromSASeqSrc
static EISeq *
gt_createEncIdxSeqFromSASeqSrc(SASeqSrc *src,
                            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)
{
  SeqDataReader readSfxBWTSym;
  MRAEnc *alphabet;
  struct encIdxSeq *newSeqIdx;
  if (!SDRIsValid(readSfxBWTSym
                  = SASSCreateReader(src, SFX_REQUEST_BWTTAB)))
    return NULL;
  alphabet = SASSNewMRAEnc(src);
  newSeqIdx = gt_createEncIdxSeqGen(SASSGetLength(src), projectName,
                                 alphabet, SASSGetSeqStats(src),
                                 readSfxBWTSym, params,
                                 numExtHeaders, headerIDs, extHeaderSizes,
                                 extHeaderCallbacks, headerCBData, biFunc,
                                 cwExtBitsPerPos, biVarBits,
                                 cbState, err);
  if (!newSeqIdx)
    gt_MRAEncDelete(alphabet);
  return newSeqIdx;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, 0x18(%rsp)
movq %r8, 0x20(%rsp)
movq %rcx, %r13
movq %rdx, %r12
movq %rsi, %rbp
movq %rdi, %r15
pushq $0x2
popq %rsi
callq *0x8(%rdi)
testq %rdx, %rdx
je 0x1481d4
movq %rax, %rbx
movq %rdx, %r14
movq %r13, 0x8(%rsp)
movq %r12, 0x10(%rsp)
movq %r15, %rdi
callq *0x40(%r15)
movq %rax, %r13
movq (%r15), %r12
movq 0x20(%r15), %rax
testq %rax, %rax
je 0x148168
movq %r15, %rdi
callq *%rax
movq %rax, %rcx
jmp 0x14816a
xorl %ecx, %ecx
subq $0x8, %rsp
movq %r12, %rdi
movq %rbp, %rsi
movq %r13, %rdx
movq %rbx, %r8
movq %r14, %r9
pushq 0x98(%rsp)
pushq 0x98(%rsp)
pushq 0x98(%rsp)
pushq 0x98(%rsp)
pushq 0x98(%rsp)
pushq 0x98(%rsp)
pushq 0x98(%rsp)
pushq 0x58(%rsp)
pushq 0x68(%rsp)
pushq 0x58(%rsp)
pushq 0x68(%rsp)
callq 0x14826a
addq $0x60, %rsp
testq %rax, %rax
jne 0x1481d6
movq %r13, %rdi
callq 0x149458
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x148234
movq %rsi, %r13
testq %rsi, %rsi
je 0x148234
cmpq $0x0, 0x60(%rsp)
je 0x148234
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
callq 0x14a674
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 0x148105
movq 0x2efd2d(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x19cdce(%rip), %rsi    # 0x2e5013
leaq 0x1fb53d(%rip), %rdx    # 0x343789
leaq 0x1fb551(%rip), %rcx    # 0x3437a4
leaq 0x1fb4a5(%rip), %r8     # 0x3436ff
pushq $0x79
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x1482f5
movq %r8, %rbx
movl %ecx, %ebp
movl %edx, %r15d
movq %rsi, %r14
callq 0x14a618
cmpl $0x2, %r15d
jne 0x1482cb
movq %rax, %rdi
movq %r14, %rsi
movl %ebp, %edx
movq %rbx, %rcx
callq 0x2a93db
testq %rax, %rax
jne 0x1482ea
jmp 0x1482dc
leaq 0x1fb4ed(%rip), %rsi    # 0x3437bf
movq %rbx, %rdi
xorl %eax, %eax
callq 0x89dbb
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
je 0x148323
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x2efc6c(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x19cd0d(%rip), %rsi    # 0x2e5013
leaq 0x1fb4e4(%rip), %rdx    # 0x3437f1
leaq 0x1fb4ee(%rip), %rcx    # 0x343802
leaq 0x1fb3e4(%rip), %r8     # 0x3436ff
movl $0xc4, %r9d
jmp 0x14834f
movq 0x2efc3e(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x19ccdf(%rip), %rsi    # 0x2e5013
leaq 0x1fb4dd(%rip), %rdx    # 0x343818
leaq 0x1fb4c0(%rip), %rcx    # 0x343802
leaq 0x1fb3b6(%rip), %r8     # 0x3436ff
movl $0xd0, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x791cd
movq %rax, %r13
movq %rax, %rdi
callq 0x7d25b
movq %r13, %rdi
callq 0x7d0cd
movq %r13, %rdi
callq 0x7d193
movq %r13, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x7921d
movq %rax, %r12
movq %r13, %rdi
callq 0x79f01
testq %r12, %r12
je 0x1483da
movq %r12, %rdi
callq 0x754dd
movq %rax, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
movq %rbx, %r8
callq 0x148292
movq %rax, %rbx
movq %r12, %rdi
callq 0x735fd
movq %rbx, %rax
jmp 0x1483dc
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_O2/genometools[P]genometools/src/match/eis-mrangealphabet.c
// Function: gt_MRAEncGTAlphaNew
MRAEnc *
gt_MRAEncGTAlphaNew(const GtAlphabet *alpha)
{
  AlphabetRangeSize symsPerRange[2];
  uint8_t *mappings;
  MRAEnc *result;
  uint32_t numofchars = gt_alphabet_num_of_chars(alpha);
  mappings = gt_malloc(sizeof (uint8_t) * (UINT8_MAX + 1));
  memset(mappings, UNDEF_UCHAR, UINT8_MAX+1);
  {
    /* handle regular symbols */
    int i;
    for (i = 0; i < numofchars; ++i)
      mappings[i] = i;
    symsPerRange[0] = numofchars;
  }
  /* handle special symbols */
  mappings[GT_WILDCARD] = numofchars;
  symsPerRange[1] = 1;
  result = gt_newMultiRangeAlphabetEncodingUInt8(2, symsPerRange, mappings);
  gt_free(mappings);
  return result;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
callq 0x56c8e
movl %eax, %ebp
leaq 0x1facf5(%rip), %rsi    # 0x343b0e
pushq $0x5f
popq %rdx
movl $0x100, %edi            # imm = 0x100
callq 0x93160
movq %rax, %rbx
movl $0x100, %edx            # imm = 0x100
movq %rax, %rdi
movl $0xff, %esi
callq 0x17380
movl %ebp, %eax
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x148e4c
movb %cl, (%rbx,%rcx)
incq %rcx
jmp 0x148e3f
leaq 0xc(%rsp), %rsi
movw %ax, (%rsi)
movb %al, 0xfe(%rbx)
movw $0x1, 0x2(%rsi)
pushq $0x2
popq %rdi
movq %rbx, %rdx
callq 0x148d08
movq %rax, %r14
leaq 0x1fac99(%rip), %rsi    # 0x343b0e
pushq $0x6c
popq %rdx
movq %rbx, %rdi
callq 0x936f9
movq %r14, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %edx, %edx
xorl %eax, %eax
cmpq %rdx, %rcx
je 0x149083
movq 0x10(%rdi), %rsi
addw (%rsi,%rdx,2), %ax
incq %rdx
jmp 0x149071
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x149193
movl %ecx, %ebx
movl %esi, %ebp
movq %rdi, %r15
movl 0x4(%rdi), %r12d
callq 0x149025
leaq 0x1faa5b(%rip), %r14    # 0x343b0e
movl $0x100, %edi            # imm = 0x100
movq %r14, %rsi
movl $0xbd, %edx
callq 0x93160
movq %rax, %r13
movl $0x100, %edx            # imm = 0x100
movq %rax, %rdi
movl $0xff, %esi
callq 0x17380
leaq (%r12,%r12), %rdi
movq %r14, %rsi
movl $0xbf, %edx
callq 0x93160
movq %rax, %r14
xorl %eax, %eax
xorl %ecx, %ecx
xorl %edx, %edx
movq (%rsp), %rdi
cmpq %r12, %rax
je 0x149149
movzwl %cx, %ecx
cmpl %ebp, (%rdi,%rax,4)
je 0x149126
movq 0x8(%r15), %rsi
movzwl (%rsi,%rax,2), %esi
cmpq %rsi, %rcx
jae 0x14913d
movb %bl, (%r13,%rcx)
incq %rcx
jmp 0x149105
movb %dl, (%r13,%rcx)
incb %dl
incq %rcx
movq 0x8(%r15), %rsi
movzwl (%rsi,%rax,2), %esi
cmpq %rsi, %rcx
jb 0x14911c
movq 0x10(%r15), %rsi
movzwl (%rsi,%rax,2), %esi
jmp 0x14913f
xorl %esi, %esi
movw %si, (%r14,%rax,2)
incq %rax
jmp 0x1490f8
movl %r12d, %edi
movq %r14, %rsi
movq %r13, %rdx
callq 0x148d08
movq %rax, %rbx
leaq 0x1fa9ad(%rip), %r15    # 0x343b0e
movq %r13, %rdi
movq %r15, %rsi
movl $0xd3, %edx
callq 0x936f9
movq %r14, %rdi
movq %r15, %rsi
movl $0xd4, %edx
callq 0x936f9
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testq %rdi, %rdi
je 0x14924e
movq %rdi, %rbx
movl 0x4(%rdi), %eax
cmpl %edx, %eax
jbe 0x14924e
cmpl $0x1, (%rbx)
jne 0x14927c
movl %esi, %ebp
movq 0x8(%rbx), %rcx
movl %edx, %r14d
movzwl (%rcx,%r14,2), %r15d
decl %eax
movzwl (%rcx,%rax,2), %r12d
movq %rbx, %rdi
callq 0x1492b9
movzbl %bpl, %eax
cmpb $-0x1, 0x18(%rbx,%rax)
jne 0x149281
movzbl %r15b, %ecx
cmpb %cl, %r12b
jbe 0x149216
movzbl %r12b, %edx
movl %edx, %esi
decl %esi
movzbl 0x118(%rbx,%rsi), %esi
movb %sil, 0x118(%rbx,%rdx)
incb 0x18(%rbx,%rsi)
decb %r12b
jmp 0x1491f0
movb %r15b, 0x18(%rbx,%rax)
movb %bpl, 0x118(%rbx,%rcx)
movq 0x10(%rbx), %rax
incw (%rax,%r14,2)
movl 0x4(%rbx), %eax
cmpq %rax, %r14
jae 0x149242
movq 0x8(%rbx), %rcx
incw (%rcx,%r14,2)
incq %r14
jmp 0x14922f
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x2eed13(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x19bdb4(%rip), %rsi    # 0x2e5013
leaq 0x1fa8e3(%rip), %rdx    # 0x343b49
leaq 0x1fa902(%rip), %rcx    # 0x343b6f
leaq 0x1fa89a(%rip), %r8     # 0x343b0e
movl $0xe2, %r9d
jmp 0x1492ad
callq 0x17390
movq 0x2eece0(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x19bd81(%rip), %rsi    # 0x2e5013
leaq 0x1fa8f0(%rip), %rdx    # 0x343b89
leaq 0x1fa8cf(%rip), %rcx    # 0x343b6f
leaq 0x1fa867(%rip), %r8     # 0x343b0e
movl $0xeb, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x14934d
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
callq 0x149025
xorl %r13d, %r13d
cmpq %r13, %rbx
je 0x149340
movq %r15, %rdi
callq 0x171d0
cmpl $-0x1, %eax
je 0x14933d
cltq
movb 0x18(%r12,%rax), %al
movb %al, (%r14,%r13)
incq %r13
jmp 0x14931b
movq %r13, %rbx
movslq %ebx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/eis-mrangealphabet.c
// Function: gt_MRAEncSymbolsTransform
void
gt_MRAEncSymbolsTransform(const MRAEnc *mralpha, Symbol *symbols,
                          size_t numSyms)
{
  switch (mralpha->encType)
  {
  case sourceUInt8:
    {
      const MRAEncUInt8 *ui8alpha;
      size_t i;
      ui8alpha = constMRAEnc2MRAEncUInt8(mralpha);
      for (i = 0; i < numSyms; ++i)
      {
        symbols[i] = ui8alpha->mappings[symbols[i]];
      }
    }
    break;
  default:
    abort();
    break;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpl $0x1, (%rdi)
jne 0x14938a
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x149025
xorl %eax, %eax
cmpq %rax, %rbx
je 0x149384
movzbl (%r14,%rax), %ecx
movb 0x18(%r15,%rcx), %cl
movb %cl, (%r14,%rax)
incq %rax
jmp 0x14936c
popq %rbx
popq %r14
popq %r15
retq
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/eis-mrangealphabet.c
// Function: gt_MRAEncSymbolsRevTransform
void
gt_MRAEncSymbolsRevTransform(const MRAEnc *mralpha, Symbol *symbols,
                          size_t numSyms)
{
  switch (mralpha->encType)
  {
  case sourceUInt8:
    {
      const MRAEncUInt8 *ui8alpha;
      size_t i;
      ui8alpha = constMRAEnc2MRAEncUInt8(mralpha);
      for (i = 0; i < numSyms; ++i)
      {
        symbols[i] = ui8alpha->revMappings[symbols[i]];
      }
    }
    break;
  default:
    abort();
    break;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpl $0x1, (%rdi)
jne 0x1493ca
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x149025
xorl %eax, %eax
cmpq %rax, %rbx
je 0x1493c4
movzbl (%r14,%rax), %ecx
movb 0x118(%r15,%rcx), %cl
movb %cl, (%r14,%rax)
incq %rax
jmp 0x1493a9
popq %rbx
popq %r14
popq %r15
retq
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x149420
testq %rcx, %rcx
je 0x149420
movl 0x4(%rdi), %r9d
movzbl %sil, %esi
xorl %r8d, %r8d
pushq $-0x1
popq %rax
cmpq %r8, %r9
je 0x14941e
movq 0x8(%rdi), %r10
cmpw %si, (%r10,%r8,2)
ja 0x1493fd
incq %r8
jmp 0x1493e8
cmpl %edx, (%rcx,%r8,4)
jne 0x149417
movzwl (%r10,%r8,2), %eax
movq 0x10(%rdi), %rcx
movzwl (%rcx,%r8,2), %ecx
subl %ecx, %eax
cmpl %esi, %eax
jle 0x14941b
xorl %eax, %eax
jmp 0x14941e
pushq $0x1
popq %rax
popq %rcx
retq
movq 0x2eeb41(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x19bbe2(%rip), %rsi    # 0x2e5013
leaq 0x1fa778(%rip), %rdx    # 0x343bb0
leaq 0x1fa785(%rip), %rcx    # 0x343bc4
leaq 0x1fa6c8(%rip), %r8     # 0x343b0e
movl $0x15f, %r9d            # imm = 0x15F
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/eis-mrangealphabet.c
// Function: gt_MRAEncDelete
void
gt_MRAEncDelete(struct multiRangeAlphabetEncoding *mralpha)
{
  gt_assert(mralpha);
  switch (mralpha->encType)
  {
    MRAEncUInt8 *ui8alpha;
  case sourceUInt8:
    ui8alpha = MRAEnc2MRAEncUInt8(mralpha);
    gt_free(ui8alpha);
    break;
  default:
    abort();
    break;
  }
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x149483
movq %rdi, %rbx
cmpl $0x1, (%rdi)
jne 0x1494b6
movq %rbx, %rdi
callq 0x1492b9
leaq 0x1fa699(%rip), %rsi    # 0x343b0e
movq %rbx, %rdi
movl $0x17a, %edx            # imm = 0x17A
popq %rbx
jmp 0x936f9
movq 0x2eeade(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x19bb7f(%rip), %rsi    # 0x2e5013
leaq 0x1f983e(%rip), %rdx    # 0x342cd9
leaq 0x1fa744(%rip), %rcx    # 0x343be6
leaq 0x1fa665(%rip), %r8     # 0x343b0e
movl $0x174, %r9d            # imm = 0x174
xorl %eax, %eax
callq 0x17a50
callq 0x17390
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x149506
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
xorl %r13d, %r13d
cmpq %r13, %rbx
je 0x1494f9
movq (%r14,%r13,8), %rdi
movq (%r12), %rsi
movl 0x8(%r12), %edx
callq 0x14953c
movb %al, (%r15,%r13)
incq %r13
jmp 0x1494d9
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x2eea5b(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x19bafc(%rip), %rsi    # 0x2e5013
leaq 0x1fa6d8(%rip), %rdx    # 0x343bf6
leaq 0x1fa6d9(%rip), %rcx    # 0x343bfe
leaq 0x1fa6e9(%rip), %r8     # 0x343c15
pushq $0x20
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x1495b2
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
xorl %ebp, %ebp
cmpq %rbp, %rbx
je 0x1495a0
leaq (%r14,%rbp), %rsi
movq %r15, %rdi
callq 0x1af5f2
movq (%r13), %rsi
movl 0x8(%r13), %edx
movq %rax, %rdi
callq 0x14953c
movb %al, (%r12,%rbp)
incq %rbp
jmp 0x149576
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x2ee9af(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x19ba50(%rip), %rsi    # 0x2e5013
leaq 0x1fa62c(%rip), %rdx    # 0x343bf6
leaq 0x1fa65e(%rip), %rcx    # 0x343c2f
leaq 0x1fa63d(%rip), %r8     # 0x343c15
pushq $0x34
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x149622
movq 0x8(%rdi), %rdi
leaq 0x1fa612(%rip), %rbx    # 0x343c15
pushq $0x56
popq %rbp
testq %rdi, %rdi
je 0x14961d
movq (%rdi), %r14
movq %rbx, %rsi
movl %ebp, %edx
callq 0x936f9
movq %r14, %rdi
jmp 0x149606
popq %rbx
popq %r14
popq %rbp
retq
movq 0x2ee93f(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x19b9e0(%rip), %rsi    # 0x2e5013
leaq 0x1fa61b(%rip), %rdx    # 0x343c55
leaq 0x1fa625(%rip), %rcx    # 0x343c66
leaq 0x1fa5cd(%rip), %r8     # 0x343c15
pushq $0x50
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x1fa5a5(%rip), %rsi    # 0x343c15
pushq $0x20
popq %rdi
pushq $0x60
popq %rdx
callq 0x93160
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_O2/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x149791
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
leaq 0x1fa578(%rip), %r14    # 0x343caa
pushq $0x73
popq %rbp
testq %rdi, %rdi
je 0x14974c
movq (%rdi), %r15
movq %r14, %rsi
movl %ebp, %edx
callq 0x936f9
movq %r15, %rdi
jmp 0x149735
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x149764
leaq 0x1fa54e(%rip), %rsi    # 0x343caa
pushq $0x75
popq %rdx
callq 0x936f9
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x149786
leaq 0x1fa536(%rip), %rsi    # 0x343caa
pushq $0x77
popq %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x936f9
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x2ee7d0(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x19b871(%rip), %rsi    # 0x2e5013
leaq 0x1fa4df(%rip), %rdx    # 0x343c88
leaq 0x1fa4e2(%rip), %rcx    # 0x343c92
leaq 0x1fa4f3(%rip), %r8     # 0x343caa
pushq $0x72
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x1fa4c9(%rip), %rsi    # 0x343caa
pushq $0x48
popq %rdi
movl $0x82, %edx
callq 0x93160
movq %r14, 0x18(%rax)
movl %r15d, 0x20(%rax)
movaps 0x20(%rsp), %xmm0
movups %xmm0, 0x30(%rax)
movq 0x30(%rsp), %rcx
movq %rcx, 0x40(%rax)
andq $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         # 0x14982c
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/eis-specialsrank.c
// Function: nextRange
static inline bool
nextRange(GtRange *range, GtSpecialrangeiterator *sri,
          GtReadmode readmode, GtUword seqLastPos)
{
  bool hasNextRange = gt_specialrangeiterator_next(sri, range);
  if (hasNextRange)
  {
    if (GT_ISDIRREVERSE(readmode))
    {
      GtUword temp = range->end;
      range->end = seqLastPos - range->start;
      range->start = seqLastPos - temp;
    }
  }
  else
    range->end = seqLastPos + 1, range->start = seqLastPos;
  return hasNextRange;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rcx, %rbx
movl %edx, %ebp
movq %rdi, %r14
movq %rsi, %rdi
movq %r14, %rsi
callq 0x7428b
testb %al, %al
je 0x149e98
andl $-0x3, %ebp
cmpl $0x1, %ebp
jne 0x149ea3
movq %rbx, %rax
subq (%r14), %rax
subq 0x8(%r14), %rbx
jmp 0x149e9c
leaq 0x1(%rbx), %rax
movq %rax, 0x8(%r14)
movq %rbx, (%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x149f82
movq %rsi, %rbx
movq %rdi, %r12
movq 0x8(%rdi), %rdi
callq 0x7055e
movq %rax, %r14
incq %rax
cmpq %rbx, %rax
jb 0x149fb0
movq %rax, (%rsp)
xorl %r15d, %r15d
subq 0x28(%r12), %r15
movb 0x34(%r12), %cl
movq %rbx, %rax
shrq %cl, %rax
andq %rbx, %r15
movq 0x18(%r12), %rcx
movq (%rcx,%rax,8), %rbp
cmpq %rbx, %r14
cmovaeq %rbx, %r14
cmpq %r14, %r15
jae 0x149f67
movq 0x10(%r12), %r13
movl 0x30(%r12), %edx
movq 0x8(%r12), %rsi
movq %r13, %rdi
movq %r15, %rcx
callq 0x71f38
incq %r15
movq %r13, %rdi
callq 0x70f55
cmpb $-0x2, %al
sbbq $-0x1, %rbp
cmpq %r14, %r15
jb 0x149f51
xorl %eax, %eax
cmpq %rbx, (%rsp)
sete %al
addq %rbp, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x2edfdf(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x19b080(%rip), %rsi    # 0x2e5013
leaq 0x1f9f30(%rip), %rdx    # 0x343eca
leaq 0x1f9f30(%rip), %rcx    # 0x343ed1
leaq 0x1f9e8b(%rip), %r8     # 0x343e33
movl $0xa3, %r9d
jmp 0x149fdc
movq 0x2edfb1(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x19b052(%rip), %rsi    # 0x2e5013
leaq 0x1f9f25(%rip), %rdx    # 0x343eed
leaq 0x1f9f02(%rip), %rcx    # 0x343ed1
leaq 0x1f9e5d(%rip), %r8     # 0x343e33
movl $0xa5, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x14a0ff
movq %rdx, %r14
movq %rdi, %rbx
movq %rsi, (%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x17e(%rip), %rax       # 0x14a1f5
movq %rax, 0x8(%rdi)
leaq 0x178(%rip), %rax       # 0x14a1fa
movq %rax, 0x18(%rdi)
andq $0x0, 0x20(%rdi)
leaq 0xa3(%rip), %rax        # 0x14a135
movq %rax, 0x28(%rdi)
movq %rdi, 0x30(%rdi)
leaq 0x15e(%rip), %rax       # 0x14a1ff
movq %rax, 0x38(%rdi)
leaq -0x70(%rip), %rax       # 0x14a03c
movq %rax, 0x40(%rdi)
andq $0x0, 0x48(%rdi)
addq $0x50, %rdi
leaq 0x144(%rip), %r8        # 0x14a204
pushq $0x8
popq %rcx
xorl %esi, %esi
xorl %edx, %edx
movq %rbx, %r9
callq 0x1496ec
leaq 0xb0(%rbx), %rdi
callq 0x1495e8
movq %r14, 0xd0(%rbx)
movb $0x0, 0xd8(%rbx)
addq $0xc0, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1495e8
movq 0x2ede62(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x19af03(%rip), %rsi    # 0x2e5013
leaq 0x1b412e(%rip), %rdx    # 0x2fe245
leaq 0x1f8f13(%rip), %rcx    # 0x343031
leaq 0x1f8f19(%rip), %r8     # 0x34303e
pushq $0x69
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x14a191
movq 0xd0(%rdi), %rax
movq (%rax), %r12
testq %r12, %r12
je 0x14a1bf
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movl 0x48(%rax), %ebp
xorl %r13d, %r13d
cmpq %r13, %rbx
je 0x14a17f
leaq (%r14,%r13), %rsi
movq %r12, %rdi
movl %ebp, %edx
callq 0x705e4
movb %al, (%r15,%r13)
incq %r13
jmp 0x14a163
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x2eddd0(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x19ae71(%rip), %rsi    # 0x2e5013
leaq 0x1e986e(%rip), %rdx    # 0x333a17
leaq 0x1f9de5(%rip), %rcx    # 0x343f95
leaq 0x1f9d4b(%rip), %r8     # 0x343f02
movl $0xc9, %r9d
jmp 0x14a1e9
movq 0x2edda2(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x19ae43(%rip), %rsi    # 0x2e5013
leaq 0x1dd41b(%rip), %rdx    # 0x3275f2
leaq 0x1f9e06(%rip), %rcx    # 0x343fe4
leaq 0x1f8e59(%rip), %r8     # 0x34303e
pushq $0x25
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 %r8, -0x40(%rbp)
movq %rcx, -0x30(%rbp)
movq %rdx, -0x48(%rbp)
movq %rsi, -0x38(%rbp)
movq %rsp, %r15
leaq 0xf(,%r9,8), %rax
andq $-0x10, %rax
subq %rax, %r15
movq %r15, %rsp
testq %rdi, %rdi
je 0x14a35a
movq %r9, %r14
movq 0xd0(%rdi), %r12
xorl %ebx, %ebx
cmpq %rbx, %r14
je 0x14a2df
movl 0xa4(%r12), %eax
movq 0xa8(%r12), %rdi
cmpl 0xa0(%r12), %eax
jb 0x14a2bf
movq 0xb0(%r12), %rcx
movl $0x1000, %edx           # imm = 0x1000
pushq $0x8
popq %rsi
callq 0x17ad0
movq %rax, %r13
movl %r13d, 0xa0(%r12)
movq 0xb0(%r12), %rdi
callq 0x17e70
testl %eax, %eax
jne 0x14a333
andl $0x0, 0xa4(%r12)
testl %r13d, %r13d
je 0x14a2dc
movq 0xa8(%r12), %rdi
xorl %eax, %eax
leal 0x1(%rax), %ecx
movl %ecx, 0xa4(%r12)
movl %eax, %eax
movq (%rdi,%rax,8), %rax
movq %rax, (%r15,%rbx,8)
incq %rbx
jmp 0x14a24f
movq %rbx, %r14
movq -0x38(%rbp), %rdi
movq %r15, %rsi
movq -0x40(%rbp), %rdx
movq %r14, %rcx
callq *-0x48(%rbp)
leaq 0x10(%rbp), %rax
movq (%rax), %rdx
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x14a311
movq %rdx, %rdi
movq -0x30(%rbp), %rsi
movq %r15, %rdx
movq %r14, %rcx
callq *%rax
jmp 0x14a321
imulq %r14, %rdx
movq -0x30(%rbp), %rdi
movq %r15, %rsi
callq 0x17630
movq %r14, %rax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x2edc2e(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1af885(%rip), %rsi    # 0x2f9bc9
leaq 0x2389e0(%rip), %rdx    # 0x382d2b
xorl %eax, %eax
callq 0x17a50
pushq $0x2
popq %rdi
callq 0x178f0
movq 0x2edc07(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x19aca8(%rip), %rsi    # 0x2e5013
leaq 0x20dd49(%rip), %rdx    # 0x3580bb
leaq 0x1f9c7b(%rip), %rcx    # 0x343ff4
leaq 0x1f9b82(%rip), %r8     # 0x343f02
movl $0xeb, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq 0xd0(%rdi), %rax
cmpq $0x0, 0xc8(%rax)
je 0x14a442
movb 0xd8(%rbx), %cl
testb %cl, %cl
jle 0x14a4a0
movq (%rax), %rdx
testq %rdx, %rdx
je 0x14a4b9
movl 0x48(%rax), %ecx
leaq 0xc0(%rbx), %rdi
pushq $0x2
popq %rbp
movl %ebp, %esi
callq 0x149658
addq $0x8, %rax
movq %rax, 0x20(%rsp)
leaq -0xfb2(%rip), %rax      # 0x1494bc
movq %rax, 0x28(%rsp)
leaq -0xf25(%rip), %rax      # 0x149555
movq %rax, 0x30(%rsp)
addq $0x50, %rbx
movq %rax, 0x10(%rsp)
movups 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
movl %ebp, %esi
callq 0x1497c7
movq %rax, %rbx
jmp 0x14a4af
incb %cl
movb %cl, 0xd8(%rbx)
leaq 0x26(%rip), %rdx        # 0x14a4d5
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %rbp
retq
movq 0x2edaa8(%rip), %rax    # 0x437f68
movq (%rax), %rsi
leaq 0x1f9a5e(%rip), %rdi    # 0x343f28
callq 0x17870
xorl %edx, %edx
xorl %ebx, %ebx
jmp 0x14a4af
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/eis-suffixarray-interface.c
// Function: gt_SAIMakeSufTabReader
struct seqDataReader
gt_SAIMakeSufTabReader(SuffixarrayFileInterface *sai)
{
  struct seqDataReader reader = { NULL, NULL};
  if (sai->sa->suftabstream_GtUword.fp)
  {
    struct seqDataTranslator xltor = {
      { .elemSize = sizeof (GtUword) }, NULL, NULL,
    };
    reader = gt_seqReaderSetRegisterConsumer(&sai->baseClass.readerSet,
                                             SFX_REQUEST_SUFTAB, xltor);
  }
  else
  {
    fputs("error: suffix array data not available for given project.\n",
          stderr);
  }
  return reader;
}

// Assembly:
subq $0x18, %rsp
movq 0xd0(%rdi), %rax
cmpq $0x0, 0xb0(%rax)
je 0x14a56c
addq $0x50, %rdi
movq 0x1f9ac1(%rip), %rax    # 0x344010
movq %rax, 0x10(%rsp)
movups 0x1f9aa5(%rip), %xmm0   # 0x344000
movups %xmm0, (%rsp)
pushq $0x1
popq %rsi
callq 0x1497c7
addq $0x18, %rsp
retq
movq 0x2ed9f5(%rip), %rax    # 0x437f68
movq (%rax), %rsi
leaq 0x1f99dd(%rip), %rdi    # 0x343f5a
callq 0x17870
xorl %edx, %edx
xorl %eax, %eax
jmp 0x14a567
// File: /workspace/github_c_makefile_star2_O2/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 0x14a63b
callq 0x148e03
movq %rax, %rbx
pushq $0x1
popq %rdx
movq %rax, %rdi
movl $0xff, %esi
callq 0x149198
movq %rbx, %rax
popq %rbx
retq
movq 0x2ed926(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x19a9c7(%rip), %rsi    # 0x2e5013
leaq 0x1f9964(%rip), %rdx    # 0x343fb7
leaq 0x1f9970(%rip), %rcx    # 0x343fca
leaq 0x1f98a1(%rip), %r8     # 0x343f02
movl $0xda, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
nop
// File: /workspace/github_c_makefile_star2_O2/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 0x14aa64
movq 0xe0(%rdi), %r12
testq %r12, %r12
je 0x14aa92
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movl 0xc0(%rdi), %ebp
xorl %r13d, %r13d
cmpq %r13, %rbx
je 0x14aa52
leaq (%r14,%r13), %rsi
movq %r12, %rdi
movl %ebp, %edx
callq 0x705e4
movb %al, (%r15,%r13)
incq %r13
jmp 0x14aa36
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x2ed4fd(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x19a59e(%rip), %rsi    # 0x2e5013
leaq 0x1e8f9b(%rip), %rdx    # 0x333a17
leaq 0x1f95fc(%rip), %rcx    # 0x34407f
leaq 0x1f95ac(%rip), %r8     # 0x344036
movl $0x165, %r9d            # imm = 0x165
jmp 0x14aabc
movq 0x2ed4cf(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x19a570(%rip), %rsi    # 0x2e5013
leaq 0x1dcb48(%rip), %rdx    # 0x3275f2
leaq 0x1f9533(%rip), %rcx    # 0x343fe4
leaq 0x1f8586(%rip), %r8     # 0x34303e
pushq $0x25
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rdi, %rbx
movq 0x48(%rdi), %rdi
testq %rdi, %rdi
je 0x14ad9e
callq 0x149458
leaq 0xb0(%rbx), %rdi
callq 0x1495ef
leaq 0x50(%rbx), %rdi
callq 0x149718
movq 0xf0(%rbx), %rdi
xorl %esi, %esi
callq 0x1a8f90
andq $0x0, 0xf0(%rbx)
movq 0xe8(%rbx), %rdi
callq 0x14ad2d
leaq 0x1f925a(%rip), %rsi    # 0x344036
movq %rbx, %rdi
movl $0x127, %edx            # imm = 0x127
popq %rbx
jmp 0x936f9
// File: /workspace/github_c_makefile_star2_O2/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 0x14ae1c
movq 0xd8(%rdi), %rdi
callq 0x148e03
movq %rax, %rbx
pushq $0x1
popq %rdx
movq %rax, %rdi
movl $0xff, %esi
callq 0x149198
movq %rbx, %rax
popq %rbx
retq
movq 0x2ed145(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x19a1e6(%rip), %rsi    # 0x2e5013
leaq 0x1c5580(%rip), %rdx    # 0x3103b4
leaq 0x1f9222(%rip), %rcx    # 0x34405d
leaq 0x1f91f4(%rip), %r8     # 0x344036
movl $0x134, %r9d            # imm = 0x134
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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)
andq $0x0, 0x10(%rdi)
cmpl $0x1, %edx
je 0x14af14
cmpl $0x2, %edx
jne 0x14af20
movl 0xc0(%rsi), %ecx
movq 0xe0(%rsi), %rdx
addq $0xb0, %rsi
pushq $0x2
popq %rax
movq %rsi, %rdi
movl %eax, %esi
callq 0x149658
addq $0x8, %rax
movq %rax, (%rbx)
leaq -0x1a47(%rip), %rax     # 0x1494bc
movq %rax, 0x8(%rbx)
leaq -0x19b9(%rip), %rax     # 0x149555
movq %rax, 0x10(%rbx)
jmp 0x14af1b
movq $0x8, (%rbx)
movq %rbx, %rax
popq %rbx
retq
movq 0x2ed041(%rip), %rax    # 0x437f68
movq (%rax), %rcx
leaq 0x1f9160(%rip), %rdi    # 0x344091
pushq $0x1e
popq %rsi
pushq $0x1
popq %rdx
callq 0x17f00
callq 0x17390
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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, %rbx
movaps %xmm0, 0x20(%rbx)
movaps %xmm0, 0x10(%rbx)
movaps %xmm0, (%rbx)
andq $0x0, 0x30(%rbx)
movq %rbx, %rdx
callq 0x1457be
movq %rax, %r14
movq %rbx, %rdi
callq 0x14af7f
movq %r14, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq