LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/greedyfwdmat.c
// Function: showifinlengthrange
static void showifinlengthrange(const GtAlphabet *alphabet,
                                const GtUchar *start,
                                GtUword gmatchlength,
                                GtUword querystart,
                                GtUword subjectpos,
                                void *info)
{
  Rangespecinfo *rangespecinfo = (Rangespecinfo *) info;

  if ((!rangespecinfo->minlength.defined ||
      gmatchlength >= rangespecinfo->minlength.valueunsignedlong) &&
     (!rangespecinfo->maxlength.defined ||
      gmatchlength <= rangespecinfo->maxlength.valueunsignedlong))
  {
    if (rangespecinfo->showquerypos)
    {
      printf(""GT_WU" ",querystart);
    }
    printf(""GT_WU"",gmatchlength);
    if (rangespecinfo->showsubjectpos)
    {
      printf(" "GT_WU"",subjectpos);
    }
    if (rangespecinfo->showsequence)
    {
      (void) putchar(' ');
      gt_alphabet_decode_seq_to_fp(alphabet,stdout,start + querystart,
                                   gmatchlength);
    }
    (void) putchar('\n');
  }
}

// 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 %r9, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
testb $0x1, 0x8(%rax)
je 0x254548
movq 0x20(%rsp), %rax
movq (%rsp), %rcx
cmpq 0x10(%rcx), %rax
jb 0x2545f2
movq (%rsp), %rax
testb $0x1, 0x18(%rax)
je 0x254565
movq 0x20(%rsp), %rax
movq (%rsp), %rcx
cmpq 0x20(%rcx), %rax
ja 0x2545f2
movq (%rsp), %rax
testb $0x1, 0x1(%rax)
je 0x254582
movq 0x18(%rsp), %rsi
leaq 0x32567a(%rip), %rdi    # 0x579bf5
movb $0x0, %al
callq 0x19070
movq 0x20(%rsp), %rsi
leaq 0x33aa7b(%rip), %rdi    # 0x58f009
movb $0x0, %al
callq 0x19070
movq (%rsp), %rax
testb $0x1, 0x2(%rax)
je 0x2545b2
movq 0x10(%rsp), %rsi
leaq 0x32ec79(%rip), %rdi    # 0x583224
movb $0x0, %al
callq 0x19070
movq (%rsp), %rax
testb $0x1, (%rax)
je 0x2545e8
movl $0x20, %edi
callq 0x19960
movq 0x30(%rsp), %rdi
movq 0x3e7967(%rip), %rax    # 0x63bf38
movq (%rax), %rsi
movq 0x28(%rsp), %rdx
addq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rcx
callq 0x7ed90
movl $0xa, %edi
callq 0x19960
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/greedyfwdmat.c
// Function: checkifsequenceisthere
static void checkifsequenceisthere(const GtEncseq *encseq,
                                   GtUword witnessposition,
                                   GtUword gmatchlength,
                                   const GtUchar *qptr)
{
  GtUword i;
  GtUchar cc;

  for (i=0; i<gmatchlength; i++)
  {
    cc = gt_encseq_get_encoded_char_nospecial(encseq,
                                              witnessposition+i,
                                              GT_READMODE_FORWARD);
    if (qptr[i] != cc)
    {
      fprintf(stderr,"sequence of length "GT_WU" at witnesspos "GT_WU""
                     " query["GT_WU"] = %u != %u = subject["GT_WU"]\n",
                     gmatchlength,
                     witnessposition,
                     i,
                     (unsigned int) qptr[i],
                     (unsigned int) cc,
                     witnessposition+(GtUword) i);
      exit(GT_EXIT_PROGRAMMING_ERROR);
    }
  }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x30(%rsp), %rax
jae 0x254950
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
addq 0x20(%rsp), %rsi
xorl %edx, %edx
callq 0xaa7f0
movb %al, 0x1f(%rsp)
movq 0x28(%rsp), %rax
movq 0x20(%rsp), %rcx
movzbl (%rax,%rcx), %eax
movzbl 0x1f(%rsp), %ecx
cmpl %ecx, %eax
je 0x25493b
movq 0x3e76b7(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
movq 0x30(%rsp), %rdx
movq 0x38(%rsp), %rcx
movq 0x20(%rsp), %r8
movq 0x28(%rsp), %rax
movq 0x20(%rsp), %rsi
movzbl (%rax,%rsi), %r9d
movzbl 0x1f(%rsp), %r10d
movq 0x38(%rsp), %rax
addq 0x20(%rsp), %rax
leaq 0x325621(%rip), %rsi    # 0x579f42
movl %r10d, (%rsp)
movq %rax, 0x8(%rsp)
movb $0x0, %al
callq 0x199f0
movl $0x2, %edi
callq 0x19890
jmp 0x25493d
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x2548a1
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/idx-limdfs.c
// Function: genericindex_delete
void genericindex_delete(Genericindex *genericindex)
{
  if (genericindex == NULL)
  {
    return;
  }
  gt_freesuffixarray(genericindex->suffixarray);
  gt_free(genericindex->suffixarray);
  if (genericindex->packedindex != NULL)
  {
    gt_deletevoidBWTSeq(genericindex->packedindex);
  }
  gt_free(genericindex);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x25496e
jmp 0x2549bf
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x233320
movq (%rsp), %rax
movq (%rax), %rdi
leaq 0x325609(%rip), %rsi    # 0x579f91
movl $0x37, %edx
callq 0xe88c0
movq (%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x2549aa
movq (%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x22fd20
movq (%rsp), %rdi
leaq 0x3255dc(%rip), %rsi    # 0x579f91
movl $0x3c, %edx
callq 0xe88c0
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/idx-limdfs.c
// Function: gen_esa_overinterval
static void gen_esa_overinterval(const Genericindex *genericindex,
                                 ProcessIdxMatch processmatch,
                                 void *processmatchinfo,
                                 const Indexbounds *itv,
                                 GT_UNUSED GtUword totallength,
                                 GtIdxMatch *match)
{
  GtUword idx;

  for (idx = itv->leftbound; idx <= itv->rightbound; idx++)
  {
    match->dbstartpos = ESASUFFIXPTRGET(genericindex->suffixarray->suftab,idx);
    /* call processmatch */
    processmatch(processmatchinfo,match);
  }
}

// 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 %r9, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x10(%rcx), %rax
ja 0x25558a
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq 0x58(%rax), %rax
movq (%rsp), %rcx
movq (%rax,%rcx,8), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x28(%rsp), %rax
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq *%rax
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x25553f
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/idx-limdfs.c
// Function: gen_pck_overinterval
static void gen_pck_overinterval(const Genericindex *genericindex,
                                 ProcessIdxMatch processmatch,
                                 void *processmatchinfo,
                                 const Indexbounds *itv,
                                 GtUword totallength,
                                 GtIdxMatch *match)
{
  Bwtseqpositioniterator *bspi;
  GtUword dbstartpos;

  gt_assert(itv->leftbound < itv->rightbound);
  bspi = gt_Bwtseqpositioniterator_new(genericindex->packedindex,
                                       itv->leftbound,itv->rightbound);
  while (gt_Bwtseqpositioniterator_next(&dbstartpos,bspi))
  {
    gt_assert(totallength >= (dbstartpos + itv->offset));
    /* call processmatch */
    match->dbstartpos = totallength - (dbstartpos + itv->offset);
    processmatch(processmatchinfo,match);
  }
  gt_Bwtseqpositioniterator_delete(bspi);
}

// Assembly:
subq $0x48, %rsp
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 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x28(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jb 0x2555fe
movq 0x3e69d3(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2c0a3c(%rip), %rsi    # 0x516013
leaq 0x324c34(%rip), %rdx    # 0x57a212
leaq 0x324c4e(%rip), %rcx    # 0x57a233
leaq 0x3249a5(%rip), %r8     # 0x579f91
movl $0x1c1, %r9d            # imm = 0x1C1
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x255600
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rsi
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rdx
callq 0x22f3a0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x22f410
testb $0x1, %al
jne 0x25563d
jmp 0x2556c4
jmp 0x25563f
movq 0x20(%rsp), %rax
movq 0x8(%rsp), %rcx
movq 0x28(%rsp), %rdx
addq (%rdx), %rcx
cmpq %rcx, %rax
jae 0x25568e
movq 0x3e6943(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2c09ac(%rip), %rsi    # 0x516013
leaq 0x324bda(%rip), %rdx    # 0x57a248
leaq 0x324bbe(%rip), %rcx    # 0x57a233
leaq 0x324915(%rip), %r8     # 0x579f91
movl $0x1c6, %r9d            # imm = 0x1C6
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x255690
movq 0x20(%rsp), %rcx
movq 0x8(%rsp), %rax
movq 0x28(%rsp), %rdx
addq (%rdx), %rax
subq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x38(%rsp), %rax
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq *%rax
jmp 0x255625
movq 0x10(%rsp), %rdi
callq 0x22f5e0
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/idx-limdfs.c
// Function: gt_indexbasedapproxpatternmatching
bool gt_indexbasedapproxpatternmatching(Limdfsresources *limdfsresources,
                                     const GtUchar *pattern,
                                     GtUword patternlength,
                                     GtUword maxdistance,
                                     GtUword maxintervalwidth,
                                     bool skpp,
                                     const AbstractDfstransformer *adfst)
{
  adfst->initdfsconstinfo(limdfsresources->dfsconstinfo,
                          (unsigned int) limdfsresources->alphasize,
                          pattern,
                          patternlength,
                          maxdistance,
                          maxintervalwidth,
                          skpp);
  runlimdfs(limdfsresources,adfst);
  return (limdfsresources->numberofmatches > 0) ? true : false;
}

// Assembly:
subq $0x38, %rsp
movb %r9b, %al
movq 0x40(%rsp), %r9
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
andb $0x1, %al
movb %al, 0xf(%rsp)
movq 0x40(%rsp), %rax
movq 0x10(%rax), %r10
movq 0x30(%rsp), %rax
movq (%rax), %rdi
movq 0x30(%rsp), %rax
movzbl 0xc9(%rax), %esi
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %r8
movq 0x10(%rsp), %r9
movb 0xf(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, (%rsp)
movb $0x0, %al
callq *%r10
movq 0x30(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x255910
movq 0x30(%rsp), %rax
movq 0x128(%rax), %rdx
xorl %eax, %eax
movl $0x1, %ecx
cmpq $0x0, %rdx
cmoval %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/idx-limdfs.c
// Function: gt_indexbasedmstats
void gt_indexbasedmstats(Limdfsresources *limdfsresources,
                      const GtUchar *pattern,
                      GtUword patternlength,
                      const AbstractDfstransformer *adfst)
{
  adfst->initdfsconstinfo(limdfsresources->dfsconstinfo,
                          (unsigned int) limdfsresources->alphasize,
                          pattern,
                          patternlength);
  runlimdfs(limdfsresources,adfst);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %r8
movq 0x20(%rsp), %rax
movq (%rax), %rdi
movq 0x20(%rsp), %rax
movzbl 0xc9(%rax), %esi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
movb $0x0, %al
callq *%r8
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x255910
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/idx-limdfs.c
// Function: gt_indexbasedspacedseeds
void gt_indexbasedspacedseeds(Limdfsresources *limdfsresources,
                           const GtUchar *pattern,
                           GtBitsequence seedbitvector,
                           GtUword seedweight,
                           const AbstractDfstransformer *adfst)
{
  adfst->initdfsconstinfo(limdfsresources->dfsconstinfo,
                          (unsigned int) limdfsresources->alphasize,
                          pattern,
                          seedbitvector,
                          seedweight);
  runlimdfs(limdfsresources,adfst);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq %r8, (%rsp)
movq (%rsp), %rax
movq 0x10(%rax), %r9
movq 0x20(%rsp), %rax
movq (%rax), %rdi
movq 0x20(%rsp), %rax
movzbl 0xc9(%rax), %esi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %r8
movb $0x0, %al
callq *%r9
movq 0x20(%rsp), %rdi
movq (%rsp), %rsi
callq 0x255910
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/idx-limdfs.c
// Function: gt_indexbasedlocali
void gt_indexbasedlocali(Limdfsresources *limdfsresources,
                      GtWord matchscore,
                      GtWord mismatchscore,
                      GtWord gapstart,
                      GtWord gapextend,
                      GtUword threshold,
                      const GtUchar *query,
                      GtUword querylength,
                      const AbstractDfstransformer *adfst)
{
  adfst->initdfsconstinfo(limdfsresources->dfsconstinfo,
                          (unsigned int) limdfsresources->alphasize,
                          matchscore,
                          mismatchscore,
                          gapstart,
                          gapextend,
                          threshold,
                          query,
                          querylength);
  runlimdfs(limdfsresources,adfst);
}

// Assembly:
pushq %rbx
subq $0x50, %rsp
movq 0x70(%rsp), %rax
movq 0x68(%rsp), %rax
movq 0x60(%rsp), %rax
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq %rcx, 0x30(%rsp)
movq %r8, 0x28(%rsp)
movq %r9, 0x20(%rsp)
movq 0x70(%rsp), %rax
movq 0x10(%rax), %r10
movq 0x48(%rsp), %rax
movq (%rax), %rdi
movq 0x48(%rsp), %rax
movzbl 0xc9(%rax), %esi
movq 0x40(%rsp), %rdx
movq 0x38(%rsp), %rcx
movq 0x30(%rsp), %r8
movq 0x28(%rsp), %r9
movq 0x20(%rsp), %rbx
movq 0x60(%rsp), %r11
movq 0x68(%rsp), %rax
movq %rbx, (%rsp)
movq %r11, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movb $0x0, %al
callq *%r10
movq 0x48(%rsp), %rdi
movq 0x70(%rsp), %rsi
callq 0x255910
addq $0x50, %rsp
popq %rbx
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/idx-limdfs.c
// Function: genericmstats
GtUword genericmstats(const Limdfsresources *limdfsresources,
                            const GtUchar *qstart,
                            const GtUchar *qend)
{
  if (limdfsresources->genericindex->withesa)
  {
    return gt_suffixarraymstats (limdfsresources->genericindex->suffixarray,
                              0,
                              0,
                              limdfsresources->genericindex->totallength,
                              NULL,
                              qstart,
                              qend);
  }
  return gt_voidpackedindexmstatsforward(limdfsresources->genericindex->
                                                       packedindex,
                                      0,
                                      0,
                                      limdfsresources->genericindex->
                                                       totallength,
                                      NULL,
                                      qstart,
                                      qend);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq 0xd8(%rax), %rax
testb $0x1, 0x18(%rax)
je 0x255db9
movq 0x18(%rsp), %rax
movq 0xd8(%rax), %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rax
movq 0xd8(%rax), %rax
movq 0x8(%rax), %rcx
movq 0x10(%rsp), %r9
movq 0x8(%rsp), %rax
xorl %edx, %edx
movl %edx, %r8d
movq %r8, %rsi
movq %r8, %rdx
movq %rax, (%rsp)
callq 0x237cb0
movq %rax, 0x20(%rsp)
jmp 0x255dfc
movq 0x18(%rsp), %rax
movq 0xd8(%rax), %rax
movq 0x10(%rax), %rdi
movq 0x18(%rsp), %rax
movq 0xd8(%rax), %rax
movq 0x8(%rax), %rcx
movq 0x10(%rsp), %r9
movq 0x8(%rsp), %rax
xorl %edx, %edx
movl %edx, %r8d
movq %r8, %rsi
movq %r8, %rdx
movq %rax, (%rsp)
callq 0x2309b0
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/idx-limdfs.c
// Function: gt_indexbasedexactpatternmatching
bool gt_indexbasedexactpatternmatching(const Limdfsresources *limdfsresources,
                                    const GtUchar *pattern,
                                    GtUword patternlength)
{
  if (limdfsresources->genericindex->withesa)
  {
    return esa_exactpatternmatching(limdfsresources->genericindex->suffixarray,
                                    pattern,
                                    patternlength,
                                    limdfsresources->currentpathspace,
                                    limdfsresources->processmatch,
                                    limdfsresources->processmatchinfo);
  } else
  {
    return gt_pck_exactpatternmatching(
                                    limdfsresources->genericindex->packedindex,
                                    pattern,
                                    patternlength,
                                    limdfsresources->genericindex->totallength,
                                    limdfsresources->currentpathspace,
                                    limdfsresources->processmatch,
                                    limdfsresources->processmatchinfo);
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq 0xd8(%rax), %rax
testb $0x1, 0x18(%rax)
je 0x255e7f
movq 0x18(%rsp), %rax
movq 0xd8(%rax), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x18(%rsp), %rax
movq 0x118(%rax), %rcx
movq 0x18(%rsp), %rax
movq 0x130(%rax), %r8
movq 0x18(%rsp), %rax
movq 0x138(%rax), %r9
callq 0x255ef0
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0x255edc
movq 0x18(%rsp), %rax
movq 0xd8(%rax), %rax
movq 0x10(%rax), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
movq 0x18(%rsp), %rax
movq 0xd8(%rax), %rax
movq 0x8(%rax), %rcx
movq 0x18(%rsp), %rax
movq 0x118(%rax), %r8
movq 0x18(%rsp), %rax
movq 0x130(%rax), %r9
movq 0x18(%rsp), %rax
movq 0x138(%rax), %rax
movq %rax, (%rsp)
callq 0x230a40
andb $0x1, %al
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/idx-limdfs.c
// Function: esa_exactpatternmatching
static bool esa_exactpatternmatching(const Suffixarray *suffixarray,
                                     const GtUchar *pattern,
                                     GtUword patternlength,
                                     GT_UNUSED const GtUchar *dbsubstring,
                                     ProcessIdxMatch processmatch,
                                     void *processmatchinfo)
{
  GtMMsearchiterator *mmsi;
  GtUword dbstartpos,
         totallength = gt_encseq_total_length(suffixarray->encseq);
  bool nomatches;
  GtIdxMatch match;

  mmsi = gt_mmsearchiterator_new_complete_plain(suffixarray->encseq,
                                           suffixarray->suftab,
                                           0,  /* leftbound */
                                           totallength, /* rightbound */
                                           0, /* offset */
                                           suffixarray->readmode,
                                           pattern,
                                           patternlength);
  nomatches = gt_mmsearchiterator_isempty(mmsi);
  match.dbabsolute = true;
  match.dblen = (GtUword) patternlength;
  match.dbsubstring = pattern;
  match.querystartpos = 0;
  match.querylen = patternlength;
  match.distance = 0;
  match.alignment = NULL;
  while (gt_mmsearchiterator_next(&dbstartpos,mmsi))
  {
    /* call processmatch */
    match.dbstartpos = dbstartpos;
    processmatch(processmatchinfo,&match);
  }
  gt_mmsearchiterator_delete(mmsi);
  return nomatches ? false : true;
}

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq %rdx, 0x90(%rsp)
movq %rcx, 0x88(%rsp)
movq %r8, 0x80(%rsp)
movq %r9, 0x78(%rsp)
movq 0xa0(%rsp), %rax
movq (%rax), %rdi
callq 0xa9d00
movq %rax, 0x60(%rsp)
movq 0xa0(%rsp), %rax
movq (%rax), %rdi
movq 0xa0(%rsp), %rax
movq 0x58(%rax), %rsi
movq 0x60(%rsp), %rcx
movq 0xa0(%rsp), %rax
movl 0x48(%rax), %r9d
movq 0x98(%rsp), %r10
movq 0x90(%rsp), %rax
xorl %edx, %edx
movl %edx, %r8d
movq %r8, %rdx
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x238170
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rdi
callq 0x2383f0
andb $0x1, %al
movb %al, 0x5f(%rsp)
movb $0x1, 0x10(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x98(%rsp), %rax
movq %rax, 0x30(%rsp)
movq $0x0, 0x38(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x40(%rsp)
movq $0x0, 0x48(%rsp)
movq $0x0, 0x50(%rsp)
movq 0x70(%rsp), %rsi
leaq 0x68(%rsp), %rdi
callq 0x238350
testb $0x1, %al
jne 0x255ff8
jmp 0x256018
movq 0x68(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x80(%rsp), %rax
movq 0x78(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq *%rax
jmp 0x255fe3
movq 0x70(%rsp), %rdi
callq 0x2384d0
movb 0x5f(%rsp), %dl
movl $0x1, %eax
xorl %ecx, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
cmpl $0x0, %eax
setne %al
andb $0x1, %al
addq $0xa8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/idx-limdfs.c
// Function: gt_limdfs_getencodedchar
GtUchar gt_limdfs_getencodedchar(const Limdfsresources *limdfsresources,
                              GtUword pos,
                              GtReadmode readmode)
{
  gt_assert(limdfsresources->encseq != NULL);

  return gt_encseq_get_encoded_char(limdfsresources->encseq,
                                           pos,
                                           readmode);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl %edx, 0x4(%rsp)
movq 0x10(%rsp), %rax
cmpq $0x0, 0xf8(%rax)
jne 0x2560a9
movq 0x3e5f28(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2bff91(%rip), %rsi    # 0x516013
leaq 0x3240c5(%rip), %rdx    # 0x57a14e
leaq 0x3240de(%rip), %rcx    # 0x57a16e
leaq 0x323efa(%rip), %r8     # 0x579f91
movl $0x55f, %r9d            # imm = 0x55F
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2560ab
movq 0x10(%rsp), %rax
movq 0xf8(%rax), %rdi
movq 0x8(%rsp), %rsi
movl 0x4(%rsp), %edx
callq 0xa9da0
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/idx-limdfs.c
// Function: gt_intervalwidthleq
bool gt_intervalwidthleq(const Limdfsresources *limdfsresources,
                      GtUword leftbound,GtUword rightbound)
{
  GtUword width;

  if (limdfsresources->genericindex->withesa)
  {
    if (leftbound > rightbound)
    {
      width = 0;
    } else
    {
      width = rightbound - leftbound + 1;
    }
  } else
  {
    if (leftbound >= rightbound)
    {
      width = 0;
    } else
    {
      width = rightbound - leftbound;
    }
  }
  if (width > 0 && width <= (GtUword) limdfsresources->maxintervalwidth)
  {
    return true;
  }
  return false;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq -0x10(%rsp), %rax
movq 0xd8(%rax), %rax
testb $0x1, 0x18(%rax)
je 0x25611d
movq -0x18(%rsp), %rax
cmpq -0x20(%rsp), %rax
jbe 0x256108
movq $0x0, -0x28(%rsp)
jmp 0x25611b
movq -0x20(%rsp), %rax
subq -0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rsp)
jmp 0x256145
movq -0x18(%rsp), %rax
cmpq -0x20(%rsp), %rax
jb 0x256134
movq $0x0, -0x28(%rsp)
jmp 0x256143
movq -0x20(%rsp), %rax
subq -0x18(%rsp), %rax
movq %rax, -0x28(%rsp)
jmp 0x256145
cmpq $0x0, -0x28(%rsp)
jbe 0x256167
movq -0x28(%rsp), %rax
movq -0x10(%rsp), %rcx
cmpq 0xe8(%rcx), %rax
ja 0x256167
movb $0x1, -0x1(%rsp)
jmp 0x25616c
movb $0x0, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/idx-limdfs.c
// Function: esa_exact_pattern_count
GtUword esa_exact_pattern_count(const Suffixarray *suffixarray,
                                      const GtUchar *pattern,
                                      GtUword patternlength) {
  GtMMsearchiterator *mmsi;
  GtUword count,
                totallength = gt_encseq_total_length(suffixarray->encseq);

  mmsi = gt_mmsearchiterator_new_complete_plain(suffixarray->encseq,
                                           suffixarray->suftab,
                                           0,  /* leftbound */
                                           totallength, /* rightbound */
                                           0, /* offset */
                                           suffixarray->readmode,
                                           pattern,
                                           patternlength);

  count = gt_mmsearchiterator_count(mmsi);
  gt_mmsearchiterator_delete(mmsi);
  return count;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq (%rax), %rdi
callq 0xa9d00
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rax
movq (%rax), %rdi
movq 0x40(%rsp), %rax
movq 0x58(%rax), %rsi
movq 0x18(%rsp), %rcx
movq 0x40(%rsp), %rax
movl 0x48(%rax), %r9d
movq 0x38(%rsp), %r10
movq 0x30(%rsp), %rax
xorl %edx, %edx
movl %edx, %r8d
movq %r8, %rdx
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x238170
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x2382c0
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x2384d0
movq 0x20(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/idx-limdfs.c
// Function: gt_indexbased_exact_pattern_count
GtUword gt_indexbased_exact_pattern_count(
                                              const Genericindex *genericindex,
                                              const GtUchar *pattern,
                                              GtUword patternlength) {
  if (genericindex->withesa) {
    return esa_exact_pattern_count(genericindex->suffixarray,
                                    pattern,
                                    patternlength);
  }
  else {
    return gt_pck_exact_pattern_count(genericindex->packedindex,
                                       pattern,
                                       patternlength);
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rax
testb $0x1, 0x18(%rax)
je 0x25630c
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x256240
movq %rax, 0x20(%rsp)
jmp 0x256329
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x231610
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/idx-limdfs.c
// Function: initlcpinfostack
static void initlcpinfostack(Limdfsresources *limdfsresources,
                             const AbstractDfstransformer *adfst)
{
  Lcpintervalwithinfo *stackptr;

  limdfsresources->stack.nextfreeLcpintervalwithinfo = 0;
  stackptr = allocateStackspace(limdfsresources,adfst);
  stackptr->lcpitv.offset = 0;
  stackptr->lcpitv.leftbound = 0;
  stackptr->lcpitv.rightbound = limdfsresources->genericindex->withesa
                                ? limdfsresources->genericindex->totallength
                                : limdfsresources->genericindex->totallength+1;
  stackptr->lcpitv.code = 0;
  if (limdfsresources->keepexpandedonstack)
  {
    stackptr->previousstackelem = 0; /* Just to let it be defined */
    stackptr->keeponstack = true;
  }
  if (adfst->initrootLimdfsstate != NULL)
  {
    adfst->initrootLimdfsstate(stackptr->aliasstate,
                               limdfsresources->dfsconstinfo);
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq $0x0, 0x30(%rax)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x256c40
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq $0x0, (%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0x8(%rax)
movq 0x20(%rsp), %rax
movq 0xd8(%rax), %rax
testb $0x1, 0x18(%rax)
je 0x2563b1
movq 0x20(%rsp), %rax
movq 0xd8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x2563ca
movq 0x20(%rsp), %rax
movq 0xd8(%rax), %rax
movq 0x8(%rax), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x20(%rsp), %rax
testb $0x1, 0xc8(%rax)
je 0x256409
movq 0x10(%rsp), %rax
movq $0x0, 0x58(%rax)
movq 0x10(%rsp), %rax
movb $0x1, 0x50(%rax)
movq 0x18(%rsp), %rax
cmpq $0x0, 0x28(%rax)
je 0x256431
movq 0x18(%rsp), %rax
movq 0x28(%rax), %rax
movq 0x10(%rsp), %rdi
addq $0x28, %rdi
movq 0x20(%rsp), %rcx
movq (%rcx), %rsi
callq *%rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/idx-limdfs.c
// Function: currentparent
static const Lcpintervalwithinfo *currentparent(const Limdfsresources
                                                *limdfsresources)
{
  const Lcpintervalwithinfo *ptr;

  if (limdfsresources->keepexpandedonstack)
  {
    gt_assert(limdfsresources->parentindex <
              limdfsresources->stack.nextfreeLcpintervalwithinfo);
  }
  ptr = limdfsresources->keepexpandedonstack
           ? (limdfsresources->stack.spaceLcpintervalwithinfo +
              limdfsresources->parentindex)
           : &limdfsresources->copyofparent;
  return ptr;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
testb $0x1, 0xc8(%rax)
je 0x2564ac
jmp 0x256459
movq 0x10(%rsp), %rax
movq 0xc0(%rax), %rax
movq 0x10(%rsp), %rcx
cmpq 0x30(%rcx), %rax
jb 0x2564a8
movq 0x3e5b29(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2bfb92(%rip), %rsi    # 0x516013
leaq 0x323ee4(%rip), %rdx    # 0x57a36c
leaq 0x323f2f(%rip), %rcx    # 0x57a3be
leaq 0x323afb(%rip), %r8     # 0x579f91
movl $0x32c, %r9d            # imm = 0x32C
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2564aa
jmp 0x2564ac
movq 0x10(%rsp), %rax
testb $0x1, 0xc8(%rax)
je 0x2564d9
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rsp), %rcx
imulq $0x60, 0xc0(%rcx), %rcx
addq %rcx, %rax
movq %rax, (%rsp)
jmp 0x2564e6
movq 0x10(%rsp), %rax
addq $0x38, %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/idx-limdfs.c
// Function: allocateStackspace
static Lcpintervalwithinfo *allocateStackspace(Limdfsresources *limdfsresources,
                                               const AbstractDfstransformer
                                                      *adfst)
{
  GtArrayLcpintervalwithinfo *stack = &limdfsresources->stack;

  if (stack->nextfreeLcpintervalwithinfo >= stack->allocatedLcpintervalwithinfo)
  {
    GtUword idx;
    const GtUword addelems = 32UL;

    stack->spaceLcpintervalwithinfo
      = gt_realloc(stack->spaceLcpintervalwithinfo,
                   sizeof *stack->spaceLcpintervalwithinfo
                   * (stack->allocatedLcpintervalwithinfo + addelems));
    if (adfst->initLimdfsstackelem != NULL)
    {
      for (idx = stack->allocatedLcpintervalwithinfo;
           idx < stack->allocatedLcpintervalwithinfo + addelems; idx++)
      {
        adfst->initLimdfsstackelem(stack->spaceLcpintervalwithinfo[idx].
                                   aliasstate);
      }
    }
    stack->allocatedLcpintervalwithinfo += addelems;
  }
  return stack->spaceLcpintervalwithinfo + stack->nextfreeLcpintervalwithinfo++;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jb 0x256d25
movq $0x20, (%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
addq $0x20, %rax
imulq $0x60, %rax, %rsi
leaq 0x3232f5(%rip), %rdx    # 0x579f91
movl $0x151, %ecx            # imm = 0x151
callq 0xe8540
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rax
cmpq $0x0, 0x30(%rax)
je 0x256d14
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %rcx
addq $0x20, %rcx
cmpq %rcx, %rax
jae 0x256d12
movq 0x18(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x10(%rsp), %rcx
movq (%rcx), %rdi
imulq $0x60, 0x8(%rsp), %rcx
addq %rcx, %rdi
addq $0x28, %rdi
callq *%rax
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x256ccb
jmp 0x256d14
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rcx
addq $0x20, %rcx
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rsp), %rdx
movq 0x10(%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0x10(%rdx)
imulq $0x60, %rcx, %rcx
addq %rcx, %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/idx-limdfs.c
// Function: processchildinterval
static void processchildinterval(Limdfsresources *limdfsresources,
                                 const Indexbounds *child,
                                 const AbstractDfstransformer *adfst)
{
  if (child->leftbound + 1 < child->rightbound ||
      (limdfsresources->genericindex->withesa &&
       child->leftbound + 1 == child->rightbound))
  {
    pushandpossiblypop(limdfsresources, child, adfst);
  } else
  {
    if (limdfsresources->genericindex->withesa)
    {
      esa_overcontext(limdfsresources,child,adfst);
    } else
    {
      pck_overcontext(limdfsresources,child,adfst);
    }
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
addq $0x1, %rax
movq 0x8(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jb 0x256da4
movq 0x10(%rsp), %rax
movq 0xd8(%rax), %rax
testb $0x1, 0x18(%rax)
je 0x256db9
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
addq $0x1, %rax
movq 0x8(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jne 0x256db9
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq 0x2571e0
jmp 0x256df5
movq 0x10(%rsp), %rax
movq 0xd8(%rax), %rax
testb $0x1, 0x18(%rax)
je 0x256de0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq 0x256e00
jmp 0x256df3
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq 0x257550
jmp 0x256df5
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/idx-limdfs.c
// Function: esa_overinterval
static void esa_overinterval(Limdfsresources *limdfsresources,
                             const Indexbounds *itv,
                             GtIdxMatch *match)
{
  gen_esa_overinterval(limdfsresources->genericindex,
                       limdfsresources->processmatch,
                       limdfsresources->processmatchinfo,
                       itv,
                       limdfsresources->genericindex->totallength,
                       match);
  limdfsresources->numberofmatches += (itv->rightbound - itv->leftbound + 1);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x10(%rsp), %rax
movq 0xd8(%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x130(%rax), %rsi
movq 0x10(%rsp), %rax
movq 0x138(%rax), %rdx
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq 0xd8(%rax), %rax
movq 0x8(%rax), %r8
movq (%rsp), %r9
callq 0x255510
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rcx
movq 0x8(%rsp), %rax
subq 0x8(%rax), %rcx
addq $0x1, %rcx
movq 0x10(%rsp), %rax
addq 0x128(%rax), %rcx
movq %rcx, 0x128(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/idx-limdfs.c
// Function: pck_overinterval
static void pck_overinterval(Limdfsresources *limdfsresources,
                             const Indexbounds *itv,
                             GtIdxMatch *match)
{
  gen_pck_overinterval(limdfsresources->genericindex,
                       limdfsresources->processmatch,
                       limdfsresources->processmatchinfo,
                       itv,
                       limdfsresources->genericindex->totallength,
                       match);
  limdfsresources->numberofmatches += (itv->rightbound - itv->leftbound);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x10(%rsp), %rax
movq 0xd8(%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x130(%rax), %rsi
movq 0x10(%rsp), %rax
movq 0x138(%rax), %rdx
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq 0xd8(%rax), %rax
movq 0x8(%rax), %r8
movq (%rsp), %r9
callq 0x255590
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rcx
movq 0x8(%rsp), %rax
subq 0x8(%rax), %rcx
movq 0x10(%rsp), %rax
addq 0x128(%rax), %rcx
movq %rcx, 0x128(%rax)
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/idx-limdfs.c
// Function: initparentcopy
static void initparentcopy(Limdfsresources *limdfsresources,
                           const AbstractDfstransformer *adfst)
{
  if (!limdfsresources->keepexpandedonstack)
  {
    if (adfst->copyLimdfsstate == NULL)
    {
      memcpy(limdfsresources->copyofcopyofparentstate,
             limdfsresources->copyofparent.aliasstate,
             adfst->sizeofdfsstate);
    } else
    {
      adfst->copyLimdfsstate(limdfsresources->copyofcopyofparentstate,
                             limdfsresources->copyofparent.aliasstate,
                             limdfsresources->dfsconstinfo);
    }
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
testb $0x1, 0xc8(%rax)
jne 0x257d8e
movq 0x8(%rsp), %rax
cmpq $0x0, 0x40(%rax)
jne 0x257d60
movq 0x10(%rsp), %rdi
addq $0x98, %rdi
movq 0x10(%rsp), %rsi
addq $0x38, %rsi
addq $0x28, %rsi
movq 0x8(%rsp), %rax
movq (%rax), %rdx
callq 0x19610
jmp 0x257d8c
movq 0x8(%rsp), %rax
movq 0x40(%rax), %rax
movq 0x10(%rsp), %rdi
addq $0x98, %rdi
movq 0x10(%rsp), %rsi
addq $0x38, %rsi
addq $0x28, %rsi
movq 0x10(%rsp), %rcx
movq (%rcx), %rdx
callq *%rax
jmp 0x257d8e
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/idx-limdfs.c
// Function: smalldepthbwtrangesplitwithoutspecial
static void smalldepthbwtrangesplitwithoutspecial(GtArrayBoundswithchar *bwci,
                                                  const Mbtab **mbtab,
                                                  GtUchar alphasize,
                                                  GtCodetype parentcode,
                                                  GtUword childdepth)
{
  GtCodetype childcode;
  const Mbtab *mbptr;

  gt_assert(childdepth > 0);
  bwci->nextfreeBoundswithchar = 0;
  childcode = parentcode * alphasize;
  for (mbptr = mbtab[childdepth] + childcode;
       mbptr < mbtab[childdepth] + childcode + alphasize;
       mbptr++)
  {
    if (mbptr->lowerbound < mbptr->upperbound)
    {
      bwci->spaceBoundswithchar[bwci->nextfreeBoundswithchar].inchar
        = (GtUchar) (mbptr - (mbtab[childdepth] + childcode));
      bwci->spaceBoundswithchar[bwci->nextfreeBoundswithchar].lbound
        = mbptr->lowerbound;
      bwci->spaceBoundswithchar[bwci->nextfreeBoundswithchar++].rbound
        = mbptr->upperbound;
    }
  }
}

// Assembly:
subq $0x38, %rsp
movb %dl, %al
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movb %al, 0x27(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
ja 0x25804e
movq 0x3e3f83(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2bdfec(%rip), %rsi    # 0x516013
leaq 0x322684(%rip), %rdx    # 0x57a6b2
leaq 0x32268c(%rip), %rcx    # 0x57a6c1
leaq 0x321f55(%rip), %r8     # 0x579f91
movl $0x405, %r9d            # imm = 0x405
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x258050
movq 0x30(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x18(%rsp), %rax
movzbl 0x27(%rsp), %ecx
imulq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq 0x28(%rsp), %rcx
movq 0x10(%rsp), %rdx
movq (%rcx,%rdx,8), %rcx
movq 0x8(%rsp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movzbl 0x27(%rsp), %edx
movslq %edx, %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0x258179
movq (%rsp), %rax
movq (%rax), %rax
movq (%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x258166
movq (%rsp), %rax
movq 0x28(%rsp), %rcx
movq 0x10(%rsp), %rdx
movq (%rcx,%rdx,8), %rcx
movq 0x8(%rsp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
subq %rcx, %rax
sarq $0x4, %rax
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 (%rsp), %rax
movq (%rax), %rcx
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq 0x30(%rsp), %rdx
imulq $0x18, 0x10(%rdx), %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq (%rsp), %rax
movq 0x8(%rax), %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 0x258168
movq (%rsp), %rax
addq $0x10, %rax
movq %rax, (%rsp)
jmp 0x25808e
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/idxlocali.c
// Function: storematch
static void storematch(void *info,const GtIdxMatch *match)
{
  Storematchinfo *storematch = (Storematchinfo *) info;
  GtUword seqnum;

  if (match->dbabsolute)
  {
    seqnum = gt_encseq_seqnum(storematch->encseq,
                                           match->dbstartpos);
  } else
  {
    seqnum = match->dbseqnum;
  }
  if (!GT_ISIBITSET(storematch->hasmatch,seqnum))
  {
    GT_SETIBIT(storematch->hasmatch,seqnum);
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
testb $0x1, (%rax)
je 0x258c1f
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0xb03a0
movq %rax, 0x8(%rsp)
jmp 0x258c2d
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rsp), %rcx
shrq $0x6, %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rsp), %rcx
andq $0x3f, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
shrq %cl, %rdx
movq %rdx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
jne 0x258c95
movq 0x8(%rsp), %rcx
andq $0x3f, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
shrq %cl, %rdx
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rsp), %rcx
shrq $0x6, %rcx
orq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/idxlocali.c
// Function: idxlocali_showmatch
static void idxlocali_showmatch(void *processinfo,const GtIdxMatch *match)
{
  Showmatchinfo *showmatchinfo = (Showmatchinfo *) processinfo;
  GtUword seqnum;
  GtUword relpos;

  if (match->dbabsolute)
  {
    GtUword seqstartpos;
    seqnum = gt_encseq_seqnum(showmatchinfo->encseq, match->dbstartpos);
    seqstartpos = gt_encseq_seqstartpos(showmatchinfo->encseq, seqnum);
    gt_assert(seqstartpos <= match->dbstartpos);
    relpos = match->dbstartpos - seqstartpos;
  } else
  {
    relpos = match->dbstartpos;
    seqnum = match->dbseqnum;
  }
  printf(""GT_WU"\t"GT_WU"\t",seqnum,relpos);
  printf(""GT_WU"\t",match->dblen);
  printf("\t" Formatuint64_t "\t"GT_WU"\t"GT_WU"\t"GT_WU"\n",
              PRINTuint64_tcast(showmatchinfo->queryunit),
              match->querystartpos,
              match->querylen,
              match->distance);
  if (showmatchinfo->showalignment)
  {
    gt_alignment_show_with_mapped_chars(
                (const GtAlignment *) match->alignment,
                showmatchinfo->characters,
                showmatchinfo->wildcardshow,
                stdout,
                70);
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rax
testb $0x1, (%rax)
je 0x258d59
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0xb03a0
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0xb0530
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x28(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jbe 0x258d42
movq 0x3e328f(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2bd2f8(%rip), %rsi    # 0x516013
leaq 0x321a98(%rip), %rdx    # 0x57a7ba
leaq 0x321ab2(%rip), %rcx    # 0x57a7db
leaq 0x3219b7(%rip), %r8     # 0x57a6e7
movl $0x34, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x258d44
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
subq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x258d75
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0x35a50e(%rip), %rdi    # 0x5b3294
movb $0x0, %al
callq 0x19070
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rsi
leaq 0x3254f3(%rip), %rdi    # 0x57e290
movb $0x0, %al
callq 0x19070
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rsi
movq 0x28(%rsp), %rax
movq 0x28(%rax), %rdx
movq 0x28(%rsp), %rax
movq 0x30(%rax), %rcx
movq 0x28(%rsp), %rax
movq 0x38(%rax), %r8
leaq 0x2c8b9f(%rip), %rdi    # 0x52196e
movb $0x0, %al
callq 0x19070
movq 0x20(%rsp), %rax
testb $0x1, 0x11(%rax)
je 0x258e12
movq 0x28(%rsp), %rax
movq 0x40(%rax), %rdi
movq 0x20(%rsp), %rax
movq (%rax), %rsi
movq 0x20(%rsp), %rax
movb 0x10(%rax), %al
movq 0x3e3137(%rip), %rcx    # 0x63bf38
movq (%rcx), %rcx
movl $0x46, %r8d
movzbl %al, %edx
callq 0x12c2c0
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/idxlocalidp.c
// Function: gt_reinitLocaliTracebackstate
void gt_reinitLocaliTracebackstate(Limdfsconstinfo *lci,
                                GtUword dbprefixlen,
                                GtUword pprefixlen)
{
  LocaliTracebackstate *tbs = &lci->tbs;

  tbs->dbprefixlen = tbs->dbcurrent = dbprefixlen;
  tbs->queryend = tbs->querypos = pprefixlen;
  if (dbprefixlen > (GtUword) tbs->allocatedGtUchardbsubstring)
  {
    tbs->spaceGtUchardbsubstring = gt_realloc(tbs->spaceGtUchardbsubstring,
                                            sizeof (GtUchar) * dbprefixlen);
  }
  gt_alignment_reset(tbs->alignment);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
addq $0x40, %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x18(%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq 0x28(%rcx), %rax
jbe 0x258ead
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x18(%rsp), %rsi
shlq $0x0, %rsi
leaq 0x321969(%rip), %rdx    # 0x57a800
movl $0x2b0, %ecx            # imm = 0x2B0
callq 0xe8540
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x12a560
addq $0x28, %rsp
retq