LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/chain2dim.c
// Function: gt_chain2dim_local_determineequivreps
static void gt_chain2dim_local_determineequivreps(
                                GtChain2DimBestofclass *chainequivalenceclasses,
                                const GtChain2Dimmatchtable *matchtable)
{
  GtUword matchnum;
  GtChain2DimBestofclass *classptr, *classrep;

  for (classptr = chainequivalenceclasses;
       classptr < chainequivalenceclasses + matchtable->nextfree;
       classptr++)
  {
    classptr->isavailable = false;
  }
  for (matchnum=0; matchnum<matchtable->nextfree; matchnum++)
  {
    if (gt_chain2dim_isrightmaximal_chain(matchtable,matchnum))
    {
      classrep = gt_chain2dim_local_getclassrep(chainequivalenceclasses,
                                                matchtable,matchnum);
      if (!classrep->isavailable ||
          classrep->score < matchtable->matches[matchnum].score)
      {
        classrep->score = matchtable->matches[matchnum].score;
        classrep->isavailable = true;
      }
    }
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %rdx
movq 0x18(%rdx), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0x20a58f
movq 0x8(%rsp), %rax
movb $0x0, (%rax)
movq 0x8(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x8(%rsp)
jmp 0x20a558
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq 0x18(%rcx), %rax
jae 0x20a63c
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x20ab80
testb $0x1, %al
jne 0x20a5c1
jmp 0x20a627
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x20ac20
movq %rax, (%rsp)
movq (%rsp), %rax
testb $0x1, (%rax)
je 0x20a601
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rsp), %rcx
movq (%rcx), %rcx
imulq $0x50, 0x10(%rsp), %rdx
addq %rdx, %rcx
cmpq 0x48(%rcx), %rax
jge 0x20a625
movq 0x18(%rsp), %rax
movq (%rax), %rax
imulq $0x50, 0x10(%rsp), %rcx
addq %rcx, %rax
movq 0x48(%rax), %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq (%rsp), %rax
movb $0x1, (%rax)
jmp 0x20a627
jmp 0x20a629
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x20a598
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/chain2dim.c
// Function: gt_chain2dim_retrievemaximalscore
static bool gt_chain2dim_retrievemaximalscore(GtChain2Dimscoretype *maxscore,
                                              const GtChain2Dimmode *chainmode,
                                              const GtChain2Dimmatchtable
                                                *matchtable)
{
  GtUword matchnum;
  GtChain2Dimscoretype tgap;
  bool maxscoredefined = false;

  *maxscore = 0;
  for (matchnum=0; matchnum<matchtable->nextfree; matchnum++)
  {
    if (gt_chain2dim_isrightmaximal_chain(matchtable,matchnum))
    {
      if (chainmode->chainkind == GLOBALCHAININGWITHGAPCOST)
      {
        tgap = GT_CHAIN2DIM_TERMINALGAP(matchnum);
      } else
      {
        tgap = 0;
      }
      if (!maxscoredefined ||
          *maxscore < matchtable->matches[matchnum].score - tgap)
      {
        *maxscore = matchtable->matches[matchnum].score - tgap;
        maxscoredefined = true;
      }
    }
  }
  return maxscoredefined;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movb $0x0, 0xf(%rsp)
movq 0x30(%rsp), %rax
movq $0x0, (%rax)
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
cmpq 0x18(%rcx), %rax
jae 0x20a744
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x20ab80
testb $0x1, %al
jne 0x20a6a9
jmp 0x20a72f
movq 0x28(%rsp), %rax
cmpl $0x1, (%rax)
jne 0x20a6cf
movq 0x20(%rsp), %rax
movq (%rax), %rax
imulq $0x50, 0x18(%rsp), %rcx
addq %rcx, %rax
movq 0x40(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x20a6d8
movq $0x0, 0x10(%rsp)
testb $0x1, 0xf(%rsp)
je 0x20a706
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq 0x20(%rsp), %rcx
movq (%rcx), %rcx
imulq $0x50, 0x18(%rsp), %rdx
addq %rdx, %rcx
movq 0x48(%rcx), %rcx
subq 0x10(%rsp), %rcx
cmpq %rcx, %rax
jge 0x20a72d
movq 0x20(%rsp), %rax
movq (%rax), %rax
imulq $0x50, 0x18(%rsp), %rcx
addq %rcx, %rax
movq 0x48(%rax), %rcx
subq 0x10(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, (%rax)
movb $0x1, 0xf(%rsp)
jmp 0x20a72f
jmp 0x20a731
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x20a67d
movb 0xf(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/chain2dim.c
// Function: retrieve_local_chainbestscores
static void retrieve_local_chainbestscores(bool *minscoredefined,
                                    GtChain2Dimscoretype *minscore,
                                    const GtChain2Dimmatchtable *matchtable,
                                    GtUword howmanybest)
{
  GtUword idx, matchnum = 0;
  GtChain2Dimscoretype *scores;
  GtRankedList *dictbestmatches;
  void *minkey;

  scores = gt_malloc(sizeof (*scores) * matchtable->nextfree);
  dictbestmatches = gt_ranked_list_new(howmanybest,comparescores,NULL,NULL);
  for (idx=0; idx<matchtable->nextfree; idx++)
  {
    if (gt_chain2dim_isrightmaximal_chain(matchtable,idx))
    {
      scores[matchnum] = matchtable->matches[idx].score;
      gt_ranked_list_insert(dictbestmatches,
                            (void *) (scores + matchnum));
      matchnum++;
    }
  }
  if (matchnum == 0)
  {
    *minscoredefined = false;
  } else
  {
    minkey = gt_ranked_list_last(dictbestmatches);
    gt_assert(minkey != NULL);
    *minscore = *((GtChain2Dimscoretype *) minkey);
    *minscoredefined = true;
  }
  gt_ranked_list_delete(dictbestmatches);
  gt_free(scores);
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rdi
shlq $0x3, %rdi
leaq 0x366d83(%rip), %rsi    # 0x571508
movl $0x45c, %edx            # imm = 0x45C
callq 0xe80f0
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
leaq 0x4c0(%rip), %rsi       # 0x20ac60
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x1b6f40
movq %rax, 0x8(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x30(%rsp), %rcx
cmpq 0x18(%rcx), %rax
jae 0x20a840
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x20ab80
testb $0x1, %al
jne 0x20a7df
jmp 0x20a82b
movq 0x30(%rsp), %rax
movq (%rax), %rax
imulq $0x50, 0x20(%rsp), %rcx
addq %rcx, %rax
movq 0x48(%rax), %rdx
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rsi
callq 0x1b7030
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x20a82d
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x20a7ba
cmpq $0x0, 0x18(%rsp)
jne 0x20a852
movq 0x40(%rsp), %rax
movb $0x0, (%rax)
jmp 0x20a8b8
movq 0x8(%rsp), %rdi
callq 0x1b71a0
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x20a89f
movq 0x431732(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x30b79b(%rip), %rsi    # 0x516013
leaq 0x367114(%rip), %rdx    # 0x571993
leaq 0x36711c(%rip), %rcx    # 0x5719a2
leaq 0x366c7b(%rip), %r8     # 0x571508
movl $0x46e, %r9d            # imm = 0x46E
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x20a8a1
movq (%rsp), %rax
movq (%rax), %rcx
movq 0x38(%rsp), %rax
movq %rcx, (%rax)
movq 0x40(%rsp), %rax
movb $0x1, (%rax)
movq 0x8(%rsp), %rdi
callq 0x1b73c0
movq 0x10(%rsp), %rdi
leaq 0x366c3a(%rip), %rsi    # 0x571508
movl $0x473, %edx            # imm = 0x473
callq 0xe88c0
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/chain2dim.c
// Function: gt_chain2dim_isrightmaximal_chain
static bool gt_chain2dim_isrightmaximal_chain(
                                        const GtChain2Dimmatchtable *matchtable,
                                        GtUword currentmatch)
{
  if (currentmatch == matchtable->nextfree - 1)
  {
    return true;
  }
  /* Use previousinchain */
  if (matchtable->matches[currentmatch+1].previousinchain != currentmatch)
  {
    return true;
  }
  if (matchtable->matches[currentmatch+1].score <
      matchtable->matches[currentmatch].score)
  {
    return true;
  }
  return false;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x18(%rsp), %rax
movq -0x10(%rsp), %rcx
movq 0x18(%rcx), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jne 0x20aba8
movb $0x1, -0x1(%rsp)
jmp 0x20ac11
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq -0x18(%rsp), %rcx
addq $0x1, %rcx
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movq 0x28(%rax), %rax
cmpq -0x18(%rsp), %rax
je 0x20abd2
movb $0x1, -0x1(%rsp)
jmp 0x20ac11
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq -0x18(%rsp), %rcx
addq $0x1, %rcx
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movq 0x48(%rax), %rax
movq -0x10(%rsp), %rcx
movq (%rcx), %rcx
imulq $0x50, -0x18(%rsp), %rdx
addq %rdx, %rcx
cmpq 0x48(%rcx), %rax
jge 0x20ac0c
movb $0x1, -0x1(%rsp)
jmp 0x20ac11
movb $0x0, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/chain2dim.c
// Function: comparescores
static int comparescores(const void *key1,
                         const void *key2,
                         GT_UNUSED void *info)
{
  if (*((GtChain2Dimscoretype *) key1) < *(((GtChain2Dimscoretype *) key2)))
  {
    return -1;
  }
  if (*((GtChain2Dimscoretype *) key1) > *(((GtChain2Dimscoretype *) key2)))
  {
    return 1;
  }
  return 0;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq %rdx, -0x20(%rsp)
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq -0x18(%rsp), %rcx
cmpq (%rcx), %rax
jge 0x20ac8b
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x20acaf
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq -0x18(%rsp), %rcx
cmpq (%rcx), %rax
jle 0x20aca7
movl $0x1, -0x4(%rsp)
jmp 0x20acaf
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/chainofin.c
// Function: numberoflinesinfile
static int numberoflinesinfile(GtUword *linenum,
                               const char *filename,
                               GtError *err)
{
  FILE *fp;
  int cc;

  fp = gt_fa_fopen(filename,"r",err);
  *linenum = 0;
  if (fp == NULL)
  {
    return -1;
  }
  while ((cc = getc(fp)) != EOF)
  {
    if (cc == '\n')
    {
      (*linenum)++;
    }
  }
  gt_fa_fclose(fp);
  return 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %r8
leaq 0x320806(%rip), %rsi    # 0x52bfda
leaq 0x366395(%rip), %rdx    # 0x571b70
movl $0x26, %ecx
callq 0xd8df0
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq $0x0, (%rax)
cmpq $0x0, 0x10(%rsp)
jne 0x20b808
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x20b847
jmp 0x20b80a
movq 0x10(%rsp), %rdi
callq 0x191b0
movl %eax, 0xc(%rsp)
cmpl $-0x1, %eax
je 0x20b835
cmpl $0xa, 0xc(%rsp)
jne 0x20b833
movq 0x28(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x20b80a
movq 0x10(%rsp), %rdi
callq 0xd9390
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/cutendpfx.c
// Function: gt_newbucketenumerator
Bucketenumerator *gt_newbucketenumerator(const GtBcktab *bcktab,
                                      unsigned int prefixlength,
                                      const GtUchar *demandprefix,
                                      unsigned int demandprefixlength)
{
  Bucketenumerator *bucketenumerator;
  GT_UNUSED unsigned int firstspecial;

  bucketenumerator = gt_malloc(sizeof *bucketenumerator);
  bucketenumerator->bcktab = bcktab;
  bucketenumerator->prefixlength = prefixlength;
  bucketenumerator->demandprefixlength = demandprefixlength;
  firstspecial = prefixqgram2code(&bucketenumerator->currentcode,
                                  gt_bcktab_multimappower(bcktab),
                                  prefixlength,
                                  demandprefixlength,
                                  demandprefix);
  gt_assert(firstspecial == prefixlength);
  bucketenumerator->lastcode
    = bucketenumerator->currentcode
      + gt_bcktab_filltable(bcktab,demandprefixlength);
  return bucketenumerator;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq %rdx, 0x30(%rsp)
movl %ecx, 0x2c(%rsp)
movl $0x38, %edi
leaq 0x36638e(%rip), %rsi    # 0x571c00
movl $0x46, %edx
callq 0xe80f0
movq %rax, 0x20(%rsp)
movq 0x40(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movl 0x3c(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x8(%rax)
movl 0x2c(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0xc(%rax)
movq 0x20(%rsp), %rax
addq $0x28, %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rdi
callq 0x2065c0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
movl 0x3c(%rsp), %edx
movl 0x2c(%rsp), %ecx
movq 0x30(%rsp), %r8
callq 0x20b960
movl %eax, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x3c(%rsp), %eax
je 0x20b91e
movq 0x4306b3(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x30a71c(%rip), %rsi    # 0x516013
leaq 0x366318(%rip), %rdx    # 0x571c16
leaq 0x36632e(%rip), %rcx    # 0x571c33
leaq 0x3662f4(%rip), %r8     # 0x571c00
movl $0x4f, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x20b920
movq 0x20(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rdi
movl 0x2c(%rsp), %esi
callq 0x2065d0
movq 0x8(%rsp), %rcx
addq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x30(%rax)
movq 0x20(%rsp), %rax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/cutendpfx.c
// Function: prefixqgram2code
static inline unsigned int prefixqgram2code(GtCodetype *code,
                                            const GtCodetype **multimappower,
                                            unsigned int qvalue,
                                            unsigned int qvalueprefix,
                                            const GtUchar *qgram)
{
  int i;
  GtCodetype tmpcode = 0;
  GtUchar a;

  gt_assert(qvalueprefix > 0);
  gt_assert(qvalue > qvalueprefix);
  for (i = (int) (qvalueprefix-1); i>=0; i--)
  {
    a = qgram[i];
    if (GT_ISSPECIAL(a))
    {
      return (unsigned int) i;
    }
    tmpcode += multimappower[i][a];
  }
  *code = tmpcode;
  return qvalue;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movl %edx, 0x2c(%rsp)
movl %ecx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq $0x0, 0x10(%rsp)
cmpl $0x0, 0x28(%rsp)
ja 0x20b9c3
movq 0x43060e(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x30a677(%rip), %rsi    # 0x516013
leaq 0x3662a7(%rip), %rdx    # 0x571c4a
leaq 0x3662b1(%rip), %rcx    # 0x571c5b
leaq 0x36624f(%rip), %r8     # 0x571c00
movl $0x2f, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x20b9c5
jmp 0x20b9c7
movl 0x2c(%rsp), %eax
cmpl 0x28(%rsp), %eax
ja 0x20ba09
movq 0x4305c8(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x30a631(%rip), %rsi    # 0x516013
leaq 0x366283(%rip), %rdx    # 0x571c6c
leaq 0x36626b(%rip), %rcx    # 0x571c5b
leaq 0x366209(%rip), %r8     # 0x571c00
movl $0x30, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x20ba0b
movl 0x28(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x1c(%rsp)
cmpl $0x0, 0x1c(%rsp)
jl 0x20ba72
movq 0x20(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movb (%rax,%rcx), %al
movb %al, 0xf(%rsp)
movzbl 0xf(%rsp), %eax
cmpl $0xfe, %eax
jl 0x20ba44
movl 0x1c(%rsp), %eax
movl %eax, 0x44(%rsp)
jmp 0x20ba87
movq 0x30(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movzbl 0xf(%rsp), %ecx
movq (%rax,%rcx,8), %rax
addq 0x10(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x1c(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x20ba16
movq 0x10(%rsp), %rcx
movq 0x38(%rsp), %rax
movq %rcx, (%rax)
movl 0x2c(%rsp), %eax
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/cutendpfx.c
// Function: gt_nextbucketenumerator
bool gt_nextbucketenumerator(Lcpinterval *itv,
                             Bucketenumerator *bucketenumerator)
{
  while (true)
  {
    if (bucketenumerator->currentcode > bucketenumerator->lastcode)
    {
      break;
    }
    gt_bcktab_calcboundaries(&bucketenumerator->bucketspec,
                             bucketenumerator->bcktab,
                             bucketenumerator->currentcode);
    bucketenumerator->currentcode++;
    if (bucketenumerator->bucketspec.nonspecialsinbucket > 0)
    {
      itv->left = bucketenumerator->bucketspec.left;
      itv->right = itv->left +
                   bucketenumerator->bucketspec.nonspecialsinbucket - 1;
      itv->offset = (GtUword) bucketenumerator->demandprefixlength;
      return true;
    }
  }
  return false;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq (%rsp), %rax
movq 0x28(%rax), %rax
movq (%rsp), %rcx
cmpq 0x30(%rcx), %rax
jbe 0x20bab4
jmp 0x20bb37
movq (%rsp), %rdi
addq $0x10, %rdi
movq (%rsp), %rax
movq (%rax), %rsi
movq (%rsp), %rax
movq 0x28(%rax), %rdx
callq 0x205b80
movq (%rsp), %rax
movq 0x28(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x28(%rax)
movq (%rsp), %rax
cmpq $0x0, 0x18(%rax)
jbe 0x20bb32
movq (%rsp), %rax
movq 0x10(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rcx
movq (%rsp), %rax
addq 0x18(%rax), %rcx
subq $0x1, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq (%rsp), %rax
movl 0xc(%rax), %eax
movl %eax, %ecx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movb $0x1, 0x17(%rsp)
jmp 0x20bb3c
jmp 0x20ba9d
movb $0x0, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/dbs_spaced_seeds.c
// Function: gt_spaced_seed_span
int gt_spaced_seed_span(GtCodetype spaced_seed)
{
  int span = 0;

  for (/* Nothing */; spaced_seed > 0; spaced_seed >>= 1)
  {
    span++;
  }
  return span;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl $0x0, -0xc(%rsp)
cmpq $0x0, -0x8(%rsp)
jbe 0x20bb9f
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
movq -0x8(%rsp), %rax
shrq %rax
movq %rax, -0x8(%rsp)
jmp 0x20bb7d
movl -0xc(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/dbs_spaced_seeds.c
// Function: gt_spaced_seed_weight
int gt_spaced_seed_weight(GtCodetype spaced_seed)
{
  int weight = 0;

  for (/* Nothing */; spaced_seed > 0; spaced_seed >>= 1)
  {
    if (spaced_seed & (GtCodetype) 1)
    {
      weight++;
    }
  }
  return weight;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl $0x0, -0xc(%rsp)
cmpq $0x0, -0x8(%rsp)
jbe 0x20bbf0
movq -0x8(%rsp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x20bbdf
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x20bbe1
movq -0x8(%rsp), %rax
shrq %rax
movq %rax, -0x8(%rsp)
jmp 0x20bbbd
movl -0xc(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/dbs_spaced_seeds.c
// Function: gt_spaced_seed_weight_range
void gt_spaced_seed_weight_range(int *min_weight,int *max_weight, int span)
{
  const int size_table = sizeof gt_spaced_seed_spec_tab/
                         sizeof gt_spaced_seed_spec_tab[0];
  const int num_spans = sizeof gt_spaced_seed_span_start_tab/
                        sizeof gt_spaced_seed_span_start_tab[0];
  int span_offset, end_of_span;

  gt_assert(GT_SPACED_SEED_FIRST_SPAN <= span &&
            span - GT_SPACED_SEED_FIRST_SPAN <= num_spans - 1);
  *min_weight
    = gt_spaced_seed_first_weight_tab[span - GT_SPACED_SEED_FIRST_SPAN];
  if (span - GT_SPACED_SEED_FIRST_SPAN == num_spans - 1)
  {
    end_of_span = size_table;
  } else
  {
    end_of_span
      = gt_spaced_seed_span_start_tab[span + 1 - GT_SPACED_SEED_FIRST_SPAN];
  }
  span_offset = gt_spaced_seed_span_start_tab[span - GT_SPACED_SEED_FIRST_SPAN];
  *max_weight = *min_weight + end_of_span - span_offset - 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movl $0xc5, 0x10(%rsp)
movl $0x12, 0xc(%rsp)
movl $0xf, %eax
cmpl 0x14(%rsp), %eax
jg 0x20bc39
movl 0x14(%rsp), %eax
subl $0xf, %eax
cmpl $0x11, %eax
jle 0x20bc71
movq 0x430360(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x30a3c9(%rip), %rsi    # 0x516013
leaq 0x366031(%rip), %rdx    # 0x571c82
leaq 0x366081(%rip), %rcx    # 0x571cd9
leaq 0x366096(%rip), %r8     # 0x571cf5
movl $0x10b, %r9d            # imm = 0x10B
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x20bc73
movl 0x14(%rsp), %eax
subl $0xf, %eax
movslq %eax, %rcx
leaq 0x431f0c(%rip), %rax    # 0x63db90
movl (%rax,%rcx,4), %ecx
movq 0x20(%rsp), %rax
movl %ecx, (%rax)
movl 0x14(%rsp), %eax
subl $0xf, %eax
cmpl $0x11, %eax
jne 0x20bca4
movl $0xc5, 0x4(%rsp)
jmp 0x20bcbf
movl 0x14(%rsp), %eax
addl $0x1, %eax
subl $0xf, %eax
movslq %eax, %rcx
leaq 0x431f28(%rip), %rax    # 0x63dbe0
movl (%rax,%rcx,4), %eax
movl %eax, 0x4(%rsp)
movl 0x14(%rsp), %eax
subl $0xf, %eax
movslq %eax, %rcx
leaq 0x431f10(%rip), %rax    # 0x63dbe0
movl (%rax,%rcx,4), %eax
movl %eax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movl (%rax), %ecx
addl 0x4(%rsp), %ecx
subl 0x8(%rsp), %ecx
subl $0x1, %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/dbs_spaced_seeds.c
// Function: gt_spaced_seed_spec_new_from_ws
GtSpacedSeedSpec *gt_spaced_seed_spec_new_from_ws(int weight,int span)
{
  int min_weight, max_weight, seed_num;;

  gt_spaced_seed_weight_range(&min_weight,&max_weight, span);
  gt_assert(min_weight <= weight && weight <= max_weight);
  seed_num = gt_spaced_seed_tab_num_extract(weight,span);
  return gt_spaced_seed_spec_new(gt_spaced_seed_spec_tab[seed_num]);
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movl %esi, 0x10(%rsp)
movl 0x10(%rsp), %edx
leaq 0xc(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x20bc00
movl 0xc(%rsp), %eax
cmpl 0x14(%rsp), %eax
jg 0x20c173
movl 0x14(%rsp), %eax
cmpl 0x8(%rsp), %eax
jle 0x20c1ab
movq 0x42fe26(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x309e8f(%rip), %rsi    # 0x516013
leaq 0x365c8b(%rip), %rdx    # 0x571e16
leaq 0x365cb1(%rip), %rcx    # 0x571e43
leaq 0x365b5c(%rip), %r8     # 0x571cf5
movl $0x173, %r9d            # imm = 0x173
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x20c1ad
movl 0x14(%rsp), %edi
movl 0x10(%rsp), %esi
callq 0x20c1e0
movl %eax, 0x4(%rsp)
movslq 0x4(%rsp), %rcx
leaq 0x431a66(%rip), %rax    # 0x63dc30
movq (%rax,%rcx,8), %rdi
callq 0x20bd00
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/dbs_spaced_seeds.c
// Function: gt_spaced_seed_tab_num_extract
static int gt_spaced_seed_tab_num_extract(int weight,int span)
{
  int first_weight, span_offset;

  gt_assert(GT_SPACED_SEED_FIRST_SPAN <= span);
  span_offset = gt_spaced_seed_span_start_tab[span - GT_SPACED_SEED_FIRST_SPAN];
  first_weight
    = gt_spaced_seed_first_weight_tab[span - GT_SPACED_SEED_FIRST_SPAN];
  gt_assert(first_weight <= weight);
  return span_offset + weight - first_weight;
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movl %esi, 0x10(%rsp)
movl $0xf, %eax
cmpl 0x10(%rsp), %eax
jle 0x20c22f
movq 0x42fda2(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x309e0b(%rip), %rsi    # 0x516013
leaq 0x365c85(%rip), %rdx    # 0x571e94
leaq 0x365ca0(%rip), %rcx    # 0x571eb6
leaq 0x365ad8(%rip), %r8     # 0x571cf5
movl $0x166, %r9d            # imm = 0x166
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x20c231
movl 0x10(%rsp), %eax
subl $0xf, %eax
movslq %eax, %rcx
leaq 0x43199e(%rip), %rax    # 0x63dbe0
movl (%rax,%rcx,4), %eax
movl %eax, 0x8(%rsp)
movl 0x10(%rsp), %eax
subl $0xf, %eax
movslq %eax, %rcx
leaq 0x431936(%rip), %rax    # 0x63db90
movl (%rax,%rcx,4), %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x14(%rsp), %eax
jle 0x20c2a3
movq 0x42fd2e(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x309d97(%rip), %rsi    # 0x516013
leaq 0x365c52(%rip), %rdx    # 0x571ed5
leaq 0x365c2c(%rip), %rcx    # 0x571eb6
leaq 0x365a64(%rip), %r8     # 0x571cf5
movl $0x16a, %r9d            # imm = 0x16A
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x20c2a5
movl 0x8(%rsp), %eax
addl 0x14(%rsp), %eax
subl 0xc(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/dbs_spaced_seeds.c
// Function: gt_spaced_seed_extract_generic
GtCodetype gt_spaced_seed_extract_generic(const GtSpacedSeedSpec *seed_spec,
                                          GtCodetype kmer)
{
  GtCodetype ext = 0;
  const GtSpacedSeedSpecValue *seed_spec_ptr;

  gt_assert(seed_spec != NULL);
  for (seed_spec_ptr = seed_spec->spec_tab;
       seed_spec_ptr < seed_spec->spec_tab + seed_spec->num_specs;
       seed_spec_ptr++)
  {
    ext |= ((kmer & seed_spec_ptr->extract) >> seed_spec_ptr->shiftright);
  }
  return ext;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x20c317
movq 0x42fcba(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x309d23(%rip), %rsi    # 0x516013
leaq 0x365b6c(%rip), %rdx    # 0x571e63
leaq 0x365b77(%rip), %rcx    # 0x571e75
leaq 0x3659f0(%rip), %r8     # 0x571cf5
movl $0x17e, %r9d            # imm = 0x17E
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x20c319
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x20(%rsp), %rcx
movq (%rcx), %rcx
movq 0x20(%rsp), %rdx
movq 0x8(%rdx), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0x20c37a
movq 0x18(%rsp), %rax
movq 0x8(%rsp), %rcx
andq (%rcx), %rax
movq 0x8(%rsp), %rcx
movl 0x8(%rcx), %ecx
shrq %cl, %rax
orq 0x10(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x8(%rsp)
jmp 0x20c326
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/diagbandseed.c
// Function: gt_diagbandseed_base_list_get
GtDiagbandseedBaseListType gt_diagbandseed_base_list_get(
                                   bool with_splt,
                                   const char *base_list_string,GtError *err)
{
  size_t idx;
  for (idx = 0; idx < sizeof gt_base_list_arguments/
                      sizeof gt_base_list_arguments[0]; idx++)
  {
    if (strcmp(base_list_string,gt_base_list_arguments[idx]) == 0)
    {
      return (GtDiagbandseedBaseListType) idx;
    }
  }
  gt_error_set(err,"illegal parameter for option -%s: %s",
                    with_splt ? "splt" : "kmplt",
                    with_splt ? gt_diagbandseed_splt_comment()
                              : gt_diagbandseed_kmplt_comment());
  return -1;
}

// Assembly:
subq $0x38, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, 0x33(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
cmpq $0x4, 0x18(%rsp)
jae 0x20c9e4
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rcx
leaq 0x4318a7(%rip), %rax    # 0x63e260
movq (%rax,%rcx,8), %rsi
callq 0x19980
cmpl $0x0, %eax
jne 0x20c9d2
movq 0x18(%rsp), %rax
movl %eax, 0x34(%rsp)
jmp 0x20ca4b
jmp 0x20c9d4
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x20c9a0
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movb 0x33(%rsp), %dl
leaq 0x31ac11(%rip), %rax    # 0x52760a
leaq 0x31ac05(%rip), %rcx    # 0x527605
testb $0x1, %dl
cmovneq %rcx, %rax
movq %rax, 0x10(%rsp)
testb $0x1, 0x33(%rsp)
je 0x20ca1e
callq 0x20c960
movq %rax, (%rsp)
jmp 0x20ca27
callq 0x20c970
movq %rax, (%rsp)
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rdi
movq (%rsp), %rcx
leaq 0x365632(%rip), %rsi    # 0x57206e
movb $0x0, %al
callq 0xd88c0
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/diagbandseed.c
// Function: gt_diagbandseed_dbs_state_new
static GtDiagbandseedState *gt_diagbandseed_dbs_state_new(bool verbose,
                                                        GtUword a_num_sequences,
                                                        GtUword b_num_sequences)
{
  GtDiagbandseedState *dbs_state = gt_calloc(1,sizeof *dbs_state);
  dbs_state->withtiming = verbose;
  if (a_num_sequences > 0)
  {
    dbs_state->used_a_sequences = gt_bittab_new(a_num_sequences);
  } else
  {
    dbs_state->used_a_sequences = NULL;
  }
  if (b_num_sequences > 0)
  {
    gt_assert(a_num_sequences > 0);
    dbs_state->used_b_sequences = gt_bittab_new(b_num_sequences);
  } else
  {
    dbs_state->used_b_sequences = NULL;
  }
  return dbs_state;
}

// Assembly:
subq $0x28, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, 0x27(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl $0x1, %edi
movl $0x78, %esi
leaq 0x363c8c(%rip), %rdx    # 0x571f94
movl $0x903, %ecx            # imm = 0x903
callq 0xe83c0
movq %rax, 0x8(%rsp)
movb 0x27(%rsp), %cl
movq 0x8(%rsp), %rax
andb $0x1, %cl
movb %cl, 0x58(%rax)
cmpq $0x0, 0x18(%rsp)
jbe 0x20e346
movq 0x18(%rsp), %rdi
callq 0x89a20
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x60(%rax)
jmp 0x20e353
movq 0x8(%rsp), %rax
movq $0x0, 0x60(%rax)
cmpq $0x0, 0x10(%rsp)
jbe 0x20e3b7
jmp 0x20e35d
cmpq $0x0, 0x18(%rsp)
ja 0x20e39d
movq 0x42dc34(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x307c9d(%rip), %rsi    # 0x516013
leaq 0x363e2a(%rip), %rdx    # 0x5721a7
leaq 0x363e37(%rip), %rcx    # 0x5721bb
leaq 0x363c09(%rip), %r8     # 0x571f94
movl $0x90e, %r9d            # imm = 0x90E
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x20e39f
movq 0x10(%rsp), %rdi
callq 0x89a20
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x68(%rax)
jmp 0x20e3c4
movq 0x8(%rsp), %rax
movq $0x0, 0x68(%rax)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/diagbandseed.c
// Function: gt_diagbandseed_kmer_filename
static char *gt_diagbandseed_kmer_filename(const GtEncseq *encseq,
                                           unsigned int spacedseedweight,
                                           unsigned int seedlength,
                                           bool forward,
                                           unsigned int numparts,
                                           unsigned int partindex,
                                           GtDiagbandseedBaseListType kmplt)
{
  char *filename;
  GtStr *str = gt_str_new_cstr(gt_encseq_indexname(encseq));
  if (spacedseedweight < seedlength)
  {
    gt_str_append_char(str, '.');
    gt_str_append_uint(str, spacedseedweight);
  }
  gt_str_append_char(str, '.');
  gt_str_append_uint(str, seedlength);
  gt_str_append_char(str, forward ? 'f' : 'r');
  gt_str_append_uint(str, numparts);
  gt_str_append_char(str, '-');
  gt_str_append_uint(str, partindex + 1);
  if (kmplt == GT_DIAGBANDSEED_BASE_LIST_ULONG)
  {
    gt_str_append_char(str, 'U');
  } else
  {
    gt_assert(kmplt == GT_DIAGBANDSEED_BASE_LIST_STRUCT);
  }
  gt_str_append_cstr(str, ".kmer");
  filename = gt_cstr_dup(gt_str_get(str));
  gt_str_delete(str);
  return filename;
}

// Assembly:
subq $0x38, %rsp
movb %cl, %al
movl 0x40(%rsp), %ecx
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl %edx, 0x28(%rsp)
andb $0x1, %al
movb %al, 0x27(%rsp)
movl %r8d, 0x20(%rsp)
movl %r9d, 0x1c(%rsp)
movq 0x30(%rsp), %rdi
callq 0xabb10
movq %rax, %rdi
callq 0x11d510
movq %rax, 0x8(%rsp)
movl 0x2c(%rsp), %eax
cmpl 0x28(%rsp), %eax
jae 0x20e6d5
movq 0x8(%rsp), %rdi
movl $0x2e, %esi
callq 0x11da70
movq 0x8(%rsp), %rdi
movl 0x2c(%rsp), %esi
callq 0x11de00
movq 0x8(%rsp), %rdi
movl $0x2e, %esi
callq 0x11da70
movq 0x8(%rsp), %rdi
movl 0x28(%rsp), %esi
callq 0x11de00
movq 0x8(%rsp), %rdi
movb 0x27(%rsp), %dl
movl $0x72, %eax
movl $0x66, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movsbl %al, %esi
callq 0x11da70
movq 0x8(%rsp), %rdi
movl 0x20(%rsp), %esi
callq 0x11de00
movq 0x8(%rsp), %rdi
movl $0x2d, %esi
callq 0x11da70
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %esi
addl $0x1, %esi
callq 0x11de00
cmpl $0x1, 0x40(%rsp)
jne 0x20e759
movq 0x8(%rsp), %rdi
movl $0x55, %esi
callq 0x11da70
jmp 0x20e79e
jmp 0x20e75b
cmpl $0x0, 0x40(%rsp)
je 0x20e79a
movq 0x42d837(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x3078a0(%rip), %rsi    # 0x516013
leaq 0x363aa8(%rip), %rdx    # 0x572222
leaq 0x363acb(%rip), %rcx    # 0x57224c
leaq 0x36380c(%rip), %r8     # 0x571f94
movl $0xf92, %r9d            # imm = 0xF92
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x20e79c
jmp 0x20e79e
movq 0x8(%rsp), %rdi
leaq 0x363ac0(%rip), %rsi    # 0x57226a
callq 0x11d550
movq 0x8(%rsp), %rdi
callq 0x11dee0
movq %rax, %rdi
callq 0xa2db0
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rdi
callq 0x11f560
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/diagbandseed.c
// Function: gt_create_or_update_file
static bool gt_create_or_update_file(const char *path,const GtEncseq *encseq)
{
  if (gt_file_exists(path))
  {
    GtStr *esqfile = gt_str_new_cstr(gt_encseq_indexname(encseq));

    gt_str_append_cstr(esqfile, ".esq");
    if (gt_file_is_newer(path,gt_str_get(esqfile)))
    {
      gt_str_delete(esqfile);
      return false;
    }
    gt_str_delete(esqfile);
  }
  return true;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0xde820
testb $0x1, %al
jne 0x20e81e
jmp 0x20e886
movq 0x10(%rsp), %rdi
callq 0xabb10
movq %rax, %rdi
callq 0x11d510
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
leaq 0x3091f2(%rip), %rsi    # 0x517a33
callq 0x11d550
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
callq 0x11dee0
movq (%rsp), %rdi
movq %rax, %rsi
callq 0xde9c0
testb $0x1, %al
jne 0x20e86b
jmp 0x20e87c
movq 0x8(%rsp), %rdi
callq 0x11f560
movb $0x0, 0x27(%rsp)
jmp 0x20e88b
movq 0x8(%rsp), %rdi
callq 0x11f560
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/diagbandseed.c
// Function: gt_kmerpos_list_delete
static void gt_kmerpos_list_delete(GtKmerPosList *kmerpos_list)
{
  if (kmerpos_list != NULL)
  {
    gt_free(kmerpos_list->spaceGtDiagbandseedKmerPos);
    gt_free(kmerpos_list->spaceGtUword);
    gt_free(kmerpos_list);
  }
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x20f112
movq (%rsp), %rax
movq (%rax), %rdi
leaq 0x362eba(%rip), %rsi    # 0x571f94
movl $0x1ae, %edx            # imm = 0x1AE
callq 0xe88c0
movq (%rsp), %rax
movq 0x8(%rax), %rdi
leaq 0x362ea1(%rip), %rsi    # 0x571f94
movl $0x1af, %edx            # imm = 0x1AF
callq 0xe88c0
movq (%rsp), %rdi
leaq 0x362e8c(%rip), %rsi    # 0x571f94
movl $0x1b0, %edx            # imm = 0x1B0
callq 0xe88c0
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/diagbandseed.c
// Function: gt_diagbandseed_thread_info_set
static void gt_diagbandseed_thread_info_set(GtDiagbandseedThreadInfo *ti,
                                     const GtDiagbandseedInfo *arg,
                                     const GtKmerPosList *alist,
                                     FILE *stream,
                                     const GtEncseq *aencseq,
                                     const GtSequencePartsInfo *aseqranges,
                                     const GtEncseq *bencseq,
                                     const GtSequencePartsInfo *bseqranges,
                                     const GtKarlinAltschulStat
                                       *karlin_altschul_stat,
                                     GtArray *combinations,
                                     GtError *err)
{
  gt_assert(ti != NULL);
  ti->arg = arg;
  ti->alist = alist;
  ti->stream = stream;
  ti->aencseq = aencseq;
  ti->aseqranges = aseqranges;
  ti->bencseq = bencseq;
  ti->bseqranges = bseqranges;
  ti->karlin_altschul_stat = karlin_altschul_stat;
  ti->combinations = gt_array_clone(combinations);
  ti->had_err = 0;
  ti->err = err;
}

// Assembly:
subq $0x38, %rsp
movq 0x60(%rsp), %rax
movq 0x58(%rsp), %rax
movq 0x50(%rsp), %rax
movq 0x48(%rsp), %rax
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)
cmpq $0x0, 0x30(%rsp)
jne 0x21123b
movq 0x42ad96(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x304dff(%rip), %rsi    # 0x516013
leaq 0x362d91(%rip), %rdx    # 0x573fac
leaq 0x362d95(%rip), %rcx    # 0x573fb7
leaq 0x360d6b(%rip), %r8     # 0x571f94
movl $0x11c9, %r9d           # imm = 0x11C9
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x21123d
movq 0x28(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x40(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x48(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x30(%rax)
movq 0x50(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x58(%rax)
movq 0x58(%rsp), %rdi
callq 0x80a20
movq %rax, %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x40(%rax)
movq 0x30(%rsp), %rax
movl $0x0, 0x48(%rax)
movq 0x60(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x50(%rax)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/diagbandseed.c
// Function: gt_diagbandseed_thread_algorithm
static void *gt_diagbandseed_thread_algorithm(void *thread_info)
{
  GtDiagbandseedThreadInfo *info = (GtDiagbandseedThreadInfo *)thread_info;
  if (gt_array_size(info->combinations) > 0) {
    const GtUwordPair *last = gt_array_get_last(info->combinations),
                      *comb;

    for (comb = gt_array_get_first(info->combinations); comb <= last; comb++) {
      info->had_err = gt_diagbandseed_algorithm(
                           info->arg,
                           info->alist,
                           info->stream,
                           info->aencseq,
                           info->aseqranges,
                           comb->a,
                           info->bencseq,
                           info->bseqranges,
                           comb->b,
                           info->karlin_altschul_stat,
                           NULL,
                           NULL,
                           info->err);
      if (info->had_err) break;
    }
  }
  gt_array_delete(info->combinations);
  return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq 0x40(%rax), %rdi
callq 0x81370
cmpq $0x0, %rax
jbe 0x211417
movq 0x48(%rsp), %rax
movq 0x40(%rax), %rdi
callq 0x80c00
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rax
movq 0x40(%rax), %rdi
callq 0x80be0
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
cmpq 0x40(%rsp), %rax
ja 0x211415
movq 0x48(%rsp), %rax
movq (%rax), %rdi
movq 0x48(%rsp), %rax
movq 0x8(%rax), %rsi
movq 0x48(%rsp), %rax
movq 0x10(%rax), %rdx
movq 0x48(%rsp), %rax
movq 0x18(%rax), %rcx
movq 0x48(%rsp), %rax
movq 0x28(%rax), %r8
movq 0x38(%rsp), %rax
movq (%rax), %r9
movq 0x48(%rsp), %rax
movq 0x20(%rax), %r14
movq 0x48(%rsp), %rax
movq 0x30(%rax), %rbx
movq 0x38(%rsp), %rax
movq 0x8(%rax), %r11
movq 0x48(%rsp), %rax
movq 0x58(%rax), %r10
movq 0x48(%rsp), %rax
movq 0x50(%rax), %rax
xorl %ebp, %ebp
movq %r14, (%rsp)
movq %rbx, 0x8(%rsp)
movq %r11, 0x10(%rsp)
movq %r10, 0x18(%rsp)
movq $0x0, 0x20(%rsp)
movq $0x0, 0x28(%rsp)
movq %rax, 0x30(%rsp)
callq 0x20f150
movl %eax, %ecx
movq 0x48(%rsp), %rax
movl %ecx, 0x48(%rax)
movq 0x48(%rsp), %rax
cmpl $0x0, 0x48(%rax)
je 0x211400
jmp 0x211415
jmp 0x211402
movq 0x38(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x38(%rsp)
jmp 0x211347
jmp 0x211417
movq 0x48(%rsp), %rax
movq 0x40(%rax), %rdi
callq 0x81f80
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/diagbandseed.c
// Function: gt_diagbandseed_process_seeds_times
static void gt_diagbandseed_process_seeds_times(
                 bool extendgreedy,
                 bool maxmat_show,
                 GtUword mlistlen,
                 GtUword extended_seeds,
                 GtUword total_process_seeds_usec,
                 GtUword total_extension_time_usec)
{
  GtUword process_seeds_usec;

  gt_assert(total_process_seeds_usec >= total_extension_time_usec);
  process_seeds_usec = total_process_seeds_usec - total_extension_time_usec;
  if (!maxmat_show)
  {
    printf("# ... %s extension of " GT_WU " seeds in "
                   GT_WD ".%.06ld seconds.\n",
            extendgreedy ? "greedy" : "xdrop",
            extended_seeds,
            GT_USEC2SEC(total_extension_time_usec),
            GT_USECREMAIN(total_extension_time_usec));
  }
  printf( "# ... processed " GT_WU " seeds %sin "
                  GT_WD ".%06ld seconds.\n",mlistlen,
          maxmat_show ? "" : "(excluding extensions) ",
          GT_USEC2SEC(process_seeds_usec),
          GT_USECREMAIN(process_seeds_usec));
}

// Assembly:
subq $0x48, %rsp
movb %sil, %al
movb %dil, %sil
andb $0x1, %sil
movb %sil, 0x47(%rsp)
andb $0x1, %al
movb %al, 0x46(%rsp)
movq %rdx, 0x38(%rsp)
movq %rcx, 0x30(%rsp)
movq %r8, 0x28(%rsp)
movq %r9, 0x20(%rsp)
movq 0x28(%rsp), %rax
cmpq 0x20(%rsp), %rax
jae 0x2116d1
movq 0x42a900(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x304969(%rip), %rsi    # 0x516013
leaq 0x362aa4(%rip), %rdx    # 0x574155
leaq 0x362ad3(%rip), %rcx    # 0x57418b
leaq 0x3608d5(%rip), %r8     # 0x571f94
movl $0xd7c, %r9d            # imm = 0xD7C
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x2116d3
movq 0x28(%rsp), %rax
subq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
testb $0x1, 0x46(%rsp)
jne 0x21174f
movb 0x47(%rsp), %cl
leaq 0x33a9ad(%rip), %rsi    # 0x54c0a1
leaq 0x314bb0(%rip), %rax    # 0x5262ab
testb $0x1, %cl
cmovneq %rax, %rsi
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movl $0xf4240, %ecx          # imm = 0xF4240
xorl %edx, %edx
divq %rcx
movq %rax, %rcx
movq 0x20(%rsp), %r8
movq 0x20(%rsp), %rax
movl $0xf4240, %edi          # imm = 0xF4240
xorl %edx, %edx
divq %rdi
movq 0x10(%rsp), %rdx
imulq $0xf4240, %rax, %rax    # imm = 0xF4240
subq %rax, %r8
leaq 0x362a67(%rip), %rdi    # 0x5741af
movb $0x0, %al
callq 0x19070
movq 0x38(%rsp), %rsi
movb 0x46(%rsp), %dl
leaq 0x362abb(%rip), %rax    # 0x57421a
leaq 0x38bec2(%rip), %rcx    # 0x59d628
testb $0x1, %dl
cmovneq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movl $0xf4240, %ecx          # imm = 0xF4240
xorl %edx, %edx
divq %rcx
movq %rax, %rcx
movq 0x18(%rsp), %r8
movq 0x18(%rsp), %rax
movl $0xf4240, %edi          # imm = 0xF4240
xorl %edx, %edx
divq %rdi
movq 0x8(%rsp), %rdx
imulq $0xf4240, %rax, %rax    # imm = 0xF4240
subq %rax, %r8
leaq 0x362a39(%rip), %rdi    # 0x5741e7
movb $0x0, %al
callq 0x19070
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/diagbandseed.c
// Function: gt_diagbandseed_out_sequences_with_matches
static void gt_diagbandseed_out_sequences_with_matches(
                char seqtype,
                const GtEncseq *encseq,
                const GtBittab *used_sequences)
{
  GtUword seqnum, idx, numbits, max_seq_length;
  char *string_buffer;

  gt_assert(encseq != NULL && used_sequences != NULL);
  numbits = gt_bittab_count_set_bits(used_sequences);
  max_seq_length = gt_encseq_max_seq_length(encseq);
  string_buffer = gt_malloc(sizeof *string_buffer * max_seq_length);
  for (idx = 0, seqnum = gt_bittab_get_first_bitnum(used_sequences);
       idx < numbits;
       idx++, seqnum = gt_bittab_get_next_bitnum(used_sequences,seqnum))
  {
    const GtUword seqstartpos = gt_encseq_seqstartpos(encseq,seqnum),
                  seqlength = gt_encseq_seqlength(encseq,seqnum);
    gt_encseq_extract_decoded(encseq,string_buffer,seqstartpos,
                              seqstartpos + seqlength - 1);
    printf("S\t%c" GT_WU "\t" GT_WU "\t",seqtype,seqnum,seqlength);
    fwrite(string_buffer,sizeof *string_buffer,seqlength,stdout);
    fputc('\n',stdout);
  }
  gt_free(string_buffer);
}

// Assembly:
subq $0x58, %rsp
movb %dil, %al
movb %al, 0x57(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
cmpq $0x0, 0x48(%rsp)
je 0x2117e5
cmpq $0x0, 0x40(%rsp)
jne 0x21181d
movq 0x42a7b4(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x30481d(%rip), %rsi    # 0x516013
leaq 0x362a35(%rip), %rdx    # 0x574232
leaq 0x362a57(%rip), %rcx    # 0x57425b
leaq 0x360789(%rip), %r8     # 0x571f94
movl $0x1237, %r9d           # imm = 0x1237
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x21181f
movq 0x40(%rsp), %rdi
callq 0x8ac40
movq %rax, 0x28(%rsp)
movq 0x48(%rsp), %rdi
callq 0xb10b0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
shlq $0x0, %rdi
leaq 0x360747(%rip), %rsi    # 0x571f94
movl $0x123a, %edx           # imm = 0x123A
callq 0xe80f0
movq %rax, 0x18(%rsp)
movq $0x0, 0x30(%rsp)
movq 0x40(%rsp), %rdi
callq 0x8aa00
movq %rax, 0x38(%rsp)
movq 0x30(%rsp), %rax
cmpq 0x28(%rsp), %rax
jae 0x211944
movq 0x48(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0xb0530
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0xb09f0
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x10(%rsp), %rcx
addq 0x8(%rsp), %rcx
subq $0x1, %rcx
callq 0xac570
movsbl 0x57(%rsp), %esi
movq 0x38(%rsp), %rdx
movq 0x8(%rsp), %rcx
leaq 0x3629a2(%rip), %rdi    # 0x574286
movb $0x0, %al
callq 0x19070
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rdx
movq 0x42a63c(%rip), %rax    # 0x63bf38
movq (%rax), %rcx
movl $0x1, %esi
callq 0x19ea0
movq 0x42a628(%rip), %rax    # 0x63bf38
movq (%rax), %rsi
movl $0xa, %edi
callq 0x198d0
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x8ab20
movq %rax, 0x38(%rsp)
jmp 0x211874
movq 0x18(%rsp), %rdi
leaq 0x360644(%rip), %rsi    # 0x571f94
movl $0x1247, %edx           # imm = 0x1247
callq 0xe88c0
addq $0x58, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/diagbandseed.c
// Function: gt_diagbandseed_dbs_state_delete
static void gt_diagbandseed_dbs_state_delete(GtDiagbandseedState *dbs_state)
{
  if (dbs_state != NULL)
  {
    gt_bittab_delete(dbs_state->used_a_sequences);
    gt_bittab_delete(dbs_state->used_b_sequences);
    gt_free(dbs_state);
  }
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x21199b
movq (%rsp), %rax
movq 0x60(%rax), %rdi
callq 0x8af40
movq (%rsp), %rax
movq 0x68(%rax), %rdi
callq 0x8af40
movq (%rsp), %rdi
leaq 0x360603(%rip), %rsi    # 0x571f94
movl $0x91d, %edx            # imm = 0x91D
callq 0xe88c0
popq %rax
retq
nopl (%rax)