LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/eis-seqblocktranslate.h
// Function: addSymCountsFromComposition
static inline void
addSymCountsFromComposition(struct compList *compositionTable,
                            unsigned alphabetSize,
                            PermCompIndex compIndex, GtUword *counts)
{
  BitOffset bitsPerComp, bitsPerCount;
  gt_assert(compositionTable);
  bitsPerCount = compositionTable->bitsPerCount;
  bitsPerComp = bitsPerCount * alphabetSize;
  gt_assert(compIndex < compositionTable->numCompositions);
  gt_bsGetUniformUlongArrayAdd(compositionTable->catCompsPerms,
                             compIndex * bitsPerComp, bitsPerCount,
                             alphabetSize,
#if defined (_LP64) || defined (_WIN64)
                             (uint64_t*) counts);
#else
                             (uint32_t*) counts);
#endif
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x2ac193
movl %esi, %eax
movl %edx, %esi
cmpq %rsi, (%rdi)
jbe 0x2ac1c1
movq %rcx, %r8
movl 0x18(%rdi), %edx
movl %eax, %ecx
movq 0x10(%rdi), %rdi
imulq %rcx, %rsi
imulq %rdx, %rsi
popq %rax
jmp 0x28ee25
movq 0x18bdce(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x38e6f(%rip), %rsi     # 0x2e5013
leaq 0xd5550(%rip), %rdx     # 0x3816fb
leaq 0xd56a2(%rip), %rcx     # 0x381854
leaq 0xd556b(%rip), %r8      # 0x381724
movl $0xc9, %r9d
jmp 0x2ac1ed
movq 0x18bda0(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x38e41(%rip), %rsi     # 0x2e5013
leaq 0xd55ad(%rip), %rdx     # 0x381786
leaq 0xd5674(%rip), %rcx     # 0x381854
leaq 0xd553d(%rip), %r8      # 0x381724
movl $0xcc, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
movq %r8, %rbx
movq %rdx, %rax
movl %ecx, %r8d
xorl %edx, %edx
divq %r8
testq %rdx, %rdx
je 0x2ac258
movq %rdx, %r14
movq %rsp, %r12
movq 0x10(%rbp), %rcx
movq %rsp, %r15
addq $0xf, %r8
andq $-0x10, %r8
subq %r8, %r15
movq %r15, %rsp
movq %r9, %rdx
movq %r15, %r8
movl %r14d, %r9d
callq 0x2ac054
xorl %eax, %eax
cmpq %r14, %rax
jae 0x2ac255
movzbl (%r15,%rax), %ecx
incq (%rbx,%rcx,8)
incq %rax
jmp 0x2ac242
movq %r12, %rsp
leaq -0x20(%rbp), %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xd49cd(%rip), %r12     # 0x381f80
pushq $0x38
popq %rdi
pushq $0x22
popq %rdx
movq %r12, %rsi
callq 0x93160
movq %rax, %rbx
andq $0x0, 0x8(%rax)
movq %r15, (%rax)
movq %r15, %rdi
shlq $0x4, %rdi
pushq $0x25
popq %rdx
movq %r12, %rsi
callq 0x93160
movq %rax, 0x10(%rbx)
testb $0x1, %bpl
jne 0x2ad5ec
xorl %eax, %eax
jmp 0x2ad611
movq %r14, %rdi
callq 0x14906a
movzwl %ax, %eax
imulq %rax, %r15
shlq $0x3, %r15
leaq 0xd497a(%rip), %rsi     # 0x381f80
pushq $0x29
popq %rdx
movq %r15, %rdi
callq 0x93160
movq %rax, 0x18(%rbx)
movq %r14, 0x20(%rbx)
movq %r14, %rdi
callq 0x14906a
decb %al
movzbl %al, %edi
callq 0x2ad656
movl %eax, 0x28(%rbx)
movl %eax, %ecx
negb %cl
pushq $-0x1
popq %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_O2/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 0x2ad6c9
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
movq 0x10(%rdi), %rdi
shlq $0x4, %rsi
leaq 0xd4906(%rip), %rdx     # 0x381f80
pushq $0x3c
popq %rcx
callq 0x93472
movq %rax, 0x10(%rbx)
movq 0x18(%rbx), %r14
testq %r14, %r14
je 0x2ad6ba
movq 0x20(%rbx), %rdi
callq 0x14906a
movzwl %ax, %esi
imulq 0x8(%rbx), %rsi
shlq $0x3, %rsi
leaq 0xd48d5(%rip), %rdx     # 0x381f80
pushq $0x41
popq %rcx
movq %r14, %rdi
callq 0x93472
movq %rax, 0x18(%rbx)
movq 0x8(%rbx), %rax
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x18a898(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x37939(%rip), %rsi     # 0x2e5013
leaq 0xd48b9(%rip), %rdx     # 0x381f9a
leaq 0xd48bc(%rip), %rcx     # 0x381fa4
leaq 0xd4891(%rip), %r8      # 0x381f80
pushq $0x39
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x2ad74b
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
testq %rdi, %rdi
je 0x2ad720
leaq 0xd4868(%rip), %rsi     # 0x381f80
pushq $0x4a
popq %rdx
callq 0x936f9
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x2ad738
leaq 0xd4850(%rip), %rsi     # 0x381f80
pushq $0x4c
popq %rdx
callq 0x936f9
leaq 0xd4841(%rip), %rsi     # 0x381f80
pushq $0x4d
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
movq 0x18a816(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x378b7(%rip), %rsi     # 0x2e5013
leaq 0xd4837(%rip), %rdx     # 0x381f9a
leaq 0xd4848(%rip), %rcx     # 0x381fb2
leaq 0xd480f(%rip), %r8      # 0x381f80
pushq $0x48
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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
pushq %rax
testq %rdi, %rdi
je 0x2adc65
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rdi), %rdi
movzbl %dl, %ebp
movl %ebp, %esi
callq 0x2adaf8
movq 0x8(%r14), %rdx
testq %rdx, %rdx
je 0x2adc47
movb %al, 0x7(%rsp)
movq 0x10(%r14), %rcx
shlq $0x4, %rdx
leaq (%rcx,%rdx), %r12
addq $-0x10, %r12
movl 0x28(%r14), %r15d
movq %r12, %rdi
movl %r15d, %esi
callq 0x2adb40
movq %rax, %r13
movq (%r12), %rax
addq %r13, %rax
cmpq %rbx, %rax
ja 0x2adc98
movq %r12, %rdi
movl %r15d, %esi
callq 0x2adb53
cmpb 0x7(%rsp), %al
jne 0x2adc47
movq (%r12), %rax
addq %r13, %rax
cmpq %rbx, %rax
jne 0x2adc47
cmpq 0x30(%r14), %r13
jae 0x2adc47
incq %r13
movq %r12, %rdi
movq %r13, %rsi
movl %r15d, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2adb2b
pushq $0x1
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
movl %ebp, %ecx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2ad781
movq 0x18a2fc(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x3739d(%rip), %rsi     # 0x2e5013
leaq 0xd431d(%rip), %rdx     # 0x381f9a
leaq 0xd439f(%rip), %rcx     # 0x382023
leaq 0xd42f5(%rip), %r8      # 0x381f80
movl $0xbe, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x2addd2
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
testq %rdx, %rdx
je 0x2add15
movq (%r15), %rax
jmp 0x2add1c
movq 0x8(%r14), %rax
shrq %rax
movq 0x10(%r14), %r13
shlq $0x4, %rax
movq (%r13,%rax), %rbp
cmpq %r12, %rbp
ja 0x2add70
addq %rax, %r13
movl 0x28(%r14), %esi
movq %r13, %rdi
callq 0x2adb40
addq %rbp, %rax
cmpq %r12, %rax
jbe 0x2add6c
pushq $0x1
popq %rbp
testq %rbx, %rbx
je 0x2addc1
movq 0x20(%r14), %r15
movl 0x28(%r14), %esi
movq %r13, %rdi
callq 0x2adb53
movzbl %al, %esi
movq %r15, %rdi
callq 0x2ade0a
movb %al, (%rbx)
jmp 0x2addc1
movq 0x10(%r14), %r13
movq %rsp, %rdi
movq %r12, (%rdi)
movq 0x8(%r14), %rdx
leaq 0xb2(%rip), %r8         # 0x2ade33
pushq $0x10
popq %rcx
movq %r13, %rsi
movq %r14, %r9
callq 0x5fb54
testq %rax, %rax
je 0x2addbf
movq %rax, %r12
testq %rbx, %rbx
je 0x2addaa
movl 0x28(%r14), %esi
movq %r12, %rdi
callq 0x2adb53
movb %al, (%rbx)
pushq $0x1
popq %rbp
testq %r15, %r15
je 0x2addc1
subq 0x10(%r14), %r12
sarq $0x4, %r12
movq %r12, (%r15)
jmp 0x2addc1
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x18a18f(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x37230(%rip), %rsi     # 0x2e5013
leaq 0xd41b0(%rip), %rdx     # 0x381f9a
leaq 0xd426f(%rip), %rcx     # 0x382060
leaq 0xd4188(%rip), %r8      # 0x381f80
movl $0xf3, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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
cmpq %r14, %rbx
jae 0x2ade47
pushq $-0x1
popq %rax
jmp 0x2ade62
movl 0x28(%rdx), %eax
movq %rsi, %rdi
movl %eax, %esi
callq 0x2adb40
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_O2/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 0x2ae0fe
movq -0x10(%rax), %r14
addq $-0x10, %rax
movl 0x28(%rdx), %esi
movq %rax, %rdi
callq 0x2adb40
movq %rax, %rcx
addq %r14, %rcx
xorl %eax, %eax
cmpq %rcx, %rbx
sbbl %eax, %eax
jmp 0x2ae117
movl 0x28(%rdx), %esi
movq %rax, %rdi
callq 0x2adb40
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_O2/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 0x2ae2dd
movq %rsi, %rbx
testq %rsi, %rsi
je 0x2ae2dd
movq %rdi, %r14
addq $0x8, %rdi
movq 0x8(%r14), %r15
pushq $0x8
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
callq 0xb302c
movq 0x10(%r14), %rdi
pushq $0x10
popq %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0xb302c
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %r15
retq
movq 0x189c84(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x36d25(%rip), %rsi     # 0x2e5013
leaq 0xd3db0(%rip), %rdx     # 0x3820a5
leaq 0xd3db9(%rip), %rcx     # 0x3820b5
leaq 0xd3c7d(%rip), %r8      # 0x381f80
movl $0x1cf, %r9d            # imm = 0x1CF
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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:
cmpq $0x0, 0x8(%rdi)
je 0x2ae5e9
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %r15
movq %r8, %rdx
callq 0x2ade6a
testq %rax, %rax
je 0x2ae5db
movq %rax, %r12
movq (%rax), %rbp
cmpq %r13, %rbp
cmovaq %rbp, %r13
movq 0x8(%r15), %rax
movq 0x10(%r15), %rcx
shlq $0x4, %rax
addq %rcx, %rax
addq $-0x10, %rax
movq %rax, 0x10(%rsp)
leaq 0x1(%r14), %rax
movq %rax, 0x8(%rsp)
movq %r14, (%rsp)
cmpq %r14, %r13
ja 0x2ae5db
movl 0x28(%r15), %esi
movq %r12, %rdi
callq 0x2adb40
addq %rbp, %rax
movq 0x8(%rsp), %rcx
movq %rcx, %rbp
cmpq %rcx, %rax
jae 0x2ae5a1
movq %rbx, %r14
movq (%r12), %rbx
movl 0x28(%r15), %esi
movq %r12, %rdi
callq 0x2adb40
movq %rax, %rbp
addq %rbx, %rbp
movq %r14, %rbx
movq (%rsp), %r14
subq %r13, %rbp
movq 0x20(%r15), %r13
movl 0x28(%r15), %esi
movq %r12, %rdi
callq 0x2adb53
movzbl %al, %esi
movq %r13, %rdi
callq 0x2ade0a
movzbl %al, %eax
addq %rbp, (%rbx,%rax,8)
cmpq 0x10(%rsp), %r12
je 0x2ae5db
movq 0x10(%r12), %rbp
addq $0x10, %r12
movq %rbp, %r13
jmp 0x2ae560
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/eis-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 $0x28, %rsp
movq %r8, 0x10(%rsp)
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r15
movl 0x28(%rdi), %ebp
movq %rdi, 0x18(%rsp)
movq %rdx, %rsi
movq %r9, %rdx
callq 0x2ade6a
movq %rax, %r13
addq %r12, %rbx
movq %rbx, 0x20(%rsp)
movl %ebp, 0xc(%rsp)
movq (%r13), %r14
cmpq %r14, %r12
jb 0x2aea45
movq %r13, %rdi
movl %ebp, %esi
callq 0x2adb40
addq %r14, %rax
movq %rbx, %r14
cmpq %rbx, %rax
jae 0x2ae9fc
movq (%r13), %rbx
movq %r13, %rdi
movl %ebp, %esi
callq 0x2adb40
movq %rax, %r14
addq %rbx, %r14
movl %ebp, %esi
movq 0x10(%rsp), %rbp
subl %ebp, %r14d
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rbx
movq %r13, %rdi
callq 0x2adb53
movzbl %al, %esi
movq %rbx, %rdi
callq 0x2ade0a
subq %rbp, %r12
cmpq %r14, %r12
jae 0x2aea33
movb %al, (%r15,%r12)
incq %r12
jmp 0x2aea25
addq 0x10(%rsp), %r14
addq $0x10, %r13
movq 0x20(%rsp), %rbx
movl 0xc(%rsp), %ebp
movq %r14, %r12
cmpq %rbx, %r14
jb 0x2ae9ca
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/eis-seqranges.c
// Function: gt_SRLPrintRangesInfo
int
gt_SRLPrintRangesInfo(struct seqRangeList *rangeList,
                   FILE *fp,
                   GtUword start,
                   GtUword len,
                   seqRangeListSearchHint *hint)
{
  struct seqRange *nextRange;
  GtUword end = start + len;
  unsigned symBits = rangeList->symBits;
  int result = 0;
  gt_assert(rangeList);
  nextRange = gt_SRLFindPositionNext(rangeList, start, hint);
  while (nextRange->startPos < end)
  {
    if (rangeList->partialSymSums)
    {
      size_t numSyms = gt_MRAEncGetSize(rangeList->alphabet);
      size_t pOff = nextRange - rangeList->ranges;
      Symbol sym;
      fputs("# range partial sums:", fp);
      for (sym = 0; sym < numSyms; ++sym)
        fprintf(fp, " sum[%u]="GT_WU"",
                MRAEncRevMapSymbol(rangeList->alphabet, sym),
                rangeList->partialSymSums[pOff * numSyms + sym]);
      fputs("\n", fp);
    }
    if (result +=
        fprintf(fp, "# range overlap: symbol %u, start="GT_WU", length="
                GT_WU"\n", MRAEncRevMapSymbol(rangeList->alphabet,
                                              seqRangeSym(nextRange, symBits)),
                nextRange->startPos, seqRangeLen(nextRange, symBits)) < 0)
    {
      result = -1;
      break;
    }
    ++nextRange;
  }
  return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %r15
addq %rdx, %rcx
movq %rcx, 0x10(%rsp)
movl 0x28(%rdi), %eax
movl %eax, 0xc(%rsp)
movq %rdx, %rsi
movq %r8, %rdx
callq 0x2ade6a
movq %rax, %r12
movq 0x10(%rsp), %rax
cmpq %rax, (%r12)
jae 0x2aeb78
cmpq $0x0, 0x18(%r15)
je 0x2aeb1d
movq 0x20(%r15), %rdi
callq 0x14906a
movzwl %ax, %ebp
movq %r12, %r13
subq 0x10(%r15), %r13
sarq $0x4, %r13
leaq 0xd3622(%rip), %rdi     # 0x3820e7
movq %r14, %rsi
callq 0x17870
imulq %rbp, %r13
xorl %eax, %eax
shlq $0x3, %r13
movzbl %al, %ebx
cmpq %rbp, %rbx
jae 0x2aeb0e
movq 0x20(%r15), %rdi
movl %ebx, %esi
callq 0x2ade0a
movzbl %al, %edx
movq 0x18(%r15), %rax
addq %r13, %rax
movq (%rax,%rbx,8), %rcx
movq %r14, %rdi
leaq 0xd35fb(%rip), %rsi     # 0x3820fd
xorl %eax, %eax
callq 0x17a50
leal 0x1(%rbx), %eax
jmp 0x2aead7
leaq 0xb19da(%rip), %rdi     # 0x3604ef
movq %r14, %rsi
callq 0x17870
movq 0x20(%r15), %rbx
movq %r12, %rdi
movl 0xc(%rsp), %r13d
movl %r13d, %esi
callq 0x2adb53
movzbl %al, %esi
movq %rbx, %rdi
callq 0x2ade0a
movzbl %al, %ebx
movq (%r12), %rbp
movq %r12, %rdi
movl %r13d, %esi
callq 0x2adb40
movq %r14, %rdi
leaq 0xd35b2(%rip), %rsi     # 0x38210a
movl %ebx, %edx
movq %rbp, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x17a50
addq $0x10, %r12
testl %eax, %eax
jns 0x2aea91
pushq $-0x1
popq %rax
jmp 0x2aeb7a
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/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 %rsi, %r14
movq %rdi, %rbx
pushq $0x18
popq %r15
xorl %r12d, %r12d
movq (%rbx), %rdi
cmpq 0x8(%rbx), %r12
jae 0x2aef43
movq (%rdi,%r15), %rdi
movq %r14, %rsi
callq 0x155131
incq %r12
addq $0x20, %r15
jmp 0x2aef25
leaq 0xd3251(%rip), %r14     # 0x38219b
pushq $0x4e
popq %rdx
movq %r14, %rsi
callq 0x936f9
pushq $0x4f
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x936f9
// File: /workspace/github_c_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdx, %rsi
shlq $0x5, %rsi
leaq 0xd2780(%rip), %rdx     # 0x38219b
pushq $0x6a
popq %rcx
callq 0x93472
cmpq %r15, %r14
jbe 0x2afa66
movq %rax, %r12
movq %r15, %rax
shlq $0x5, %rax
leaq (%rax,%r12), %r13
addq $0x18, %r13
cmpq %r14, %r15
jae 0x2afa54
movq %rbx, %rdi
callq 0x1550df
movq %rax, (%r13)
incq %r15
addq $0x20, %r13
jmp 0x2afa3a
testq %r12, %r12
je 0x2afa90
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x1884fb(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x3559c(%rip), %rsi     # 0x2e5013
leaq 0x94fc0(%rip), %rdx     # 0x344a3e
leaq 0xd2763(%rip), %rcx     # 0x3821e8
leaq 0xd270f(%rip), %r8      # 0x38219b
pushq $0x6b
jmp 0x2afab8
movq 0x1884d1(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x35572(%rip), %rsi     # 0x2e5013
leaq 0x94fcc(%rip), %rdx     # 0x344a74
leaq 0xd2739(%rip), %rcx     # 0x3821e8
leaq 0xd26e5(%rip), %r8      # 0x38219b
pushq $0x70
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
imulq $0x18, %rdx, %rsi
leaq 0xd192d(%rip), %rdx     # 0x38222d
pushq $0x3f
popq %rcx
callq 0x93472
movq %rax, %r13
testq %r14, %r14
je 0x2b0939
cmpq %r12, %r15
jbe 0x2b097a
imulq $0x18, %r12, %rax
leaq (%rax,%r13), %rbp
addq $0x10, %rbp
cmpq %r15, %r12
jae 0x2b0939
movq %rbx, %rdi
callq *%r14
movq %rax, (%rbp)
incq %r12
addq $0x18, %rbp
jmp 0x2b0921
testq %r13, %r13
je 0x2b0950
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x187611(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x346b2(%rip), %rsi     # 0x2e5013
leaq 0x9410c(%rip), %rdx     # 0x344a74
leaq 0xd1909(%rip), %rcx     # 0x382278
leaq 0xd18b7(%rip), %r8      # 0x38222d
pushq $0x48
jmp 0x2b09a2
movq 0x1875e7(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x34688(%rip), %rsi     # 0x2e5013
leaq 0x940ac(%rip), %rdx     # 0x344a3e
leaq 0xd18df(%rip), %rcx     # 0x382278
leaq 0xd188d(%rip), %r8      # 0x38222d
pushq $0x42
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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
xorl %r14d, %r14d
xorl %r15d, %r15d
movl 0xc(%rbx), %eax
movq 0x30058(%rbx), %rdi
cmpq %rax, %r15
jae 0x2b1119
addq %r14, %rdi
callq 0x14d148
incq %r15
addq $0x100, %r14            # imm = 0x100
jmp 0x2b10f6
leaq 0xd119b(%rip), %r14     # 0x3822bb
movq %r14, %rsi
movl $0x12f, %edx            # imm = 0x12F
callq 0x936f9
movq 0x30028(%rbx), %rdi
movq %r14, %rsi
movl $0x130, %edx            # imm = 0x130
callq 0x936f9
andq $0x0, 0x30028(%rbx)
cmpl $0x2, 0xc(%rbx)
jb 0x2b115b
leaq 0x30028(%rbx), %rdi
callq 0x2c1035
movq 0x10(%rbx), %rdi
leaq 0xd1155(%rip), %rsi     # 0x3822bb
movl $0x136, %edx            # imm = 0x136
popq %rbx
popq %r14
popq %r15
jmp 0x936f9
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 0x343c2(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x343ca(%rip), %xmm1    # 0x2e78f0
movl %esi, %ebp
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
callq 0x17320
cvttsd2si %xmm0, %r15
addl %ebp, %r15d
incq %r15
pushq $0x1
popq %rax
xorl %r14d, %r14d
movq %rax, %rbp
movl %r15d, %ecx
shlq %cl, %rbp
cmpq %r13, %rbp
setb %dl
movq %r13, %r12
shrq %cl, %r12
cmpq $0x20, %r12
setae %cl
andb %dl, %cl
cmpb $0x1, %cl
je 0x2b3577
decq %r15
jne 0x2b354a
jmp 0x2b35f9
movl %r15d, %r13d
decl %r15d
leaq 0xcefab(%rip), %rsi     # 0x38252f
pushq $0x28
popq %rdi
pushq $0x37
popq %rdx
callq 0x93160
movq %rax, %r14
movl %r15d, 0x20(%rax)
andq $0x0, 0x10(%rax)
movq %rbp, 0x18(%rax)
movq %r12, 0x8(%rax)
pushq $0x10
popq %r15
movl %r13d, %ecx
shlq %cl, %r15
pushq $0x3f
popq %rdx
movq %r15, %rdi
leaq 0xcef75(%rip), %r12     # 0x38252f
movq %r12, %rsi
callq 0x93160
movq %rax, (%r14)
movl 0x20(%r14), %esi
leaq 0xcef7c(%rip), %rdi     # 0x38254c
movq %r15, %rdx
xorl %eax, %eax
callq 0x92a82
movq %r15, (%rsp)
leaq 0x992aa(%rip), %r8      # 0x34c88f
pushq $0x43
popq %rsi
pushq $0x1
popq %rcx
movq %rbx, %rdi
movq %r12, %rdx
movl %ecx, %r9d
callq 0x2b613a
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_O2/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 0x2b367e
movq (%rdi), %rax
testq %rax, %rax
je 0x2b36e0
movq 0x8(%rdi), %rcx
movq 0x10(%rdi), %rdi
addq $0x8, %rax
xorl %r8d, %r8d
movq %rcx, %r9
cmpq %rdi, %r8
jae 0x2b367e
cmpq %rdx, %r9
jae 0x2b367e
cmpq -0x8(%rax), %r9
jne 0x2b36aa
movq (%rax), %r10
cmpq (%rsi,%r9,8), %r10
jne 0x2b3680
addq %rcx, %r9
incq %r8
addq $0x10, %rax
jmp 0x2b3659
popq %rax
retq
movq 0x1848e1(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x31982(%rip), %rsi     # 0x2e5013
leaq 0xcef68(%rip), %rdx     # 0x382600
leaq 0xcef00(%rip), %rcx     # 0x38259f
leaq 0xcee89(%rip), %r8      # 0x38252f
pushq $0x77
jmp 0x2b36d2
movq 0x1848b7(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x31958(%rip), %rsi     # 0x2e5013
leaq 0xcef00(%rip), %rdx     # 0x3825c2
leaq 0xceed6(%rip), %rcx     # 0x38259f
leaq 0xcee5f(%rip), %r8      # 0x38252f
pushq $0x75
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
movq 0x184881(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x31922(%rip), %rsi     # 0x2e5013
leaq 0xcee7a(%rip), %rdx     # 0x382572
leaq 0xceea0(%rip), %rcx     # 0x38259f
leaq 0xcee29(%rip), %r8      # 0x38252f
pushq $0x71
jmp 0x2b36d2
// File: /workspace/github_c_makefile_star2_O2/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 0x2b3780
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpq $0x0, (%rdi)
je 0x2b3767
andq $0x0, (%rsp)
leaq 0xcee06(%rip), %rdx     # 0x38252f
leaq 0x9915f(%rip), %r8      # 0x34c88f
pushq $0x1
popq %r9
movq %rsi, %rdi
movl $0x84, %esi
xorl %ecx, %ecx
callq 0x2b613a
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2b3767
leaq 0xceddd(%rip), %rsi     # 0x38252f
movl $0x85, %edx
callq 0x936f9
andq $0x0, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
leaq 0xcedc1(%rip), %rsi     # 0x38252f
movq %rbx, %rdi
movl $0x87, %edx
addq $0x10, %rsp
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xcc81a(%rip), %rsi     # 0x382832
pushq $0x40
popq %rdi
pushq $0x34
popq %rdx
callq 0x93160
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movb $0x0, 0x20(%rax)
movups %xmm0, 0x28(%rax)
andq $0x0, 0x38(%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x20
popq %r12
xorl %eax, %eax
leaq 0x2f6e1(%rip), %rbp     # 0x2e575f
leaq 0xcc7cd(%rip), %r15     # 0x382852
xorl %r13d, %r13d
cmpq 0x30(%rbx), %r13
jae 0x2b60da
movq 0x28(%rbx), %rdi
movq -0x8(%rdi,%r12), %rsi
testq %rsi, %rsi
je 0x2b60d1
movq -0x20(%rdi,%r12), %rdx
movl -0x18(%rdi,%r12), %ecx
cmpb $0x0, (%rdi,%r12)
movq -0x10(%rdi,%r12), %r8
movq %rbp, %r9
leaq 0xcc7a9(%rip), %rax     # 0x382863
cmovneq %rax, %r9
movq %rsi, (%rsp)
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x17a50
movb $0x1, %al
incq %r13
addq $0x28, %r12
jmp 0x2b6088
andb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/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 0x2b6139
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movsd 0x18(%rdi), %xmm0
leaq 0xcc765(%rip), %rdi     # 0x382868
movb $0x1, %al
callq 0x92a82
movq 0x28(%rbx), %rdi
leaq 0xcc71d(%rip), %r14     # 0x382832
movq %r14, %rsi
movl $0xa5, %edx
callq 0x936f9
movq %rbx, %rdi
movq %r14, %rsi
movl $0xa6, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x2b6506
movq %rax, %xmm1
punpckldq 0x31408(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
movq %rax, 0x10(%rdi)
subpd 0x3140c(%rip), %xmm1    # 0x2e78f0
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
mulsd 0x31408(%rip), %xmm0    # 0x2e7900
leaq 0xcc508(%rip), %rdi     # 0x382a07
movb $0x1, %al
jmp 0x92a82
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
testq %rcx, %rcx
je 0x2b6aec
movq %rcx, %rax
movq %rdi, %rbx
movq 0x38(%rdi), %rcx
testq %rcx, %rcx
je 0x2b6aac
cmpq $0xff, %rax
ja 0x2b6ac3
movb %al, (%rcx,%rdx)
jmp 0x2b6aea
cmpq %rax, 0x60(%rbx)
jae 0x2b6ae0
movq 0x58(%rbx), %rcx
andq %rcx, (%rsi,%rdx,8)
movq 0x40(%rbx), %rdi
subl 0x60(%rbx), %eax
jmp 0x2b6ad0
movb $0x0, (%rcx,%rdx)
movq 0x40(%rbx), %rdi
addl $0xffffff01, %eax       # imm = 0xFFFFFF01
movq %rdx, %rsi
movl %eax, %edx
callq 0x2b7753
incq 0x18(%rbx)
jmp 0x2b6aea
movb 0x68(%rbx), %cl
shlq %cl, %rax
orq %rax, (%rsi,%rdx,8)
popq %rbx
retq
movq 0x181475(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2e516(%rip), %rsi     # 0x2e5013
leaq 0x49228(%rip), %rdx     # 0x2ffd2c
leaq 0xcc3e6(%rip), %rcx     # 0x382ef1
leaq 0xcbfb8(%rip), %r8      # 0x382aca
pushq $0x41
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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
cmpq %rdx, %r9
jae 0x2b6bd9
movq %r9, %r14
movq %r8, %r13
movq %rcx, %rbp
movq %rdx, %r15
movq 0x50(%rsp), %rbx
decq %r15
xorl %eax, %eax
xorl %r12d, %r12d
cmpq %r13, %rbp
ja 0x2b6bb1
cmpq %rbx, (%rbp)
ja 0x2b6b6c
sete %cl
movzbl %cl, %ecx
addq %rcx, %r12
addq $0x8, %rbp
jmp 0x2b6b52
testq %r12, %r12
movq %rsi, 0x10(%rsp)
movq %rdi, 0x8(%rsp)
je 0x2b6b91
movq %r14, %rdx
movq %rax, (%rsp)
movq %r12, %rcx
callq 0x2b6c11
movq (%rsp), %rax
addq %r12, %rax
cmpq %r15, %r14
jae 0x2b6bca
movq 0x8(%rsp), %rdi
movq 0x58(%rdi), %rcx
movq 0x10(%rsp), %rsi
andq 0x8(%rsi,%r14,8), %rcx
incq %r14
addq %rcx, %rbx
jmp 0x2b6b4f
testq %r12, %r12
je 0x2b6bca
movq %r14, %rdx
movq %rax, %rbx
movq %r12, %rcx
callq 0x2b6c11
movq %rbx, %rax
addq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x181388(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2e429(%rip), %rsi     # 0x2e5013
leaq 0xcbfce(%rip), %rdx     # 0x382bbf
leaq 0xcbfe5(%rip), %rcx     # 0x382bdd
leaq 0xcbecb(%rip), %r8      # 0x382aca
movl $0x172, %r9d            # imm = 0x172
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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
movq %rdi, %rbx
movq 0x38(%rdi), %rax
testq %rax, %rax
je 0x2b740f
movzbl (%rax,%rdx), %eax
testl %eax, %eax
jne 0x2b7434
movq 0x40(%rbx), %rdi
movq %rdx, %rsi
callq 0x2b7784
testq %rax, %rax
je 0x2b7436
movq %rax, %rcx
movl $0xff, %eax
addl (%rcx), %eax
jmp 0x2b7434
movq (%rsi,%rdx,8), %rax
movb 0x68(%rbx), %cl
shrq %cl, %rax
testq %rax, %rax
jne 0x2b7434
movq 0x40(%rbx), %rdi
movq %rdx, %rsi
callq 0x2b7784
testq %rax, %rax
je 0x2b7464
movl (%rax), %eax
addl 0x60(%rbx), %eax
popq %rbx
retq
movq 0x180b2b(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2dbcc(%rip), %rsi     # 0x2e5013
leaq 0xcbb11(%rip), %rdx     # 0x382f5f
leaq 0xcbb1b(%rip), %rcx     # 0x382f70
leaq 0xcb66e(%rip), %r8      # 0x382aca
movl $0x1b2, %r9d            # imm = 0x1B2
jmp 0x2b7490
movq 0x180afd(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x2db9e(%rip), %rsi     # 0x2e5013
leaq 0xcbae3(%rip), %rdx     # 0x382f5f
leaq 0xcbaed(%rip), %rcx     # 0x382f70
leaq 0xcb640(%rip), %r8      # 0x382aca
movl $0x1a6, %r9d            # imm = 0x1A6
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x2b750b
movq 0x70(%rdi), %rdx
cmpq %rsi, (%rdx,%rcx,8)
jae 0x2b7508
incq %rcx
jmp 0x2b74f4
movq %rcx, %rax
movq 0x30(%rdi), %rcx
movl (%rcx,%rsi,4), %ecx
shlq $0x20, %rax
orq %rcx, %rax
retq