LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-voiditf.c
// Function: gt_bwtrangesplitwithoutspecial
void gt_bwtrangesplitwithoutspecial(GtArrayBoundswithchar *bwci,
                                    GtUword *rangeOccs,
                                    const FMindex *fmindex,
                                    GtUword lbound,
                                    GtUword ubound)
{
  const BWTSeq *bwtseq = (const BWTSeq *) fmindex;
  AlphabetRangeSize idx, rangesize;

  rangesize = MRAEncGetRangeSize(EISGetAlphabet(bwtseq->seqIdx),0);
  bwci->nextfreeBoundswithchar = 0;
  BWTSeqPosPairRangeOcc(bwtseq, 0, lbound, ubound,rangeOccs);
  for (idx = 0; idx < rangesize; idx++)
  {
    if (rangeOccs[idx] < rangeOccs[rangesize+idx])
    {
      bwci->spaceBoundswithchar[bwci->nextfreeBoundswithchar].inchar = idx;
      bwci->spaceBoundswithchar[bwci->nextfreeBoundswithchar].lbound
        = bwtseq->count[idx] + rangeOccs[idx];
      bwci->spaceBoundswithchar[bwci->nextfreeBoundswithchar++].rbound
        = bwtseq->count[idx] + rangeOccs[rangesize+idx];
    }
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x230120
movq %rax, %rdi
xorl %esi, %esi
callq 0x230070
movw %ax, 0x4(%rsp)
movq 0x30(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq 0x28(%rsp), %r8
xorl %esi, %esi
callq 0x230170
movw $0x0, 0x6(%rsp)
movzwl 0x6(%rsp), %eax
movzwl 0x4(%rsp), %ecx
cmpl %ecx, %eax
jge 0x23005d
movq 0x28(%rsp), %rax
movzwl 0x6(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq 0x28(%rsp), %rcx
movzwl 0x4(%rsp), %edx
movzwl 0x6(%rsp), %esi
addl %esi, %edx
movslq %edx, %rdx
cmpq (%rcx,%rdx,8), %rax
jae 0x230048
movw 0x6(%rsp), %ax
movb %al, %cl
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq 0x30(%rsp), %rdx
imulq $0x18, 0x10(%rdx), %rdx
addq %rdx, %rax
movb %cl, 0x10(%rax)
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rax
movzwl 0x6(%rsp), %ecx
movq (%rax,%rcx,8), %rcx
movq 0x28(%rsp), %rax
movzwl 0x6(%rsp), %edx
addq (%rax,%rdx,8), %rcx
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq 0x30(%rsp), %rdx
imulq $0x18, 0x10(%rdx), %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rax
movzwl 0x6(%rsp), %ecx
movq (%rax,%rcx,8), %rcx
movq 0x28(%rsp), %rax
movzwl 0x4(%rsp), %edx
movzwl 0x6(%rsp), %esi
addl %esi, %edx
movslq %edx, %rdx
addq (%rax,%rdx,8), %rcx
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq 0x30(%rsp), %rsi
movq 0x10(%rsi), %rdx
movq %rdx, %rdi
addq $0x1, %rdi
movq %rdi, 0x10(%rsi)
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
jmp 0x23004a
movw 0x6(%rsp), %ax
addw $0x1, %ax
movw %ax, 0x6(%rsp)
jmp 0x22ff62
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-voiditf.c
// Function: gt_bwtrangesplitallwithoutspecial
GtUword gt_bwtrangesplitallwithoutspecial(Mbtab *mbtab,
                                                GtUword *rangeOccs,
                                                const FMindex *fmindex,
                                                GtUword lbound,
                                                GtUword ubound)
{
  const BWTSeq *bwtseq = (const BWTSeq *) fmindex;
  AlphabetRangeSize idx, rangesize
    = MRAEncGetRangeSize(EISGetAlphabet(bwtseq->seqIdx),0);

  gt_assert(sizeof (AlphabetRangeSize) <= sizeof (GtUword));
  BWTSeqPosPairRangeOcc(bwtseq, 0, lbound, ubound,rangeOccs);
  for (idx = 0; idx < rangesize; idx++)
  {
    if (rangeOccs[idx] < rangeOccs[rangesize+idx])
    {
      mbtab[idx].lowerbound = bwtseq->count[idx] + rangeOccs[idx];
      mbtab[idx].upperbound = bwtseq->count[idx] + rangeOccs[rangesize+idx];
    } else
    {
      mbtab[idx].lowerbound = mbtab[idx].upperbound = 0;
    }
  }
  return (GtUword) rangesize;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x230120
movq %rax, %rdi
xorl %esi, %esi
callq 0x230070
movw %ax, 0x4(%rsp)
jmp 0x2304e5
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq 0x28(%rsp), %r8
xorl %esi, %esi
callq 0x230170
movw $0x0, 0x6(%rsp)
movzwl 0x6(%rsp), %eax
movzwl 0x4(%rsp), %ecx
cmpl %ecx, %eax
jge 0x2305fc
movq 0x28(%rsp), %rax
movzwl 0x6(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq 0x28(%rsp), %rcx
movzwl 0x4(%rsp), %edx
movzwl 0x6(%rsp), %esi
addl %esi, %edx
movslq %edx, %rdx
cmpq (%rcx,%rdx,8), %rax
jae 0x2305b6
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rax
movzwl 0x6(%rsp), %ecx
movq (%rax,%rcx,8), %rcx
movq 0x28(%rsp), %rax
movzwl 0x6(%rsp), %edx
addq (%rax,%rdx,8), %rcx
movq 0x30(%rsp), %rax
movzwl 0x6(%rsp), %edx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rax
movzwl 0x6(%rsp), %ecx
movq (%rax,%rcx,8), %rcx
movq 0x28(%rsp), %rax
movzwl 0x4(%rsp), %edx
movzwl 0x6(%rsp), %esi
addl %esi, %edx
movslq %edx, %rdx
addq (%rax,%rdx,8), %rcx
movq 0x30(%rsp), %rax
movzwl 0x6(%rsp), %edx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
jmp 0x2305e7
movq 0x30(%rsp), %rax
movzwl 0x6(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq $0x0, 0x8(%rax)
movq 0x30(%rsp), %rax
movzwl 0x6(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq $0x0, (%rax)
jmp 0x2305e9
movw 0x6(%rsp), %ax
addw $0x1, %ax
movw %ax, 0x6(%rsp)
jmp 0x230507
movzwl 0x4(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-voiditf.c
// Function: gt_voidpackedfindfirstmatchconvert
GtUword gt_voidpackedfindfirstmatchconvert(const FMindex *fmindex,
                                                 GtUword witnessbound,
                                                 GtUword matchlength)
{
  const BWTSeq *bwtseq = (const BWTSeq *) fmindex;
  GtUword startpos;

  startpos = gt_bwtseqfirstmatch(fmindex,witnessbound);
  gt_assert((bwtseq->seqIdx->seqLen-1) >= (startpos + matchlength));
  return (bwtseq->seqIdx->seqLen - 1) - (startpos + matchlength);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x22f2c0
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
subq $0x1, %rax
movq (%rsp), %rcx
addq 0x10(%rsp), %rcx
cmpq %rcx, %rax
jae 0x230986
movq 0x40b64b(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2e56b4(%rip), %rsi    # 0x516013
leaq 0x345c74(%rip), %rdx    # 0x5765da
leaq 0x345ca4(%rip), %rcx    # 0x576611
leaq 0x345bad(%rip), %r8     # 0x576521
movl $0x1b4, %r9d            # imm = 0x1B4
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x230988
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
subq $0x1, %rax
movq (%rsp), %rcx
addq 0x10(%rsp), %rcx
subq %rcx, %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-voiditf.c
// Function: gt_voidpackedindexmstatsforward
GtUword gt_voidpackedindexmstatsforward(const void *fmindex,
                                              GT_UNUSED GtUword offset,
                                              GT_UNUSED GtUword left,
                                              GT_UNUSED GtUword right,
                                              GtUword *witnessposition,
                                              const GtUchar *qstart,
                                              const GtUchar *qend)
{
  const BWTSeq *bwtseq = (const BWTSeq *) fmindex;
  GtUword matchlength;

  matchlength = gt_packedindexmstatsforward(bwtseq,witnessposition,qstart,qend);
  if (matchlength > 0 && witnessposition != NULL)
  {
    *witnessposition = gt_voidpackedfindfirstmatchconvert(fmindex,
                                                          *witnessposition,
                                                          matchlength);
  }
  return matchlength;
}

// Assembly:
subq $0x48, %rsp
movq 0x50(%rsp), %rax
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %r9, 0x18(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x50(%rsp), %rcx
callq 0x2266a0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jbe 0x230a31
cmpq $0x0, 0x20(%rsp)
je 0x230a31
movq 0x40(%rsp), %rdi
movq 0x20(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rsp), %rdx
callq 0x230900
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-voiditf.c
// Function: gt_pck_getGCcontent
double gt_pck_getGCcontent(const FMindex *bwtSubject,
                           const GtAlphabet *alphabet)
{
  GtUword  c, length;
  double gc;
  const MRAEnc *FM_alphabet;
  GtUchar c_sym;

  FM_alphabet = BWTSeqGetAlphabet((const BWTSeq *) bwtSubject);

  c_sym = MRAEncMapSymbol(FM_alphabet,
                          gt_alphabet_encode(alphabet, 'c'));
  length = ((const BWTSeq *) bwtSubject)->seqIdx->seqLen;

  c = ((const BWTSeq *) bwtSubject)->count[c_sym+1] -
    ((const BWTSeq *) bwtSubject)->count[c_sym];

  gc = c * 2 / (double) (length - 2);
  return gc;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rdi
callq 0x230810
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
movl $0x63, %esi
callq 0x7f6f0
movq 0x8(%rsp), %rdi
movzbl %al, %esi
callq 0x230f20
movb %al, 0x17(%rsp)
movq 0x40(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x40(%rsp), %rax
movq 0x38(%rax), %rax
movzbl 0x17(%rsp), %ecx
movl %ecx, %edx
movq (%rax,%rdx,8), %rcx
movq 0x8(%rax,%rdx,8), %rax
subq %rcx, %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq %rax, %rax
movq %rax, %xmm0
movaps 0x2e7733(%rip), %xmm3   # 0x518930
punpckldq %xmm3, %xmm0    # xmm0 = xmm0[0],xmm3[0],xmm0[1],xmm3[1]
movapd 0x2e7737(%rip), %xmm2   # 0x518940
subpd %xmm2, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movq 0x28(%rsp), %rax
addq $-0x2, %rax
movq %rax, %xmm1
punpckldq %xmm3, %xmm1    # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x20(%rsp), %xmm0
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-voiditf.c
// Function: gt_pck_get_nonspecial_count
GtUword gt_pck_get_nonspecial_count(const FMindex *index)
{
  const BWTSeq *bwtseq = (const BWTSeq *) index;

  return BWTSeqAggTransformedCount(bwtseq,
                                   MRAEncGetRangeSize(BWTSeqGetAlphabet(bwtseq),
                                     0));
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
callq 0x230810
movq %rax, %rdi
xorl %esi, %esi
callq 0x230070
movq (%rsp), %rdi
movzbl %al, %esi
callq 0x2312a0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-voiditf.c
// Function: gt_pck_special_occ_in_nonspecial_intervals
GtUword gt_pck_special_occ_in_nonspecial_intervals(const FMindex *index)
{
  const BWTSeq *bwtseq = (const BWTSeq *) index;
  GtUword count = 0,
                *rangeOccs, first_special_row;
  unsigned short idx, rangesize;

  rangesize = (unsigned short) MRAEncGetRangeSize(BWTSeqGetAlphabet(bwtseq), 1);
  rangeOccs = gt_calloc(rangesize, sizeof (GtUword));
  first_special_row = gt_pck_get_nonspecial_count(index);
  BWTSeqRangeOcc(bwtseq, 1, first_special_row, rangeOccs);
  for (idx = 0; idx < rangesize; idx++)
    count += rangeOccs[idx];
  gt_free(rangeOccs);
  return count;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x230810
movq %rax, %rdi
movl $0x1, %esi
callq 0x230070
movw %ax, 0xc(%rsp)
movzwl 0xc(%rsp), %eax
movl %eax, %edi
movl $0x8, %esi
leaq 0x345176(%rip), %rdx    # 0x576521
movl $0x245, %ecx            # imm = 0x245
callq 0xe83c0
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
callq 0x231250
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
movl $0x1, %esi
callq 0x231440
movw $0x0, 0xe(%rsp)
movzwl 0xe(%rsp), %eax
movzwl 0xc(%rsp), %ecx
cmpl %ecx, %eax
jge 0x23141f
movq 0x18(%rsp), %rax
movzwl 0xe(%rsp), %ecx
movq (%rax,%rcx,8), %rax
addq 0x20(%rsp), %rax
movq %rax, 0x20(%rsp)
movw 0xe(%rsp), %ax
addw $0x1, %ax
movw %ax, 0xe(%rsp)
jmp 0x2313e9
movq 0x18(%rsp), %rdi
leaq 0x3450f6(%rip), %rsi    # 0x576521
movl $0x24a, %edx            # imm = 0x24A
callq 0xe88c0
movq 0x20(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-bwtseq-siop.h
// Function: BWTSeqRangeOcc
static inline void
BWTSeqRangeOcc(const BWTSeq *bwtSeq, AlphabetRangeID range, GtUword pos,
               GtUword *rangeOccs)
{
  gt_assert(bwtSeq && rangeOccs);
  gt_assert(range < MRAEncGetNumRanges(BWTSeqGetAlphabet(bwtSeq)));
  EISRangeRank(bwtSeq->seqIdx, range, pos, rangeOccs, bwtSeq->hint);
  if (range == bwtSeq->bwtTerminatorFallbackRange)
  {
    const MRAEnc *alphabet = BWTSeqGetAlphabet(bwtSeq);
    AlphabetRangeSize
      termIdx = MRAEncMapSymbol(alphabet, bwtTerminatorSym)
      - MRAEncGetRangeBase(alphabet, range),
      fbIdx = bwtSeq->bwtTerminatorFallback
      - MRAEncGetRangeBase(alphabet, range);
    if (pos > BWTSeqTerminatorPos(bwtSeq))
    {
      rangeOccs[termIdx] = 1;
      --(rangeOccs[fbIdx]);
    }
    else
      rangeOccs[termIdx] = 0;
  }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
cmpq $0x0, 0x40(%rsp)
je 0x231467
cmpq $0x0, 0x28(%rsp)
jne 0x23149f
movq 0x40ab32(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2e4b9b(%rip), %rsi    # 0x516013
leaq 0x345268(%rip), %rdx    # 0x5766e7
leaq 0x345305(%rip), %rcx    # 0x57678b
leaq 0x3434da(%rip), %r8     # 0x574967
movl $0x79, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2314a1
jmp 0x2314a3
movl 0x3c(%rsp), %eax
movl %eax, 0x18(%rsp)
movq 0x40(%rsp), %rdi
callq 0x230810
movq %rax, %rdi
callq 0x230820
movl %eax, %ecx
movl 0x18(%rsp), %eax
cmpl %ecx, %eax
jb 0x2314ff
movq 0x40aad2(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2e4b3b(%rip), %rsi    # 0x516013
leaq 0x34523f(%rip), %rdx    # 0x57671e
leaq 0x3452a5(%rip), %rcx    # 0x57678b
leaq 0x34347a(%rip), %r8     # 0x574967
movl $0x7a, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x231501
movq 0x40(%rsp), %rax
movq (%rax), %rdi
movl 0x3c(%rsp), %esi
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rcx
movq 0x40(%rsp), %rax
movq 0x18(%rax), %r8
callq 0x231d00
movl 0x3c(%rsp), %eax
movq 0x40(%rsp), %rcx
cmpl 0x28(%rcx), %eax
jne 0x231604
movq 0x40(%rsp), %rdi
callq 0x230810
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl $0xfc, %esi
callq 0x230f20
movzbl %al, %eax
movl %eax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movl 0x3c(%rsp), %esi
callq 0x230830
movb %al, %cl
movl 0x8(%rsp), %eax
movzbl %cl, %ecx
subl %ecx, %eax
movw %ax, 0x1e(%rsp)
movq 0x40(%rsp), %rax
movzbl 0x24(%rax), %eax
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rdi
movl 0x3c(%rsp), %esi
callq 0x230830
movb %al, %cl
movl 0xc(%rsp), %eax
movzbl %cl, %ecx
subl %ecx, %eax
movw %ax, 0x1c(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rdi
callq 0x22f560
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jbe 0x2315f0
movq 0x28(%rsp), %rax
movzwl 0x1e(%rsp), %ecx
movq $0x1, (%rax,%rcx,8)
movq 0x28(%rsp), %rax
movzwl 0x1c(%rsp), %ecx
movq (%rax,%rcx,8), %rdx
addq $-0x1, %rdx
movq %rdx, (%rax,%rcx,8)
jmp 0x231602
movq 0x28(%rsp), %rax
movzwl 0x1e(%rsp), %ecx
movq $0x0, (%rax,%rcx,8)
jmp 0x231604
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/eis-voiditf.c
// Function: gt_pck_exact_pattern_count
GtUword gt_pck_exact_pattern_count(const FMindex *index,
                                         const GtUchar *pattern,
                                         GtUword patternlength) {
  return gt_BWTSeqMatchCount((const BWTSeq *) index,
                              pattern,
                              (size_t) patternlength,
                              true); /* XXX check if this is right! */
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
movl $0x1, %ecx
callq 0x2268f0
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/enum-patt.c
// Function: reversesequenceinplace
static void reversesequenceinplace(GtUchar *s,GtUword len)
{
  GtUchar *front, *back, tmp;

  for (front = s, back = s + len - 1; front < back; front++, back--)
  {
    tmp = *front;
    *front = *back;
    *back = tmp;
  }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x18(%rsp)
movq -0x8(%rsp), %rax
addq -0x10(%rsp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rsp)
movq -0x18(%rsp), %rax
cmpq -0x20(%rsp), %rax
jae 0x2321c5
movq -0x18(%rsp), %rax
movb (%rax), %al
movb %al, -0x21(%rsp)
movq -0x20(%rsp), %rax
movb (%rax), %cl
movq -0x18(%rsp), %rax
movb %cl, (%rax)
movb -0x21(%rsp), %cl
movq -0x20(%rsp), %rax
movb %cl, (%rax)
movq -0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rsp)
movq -0x20(%rsp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rsp)
jmp 0x232177
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/enum-patt.c
// Function: gt_showPatterndistribution
void gt_showPatterndistribution(const Enumpatterniterator *epi)
{
  GtUword i;
  double addprob, probsum = 0.0;

  printf("# "GT_WU" pattern with the following length distribution:\n",
         epi->samplecount);
  for (i=epi->minpatternlen; i<=epi->maxpatternlen; i++)
  {
    if (epi->patternstat[i] > 0)
    {
      addprob = (double) epi->patternstat[i] / epi->samplecount;
      probsum += addprob;
      printf("# "GT_WU": "GT_WU" (prob=%.4f,cumulative=%.4f)\n",
             i,
             epi->patternstat[i],
             addprob,
             probsum);
    }
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rsi
leaq 0x34464b(%rip), %rdi    # 0x57683d
movb $0x0, %al
callq 0x19070
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
cmpq 0x8(%rcx), %rax
ja 0x2322e2
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jbe 0x2322cd
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rcx
movq 0x18(%rsp), %rdx
movq (%rcx,%rdx,8), %xmm0
movaps 0x2e66e3(%rip), %xmm3   # 0x518930
punpckldq %xmm3, %xmm0    # xmm0 = xmm0[0],xmm3[0],xmm0[1],xmm3[1]
movapd 0x2e66e7(%rip), %xmm2   # 0x518940
subpd %xmm2, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movq 0x10(%rax), %xmm1
punpckldq %xmm3, %xmm1    # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
addsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
movsd 0x10(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
leaq 0x3445ae(%rip), %rdi    # 0x576874
movb $0x2, %al
callq 0x19070
jmp 0x2322cf
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x232206
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/enum-patt.c
// Function: gt_freeEnumpatterniterator
void gt_freeEnumpatterniterator(Enumpatterniterator *epi)
{
  if (!epi) return;
  gt_free(epi->patternspace);
  gt_free(epi->patternstat);
  gt_encseq_reader_delete(epi->esr);
  gt_free(epi);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x2322fe
jmp 0x232352
movq (%rsp), %rax
movq 0x20(%rax), %rdi
leaq 0x3444a5(%rip), %rsi    # 0x5767b2
movl $0xa4, %edx
callq 0xe88c0
movq (%rsp), %rax
movq 0x18(%rax), %rdi
leaq 0x34448c(%rip), %rsi    # 0x5767b2
movl $0xa5, %edx
callq 0xe88c0
movq (%rsp), %rax
movq 0x40(%rax), %rdi
callq 0xac3f0
movq (%rsp), %rdi
leaq 0x34446a(%rip), %rsi    # 0x5767b2
movl $0xa7, %edx
callq 0xe88c0
popq %rax
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/esa-lcpintervals.c
// Function: processleafedge_elcp
static int processleafedge_elcp(bool firstsucc,
                                GtUword fatherdepth,
                                Dfsinfo *afather,
                                GtUword leafnumber,
                                GT_UNUSED Dfsstate *astate,
                                GT_UNUSED GtError *err)
{
  Lcpinterval *father = (Lcpinterval *) afather;

  printf("L %c "GT_WU" "GT_WU" "GT_WU"\n",firstsucc ? '1' : '0',
                              fatherdepth,father->left,leafnumber);
  return 0;
}

// Assembly:
subq $0x38, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, 0x37(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq %r9, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movb 0x37(%rsp), %cl
movl $0x30, %esi
movl $0x31, %eax
testb $0x1, %cl
cmovnel %eax, %esi
movq 0x28(%rsp), %rdx
movq (%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x18(%rsp), %r8
leaq 0x344364(%rip), %rdi    # 0x576900
movb $0x0, %al
callq 0x19070
xorl %eax, %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/esa-lcpintervals.c
// Function: processbranchedge_elcp
static int processbranchedge_elcp(bool firstsucc,
                                  GtUword fatherdepth,
                                  Dfsinfo *afather,
                                  Dfsinfo *ason,
                                  Dfsstate *astate,
                                  GT_UNUSED GtError *err)
{
  Lcpinterval *father = (Lcpinterval *) afather;
  Lcpinterval *son = (Lcpinterval *) ason;
  Elcpstate *state = (Elcpstate *) astate;

  if (son != NULL)
  {
    showbranchingedgeDFS(firstsucc,fatherdepth,father->left,son->offset,
                       son->left);
  } else
  {
    showbranchingedgeDFS(firstsucc,fatherdepth,father->left,
                       state->lastcompletenode.offset,
                       state->lastcompletenode.left);
  }
  return 0;
}

// Assembly:
subq $0x48, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, 0x47(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %r9, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x23262a
movb 0x47(%rsp), %al
movq 0x38(%rsp), %rsi
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %rdx
movq 0x8(%rsp), %rcx
movq (%rcx), %rcx
movq 0x8(%rsp), %rdi
movq 0x8(%rdi), %r8
andb $0x1, %al
movzbl %al, %edi
callq 0x2330f0
jmp 0x232655
movb 0x47(%rsp), %al
movq 0x38(%rsp), %rsi
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %rdx
movq (%rsp), %rcx
movq (%rcx), %rcx
movq (%rsp), %rdi
movq 0x8(%rdi), %r8
andb $0x1, %al
movzbl %al, %edi
callq 0x2330f0
xorl %eax, %eax
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/esa-lcpintervals.c
// Function: processcompletenode_elcp
static int processcompletenode_elcp(
                          GtUword nodeptrdepth,
                          Dfsinfo *anodeptr,
                          GT_UNUSED GtUword nodeptrminusonedepth,
                          Dfsstate *astate,
                          GT_UNUSED GtError *err)
{
  Lcpinterval *nodeptr = (Lcpinterval *) anodeptr;
  Elcpstate *state = (Elcpstate *) astate;

  gt_assert(state != NULL);
  gt_assert(nodeptr != NULL);
  nodeptr->offset = state->lastcompletenode.offset = nodeptrdepth;
  state->lastcompletenode.left = nodeptr->left;
  state->lastcompletenode.right = nodeptr->right;
  if (state->processlcpinterval != NULL)
  {
    if (state->processlcpinterval(state->processinfo,
                                  &state->lastcompletenode) != 0)
    {
      return -1;
    }
  }
  return 0;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq %r8, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x2326d1
movq 0x409900(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2e3969(%rip), %rsi    # 0x516013
leaq 0x34126f(%rip), %rdx    # 0x573920
leaq 0x344270(%rip), %rcx    # 0x576928
leaq 0x3441dd(%rip), %r8     # 0x57689c
movl $0x64, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2326d3
jmp 0x2326d5
cmpq $0x0, 0x10(%rsp)
jne 0x232715
movq 0x4098bc(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2e3925(%rip), %rsi    # 0x516013
leaq 0x356642(%rip), %rdx    # 0x588d37
leaq 0x34422c(%rip), %rcx    # 0x576928
leaq 0x344199(%rip), %r8     # 0x57689c
movl $0x65, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x232717
movq 0x38(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x232786
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x20(%rcx), %rdi
movq 0x8(%rsp), %rsi
callq *%rax
cmpl $0x0, %eax
je 0x232784
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0x23278e
jmp 0x232786
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/esa-lcpintervals.c
// Function: gt_runenumlcpvalues_bottomup
int gt_runenumlcpvalues_bottomup(const char *inputindex,
                                 GtLogger *logger,
                                 GtError *err)
{
  bool haserr = false;
  Sequentialsuffixarrayreader *ssar;

  gt_error_check(err);
  ssar = gt_newSequentialsuffixarrayreaderfromfile(inputindex,
                                                   SARR_LCPTAB |
                                                   SARR_SUFTAB |
                                                   SARR_ESQTAB,
                                                   true,
                                                   logger,
                                                   err);
  if (ssar == NULL)
  {
    haserr = true;
  }
  if (!haserr)
  {
    GtESAVisitor *elv = gt_esa_lcpitvs_visitor_new();
    if (gt_esa_bottomup(ssar, elv, err) != 0)
    {
      haserr = true;
    }
    gt_esa_visitor_delete(elv);
  }
  if (ssar != NULL)
  {
    gt_freeSequentialsuffixarrayreader(&ssar);
  }
  return haserr ? -1 : 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movb $0x0, 0x1f(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x232858
movq 0x20(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x232820
jmp 0x232858
movq 0x409779(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2e37e2(%rip), %rsi    # 0x516013
leaq 0x2e3987(%rip), %rdx    # 0x5161bf
leaq 0x34407a(%rip), %rcx    # 0x5768b9
leaq 0x344056(%rip), %r8     # 0x57689c
movl $0xb7, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x23285a
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rcx
movq 0x20(%rsp), %r8
movl $0x7, %esi
movl $0x1, %edx
callq 0x23b3e0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x23288a
movb $0x1, 0x1f(%rsp)
testb $0x1, 0x1f(%rsp)
jne 0x2328c3
callq 0x241980
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x4b2f60
cmpl $0x0, %eax
je 0x2328b9
movb $0x1, 0x1f(%rsp)
movq 0x8(%rsp), %rdi
callq 0x242b70
cmpq $0x0, 0x10(%rsp)
je 0x2328d5
leaq 0x10(%rsp), %rdi
callq 0x23b5e0
movb 0x1f(%rsp), %dl
xorl %eax, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testb $0x1, %dl
cmovnel %ecx, %eax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/esa-lcpintervals.c
// Function: gt_runenumlcpvalues_process
int gt_runenumlcpvalues_process(const char *inputindex,
                             int (*processfunction)(void *,const Lcpinterval *),
                             void *processdata,
                             GtLogger *logger,
                             GtError *err)
{
  bool haserr = false;
  Sequentialsuffixarrayreader *ssar;

  gt_error_check(err);
  ssar = gt_newSequentialsuffixarrayreaderfromfile(inputindex,
                                                   SARR_LCPTAB |
                                                   SARR_SUFTAB |
                                                   SARR_ESQTAB,
                                                   true,
                                                   logger,
                                                   err);
  if (ssar == NULL)
  {
    haserr = true;
  }
  if (!haserr)
  {
    if (gt_processlcpintervals(ssar, processfunction, processdata,
                               logger, err) != 0)
    {
      haserr = true;
    }
  }
  if (ssar != NULL)
  {
    gt_freeSequentialsuffixarrayreader(&ssar);
  }
  return haserr ? -1 : 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movb $0x0, 0xf(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x232962
movq 0x10(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x23292a
jmp 0x232962
movq 0x40966f(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2e36d8(%rip), %rsi    # 0x516013
leaq 0x2e387d(%rip), %rdx    # 0x5161bf
leaq 0x343f8d(%rip), %rcx    # 0x5768d6
leaq 0x343f4c(%rip), %r8     # 0x57689c
movl $0xdc, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x232964
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %r8
movl $0x7, %esi
movl $0x1, %edx
callq 0x23b3e0
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x232992
movb $0x1, 0xf(%rsp)
testb $0x1, 0xf(%rsp)
jne 0x2329c2
movq (%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %r8
callq 0x232360
cmpl $0x0, %eax
je 0x2329c0
movb $0x1, 0xf(%rsp)
jmp 0x2329c2
cmpq $0x0, (%rsp)
je 0x2329d1
movq %rsp, %rdi
callq 0x23b5e0
movb 0xf(%rsp), %dl
xorl %eax, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testb $0x1, %dl
cmovnel %ecx, %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/esa-lcpintervals.c
// Function: gt_runscanesa
int gt_runscanesa(const char *inputindex, unsigned int mode,
                  GtLogger *logger,GtError *err)
{
  bool haserr = false;
  Sequentialsuffixarrayreader *ssar;

  gt_error_check(err);
  ssar = gt_newSequentialsuffixarrayreaderfromfile(inputindex,
                                                   SARR_LCPTAB |
                                                   SARR_SUFTAB |
                                                   SARR_ESQTAB,
                                                   true,
                                                   logger,
                                                   err);
  if (ssar == NULL)
  {
    haserr = true;
  }
  if (!haserr && gt_esa_scantables(ssar, mode, err) != 0)
  {
    haserr = true;
  }
  if (ssar != NULL)
  {
    gt_freeSequentialsuffixarrayreader(&ssar);
  }
  return haserr ? -1 : 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movb $0x0, 0x17(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x232a5c
movq 0x18(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x232a24
jmp 0x232a5c
movq 0x409575(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2e35de(%rip), %rsi    # 0x516013
leaq 0x2e3783(%rip), %rdx    # 0x5161bf
leaq 0x343eaf(%rip), %rcx    # 0x5768f2
leaq 0x343e52(%rip), %r8     # 0x57689c
movl $0x13e, %r9d            # imm = 0x13E
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x232a5e
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %r8
movl $0x7, %esi
movl $0x1, %edx
callq 0x23b3e0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x232a8e
movb $0x1, 0x17(%rsp)
testb $0x1, 0x17(%rsp)
jne 0x232ab2
movq 0x8(%rsp), %rdi
movl 0x2c(%rsp), %esi
movq 0x18(%rsp), %rdx
callq 0x232ae0
cmpl $0x0, %eax
je 0x232ab2
movb $0x1, 0x17(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x232ac4
leaq 0x8(%rsp), %rdi
callq 0x23b5e0
movb 0x17(%rsp), %dl
xorl %eax, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testb $0x1, %dl
cmovnel %ecx, %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/esa-map.c
// Function: streamsuffixarray
int streamsuffixarray(Suffixarray *suffixarray,
                      unsigned int demand,
                      const char *indexname,
                      GtLogger *logger,
                      GtError *err)
{
  gt_error_check(err);
  return inputsuffixarray(false,
                          suffixarray,
                          demand,
                          indexname,
                          logger,
                          err);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq %r8, (%rsp)
cmpq $0x0, (%rsp)
je 0x233569
movq (%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x233531
jmp 0x233569
movq 0x408a68(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2e2ad1(%rip), %rsi    # 0x516013
leaq 0x2e2c76(%rip), %rdx    # 0x5161bf
leaq 0x34345d(%rip), %rcx    # 0x5769ad
leaq 0x343442(%rip), %r8     # 0x576999
movl $0x1ed, %r9d            # imm = 0x1ED
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x23356b
movq 0x20(%rsp), %rsi
movl 0x1c(%rsp), %edx
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %r8
movq (%rsp), %r9
xorl %edi, %edi
callq 0x233590
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/esa-map.c
// Function: gt_mapsuffixarray
int gt_mapsuffixarray(Suffixarray *suffixarray,
                      unsigned int demand,
                      const char *indexname,
                      GtLogger *logger,
                      GtError *err)
{
  gt_error_check(err);
  /* printf("sizeof (Suffixarray)="GT_WU"\n",sizeof (Suffixarray)); */
  return inputsuffixarray(true,
                          suffixarray,
                          demand,
                          indexname,
                          logger,
                          err);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq %r8, (%rsp)
cmpq $0x0, (%rsp)
je 0x233e69
movq (%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x233e31
jmp 0x233e69
movq 0x408168(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2e21d1(%rip), %rsi    # 0x516013
leaq 0x2e2376(%rip), %rdx    # 0x5161bf
leaq 0x342b6f(%rip), %rcx    # 0x5769bf
leaq 0x342b42(%rip), %r8     # 0x576999
movl $0x1fc, %r9d            # imm = 0x1FC
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x233e6b
movq 0x20(%rsp), %rsi
movl 0x1c(%rsp), %edx
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %r8
movq (%rsp), %r9
movl $0x1, %edi
callq 0x233590
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/esa-map.c
// Function: initsuffixarray
static void initsuffixarray(Suffixarray *suffixarray)
{
  suffixarray->encseq = NULL;
  suffixarray->suftab = NULL;
  suffixarray->lcptab = NULL;
  suffixarray->llvtab = NULL;
  suffixarray->bwttab = NULL;
  suffixarray->bcktab = NULL;
  suffixarray->bwttabstream.fp = NULL;
  suffixarray->bwttabstream.bufferedfilespace = NULL;
  suffixarray->suftabstream_GtUword.fp = NULL;
  suffixarray->suftabstream_GtUword.bufferedfilespace = NULL;
#if defined (_LP64) || defined (_WIN64)
  suffixarray->suftabstream_uint32_t.fp = NULL;
  suffixarray->suftabstream_uint32_t.bufferedfilespace = NULL;
#endif
  suffixarray->lcptabstream.fp = NULL;
  suffixarray->lcptabstream.bufferedfilespace = NULL;
  suffixarray->llvtabstream.fp = NULL;
  suffixarray->llvtabstream.bufferedfilespace = NULL;
  suffixarray->numberofallsortedsuffixes = 0;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq $0x0, (%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x58(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x60(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x68(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x70(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x80(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0xc8(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0xc0(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0xb0(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0xa8(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x98(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x90(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0xe0(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0xd8(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0xf8(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0xf0(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x50(%rax)
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/esa-map.c
// Function: scanprjfileuintkeys
static bool scanprjfileuintkeys(Suffixarray *suffixarray,
                                const char *indexname,
                                GtLogger *logger,
                                GtError *err)
{
  bool haserr = false;
  FILE *fp;

  gt_error_check(err);
  fp = gt_fa_fopen_with_suffix(indexname,GT_PROJECTFILESUFFIX,"rb",err);
  if (fp == NULL)
  {
    haserr = true;
  }
  if (!haserr && scanprjfileuintkeysviafileptr(suffixarray,
                                               indexname,logger,
                                               fp,err) != 0)
  {
    haserr = true;
  }
  gt_fa_xfclose(fp);
  return haserr;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movb $0x0, 0x17(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x23401d
movq 0x18(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x233fe5
jmp 0x23401d
movq 0x407fb4(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2e201d(%rip), %rsi    # 0x516013
leaq 0x2e21c2(%rip), %rdx    # 0x5161bf
leaq 0x342a7d(%rip), %rcx    # 0x576a81
leaq 0x34298e(%rip), %r8     # 0x576999
movl $0xf3, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x23401f
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %r9
leaq 0x2ea991(%rip), %rsi    # 0x51e9c1
leaq 0x343eae(%rip), %rdx    # 0x577ee5
leaq 0x34295b(%rip), %rcx    # 0x576999
movl $0xf4, %r8d
callq 0xd92c0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x23405b
movb $0x1, 0x17(%rsp)
testb $0x1, 0x17(%rsp)
jne 0x23408a
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %r8
callq 0x2340a0
cmpl $0x0, %eax
je 0x23408a
movb $0x1, 0x17(%rsp)
movq 0x8(%rsp), %rdi
callq 0xd9570
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/esa-maxpairs.c
// Function: gt_enumeratemaxpairs
int gt_enumeratemaxpairs(Sequentialsuffixarrayreader *ssar,
                         unsigned int searchlength,
                         GtProcessmaxpairs processmaxpairs,
                         void *processmaxpairsinfo,
                         GtError *err)
{
  gt_assert (ssar != NULL);
  return gt_enumeratemaxpairs_generic(ssar,
                                      NULL,
                                      searchlength,
                                      processmaxpairs,
                                      processmaxpairsinfo,
                                      err);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq %r8, (%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x235f3b
movq 0x406096(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2e00ff(%rip), %rsi    # 0x516013
leaq 0x2f4d40(%rip), %rdx    # 0x52ac5b
leaq 0x340e6b(%rip), %rcx    # 0x576d8d
leaq 0x340e17(%rip), %r8     # 0x576d40
movl $0x223, %r9d            # imm = 0x223
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x235f3d
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %edx
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %r8
movq (%rsp), %r9
xorl %eax, %eax
movl %eax, %esi
callq 0x234990
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/esa-maxpairs.c
// Function: gt_enumeratemaxpairs_sain
int gt_enumeratemaxpairs_sain(GtSainSufLcpIterator *suflcpiterator,
                              unsigned int searchlength,
                              GtProcessmaxpairs processmaxpairs,
                              void *processmaxpairsinfo,
                              GtError *err)
{
  gt_assert(suflcpiterator != NULL);
  return gt_enumeratemaxpairs_generic(NULL,
                                      suflcpiterator,
                                      searchlength,
                                      processmaxpairs,
                                      processmaxpairsinfo,
                                      err);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq %r8, (%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x235fcb
movq 0x406006(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2e006f(%rip), %rsi    # 0x516013
leaq 0x340dae(%rip), %rdx    # 0x576d59
leaq 0x340df0(%rip), %rcx    # 0x576da2
leaq 0x340d87(%rip), %r8     # 0x576d40
movl $0x232, %r9d            # imm = 0x232
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x235fcd
movq 0x20(%rsp), %rsi
movl 0x1c(%rsp), %edx
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %r8
movq (%rsp), %r9
xorl %eax, %eax
movl %eax, %edi
callq 0x234990
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/esa-maxpairs.c
// Function: showcollectedintervals
void showcollectedintervals(const Lcpinterval *itvtab,GtUword num)
{
  const Lcpinterval *lcpitv;

  for (lcpitv = itvtab; lcpitv < itvtab + num; lcpitv++)
  {
    printf("# " GT_WU " " GT_WU " " GT_WU "\n",lcpitv->offset,lcpitv->left,
                                               lcpitv->right);
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
imulq $0x18, 0x8(%rsp), %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0x236061
movq (%rsp), %rax
movq (%rax), %rsi
movq (%rsp), %rax
movq 0x8(%rax), %rdx
movq (%rsp), %rax
movq 0x10(%rax), %rcx
leaq 0x340d70(%rip), %rdi    # 0x576dbc
movb $0x0, %al
callq 0x19070
movq (%rsp), %rax
addq $0x18, %rax
movq %rax, (%rsp)
jmp 0x236017
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/esa-maxpairs.c
// Function: setpostabto0_maxpairs
static void setpostabto0_maxpairs(GtBUstate_maxpairs *state)
{
  unsigned int base;

  if (!state->initialized)
  {
    for (base = 0; base < state->alphabetsize; base++)
    {
      state->poslist[base].nextfreeGtUword = 0;
    }
    state->uniquechar.nextfreeGtUword = 0;
    state->initialized = true;
  }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
testb $0x1, (%rax)
jne 0x237243
movl $0x0, -0xc(%rsp)
movl -0xc(%rsp), %eax
movq -0x8(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jae 0x23722e
movq -0x8(%rsp), %rax
movq 0x28(%rax), %rax
movl -0xc(%rsp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq $0x0, 0x10(%rax)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x2371f7
movq -0x8(%rsp), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rsp), %rax
movb $0x1, (%rax)
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/esa-maxpairs.c
// Function: cartproduct1_maxpairs
static int cartproduct1_maxpairs(GtBUstate_maxpairs *state,
                                 GtUword fatherdepth,
                                 const GtBUinfo_maxpairs *ninfo,
                                 unsigned int base,
                                 GtUword leafnumber,GtError *err)
{
  Listtype *pl;
  GtUword *spptr, *start;

  pl = &NODEPOSLISTENTRY(ninfo,base);
  start = state->poslist[base].spaceGtUword + pl->start;
  for (spptr = start; spptr < start + pl->length; spptr++)
  {
    if (state->processmaxpairs(state->processmaxpairsinfo,&state->genericencseq,
                               fatherdepth,GT_MIN(leafnumber,*spptr),
                                           GT_MAX(leafnumber,*spptr),err) != 0)
    {
      return -1;
    }
  }
  return 0;
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movq %rdx, 0x68(%rsp)
movl %ecx, 0x64(%rsp)
movq %r8, 0x58(%rsp)
movq %r9, 0x50(%rsp)
movq 0x68(%rsp), %rax
movq 0x18(%rax), %rax
movl 0x64(%rsp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, 0x48(%rsp)
movq 0x78(%rsp), %rax
movq 0x28(%rax), %rax
movl 0x64(%rsp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq 0x48(%rsp), %rcx
movq (%rcx), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq 0x38(%rsp), %rcx
movq 0x48(%rsp), %rdx
movq 0x8(%rdx), %rdx
shlq $0x3, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0x23767c
movq 0x78(%rsp), %rax
movq 0x50(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x78(%rsp), %rax
movq 0x68(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x78(%rsp), %rax
addq $0x30, %rax
movq %rax, 0x28(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x58(%rsp), %rax
movq 0x40(%rsp), %rcx
cmpq (%rcx), %rax
jae 0x2375f4
movq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x237601
movq 0x40(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x58(%rsp), %rax
movq 0x40(%rsp), %rcx
cmpq (%rcx), %rax
jbe 0x237625
movq 0x58(%rsp), %rax
movq %rax, (%rsp)
jmp 0x237631
movq 0x40(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rax
movq 0x8(%rsp), %rcx
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdi
movq (%rsp), %r8
movq 0x50(%rsp), %r9
callq *%rax
cmpl $0x0, %eax
je 0x237667
movl $0xffffffff, 0x84(%rsp) # imm = 0xFFFFFFFF
jmp 0x237687
jmp 0x237669
movq 0x40(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x40(%rsp)
jmp 0x237582
movl $0x0, 0x84(%rsp)
movl 0x84(%rsp), %eax
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)