LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/fmi-fwduni.c
// Function: gt_skfmuniqueforward
GtUword gt_skfmuniqueforward (const void *genericindex,
                                 GT_UNUSED GtUword offset,
                                 GT_UNUSED GtUword left,
                                 GT_UNUSED GtUword right,
                                 GT_UNUSED GtUword *witnessposition,
                                 const GtUchar *qstart,
                                 const GtUchar *qend)
{
  GtUchar cc;
  const GtUchar *qptr;
  GtUwordBound bwtbound;
  const Fmindex *fmindex = (Fmindex *) genericindex;

  gt_assert(qstart < qend);
  qptr = qstart;
  cc = *qptr++;
  if (GT_ISSPECIAL(cc))
  {
    return 0;
  }
  bwtbound.lbound = fmindex->tfreq[cc];
  bwtbound.ubound = fmindex->tfreq[cc+1];
  while (qptr < qend && bwtbound.lbound + 1 < bwtbound.ubound)
  {
    cc = *qptr;
    if (GT_ISSPECIAL (cc))
    {
      return 0;
    }
    bwtbound.lbound = fmindex->tfreq[cc] +
                      fmoccurrence (fmindex, cc, bwtbound.lbound);
    bwtbound.ubound = fmindex->tfreq[cc] +
                      fmoccurrence (fmindex, cc, bwtbound.ubound);
    qptr++;
  }
  if (bwtbound.lbound + 1 == bwtbound.ubound)
  {
    return (GtUword) (qptr - qstart);
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, (%rsp)
cmpq 0x50(%rsp), %r9
jae 0x15a9cd
movzbl (%r9), %eax
cmpq $0xfd, %rax
ja 0x15a9b9
movq (%rsp), %rcx
movq 0x18(%rcx), %rcx
movq (%rcx,%rax,8), %r13
movq 0x8(%rcx,%rax,8), %r12
pushq $0x1
popq %rdx
movq %r9, 0x8(%rsp)
movq (%rsp), %r15
leaq (%r9,%rdx), %rax
leaq 0x1(%r13), %rcx
cmpq 0x50(%rsp), %rax
jae 0x15a9b4
cmpq %r12, %rcx
jae 0x15a9b4
movzbl (%rax), %ebp
cmpq $0xfd, %rbp
ja 0x15a9b9
movq 0x18(%r15), %rax
leal (,%rbp,8), %r14d
movq (%rax,%r14), %rbx
movq %r15, %rdi
movl %ebp, %esi
movq %rdx, 0x10(%rsp)
movq %r13, %rdx
callq 0x15aa03
movq %rax, %r13
addq %rbx, %r13
movq 0x18(%r15), %rax
movq (%rax,%r14), %rbx
movq %r15, %rdi
movl %ebp, %esi
movq %r12, %rdx
callq 0x15aa03
movq 0x8(%rsp), %r9
movq 0x10(%rsp), %rdx
movq %rax, %r12
addq %rbx, %r12
incq %rdx
jmp 0x15a942
cmpq %r12, %rcx
je 0x15a9bb
xorl %edx, %edx
movq %rdx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x2dd594(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x18a635(%rip), %rsi    # 0x2e5013
leaq 0x1e87d3(%rip), %rdx    # 0x3431b8
leaq 0x1ebeb9(%rip), %rcx    # 0x3468a5
leaq 0x1ebec7(%rip), %r8     # 0x3468ba
pushq $0x29
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/fmi-map.c
// Function: gt_freefmindex
void gt_freefmindex(Fmindex *fmindex)
{
  if (fmindex->mappedptr != NULL)
  {
    gt_fa_xmunmap(fmindex->mappedptr);
  }
  if (fmindex->bwtformatching != NULL)
  {
    gt_encseq_delete(fmindex->bwtformatching);
    fmindex->bwtformatching = NULL;
  }
  gt_alphabet_delete((GtAlphabet *) fmindex->alphabet);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x70(%rdi), %rdi
testq %rdi, %rdi
je 0x15b19a
callq 0x8b9fa
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x15b1ab
callq 0x735fd
andq $0x0, (%rbx)
movq 0x68(%rbx), %rdi
popq %rbx
jmp 0x568b5
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/fmi-mapspec.c
// Function: gt_flushfmindex2file
int gt_flushfmindex2file(FILE *fp,
                         Fmindex *fmindex,
                         bool storeindexpos,
                         GtError *err)
{
  Fmindexwithoptions fmwithoptions;

  gt_error_check(err);
  fmwithoptions.fmptr = fmindex;
  fmwithoptions.storeindexpos = storeindexpos;
  return gt_mapspec_write(assignfmmapspecification,fp,
                          (void *) &fmwithoptions,fmindex->sizeofindex,err);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
testq %rcx, %rcx
je 0x15b766
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x15b796
leaq 0x8(%rsp), %rdx
movq %r15, (%rdx)
movb %bpl, 0x8(%rdx)
movq 0xa0(%r15), %rcx
leaq 0x4c(%rip), %rdi        # 0x15b7cc
movq %r14, %rsi
movq %rbx, %r8
callq 0x945a2
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x2dc7cb(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x18986c(%rip), %rsi    # 0x2e5013
leaq 0x189a11(%rip), %rdx    # 0x2e51bf
leaq 0x1eb255(%rip), %rcx    # 0x346a0a
leaq 0x1eb263(%rip), %r8     # 0x346a1f
pushq $0x3a
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/fmi-mapspec.c
// Function: assignfmmapspecification
static void assignfmmapspecification(GtMapspec *mapspec,
                                     void *data,
                                     GT_UNUSED bool writemode)
{
  Fmindexwithoptions *fmwithoptions = (Fmindexwithoptions *) data;
  Fmindex *fmindex;

  fmindex = fmwithoptions->fmptr;
  gt_mapspec_add_ulong(mapspec, fmindex->tfreq,
                       (GtUword) TFREQSIZE(fmindex->mapsize));
  gt_mapspec_add_ulong(mapspec, fmindex->superbfreq,
                       (GtUword) SUPERBFREQSIZE(fmindex->mapsize,
                                                      fmindex->nofsuperblocks));
  gt_mapspec_add_ulong(mapspec, fmindex->markpostable,
                       fmwithoptions->storeindexpos
                       ? (GtUword) MARKPOSTABLELENGTH(fmindex->bwtlength,
                                                            fmindex->markdist)
                       : 0);
  gt_mapspec_add_ulongbound(mapspec, fmindex->boundarray,
                            (GtUword) fmindex->numofcodes);
  gt_mapspec_add_pairbwtindex(mapspec, fmindex->specpos.spaceGtPairBwtidx,
                              fmwithoptions->storeindexpos
                              ? fmindex->specpos.nextfreeGtPairBwtidx
                              : 0);
  gt_mapspec_add_uchar(mapspec, fmindex->bfreq,
                (GtUword) BFREQSIZE(fmindex->mapsize,fmindex->nofblocks));
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %r15
leaq 0x18(%r15), %rsi
movl 0x78(%r15), %edx
incl %edx
callq 0x94a45
leaq 0x20(%r15), %rsi
movl 0x78(%r15), %edx
imulq 0xb0(%r15), %rdx
movq %rbx, %rdi
callq 0x94a45
leaq 0x28(%r15), %rsi
cmpb $0x1, 0x8(%r14)
jne 0x15b824
movq 0x10(%r15), %rax
decq %rax
xorl %edx, %edx
divq 0xb8(%r15)
movq %rax, %rdx
incq %rdx
jmp 0x15b826
xorl %edx, %edx
movq %rbx, %rdi
callq 0x94a45
leaq 0xc8(%r15), %rsi
movq 0xc0(%r15), %rdx
movq %rbx, %rdi
callq 0x94b3a
cmpb $0x1, 0x8(%r14)
jne 0x15b851
movq 0x60(%r15), %rdx
jmp 0x15b853
xorl %edx, %edx
leaq 0x50(%r15), %rsi
movq %rbx, %rdi
callq 0x952e2
movl 0x78(%r15), %edx
imulq 0xa8(%r15), %rdx
leaq 0x8(%r15), %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x9485b
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/fmi-mapspec.c
// Function: gt_fillfmmapspecstartptr
int gt_fillfmmapspecstartptr(Fmindex *fmindex,
                             bool storeindexpos,
                             const GtStr *tmpfilename,
                             GtError *err)
{
  Fmindexwithoptions fmwithoptions;

  gt_error_check(err);
  fmwithoptions.fmptr = fmindex;
  fmwithoptions.storeindexpos = storeindexpos;
  return gt_mapspec_read(assignfmmapspecification,
                         (void *) &fmwithoptions,
                         gt_str_get(tmpfilename),
                         fmindex->sizeofindex,
                         &fmindex->mappedptr,
                         err);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %r14
testq %rcx, %rcx
je 0x15b8a4
movq %rbx, %rdi
callq 0x89eb7
testb %al, %al
jne 0x15b8e8
movq %rsp, %r12
movq %r14, (%r12)
movb %bpl, 0x8(%r12)
movq %r15, %rdi
callq 0xad1fa
movq 0xa0(%r14), %rcx
addq $0x70, %r14
leaq -0xfe(%rip), %rdi       # 0x15b7cc
movq %r12, %rsi
movq %rax, %rdx
movq %r14, %r8
movq %rbx, %r9
callq 0x9430d
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x2dc679(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x18971a(%rip), %rsi    # 0x2e5013
leaq 0x1898bf(%rip), %rdx    # 0x2e51bf
leaq 0x1eb130(%rip), %rcx    # 0x346a37
leaq 0x1eb111(%rip), %r8     # 0x346a1f
pushq $0x48
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
nop
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/ft-polish.c
// Function: polishing_info_new_with_bias
GtFtPolishing_info *polishing_info_new_with_bias(double errorpercentage,
                                                 double matchscore_bias,
                                                 GtUword history_size)
{
  GtFtPolishing_info *pol_info = gt_malloc(sizeof *pol_info);

  gt_assert(pol_info != NULL);
  if (history_size == 0)
  {
    pol_info->cut_depth = (GtUword) 15;
  } else
  {
    pol_info->cut_depth = GT_MIN(history_size/2,(GtUword) 15);
  }
  pol_info->pol_size = 2 * pol_info->cut_depth;
  pol_info->entries = 1UL << pol_info->cut_depth;
  pol_info->mask = pol_info->entries - 1;
  pol_info->values = gt_malloc(sizeof *pol_info->values * pol_info->entries);
  gt_assert(pol_info->values != NULL);
  pol_info->match_score = 20.0 * errorpercentage * matchscore_bias;
  gt_assert(pol_info->match_score <= 1000.0);
  pol_info->difference_score = 1000.0 - pol_info->match_score;
  fill_polishing_info(pol_info,0,0,0,0);
  return pol_info;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, 0x10(%rsp)
leaq 0x1ea277(%rip), %rsi    # 0x346fa8
pushq $0x38
popq %rdi
pushq $0x29
popq %rdx
callq 0x93160
testq %rax, %rax
je 0x15cdfb
movq %rax, %rbx
movq %r14, %rcx
shrq %rcx
pushq $0xf
popq %rax
cmpq %rax, %rcx
cmovaeq %rax, %rcx
testq %r14, %r14
cmoveq %rax, %rcx
movq %rcx, 0x8(%rbx)
leal (%rcx,%rcx), %eax
movq %rax, 0x10(%rbx)
pushq $0x1
popq %rax
shlq %cl, %rax
movq %rax, (%rbx)
decq %rax
movq %rax, 0x18(%rbx)
pushq $0x4
popq %rdi
shlq %cl, %rdi
leaq 0x1ea221(%rip), %rsi    # 0x346fa8
pushq $0x36
popq %rdx
callq 0x93160
movq %rax, 0x30(%rbx)
testq %rax, %rax
je 0x15ce25
movsd 0x10(%rsp), %xmm0
mulsd 0x1ea1f6(%rip), %xmm0   # 0x346fa0
mulsd 0x8(%rsp), %xmm0
cvttsd2si %xmm0, %rax
movq %rax, 0x28(%rbx)
cmpq $0x3e9, %rax            # imm = 0x3E9
jge 0x15ce4f
cvtsi2sd %rax, %xmm0
movsd 0x1c78e6(%rip), %xmm1   # 0x3246b8
subsd %xmm0, %xmm1
cvttsd2si %xmm1, %rax
movq %rax, 0x20(%rbx)
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x15ce85
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq 0x2db166(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x188207(%rip), %rsi    # 0x2e5013
leaq 0x1ed35b(%rip), %rdx    # 0x34a16e
leaq 0x1ea1a4(%rip), %rcx    # 0x346fbe
leaq 0x1ea187(%rip), %r8     # 0x346fa8
pushq $0x2b
jmp 0x15ce77
movq 0x2db13c(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1881dd(%rip), %rsi    # 0x2e5013
leaq 0x1ea19e(%rip), %rdx    # 0x346fdb
leaq 0x1ea17a(%rip), %rcx    # 0x346fbe
leaq 0x1ea15d(%rip), %r8     # 0x346fa8
pushq $0x37
jmp 0x15ce77
movq 0x2db112(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1881b3(%rip), %rsi    # 0x2e5013
leaq 0x1ea18d(%rip), %rdx    # 0x346ff4
leaq 0x1ea150(%rip), %rcx    # 0x346fbe
leaq 0x1ea133(%rip), %r8     # 0x346fa8
pushq $0x39
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/ft-polish.c
// Function: fill_polishing_info
static void fill_polishing_info(GtFtPolishing_info *pol_info,
                                GtUword currentdepth,
                                GtUword prefix, GtWord score, GtWord maxscore)
{
  gt_assert(currentdepth <= pol_info->cut_depth);
  if (currentdepth == pol_info->cut_depth)
  {
    gt_assert(prefix < pol_info->entries && score >= INT16_MIN + maxscore);
    pol_info->values[prefix].diff_from_max = (int16_t) (score - maxscore);
    pol_info->values[prefix].score_sum = (int16_t) score;
  } else
  {
    if (score > maxscore)
    {
      maxscore = score;
    }
    gt_assert(score >= INT16_MIN - pol_info->difference_score);
    fill_polishing_info(pol_info,currentdepth+1, prefix << 1,
                        score - pol_info->difference_score,maxscore);
    gt_assert(score <= INT16_MAX - pol_info->match_score);
    fill_polishing_info(pol_info,currentdepth+1,(prefix << 1) | 1UL,
                        score + pol_info->match_score,maxscore);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r15
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %r12
movq 0x8(%r12), %rax
cmpq %r13, %rax
jb 0x15cf41
je 0x15cf08
cmpq %r15, %rbx
cmovgq %rbx, %r15
movq 0x20(%r12), %rax
movq $-0x8000, %rcx          # imm = 0x8000
subq %rax, %rcx
cmpq %rbx, %rcx
jg 0x15cf6b
incq %r13
addq %r14, %r14
movq %rbx, %rcx
subq %rax, %rcx
movq %r12, %rdi
movq %r13, %rsi
movq %r14, %rdx
movq %r15, %r8
callq 0x15ce85
movq 0x28(%r12), %rax
movl $0x7fff, %ecx           # imm = 0x7FFF
subq %rax, %rcx
cmpq %rbx, %rcx
jl 0x15cf95
orq $0x1, %r14
addq %rax, %rbx
jmp 0x15ce9d
cmpq %r14, (%r12)
jbe 0x15cfcb
leaq -0x8000(%r15), %rax
cmpq %rbx, %rax
jg 0x15cfcb
movl %ebx, %eax
subl %r15d, %eax
movq 0x30(%r12), %rcx
movw %ax, 0x2(%rcx,%r14,4)
movw %bx, (%rcx,%r14,4)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x2db020(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1880c1(%rip), %rsi    # 0x2e5013
leaq 0x1ea13f(%rip), %rdx    # 0x347098
leaq 0x1ea15c(%rip), %rcx    # 0x3470bc
leaq 0x1ea041(%rip), %r8     # 0x346fa8
pushq $0x10
jmp 0x15cfbd
movq 0x2daff6(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x188097(%rip), %rsi    # 0x2e5013
leaq 0x1ea189(%rip), %rdx    # 0x34710c
leaq 0x1ea132(%rip), %rcx    # 0x3470bc
leaq 0x1ea017(%rip), %r8     # 0x346fa8
pushq $0x1c
jmp 0x15cfbd
movq 0x2dafcc(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x18806d(%rip), %rsi    # 0x2e5013
leaq 0x1ea18f(%rip), %rdx    # 0x34713c
leaq 0x1ea108(%rip), %rcx    # 0x3470bc
leaq 0x1e9fed(%rip), %r8     # 0x346fa8
pushq $0x1f
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
movq 0x2daf96(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x188037(%rip), %rsi    # 0x2e5013
leaq 0x1ea0ed(%rip), %rdx    # 0x3470d0
leaq 0x1ea0d2(%rip), %rcx    # 0x3470bc
leaq 0x1e9fb7(%rip), %r8     # 0x346fa8
pushq $0x13
jmp 0x15cfbd
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/ft-polish.c
// Function: polishing_info_show
void polishing_info_show(const GtFtPolishing_info *pol_info)
{
  GtUword idx;

  printf("pi->cut_depth=" GT_WU "\n",pol_info->cut_depth);
  printf("pi->entries=" GT_WU "\n",pol_info->entries);
  printf("pi->match_score=" GT_WD "\n",pol_info->match_score);
  printf("pi->difference_score=" GT_WD "\n",pol_info->difference_score);
  printf("pi->mask=%s\n",
         polish_intbits2string(pol_info->cut_depth,pol_info->mask));
  for (idx = 0; idx < pol_info->entries; idx++)
  {
    printf("[%s]=%+hd/%+hd\n",polish_intbits2string(pol_info->cut_depth,idx),
                              pol_info->values[idx].score_sum,
                              pol_info->values[idx].diff_from_max);
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
leaq 0x1e9fed(%rip), %rdi    # 0x347014
xorl %eax, %eax
callq 0x17070
movq (%rbx), %rsi
leaq 0x1e9fef(%rip), %rdi    # 0x347027
xorl %eax, %eax
callq 0x17070
movq 0x28(%rbx), %rsi
leaq 0x1e9fee(%rip), %rdi    # 0x347038
xorl %eax, %eax
callq 0x17070
movq 0x20(%rbx), %rsi
leaq 0x1e9ff1(%rip), %rdi    # 0x34704d
xorl %eax, %eax
callq 0x17070
movq 0x8(%rbx), %rdi
movq 0x18(%rbx), %rsi
callq 0x15d0d0
leaq 0x1e9ff0(%rip), %rdi    # 0x347067
leaq 0x2e0852(%rip), %r14    # 0x43d8d0
movq %r14, %rsi
xorl %eax, %eax
callq 0x17070
leaq 0x1e9fe5(%rip), %r15    # 0x347074
xorl %r12d, %r12d
cmpq (%rbx), %r12
jae 0x15d0c4
movq 0x8(%rbx), %rdi
movq %r12, %rsi
callq 0x15d0d0
movq 0x30(%rbx), %rax
movswl (%rax,%r12,4), %edx
movswl 0x2(%rax,%r12,4), %ecx
movq %r15, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x17070
incq %r12
jmp 0x15d092
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/ft-polish.c
// Function: polish_intbits2string
static char *polish_intbits2string(GtUword bits,GtUword bs)
{
  char *csptr;
  GtUword mask;
  static char cs[64+1];

  gt_assert(bits > 0 && bits <= sizeof (GtUword) * CHAR_BIT);
  for (csptr = cs, mask = ((GtUword) 1) << (bits-1); mask > 0;
       mask >>= 1, csptr++)
  {
     *csptr = (bs & mask) ? '1' : '0';
  }
  *csptr = '\0';
  return cs;
}

// Assembly:
pushq %rax
decq %rdi
cmpq $0x40, %rdi
jae 0x15d106
pushq $0x1
popq %rax
movl %edi, %ecx
shlq %cl, %rax
leaq 0x2e07e7(%rip), %rcx    # 0x43d8d0
testq %rax, %rax
je 0x15d101
testq %rsi, %rax
sete %dl
xorb $0x31, %dl
movb %dl, (%rcx)
shrq %rax
incq %rcx
jmp 0x15d0e9
movb $0x0, (%rcx)
popq %rax
retq
movq 0x2dae5b(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x187efc(%rip), %rsi    # 0x2e5013
leaq 0x1ea049(%rip), %rdx    # 0x347167
leaq 0x1ea072(%rip), %rcx    # 0x347197
leaq 0x1e9e7c(%rip), %r8     # 0x346fa8
pushq $0x50
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/ft-polish.c
// Function: history_is_polished_brute_force
bool history_is_polished_brute_force(const GtFtPolishing_info *pol_info,
                                     uint64_t matchhistory,
                                     bool withoutput)
{
  GtUword idx;
  uint64_t mask;
  GtWord sum_score = 0;

  for (mask = (uint64_t) 1, idx = 0; idx < 2 * pol_info->cut_depth;
       idx++, mask <<= 1)
  {
    if (matchhistory & mask)
    {
      sum_score += pol_info->match_score;
    } else
    {
      sum_score -= pol_info->difference_score;
    }
    if (withoutput)
    {
      printf(GT_WU ": sum_score=" GT_WD "\n",idx,sum_score);
    }
    if (sum_score < 0)
    {
      return false;
    }
  }
  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r14d
movq %rsi, %r15
pushq $0x1
popq %r13
xorl %r12d, %r12d
xorl %ebp, %ebp
movq %rdi, (%rsp)
movq 0x8(%rdi), %rbx
addq %rbx, %rbx
cmpq %rbx, %r12
jae 0x15d1d7
testq %r15, %r13
je 0x15d1a9
addq 0x28(%rdi), %rbp
jmp 0x15d1ad
subq 0x20(%rdi), %rbp
testb %r14b, %r14b
je 0x15d1ca
leaq 0x1e9ecb(%rip), %rdi    # 0x347084
movq %r12, %rsi
movq %rbp, %rdx
xorl %eax, %eax
callq 0x17070
movq (%rsp), %rdi
testq %rbp, %rbp
js 0x15d1d7
incq %r12
addq %r13, %r13
jmp 0x15d192
cmpq %rbx, %r12
setae %al
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/ft-trimstat.c
// Function: gt_ft_trimstat_new
GtFtTrimstat *gt_ft_trimstat_new(void)
{
  GtFtTrimstat *trimstat = gt_malloc(sizeof *trimstat);

  gt_assert(trimstat != 0);
  trimstat->trim_dist = gt_calloc(101,sizeof *trimstat->trim_dist);
  gt_assert(trimstat->trim_dist != NULL);
  trimstat->matchlength_dist = gt_calloc(101,
                                         sizeof *trimstat->matchlength_dist);
  gt_assert(trimstat->matchlength_dist != NULL);
  trimstat->diedout = 0;
  GT_INITARRAY(&trimstat->distance_dist,GtUword);
  GT_INITARRAY(&trimstat->maxvalid_dist,GtUword);
  trimstat->spaceforfront_total = 0;
  trimstat->sum_meanvalid = 0.0;
  return trimstat;
}

// Assembly:
pushq %rbx
leaq 0x1e9fc4(%rip), %rsi    # 0x3471b8
pushq $0x58
popq %rdi
pushq $0x11
popq %rdx
callq 0x93160
testq %rax, %rax
je 0x15d25f
movq %rax, %rbx
leaq 0x1e9faa(%rip), %rdx    # 0x3471b8
pushq $0x65
popq %rdi
pushq $0x8
popq %rsi
pushq $0x14
popq %rcx
callq 0x9334a
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x15d289
leaq 0x1e9f8c(%rip), %rdx    # 0x3471b8
pushq $0x65
popq %rdi
pushq $0x8
popq %rsi
pushq $0x17
popq %rcx
callq 0x9334a
movq %rax, 0x10(%rbx)
testq %rax, %rax
je 0x15d2b3
andq $0x0, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rbx)
movups %xmm0, 0x28(%rbx)
movups %xmm0, 0x38(%rbx)
movups %xmm0, 0x48(%rbx)
movq %rbx, %rax
popq %rbx
retq
movq 0x2dad02(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x187da3(%rip), %rsi    # 0x2e5013
leaq 0x1e9f59(%rip), %rdx    # 0x3471d0
leaq 0x1e9f60(%rip), %rcx    # 0x3471de
leaq 0x1e9f33(%rip), %r8     # 0x3471b8
pushq $0x13
jmp 0x15d2db
movq 0x2dacd8(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x187d79(%rip), %rsi    # 0x2e5013
leaq 0x1e9f50(%rip), %rdx    # 0x3471f1
leaq 0x1e9f36(%rip), %rcx    # 0x3471de
leaq 0x1e9f09(%rip), %r8     # 0x3471b8
pushq $0x15
jmp 0x15d2db
movq 0x2dacae(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x187d4f(%rip), %rsi    # 0x2e5013
leaq 0x1e9fae(%rip), %rdx    # 0x347279
leaq 0x1e9f0c(%rip), %rcx    # 0x3471de
leaq 0x1e9edf(%rip), %r8     # 0x3471b8
pushq $0x18
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/ft-trimstat.c
// Function: gt_ft_trimstat_delete
void gt_ft_trimstat_delete(GtFtTrimstat *trimstat)
{
  if (trimstat != NULL)
  {
    gt_free(trimstat->trim_dist);
    GT_FREEARRAY(&trimstat->distance_dist,GtUword);
    GT_FREEARRAY(&trimstat->maxvalid_dist,GtUword);
    gt_free(trimstat->matchlength_dist);
    gt_free(trimstat);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x15d664
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
leaq 0x1e9be1(%rip), %rsi    # 0x3471b8
movl $0x81, %edx
callq 0x936f9
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x15d60b
leaq 0x18(%rbx), %r14
leaq 0x1e9bc3(%rip), %rsi    # 0x3471b8
movl $0x82, %edx
callq 0x936f9
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
andq $0x0, 0x10(%r14)
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x15d635
leaq 0x30(%rbx), %r14
leaq 0x1e9b99(%rip), %rsi    # 0x3471b8
movl $0x83, %edx
callq 0x936f9
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
andq $0x0, 0x10(%r14)
movq 0x10(%rbx), %rdi
leaq 0x1e9b78(%rip), %r14    # 0x3471b8
movq %r14, %rsi
movl $0x84, %edx
callq 0x936f9
movq %rbx, %rdi
movq %r14, %rsi
movl $0x85, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/gfa_writer.c
// Function: gt_gfa_writer_new
GtGfaWriter* gt_gfa_writer_new(GtFile *file,
                               const GtEncseq *encseq,
                               GtGfaVersion version)
{
  GtGfaWriter *gw;
  gw = gt_malloc(sizeof (*gw));
  gw->file = gt_file_ref(file);
  gw->encseq = gt_encseq_ref((GtEncseq*)encseq);
  gw->version = version;
  return gw;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x1e9a4d(%rip), %rsi    # 0x34739c
pushq $0x18
popq %rdi
pushq $0x22
popq %rdx
callq 0x93160
movq %rax, %r12
movq %r15, %rdi
callq 0x8d073
movq %rax, (%r12)
movq %r14, %rdi
callq 0x73cbe
movq %rax, 0x8(%r12)
movl %ebx, 0x10(%r12)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/gfa_writer.c
// Function: gt_gfa_writer_show_header
int gt_gfa_writer_show_header(GtGfaWriter *gw,
    GtUword minlen, const char *inputfilename, bool has_containments,
    bool has_transitives, GT_UNUSED GtError *err)
{
  gt_assert(gw != NULL);
  gt_file_xprintf(gw->file,
      "H\tVN:Z:%s\n"
      "H\tpn:Z:readjoiner\n"
      "H\tol:i:"GT_WU"\n"
      "H\tin:Z:%s\n"
      "H\tcn:i:%c\n"
      "H\tte:i:%c\n",
      gt_gfa_writer_versionstr(gw->version),
      minlen,
      inputfilename,
      has_containments ? '1' : '0',
      has_transitives ? '1' : '0');
  return 0;
}

// Assembly:
pushq %rax
testq %rdi, %rdi
je 0x15d9e2
movq %rdx, %rax
movq %rsi, %r10
movq %rdi, %rdx
movq (%rdi), %rdi
movl 0x10(%rdx), %edx
testl %edx, %edx
je 0x15d9b1
cmpl $0x1, %edx
jne 0x15da0c
leaq 0x195e65(%rip), %rdx    # 0x2f3814
jmp 0x15d9b8
leaq 0x195e4a(%rip), %rdx    # 0x2f3802
movzbl %cl, %r9d
orl $0x30, %r9d
movzbl %r8b, %ecx
orl $0x30, %ecx
movl %ecx, (%rsp)
leaq 0x1e9a07(%rip), %rsi    # 0x3473d8
movq %r10, %rcx
movq %rax, %r8
xorl %eax, %eax
callq 0x8d432
xorl %eax, %eax
popq %rcx
retq
movq 0x2da57f(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x187620(%rip), %rsi    # 0x2e5013
leaq 0x1e99b9(%rip), %rdx    # 0x3473b3
leaq 0x1e99bd(%rip), %rcx    # 0x3473be
leaq 0x1e9994(%rip), %r8     # 0x34739c
pushq $0x3a
jmp 0x15da34
movq 0x2da555(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1875f6(%rip), %rsi    # 0x2e5013
leaq 0x1c8fc8(%rip), %rdx    # 0x3269ec
leaq 0x1e99f3(%rip), %rcx    # 0x34741e
leaq 0x1e996a(%rip), %r8     # 0x34739c
pushq $0x31
popq %r9
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/gfa_writer.c
// Function: gt_spmproc_show_gfa
void gt_spmproc_show_gfa(GtUword suffix_readnum,
    GtUword prefix_readnum, GtUword length,
    bool suffixseq_direct, bool prefixseq_direct, void *gfa_writer)
{
  GtGfaWriter *gw = gfa_writer;
  const GtUword sl1 = gt_encseq_seqlength(gw->encseq, suffix_readnum),
                sl2 = gt_encseq_seqlength(gw->encseq, prefix_readnum);
  gt_gfa_writer_show_edge(gw->version, gw->file,
      suffix_readnum, suffixseq_direct,
      prefix_readnum, prefixseq_direct,
      suffixseq_direct ? sl1 - length : 0,
      suffixseq_direct ? sl1 : length,
      suffixseq_direct,
      prefixseq_direct ? 0 : sl2 - length,
      prefixseq_direct ? length : sl2,
      !prefixseq_direct,
      length);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movl %r8d, %ebp
movl %ecx, %r13d
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rsi
movq 0x8(%r9), %rdi
movq %rsi, (%rsp)
callq 0x75173
movq %rax, %rbx
movq 0x8(%r14), %rdi
movq %r15, %rsi
callq 0x75173
movq %rax, %r10
movl 0x10(%r14), %eax
movq (%r14), %rdi
cmpl $0x1, %eax
je 0x15dcb6
movq (%rsp), %rdx
testl %eax, %eax
jne 0x15dd42
xorb $0x1, %r13b
movzbl %r13b, %eax
leal 0x2b(,%rax,2), %ecx
xorb $0x1, %bpl
movzbl %bpl, %eax
leal 0x2b(,%rax,2), %r9d
subq $0x8, %rsp
leaq 0x1e97e1(%rip), %rsi    # 0x347482
movq %r15, %r8
xorl %eax, %eax
pushq %r12
callq 0x8d432
addq $0x18, %rsp
jmp 0x15dd37
movq %r10, %r14
subq %r12, %r14
movq %rbx, %r11
subq %r12, %r11
movl %r13d, %eax
xorb $0x1, %al
movl %ebp, %edx
xorb $0x1, %dl
xorl %ecx, %ecx
testb %r13b, %r13b
cmoveq %r12, %rbx
cmoveq %rcx, %r11
movq %r15, %r8
leaq 0x1af7c4(%rip), %r15    # 0x30d4a7
leaq 0x20c886(%rip), %rsi    # 0x36a570
movq %rsi, %r13
cmovneq %r15, %r13
testb %bpl, %bpl
cmovneq %r12, %r10
cmovneq %rcx, %r14
movzbl %al, %eax
leal 0x2b(%rax,%rax), %ecx
movzbl %dl, %eax
leal 0x2b(%rax,%rax), %r9d
cmovneq %rsi, %r15
subq $0x8, %rsp
leaq 0x1e977e(%rip), %rsi    # 0x347498
movq 0x8(%rsp), %rdx
xorl %eax, %eax
pushq %r12
pushq %r15
pushq %r10
pushq %r14
pushq %r13
pushq %rbx
pushq %r11
callq 0x8d432
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x2da21f(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x1872c0(%rip), %rsi    # 0x2e5013
leaq 0x1c8c92(%rip), %rdx    # 0x3269ec
leaq 0x1e9709(%rip), %rcx    # 0x34746a
leaq 0x1e9634(%rip), %r8     # 0x34739c
movl $0xc7, %r9d
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/giextract.c
// Function: desc2key
static const char *desc2key(GtUword *keylen,const char *desc,
                            GtError *err)
{
  GtUword i, firstpipe = 0, secondpipe = 0;

  gt_error_check(err);
  for (i=0; desc[i] != '\0'; i++)
  {
    if (desc[i] == '|')
    {
      if (firstpipe > 0)
      {
        gt_assert(i>0);
        secondpipe = i;
        break;
      }
      gt_assert(i>0);
      firstpipe = i;
    }
  }
  if (firstpipe == 0 || secondpipe == 0)
  {
    gt_error_set(err,"Cannot find key in description \"%s\"",desc);
    return NULL;
  }
  gt_assert(firstpipe < secondpipe);
  *keylen = secondpipe - firstpipe - 1;
  return desc + firstpipe + 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0x15e3ed
movq %r15, %rdi
callq 0x89eb7
testb %al, %al
jne 0x15e494
xorl %eax, %eax
xorl %ecx, %ecx
movzbl (%rbx,%rax), %edx
cmpl $0x7c, %edx
je 0x15e400
testl %edx, %edx
jne 0x15e40d
jmp 0x15e412
testq %rcx, %rcx
jne 0x15e42b
movq %rax, %rcx
testq %rax, %rax
je 0x15e45c
incq %rax
jmp 0x15e3f1
leaq 0x1e92e9(%rip), %rsi    # 0x347702
xorl %r12d, %r12d
movq %r15, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x89dbb
jmp 0x15e44d
testq %rax, %rax
je 0x15e4c2
cmpq %rax, %rcx
jae 0x15e4f0
leaq (%rbx,%rcx), %r12
incq %r12
notq %rcx
addq %rax, %rcx
movq %rcx, (%r14)
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x2d9b05(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x186ba6(%rip), %rsi    # 0x2e5013
leaq 0x1e928a(%rip), %rdx    # 0x3476fe
leaq 0x1e927a(%rip), %rcx    # 0x3476f5
leaq 0x1e9040(%rip), %r8     # 0x3474c2
movl $0x17c, %r9d            # imm = 0x17C
xorl %eax, %eax
callq 0x17a50
callq 0x17390
movq 0x2d9acd(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x186b6e(%rip), %rsi    # 0x2e5013
leaq 0x186d13(%rip), %rdx    # 0x2e51bf
leaq 0x1e9242(%rip), %rcx    # 0x3476f5
leaq 0x1e9008(%rip), %r8     # 0x3474c2
movl $0x171, %r9d            # imm = 0x171
jmp 0x15e488
movq 0x2d9a9f(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x186b40(%rip), %rsi    # 0x2e5013
leaq 0x1e9224(%rip), %rdx    # 0x3476fe
leaq 0x1e9214(%rip), %rcx    # 0x3476f5
leaq 0x1e8fda(%rip), %r8     # 0x3474c2
movl $0x178, %r9d            # imm = 0x178
jmp 0x15e488
movq 0x2d9a71(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x186b12(%rip), %rsi    # 0x2e5013
leaq 0x1e921e(%rip), %rdx    # 0x347726
leaq 0x1e91e6(%rip), %rcx    # 0x3476f5
leaq 0x1e8fac(%rip), %r8     # 0x3474c2
movl $0x185, %r9d            # imm = 0x185
jmp 0x15e488
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/giextract.c
// Function: giextract_encodedseq2fasta
static int giextract_encodedseq2fasta(FILE *fpout,
                                      const GtEncseq *encseq,
                                      GtUword seqnum,
                                      const Fastakeyquery *fastakeyquery,
                                      GtUword linewidth,
                                      GT_UNUSED GtError *err)
{
  const char *desc;
  GtUword desclen;
  bool haserr = false;

  desc = gt_encseq_description(encseq, &desclen, seqnum);
  gt_xfputc('>',fpout);
  if (fastakeyquery != NULL && !COMPLETE(fastakeyquery))
  {
    printf("%s "GT_WU" "GT_WU" ",fastakeyquery->fastakey,
                         fastakeyquery->frompos,
                         fastakeyquery->topos);
  }
  gt_xfwrite(desc,sizeof *desc,(size_t) desclen,fpout);
  if (!haserr)
  {
    GtUword frompos, topos, seqstartpos, seqlength ;

    gt_xfputc('\n',fpout);
    seqstartpos = gt_encseq_seqstartpos(encseq, seqnum);
    seqlength = gt_encseq_seqlength(encseq, seqnum);
    if (fastakeyquery != NULL && !COMPLETE(fastakeyquery))
    {
      frompos = fastakeyquery->frompos-1;
      topos = fastakeyquery->topos - fastakeyquery->frompos + 1;
    } else
    {
      frompos = 0;
      topos = seqlength;
    }
    gt_encseq2symbolstring(fpout,
                           encseq,
                           GT_READMODE_FORWARD,
                           seqstartpos + frompos,
                           topos,
                           linewidth);
  }
  return haserr ? -1 : 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %r15
movq %rsp, %rsi
movq %r14, %rdi
callq 0x75b24
movq %rax, %rbp
pushq $0x3e
popq %rdi
movq %r15, %rsi
callq 0xb2f2e
testq %r12, %r12
je 0x15e586
movq 0x8(%r12), %rdx
movq 0x10(%r12), %rcx
movq %rdx, %rax
xorq $0x1, %rax
orq %rcx, %rax
je 0x15e586
movq (%r12), %rsi
leaq 0x1e91be(%rip), %rdi    # 0x34773d
xorl %eax, %eax
callq 0x17070
movq (%rsp), %rdx
pushq $0x1
popq %rsi
movq %rbp, %rdi
movq %r15, %rcx
callq 0xb302c
pushq $0xa
popq %rdi
movq %r15, %rsi
callq 0xb2f2e
movq %r14, %rdi
movq %r13, %rsi
callq 0x74d9c
movq %rax, %rbp
movq %r14, %rdi
movq %r13, %rsi
callq 0x75173
testq %r12, %r12
je 0x15e5d7
movq 0x8(%r12), %rcx
movq 0x10(%r12), %rdx
movq %rcx, %rsi
xorq $0x1, %rsi
orq %rdx, %rsi
jne 0x15e5db
xorl %ecx, %ecx
jmp 0x15e5e7
subq %rcx, %rdx
decq %rcx
incq %rdx
movq %rdx, %rax
addq %rbp, %rcx
movq %r15, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rax, %r8
movq %rbx, %r9
callq 0x142d1c
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/giextract.c
// Function: fastakeyqueries_delete
static void fastakeyqueries_delete(Fastakeyquery *fastakeyqueries,
                                   GtUword numofqueries)
{
  if (fastakeyqueries != NULL)
  {
    GtUword idx;

    for (idx=0; idx<numofqueries; idx++)
    {
      gt_free(fastakeyqueries[idx].fastakey);
    }
    gt_free(fastakeyqueries);
  }
}

// Assembly:
testq %rdi, %rdi
je 0x15f239
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1e82c8(%rip), %r15    # 0x3474c2
movq %rdi, %r12
subq $0x1, %r14
jb 0x15f21a
movq (%r12), %rdi
movq %r15, %rsi
movl $0x9f, %edx
callq 0x936f9
addq $0x20, %r12
jmp 0x15f1fd
leaq 0x1e82a1(%rip), %rsi    # 0x3474c2
movq %rbx, %rdi
movl $0xa1, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/giextract.c
// Function: comparefastakeys
static int comparefastakeys(const void *a,const void *b)
{
  int cmp = strcmp(((Fastakeyquery *) a)->fastakey,
                   ((Fastakeyquery *) b)->fastakey);

  if (cmp < 0)
  {
    return -1;
  }
  if (cmp > 0)
  {
    return 1;
  }
  if (((Fastakeyquery *) a)->frompos < ((Fastakeyquery *) b)->frompos)
  {
    return -1;
  }
  if (((Fastakeyquery *) a)->frompos > ((Fastakeyquery *) b)->frompos)
  {
    return 1;
  }
  if (((Fastakeyquery *) a)->topos < ((Fastakeyquery *) b)->topos)
  {
    return -1;
  }
  if (((Fastakeyquery *) a)->topos > ((Fastakeyquery *) b)->topos)
  {
    return 1;
  }
  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
movq (%rsi), %rsi
callq 0x179e0
pushq $-0x1
popq %rcx
testl %eax, %eax
jns 0x15f433
movl %ecx, %eax
jmp 0x15f438
pushq $0x1
popq %rax
je 0x15f440
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x8(%r14), %rdx
cmpq %rdx, 0x8(%rbx)
jb 0x15f42f
ja 0x15f438
movq 0x10(%r14), %rdx
movl %ecx, %eax
cmpq %rdx, 0x10(%rbx)
jb 0x15f438
seta %al
movzbl %al, %eax
jmp 0x15f438
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/greedyedist.c
// Function: gt_frontresource_new
GtFrontResource *gt_frontresource_new(GtUword maxdist)
{
  GtFrontResource *ftres = gt_malloc(sizeof *ftres);

  ftres->currentallocated = sumofoddnumbers(maxdist);
  ftres->frontspace = gt_malloc(sizeof *ftres->frontspace
                                * ftres->currentallocated);
  return ftres;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x1e8541(%rip), %r14    # 0x3479b0
pushq $0x28
popq %rdi
pushq $0x3c
popq %rdx
movq %r14, %rsi
callq 0x93160
movq %rax, %r15
imulq %rbx, %rbx
movq %rbx, (%rax)
shlq $0x3, %rbx
pushq $0x40
popq %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x93160
movq %rax, 0x20(%r15)
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/idx-limdfs.c
// Function: genericindex_delete
void genericindex_delete(Genericindex *genericindex)
{
  if (genericindex == NULL)
  {
    return;
  }
  gt_freesuffixarray(genericindex->suffixarray);
  gt_free(genericindex->suffixarray);
  if (genericindex->packedindex != NULL)
  {
    gt_deletevoidBWTSeq(genericindex->packedindex);
  }
  gt_free(genericindex);
}

// Assembly:
testq %rdi, %rdi
je 0x15fcac
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x14d148
movq (%rbx), %rdi
leaq 0x1e7e35(%rip), %rsi    # 0x347ab8
pushq $0x37
popq %rdx
callq 0x936f9
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x15fc99
callq 0x14b703
leaq 0x1e7e18(%rip), %rsi    # 0x347ab8
pushq $0x3c
popq %rdx
movq %rbx, %rdi
popq %rbx
jmp 0x936f9
retq
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/idx-limdfs.c
// Function: gt_freeLimdfsresources
void gt_freeLimdfsresources(Limdfsresources **ptrlimdfsresources,
                         const AbstractDfstransformer *adfst)
{
  Limdfsresources *limdfsresources = *ptrlimdfsresources;

  adfst->freedfsconstinfo(&limdfsresources->dfsconstinfo);
  GT_FREEARRAY(&limdfsresources->bwci,Boundswithchar);
  if (adfst->freeLimdfsstackelem != NULL)
  {
    GtUword idx;

    for (idx = 0; idx < limdfsresources->stack.allocatedLcpintervalwithinfo;
         idx++)
    {
      adfst->freeLimdfsstackelem(limdfsresources->stack.
                                 spaceLcpintervalwithinfo[idx].aliasstate);
    }
    if (!limdfsresources->keepexpandedonstack)
    {
      adfst->freeLimdfsstackelem(limdfsresources->copyofcopyofparentstate);
      adfst->freeLimdfsstackelem(limdfsresources->copyofparent.aliasstate);
    }
  }
  GT_FREEARRAY(&limdfsresources->stack,Lcpintervalwithinfo);
  gt_free(limdfsresources->rangeOccs);
  gt_free(limdfsresources->currentpathspace);
  GT_FREEARRAY(&limdfsresources->mstatspos,GtUword);
  gt_free(*ptrlimdfsresources);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
movq (%rdi), %r14
movq %r14, %rdi
callq *0x20(%rsi)
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x160120
leaq 0x8(%r14), %r12
leaq 0x1e79b0(%rip), %rsi    # 0x347ab8
movl $0x17f, %edx            # imm = 0x17F
callq 0x936f9
xorps %xmm0, %xmm0
movups %xmm0, (%r12)
andq $0x0, 0x10(%r12)
cmpq $0x0, 0x38(%r15)
je 0x160165
pushq $0x28
popq %r12
xorl %r13d, %r13d
cmpq 0x28(%r14), %r13
jae 0x160148
movq 0x20(%r14), %rdi
addq %r12, %rdi
callq *0x38(%r15)
incq %r13
addq $0x60, %r12
jmp 0x16012e
cmpb $0x0, 0xc8(%r14)
jne 0x160165
leaq 0x98(%r14), %rdi
callq *0x38(%r15)
leaq 0x60(%r14), %rdi
callq *0x38(%r15)
movq 0x20(%r14), %rdi
testq %rdi, %rdi
je 0x16018f
leaq 0x20(%r14), %r15
leaq 0x1e793f(%rip), %rsi    # 0x347ab8
movl $0x190, %edx            # imm = 0x190
callq 0x936f9
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
andq $0x0, 0x10(%r15)
movq 0xf0(%r14), %rdi
leaq 0x1e791b(%rip), %r15    # 0x347ab8
movq %r15, %rsi
movl $0x191, %edx            # imm = 0x191
callq 0x936f9
movq 0x118(%r14), %rdi
movq %r15, %rsi
movl $0x192, %edx            # imm = 0x192
callq 0x936f9
movq 0x100(%r14), %rdi
testq %rdi, %rdi
je 0x1601ee
addq $0x100, %r14            # imm = 0x100
leaq 0x1e78e0(%rip), %rsi    # 0x347ab8
movl $0x193, %edx            # imm = 0x193
callq 0x936f9
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
andq $0x0, 0x10(%r14)
movq (%rbx), %rdi
leaq 0x1e78c0(%rip), %rsi    # 0x347ab8
movl $0x194, %edx            # imm = 0x194
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x936f9
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/idx-limdfs.c
// Function: gt_fromitv2sortedmatchpositions
GtArrayGtUword *gt_fromitv2sortedmatchpositions(
                                             Limdfsresources *limdfsresources,
                                             GtUword leftbound,
                                             GtUword rightbound,
                                             GtUword offset)
{
  Indexbounds itv;
  GtIdxMatch match;

  gt_assert(limdfsresources != NULL &&
            limdfsresources->genericindex != NULL);
  limdfsresources->mstatspos.nextfreeGtUword = 0;
  itv.leftbound = leftbound;
  itv.rightbound = rightbound;
  itv.offset = offset;
  match.dbabsolute = true;
  match.dblen = itv.offset;
  match.dbsubstring = limdfsresources->currentpathspace;
  match.querystartpos = 0;
  match.querylen = offset;
  match.distance = 0;
  match.alignment = NULL;
  (limdfsresources->genericindex->withesa
       ? gen_esa_overinterval
       : gen_pck_overinterval)
    (limdfsresources->genericindex,
     storemstatsposition,
     &limdfsresources->mstatspos,
     &itv,
     limdfsresources->genericindex->totallength,
     &match);
  qsort(limdfsresources->mstatspos.spaceGtUword,
        (size_t) limdfsresources->mstatspos.nextfreeGtUword,
        sizeof (GtUword), comparepositions);
  if (limdfsresources->genericindex->withesa)
  {
    limdfsresources->numberofmatches += (rightbound - leftbound + 1);
  } else
  {
    limdfsresources->numberofmatches += (rightbound - leftbound);
  }
  return &limdfsresources->mstatspos;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x78, %rsp
testq %rdi, %rdi
je 0x160306
movq %rdi, %r14
movq 0xd8(%rdi), %rdi
testq %rdi, %rdi
je 0x160306
movq %rdx, %rbx
movq %rsi, %r15
andq $0x0, 0x110(%r14)
leaq 0x8(%rsp), %rax
movq %rsi, 0x8(%rax)
movq %rdx, 0x10(%rax)
movq %rcx, (%rax)
leaq 0x30(%rsp), %r9
movb $0x1, (%r9)
movq %rcx, 0x18(%r9)
movq 0x118(%r14), %rdx
movq %rdx, 0x20(%r9)
andq $0x0, 0x28(%r9)
leaq 0x100(%r14), %r12
movq %rcx, 0x30(%r9)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%r9)
leaq 0xb7(%rip), %rcx        # 0x16033e
cmpb $0x0, 0x18(%rdi)
leaq 0xfd(%rip), %r10        # 0x16038f
cmovneq %rcx, %r10
movq 0x8(%rdi), %r8
leaq 0x1cf(%rip), %rsi       # 0x160470
movq %r12, %rdx
movq %rax, %rcx
callq *%r10
movq 0x100(%r14), %rdi
movq 0x110(%r14), %rsi
leaq 0x24a(%rip), %rcx       # 0x160509
pushq $0x8
popq %rdx
callq 0x17ed0
movq 0xd8(%r14), %rax
cmpb $0x1, 0x18(%rax)
jne 0x1602ed
movq 0x128(%r14), %rax
subq %r15, %rbx
addq %rbx, %rax
incq %rax
movq %rax, 0x128(%r14)
jmp 0x1602f7
subq %r15, %rbx
addq %rbx, 0x128(%r14)
movq %r12, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x2d7c5b(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x184cfc(%rip), %rsi    # 0x2e5013
leaq 0x1e78f6(%rip), %rdx    # 0x347c14
leaq 0x1e7930(%rip), %rcx    # 0x347c55
leaq 0x1e778c(%rip), %r8     # 0x347ab8
movl $0x1f5, %r9d            # imm = 0x1F5
xorl %eax, %eax
callq 0x17a50
callq 0x17390
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/idx-limdfs.c
// Function: gen_esa_overinterval
static void gen_esa_overinterval(const Genericindex *genericindex,
                                 ProcessIdxMatch processmatch,
                                 void *processmatchinfo,
                                 const Indexbounds *itv,
                                 GT_UNUSED GtUword totallength,
                                 GtIdxMatch *match)
{
  GtUword idx;

  for (idx = itv->leftbound; idx <= itv->rightbound; idx++)
  {
    match->dbstartpos = ESASUFFIXPTRGET(genericindex->suffixarray->suftab,idx);
    /* call processmatch */
    processmatch(processmatchinfo,match);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
movq 0x8(%rcx), %rbp
cmpq 0x10(%r14), %rbp
ja 0x160380
movq (%r13), %rax
movq 0x58(%rax), %rax
movq (%rax,%rbp,8), %rax
movq %rax, 0x10(%rbx)
movq %r15, %rdi
movq %rbx, %rsi
callq *%r12
incq %rbp
jmp 0x16035c
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/idx-limdfs.c
// Function: gen_pck_overinterval
static void gen_pck_overinterval(const Genericindex *genericindex,
                                 ProcessIdxMatch processmatch,
                                 void *processmatchinfo,
                                 const Indexbounds *itv,
                                 GtUword totallength,
                                 GtIdxMatch *match)
{
  Bwtseqpositioniterator *bspi;
  GtUword dbstartpos;

  gt_assert(itv->leftbound < itv->rightbound);
  bspi = gt_Bwtseqpositioniterator_new(genericindex->packedindex,
                                       itv->leftbound,itv->rightbound);
  while (gt_Bwtseqpositioniterator_next(&dbstartpos,bspi))
  {
    gt_assert(totallength >= (dbstartpos + itv->offset));
    /* call processmatch */
    match->dbstartpos = totallength - (dbstartpos + itv->offset);
    processmatch(processmatchinfo,match);
  }
  gt_Bwtseqpositioniterator_delete(bspi);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r13
movq 0x8(%rcx), %rsi
movq 0x10(%rcx), %rdx
cmpq %rdx, %rsi
jae 0x160442
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq 0x10(%rdi), %rdi
callq 0x14afc8
movq %rax, %rbp
movq %rsp, %rdi
movq %rbp, %rsi
callq 0x14b00d
testb %al, %al
je 0x1603f3
movq (%r15), %rcx
addq (%rsp), %rcx
movq %r14, %rax
subq %rcx, %rax
jb 0x16040a
movq %rax, 0x10(%rbx)
movq %r12, %rdi
movq %rbx, %rsi
callq *%r13
jmp 0x1603c6
movq %rbp, %rdi
callq 0x14b161
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x2d7b57(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x184bf8(%rip), %rsi    # 0x2e5013
leaq 0x1e794d(%rip), %rdx    # 0x347d6f
leaq 0x1e7931(%rip), %rcx    # 0x347d5a
leaq 0x1e7688(%rip), %r8     # 0x347ab8
movl $0x1c6, %r9d            # imm = 0x1C6
xorl %eax, %eax
callq 0x17a50
callq 0x17390
movq 0x2d7b1f(%rip), %rax    # 0x437f68
movq (%rax), %rdi
leaq 0x184bc0(%rip), %rsi    # 0x2e5013
leaq 0x1e78df(%rip), %rdx    # 0x347d39
leaq 0x1e78f9(%rip), %rcx    # 0x347d5a
leaq 0x1e7650(%rip), %r8     # 0x347ab8
movl $0x1c1, %r9d            # imm = 0x1C1
jmp 0x160436
// File: /workspace/github_c_makefile_star2_O2/genometools[P]genometools/src/match/idx-limdfs.c
// Function: genericmstats
GtUword genericmstats(const Limdfsresources *limdfsresources,
                            const GtUchar *qstart,
                            const GtUchar *qend)
{
  if (limdfsresources->genericindex->withesa)
  {
    return gt_suffixarraymstats (limdfsresources->genericindex->suffixarray,
                              0,
                              0,
                              limdfsresources->genericindex->totallength,
                              NULL,
                              qstart,
                              qend);
  }
  return gt_voidpackedindexmstatsforward(limdfsresources->genericindex->
                                                       packedindex,
                                      0,
                                      0,
                                      limdfsresources->genericindex->
                                                       totallength,
                                      NULL,
                                      qstart,
                                      qend);
}

// Assembly:
pushq %rax
movq %rsi, %r9
movq 0xd8(%rdi), %rax
cmpb $0x1, 0x18(%rax)
jne 0x1608c3
movq (%rax), %rdi
movq 0x8(%rax), %rcx
movq %rdx, (%rsp)
xorl %esi, %esi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x14f8a1
popq %rcx
retq
movq 0x8(%rax), %rcx
movq 0x10(%rax), %rdi
movq %rdx, (%rsp)
xorl %esi, %esi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x14bd8a
popq %rcx
retq