LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/tagerator.c
// Function: tgr_storematch
static void tgr_storematch(void *processinfo,const GtIdxMatch *match)
{
  ArrayTgrSimplematch *storetab = (ArrayTgrSimplematch *) processinfo;
  TgrSimplematch *simplematch;

  GT_GETNEXTFREEINARRAY(simplematch,storetab,TgrSimplematch,32);
  simplematch->dbstartpos = match->dbstartpos;
  simplematch->matchlength = match->dblen;
  simplematch->rcmatch = ISRCDIR(storetab->twlptr);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdi), %rax
cmpq %rax, 0x8(%rdi)
jae 0x1ff597
movq (%rbx), %rax
jmp 0x1ff5c2
leaq 0x20(%rax), %rcx
movq %rcx, 0x10(%rbx)
movq (%rbx), %rdi
leaq 0x100(,%rax,8), %rax
leaq (%rax,%rax,2), %rsi
leaq 0x1bc888(%rip), %rdx    # 0x3bbe3d
movl $0xcb, %ecx
callq 0x104461
movq %rax, (%rbx)
testq %rax, %rax
je 0x1ff5f8
movq 0x8(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x8(%rbx)
leaq (%rcx,%rcx,2), %rcx
movups 0x10(%r14), %xmm0
movups %xmm0, (%rax,%rcx,8)
movq 0x18(%rbx), %rdx
leaq 0x8(%rdx), %rsi
cmpq %rsi, (%rdx)
setne 0x10(%rax,%rcx,8)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
callq 0x7ef5a
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/tagerator.c
// Function: showmstats
static void showmstats(void *processinfo,
                       const void *patterninfo,
                       GT_UNUSED GtUword patternstartpos,
                       GtUword mstatlength,
                       GtUword leftbound,
                       GtUword rightbound)
{
  TgrTagwithlength *twl = (TgrTagwithlength *) patterninfo;

  printf(""GT_WU" %c",mstatlength,ISRCDIR(twl) ? '-' : '+');
  if (gt_intervalwidthleq((const Limdfsresources *) processinfo,leftbound,
                       rightbound))
  {
    GtUword idx;
    GtArrayGtUword *mstatspos = gt_fromitv2sortedmatchpositions(
                                  (Limdfsresources *) processinfo,
                                  leftbound,
                                  rightbound,
                                  mstatlength);
    for (idx = 0; idx<mstatspos->nextfreeGtUword; idx++)
    {
      printf(" "GT_WU"",mstatspos->spaceGtUword[idx]);
    }
  }
  printf("\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r15
movq %rcx, %r14
movq %rdi, %r12
leaq 0x8(%rsi), %rax
xorl %ecx, %ecx
cmpq %rax, (%rsi)
setne %cl
leal 0x2b(,%rcx,2), %edx
leaq 0x19dc47(%rip), %rdi    # 0x39d6e6
movq %r14, %rsi
xorl %eax, %eax
callq 0x17070
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x1b2e4a
testb %al, %al
je 0x1ffafa
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x1b2772
cmpq $0x0, 0x10(%rax)
je 0x1ffafa
movq %rax, %rbx
leaq 0x1b09a6(%rip), %r14    # 0x3b0483
xorl %r15d, %r15d
movq (%rbx), %rax
movq (%rax,%r15,8), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x17070
incq %r15
cmpq 0x10(%rbx), %r15
jb 0x1ffae0
movl $0xa, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x17a20
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/test-maxpairs.c
// Function: gt_samplesubstring
static GtUword gt_samplesubstring(bool replacespecialchars,
                                  GtUchar *seqspace,
                                  const GtEncseq *encseq,
                                  GtUword substringlength)
{
  GtUword start, totallength = gt_encseq_total_length(encseq);

  start = (GtUword) (random() % totallength);
  if (start + substringlength > totallength)
  {
    substringlength = totallength - start;
  }
  gt_assert(substringlength > 0);
  gt_encseq_extract_encoded(encseq,seqspace,start,start+substringlength-1);
  if (replacespecialchars)
  {
    GtUword idx;
    const unsigned int numofchars = gt_encseq_alphabetnumofchars(encseq);

    for (idx = 0; idx < substringlength; idx++)
    {
      if (GT_ISSPECIAL(seqspace[idx]))
      {
        seqspace[idx] = (GtUchar) (random() % numofchars);
      }
    }
  }
  return substringlength;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, %r15
movq %rsi, %rbx
movl %edi, %ebp
movq %rdx, %rdi
callq 0xe7b9c
movq %rax, %r13
callq 0x11fe0c
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %edx, %edx
divq %r13
leaq (%rdx,%r12), %rax
movq %r13, %r14
subq %rdx, %r14
cmpq %r13, %rax
cmovbeq %r12, %r14
testq %r14, %r14
je 0x2004b2
leaq (%rdx,%r14), %rcx
decq %rcx
movq %r15, %rdi
movq %rbx, %rsi
callq 0xe9127
testb %bpl, %bpl
je 0x2004a0
movq %r15, %rdi
callq 0xebcb6
movl %eax, %ebp
xorl %r15d, %r15d
cmpb $-0x2, (%rbx,%r15)
jb 0x200498
callq 0x11fe0c
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %edx, %edx
divl %ebp
movb %dl, (%rbx,%r15)
incq %r15
cmpq %r14, %r15
jb 0x20047f
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x7f1c3
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/test-maxpairs.c
// Function: gt_storemaxmatchquery
static void gt_storemaxmatchquery(void *info, const GtQuerymatch *querymatch)
{
  GtArray *tab = (GtArray *) info;
  Substringmatch subm;
  GtUword query_seqlen, query_seqstart;

  subm.len = gt_querymatch_querylen(querymatch);
  subm.dbstart = gt_querymatch_dbstart(querymatch);
  subm.querystart = gt_querymatch_querystart(querymatch);
  gt_querymatch_query_coordinates(&subm.queryseqnum,&query_seqstart,
                                  &query_seqlen, querymatch);
  gt_array_add(tab,subm);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x1bac21
leaq 0x28(%rsp), %r15
movq %rax, -0x18(%r15)
movq %r14, %rdi
callq 0x1bac26
movq %rax, -0x10(%r15)
movq %r14, %rdi
callq 0x1bac39
movq %rax, -0x8(%r15)
movq %rsp, %rsi
leaq 0x8(%rsp), %rdx
movq %r15, %rdi
movq %r14, %rcx
callq 0x1bac53
leaq 0x10(%rsp), %rsi
movl $0x20, %edx
movq %rbx, %rdi
callq 0xd2410
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/test-maxpairs.c
// Function: gt_storemaxmatchself
static int gt_storemaxmatchself(void *info,
                                GT_UNUSED const GtGenericEncseq *genericencseq,
                                GtUword len,
                                GtUword pos1,
                                GtUword pos2,
                                GT_UNUSED GtError *err)
{
  GtMaxmatchselfinfo *maxmatchselfinfo = (GtMaxmatchselfinfo *) info;
  GtUword dbstart, querystart;

  if (pos1 < pos2)
  {
    dbstart = pos1;
    querystart = pos2;
  } else
  {
    dbstart = pos2;
    querystart = pos1;
  }
  if (dbstart < maxmatchselfinfo->dblen &&
      maxmatchselfinfo->dblen < querystart)
  {
    Substringmatch subm;
    GtUword pos;

    subm.len = len;
    subm.dbstart = dbstart;
    pos = querystart - (maxmatchselfinfo->dblen + 1);
    if (maxmatchselfinfo->querymarkpos == NULL)
    {
      subm.queryseqnum = 0;
      subm.querystart = pos;
    } else
    {
      GtUword queryseqnum
        = gt_encseq_sep2seqnum(maxmatchselfinfo->querymarkpos,
                               maxmatchselfinfo->numofquerysequences,
                               maxmatchselfinfo->querylen,
                               pos);
      if (queryseqnum == maxmatchselfinfo->numofquerysequences)
      {
        return -1;
      }
      if (queryseqnum == 0)
      {
        subm.querystart = pos;
      } else
      {
        subm.querystart = pos -
                          (maxmatchselfinfo->querymarkpos[queryseqnum-1] + 1);
      }
      subm.queryseqnum = queryseqnum;
    }
    gt_array_add(maxmatchselfinfo->results,subm);
  }
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
cmpq %r8, %rcx
movq %r8, %r14
cmovaq %rcx, %r14
cmovbq %rcx, %r8
movq 0x8(%rdi), %rax
cmpq %rax, %r8
setae %cl
cmpq %r14, %rax
setae %sil
xorl %ebx, %ebx
orb %cl, %sil
jne 0x2005d3
movq %rdi, %r15
movq %rdx, (%rsp)
movq %r8, 0x8(%rsp)
notq %rax
addq %rax, %r14
movq 0x10(%rdi), %rdi
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x20058b
movq 0x18(%r15), %rdx
movq 0x20(%r15), %rsi
movq %r14, %rcx
callq 0xeb47d
cmpq 0x20(%r15), %rax
jne 0x200599
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x2005d3
leaq 0x18(%rsp), %rdx
leaq 0x10(%rsp), %rcx
xorl %esi, %esi
jmp 0x2005bd
leaq 0x18(%rsp), %rcx
leaq 0x10(%rsp), %rdx
testq %rax, %rax
je 0x2005b7
movq 0x10(%r15), %rsi
movq -0x8(%rsi,%rax,8), %rsi
notq %rsi
addq %rsi, %r14
movq %r14, %rsi
movq %rax, %r14
movq %rsi, (%rdx)
movq %r14, (%rcx)
movq (%r15), %rdi
movq %rsp, %rsi
movl $0x20, %edx
callq 0xd2410
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/test-maxpairs.c
// Function: gt_showSubstringmatch
static int gt_showSubstringmatch(void *a, GT_UNUSED void *info,
                                 GT_UNUSED GtError *err)
{
  Substringmatch *m = (Substringmatch *) a;

  printf(GT_WU " " GT_WU " " GT_WU " " GT_WU "\n",
         m->len,
         m->dbstart,
         m->queryseqnum,
         m->querystart);
  return 0;
}

// Assembly:
pushq %rax
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
movq 0x18(%rdi), %rcx
movq 0x10(%rdi), %r8
leaq 0x1a3b18(%rip), %rdi    # 0x3a4152
xorl %eax, %eax
callq 0x17070
xorl %eax, %eax
popq %rcx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/test-mergeesa.c
// Function: initNameandFILE
static int initNameandFILE(NameandFILE *nf,
                            const GtStr *outindex,
                            const char *suffix,
                            GtError *err)
{
  gt_error_check(err);
  nf->outfilename = gt_str_clone(outindex);
  gt_str_append_cstr(nf->outfilename,suffix);
  nf->fp = gt_fa_fopen(gt_str_get(nf->outfilename),"wb",err);
  if (nf->fp == NULL)
  {
    return -1;
  }
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
testq %rcx, %rcx
je 0x2009be
movq %r14, %rdi
callq 0xfcc32
testb %al, %al
jne 0x200a14
movq %r12, %rdi
callq 0x11b191
movq %rax, (%rbx)
movq %rax, %rdi
movq %r15, %rsi
callq 0x11acf3
movq (%rbx), %rdi
callq 0x11b0a1
leaq 0x1550fe(%rip), %rsi    # 0x355ae1
leaq 0x1bbb1f(%rip), %rdx    # 0x3bc509
movq %rax, %rdi
movl $0x39, %ecx
movq %r14, %r8
callq 0xfcdbb
movq %rax, 0x8(%rbx)
xorl %ecx, %ecx
cmpq $0x1, %rax
sbbl %ecx, %ecx
movl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x7f2dc
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/test-mtrieins.c
// Function: gt_test_trieins
int gt_test_trieins(bool onlyins,const char *indexname,GtError *err)
{
  Suffixarray suffixarray;
  bool haserr = false;
  GtUword totallength = 0;

  gt_error_check(err);
  if (streamsuffixarray(&suffixarray,
                        SARR_ESQTAB,
                        indexname,
                        NULL,
                        err) != 0)
  {
    haserr = true;
  } else
  {
    totallength = gt_encseq_total_length(suffixarray.encseq);
  }
  if (!haserr)
  {
    Mergertrierep trierep;
    const GtUchar *characters;

    trierep.encseqreadinfo = gt_malloc(sizeof *trierep.encseqreadinfo);
    trierep.encseqreadinfo->encseqptr = suffixarray.encseq;
    trierep.encseqreadinfo->readmode = suffixarray.readmode;
    characters
      = gt_alphabet_characters(gt_encseq_alphabet(suffixarray.encseq));
    gt_mergertrie_initnodetable(&trierep,totallength,1U);
    maketrie(&trierep,characters,totallength);
    if (onlyins)
    {
#ifdef WITHTRIEIDENT
#ifdef WITHTRIESHOW
      showtrie(&trierep,characters);
#endif
      checktrie(&trierep,totallength+1,totallength,err);
#endif
    } else
    {
#ifdef WITHTRIEIDENT
#ifdef WITHTRIESHOW
      mergertrie_showallnoderelations(trierep.root);
#endif
#endif
      successivelydeletesmallest(&trierep,totallength,characters,err);
    }
    gt_mergertrie_delete(&trierep);
  }
  gt_freesuffixarray(&suffixarray);
  return haserr ? -1 : 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp            # imm = 0x148
movq %rdx, %r15
movq %rsi, %r12
movl %edi, %r14d
testq %rdx, %rdx
je 0x200a4b
movq %r15, %rdi
callq 0xfcc32
testb %al, %al
jne 0x200b65
xorl %ebx, %ebx
leaq 0x48(%rsp), %rdi
movl $0x1, %esi
movq %r12, %rdx
xorl %ecx, %ecx
movq %r15, %r8
callq 0x1a1676
movl %eax, %ebp
testl %eax, %eax
jne 0x200b43
movq 0x48(%rsp), %rdi
callq 0xe7b9c
movq %rax, %r15
leaq 0x1bbb25(%rip), %rsi    # 0x3bc5a7
movl $0x10, %edi
movl $0x63, %edx
callq 0x104226
leaq 0x18(%rsp), %r12
movq %rax, (%r12)
movq 0x48(%rsp), %rdi
movq %rdi, (%rax)
movl 0x90(%rsp), %ecx
movl %ecx, 0x8(%rax)
callq 0xebcd9
movq %rax, %rdi
callq 0xd11de
movq %r12, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x31ff15
leaq 0x8(%rsp), %r13
movl $0x0, (%r13)
movq $0x0, 0x8(%r13)
movq 0x28(%rsp), %rsi
movq %r12, %rdi
movq %r13, %rdx
callq 0x31fa2c
movq 0x10(%rsp), %rax
incq %rax
movq %rax, 0x10(%rsp)
cmpq %r15, %rax
jbe 0x200ade
movq 0x28(%rsp), %rax
testq %rax, %rax
sete %cl
orb %cl, %r14b
jne 0x200b39
leaq 0x18(%rsp), %r14
cmpq $0x0, 0x10(%rax)
je 0x200b39
movq %r14, %rdi
callq 0x31fe50
movq %rax, %rdi
movq %r14, %rsi
callq 0x31fe6d
movq 0x28(%rsp), %rax
testq %rax, %rax
jne 0x200b15
leaq 0x18(%rsp), %rdi
callq 0x31ff79
leaq 0x48(%rsp), %rdi
callq 0x1a1540
negl %ebp
sbbl %ebx, %ebx
movl %ebx, %eax
addq $0x148, %rsp            # imm = 0x148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x7f313
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/test-pairwise.c
// Function: gt_runcheckfunctionontwofiles
void gt_runcheckfunctionontwofiles(Checkcmppairfuntype checkfunction,
                                   const char *file1,
                                   const char *file2)
{
  const GtUchar *useq = NULL, *vseq = NULL;
  size_t ulen, vlen;
  bool forward = true;
  GtError *err;

  err = gt_error_new();
  useq = (const GtUchar *) gt_fa_mmap_read(file1,&ulen,err);
  if (useq == NULL)
  {
    fprintf(stderr, "error: %s\n", gt_error_get(err));
    exit(GT_EXIT_PROGRAMMING_ERROR);
  }
  vseq = (const GtUchar *) gt_fa_mmap_read(file2,&vlen,err);
  if (vseq == NULL)
  {
    fprintf(stderr, "error: %s\n", gt_error_get(err));
    exit(GT_EXIT_PROGRAMMING_ERROR);
  }
  gt_error_delete(err);
  while (true)
  {
    checkfunction(forward,useq,(GtUword) ulen,
                          vseq,(GtUword) vlen);
    if (!forward)
    {
      break;
    }
    forward = false;
  }
  gt_fa_xmunmap((void *) useq);
  gt_fa_xmunmap((void *) vseq);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
callq 0xfcb4c
movq %rax, %r15
leaq 0x1bba32(%rip), %rdx    # 0x3bc5c1
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
movl $0x27, %ecx
movq %rax, %r8
callq 0xfd6db
testq %rax, %rax
je 0x200c1f
movq %rax, %r14
leaq 0x1bba0e(%rip), %rdx    # 0x3bc5c1
leaq 0x8(%rsp), %rsi
movq %r12, %rdi
movl $0x2d, %ecx
movq %r15, %r8
callq 0xfd6db
testq %rax, %rax
je 0x200c27
movq %rax, %r12
movq %r15, %rdi
callq 0xfcccd
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %r8
movl $0x1, %edi
movq %r14, %rsi
movq %r12, %rcx
callq *%rbx
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %r8
xorl %edi, %edi
movq %r14, %rsi
movq %r12, %rcx
callq *%rbx
movq %r14, %rdi
callq 0xfdc54
movq %r12, %rdi
callq 0xfdc54
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r15, %rdi
callq 0x7f376
movq %r15, %rdi
callq 0x7f34a
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/test-pairwise.c
// Function: gt_runcheckfunctionontext
GtUword gt_runcheckfunctionontext(Checkcmppairfuntype checkfunction,
                                     const char *text)
{
  GtUword i, len;

  len = (GtUword) strlen(text);
  for (i=1UL; i<=len/2; i++)
  {
    checkfunction(true,
                  (const GtUchar *) text,
                  i,
                  (const GtUchar *) (text+i),
                  len-i);
  }
  return len/2;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x172f0
movq %rax, %r15
shrq %r15
cmpq $0x2, %rax
jb 0x200c92
movq %rax, %r12
movq %r15, %rbp
negq %rbp
decq %r12
movl $0x1, %r13d
leaq (%rbx,%r13), %rcx
movl $0x1, %edi
movq %rbx, %rsi
movq %r13, %rdx
movq %r12, %r8
callq *%r14
leaq 0x1(,%r13), %rax
addq %rbp, %rax
incq %r13
decq %r12
cmpq $0x1, %rax
jne 0x200c66
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/test-pairwise.c
// Function: gt_runcheckfunctiononalphalen
GtUword gt_runcheckfunctiononalphalen(Checkcmppairfuntype checkfunction,
                                         const char *charlist,
                                         GtUword len)
{
  return applyall(charlist,
                  len,
                  (void *) checkfunction,
                  gt_applycheckfunctiontotext);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0x172f0
movq %rax, 0x10(%rsp)
leaq 0x1(%r12), %rbx
leaq 0x8(,%r12,8), %rdi
leaq 0x1bb89b(%rip), %rbp    # 0x3bc5c1
movq %rbp, %rsi
movl $0x70, %edx
callq 0x104226
movq %rax, %r13
movq %rbx, %rdi
movq %rbp, %rsi
movl $0x71, %edx
callq 0x104226
movq %rax, %rbp
cmpq $0x1, %rbx
movq %r12, %rdx
adcq $0x1, %rdx
shlq $0x3, %rdx
movq $0x0, (%rsp)
movq %r13, %rdi
xorl %esi, %esi
callq 0x173a0
movq %r12, %rbx
leaq -0x1(%r12), %rax
movq %rax, 0x8(%rsp)
movb $0x0, (%rbp,%r12)
shrq %r12
incq %r12
movq %rbx, 0x20(%rsp)
movq %r14, 0x18(%rsp)
testq %rbx, %rbx
je 0x200da9
xorl %eax, %eax
movq (%r13,%rax,8), %rcx
movb (%r14,%rcx), %cl
movb %cl, (%rbp,%rax)
incq %rax
cmpq %rax, %rbx
jne 0x200d94
xorl %r14d, %r14d
leaq (%r14,%rbp), %rcx
movl $0x1, %edi
movq %rbp, %rsi
movq %r14, %rdx
movq %rbx, %r8
callq *%r15
incq %r14
decq %rbx
cmpq %r14, %r12
jne 0x200dac
addq %r12, (%rsp)
movq 0x20(%rsp), %rbx
movq -0x8(%r13,%rbx,8), %rcx
incq %rcx
movq %rcx, -0x8(%r13,%rbx,8)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rdx
cmpq %rdx, %rcx
movq 0x18(%rsp), %r14
jne 0x200d8d
movq $0x0, (%r13,%rax,8)
subq $0x1, %rax
jb 0x200e1c
movq (%r13,%rax,8), %rcx
incq %rcx
movq %rcx, (%r13,%rax,8)
cmpq %rdx, %rcx
je 0x200df6
jmp 0x200d8d
leaq 0x1bb79e(%rip), %rbx    # 0x3bc5c1
movq %r13, %rdi
movq %rbx, %rsi
movl $0x91, %edx
callq 0x1045eb
movq %rbp, %rdi
movq %rbx, %rsi
movl $0x92, %edx
callq 0x1045eb
movq (%rsp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/test-pairwise.c
// Function: gt_computegreedyunitedist
GtUword gt_computegreedyunitedist(const GtUchar *useq,
                                        GtUword ulen,
                                        const GtUchar *vseq,
                                        GtUword vlen)
{
  GtUword edist;
  bool rightextension = true;
  GtFrontResource *frontresource = gt_frontresource_new(10UL);
  GtSeqabstract *greedyedistuseq, *greedyedistvseq;

  greedyedistuseq
    = gt_seqabstract_new_gtuchar(rightextension,GT_READMODE_FORWARD,
                                 useq,ulen,0,ulen);
  greedyedistvseq
    = gt_seqabstract_new_gtuchar(rightextension,GT_READMODE_FORWARD,
                                 vseq,vlen,0,vlen);
  edist = greedyunitedist(frontresource,greedyedistuseq,greedyedistvseq);
  gt_seqabstract_delete(greedyedistuseq);
  gt_seqabstract_delete(greedyedistvseq);
  gt_frontresource_delete(frontresource);
  return edist;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movl $0xa, %edi
callq 0x1b1a84
movq %rax, %rbx
movl $0x1, %edi
xorl %esi, %esi
movq %r13, %rdx
movq %r12, %rcx
xorl %r8d, %r8d
movq %r12, %r9
callq 0x1e28c9
movq %rax, %r12
movl $0x1, %edi
xorl %esi, %esi
movq %r15, %rdx
movq %r14, %rcx
xorl %r8d, %r8d
movq %r14, %r9
callq 0x1e28c9
movq %rax, %r14
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x1b1b0c
movq %rax, %r15
movq %r12, %rdi
callq 0x1e2a17
movq %r14, %rdi
callq 0x1e2a17
movq %rbx, %rdi
callq 0x1b1ad0
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/test-pairwise.c
// Function: gt_checkgreedyunitedist
void gt_checkgreedyunitedist(GT_UNUSED bool forward,
                             const GtUchar *useq,
                             GtUword ulen,
                             const GtUchar *vseq,
                             GtUword vlen)
{
  GtUword edist1, edist2;
  GtFrontResource *frontresource = gt_frontresource_new(10UL);
  bool rightextension = true;
  GtSeqabstract *greedyedistuseq, *greedyedistvseq;

  greedyedistuseq
    = gt_seqabstract_new_gtuchar(rightextension,GT_READMODE_FORWARD,
                                 useq,ulen,0,ulen);
  greedyedistvseq
    = gt_seqabstract_new_gtuchar(rightextension,GT_READMODE_FORWARD,
                                 vseq,vlen,0,vlen);
  edist1 = greedyunitedist(frontresource,greedyedistuseq,greedyedistvseq);
  edist2 = gt_squarededistunit (useq,ulen,vseq,vlen);
#ifdef SKDEBUG
  printf("edist = " GT_WU "\n",edist1);
#endif
  if (edist1 != edist2)
  {
    fprintf(stderr,"greedyunitedist = "GT_WU" != "GT_WU
            " = gt_squarededistunit\n", edist1,edist2);
    exit(GT_EXIT_PROGRAMMING_ERROR);
  }
  gt_seqabstract_delete(greedyedistuseq);
  gt_seqabstract_delete(greedyedistvseq);
  gt_frontresource_delete(frontresource);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %r14
movq %rcx, %rbx
movq %rcx, 0x10(%rsp)
movq %rdx, %r12
movq %rsi, %r13
movl $0xa, %edi
callq 0x1b1a84
movq %rax, %r15
movl $0x1, %edi
xorl %esi, %esi
movq %r13, %rdx
movq %r12, %rcx
xorl %r8d, %r8d
movq %r12, %r9
callq 0x1e28c9
movq %rax, %rbp
movl $0x1, %edi
xorl %esi, %esi
movq %rbx, %rdx
movq %r14, %rcx
xorl %r8d, %r8d
movq %r14, %r9
callq 0x1e28c9
movq %rax, %rbx
movq %r15, 0x8(%rsp)
movq %r15, %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0x1b1b0c
movq %rax, %r15
movq %r13, %rdi
movq %r12, %rsi
movq 0x10(%rsp), %rdx
movq %r14, %rcx
callq 0x32b770
cmpq %rax, %r15
jne 0x200f9c
movq %rbp, %rdi
callq 0x1e2a17
movq %rbx, %rdi
callq 0x1e2a17
movq 0x8(%rsp), %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1b1ad0
movq %r15, %rdi
movq %rax, %rsi
callq 0x7f3a2
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/turnwheels.c
// Function: gt_turningwheel_new
Turningwheel *gt_turningwheel_new(unsigned int numofwheels,
                                  unsigned int asize)
{
  unsigned int i;
  Turningwheel *tw;

  tw = gt_malloc(sizeof (*tw));
  gt_assert(numofwheels < (unsigned int) MAXNUMOFWHEELS);
  gt_assert(numofwheels > 0);
  gt_assert(asize > 0);
  for (i=0; i<numofwheels; i++)
  {
    tw->wheelspace[i] = 0;
  }
  tw->numofwheels = numofwheels;
  tw->asize = asize;
  tw->idx = numofwheels - 1;
  tw->minchanged = 0;
  return tw;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movl %edi, %ebx
leaq 0x1bb658(%rip), %rsi    # 0x3bc60f
movl $0x58, %edi
movl $0x26, %edx
callq 0x104226
cmpl $0x12, %ebx
jae 0x201005
testl %ebx, %ebx
je 0x20100a
testl %ebp, %ebp
je 0x20100f
movq %rax, %r14
leal (,%rbx,4), %edx
movq %rax, %rdi
xorl %esi, %esi
callq 0x173a0
movl %ebx, 0x48(%r14)
movl %ebp, 0x4c(%r14)
decl %ebx
movl %ebx, 0x50(%r14)
movl $0x0, 0x54(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
callq 0x7f3c9
callq 0x7f437
callq 0x7f400
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/turnwheels.c
// Function: gt_turningwheel_next
bool gt_turningwheel_next(Turningwheel *tw)
{
  while (true)
  {
    tw->wheelspace[tw->idx]++;
    tw->minchanged = tw->idx;
    if (tw->wheelspace[tw->idx] == tw->asize)
    {
      tw->wheelspace[tw->idx] = 0;
      if (tw->idx == 0)
      {
        return false;
      }
      tw->idx--;
    } else
    {
      tw->idx = tw->numofwheels-1;
      break;
    }
  }
  return true;
}

// Assembly:
movl 0x50(%rdi), %eax
incl (%rdi,%rax,4)
movl 0x50(%rdi), %eax
movl %eax, 0x54(%rdi)
movl (%rdi,%rax,4), %ecx
cmpl 0x4c(%rdi), %ecx
jne 0x201058
leaq (%rdi,%rax,4), %rax
movl $0x0, (%rax)
movl 0x50(%rdi), %eax
testl %eax, %eax
je 0x201063
decl %eax
movl %eax, 0x50(%rdi)
incl (%rdi,%rax,4)
movl 0x50(%rdi), %eax
movl %eax, 0x54(%rdi)
leaq (%rdi,%rax,4), %rax
movl (%rax), %ecx
cmpl 0x4c(%rdi), %ecx
je 0x201032
movl 0x48(%rdi), %eax
decl %eax
movl %eax, 0x50(%rdi)
movb $0x1, %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/twobits2kmers.c
// Function: gt_checkkmercode
static void gt_checkkmercode(GT_UNUSED void *processinfo,
                             GT_UNUSED bool firstinrange,
                             GT_UNUSED GtUword pos,
                             GT_UNUSED GtCodetype code)
{
#ifndef NDEBUG
  GtKmercodeiterator *kmercodeiterator = (GtKmercodeiterator *) processinfo;
  const GtKmercode *kmercodeptr;

  gt_assert(kmercodeiterator != NULL);
  kmercodeptr = gt_kmercodeiterator_encseq_nonspecial_next(kmercodeiterator);
  gt_assert(kmercodeptr != NULL && !kmercodeptr->definedspecialposition);
  gt_assert(code == kmercodeptr->code);
#endif
}

// Assembly:
pushq %rbx
testq %rdi, %rdi
je 0x2014b8
movq %rcx, %rbx
callq 0x1ee902
testq %rax, %rax
je 0x2014b3
cmpb $0x1, (%rax)
je 0x2014b3
cmpq %rbx, 0x8(%rax)
jne 0x2014bd
popq %rbx
retq
callq 0x7f6fb
callq 0x7f734
callq 0x7f6c2
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/tyr-mersplit.c
// Function: gt_tyrbckinfo_new
Tyrbckinfo *gt_tyrbckinfo_new(const char *tyrindexname,unsigned int alphasize,
                              GtError *err)
{
  size_t numofbytes;
  Tyrbckinfo *tyrbckinfo;
  bool haserr = false;

  tyrbckinfo = gt_malloc(sizeof *tyrbckinfo);
  tyrbckinfo->mappedmbdfileptr = gt_fa_mmap_read_with_suffix(tyrindexname,
                                                          BUCKETSUFFIX,
                                                          &numofbytes,err);
  if (tyrbckinfo->mappedmbdfileptr == NULL)
  {
    haserr = true;
  }
  if (!haserr)
  {
    GtUword pl_long;

    gt_assert(tyrbckinfo->mappedmbdfileptr != NULL);
    pl_long = *((GtUword *) tyrbckinfo->mappedmbdfileptr);
    tyrbckinfo->prefixlength = (unsigned int) pl_long;
    tyrbckinfo->numofcodes
      = gt_power_for_small_exponents(alphasize,tyrbckinfo->prefixlength);
    /*check if numofbytes == expected size*/
    gt_assert(numofbytes == sizeof (GtUword) *
                            (1UL +
                             (tyrbckinfo->numofcodes+1) +
                             GT_NUMOFINTSFORBITS(tyrbckinfo->numofcodes + 1)));
    tyrbckinfo->bounds = ((GtUword *) tyrbckinfo->mappedmbdfileptr) + 1;
    tyrbckinfo->boundisdefined
      = tyrbckinfo->bounds + tyrbckinfo->numofcodes + 1;
    if (tyrbckinfo->prefixlength > 0 && GT_MOD4(tyrbckinfo->prefixlength) > 0)
    {
      tyrbckinfo->remainmask
        = (GtUchar) MAXUCHARVALUEWITHBITS(GT_MULT2(
                                       4U - GT_MOD4(tyrbckinfo->prefixlength)));
    }
  }
  if (haserr)
  {
    gt_free(tyrbckinfo);
    return NULL;
  }
  return tyrbckinfo;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
leaq 0x1baca2(%rip), %r12    # 0x3bc884
movl $0x30, %edi
movq %r12, %rsi
movl $0x197, %edx            # imm = 0x197
callq 0x104226
movq %rax, %rbx
leaq 0x1bad13(%rip), %rsi    # 0x3bc911
leaq 0x8(%rsp), %rdx
movq %r15, %rdi
movq %r12, %rcx
movl $0x19a, %r8d            # imm = 0x19A
movq %r14, %r9
callq 0xfdd02
movq %rax, (%rbx)
testq %rax, %rax
je 0x201c93
movl (%rax), %esi
movl %esi, 0x8(%rbx)
movl %ebp, %edi
callq 0x105ed6
movq %rax, 0x10(%rbx)
leaq 0x1(%rax), %rcx
movq %rax, %rdx
shrq $0x6, %rdx
incq %rdx
cmpq $0x40, %rcx
movl $0x1, %ecx
cmovaeq %rdx, %rcx
addq %rax, %rcx
leaq 0x10(,%rcx,8), %rcx
cmpq %rcx, 0x8(%rsp)
jne 0x201cb9
movq (%rbx), %rcx
leaq 0x8(%rcx), %rdx
movq %rdx, 0x20(%rbx)
leaq (%rcx,%rax,8), %rax
addq $0x10, %rax
movq %rax, 0x18(%rbx)
movl 0x8(%rbx), %eax
testl %eax, %eax
je 0x201ca9
andl $0x3, %eax
je 0x201ca9
addl %eax, %eax
movb $0x8, %cl
subb %al, %cl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
shll %cl, %eax
notb %al
movb %al, 0x28(%rbx)
jmp 0x201ca9
leaq 0x1babea(%rip), %rsi    # 0x3bc884
movq %rbx, %rdi
movl $0x1b9, %edx            # imm = 0x1B9
callq 0x1045eb
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
callq 0x7f931
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/tyr-mersplit.c
// Function: gt_tyrbckinfo_delete
void gt_tyrbckinfo_delete(Tyrbckinfo **tyrbckinfoptr)
{
  Tyrbckinfo *tyrbckinfo = *tyrbckinfoptr;

  gt_fa_xmunmap(tyrbckinfo->mappedmbdfileptr);
  tyrbckinfo->mappedmbdfileptr = NULL;
  gt_free(tyrbckinfo);
  *tyrbckinfoptr = NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
movq (%r14), %rdi
callq 0xfdc54
xorl %r15d, %r15d
movq %r15, (%r14)
leaq 0x1baba6(%rip), %rsi    # 0x3bc884
movq %r14, %rdi
movl $0x1c5, %edx            # imm = 0x1C5
callq 0x1045eb
movq %r15, (%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/tyr-mkindex.c
// Function: adddistpos2distribution
static int adddistpos2distribution(GtUword countocc,
                                   GtUword position,
                                   void *adddistposinfo,
                                   GT_UNUSED GtError *err)
{
  TyrDfsstate *state = (TyrDfsstate *) adddistposinfo;

  incrementdistribcounts(&state->occdistribution,countocc,1UL);
  if (decideifocc(state,countocc))
  {
    state->occdistribution.spaceCountwithpositions[countocc].positionlist
      = insertListUlong(state->occdistribution.
                               spaceCountwithpositions[countocc].positionlist,
                         position);
  }
  if (state->performtest)
  {
    checknumberofoccurrences(state,countocc,position);
  }
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpq %rdi, 0x40(%rdx)
ja 0x2024e3
movq 0x38(%r14), %rdi
leaq 0x80(%rbx), %r12
movq %r12, %rsi
shlq $0x4, %rsi
leaq 0x1ba547(%rip), %rdx    # 0x3bc9f7
movl $0x133, %ecx            # imm = 0x133
callq 0x104461
movq %rax, 0x38(%r14)
movq 0x40(%r14), %rcx
movq %r12, %rdx
subq %rcx, %rdx
jbe 0x2024df
shlq $0x4, %rcx
addq %rcx, %rax
shlq $0x4, %rdx
movq %rax, %rdi
xorl %esi, %esi
callq 0x173a0
movq %r12, 0x40(%r14)
leaq 0x1(%rbx), %rax
cmpq 0x48(%r14), %rax
jbe 0x2024f1
movq %rax, 0x48(%r14)
movq 0x38(%r14), %rax
movq %rbx, %r12
shlq $0x4, %r12
incq (%rax,%r12)
movq 0x10(%r14), %rdx
movq 0x18(%r14), %rcx
testq %rdx, %rdx
je 0x20251a
testq %rcx, %rcx
je 0x20258e
cmpq %rbx, %rdx
seta %dl
jmp 0x202520
testq %rcx, %rcx
sete %dl
cmpq %rbx, %rcx
setb %cl
orb %dl, %cl
jne 0x202555
movq 0x8(%rax,%r12), %r13
leaq 0x1ba4c1(%rip), %rsi    # 0x3bc9f7
movl $0x10, %edi
movl $0x9d, %edx
callq 0x104226
movq %r15, (%rax)
movq %r13, 0x8(%rax)
movq 0x38(%r14), %rcx
movq %rax, 0x8(%rcx,%r12)
cmpb $0x1, 0x68(%r14)
jne 0x2025d8
cmpq $0x0, (%r14)
je 0x202595
xorl %r12d, %r12d
movq 0x20(%r14), %rdi
leaq (%r15,%r12), %rsi
movl 0x28(%r14), %edx
callq 0xe7bbc
movq 0xa8(%r14), %rcx
movb %al, (%rcx,%r12)
incq %r12
movq (%r14), %rax
cmpq %rax, %r12
jb 0x202565
jmp 0x202597
cmpq %rbx, %rdx
jbe 0x20252a
jmp 0x202555
xorl %eax, %eax
movq 0x8(%r14), %rcx
movq 0x20(%r14), %rdi
movq 0xa0(%r14), %rsi
movl 0x28(%r14), %r9d
xorl %edx, %edx
xorl %r8d, %r8d
pushq %rax
pushq 0xa8(%r14)
callq 0x1a3e08
addq $0x10, %rsp
movq %rax, %r14
movq %rax, %rdi
callq 0x1a3ec7
cmpq %rbx, %rax
jne 0x2025e4
movq %r14, %rdi
callq 0x1a3f54
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rdi
movq %rbx, %rsi
callq 0x7fa03
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/tyr-mkindex.c
// Function: outputsortedstring2index
static int outputsortedstring2index(GtUword countocc,
                                    GtUword position,
                                    void *adddistposinfo,
                                    GtError *err)
{
  TyrDfsstate *state = (TyrDfsstate *) adddistposinfo;

  if (decideifocc(state,countocc))
  {
    if (outputsortedstring2indexviafileptr(state->encseq,
                                           state->mersize,
                                           state->bytebuffer,
                                           state->sizeofbuffer,
                                           state->merindexfpout,
                                           state->countsfilefpout,
                                           position,
                                           countocc,
                                           &state->largecounts,
                                           state->countoutputmers,
                                           err) != 0)
    {
      return -1;
    }
    state->countoutputmers++;
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %r14
movq 0x10(%rbx), %rcx
movq 0x18(%rbx), %rax
testq %rcx, %rcx
je 0x202620
testq %rax, %rax
je 0x202635
cmpq %r14, %rcx
seta %cl
jmp 0x202626
testq %rax, %rax
sete %cl
cmpq %r14, %rax
setb %al
orb %cl, %al
je 0x20263e
jmp 0x202722
cmpq %r14, %rcx
ja 0x202722
movq (%rbx), %rcx
movq 0x20(%rbx), %rsi
movq 0x70(%rbx), %r12
movq 0x78(%rbx), %r13
movq 0x50(%rbx), %rbp
movq 0x58(%rbx), %r15
movq 0x98(%rbx), %rax
movq %rax, 0x10(%rsp)
movq %r12, %rdi
callq 0xe7630
movl $0x1, %esi
movq %r12, %rdi
movq %r13, %rdx
movq %rbp, %rcx
callq 0x11f89c
testq %r15, %r15
je 0x20271b
cmpq $0xff, %r14
jbe 0x202701
movq 0x88(%rbx), %rsi
cmpq %rsi, 0x90(%rbx)
jae 0x2026a7
movq 0x80(%rbx), %rax
jmp 0x2026d5
addq $0x20, %rsi
movq %rsi, 0x88(%rbx)
movq 0x80(%rbx), %rdi
shlq $0x4, %rsi
leaq 0x1ba333(%rip), %rdx    # 0x3bc9f7
movl $0x175, %ecx            # imm = 0x175
callq 0x104461
movq %rax, 0x80(%rbx)
testq %rax, %rax
je 0x202733
movq 0x90(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x90(%rbx)
shlq $0x4, %rcx
movq 0x10(%rsp), %rdx
movq %rdx, (%rax,%rcx)
movq %r14, 0x8(%rax,%rcx)
xorl %r14d, %r14d
leaq 0xf(%rsp), %rdi
movb %r14b, (%rdi)
movl $0x1, %esi
movl $0x1, %edx
movq %r15, %rcx
callq 0x11f89c
incq 0x98(%rbx)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x7fa2a
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/tyr-mkindex.c
// Function: tyr_processleafedge
static int tyr_processleafedge(GT_UNUSED bool firstsucc,
                           GtUword fatherdepth,
                           GT_UNUSED Dfsinfo *father,
                           GtUword leafnumber,
                           Dfsstate *astate,
                           GtError *err)
{
  TyrDfsstate *state = (TyrDfsstate*) astate;
  gt_error_check(err);
  if (fatherdepth < state->mersize &&
      leafnumber + state->mersize <= state->totallength &&
      !gt_encseq_contains_special(state->encseq,
                                  state->readmode,
                                  state->esrspace,
                                  leafnumber + fatherdepth,
                                  state->mersize - fatherdepth))
  {
    if (state->processoccurrencecount(1UL,leafnumber,state,err) != 0)
    {
      return -1;
    }
  }
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movq %r8, %rbx
movq %rcx, %r15
movq %rsi, %r12
testq %r9, %r9
je 0x202784
movq %r14, %rdi
callq 0xfcc32
testb %al, %al
jne 0x2027dc
movq (%rbx), %rax
movq %rax, %r8
subq %r12, %r8
jbe 0x2027ce
addq %r15, %rax
cmpq 0x8(%rbx), %rax
ja 0x2027ce
movq 0x20(%rbx), %rdi
movl 0x28(%rbx), %esi
movq 0x60(%rbx), %rdx
addq %r15, %r12
movq %r12, %rcx
callq 0xe8e42
testb %al, %al
jne 0x2027ce
movl $0x1, %edi
movq %r15, %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq *0x30(%rbx)
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0x2027d0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x7fa63
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/tyr-mkindex.c
// Function: tyr_processcompletenode
static int tyr_processcompletenode(GtUword nodeptrdepth,
                               Dfsinfo *anodeptr,
                               GtUword nodeptrminusonedepth,
                               Dfsstate *astate,
                               GtError *err)
{
  TyrDfsinfo *nodeptr = (TyrDfsinfo*) anodeptr;
  TyrDfsstate *state = (TyrDfsstate*) astate;
  gt_error_check(err);
  if (state->mersize <= nodeptrdepth)
  {
    GtUword fatherdepth;

    fatherdepth = nodeptr->lcptabrightmostleafplus1;
    if (fatherdepth < nodeptrminusonedepth)
    {
      fatherdepth = nodeptrminusonedepth;
    }
    if (fatherdepth < state->mersize)
    {
      if (state->processoccurrencecount((GtUword)
                                        (nodeptr->rightmostleaf -
                                         nodeptr->leftmostleaf + 1),
                                        nodeptr->suftabrightmostleaf,
                                        state,
                                        err) != 0)
      {
        return -1;
      }
    }
  }
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r14
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r13
testq %r8, %r8
je 0x20280a
movq %r14, %rdi
callq 0xfcc32
testb %al, %al
jne 0x202852
movq (%rbx), %rcx
xorl %eax, %eax
cmpq %r13, %rcx
ja 0x202848
movq 0x18(%r15), %rax
cmpq %r12, %rax
cmovaq %rax, %r12
cmpq %rcx, %r12
jae 0x202846
movq 0x8(%r15), %rdi
movq 0x10(%r15), %rsi
subq (%r15), %rdi
incq %rdi
movq %rbx, %rdx
movq %r14, %rcx
callq *0x30(%rbx)
movl %eax, %ecx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testl %ecx, %ecx
jne 0x202848
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x7fa9c
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/tyr-occratio.c
// Function: occ_processleafedge
static int occ_processleafedge(GT_UNUSED bool firstsucc,
                           GtUword fatherdepth,
                           GT_UNUSED Dfsinfo *father,
                           GtUword leafnumber,
                           Dfsstate *astate,
                           GT_UNUSED GtError *err)
{
  OccDfsstate *state = (OccDfsstate*) astate;
  iteritvdistribution(state->uniquedistribution,
                      state->encseq,
                      state->readmode,
                      state->totallength,
                      state->minmersize,
                      state->maxmersize,
                      fatherdepth+1,
                      leafnumber);
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq 0x10(%r8), %rcx
movq 0x20(%r8), %r15
leaq 0x1(%rsi), %rax
cmpq %r15, %rax
setbe %al
addq %rsi, %rbx
movq %rcx, 0x10(%rsp)
cmpq %rcx, %rbx
setb %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x202a8d
movq %rsi, %r14
movq 0x28(%r8), %rax
movq %rax, 0x8(%rsp)
movq (%r8), %r12
movl 0x8(%r8), %ebp
movq 0x18(%r8), %r13
addq $0x2, %r14
movq %r12, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0xe7bbc
cmpb $-0x3, %al
ja 0x202a8d
leaq -0x1(%r14), %rsi
cmpq %r13, %rsi
jb 0x202a7b
movl $0x1, %edx
movq 0x8(%rsp), %rdi
callq 0x202b25
cmpq %r15, %r14
ja 0x202a8d
incq %rbx
incq %r14
cmpq 0x10(%rsp), %rbx
jb 0x202a52
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/tyr-occratio.c
// Function: adddistributionuint64_t
static void adddistributionuint64_t(GtArrayuint64_t *occdistribution,
                                    GtUword countocc,
                                    GtUword value)
{
  if (countocc >= occdistribution->allocateduint64_t)
  {
    const GtUword addamount = 128UL;
    GtUword idx;

    occdistribution->spaceuint64_t
      = gt_realloc(occdistribution->spaceuint64_t,
                   sizeof *occdistribution->spaceuint64_t *
                   (countocc+addamount));
    for (idx=occdistribution->allocateduint64_t;
         idx<countocc+addamount; idx++)
    {
      occdistribution->spaceuint64_t[idx] = 0;
    }
    occdistribution->allocateduint64_t = countocc+addamount;
  }
  if (countocc + 1 > occdistribution->nextfreeuint64_t)
  {
    occdistribution->nextfreeuint64_t = countocc+1;
  }
  occdistribution->spaceuint64_t[countocc] += value;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpq %rsi, 0x8(%rdi)
ja 0x202b81
movq (%r15), %rdi
leaq 0x80(%r14), %r12
leaq 0x400(,%r14,8), %rsi
leaq 0x1ba18d(%rip), %rdx    # 0x3bcce2
movl $0x48, %ecx
callq 0x104461
movq %rax, (%r15)
movq 0x8(%r15), %rcx
movq %r12, %rdx
subq %rcx, %rdx
jbe 0x202b7d
leaq (%rax,%rcx,8), %rdi
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x173a0
movq %r12, 0x8(%r15)
leaq 0x1(%r14), %rax
cmpq 0x10(%r15), %rax
jbe 0x202b8f
movq %rax, 0x10(%r15)
movq (%r15), %rax
addq %rbx, (%rax,%r14,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/tyr-search.c
// Function: gt_searchsinglemer
const GtUchar *gt_searchsinglemer(const GtUchar *qptr,
                                        const Tyrindex *tyrindex,
                                        const Tyrsearchinfo *tyrsearchinfo,
                                        const Tyrbckinfo *tyrbckinfo)
{
  const GtUchar *result;

  gt_encseq_plainseq2bytecode(tyrsearchinfo->bytecode,qptr,
                                       tyrsearchinfo->mersize);
  if (tyrbckinfo == NULL)
  {
    result = gt_tyrindex_binmersearch(tyrindex,0,tyrsearchinfo->bytecode,
                                   tyrsearchinfo->mertable,
                                   tyrsearchinfo->lastmer);
  } else
  {
    result = gt_searchinbuckets(tyrindex,tyrbckinfo,tyrsearchinfo->bytecode);
  }
  return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %rsi
movq (%rdx), %rdi
movq 0x20(%rdx), %rdx
callq 0xe75b0
movq (%r15), %rdx
testq %r14, %r14
je 0x202bd9
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x2014c4
movq 0x10(%r15), %rcx
movq 0x18(%r15), %r8
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x32bca9
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/tyr-search.c
// Function: mermatchoutput
static void mermatchoutput(const Tyrindex *tyrindex,
                           const Tyrcountinfo *tyrcountinfo,
                           const Tyrsearchinfo *tyrsearchinfo,
                           const GtUchar *result,
                           const GtUchar *query,
                           const GtUchar *qptr,
                           uint64_t unitnum,
                           bool forward)
{
  bool firstitem = true;
  GtUword queryposition;

  queryposition = (GtUword) (qptr-query);
  if (tyrsearchinfo->showmode & SHOWQSEQNUM)
  {
    printf(Formatuint64_t,PRINTuint64_tcast(unitnum));
    firstitem = false;
  }
  if (tyrsearchinfo->showmode & SHOWQPOS)
  {
    ADDTABULATOR;
    printf("%c"GT_WU"",forward ? '+' : '-',queryposition);
  }
  if (tyrsearchinfo->showmode & SHOWCOUNTS)
  {
    GtUword mernumber = gt_tyrindex_ptr2number(tyrindex,result);
    ADDTABULATOR;
    printf(""GT_WU"",gt_tyrcountinfo_get(tyrcountinfo,mernumber));
  }
  if (tyrsearchinfo->showmode & SHOWSEQUENCE)
  {
    ADDTABULATOR;
    gt_alphabet_decode_seq_to_fp(tyrsearchinfo->dnaalpha,
                                 stdout,
                                 qptr,
                                 tyrsearchinfo->mersize);
  }
  if (tyrsearchinfo->showmode & (SHOWSEQUENCE | SHOWQPOS | SHOWCOUNTS))
  {
    (void) putchar('\n');
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, (%rsp)
movq %r8, %rbp
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, 0x10(%rsp)
movq %rdi, %r13
movb 0x58(%rsp), %r12b
movl 0x28(%rdx), %eax
movb $0x1, %r15b
testb $0x1, %al
je 0x20306e
movq 0x50(%rsp), %rsi
leaq 0x1b8f5b(%rip), %rdi    # 0x3bbfbc
xorl %r15d, %r15d
xorl %eax, %eax
callq 0x17070
movl 0x28(%rbx), %eax
testb $0x2, %al
je 0x2030c0
movq %r13, 0x8(%rsp)
movq %r14, %r13
movq (%rsp), %r14
subq %rbp, %r14
testb %r15b, %r15b
je 0x20308b
xorl %r15d, %r15d
jmp 0x203095
movl $0x9, %edi
callq 0x17a20
xorb $0x1, %r12b
movzbl %r12b, %eax
leal 0x2b(,%rax,2), %esi
leaq 0x1b9cbb(%rip), %rdi    # 0x3bcd66
movq %r14, %rdx
xorl %eax, %eax
callq 0x17070
movl 0x28(%rbx), %eax
movq %r13, %r14
movq 0x8(%rsp), %r13
testb $0x4, %al
je 0x203107
movq %r13, %rdi
movq %r14, %rsi
callq 0x32bab5
movq %rax, %r14
testb %r15b, %r15b
je 0x2030dc
xorl %r15d, %r15d
jmp 0x2030e6
movl $0x9, %edi
callq 0x17a20
movq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x32bc14
leaq 0x1b8ec2(%rip), %rdi    # 0x3bbfbc
movq %rax, %rsi
xorl %eax, %eax
callq 0x17070
movl 0x28(%rbx), %eax
testb $0x8, %al
je 0x203138
testb %r15b, %r15b
jne 0x20311a
movl $0x9, %edi
callq 0x17a20
movq 0x20(%rbx), %rcx
movq 0x30(%rbx), %rdi
movq 0x2b5daf(%rip), %rax    # 0x4b8ed8
movq (%rax), %rsi
movq (%rsp), %rdx
callq 0xd1412
movl 0x28(%rbx), %eax
testb $0xe, %al
je 0x203154
movl $0xa, %edi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x17a20
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/xdrop.c
// Function: gt_xdrop_resources_new
GtXdropresources *gt_xdrop_resources_new(const GtXdropArbitraryscores *scores)
{
  GtXdropresources *res = gt_malloc(sizeof *res);

  res->arbitscores = scores;
  GT_INITARRAY (&res->fronts, GtXdropfrontvalue);
  GT_INITARRAY (&res->big_t, GtXdropscore);
  gt_calculatedistancesfromscores(scores,&res->arbitdistances);
  return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x1b99a2(%rip), %rsi    # 0x3bcd9e
movl $0x48, %edi
movl $0xae, %edx
callq 0x104226
movq %r14, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x28(%rax)
movups %xmm0, 0x38(%rax)
movl (%r14), %ebp
testl %ebp, %ebp
jle 0x2034af
movq %rax, %rbx
testb $0x1, %bpl
jne 0x20343f
movl 0x4(%r14), %edx
movl 0x8(%r14), %eax
movl 0xc(%r14), %ecx
jmp 0x203453
addl %ebp, %ebp
movl 0x4(%r14), %edx
movl 0x8(%r14), %eax
addl %edx, %edx
addl %eax, %eax
movl 0xc(%r14), %ecx
addl %ecx, %ecx
movl %ebp, %r14d
subl %edx, %r14d
jl 0x2034aa
shrl %ebp
movl %ebp, %r15d
subl %eax, %r15d
jl 0x2034aa
subl %ecx, %ebp
jl 0x2034aa
movl %r14d, %edi
movl %r15d, %esi
callq 0x106015
movl %eax, %edi
movl %ebp, %esi
callq 0x106015
movl %eax, %ecx
movl %eax, 0x14(%rbx)
movl %r14d, %eax
cltd
idivl %ecx
movl %eax, 0x8(%rbx)
movl %r15d, %eax
cltd
idivl %ecx
movl %eax, 0xc(%rbx)
movl %ebp, %eax
cltd
idivl %ecx
movl %eax, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x7fc29
callq 0x7fbf0
// File: /workspace/github_c_makefile_star2_O3/genometools[P]genometools/src/match/xdrop.c
// Function: gt_xdrop_resources_delete
void gt_xdrop_resources_delete(GtXdropresources *res)
{
  if (res != NULL)
  {
    GT_FREEARRAY (&res->fronts, GtXdropfrontvalue);
    GT_FREEARRAY (&res->big_t, GtXdropscore);
    gt_free(res);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x203535
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0x2034ed
leaq 0x18(%rbx), %r14
leaq 0x1b98ca(%rip), %rsi    # 0x3bcd9e
movl $0xbb, %edx
callq 0x1045eb
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x20351a
leaq 0x30(%rbx), %r14
leaq 0x1b989d(%rip), %rsi    # 0x3bcd9e
movl $0xbc, %edx
callq 0x1045eb
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq $0x0, 0x10(%r14)
leaq 0x1b987d(%rip), %rsi    # 0x3bcd9e
movq %rbx, %rdi
movl $0xbd, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1045eb
retq