LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/eis-blockcomp.c
// Function: deleteBlockCompSeqHint
static void
deleteBlockCompSeqHint(struct encIdxSeq *seq, union EISHint *hint)
{
  GT_UNUSED struct blockCompositionSeq *seqIdx;
  gt_assert(seq && seq->classInfo == &blockCompositionSeqClass);
  seqIdx = encIdxSeq2blockCompositionSeq(seq);
  destructSuperBlockSeqCache(&hint->bcHint.sBlockCache);
  gt_free(hint);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x30c7a4
leaq 0x1ac443(%rip), %rax    # 0x4b8bb0
cmpq %rax, (%rdi)
jne 0x30c7a4
movq %rsi, %rbx
movq 0x8(%rsi), %rdi
leaq 0xd4250(%rip), %r14     # 0x3e09d0
movq %r14, %rsi
movl $0x3f5, %edx            # imm = 0x3F5
callq 0x1045eb
movq %rbx, %rdi
movq %r14, %rsi
movl $0x9cf, %edx            # imm = 0x9CF
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1045eb
callq 0x8ff16
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/eis-blockcomp.c
// Function: seekToHeader
static FILE *
seekToHeader(const struct encIdxSeq *seqIdx, uint16_t headerID,
             uint32_t *lenRet)
{
  const struct blockCompositionSeq *bSeqIdx;
  size_t i;
  uint32_t query = headerID | EH_HEADER_PREFIX;
  gt_assert(seqIdx);
  bSeqIdx =
    constEncIdxSeq2blockCompositionSeq(seqIdx);
  for (i = 0; i < bSeqIdx->numExtHeaders; ++i)
  {
    if (bSeqIdx->extHeaderPos[i].headerID == query)
    {
      uint32_t headerPrefix[2];
      if (lenRet)
      {
        if (fseeko(bSeqIdx->externalData.idxFP,
                   bSeqIdx->extHeaderPos[i].pos - EXT_HEADER_PREFIX_SIZE,
                   SEEK_SET))
           return NULL;
        if (fread(headerPrefix, sizeof (headerPrefix[0]), 2,
                  bSeqIdx->externalData.idxFP) != 2)
          return NULL;
        *lenRet = headerPrefix[1];
      }
      else
        if (fseeko(bSeqIdx->externalData.idxFP, bSeqIdx->extHeaderPos[i].pos,
                   SEEK_SET))
          return NULL;
      return bSeqIdx->externalData.idxFP;
    }
  }
  return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x30cae2
movq %rdi, %rbx
leaq 0x1ac170(%rip), %rax    # 0x4b8bb0
cmpq %rax, (%rdi)
jne 0x30cae7
movq 0x80(%rbx), %rax
testq %rax, %rax
je 0x30cabe
movq %rdx, %r14
orl $0x45480000, %esi       # imm = 0x45480000
movq 0x78(%rbx), %rcx
addq $0x8, %rcx
xorl %r15d, %r15d
cmpl %esi, (%rcx)
je 0x30ca78
addq $0x10, %rcx
decq %rax
jne 0x30ca69
jmp 0x30cac1
movq 0x18(%rbx), %rdi
movq -0x8(%rcx), %rsi
testq %r14, %r14
je 0x30cace
addq $-0x8, %rsi
xorl %r15d, %r15d
xorl %edx, %edx
callq 0x17cf0
testl %eax, %eax
jne 0x30cac1
movq 0x18(%rbx), %rcx
leaq 0x8(%rsp), %rdi
movl $0x4, %esi
movl $0x2, %edx
callq 0x17b40
cmpq $0x2, %rax
jne 0x30cabe
movl 0xc(%rsp), %eax
movl %eax, (%r14)
jmp 0x30cadc
xorl %r15d, %r15d
movq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
xorl %r15d, %r15d
xorl %edx, %edx
callq 0x17cf0
testl %eax, %eax
jne 0x30cac1
movq 0x18(%rbx), %r15
jmp 0x30cac1
callq 0x8fffa
callq 0x8ffc1
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/eis-blockcomp.c
// Function: printBlockEncPosDiags
static int
printBlockEncPosDiags(const EISeq *seq, GtUword pos, FILE *fp,
                      EISHint hint)
{
  const struct blockCompositionSeq *seqIdx;
  int outCount = 0;
  GtUword bucketNum;
  gt_assert(seq && seq->classInfo == &blockCompositionSeqClass);
  seqIdx = constEncIdxSeq2blockCompositionSeq(seq);
  bucketNum = bucketNumFromPos(seqIdx, pos);
  fputs("##################################################\n"
        "# This bucket:\n"
        "##################################################\n", fp);
  outCount += printBucket(seqIdx, bucketNum, BUCKET_PLAIN, fp, hint);
  if (bucketNum)
  {
    fputs("##################################################\n"
          "# Previous bucket:\n"
          "##################################################\n", fp);
    outCount += printBucket(seqIdx, bucketNum - 1, BUCKET_PLAIN, fp, hint);
  }
  if (bucketNum < bucketNumFromPos(seqIdx, EISLength(seq)))
  {
    fputs("##################################################\n"
          "# Next bucket:\n"
          "##################################################\n", fp);
    outCount += printBucket(seqIdx, bucketNum + 1, BUCKET_PLAIN, fp, hint);
  }
  return outCount;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x30cbe0
movq %rdi, %r15
leaq 0x1ac0a6(%rip), %rax    # 0x4b8bb0
cmpq %rax, (%rdi)
jne 0x30cbe0
movq %rcx, %rbp
movq %rdx, %r14
movq %rsi, %r13
movl 0xb4(%r15), %ebx
imull 0xb0(%r15), %ebx
movq %rsi, %rax
xorl %edx, %edx
divq %rbx
movq %rax, %r12
leaq 0xd4a32(%rip), %rdi     # 0x3e156f
movq %r14, %rsi
callq 0x178c0
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
movq %r14, %rcx
movq %rbp, (%rsp)
movq %rbp, %r8
callq 0x30d256
movl %eax, %ebp
cmpq %r13, %rbx
ja 0x30cb8a
leaq 0xd4a7b(%rip), %rdi     # 0x3e15e5
movq %r14, %rsi
callq 0x178c0
leaq -0x1(%r12), %rsi
movq %r15, %rdi
xorl %edx, %edx
movq %r14, %rcx
movq (%rsp), %r8
callq 0x30d256
addl %eax, %ebp
movq 0x10(%r15), %rax
movl 0xb4(%r15), %ecx
imull 0xb0(%r15), %ecx
xorl %edx, %edx
divq %rcx
cmpq %rax, %r12
jae 0x30cbcf
leaq 0xd4ab1(%rip), %rdi     # 0x3e165f
movq %r14, %rsi
callq 0x178c0
incq %r12
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
movq %r14, %rcx
movq (%rsp), %r8
callq 0x30d256
addl %eax, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x90033
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/eis-blockcomp.c
// Function: displayBlockEncBlock
static int
displayBlockEncBlock(const EISeq *seq, GtUword pos, FILE *fp,
                     EISHint hint)
{
  const struct blockCompositionSeq *seqIdx;
  int outCount;
  GtUword bucketNum;
  gt_assert(seq && seq->classInfo == &blockCompositionSeqClass);
  seqIdx = constEncIdxSeq2blockCompositionSeq(seq);
  bucketNum = bucketNumFromPos(seqIdx, pos);
  outCount = printBucket(seqIdx, bucketNum, BUCKET_PRINT_BITSTRING_SEPARATOR
                         | BUCKET_PRINT_BITSTRING | BUCKET_PRINT_BITSIZES
                         | BUCKET_PRINT_RANGES_OVERLAY, fp, hint);
  return outCount;
}

// Assembly:
testq %rdi, %rdi
je 0x30cc20
leaq 0x1abfbf(%rip), %rax    # 0x4b8bb0
cmpq %rax, (%rdi)
jne 0x30cc20
movq %rcx, %r8
movq %rdx, %rcx
movl 0xb4(%rdi), %r9d
imull 0xb0(%rdi), %r9d
movq %rsi, %rax
xorl %edx, %edx
divq %r9
movq %rax, %rsi
movl $0xf, %edx
jmp 0x30d256
pushq %rax
callq 0x9006c
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/eis-blockcomp.c
// Function: adjustPosRankForBlock
static inline GtUword
adjustPosRankForBlock(struct blockCompositionSeq *seqIdx,
                      struct superBlock *sBlock, GtUword pos, Symbol bSym,
                      unsigned blockSize, GtUword preBlockRankCount,
                      BitOffset cwIdxMemOffset, BitOffset varDataMemOffset,
                      unsigned bitsPerCompositionIdx)
{
  GtUword rankCount = preBlockRankCount;
  unsigned inBlockPos;
  if ((inBlockPos = pos % blockSize)
      && symCountFromComposition(
        &seqIdx->compositionTable, seqIdx->blockMapAlphabetSize,
        gt_bsGetPermCompIndex(sBlock->cwData, cwIdxMemOffset,
                           bitsPerCompositionIdx), bSym))
  {
    Symbol block[blockSize];
    unsigned i;
    unpackBlock(seqIdx, sBlock, cwIdxMemOffset, varDataMemOffset, block,
                inBlockPos);
    for (i = 0; i < inBlockPos; ++i)
    {
      if (block[i] == bSym)
        ++rankCount;
    }
  }
  return rankCount;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %rbx
movl %ecx, %r14d
movq %rdx, %rax
movl %r8d, %ecx
xorl %edx, %edx
divq %rcx
testq %rdx, %rdx
je 0x30d0d7
movq %rdi, %r12
movq %rdx, %r15
movq %rcx, -0x30(%rbp)
movl 0x20(%rbp), %edx
movq 0x10(%rbp), %rax
movzwl 0xc4(%rdi), %r13d
movq %rsi, -0x38(%rbp)
movq 0x10(%rsi), %rdi
movq %rax, %rsi
callq 0x2f2688
movl %eax, %eax
cmpq %rax, 0x48(%r12)
jbe 0x30d0e9
movl 0x60(%r12), %edx
movq 0x58(%r12), %rdi
imulq %r13, %rax
movzbl %r14b, %esi
addq %rax, %rsi
imulq %rdx, %rsi
callq 0x2f2688
testl %eax, %eax
je 0x30d0d7
movq %rsp, -0x40(%rbp)
movq %rsp, %r13
movq -0x30(%rbp), %rax
addq $0xf, %rax
andq $-0x10, %rax
subq %rax, %r13
movq %r13, %rsp
movl 0x68(%r12), %edx
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rdi
movq 0x10(%rbp), %rsi
callq 0x2f2688
movq 0x50(%r12), %rcx
movl %eax, %eax
leaq (%rax,%rax,2), %rax
movq %rax, -0x30(%rbp)
movl 0x8(%rcx,%rax,8), %edx
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdi
movq 0x18(%rbp), %rsi
callq 0x2f2688
movl 0xb4(%r12), %esi
cmpl %r15d, %esi
jb 0x30d0ee
movl 0x64(%r12), %edx
movq 0x50(%r12), %rcx
movq 0x58(%r12), %rdi
imull %eax, %esi
imull %edx, %esi
movq -0x30(%rbp), %rax
addq 0x10(%rcx,%rax,8), %rsi
movq %r15, %rcx
movq %r13, %r8
callq 0x2f4ac5
xorl %eax, %eax
xorl %ecx, %ecx
cmpb %r14b, (%r13,%rax)
sete %cl
addq %rcx, %rbx
incq %rax
cmpq %r15, %rax
jb 0x30d0be
movq -0x40(%rbp), %rsp
movq %rbx, %rax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x900de
callq 0x90117
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/eis-blockcomp.c
// Function: unpackBlock
static inline void
unpackBlock(const struct blockCompositionSeq *seqIdx,
            const struct superBlock *sBlock,
            BitOffset cwOffset, BitOffset varOffset, Symbol *block,
            unsigned sublen)
{
  unsigned varIdxBits, bitsPerCompositionIdx;
  PermCompIndex compIndex, permIndex;
  bitsPerCompositionIdx = seqIdx->compositionTable.compositionIdxBits;
  compIndex = gt_bsGetPermCompIndex(sBlock->cwData, cwOffset,
                                 bitsPerCompositionIdx);
  varIdxBits = seqIdx->compositionTable.permutations[compIndex].permIdxBits;
  permIndex = gt_bsGetPermCompIndex(sBlock->varData, varOffset, varIdxBits);
  indexPair2block(&seqIdx->compositionTable, seqIdx->blockSize,
                  compIndex, permIndex, block, sublen);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebp
movq %r8, %rbx
movq %rcx, %r15
movq %rsi, %r12
movq %rdi, %r14
movl 0x68(%rdi), %eax
movq 0x10(%rsi), %rdi
movq %rdx, %rsi
movl %eax, %edx
callq 0x2f2688
movq 0x50(%r14), %rcx
movl %eax, %eax
leaq (%rax,%rax,2), %r13
movl 0x8(%rcx,%r13,8), %edx
movq 0x8(%r12), %rdi
movq %r15, %rsi
callq 0x2f2688
testq %rbx, %rbx
je 0x30d179
movl 0xb4(%r14), %esi
cmpl %ebp, %esi
jb 0x30d17e
movl 0x64(%r14), %edx
movq 0x50(%r14), %rcx
movq 0x58(%r14), %rdi
imull %eax, %esi
imull %edx, %esi
addq 0x10(%rcx,%r13,8), %rsi
movl %ebp, %ecx
movq %rbx, %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2f4ac5
callq 0x90189
callq 0x90150
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/eis-blockcomp.c
// Function: adjustRanksForBlock
static inline void
adjustRanksForBlock(struct blockCompositionSeq *seqIdx,
                    struct superBlock *sBlock, GtUword pos,
                    unsigned blockSize, GtUword rankCounts[],
                    BitOffset cwIdxMemOffset, BitOffset varDataMemOffset)
{
  unsigned inBlockPos = pos % blockSize;
  if (inBlockPos)
  {
    Symbol block[blockSize];
    unsigned i;
    unpackBlock(seqIdx, sBlock, cwIdxMemOffset, varDataMemOffset, block,
                inBlockPos);
    for (i = 0; i < inBlockPos; ++i)
      ++(rankCounts[block[i]]);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rax
movl %ecx, %ecx
xorl %edx, %edx
divq %rcx
testq %rdx, %rdx
je 0x30d242
movq %r8, %rbx
movq %rdi, %r12
movq %rdx, %r14
movq %rsp, -0x30(%rbp)
movq %rsp, %r15
addq $0xf, %rcx
andq $-0x10, %rcx
subq %rcx, %r15
movq %r15, %rsp
movl 0x68(%rdi), %edx
movq 0x10(%rsi), %rdi
movq %rsi, -0x38(%rbp)
movq %r9, %rsi
callq 0x2f2688
movq 0x50(%r12), %rcx
movl %eax, %eax
leaq (%rax,%rax,2), %r13
movl 0x8(%rcx,%r13,8), %edx
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rbp), %rsi
callq 0x2f2688
movl 0xb4(%r12), %esi
cmpl %r14d, %esi
jb 0x30d251
movl 0x64(%r12), %edx
movq 0x50(%r12), %rcx
movq 0x58(%r12), %rdi
imull %eax, %esi
imull %edx, %esi
addq 0x10(%rcx,%r13,8), %rsi
movq %r14, %rcx
movq %r15, %r8
callq 0x2f4ac5
xorl %eax, %eax
movzbl (%r15,%rax), %ecx
incq (%rbx,%rcx,8)
incq %rax
cmpq %r14, %rax
jb 0x30d22d
movq -0x30(%rbp), %rsp
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x901c2
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/eis-seqranges.c
// Function: gt_newSeqRangeList
struct seqRangeList *
gt_newSeqRangeList(size_t rangesStartNum, const MRAEnc *alphabet,
                enum SRLFeatures features)
{
  struct seqRangeList *newList;
  newList = gt_malloc(sizeof (struct seqRangeList));
  newList->numRanges = 0;
  newList->numRangesStorable = rangesStartNum;
  newList->ranges = gt_malloc(sizeof (newList->ranges[0]) * rangesStartNum);
  if (features & SRL_PARTIAL_SYMBOL_SUMS)
    newList->partialSymSums = gt_malloc(sizeof (GtUword)
                                        * gt_MRAEncGetSize(alphabet)
                                        * rangesStartNum);
  else
    newList->partialSymSums = NULL;
  newList->alphabet = alphabet;
  newList->symBits = requiredSymbolBits(gt_MRAEncGetSize(alphabet) - 1);
  if (newList->symBits)
    newList->maxRangeLen =
      (((GtUword)1) << (symLenStrBits - newList->symBits)) - 1;
  else
    newList->maxRangeLen = ~(GtUword)0;
  return newList;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
leaq 0xd3612(%rip), %r12     # 0x3e1ba1
movl $0x38, %edi
movq %r12, %rsi
movl $0x22, %edx
callq 0x104226
movq %rax, %rbx
movq $0x0, 0x8(%rax)
movq %r15, (%rax)
movq %r15, %rdi
shlq $0x4, %rdi
movq %r12, %rsi
movl $0x25, %edx
callq 0x104226
movq %rax, 0x10(%rbx)
testb $0x1, %bpl
jne 0x30e5d1
xorl %eax, %eax
jmp 0x30e5f8
movq %r14, %rdi
callq 0x19e077
movzwl %ax, %eax
imulq %rax, %r15
shlq $0x3, %r15
leaq 0xd35b6(%rip), %rsi     # 0x3e1ba1
movq %r15, %rdi
movl $0x29, %edx
callq 0x104226
movq %rax, 0x18(%rbx)
movq %r14, 0x20(%rbx)
movq %r14, %rdi
callq 0x19e077
decl %eax
movzbl %al, %edi
callq 0x2f09a0
movl %eax, 0x28(%rbx)
movl %eax, %ecx
negb %cl
movq $-0x1, %rdx
shlq %cl, %rdx
xorl %ecx, %ecx
cmpl $0x1, %eax
sbbq %rcx, %rcx
notq %rdx
orq %rdx, %rcx
movq %rcx, 0x30(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/eis-seqranges.c
// Function: gt_SRLCompact
void
gt_SRLCompact(struct seqRangeList *rangeList)
{
  gt_assert(rangeList);
  rangeList->ranges = gt_realloc(rangeList->ranges,
                                 sizeof (rangeList->ranges[0])
                                 * rangeList->numRanges);
  if (rangeList->partialSymSums)
    rangeList->partialSymSums =
      gt_realloc(rangeList->partialSymSums, sizeof (GtUword)
                 * gt_MRAEncGetSize(rangeList->alphabet)
                 * rangeList->numRanges);
  rangeList->numRangesStorable = rangeList->numRanges;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x30e6b3
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
movq 0x10(%rdi), %rdi
shlq $0x4, %rsi
leaq 0xd3541(%rip), %rdx     # 0x3e1ba1
movl $0x3c, %ecx
callq 0x104461
movq %rax, 0x10(%rbx)
movq 0x18(%rbx), %r14
testq %r14, %r14
je 0x30e6a4
movq 0x20(%rbx), %rdi
callq 0x19e077
movzwl %ax, %esi
imulq 0x8(%rbx), %rsi
shlq $0x3, %rsi
leaq 0xd350e(%rip), %rdx     # 0x3e1ba1
movq %r14, %rdi
movl $0x41, %ecx
callq 0x104461
movq %rax, 0x18(%rbx)
movq 0x8(%rbx), %rax
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x90431
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/eis-seqranges.c
// Function: gt_deleteSeqRangeList
void
gt_deleteSeqRangeList(struct seqRangeList *rangeList)
{
  gt_assert(rangeList);
  if (rangeList->ranges)
    gt_free(rangeList->ranges);
  if (rangeList->partialSymSums)
    gt_free(rangeList->partialSymSums);
  gt_free(rangeList);
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x30e70a
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x30e6db
leaq 0xd34d0(%rip), %rsi     # 0x3e1ba1
movl $0x4a, %edx
callq 0x1045eb
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x30e6f5
leaq 0xd34b6(%rip), %rsi     # 0x3e1ba1
movl $0x4c, %edx
callq 0x1045eb
leaq 0xd34a5(%rip), %rsi     # 0x3e1ba1
movq %rbx, %rdi
movl $0x4d, %edx
popq %rbx
jmp 0x1045eb
callq 0x90468
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/eis-seqranges.c
// Function: gt_SRLAddPosition
void
gt_SRLAddPosition(struct seqRangeList *rangeList, GtUword pos,
                  Symbol esym)
{
  size_t numRanges;
  struct seqRange *lastRange;
  GtUword lastRangeLen;
  unsigned symBits;
  Symbol sym;
  gt_assert(rangeList);
  sym = MRAEncMapSymbol(rangeList->alphabet, esym);
  numRanges = rangeList->numRanges;
  lastRange = rangeList->ranges + numRanges - 1;
  symBits = rangeList->symBits;
  if (numRanges)
    lastRangeLen = seqRangeLen(lastRange, symBits);

  if (numRanges && lastRange->startPos + lastRangeLen > pos)
  {
    /* TODO: search for range */
    gt_SRLinsertNewRange(rangeList, pos, 1, esym);
  }
  else if (numRanges
           && (seqRangeSym(lastRange, symBits) == sym)
           && (lastRange->startPos + lastRangeLen == pos)
           && (lastRangeLen < rangeList->maxRangeLen))
    seqRangeSetLen(lastRange, ++lastRangeLen, symBits);
  else
    gt_SRLAppendNewRange(rangeList, pos, 1, esym);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
testq %rdi, %rdi
je 0x30ebbd
movq %rdi, %r14
movq 0x20(%rdi), %rax
cmpl $0x1, (%rax)
jne 0x30ebb8
movzbl %dl, %ecx
movq 0x8(%r14), %rbx
testq %rbx, %rbx
je 0x30eb9d
movq %rcx, 0x20(%rsp)
movb 0x18(%rax,%rcx), %al
movb %al, 0xf(%rsp)
shlq $0x4, %rbx
addq 0x10(%r14), %rbx
movl 0x28(%r14), %r12d
leaq -0x8(%rbx), %r13
movl $0x40, %ebp
subl %r12d, %ebp
movq %r13, %rdi
movq %rsi, %r15
movq %r12, %rsi
movl %ebp, %edx
callq 0x2f37dc
movq -0x10(%rbx), %rcx
movq %rax, 0x10(%rsp)
addq %rax, %rcx
movq %r15, 0x18(%rsp)
cmpq %r15, %rcx
ja 0x30ebb8
movq %r13, %rdi
xorl %esi, %esi
movl %r12d, %edx
callq 0x2f4934
cmpb 0xf(%rsp), %al
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rcx
jne 0x30eb9d
movq -0x10(%rbx), %rax
addq 0x10(%rsp), %rax
cmpq %rsi, %rax
jne 0x30eb9d
movq 0x10(%rsp), %rax
cmpq 0x30(%r14), %rax
jae 0x30eb9d
movq 0x10(%rsp), %rcx
incq %rcx
movq %r13, %rdi
movq %r12, %rsi
movl %ebp, %edx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2f388c
movl $0x1, %edx
movq %r14, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x30e70f
callq 0x173b0
callq 0x9050f
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/eis-seqranges.c
// Function: gt_SRLOverlapsPosition
int
gt_SRLOverlapsPosition(struct seqRangeList *rangeList, GtUword pos,
                    seqRangeListSearchHint *hint, Symbol *symAtPos)
{
  size_t rangeIdx;
  struct seqRange *p;
  gt_assert(rangeList);
  if (hint)
    rangeIdx = *hint;
  else
    rangeIdx = rangeList->numRanges / 2;
  p = rangeList->ranges + rangeIdx;
  if (posIsInSeqRange(p, pos, rangeList->symBits))
  {
    if (symAtPos)
      *symAtPos = MRAEncRevMapSymbol(rangeList->alphabet,
                                     seqRangeSym(p, rangeList->symBits));
    return 1;
  }
  /* TODO: implement "else if" case to also look at next range */
  else
  {
    GtUword searchPos = pos;
    struct seqRange *searchRes =
      gt_bsearch_data(&searchPos, rangeList->ranges, rangeList->numRanges,
                   sizeof (struct seqRange), posSeqRangeOverlapCompare,
                   rangeList);
    if (searchRes)
    {
      if (symAtPos)
        *symAtPos = seqRangeSym(searchRes, rangeList->symBits);
      if (hint)
        *hint = searchRes - rangeList->ranges;
      return 1;
    }
    else
      return 0;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x30ece9
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
testq %rdx, %rdx
je 0x30ec07
movq (%r15), %rax
jmp 0x30ec0e
movq 0x8(%r14), %rax
shrq %rax
movq 0x10(%r14), %r13
shlq $0x4, %rax
movq (%r13,%rax), %rbp
cmpq %r12, %rbp
ja 0x30ec7f
addq %rax, %r13
movl 0x28(%r14), %esi
addq $0x8, %r13
movl $0x40, %edx
subl %esi, %edx
movq %r13, %rdi
callq 0x2f37dc
addq %rbp, %rax
cmpq %r12, %rax
jbe 0x30ec7b
movl $0x1, %ebp
testq %rbx, %rbx
je 0x30ecd8
movq 0x20(%r14), %r15
movl 0x28(%r14), %edx
movq %r13, %rdi
xorl %esi, %esi
callq 0x2f4934
cmpl $0x1, (%r15)
jne 0x30ecee
movzbl %al, %eax
movb 0x118(%r15,%rax), %al
movb %al, (%rbx)
jmp 0x30ecd8
movq 0x10(%r14), %r13
movq %rsp, %rdi
movq %r12, (%rdi)
movq 0x8(%r14), %rdx
leaq 0x63(%rip), %r8         # 0x30ecf3
movl $0x10, %ecx
movq %r13, %rsi
movq %r14, %r9
callq 0xd7ff0
testq %rax, %rax
je 0x30ecd6
movq %rax, %r12
testq %rbx, %rbx
je 0x30ecbf
movl 0x28(%r14), %edx
leaq 0x8(%r12), %rdi
xorl %esi, %esi
callq 0x2f4934
movb %al, (%rbx)
movl $0x1, %ebp
testq %r15, %r15
je 0x30ecd8
subq 0x10(%r14), %r12
sarq $0x4, %r12
movq %r12, (%r15)
jmp 0x30ecd8
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x90581
callq 0x173b0
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/eis-seqranges.c
// Function: posSeqRangeOverlapCompare
static int
posSeqRangeOverlapCompare(const void *key, const void *elem, void *data)
{
  GtUword pos;
  const struct seqRange *range;
  const struct seqRangeList *rangeList;
  pos = *(const GtUword *)key;
  range = elem;
  rangeList = data;
  if (pos < range->startPos)
    return -1;
  else if (pos >= range->startPos + seqRangeLen(range, rangeList->symBits))
    return 1;
  else
    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %rbx
movq (%rsi), %r14
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %r14, %rbx
jb 0x30ed2e
movl 0x28(%rdx), %eax
addq $0x8, %rsi
movl $0x40, %edx
subl %eax, %edx
movq %rsi, %rdi
movq %rax, %rsi
callq 0x2f37dc
movq %rax, %rcx
addq %r14, %rcx
xorl %eax, %eax
cmpq %rcx, %rbx
setae %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/eis-seqranges.c
// Function: posSeqRangeNextCompare
static int
posSeqRangeNextCompare(const void *key, const void *elem, void *data)
{
  GtUword pos;
  const struct seqRange *range;
  const struct seqRangeList *rangeList;
  pos = *(const GtUword *)key;
  range = elem;
  rangeList = data;
  if (pos < range->startPos)
    if (pos < range[-1].startPos + seqRangeLen(range - 1, rangeList->symBits))
      return -1;
    else
      return 0;
  else if (pos >= range->startPos + seqRangeLen(range, rangeList->symBits))
    return 1;
  else /* pos < range->startPos + range->len  && pos >= range->startPos */
    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rax
movq (%rdi), %rbx
movq (%rsi), %r14
cmpq %r14, %rbx
jae 0x30efc4
movq -0x10(%rax), %r14
movl 0x28(%rdx), %esi
addq $-0x8, %rax
movl $0x40, %edx
subl %esi, %edx
movq %rax, %rdi
callq 0x2f37dc
movq %rax, %rcx
addq %r14, %rcx
xorl %eax, %eax
cmpq %rcx, %rbx
sbbl %eax, %eax
jmp 0x30efe8
movl 0x28(%rdx), %esi
addq $0x8, %rax
movl $0x40, %edx
subl %esi, %edx
movq %rax, %rdi
callq 0x2f37dc
movq %rax, %rcx
addq %r14, %rcx
xorl %eax, %eax
cmpq %rcx, %rbx
setae %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/eis-seqranges.c
// Function: gt_SRLFindPositionLast
struct seqRange *
gt_SRLFindPositionLast(struct seqRangeList *rangeList, GtUword pos,
                    seqRangeListSearchHint *hint)
{
  /* no ranges no matches in ranges */
  seqRangeListSearchHint hintCopy;
  size_t numRanges;
  struct seqRange *ranges;
  GT_UNUSED unsigned symBits;
  gt_assert(rangeList);
  ranges = rangeList->ranges;
  symBits = rangeList->symBits;
  if (hint)
    hintCopy = *hint;
  else
    gt_SRLInitListSearchHint(rangeList, &hintCopy);
  if ((numRanges = rangeList->numRanges) == 0)
  {
    return NULL;
  }
  if (ranges[0].startPos > pos)
    return NULL;
  else if (ranges[numRanges - 1].startPos <= pos)
  {
    return ranges + numRanges - 1;
  }
  else if ((hintCopy < numRanges - 1) && rangeLastMatch(hintCopy))
  {
    return ranges + hintCopy;
  }
  else if ((hintCopy < numRanges - 2) && rangeLastMatch(hintCopy + 1))
  {
    ++hintCopy;
    if (hint)
      *hint = hintCopy;
    return ranges + hintCopy;
  }
  else if (hintCopy && rangeLastMatch(hintCopy - 1))
  {
    --hintCopy;
    if (hint)
      *hint = hintCopy;
    return ranges + hintCopy;
  }
  else if (numRanges > 2)
  {
    GtUword searchPos = pos;
    struct seqRange *searchRes =
      bsearch(&searchPos, ranges, rangeList->numRanges - 1,
              sizeof (struct seqRange), posSeqRangeLastCompare);
    if (searchRes && hint)
      *hint = searchRes - ranges;
    return searchRes;
  }
  else /* numRanges <= 2 */
    return NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x30f11c
movq %rdx, %rbx
testq %rdx, %rdx
je 0x30f00e
movq (%rbx), %rcx
movq 0x8(%rdi), %r8
jmp 0x30f018
movq 0x8(%rdi), %r8
movq %r8, %rcx
shrq %rcx
testq %r8, %r8
je 0x30f026
movq 0x10(%rdi), %r14
cmpq %rsi, (%r14)
jbe 0x30f030
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq -0x1(%r8), %rdx
movq %rdx, %rax
shlq $0x4, %rax
cmpq %rsi, (%r14,%rax)
jbe 0x30f091
cmpq %rdx, %rcx
jae 0x30f05c
movq %rcx, %rax
shlq $0x4, %rax
cmpq %rsi, (%r14,%rax)
ja 0x30f05c
addq %r14, %rax
cmpq %rsi, 0x10(%rax)
ja 0x30f028
leaq -0x2(%r8), %rax
cmpq %rax, %rcx
jae 0x30f09f
leaq 0x1(%rcx), %rax
movq %rax, %rdi
shlq $0x4, %rdi
cmpq %rsi, (%r14,%rdi)
ja 0x30f09f
movq %rcx, %r9
shlq $0x4, %r9
cmpq %rsi, 0x20(%r14,%r9)
jbe 0x30f09f
addq %rdi, %r14
testq %rbx, %rbx
je 0x30f0cc
movq %rax, (%rbx)
jmp 0x30f0cc
shlq $0x4, %r8
leaq (%r14,%r8), %rax
addq $-0x10, %rax
jmp 0x30f028
testq %rcx, %rcx
je 0x30f0d4
movq %rcx, %rax
shlq $0x4, %rax
cmpq %rsi, -0x10(%r14,%rax)
ja 0x30f0d4
addq %r14, %rax
cmpq %rsi, (%rax)
jbe 0x30f0d4
decq %rcx
testq %rbx, %rbx
je 0x30f0c5
movq %rcx, (%rbx)
shlq $0x4, %rcx
addq %rcx, %r14
movq %r14, %rax
jmp 0x30f028
cmpq $0x3, %r8
jb 0x30f026
movq %rsp, %rdi
movq %rsi, (%rdi)
leaq 0x36(%rip), %r8         # 0x30f121
movl $0x10, %ecx
movq %r14, %rsi
callq 0x17990
testq %rbx, %rbx
je 0x30f028
testq %rax, %rax
je 0x30f028
movq %rax, %rcx
subq %r14, %rcx
sarq $0x4, %rcx
movq %rcx, (%rbx)
jmp 0x30f028
callq 0x905f3
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/eis-seqranges.c
// Function: gt_SRLSaveToStream
int
gt_SRLSaveToStream(struct seqRangeList *rangeList, FILE *fp)
{
  size_t numRanges;
  gt_assert(rangeList && fp);
  numRanges = rangeList->numRanges;
  gt_xfwrite(&(rangeList->numRanges), sizeof (rangeList->numRanges), 1, fp);
  gt_xfwrite(rangeList->ranges, sizeof (struct seqRange), numRanges, fp);
  return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x30f186
movq %rsi, %rbx
testq %rsi, %rsi
je 0x30f186
movq %rdi, %r14
addq $0x8, %rdi
movq 0x8(%r14), %r15
movl $0x8, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x11f89c
movq 0x10(%r14), %rdi
movl $0x10, %esi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x11f89c
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x9062c
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/eis-seqranges.c
// Function: gt_SRLSymbolsInSeqRegion
void
gt_SRLSymbolsInSeqRegion(struct seqRangeList *rangeList, GtUword start,
                      GtUword end, GtUword *occStore,
                      seqRangeListSearchHint *hint)
{
  struct seqRange *p;
  /* find range next to start position */
  /* first solve special case where pos precedes very first list
   * entry, because we want to be able to look at the preceding range
   * in binary search */
  /* no ranges => no symbols in ranges */
  if (rangeList->numRanges == 0)
    return;
  p = gt_SRLFindPositionNext(rangeList, start, hint);
  /* no range overlapping or between start and end of sequence? */
  if (!p)
    return;
  /* iterate over ranges left */
  {
    GtUword s = GT_MAX(start, p->startPos);
    struct seqRange *maxRange = rangeList->ranges + rangeList->numRanges - 1;
    while (s <= end)
    {
      GtUword overlap = GT_MIN(p->startPos + seqRangeLen(p,
                                                            rangeList->symBits),
                                  end + 1) - s;
      occStore[MRAEncRevMapSymbol(rangeList->alphabet,
                                  seqRangeSym(p, rangeList->symBits))]
               += overlap;
      if (p == maxRange)
        break;
      s = (++p)->startPos;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, 0x20(%rsp)
movq %rdx, 0x8(%rsp)
cmpq $0x0, 0x8(%rdi)
je 0x30f44e
movq %rsi, %r13
movq %rdi, %r15
movq %r8, %rdx
callq 0x30ed36
testq %rax, %rax
je 0x30f44e
movq %rax, %r12
movq (%rax), %rbx
cmpq %r13, %rbx
cmovaq %rbx, %r13
cmpq 0x8(%rsp), %r13
ja 0x30f44e
movq 0x8(%r15), %rax
movq 0x10(%r15), %rcx
shlq $0x4, %rax
addq %rcx, %rax
addq $-0x10, %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rax
incq %rax
movq %rax, 0x18(%rsp)
movl 0x28(%r15), %esi
leaq 0x8(%r12), %rbp
movl $0x40, %edx
subl %esi, %edx
movq %rbp, %rdi
callq 0x2f37dc
addq %rbx, %rax
movq 0x18(%rsp), %rcx
movq %rcx, %rbx
cmpq %rcx, %rax
jae 0x30f400
movq (%r12), %r14
movl 0x28(%r15), %esi
movl $0x40, %edx
subl %esi, %edx
movq %rbp, %rdi
callq 0x2f37dc
movq %rax, %rbx
addq %r14, %rbx
movq 0x20(%r15), %r14
movl 0x28(%r15), %edx
movq %rbp, %rdi
xorl %esi, %esi
callq 0x2f4934
cmpl $0x1, (%r14)
jne 0x30f45d
subq %r13, %rbx
movzbl %al, %eax
movzbl 0x118(%r14,%rax), %eax
movq 0x20(%rsp), %rcx
addq %rbx, (%rcx,%rax,8)
cmpq 0x10(%rsp), %r12
je 0x30f44e
movq 0x10(%r12), %rbx
addq $0x10, %r12
movq %rbx, %r13
cmpq 0x8(%rsp), %rbx
jbe 0x30f3bb
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x173b0
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/eis-seqranges.c
// Function: gt_SRLApplyRangesToSubString
void
gt_SRLApplyRangesToSubString(struct seqRangeList *rangeList,
                          Symbol *subString,
                          GtUword start,
                          GtUword len,
                          GtUword subStringOffset,
                          seqRangeListSearchHint *hint)
{
  struct seqRange *nextRange;
  GtUword inSeqPos = start;
  unsigned symBits = rangeList->symBits;
  gt_assert(rangeList);
  nextRange = gt_SRLFindPositionNext(rangeList, inSeqPos, hint);
  do {
    if (inSeqPos < nextRange->startPos)
    {
      inSeqPos = nextRange->startPos;
    }
    else
    {
      size_t i;
      unsigned maxSubstPos =
        GT_MIN(nextRange->startPos + seqRangeLen(nextRange, symBits),
            start + len) - subStringOffset;
      Symbol sym = MRAEncRevMapSymbol(rangeList->alphabet,
                                      seqRangeSym(nextRange, symBits));
      for (i = inSeqPos - subStringOffset; i < maxSubstPos; ++i)
        subString[i] = sym;
      inSeqPos = subStringOffset + maxSubstPos;
      ++nextRange;
    }
  } while (inSeqPos < start + len);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %r13
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r14
movl 0x28(%rdi), %r12d
movq %rdi, 0x28(%rsp)
movq %rdx, %rsi
movq %r9, %rdx
callq 0x30ed36
movq %r12, %rcx
movq %rax, %rbp
movl $0x40, %eax
subl %ecx, %eax
movl %eax, 0xc(%rsp)
addq %r15, %rbx
subq %r13, %r14
movq %r14, 0x18(%rsp)
movq %rbx, 0x10(%rsp)
movq %r13, 0x20(%rsp)
movq (%rbp), %r12
cmpq %r12, %r15
jb 0x30f9c7
leaq 0x8(%rbp), %r13
movq %r13, %rdi
movq %rcx, %r14
movq %rcx, %rsi
movl 0xc(%rsp), %edx
callq 0x2f37dc
addq %r12, %rax
movq %rbx, %r12
cmpq %rbx, %rax
jae 0x30f959
movq (%rbp), %rbx
movq %r13, %rdi
movq %r14, %rsi
movl 0xc(%rsp), %edx
callq 0x2f37dc
movq %rax, %r12
addq %rbx, %r12
movq %rbp, 0x30(%rsp)
movq 0x28(%rsp), %rax
movq 0x20(%rax), %rbx
movq %r13, %rdi
xorl %esi, %esi
movq %r14, %rbp
movl %r14d, %edx
callq 0x2f4934
cmpl $0x1, (%rbx)
jne 0x30f9e2
movq 0x20(%rsp), %r13
subl %r13d, %r12d
movq %r15, %rcx
subq %r13, %rcx
cmpq %r12, %rcx
jae 0x30f9b3
movzbl %al, %eax
movq 0x18(%rsp), %rcx
leaq (%rcx,%r15), %rdi
addq %r13, %r12
movq %r12, %rdx
subq %r15, %rdx
movzbl 0x118(%rbx,%rax), %esi
callq 0x173a0
jmp 0x30f9b6
addq %r13, %r12
movq 0x10(%rsp), %rbx
movq %rbp, %rcx
movq 0x30(%rsp), %rbp
addq $0x10, %rbp
movq %r12, %r15
cmpq %rbx, %r12
jb 0x30f912
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x173b0
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/esa-bottomup.c
// Function: gt_GtArrayGtBUItvinfo_delete
void gt_GtArrayGtBUItvinfo_delete(GtArrayGtBUItvinfo *stack,
                                  GtESAVisitor *ev)
{
  GtUword idx;

  for (idx=0; idx<stack->allocatedGtBUItvinfo; idx++)
  {
    gt_esa_visitor_info_delete(stack->spaceGtBUItvinfo[idx].info, ev);
  }
  gt_free(stack->spaceGtBUItvinfo);
  gt_free(stack);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0x30fe99
movq %rsi, %r14
movl $0x18, %r15d
xorl %r12d, %r12d
movq (%rbx), %rax
movq (%rax,%r15), %rdi
movq %r14, %rsi
callq 0x1a85e7
incq %r12
addq $0x20, %r15
cmpq 0x8(%rbx), %r12
jb 0x30fe7d
movq (%rbx), %rdi
leaq 0xd1f19(%rip), %r14     # 0x3e1dbc
movq %r14, %rsi
movl $0x4e, %edx
callq 0x1045eb
movq %rbx, %rdi
movq %r14, %rsi
movl $0x4f, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1045eb
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/esa-bottomup.c
// Function: allocateBUstack
static GtBUItvinfo *allocateBUstack(GtBUItvinfo *ptr,
                                    GtUword currentallocated,
                                    GtUword allocated,
                                    GtESAVisitor *ev)
{
  GtUword idx;
  GtBUItvinfo *itvinfo;

  itvinfo = gt_realloc(ptr,sizeof (*itvinfo) * allocated);
  gt_assert(allocated > currentallocated);
  for (idx=currentallocated; idx<allocated; idx++)
  {
    itvinfo[idx].info = gt_esa_visitor_info_new(ev);
  }
  gt_assert(itvinfo != NULL);
  return itvinfo;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r12
movq %rdx, %rsi
shlq $0x5, %rsi
leaq 0xd1514(%rip), %rdx     # 0x3e1dbc
movl $0x6a, %ecx
callq 0x104461
subq %r12, %r14
jbe 0x3108e9
movq %rax, %r15
shlq $0x5, %r12
addq %rax, %r12
addq $0x18, %r12
movq %rbx, %rdi
callq 0x1a85c6
movq %rax, (%r12)
addq $0x20, %r12
decq %r14
jne 0x3108c5
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x90926
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/esa-dfs.c
// Function: allocItvinfo
static Itvinfo *allocItvinfo(Itvinfo *ptr,
                             GtUword currentallocated,
                             GtUword allocated,
                             Dfsinfo *(*allocateDfsinfo)(Dfsstate *),
                             Dfsstate *state)
{
  GtUword i;
  Itvinfo *itvinfo;

  itvinfo = gt_realloc(ptr,sizeof *ptr * allocated);
  if (allocateDfsinfo != NULL)
  {
    gt_assert(allocated > currentallocated);
    for (i=currentallocated; i<allocated; i++)
    {
      itvinfo[i].dfsinfo = allocateDfsinfo(state);
    }
  }
  gt_assert(itvinfo != NULL);
  return itvinfo;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r13
leaq (,%rdx,8), %rax
leaq (%rax,%rax,2), %rsi
leaq 0xd08ea(%rip), %rdx     # 0x3e1e4e
movl $0x3f, %ecx
callq 0x104461
movq %rax, %r12
testq %r14, %r14
je 0x3115a3
subq %r13, %r15
jbe 0x3115b5
leaq (,%r13,2), %rax
addq %r13, %rax
leaq (%r12,%rax,8), %r13
addq $0x10, %r13
movq %rbx, %rdi
callq *%r14
movq %rax, (%r13)
addq $0x18, %r13
decq %r15
jne 0x31158e
jmp 0x3115a8
testq %r12, %r12
je 0x3115ba
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x90ccb
callq 0x90d02
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/esa-merge.c
// Function: gt_emissionmergedesa_wrap
void gt_emissionmergedesa_wrap(Emissionmergedesa *emmesa)
{
  unsigned int idx;

  for (idx = 0; idx < emmesa->numofindexes; idx++)
  {
    gt_freesuffixarray(emmesa->suffixarraytable + idx);
  }
  gt_free(emmesa->suffixarraytable);
  gt_free(emmesa->trierep.encseqreadinfo);
  emmesa->trierep.encseqreadinfo = NULL;
  if (emmesa->numofindexes > 1U)
  {
    gt_mergertrie_delete(&emmesa->trierep);
  }
  gt_free(emmesa->nextpostable);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0xc(%rdi)
je 0x311c32
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x30058(%rbx), %rdi
addq %r14, %rdi
callq 0x1a1540
incq %r15
movl 0xc(%rbx), %eax
addq $0x100, %r14            # imm = 0x100
cmpq %rax, %r15
jb 0x311c11
movq 0x30058(%rbx), %rdi
leaq 0xd029c(%rip), %r14     # 0x3e1edc
movq %r14, %rsi
movl $0x12f, %edx            # imm = 0x12F
callq 0x1045eb
movq 0x30028(%rbx), %rdi
movq %r14, %rsi
movl $0x130, %edx            # imm = 0x130
callq 0x1045eb
movq $0x0, 0x30028(%rbx)
cmpl $0x2, 0xc(%rbx)
jb 0x311c7e
leaq 0x30028(%rbx), %rdi
callq 0x31ff79
movq 0x10(%rbx), %rdi
leaq 0xd0253(%rip), %rsi     # 0x3e1edc
movl $0x136, %edx            # imm = 0x136
popq %rbx
popq %r14
popq %r15
jmp 0x1045eb
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/firstcodes-cache.c
// Function: gt_firstcodes_binsearchcache_new
GtArrayGtIndexwithcode *gt_firstcodes_binsearchcache_new(
                                      GtUword differentcodes,
                                      unsigned int addbscache_depth,
                                      GtFirstcodesspacelog *fcsl)
{
  unsigned int depth = addbscache_depth +
                       (unsigned int) log10((double) differentcodes);
  while (true)
  {
    GtUword allocated = 1UL << (depth+1);
    if (allocated < differentcodes && differentcodes/allocated >= 32UL)
    {
      GtArrayGtIndexwithcode *binsearchcache;
      size_t allocbytes;

      binsearchcache = gt_malloc(sizeof (*binsearchcache));
      binsearchcache->depth = depth;
      binsearchcache->nextfreeGtIndexwithcode = 0;
      binsearchcache->allocatedGtIndexwithcode = allocated;
      binsearchcache->width = differentcodes/allocated;
      allocbytes = sizeof (*binsearchcache->spaceGtIndexwithcode)
                   * binsearchcache->allocatedGtIndexwithcode;
      gt_assert(binsearchcache->width > 0);
      binsearchcache->spaceGtIndexwithcode = gt_malloc(allocbytes);
      gt_log_log("binsearchcache->depth=%u => "GT_WU" bytes",
                 binsearchcache->depth,
                 (GtUword) allocbytes);
      GT_FCI_ADDWORKSPACE(fcsl,"binsearchcache",allocbytes);
      return binsearchcache;
    } else
    {
      if (depth > 0)
      {
        depth--;
      } else
      {
        break;
      }
    }
  }
  return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r13
movq %rdi, %xmm1
punpckldq 0x3392a(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x33932(%rip), %xmm1    # 0x3478f0
movl %esi, %ebp
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
callq 0x17340
cvttsd2si %xmm0, %r15
addl %ebp, %r15d
incq %r15
xorl %r14d, %r14d
movl $0x1, %ebp
movl %r15d, %ecx
shlq %cl, %rbp
cmpq %r13, %rbp
setb %al
movq %r13, %r12
shrq %cl, %r12
cmpq $0x20, %r12
setae %cl
andb %al, %cl
cmpb $0x1, %cl
je 0x31400e
decq %r15
jne 0x313fdf
jmp 0x3140a2
movl %r15d, %r13d
decl %r15d
leaq 0xce134(%rip), %rsi     # 0x3e214f
movl $0x28, %edi
movl $0x37, %edx
callq 0x104226
movq %rax, %r14
movl %r15d, 0x20(%rax)
movq $0x0, 0x10(%rax)
movq %rbp, 0x18(%rax)
movq %r12, 0x8(%rax)
movl $0x10, %r15d
movl %r13d, %ecx
shlq %cl, %r15
movq %r15, %rdi
leaq 0xce0f8(%rip), %r12     # 0x3e214f
movq %r12, %rsi
movl $0x3f, %edx
callq 0x104226
movq %rax, (%r14)
movl 0x20(%r14), %esi
leaq 0xce0fa(%rip), %rdi     # 0x3e216c
movq %r15, %rdx
xorl %eax, %eax
callq 0x103d72
movq %r15, (%rsp)
leaq 0x984a8(%rip), %r8      # 0x3ac52f
movq %rbx, %rdi
movl $0x43, %esi
movq %r12, %rdx
movl $0x1, %ecx
movl $0x1, %r9d
callq 0x316945
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/firstcodes-cache.c
// Function: gt_firstcodes_binsearchcache_check
void gt_firstcodes_binsearchcache_check(GtArrayGtIndexwithcode *binsearchcache,
                                       GT_UNUSED const GtUword
                                                                 *allfirstcodes,
                                       GtUword differentcodes)
{
  if (binsearchcache != NULL)
  {
    GtUword idx, current = binsearchcache->width;

    gt_assert(binsearchcache->spaceGtIndexwithcode != NULL);
    for (idx=0; idx < binsearchcache->nextfreeGtIndexwithcode &&
                current < differentcodes; idx++)
    {
      gt_assert(binsearchcache->spaceGtIndexwithcode[idx].afcindex == current);
      gt_assert(binsearchcache->spaceGtIndexwithcode[idx].code
                == allfirstcodes[current]);
      current += binsearchcache->width;
    }
  }
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x314146
movq (%rdi), %rax
testq %rax, %rax
je 0x314152
movq 0x8(%rdi), %rcx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
setne %r8b
cmpq %rdx, %rcx
setb %r9b
andb %r8b, %r9b
cmpb $0x1, %r9b
jne 0x314146
leaq (%rcx,%rcx), %r9
addq $0x8, %rax
movl $0x1, %r8d
movq %rcx, %r10
cmpq -0x8(%rax), %r10
jne 0x31414d
movq (%rax), %r11
cmpq (%rsi,%r10,8), %r11
jne 0x314148
cmpq %rdi, %r8
jae 0x314146
addq %rcx, %r10
leaq (%r9,%rcx), %r11
incq %r8
addq $0x10, %rax
cmpq %rdx, %r9
movq %r11, %r9
jb 0x31411c
popq %rax
retq
callq 0x910a5
callq 0x9106e
callq 0x910dc
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/firstcodes-cache.c
// Function: gt_firstcodes_binsearchcache_delete
void gt_firstcodes_binsearchcache_delete(GtArrayGtIndexwithcode *binsearchcache,
                                         GtFirstcodesspacelog *fcsl)
{
  if (binsearchcache != NULL)
  {
    if (binsearchcache->spaceGtIndexwithcode != NULL)
    {
      GT_FCI_SUBTRACTWORKSPACE(fcsl,"binsearchcache");
      GT_FREEARRAY(binsearchcache,GtIndexwithcode);
    }
    gt_free (binsearchcache);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x3141d5
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x3141bc
movq $0x0, (%rsp)
leaq 0xcdfd6(%rip), %rdx     # 0x3e214f
leaq 0x983af(%rip), %r8      # 0x3ac52f
movq %rsi, %rdi
movl $0x84, %esi
xorl %ecx, %ecx
movl $0x1, %r9d
callq 0x316945
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x3141bc
leaq 0xcdfab(%rip), %rsi     # 0x3e214f
movl $0x85, %edx
callq 0x1045eb
movq $0x0, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
leaq 0xcdf8c(%rip), %rsi     # 0x3e214f
movq %rbx, %rdi
movl $0x87, %edx
addq $0x10, %rsp
popq %rbx
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/firstcodes-spacelog.c
// Function: gt_firstcodes_spacelog_new
GtFirstcodesspacelog *gt_firstcodes_spacelog_new(void)
{
  GtFirstcodesspacelog *fcsl;

  fcsl = gt_malloc(sizeof (GtFirstcodesspacelog));
  fcsl->workspace = fcsl->splitspace = 0;
  fcsl->nextfree = fcsl->allocated = 0;
  fcsl->spacepeak = 0;
  fcsl->max_percent_difference = 0.0;
  fcsl->calc_difference = false;
  fcsl->entries = NULL;
  return fcsl;
}

// Assembly:
pushq %rax
leaq 0xcbc4a(%rip), %rsi     # 0x3e2452
movl $0x40, %edi
movl $0x34, %edx
callq 0x104226
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movb $0x0, 0x20(%rax)
movups %xmm0, 0x28(%rax)
movq $0x0, 0x38(%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/firstcodes-spacelog.c
// Function: gt_firstcodes_spacelog_showentries
bool gt_firstcodes_spacelog_showentries(FILE *fp,
                                        const GtFirstcodesspacelog *fcsl)
{
  GtUword idx;
  bool foundnonempty = false;

  for (idx = 0; idx < fcsl->nextfree; idx++)
  {
    if (fcsl->entries[idx].size > 0)
    {
      fprintf(fp,"%s %d %s %s "GT_WU"\n",
               fcsl->entries[idx].filename,
               fcsl->entries[idx].line,
               fcsl->entries[idx].title,
               fcsl->entries[idx].work ? "work" : "split",
               (GtUword) fcsl->entries[idx].size);
      foundnonempty = true;
    }
  }
  return foundnonempty;
}

// Assembly:
movq 0x30(%rsi), %rcx
testq %rcx, %rcx
je 0x3168f1
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x20, %r12d
xorl %eax, %eax
leaq 0x2eedb(%rip), %rbp     # 0x34575f
leaq 0xcbbe7(%rip), %r15     # 0x3e2472
xorl %r13d, %r13d
movq 0x28(%rbx), %rdi
movq -0x8(%rdi,%r12), %rsi
testq %rsi, %rsi
je 0x3168d5
movq -0x20(%rdi,%r12), %rdx
movl -0x18(%rdi,%r12), %ecx
cmpb $0x0, (%rdi,%r12)
movq -0x10(%rdi,%r12), %r8
movq %rbp, %r9
leaq 0xcbbc9(%rip), %rax     # 0x3e2483
cmovneq %rax, %r9
movq %rsi, (%rsp)
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x17ab0
movq 0x30(%rbx), %rcx
movb $0x1, %al
incq %r13
addq $0x28, %r12
cmpq %rcx, %r13
jb 0x31688e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3168f3
xorl %eax, %eax
andb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/firstcodes-spacelog.c
// Function: gt_firstcodes_spacelog_delete
void gt_firstcodes_spacelog_delete(GtFirstcodesspacelog *fcsl)
{
  if (fcsl != NULL)
  {
#ifdef SKDEBUG
    if (gt_firstcodes_spacelog_showentries(stderr,fcsl))
    {
      exit(GT_EXIT_PROGRAMMING_ERROR);
    }
#endif
    gt_log_log("maximal difference between estimated and real space = %.2f%%",
               fcsl->max_percent_difference);
    gt_free(fcsl->entries);
    gt_free(fcsl);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x316944
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movsd 0x18(%rdi), %xmm0
leaq 0xcbb7a(%rip), %rdi     # 0x3e2488
movb $0x1, %al
callq 0x103d72
movq 0x28(%rbx), %rdi
leaq 0xcbb32(%rip), %r14     # 0x3e2452
movq %r14, %rsi
movl $0xa5, %edx
callq 0x1045eb
movq %rbx, %rdi
movq %r14, %rsi
movl $0xa6, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1045eb
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/firstcodes-spacelog.c
// Function: gt_firstcodes_updatemax
static void gt_firstcodes_updatemax(GtFirstcodesspacelog *fcsl)
{
  if (fcsl->workspace + fcsl->splitspace > fcsl->spacepeak)
  {
    fcsl->spacepeak = fcsl->workspace + fcsl->splitspace;
    gt_log_log("update spacepeak to %.2f MB",
               GT_MEGABYTES(fcsl->spacepeak));
  }
}

// Assembly:
movq 0x8(%rdi), %rax
addq (%rdi), %rax
cmpq 0x10(%rdi), %rax
jbe 0x316cc1
movq %rax, %xmm1
punpckldq 0x30c4d(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
movq %rax, 0x10(%rdi)
subpd 0x30c51(%rip), %xmm1    # 0x3478f0
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
mulsd 0x30c4d(%rip), %xmm0    # 0x347900
leaq 0xcb96d(%rip), %rdi     # 0x3e2627
movb $0x1, %al
jmp 0x103d72
retq
nop