LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/initeqsvec.c
// Function: gt_initeqsvector
void gt_initeqsvector(GtUword *eqsvector,
                   GtUword eqslen,
                   const GtUchar *pattern,
                   GtUword patternlength)
{
  GtUword *eptr, shiftmask;
  const GtUchar *pptr;

  gt_assert(patternlength <=
            (GtUword) (CHAR_BIT * sizeof (GtUword)));
  for (eptr = eqsvector; eptr < eqsvector + eqslen; eptr++)
  {
    *eptr = 0;
  }
  for (pptr = pattern, shiftmask = 1UL;
       pptr < pattern + patternlength && shiftmask != 0;
       pptr++, shiftmask <<= 1)
  {
    gt_assert(*pptr != (GtUchar) GT_SEPARATOR);
    if (*pptr != (GtUchar) GT_WILDCARD)
    {
      eqsvector[(GtUword) *pptr] |= shiftmask;
    }
  }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
cmpq $0x40, 0x28(%rsp)
jbe 0x4d1d68
movq 0x16a269(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x442d2(%rip), %rsi     # 0x516013
leaq 0xe7e9c(%rip), %rdx     # 0x5b9be4
leaq 0xe7ece(%rip), %rcx     # 0x5b9c1d
leaq 0xe7ed8(%rip), %r8      # 0x5b9c2e
movl $0x20, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4d1d6a
movq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x40(%rsp), %rcx
movq 0x38(%rsp), %rdx
shlq $0x3, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0x4d1dab
movq 0x20(%rsp), %rax
movq $0x0, (%rax)
movq 0x20(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x20(%rsp)
jmp 0x4d1d74
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq $0x1, 0x18(%rsp)
movq 0x10(%rsp), %rcx
movq 0x30(%rsp), %rdx
addq 0x28(%rsp), %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, 0xf(%rsp)
jae 0x4d1de5
cmpq $0x0, 0x18(%rsp)
setne %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x4d1df2
jmp 0x4d1e88
jmp 0x4d1df4
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xff, %eax
jne 0x4d1e3b
movq 0x16a196(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x441ff(%rip), %rsi     # 0x516013
leaq 0xe7e2a(%rip), %rdx     # 0x5b9c45
leaq 0xe7dfb(%rip), %rcx     # 0x5b9c1d
leaq 0xe7e05(%rip), %r8      # 0x5b9c2e
movl $0x29, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4d1e3d
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xfe, %eax
je 0x4d1e66
movq 0x18(%rsp), %rdx
movq 0x40(%rsp), %rax
movq 0x10(%rsp), %rcx
movzbl (%rcx), %ecx
orq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
jmp 0x4d1e68
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
shlq %rax
movq %rax, 0x18(%rsp)
jmp 0x4d1dbe
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/initeqsvec.c
// Function: gt_initeqsvectorrev
void gt_initeqsvectorrev(GtUword *eqsvectorrev,
                      GtUword eqslen,
                      const GtUchar *pattern,
                      GtUword patternlength)
{
  GtUword *eptr, shiftmask;
  const GtUchar *pptr;

  gt_assert(patternlength <=
            (GtUword) (CHAR_BIT * sizeof (GtUword)));
  for (eptr = eqsvectorrev; eptr < eqsvectorrev + eqslen; eptr++)
  {
    *eptr = 0;
  }
  for (pptr = pattern+patternlength-1, shiftmask = 1UL;
       pptr >= pattern && shiftmask != 0;
       pptr--, shiftmask <<= 1)
  {
    gt_assert(*pptr != (GtUchar) GT_SEPARATOR);
    if (*pptr != (GtUchar) GT_WILDCARD)
    {
      eqsvectorrev[(GtUword) *pptr] |= shiftmask;
    }
  }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
cmpq $0x40, 0x28(%rsp)
jbe 0x4d1ee8
movq 0x16a0e9(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x44152(%rip), %rsi     # 0x516013
leaq 0xe7d1c(%rip), %rdx     # 0x5b9be4
leaq 0xe7d96(%rip), %rcx     # 0x5b9c65
leaq 0xe7d58(%rip), %r8      # 0x5b9c2e
movl $0x3a, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4d1eea
movq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x40(%rsp), %rcx
movq 0x38(%rsp), %rdx
shlq $0x3, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0x4d1f2b
movq 0x20(%rsp), %rax
movq $0x0, (%rax)
movq 0x20(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x20(%rsp)
jmp 0x4d1ef4
movq 0x30(%rsp), %rax
addq 0x28(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x10(%rsp)
movq $0x1, 0x18(%rsp)
movq 0x10(%rsp), %rcx
xorl %eax, %eax
cmpq 0x30(%rsp), %rcx
movb %al, 0xf(%rsp)
jb 0x4d1f66
cmpq $0x0, 0x18(%rsp)
setne %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x4d1f73
jmp 0x4d2009
jmp 0x4d1f75
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xff, %eax
jne 0x4d1fbc
movq 0x16a015(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4407e(%rip), %rsi     # 0x516013
leaq 0xe7ca9(%rip), %rdx     # 0x5b9c45
leaq 0xe7cc2(%rip), %rcx     # 0x5b9c65
leaq 0xe7c84(%rip), %r8      # 0x5b9c2e
movl $0x43, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4d1fbe
movq 0x10(%rsp), %rax
movzbl (%rax), %eax
cmpl $0xfe, %eax
je 0x4d1fe7
movq 0x18(%rsp), %rdx
movq 0x40(%rsp), %rax
movq 0x10(%rsp), %rcx
movzbl (%rcx), %ecx
orq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
jmp 0x4d1fe9
movq 0x10(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
shlq %rax
movq %rax, 0x18(%rsp)
jmp 0x4d1f47
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/kmer2string.c
// Function: gt_fromkmercode2string
void gt_fromkmercode2string(char *buffer,
                         GtCodetype code,
                         unsigned int numofchars,
                         unsigned int kmersize,
                         const char *characters)
{
  int i;
  unsigned int cc;
  GtCodetype tmpcode = code;

  buffer[kmersize] = '\0';
  for (i=(int) (kmersize-1); i>=0; i--)
  {
    cc = (unsigned int) (tmpcode % numofchars);
    buffer[i] = (char) characters[cc];
    tmpcode = (tmpcode - cc) / numofchars;
  }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl %edx, -0x14(%rsp)
movl %ecx, -0x18(%rsp)
movq %r8, -0x20(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x30(%rsp)
movq -0x8(%rsp), %rax
movl -0x18(%rsp), %ecx
movb $0x0, (%rax,%rcx)
movl -0x18(%rsp), %eax
subl $0x1, %eax
movl %eax, -0x24(%rsp)
cmpl $0x0, -0x24(%rsp)
jl 0x4d20a4
movq -0x30(%rsp), %rax
movl -0x14(%rsp), %ecx
xorl %edx, %edx
divq %rcx
movl %edx, %eax
movl %eax, -0x28(%rsp)
movq -0x20(%rsp), %rax
movl -0x28(%rsp), %ecx
movb (%rax,%rcx), %dl
movq -0x8(%rsp), %rax
movslq -0x24(%rsp), %rcx
movb %dl, (%rax,%rcx)
movq -0x30(%rsp), %rax
movl -0x28(%rsp), %ecx
subq %rcx, %rax
movl -0x14(%rsp), %ecx
xorl %edx, %edx
divq %rcx
movq %rax, -0x30(%rsp)
movl -0x24(%rsp), %eax
addl $-0x1, %eax
movl %eax, -0x24(%rsp)
jmp 0x4d2049
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/merger-trie.c
// Function: mtrie_makeroot
static Mergertrienode *mtrie_makeroot(Mergertrierep *trierep,
                                      Suffixinfo *suffixinfo)
{
  Mergertrienode *root, *newleaf;

#ifdef WITHTRIEIDENT
#ifdef WITHTRIESHOW
  printf("makeroot(" Formatuint64_t ")\n",PRINTuint64_tcast(suffixinfo->ident));
#endif
#endif
  root = newMergertrienode(trierep);
  root->parent = NULL;
  root->suffixinfo = *suffixinfo;
  root->depth = 0;
  root->rightsibling = NULL;
  newleaf = mtrie_makenewleaf(trierep,suffixinfo);
  SETFIRSTCHILD(root,newleaf);
  SHOWNODERELATIONS(root);
  return root;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x4d2e60
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq $0x0, 0x20(%rax)
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0x28(%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x4d2870
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
cmpq $0x0, 0x8(%rsp)
je 0x4d2774
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/merger-trie.c
// Function: hassuccessor
static bool hassuccessor(const Mergertrierep *trierep,
                         Nodepair *np,
                         GtUword prevdepth,
                         const Mergertrienode *node,
                         GtUchar cc2,
                         unsigned int idx2)
{
  GtUchar cc1;
  int cmpresult;

  for (np->previous = NULL, np->current = node->firstchild;
      np->current != NULL;
      np->current = np->current->rightsibling)
  {
    cc1 = getfirstedgechar(trierep,np->current,prevdepth);
    cmpresult = mtrie_comparecharacters(cc1,np->current->suffixinfo.idx,cc2,
                                        idx2);
    if (cmpresult == 1)
    {
      return false;
    }
    if (cmpresult == 0)
    {
      return true;
    }
    np->previous = np->current;
  }
  return false;
}

// Assembly:
subq $0x38, %rsp
movb %r8b, %al
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movb %al, 0xf(%rsp)
movl %r9d, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq $0x0, (%rax)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x4d2859
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rsi
movq 0x18(%rsp), %rdx
callq 0x4d2f20
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %dl
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movl (%rax), %esi
movb 0xf(%rsp), %al
movl 0x8(%rsp), %ecx
movzbl %dl, %edi
movzbl %al, %edx
callq 0x4d2fc0
movl %eax, (%rsp)
cmpl $0x1, (%rsp)
jne 0x4d2820
movb $0x0, 0x37(%rsp)
jmp 0x4d285e
cmpl $0x0, (%rsp)
jne 0x4d282d
movb $0x1, 0x37(%rsp)
jmp 0x4d285e
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
jmp 0x4d27c2
movb $0x0, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/merger-trie.c
// Function: mtrie_makenewleaf
static Mergertrienode *mtrie_makenewleaf(Mergertrierep *trierep,
                                   Suffixinfo *suffixinfo)
{
  Mergertrienode *newleaf;

#ifdef WITHTRIEIDENT
#ifdef WITHTRIESHOW
  printf("makenewleaf(" Formatuint64_t ")\n",
         PRINTuint64_tcast(suffixinfo->ident));
#endif
#endif
  newleaf = newMergertrienode(trierep);
  newleaf->suffixinfo = *suffixinfo;
  SETFIRSTCHILDNULL(newleaf);
  newleaf->rightsibling = NULL;
  SHOWNODERELATIONS(newleaf);
  return newleaf;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x4d2e60
movq %rax, (%rsp)
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq (%rsp), %rax
movq $0x0, 0x10(%rax)
movq (%rsp), %rax
movq $0x0, 0x18(%rax)
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/merger-trie.c
// Function: getlcp
static GtUword getlcp(const GtEncseq *encseq1,
                            GtReadmode readmode1,
                            GtUword start1, GtUword end1,
                            const GtEncseq *encseq2,
                            GtReadmode readmode2,
                            GtUword start2, GtUword end2)
{
  GtUword i1, i2;
  GtUchar cc1;

  for (i1=start1, i2=start2; i1 <= end1 && i2 <= end2; i1++, i2++)
  {
    cc1 = gt_encseq_get_encoded_char(/*XXX*/ encseq1,i1,readmode1);
    if (cc1 != gt_encseq_get_encoded_char(/*XXX*/ encseq2,i2,readmode2)
          || GT_ISSPECIAL(cc1))
    {
      break;
    }
  }
  return i1 - start1;
}

// Assembly:
subq $0x48, %rsp
movq 0x58(%rsp), %rax
movq 0x50(%rsp), %rax
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movl %r9d, 0x1c(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rcx
xorl %eax, %eax
cmpq 0x28(%rsp), %rcx
movb %al, 0x6(%rsp)
ja 0x4d2932
movq 0x8(%rsp), %rax
cmpq 0x58(%rsp), %rax
setbe %al
movb %al, 0x6(%rsp)
movb 0x6(%rsp), %al
testb $0x1, %al
jne 0x4d293c
jmp 0x4d29ab
movq 0x40(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl 0x3c(%rsp), %edx
callq 0xa9da0
movb %al, 0x7(%rsp)
movzbl 0x7(%rsp), %eax
movl %eax, (%rsp)
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl 0x1c(%rsp), %edx
callq 0xa9da0
movb %al, %cl
movl (%rsp), %eax
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x4d2986
movzbl 0x7(%rsp), %eax
cmpl $0xfe, %eax
jl 0x4d2988
jmp 0x4d29ab
jmp 0x4d298a
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x4d290f
movq 0x10(%rsp), %rax
subq 0x30(%rsp), %rax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/merger-trie.c
// Function: mtrie_makenewbranch
static Mergertrienode *mtrie_makenewbranch(Mergertrierep *trierep,
                                     Suffixinfo *suffixinfo,
                                     GtUword currentdepth,
                                     Mergertrienode *oldnode)
{
  Mergertrienode *newbranch, *newleaf;
  GtUchar cc1, cc2;
  Encseqreadinfo *eri = trierep->encseqreadinfo + suffixinfo->idx;

#ifdef WITHTRIEIDENT
#ifdef WITHTRIESHOW
  printf("makenewbranch(ident=" Formatuint64_t ")\n",
          PRINTuint64_tcast(suffixinfo->ident));
#endif
#endif
  newbranch = newMergertrienode(trierep);
  newbranch->suffixinfo = *suffixinfo;
  newbranch->rightsibling = oldnode->rightsibling;
  cc1 = getfirstedgechar(trierep,oldnode,currentdepth);
  if (suffixinfo->startpos + currentdepth >=
      gt_encseq_total_length(eri->encseqptr))
  {
    cc2 = (GtUchar) GT_SEPARATOR;
  } else
  {
    cc2 = gt_encseq_get_encoded_char(eri->encseqptr,
                         suffixinfo->startpos + currentdepth,
                         eri->readmode);
  }
  newleaf = mtrie_makenewleaf(trierep,suffixinfo);
  if (mtrie_comparecharacters(cc1,oldnode->suffixinfo.idx,
                        cc2,suffixinfo->idx) <= 0)
  {
    makesuccs(newbranch,oldnode,newleaf);
  } else
  {
    makesuccs(newbranch,newleaf,oldnode);
  }
  newbranch->depth = currentdepth;
  return newbranch;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x40(%rsp), %rax
movq (%rax), %rax
movq 0x38(%rsp), %rcx
movl (%rcx), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rdi
callq 0x4d2e60
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x38(%rsp), %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x40(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
callq 0x4d2f20
movb %al, 0x17(%rsp)
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rax
addq 0x30(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0xa9d00
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jb 0x4d2a76
movb $-0x1, 0x16(%rsp)
jmp 0x4d2a9d
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rsi
addq 0x30(%rsp), %rsi
movq 0x8(%rsp), %rax
movl 0x8(%rax), %edx
callq 0xa9da0
movb %al, 0x16(%rsp)
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x4d2870
movq %rax, 0x18(%rsp)
movb 0x17(%rsp), %dl
movq 0x28(%rsp), %rax
movl (%rax), %esi
movb 0x16(%rsp), %al
movq 0x38(%rsp), %rcx
movl (%rcx), %ecx
movzbl %dl, %edi
movzbl %al, %edx
callq 0x4d2fc0
cmpl $0x0, %eax
jg 0x4d2aed
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x4d3070
jmp 0x4d2b01
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0x4d3070
movq 0x30(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x20(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/merger-trie.c
// Function: gt_mergertrie_deletesmallestpath
void gt_mergertrie_deletesmallestpath(Mergertrienode *smallest,
                                   Mergertrierep *trierep)
{
  Mergertrienode *father, *son;

  for (son = smallest; son->parent != NULL; son = son->parent)
  {
    father = son->parent;
    if (son->firstchild == NULL)
    {
      SETFIRSTCHILD(father,son->rightsibling);
      SHOWNODERELATIONS(father);
      son->rightsibling = NULL;
    } else
    {
      if (son->firstchild->rightsibling != NULL)
      {
        break;
      }
      son->firstchild->rightsibling = father->firstchild->rightsibling;
      SETFIRSTCHILD(father,son->firstchild);
      SHOWNODERELATIONS(father);
      son->rightsibling = NULL;
      SETFIRSTCHILDNULL(son);
    }
#ifdef WITHTRIEIDENT
#ifdef WITHTRIESHOW
    printf("delete %s " Formatuint64_t "\n",
             MTRIE_ISLEAF(son) ? "leaf" : "branch",
             PRINTuint64_tcast(son->suffixinfo.ident));
#endif
#endif
    trierep->unusedMergertrienodes[trierep->nextunused++] = son;
  }
  if (trierep->root->firstchild == NULL)
  {
    trierep->unusedMergertrienodes[trierep->nextunused++] = trierep->root;
    trierep->root = NULL;
  }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0x4d2cdd
movq -0x20(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rsp)
movq -0x20(%rsp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x4d2c2d
movq -0x20(%rsp), %rax
movq 0x18(%rax), %rcx
movq -0x18(%rsp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x4d2c1e
movq -0x18(%rsp), %rcx
movq -0x20(%rsp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rsp), %rax
movq $0x0, 0x18(%rax)
jmp 0x4d2ca6
movq -0x20(%rsp), %rax
movq 0x10(%rax), %rax
cmpq $0x0, 0x18(%rax)
je 0x4d2c42
jmp 0x4d2cdd
movq -0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x18(%rax), %rcx
movq -0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rsp), %rax
movq 0x10(%rax), %rcx
movq -0x18(%rsp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x4d2c8c
movq -0x18(%rsp), %rcx
movq -0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rsp), %rax
movq $0x0, 0x18(%rax)
movq -0x20(%rsp), %rax
movq $0x0, 0x10(%rax)
movq -0x20(%rsp), %rdx
movq -0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rsp), %rsi
movl 0x24(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x24(%rsi)
movl %ecx, %ecx
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rsp)
jmp 0x4d2bc4
movq -0x10(%rsp), %rax
movq 0x10(%rax), %rax
cmpq $0x0, 0x10(%rax)
jne 0x4d2d22
movq -0x10(%rsp), %rax
movq 0x10(%rax), %rdx
movq -0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rsp), %rsi
movl 0x24(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x24(%rsi)
movl %ecx, %ecx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rsp), %rax
movq $0x0, 0x10(%rax)
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/merger-trie.c
// Function: gt_mergertrie_initnodetable
void gt_mergertrie_initnodetable(Mergertrierep *trierep,
                              GtUword numofsuffixes,
                              unsigned int numofindexes)
{
  trierep->numofindexes = numofindexes;
  trierep->allocatedMergertrienode
    = (unsigned int) GT_MULT2(numofsuffixes + 1) + 1;
  trierep->nodetable = gt_malloc(sizeof *trierep->nodetable
                                 * trierep->allocatedMergertrienode);
  trierep->nextfreeMergertrienode = 0;
  trierep->root = NULL;
  trierep->nextunused = 0;
  trierep->unusedMergertrienodes
    = gt_malloc(sizeof *trierep->unusedMergertrienodes
                * trierep->allocatedMergertrienode);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl %edx, 0x4(%rsp)
movl 0x4(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x20(%rax)
movq 0x8(%rsp), %rax
addq $0x1, %rax
shlq %rax
movl %eax, %ecx
addl $0x1, %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x28(%rax)
movq 0x10(%rsp), %rax
movl 0x28(%rax), %eax
imulq $0x30, %rax, %rdi
leaq 0xe6f2e(%rip), %rsi     # 0x5b9ca8
movl $0x28f, %edx            # imm = 0x28F
callq 0xe80f0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movl $0x0, 0x2c(%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0x10(%rax)
movq 0x10(%rsp), %rax
movl $0x0, 0x24(%rax)
movq 0x10(%rsp), %rax
movl 0x28(%rax), %eax
movl %eax, %edi
shlq $0x3, %rdi
leaq 0xe6ede(%rip), %rsi     # 0x5b9ca8
movl $0x295, %edx            # imm = 0x295
callq 0xe80f0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/merger-trie.c
// Function: gt_mergertrie_delete
void gt_mergertrie_delete(Mergertrierep *trierep)
{
  if (trierep != NULL)
  {
    gt_free(trierep->nodetable);
    gt_free(trierep->unusedMergertrienodes);
    gt_free(trierep->encseqreadinfo);
    trierep->encseqreadinfo = NULL;
  }
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x4d2e51
movq (%rsp), %rax
movq 0x8(%rax), %rdi
leaq 0xe6e9d(%rip), %rsi     # 0x5b9ca8
movl $0x29c, %edx            # imm = 0x29C
callq 0xe88c0
movq (%rsp), %rax
movq 0x18(%rax), %rdi
leaq 0xe6e84(%rip), %rsi     # 0x5b9ca8
movl $0x29d, %edx            # imm = 0x29D
callq 0xe88c0
movq (%rsp), %rax
movq (%rax), %rdi
leaq 0xe6e6c(%rip), %rsi     # 0x5b9ca8
movl $0x29e, %edx            # imm = 0x29E
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/merger-trie.c
// Function: newMergertrienode
static Mergertrienode *newMergertrienode(Mergertrierep *trierep)
{
#ifdef WITHTRIEIDENT
#ifdef WITHTRIESHOW
  printf("# available trie nodes: %u; ",
          trierep->allocatedMergertrienode - trierep->nextfreeMergertrienode);
  printf("unused trie nodes: %u\n",trierep->nextunused);
#endif
#endif
  if (trierep->nextfreeMergertrienode >= trierep->allocatedMergertrienode)
  {
    gt_assert(trierep->nextunused > 0);
    trierep->nextunused--;
    return trierep->unusedMergertrienodes[trierep->nextunused];
  }
  return trierep->nodetable + trierep->nextfreeMergertrienode++;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl 0x2c(%rax), %eax
movq 0x8(%rsp), %rcx
cmpl 0x28(%rcx), %eax
jb 0x4d2eec
jmp 0x4d2e7d
movq 0x8(%rsp), %rax
cmpl $0x0, 0x24(%rax)
ja 0x4d2ec0
movq 0x169111(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4317a(%rip), %rsi     # 0x516013
leaq 0xe6e84(%rip), %rdx     # 0x5b9d24
leaq 0xe6e95(%rip), %rcx     # 0x5b9d3c
leaq 0xe6dfa(%rip), %r8      # 0x5b9ca8
movl $0x14d, %r9d            # imm = 0x14D
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4d2ec2
movq 0x8(%rsp), %rax
movl 0x24(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x24(%rax)
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x8(%rsp), %rcx
movl 0x24(%rcx), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
jmp 0x4d2f13
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rsp), %rdx
movl 0x2c(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x2c(%rdx)
movl %ecx, %ecx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/merger-trie.c
// Function: getfirstedgechar
static GtUchar getfirstedgechar(const Mergertrierep *trierep,
                              const Mergertrienode *node,
                              GtUword prevdepth)
{
  Encseqreadinfo *eri = trierep->encseqreadinfo + node->suffixinfo.idx;

  if (MTRIE_ISLEAF(node) &&
      node->suffixinfo.startpos + prevdepth >=
      gt_encseq_total_length(eri->encseqptr))
  {
    return (GtUchar) GT_SEPARATOR;
  }
  return gt_encseq_get_encoded_char(eri->encseqptr, /* Random access */
                        node->suffixinfo.startpos + prevdepth,
                        eri->readmode);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq 0x20(%rsp), %rcx
movl (%rcx), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x4d2f8e
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
addq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0xa9d00
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jb 0x4d2f8e
movb $-0x1, 0x37(%rsp)
jmp 0x4d2fb5
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rsi
addq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rax
movl 0x8(%rax), %edx
callq 0xa9da0
movb %al, 0x37(%rsp)
movb 0x37(%rsp), %al
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/merger-trie.c
// Function: mtrie_comparecharacters
static int mtrie_comparecharacters(GtUchar cc1,unsigned int idx1,
                                   GtUchar cc2,unsigned int idx2)
{
  if (GT_ISSPECIAL(cc1))
  {
    if (GT_ISSPECIAL(cc2))
    {
      if (idx1 <= idx2)
      {
        return -1;  /* cc1 < cc2 */
      } else
      {
        return 1;  /* cc1 > cc2 */
      }
    } else
    {
      return 1; /* cc1 > cc2 */
    }
  } else
  {
    if (GT_ISSPECIAL(cc2))
    {
      return -1;  /* cc1 < cc2 */
    } else
    {
      if (cc1 < cc2)
      {
        return -1;  /* cc1 < cc2 */
      } else
      {
        if (cc1 > cc2)
        {
          return 1;  /* cc1 > cc2 */
        } else
        {
          return 0; /* cc1 == cc2 */
        }
      }
    }
  }
}

// Assembly:
movb %dl, %al
movb %dil, %dl
movb %dl, -0x5(%rsp)
movl %esi, -0xc(%rsp)
movb %al, -0xd(%rsp)
movl %ecx, -0x14(%rsp)
movzbl -0x5(%rsp), %eax
cmpl $0xfe, %eax
jl 0x4d3015
movzbl -0xd(%rsp), %eax
cmpl $0xfe, %eax
jl 0x4d300b
movl -0xc(%rsp), %eax
cmpl -0x14(%rsp), %eax
ja 0x4d3001
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x4d3063
movl $0x1, -0x4(%rsp)
jmp 0x4d3063
movl $0x1, -0x4(%rsp)
jmp 0x4d3063
movzbl -0xd(%rsp), %eax
cmpl $0xfe, %eax
jl 0x4d302b
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x4d3063
movzbl -0x5(%rsp), %eax
movzbl -0xd(%rsp), %ecx
cmpl %ecx, %eax
jge 0x4d3043
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
jmp 0x4d3063
movzbl -0x5(%rsp), %eax
movzbl -0xd(%rsp), %ecx
cmpl %ecx, %eax
jle 0x4d305b
movl $0x1, -0x4(%rsp)
jmp 0x4d3063
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/mssufpat.c
// Function: pms_allocatedfsconstinfo
static Limdfsconstinfo *pms_allocatedfsconstinfo(unsigned int alphasize)
{
  GtMssufpatLimdfsconstinfo *mti =
                                  gt_malloc(sizeof (GtMssufpatLimdfsconstinfo));

  mti->eqsvector = gt_malloc(sizeof (*mti->eqsvector) * alphasize);
  return (Limdfsconstinfo*) mti;
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movl $0x610, %edi            # imm = 0x610
leaq 0xe6c6a(%rip), %rsi     # 0x5b9d4e
movl $0x4e, %edx
callq 0xe80f0
movq %rax, 0x8(%rsp)
movl 0x14(%rsp), %eax
movl %eax, %edi
shlq $0x3, %rdi
leaq 0xe6c4a(%rip), %rsi     # 0x5b9d4e
movl $0x50, %edx
callq 0xe80f0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x208(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/mssufpat.c
// Function: pms_initdfsconstinfo
static void pms_initdfsconstinfo(Limdfsconstinfo *mt,
                                 unsigned int alphasize,
                                 ...)
                                 /* Variable argument list is as follows:
                                    unsigned int alphasize
                                    const GtUchar *pattern,
                                    GtUword patternlength
                                 */
{
  va_list ap;
  GtMssufpatLimdfsconstinfo *mti = (GtMssufpatLimdfsconstinfo*) mt;
  const GtUchar *pattern;

  va_start(ap,alphasize);
  pattern = va_arg(ap, const GtUchar *);
  mti->patternlength = va_arg(ap, GtUword);
  va_end(ap);
  gt_initeqsvector(mti->eqsvector,(GtUword) alphasize,
                pattern,mti->patternlength);
}

// Assembly:
subq $0x118, %rsp            # imm = 0x118
testb %al, %al
je 0x4d3175
movaps %xmm0, 0x60(%rsp)
movaps %xmm1, 0x70(%rsp)
movaps %xmm2, 0x80(%rsp)
movaps %xmm3, 0x90(%rsp)
movaps %xmm4, 0xa0(%rsp)
movaps %xmm5, 0xb0(%rsp)
movaps %xmm6, 0xc0(%rsp)
movaps %xmm7, 0xd0(%rsp)
movq %r9, 0x58(%rsp)
movq %r8, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rdi, 0x110(%rsp)
movl %esi, 0x10c(%rsp)
movq 0x110(%rsp), %rax
movq %rax, 0xe8(%rsp)
leaq 0xf0(%rsp), %rax
leaq 0x30(%rsp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x120(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
leaq 0xf0(%rsp), %rax
movq %rax, 0x20(%rsp)
movl 0xf0(%rsp), %eax
movl %eax, 0x2c(%rsp)
cmpl $0x28, %eax
ja 0x4d320b
movq 0x20(%rsp), %rcx
movl 0x2c(%rsp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, 0x18(%rsp)
jmp 0x4d3224
movq 0x20(%rsp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, 0xe0(%rsp)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0xf0(%rsp), %eax
movl %eax, 0x14(%rsp)
cmpl $0x28, %eax
ja 0x4d326c
movq 0x8(%rsp), %rcx
movl 0x14(%rsp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, (%rsp)
jmp 0x4d3284
movq 0x8(%rsp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, (%rsp)
movq (%rsp), %rax
movq (%rax), %rcx
movq 0xe8(%rsp), %rax
movq %rcx, (%rax)
movq 0xe8(%rsp), %rax
movq 0x208(%rax), %rdi
movl 0x10c(%rsp), %ecx
movl %ecx, %esi
movq 0xe0(%rsp), %rdx
movq (%rax), %rcx
callq 0x4d1d10
addq $0x118, %rsp            # imm = 0x118
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/mssufpat.c
// Function: pms_extractdfsconstinfo
static void pms_extractdfsconstinfo(Processresult processresult,
                                    void *processinfo,
                                    const void *patterninfo,
                                    Limdfsconstinfo *mt)
{
  GtUword idx;
  GtMssufpatLimdfsconstinfo *mti = (GtMssufpatLimdfsconstinfo*) mt;

  for (idx=0; idx<mti->patternlength; idx++)
  {
    processresult(processinfo,patterninfo,idx,mti->mstatlength[idx],
                                              mti->mstatwitnessleftbound[idx],
                                              mti->mstatwitnessrightbound[idx]);
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq (%rcx), %rax
jae 0x4d3363
movq 0x30(%rsp), %rax
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %r8
movq 0x8(%rcx,%r8,8), %rcx
movq 0x8(%rsp), %r8
movq 0x10(%rsp), %r9
movq 0x210(%r8,%r9,8), %r8
movq 0x8(%rsp), %r9
movq 0x10(%rsp), %r10
movq 0x410(%r9,%r10,8), %r9
callq *%rax
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x4d32fb
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/mssufpat.c
// Function: pms_freedfsconstinfo
static void pms_freedfsconstinfo(Limdfsconstinfo **mtptr)
{
  GtMssufpatLimdfsconstinfo **mtiptr = (GtMssufpatLimdfsconstinfo**) mtptr;
  gt_free((*mtiptr)->eqsvector);
  gt_free((*mtiptr));
  *mtiptr = NULL;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq 0x208(%rax), %rdi
leaq 0xe69b5(%rip), %rsi     # 0x5b9d4e
movl $0x7c, %edx
callq 0xe88c0
movq 0x8(%rsp), %rax
movq (%rax), %rdi
leaq 0xe699c(%rip), %rsi     # 0x5b9d4e
movl $0x7d, %edx
callq 0xe88c0
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/mssufpat.c
// Function: pms_initLimdfsstate
static void pms_initLimdfsstate(DECLAREPTRDFSSTATE(aliascolumn),
                                Limdfsconstinfo *mt)
{
  GtMssufpatLimdfsstate *column = (GtMssufpatLimdfsstate *) aliascolumn;
  GtMssufpatLimdfsconstinfo *mti = (GtMssufpatLimdfsconstinfo*) mt;
  GtUword idx;

  column->prefixofsuffixbits = ~0UL;
  gt_assert(mti->patternlength <= (GtUword) GT_INTWORDSIZE);
  for (idx = 0; idx<mti->patternlength; idx++)
  {
    mti->mstatlength[idx] = 0;
    mti->mstatwitnessleftbound[idx] = 0;
    mti->mstatwitnessrightbound[idx] = 0;
  }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq $-0x1, (%rax)
movq 0x8(%rsp), %rax
cmpq $0x40, (%rax)
jbe 0x4d3441
movq 0x168b90(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x42bf9(%rip), %rsi     # 0x516013
leaq 0xe6942(%rip), %rdx     # 0x5b9d63
leaq 0xe696a(%rip), %rcx     # 0x5b9d92
leaq 0xe691f(%rip), %r8      # 0x5b9d4e
movl $0xb4, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4d3443
movq $0x0, (%rsp)
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq (%rcx), %rax
jae 0x4d34a3
movq 0x8(%rsp), %rax
movq (%rsp), %rcx
movq $0x0, 0x8(%rax,%rcx,8)
movq 0x8(%rsp), %rax
movq (%rsp), %rcx
movq $0x0, 0x210(%rax,%rcx,8)
movq 0x8(%rsp), %rax
movq (%rsp), %rcx
movq $0x0, 0x410(%rax,%rcx,8)
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x4d344b
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/mssufpat.c
// Function: pms_nextLimdfsstate
static void pms_nextLimdfsstate(const Limdfsconstinfo *mt,
                                DECLAREPTRDFSSTATE(aliasoutcol),
                                GtUword currentdepth,
                                GtUchar currentchar,
                                const DECLAREPTRDFSSTATE(aliasincol))
{
#ifdef SKDEBUG
  char buffer1[GT_INTWORDSIZE+1], buffer2[GT_INTWORDSIZE+1];
#endif
  GtMssufpatLimdfsstate *outcol = (GtMssufpatLimdfsstate *) aliasoutcol;
  GtMssufpatLimdfsconstinfo *mti = (GtMssufpatLimdfsconstinfo*) mt;
  const GtMssufpatLimdfsstate *incol =
                                     (const GtMssufpatLimdfsstate *) aliasincol;

  gt_assert(GT_ISNOTSPECIAL(currentchar));
  gt_assert(currentdepth > 0);

  if (currentdepth > 1UL)
  {
    outcol->prefixofsuffixbits
      = incol->prefixofsuffixbits &
        (mti->eqsvector[currentchar] >> (currentdepth-1));
  } else
  {
    outcol->prefixofsuffixbits = mti->eqsvector[currentchar];
  }
#ifdef SKDEBUG
  bitsequence2string(buffer1,(Bitsequence) incol->prefixofsuffixbits);
  bitsequence2string(buffer2,(Bitsequence) outcol->prefixofsuffixbits);
  printf("next(%s,%u,depth="GT_WU")->%s\n",buffer1,(unsigned int) currentchar,
                                       currentdepth,buffer2);
#endif
}

// Assembly:
subq $0x48, %rsp
movb %cl, %al
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movb %al, 0x2f(%rsp)
movq %r8, 0x20(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movzbl 0x2f(%rsp), %eax
cmpl $0xfe, %eax
jl 0x4d36b0
movq 0x168921(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x4298a(%rip), %rsi     # 0x516013
leaq 0xa0c48(%rip), %rdx     # 0x5742d8
leaq 0xe6765(%rip), %rcx     # 0x5b9dfc
leaq 0xe66b0(%rip), %r8      # 0x5b9d4e
movl $0xf5, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4d36b2
jmp 0x4d36b4
cmpq $0x0, 0x30(%rsp)
ja 0x4d36f4
movq 0x1688dd(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x42946(%rip), %rsi     # 0x516013
leaq 0xbb6ba(%rip), %rdx     # 0x58ed8e
leaq 0xe6721(%rip), %rcx     # 0x5b9dfc
leaq 0xe666c(%rip), %r8      # 0x5b9d4e
movl $0xf6, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4d36f6
cmpq $0x1, 0x30(%rsp)
jbe 0x4d373c
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
movq 0x208(%rax), %rax
movzbl 0x2f(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq 0x30(%rsp), %rcx
subq $0x1, %rcx
shrq %cl, %rax
movq (%rsp), %rcx
andq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
jmp 0x4d3759
movq 0x10(%rsp), %rax
movq 0x208(%rax), %rax
movzbl 0x2f(%rsp), %ecx
movq (%rax,%rcx,8), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/mssufpat.c
// Function: pms_inplacenextLimdfsstate
static void pms_inplacenextLimdfsstate(const Limdfsconstinfo *mt,
                                       DECLAREPTRDFSSTATE(aliascol),
                                       GtUword currentdepth,
                                       GtUchar currentchar)
{
#ifdef SKDEBUG
  char buffer1[INTWORDSIZE+1], buffer2[INTWORDSIZE+1];
  GtUword tmp;
#endif
  GtMssufpatLimdfsstate *col = (GtMssufpatLimdfsstate *) aliascol;
  GtMssufpatLimdfsconstinfo *mti = (GtMssufpatLimdfsconstinfo*) mt;

  gt_assert(GT_ISNOTSPECIAL(currentchar));
#ifdef SKDEBUG
  tmp = col->prefixofsuffixbits;
#endif
  col->prefixofsuffixbits &= (mti->eqsvector[currentchar] >> (currentdepth-1));
#ifdef SKDEBUG
  bitsequence2string(buffer1,(uint32_t) tmp);
  bitsequence2string(buffer2,(uint32_t) col->prefixofsuffixbits);
  printf("inplacenext(%s,%u,"GT_WU")->%s\n",buffer1,(unsigned int) currentchar,
                                        currentdepth,buffer2);
#endif
}

// Assembly:
subq $0x38, %rsp
movb %cl, %al
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movb %al, 0x1f(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movzbl 0x1f(%rsp), %eax
cmpl $0xfe, %eax
jl 0x4d37d1
movq 0x168800(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x42869(%rip), %rsi     # 0x516013
leaq 0xa0b27(%rip), %rdx     # 0x5742d8
leaq 0xe6658(%rip), %rcx     # 0x5b9e10
leaq 0xe658f(%rip), %r8      # 0x5b9d4e
movl $0x115, %r9d            # imm = 0x115
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4d37d3
movq 0x8(%rsp), %rax
movq 0x208(%rax), %rax
movzbl 0x1f(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq 0x20(%rsp), %rcx
subq $0x1, %rcx
shrq %cl, %rax
movq %rax, %rcx
movq 0x10(%rsp), %rax
andq (%rax), %rcx
movq %rcx, (%rax)
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/mssufpat.c
// Function: zerosontheright
static GtUword zerosontheright(GtUword v)
{
  GtUword c;     /* c will be the number of zero bits on the right,
                         so if v is 1101000 (base 2), then c will be 3 */
  gt_assert(v > 0);
  if (v & 0x1)
  {
    c = 0; /* special case for odd v (assumed to happen half of the time) */
  } else
  {
    c = 1UL;
#if defined (_LP64) || defined (_WIN64)
    if ((v & 0xffffffff) == 0)
    {
      v >>= 32;
      c+= 32UL;
    }
#endif
    if ((v & 0xffff) == 0)
    {
      v >>= 16;
      c += 16UL;
    }
    if ((v & 0xff) == 0)
    {
      v >>= 8;
      c += 8UL;
    }
    if ((v & 0xf) == 0)
    {
      v >>= 4;
      c += 4UL;
    }
    if ((v & 0x3) == 0)
    {
      v >>= 2;
      c += 2UL;
    }
    c -= v & 0x1;
  }
  return c;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
ja 0x4d3859
movq 0x168778(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x427e1(%rip), %rsi     # 0x516013
leaq 0xe65ad(%rip), %rdx     # 0x5b9de6
leaq 0xe65ac(%rip), %rcx     # 0x5b9dec
leaq 0xe6507(%rip), %r8      # 0x5b9d4e
movl $0x85, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4d385b
movq 0x10(%rsp), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x4d3878
movq $0x0, 0x8(%rsp)
jmp 0x4d3978
movq $0x1, 0x8(%rsp)
movabsq $0xffffffff, %rax       # imm = 0xFFFFFFFF
andq 0x10(%rsp), %rax
cmpq $0x0, %rax
jne 0x4d38b2
movq 0x10(%rsp), %rax
shrq $0x20, %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
andq $0xffff, %rax           # imm = 0xFFFF
cmpq $0x0, %rax
jne 0x4d38df
movq 0x10(%rsp), %rax
shrq $0x10, %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
andq $0xff, %rax
cmpq $0x0, %rax
jne 0x4d390c
movq 0x10(%rsp), %rax
shrq $0x8, %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
andq $0xf, %rax
cmpq $0x0, %rax
jne 0x4d3937
movq 0x10(%rsp), %rax
shrq $0x4, %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
andq $0x3, %rax
cmpq $0x0, %rax
jne 0x4d3962
movq 0x10(%rsp), %rax
shrq $0x2, %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rax
addq $0x2, %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rcx
andq $0x1, %rcx
movq 0x8(%rsp), %rax
subq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/myersapm.c
// Function: gt_newMyersonlineresources
Myersonlineresources *gt_newMyersonlineresources(unsigned int numofchars,
                                                 bool nowildcards,
                                                 const GtEncseq *encseq,
                                                 ProcessIdxMatch processmatch,
                                                 void *processmatchinfo)
{
  Myersonlineresources *mor;

  mor = gt_malloc(sizeof *mor);
  mor->eqsvectorrev = gt_malloc(sizeof *mor->eqsvectorrev * numofchars);
  mor->eqsvector = gt_malloc(sizeof *mor->eqsvector * numofchars);
  mor->encseq = encseq;
  mor->esr = gt_encseq_create_reader_with_readmode(encseq, GT_READMODE_REVERSE,
                                                   0);
  gt_assert(numofchars <= GT_MAXALPHABETCHARACTER);
  mor->alphasize = numofchars;
  mor->totallength = gt_encseq_total_length(encseq);
  mor->nowildcards = nowildcards;
  mor->processmatch = processmatch;
  mor->processmatchinfo = processmatchinfo;
  return mor;
}

// Assembly:
subq $0x28, %rsp
movb %sil, %al
movl %edi, 0x24(%rsp)
andb $0x1, %al
movb %al, 0x23(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq %r8, 0x8(%rsp)
movl $0x40, %edi
leaq 0xe646f(%rip), %rsi     # 0x5b9e2b
movl $0x31, %edx
callq 0xe80f0
movq %rax, (%rsp)
movl 0x24(%rsp), %eax
movl %eax, %edi
shlq $0x3, %rdi
leaq 0xe6450(%rip), %rsi     # 0x5b9e2b
movl $0x32, %edx
callq 0xe80f0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
movl 0x24(%rsp), %eax
movl %eax, %edi
shlq $0x3, %rdi
leaq 0xe642a(%rip), %rsi     # 0x5b9e2b
movl $0x33, %edx
callq 0xe80f0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x18(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0xac380
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
cmpl $0xff, 0x24(%rsp)
jbe 0x4d3a82
movq 0x16854f(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x425b8(%rip), %rsi     # 0x516013
leaq 0xa664f(%rip), %rdx     # 0x57a0b1
leaq 0xe63d7(%rip), %rcx     # 0x5b9e40
leaq 0xe63bb(%rip), %r8      # 0x5b9e2b
movl $0x37, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4d3a84
movl 0x24(%rsp), %ecx
movq (%rsp), %rax
movl %ecx, 0x28(%rax)
movq 0x18(%rsp), %rdi
callq 0xa9d00
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movb 0x23(%rsp), %cl
movq (%rsp), %rax
andb $0x1, %cl
movb %cl, 0x2c(%rax)
movq 0x10(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x30(%rax)
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x38(%rax)
movq (%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/myersapm.c
// Function: gt_freeMyersonlineresources
void gt_freeMyersonlineresources(Myersonlineresources *ptrmyersonlineresources)
{
  if (ptrmyersonlineresources != NULL)
  {
    gt_free(ptrmyersonlineresources->eqsvectorrev);
    gt_free(ptrmyersonlineresources->eqsvector);
    gt_encseq_reader_delete(ptrmyersonlineresources->esr);
    gt_free(ptrmyersonlineresources);
  }
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x4d3b3f
movq (%rsp), %rax
movq 0x18(%rax), %rdi
leaq 0xe6330(%rip), %rsi     # 0x5b9e2b
movl $0x44, %edx
callq 0xe88c0
movq (%rsp), %rax
movq 0x20(%rax), %rdi
leaq 0xe6317(%rip), %rsi     # 0x5b9e2b
movl $0x45, %edx
callq 0xe88c0
movq (%rsp), %rax
movq (%rax), %rdi
callq 0xac3f0
movq (%rsp), %rdi
leaq 0xe62f6(%rip), %rsi     # 0x5b9e2b
movl $0x47, %edx
callq 0xe88c0
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/radixsort_str.c
// Function: gt_radixsort_str_init_xorvalue2lcp
static uint8_t *gt_radixsort_str_init_xorvalue2lcp(void)
{
  const GtUword nofcodes
    = (GtUword) GT_POW2(GT_MULT2(GT_RADIXSORT_STR_KMERSIZE));
  uint8_t *xorvalue2lcp, lcp = GT_RADIXSORT_STR_KMERSIZE;
  GtUword i, j = 0, j_bound = 1UL;

  xorvalue2lcp = gt_malloc(sizeof (*xorvalue2lcp) * nofcodes);
  for (i = 0; i < (GtUword) GT_RADIXSORT_STR_KMERSIZE; i++)
  {
    if (i > 0)
    {
      j_bound = (GtUword) GT_POW2(GT_MULT2(i));
      gt_assert(lcp > 0);
      lcp--;
    }
    while (j < j_bound)
    {
      xorvalue2lcp[j++] = lcp;
    }
  }
  while (j < nofcodes)
  {
    xorvalue2lcp[j++] = 0;
  }
  return xorvalue2lcp;
}

// Assembly:
subq $0x38, %rsp
movq $0x100, 0x30(%rsp)      # imm = 0x100
movb $0x4, 0x27(%rsp)
movq $0x0, 0x10(%rsp)
movq $0x1, 0x8(%rsp)
movl $0x100, %edi            # imm = 0x100
leaq 0xe5c6d(%rip), %rsi     # 0x5b9e9d
movl $0x6d, %edx
callq 0xe80f0
movq %rax, 0x28(%rsp)
movq $0x0, 0x18(%rsp)
cmpq $0x4, 0x18(%rsp)
jae 0x4d4301
cmpq $0x0, 0x18(%rsp)
jbe 0x4d42bf
movq 0x18(%rsp), %rcx
shlq %rcx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, 0x8(%rsp)
movzbl 0x27(%rsp), %eax
cmpl $0x0, %eax
jg 0x4d42b3
movq 0x167d1e(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x41d87(%rip), %rsi     # 0x516013
leaq 0xb50a0(%rip), %rdx     # 0x589333
leaq 0xe5d2e(%rip), %rcx     # 0x5b9fc8
leaq 0xe5bfc(%rip), %r8      # 0x5b9e9d
movl $0x73, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x4d42b5
movb 0x27(%rsp), %al
addb $-0x1, %al
movb %al, 0x27(%rsp)
jmp 0x4d42c1
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
jae 0x4d42ec
movb 0x27(%rsp), %dl
movq 0x28(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0x10(%rsp)
movb %dl, (%rax,%rcx)
jmp 0x4d42c1
jmp 0x4d42ee
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x4d4248
jmp 0x4d4303
cmpq $0x100, 0x10(%rsp)      # imm = 0x100
jae 0x4d432a
movq 0x28(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, 0x10(%rsp)
movb $0x0, (%rax,%rcx)
jmp 0x4d4303
movq 0x28(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/radixsort_str.c
// Function: gt_radixsort_str_delete
void gt_radixsort_str_delete(GtRadixsortstringinfo *rsi)
{
  if (rsi != NULL)
  {
    gt_free(rsi->sizesofbuckets);
    gt_free(rsi->sorted);
    gt_free(rsi->oracle);
    gt_free(rsi->xorvalue2lcp);
    GT_STACK_DELETE(&rsi->stack);
    gt_free(rsi);
  }
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
cmpq $0x0, (%rsp)
je 0x4d4406
movq (%rsp), %rax
movq 0x28(%rax), %rdi
leaq 0xe5b3e(%rip), %rsi     # 0x5b9e9d
movl $0x9c, %edx
callq 0xe88c0
movq (%rsp), %rax
movq 0x30(%rax), %rdi
leaq 0xe5b25(%rip), %rsi     # 0x5b9e9d
movl $0x9d, %edx
callq 0xe88c0
movq (%rsp), %rax
movq 0x38(%rax), %rdi
leaq 0xe5b0c(%rip), %rsi     # 0x5b9e9d
movl $0x9e, %edx
callq 0xe88c0
movq (%rsp), %rax
movq 0x40(%rax), %rdi
leaq 0xe5af3(%rip), %rsi     # 0x5b9e9d
movl $0x9f, %edx
callq 0xe88c0
movq (%rsp), %rax
movq 0x48(%rax), %rax
movq (%rsp), %rcx
cmpq 0x60(%rcx), %rax
jbe 0x4d43f1
movq (%rsp), %rax
movq 0x8070(%rax), %rdi
leaq 0xe5ac5(%rip), %rsi     # 0x5b9e9d
movl $0xa0, %edx
callq 0xe88c0
movq (%rsp), %rax
movq $0x0, 0x8070(%rax)
movq (%rsp), %rdi
leaq 0xe5aa1(%rip), %rsi     # 0x5b9e9d
movl $0xa1, %edx
callq 0xe88c0
popq %rax
retq
nopl (%rax,%rax)