LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rax
movq 0xd8(%rdi), %rdx
cmpb $0x1, 0x18(%rdx)
jne 0x1609ae
movq (%rdx), %r12
movq 0x130(%rax), %rbp
movq 0x138(%rax), %rbx
movq (%r12), %rdi
callq 0x7055e
movq (%r12), %rdi
movq 0x58(%r12), %rsi
movl 0x48(%r12), %r9d
xorl %edx, %edx
movq %rax, %rcx
xorl %r8d, %r8d
pushq %r14
pushq %r15
callq 0x14fb98
popq %rcx
popq %rdx
movq %rax, %r12
movq %rax, %rdi
callq 0x14fcf1
movb %al, 0x7(%rsp)
leaq 0x10(%rsp), %r13
movb $0x1, (%r13)
movq %r14, 0x18(%r13)
movq %r15, 0x20(%r13)
andq $0x0, 0x28(%r13)
movq %r14, 0x30(%r13)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%r13)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %r12, %rsi
callq 0x14fc8c
testb %al, %al
je 0x16099a
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq %rbx, %rdi
movq %r13, %rsi
callq *%rbp
jmp 0x160977
movq %r12, %rdi
callq 0x14fd61
movb 0x7(%rsp), %al
xorb $0x1, %al
addq $0x58, %rsp
jmp 0x1609dd
movq 0x8(%rdx), %rcx
movq 0x10(%rdx), %rdi
movq 0x118(%rax), %r8
movq 0x130(%rax), %r9
subq $0x8, %rsp
movq %r15, %rsi
movq %r14, %rdx
pushq 0x138(%rax)
callq 0x14bdd2
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rdi), %rdi
callq 0x7055e
movq (%r15), %rdi
movq 0x58(%r15), %rsi
movl 0x48(%r15), %r9d
xorl %edx, %edx
movq %rax, %rcx
xorl %r8d, %r8d
pushq %rbx
pushq %r14
callq 0x14fb98
popq %rcx
popq %rdx
movq %rax, %rbx
movq %rax, %rdi
callq 0x14fc3b
movq %rax, %r14
movq %rbx, %rdi
callq 0x14fd61
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
cmpb $0x1, 0xc8(%rdi)
jne 0x160b73
movq 0xc0(%rdi), %rax
cmpq 0x30(%rdi), %rax
jae 0x160b7b
imulq $0x60, %rax, %rax
addq 0x20(%rdi), %rax
retq
addq $0x38, %rdi
movq %rdi, %rax
retq
pushq %rax
movq 0x2d73e5(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x184486(%rip), %rsi    # 0x2e5013
leaq 0x1e72ff(%rip), %rdx    # 0x347e93
leaq 0x1e734a(%rip), %rcx    # 0x347ee5
leaq 0x1e6f16(%rip), %r8     # 0x347ab8
movl $0x32c, %r9d            # imm = 0x32C
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x30(%rdi), %rcx
movq 0x20(%rdi), %rax
movq 0x28(%rdi), %rdx
cmpq %rdx, %rcx
jb 0x160fd6
movq %rsi, %r14
imulq $0x60, %rdx, %rsi
addq $0xc00, %rsi            # imm = 0xC00
leaq 0x1e6b3c(%rip), %rdx    # 0x347ab8
movq %rax, %rdi
movl $0x151, %ecx            # imm = 0x151
callq 0x93472
movq %rax, 0x20(%rbx)
cmpq $0x0, 0x30(%r14)
movq 0x28(%rbx), %rcx
je 0x160fca
imulq $0x60, %rcx, %r15
addq $0x28, %r15
movq %rcx, %r12
addq $0x20, %rcx
cmpq %rcx, %r12
jae 0x160fc4
movq 0x20(%rbx), %rdi
addq %r15, %rdi
callq *0x30(%r14)
incq %r12
movq 0x28(%rbx), %rcx
addq $0x60, %r15
jmp 0x160fa3
movq 0x20(%rbx), %rax
jmp 0x160fce
addq $0x20, %rcx
movq %rcx, 0x28(%rbx)
movq 0x30(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x30(%rbx)
imulq $0x60, %rcx, %rcx
addq %rax, %rcx
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r9
movq %rsi, %rbx
movq %rdi, %r14
movq 0xd8(%rdi), %rdi
movq 0x130(%r14), %rsi
movq 0x138(%r14), %rdx
movq %rbx, %rcx
callq 0x16033e
movq 0x10(%rbx), %rax
movq 0x128(%r14), %rcx
subq 0x8(%rbx), %rax
addq %rcx, %rax
incq %rax
movq %rax, 0x128(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r9
movq %rsi, %rbx
movq %rdi, %r14
movq 0xd8(%rdi), %rdi
movq 0x130(%r14), %rsi
movq 0x138(%r14), %rdx
movq 0x8(%rdi), %r8
movq %rbx, %rcx
callq 0x16038f
movq 0x10(%rbx), %rax
subq 0x8(%rbx), %rax
addq %rax, 0x128(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/idxlocali.c
// Function: gt_checkandresetstorematch
void gt_checkandresetstorematch(GT_UNUSED uint64_t queryunit,
                             Storematchinfo *storeonline,
                             Storematchinfo *storeoffline)
{
  GtUword seqnum, countmatchseq = 0,
    numofdbsequences = gt_encseq_num_of_sequences(storeonline->encseq);

  for (seqnum = 0; seqnum < numofdbsequences; seqnum++)
  {
#ifndef NDEBUG
    if (GT_ISIBITSET(storeonline->hasmatch,seqnum) &&
        !GT_ISIBITSET(storeoffline->hasmatch,seqnum))
    {
      fprintf(stderr,"query " Formatuint64_t " refseq "GT_WU": "
                     "online has match but offline not\n",
                     PRINTuint64_tcast(queryunit),seqnum);
      exit(GT_EXIT_PROGRAMMING_ERROR);
    }
    if (!GT_ISIBITSET(storeonline->hasmatch,seqnum) &&
        GT_ISIBITSET(storeoffline->hasmatch,seqnum))
    {
      fprintf(stderr,"query " Formatuint64_t " refseq "GT_WU": "
                     "offline has match but online not\n",
                     PRINTuint64_tcast(queryunit),seqnum);
      exit(GT_EXIT_PROGRAMMING_ERROR);
    }
#endif
    if (GT_ISIBITSET(storeonline->hasmatch,seqnum))
    {
      countmatchseq++;
    }
  }
  GT_CLEARBITTAB(storeonline->hasmatch,numofdbsequences);
  GT_CLEARBITTAB(storeoffline->hasmatch,numofdbsequences);
  printf("matching sequences: "GT_WU"\n",countmatchseq);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
callq 0x705a1
movq 0x8(%r14), %rdi
xorl %r14d, %r14d
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x161b3c
movq %rcx, %r9
shrq $0x6, %r9
movq %rdx, %rsi
shrq %cl, %rsi
movq (%rdi,%r9,8), %r8
movq 0x8(%r15), %r10
movq (%r10,%r9,8), %r9
testq %rsi, %r8
je 0x161b27
testq %rsi, %r9
jne 0x161b2c
jmp 0x161b85
testq %rsi, %r9
jne 0x161b98
andq %rsi, %r8
cmpq $0x1, %r8
sbbq $-0x1, %r14
incq %rcx
jmp 0x161afd
leaq -0x1(%rax), %rcx
shrq $0x6, %rcx
cmpq $0x40, %rax
leaq 0x8(,%rcx,8), %rax
pushq $0x8
popq %rbx
cmovaeq %rax, %rbx
xorl %esi, %esi
movq %rbx, %rdx
callq 0x17380
movq 0x8(%r15), %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x17380
leaq 0x1e66e9(%rip), %rdi    # 0x34825f
movq %r14, %rsi
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
jmp 0x17070
movq 0x2d63dc(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1e6659(%rip), %rsi    # 0x3481ef
jmp 0x161ba9
movq 0x2d63c9(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1e667e(%rip), %rsi    # 0x348227
movq %rbx, %rdx
xorl %eax, %eax
callq 0x17a50
pushq $0x2
popq %rdi
callq 0x178f0
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, (%rsi)
jne 0x161ffc
movq (%rbx), %rdi
movq 0x10(%rsi), %rsi
callq 0x74c9d
movq %rax, %rcx
jmp 0x162000
movq 0x8(%rsi), %rcx
movq 0x8(%rbx), %rax
movq %rcx, %rdx
shrq $0x6, %rdx
movq (%rax,%rdx,8), %rsi
movabsq $-0x8000000000000000, %rdi # imm = 0x8000000000000000
shrq %cl, %rdi
testq %rdi, %rsi
jne 0x162028
orq %rdi, %rsi
movq %rsi, (%rax,%rdx,8)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
cmpb $0x1, (%rsi)
jne 0x162095
movq 0x18(%rbx), %rdi
movq 0x10(%r14), %rsi
callq 0x74c9d
movq %rax, %r15
movq 0x18(%rbx), %rdi
movq %rax, %rsi
callq 0x74d9c
movq 0x10(%r14), %rdx
subq %rax, %rdx
jae 0x16209d
movq 0x2d5f02(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x182fa3(%rip), %rsi    # 0x2e5013
leaq 0x1e6235(%rip), %rdx    # 0x3482ac
leaq 0x1e624f(%rip), %rcx    # 0x3482cd
leaq 0x1e6154(%rip), %r8     # 0x3481d9
pushq $0x34
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
movq 0x8(%r14), %r15
movq 0x10(%r14), %rdx
leaq 0x21c1b4(%rip), %rdi    # 0x37e258
movq %r15, %rsi
xorl %eax, %eax
callq 0x17070
movq 0x18(%r14), %rsi
leaq 0x1e9aef(%rip), %rdi    # 0x34bba8
xorl %eax, %eax
callq 0x17070
movq 0x8(%rbx), %rsi
movq 0x28(%r14), %rdx
movq 0x30(%r14), %rcx
movq 0x38(%r14), %r8
leaq 0x18e82c(%rip), %rdi    # 0x2f0903
xorl %eax, %eax
callq 0x17070
cmpb $0x1, 0x11(%rbx)
jne 0x162107
movq 0x40(%r14), %rdi
movq (%rbx), %rsi
movzbl 0x10(%rbx), %edx
movq 0x2d5dba(%rip), %rax    # 0x437eb0
movq (%rax), %rcx
pushq $0x46
popq %r8
popq %rbx
popq %r14
popq %r15
jmp 0xb63a4
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbx
movq %rdi, %rbx
movq %rsi, 0x40(%rdi)
movq %rsi, 0x48(%rdi)
movq %rdx, 0x50(%rdi)
movq %rdx, 0x58(%rdi)
cmpq %rsi, 0x68(%rdi)
jae 0x162143
movq 0x60(%rbx), %rdi
leaq 0x1e61bf(%rip), %rdx    # 0x3482f4
movl $0x2b0, %ecx            # imm = 0x2B0
callq 0x93472
movq %rax, 0x60(%rbx)
movq 0x70(%rbx), %rdi
popq %rbx
jmp 0xb52f8
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/idxlocalidp.c
// Function: gt_completealignmentfromLocaliTracebackstate
const void *gt_completealignmentfromLocaliTracebackstate(
                                        GtUword *alignedquerylength,
                                        const Limdfsconstinfo *lci)
{
#ifndef NDEBUG
  Scoretype evalscore;
#endif
  const GtUchar *querysubstart;

#ifdef SKDEBUG
  gt_alignment_show_multieop_list(lci->tbs.alignment,stdout);
#endif
  gt_assert(lci->tbs.queryend >= lci->tbs.querypos);
  *alignedquerylength = lci->tbs.queryend - lci->tbs.querypos;
  querysubstart = lci->query + lci->tbs.querypos;
  gt_assert(querysubstart != NULL);
  gt_alignment_set_seqs(lci->tbs.alignment,
                        querysubstart,
                        *alignedquerylength,
                        lci->tbs.spaceGtUchardbsubstring,
                        (GtUword) lci->tbs.dbprefixlen);
#ifndef NDEBUG
  evalscore = gt_alignment_eval_with_score(lci->tbs.alignment,false,
                                           lci->scorevalues.matchscore,
                                           lci->scorevalues.mismatchscore,
                                           lci->scorevalues.gapextend);
  if (evalscore < 0 || (GtUword) evalscore < lci->threshold)
  {
    fprintf(stderr,"unexpected eval score "GT_WD"\n",evalscore);
    exit(GT_EXIT_PROGRAMMING_ERROR);
  }
#endif
  return (const void *) lci->tbs.alignment;
}

// Assembly:
pushq %rbx
movq 0x58(%rsi), %rdx
subq 0x50(%rsi), %rdx
jb 0x1623b3
movq %rsi, %rbx
movq %rdx, (%rdi)
movq 0x20(%rsi), %rsi
testq %rsi, %rsi
je 0x1623e1
addq 0x50(%rbx), %rsi
movq 0x70(%rbx), %rdi
movq 0x48(%rbx), %r8
movq 0x60(%rbx), %rcx
callq 0xb4f1f
movq 0x70(%rbx), %rdi
movq (%rbx), %rdx
movq 0x8(%rbx), %rcx
movq 0x18(%rbx), %r8
xorl %esi, %esi
callq 0xb55cb
testq %rax, %rax
js 0x162390
cmpq 0x38(%rbx), %rax
jb 0x162390
movq 0x70(%rbx), %rax
popq %rbx
retq
movq 0x2d5bd1(%rip), %rcx    # 0x437f68
movq (%rcx), %rdi
leaq 0x1e608b(%rip), %rsi    # 0x34842c
movq %rax, %rdx
xorl %eax, %eax
callq 0x17a50
pushq $0x2
popq %rdi
callq 0x178f0
movq 0x2d5bae(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x182c4f(%rip), %rsi    # 0x2e5013
leaq 0x1e5ff7(%rip), %rdx    # 0x3483c2
leaq 0x1e6017(%rip), %rcx    # 0x3483e9
leaq 0x1e5f1b(%rip), %r8     # 0x3482f4
movl $0x2f4, %r9d            # imm = 0x2F4
jmp 0x16240d
movq 0x2d5b80(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x182c21(%rip), %rsi    # 0x2e5013
leaq 0x1e601d(%rip), %rdx    # 0x348416
leaq 0x1e5fe9(%rip), %rcx    # 0x3483e9
leaq 0x1e5eed(%rip), %r8     # 0x3482f4
movl $0x2f7, %r9d            # imm = 0x2F7
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/idxlocalidp.c
// Function: locali_allocatedfsconstinfo
static Limdfsconstinfo *locali_allocatedfsconstinfo (GT_UNUSED
                                                     unsigned int alphasize)
{
  Limdfsconstinfo *lci;

  lci = gt_malloc (sizeof (Limdfsconstinfo));
  lci->maxcollen = 0;
  lci->tbs.alignment = gt_alignment_new();
  lci->tbs.spaceGtUchardbsubstring = NULL;
  lci->tbs.allocatedGtUchardbsubstring = 0;
  return lci;
}

// Assembly:
pushq %rbx
leaq 0x1e5ecb(%rip), %rsi    # 0x3482f4
pushq $0x78
popq %rdi
movl $0x1ea, %edx            # imm = 0x1EA
callq 0x93160
movq %rax, %rbx
andq $0x0, 0x28(%rax)
callq 0xb4e60
movq %rax, 0x70(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/idxlocalidp.c
// Function: locali_initdfsconstinfo
static void locali_initdfsconstinfo (Limdfsconstinfo *lci,
                                     unsigned int alphasize,...)
{
  va_list ap;

  va_start (ap, alphasize);
  lci->scorevalues.matchscore = va_arg (ap, Scoretype);
  lci->scorevalues.mismatchscore = va_arg (ap, Scoretype);
  lci->scorevalues.gapstart = va_arg (ap, Scoretype);
  lci->scorevalues.gapextend = va_arg (ap, Scoretype);
  lci->threshold = va_arg (ap, GtUword);
  lci->query = va_arg (ap, const GtUchar *);
  lci->querylength = va_arg (ap, GtUword);
  if (lci->maxcollen < lci->querylength + 1)
  {
    lci->maxcollen = lci->querylength+1;
  }
  va_end(ap);
}

// Assembly:
subq $0x58, %rsp
leaq -0x60(%rsp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0x162497
movaps %xmm0, -0x30(%rsp)
movaps %xmm1, -0x20(%rsp)
movaps %xmm2, -0x10(%rsp)
movaps %xmm3, (%rsp)
movaps %xmm4, 0x10(%rsp)
movaps %xmm5, 0x20(%rsp)
movaps %xmm6, 0x30(%rsp)
movaps %xmm7, 0x40(%rsp)
movq %rsi, -0x70(%rsp)
leaq 0x60(%rsp), %rax
movq %rax, -0x78(%rsp)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, -0x80(%rsp)
movabsq $0x10, %rax
cmpq $0x29, %rax
jae 0x162566
movq -0x70(%rsp), %rdx
leaq 0x8(%rax), %rcx
movl %ecx, -0x80(%rsp)
movq (%rdx,%rax), %rdx
movq %rdx, (%rdi)
cmpl $0x21, %eax
jae 0x16257a
movq -0x70(%rsp), %rsi
leaq 0x10(%rax), %rdx
movl %edx, -0x80(%rsp)
movq (%rsi,%rcx), %rcx
movq %rcx, 0x8(%rdi)
cmpl $0x19, %eax
jae 0x16258f
movq -0x70(%rsp), %rcx
leaq 0x18(%rax), %rsi
movl %esi, -0x80(%rsp)
movq (%rcx,%rdx), %rcx
movq %rcx, 0x10(%rdi)
cmpl $0x11, %eax
jae 0x1625a4
movq -0x70(%rsp), %rdx
leaq 0x20(%rax), %rcx
movl %ecx, -0x80(%rsp)
movq (%rdx,%rsi), %rdx
movq %rdx, 0x18(%rdi)
cmpl $0x29, %ecx
jae 0x1625b9
movq -0x70(%rsp), %rsi
leal 0x28(%rax), %edx
movl %edx, -0x80(%rsp)
movq (%rsi,%rcx), %rcx
movq %rcx, 0x38(%rdi)
testq %rax, %rax
jne 0x1625ce
movl %edx, %eax
addq -0x70(%rsp), %rax
movl $0x30, -0x80(%rsp)
jmp 0x1625dc
movq -0x78(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, -0x78(%rsp)
movq (%rax), %rax
movq %rax, (%rdi)
movq -0x78(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, -0x78(%rsp)
movq (%rax), %rax
movq %rax, 0x8(%rdi)
movq -0x78(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, -0x78(%rsp)
movq (%rax), %rax
movq %rax, 0x10(%rdi)
movq -0x78(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, -0x78(%rsp)
movq (%rax), %rax
movq %rax, 0x18(%rdi)
movq -0x78(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, -0x78(%rsp)
movq (%rax), %rax
movq %rax, 0x38(%rdi)
movq -0x78(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, -0x78(%rsp)
movq (%rax), %rax
movq %rax, 0x20(%rdi)
movq -0x78(%rsp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, -0x78(%rsp)
movq (%rax), %rax
movq %rax, 0x30(%rdi)
incq %rax
cmpq %rax, 0x28(%rdi)
jae 0x162605
movq %rax, 0x28(%rdi)
addq $0x58, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/idxlocalidp.c
// Function: locali_freedfsconstinfo
static void locali_freedfsconstinfo (Limdfsconstinfo **lci)
{
  gt_alignment_delete((*lci)->tbs.alignment);
  (*lci)->tbs.alignment = NULL;
  gt_free((*lci)->tbs.spaceGtUchardbsubstring);
  (*lci)->tbs.spaceGtUchardbsubstring = NULL;
  gt_free (*lci);
  *lci = NULL;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x70(%rax), %rdi
callq 0xb647f
movq (%rbx), %rax
andq $0x0, 0x70(%rax)
movq (%rbx), %rax
movq 0x60(%rax), %rdi
leaq 0x1e5cc1(%rip), %r14    # 0x3482f4
movq %r14, %rsi
movl $0x20a, %edx            # imm = 0x20A
callq 0x936f9
movq (%rbx), %rax
andq $0x0, 0x60(%rax)
movq (%rbx), %rdi
movq %r14, %rsi
movl $0x20c, %edx            # imm = 0x20C
callq 0x936f9
andq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/idxlocalidp.c
// Function: locali_copyLimdfsstate
static void locali_copyLimdfsstate (DECLAREPTRDFSSTATE(deststate),
                                    const DECLAREPTRDFSSTATE(srcstate),
                                    Limdfsconstinfo *lci)
{
  LocaliColumn *destcol = (LocaliColumn *) deststate;
  const LocaliColumn *srccol = (const LocaliColumn *) srcstate;

  if (srccol->colvalues != NULL)
  {
    GtUword idx;

    if (destcol->lenval < lci->maxcollen)
    {
      REALLOCMSG(destcol);
      destcol->colvalues = gt_realloc(destcol->colvalues,
                                      sizeof (LocaliMatrixvalue)
                                        * lci->maxcollen);
      destcol->lenval = lci->maxcollen;
      ATADDRESS("",destcol);
    }
#ifndef NDEBUG
    if (destcol->lenval < lci->querylength+1)
    {
      fprintf(stderr,"destcol->lenval = "GT_WU" < "GT_WU" lci->querylength+1\n",
                      destcol->lenval,lci->querylength+1);
      exit(GT_EXIT_PROGRAMMING_ERROR);
    }
    if (srccol->lenval < lci->querylength+1)
    {
      fprintf(stderr,"srccol->lenval = "GT_WU" < "GT_WU" lci->querylength+1\n",
                      srccol->lenval,lci->querylength+1);
      exit(GT_EXIT_PROGRAMMING_ERROR);
    }
#endif
    for (idx = 0; idx<=lci->querylength; idx++)
    {
      destcol->colvalues[idx] = srccol->colvalues[idx];
    }
  }
  destcol->maxvalue = srccol->maxvalue;
  destcol->pprefixlen = srccol->pprefixlen;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, (%rsi)
je 0x16274d
movq %rdx, %r15
movq 0x8(%rbx), %rdx
movq 0x28(%r15), %rsi
cmpq %rsi, %rdx
jae 0x162713
movq (%rbx), %rdi
shlq $0x4, %rsi
leaq 0x1e5bf6(%rip), %rdx    # 0x3482f4
movl $0x245, %ecx            # imm = 0x245
callq 0x93472
movq %rax, (%rbx)
movq 0x28(%r15), %rdx
movq %rdx, 0x8(%rbx)
movq 0x30(%r15), %rax
leaq 0x1(%rax), %rcx
cmpq %rcx, %rdx
jb 0x16275c
movq 0x8(%r14), %rdx
cmpq %rcx, %rdx
jb 0x16276f
xorl %ecx, %ecx
xorl %edx, %edx
cmpq %rax, %rdx
ja 0x16274d
movq (%rbx), %rax
movq (%r14), %rsi
movups (%rsi,%rcx), %xmm0
movups %xmm0, (%rax,%rcx)
incq %rdx
movq 0x30(%r15), %rax
addq $0x10, %rcx
jmp 0x16272d
movups 0x10(%r14), %xmm0
movups %xmm0, 0x10(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq 0x2d5805(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1e5cda(%rip), %rsi    # 0x348447
jmp 0x162780
movq 0x2d57f2(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1e5cf7(%rip), %rsi    # 0x348477
xorl %eax, %eax
callq 0x17a50
pushq $0x2
popq %rdi
callq 0x178f0
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/idxlocalisw.c
// Function: gt_newSWdpresource
SWdpresource *gt_newSWdpresource(Scoretype matchscore,
                              Scoretype mismatchscore,
                              Scoretype gapextend,
                              GtUword scorethreshold,
                              bool showalignment,
                              ProcessIdxMatch processmatch,
                              void *processmatchinfo)
{
  SWdpresource *swdpresource;

  swdpresource = gt_malloc(sizeof *swdpresource);
  swdpresource->showalignment = showalignment;
  swdpresource->scorevalues.matchscore = matchscore;
  swdpresource->scorevalues.mismatchscore = mismatchscore;
  swdpresource->scorevalues.gapextend = gapextend;
  swdpresource->scorethreshold = scorethreshold;
  swdpresource->alignment = gt_alignment_new();
  swdpresource->swcol = NULL;
  swdpresource->swentrycol = NULL;
  swdpresource->maxedges = NULL;
  swdpresource->allocatedswcol = 0;
  swdpresource->allocatedmaxedges = 0;
  swdpresource->processmatch = processmatch;
  swdpresource->processmatchinfo = processmatchinfo;
  swdpresource->dbsubstring = NULL;
  swdpresource->allocateddbsubstring = 0;
  return swdpresource;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, (%rsp)
movl %r8d, %ebp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
leaq 0x1e501e(%rip), %rsi    # 0x348530
movl $0x80, %edi
movl $0x1cc, %edx            # imm = 0x1CC
callq 0x93160
movq %rax, %rbx
movb %bpl, (%rax)
movq %r13, 0x10(%rax)
movq %r12, 0x18(%rax)
movq %r15, 0x28(%rax)
movq %r14, 0x38(%rax)
callq 0xb4e60
movq %rax, 0x8(%rbx)
andq $0x0, 0x30(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
movups %xmm0, 0x50(%rbx)
movq (%rsp), %rax
movq %rax, 0x70(%rbx)
movq 0x40(%rsp), %rax
movq %rax, 0x78(%rbx)
movups %xmm0, 0x60(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/idxlocalisw.c
// Function: gt_freeSWdpresource
void gt_freeSWdpresource(SWdpresource *swdpresource)
{
  gt_alignment_delete(swdpresource->alignment);
  swdpresource->alignment = NULL;
  gt_free(swdpresource->swcol);
  gt_free(swdpresource->swentrycol);
  gt_free(swdpresource->maxedges);
  gt_free(swdpresource->dbsubstring);
  swdpresource->allocatedswcol = 0;
  swdpresource->allocatedmaxedges = 0;
  gt_free(swdpresource);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
callq 0xb647f
andq $0x0, 0x8(%rbx)
movq 0x30(%rbx), %rdi
leaq 0x1e4f99(%rip), %r14    # 0x348530
movq %r14, %rsi
movl $0x1e3, %edx            # imm = 0x1E3
callq 0x936f9
movq 0x40(%rbx), %rdi
movq %r14, %rsi
movl $0x1e4, %edx            # imm = 0x1E4
callq 0x936f9
movq 0x68(%rbx), %rdi
movq %r14, %rsi
movl $0x1e5, %edx            # imm = 0x1E5
callq 0x936f9
movq 0x48(%rbx), %rdi
movq %r14, %rsi
movl $0x1e6, %edx            # imm = 0x1E6
callq 0x936f9
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
movl $0x1e9, %edx            # imm = 0x1E9
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x936f9
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/index_options.c
// Function: gt_parse_algbounds
int gt_parse_algbounds(Sfxstrategy *sfxstrategy,
                       const GtStrArray *algbounds,
                       GtError *err)
{
  bool haserr = false;
  const char *arg;
  GtWord readint;

  if (gt_str_array_size(algbounds) != 3UL)
  {
    gt_error_set(err,"option -algbds must have exactly 3 arguments");
    haserr = true;
  }
  GT_IDXOPTS_READMAXBOUND(maxinsertionsort, 0);
  GT_IDXOPTS_READMAXBOUND(maxbltriesort, 1UL);
  if (sfxstrategy->maxinsertionsort > sfxstrategy->maxbltriesort)
  {
    gt_error_set(err,"first argument of option -algbds must not be larger "
                     "than second argument");
    haserr = true;
  }
  GT_IDXOPTS_READMAXBOUND(maxcountingsort, 2UL);
  if (sfxstrategy->maxbltriesort > sfxstrategy->maxcountingsort)
  {
    gt_error_set(err,"second argument of option -algbds must not be larger "
                     "than third argument");
    haserr = true;
  }
  return haserr ? -1 : 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
callq 0xae61c
cmpq $0x3, %rax
jne 0x163671
movq %r15, %rdi
xorl %esi, %esi
callq 0xae386
leaq 0x1b90a3(%rip), %rsi    # 0x31c6cf
leaq 0x8(%rsp), %r12
movq %rax, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x177b0
cmpl $0x1, %eax
setne %cl
movq (%r12), %rax
testq %rax, %rax
setle %dl
orb %cl, %dl
cmpb $0x1, %dl
jne 0x163687
leaq 0x1e5001(%rip), %rsi    # 0x34865d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x89dbb
movq 0x8(%rsp), %rax
movq %rax, 0x8(%r14)
jmp 0x163682
leaq 0x1e4fb8(%rip), %rsi    # 0x348630
movq %rbx, %rdi
xorl %eax, %eax
callq 0x89dbb
movb $0x1, %bpl
jmp 0x1636e5
movq %rax, 0x8(%r14)
pushq $0x1
popq %rsi
movq %r15, %rdi
callq 0xae386
leaq 0x1b9032(%rip), %rsi    # 0x31c6cf
xorl %ebp, %ebp
leaq 0x8(%rsp), %r12
movq %rax, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x177b0
cmpl $0x1, %eax
setne %cl
movq (%r12), %rax
testq %rax, %rax
setle %dl
orb %cl, %dl
cmpb $0x1, %dl
jne 0x1636e1
leaq 0x1e4f8e(%rip), %rsi    # 0x34865d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x89dbb
movb $0x1, %bpl
movq 0x8(%rsp), %rax
movq %rax, 0x10(%r14)
movq 0x8(%r14), %rax
cmpq 0x10(%r14), %rax
jbe 0x163705
leaq 0x1e4f9e(%rip), %rsi    # 0x348694
movq %rbx, %rdi
xorl %eax, %eax
callq 0x89dbb
movb $0x1, %bpl
jmp 0x163761
testb %bpl, %bpl
jne 0x163761
pushq $0x2
popq %rsi
movq %r15, %rdi
callq 0xae386
leaq 0x1b8fb3(%rip), %rsi    # 0x31c6cf
leaq 0x8(%rsp), %r15
movq %rax, %rdi
movq %r15, %rdx
xorl %eax, %eax
callq 0x177b0
cmpl $0x1, %eax
setne %cl
movq (%r15), %rax
testq %rax, %rax
setle %dl
orb %cl, %dl
cmpb $0x1, %dl
jne 0x16375d
leaq 0x1e4f12(%rip), %rsi    # 0x34865d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x89dbb
movb $0x1, %bpl
movq 0x8(%rsp), %rax
movq %rax, 0x18(%r14)
movq 0x10(%r14), %rax
cmpq 0x18(%r14), %rax
jbe 0x16377f
leaq 0x1e4f6b(%rip), %rsi    # 0x3486dd
movq %rbx, %rdi
xorl %eax, %eax
callq 0x89dbb
movb $0x1, %bpl
movzbl %bpl, %eax
negl %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/index_options.c
// Function: gt_index_options_register_esa
GtIndexOptions* gt_index_options_register_esa(GtOptionParser *op,
                                              GtEncseqOptions *encopts)
{
  GtIndexOptions *idxo;
  gt_assert(op != NULL);

  idxo = gt_index_options_register_generic_create(op,
                                                  GT_INDEX_OPTIONS_ESA);
  return gt_index_options_register_generic_output(op, idxo, NULL, encopts);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1637c0
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x1
popq %rsi
callq 0x1637f8
movq %r14, %rdi
movq %rax, %rsi
xorl %edx, %edx
movq %rbx, %rcx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x163d2a
movq 0x2d47a1(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x181842(%rip), %rsi    # 0x2e5013
leaq 0x1c9edd(%rip), %rdx    # 0x32d6b5
leaq 0x1e4f47(%rip), %rcx    # 0x348726
leaq 0x1e4f5e(%rip), %r8     # 0x348744
movl $0x20f, %r9d            # imm = 0x20F
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/index_options.c
// Function: gt_index_options_register_packedidx
GtIndexOptions* gt_index_options_register_packedidx(GtOptionParser *op,
                                                    GtStr *indexname,
                                                    GtEncseqOptions *encopts)
{
  GtIndexOptions *idxo;
  gt_assert(op != NULL);
  idxo = gt_index_options_register_generic_create(op,
                                                  GT_INDEX_OPTIONS_PACKED);
  return gt_index_options_register_generic_output(op, idxo, indexname, encopts);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x164049
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
pushq $0x2
popq %rsi
callq 0x1637f8
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
movq %rbx, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x163d2a
movq 0x2d3f18(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x180fb9(%rip), %rsi    # 0x2e5013
leaq 0x1c9654(%rip), %rdx    # 0x32d6b5
leaq 0x1e471a(%rip), %rcx    # 0x348782
leaq 0x1e46d5(%rip), %r8     # 0x348744
movl $0x223, %r9d            # imm = 0x223
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/index_options.c
// Function: gt_index_options_delete
void gt_index_options_delete(GtIndexOptions *oi)
{
  if (oi == NULL) return;
  gt_str_delete(oi->kysargumentstring);
  gt_str_delete(oi->indexname);
  gt_str_delete(oi->dir);
  gt_str_delete(oi->memlimit);
  gt_str_array_delete(oi->algbounds);
  gt_free(oi);
}

// Assembly:
testq %rdi, %rdi
je 0x1640cc
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
callq 0xae103
movq 0x30(%rbx), %rdi
callq 0xae103
movq 0x38(%rbx), %rdi
callq 0xae103
movq 0x40(%rbx), %rdi
callq 0xae103
movq 0x10(%rbx), %rdi
callq 0xae662
leaq 0x1e4686(%rip), %rsi    # 0x348744
movq %rbx, %rdi
movl $0x231, %edx            # imm = 0x231
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/initbasepower.c
// Function: gt_maxbasepower
unsigned int gt_maxbasepower(unsigned int numofchars)
{
  GtCodetype minfailure, thepower = (GtCodetype) 1;
  unsigned int i;

  minfailure = GT_CODETYPE_MAX/(GtCodetype) numofchars;
  for (i=0; thepower < minfailure; i++)
  {
    thepower *= numofchars;
  }
  return i;
}

// Assembly:
movl %edi, %esi
xorl %ecx, %ecx
pushq $-0x1
popq %rax
xorl %edx, %edx
divq %rsi
pushq $0x1
popq %rdx
cmpq %rax, %rdx
jae 0x1649cc
imulq %rsi, %rdx
incl %ecx
jmp 0x1649bf
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/initbasepower.c
// Function: gt_initbasepower
GtCodetype *gt_initbasepower(unsigned int numofchars,unsigned int prefixlength)
{
  GtCodetype thepower = (GtCodetype) 1, *basepower;
  unsigned int i;

  basepower = gt_malloc(sizeof *basepower * (prefixlength+1));
  for (i=0; /* Nothing */; i++)
  {
    basepower[i] = thepower;
    if (i == prefixlength)
    {
      break;
    }
    gt_assert(thepower < GT_CODETYPE_MAX/(GtCodetype) numofchars);
    thepower *= numofchars;
  }
  return basepower;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
leal 0x1(%rbx), %edi
shlq $0x3, %rdi
leaq 0x1e47bd(%rip), %rsi    # 0x3491a1
pushq $0x29
popq %rdx
callq 0x93160
movq %rax, %rcx
movl %ebp, %edi
movl %ebx, %r8d
pushq $0x1
popq %r9
xorl %r10d, %r10d
pushq $-0x1
popq %rsi
movq %r9, (%rcx,%r10,8)
cmpq %r10, %r8
je 0x164a1d
movq %rsi, %rax
xorl %edx, %edx
divq %rdi
cmpq %rax, %r9
jae 0x164a27
imulq %rdi, %r9
incq %r10
jmp 0x1649fe
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x2d353a(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1805db(%rip), %rsi    # 0x2e5013
leaq 0x1e477c(%rip), %rdx    # 0x3491bb
leaq 0x1e47a8(%rip), %rcx    # 0x3491ee
leaq 0x1e4754(%rip), %r8     # 0x3491a1
pushq $0x31
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/initbasepower.c
// Function: gt_filllargestchartable
GtCodetype *gt_filllargestchartable(unsigned int numofchars,
                                    unsigned int kmersize)
{
  GtCodetype code, *ptr, *filltable;

  filltable = gt_malloc(sizeof *filltable * kmersize);
  code = (GtCodetype) numofchars;
  for (ptr = filltable + kmersize - 1; ptr >= filltable; ptr--)
  {
    *ptr = code-1;
    gt_assert(code <= GT_CODETYPE_MAX/(GtCodetype) numofchars);
    code *= numofchars;
  }
  return filltable;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
movl %esi, %r14d
leaq (,%r14,8), %rdi
leaq 0x1e472c(%rip), %rsi    # 0x3491a1
pushq $0x3c
popq %rdx
callq 0x93160
movq %rax, %rcx
movl %ebx, %esi
leaq (%rax,%r14,8), %rdi
addq $-0x8, %rdi
movq %rsi, %r8
cmpq %rcx, %rdi
jb 0x164aab
leaq -0x1(%r8), %rax
movq %rax, (%rdi)
movq %rsi, %rax
mulq %r8
jo 0x164ab6
imulq %rsi, %r8
addq $-0x8, %rdi
jmp 0x164a8d
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x2d34ab(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x18054c(%rip), %rsi    # 0x2e5013
leaq 0x1e4731(%rip), %rdx    # 0x3491ff
leaq 0x1e475a(%rip), %rcx    # 0x34922f
leaq 0x1e46c5(%rip), %r8     # 0x3491a1
pushq $0x41
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/initbasepower.c
// Function: gt_initfilltable
GtCodetype *gt_initfilltable(unsigned int numofchars,unsigned int prefixlength)
{
  unsigned int i;
  GtCodetype *filltable, *basepower;

  basepower = gt_initbasepower(numofchars,prefixlength);
  filltable = gt_malloc(sizeof *filltable * prefixlength);
  for (i=0; i<prefixlength; i++)
  {
    filltable[i] = basepower[prefixlength-i]-1;
  }
  gt_free(basepower);
  return filltable;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
callq 0x1649cf
movq %rax, %rbx
movl %ebp, %r15d
leaq (,%r15,8), %rdi
leaq 0x1e4692(%rip), %rsi    # 0x3491a1
pushq $0x4d
popq %rdx
callq 0x93160
movq %rax, %r14
movq %r15, %rcx
subq $0x1, %rcx
jb 0x164b39
movl %r15d, %edx
movq (%rbx,%rdx,8), %rdx
decq %rdx
movq %rdx, (%rax)
addq $0x8, %rax
movq %rcx, %r15
jmp 0x164b1d
leaq 0x1e4661(%rip), %rsi    # 0x3491a1
pushq $0x52
popq %rdx
movq %rbx, %rdi
callq 0x936f9
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/initbasepower.c
// Function: gt_initmultimappower
GtCodetype **gt_initmultimappower(unsigned int numofchars,unsigned int qvalue)
{
  int offset;
  unsigned int mapindex;
  GtCodetype thepower = (GtCodetype) 1, *mmptr, **multimappower;

  gt_array2dim_malloc(multimappower,(GtUword) qvalue,numofchars);
  for (offset = (int) (qvalue - 1); offset>=0; offset--)
  {
    mmptr = multimappower[offset];
    mmptr[0] = 0;
    for (mapindex = 1U; mapindex < numofchars; mapindex++)
    {
      gt_assert(mmptr[mapindex-1] <= GT_CODETYPE_MAX - thepower);
      mmptr[mapindex] = mmptr[mapindex-1] + thepower;
    }
    gt_assert(thepower <= GT_CODETYPE_MAX/(GtUword) numofchars);
    thepower *= numofchars;
  }
  return multimappower;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebp
movl %esi, %r12d
leaq (,%r12,8), %r15
leaq 0x1e4629(%rip), %rsi    # 0x3491a1
pushq $0x5c
popq %r13
movq %r15, %rdi
movl %r13d, %edx
callq 0x93160
movq %rax, %rbx
movl %ebp, %r14d
imulq %r14, %r15
movq %r15, %rdi
leaq 0x1e4606(%rip), %rsi    # 0x3491a1
movl %r13d, %edx
callq 0x93160
movq %rax, (%rbx)
pushq $0x1
popq %rax
leaq (,%r14,8), %rcx
cmpq %r12, %rax
jae 0x164bc7
movq -0x8(%rbx,%rax,8), %rdx
addq %rcx, %rdx
movq %rdx, (%rbx,%rax,8)
incq %rax
jmp 0x164bb1
pushq $0x1
popq %rcx
movq %rcx, %rsi
decq %r12
testl %r12d, %r12d
js 0x164c14
movl %r12d, %eax
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movq (%rbx,%rax,8), %rax
andq $0x0, (%rax)
movq %rsi, %rdx
notq %rdx
xorl %edi, %edi
movq %rcx, %r8
cmpq %r14, %r8
jae 0x164c06
cmpq %rdx, %rdi
ja 0x164c26
addq %rsi, %rdi
movq %rdi, (%rax,%r8,8)
incq %r8
jmp 0x164bf0
movq %r14, %rax
mulq %rsi
jo 0x164c5c
imulq %r14, %rsi
jmp 0x164bcd
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x2d333b(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1803dc(%rip), %rsi    # 0x2e5013
leaq 0x1e4609(%rip), %rdx    # 0x349247
leaq 0x1e4632(%rip), %rcx    # 0x349277
leaq 0x1e4555(%rip), %r8     # 0x3491a1
pushq $0x63
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
movq 0x2d3305(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1803a6(%rip), %rsi    # 0x2e5013
leaq 0x1e4618(%rip), %rdx    # 0x34928c
leaq 0x1e45fc(%rip), %rcx    # 0x349277
leaq 0x1e451f(%rip), %r8     # 0x3491a1
pushq $0x66
jmp 0x164c4e
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/karlin_altschul_stat.c
// Function: gt_evalue_raw_score
GtWord gt_evalue_raw_score(const GtKarlinAltschulStat *ka,
                           GtUword matches,
                           GtUword mismatches,
                           GtUword indels)
{
  GtWord matchscore, mismatchscore, gapscore;

  gt_assert(ka != NULL);
  matchscore = gt_karlin_altschul_stat_matchscore(ka);
  mismatchscore = gt_karlin_altschul_stat_mismatchscore(ka);
  gapscore = gt_karlin_altschul_stat_gapscore(ka);
  gt_assert(matchscore > 0 && mismatchscore < 0 && gapscore < 0);
  return (GtWord) matches * matchscore +
         (GtWord) mismatches * mismatchscore +
         (GtWord) indels * gapscore;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x166247
movq 0x38(%rdi), %r8
testq %r8, %r8
jle 0x166275
movq 0x40(%rdi), %r9
testq %r9, %r9
jns 0x166275
movq 0x48(%rdi), %rax
testq %rax, %rax
jns 0x166275
imulq %rsi, %r8
imulq %rdx, %r9
addq %r8, %r9
imulq %rcx, %rax
addq %r9, %rax
popq %rcx
retq
movq 0x2d1d1a(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x17edbb(%rip), %rsi    # 0x2e5013
leaq 0x1e30e2(%rip), %rdx    # 0x349341
leaq 0x1e3220(%rip), %rcx    # 0x349486
leaq 0x1e30b3(%rip), %r8     # 0x349320
movl $0x348, %r9d            # imm = 0x348
jmp 0x1662a1
movq 0x2d1cec(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x17ed8d(%rip), %rsi    # 0x2e5013
leaq 0x1e320d(%rip), %rdx    # 0x34949a
leaq 0x1e31f2(%rip), %rcx    # 0x349486
leaq 0x1e3085(%rip), %r8     # 0x349320
movl $0x34c, %r9d            # imm = 0x34C
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/karlin_altschul_stat.c
// Function: gt_evalue_bit_score2raw_score
GtWord gt_evalue_bit_score2raw_score(const GtKarlinAltschulStat *ka,
                                     double bit_score)
{
  double raw_score, lambda, logK;

  gt_assert(ka != NULL);
  lambda = gt_karlin_altschul_stat_get_lambda(ka);
  logK = gt_karlin_altschul_stat_get_logK(ka);

  raw_score = (bit_score * ka->log2 + logK)/lambda;
  return (GtWord) round(raw_score);
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x16631f
mulsd 0x30(%rdi), %xmm0
addsd 0x10(%rdi), %xmm0
divsd (%rdi), %xmm0
callq 0x172c0
cvttsd2si %xmm0, %rax
popq %rcx
retq
movq 0x2d1c42(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x17ece3(%rip), %rsi    # 0x2e5013
leaq 0x1e300a(%rip), %rdx    # 0x349341
leaq 0x1e31ae(%rip), %rcx    # 0x3494ec
leaq 0x1e2fdb(%rip), %r8     # 0x349320
movl $0x362, %r9d            # imm = 0x362
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/karlin_altschul_stat.c
// Function: gt_evalue_from_bitscore
double gt_evalue_from_bitscore(const GtKarlinAltschulStat *ka,
                               double bit_score,
                               GtUword searchspace)
{
  GtWord raw_score;

  gt_assert(ka != NULL);
  raw_score = gt_evalue_bit_score2raw_score(ka, bit_score);
  return gt_evalue_from_raw_score(ka,raw_score,searchspace);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x166418
movq %rsi, %rbx
movq %rdi, %r14
mulsd 0x30(%rdi), %xmm0
addsd 0x10(%rdi), %xmm0
divsd (%rdi), %xmm0
callq 0x172c0
cvttsd2si %xmm0, %rsi
movq %r14, %rdi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x166357
movq 0x2d1b49(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x17ebea(%rip), %rsi    # 0x2e5013
leaq 0x1e2f11(%rip), %rdx    # 0x349341
leaq 0x1e30d3(%rip), %rcx    # 0x34950a
leaq 0x1e2ee2(%rip), %r8     # 0x349320
movl $0x379, %r9d            # imm = 0x379
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/karlin_altschul_stat.c
// Function: gt_evalue_from_eop_count
double gt_evalue_from_eop_count(const GtKarlinAltschulStat *ka,
                                GtUword matches,
                                GtUword mismatches,
                                GtUword indels,
                                GtUword searchspace)
{
  GtWord raw_score;

  gt_assert(ka != NULL);
  raw_score = gt_evalue_raw_score(ka, matches, mismatches, indels);
  return gt_evalue_from_raw_score(ka,raw_score,searchspace);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x166479
movq %r8, %rbx
movq %rdi, %r14
callq 0x166212
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x166357
movq 0x2d1ae8(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x17eb89(%rip), %rsi    # 0x2e5013
leaq 0x1e2eb0(%rip), %rdx    # 0x349341
leaq 0x1e308a(%rip), %rcx    # 0x349522
leaq 0x1e2e81(%rip), %r8     # 0x349320
movl $0x386, %r9d            # imm = 0x386
xorl %eax, %eax
callq 0x17a50
callq 0x17390