LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x317452
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 0x2fba84
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 0x2fba84
movl 0xb4(%r12), %esi
cmpl %r14d, %esi
jb 0x317461
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 0x2fdfa6
xorl %eax, %eax
movzbl (%r15,%rax), %ecx
incq (%rbx,%rcx,8)
incq %rax
cmpq %r14, %rax
jb 0x31743d
movq -0x30(%rbp), %rsp
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x91f81
// File: /workspace/github_c_makefile_star2_O1/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 0xd2b66(%rip), %r12     # 0x3eb291
movl $0x38, %edi
movq %r12, %rsi
movl $0x22, %edx
callq 0x1092b2
movq %rax, %rbx
movq $0x0, 0x8(%rax)
movq %r15, (%rax)
movq %r15, %rdi
shlq $0x4, %rdi
movq %r12, %rsi
movl $0x25, %edx
callq 0x1092b2
movq %rax, 0x10(%rbx)
testb $0x1, %bpl
jne 0x31876d
xorl %eax, %eax
jmp 0x318794
movq %r14, %rdi
callq 0x1a67a7
movzwl %ax, %eax
imulq %rax, %r15
shlq $0x3, %r15
leaq 0xd2b0a(%rip), %rsi     # 0x3eb291
movq %r15, %rdi
movl $0x29, %edx
callq 0x1092b2
movq %rax, 0x18(%rbx)
movq %r14, 0x20(%rbx)
movq %r14, %rdi
callq 0x1a67a7
decl %eax
movzbl %al, %edi
callq 0x2f9d04
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_O1/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 0x31884f
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
movq 0x10(%rdi), %rdi
shlq $0x4, %rsi
leaq 0xd2a95(%rip), %rdx     # 0x3eb291
movl $0x3c, %ecx
callq 0x1094e6
movq %rax, 0x10(%rbx)
movq 0x18(%rbx), %r14
testq %r14, %r14
je 0x318840
movq 0x20(%rbx), %rdi
callq 0x1a67a7
movzwl %ax, %esi
imulq 0x8(%rbx), %rsi
shlq $0x3, %rsi
leaq 0xd2a62(%rip), %rdx     # 0x3eb291
movq %r14, %rdi
movl $0x41, %ecx
callq 0x1094e6
movq %rax, 0x18(%rbx)
movq 0x8(%rbx), %rax
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x921f0
// File: /workspace/github_c_makefile_star2_O1/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 0x3188a6
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x318877
leaq 0xd2a24(%rip), %rsi     # 0x3eb291
movl $0x4a, %edx
callq 0x109670
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x318891
leaq 0xd2a0a(%rip), %rsi     # 0x3eb291
movl $0x4c, %edx
callq 0x109670
leaq 0xd29f9(%rip), %rsi     # 0x3eb291
movq %rbx, %rdi
movl $0x4d, %edx
popq %rbx
jmp 0x109670
callq 0x92227
// File: /workspace/github_c_makefile_star2_O1/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 $0x18, %rsp
testq %rdi, %rdi
je 0x318d43
movq %rdi, %r14
movq 0x20(%rdi), %rax
cmpl $0x1, (%rax)
jne 0x318d3e
movq %rsi, %rbx
movzbl %dl, %r15d
movb 0x18(%rax,%r15), %al
movb %al, 0xf(%rsp)
movq 0x8(%r14), %r13
movq %r13, %rbp
shlq $0x4, %rbp
addq 0x10(%r14), %rbp
movl 0x28(%r14), %r12d
testq %r13, %r13
je 0x318cb5
leaq -0x8(%rbp), %rdi
movl $0x40, %edx
subl %r12d, %edx
movq %r12, %rsi
callq 0x2fcc2c
jmp 0x318cb5
testq %r13, %r13
je 0x318d1d
movq -0x10(%rbp), %rcx
addq %rax, %rcx
cmpq %rbx, %rcx
ja 0x318d3e
movq %rax, %r13
leaq -0x8(%rbp), %rdi
movq %rdi, 0x10(%rsp)
xorl %esi, %esi
movl %r12d, %edx
callq 0x2fddcc
cmpb 0xf(%rsp), %al
jne 0x318d1d
movq %r13, %rcx
movq -0x10(%rbp), %rax
addq %r13, %rax
cmpq %rbx, %rax
jne 0x318d1d
cmpq 0x30(%r14), %rcx
jae 0x318d1d
incq %rcx
movl $0x40, %edx
subl %r12d, %edx
movq 0x10(%rsp), %rdi
movq %r12, %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2fcd13
movl $0x1, %edx
movq %r14, %rdi
movq %rbx, %rsi
movl %r15d, %ecx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3188ab
callq 0x173b0
callq 0x922ce
// File: /workspace/github_c_makefile_star2_O1/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 0x318e68
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
testq %rdx, %rdx
je 0x318d8d
movq (%r15), %rax
jmp 0x318d94
movq 0x8(%r14), %rax
shrq %rax
movq 0x10(%r14), %r13
shlq $0x4, %rax
movq (%r13,%rax), %rbp
cmpq %r12, %rbp
ja 0x318dfd
addq %rax, %r13
movl 0x28(%r14), %esi
addq $0x8, %r13
movl $0x40, %edx
subl %esi, %edx
movq %r13, %rdi
callq 0x2fcc2c
addq %rbp, %rax
cmpq %r12, %rax
jbe 0x318dfd
movl $0x1, %ebp
testq %rbx, %rbx
je 0x318e57
movq 0x20(%r14), %r15
movl 0x28(%r14), %edx
movq %r13, %rdi
xorl %esi, %esi
callq 0x2fddcc
cmpl $0x1, (%r15)
jne 0x318e6d
movzbl %al, %eax
movb 0x118(%r15,%rax), %al
movb %al, (%rbx)
jmp 0x318e57
movq %rsp, %rdi
movq %r12, (%rdi)
movq 0x8(%r14), %rdx
movq 0x10(%r14), %rsi
leaq 0x60(%rip), %r8         # 0x318e72
movl $0x10, %ecx
movq %r14, %r9
callq 0xda650
testq %rax, %rax
je 0x318e55
movq %rax, %r12
testq %rbx, %rbx
je 0x318e3e
movl 0x28(%r14), %edx
leaq 0x8(%r12), %rdi
xorl %esi, %esi
callq 0x2fddcc
movb %al, (%rbx)
movl $0x1, %ebp
testq %r15, %r15
je 0x318e57
subq 0x10(%r14), %r12
sarq $0x4, %r12
movq %r12, (%r15)
jmp 0x318e57
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x92340
callq 0x173b0
// File: /workspace/github_c_makefile_star2_O1/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 0x318ead
movl 0x28(%rdx), %eax
addq $0x8, %rsi
movl $0x40, %edx
subl %eax, %edx
movq %rsi, %rdi
movq %rax, %rsi
callq 0x2fcc2c
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_O1/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 0x319141
movq -0x10(%rax), %r14
movl 0x28(%rdx), %esi
addq $-0x8, %rax
movl $0x40, %edx
subl %esi, %edx
movq %rax, %rdi
callq 0x2fcc2c
movq %rax, %rcx
addq %r14, %rcx
xorl %eax, %eax
cmpq %rcx, %rbx
sbbl %eax, %eax
jmp 0x319165
movl 0x28(%rdx), %esi
addq $0x8, %rax
movl $0x40, %edx
subl %esi, %edx
movq %rax, %rdi
callq 0x2fcc2c
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_O1/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 %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x3192a1
movq %rdx, %rbx
testq %rdx, %rdx
je 0x31918b
movq (%rbx), %rcx
jmp 0x319192
movq 0x8(%rdi), %rcx
shrq %rcx
movq 0x8(%rdi), %r8
testq %r8, %r8
je 0x3191a4
movq 0x10(%rdi), %r14
cmpq %rsi, (%r14)
jbe 0x3191af
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq -0x1(%r8), %rdx
movq %rdx, %rax
shlq $0x4, %rax
cmpq %rsi, (%r14,%rax)
jbe 0x319210
cmpq %rdx, %rcx
jae 0x3191db
movq %rcx, %rax
shlq $0x4, %rax
cmpq %rsi, (%r14,%rax)
ja 0x3191db
addq %r14, %rax
cmpq %rsi, 0x10(%rax)
ja 0x3191a6
leaq -0x2(%r8), %rax
cmpq %rax, %rcx
jae 0x31921e
leaq 0x1(%rcx), %rax
movq %rax, %rdi
shlq $0x4, %rdi
cmpq %rsi, (%r14,%rdi)
ja 0x31921e
movq %rcx, %r9
shlq $0x4, %r9
cmpq %rsi, 0x20(%r14,%r9)
jbe 0x31921e
addq %rdi, %r14
testq %rbx, %rbx
je 0x31924b
movq %rax, (%rbx)
jmp 0x31924b
shlq $0x4, %r8
leaq (%r14,%r8), %rax
addq $-0x10, %rax
jmp 0x3191a6
testq %rcx, %rcx
je 0x319253
movq %rcx, %rax
shlq $0x4, %rax
cmpq %rsi, -0x10(%r14,%rax)
ja 0x319253
addq %r14, %rax
cmpq %rsi, (%rax)
jbe 0x319253
decq %rcx
testq %rbx, %rbx
je 0x319244
movq %rcx, (%rbx)
shlq $0x4, %rcx
addq %rcx, %r14
movq %r14, %rax
jmp 0x3191a6
cmpq $0x3, %r8
jb 0x3191a4
testq %rbx, %rbx
sete %bpl
leaq 0x8(%rsp), %rdi
movq %rsi, (%rdi)
leaq 0x33(%rip), %r8         # 0x3192a6
movl $0x10, %ecx
movq %r14, %rsi
callq 0x17990
testq %rax, %rax
sete %cl
orb %bpl, %cl
jne 0x3191a6
movq %rax, %rcx
subq %r14, %rcx
sarq $0x4, %rcx
movq %rcx, (%rbx)
jmp 0x3191a6
callq 0x923b2
// File: /workspace/github_c_makefile_star2_O1/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 0x31930b
movq %rsi, %rbx
testq %rsi, %rsi
je 0x31930b
movq %rdi, %r14
addq $0x8, %rdi
movq 0x8(%r14), %r15
movl $0x8, %esi
movl $0x1, %edx
movq %rbx, %rcx
callq 0x125658
movq 0x10(%r14), %rdi
movl $0x10, %esi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x125658
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
callq 0x923eb
// File: /workspace/github_c_makefile_star2_O1/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, 0x18(%rsp)
movq %rdx, 0x8(%rsp)
cmpq $0x0, 0x8(%rdi)
je 0x3195da
movq %rsi, %rbp
movq %rdi, %r15
movq %r8, %rdx
callq 0x318eb5
testq %rax, %rax
je 0x3195da
movq %rax, %r13
movq (%rax), %rax
cmpq %rbp, %rax
cmovaq %rax, %rbp
movq 0x8(%r15), %rax
movq 0x10(%r15), %rcx
shlq $0x4, %rax
leaq (%rcx,%rax), %r12
addq $-0x10, %r12
movq 0x8(%rsp), %rax
incq %rax
movq %rax, 0x10(%rsp)
cmpq 0x8(%rsp), %rbp
ja 0x3195da
movq %rbp, 0x20(%rsp)
movq (%r13), %rbx
movl 0x28(%r15), %esi
leaq 0x8(%r13), %rbp
movl $0x40, %edx
subl %esi, %edx
movq %rbp, %rdi
callq 0x2fcc2c
addq %rbx, %rax
movq 0x10(%rsp), %rcx
movq %rcx, %rbx
cmpq %rcx, %rax
jae 0x319589
movq (%r13), %r14
movl 0x28(%r15), %esi
movl $0x40, %edx
subl %esi, %edx
movq %rbp, %rdi
callq 0x2fcc2c
movq %rax, %rbx
addq %r14, %rbx
movq 0x20(%r15), %r14
movl 0x28(%r15), %edx
movq %rbp, %rdi
xorl %esi, %esi
callq 0x2fddcc
cmpl $0x1, (%r14)
jne 0x3195e9
movq 0x20(%rsp), %rbp
subq %rbp, %rbx
movzbl %al, %eax
movzbl 0x118(%r14,%rax), %eax
movq 0x18(%rsp), %rcx
addq %rbx, (%rcx,%rax,8)
movq %r13, %rax
cmpq %r12, %r13
je 0x3195ce
leaq 0x10(%r13), %rax
movq 0x10(%r13), %rbp
cmpq %r12, %r13
movq %rax, %r13
jne 0x319531
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x173b0
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/eis-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
testq %rdi, %rdi
je 0x319b7a
movq %r8, %r13
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r14
movl 0x28(%rdi), %ebp
movq %rdi, 0x30(%rsp)
movq %rdx, %rsi
movq %r9, %rdx
callq 0x318eb5
movl $0x40, %ecx
subl %ebp, %ecx
movl %ecx, 0xc(%rsp)
addq %r15, %rbx
subq %r13, %r14
movq %r14, 0x18(%rsp)
movq %rbx, 0x28(%rsp)
movq %r13, 0x20(%rsp)
movq (%rax), %r12
cmpq %r12, %r15
jb 0x319b5a
movq %rax, 0x10(%rsp)
leaq 0x8(%rax), %r13
movq %r13, %rdi
movq %rbp, %r14
movq %rbp, %rsi
movl 0xc(%rsp), %edx
callq 0x2fcc2c
addq %r12, %rax
movq %rbx, %r12
cmpq %rbx, %rax
jae 0x319af8
movq 0x10(%rsp), %rax
movq (%rax), %rbx
movq %r13, %rdi
movq %r14, %rsi
movl 0xc(%rsp), %edx
callq 0x2fcc2c
movq %rax, %r12
addq %rbx, %r12
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rbx
movq %r13, %rdi
xorl %esi, %esi
movq %r14, %rbp
movl %r14d, %edx
callq 0x2fddcc
cmpl $0x1, (%rbx)
jne 0x319b75
movq 0x20(%rsp), %r13
subl %r13d, %r12d
movq %r15, %rcx
subq %r13, %rcx
cmpq %r12, %rcx
jae 0x319b49
movzbl %al, %eax
movq 0x18(%rsp), %rcx
leaq (%rcx,%r15), %rdi
leaq (%r12,%r13), %rdx
subq %r15, %rdx
movzbl 0x118(%rbx,%rax), %esi
callq 0x173a0
addq %r13, %r12
movq 0x10(%rsp), %rax
addq $0x10, %rax
movq 0x28(%rsp), %rbx
movq %r12, %r15
cmpq %rbx, %r12
jb 0x319aa9
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x173b0
callq 0x9245d
// File: /workspace/github_c_makefile_star2_O1/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 0x31a041
movq %rsi, %r14
movl $0x18, %r15d
xorl %r12d, %r12d
movq (%rbx), %rax
movq (%rax,%r15), %rdi
movq %r14, %rsi
callq 0x1b117b
incq %r12
addq $0x20, %r15
cmpq 0x8(%rbx), %r12
jb 0x31a025
movq (%rbx), %rdi
leaq 0xd1494(%rip), %r14     # 0x3eb4df
movq %r14, %rsi
movl $0x4e, %edx
callq 0x109670
movq %rbx, %rdi
movq %r14, %rsi
movl $0x4f, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x109670
// File: /workspace/github_c_makefile_star2_O1/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 0xd09d2(%rip), %rdx     # 0x3eb4df
movl $0x6a, %ecx
callq 0x1094e6
subq %r12, %r14
jbe 0x31ab53
movq %rax, %r15
shlq $0x5, %r12
addq %rax, %r12
addq $0x18, %r12
movq %rbx, %rdi
callq 0x1b115a
movq %rax, (%r12)
addq $0x20, %r12
decq %r14
jne 0x31ab2a
testq %r15, %r15
je 0x31ab58
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x92790
callq 0x927c7
// File: /workspace/github_c_makefile_star2_O1/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 0xcfd4a(%rip), %rdx     # 0x3eb571
movl $0x3f, %ecx
callq 0x1094e6
movq %rax, %r12
testq %r14, %r14
je 0x31b864
subq %r13, %r15
jbe 0x31b87b
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 0x31b851
testq %r12, %r12
je 0x31b876
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x92ba3
callq 0x92b6c
// File: /workspace/github_c_makefile_star2_O1/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 0x31bf74
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x30058(%rbx), %rdi
addq %r14, %rdi
callq 0x1a9e1c
incq %r15
movl 0xc(%rbx), %eax
addq $0x100, %r14            # imm = 0x100
cmpq %rax, %r15
jb 0x31bf53
movq 0x30058(%rbx), %rdi
leaq 0xcf67d(%rip), %r14     # 0x3eb5ff
movq %r14, %rsi
movl $0x12f, %edx            # imm = 0x12F
callq 0x109670
movq 0x30028(%rbx), %rdi
movq %r14, %rsi
movl $0x130, %edx            # imm = 0x130
callq 0x109670
movq $0x0, 0x30028(%rbx)
cmpl $0x2, 0xc(%rbx)
jb 0x31bfc0
leaq 0x30028(%rbx), %rdi
callq 0x32a2b9
movq 0x10(%rbx), %rdi
leaq 0xcf634(%rip), %rsi     # 0x3eb5ff
movl $0x136, %edx            # imm = 0x136
popq %rbx
popq %r14
popq %r15
jmp 0x109670
nop
// File: /workspace/github_c_makefile_star2_O1/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
subq $0x18, %rsp
movq %rdx, 0x10(%rsp)
movq %rdi, %r15
movq %rdi, %xmm1
punpckldq 0x325ed(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x325f5(%rip), %xmm1    # 0x3508f0
movl %esi, %ebp
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
callq 0x17340
cvttsd2si %xmm0, %rbx
addl %ebp, %ebx
xorl %edx, %edx
leal 0x1(%rbx), %r12d
movl $0x1, %ebp
movl %r12d, %ecx
shlq %cl, %rbp
cmpq %r15, %rbp
jae 0x31e3da
movq %r15, %r14
movl %r12d, %ecx
shrq %cl, %r14
cmpq $0x20, %r14
jb 0x31e3da
movl $0x28, %edi
leaq 0xcd525(%rip), %rsi     # 0x3eb873
movl $0x37, %edx
callq 0x1092b2
movq %rax, %r13
movl %ebx, 0x20(%rax)
movq $0x0, 0x10(%rax)
movq %rbp, 0x18(%rax)
movq %r14, 0x8(%rax)
movl $0x10, %ebp
movl %r12d, %ecx
shlq %cl, %rbp
movq %rbp, %rdi
leaq 0xcd4f0(%rip), %r14     # 0x3eb873
movq %r14, %rsi
movl $0x3f, %edx
callq 0x1092b2
movq %rax, (%r13)
movl 0x20(%r13), %esi
leaq 0xcd4f1(%rip), %rdi     # 0x3eb890
movq %rbp, %rdx
xorl %eax, %eax
callq 0x108e02
movq %rbp, (%rsp)
movl $0x1, %ebp
movq 0x10(%rsp), %rdi
movl $0x43, %esi
movq %r14, %rdx
movl $0x1, %ecx
leaq 0x97774(%rip), %r8      # 0x3b5b3f
movl $0x1, %r9d
callq 0x320ca8
xorl %edx, %edx
jmp 0x31e3ea
xorl %eax, %eax
testl %ebx, %ebx
sete %al
subl $0x1, %ebx
cmovbl %edx, %ebx
leal (%rax,%rax,2), %ebp
testl %ebp, %ebp
je 0x31e317
cmpl $0x3, %ebp
jne 0x31e3fa
xorl %r13d, %r13d
movq %r13, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x31e49e
movq (%rdi), %rax
testq %rax, %rax
je 0x31e4aa
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 0x31e49e
leaq (%rcx,%rcx), %r9
addq $0x8, %rax
movl $0x1, %r8d
movq %rcx, %r10
cmpq -0x8(%rax), %r10
jne 0x31e4a5
movq (%rax), %r11
cmpq (%rsi,%r10,8), %r11
jne 0x31e4a0
cmpq %rdi, %r8
jae 0x31e49e
addq %rcx, %r10
leaq (%r9,%rcx), %r11
incq %r8
addq $0x10, %rax
cmpq %rdx, %r9
movq %r11, %r9
jb 0x31e474
popq %rax
retq
callq 0x92f46
callq 0x92f0f
callq 0x92f7d
// File: /workspace/github_c_makefile_star2_O1/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 0x31e52d
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x31e514
movq $0x0, (%rsp)
leaq 0xcd3a2(%rip), %rdx     # 0x3eb873
leaq 0x97667(%rip), %r8      # 0x3b5b3f
movq %rsi, %rdi
movl $0x84, %esi
xorl %ecx, %ecx
movl $0x1, %r9d
callq 0x320ca8
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x31e514
leaq 0xcd377(%rip), %rsi     # 0x3eb873
movl $0x85, %edx
callq 0x109670
movq $0x0, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
leaq 0xcd358(%rip), %rsi     # 0x3eb873
movq %rbx, %rdi
movl $0x87, %edx
addq $0x10, %rsp
popq %rbx
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xcb006(%rip), %rsi     # 0x3ebb76
movl $0x40, %edi
movl $0x34, %edx
callq 0x1092b2
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_O1/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:
cmpq $0x0, 0x30(%rsi)
je 0x320c54
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 0x2db75(%rip), %rbp     # 0x34e75f
leaq 0xcafa5(%rip), %r15     # 0x3ebb96
xorl %r13d, %r13d
movq 0x28(%rbx), %rdi
movq -0x8(%rdi,%r12), %rsi
testq %rsi, %rsi
je 0x320c37
movq -0x20(%rdi,%r12), %rdx
movl -0x18(%rdi,%r12), %ecx
cmpb $0x0, (%rdi,%r12)
movq -0x10(%rdi,%r12), %r8
movq %rbp, %r9
leaq 0xcaf87(%rip), %rax     # 0x3ebba7
cmovneq %rax, %r9
movq %rsi, (%rsp)
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x17ab0
movb $0x1, %al
incq %r13
addq $0x28, %r12
cmpq 0x30(%rbx), %r13
jb 0x320bf4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x320c56
xorl %eax, %eax
andb $0x1, %al
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x320ca7
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movsd 0x18(%rdi), %xmm0
leaq 0xcaf3b(%rip), %rdi     # 0x3ebbac
movb $0x1, %al
callq 0x108e02
movq 0x28(%rbx), %rdi
leaq 0xcaef3(%rip), %r14     # 0x3ebb76
movq %r14, %rsi
movl $0xa5, %edx
callq 0x109670
movq %rbx, %rdi
movq %r14, %rsi
movl $0xa6, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x109670
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x32102c
movq %rax, %xmm1
punpckldq 0x2f8e2(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
movq %rax, 0x10(%rdi)
subpd 0x2f8e6(%rip), %xmm1    # 0x3508f0
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
mulsd 0x2f8e2(%rip), %xmm0    # 0x350900
leaq 0xcad26(%rip), %rdi     # 0x3ebd4b
movb $0x1, %al
jmp 0x108e02
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/firstcodes-tab.c
// Function: gt_firstcodes_countocc_set
static void gt_firstcodes_countocc_set(GtFirstcodestab *fct,
                                       GtUword *differences,
                                       GtUword idx,
                                       GtUword value)
{
  gt_assert(value > 0);
  if (fct->countocc_small == NULL)
  {
    if (value <= fct->countmax)
    {
      differences[idx] |= (value << fct->shiftforcounts);
    } else
    {
      differences[idx] &= fct->differencemask;
      ul_u32_gt_hashmap_add(fct->countocc_exceptions,idx,
                            (uint32_t) (value - fct->countmax));
      fct->hashmap_addcount++;
    }
  } else
  {
    if (value <= GT_FIRSTCODES_MAXSMALL)
    {
      fct->countocc_small[idx] = (GtCountAFCtype) value;
    } else
    {
      fct->countocc_small[idx] = 0;
      ul_u32_gt_hashmap_add(fct->countocc_exceptions,idx,
                            value - GT_FIRSTCODES_MAXSMALL);
      fct->hashmap_addcount++;
    }
  }
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
testq %rcx, %rcx
je 0x321576
movq %rcx, %rbx
movq %rdi, %r14
movq 0x38(%rdi), %rax
testq %rax, %rax
je 0x321519
cmpq $0xff, %rbx
ja 0x321531
movb %bl, (%rax,%rdx)
jmp 0x32156e
cmpq %rbx, 0x60(%r14)
jae 0x321563
movq 0x58(%r14), %rax
andq %rax, (%rsi,%rdx,8)
subl 0x60(%r14), %ebx
movq 0x40(%r14), %rdi
jmp 0x32153f
movb $0x0, (%rax,%rdx)
movq 0x40(%r14), %rdi
addl $0xffffff01, %ebx       # imm = 0xFFFFFF01
leaq 0x8(%rsp), %rsi
movq %rdx, (%rsi)
movl %ebx, 0x8(%rsi)
movq %rsp, %rdx
callq 0x106536
testl %eax, %eax
jne 0x32155d
movq (%rsp), %rax
movl %ebx, 0x8(%rax)
incq 0x18(%r14)
jmp 0x32156e
movb 0x68(%r14), %cl
shlq %cl, %rbx
orq %rbx, (%rsi,%rdx,8)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
callq 0x9352f
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/firstcodes-tab.c
// Function: gt_firstcodes_accumulatecounts_merge
GtUword gt_firstcodes_accumulatecounts_merge(
                                        GtFirstcodestab *tab,
                                        GtUword *differences,
                                        GtUword differentcodes,
                                        const GtUword *querystream_fst,
                                        const GtUword *querystream_lst,
                                        GtUword subjectindex,
                                        GtUword subjectcode)
{
  GtUword found = 0, lastocc = 0;
  const GtUword *query = querystream_fst;

  gt_assert(subjectindex < differentcodes);
  while (query <= querystream_lst)
  {
    if (*query <= subjectcode)
    {
      if (*query == subjectcode)
      {
        lastocc++;
      }
      query++;
    } else
    {
      if (lastocc > 0)
      {
        gt_firstcodes_countocc_increment(tab,differences,subjectindex,lastocc);
        found += lastocc;
        lastocc = 0;
      }
      if (subjectindex < differentcodes - 1)
      {
        subjectindex++;
        /* extract diff */
        subjectcode += (differences[subjectindex] & tab->differencemask);
      } else
      {
        break;
      }
    }
  }
  if (lastocc > 0)
  {
    gt_firstcodes_countocc_increment(tab,differences,subjectindex,lastocc);
    found += lastocc;
  }
  return found;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, 0x8(%rsp)
movq %rdi, (%rsp)
cmpq %rdx, %r9
jae 0x321650
movq %r9, %r12
movq %r8, %rbx
movq %rcx, %rbp
cmpq %r8, %rcx
jbe 0x3215b1
xorl %r15d, %r15d
xorl %r14d, %r14d
jmp 0x321622
movq %rdx, %r13
movq 0x50(%rsp), %rsi
decq %r13
xorl %r14d, %r14d
xorl %r15d, %r15d
cmpq %rsi, (%rbp)
jbe 0x321610
testq %r14, %r14
je 0x3215ee
movq (%rsp), %rdi
movq %rsi, 0x10(%rsp)
movq 0x8(%rsp), %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0x321655
movq 0x10(%rsp), %rsi
addq %r14, %r15
cmpq %r13, %r12
jae 0x3215ac
movq (%rsp), %rcx
movq 0x58(%rcx), %rdx
movq 0x8(%rsp), %rcx
andq 0x8(%rcx,%r12,8), %rdx
incq %r12
addq %rdx, %rsi
xorl %r14d, %r14d
jmp 0x32161d
sete %cl
movzbl %cl, %ecx
addq %rcx, %r14
addq $0x8, %rbp
cmpq %rbx, %rbp
jbe 0x3215c2
testq %r14, %r14
je 0x32163e
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0x321655
addq %r14, %r15
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x93566
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/firstcodes-tab.c
// Function: gt_firstcodes_countocc_get
static uint32_t gt_firstcodes_countocc_get(const GtFirstcodestab *fct,
                                           const GtUword *differences,
                                           GtUword idx)
{
  if (fct->countocc_small == NULL)
  {
    GtUword count;

    if ((count = (GtUword) (differences[idx] >> fct->shiftforcounts)) > 0)
    {
      return (uint32_t) count;
    } else
    {
      uint32_t *valueptr = ul_u32_gt_hashmap_get(fct->countocc_exceptions,idx);

      gt_assert(valueptr != NULL);
      return *valueptr + (uint32_t) fct->countmax;
    }
  } else
  {
    if (fct->countocc_small[idx] > 0)
    {
      return (uint32_t) fct->countocc_small[idx];
    } else
    {
      uint32_t *valueptr = ul_u32_gt_hashmap_get(fct->countocc_exceptions,idx);

      gt_assert(valueptr != NULL);
      return *valueptr + (uint32_t) GT_FIRSTCODES_MAXSMALL;
    }
  }
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x38(%rdi), %rax
testq %rax, %rax
je 0x321cb4
movzbl (%rax,%rdx), %eax
testl %eax, %eax
jne 0x321cdf
movq 0x40(%rbx), %rdi
leaq 0x8(%rsp), %rsi
movq %rdx, (%rsi)
callq 0x10620e
testq %rax, %rax
je 0x321ce5
movq %rax, %rcx
movl $0xff, %eax
addl 0x8(%rcx), %eax
jmp 0x321cdf
movq (%rsi,%rdx,8), %rax
movb 0x68(%rbx), %cl
shrq %cl, %rax
testq %rax, %rax
jne 0x321cdf
movq 0x40(%rbx), %rdi
leaq 0x8(%rsp), %rsi
movq %rdx, (%rsi)
callq 0x10620e
testq %rax, %rax
je 0x321cea
movl 0x8(%rax), %eax
addl 0x60(%rbx), %eax
addq $0x10, %rsp
popq %rbx
retq
callq 0x93810
callq 0x93849
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/firstcodes-tab.c
// Function: gt_firstcodes_get_leftborder
GtUword gt_firstcodes_get_leftborder(const GtFirstcodestab *fct,
                                           GtUword idx)
{
#if defined (_LP64) || defined (_WIN64)
  GT_CHANGEPOINT_GET(changepoint);

  return (GtUword) fct->leftborder[idx]
                         + (changepoint << GT_MODVALUEBITS);
#else
  return (GtUword) fct->leftborder[idx];
#endif
}

// Assembly:
movq 0x80(%rdi), %rax
testq %rax, %rax
je 0x321d34
movq 0x70(%rdi), %rdx
xorl %ecx, %ecx
cmpq %rsi, (%rdx,%rcx,8)
jae 0x321d2e
incq %rcx
cmpq %rcx, %rax
jne 0x321d1d
movq %rax, %rcx
shlq $0x20, %rcx
jmp 0x321d36
xorl %ecx, %ecx
movq 0x30(%rdi), %rax
movl (%rax,%rsi,4), %eax
orq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/firstcodes-tab.c
// Function: gt_firstcodes_findfirstsamplelarger
GtUword gt_firstcodes_findfirstsamplelarger(const GtFirstcodestab *fct,
                                                  GtUword suftaboffset)
{
  GtUword left = 0, right, mid, midval, found;

  right = found = fct->numofsamples;
  while (left+1 < right)
  {
    mid = GT_DIV2(left+right);
    midval = gt_firstcodes_get_sample(fct,mid);
    if (suftaboffset == midval)
    {
      return mid;
    }
    if (suftaboffset < midval)
    {
      found = mid;
      right = mid - 1;
    } else
    {
      left = mid + 1;
    }
  }
  gt_assert(suftaboffset <= gt_firstcodes_get_sample(fct,found));
  return found;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r12
cmpq $0x2, %r12
jb 0x321d9f
xorl %r13d, %r13d
movq %r12, %rbp
movq %r13, %r15
addq %rbp, %r15
shrq %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x321cf6
cmpq %rbx, %rax
je 0x321db2
ja 0x321d8d
incq %r15
movq %r15, %r13
movq %r12, %r15
jmp 0x321d94
leaq -0x1(%r15), %rbp
movq %r15, %r12
leaq 0x1(%r13), %rax
cmpq %rbp, %rax
jb 0x321d67
jmp 0x321da2
movq %r12, %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x321cf6
cmpq %rbx, %rax
jb 0x321dc4
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x938bb
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/firstcodes-tab.c
// Function: gt_firstcodes_sample2full
GtUword gt_firstcodes_sample2full(const GtFirstcodestab *fct,
                                        GtUword idx)
{
  gt_assert(idx <= fct->numofsamples);
  if (idx < fct->numofsamples)
  {
    return (GtUword) idx << (GtUword) fct->sampleshift;
  }
  return fct->differentcodes - 1;
}

// Assembly:
cmpq %rsi, 0x8(%rdi)
jb 0x321de3
jbe 0x321dd9
movb 0x28(%rdi), %cl
shlq %cl, %rsi
jmp 0x321ddf
movq (%rdi), %rsi
decq %rsi
movq %rsi, %rax
retq
pushq %rax
callq 0x938f4
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/firstcodes-tab.c
// Function: gt_firstcodes_samples_delete
void gt_firstcodes_samples_delete(GtFirstcodesspacelog *fcsl,
                                  GtFirstcodestab *fct)
{
  if (fct->leftborder_samples != NULL)
  {
    gt_free(fct->leftborder_samples);
    GT_FCI_SUBTRACTWORKSPACE(fcsl,"leftborder_samples");
    fct->leftborder_samples = NULL;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x48(%rsi), %rdi
testq %rdi, %rdi
je 0x321e3e
movq %rsi, %rbx
leaq 0xca007(%rip), %r15     # 0x3ebe0e
movq %r15, %rsi
movl $0x29a, %edx            # imm = 0x29A
callq 0x109670
xorl %r12d, %r12d
movq %r12, (%rsp)
leaq 0xca1ca(%rip), %r8      # 0x3ebfec
movq %r14, %rdi
movl $0x29b, %esi            # imm = 0x29B
movq %r15, %rdx
xorl %ecx, %ecx
movl $0x1, %r9d
callq 0x320ca8
movq %r12, 0x48(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/firstcodes-tab.c
// Function: gt_firstcodes_countocc_delete
void gt_firstcodes_countocc_delete(GtFirstcodesspacelog *fcsl,
                                   GtFirstcodestab *fct)
{
  if (fct->countocc_small != NULL)
  {
    GT_FCI_SUBTRACTWORKSPACE(fcsl,"countocc_small");
    gt_free(fct->countocc_small);
    fct->countocc_small = NULL;
  }
  gt_hashtable_delete(fct->countocc_exceptions);
  fct->countocc_exceptions = NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
cmpq $0x0, 0x38(%rsi)
je 0x321e9c
xorl %r15d, %r15d
movq %r15, (%rsp)
leaq 0xc9fa3(%rip), %r14     # 0x3ebe0e
leaq 0xca280(%rip), %r8      # 0x3ec0f2
movl $0x2a5, %esi            # imm = 0x2A5
movq %r14, %rdx
xorl %ecx, %ecx
movl $0x1, %r9d
callq 0x320ca8
movq 0x38(%rbx), %rdi
movq %r14, %rsi
movl $0x2a6, %edx            # imm = 0x2A6
callq 0x109670
movq %r15, 0x38(%rbx)
movq 0x40(%rbx), %rdi
callq 0x106d10
movq $0x0, 0x40(%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/genometools[P]genometools/src/match/firstcodes-tab.c
// Function: gt_firstcodes_tab_delete
void gt_firstcodes_tab_delete(GtFirstcodesspacelog *fcsl,GtFirstcodestab *fct)
{
  gt_firstcodes_samples_delete(fcsl,fct);
  gt_str_delete(fct->outfilenameleftborder);
  fct->outfilenameleftborder = NULL;
#if defined (_LP64) || defined (_WIN64)
  GT_FREEARRAY(&fct->bitchangepoints,GtUword);
#endif
}

// Assembly:
pushq %rbx
movq %rsi, %rbx
callq 0x321de9
movq 0x50(%rbx), %rdi
callq 0x121b03
movq $0x0, 0x50(%rbx)
movq 0x70(%rbx), %rdi
testq %rdi, %rdi
je 0x321efd
addq $0x70, %rbx
leaq 0xc9f29(%rip), %rsi     # 0x3ebe0e
movl $0x2b3, %edx            # imm = 0x2B3
callq 0x109670
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
popq %rbx
retq