LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/kmercodes.h
// Function: gt_kmercode_at_position
static inline GtCodetype gt_kmercode_at_position(
                                   const GtTwobitencoding *twobitencoding,
                                   GtUword pos,
                                   unsigned int kmersize)
{
  const unsigned int unitoffset = (unsigned int) GT_MODBYUNITSIN2BITENC(pos);
  const GtUword unitindex = GT_DIVBYUNITSIN2BITENC(pos);
  const GtCodetype maskright = GT_MASKRIGHT(kmersize);

  if (unitoffset <= (unsigned int) GT_UNITSIN2BITENC - kmersize)
  {
    return (GtCodetype) (twobitencoding[unitindex]
            >> GT_MULT2(GT_UNITSIN2BITENC - kmersize - unitoffset))
           & maskright;
  } else
  {
    unsigned int shiftleft = GT_MULT2(unitoffset+kmersize-GT_UNITSIN2BITENC);
    return (GtCodetype)
           ((twobitencoding[unitindex] << shiftleft) |
            (twobitencoding[unitindex+1] >> (GT_MULT2(GT_UNITSIN2BITENC) -
                                             shiftleft)))
           & maskright;
  }
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movl %edx, -0x1c(%rsp)
movq -0x18(%rsp), %rax
andq $0x1f, %rax
movl %eax, -0x20(%rsp)
movq -0x18(%rsp), %rax
shrq $0x5, %rax
movq %rax, -0x28(%rsp)
movl $0x20, %eax
subl -0x1c(%rsp), %eax
shll %eax
movl %eax, %eax
movl %eax, %ecx
movq $-0x1, %rax
shrq %cl, %rax
movq %rax, -0x30(%rsp)
movl -0x20(%rsp), %eax
movl $0x20, %ecx
subl -0x1c(%rsp), %ecx
cmpl %ecx, %eax
ja 0x243726
movq -0x10(%rsp), %rax
movq -0x28(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl $0x20, %ecx
subl -0x1c(%rsp), %ecx
subl -0x20(%rsp), %ecx
shll %ecx
movl %ecx, %ecx
shrq %cl, %rax
andq -0x30(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x243779
movl -0x20(%rsp), %eax
addl -0x1c(%rsp), %eax
subl $0x20, %eax
shll %eax
movl %eax, -0x34(%rsp)
movq -0x10(%rsp), %rax
movq -0x28(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl -0x34(%rsp), %ecx
shlq %cl, %rax
movq -0x10(%rsp), %rcx
movq -0x28(%rsp), %rdx
movq 0x8(%rcx,%rdx,8), %rdx
movl $0x40, %ecx
subl -0x34(%rsp), %ecx
movl %ecx, %ecx
shrq %cl, %rdx
movq %rdx, %rcx
orq %rcx, %rax
andq -0x30(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/firstcodes.c
// Function: gt_firstcodes_find_insert
const GtUword *gt_firstcodes_find_insert(const GtFirstcodesinfo *fci,
                                               GtUword code)
{
  const GtUword *found = NULL, *leftptr = NULL, *midptr, *rightptr = NULL;

  leftptr = fci->allfirstcodes + fci->currentminindex;
  rightptr = fci->allfirstcodes + fci->currentmaxindex;
  while (leftptr <= rightptr)
  {
    midptr = leftptr + GT_DIV2((GtUword) (rightptr-leftptr));
    if (code < *midptr)
    {
      rightptr = midptr - 1;
      found = midptr;
    } else
    {
      if (code > *midptr)
      {
        leftptr = midptr + 1;
      } else
      {
        return midptr;
      }
    }
  }
  return found;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq $0x0, -0x20(%rsp)
movq $0x0, -0x28(%rsp)
movq $0x0, -0x38(%rsp)
movq -0x10(%rsp), %rax
movq 0x98(%rax), %rax
movq -0x10(%rsp), %rcx
movq 0x28(%rcx), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rsp)
movq -0x10(%rsp), %rax
movq 0x98(%rax), %rax
movq -0x10(%rsp), %rcx
movq 0x30(%rcx), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rsp)
movq -0x28(%rsp), %rax
cmpq -0x38(%rsp), %rax
ja 0x245f47
movq -0x28(%rsp), %rax
movq -0x38(%rsp), %rcx
movq -0x28(%rsp), %rdx
subq %rdx, %rcx
sarq $0x3, %rcx
shrq %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rsp)
movq -0x18(%rsp), %rax
movq -0x30(%rsp), %rcx
cmpq (%rcx), %rax
jae 0x245f15
movq -0x30(%rsp), %rax
addq $-0x8, %rax
movq %rax, -0x38(%rsp)
movq -0x30(%rsp), %rax
movq %rax, -0x20(%rsp)
jmp 0x245f42
movq -0x18(%rsp), %rax
movq -0x30(%rsp), %rcx
cmpq (%rcx), %rax
jbe 0x245f34
movq -0x30(%rsp), %rax
addq $0x8, %rax
movq %rax, -0x28(%rsp)
jmp 0x245f40
movq -0x30(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x245f51
jmp 0x245f42
jmp 0x245eb7
movq -0x20(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/firstcodes.c
// Function: gt_rungetencseqkmers
void gt_rungetencseqkmers(const GtEncseq *encseq,unsigned int kmersize)
{
  const GtReadmode readmode = GT_READMODE_FORWARD;

  getencseqkmers_twobitencoding(encseq,
                                readmode,
                                kmersize,
                                kmersize,
                                false,
                                NULL,
                                NULL,
                                NULL,
                                NULL);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %edx
movl 0x1c(%rsp), %ecx
xorl %r8d, %r8d
xorl %eax, %eax
movl %eax, %r9d
movl %r8d, %esi
movq $0x0, (%rsp)
movq $0x0, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
callq 0x2de9c0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/firstcodes.c
// Function: gt_firstcodes_restore_from_differences
static void gt_firstcodes_restore_from_differences(GtFirstcodesinfo *fci)
{
  GtUword idx;

  fci->allfirstcodes[0] = fci->allfirstcodes0_save;
  for (idx=1UL; idx < fci->differentcodes; idx++)
  {
    fci->allfirstcodes[idx]
      = (fci->allfirstcodes[idx] & fci->tab.differencemask)
        + fci->allfirstcodes[idx-1];
  }
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq 0xa0(%rax), %rcx
movq -0x8(%rsp), %rax
movq 0x98(%rax), %rax
movq %rcx, (%rax)
movq $0x1, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq -0x8(%rsp), %rcx
cmpq 0x38(%rcx), %rax
jae 0x2480b8
movq -0x8(%rsp), %rax
movq 0x98(%rax), %rax
movq -0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x8(%rsp), %rax
andq 0x168(%rax), %rdx
movq -0x8(%rsp), %rax
movq 0x98(%rax), %rax
movq -0x10(%rsp), %rcx
subq $0x1, %rcx
addq (%rax,%rcx,8), %rdx
movq -0x8(%rsp), %rax
movq 0x98(%rax), %rax
movq -0x10(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rsp)
jmp 0x248049
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/firstcodes.c
// Function: gt_firstcodes_map_sections
static void gt_firstcodes_map_sections(GtFirstcodesinfo *fci,
                                       GtSfxmappedrangelist *sfxmrlist)
{
  fci->mappedmarkprefix
    = gt_Sfxmappedrange_new("markprefix",
                            gt_marksubstring_entries(fci->buf.markprefix),
                            GtSfxGtBitsequence,
                            gt_minmax_index_kmercode2prefix,
                            fci);
  gt_Sfxmappedrangelist_add(sfxmrlist,fci->mappedmarkprefix);
  if (fci->differentcodes > 0)
  {
    fci->mappedallfirstcodes = gt_Sfxmappedrange_new("allfirstcodes",
                                                    fci->differentcodes,
                                                    GtSfxunsignedlong,
                                                    NULL,
                                                    NULL);
    gt_Sfxmappedrangelist_add(sfxmrlist,fci->mappedallfirstcodes);
    fci->mappedleftborder = gt_Sfxmappedrange_new("leftborder",
                                                 fci->differentcodes+1,
                                                 GtSfxuint32_t,
                                                 NULL,
                                                 NULL);
    gt_Sfxmappedrangelist_add(sfxmrlist,fci->mappedleftborder);
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0xd0(%rax), %rdi
callq 0x2611f0
movq %rax, %rsi
movq 0x10(%rsp), %r8
leaq 0x33041b(%rip), %rdi    # 0x578509
xorl %edx, %edx
leaq 0x19b9(%rip), %rcx      # 0x249ab0
callq 0x2cbb80
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x90(%rax)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x90(%rax), %rsi
callq 0x2ccb80
movq 0x10(%rsp), %rax
cmpq $0x0, 0x38(%rax)
jbe 0x2481c3
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rsi
leaq 0x2d3765(%rip), %rdi    # 0x51b8a6
movl $0x1, %edx
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rcx
callq 0x2cbb80
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x88(%rax)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x88(%rax), %rsi
callq 0x2ccb80
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rsi
addq $0x1, %rsi
leaq 0x2f8b78(%rip), %rdi    # 0x540d04
movl $0x2, %edx
xorl %eax, %eax
movl %eax, %r8d
movq %r8, %rcx
callq 0x2cbb80
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x80(%rax)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x80(%rax), %rsi
callq 0x2ccb80
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/firstcodes.c
// Function: gt_firstcodes_idx2code
static GtUword gt_firstcodes_idx2code(const GtFirstcodesinfo *fci,
                                            GtUword idx)
{
  gt_assert(idx <= fci->differentcodes);
  if (idx == fci->differentcodes)
  {
    return fci->allfirstcodes[idx-1];
  }
  return fci->allfirstcodes[idx];
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq 0x38(%rcx), %rax
jbe 0x248474
movq 0x3f3b5d(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2cdbc6(%rip), %rsi    # 0x516013
leaq 0x330373(%rip), %rdx    # 0x5787c7
leaq 0x330387(%rip), %rcx    # 0x5787e2
leaq 0x32fd9a(%rip), %r8     # 0x5781fc
movl $0x282, %r9d            # imm = 0x282
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x248476
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
cmpq 0x38(%rcx), %rax
jne 0x2484a4
movq 0x8(%rsp), %rax
movq 0x98(%rax), %rax
movq (%rsp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
jmp 0x2484bd
movq 0x8(%rsp), %rax
movq 0x98(%rax), %rax
movq (%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/firstcodes.c
// Function: gt_firstcodes_insertsuffixes_flush
static void gt_firstcodes_insertsuffixes_flush(void *data)
{
  GtFirstcodesinfo *fci = (GtFirstcodesinfo *) data;

  if (fci->buf.nextfree > 0)
  {
    const GtUword *ptr;

    gt_assert(fci->allfirstcodes != NULL);
    fci->codebuffer_total += fci->buf.nextfree;
    gt_radixsort_inplace_sort(fci->radixsort_codepos,fci->buf.nextfree);
    ptr = gt_firstcodes_find_insert(fci,fci->buf.spaceGtUwordPair[0].a);
    if (ptr != NULL)
    {
      fci->firstcodeposhits
        += gt_firstcodes_insertsuffixes_merge(fci,fci->buf.spaceGtUwordPair,
                                              ptr);
    }
    fci->flushcount++;
    fci->buf.nextfree = 0;
  }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq $0x0, 0xc0(%rax)
jbe 0x248910
jmp 0x248828
movq 0x8(%rsp), %rax
cmpq $0x0, 0x98(%rax)
jne 0x24886f
movq 0x3f3762(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2cd7cb(%rip), %rsi    # 0x516013
leaq 0x32fcd0(%rip), %rdx    # 0x57851f
leaq 0x330034(%rip), %rcx    # 0x57888a
leaq 0x32f99f(%rip), %r8     # 0x5781fc
movl $0xee, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x248871
movq 0x8(%rsp), %rax
movq 0xc0(%rax), %rcx
movq 0x8(%rsp), %rax
addq 0x20(%rax), %rcx
movq %rcx, 0x20(%rax)
movq 0x8(%rsp), %rax
movq 0x70(%rax), %rdi
movq 0x8(%rsp), %rax
movq 0xc0(%rax), %rsi
callq 0x101870
movq 0x8(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0xe8(%rax), %rax
movq (%rax), %rsi
callq 0x245e50
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x2488f2
movq 0x8(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0xe8(%rax), %rsi
movq (%rsp), %rdx
callq 0x249b90
movq %rax, %rcx
movq 0x8(%rsp), %rax
addq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
movl 0x50(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x50(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0xc0(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/firstcodes.c
// Function: gt_firstcodes_allocsize_for_insertion
static void gt_firstcodes_allocsize_for_insertion(GtFirstcodesinfo *fci,
                                                  GtUword maximumspace,
                                                  const GtSuftabparts
                                                    *suftabparts,
                                                  GtUword phase2extra)
{
  if (maximumspace > 0)
  {
    const GtUword maxrounds = 400UL;
    size_t used = gt_firstcodes_spacelog_workspace(fci->fcsl) +
                  phase2extra +
                  gt_suftabparts_largestsizemappedpartwise(suftabparts);

    if ((GtUword) used < maximumspace)
    {
      fci->buf.allocated = gt_radixsort_max_num_of_entries_ulongpair(
                                                (size_t) maximumspace - used);
    } else
    {
      fci->buf.allocated /= 4UL;
    }
    if ((GtUword) (fci->codebuffer_total+fci->numofsequences)/
                        fci->buf.allocated > maxrounds)
    {
      fci->buf.allocated
        = (fci->codebuffer_total+fci->numofsequences)/maxrounds;
    }
  } else
  {
    fci->buf.allocated /= 2UL;
  }
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
cmpq $0x0, 0x28(%rsp)
jbe 0x248a18
movq $0x190, 0x10(%rsp)      # imm = 0x190
movq 0x30(%rsp), %rax
movq 0xa8(%rax), %rdi
callq 0x4be8d0
addq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
callq 0x2ce3e0
movq %rax, %rcx
movq (%rsp), %rax
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x28(%rsp), %rax
jae 0x2489ac
movq 0x28(%rsp), %rdi
subq 0x8(%rsp), %rdi
callq 0x100d00
movq %rax, %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0xc8(%rax)
jmp 0x2489c3
movq 0x30(%rsp), %rax
movq 0xc8(%rax), %rcx
shrq $0x2, %rcx
movq %rcx, 0xc8(%rax)
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x30(%rsp), %rcx
addq 0x18(%rcx), %rax
movq 0x30(%rsp), %rcx
xorl %edx, %edx
divq 0xc8(%rcx)
cmpq $0x190, %rax            # imm = 0x190
jbe 0x248a16
movq 0x30(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x30(%rsp), %rcx
addq 0x18(%rcx), %rax
movl $0x190, %ecx            # imm = 0x190
xorl %edx, %edx
divq %rcx
movq %rax, %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0xc8(%rax)
jmp 0x248a2e
movq 0x30(%rsp), %rax
movq 0xc8(%rax), %rcx
shrq %rcx
movq %rcx, 0xc8(%rax)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/firstcodes.c
// Function: gt_kmercode2prefix_index
static GtUword gt_kmercode2prefix_index(GtUword idx,
                                              const void *data)
{
  const GtFirstcodesinfo *fci = (const GtFirstcodesinfo *) data;

  gt_assert(fci != NULL && idx < fci->differentcodes);
  return (GtUword) fci->allfirstcodes[idx]
            >> (GtUword) fci->shiftright2index;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x249b2d
movq 0x10(%rsp), %rax
movq (%rsp), %rcx
cmpq 0x38(%rcx), %rax
jb 0x249b65
movq 0x3f246c(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2cc4d5(%rip), %rsi    # 0x516013
leaq 0x32ec0a(%rip), %rdx    # 0x57874f
leaq 0x32ec2c(%rip), %rcx    # 0x578778
leaq 0x32e6a9(%rip), %r8     # 0x5781fc
movl $0x5a, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x249b67
movq (%rsp), %rax
movq 0x98(%rax), %rax
movq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rsp), %rcx
movl 0x54(%rcx), %ecx
shrq %cl, %rax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/firstcodes-tab.h
// Function: gt_firstcodes_insertionindex
GT_UNUSED
static inline GtUword gt_firstcodes_insertionindex(GtFirstcodestab *fct,
                                                         GtUword idx)
{
#if defined (_LP64) || defined (_WIN64)
  GT_CHANGEPOINT_GET(changepoint);
  gt_assert(idx < fct->differentcodes);
  if (fct->leftborder[idx] > 0)
  {
    return (GtUword) --fct->leftborder[idx]
                           + (changepoint << GT_MODVALUEBITS);
  } else
  {
    gt_assert(changepoint > 0);
    changepoint--;
    fct->bitchangepoints.spaceGtUword[changepoint]++;
    fct->leftborder[idx] = GT_MODVALUEMASK;
    return (GtUword)
           fct->leftborder[idx] + (changepoint << GT_MODVALUEBITS);
  }
#else
  gt_assert(idx < fct->differentcodes && fct->leftborder[idx] > 0);
  return (GtUword) --fct->leftborder[idx];
#endif
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %rdx
xorl %eax, %eax
cmpq 0x80(%rdx), %rcx
movb %al, 0x7(%rsp)
jae 0x249dde
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq 0x70(%rcx), %rcx
movq 0x8(%rsp), %rdx
cmpq (%rcx,%rdx,8), %rax
seta %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x249de8
jmp 0x249df8
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x249da7
jmp 0x249dfa
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq (%rcx), %rax
jb 0x249e41
movq 0x3f2190(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2cc1f9(%rip), %rsi    # 0x516013
leaq 0x32eade(%rip), %rdx    # 0x5788ff
leaq 0x32eaf1(%rip), %rcx    # 0x578919
leaq 0x32eb07(%rip), %r8     # 0x578936
movl $0x4d, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x249e43
movq 0x18(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x10(%rsp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jbe 0x249e86
movq 0x18(%rsp), %rax
movq 0x30(%rax), %rcx
movq 0x10(%rsp), %rdx
movl (%rcx,%rdx,4), %eax
addl $-0x1, %eax
movl %eax, (%rcx,%rdx,4)
movl %eax, %eax
movq 0x8(%rsp), %rcx
shlq $0x20, %rcx
addq %rcx, %rax
movq %rax, 0x20(%rsp)
jmp 0x249f29
jmp 0x249e88
cmpq $0x0, 0x8(%rsp)
ja 0x249ec8
movq 0x3f2109(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2cc172(%rip), %rsi    # 0x516013
leaq 0x32eaa9(%rip), %rdx    # 0x578951
leaq 0x32ea6a(%rip), %rcx    # 0x578919
leaq 0x32ea80(%rip), %r8     # 0x578936
movl $0x54, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x249eca
movq 0x8(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq 0x70(%rax), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
addq $0x1, %rdx
movq %rdx, (%rax,%rcx,8)
movq 0x18(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x10(%rsp), %rcx
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
movq 0x18(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x10(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movq 0x8(%rsp), %rcx
shlq $0x20, %rcx
addq %rcx, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/spmsuftab.h
// Function: gt_spmsuftab_set
GT_UNUSED static inline void gt_spmsuftab_set(GtSpmsuftab *spmsuftab,
                                              GtUword idx,
                                              GtUword value)
{
  gt_assert(idx >= spmsuftab->partoffset);
  idx -= spmsuftab->partoffset;
  gt_assert(idx < spmsuftab->numofentries && value <= spmsuftab->maxvalue);
  gt_assert(spmsuftab->bitpackarray != NULL);
  gt_compact_ulong_store_update(spmsuftab->bitpackarray,idx,value);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq (%rcx), %rax
jae 0x249f99
movq 0x3f2038(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2cc0a1(%rip), %rsi    # 0x516013
leaq 0x32e9e8(%rip), %rdx    # 0x578961
leaq 0x32e9fe(%rip), %rcx    # 0x57897e
leaq 0x335332(%rip), %r8     # 0x57f2b9
movl $0x24, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x249f9b
movq 0x10(%rsp), %rax
movq (%rax), %rcx
movq 0x8(%rsp), %rax
subq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x249fcf
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jbe 0x24a007
movq 0x3f1fca(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2cc033(%rip), %rsi    # 0x516013
leaq 0x32e9a8(%rip), %rdx    # 0x57898f
leaq 0x32e990(%rip), %rcx    # 0x57897e
leaq 0x3352c4(%rip), %r8     # 0x57f2b9
movl $0x26, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x24a009
jmp 0x24a00b
movq 0x10(%rsp), %rax
cmpq $0x0, 0x20(%rax)
jne 0x24a04f
movq 0x3f1f82(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2cbfeb(%rip), %rsi    # 0x516013
leaq 0x32e99e(%rip), %rdx    # 0x5789cd
leaq 0x32e948(%rip), %rcx    # 0x57897e
leaq 0x33527c(%rip), %r8     # 0x57f2b9
movl $0x27, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x24a051
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq 0xa21f0
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/firstcodes.c
// Function: gt_firstcodes_thread_caller_sortremaining
static void *gt_firstcodes_thread_caller_sortremaining(void *data)
{
  GtSortRemainingThreadinfo *threadinfo = (GtSortRemainingThreadinfo *) data;

  if (gt_firstcodes_sortremaining(threadinfo->srsw,
                                  threadinfo->encseq,
                                  threadinfo->readmode,
                                  threadinfo->spmsuftab,
                                  threadinfo->snrp,
                                  threadinfo->fct,
                                  threadinfo->minindex,
                                  threadinfo->maxindex,
                                  threadinfo->sumofwidth,
                                  threadinfo->spaceforbucketprocessing,
                                  threadinfo->depth,
                                  threadinfo->itvprocess,
                                  threadinfo->itvprocess_end,
                                  threadinfo->itvprocessdata,
                                  threadinfo->withsuftabcheck,
                                  threadinfo->err) != 0)
  {
    gt_assert(false);
  }
  return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq (%rax), %rdi
movq 0x68(%rsp), %rax
movq 0x8(%rax), %rsi
movq 0x68(%rsp), %rax
movl 0x10(%rax), %edx
movq 0x68(%rsp), %rax
movq 0x18(%rax), %rcx
movq 0x68(%rsp), %rax
movq 0x20(%rax), %r8
movq 0x68(%rsp), %rax
movq 0x28(%rax), %r9
movq 0x68(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, 0x58(%rsp)
movq 0x68(%rsp), %rax
movq 0x40(%rax), %rbp
movq 0x68(%rsp), %rax
movq 0x48(%rax), %r13
movq 0x68(%rsp), %rax
movq 0x50(%rax), %r12
movq 0x68(%rsp), %rax
movq 0x30(%rax), %r15
movq 0x68(%rsp), %rax
movq 0x60(%rax), %r14
movq 0x68(%rsp), %rax
movq 0x68(%rax), %rbx
movq 0x68(%rsp), %rax
movq 0x70(%rax), %r11
movq 0x68(%rsp), %rax
movb 0x58(%rax), %r10b
movq 0x68(%rsp), %rax
movq 0x78(%rax), %rax
movq %rax, 0x60(%rsp)
movq 0x58(%rsp), %rax
andb $0x1, %r10b
movq %rax, (%rsp)
movq 0x60(%rsp), %rax
movq %rbp, 0x8(%rsp)
movq %r13, 0x10(%rsp)
movq %r12, 0x18(%rsp)
movq %r15, 0x20(%rsp)
movq %r14, 0x28(%rsp)
movq %rbx, 0x30(%rsp)
movq %r11, 0x38(%rsp)
movzbl %r10b, %r10d
movl %r10d, 0x40(%rsp)
movq %rax, 0x48(%rsp)
callq 0x24a700
cmpl $0x0, %eax
je 0x24ae7c
jmp 0x24ae44
movq 0x3f1155(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2cb1be(%rip), %rsi    # 0x516013
leaq 0x30df07(%rip), %rdx    # 0x558d63
leaq 0x32dd59(%rip), %rcx    # 0x578bbc
leaq 0x32d392(%rip), %r8     # 0x5781fc
movl $0x1f5, %r9d            # imm = 0x1F5
movb $0x0, %al
callq 0x199f0
callq 0x19370
xorl %eax, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/firstcodes.c
// Function: gt_firstcodes_findfirstlarger
static GtUword gt_firstcodes_findfirstlarger(const GtFirstcodestab *fct,
                                                   GtUword start,
                                                   GtUword end,
                                                   GtUword offset)
{
  GtUword left = start, right = end, found = end, mid, midval;

  while (left+1 < right)
  {
    mid = GT_DIV2(left+right);
    midval = gt_firstcodes_get_leftborder(fct,mid);
    if (offset == midval)
    {
      return mid;
    }
    if (offset < midval)
    {
      found = mid;
      right = mid - 1;
    } else
    {
      left = mid + 1;
    }
  }
  return found;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq %rcx, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
addq $0x1, %rax
cmpq 0x20(%rsp), %rax
jae 0x24af4d
movq 0x28(%rsp), %rax
addq 0x20(%rsp), %rax
shrq %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x4c0d80
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
cmpq 0x8(%rsp), %rax
jne 0x24af14
movq 0x10(%rsp), %rax
movq %rax, 0x50(%rsp)
jmp 0x24af57
movq 0x30(%rsp), %rax
cmpq 0x8(%rsp), %rax
jae 0x24af3a
movq 0x10(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x10(%rsp), %rax
subq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x24af48
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x24aec6
movq 0x18(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/fmi-locate.c
// Function: gt_fmfindtextpos
GtUword gt_fmfindtextpos (const Fmindex *fm,GtUword idx)
{
  GtUword offset = 0;
  GtUchar cc;

  while ((idx & fm->markdistminus1) != 0)
  {
    if (idx == fm->longestsuffixpos || GT_ISSPECIAL(cc = ACCESSBWTTEXT(idx)))
    {
      GtUword smallestgeq
               = searchsmallestgeq(fm->specpos.spaceGtPairBwtidx,
                                   fm->specpos.spaceGtPairBwtidx +
                                   fm->specpos.nextfreeGtPairBwtidx - 1,
                                   idx);
      return (smallestgeq + offset) % fm->bwtlength;
    }
    idx = fm->tfreq[cc] + fmoccurrence (fm, cc, idx);
    offset++;
  }
  return (fm->markpostable[idx / fm->markdist] + offset) % fm->bwtlength;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq $0x0, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq 0x38(%rsp), %rcx
andq 0x48(%rcx), %rax
cmpq $0x0, %rax
je 0x24bd55
movq 0x30(%rsp), %rax
movq 0x38(%rsp), %rcx
cmpq 0x30(%rcx), %rax
je 0x24bcb1
movq 0x38(%rsp), %rax
movq (%rax), %rdi
movq 0x30(%rsp), %rsi
xorl %edx, %edx
callq 0xa9da0
movb %al, 0x27(%rsp)
movzbl %al, %eax
cmpl $0xfe, %eax
jl 0x24bd05
movq 0x38(%rsp), %rax
movq 0x50(%rax), %rdi
movq 0x38(%rsp), %rax
movq 0x50(%rax), %rsi
movq 0x38(%rsp), %rax
movq 0x60(%rax), %rax
shlq $0x4, %rax
addq %rax, %rsi
addq $-0x10, %rsi
movq 0x30(%rsp), %rdx
callq 0x24bdb0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
addq 0x28(%rsp), %rax
movq 0x38(%rsp), %rcx
xorl %edx, %edx
divq 0x10(%rcx)
movq %rdx, 0x40(%rsp)
jmp 0x24bd97
movq 0x38(%rsp), %rax
movq 0x18(%rax), %rax
movzbl 0x27(%rsp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
movb 0x27(%rsp), %al
movq 0x30(%rsp), %rdx
movzbl %al, %esi
callq 0x24bf60
movq %rax, %rcx
movq 0x10(%rsp), %rax
addq %rcx, %rax
movq %rax, 0x30(%rsp)
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x24bc67
movq 0x38(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
movq 0x38(%rsp), %rcx
xorl %edx, %edx
divq 0xb8(%rcx)
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq (%rax,%rcx,8), %rax
addq 0x28(%rsp), %rax
movq 0x38(%rsp), %rcx
xorl %edx, %edx
divq 0x10(%rcx)
movq %rdx, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/fmi-locate.c
// Function: searchsmallestgeq
static GtUword searchsmallestgeq(const GtPairBwtidx *left,
                                const GtPairBwtidx *right,
                                GtUword key)
{
  const GtPairBwtidx *leftptr, *midptr, *rightptr, *found = NULL;
  GtUword len;

  gt_assert(left != NULL);
  gt_assert(right != NULL);
  leftptr = left;
  rightptr = right;
  while (leftptr<=rightptr)
  {
    len = (GtUword) (rightptr-leftptr);
    midptr = leftptr + GT_DIV2(len);
    if (key < midptr->bwtpos)
    {
      found = midptr;
      rightptr = midptr - 1;
    } else
    {
      if (key > midptr->bwtpos)
      {
        leftptr = midptr + 1;
      } else
      {
        return midptr->suftabvalue;
      }
    }
  }
  gt_assert(found != NULL);
  return found->suftabvalue;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq $0x0, 0x8(%rsp)
cmpq $0x0, 0x38(%rsp)
jne 0x24be0c
movq 0x3f01c5(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2ca22e(%rip), %rsi    # 0x516013
leaq 0x32cf7c(%rip), %rdx    # 0x578d68
leaq 0x32cf82(%rip), %rcx    # 0x578d75
leaq 0x32cf8d(%rip), %r8     # 0x578d87
movl $0x1f, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x24be0e
jmp 0x24be10
cmpq $0x0, 0x30(%rsp)
jne 0x24be50
movq 0x3f0181(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2ca1ea(%rip), %rsi    # 0x516013
leaq 0x32cf6e(%rip), %rdx    # 0x578d9e
leaq 0x32cf3e(%rip), %rcx    # 0x578d75
leaq 0x32cf49(%rip), %r8     # 0x578d87
movl $0x20, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x24be52
movq 0x38(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x10(%rsp), %rax
ja 0x24bf02
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
subq %rcx, %rax
sarq $0x4, %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rax
movq (%rsp), %rcx
shrq %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq (%rcx), %rax
jae 0x24becc
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
addq $-0x10, %rax
movq %rax, 0x10(%rsp)
jmp 0x24befd
movq 0x28(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq (%rcx), %rax
jbe 0x24beeb
movq 0x18(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x20(%rsp)
jmp 0x24befb
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x40(%rsp)
jmp 0x24bf54
jmp 0x24befd
jmp 0x24be66
jmp 0x24bf04
cmpq $0x0, 0x8(%rsp)
jne 0x24bf44
movq 0x3f008d(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2ca0f6(%rip), %rsi    # 0x516013
leaq 0x32ce88(%rip), %rdx    # 0x578dac
leaq 0x32ce4a(%rip), %rcx    # 0x578d75
leaq 0x32ce55(%rip), %r8     # 0x578d87
movl $0x36, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x24bf46
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/fmi-map.c
// Function: gt_fmindexexists
bool gt_fmindexexists(const char *indexname)
{
  if (!gt_file_exists_with_suffix(indexname,FMASCIIFILESUFFIX))
  {
    return false;
  }
  if (!gt_file_exists_with_suffix(indexname,FMDATAFILESUFFIX))
  {
    return false;
  }
  return true;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
leaq 0x32c8a5(%rip), %rsi    # 0x578dba
callq 0xde8e0
testb $0x1, %al
jne 0x24c525
movb $0x0, 0x17(%rsp)
jmp 0x24c546
movq 0x8(%rsp), %rdi
leaq 0x32c88e(%rip), %rsi    # 0x578dbf
callq 0xde8e0
testb $0x1, %al
jne 0x24c541
movb $0x0, 0x17(%rsp)
jmp 0x24c546
movb $0x1, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
cmpq $0x0, 0x70(%rax)
je 0x24c57d
movq (%rsp), %rax
movq 0x70(%rax), %rdi
callq 0xdb2a0
movq (%rsp), %rax
cmpq $0x0, (%rax)
je 0x24c59e
movq (%rsp), %rax
movq (%rax), %rdi
callq 0xae070
movq (%rsp), %rax
movq $0x0, (%rax)
movq (%rsp), %rax
movq 0x68(%rax), %rdi
callq 0x7e3d0
popq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/fmi-map.c
// Function: mapbwtencoding
static GtEncseq *mapbwtencoding(const char *indexname,
                                GtLogger *logger,
                                GtError *err)
{
  GtEncseqLoader *el;
  GtEncseq *ret;
  gt_error_check(err);

  el = gt_encseq_loader_new();
  gt_encseq_loader_do_not_require_des_tab(el);
  gt_encseq_loader_do_not_require_ssp_tab(el);
  gt_encseq_loader_do_not_require_sds_tab(el);
  gt_encseq_loader_set_logger(el, logger);
  ret = gt_encseq_loader_load(el, indexname, err);
  gt_encseq_loader_delete(el);
  return ret;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x24cdf3
movq 0x10(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x24cdbb
jmp 0x24cdf3
movq 0x3ef1de(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2c9247(%rip), %rsi    # 0x516013
leaq 0x2c93ec(%rip), %rdx    # 0x5161bf
leaq 0x32c085(%rip), %rcx    # 0x578e5f
leaq 0x32bff1(%rip), %r8     # 0x578dd2
movl $0x9b, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x24cdf5
callq 0xb7a40
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0xba820
movq 0x8(%rsp), %rdi
callq 0xba910
movq 0x8(%rsp), %rdi
callq 0xbaa10
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xbacf0
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0xb7aa0
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
callq 0xb7e50
movq (%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movb %dl, %al
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
andb $0x1, %al
movb %al, 0x27(%rsp)
movq %rcx, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x24cecb
movq 0x18(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x24ce93
jmp 0x24cecb
movq 0x3ef106(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2c916f(%rip), %rsi    # 0x516013
leaq 0x2c9314(%rip), %rdx    # 0x5161bf
leaq 0x32bfbc(%rip), %rcx    # 0x578e6e
leaq 0x32bfca(%rip), %r8     # 0x578e83
movl $0x3a, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x24cecd
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
movb %al, 0x10(%rsp)
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rax
movq 0xa0(%rax), %rcx
movq 0x18(%rsp), %r8
leaq 0x12(%rip), %rdi        # 0x24cf10
leaq 0x8(%rsp), %rdx
callq 0xea260
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
subq $0x38, %rsp
movb %sil, %al
movq %rdi, 0x30(%rsp)
andb $0x1, %al
movb %al, 0x2f(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x24d0fc
movq 0x18(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x24d0c4
jmp 0x24d0fc
movq 0x3eeed5(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2c8f3e(%rip), %rsi    # 0x516013
leaq 0x2c90e3(%rip), %rdx    # 0x5161bf
leaq 0x32bdb8(%rip), %rcx    # 0x578e9b
leaq 0x32bd99(%rip), %r8     # 0x578e83
movl $0x48, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x24d0fe
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movb 0x2f(%rsp), %al
andb $0x1, %al
movb %al, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x11dee0
movq %rax, %rdx
movq 0x30(%rsp), %rax
movq 0xa0(%rax), %rcx
movq 0x30(%rsp), %r8
addq $0x70, %r8
movq 0x18(%rsp), %r9
leaq -0x230(%rip), %rdi      # 0x24cf10
leaq 0x8(%rsp), %rsi
callq 0xe9d20
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/fmi-mkindex.c
// Function: gt_parseargsandcallmkfmindex
int gt_parseargsandcallmkfmindex(int argc,const char **argv,GtError *err)
{
  Mkfmcallinfo mkfmcallinfo;
  int retval;
  bool haserr = false;

  retval = mkfmindexoptions(&mkfmcallinfo,argc,argv,err);
  if (retval == 0)
  {
    GtLogger *logger = gt_logger_new(false, GT_LOGGER_DEFLT_PREFIX, stdout);
    if (runmkfmindex(&mkfmcallinfo,logger,err) < 0)
    {
      haserr = true;
    }
    gt_logger_delete(logger);
    logger = NULL;
  } else
  {
    if (retval < 0)
    {
      haserr = true;
    }
  }
  freemkfmcallinfo(&mkfmcallinfo);
  return haserr ? -1 : 0;
}

// Assembly:
subq $0x48, %rsp
movl %edi, 0x44(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movb $0x0, 0xb(%rsp)
movl 0x44(%rsp), %esi
movq 0x38(%rsp), %rdx
movq 0x30(%rsp), %rcx
leaq 0x10(%rsp), %rdi
callq 0x24d210
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jne 0x24d1d6
movq 0x3eeda7(%rip), %rax    # 0x63bf38
movq (%rax), %rdx
xorl %edi, %edi
leaq 0x2ca74f(%rip), %rsi    # 0x5178ec
callq 0xe7870
movq %rax, (%rsp)
movq (%rsp), %rsi
movq 0x30(%rsp), %rdx
leaq 0x10(%rsp), %rdi
callq 0x24d2d0
cmpl $0x0, %eax
jge 0x24d1c3
movb $0x1, 0xb(%rsp)
movq (%rsp), %rdi
callq 0xe7ed0
movq $0x0, (%rsp)
jmp 0x24d1e4
cmpl $0x0, 0xc(%rsp)
jge 0x24d1e2
movb $0x1, 0xb(%rsp)
jmp 0x24d1e4
leaq 0x10(%rsp), %rdi
callq 0x24d570
movb 0xb(%rsp), %dl
xorl %eax, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
testb $0x1, %dl
cmovnel %ecx, %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/fmi-mkindex.c
// Function: mkfmindexoptions
static int mkfmindexoptions(Mkfmcallinfo *mkfmcallinfo,
                            int argc,const char **argv,GtError *err)
{
  GtOPrval rval;
  int retval = 0;

  gt_error_check(err);
  rval = parsemkfmindex(mkfmcallinfo,argc,argv,err);
  if (rval == GT_OPTION_PARSER_ERROR)
  {
    retval = -1;
  } else
  {
    if (rval == GT_OPTION_PARSER_REQUESTS_EXIT)
    {
      retval = 2;
    }
  }
  return retval;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movl $0x0, (%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x24d27e
movq 0x8(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x24d246
jmp 0x24d27e
movq 0x3eed53(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2c8dbc(%rip), %rsi    # 0x516013
leaq 0x2c8f61(%rip), %rdx    # 0x5161bf
leaq 0x32bc4f(%rip), %rcx    # 0x578eb4
leaq 0x32bc59(%rip), %r8     # 0x578ec5
movl $0xa9, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x24d280
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
callq 0x24d5a0
movl %eax, 0x4(%rsp)
cmpl $0x1, 0x4(%rsp)
jne 0x24d2ac
movl $0xffffffff, (%rsp)     # imm = 0xFFFFFFFF
jmp 0x24d2bc
cmpl $0x2, 0x4(%rsp)
jne 0x24d2ba
movl $0x2, (%rsp)
jmp 0x24d2bc
movl (%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/fmi-mkindex.c
// Function: levedescl2levelnum
static int levedescl2levelnum(const char *name,
                              unsigned int *log2bsize,
                              unsigned int *log2markdist)
{
  size_t i;

  gt_assert(name != NULL);
  for (i=0; i<sizeof (indexlevel)/sizeof (indexlevel[0]); i++)
  {
    if (strcmp(name,indexlevel[i].name) == 0)
    {
      *log2bsize = indexlevel[i].log2bsize;
      *log2markdist = indexlevel[i].log2markdist;
      return 0;
    }
  }
  return -1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x24d893
movq 0x3ee73e(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2c87a7(%rip), %rsi    # 0x516013
leaq 0x2cb2e5(%rip), %rdx    # 0x518b58
leaq 0x32b81d(%rip), %rcx    # 0x579097
leaq 0x32b644(%rip), %r8     # 0x578ec5
movl $0x89, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x24d895
movq $0x0, (%rsp)
cmpq $0x4, (%rsp)
jae 0x24d91a
movq 0x18(%rsp), %rdi
movq (%rsp), %rcx
leaq 0x3f09fc(%rip), %rax    # 0x63e2b0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
callq 0x19980
cmpl $0x0, %eax
jne 0x24d90a
movq (%rsp), %rcx
leaq 0x3f09dd(%rip), %rax    # 0x63e2b0
shlq $0x4, %rcx
addq %rcx, %rax
movl 0x8(%rax), %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
movq (%rsp), %rcx
leaq 0x3f09c1(%rip), %rax    # 0x63e2b0
shlq $0x4, %rcx
addq %rcx, %rax
movl 0xc(%rax), %ecx
movq 0x8(%rsp), %rax
movl %ecx, (%rax)
movl $0x0, 0x24(%rsp)
jmp 0x24d922
jmp 0x24d90c
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x24d89d
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/fmi-mkindex.c
// Function: freeconstructedfmindex
static void freeconstructedfmindex(Fmindex *fm)
{
  GT_FREEARRAY (&fm->specpos, GtPairBwtidx);
  gt_free (fm->bfreq);
  gt_free (fm->superbfreq);
  gt_free (fm->tfreq);
  gt_free (fm->markpostable);
  if (fm->suffixlength > 0)
  {
    gt_free(fm->boundarray);
  }
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
cmpq $0x0, 0x50(%rax)
je 0x24d97d
movq (%rsp), %rax
movq 0x50(%rax), %rdi
leaq 0x32b576(%rip), %rsi    # 0x578ec5
movl $0x98, %edx
callq 0xe88c0
movq (%rsp), %rax
movq $0x0, 0x58(%rax)
movq (%rsp), %rax
movq $0x0, 0x60(%rax)
movq (%rsp), %rax
movq $0x0, 0x50(%rax)
jmp 0x24d97f
movq (%rsp), %rax
movq 0x8(%rax), %rdi
leaq 0x32b537(%rip), %rsi    # 0x578ec5
movl $0x99, %edx
callq 0xe88c0
movq (%rsp), %rax
movq 0x20(%rax), %rdi
leaq 0x32b51e(%rip), %rsi    # 0x578ec5
movl $0x9a, %edx
callq 0xe88c0
movq (%rsp), %rax
movq 0x18(%rax), %rdi
leaq 0x32b505(%rip), %rsi    # 0x578ec5
movl $0x9b, %edx
callq 0xe88c0
movq (%rsp), %rax
movq 0x28(%rax), %rdi
leaq 0x32b4ec(%rip), %rsi    # 0x578ec5
movl $0x9c, %edx
callq 0xe88c0
movq (%rsp), %rax
cmpl $0x0, 0x98(%rax)
jbe 0x24da0c
movq (%rsp), %rax
movq 0xc8(%rax), %rdi
leaq 0x32b4c3(%rip), %rsi    # 0x578ec5
movl $0x9f, %edx
callq 0xe88c0
popq %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/fmi-save.c
// Function: gt_saveFmindex
int gt_saveFmindex(const char *indexname,Fmindex *fm,
                   const GtSpecialcharinfo *specialcharinfo,
                   bool storeindexpos,GtError *err)
{
  gt_error_check(err);
  if (writefmascii(indexname, fm, specialcharinfo,storeindexpos,err) != 0)
  {
    return -1;
  }
  if (writefmdata (indexname, fm, storeindexpos,err) != 0)
  {
    return -2;
  }
  return 0;
}

// Assembly:
subq $0x38, %rsp
movb %cl, %al
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
andb $0x1, %al
movb %al, 0x17(%rsp)
movq %r8, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x24da80
movq 0x8(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x24da48
jmp 0x24da80
movq 0x3ee551(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2c85ba(%rip), %rsi    # 0x516013
leaq 0x2c875f(%rip), %rdx    # 0x5161bf
leaq 0x32b648(%rip), %rcx    # 0x5790af
leaq 0x32b650(%rip), %r8     # 0x5790be
movl $0x5d, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x24da82
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
movb 0x17(%rsp), %al
movq 0x8(%rsp), %r8
andb $0x1, %al
movzbl %al, %ecx
callq 0x24daf0
cmpl $0x0, %eax
je 0x24dab3
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x24dae7
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
movb 0x17(%rsp), %al
movq 0x8(%rsp), %rcx
andb $0x1, %al
movzbl %al, %edx
callq 0x24dd80
cmpl $0x0, %eax
je 0x24dadf
movl $0xfffffffe, 0x34(%rsp) # imm = 0xFFFFFFFE
jmp 0x24dae7
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/fmi-save.c
// Function: writefmdata
static int writefmdata(const char *indexname,
                       Fmindex *fm,
                       bool storeindexpos,
                       GtError *err)
{
  FILE *fp;

  gt_error_check(err);
  fp = gt_fa_fopen_with_suffix(indexname,FMDATAFILESUFFIX,"wb",err);
  if (fp == NULL)
  {
    return -1;
  }
  if (gt_flushfmindex2file(fp,fm,storeindexpos,err) != 0)
  {
    return -2;
  }
  gt_fa_xfclose(fp);
  return 0;
}

// Assembly:
subq $0x38, %rsp
movb %dl, %al
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
andb $0x1, %al
movb %al, 0x1f(%rsp)
movq %rcx, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x24ddeb
movq 0x10(%rsp), %rdi
callq 0xd8a60
testb $0x1, %al
jne 0x24ddb3
jmp 0x24ddeb
movq 0x3ee1e6(%rip), %rax    # 0x63bfa0
movq (%rax), %rdi
leaq 0x2c824f(%rip), %rsi    # 0x516013
leaq 0x2c83f4(%rip), %rdx    # 0x5161bf
leaq 0x32b433(%rip), %rcx    # 0x579205
leaq 0x32b2e5(%rip), %r8     # 0x5790be
movl $0x4b, %r9d
movb $0x0, %al
callq 0x199f0
callq 0x19370
jmp 0x24dded
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %r9
leaq 0x32afc1(%rip), %rsi    # 0x578dbf
leaq 0x2d8d98(%rip), %rdx    # 0x526b9d
leaq 0x32b2b2(%rip), %rcx    # 0x5790be
movl $0x4c, %r8d
callq 0xd92c0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jne 0x24de2e
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x24de6c
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
movb 0x1f(%rsp), %al
movq 0x10(%rsp), %rcx
andb $0x1, %al
movzbl %al, %edx
callq 0x24ce60
cmpl $0x0, %eax
je 0x24de5a
movl $0xfffffffe, 0x34(%rsp) # imm = 0xFFFFFFFE
jmp 0x24de6c
movq 0x8(%rsp), %rdi
callq 0xd9570
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/match/fmi-sufbwtstream.c
// Function: showconstructionmessage
static void showconstructionmessage(const char *indexname,
                                    GtUword totallength,
                                    GtUword fmsize,
                                    unsigned int log2bsize,
                                    unsigned int log2markdist,
                                    unsigned int numofchars)
{
  printf("# construct fmindex \"%s\" for bsize="GT_WU", superbsize="GT_WU",",
          indexname,
          (GtUword) GT_POW2(log2bsize),
          (GtUword) GT_POW2(log2markdist));
  printf(" len="GT_WU", alphasize=%u: size ",
          totallength,
          numofchars);
  printf(""GT_WU" bytes, space overhead %.2f\n",
          fmsize,
          (double) fmsize/(double) (totallength+1));
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl %ecx, 0xc(%rsp)
movl %r8d, 0x8(%rsp)
movl %r9d, 0x4(%rsp)
movq 0x20(%rsp), %rsi
movb 0xc(%rsp), %cl
movl $0x1, %eax
movl %eax, %edx
shll %cl, %edx
movl %edx, %ecx
movl %ecx, %edx
movb 0x8(%rsp), %cl
shll %cl, %eax
movl %eax, %ecx
leaq 0x32a81f(%rip), %rdi    # 0x579315
xorl %eax, %eax
movb %al, 0x3(%rsp)
callq 0x19070
movb 0x3(%rsp), %al
movq 0x18(%rsp), %rsi
movl 0x4(%rsp), %edx
leaq 0x32a838(%rip), %rdi    # 0x57934d
callq 0x19070
movq 0x10(%rsp), %rsi
movq %rsi, %xmm0
movaps 0x2c9e05(%rip), %xmm3   # 0x518930
punpckldq %xmm3, %xmm0    # xmm0 = xmm0[0],xmm3[0],xmm0[1],xmm3[1]
movapd 0x2c9e09(%rip), %xmm2   # 0x518940
subpd %xmm2, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movq 0x18(%rsp), %rax
incq %rax
movq %rax, %xmm1
punpckldq %xmm3, %xmm1    # xmm1 = xmm1[0],xmm3[0],xmm1[1],xmm3[1]
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
leaq 0x32a7fa(%rip), %rdi    # 0x57936b
movb $0x1, %al
callq 0x19070
addq $0x28, %rsp
retq
nopl (%rax)