LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-bwtseq.c
// Function: gt_newBWTSeq
BWTSeq *
gt_newBWTSeq(EISeq *seqIdx, MRAEnc *alphabet,
          const enum rangeSortMode *defaultRangeSort)
{
  BWTSeq *bwtSeq;
  GtUword *counts;
  size_t countsOffset, rangeSortOffset, totalSize;
  enum rangeSortMode *rangeSort;
  unsigned alphabetSize;
  gt_assert(seqIdx);
  /* alphabetSize is increased by one to handle the flattened
   * terminator symbol correctly */
  alphabetSize = gt_MRAEncGetSize(alphabet) + 1;
  countsOffset = offsetAlign(sizeof (struct BWTSeq), sizeof (GtUword));
  rangeSortOffset = offsetAlign(countsOffset
                                + sizeof (GtUword) * (alphabetSize + 1),
                                sizeof (enum rangeSortMode));
  totalSize = rangeSortOffset + sizeof (enum rangeSortMode)
    * MRAEncGetNumRanges(alphabet);
  bwtSeq = gt_malloc(totalSize);
  bwtSeq->pckbuckettable = NULL;
  counts = (GtUword *)((char  *)bwtSeq + countsOffset);
  rangeSort = (enum rangeSortMode *)((char *)bwtSeq + rangeSortOffset);
  if (!initBWTSeqFromEncSeqIdx(bwtSeq, seqIdx, alphabet, counts, rangeSort,
                               defaultRangeSort))
  {
    gt_free(bwtSeq);
    bwtSeq = NULL;
  }
  return bwtSeq;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
cmpq $0x0, 0x50(%rsp)
jne 0x225bf3
movq 0x4163de(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2f0447(%rip), %rsi    # 0x516013
leaq 0x390ae4(%rip), %rdx    # 0x5b66b7
leaq 0x34f8d8(%rip), %rcx    # 0x5754b2
leaq 0x34f8de(%rip), %r8     # 0x5754bf
movl $0x74, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x225bf5
movq 0x48(%rsp), %rdi
callq 0x22aeb0
movzwl %ax, %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
movl $0x58, %edi
movl $0x8, %esi
callq 0x225d00
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, %eax
shlq $0x3, %rax
addq %rax, %rdi
movl $0x4, %esi
callq 0x225d00
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x48(%rsp), %rdi
callq 0x225da0
movl %eax, %ecx
movq (%rsp), %rax
movl %ecx, %ecx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
leaq 0x34f84b(%rip), %rsi    # 0x5754bf
movl $0x7e, %edx
callq 0xe80f0
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq $0x0, 0x50(%rax)
movq 0x38(%rsp), %rax
addq 0x28(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rax
addq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
movq 0x50(%rsp), %rsi
movq 0x48(%rsp), %rdx
movq 0x30(%rsp), %rcx
movq 0x10(%rsp), %r8
movq 0x40(%rsp), %r9
callq 0x225db0
cmpl $0x0, %eax
jne 0x225cf5
movq 0x38(%rsp), %rdi
leaq 0x34f7dd(%rip), %rsi    # 0x5754bf
movl $0x85, %edx
callq 0xe88c0
movq $0x0, 0x38(%rsp)
movq 0x38(%rsp), %rax
addq $0x58, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-bwtseq.c
// Function: gt_deleteBWTSeq
void
gt_deleteBWTSeq(BWTSeq *bwtSeq)
{
  gt_MRAEncDelete(bwtSeq->alphabet);
  deleteEISHint(bwtSeq->seqIdx, bwtSeq->hint);
  gt_deleteEncIdxSeq(bwtSeq->seqIdx);
  gt_free(bwtSeq);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x22b660
movq (%rsp), %rax
movq (%rax), %rdi
movq (%rsp), %rax
movq 0x18(%rax), %rsi
callq 0x2261f0
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x229620
movq (%rsp), %rdi
leaq 0x34f2e2(%rip), %rsi    # 0x5754bf
movl $0x91, %edx
callq 0xe88c0
popq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-bwtseq.c
// Function: gt_BWTSeqMatchCount
GtUword
gt_BWTSeqMatchCount(const BWTSeq *bwtSeq, const Symbol *query, size_t queryLen,
                 bool forward)
{
  struct matchBound match;
  gt_assert(bwtSeq && query);
  getMatchBound(bwtSeq, query, queryLen, &match, forward);
  if (match.end < match.start)
    return 0;
  else
    return match.end - match.start;
}

// Assembly:
subq $0x38, %rsp
movb %cl, %al
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
andb $0x1, %al
movb %al, 0x17(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x22691b
cmpq $0x0, 0x20(%rsp)
jne 0x226953
movq 0x41567e(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2ef6e7(%rip), %rsi    # 0x516013
leaq 0x34ec2a(%rip), %rdx    # 0x57555d
leaq 0x34ec07(%rip), %rcx    # 0x575541
leaq 0x34eb7e(%rip), %r8     # 0x5754bf
movl $0x173, %r9d            # imm = 0x173
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x226955
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
movb 0x17(%rsp), %al
movq %rsp, %rcx
andb $0x1, %al
movzbl %al, %r8d
callq 0x2269b0
movq 0x8(%rsp), %rax
cmpq (%rsp), %rax
jae 0x22698c
movq $0x0, 0x30(%rsp)
jmp 0x22699a
movq 0x8(%rsp), %rax
subq (%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-bwtseq.c
// Function: gt_initEMIterator
bool
gt_initEMIterator(BWTSeqExactMatchesIterator *iter, const BWTSeq *bwtSeq,
               const Symbol *query, size_t queryLen, bool forward)
{
  gt_assert(iter && bwtSeq && query);
  if (!bwtSeq->locateSampleInterval)
  {
    fputs("Index does not contain locate information.\n"
          "Localization of matches impossible!", stderr);
    return false;
  }
  getMatchBound(bwtSeq, query, queryLen, &iter->bounds, forward);
  iter->nextMatchBWTPos = iter->bounds.start;
  initExtBitsRetrieval(&iter->extBits);
  return true;
}

// Assembly:
subq $0x38, %rsp
movb %r8b, %al
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
andb $0x1, %al
movb %al, 0xf(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x226df9
cmpq $0x0, 0x20(%rsp)
je 0x226df9
cmpq $0x0, 0x18(%rsp)
jne 0x226e31
movq 0x4151a0(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2ef209(%rip), %rsi    # 0x516013
leaq 0x34e744(%rip), %rdx    # 0x575555
leaq 0x34e755(%rip), %rcx    # 0x57556d
leaq 0x34e6a0(%rip), %r8     # 0x5754bf
movl $0x17f, %r9d            # imm = 0x17F
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x226e33
movq 0x20(%rsp), %rax
cmpl $0x0, 0x20(%rax)
jne 0x226e5b
movq 0x41515b(%rip), %rax    # 0x63bfa0
movq (%rax), %rsi
leaq 0x34e730(%rip), %rdi    # 0x57557f
callq 0x19810
movb $0x0, 0x37(%rsp)
jmp 0x226ea2
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x28(%rsp), %rcx
movb 0xf(%rsp), %al
andb $0x1, %al
movzbl %al, %r8d
callq 0x2269b0
movq 0x28(%rsp), %rax
movq (%rax), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x28(%rsp), %rdi
addq $0x18, %rdi
callq 0x226eb0
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-bwtseq.c
// Function: gt_initEmptyEMIterator
bool
gt_initEmptyEMIterator(BWTSeqExactMatchesIterator *iter, const BWTSeq *bwtSeq)
{
  gt_assert(iter && bwtSeq);
  if (!bwtSeq->locateSampleInterval)
  {
    fputs("Index does not contain locate information.\n"
          "Localization of matches impossible!", stderr);
    return false;
  }
  iter->bounds.start = iter->bounds.end = iter->nextMatchBWTPos = 0;
  initExtBitsRetrieval(&iter->extBits);
  return true;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x226eec
cmpq $0x0, (%rsp)
jne 0x226f24
movq 0x4150ad(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2ef116(%rip), %rsi    # 0x516013
leaq 0x34e6ca(%rip), %rdx    # 0x5755ce
leaq 0x34e6d2(%rip), %rcx    # 0x5755dd
leaq 0x34e5ad(%rip), %r8     # 0x5754bf
movl $0x18f, %r9d            # imm = 0x18F
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x226f26
movq (%rsp), %rax
cmpl $0x0, 0x20(%rax)
jne 0x226f4d
movq 0x415069(%rip), %rax    # 0x63bfa0
movq (%rax), %rsi
leaq 0x34e63e(%rip), %rdi    # 0x57557f
callq 0x19810
movb $0x0, 0x17(%rsp)
jmp 0x226f86
movq 0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x8(%rax)
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
callq 0x226eb0
movb $0x1, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-bwtseq.c
// Function: gt_newEMIterator
struct BWTSeqExactMatchesIterator *
gt_newEMIterator(const BWTSeq *bwtSeq, const Symbol *query, size_t queryLen,
              bool forward)
{
  struct BWTSeqExactMatchesIterator *iter;
  gt_assert(bwtSeq && query);
  iter = gt_malloc(sizeof (*iter));
  if (gt_initEMIterator(iter, bwtSeq, query, queryLen,forward))
  {
    return iter;
  }
  gt_free(iter);
  return NULL;
}

// Assembly:
subq $0x38, %rsp
movb %cl, %al
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
andb $0x1, %al
movb %al, 0x17(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x226fcb
cmpq $0x0, 0x20(%rsp)
jne 0x227003
movq 0x414fce(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2ef037(%rip), %rsi    # 0x516013
leaq 0x34e57a(%rip), %rdx    # 0x57555d
leaq 0x34e60a(%rip), %rcx    # 0x5755f4
leaq 0x34e4ce(%rip), %r8     # 0x5754bf
movl $0x1a0, %r9d            # imm = 0x1A0
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x227005
movl $0x50, %edi
leaq 0x34e4ae(%rip), %rsi    # 0x5754bf
movl $0x1a1, %edx            # imm = 0x1A1
callq 0xe80f0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
movb 0x17(%rsp), %al
andb $0x1, %al
movzbl %al, %r8d
callq 0x226dc0
testb $0x1, %al
jne 0x227049
jmp 0x227055
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x227074
movq 0x8(%rsp), %rdi
leaq 0x34e45e(%rip), %rsi    # 0x5754bf
movl $0x1a6, %edx            # imm = 0x1A6
callq 0xe88c0
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-bwtseq.c
// Function: gt_EMINumMatchesTotal
GtUword
gt_EMINumMatchesTotal(const struct BWTSeqExactMatchesIterator *iter)
{
  gt_assert(iter);
  if (iter->bounds.start > iter->bounds.end)
    return 0;
  else
    return iter->bounds.end - iter->bounds.start;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x2271d9
movq 0x414df8(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2eee61(%rip), %rsi    # 0x516013
leaq 0x32e016(%rip), %rdx    # 0x5551cf
leaq 0x34e445(%rip), %rcx    # 0x575605
leaq 0x34e2f8(%rip), %r8     # 0x5754bf
movl $0x1c2, %r9d            # imm = 0x1C2
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2271db
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0x2271f9
movq $0x0, 0x10(%rsp)
jmp 0x22720f
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rsp), %rcx
subq (%rcx), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-bwtseq.c
// Function: gt_EMINumMatchesLeft
GtUword
gt_EMINumMatchesLeft(const struct BWTSeqExactMatchesIterator *iter)
{
  gt_assert(iter);
  if (iter->nextMatchBWTPos > iter->bounds.end)
    return 0;
  else
    return iter->bounds.end - iter->bounds.start;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x227269
movq 0x414d68(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2eedd1(%rip), %rsi    # 0x516013
leaq 0x32df86(%rip), %rdx    # 0x5551cf
leaq 0x34e3cb(%rip), %rcx    # 0x57561b
leaq 0x34e268(%rip), %r8     # 0x5754bf
movl $0x1cc, %r9d            # imm = 0x1CC
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x22726b
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0x22728a
movq $0x0, 0x10(%rsp)
jmp 0x2272a0
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rsp), %rcx
subq (%rcx), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-encidxseq-siop.h
// Function: EISSymTransformedPosPairRank
static inline GtUwordPair
EISSymTransformedPosPairRank(EISeq *seq, Symbol tSym, GtUword posA,
                             GtUword posB, union EISHint *hint)
{
  if (tSym >= gt_MRAEncGetSize(EISGetAlphabet(seq)))
  {
    fprintf(stderr,"tsym="GT_WU",gt_MRAEncGetSize(EISGetAlphabet(seq)="
            GT_WU"\n", (GtUword) tSym,
            (GtUword) gt_MRAEncGetSize(EISGetAlphabet(seq)));
    exit(GT_EXIT_PROGRAMMING_ERROR);
  }
  gt_assert(tSym < gt_MRAEncGetSize(EISGetAlphabet(seq)));
  return seq->classInfo->posPairRank(seq, tSym, posA, posB, hint);
}

// Assembly:
subq $0x58, %rsp
movb %sil, %al
movq %rdi, 0x40(%rsp)
movb %al, 0x3f(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movzbl 0x3f(%rsp), %eax
movl %eax, 0x1c(%rsp)
movq 0x40(%rsp), %rdi
callq 0x2281d0
movq %rax, %rdi
callq 0x22aeb0
movw %ax, %cx
movl 0x1c(%rsp), %eax
movzwl %cx, %ecx
cmpl %ecx, %eax
jl 0x22831a
movq 0x413cd1(%rip), %rax    # 0x63bfa0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movzbl 0x3f(%rsp), %eax
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rdi
callq 0x2281d0
movq %rax, %rdi
callq 0x22aeb0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
movzwl %ax, %eax
movl %eax, %ecx
leaq 0x34d6de(%rip), %rsi    # 0x5759e7
movb $0x0, %al
callq 0x199f0
movl $0x2, %edi
callq 0x19890
jmp 0x22831c
movzbl 0x3f(%rsp), %eax
movl %eax, 0x4(%rsp)
movq 0x40(%rsp), %rdi
callq 0x2281d0
movq %rax, %rdi
callq 0x22aeb0
movw %ax, %cx
movl 0x4(%rsp), %eax
movzwl %cx, %ecx
cmpl %ecx, %eax
jl 0x22837d
movq 0x413c54(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2edcbd(%rip), %rsi    # 0x516013
leaq 0x34c7c2(%rip), %rdx    # 0x574b1f
leaq 0x34d6b6(%rip), %rcx    # 0x575a1a
leaq 0x34c679(%rip), %r8     # 0x5749e4
movl $0x69, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x22837f
movq 0x40(%rsp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
movzbl 0x3f(%rsp), %esi
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rcx
movq 0x20(%rsp), %r8
callq *%rax
movq %rax, 0x48(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x48(%rsp), %rax
movq 0x50(%rsp), %rdx
addq $0x58, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-encidxseq-construct.c
// Function: gt_createEncIdxSeq
EISeq *
gt_createEncIdxSeq(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,
                GtLogger *verbosity, GtError *err)
{
  Suffixarray suffixArray;
  struct encIdxSeq *newSeqIdx;
  GtUword length;
  gt_assert(projectName);
  /* map and interpret index project file */
  if (streamsuffixarray(&suffixArray,
                       SARR_SUFTAB | SARR_BWTTAB, projectName, verbosity, err))
    return NULL;
  length = gt_encseq_total_length(suffixArray.encseq) + 1;
  newSeqIdx = gt_createEncIdxSeqFromSA(&suffixArray, length,
                                      projectName, params,
                                      numExtHeaders, headerIDs,
                                      extHeaderSizes, extHeaderCallbacks,
                                      headerCBData, biFunc, cwExtBitsPerPos,
                                      biVarBits, cbState, err);
  gt_freesuffixarray(&suffixArray);
  return newSeqIdx;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq 0x1f0(%rsp), %rax
movq 0x1e8(%rsp), %rax
movq 0x1e0(%rsp), %rax
movq 0x1d8(%rsp), %rax
movq 0x1d0(%rsp), %rax
movq 0x1c8(%rsp), %rax
movq 0x1c0(%rsp), %rax
movq %rdi, 0x180(%rsp)
movq %rsi, 0x178(%rsp)
movq %rdx, 0x170(%rsp)
movq %rcx, 0x168(%rsp)
movq %r8, 0x160(%rsp)
movq %r9, 0x158(%rsp)
cmpq $0x0, 0x180(%rsp)
jne 0x22897b
movq 0x413656(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2ed6bf(%rip), %rsi    # 0x516013
leaq 0x34bd4c(%rip), %rdx    # 0x5746a7
leaq 0x34d0fa(%rip), %rcx    # 0x575a5c
leaq 0x34d106(%rip), %r8     # 0x575a6f
movl $0x31, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x22897d
movq 0x180(%rsp), %rdx
movq 0x1e8(%rsp), %rcx
movq 0x1f0(%rsp), %r8
leaq 0x58(%rsp), %rdi
movl $0xa, %esi
callq 0x233500
cmpl $0x0, %eax
je 0x2289ba
movq $0x0, 0x188(%rsp)
jmp 0x228a7f
movq 0x58(%rsp), %rdi
callq 0xa9d00
addq $0x1, %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rsi
movq 0x180(%rsp), %rdx
movq 0x178(%rsp), %rcx
movq 0x170(%rsp), %r8
movq 0x168(%rsp), %r9
movq 0x160(%rsp), %r13
movq 0x158(%rsp), %r12
movq 0x1c0(%rsp), %r15
movq 0x1c8(%rsp), %r14
movq 0x1d0(%rsp), %rbx
movq 0x1d8(%rsp), %r11
movq 0x1e0(%rsp), %r10
movq 0x1f0(%rsp), %rax
leaq 0x58(%rsp), %rdi
movq %r13, (%rsp)
movq %r12, 0x8(%rsp)
movq %r15, 0x10(%rsp)
movq %r14, 0x18(%rsp)
movq %rbx, 0x20(%rsp)
movq %r11, 0x28(%rsp)
movq %r10, 0x30(%rsp)
movq %rax, 0x38(%rsp)
callq 0x228aa0
movq %rax, 0x50(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x233320
movq 0x50(%rsp), %rax
movq %rax, 0x188(%rsp)
movq 0x188(%rsp), %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-encidxseq-construct.c
// Function: gt_createEncIdxSeqFromSA
EISeq *
gt_createEncIdxSeqFromSA(Suffixarray *sa, GtUword totalLen,
                      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)
{
  struct encIdxSeq *newSeqIdx;
  SuffixarrayFileInterface sai;
  gt_assert(sa && projectName && err);
  gt_initSuffixarrayFileInterface(&sai, totalLen, sa);
  newSeqIdx = gt_createEncIdxSeqFromSAI(
    &sai, projectName, params, numExtHeaders, headerIDs,
    extHeaderSizes, extHeaderCallbacks, headerCBData, biFunc, cwExtBitsPerPos,
    biVarBits, cbState, err);
  gt_destructSuffixarrayFileInterface(&sai);
  return newSeqIdx;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x158, %rsp            # imm = 0x158
movq 0x1b8(%rsp), %rax
movq 0x1b0(%rsp), %rax
movq 0x1a8(%rsp), %rax
movq 0x1a0(%rsp), %rax
movq 0x198(%rsp), %rax
movq 0x190(%rsp), %rax
movq 0x188(%rsp), %rax
movq 0x180(%rsp), %rax
movq %rdi, 0x150(%rsp)
movq %rsi, 0x148(%rsp)
movq %rdx, 0x140(%rsp)
movq %rcx, 0x138(%rsp)
movq %r8, 0x130(%rsp)
movq %r9, 0x128(%rsp)
cmpq $0x0, 0x150(%rsp)
je 0x228b3f
cmpq $0x0, 0x140(%rsp)
je 0x228b3f
cmpq $0x0, 0x1b8(%rsp)
jne 0x228b77
movq 0x41345a(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2ed4c3(%rip), %rsi    # 0x516013
leaq 0x34cf3c(%rip), %rdx    # 0x575a93
leaq 0x34cf4e(%rip), %rcx    # 0x575aac
leaq 0x34cf0a(%rip), %r8     # 0x575a6f
movl $0x4f, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x228b79
movq 0x148(%rsp), %rsi
movq 0x150(%rsp), %rdx
leaq 0x40(%rsp), %rdi
callq 0x22d190
movq 0x140(%rsp), %rsi
movq 0x138(%rsp), %rdx
movq 0x130(%rsp), %rcx
movq 0x128(%rsp), %r8
movq 0x180(%rsp), %r9
movq 0x188(%rsp), %r12
movq 0x190(%rsp), %r15
movq 0x198(%rsp), %r14
movq 0x1a0(%rsp), %rbx
movq 0x1a8(%rsp), %r11
movq 0x1b0(%rsp), %r10
movq 0x1b8(%rsp), %rax
leaq 0x40(%rsp), %rdi
movq %r12, (%rsp)
movq %r15, 0x8(%rsp)
movq %r14, 0x10(%rsp)
movq %rbx, 0x18(%rsp)
movq %r11, 0x20(%rsp)
movq %r10, 0x28(%rsp)
movq %rax, 0x30(%rsp)
callq 0x228c50
movq %rax, 0x120(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x22d740
movq 0x120(%rsp), %rax
addq $0x158, %rsp            # imm = 0x158
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-encidxseq-construct.c
// Function: gt_createEncIdxSeqFromSAI
EISeq *
gt_createEncIdxSeqFromSAI(SuffixarrayFileInterface *sai,
                       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(sai && projectName && err);
  return gt_createEncIdxSeqFromSASeqSrc(
    SAI2SASS(sai), projectName, params,
    numExtHeaders, headerIDs, extHeaderSizes,
    extHeaderCallbacks, headerCBData, biFunc,
    cwExtBitsPerPos, biVarBits, cbState, err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq 0xc0(%rsp), %rax
movq 0xb8(%rsp), %rax
movq 0xb0(%rsp), %rax
movq 0xa8(%rsp), %rax
movq 0xa0(%rsp), %rax
movq 0x98(%rsp), %rax
movq 0x90(%rsp), %rax
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x38(%rsp)
cmpq $0x0, 0x60(%rsp)
je 0x228ccc
cmpq $0x0, 0x58(%rsp)
je 0x228ccc
cmpq $0x0, 0xc0(%rsp)
jne 0x228d04
movq 0x4132cd(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2ed336(%rip), %rsi    # 0x516013
leaq 0x34cde1(%rip), %rdx    # 0x575ac5
leaq 0x34cdf4(%rip), %rcx    # 0x575adf
leaq 0x34cd7d(%rip), %r8     # 0x575a6f
movl $0x65, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x228d06
movq 0x60(%rsp), %rdi
callq 0x229010
movq %rax, %rdi
movq 0x58(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq 0x48(%rsp), %rcx
movq 0x40(%rsp), %r8
movq 0x38(%rsp), %r9
movq 0x90(%rsp), %r12
movq 0x98(%rsp), %r15
movq 0xa0(%rsp), %r14
movq 0xa8(%rsp), %rbx
movq 0xb0(%rsp), %r11
movq 0xb8(%rsp), %r10
movq 0xc0(%rsp), %rax
movq %r12, (%rsp)
movq %r15, 0x8(%rsp)
movq %r14, 0x10(%rsp)
movq %rbx, 0x18(%rsp)
movq %r11, 0x20(%rsp)
movq %r10, 0x28(%rsp)
movq %rax, 0x30(%rsp)
callq 0x228da0
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %r12
pushq %rbx
subq $0x68, %rsp
movq 0xc0(%rsp), %rax
movq 0xb8(%rsp), %rax
movq 0xb0(%rsp), %rax
movq 0xa8(%rsp), %rax
movq 0xa0(%rsp), %rax
movq 0x98(%rsp), %rax
movq 0x90(%rsp), %rax
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x38(%rsp)
cmpq $0x0, 0x60(%rsp)
je 0x22909c
cmpq $0x0, 0x58(%rsp)
je 0x22909c
cmpq $0x0, 0xc0(%rsp)
jne 0x2290d4
movq 0x412efd(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2ecf66(%rip), %rsi    # 0x516013
leaq 0x34ca45(%rip), %rdx    # 0x575af9
leaq 0x34ca59(%rip), %rcx    # 0x575b14
leaq 0x34c9ad(%rip), %r8     # 0x575a6f
movl $0x79, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2290d6
movq 0x60(%rsp), %rdi
callq 0x22dea0
movq %rax, %rdi
movq 0x58(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq 0x48(%rsp), %rcx
movq 0x40(%rsp), %r8
movq 0x38(%rsp), %r9
movq 0x90(%rsp), %r12
movq 0x98(%rsp), %r15
movq 0xa0(%rsp), %r14
movq 0xa8(%rsp), %rbx
movq 0xb0(%rsp), %r11
movq 0xb8(%rsp), %r10
movq 0xc0(%rsp), %rax
movq %r12, (%rsp)
movq %r15, 0x8(%rsp)
movq %r14, 0x10(%rsp)
movq %rbx, 0x18(%rsp)
movq %r11, 0x20(%rsp)
movq %r10, 0x28(%rsp)
movq %rax, 0x30(%rsp)
callq 0x228da0
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-encidxseq-construct.c
// Function: gt_createEncIdxSeqGen
EISeq *
gt_createEncIdxSeqGen(GtUword totalLen, const char *projectName,
                   MRAEnc *alphabet, const struct seqStats *stats,
                   SeqDataReader seqGenerator,
                   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)
{
  EISeq *seqIdx = NULL;
  switch (params->encType)
  {
  case BWT_ON_BLOCK_ENC:
    seqIdx = gt_newGenBlockEncIdxSeq(totalLen, projectName, alphabet, stats,
                                  seqGenerator, params, numExtHeaders,
                                  headerIDs, extHeaderSizes, extHeaderCallbacks,
                                  headerCBData, biFunc, cwExtBitsPerPos,
                                  biVarBits, cbState, err);
    break;
  default:
    gt_error_set(err, "Illegal/unknown/unimplemented encoding requested!");
    break;
  }
  return seqIdx;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq 0x130(%rsp), %rax
movq 0x128(%rsp), %rax
movq 0x120(%rsp), %rax
movq 0x118(%rsp), %rax
movq 0x110(%rsp), %rax
movq 0x108(%rsp), %rax
movq 0x100(%rsp), %rax
movq 0xf8(%rsp), %rax
movq 0xf0(%rsp), %rax
movq 0xe8(%rsp), %rax
movq 0xe0(%rsp), %rax
movq %r8, 0x98(%rsp)
movq %r9, 0xa0(%rsp)
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movq %rcx, 0x78(%rsp)
movq $0x0, 0x70(%rsp)
movq 0xe0(%rsp), %rax
movl (%rax), %eax
subl $0x2, %eax
jne 0x2292ff
jmp 0x229224
movq 0x90(%rsp), %rdi
movq 0x88(%rsp), %rsi
movq 0x80(%rsp), %rdx
movq 0x78(%rsp), %rcx
movq 0xe0(%rsp), %rax
movq 0xe8(%rsp), %r8
movq %r8, 0x60(%rsp)
movq 0xf0(%rsp), %rbp
movq 0xf8(%rsp), %r13
movq 0x100(%rsp), %r12
movq 0x108(%rsp), %r15
movq 0x110(%rsp), %r14
movq 0x118(%rsp), %rbx
movq 0x120(%rsp), %r11
movq 0x128(%rsp), %r10
movq 0x130(%rsp), %r8
movq %r8, 0x68(%rsp)
movq 0x98(%rsp), %r8
movq 0xa0(%rsp), %r9
movq %rax, (%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x68(%rsp), %rax
movq %rbp, 0x10(%rsp)
movq %r13, 0x18(%rsp)
movq %r12, 0x20(%rsp)
movq %r15, 0x28(%rsp)
movq %r14, 0x30(%rsp)
movq %rbx, 0x38(%rsp)
movq %r11, 0x40(%rsp)
movq %r10, 0x48(%rsp)
movq %rax, 0x50(%rsp)
callq 0x4a4980
movq %rax, 0x70(%rsp)
jmp 0x229315
movq 0x130(%rsp), %rdi
leaq 0x34c821(%rip), %rsi    # 0x575b2f
movb $0x0, %al
callq 0xd88c0
movq 0x70(%rsp), %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movl %ecx, 0x20(%rsp)
movq %r8, 0x18(%rsp)
movq $0x0, 0x8(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x229394
movq 0x412c3d(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2ecca6(%rip), %rsi    # 0x516013
leaq 0x34c7ed(%rip), %rdx    # 0x575b61
leaq 0x34c7f7(%rip), %rcx    # 0x575b72
leaq 0x34c6ed(%rip), %r8     # 0x575a6f
movl $0xc4, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x229396
movq 0x30(%rsp), %rdi
callq 0x22dcb0
movq %rax, 0x10(%rsp)
movl 0x24(%rsp), %eax
subl $0x2, %eax
jne 0x2293cf
jmp 0x2293b0
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rsi
movl 0x20(%rsp), %edx
movq 0x18(%rsp), %rcx
callq 0x4a7bb0
movq %rax, 0x8(%rsp)
jmp 0x2293e2
movq 0x18(%rsp), %rdi
leaq 0x34c754(%rip), %rsi    # 0x575b2f
movb $0x0, %al
callq 0xd88c0
jmp 0x2293e4
cmpq $0x0, 0x8(%rsp)
jne 0x229432
movq 0x18(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x229432
movq 0x412b9f(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2ecc08(%rip), %rsi    # 0x516013
leaq 0x34c776(%rip), %rdx    # 0x575b88
leaq 0x34c759(%rip), %rcx    # 0x575b72
leaq 0x34c64f(%rip), %r8     # 0x575a6f
movl $0xd0, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x229434
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl %edx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq %r8, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq $0x0, (%rsp)
callq 0xb7a40
movq %rax, (%rsp)
movq (%rsp), %rdi
callq 0xbaa10
movq (%rsp), %rdi
callq 0xba820
movq (%rsp), %rdi
callq 0xba910
movq (%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0xb7aa0
movq %rax, 0x8(%rsp)
movq (%rsp), %rdi
callq 0xb7e50
cmpq $0x0, 0x8(%rsp)
jne 0x2294c4
jmp 0x2294f7
movq 0x8(%rsp), %rdi
callq 0xb0f00
movq %rax, %rdi
movq 0x30(%rsp), %rsi
movl 0x2c(%rsp), %edx
movl 0x28(%rsp), %ecx
movq 0x18(%rsp), %r8
callq 0x229330
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rdi
callq 0xae070
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-encidxseq.c
// Function: gt_estimateSegmentSize
unsigned
gt_estimateSegmentSize(const struct seqBaseParam *params)
{
  unsigned segmentLen = 0;
  switch (params->encType)
  {
  case BWT_ON_BLOCK_ENC:
    segmentLen =
      gt_blockEncIdxSeqSegmentLen(&params->encParams.blockEnc);
    break;
  default:
    fputs("Illegal/unknown/unimplemented encoding requested!", stderr);
    abort();
    break;
  }
  return segmentLen;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movq 0x10(%rsp), %rax
movl (%rax), %eax
subl $0x2, %eax
jne 0x22a783
jmp 0x22a76f
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
callq 0x4a9620
movl %eax, 0xc(%rsp)
jmp 0x22a79e
movq 0x411816(%rip), %rax    # 0x63bfa0
movq (%rax), %rsi
leaq 0x34b39b(%rip), %rdi    # 0x575b2f
callq 0x19810
callq 0x19370
movl 0xc(%rsp), %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x7e8c0
movl %eax, 0x4(%rsp)
movl $0x100, %edi            # imm = 0x100
leaq 0x34b34b(%rip), %rsi    # 0x575e7e
movl $0x5f, %edx
callq 0xe80f0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0xff, %esi
movl $0x100, %edx            # imm = 0x100
callq 0x19360
movl $0x0, (%rsp)
movl (%rsp), %eax
cmpl 0x4(%rsp), %eax
jae 0x22ab82
movl (%rsp), %eax
movb %al, %dl
movq 0x10(%rsp), %rax
movslq (%rsp), %rcx
movb %dl, (%rax,%rcx)
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0x22ab5d
movl 0x4(%rsp), %eax
movw %ax, 0x1c(%rsp)
movl 0x4(%rsp), %eax
movb %al, %cl
movq 0x10(%rsp), %rax
movb %cl, 0xfe(%rax)
movw $0x1, 0x1e(%rsp)
leaq 0x1c(%rsp), %rsi
movq 0x10(%rsp), %rdx
movl $0x2, %edi
callq 0x22a810
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x34b2b6(%rip), %rsi    # 0x575e7e
movl $0x6c, %edx
callq 0xe88c0
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x10(%rsp)
movl $0x0, -0x14(%rsp)
movl $0x0, -0xc(%rsp)
movl -0xc(%rsp), %eax
cmpl -0x10(%rsp), %eax
jae 0x22af01
movq -0x8(%rsp), %rax
movq 0x10(%rax), %rax
movl -0xc(%rsp), %ecx
movzwl (%rax,%rcx,2), %eax
addl -0x14(%rsp), %eax
movl %eax, -0x14(%rsp)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x22aed1
movl -0x14(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movq 0x40(%rsp), %rax
movl (%rax), %eax
subl $0x1, %eax
jne 0x22b403
jmp 0x22b38e
movq 0x40(%rsp), %rdi
callq 0x22ae50
movq %rax, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x30(%rsp), %rax
jae 0x22b3f8
movq 0x38(%rsp), %rdi
callq 0x191b0
movl %eax, 0xc(%rsp)
cmpl $-0x1, 0xc(%rsp)
je 0x22b3e4
movq 0x18(%rsp), %rax
movslq 0xc(%rsp), %rcx
movb 0x18(%rax,%rcx), %dl
movq 0x28(%rsp), %rax
movq 0x10(%rsp), %rcx
movb %dl, (%rax,%rcx)
jmp 0x22b3e6
jmp 0x22b3f8
jmp 0x22b3e8
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x22b3a6
movq 0x10(%rsp), %rax
movl %eax, 0x24(%rsp)
jmp 0x22b408
callq 0x19370
movslq 0x24(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movl (%rax), %eax
subl $0x1, %eax
jne 0x22b495
jmp 0x22b441
movq 0x20(%rsp), %rdi
callq 0x22ae50
movq %rax, 0x8(%rsp)
movq $0x0, (%rsp)
movq (%rsp), %rax
cmpq 0x10(%rsp), %rax
jae 0x22b493
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movq (%rsp), %rdx
movzbl (%rcx,%rdx), %ecx
movb 0x18(%rax,%rcx), %dl
movq 0x18(%rsp), %rax
movq (%rsp), %rcx
movb %dl, (%rax,%rcx)
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x22b458
jmp 0x22b49a
callq 0x19370
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movl (%rax), %eax
subl $0x1, %eax
jne 0x22b518
jmp 0x22b4c1
movq 0x20(%rsp), %rdi
callq 0x22ae50
movq %rax, 0x8(%rsp)
movq $0x0, (%rsp)
movq (%rsp), %rax
cmpq 0x10(%rsp), %rax
jae 0x22b516
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movq (%rsp), %rdx
movzbl (%rcx,%rdx), %ecx
movb 0x118(%rax,%rcx), %dl
movq 0x18(%rsp), %rax
movq (%rsp), %rcx
movb %dl, (%rax,%rcx)
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x22b4d8
jmp 0x22b51d
callq 0x19370
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x18(%rsp)
movb %al, 0x17(%rsp)
movl %edx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x22b561
cmpq $0x0, 0x8(%rsp)
jne 0x22b599
movq 0x410a38(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2eaaa1(%rip), %rsi    # 0x516013
leaq 0x34a9a7(%rip), %rdx    # 0x575f20
leaq 0x34a9b4(%rip), %rcx    # 0x575f34
leaq 0x34a8f7(%rip), %r8     # 0x575e7e
movl $0x15f, %r9d            # imm = 0x15F
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x22b59b
jmp 0x22b59d
movl 0x4(%rsp), %ecx
movq 0x18(%rsp), %rdx
xorl %eax, %eax
cmpl 0x4(%rdx), %ecx
movb %al, 0x3(%rsp)
jae 0x22b5d0
movzbl 0x17(%rsp), %eax
movq 0x18(%rsp), %rcx
movq 0x8(%rcx), %rcx
movl 0x4(%rsp), %edx
movzwl (%rcx,%rdx,2), %ecx
cmpl %ecx, %eax
setge %al
movb %al, 0x3(%rsp)
movb 0x3(%rsp), %al
testb $0x1, %al
jne 0x22b5da
jmp 0x22b5e7
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x22b59d
movl 0x4(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jae 0x22b648
movq 0x8(%rsp), %rax
movl 0x4(%rsp), %ecx
movl (%rax,%rcx,4), %eax
cmpl 0x10(%rsp), %eax
jne 0x22b63e
movzbl 0x17(%rsp), %eax
movq 0x18(%rsp), %rcx
movq 0x8(%rcx), %rcx
movl 0x4(%rsp), %edx
movzwl (%rcx,%rdx,2), %ecx
movq 0x18(%rsp), %rdx
movq 0x10(%rdx), %rdx
movl 0x4(%rsp), %esi
movzwl (%rdx,%rsi,2), %edx
subl %edx, %ecx
cmpl %ecx, %eax
jl 0x22b63e
movl $0x1, 0x24(%rsp)
jmp 0x22b650
movl $0x0, 0x24(%rsp)
jmp 0x22b650
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x22b6a9
movq 0x410928(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2ea991(%rip), %rsi    # 0x516013
leaq 0x349974(%rip), %rdx    # 0x574ffd
leaq 0x34a8c6(%rip), %rcx    # 0x575f56
leaq 0x34a7e7(%rip), %r8     # 0x575e7e
movl $0x174, %r9d            # imm = 0x174
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x22b6ab
movq 0x10(%rsp), %rax
movl (%rax), %eax
subl $0x1, %eax
jne 0x22b6e0
jmp 0x22b6b9
movq 0x10(%rsp), %rdi
callq 0x22b300
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
leaq 0x34a7aa(%rip), %rsi    # 0x575e7e
movl $0x17a, %edx            # imm = 0x17A
callq 0xe88c0
jmp 0x22b6e5
callq 0x19370
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x22b7cc
movq 0x410805(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2ea86e(%rip), %rsi    # 0x516013
leaq 0x34a7ba(%rip), %rdx    # 0x575f66
leaq 0x34a7bb(%rip), %rcx    # 0x575f6e
leaq 0x34a7cb(%rip), %r8     # 0x575f85
movl $0x20, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x22b7ce
movq $0x0, (%rsp)
movq (%rsp), %rax
cmpq 0x18(%rsp), %rax
jae 0x22b81f
movq 0x20(%rsp), %rax
movq (%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rsi
movq 0x10(%rsp), %rax
movl 0x8(%rax), %edx
callq 0x22b830
movb %al, %dl
movq 0x8(%rsp), %rax
movq (%rsp), %rcx
movb %dl, (%rax,%rcx)
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x22b7d6
movq 0x18(%rsp), %rax
shlq $0x0, %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x22b8f1
movq 0x4106e0(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2ea749(%rip), %rsi    # 0x516013
leaq 0x34a695(%rip), %rdx    # 0x575f66
leaq 0x34a6c7(%rip), %rcx    # 0x575f9f
leaq 0x34a6a6(%rip), %r8     # 0x575f85
movl $0x34, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x22b8f3
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x20(%rsp), %rax
jae 0x22b953
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
addq 0x8(%rsp), %rsi
callq 0x2e9a60
movq %rax, %rdi
movq 0x18(%rsp), %rax
movq (%rax), %rsi
movq 0x18(%rsp), %rax
movl 0x8(%rax), %edx
callq 0x22b830
movb %al, %dl
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movb %dl, (%rax,%rcx)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x22b8fc
movq 0x20(%rsp), %rax
shlq $0x0, %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x22b9d9
movq 0x4105f8(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2ea661(%rip), %rsi    # 0x516013
leaq 0x34a60c(%rip), %rdx    # 0x575fc5
leaq 0x34a616(%rip), %rcx    # 0x575fd6
leaq 0x34a5be(%rip), %r8     # 0x575f85
movl $0x50, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x22b9db
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x22ba1e
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq (%rsp), %rdi
leaq 0x34a573(%rip), %rsi    # 0x575f85
movl $0x56, %edx
callq 0xe88c0
jmp 0x22b9e9
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdx, 0x18(%rsp)
movl %ecx, 0x20(%rsp)
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl $0x20, %edi
leaq 0x34a533(%rip), %rsi    # 0x575f85
movl $0x60, %edx
callq 0xe80f0
movq %rax, (%rsp)
movl 0xc(%rsp), %ecx
movq (%rsp), %rax
movl %ecx, 0x8(%rax)
movq (%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq 0x20(%rsp), %rcx
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq (%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq (%rsp), %rax
addq $0x8, %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)