LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-blockcomp.c
// Function: deleteBlockEncIdxSeq
static void
deleteBlockEncIdxSeq(struct encIdxSeq *seq)
{
  struct blockCompositionSeq *bseq;
  gt_assert(seq && seq->classInfo == &blockCompositionSeqClass);
  bseq = encIdxSeq2blockCompositionSeq(seq);
  gt_free(bseq->extHeaderPos);
  gt_free(bseq->partialSymSumBits);
  destructOnDiskBlockCompIdx(&bseq->externalData);
  gt_destructCompositionList(&bseq->compositionTable);
  gt_MRAEncDelete(bseq->baseClass.alphabet);
  gt_MRAEncDelete(bseq->rangeMapAlphabet);
  gt_MRAEncDelete(bseq->blockMapAlphabet);
  gt_deleteSeqRangeList(bseq->rangeEncs);
  gt_free(bseq->modes);
  gt_free(bseq);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x4aa2e2
movq 0x10(%rsp), %rax
leaq 0x191933(%rip), %rcx    # 0x63bc10
cmpq %rcx, (%rax)
je 0x4aa31a
movq 0x191cb7(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x6bd20(%rip), %rsi     # 0x516013
leaq 0x10c492(%rip), %rdx    # 0x5b678c
leaq 0x10c4be(%rip), %rcx    # 0x5b67bf
leaq 0x10bc00(%rip), %r8     # 0x5b5f08
movl $0x295, %r9d            # imm = 0x295
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4aa31c
movq 0x10(%rsp), %rdi
callq 0x4ac370
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x78(%rax), %rdi
leaq 0x10bbcd(%rip), %rsi    # 0x5b5f08
movl $0x297, %edx            # imm = 0x297
callq 0xe88c0
movq 0x8(%rsp), %rax
movq 0xd0(%rax), %rdi
leaq 0x10bbb0(%rip), %rsi    # 0x5b5f08
movl $0x298, %edx            # imm = 0x298
callq 0xe88c0
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
callq 0x4a6560
movq 0x8(%rsp), %rdi
addq $0x48, %rdi
callq 0x4af220
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x22b660
movq 0x8(%rsp), %rax
movq 0xa0(%rax), %rdi
callq 0x22b660
movq 0x8(%rsp), %rax
movq 0x98(%rax), %rdi
callq 0x22b660
movq 0x8(%rsp), %rax
movq 0x70(%rax), %rdi
callq 0x4afea0
movq 0x8(%rsp), %rax
movq 0xa8(%rax), %rdi
leaq 0x10bb39(%rip), %rsi    # 0x5b5f08
movl $0x29f, %edx            # imm = 0x29F
callq 0xe88c0
movq 0x8(%rsp), %rdi
leaq 0x10bb23(%rip), %rsi    # 0x5b5f08
movl $0x2a0, %edx            # imm = 0x2A0
callq 0xe88c0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-blockcomp.c
// Function: blockCompSeqGet
static Symbol
blockCompSeqGet(struct encIdxSeq *seq, GtUword pos, union EISHint *hint)
{
  Symbol sym;
  struct blockCompositionSeq *seqIdx;
  unsigned blockSize;
  gt_assert(seq && seq->classInfo == &blockCompositionSeqClass);
  if (pos >= seq->seqLen)
    return ~(Symbol)0;
  seqIdx = encIdxSeq2blockCompositionSeq(seq);
  blockSize = seqIdx->blockSize;
  {
    Symbol block[blockSize];
    blockCompSeqGetBlock(seqIdx, pos/blockSize, &(hint->bcHint), 1, NULL,
                         block);
    sym = block[pos%blockSize];
  }
  return sym;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x4aba0b
movq -0x10(%rbp), %rax
leaq 0x19020a(%rip), %rcx    # 0x63bc10
cmpq %rcx, (%rax)
je 0x4aba43
movq 0x19058e(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x6a5f7(%rip), %rsi     # 0x516013
leaq 0x10ad69(%rip), %rdx    # 0x5b678c
leaq 0x10b07a(%rip), %rcx    # 0x5b6aa4
leaq 0x10a4d7(%rip), %r8     # 0x5b5f08
movl $0x619, %r9d            # imm = 0x619
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4aba45
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jb 0x4aba5c
movb $-0x1, -0x1(%rbp)
jmp 0x4abae5
movq -0x10(%rbp), %rdi
callq 0x4ac370
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl 0xb4(%rax), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movq %rsp, %rcx
movq %rcx, -0x40(%rbp)
movq %rax, %rcx
addq $0xf, %rcx
andq $-0x10, %rcx
movq %rsp, %r9
subq %rcx, %r9
movq %r9, -0x50(%rbp)
movq %r9, %rsp
movq %rax, -0x48(%rbp)
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rax
movl -0x34(%rbp), %ecx
xorl %edx, %edx
divq %rcx
movq %rax, %rsi
movq -0x20(%rbp), %rdx
movl $0x1, %ecx
xorl %eax, %eax
movl %eax, %r8d
callq 0x4ad340
movq -0x18(%rbp), %rax
movl -0x34(%rbp), %ecx
xorl %edx, %edx
divq %rcx
movq -0x50(%rbp), %rax
movb (%rax,%rdx), %al
movb %al, -0x21(%rbp)
movq -0x40(%rbp), %rax
movq %rax, %rsp
movb -0x21(%rbp), %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
movq %rbp, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-blockcomp.c
// Function: newBlockCompSeqHint
static union EISHint *
newBlockCompSeqHint(const struct encIdxSeq *seq)
{
  union EISHint *hintret;
  const struct blockCompositionSeq *seqIdx;
  gt_assert(seq && seq->classInfo == &blockCompositionSeqClass);
  seqIdx = constEncIdxSeq2blockCompositionSeq(seq);
  hintret = gt_malloc(sizeof (union EISHint));
  gt_SRLInitListSearchHint(seqIdx->rangeEncs, &hintret->bcHint.rangeHint);
  /* FIXME: make cache size user-configurable */
  initSuperBlockSeqCache(&hintret->bcHint.sBlockCache, seqIdx, 32);
  return hintret;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x4abb12
movq 0x10(%rsp), %rax
leaq 0x190103(%rip), %rcx    # 0x63bc10
cmpq %rcx, (%rax)
je 0x4abb4a
movq 0x190487(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x6a4f0(%rip), %rsi     # 0x516013
leaq 0x10ac62(%rip), %rdx    # 0x5b678c
leaq 0x10af98(%rip), %rcx    # 0x5b6ac9
leaq 0x10a3d0(%rip), %r8     # 0x5b5f08
movl $0x9bf, %r9d            # imm = 0x9BF
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4abb4c
movq 0x10(%rsp), %rdi
callq 0x4ad5e0
movq %rax, (%rsp)
movl $0x28, %edi
leaq 0x10a3a2(%rip), %rsi    # 0x5b5f08
movl $0x9c1, %edx            # imm = 0x9C1
callq 0xe80f0
movq %rax, 0x8(%rsp)
movq (%rsp), %rax
movq 0x70(%rax), %rdi
movq 0x8(%rsp), %rsi
addq $0x20, %rsi
callq 0x4b08e0
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
movl $0x20, %edx
callq 0x4ad640
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-blockcomp.c
// Function: deleteBlockCompSeqHint
static void
deleteBlockCompSeqHint(struct encIdxSeq *seq, union EISHint *hint)
{
  GT_UNUSED struct blockCompositionSeq *seqIdx;
  gt_assert(seq && seq->classInfo == &blockCompositionSeqClass);
  seqIdx = encIdxSeq2blockCompositionSeq(seq);
  destructSuperBlockSeqCache(&hint->bcHint.sBlockCache);
  gt_free(hint);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x4abbd7
movq 0x10(%rsp), %rax
leaq 0x19003e(%rip), %rcx    # 0x63bc10
cmpq %rcx, (%rax)
je 0x4abc0f
movq 0x1903c2(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x6a42b(%rip), %rsi     # 0x516013
leaq 0x10ab9d(%rip), %rdx    # 0x5b678c
leaq 0x10af37(%rip), %rcx    # 0x5b6b2d
leaq 0x10a30b(%rip), %r8     # 0x5b5f08
movl $0x9cc, %r9d            # imm = 0x9CC
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4abc11
movq 0x10(%rsp), %rdi
callq 0x4ac370
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
callq 0x4ad7d0
movq 0x8(%rsp), %rdi
leaq 0x10a2d3(%rip), %rsi    # 0x5b5f08
movl $0x9cf, %edx            # imm = 0x9CF
callq 0xe88c0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-blockcomp.c
// Function: seekToHeader
static FILE *
seekToHeader(const struct encIdxSeq *seqIdx, uint16_t headerID,
             uint32_t *lenRet)
{
  const struct blockCompositionSeq *bSeqIdx;
  size_t i;
  uint32_t query = headerID | EH_HEADER_PREFIX;
  gt_assert(seqIdx);
  bSeqIdx =
    constEncIdxSeq2blockCompositionSeq(seqIdx);
  for (i = 0; i < bSeqIdx->numExtHeaders; ++i)
  {
    if (bSeqIdx->extHeaderPos[i].headerID == query)
    {
      uint32_t headerPrefix[2];
      if (lenRet)
      {
        if (fseeko(bSeqIdx->externalData.idxFP,
                   bSeqIdx->extHeaderPos[i].pos - EXT_HEADER_PREFIX_SIZE,
                   SEEK_SET))
           return NULL;
        if (fread(headerPrefix, sizeof (headerPrefix[0]), 2,
                  bSeqIdx->externalData.idxFP) != 2)
          return NULL;
        *lenRet = headerPrefix[1];
      }
      else
        if (fseeko(bSeqIdx->externalData.idxFP, bSeqIdx->extHeaderPos[i].pos,
                   SEEK_SET))
          return NULL;
      return bSeqIdx->externalData.idxFP;
    }
  }
  return NULL;
}

// Assembly:
subq $0x48, %rsp
movw %si, %ax
movq %rdi, 0x38(%rsp)
movw %ax, 0x36(%rsp)
movq %rdx, 0x28(%rsp)
movzwl 0x36(%rsp), %eax
orl $0x45480000, %eax       # imm = 0x45480000
movl %eax, 0x14(%rsp)
cmpq $0x0, 0x38(%rsp)
jne 0x4abfd4
movq 0x18fffd(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x6a066(%rip), %rsi     # 0x516013
leaq 0x10a703(%rip), %rdx    # 0x5b66b7
leaq 0x10ab9c(%rip), %rcx    # 0x5b6b57
leaq 0x109f46(%rip), %r8     # 0x5b5f08
movl $0x954, %r9d            # imm = 0x954
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4abfd6
movq 0x38(%rsp), %rdi
callq 0x4ad5e0
movq %rax, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
cmpq 0x80(%rcx), %rax
jae 0x4ac108
movq 0x20(%rsp), %rax
movq 0x78(%rax), %rax
movq 0x18(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
cmpl 0x14(%rsp), %eax
jne 0x4ac0f3
cmpq $0x0, 0x28(%rsp)
je 0x4ac0a9
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x20(%rsp), %rax
movq 0x78(%rax), %rax
movq 0x18(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
subq $0x8, %rsi
xorl %edx, %edx
callq 0x19c10
cmpl $0x0, %eax
je 0x4ac06e
movq $0x0, 0x40(%rsp)
jmp 0x4ac111
leaq 0xc(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rcx
movl $0x4, %esi
movl $0x2, %edx
callq 0x19a70
cmpq $0x2, %rax
je 0x4ac09c
movq $0x0, 0x40(%rsp)
jmp 0x4ac111
movl 0x10(%rsp), %ecx
movq 0x28(%rsp), %rax
movl %ecx, (%rax)
jmp 0x4ac0e3
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x20(%rsp), %rax
movq 0x78(%rax), %rax
movq 0x18(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
xorl %edx, %edx
callq 0x19c10
cmpl $0x0, %eax
je 0x4ac0e1
movq $0x0, 0x40(%rsp)
jmp 0x4ac111
jmp 0x4ac0e3
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x40(%rsp)
jmp 0x4ac111
jmp 0x4ac0f5
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x4abfee
movq $0x0, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-blockcomp.c
// Function: printBlockEncPosDiags
static int
printBlockEncPosDiags(const EISeq *seq, GtUword pos, FILE *fp,
                      EISHint hint)
{
  const struct blockCompositionSeq *seqIdx;
  int outCount = 0;
  GtUword bucketNum;
  gt_assert(seq && seq->classInfo == &blockCompositionSeqClass);
  seqIdx = constEncIdxSeq2blockCompositionSeq(seq);
  bucketNum = bucketNumFromPos(seqIdx, pos);
  fputs("##################################################\n"
        "# This bucket:\n"
        "##################################################\n", fp);
  outCount += printBucket(seqIdx, bucketNum, BUCKET_PLAIN, fp, hint);
  if (bucketNum)
  {
    fputs("##################################################\n"
          "# Previous bucket:\n"
          "##################################################\n", fp);
    outCount += printBucket(seqIdx, bucketNum - 1, BUCKET_PLAIN, fp, hint);
  }
  if (bucketNum < bucketNumFromPos(seqIdx, EISLength(seq)))
  {
    fputs("##################################################\n"
          "# Next bucket:\n"
          "##################################################\n", fp);
    outCount += printBucket(seqIdx, bucketNum + 1, BUCKET_PLAIN, fp, hint);
  }
  return outCount;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movl $0x0, 0x1c(%rsp)
cmpq $0x0, 0x40(%rsp)
je 0x4ac159
movq 0x40(%rsp), %rax
leaq 0x18fabc(%rip), %rcx    # 0x63bc10
cmpq %rcx, (%rax)
je 0x4ac191
movq 0x18fe40(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x69ea9(%rip), %rsi     # 0x516013
leaq 0x10a61b(%rip), %rdx    # 0x5b678c
leaq 0x10a9ec(%rip), %rcx    # 0x5b6b64
leaq 0x109d89(%rip), %r8     # 0x5b5f08
movl $0xa87, %r9d            # imm = 0xA87
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4ac193
movq 0x40(%rsp), %rdi
callq 0x4ad5e0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x4ac3d0
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rsi
leaq 0x10a9b8(%rip), %rdi    # 0x5b6b7a
callq 0x19810
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x30(%rsp), %rcx
movq 0x28(%rsp), %r8
xorl %edx, %edx
callq 0x4ad8a0
addl 0x1c(%rsp), %eax
movl %eax, 0x1c(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x4ac22a
movq 0x30(%rsp), %rsi
leaq 0x10a9f2(%rip), %rdi    # 0x5b6bf0
callq 0x19810
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
subq $0x1, %rsi
movq 0x30(%rsp), %rcx
movq 0x28(%rsp), %r8
xorl %edx, %edx
callq 0x4ad8a0
addl 0x1c(%rsp), %eax
movl %eax, 0x1c(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x40(%rsp), %rdi
callq 0x4ad5b0
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x4ac3d0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x4ac298
movq 0x30(%rsp), %rsi
leaq 0x10a9fe(%rip), %rdi    # 0x5b6c6a
callq 0x19810
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
addq $0x1, %rsi
movq 0x30(%rsp), %rcx
movq 0x28(%rsp), %r8
xorl %edx, %edx
callq 0x4ad8a0
addl 0x1c(%rsp), %eax
movl %eax, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-blockcomp.c
// Function: displayBlockEncBlock
static int
displayBlockEncBlock(const EISeq *seq, GtUword pos, FILE *fp,
                     EISHint hint)
{
  const struct blockCompositionSeq *seqIdx;
  int outCount;
  GtUword bucketNum;
  gt_assert(seq && seq->classInfo == &blockCompositionSeqClass);
  seqIdx = constEncIdxSeq2blockCompositionSeq(seq);
  bucketNum = bucketNumFromPos(seqIdx, pos);
  outCount = printBucket(seqIdx, bucketNum, BUCKET_PRINT_BITSTRING_SEPARATOR
                         | BUCKET_PRINT_BITSTRING | BUCKET_PRINT_BITSIZES
                         | BUCKET_PRINT_RANGES_OVERLAY, fp, hint);
  return outCount;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x4ac2e1
movq 0x30(%rsp), %rax
leaq 0x18f934(%rip), %rcx    # 0x63bc10
cmpq %rcx, (%rax)
je 0x4ac319
movq 0x18fcb8(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x69d21(%rip), %rsi     # 0x516013
leaq 0x10a493(%rip), %rdx    # 0x5b678c
leaq 0x10abf2(%rip), %rcx    # 0x5b6ef2
leaq 0x109c01(%rip), %r8     # 0x5b5f08
movl $0xaa6, %r9d            # imm = 0xAA6
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4ac31b
movq 0x30(%rsp), %rdi
callq 0x4ad5e0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x4ac3d0
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %r8
movl $0xf, %edx
callq 0x4ad8a0
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-blockcomp.c
// Function: cacheFetchSuperBlock
static struct superBlock *
cacheFetchSuperBlock(const struct blockCompositionSeq *seqIdx,
                     GtUword superBlockNum, struct seqCache *sBlockCache)
{
  size_t cachePos = pos2CachePos(sBlockCache, superBlockNum);
  if (inSeqCache(sBlockCache, superBlockNum))
    return (struct superBlock *)sBlockCache->entriesPtr[cachePos];
  else
  {
    struct superBlock *sb =
      (struct superBlock *)sBlockCache->entriesPtr[cachePos];
    return fetchSuperBlock(seqIdx, superBlockNum, sb);
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x4ac7c0
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x4ac7e0
cmpl $0x0, %eax
je 0x4ac454
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x30(%rsp)
jmp 0x4ac484
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x4ac830
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-seqblocktranslate.h
// Function: symCountFromComposition
static inline unsigned
symCountFromComposition(struct compList *compositionTable,
                        unsigned alphabetSize,
                        PermCompIndex compIndex, Symbol sym)
{
  BitOffset bitsPerComp, bitsPerCount;
  gt_assert(compositionTable);
  bitsPerCount = compositionTable->bitsPerCount;
  bitsPerComp = bitsPerCount * alphabetSize;
  gt_assert(compIndex < compositionTable->numCompositions);
  return gt_bsGetUInt(compositionTable->catCompsPerms,
                   compIndex * bitsPerComp + sym * bitsPerCount,
                   bitsPerCount);
}

// Assembly:
subq $0x28, %rsp
movb %cl, %al
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movb %al, 0x17(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x4ac5c7
movq 0x18fa0a(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x69a73(%rip), %rsi     # 0x516013
leaq 0x10a36b(%rip), %rdx    # 0x5b6912
leaq 0x10a375(%rip), %rcx    # 0x5b6923
leaq 0x10a386(%rip), %r8     # 0x5b693b
movl $0xb3, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4ac5c9
movq 0x20(%rsp), %rax
movl 0x18(%rax), %eax
movq %rax, (%rsp)
movq (%rsp), %rax
movl 0x1c(%rsp), %ecx
imulq %rcx, %rax
movq %rax, 0x8(%rsp)
movl 0x18(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpq (%rcx), %rax
jb 0x4ac62c
movq 0x18f9a5(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x69a0e(%rip), %rsi     # 0x516013
leaq 0x10a391(%rip), %rdx    # 0x5b699d
leaq 0x10a310(%rip), %rcx    # 0x5b6923
leaq 0x10a321(%rip), %r8     # 0x5b693b
movl $0xb6, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4ac62e
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rdi
movl 0x18(%rsp), %eax
movl %eax, %esi
imulq 0x8(%rsp), %rsi
movzbl 0x17(%rsp), %eax
imulq (%rsp), %rax
addq %rax, %rsi
movq (%rsp), %rax
movl %eax, %edx
callq 0x473e40
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-blockcomp.c
// Function: adjustPosRankForBlock
static inline GtUword
adjustPosRankForBlock(struct blockCompositionSeq *seqIdx,
                      struct superBlock *sBlock, GtUword pos, Symbol bSym,
                      unsigned blockSize, GtUword preBlockRankCount,
                      BitOffset cwIdxMemOffset, BitOffset varDataMemOffset,
                      unsigned bitsPerCompositionIdx)
{
  GtUword rankCount = preBlockRankCount;
  unsigned inBlockPos;
  if ((inBlockPos = pos % blockSize)
      && symCountFromComposition(
        &seqIdx->compositionTable, seqIdx->blockMapAlphabetSize,
        gt_bsGetPermCompIndex(sBlock->cwData, cwIdxMemOffset,
                           bitsPerCompositionIdx), bSym))
  {
    Symbol block[blockSize];
    unsigned i;
    unpackBlock(seqIdx, sBlock, cwIdxMemOffset, varDataMemOffset, block,
                inBlockPos);
    for (i = 0; i < inBlockPos; ++i)
    {
      if (block[i] == bSym)
        ++rankCount;
    }
  }
  return rankCount;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movb %cl, %al
movl 0x20(%rbp), %ecx
movq 0x18(%rbp), %rcx
movq 0x10(%rbp), %rcx
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb %al, -0x19(%rbp)
movl %r8d, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
movl -0x20(%rbp), %ecx
xorl %edx, %edx
divq %rcx
movl %edx, %eax
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
je 0x4ac778
movq -0x8(%rbp), %rax
addq $0x48, %rax
movq %rax, -0x58(%rbp)
movq -0x8(%rbp), %rax
movzwl 0xc4(%rax), %eax
movl %eax, -0x50(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq 0x10(%rbp), %rsi
movl 0x20(%rbp), %edx
callq 0x473e40
movq -0x58(%rbp), %rdi
movl -0x50(%rbp), %esi
movl %eax, %edx
movzbl -0x19(%rbp), %ecx
callq 0x4ac570
cmpl $0x0, %eax
je 0x4ac778
movl -0x20(%rbp), %eax
movq %rsp, %rcx
movq %rcx, -0x40(%rbp)
movq %rax, %rcx
addq $0xf, %rcx
andq $-0x10, %rcx
movq %rsp, %r8
subq %rcx, %r8
movq %r8, -0x60(%rbp)
movq %r8, %rsp
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq 0x10(%rbp), %rdx
movq 0x18(%rbp), %rcx
movl -0x34(%rbp), %r9d
callq 0x4aced0
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
cmpl -0x34(%rbp), %eax
jae 0x4ac771
movq -0x60(%rbp), %rax
movl -0x4c(%rbp), %ecx
movzbl (%rax,%rcx), %eax
movzbl -0x19(%rbp), %ecx
cmpl %ecx, %eax
jne 0x4ac764
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x4ac766
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x4ac73d
movq -0x40(%rbp), %rax
movq %rax, %rsp
movq -0x30(%rbp), %rax
movq %rbp, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-blockcomp.c
// Function: superBlockMemSize
static inline size_t
superBlockMemSize(const struct blockCompositionSeq *seqIdx)
{
  if (seqIdxUsesMMap(seqIdx))
  {
    return sizeof (struct superBlock);
  }
  else
  {
    size_t offset;
    offset = offsetAlign(sizeof (struct superBlock), sizeof (BitElem));
    offset = offsetAlign(offset + superBlockCWMaxReadSize(seqIdx),
                         sizeof (BitElem));
    offset += superBlockVarMaxReadSize(seqIdx);
    return offsetAlign(offset, MAX_ALIGN_REQUIREMENT);
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x4acc10
cmpl $0x0, %eax
je 0x4acd13
movq $0x18, 0x20(%rsp)
jmp 0x4acd7a
movl $0x18, %edi
movl $0x1, %esi
callq 0x4ace30
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x4acc80
movq 0x8(%rsp), %rdi
addq %rax, %rdi
movl $0x1, %esi
callq 0x4ace30
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x4accd0
addq 0x10(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x8, %esi
callq 0x4ace30
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-blockcomp.c
// Function: initEmptySuperBlock
static inline void
initEmptySuperBlock(struct superBlock *sBlock,
                    const struct blockCompositionSeq *seqIdx)
{
  if (!seqIdxUsesMMap(seqIdx))
  {
    size_t offset;
    sBlock->cwData = (BitString)
      ((char *)sBlock + (offset = offsetAlign(sizeof (*sBlock),
                                              sizeof (BitElem))));
    sBlock->varData = (BitString)
      ((char *)sBlock + (offset = offsetAlign(offset
                                              + superBlockCWMaxReadSize(seqIdx),
                                              sizeof (BitElem))));
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x4acc10
cmpl $0x0, %eax
jne 0x4ace22
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x18, %edi
movl $0x1, %esi
callq 0x4ace30
movq 0x8(%rsp), %rcx
movq %rax, 0x20(%rsp)
addq %rax, %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
callq 0x4acc80
movq 0x10(%rsp), %rdi
addq %rax, %rdi
movl $0x1, %esi
callq 0x4ace30
movq 0x18(%rsp), %rcx
movq %rax, 0x20(%rsp)
addq %rax, %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x8(%rax)
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-blockcomp.c
// Function: unpackBlock
static inline void
unpackBlock(const struct blockCompositionSeq *seqIdx,
            const struct superBlock *sBlock,
            BitOffset cwOffset, BitOffset varOffset, Symbol *block,
            unsigned sublen)
{
  unsigned varIdxBits, bitsPerCompositionIdx;
  PermCompIndex compIndex, permIndex;
  bitsPerCompositionIdx = seqIdx->compositionTable.compositionIdxBits;
  compIndex = gt_bsGetPermCompIndex(sBlock->cwData, cwOffset,
                                 bitsPerCompositionIdx);
  varIdxBits = seqIdx->compositionTable.permutations[compIndex].permIdxBits;
  permIndex = gt_bsGetPermCompIndex(sBlock->varData, varOffset, varIdxBits);
  indexPair2block(&seqIdx->compositionTable, seqIdx->blockSize,
                  compIndex, permIndex, block, sublen);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movl %r9d, 0x1c(%rsp)
movq 0x40(%rsp), %rax
movl 0x68(%rax), %eax
movl %eax, 0x14(%rsp)
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x30(%rsp), %rsi
movl 0x14(%rsp), %edx
callq 0x473e40
movl %eax, 0x10(%rsp)
movq 0x40(%rsp), %rax
movq 0x50(%rax), %rax
movl 0x10(%rsp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movl %eax, 0x18(%rsp)
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x28(%rsp), %rsi
movl 0x18(%rsp), %edx
callq 0x473e40
movl %eax, 0xc(%rsp)
movq 0x40(%rsp), %rdi
addq $0x48, %rdi
movq 0x40(%rsp), %rax
movl 0xb4(%rax), %esi
movl 0x10(%rsp), %edx
movl 0xc(%rsp), %ecx
movq 0x20(%rsp), %r8
movl 0x1c(%rsp), %r9d
callq 0x4acf80
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-seqblocktranslate.h
// Function: indexPair2block
static inline void
indexPair2block(const struct compList *compositionTable, unsigned blockSize,
                PermCompIndex compIdx, PermCompIndex permIdx,
                Symbol *block, unsigned subLen)
{
  unsigned bitsPerPermutation;
  struct permList *permutationList;
  gt_assert(compositionTable && block);
  gt_assert(subLen <= blockSize);
  bitsPerPermutation = compositionTable->bitsPerSymbol * blockSize;
  permutationList = compositionTable->permutations + compIdx;
  gt_bsGetUniformSymbolArray(
    compositionTable->catCompsPerms,
    permutationList->catPermsOffset + bitsPerPermutation * permIdx,
    compositionTable->bitsPerSymbol, subLen, block);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl %edx, 0x28(%rsp)
movl %ecx, 0x24(%rsp)
movq %r8, 0x18(%rsp)
movl %r9d, 0x14(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x4acfaf
cmpq $0x0, 0x18(%rsp)
jne 0x4acfe7
movq 0x18efea(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x69053(%rip), %rsi     # 0x516013
leaq 0x109a04(%rip), %rdx    # 0x5b69cb
leaq 0x109a17(%rip), %rcx    # 0x5b69e5
leaq 0x109966(%rip), %r8     # 0x5b693b
movl $0x9b, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4acfe9
jmp 0x4acfeb
movl 0x14(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jbe 0x4ad02d
movq 0x18efa4(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x6900d(%rip), %rsi     # 0x516013
leaq 0x1099e8(%rip), %rdx    # 0x5b69f5
leaq 0x1099d1(%rip), %rcx    # 0x5b69e5
leaq 0x109920(%rip), %r8     # 0x5b693b
movl $0x9c, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4ad02f
movq 0x30(%rsp), %rax
movl 0x1c(%rax), %eax
imull 0x2c(%rsp), %eax
movl %eax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movl 0x28(%rsp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rsi
movl 0x10(%rsp), %eax
imull 0x24(%rsp), %eax
movl %eax, %eax
addq %rax, %rsi
movq 0x30(%rsp), %rax
movl 0x1c(%rax), %edx
movl 0x14(%rsp), %eax
movl %eax, %ecx
movq 0x18(%rsp), %r8
callq 0x47a490
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-blockcomp.c
// Function: sBlockGetPartialSymSums
static inline void
sBlockGetPartialSymSums(struct superBlock *sBlock,
                        const struct blockCompositionSeq *seqIdx,
                        GtUword *sums)
{
  gt_bsGetNonUniformUlongArray(
    sBlock->cwData, sBlock->cwIdxMemBase, seqIdx->blockMapAlphabetSize,
    seqIdx->symSumBits, seqIdx->partialSymSumBits,
#if defined (_LP64) || defined (_WIN64)
                             (uint64_t*) sums);
#else
                             (uint32_t*) sums);
#endif
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x10(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, %esi
movq 0x8(%rsp), %rax
movzwl 0xc4(%rax), %eax
movl %eax, %edx
movq 0x8(%rsp), %rax
movl 0xe0(%rax), %eax
movl %eax, %ecx
movq 0x8(%rsp), %rax
movq 0xd0(%rax), %r8
movq (%rsp), %r9
callq 0x4777a0
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl %edx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x4ad1a6
movq 0x18ee2b(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x68e94(%rip), %rsi     # 0x516013
leaq 0x10978c(%rip), %rdx    # 0x5b6912
leaq 0x1098de(%rip), %rcx    # 0x5b6a6b
leaq 0x1097a7(%rip), %r8     # 0x5b693b
movl $0xc9, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4ad1a8
movq 0x20(%rsp), %rax
movl 0x18(%rax), %eax
movq %rax, (%rsp)
movq (%rsp), %rax
movl 0x1c(%rsp), %ecx
imulq %rcx, %rax
movq %rax, 0x8(%rsp)
movl 0x18(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpq (%rcx), %rax
jb 0x4ad20b
movq 0x18edc6(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x68e2f(%rip), %rsi     # 0x516013
leaq 0x1097b2(%rip), %rdx    # 0x5b699d
leaq 0x109879(%rip), %rcx    # 0x5b6a6b
leaq 0x109742(%rip), %r8     # 0x5b693b
movl $0xcc, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4ad20d
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rdi
movl 0x18(%rsp), %eax
movl %eax, %esi
imulq 0x8(%rsp), %rsi
movq (%rsp), %rax
movl %eax, %edx
movl 0x1c(%rsp), %eax
movl %eax, %ecx
movq 0x10(%rsp), %r8
callq 0x479240
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x60, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
xorl %edx, %edx
divq %rcx
movl %edx, %eax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0x4ad2f5
movl -0x1c(%rbp), %eax
movq %rsp, %rcx
movq %rcx, -0x40(%rbp)
movq %rax, %rcx
addq $0xf, %rcx
andq $-0x10, %rcx
movq %rsp, %r8
subq %rcx, %r8
movq %r8, -0x58(%rbp)
movq %r8, %rsp
movq %rax, -0x48(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq 0x10(%rbp), %rcx
movl -0x34(%rbp), %r9d
callq 0x4aced0
movl $0x0, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
cmpl -0x34(%rbp), %eax
jae 0x4ad2ee
movq -0x58(%rbp), %rcx
movq -0x28(%rbp), %rax
movl -0x4c(%rbp), %edx
movzbl (%rcx,%rdx), %ecx
movq (%rax,%rcx,8), %rdx
addq $0x1, %rdx
movq %rdx, (%rax,%rcx,8)
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x4ad2c0
movq -0x40(%rbp), %rax
movq %rax, %rsp
movq %rbp, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-blockcomp.c
// Function: initSuperBlockSeqCache
static void
initSuperBlockSeqCache(struct seqCache *sBlockCache,
                       const struct blockCompositionSeq *seqIdx,
                       size_t numEntries)
{
  unsigned bucketBlocks, GT_UNUSED bucketLen, blockSize;
  size_t superBlockSize;

  gt_assert(seqIdx && sBlockCache);
  blockSize = seqIdx->blockSize;
  bucketLen = (bucketBlocks = seqIdx->bucketBlocks) * blockSize;
  superBlockSize = superBlockMemSize(seqIdx);
  sBlockCache->numEntries = numEntries;
  {
    void *temp = gt_malloc((sizeof (GtUword) + superBlockSize
                           + sizeof (void *)) * numEntries);
    sBlockCache->cachedPos = temp;
    sBlockCache->entriesPtr = (void **)((char *)temp
                                        + sizeof (GtUword) * numEntries);
    sBlockCache->entries =
                      (char *)temp + (sizeof (GtUword) + sizeof (void *))
                         * numEntries;
  }
  {
    size_t i;
    for (i = 0; i < numEntries; ++i)
    {
      sBlockCache->entriesPtr[i] = (char *)sBlockCache->entries
        + superBlockSize * i;
      initEmptySuperBlock(sBlockCache->entriesPtr[i], seqIdx);
      sBlockCache->cachedPos[i] = -1;
    }
  }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
cmpq $0x0, 0x38(%rsp)
je 0x4ad663
cmpq $0x0, 0x40(%rsp)
jne 0x4ad69b
movq 0x18e936(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x6899f(%rip), %rsi     # 0x516013
leaq 0x109485(%rip), %rdx    # 0x5b6b00
leaq 0x109494(%rip), %rcx    # 0x5b6b16
leaq 0x10887f(%rip), %r8     # 0x5b5f08
movl $0x3d7, %r9d            # imm = 0x3D7
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4ad69d
movq 0x38(%rsp), %rax
movl 0xb4(%rax), %eax
movl %eax, 0x24(%rsp)
movq 0x38(%rsp), %rax
movl 0xb0(%rax), %eax
movl %eax, 0x2c(%rsp)
imull 0x24(%rsp), %eax
movl %eax, 0x28(%rsp)
movq 0x38(%rsp), %rdi
callq 0x4accf0
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rcx
movq 0x40(%rsp), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rdi
addq $0x8, %rdi
addq $0x8, %rdi
imulq 0x30(%rsp), %rdi
leaq 0x10880e(%rip), %rsi    # 0x5b5f08
movl $0x3de, %edx            # imm = 0x3DE
callq 0xe80f0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rcx
movq 0x40(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rcx
movq 0x30(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rcx
movq 0x40(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rcx
movq 0x30(%rsp), %rax
shlq $0x4, %rax
addq %rax, %rcx
movq 0x40(%rsp), %rax
movq %rcx, 0x18(%rax)
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x30(%rsp), %rax
jae 0x4ad7cb
movq 0x40(%rsp), %rax
movq 0x18(%rax), %rdx
movq 0x18(%rsp), %rax
imulq 0x8(%rsp), %rax
addq %rax, %rdx
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x38(%rsp), %rsi
callq 0x4acd90
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rsp), %rcx
movq $-0x1, (%rax,%rcx,8)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x4ad754
addq $0x48, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-blockcomp.c
// Function: printBlock
static int
printBlock(Symbol *block, unsigned blockSize, FILE *fp)
{
  unsigned i;
  int outCount = 0;
  for (i = 0; i < blockSize; ++i)
    outCount += fprintf(fp, " %d", (int)block[i]);
  return outCount;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movl $0x0, 0x8(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jae 0x4ae611
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rax
movl 0xc(%rsp), %ecx
movzbl (%rax,%rcx), %edx
leaq 0xeeeac(%rip), %rsi     # 0x59d4a1
movb $0x0, %al
callq 0x199f0
addl 0x8(%rsp), %eax
movl %eax, 0x8(%rsp)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x4ae5d2
movl 0x8(%rsp), %eax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/combinatorics_impl.h
// Function: gt_combinatorics_i_pow
static inline GtUint64 gt_combinatorics_i_pow(GtUint64 x,
                                              unsigned int i)
{
   GtUint64 result = 1ULL;
   if (x == 2ULL)
     return 1ULL << (GtUint64) i;
   while (i != 0) {
     if (i & 1)
       result *= x;
     x *= x;
     i >>= 1;
   }
   return result;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
movq $0x1, -0x20(%rsp)
cmpq $0x2, -0x10(%rsp)
jne 0x4aee4f
movl -0x14(%rsp), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, -0x8(%rsp)
jmp 0x4aee9a
jmp 0x4aee51
cmpl $0x0, -0x14(%rsp)
je 0x4aee90
movl -0x14(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x4aee74
movq -0x10(%rsp), %rax
imulq -0x20(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x10(%rsp), %rax
imulq -0x10(%rsp), %rax
movq %rax, -0x10(%rsp)
movl -0x14(%rsp), %eax
shrl %eax
movl %eax, -0x14(%rsp)
jmp 0x4aee51
movq -0x20(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-seqblocktranslate.c
// Function: nextComposition
static inline void
nextComposition(unsigned composition[],
                Symbol maxSym,
                unsigned *symRMNZ)
{
  ++composition[*symRMNZ - 1];
  if (!(--composition[*symRMNZ]))
  {
    --*symRMNZ;
  }
  else if (!(composition[maxSym]))
  {
    composition[maxSym] = composition[*symRMNZ];
    composition[*symRMNZ] = 0;
    *symRMNZ = maxSym;
  }
}

// Assembly:
movb %sil, %al
movq %rdi, -0x8(%rsp)
movb %al, -0x9(%rsp)
movq %rdx, -0x18(%rsp)
movq -0x8(%rsp), %rax
movq -0x18(%rsp), %rcx
movl (%rcx), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rsp), %rcx
movq -0x18(%rsp), %rax
movl (%rax), %eax
movl %eax, %edx
movl (%rcx,%rdx,4), %eax
addl $-0x1, %eax
movl %eax, (%rcx,%rdx,4)
cmpl $0x0, %eax
jne 0x4af1c5
movq -0x18(%rsp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
jmp 0x4af212
movq -0x8(%rsp), %rax
movzbl -0x9(%rsp), %ecx
cmpl $0x0, (%rax,%rcx,4)
jne 0x4af210
movq -0x8(%rsp), %rax
movq -0x18(%rsp), %rcx
movl (%rcx), %ecx
movl (%rax,%rcx,4), %edx
movq -0x8(%rsp), %rax
movzbl -0x9(%rsp), %ecx
movl %edx, (%rax,%rcx,4)
movq -0x8(%rsp), %rax
movq -0x18(%rsp), %rcx
movl (%rcx), %ecx
movl $0x0, (%rax,%rcx,4)
movzbl -0x9(%rsp), %ecx
movq -0x18(%rsp), %rax
movl %ecx, (%rax)
jmp 0x4af212
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-seqblocktranslate.c
// Function: gt_destructCompositionList
void
gt_destructCompositionList(struct compList *clist)
{
  {
    unsigned i;
    for (i = 0; i < clist->numCompositions; ++i)
      destructPermutationsList(clist->permutations + i);
  }
  gt_free(clist->permutations);
  gt_free(clist->catCompsPerms);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpq (%rcx), %rax
jae 0x4af265
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
movl 0xc(%rsp), %eax
imulq $0x18, %rax, %rax
addq %rax, %rdi
callq 0x4aee10
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x4af231
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
leaq 0x107cb5(%rip), %rsi    # 0x5b6f2a
movl $0xf8, %edx
callq 0xe88c0
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
leaq 0x107c9b(%rip), %rsi    # 0x5b6f2a
movl $0xf9, %edx
callq 0xe88c0
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-seqblocktranslate.c
// Function: gt_newCompositionList
struct compList *
gt_newCompositionList(unsigned blockSize, unsigned alphabetSize)
{
  struct compList *newList = NULL;
  if (!(newList = gt_calloc(1, sizeof (struct compList))))
    return NULL;
  if (!gt_initCompositionList(newList, blockSize, alphabetSize))
  {
    gt_free(newList);
    return NULL;
  }
  return newList;
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0xc(%rsp)
movl %esi, 0x8(%rsp)
movq $0x0, (%rsp)
movl $0x1, %edi
movl $0x28, %esi
leaq 0x107c65(%rip), %rdx    # 0x5b6f2a
movl $0x100, %ecx            # imm = 0x100
callq 0xe83c0
movq %rax, (%rsp)
cmpq $0x0, %rax
jne 0x4af2e4
movq $0x0, 0x10(%rsp)
jmp 0x4af323
movq (%rsp), %rdi
movl 0xc(%rsp), %esi
movl 0x8(%rsp), %edx
callq 0x4ae620
cmpl $0x0, %eax
jne 0x4af31a
movq (%rsp), %rdi
leaq 0x107c25(%rip), %rsi    # 0x5b6f2a
movl $0x104, %edx            # imm = 0x104
callq 0xe88c0
movq $0x0, 0x10(%rsp)
jmp 0x4af323
movq (%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/combinatorics_impl.h
// Function: gt_combinatorics_multinomial
static inline GtUword gt_combinatorics_multinomial(unsigned n,
                                                   size_t numBins,
                                                   const unsigned binSizes[])
{
  GtUword accum = 1UL, nfac;
  size_t i, maxBin = 0, maxBinSize = 0;
#ifndef NDEBUG
  GtUword binSum = 0;
#endif
  gt_assert(n > 0 && numBins > 0 && binSizes);
  for (i = 0; i < numBins; ++i) {
#ifndef NDEBUG
    binSum += binSizes[i];
#endif
    if ((size_t) binSizes[i] > maxBinSize) {
      maxBinSize = (size_t) binSizes[i];
      maxBin = i;
    }
  }
  gt_assert(binSum <= (GtUword) n);
  for (nfac = (GtUword) maxBinSize + 1; nfac <= (GtUword) n; ++nfac)
    accum *= nfac;
  for (i = 0; i < numBins; ++i)
    if (i != maxBin)
      accum /= gt_combinatorics_factorial(binSizes[i]);
  return accum;
}

// Assembly:
subq $0x48, %rsp
movl %edi, 0x44(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq $0x1, 0x28(%rsp)
movq $0x0, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq $0x0, (%rsp)
cmpl $0x0, 0x44(%rsp)
jbe 0x4af7ec
cmpq $0x0, 0x38(%rsp)
jbe 0x4af7ec
cmpq $0x0, 0x30(%rsp)
jne 0x4af824
movq 0x18c7ad(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x66816(%rip), %rsi     # 0x516013
leaq 0x1078f6(%rip), %rdx    # 0x5b70fa
leaq 0x107910(%rip), %rcx    # 0x5b711b
leaq 0x107926(%rip), %r8     # 0x5b7138
movl $0x47, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4af826
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x38(%rsp), %rax
jae 0x4af892
movq 0x30(%rsp), %rax
movq 0x18(%rsp), %rcx
movl (%rax,%rcx,4), %eax
addq (%rsp), %rax
movq %rax, (%rsp)
movq 0x30(%rsp), %rax
movq 0x18(%rsp), %rcx
movl (%rax,%rcx,4), %eax
cmpq 0x8(%rsp), %rax
jbe 0x4af880
movq 0x30(%rsp), %rax
movq 0x18(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x4af882
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x4af82f
jmp 0x4af894
movq (%rsp), %rax
movl 0x44(%rsp), %ecx
cmpq %rcx, %rax
jbe 0x4af8d9
movq 0x18c6f8(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x66761(%rip), %rsi     # 0x516013
leaq 0x1078dd(%rip), %rdx    # 0x5b7196
leaq 0x10785b(%rip), %rcx    # 0x5b711b
leaq 0x107871(%rip), %r8     # 0x5b7138
movl $0x51, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4af8db
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movl 0x44(%rsp), %ecx
cmpq %rcx, %rax
ja 0x4af917
movq 0x20(%rsp), %rax
imulq 0x28(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x4af8e9
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x38(%rsp), %rax
jae 0x4af96e
movq 0x18(%rsp), %rax
cmpq 0x10(%rsp), %rax
je 0x4af95c
movq 0x30(%rsp), %rax
movq 0x18(%rsp), %rcx
movl (%rax,%rcx,4), %edi
callq 0x4afc00
movq %rax, %rcx
movq 0x28(%rsp), %rax
xorl %edx, %edx
divq %rcx
movq %rax, 0x28(%rsp)
jmp 0x4af95e
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x4af920
movq 0x28(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-seqblocktranslate.c
// Function: initPermutation
static void
initPermutation(Symbol *permutation, const unsigned *composition,
                unsigned alphabetSize)
{
  Symbol sym, *p = permutation;
  unsigned j;
  for (sym = 0; sym < alphabetSize; ++sym)
    for (j = 0; j < composition[sym]; ++j)
      *(p++) = sym;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x20(%rsp)
movb $0x0, -0x15(%rsp)
movzbl -0x15(%rsp), %eax
cmpl -0x14(%rsp), %eax
jae 0x4af9f5
movl $0x0, -0x24(%rsp)
movl -0x24(%rsp), %eax
movq -0x10(%rsp), %rcx
movzbl -0x15(%rsp), %edx
cmpl (%rcx,%rdx,4), %eax
jae 0x4af9e7
movb -0x15(%rsp), %cl
movq -0x20(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x20(%rsp)
movb %cl, (%rax)
movl -0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rsp)
jmp 0x4af9b0
jmp 0x4af9e9
movb -0x15(%rsp), %al
addb $0x1, %al
movb %al, -0x15(%rsp)
jmp 0x4af99d
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/core/combinatorics_impl.h
// Function: gt_combinatorics_factorial
static inline GtUword gt_combinatorics_factorial(unsigned n)
{
  GtUword k = 1UL;
  while (n > 1U)
    k *= n--;
  return k;
}

// Assembly:
movl %edi, -0x4(%rsp)
movq $0x1, -0x10(%rsp)
cmpl $0x1, -0x4(%rsp)
jbe 0x4afc30
movl -0x4(%rsp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x4(%rsp)
movl %eax, %eax
imulq -0x10(%rsp), %rax
movq %rax, -0x10(%rsp)
jmp 0x4afc0d
movq -0x10(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movl $0x38, %edi
leaq 0x10754e(%rip), %rsi    # 0x5b71ac
movl $0x22, %edx
callq 0xe80f0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq $0x0, 0x8(%rax)
movq 0x20(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rdi
shlq $0x4, %rdi
leaq 0x107515(%rip), %rsi    # 0x5b71ac
movl $0x25, %edx
callq 0xe80f0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movl 0x14(%rsp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x4afcf1
movq 0x18(%rsp), %rdi
callq 0x22aeb0
movzwl %ax, %eax
movl %eax, %edi
shlq $0x3, %rdi
imulq 0x20(%rsp), %rdi
leaq 0x1074d3(%rip), %rsi    # 0x5b71ac
movl $0x29, %edx
callq 0xe80f0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
jmp 0x4afcfe
movq 0x8(%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x18(%rsp), %rdi
callq 0x22aeb0
movzwl %ax, %eax
subl $0x1, %eax
movzbl %al, %edi
callq 0x4afd80
movl %eax, %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x28(%rax)
movq 0x8(%rsp), %rax
cmpl $0x0, 0x28(%rax)
je 0x4afd64
movq 0x8(%rsp), %rcx
movl $0x40, %eax
subl 0x28(%rcx), %eax
movl %eax, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, %rcx
subq $0x1, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x30(%rax)
jmp 0x4afd71
movq 0x8(%rsp), %rax
movq $-0x1, 0x30(%rax)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)