LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movl $0x78, %edi
leaq 0x3214cc(%rip), %rsi    # 0x57a800
movl $0x1ea, %edx            # imm = 0x1EA
callq 0xe80f0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq $0x0, 0x28(%rax)
callq 0x129e10
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x70(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x60(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x68(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movq (%rax), %rax
movq 0x70(%rax), %rdi
callq 0x12c3e0
movq (%rsp), %rax
movq (%rax), %rax
movq $0x0, 0x70(%rax)
movq (%rsp), %rax
movq (%rax), %rax
movq 0x60(%rax), %rdi
leaq 0x32109a(%rip), %rsi    # 0x57a800
movl $0x20a, %edx            # imm = 0x20A
callq 0xe88c0
movq (%rsp), %rax
movq (%rax), %rax
movq $0x0, 0x60(%rax)
movq (%rsp), %rax
movq (%rax), %rdi
leaq 0x321073(%rip), %rsi    # 0x57a800
movl $0x20c, %edx            # imm = 0x20C
callq 0xe88c0
movq (%rsp), %rax
movq $0x0, (%rax)
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/idxlocalidp.c
// Function: locali_initrootLimdfsstate
static void locali_initrootLimdfsstate(DECLAREPTRDFSSTATE(aliasstate),
                                       Limdfsconstinfo *lci)
{
  LocaliColumn *column = (LocaliColumn *) aliasstate;

  if (column->lenval < lci->maxcollen)
  {
    REALLOCMSG(column);
    column->colvalues = gt_realloc(column->colvalues,
                                   sizeof (LocaliMatrixvalue)
                                      * lci->maxcollen);
    column->lenval = lci->maxcollen;
    ATADDRESS("",column);
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rsp), %rcx
cmpq 0x28(%rcx), %rax
jae 0x25981a
movq (%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rsi
shlq $0x4, %rsi
leaq 0x32100b(%rip), %rdx    # 0x57a800
movl $0x21a, %ecx            # imm = 0x21A
callq 0xe8540
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/idxlocalidp.c
// Function: locali_freeLimdfsstackelem
static void locali_freeLimdfsstackelem (DECLAREPTRDFSSTATE (aliasstate))
{
  LocaliColumn *column = (LocaliColumn *) aliasstate;

  if (column ->colvalues != NULL)
  {
    ATADDRESS("free ",column);
    gt_free(column->colvalues);
    column->colvalues = NULL;
    column->lenval = 0;
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
je 0x2598a0
movq 0x8(%rsp), %rax
movq (%rax), %rdi
leaq 0x320f83(%rip), %rsi    # 0x57a800
movl $0x22f, %edx            # imm = 0x22F
callq 0xe88c0
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x8(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/idxlocalidp.c
// Function: locali_fullmatchLimdfsstate
static void locali_fullmatchLimdfsstate (Limdfsresult *limdfsresult,
                                         DECLAREPTRDFSSTATE(aliasstate),
                                         GT_UNUSED GtUword leftbound,
                                         GT_UNUSED GtUword rightbound,
                                         GT_UNUSED GtUword width,
                                         GT_UNUSED GtUword currentdepth,
                                         Limdfsconstinfo *lci)
{
  LocaliColumn *column = (LocaliColumn *) aliasstate;

  if (column->colvalues != NULL)
  {
    if (column->maxvalue >= lci->threshold)
    {
      limdfsresult->status = Limdfssuccess;
      limdfsresult->distance = column->maxvalue;
      limdfsresult->pprefixlen = column->pprefixlen;
    } else
    {
      if (column->maxvalue > 0)
      {
        limdfsresult->status = Limdfscontinue;
      } else
      {
        limdfsresult->status = Limdfsstop;
      }
    }
  } else
  {
    limdfsresult->status = Limdfscontinue;
  }
}

// Assembly:
movq 0x8(%rsp), %rax
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movq %r8, -0x28(%rsp)
movq %r9, -0x30(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x38(%rsp)
movq -0x38(%rsp), %rax
cmpq $0x0, (%rax)
je 0x259b15
movq -0x38(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x8(%rsp), %rcx
cmpq 0x38(%rcx), %rax
jb 0x259aed
movq -0x8(%rsp), %rax
movl $0x0, (%rax)
movq -0x38(%rsp), %rax
movq 0x18(%rax), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq -0x38(%rsp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
jmp 0x259b13
movq -0x38(%rsp), %rax
cmpq $0x0, 0x18(%rax)
jbe 0x259b06
movq -0x8(%rsp), %rax
movl $0x1, (%rax)
jmp 0x259b11
movq -0x8(%rsp), %rax
movl $0x2, (%rax)
jmp 0x259b13
jmp 0x259b20
movq -0x8(%rsp), %rax
movl $0x1, (%rax)
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/idxlocalidp.c
// Function: locali_nextLimdfsstate
static void locali_nextLimdfsstate (const Limdfsconstinfo *lci,
                                    DECLAREPTRDFSSTATE (aliasoutcol),
                                    GT_UNUSED GtUword currentdepth,
                                    GtUchar currentchar,
                                    const DECLAREPTRDFSSTATE (aliasincol))
{
  LocaliColumn *outcol = (LocaliColumn *) aliasoutcol;
  const LocaliColumn *incol = (const LocaliColumn *) aliasincol;

  if (currentdepth > 1UL)
  {
    nextcolumn (lci,outcol,currentchar,incol);
  } else
  {
    secondcolumn (lci, outcol, currentchar);
  }
}

// Assembly:
subq $0x38, %rsp
movb %cl, %al
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movb %al, 0x1f(%rsp)
movq %r8, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x1, 0x20(%rsp)
jbe 0x259b85
movq 0x30(%rsp), %rdi
movq 0x8(%rsp), %rsi
movb 0x1f(%rsp), %al
movq (%rsp), %rcx
movzbl %al, %edx
callq 0x259ba0
jmp 0x259b99
movq 0x30(%rsp), %rdi
movq 0x8(%rsp), %rsi
movzbl 0x1f(%rsp), %edx
callq 0x25a0a0
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/idxlocalisw.c
// Function: gt_multiapplysmithwaterman
void gt_multiapplysmithwaterman(SWdpresource *dpresource,
                             const GtEncseq *encseq,
                             const GtUchar *query,
                             GtUword querylen)
{
  GtUword seqnum,
                seqstartpos,
                seqlength,
                numofdbsequences = gt_encseq_num_of_sequences(encseq);

  for (seqnum = 0; seqnum < numofdbsequences; seqnum++)
  {
    seqstartpos = gt_encseq_seqstartpos(encseq, seqnum);
    seqlength = gt_encseq_seqlength(encseq, seqnum);
    applysmithwaterman(dpresource,
                       encseq,
                       seqnum,
                       seqstartpos,
                       seqstartpos + seqlength,
                       query,
                       querylen);
  }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x38(%rsp), %rdi
callq 0xa9d50
movq %rax, 0x8(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x8(%rsp), %rax
jae 0x25a475
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xb0530
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xb09f0
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq 0x18(%rsp), %r8
addq 0x10(%rsp), %r8
movq 0x30(%rsp), %r9
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
callq 0x25a480
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x25a400
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movb %r8b, %al
movq 0x40(%rsp), %r8
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
andb $0x1, %al
movb %al, 0x17(%rsp)
movq %r9, 0x8(%rsp)
movl $0x80, %edi
leaq 0x3200b5(%rip), %rsi    # 0x57aa3c
movl $0x1cc, %edx            # imm = 0x1CC
callq 0xe80f0
movq %rax, (%rsp)
movb 0x17(%rsp), %cl
movq (%rsp), %rax
andb $0x1, %cl
movb %cl, (%rax)
movq 0x30(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x28(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x20(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x18(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x38(%rax)
callq 0x129e10
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq (%rsp), %rax
movq $0x0, 0x30(%rax)
movq (%rsp), %rax
movq $0x0, 0x40(%rax)
movq (%rsp), %rax
movq $0x0, 0x68(%rax)
movq (%rsp), %rax
movq $0x0, 0x50(%rax)
movq (%rsp), %rax
movq $0x0, 0x58(%rax)
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x70(%rax)
movq 0x40(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x78(%rax)
movq (%rsp), %rax
movq $0x0, 0x48(%rax)
movq (%rsp), %rax
movq $0x0, 0x60(%rax)
movq (%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x12c3e0
movq (%rsp), %rax
movq $0x0, 0x8(%rax)
movq (%rsp), %rax
movq 0x30(%rax), %rdi
leaq 0x31ffaf(%rip), %rsi    # 0x57aa3c
movl $0x1e3, %edx            # imm = 0x1E3
callq 0xe88c0
movq (%rsp), %rax
movq 0x40(%rax), %rdi
leaq 0x31ff96(%rip), %rsi    # 0x57aa3c
movl $0x1e4, %edx            # imm = 0x1E4
callq 0xe88c0
movq (%rsp), %rax
movq 0x68(%rax), %rdi
leaq 0x31ff7d(%rip), %rsi    # 0x57aa3c
movl $0x1e5, %edx            # imm = 0x1E5
callq 0xe88c0
movq (%rsp), %rax
movq 0x48(%rax), %rdi
leaq 0x31ff64(%rip), %rsi    # 0x57aa3c
movl $0x1e6, %edx            # imm = 0x1E6
callq 0xe88c0
movq (%rsp), %rax
movq $0x0, 0x50(%rax)
movq (%rsp), %rax
movq $0x0, 0x58(%rax)
movq (%rsp), %rdi
leaq 0x31ff37(%rip), %rsi    # 0x57aa3c
movl $0x1e9, %edx            # imm = 0x1E9
callq 0xe88c0
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/idxlocalisw.c
// Function: swproducealignment
static void swproducealignment(GtAlignment *alignment,
                               GtUchar *dbsubstring,
                               Retracebits *edges,
                               Scoretype *scol,
                               const Scorevalues *scorevalues,
                               GT_UNUSED GtUword scorethreshold,
                               const GtUchar *useq,
                               GtUword ulen,
                               const GtEncseq *vencseq,
                               GtUword startpos,
                               GtUword endpos)
{
  GtUword vlen = endpos - startpos;

  swmaximalDPedges(edges,scol,scorevalues,useq,ulen,vencseq,startpos,endpos);
  swtracebackDPedges(alignment,ulen,vencseq,vlen,dbsubstring,startpos,edges);
  gt_alignment_set_seqs(alignment,useq,ulen,dbsubstring,(GtUword) vlen);
#ifndef NDEBUG
  {
    Scoretype evalscore;

    evalscore = gt_alignment_eval_with_score(alignment,false,
                                             scorevalues->matchscore,
                                             scorevalues->mismatchscore,
                                             scorevalues->gapextend);
    if (evalscore < 0 || (GtUword) evalscore < scorethreshold)
    {
      fprintf(stderr,"unexpected eval score "GT_WD"\n",evalscore);
      exit(GT_EXIT_PROGRAMMING_ERROR);
    }
  }
#endif
}

// Assembly:
subq $0x58, %rsp
movq 0x80(%rsp), %rax
movq 0x78(%rsp), %rax
movq 0x70(%rsp), %rax
movq 0x68(%rsp), %rax
movq 0x60(%rsp), %rax
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq %r9, 0x28(%rsp)
movq 0x80(%rsp), %rax
subq 0x78(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x60(%rsp), %rcx
movq 0x68(%rsp), %r8
movq 0x70(%rsp), %r9
movq 0x78(%rsp), %r10
movq 0x80(%rsp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x25b410
movq 0x50(%rsp), %rdi
movq 0x68(%rsp), %rsi
movq 0x70(%rsp), %rdx
movq 0x20(%rsp), %rcx
movq 0x48(%rsp), %r8
movq 0x78(%rsp), %r9
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
callq 0x25b7a0
movq 0x50(%rsp), %rdi
movq 0x60(%rsp), %rsi
movq 0x68(%rsp), %rdx
movq 0x48(%rsp), %rcx
movq 0x20(%rsp), %r8
callq 0x129f60
movq 0x50(%rsp), %rdi
movq 0x30(%rsp), %rax
movq (%rax), %rdx
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x30(%rsp), %rax
movq 0x18(%rax), %r8
xorl %esi, %esi
callq 0x12a9d0
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jl 0x25b3e2
movq 0x18(%rsp), %rax
cmpq 0x28(%rsp), %rax
jae 0x25b409
movq 0x3e0bb7(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
movq 0x18(%rsp), %rdx
leaq 0x31f540(%rip), %rsi    # 0x57a938
movb $0x0, %al
callq 0x199f0
movl $0x2, %edi
callq 0x19890
addq $0x58, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/idxlocalisw.c
// Function: swtracebackDPedges
static void swtracebackDPedges(GtAlignment *alignment,
                               GtUword ulen,
                               const GtEncseq *encseq,
                               GtUword vlen,
                               GtUchar *dbsubstring,
                               GtUword startpos,
                               const Retracebits *edges)
{
  const Retracebits *eptr = edges + (ulen+1) * (vlen+1) - 1;

  while (true)
  {
    if (*eptr & DELETIONBIT)
    {
      gt_alignment_add_deletion(alignment);
      eptr--;
    } else
    {
      if (*eptr & REPLACEMENTBIT)
      {
        gt_alignment_add_replacement(alignment);
        eptr -= (ulen+2);
      } else
      {
        if (*eptr & INSERTIONBIT)
        {
          gt_alignment_add_insertion(alignment);
          eptr -= (ulen+1);
        } else
        {
          break;
        }
      }
      gt_assert(vlen > 0);
      vlen--;
      dbsubstring[vlen] = gt_encseq_get_encoded_char(encseq,
                                                           startpos + vlen,
                                                           GT_READMODE_FORWARD);
    }
  }
}

// Assembly:
subq $0x38, %rsp
movq 0x40(%rsp), %rax
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 0x40(%rsp), %rax
movq 0x28(%rsp), %rcx
addq $0x1, %rcx
movq 0x18(%rsp), %rdx
addq $0x1, %rdx
imulq %rdx, %rcx
addq %rcx, %rax
addq $-0x1, %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movzbl (%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x25b817
movq 0x30(%rsp), %rdi
callq 0x12a480
movq (%rsp), %rax
addq $-0x1, %rax
movq %rax, (%rsp)
jmp 0x25b8fa
movq (%rsp), %rax
movzbl (%rax), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x25b84b
movq 0x30(%rsp), %rdi
callq 0x12a410
movq 0x28(%rsp), %rdx
addq $0x2, %rdx
movq (%rsp), %rax
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, (%rsp)
jmp 0x25b883
movq (%rsp), %rax
movzbl (%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x25b87f
movq 0x30(%rsp), %rdi
callq 0x12a4f0
movq 0x28(%rsp), %rdx
addq $0x1, %rdx
movq (%rsp), %rax
xorl %ecx, %ecx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, (%rsp)
jmp 0x25b881
jmp 0x25b8ff
jmp 0x25b883
jmp 0x25b885
cmpq $0x0, 0x18(%rsp)
ja 0x25b8c5
movq 0x3e070c(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2ba775(%rip), %rsi    # 0x516013
leaq 0x31f27b(%rip), %rdx    # 0x57ab20
leaq 0x31f27d(%rip), %rcx    # 0x57ab29
leaq 0x31f189(%rip), %r8     # 0x57aa3c
movl $0x11a, %r9d            # imm = 0x11A
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x25b8c7
movq 0x18(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
addq 0x18(%rsp), %rsi
xorl %edx, %edx
callq 0xa9da0
movb %al, %dl
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movb %dl, (%rax,%rcx)
jmp 0x25b7ed
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
jne 0x25c79e
jmp 0x25c7f4
movq (%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x11f560
movq (%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x11f560
movq (%rsp), %rax
movq 0x38(%rax), %rdi
callq 0x11f560
movq (%rsp), %rax
movq 0x40(%rax), %rdi
callq 0x11f560
movq (%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x11fd20
movq (%rsp), %rdi
leaq 0x31e466(%rip), %rsi    # 0x57ac50
movl $0x231, %edx            # imm = 0x231
callq 0xe88c0
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/index_options.c
// Function: gt_index_options_new
static GtIndexOptions* gt_index_options_new(void)
{
  GtIndexOptions *oi = gt_malloc(sizeof *oi);
  oi->algbounds = gt_str_array_new();
  oi->dir = gt_str_new_cstr("fwd");
  oi->indexname = NULL;
  oi->kysargumentstring = gt_str_new();
  oi->lcpdist = false;
  oi->maximumspace = 0UL; /* in bytes */
  oi->memlimit = gt_str_new();
  oi->numofparts = 1U;
  oi->option = NULL;
  oi->optionalgbounds = NULL;
  oi->optioncmpcharbychar = NULL;
  oi->optiondifferencecover = NULL;
  oi->optionmaxwidthrealmedian = NULL;
  oi->optionmemlimit = NULL;
  oi->optionoutbcktab = NULL;
  oi->optionoutbwttab = NULL;
  oi->optionoutlcptab = NULL;
  oi->optionoutsuftab = NULL;
  oi->optionparts = NULL;
  oi->optionprefixlength = NULL;
  oi->optionspmopt = NULL;
  oi->optionstorespecialcodes = NULL;
  oi->outbcktab = false;
  oi->outbwttab = false;
  oi->outkyssort = false;
  oi->outkystab = false;
  oi->outlcptab = false;
  oi->outsuftab = false; /* only defined for GT_INDEX_OPTIONS_ESA */
  oi->prefixlength = GT_PREFIXLENGTH_AUTOMATIC;
  oi->swallow_tail = false;
  oi->type = GT_INDEX_OPTIONS_UNDEFINED;
  return oi;
}

// Assembly:
pushq %rax
movl $0x150, %edi            # imm = 0x150
leaq 0x31dc13(%rip), %rsi    # 0x57ac50
movl $0x5e, %edx
callq 0xe80f0
movq %rax, (%rsp)
callq 0x11f5c0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
leaq 0x336c84(%rip), %rdi    # 0x593ce6
callq 0x11d510
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x38(%rax)
movq (%rsp), %rax
movq $0x0, 0x30(%rax)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x28(%rax)
movq (%rsp), %rax
movb $0x0, 0x22(%rax)
movq (%rsp), %rax
movq $0x0, 0x8(%rax)
callq 0x11d4a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x40(%rax)
movq (%rsp), %rax
movl $0x1, (%rax)
movq (%rsp), %rax
movq $0x0, 0x90(%rax)
movq (%rsp), %rax
movq $0x0, 0xe8(%rax)
movq (%rsp), %rax
movq $0x0, 0xc0(%rax)
movq (%rsp), %rax
movq $0x0, 0x100(%rax)
movq (%rsp), %rax
movq $0x0, 0xe0(%rax)
movq (%rsp), %rax
movq $0x0, 0xf8(%rax)
movq (%rsp), %rax
movq $0x0, 0xb0(%rax)
movq (%rsp), %rax
movq $0x0, 0xa8(%rax)
movq (%rsp), %rax
movq $0x0, 0xa0(%rax)
movq (%rsp), %rax
movq $0x0, 0x98(%rax)
movq (%rsp), %rax
movq $0x0, 0xf0(%rax)
movq (%rsp), %rax
movq $0x0, 0xb8(%rax)
movq (%rsp), %rax
movq $0x0, 0xd0(%rax)
movq (%rsp), %rax
movq $0x0, 0xd8(%rax)
movq (%rsp), %rax
movb $0x0, 0x1f(%rax)
movq (%rsp), %rax
movb $0x0, 0x1e(%rax)
movq (%rsp), %rax
movb $0x0, 0x21(%rax)
movq (%rsp), %rax
movb $0x0, 0x20(%rax)
movq (%rsp), %rax
movb $0x0, 0x1d(%rax)
movq (%rsp), %rax
movb $0x0, 0x1c(%rax)
movq (%rsp), %rax
movl $0x0, 0x4(%rax)
movq (%rsp), %rax
movb $0x0, 0x23(%rax)
movq (%rsp), %rax
movl $0x0, 0x88(%rax)
movq (%rsp), %rax
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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, -0x4(%rsp)
movq $0x1, -0x18(%rsp)
movl -0x4(%rsp), %eax
movl %eax, %ecx
movq $-0x1, %rax
xorl %edx, %edx
divq %rcx
movq %rax, -0x10(%rsp)
movl $0x0, -0x1c(%rsp)
movq -0x18(%rsp), %rax
cmpq -0x10(%rsp), %rax
jae 0x25d6b4
movl -0x4(%rsp), %eax
imulq -0x18(%rsp), %rax
movq %rax, -0x18(%rsp)
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0x25d68c
movl -0x1c(%rsp), %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movl %esi, 0x20(%rsp)
movq $0x1, 0x18(%rsp)
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
shlq $0x3, %rdi
leaq 0x31e019(%rip), %rsi    # 0x57b704
movl $0x29, %edx
callq 0xe80f0
movq %rax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %ecx
movq %rdx, (%rax,%rcx,8)
movl 0xc(%rsp), %eax
cmpl 0x20(%rsp), %eax
jne 0x25d723
jmp 0x25d7a5
jmp 0x25d725
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movl 0x24(%rsp), %eax
movl %eax, %ecx
movq $-0x1, %rax
xorl %edx, %edx
divq %rcx
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jb 0x25d784
movq 0x3de84d(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2b88b6(%rip), %rsi    # 0x516013
leaq 0x31dfba(%rip), %rdx    # 0x57b71e
leaq 0x31dfe6(%rip), %rcx    # 0x57b751
leaq 0x31df92(%rip), %r8     # 0x57b704
movl $0x31, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x25d786
movl 0x24(%rsp), %eax
imulq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x25d702
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movl %esi, 0x20(%rsp)
movl 0x20(%rsp), %eax
movl %eax, %edi
shlq $0x3, %rdi
leaq 0x31df37(%rip), %rsi    # 0x57b704
movl $0x3c, %edx
callq 0xe80f0
movq %rax, 0x8(%rsp)
movl 0x24(%rsp), %eax
movq %rax, 0x18(%rsp)
movq 0x8(%rsp), %rax
movl 0x20(%rsp), %ecx
shlq $0x3, %rcx
addq %rcx, %rax
addq $-0x8, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
jb 0x25d8a2
movq 0x18(%rsp), %rcx
subq $0x1, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movl 0x24(%rsp), %eax
movl %eax, %ecx
movq $-0x1, %rax
xorl %edx, %edx
divq %rcx
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jbe 0x25d87e
movq 0x3de753(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2b87bc(%rip), %rsi    # 0x516013
leaq 0x31df04(%rip), %rdx    # 0x57b762
leaq 0x31df2d(%rip), %rcx    # 0x57b792
leaq 0x31de98(%rip), %r8     # 0x57b704
movl $0x41, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x25d880
movl 0x24(%rsp), %eax
imulq 0x18(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x10(%rsp), %rax
addq $-0x8, %rax
movq %rax, 0x10(%rsp)
jmp 0x25d7fe
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movl %esi, 0x20(%rsp)
movl 0x24(%rsp), %edi
movl 0x20(%rsp), %esi
callq 0x25d6c0
movq %rax, 0x8(%rsp)
movl 0x20(%rsp), %eax
movl %eax, %edi
shlq $0x3, %rdi
leaq 0x31de25(%rip), %rsi    # 0x57b704
movl $0x4d, %edx
callq 0xe80f0
movq %rax, 0x10(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x20(%rsp), %eax
jae 0x25d931
movq 0x8(%rsp), %rax
movl 0x20(%rsp), %ecx
subl 0x1c(%rsp), %ecx
movl %ecx, %ecx
movq (%rax,%rcx,8), %rdx
subq $0x1, %rdx
movq 0x10(%rsp), %rax
movl 0x1c(%rsp), %ecx
movq %rdx, (%rax,%rcx,8)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x25d8f6
movq 0x8(%rsp), %rdi
leaq 0x31ddc7(%rip), %rsi    # 0x57b704
movl $0x52, %edx
callq 0xe88c0
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/karlin_altschul_stat.c
// Function: gt_karlin_altschul_stat_get_gapped_params
static void gt_karlin_altschul_stat_get_gapped_params(GtKarlinAltschulStat *ka)
{
  const double *ga_vector = NULL;

  gt_assert(ka != NULL);
  ga_vector = gt_karlin_altschul_score_vector(ka->matchscore,ka->mismatchscore);
  if (ga_vector == NULL)
  {
    fprintf(stderr,"no precomputed values for combination matchscore "
                   GT_WD " and mismatchscore " GT_WD " in evalue calculation "
                   "of gapped alignments",ka->matchscore, ka->mismatchscore);
    exit(GT_EXIT_PROGRAMMING_ERROR);
  }
  gt_assert(ga_vector[gapextdidx] == ka->gapscore);
  get_values_from_vector(ka, ga_vector);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x25df62
movq 0x3de06f(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2b80d8(%rip), %rsi    # 0x516013
leaq 0x31d96f(%rip), %rdx    # 0x57b8b1
leaq 0x31dc49(%rip), %rcx    # 0x57bb92
leaq 0x31d940(%rip), %r8     # 0x57b890
movl $0x1ea, %r9d            # imm = 0x1EA
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x25df64
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x40(%rax), %rsi
callq 0x260b50
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x25dfbc
movq 0x3de011(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rdx
movq 0x10(%rsp), %rax
movq 0x40(%rax), %rcx
leaq 0x31dc11(%rip), %rsi    # 0x57bbbc
movb $0x0, %al
callq 0x199f0
movl $0x2, %edi
callq 0x19890
jmp 0x25dfbe
movq 0x8(%rsp), %rax
movsd (%rax), %xmm0
movq 0x10(%rsp), %rax
cvtsi2sdq 0x48(%rax), %xmm1
ucomisd %xmm1, %xmm0
jne 0x25dfdc
jp 0x25dfdc
jmp 0x25e014
movq 0x3ddfbd(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2b8026(%rip), %rsi    # 0x516013
leaq 0x31dc3e(%rip), %rdx    # 0x57bc32
leaq 0x31db97(%rip), %rcx    # 0x57bb92
leaq 0x31d88e(%rip), %r8     # 0x57b890
movl $0x1f3, %r9d            # imm = 0x1F3
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x25e016
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x260c50
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/karlin_altschul_stat.c
// Function: gt_karlin_altschul_stat_calculate_H
static double gt_karlin_altschul_stat_calculate_H(const ScoringFrequency *sf,
                                                  double lambda)
{
  double H, sum, etonlambda;
  GtWord idx, low, high, scale;
  gt_assert(sf->sprob);

  low = sf->low_align_score;
  high = sf->high_align_score;

  etonlambda = exp(-lambda);
  sum = low * sf->sprob[0];
  for (idx = low + 1; idx <= high; idx++)
  {
    sum = idx * sf->sprob[idx-low] + etonlambda * sum;
  }

  scale = pow(etonlambda,high);
  if (scale > 0.0)
    H = lambda * sum/scale;
  else /* case underflow */
    H = lambda * exp(lambda * high + log(sum));

  return H;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movsd %xmm0, 0x58(%rsp)
movq 0x60(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x25e7b2
movq 0x3dd81f(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2b7888(%rip), %rsi    # 0x516013
leaq 0x31d547(%rip), %rdx    # 0x57bcd9
leaq 0x31d54a(%rip), %rcx    # 0x57bce3
leaq 0x31d0f0(%rip), %r8     # 0x57b890
movl $0x119, %r9d            # imm = 0x119
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x25e7b4
movq 0x60(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x60(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x28(%rsp)
movsd 0x58(%rsp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
callq 0x19d40
movsd %xmm0, 0x40(%rsp)
cvtsi2sdq 0x30(%rsp), %xmm0
movq 0x60(%rsp), %rax
movq (%rax), %rax
mulsd (%rax), %xmm0
movsd %xmm0, 0x48(%rsp)
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
cmpq 0x28(%rsp), %rax
jg 0x25e873
cvtsi2sdq 0x38(%rsp), %xmm0
movq 0x60(%rsp), %rax
movq (%rax), %rax
movq 0x38(%rsp), %rcx
subq 0x30(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm2
movsd 0x40(%rsp), %xmm1
mulsd 0x48(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x48(%rsp)
movq 0x38(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x38(%rsp)
jmp 0x25e81f
movsd 0x40(%rsp), %xmm0
cvtsi2sdq 0x28(%rsp), %xmm1
callq 0x19cb0
cvttsd2si %xmm0, %rax
movq %rax, 0x20(%rsp)
cvtsi2sdq 0x20(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x25e8be
movsd 0x58(%rsp), %xmm0
mulsd 0x48(%rsp), %xmm0
cvtsi2sdq 0x20(%rsp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x50(%rsp)
jmp 0x25e91d
movsd 0x58(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x58(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
cvtsi2sdq 0x28(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x48(%rsp), %xmm0
callq 0x195c0
movsd 0x8(%rsp), %xmm2
movaps %xmm0, %xmm1
movsd 0x10(%rsp), %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
callq 0x19d40
movaps %xmm0, %xmm1
movsd 0x18(%rsp), %xmm0
mulsd %xmm1, %xmm0
movsd %xmm0, 0x50(%rsp)
movsd 0x50(%rsp), %xmm0
addq $0x68, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/karlin_altschul_stat.c
// Function: gt_searchspace_store_find
static GtUword gt_searchspace_store_find(const GtUwordPair *arr,
                                         GtUword len,
                                         GtUword key)
{
  const GtUwordPair *left = arr, *right = arr + len - 1;

  while (left <= right)
  {
    const GtUwordPair *mid = left + GT_DIV2(right - left);

    if (key < mid->a)
    {
      right = mid - 1;
    } else
    {
      if (key > mid->a)
      {
        left = mid + 1;
      } else
      {
        return mid->b;
      }
    }
  }
  fprintf(stderr,"%s: cannot find entry for " GT_WU "\n",__func__,key);
  gt_assert(false);
  return GT_UWORD_MAX;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq 0x20(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
addq $-0x10, %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
ja 0x25f964
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rdx
subq %rdx, %rcx
sarq $0x4, %rcx
sarq %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rax
movq (%rsp), %rcx
cmpq (%rcx), %rax
jae 0x25f934
movq (%rsp), %rax
addq $-0x10, %rax
movq %rax, 0x8(%rsp)
jmp 0x25f962
movq 0x18(%rsp), %rax
movq (%rsp), %rcx
cmpq (%rcx), %rax
jbe 0x25f951
movq (%rsp), %rax
addq $0x10, %rax
movq %rax, 0x10(%rsp)
jmp 0x25f960
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x25f9c0
jmp 0x25f962
jmp 0x25f8e7
movq 0x3dc635(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
movq 0x18(%rsp), %rcx
leaq 0x31c3ea(%rip), %rsi    # 0x57bd64
leaq 0x31c402(%rip), %rdx    # 0x57bd83
movb $0x0, %al
callq 0x199f0
movq 0x3dc611(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2b667a(%rip), %rsi    # 0x516013
leaq 0x2f93c3(%rip), %rdx    # 0x558d63
leaq 0x31c3dc(%rip), %rcx    # 0x57bd83
leaq 0x31bee2(%rip), %r8     # 0x57b890
movl $0x313, %r9d            # imm = 0x313
movb $0x0, %al
callq 0x199f0
callq 0x19370
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x260238
movq 0x3dbd99(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2b5e02(%rip), %rsi    # 0x516013
leaq 0x31b699(%rip), %rdx    # 0x57b8b1
leaq 0x31b7f8(%rip), %rcx    # 0x57ba17
leaq 0x31b66a(%rip), %r8     # 0x57b890
movl $0x348, %r9d            # imm = 0x348
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x26023a
movq 0x30(%rsp), %rdi
callq 0x2602f0
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
callq 0x260340
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
callq 0x260390
movq %rax, (%rsp)
cmpq $0x0, 0x10(%rsp)
jle 0x26027d
cmpq $0x0, 0x8(%rsp)
jge 0x26027d
cmpq $0x0, (%rsp)
jl 0x2602b5
movq 0x3dbd1c(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2b5d85(%rip), %rsi    # 0x516013
leaq 0x31b796(%rip), %rdx    # 0x57ba2b
leaq 0x31b77b(%rip), %rcx    # 0x57ba17
leaq 0x31b5ed(%rip), %r8     # 0x57b890
movl $0x34c, %r9d            # imm = 0x34C
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2602b7
movq 0x28(%rsp), %rax
imulq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
imulq 0x8(%rsp), %rcx
addq %rcx, %rax
movq 0x18(%rsp), %rcx
imulq (%rsp), %rcx
addq %rcx, %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/karlin_altschul_stat.c
// Function: gt_evalue_raw_score2bit_score
double gt_evalue_raw_score2bit_score(const GtKarlinAltschulStat *ka,
                                     GtWord raw_score)
{
  double lambda, logK;

  gt_assert(ka != NULL);
  lambda = gt_karlin_altschul_stat_get_lambda(ka);
  logK = gt_karlin_altschul_stat_get_logK(ka);
  return (lambda * (double) raw_score - logK)/ka->log2;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x26042e
movq 0x3dbba3(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2b5c0c(%rip), %rsi    # 0x516013
leaq 0x31b4a3(%rip), %rdx    # 0x57b8b1
leaq 0x31b64a(%rip), %rcx    # 0x57ba5f
leaq 0x31b474(%rip), %r8     # 0x57b890
movl $0x357, %r9d            # imm = 0x357
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x260430
movq 0x20(%rsp), %rdi
callq 0x2604a0
movsd %xmm0, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x25faf0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
cvtsi2sdq 0x18(%rsp), %xmm2
movsd 0x8(%rsp), %xmm1
movq %xmm1, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq 0x20(%rsp), %rax
divsd 0x30(%rax), %xmm0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movsd %xmm0, 0x18(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x26053f
movq 0x3dba92(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2b5afb(%rip), %rsi    # 0x516013
leaq 0x31b392(%rip), %rdx    # 0x57b8b1
leaq 0x31b557(%rip), %rcx    # 0x57ba7d
leaq 0x31b363(%rip), %r8     # 0x57b890
movl $0x362, %r9d            # imm = 0x362
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x260541
movq 0x20(%rsp), %rdi
callq 0x2604a0
movsd %xmm0, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x25faf0
movsd %xmm0, (%rsp)
movsd 0x18(%rsp), %xmm0
movq 0x20(%rsp), %rax
movsd 0x30(%rax), %xmm2
movsd (%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
divsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x192a0
cvttsd2si %xmm0, %rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/karlin_altschul_stat.c
// Function: gt_karlin_altschul_score_vector
static const double *gt_karlin_altschul_score_vector(GtWord matchscore,
                                                     GtWord mismatchscore)
{
  if (matchscore == 1 && mismatchscore == -1)
  {
    return ga_vector_1_1;
  }
  if (matchscore == 1 && mismatchscore == -4)
  {
    return ga_vector_1_4;
  }
  if (matchscore == 2 && mismatchscore == -7)
  {
    return ga_vector_2_7;
  }
  if (matchscore == 1 && mismatchscore == -3)
  {
    return ga_vector_1_3;
  }
  if (matchscore == 2 && mismatchscore == -5)
  {
    return ga_vector_2_5;
  }
  if (matchscore == 1 && mismatchscore == -2)
  {
    return ga_vector_1_2;
  }
  if (matchscore == 2 && mismatchscore == -3)
  {
    return ga_vector_2_3;
  }
  return NULL;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
cmpq $0x1, -0x10(%rsp)
jne 0x260b7b
cmpq $-0x1, -0x18(%rsp)
jne 0x260b7b
leaq 0x31b3ff(%rip), %rax    # 0x57bf70
movq %rax, -0x8(%rsp)
jmp 0x260c3e
cmpq $0x1, -0x10(%rsp)
jne 0x260b9c
cmpq $-0x4, -0x18(%rsp)
jne 0x260b9c
leaq 0x31b40e(%rip), %rax    # 0x57bfa0
movq %rax, -0x8(%rsp)
jmp 0x260c3e
cmpq $0x2, -0x10(%rsp)
jne 0x260bbd
cmpq $-0x7, -0x18(%rsp)
jne 0x260bbd
leaq 0x31b41d(%rip), %rax    # 0x57bfd0
movq %rax, -0x8(%rsp)
jmp 0x260c3e
cmpq $0x1, -0x10(%rsp)
jne 0x260bdb
cmpq $-0x3, -0x18(%rsp)
jne 0x260bdb
leaq 0x31b42c(%rip), %rax    # 0x57c000
movq %rax, -0x8(%rsp)
jmp 0x260c3e
cmpq $0x2, -0x10(%rsp)
jne 0x260bf9
cmpq $-0x5, -0x18(%rsp)
jne 0x260bf9
leaq 0x31b43e(%rip), %rax    # 0x57c030
movq %rax, -0x8(%rsp)
jmp 0x260c3e
cmpq $0x1, -0x10(%rsp)
jne 0x260c17
cmpq $-0x2, -0x18(%rsp)
jne 0x260c17
leaq 0x31b450(%rip), %rax    # 0x57c060
movq %rax, -0x8(%rsp)
jmp 0x260c3e
cmpq $0x2, -0x10(%rsp)
jne 0x260c35
cmpq $-0x3, -0x18(%rsp)
jne 0x260c35
leaq 0x31b462(%rip), %rax    # 0x57c090
movq %rax, -0x8(%rsp)
jmp 0x260c3e
movq $0x0, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/karlin_altschul_stat.c
// Function: get_values_from_vector
static void get_values_from_vector(GtKarlinAltschulStat *ka,
                                   const double *vector)
{
  ka->lambda = vector[lambdaidx];
  gt_assert(ka->lambda != 0.0);
  ka->K = vector[Kidx];
  ka->logK = log(ka->K);
  ka->H = vector[Hidx];
  ka->alpha_div_lambda = vector[alphaidx]/ka->lambda;
  ka->beta = vector[betaidx];
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movsd 0x8(%rax), %xmm0
movq 0x10(%rsp), %rax
movsd %xmm0, (%rax)
movq 0x10(%rsp), %rax
movsd (%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x260cbd
jp 0x260cbd
movq 0x3db314(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2b537d(%rip), %rsi    # 0x516013
leaq 0x31afbb(%rip), %rdx    # 0x57bc58
leaq 0x31afc6(%rip), %rcx    # 0x57bc6a
leaq 0x31abe5(%rip), %r8     # 0x57b890
movl $0x1bc, %r9d            # imm = 0x1BC
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x260cbf
movq 0x8(%rsp), %rax
movsd 0x10(%rax), %xmm0
movq 0x10(%rsp), %rax
movsd %xmm0, 0x8(%rax)
movq 0x10(%rsp), %rax
movsd 0x8(%rax), %xmm0
callq 0x195c0
movq 0x10(%rsp), %rax
movsd %xmm0, 0x10(%rax)
movq 0x8(%rsp), %rax
movsd 0x18(%rax), %xmm0
movq 0x10(%rsp), %rax
movsd %xmm0, 0x18(%rax)
movq 0x8(%rsp), %rax
movsd 0x20(%rax), %xmm0
movq 0x10(%rsp), %rax
divsd (%rax), %xmm0
movq 0x10(%rsp), %rax
movsd %xmm0, 0x20(%rax)
movq 0x8(%rsp), %rax
movsd 0x28(%rax), %xmm0
movq 0x10(%rsp), %rax
movsd %xmm0, 0x28(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/karlin_altschul_stat.c
// Function: gt_karlin_altschul_stat_gcd
static GtWord gt_karlin_altschul_stat_gcd(const ScoringFrequency *sf)
{
  GtWord idx, range, divisor;

  range = sf->high_align_score - sf->low_align_score+1;
  divisor = -sf->low_align_score;
  for (idx = 1; idx < range && divisor > 1; idx++)
  {
    if (sf->sprob[idx] != 0.0)
    {
      GtWord val = labs(idx+sf->low_align_score);
      if (val > divisor)
      {
        GtWord tmp = divisor;
        divisor = val;
        val = tmp;
      }
      while (val != 0)
      {
        GtWord tmp = divisor % val;
        divisor = val;
        val = tmp;
      }
    }
  }
  return divisor;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rsp), %rcx
subq 0x10(%rcx), %rax
addq $0x1, %rax
movq %rax, -0x18(%rsp)
movq -0x8(%rsp), %rcx
xorl %eax, %eax
subq 0x10(%rcx), %rax
movq %rax, -0x20(%rsp)
movq $0x1, -0x10(%rsp)
movq -0x10(%rsp), %rcx
xorl %eax, %eax
cmpq -0x18(%rsp), %rcx
movb %al, -0x39(%rsp)
jge 0x260d98
cmpq $0x1, -0x20(%rsp)
setg %al
movb %al, -0x39(%rsp)
movb -0x39(%rsp), %al
testb $0x1, %al
jne 0x260da5
jmp 0x260e53
movq -0x8(%rsp), %rax
movq (%rax), %rax
movq -0x10(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x260dc4
jp 0x260dc4
jmp 0x260e3e
movq -0x10(%rsp), %rax
movq -0x8(%rsp), %rcx
addq 0x10(%rcx), %rax
movq %rax, %rcx
negq %rcx
cmovnsq %rcx, %rax
movq %rax, -0x28(%rsp)
movq -0x28(%rsp), %rax
cmpq -0x20(%rsp), %rax
jle 0x260e0b
movq -0x20(%rsp), %rax
movq %rax, -0x30(%rsp)
movq -0x28(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x30(%rsp), %rax
movq %rax, -0x28(%rsp)
jmp 0x260e0d
cmpq $0x0, -0x28(%rsp)
je 0x260e3c
movq -0x20(%rsp), %rax
cqto
idivq -0x28(%rsp)
movq %rdx, -0x38(%rsp)
movq -0x28(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x38(%rsp), %rax
movq %rax, -0x28(%rsp)
jmp 0x260e0d
jmp 0x260e3e
jmp 0x260e40
movq -0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rsp)
jmp 0x260d79
movq -0x20(%rsp), %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/marksubstring.c
// Function: gt_marksubstring_new
Gtmarksubstring *gt_marksubstring_new(unsigned int numofchars,
                                      unsigned int kmersize,
                                      bool usesuffix,
                                      unsigned int units)
{
  Gtmarksubstring *mark;

  mark = gt_malloc(sizeof (*mark));
  gt_assert(kmersize >= units);
  mark->units = units;
  mark->entries = gt_power_for_small_exponents(numofchars,units);
  if (usesuffix)
  {
    mark->shiftright = 0;
    mark->mask = (GtCodetype) (mark->entries-1);
  } else
  {
    mark->shiftright = GT_MULT2(kmersize - units);
    mark->mask = ~(GtCodetype) 0;
  }
  GT_INITBITTAB(mark->bits,mark->entries);
  mark->size = sizeof (GtBitsequence) * GT_NUMOFINTSFORBITS(mark->entries);
  return mark;
}

// Assembly:
subq $0x38, %rsp
movb %dl, %al
movl %edi, 0x34(%rsp)
movl %esi, 0x30(%rsp)
andb $0x1, %al
movb %al, 0x2f(%rsp)
movl %ecx, 0x28(%rsp)
movl $0x28, %edi
leaq 0x31b23c(%rip), %rsi    # 0x57c0c0
movl $0x1d, %edx
callq 0xe80f0
movq %rax, 0x20(%rsp)
movl 0x30(%rsp), %eax
cmpl 0x28(%rsp), %eax
jae 0x260ed5
movq 0x3db0fc(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2b5165(%rip), %rsi    # 0x516013
leaq 0x31b225(%rip), %rdx    # 0x57c0da
leaq 0x31b230(%rip), %rcx    # 0x57c0ec
leaq 0x31b1fd(%rip), %r8     # 0x57c0c0
movl $0x1e, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x260ed7
movl 0x28(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x8(%rax)
movl 0x34(%rsp), %edi
movl 0x28(%rsp), %esi
callq 0xec720
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x10(%rax)
testb $0x1, 0x2f(%rsp)
je 0x260f27
movq 0x20(%rsp), %rax
movl $0x0, 0xc(%rax)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rcx
subq $0x1, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x18(%rax)
jmp 0x260f46
movl 0x30(%rsp), %ecx
subl 0x28(%rsp), %ecx
shll %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0xc(%rax)
movq 0x20(%rsp), %rax
movq $-0x1, 0x18(%rax)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
shrq $0x6, %rax
cmpq $0x0, %rax
jne 0x260f65
movl $0x1, %eax
movq %rax, 0x10(%rsp)
jmp 0x260f7f
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
subq $0x1, %rax
shrq $0x6, %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rsi
shlq $0x3, %rsi
xorl %eax, %eax
movl %eax, %edi
leaq 0x31b123(%rip), %rdx    # 0x57c0c0
movl $0x2a, %ecx
callq 0xe8540
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x18(%rsp), %rdx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x19360
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
shrq $0x6, %rax
cmpq $0x0, %rax
jne 0x260feb
movl $0x1, %eax
movq %rax, 0x8(%rsp)
jmp 0x261005
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
subq $0x1, %rax
shrq $0x6, %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rcx
shlq $0x3, %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rax
addq $0x38, %rsp
retq