LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-sequencemultiread.c
// Function: gt_initEmptySeqReaderSet
void
gt_initEmptySeqReaderSet(SeqReaderSet *readerSet, int initialSuperSet,
                         bool fromSuffixsortspace,
                         size_t seqElemSize, generatorFunc generator,
                         void *generatorState)
{
  readerSet->fromSuffixsortspace = fromSuffixsortspace;
  readerSet->tagSuperSet = initialSuperSet;
  readerSet->numAutoConsumers = readerSet->numConsumers = 0;
  readerSet->consumerList = NULL;
  readerSet->autoConsumerList = NULL;
  readerSet->backlogStartPos = 0;
  readerSet->backlogLen = readerSet->backlogSize = 0;
  readerSet->backlogElemSize = seqElemSize;
  readerSet->seqDataBacklog = NULL; /* only allocate backlog when it's
                                     * really needed! */
  readerSet->generatorState = generatorState;
  readerSet->generator = generator;
}

// Assembly:
movb %dl, %al
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
andb $0x1, %al
movb %al, -0xd(%rsp)
movq %rcx, -0x18(%rsp)
movq %r8, -0x20(%rsp)
movq %r9, -0x28(%rsp)
movb -0xd(%rsp), %cl
movq -0x8(%rsp), %rax
andb $0x1, %cl
movb %cl, 0x28(%rax)
movl -0xc(%rsp), %ecx
movq -0x8(%rsp), %rax
movl %ecx, 0x8(%rax)
movq -0x8(%rsp), %rax
movl $0x0, (%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x30(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x38(%rax)
movq -0x18(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x40(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x48(%rax)
movq -0x28(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x50(%rax)
movq -0x20(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x58(%rax)
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x22bc49
movq 0x410388(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2ea3f1(%rip), %rsi    # 0x516013
leaq 0x34a3cf(%rip), %rdx    # 0x575ff8
leaq 0x34a3d2(%rip), %rcx    # 0x576002
leaq 0x34a3e3(%rip), %r8     # 0x57601a
movl $0x72, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x22bc4b
jmp 0x22bc4d
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x22bc90
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
leaq 0x34a39f(%rip), %rsi    # 0x57601a
movl $0x73, %edx
callq 0xe88c0
movq (%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x22bc5b
jmp 0x22bc92
movq 0x10(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x22bcb8
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
leaq 0x34a36c(%rip), %rsi    # 0x57601a
movl $0x75, %edx
callq 0xe88c0
movq 0x10(%rsp), %rax
cmpq $0x0, 0x48(%rax)
je 0x22bcde
movq 0x10(%rsp), %rax
movq 0x48(%rax), %rdi
leaq 0x34a346(%rip), %rsi    # 0x57601a
movl $0x77, %edx
callq 0xe88c0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
leaq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rcx
movl (%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, (%rcx)
movl %eax, 0x18(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x22bd59
movq 0x410278(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2ea2e1(%rip), %rsi    # 0x516013
leaq 0x34a2bf(%rip), %rdx    # 0x575ff8
leaq 0x34a2fc(%rip), %rcx    # 0x57603c
leaq 0x34a2d3(%rip), %r8     # 0x57601a
movl $0x81, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x22bd5b
leaq 0x34a2b8(%rip), %rsi    # 0x57601a
movl $0x48, %edi
movl $0x82, %edx
callq 0xe80f0
movq 0x8(%rsp), %rcx
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdx
movq 0x10(%rsp), %rax
movq %rdx, 0x18(%rax)
movl 0x18(%rsp), %edx
movq 0x10(%rsp), %rax
movl %edx, 0x20(%rax)
movq 0x10(%rsp), %rax
movq 0x10(%rcx), %rdx
movq %rdx, 0x40(%rax)
movups (%rcx), %xmm0
movups %xmm0, 0x30(%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0x8(%rax)
movl 0x1c(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x10(%rax)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x10(%rax)
movl 0x1c(%rsp), %edx
movq 0x20(%rsp), %rax
movl 0x8(%rax), %ecx
orl %edx, %ecx
movl %ecx, 0x8(%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x1d(%rip), %rax        # 0x22be20
movq %rax, 0x30(%rsp)
movq 0x28(%rsp), %rax
movq 0x30(%rsp), %rdx
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-sequencemultiread.c
// Function: seqReaderSetFindMinOpenRequest
static inline GtUword
seqReaderSetFindMinOpenRequest(SeqReaderSet *readerSet)
{
  struct seqReaderState *p;
  GtUword min = -1;
  gt_assert(readerSet);
  p = readerSet->consumerList;
  while (p)
  {
    min = GT_MIN(min, seqReaderSetGetConsumerNextPos(p));
    p = p->next;
  }
  return min;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq $-0x1, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x22c692
movq 0x40f93f(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2e99a8(%rip), %rsi    # 0x516013
leaq 0x349986(%rip), %rdx    # 0x575ff8
leaq 0x349b0e(%rip), %rcx    # 0x576187
leaq 0x34999a(%rip), %r8     # 0x57601a
movl $0x108, %r9d            # imm = 0x108
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x22c694
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x22c6fc
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x22c150
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x22c6d6
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
jmp 0x22c6e4
movq 0x18(%rsp), %rdi
callq 0x22c150
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
jmp 0x22c6a2
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-specialsrank.c
// Function: allocSpecialsRankTable
static inline struct specialsRankLookup *
allocSpecialsRankTable(const GtEncseq *encseq,
                       GtUword lastSeqPos,
                       unsigned sampleIntervalLog2,
                       GtReadmode readmode)
{
  struct specialsRankTable *rankTable;
  struct specialsRankLookup *ranker;
  GtUword numSamples = (lastSeqPos >> sampleIntervalLog2) + 1;

  ranker = gt_malloc(offsetAlign(sizeof (*ranker), sizeof (GtUword))
                     + numSamples * sizeof (GtUword));
  rankTable = &ranker->implementationData.sampleTable;
  rankTable->rankSumSamples
    = (GtUword *)((char *)ranker + offsetAlign(sizeof (*ranker),
                                              sizeof (GtUword)));
  rankTable->sampleIntervalLog2 = sampleIntervalLog2;
  rankTable->sampleInterval = ((GtUword)1) << sampleIntervalLog2;
  rankTable->readmode = readmode;
  rankTable->numSamples = numSamples;
  rankTable->scanState = gt_encseq_create_reader_with_readmode(encseq,
                                                               readmode, 0);
  ranker->encseq = encseq;
  ranker->rankFunc = specialsRankFromSampleTable;
  return ranker;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movl %ecx, 0x20(%rsp)
movq 0x28(%rsp), %rax
movl 0x24(%rsp), %ecx
shrq %cl, %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
movl $0x38, %edi
movl $0x8, %esi
callq 0x22cf90
movq %rax, %rdi
movq 0x8(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rdi
leaq 0x34969a(%rip), %rsi    # 0x57620a
movl $0x31, %edx
callq 0xe80f0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x18(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movl $0x38, %edi
movl $0x8, %esi
callq 0x22cf90
movq (%rsp), %rcx
addq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x8(%rax)
movl 0x24(%rsp), %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x24(%rax)
movl 0x24(%rsp), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x18(%rax)
movl 0x20(%rsp), %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x20(%rax)
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x30(%rsp), %rdi
movl 0x20(%rsp), %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xac380
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq 0x30(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
leaq 0x164(%rip), %rcx       # 0x22cd90
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0xaf770
andb $0x1, %al
movb %al, 0x17(%rsp)
testb $0x1, 0x17(%rsp)
je 0x22ccb9
cmpl $0x1, 0x24(%rsp)
je 0x22cc81
cmpl $0x3, 0x24(%rsp)
jne 0x22ccb7
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rcx
movq 0x30(%rsp), %rax
subq (%rax), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rcx
subq 0x8(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, (%rax)
jmp 0x22ccd8
movq 0x18(%rsp), %rcx
addq $0x1, %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, (%rax)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-specialsrank.c
// Function: allocEmptySpecialsRankLookup
static inline struct specialsRankLookup *
allocEmptySpecialsRankLookup(const GtEncseq *encseq,
                             GtUword lastSeqPos)
{
  struct specialsRankLookup *ranker;
  ranker = gt_malloc(sizeof (*ranker));
  ranker->implementationData.lastSeqPos = lastSeqPos;
  ranker->rankFunc = specialsRankFromTermPos;
  ranker->encseq = encseq;
  return ranker;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl $0x38, %edi
leaq 0x349500(%rip), %rsi    # 0x57620a
movl $0x46, %edx
callq 0xe80f0
movq %rax, (%rsp)
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq (%rsp), %rax
leaq 0x370(%rip), %rcx       # 0x22d0a0
movq %rcx, (%rax)
movq 0x10(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
leaq 0xb1(%rip), %rax        # 0x22d260
movq %rax, 0x38(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x58(%rsp), %rdi
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rax
xorl %ecx, %ecx
movl %ecx, %r9d
leaq 0x337(%rip), %rcx       # 0x22d510
leaq 0x370(%rip), %r8        # 0x22d550
leaq 0x38(%rsp), %r14
leaq 0x394(%rip), %rbx       # 0x22d580
leaq -0xc3(%rip), %r11       # 0x22d130
leaq 0x3a6(%rip), %r10       # 0x22d5a0
movq %r9, %rdx
movq (%r14), %r15
movq %r15, (%rsp)
movq 0x8(%r14), %r14
movq %r14, 0x8(%rsp)
movq %rbx, 0x10(%rsp)
movq %r11, 0x18(%rsp)
movq %r10, 0x20(%rsp)
movq %rax, 0x28(%rsp)
callq 0x22d300
movq 0x48(%rsp), %rcx
movq 0x58(%rsp), %rax
movq %rcx, 0xd0(%rax)
movq 0x58(%rsp), %rax
movb $0x0, 0xd8(%rax)
movq 0x58(%rsp), %rdi
addq $0xc0, %rdi
callq 0x22b970
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x70, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
movq %rsp, %rcx
movq %rcx, -0x50(%rbp)
leaq 0xf(,%rax,8), %rdx
andq $-0x10, %rdx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, -0x60(%rbp)
movq %rcx, %rsp
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x22d637
movq 0x40e99a(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2e8a03(%rip), %rsi    # 0x516013
leaq 0x35d5b5(%rip), %rdx    # 0x58abcc
leaq 0x348dad(%rip), %rcx    # 0x5763cb
leaq 0x348cb4(%rip), %r8     # 0x5762d9
movl $0xeb, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x22d639
jmp 0x22d63b
movq -0x40(%rbp), %rax
movq 0xd0(%rax), %rax
movq %rax, -0x48(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x22d692
movq -0x60(%rbp), %rdi
movq -0x38(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x48(%rbp), %rsi
addq $0xa0, %rsi
callq 0x22dd40
cmpl $0x1, %eax
je 0x22d682
jmp 0x22d692
jmp 0x22d684
movq -0x38(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
jmp 0x22d652
movq -0x60(%rbp), %rsi
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq -0x38(%rbp), %rcx
callq *%rax
movq -0x68(%rbp), %rax
movq -0x60(%rbp), %rsi
movq -0x20(%rbp), %rdi
movq -0x38(%rbp), %rdx
subq $0x20, %rsp
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x22de20
addq $0x20, %rsp
movq -0x38(%rbp), %rax
movq -0x50(%rbp), %rcx
movq %rcx, %rsp
movq %rbp, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x78, %rsp
movq %rdi, 0x60(%rsp)
leaq 0x68(%rsp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x19360
movq 0x60(%rsp), %rax
movq 0xd0(%rax), %rax
cmpq $0x0, 0xc8(%rax)
je 0x22d815
movq 0x60(%rsp), %rax
movsbl 0xd8(%rax), %eax
cmpl $0x0, %eax
jle 0x22d905
movq 0x60(%rsp), %rax
movq 0xd0(%rax), %rax
cmpq $0x0, (%rax)
je 0x22d8ed
movq 0x60(%rsp), %rax
movq 0xd0(%rax), %rax
movq (%rax), %rax
movq %rax, 0x50(%rsp)
movq 0x60(%rsp), %rax
movq 0xd0(%rax), %rax
movl 0x48(%rax), %eax
movl %eax, 0x58(%rsp)
movq 0x60(%rsp), %rdi
addq $0xc0, %rdi
movq 0x50(%rsp), %rdx
movl 0x58(%rsp), %ecx
movl $0x2, %esi
callq 0x22ba30
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x30(%rsp)
leaq -0x212b(%rip), %rax     # 0x22b760
movq %rax, 0x38(%rsp)
leaq -0x2017(%rip), %rax     # 0x22b880
movq %rax, 0x40(%rsp)
movq 0x60(%rsp), %rdi
addq $0x50, %rdi
movl $0x2, %esi
leaq 0x30(%rsp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x22bcf0
movq %rax, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x70(%rsp)
jmp 0x22d903
movq 0x40e6ac(%rip), %rax    # 0x63bfa0
movq (%rax), %rsi
leaq 0x348a01(%rip), %rdi    # 0x5762ff
callq 0x19810
jmp 0x22d92f
leaq 0x34(%rip), %rax        # 0x22d940
movq %rax, 0x70(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x60(%rsp), %rax
movb 0xd8(%rax), %cl
addb $0x1, %cl
movb %cl, 0xd8(%rax)
movq 0x68(%rsp), %rax
movq 0x70(%rsp), %rdx
addq $0x78, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 $0x58, %rsp
movq %rdi, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x19360
movq 0x40(%rsp), %rax
movq 0xd0(%rax), %rax
cmpq $0x0, 0xb0(%rax)
je 0x22da75
movq 0x3489d1(%rip), %rax    # 0x5763d8
movq %rax, 0x28(%rsp)
movq 0x3489cd(%rip), %rax    # 0x5763e0
movq %rax, 0x30(%rsp)
movq 0x3489c9(%rip), %rax    # 0x5763e8
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rdi
addq $0x50, %rdi
movl $0x1, %esi
leaq 0x28(%rsp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x22bcf0
movq %rax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x50(%rsp)
jmp 0x22da8b
movq 0x40e524(%rip), %rax    # 0x63bfa0
movq (%rax), %rsi
leaq 0x3488ab(%rip), %rdi    # 0x576331
callq 0x19810
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-suffixarray-interface.c
// Function: gt_SAIMakeReader
struct seqDataReader
gt_SAIMakeReader(SuffixarrayFileInterface *sai, enum sfxDataRequest rtype)
{
  struct seqDataReader reader = { NULL, NULL};
  switch (rtype)
  {
  case SFX_REQUEST_SUFTAB:
    reader = gt_SAIMakeSufTabReader(sai);
    break;
  case SFX_REQUEST_BWTTAB:
    reader = gt_SAIMakeBWTReader(sai);
    break;
  default:
    fprintf(stderr, "error: unimplemented request: %d, %s: %d!\n", rtype,
            __FILE__, __LINE__);
    exit(GT_EXIT_PROGRAMMING_ERROR);
  }
  return reader;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
movl 0x34(%rsp), %eax
movl %eax, 0xc(%rsp)
subl $0x1, %eax
je 0x22dacf
jmp 0x22dac4
movl 0xc(%rsp), %eax
subl $0x2, %eax
je 0x22daf9
jmp 0x22db23
movq 0x38(%rsp), %rdi
callq 0x22d9d0
movq %rax, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x48(%rsp)
jmp 0x22db56
movq 0x38(%rsp), %rdi
callq 0x22d7d0
movq %rax, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x48(%rsp)
jmp 0x22db56
movq 0x40e476(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
movl 0x34(%rsp), %edx
leaq 0x347909(%rip), %rsi    # 0x575441
leaq 0x34879a(%rip), %rcx    # 0x5762d9
movl $0xaf, %r8d
movb $0x0, %al
callq 0x199f0
movl $0x2, %edi
callq 0x19890
movq 0x40(%rsp), %rax
movq 0x48(%rsp), %rdx
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-sa-common-siop.h
// Function: EncSeqGetSubSeq
static inline size_t
EncSeqGetSubSeq(const GtEncseq *encseq, GtReadmode readmode,
                GtUword pos, size_t len, GtUchar *subSeq)
{
  size_t i;
  gt_assert(encseq);
  for (i = 0; i < len; ++i)
    subSeq[i] = gt_encseq_get_encoded_char(encseq, pos + i, readmode);
  return len;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x22dbcc
movq 0x40e405(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2e846e(%rip), %rsi    # 0x516013
leaq 0x32bdca(%rip), %rdx    # 0x559976
leaq 0x348808(%rip), %rcx    # 0x5763bb
leaq 0x3477c4(%rip), %r8     # 0x57537e
movl $0x25, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x22dbce
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x18(%rsp), %rax
jae 0x22dc1a
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
addq 0x8(%rsp), %rsi
movl 0x2c(%rsp), %edx
callq 0xa9da0
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 0x22dbd7
movq 0x18(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x22dcf9
movq 0x40e2d8(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2e8341(%rip), %rsi    # 0x516013
leaq 0x3486b5(%rip), %rdx    # 0x57638e
leaq 0x3486c1(%rip), %rcx    # 0x5763a1
leaq 0x3485f2(%rip), %r8     # 0x5762d9
movl $0xda, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x22dcfb
movq 0x10(%rsp), %rdi
callq 0x22ab10
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movl $0xff, %esi
movl $0x1, %edx
callq 0x22b110
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-seqdatasrc.h
// Function: SDRTranslate
static inline size_t
SDRTranslate(SeqDataTranslator xltor, void *dest, const GtUword *src,
             size_t len)
{
  if (xltor.translateData != NULL)
  {
    return xltor.translateData(xltor.state.ref, dest, src, len);
  }
  /* fall back to zero-translation i.e. verbatim copy */
  memcpy(dest, src, len * xltor.state.elemSize);
  return len * xltor.state.elemSize;
}

// Assembly:
subq $0x28, %rsp
leaq 0x30(%rsp), %rax
movq %rax, (%rsp)
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
cmpq $0x0, 0x8(%rax)
je 0x22de66
movq (%rsp), %rcx
movq 0x8(%rcx), %rax
movq (%rcx), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
callq *%rax
movq %rax, 0x20(%rsp)
jmp 0x22de94
movq (%rsp), %rax
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
imulq (%rax), %rdx
callq 0x19610
movq (%rsp), %rcx
movq 0x8(%rsp), %rax
imulq (%rcx), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-suffixerator-interface.c
// Function: gt_newSfxInterface
sfxInterface *
gt_newSfxInterface(GtReadmode readmode,
                unsigned int prefixlength,
                unsigned int numofparts,
                GtUword maximumspace,
                const Sfxstrategy *sfxstrategy,
                const GtEncseq *encseq,
                GtTimer *sfxprogress,
                bool withprogressbar,
                GtUword length,
                GtLogger *verbosity,
                GtError *err)
{
  return gt_newSfxInterfaceWithReaders(readmode,
                                       prefixlength,
                                       numofparts,
                                       maximumspace,
                                       sfxstrategy,
                                       0,
                                       NULL,
                                       NULL,
                                       encseq,
                                       sfxprogress,
                                       withprogressbar,
                                       length,
                                       verbosity,
                                       err);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq 0xb0(%rsp), %rax
movq 0xa8(%rsp), %rax
movq 0xa0(%rsp), %rax
movb 0x98(%rsp), %al
movq 0x90(%rsp), %r10
movl %edi, 0x6c(%rsp)
movl %esi, 0x68(%rsp)
movl %edx, 0x64(%rsp)
movq %rcx, 0x58(%rsp)
movq %r8, 0x50(%rsp)
movq %r9, 0x48(%rsp)
andb $0x1, %al
movb %al, 0x47(%rsp)
movl 0x6c(%rsp), %edi
movl 0x68(%rsp), %esi
movl 0x64(%rsp), %edx
movq 0x58(%rsp), %rcx
movq 0x50(%rsp), %r8
movq 0x48(%rsp), %r15
movq 0x90(%rsp), %r14
movb 0x47(%rsp), %bl
movq 0xa0(%rsp), %r11
movq 0xa8(%rsp), %r10
movq 0xb0(%rsp), %rax
xorl %r9d, %r9d
andb $0x1, %bl
movq $0x0, (%rsp)
movq $0x0, 0x8(%rsp)
movq %r15, 0x10(%rsp)
movq %r14, 0x18(%rsp)
movzbl %bl, %ebx
movl %ebx, 0x20(%rsp)
movq %r11, 0x28(%rsp)
movq %r10, 0x30(%rsp)
movq %rax, 0x38(%rsp)
callq 0x22df90
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-suffixerator-interface.c
// Function: newSeqStatsFromCharDist
static struct seqStats *
newSeqStatsFromCharDist(const GtEncseq *encseq,
                        const GtAlphabet *alpha, GtUword len)
{
  struct seqStats *stats = NULL;
  unsigned i, numofchars;
  GtUword regularSymsSum = 0;
  stats = gt_malloc(offsetAlign(sizeof (*stats), sizeof (GtUword))
                    + (UINT8_MAX + 1) * sizeof (GtUword));
  unsigned int numOfSeqs;

  numOfSeqs = gt_encseq_num_of_sequences(encseq);
  stats->sourceAlphaType = sourceUInt8;
  stats->symbolDistributionTable =
    (GtUword *)((char *)stats + offsetAlign(sizeof (*stats),
                                                  sizeof (GtUword)));
  memset(stats->symbolDistributionTable,
         0,
         sizeof (GtUword) * (UINT8_MAX + 1));
  numofchars = gt_alphabet_num_of_chars(alpha);
  for (i = 0; i < numofchars; ++i)
  {
    stats->symbolDistributionTable[i]
      = (GtUword) gt_encseq_charcount(encseq,(GtUchar) i);
    regularSymsSum += stats->symbolDistributionTable[i];
  }
  stats->symbolDistributionTable[GT_WILDCARD] = len - regularSymsSum
                                                 - numOfSeqs;
  stats->symbolDistributionTable[GT_SEPARATOR] += numOfSeqs;
  stats->symbolDistributionTable[GT_UNDEFBWTCHAR] += 1;
  return stats;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq $0x0, 0x28(%rsp)
movq $0x0, 0x18(%rsp)
movl $0x10, %edi
movl $0x8, %esi
callq 0x22f0e0
movq %rax, %rdi
addq $0x800, %rdi            # imm = 0x800
leaq 0x347949(%rip), %rsi    # 0x57640e
movl $0xb8, %edx
callq 0xe80f0
movq %rax, 0x28(%rsp)
movq 0x40(%rsp), %rdi
callq 0xa9d50
movl %eax, 0x14(%rsp)
movq 0x28(%rsp), %rax
movl $0x1, 0x8(%rax)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x10, %edi
movl $0x8, %esi
callq 0x22f0e0
movq 0x8(%rsp), %rcx
addq %rax, %rcx
movq 0x28(%rsp), %rax
movq %rcx, (%rax)
movq 0x28(%rsp), %rax
movq (%rax), %rdi
xorl %esi, %esi
movl $0x800, %edx            # imm = 0x800
callq 0x19360
movq 0x38(%rsp), %rdi
callq 0x7e8c0
movl %eax, 0x20(%rsp)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x20(%rsp), %eax
jae 0x22eb96
movq 0x40(%rsp), %rdi
movl 0x24(%rsp), %eax
movzbl %al, %esi
callq 0xb0f60
movq %rax, %rdx
movq 0x28(%rsp), %rax
movq (%rax), %rax
movl 0x24(%rsp), %ecx
movq %rdx, (%rax,%rcx,8)
movq 0x28(%rsp), %rax
movq (%rax), %rax
movl 0x24(%rsp), %ecx
movq (%rax,%rcx,8), %rax
addq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x22eb41
movq 0x30(%rsp), %rcx
subq 0x18(%rsp), %rcx
movl 0x14(%rsp), %eax
subq %rax, %rcx
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq %rcx, 0x7f0(%rax)
movl 0x14(%rsp), %eax
movl %eax, %ecx
movq 0x28(%rsp), %rax
movq (%rax), %rax
addq 0x7f8(%rax), %rcx
movq %rcx, 0x7f8(%rax)
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq 0x7f0(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x7f0(%rax)
movq 0x28(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x22ed10
movq (%rsp), %rax
movq 0xf0(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2dd930
movq (%rsp), %rax
movq $0x0, 0xf0(%rax)
movq (%rsp), %rax
movq 0xe8(%rax), %rdi
callq 0x22ec00
movq (%rsp), %rdi
leaq 0x347712(%rip), %rsi    # 0x57640e
movl $0x127, %edx            # imm = 0x127
callq 0xe88c0
popq %rax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x22edb9
movq 0x40d218(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2e7281(%rip), %rsi    # 0x516013
leaq 0x313571(%rip), %rdx    # 0x54230a
leaq 0x347695(%rip), %rcx    # 0x576435
leaq 0x347667(%rip), %r8     # 0x57640e
movl $0x134, %r9d            # imm = 0x134
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x22edbb
movq 0x10(%rsp), %rdi
callq 0x22ed50
movq %rax, %rdi
callq 0x22ab10
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movl $0xff, %esi
movl $0x1, %edx
callq 0x22b110
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x48, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rsi, 0x40(%rsp)
movl %edx, 0x3c(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl 0x3c(%rsp), %eax
movl %eax, 0x1c(%rsp)
subl $0x1, %eax
je 0x22ef79
jmp 0x22eefb
movl 0x1c(%rsp), %eax
subl $0x2, %eax
jne 0x22efcd
jmp 0x22ef0a
movq 0x40(%rsp), %rax
movl 0xc0(%rax), %eax
movl %eax, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq 0xe0(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x40(%rsp), %rdi
addq $0xb0, %rdi
movl 0x3c(%rsp), %esi
movq 0x28(%rsp), %rdx
movl 0x30(%rsp), %ecx
callq 0x22ba30
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rsp)
movq 0x20(%rsp), %rcx
addq $0x8, %rcx
movq %rcx, (%rax)
leaq -0x3808(%rip), %rcx     # 0x22b760
movq %rcx, 0x8(%rax)
leaq -0x36f3(%rip), %rcx     # 0x22b880
movq %rcx, 0x10(%rax)
jmp 0x22efea
movq 0x8(%rsp), %rax
movq $0x8, (%rax)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x22efc9
movq 0x40d008(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2e7071(%rip), %rsi    # 0x516013
leaq 0x3474c0(%rip), %rdx    # 0x576469
leaq 0x3474d2(%rip), %rcx    # 0x576482
leaq 0x347457(%rip), %r8     # 0x57640e
movl $0x4d, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x22efcb
jmp 0x22efea
movq 0x40cfcc(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3474ba(%rip), %rsi    # 0x576498
movb $0x0, %al
callq 0x199f0
callq 0x19370
movq 0x10(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-seqdatasrc.h
// Function: SDRTranslateSuffixsortspace
static inline size_t
SDRTranslateSuffixsortspace(SeqDataTranslator xltor, void *dest,
                            const GtSuffixsortspace *suffixsortspace,
                            GtUword offset, size_t len)
{
  if (xltor.translateDataSuffixsortspace != NULL)
  {
    return xltor.translateDataSuffixsortspace(xltor.state.ref, dest,
                                              suffixsortspace,
                                              offset, len);
  }
  /* fall back to zero-translation i.e. verbatim copy */
  {
    size_t idx;
    GtUword *ulongdest = (GtUword *) dest;
    for (idx = 0; idx < len; idx++)
    {
      ulongdest[idx] = gt_suffixsortspace_getdirect(suffixsortspace,offset+idx);
    }
  }
  /*memcpy(dest, src, len * xltor.state.elemSize); */
  return len * xltor.state.elemSize;
}

// Assembly:
subq $0x48, %rsp
leaq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
cmpq $0x0, 0x10(%rax)
je 0x22f242
movq 0x8(%rsp), %rcx
movq 0x10(%rcx), %rax
movq (%rcx), %rdi
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rcx
movq 0x20(%rsp), %r8
callq *%rax
movq %rax, 0x40(%rsp)
jmp 0x22f2a9
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x20(%rsp), %rax
jae 0x22f296
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
addq 0x18(%rsp), %rsi
callq 0x2e9a60
movq %rax, %rdx
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x22f255
movq 0x8(%rsp), %rcx
movq 0x20(%rsp), %rax
imulq (%rcx), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x22f310
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x223230
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x22f330
movq 0x8(%rsp), %rax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-voiditf.c
// Function: gt_Bwtseqpositioniterator_new
Bwtseqpositioniterator *gt_Bwtseqpositioniterator_new(const FMindex *fmindex,
                                                      GtUword lowerbound,
                                                      GtUword upperbound)
{
  Bwtseqpositioniterator *bspi;

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

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl $0x50, %edi
leaq 0x347162(%rip), %rsi    # 0x576521
movl $0x37, %edx
callq 0xe80f0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x22f310
movq 0x20(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x38(%rax)
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x40(%rax)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x48(%rax)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-voiditf.c
// Function: gt_Bwtseqpositioniterator_next
bool gt_Bwtseqpositioniterator_next(GtUword *pos,
                                    Bwtseqpositioniterator *bspi)
{
  if (bspi->currentbound < bspi->upperbound)
  {
    *pos = gt_BWTSeqLocateMatch(bspi->bwtseq,bspi->currentbound,&bspi->extBits);
    bspi->currentbound++;
    return true;
  }
  return false;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq (%rsp), %rax
movq 0x40(%rax), %rax
movq (%rsp), %rcx
cmpq 0x48(%rcx), %rax
jae 0x22f46a
movq (%rsp), %rax
movq 0x38(%rax), %rdi
movq (%rsp), %rax
movq 0x40(%rax), %rsi
movq (%rsp), %rdx
callq 0x223230
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq (%rsp), %rax
movq 0x40(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x40(%rax)
movb $0x1, 0x17(%rsp)
jmp 0x22f46f
movb $0x0, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-voiditf.c
// Function: gt_BwtseqpositionwithoutSEPiterator_next
bool gt_BwtseqpositionwithoutSEPiterator_next(GtUword *pos,
                                              Bwtseqpositioniterator *bspi)
{
  while (bspi->currentbound < bspi->upperbound)
  {
    GtUchar cc;

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

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x40(%rax), %rax
movq 0x10(%rsp), %rcx
cmpq 0x48(%rcx), %rax
jae 0x22f550
movq 0x10(%rsp), %rax
movq 0x40(%rax), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rdi
callq 0x22f560
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
je 0x22f4ea
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x40(%rax), %rsi
callq 0x22f570
movb %al, 0xf(%rsp)
jmp 0x22f4ef
movb $-0x1, 0xf(%rsp)
movzbl 0xf(%rsp), %eax
cmpl $0xff, %eax
je 0x22f53a
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x40(%rax), %rsi
movq 0x10(%rsp), %rdx
callq 0x223230
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movq 0x40(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x40(%rax)
movb $0x1, 0x27(%rsp)
jmp 0x22f555
movq 0x10(%rsp), %rax
movq 0x40(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x40(%rax)
jmp 0x22f48e
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-voiditf.c
// Function: gt_newBwtSeqpositionextractor
BwtSeqpositionextractor *gt_newBwtSeqpositionextractor(
                                                     const FMindex *voidbwtseq,
                                                     GtUword upperbound)
{
  BwtSeqpositionextractor *bspex;

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

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl $0x48, %edi
leaq 0x346ef7(%rip), %rsi    # 0x576521
movl $0x79, %edx
callq 0xe80f0
movq %rax, (%rsp)
movq (%rsp), %rdi
callq 0x22f310
movq 0x10(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x38(%rax)
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x40(%rax)
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-voiditf.c
// Function: gt_Bwtseqcontextiterator_new
Bwtseqcontextiterator *gt_Bwtseqcontextiterator_new(const FMindex *fmindex,
                                                    GtUword bound)
{
  Bwtseqcontextiterator *bsci;

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

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl $0x48, %edi
leaq 0x346de7(%rip), %rsi    # 0x576521
movl $0x9c, %edx
callq 0xe80f0
movq %rax, (%rsp)
movq (%rsp), %rdi
callq 0x22f310
movq 0x10(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x38(%rax)
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x40(%rax)
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-voiditf.c
// Function: gt_Bwtseqcontextiterator_next
GtUchar gt_Bwtseqcontextiterator_next(GtUword *bound,
                                      Bwtseqcontextiterator *bsci)
{
  GtUchar cc;

  if (bsci->bound != BWTSeqTerminatorPos(bsci->bwtseq))
  {
    cc = BWTSeqGetSym(bsci->bwtseq, bsci->bound);
  } else
  {
    cc = GT_SEPARATOR;
  }
  *bound = bsci->bound = BWTSeqLFMap(bsci->bwtseq, bsci->bound, &bsci->extBits);
  return cc;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x40(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq 0x38(%rax), %rdi
callq 0x22f560
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
je 0x22f834
movq 0x18(%rsp), %rax
movq 0x38(%rax), %rdi
movq 0x18(%rsp), %rax
movq 0x40(%rax), %rsi
callq 0x22f570
movb %al, 0x17(%rsp)
jmp 0x22f839
movb $-0x1, 0x17(%rsp)
movq 0x18(%rsp), %rax
movq 0x38(%rax), %rdi
movq 0x18(%rsp), %rax
movq 0x40(%rax), %rsi
movq 0x18(%rsp), %rdx
callq 0x22f880
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x40(%rax)
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movb 0x17(%rsp), %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-voiditf.c
// Function: gt_deletevoidBWTSeq
void gt_deletevoidBWTSeq(FMindex *fmindex)
{
  BWTSeq *bwtseq = (BWTSeq *) fmindex;

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

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x50(%rax)
je 0x22fd5a
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rdi
callq 0x2617c0
movq 0x8(%rsp), %rax
movq $0x0, 0x50(%rax)
movq 0x8(%rsp), %rdi
callq 0x2261a0
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-voiditf.c
// Function: gt_bwtseq2mbtab
const Mbtab **gt_bwtseq2mbtab(const FMindex *fmindex)
{
  gt_assert(fmindex != NULL);
  if (((const BWTSeq *) fmindex)->pckbuckettable == NULL)
  {
    return NULL;
  }
  return (const Mbtab **)
         gt_pckbuckettable_mbtab_get(((const BWTSeq *) fmindex)
                                     ->pckbuckettable);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x22fdb9
movq 0x40c218(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2e6281(%rip), %rsi    # 0x516013
leaq 0x3467f9(%rip), %rdx    # 0x576592
leaq 0x346802(%rip), %rcx    # 0x5765a2
leaq 0x34677a(%rip), %r8     # 0x576521
movl $0x103, %r9d            # imm = 0x103
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x22fdbb
movq 0x8(%rsp), %rax
cmpq $0x0, 0x50(%rax)
jne 0x22fdd2
movq $0x0, 0x10(%rsp)
jmp 0x22fde5
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rdi
callq 0x262860
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-voiditf.c
// Function: gt_bwtseq2maxdepth
unsigned int gt_bwtseq2maxdepth(const FMindex *fmindex)
{
  gt_assert(fmindex != NULL);
  if (((const BWTSeq *) fmindex)->pckbuckettable == NULL)
  {
    return 0;
  }
  return gt_pckbuckettable_maxdepth_get(((const BWTSeq *) fmindex)
                                        ->pckbuckettable);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x22fe39
movq 0x40c198(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2e6201(%rip), %rsi    # 0x516013
leaq 0x346779(%rip), %rdx    # 0x576592
leaq 0x346792(%rip), %rcx    # 0x5765b2
leaq 0x3466fa(%rip), %r8     # 0x576521
movl $0x10f, %r9d            # imm = 0x10F
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x22fe3b
movq 0x8(%rsp), %rax
cmpq $0x0, 0x50(%rax)
jne 0x22fe51
movl $0x0, 0x14(%rsp)
jmp 0x22fe63
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rdi
callq 0x2627c0
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-voiditf.c
// Function: gt_bwtseq2numofchars
unsigned int gt_bwtseq2numofchars(const FMindex *fmindex)
{
  gt_assert(fmindex != NULL);
  if (((const BWTSeq *) fmindex)->pckbuckettable == NULL)
  {
    return 0;
  }
  return gt_pckbuckettable_numofchars_get(((const BWTSeq *) fmindex)
                                          ->pckbuckettable);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x22feb9
movq 0x40c118(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2e6181(%rip), %rsi    # 0x516013
leaq 0x3466f9(%rip), %rdx    # 0x576592
leaq 0x346725(%rip), %rcx    # 0x5765c5
leaq 0x34667a(%rip), %r8     # 0x576521
movl $0x11a, %r9d            # imm = 0x11A
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x22febb
movq 0x8(%rsp), %rax
cmpq $0x0, 0x50(%rax)
jne 0x22fed1
movl $0x0, 0x14(%rsp)
jmp 0x22fee3
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rdi
callq 0x262810
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)