LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x7055e
movq %rax, %r13
callq 0xb3a58
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 0x1b4124
leaq (%rdx,%r14), %rcx
decq %rcx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x721ca
testb %bpl, %bpl
je 0x1b4112
movq %r15, %rdi
callq 0x75487
movl %eax, %ebp
xorl %r15d, %r15d
cmpq %r14, %r15
jae 0x1b4112
cmpb $-0x2, (%rbx,%r15)
jb 0x1b410d
callq 0xb3a58
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %edx, %edx
divl %ebp
movb %dl, (%rbx,%r15)
incq %r15
jmp 0x1b40ef
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x283e3d(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x130ede(%rip), %rsi    # 0x2e5013
leaq 0x1a87de(%rip), %rdx    # 0x35c91a
leaq 0x1a87eb(%rip), %rcx    # 0x35c92e
leaq 0x1a86dc(%rip), %r8     # 0x35c826
pushq $0x53
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x16a05c
leaq 0x28(%rsp), %r15
movq %rax, -0x18(%r15)
movq %r14, %rdi
callq 0x16a061
movq %rax, -0x10(%r15)
movq %r14, %rdi
callq 0x16a074
movq %rax, -0x8(%r15)
movq %rsp, %rsi
leaq 0x8(%rsp), %rdx
movq %r15, %rdi
movq %r14, %rcx
callq 0x16a08e
leaq 0x10(%rsp), %rsi
pushq $0x20
popq %rdx
movq %rbx, %rdi
callq 0x5851d
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1b426c
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 0x1b4226
movq 0x18(%r15), %rdx
movq 0x20(%r15), %rsi
movq %r14, %rcx
callq 0x74a31
cmpq 0x20(%r15), %rax
jne 0x1b4234
pushq $-0x1
popq %rbx
jmp 0x1b426c
leaq 0x18(%rsp), %rdx
leaq 0x10(%rsp), %rcx
xorl %esi, %esi
jmp 0x1b4258
leaq 0x18(%rsp), %rcx
leaq 0x10(%rsp), %rdx
testq %rax, %rax
je 0x1b4252
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
pushq $0x20
popq %rdx
callq 0x5851d
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1901f4(%rip), %rdi    # 0x3444c2
xorl %eax, %eax
callq 0x17070
xorl %eax, %eax
popq %rcx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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 0x1b46ce
movq %r14, %rdi
callq 0x89eb7
testb %al, %al
jne 0x1b4722
movq %r12, %rdi
callq 0xad442
movq %rax, (%rbx)
movq %rax, %rdi
movq %r15, %rsi
callq 0xacbfb
movq (%rbx), %rdi
callq 0xad1fa
leaq 0x1413fe(%rip), %rsi    # 0x2f5af1
leaq 0x1a8261(%rip), %rdx    # 0x35c95b
pushq $0x39
popq %rcx
movq %rax, %rdi
movq %r14, %r8
callq 0x8a156
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
movq 0x28383f(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1308e0(%rip), %rsi    # 0x2e5013
leaq 0x130a85(%rip), %rdx    # 0x2e51bf
leaq 0x1a8288(%rip), %rcx    # 0x35c9c9
leaq 0x1a8213(%rip), %r8     # 0x35c95b
pushq $0x36
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x89da4
movq %rax, %r15
leaq 0x1a8118(%rip), %rdx    # 0x35ca13
leaq 0x10(%rsp), %rsi
pushq $0x27
popq %rcx
movq %r14, %rdi
movq %rax, %r8
callq 0x8b049
testq %rax, %rax
je 0x1b4985
movq %rax, %r14
leaq 0x1a80f6(%rip), %rdx    # 0x35ca13
leaq 0x8(%rsp), %rsi
pushq $0x2d
popq %rcx
movq %r12, %rdi
movq %r15, %r8
callq 0x8b049
testq %rax, %rax
je 0x1b4985
movq %rax, %r12
movq %r15, %rdi
callq 0x8a045
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %r8
pushq $0x1
popq %rdi
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 0x8b9fa
movq %r12, %rdi
callq 0x8b9fa
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x2835dc(%rip), %rax    # 0x437f68
movq (%rax), %rbx
movq %r15, %rdi
callq 0x89f41
leaq 0x13066a(%rip), %rsi    # 0x2e5008
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x17a50
pushq $0x2
popq %rdi
callq 0x178f0
// File: /workspace/github_c_makefile_star2_O2/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 0x172d0
movq %rax, %r12
movq %rax, %r15
shrq %r15
movq %r15, (%rsp)
negq %r15
decq %r12
pushq $0x1
popq %r13
pushq $0x1
popq %rbp
leaq (%r15,%r13), %rax
cmpq $0x1, %rax
je 0x1b4a0a
leaq (%rbx,%r13), %rcx
movl %ebp, %edi
movq %rbx, %rsi
movq %r13, %rdx
movq %r12, %r8
callq *%r14
incq %r13
decq %r12
jmp 0x1b49e6
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/test-pairwise.c
// Function: gt_applycheckfunctiontotext
GtUword gt_applycheckfunctiontotext(const GtUchar *text,
                                       GtUword textlen,
                                       void *info)
{
  GtUword i;
  Checkcmppairfuntype checkfunction = (Checkcmppairfuntype) info;

#ifdef SKDEBUG
  printf("%s\n",(char *) text);
#endif
  for (i=0; i<=textlen/2; i++)
  {
    checkfunction(true,text,i,text+i,textlen-i);
  }
  return textlen/2+1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movq %rsi, %r15
shrq %r15
incq %r15
xorl %r13d, %r13d
pushq $0x1
popq %rbp
cmpq %r13, %r15
je 0x1b4a5e
leaq (%r12,%r13), %rcx
movl %ebp, %edi
movq %r12, %rsi
movq %r13, %rdx
movq %r14, %r8
callq *%rbx
incq %r13
decq %r14
jmp 0x1b4a40
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_O2/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 $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, 0x10(%rsp)
movq %rsi, %rdi
callq 0x172d0
movq %rax, %r12
leaq 0x1(%rbx), %r15
leaq 0x8(,%rbx,8), %rdi
leaq 0x1a7f6c(%rip), %rbp    # 0x35ca13
pushq $0x70
popq %rdx
movq %rbp, %rsi
callq 0x93160
movq %rax, %r13
pushq $0x71
popq %rdx
movq %r15, %rdi
movq %rbp, %rsi
callq 0x93160
movq %rax, %rbp
pushq $-0x1
popq %rax
cmpq %rax, %rbx
je 0x1b4ad9
andq $0x0, 0x8(%r13,%rax,8)
incq %rax
jmp 0x1b4ac9
leaq -0x1(%rbx), %r15
movb $0x0, (%rbp,%rbx)
movq $0x0, (%rsp)
movq %r15, 0x8(%rsp)
xorl %eax, %eax
testb $0x1, %al
jne 0x1b4b4f
xorl %eax, %eax
cmpq %rax, %rbx
je 0x1b4b0e
movq (%r13,%rax,8), %rcx
movb (%r14,%rcx), %cl
movb %cl, (%rbp,%rax)
incq %rax
jmp 0x1b4af7
movq %rbp, %rdi
movq %rbx, %rsi
movq 0x10(%rsp), %rdx
callq 0x1b4a1d
addq %rax, (%rsp)
movq (%r13,%r15,8), %rax
incq %rax
movq %rax, (%r13,%r15,8)
cmpq %r12, %rax
sete %al
jne 0x1b4b48
andq $0x0, (%r13,%r15,8)
addq $-0x1, %r15
jb 0x1b4b22
xorl %r15d, %r15d
jmp 0x1b4af1
movq 0x8(%rsp), %r15
jmp 0x1b4af1
leaq 0x1a7ebd(%rip), %rbx    # 0x35ca13
movq %r13, %rdi
movq %rbx, %rsi
movl $0x91, %edx
callq 0x936f9
movq %rbp, %rdi
movq %rbx, %rsi
movl $0x92, %edx
callq 0x936f9
movq (%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
pushq $0xa
popq %rdi
callq 0x15f460
movq %rax, %rbx
pushq $0x1
popq %rbp
movl %ebp, %edi
xorl %esi, %esi
movq %r13, %rdx
movq %r12, %rcx
xorl %r8d, %r8d
movq %r12, %r9
callq 0x1918b9
movq %rax, %r12
movl %ebp, %edi
xorl %esi, %esi
movq %r15, %rdx
movq %r14, %rcx
xorl %r8d, %r8d
movq %r14, %r9
callq 0x1918b9
movq %rax, %r14
movq %rbx, %rdi
movq %r12, %rsi
movq %rax, %rdx
callq 0x15f4de
movq %rax, %r15
movq %r12, %rdi
callq 0x191a01
movq %r14, %rdi
callq 0x191a01
movq %rbx, %rdi
callq 0x15f4a6
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_O2/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 %rdx, %r12
movq %rsi, %r13
movq %rsi, 0x10(%rsp)
pushq $0xa
popq %rdi
callq 0x15f460
movq %rax, %r15
pushq $0x1
popq %rdi
xorl %esi, %esi
movq %r13, %rdx
movq %r12, %rcx
xorl %r8d, %r8d
movq %r12, %r9
callq 0x1918b9
movq %rax, %rbp
pushq $0x1
popq %rdi
xorl %esi, %esi
movq %rbx, %rdx
movq %rbx, %r13
movq %r14, %rcx
xorl %r8d, %r8d
movq %r14, %r9
callq 0x1918b9
movq %rax, %rbx
movq %r15, 0x8(%rsp)
movq %r15, %rdi
movq %rbp, %rsi
movq %rax, %rdx
callq 0x15f4de
movq %rax, %r15
movq 0x10(%rsp), %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %r14, %rcx
callq 0x2cd10c
cmpq %rax, %r15
jne 0x1b4cce
movq %rbp, %rdi
callq 0x191a01
movq %rbx, %rdi
callq 0x191a01
movq 0x8(%rsp), %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x15f4a6
movq 0x283293(%rip), %rcx    # 0x437f68
movq (%rcx), %rdi
leaq 0x1a7d4e(%rip), %rsi    # 0x35ca2d
movq %r15, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x17a50
pushq $0x2
popq %rdi
callq 0x178f0
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
pushq %rax
movl %esi, %ebp
movl %edi, %ebx
leaq 0x1a7d5f(%rip), %rsi    # 0x35ca61
pushq $0x58
popq %rdi
pushq $0x26
popq %rdx
callq 0x93160
cmpl $0x12, %ebx
jae 0x1b4d42
testl %ebx, %ebx
je 0x1b4d6c
testl %ebp, %ebp
je 0x1b4d96
movl %ebx, %ecx
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x1b4d2c
andl $0x0, (%rax,%rdx,4)
incq %rdx
jmp 0x1b4d1e
movl %ebx, 0x48(%rax)
movl %ebp, 0x4c(%rax)
decl %ebx
movl %ebx, 0x50(%rax)
andl $0x0, 0x54(%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x28321f(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1302c0(%rip), %rsi    # 0x2e5013
leaq 0x1a7d1e(%rip), %rdx    # 0x35ca78
leaq 0x1a7d43(%rip), %rcx    # 0x35caa4
leaq 0x1a7cf9(%rip), %r8     # 0x35ca61
pushq $0x27
jmp 0x1b4dbe
movq 0x2831f5(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x130296(%rip), %rsi    # 0x2e5013
leaq 0x1a7d34(%rip), %rdx    # 0x35cab8
leaq 0x1a7d19(%rip), %rcx    # 0x35caa4
leaq 0x1a7ccf(%rip), %r8     # 0x35ca61
pushq $0x28
jmp 0x1b4dbe
movq 0x2831cb(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x13026c(%rip), %rsi    # 0x2e5013
leaq 0x1a7d1a(%rip), %rdx    # 0x35cac8
leaq 0x1a7cef(%rip), %rcx    # 0x35caa4
leaq 0x1a7ca5(%rip), %r8     # 0x35ca61
pushq $0x29
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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), %edx
movl %edx, %eax
incl (%rdi,%rax,4)
movl 0x4c(%rdi), %eax
movl 0x50(%rdi), %edx
movl %edx, 0x54(%rdi)
movl (%rdi,%rdx,4), %ecx
cmpl %eax, %ecx
jne 0x1b4dfa
andl $0x0, (%rdi,%rdx,4)
movl 0x50(%rdi), %edx
testl %edx, %edx
je 0x1b4e02
decl %edx
movl %edx, 0x50(%rdi)
jmp 0x1b4dd3
movl 0x48(%rdi), %edx
decl %edx
movl %edx, 0x50(%rdi)
cmpl %eax, %ecx
setne %al
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/twobits2kmers.c
// Function: showdifferentkmers
static void showdifferentkmers(int line,GtUword pos,GtCodetype kmer1,
                               GtCodetype kmer2)
{
  char buffer[2*GT_INTWORDSIZE+1];

  fprintf(stderr,"line %d: pos="GT_WU"\n",line,pos);
  gt_bitsequence_tostring_units(buffer,(GtBitsequence) kmer1,2U);
  fprintf(stderr,"kmer1=%s\n",buffer);
  gt_bitsequence_tostring_units(buffer,(GtBitsequence) kmer2,2U);
  fprintf(stderr,"kmer2=%s\n",buffer);
  fprintf(stderr,"kmer1="GT_WU" != "GT_WU"= kmer2\n",kmer1,kmer2);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %rcx
movq 0x282c46(%rip), %r12    # 0x437f68
movq (%r12), %rdi
leaq 0x1a78b0(%rip), %rsi    # 0x35cbdd
movl $0xe8, %edx
xorl %eax, %eax
callq 0x17a50
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x1b53a3
movq (%r12), %rdi
leaq 0x1a789d(%rip), %rsi    # 0x35cbef
movq %r15, %rdx
xorl %eax, %eax
callq 0x17a50
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1b53a3
movq (%r12), %rdi
leaq 0x1a7887(%rip), %rsi    # 0x35cbf9
movq %r15, %rdx
xorl %eax, %eax
callq 0x17a50
movq (%r12), %rdi
leaq 0x1a787c(%rip), %rsi    # 0x35cc03
movq %r14, %rdx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x17a50
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/core/intbits.h
// Function: gt_bitsequence_tostring_units
static inline void gt_bitsequence_tostring_units(char *buffer,
                                                 GtBitsequence bs,
                                                 unsigned int units)
{
  unsigned int idx, unit = 0;
  GtBitsequence mask;

  for (idx=0, unit = 1U, mask = GT_FIRSTBIT;
       mask > 0;
       unit++, mask >>= 1) {
    buffer[idx++] = (bs & mask) ? '1' : '0';
    if (unit % units == 0) {
      buffer[idx++] = ' ';
    }
  }
  buffer[idx] = '\0';
}

// Assembly:
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
pushq $0x1
popq %rcx
xorl %edx, %edx
movl %edx, %r9d
cmpl $0x41, %ecx
je 0x1b53ea
testq %rsi, %rax
sete %r10b
xorb $0x31, %r10b
leal 0x1(%rdx), %r8d
movb %r10b, (%rdi,%r9)
testb $0x1, %cl
jne 0x1b53e0
addl $0x2, %edx
movl %r8d, %r8d
movb $0x20, (%rdi,%r8)
movl %edx, %r8d
incl %ecx
shrq %rax
movl %r8d, %edx
jmp 0x1b53b2
movb $0x0, (%rdi,%r9)
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x1b543e
movq %rcx, %rbx
callq 0x19f648
testq %rax, %rax
je 0x1b5410
cmpb $0x1, (%rax)
je 0x1b5410
cmpq %rbx, 0x8(%rax)
jne 0x1b546c
popq %rbx
retq
movq 0x282b51(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x12fbf2(%rip), %rsi    # 0x2e5013
leaq 0x1a7834(%rip), %rdx    # 0x35cc5c
leaq 0x1a781c(%rip), %rcx    # 0x35cc4b
leaq 0x1a7728(%rip), %r8     # 0x35cb5e
movl $0x9a, %r9d
jmp 0x1b5498
movq 0x282b23(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x12fbc4(%rip), %rsi    # 0x2e5013
leaq 0x1a776e(%rip), %rdx    # 0x35cbc4
leaq 0x1a77ee(%rip), %rcx    # 0x35cc4b
leaq 0x1a76fa(%rip), %r8     # 0x35cb5e
movl $0x98, %r9d
jmp 0x1b5498
movq 0x282af5(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x12fb96(%rip), %rsi    # 0x2e5013
leaq 0x1a7814(%rip), %rdx    # 0x35cc98
leaq 0x1a77c0(%rip), %rcx    # 0x35cc4b
leaq 0x1a76cc(%rip), %r8     # 0x35cb5e
movl $0x9b, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/tyr-mersplit.c
// Function: extractprefixbytecode
static GtUword extractprefixbytecode(GtUword merbytes,
                                           unsigned int prefixlength,
                                           const GtUchar *bytecode)
{
  GtUword idx, code = 0;

  for (idx=0; idx < GT_MIN((GtUword) sizeof (GtUword),merbytes); idx++)
  {
    code = (code << 8) | bytecode[idx];
    if (GT_MULT4(idx+1) == (GtUword) prefixlength)
    {
      break;
    }
    if (GT_MULT4(idx+1) > (GtUword) prefixlength)
    {
      code >>= GT_MULT2(GT_MULT4(idx+1) - prefixlength);
      break;
    }
  }
  return code;
}

// Assembly:
cmpq $0x8, %rdi
pushq $0x8
popq %r8
cmovbq %rdi, %r8
movl %esi, %ecx
shrl $0x2, %esi
incq %rsi
addq %rcx, %rcx
xorl %edi, %edi
xorl %eax, %eax
cmpq %rdi, %r8
je 0x1b56f6
movq %rax, %r9
shlq $0x8, %r9
movzbl (%rdx,%rdi), %eax
orq %r9, %rax
addq $-0x8, %rcx
je 0x1b56f6
incq %rdi
cmpq %rdi, %rsi
jne 0x1b56d0
negb %cl
shrq %cl, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
movq (%r14), %rdi
callq 0x8b9fa
andq $0x0, (%r14)
leaq 0x1a6fa1(%rip), %rsi    # 0x35ccd8
movq %r14, %rdi
movl $0x1c5, %edx            # imm = 0x1C5
callq 0x936f9
andq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/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 0x1b651d
movq 0x38(%r14), %rdi
leaq 0x80(%rbx), %r12
movq %r12, %rsi
shlq $0x4, %rsi
leaq 0x1a6962(%rip), %rdx    # 0x35ce4b
movl $0x133, %ecx            # imm = 0x133
callq 0x93472
movq %rax, 0x38(%r14)
movq 0x40(%r14), %rcx
movq %rcx, %rdx
shlq $0x4, %rdx
addq %rax, %rdx
xorps %xmm0, %xmm0
cmpq %r12, %rcx
jae 0x1b6519
incq %rcx
movups %xmm0, (%rdx)
addq $0x10, %rdx
jmp 0x1b6508
movq %r12, 0x40(%r14)
leaq 0x1(%rbx), %rax
cmpq 0x48(%r14), %rax
jbe 0x1b652b
movq %rax, 0x48(%r14)
movq 0x38(%r14), %r13
movq %rbx, %r12
shlq $0x4, %r12
incq (%r13,%r12)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1b692d
testb %al, %al
je 0x1b6573
movq 0x8(%r13,%r12), %r13
leaq 0x1a68f5(%rip), %rsi    # 0x35ce4b
pushq $0x10
popq %rdi
movl $0x9d, %edx
callq 0x93160
movq %r15, (%rax)
movq %r13, 0x8(%rax)
movq 0x38(%r14), %rcx
movq %rax, 0x8(%rcx,%r12)
cmpb $0x1, 0x68(%r14)
jne 0x1b65e1
xorl %r12d, %r12d
movq (%r14), %rax
movq 0x20(%r14), %rdi
cmpq %rax, %r12
jae 0x1b65a6
leaq (%r15,%r12), %rsi
movl 0x28(%r14), %edx
callq 0x705e4
movq 0xa8(%r14), %rcx
movb %al, (%rcx,%r12)
incq %r12
jmp 0x1b657d
movq 0xa0(%r14), %rsi
movq 0x8(%r14), %rcx
movl 0x28(%r14), %r9d
xorl %edx, %edx
xorl %r8d, %r8d
pushq %rax
pushq 0xa8(%r14)
callq 0x14fb98
popq %rcx
popq %rdx
movq %rax, %r14
movq %rax, %rdi
callq 0x14fc3b
cmpq %rbx, %rax
jne 0x1b65ed
movq %r14, %rdi
callq 0x14fd61
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x281974(%rip), %rcx    # 0x437f68
movq (%rcx), %rdi
leaq 0x1a6917(%rip), %rsi    # 0x35cf15
movq %rax, %rdx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x17a50
pushq $0x2
popq %rdi
callq 0x178f0
// File: /workspace/github_c_makefile_star2_O2/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, %r12
movq %rdi, %r14
movq %rdx, %rdi
movq %r14, %rsi
callq 0x1b692d
testb %al, %al
je 0x1b6725
movq (%rbx), %rcx
movq 0x20(%rbx), %rsi
movq 0x70(%rbx), %r13
movq 0x78(%rbx), %rbp
movq 0x50(%rbx), %rax
movq %rax, 0x10(%rsp)
movq 0x58(%rbx), %r15
movq 0x98(%rbx), %rax
movq %rax, 0x8(%rsp)
movq %r13, %rdi
movq %r12, %rdx
callq 0x7013f
pushq $0x1
popq %rsi
movq %r13, %rdi
movq %rbp, %rdx
movq 0x10(%rsp), %rcx
callq 0xb302c
testq %r15, %r15
je 0x1b671e
cmpq $0xff, %r14
jbe 0x1b6708
movq 0x88(%rbx), %rsi
cmpq %rsi, 0x90(%rbx)
jae 0x1b66ae
movq 0x80(%rbx), %rax
jmp 0x1b66dc
addq $0x20, %rsi
movq %rsi, 0x88(%rbx)
movq 0x80(%rbx), %rdi
shlq $0x4, %rsi
leaq 0x1a6780(%rip), %rdx    # 0x35ce4b
movl $0x175, %ecx            # imm = 0x175
callq 0x93472
movq %rax, 0x80(%rbx)
testq %rax, %rax
je 0x1b6736
movq 0x90(%rbx), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x90(%rbx)
shlq $0x4, %rcx
movq 0x8(%rsp), %rdx
movq %rdx, (%rax,%rcx)
movq %r14, 0x8(%rax,%rcx)
xorl %r14d, %r14d
leaq 0x7(%rsp), %rdi
movb %r14b, (%rdi)
pushq $0x1
popq %rdx
movq %rdx, %rsi
movq %r15, %rcx
callq 0xb302c
incq 0x98(%rbx)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x28182b(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x12e8cc(%rip), %rsi    # 0x2e5013
leaq 0x1a680b(%rip), %rdx    # 0x35cf59
leaq 0x1a67e1(%rip), %rcx    # 0x35cf36
leaq 0x1a66ef(%rip), %r8     # 0x35ce4b
movl $0x175, %r9d            # imm = 0x175
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 0x1b67b8
movq %r14, %rdi
callq 0x89eb7
testb %al, %al
jne 0x1b680c
movq (%rbx), %rax
movq %rax, %r8
subq %r12, %r8
jbe 0x1b67fe
addq %r15, %rax
cmpq 0x8(%rbx), %rax
ja 0x1b67fe
movq 0x20(%rbx), %rdi
movl 0x28(%rbx), %esi
movq 0x60(%rbx), %rdx
addq %r15, %r12
movq %r12, %rcx
callq 0x71e27
testb %al, %al
jne 0x1b67fe
pushq $0x1
popq %rdi
movq %r15, %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq *0x30(%rbx)
testl %eax, %eax
je 0x1b67fe
pushq $-0x1
popq %rax
jmp 0x1b6800
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x281755(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x12e7f6(%rip), %rsi    # 0x2e5013
leaq 0x12e99b(%rip), %rdx    # 0x2e51bf
leaq 0x1a6755(%rip), %rcx    # 0x35cf80
leaq 0x1a6619(%rip), %r8     # 0x35ce4b
movl $0x1b1, %r9d            # imm = 0x1B1
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r13
testq %r8, %r8
je 0x1b686f
movq %r14, %rdi
callq 0x89eb7
testb %al, %al
jne 0x1b68b8
movq (%rbx), %rax
xorl %ebp, %ebp
cmpq %r13, %rax
ja 0x1b68a7
movq 0x18(%r15), %rcx
cmpq %r12, %rcx
cmovaq %rcx, %r12
cmpq %rax, %r12
jae 0x1b68a7
movq 0x8(%r15), %rdi
movq 0x10(%r15), %rsi
subq (%r15), %rdi
incq %rdi
movq %rbx, %rdx
movq %r14, %rcx
callq *0x30(%rbx)
testl %eax, %eax
je 0x1b68a7
pushq $-0x1
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x2816a9(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x12e74a(%rip), %rsi    # 0x2e5013
leaq 0x12e8ef(%rip), %rdx    # 0x2e51bf
leaq 0x1a66bd(%rip), %rcx    # 0x35cf94
leaq 0x1a656d(%rip), %r8     # 0x35ce4b
movl $0x1ca, %r9d            # imm = 0x1CA
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/tyr-mkindex.c
// Function: outputbytewiseUlongvalue
static void outputbytewiseUlongvalue(FILE *fpout,GtUword value)
{
  size_t i;

  for (i=0; i < sizeof (value); i++)
  {
    (void) putc((int) (value & UCHAR_MAX),fpout);
    value >>= 8;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x8
popq %r15
subq $0x1, %r15
jb 0x1b6927
movzbl %bl, %edi
movq %r14, %rsi
callq 0x17ee0
shrq $0x8, %rbx
jmp 0x1b6910
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/tyr-mkindex.c
// Function: decideifocc
static bool decideifocc(const TyrDfsstate *state,GtUword countocc)
{
  if (state->minocc > 0)
  {
    if (state->maxocc > 0)
    {
      if (countocc >= state->minocc && countocc <= state->maxocc)
      {
        return true;
      }
    } else
    {
      if (countocc >= state->minocc)
      {
        return true;
      }
    }
  } else
  {
    if (state->maxocc > 0)
    {
      if (countocc <= state->maxocc)
      {
        return true;
      }
    }
  }
  return false;
}

// Assembly:
movq 0x10(%rdi), %rcx
movq 0x18(%rdi), %rax
testq %rcx, %rcx
je 0x1b6954
testq %rax, %rax
je 0x1b6968
cmpq %rsi, %rcx
seta %cl
cmpq %rsi, %rax
setb %al
orb %cl, %al
movb $0x1, %al
je 0x1b6953
xorl %eax, %eax
retq
testq %rax, %rax
setne %cl
cmpq %rsi, %rax
setae %dl
movb $0x1, %al
testb %dl, %cl
je 0x1b6951
jmp 0x1b6953
movb $0x1, %al
cmpq %rsi, %rcx
ja 0x1b6951
jmp 0x1b6953
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/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, 0x10(%rsp)
movq 0x20(%r8), %r12
leaq 0x1(%rsi), %rax
cmpq %r12, %rax
jbe 0x1b6b8c
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x28(%r8), %rax
movq %rax, 0x8(%rsp)
movq (%r8), %r15
movl 0x8(%r8), %ebp
movq 0x10(%r8), %r14
movq 0x18(%r8), %rbx
leaq 0x1(%rsi), %r13
cmpq %r12, %r13
ja 0x1b6b7b
addq 0x10(%rsp), %rsi
cmpq %r14, %rsi
jae 0x1b6b7b
movq %r15, %rdi
movl %ebp, %edx
callq 0x705e4
cmpb $-0x3, %al
ja 0x1b6b7b
cmpq %rbx, %r13
jb 0x1b6bda
movq 0x8(%rsp), %rdi
movq %r13, %rsi
pushq $0x1
popq %rdx
callq 0x1b6c69
movq %r13, %rsi
jmp 0x1b6ba4
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/tyr-occratio.c
// Function: occ_processcompletenode
static int occ_processcompletenode(GtUword nodeptrdepth,
                               Dfsinfo *anodeptr,
                               GtUword nodeptrminusonedepth,
                               Dfsstate *astate,
                               GT_UNUSED GtError *err)
{
  GtUword fatherdepth;
  GtUword startlength, endlength;
  OccDfsinfo *nodeptr = (OccDfsinfo*) anodeptr;
  OccDfsstate *state = (OccDfsstate*) astate;

  fatherdepth = nodeptr->lcptabrightmostleafplus1;
  if (fatherdepth < nodeptrminusonedepth)
  {
    fatherdepth = nodeptrminusonedepth;
  }
  startlength = (GtUword) (fatherdepth + 1);
  if (startlength < state->minmersize)
  {
    startlength = state->minmersize;
  }
  endlength = (GtUword) nodeptrdepth;
  if (endlength > state->maxmersize)
  {
    endlength = state->maxmersize;
  }
  if (startlength <= endlength)
  {
    GtUword lenval;
    GtUword occcount = nodeptr->rightmostleaf - nodeptr->leftmostleaf + 1;

    for (lenval = startlength; lenval <= endlength; lenval++)
    {
      adddistributionuint64_t(state->nonuniquemultidistribution,
                              lenval,
                              (GtUword) occcount);
      adddistributionuint64_t(state->nonuniquedistribution,
                              lenval,
                              1UL);
    }
  }
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq 0x10(%rsi), %rax
cmpq %rdx, %rax
cmovaq %rax, %r14
movq %rdi, %r15
incq %r14
movq 0x18(%rcx), %rax
movq 0x20(%rcx), %rcx
cmpq %rax, %r14
cmovbeq %rax, %r14
cmpq %rdi, %rcx
cmovbq %rcx, %r15
cmpq %r15, %r14
jbe 0x1b6c26
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x8(%rsi), %r12
subq (%rsi), %r12
incq %r12
pushq $0x1
popq %r13
cmpq %r15, %r14
ja 0x1b6c1a
movq 0x38(%rbx), %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x1b6c69
movq 0x30(%rbx), %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x1b6c69
incq %r14
jmp 0x1b6c34
// File: /workspace/github_c_makefile_star2_O2/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 0x1b6cbb
movq (%r15), %rdi
leaq 0x80(%r14), %r12
leaq 0x400(,%r14,8), %rsi
leaq 0x1a649d(%rip), %rdx    # 0x35d136
pushq $0x48
popq %rcx
callq 0x93472
movq %rax, (%r15)
movq 0x8(%r15), %rcx
cmpq %r12, %rcx
jae 0x1b6cb7
andq $0x0, (%rax,%rcx,8)
incq %rcx
jmp 0x1b6ca8
movq %r12, 0x8(%r15)
leaq 0x1(%r14), %rax
cmpq 0x10(%r15), %rax
jbe 0x1b6cc9
movq %rax, 0x10(%r15)
movq (%r15), %rax
addq %rbx, (%rax,%r14,8)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x700cc
movq (%r15), %rdx
testq %r14, %r14
je 0x1b6d11
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x1b54a4
movq 0x10(%r15), %rcx
movq 0x18(%r15), %r8
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x2cd663
// File: /workspace/github_c_makefile_star2_O2/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 0x1b7205
movq 0x50(%rsp), %rsi
leaq 0x1a5216(%rip), %rdi    # 0x35c40e
xorl %r15d, %r15d
xorl %eax, %eax
callq 0x17070
movl 0x28(%rbx), %eax
testb $0x2, %al
je 0x1b7255
movq %r13, 0x8(%rsp)
movq %r14, %r13
movq (%rsp), %r14
subq %rbp, %r14
testb %r15b, %r15b
je 0x1b7222
xorl %r15d, %r15d
jmp 0x1b722a
pushq $0x9
popq %rdi
callq 0x179c0
xorb $0x1, %r12b
movzbl %r12b, %eax
leal 0x2b(,%rax,2), %esi
leaq 0x1a5f7a(%rip), %rdi    # 0x35d1ba
movq %r14, %rdx
xorl %eax, %eax
callq 0x17070
movl 0x28(%rbx), %eax
movq %r13, %r14
movq 0x8(%rsp), %r13
testb $0x4, %al
je 0x1b729a
movq %r13, %rdi
movq %r14, %rsi
callq 0x2cd428
movq %rax, %r14
testb %r15b, %r15b
je 0x1b7271
xorl %r15d, %r15d
jmp 0x1b7279
pushq $0x9
popq %rdi
callq 0x179c0
movq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x2cd5b3
leaq 0x1a5181(%rip), %rdi    # 0x35c40e
movq %rax, %rsi
xorl %eax, %eax
callq 0x17070
movl 0x28(%rbx), %eax
testb $0x8, %al
je 0x1b72c9
testb %r15b, %r15b
jne 0x1b72ab
pushq $0x9
popq %rdi
callq 0x179c0
movq 0x20(%rbx), %rcx
movq 0x30(%rbx), %rdi
movq 0x280bf6(%rip), %rax    # 0x437eb0
movq (%rax), %rsi
movq (%rsp), %rdx
callq 0x5703f
movl 0x28(%rbx), %eax
testb $0xe, %al
je 0x1b72e3
pushq $0xa
popq %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x179c0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop